Class: Moxml::SAX::BlockHandler

Inherits:
Handler
  • Object
show all
Defined in:
lib/moxml/sax/block_handler.rb

Overview

Block-based SAX handler with DSL

Provides a convenient block-based API for simple SAX parsing cases without requiring a full class definition.

Examples:

Block-based parsing

context.sax_parse(xml) do
  start_element { |name, attrs| puts "Element: #{name}" }
  characters { |text| puts "Text: #{text}" }
  end_element { |name| puts "End: #{name}" }
end

With instance variables

books = []
context.sax_parse(xml) do
  start_element do |name, attrs|
    books << { id: attrs["id"] } if name == "book"
  end
end

Instance Method Summary collapse

Constructor Details

#initialize(&block) { ... } ⇒ BlockHandler

Create a new block handler

Parameters:

  • block (Proc) —

    Block containing DSL calls

Yields:

  • DSL context for defining handlers



30
31
32
33
34
 
# File 'lib/moxml/sax/block_handler.rb', line 30

def initialize(&block)
  super()
  @handlers = {}
  instance_eval(&block) if block
end

Instance Method Details

#cdata {|text| ... } ⇒ void

This method returns an undefined value.

Define handler for CDATA section event

Yields:

  • Block to execute when CDATA section is encountered

Yield Parameters:

  • text (String) —

    CDATA content

Yield Returns:

  • (void) 


92
93
94
 
# File 'lib/moxml/sax/block_handler.rb', line 92

def cdata(&block)
  @handlers[:cdata] = block
end

#characters {|text| ... } ⇒ void

This method returns an undefined value.

Define handler for character data event

Yields:

  • Block to execute when character data is encountered

Yield Parameters:

  • text (String) —

    Character data

Yield Returns:

  • (void) 


82
83
84
 
# File 'lib/moxml/sax/block_handler.rb', line 82

def characters(&block)
  @handlers[:characters] = block
end

#comment {|text| ... } ⇒ void

This method returns an undefined value.

Define handler for comment event

Yields:

  • Block to execute when comment is encountered

Yield Parameters:

  • text (String) —

    Comment content

Yield Returns:

  • (void) 


102
103
104
 
# File 'lib/moxml/sax/block_handler.rb', line 102

def comment(&block)
  @handlers[:comment] = block
end

#end_document { ... } ⇒ void

This method returns an undefined value.

Define handler for document end event

Yields:

  • Block to execute when document parsing completes

Yield Returns:

  • (void) 


50
51
52
 
# File 'lib/moxml/sax/block_handler.rb', line 50

def end_document(&block)
  @handlers[:end_document] = block
end

#end_element {|name| ... } ⇒ void

This method returns an undefined value.

Define handler for element end event

Yields:

  • Block to execute when closing tag is encountered

Yield Parameters:

  • name (String) —

    Element name

Yield Returns:

  • (void) 


72
73
74
 
# File 'lib/moxml/sax/block_handler.rb', line 72

def end_element(&block)
  @handlers[:end_element] = block
end

#error {|error| ... } ⇒ void

This method returns an undefined value.

Define handler for error event

Yields:

  • Block to execute when error occurs

Yield Parameters:

Yield Returns:

  • (void) 


123
124
125
 
# File 'lib/moxml/sax/block_handler.rb', line 123

def error(&block)
  @handlers[:error] = block
end

#on_cdata(text) ⇒ Object 



167
168
169
 
# File 'lib/moxml/sax/block_handler.rb', line 167

def on_cdata(text)
  @handlers[:cdata]&.call(text)
end

#on_characters(text) ⇒ Object 



162
163
164
 
# File 'lib/moxml/sax/block_handler.rb', line 162

def on_characters(text)
  (@characters_block ||= @handlers[:characters])&.call(text)
end

#on_comment(text) ⇒ Object 



172
173
174
 
# File 'lib/moxml/sax/block_handler.rb', line 172

def on_comment(text)
  @handlers[:comment]&.call(text)
end

#on_end_document ⇒ Object

The per-event hash lookup fires for every node in the document; the DSL is fixed after construction, so the resolved block memoizes into an ivar on first fire (nil short-circuits the same way &. does).



147
148
149
 
# File 'lib/moxml/sax/block_handler.rb', line 147

def on_end_document
  (@end_document_block ||= @handlers[:end_document])&.call
end

#on_end_element(name) ⇒ Object 



157
158
159
 
# File 'lib/moxml/sax/block_handler.rb', line 157

def on_end_element(name)
  (@end_element_block ||= @handlers[:end_element])&.call(name)
end

#on_error(error) ⇒ Object 



182
183
184
185
186
187
188
 
# File 'lib/moxml/sax/block_handler.rb', line 182

def on_error(error)
  if @handlers[:error]
    @handlers[:error].call(error)
  else
    super
  end
end

#on_processing_instruction(target, data) ⇒ Object 



177
178
179
 
# File 'lib/moxml/sax/block_handler.rb', line 177

def on_processing_instruction(target, data)
  @handlers[:processing_instruction]&.call(target, data)
end

#on_start_document ⇒ Object 



138
139
140
 
# File 'lib/moxml/sax/block_handler.rb', line 138

def on_start_document
  @handlers[:start_document]&.call
end

#on_start_element(name, attributes = {}, namespaces = {}) ⇒ Object 



152
153
154
 
# File 'lib/moxml/sax/block_handler.rb', line 152

def on_start_element(name, attributes = {}, namespaces = {})
  (@start_element_block ||= @handlers[:start_element])&.call(name, attributes, namespaces)
end

#on_warning(message) ⇒ Object 



191
192
193
 
# File 'lib/moxml/sax/block_handler.rb', line 191

def on_warning(message)
  @handlers[:warning]&.call(message)
end

#processing_instruction {|target, data| ... } ⇒ void

This method returns an undefined value.

Define handler for processing instruction event

Yields:

  • Block to execute when PI is encountered

Yield Parameters:

Yield Returns:

  • (void) 


113
114
115
 
# File 'lib/moxml/sax/block_handler.rb', line 113

def processing_instruction(&block)
  @handlers[:processing_instruction] = block
end

#start_document { ... } ⇒ void

This method returns an undefined value.

Define handler for document start event

Yields:

  • Block to execute when document parsing begins

Yield Returns:

  • (void) 


41
42
43
 
# File 'lib/moxml/sax/block_handler.rb', line 41

def start_document(&block)
  @handlers[:start_document] = block
end

#start_element {|name, attributes, namespaces| ... } ⇒ void

This method returns an undefined value.

Define handler for element start event

Yields:

  • Block to execute when opening tag is encountered

Yield Parameters:

  • name (String) —

    Element name

  • attributes (Hash<String, String>) —

    Element attributes

  • namespaces (Hash<String, String>) —

    Namespace declarations

Yield Returns:

  • (void) 


62
63
64
 
# File 'lib/moxml/sax/block_handler.rb', line 62

def start_element(&block)
  @handlers[:start_element] = block
end

#warning {|message| ... } ⇒ void

This method returns an undefined value.

Define handler for warning event

Yields:

  • Block to execute when warning occurs

Yield Parameters:

  • message (String) —

    Warning message

Yield Returns:

  • (void) 


133
134
135
 
# File 'lib/moxml/sax/block_handler.rb', line 133

def warning(&block)
  @handlers[:warning] = block
end