Class: Builder::XmlMarkup

Inherits:
XmlBase show all
Defined in:
lib/action_view/vendor/builder/xmlmarkup.rb

Overview

Create XML markup easily. All (well, almost all) methods sent to an XmlMarkup object will be translated to the equivalent XML markup. Any method with a block will be treated as an XML markup tag with nested markup in the block.

Examples will demonstrate this easier than words. In the following, xm is an XmlMarkup object.

xm.em("emphasized")             # => <em>emphasized</em>
xm.em { xmm.b("emp & bold") }   # => <em><b>emph &amp; bold</b></em>
xm.a("A Link", "href"=>"http://onestepback.org")
                                # => <a href="http://onestepback.org">A Link</a>
xm.div { br }                    # => <div><br/></div>
xm.target("name"=>"compile", "option"=>"fast")
                                # => <target option="fast" name="compile"\>
                                # NOTE: order of attributes is not specified.

xm.instruct!                   # <?xml version="1.0" encoding="UTF-8"?>
xm.html {                      # <html>
  xm.head {                    #   <head>
    xm.title("History")        #     <title>History</title>
  }                            #   </head>
  xm.body {                    #   <body>
    xm.comment! "HI"           #     <!-- HI -->
    xm.h1("Header")            #     <h1>Header</h1>
    xm.p("paragraph")          #     <p>paragraph</p>
  }                            #   </body>
}                              # </html>

Notes:

  • The order that attributes are inserted in markup tags is undefined.

  • Sometimes you wish to insert text without enclosing tags. Use the text! method to accomplish this.

    Example:

    xm.div {                          # <div>
      xm.text! "line"; xm.br          #   line<br/>
      xm.text! "another line"; xmbr   #    another line<br/>
    }                                 # </div>
    
  • The special XML characters <, >, and & are converted to &lt;, &gt; and &amp; automatically. Use the << operation to insert text without modification.

  • Sometimes tags use special characters not allowed in ruby identifiers. Use the tag! method to handle these cases.

    Example:

    xml.tag!("SOAP:Envelope") { ... }
    

    will produce …

    <SOAP:Envelope> ... </SOAP:Envelope>"
    

    tag! will also take text and attribute arguments (after the tag name) like normal markup methods. (But see the next bullet item for a better way to handle XML namespaces).

  • Direct support for XML namespaces is now available. If the first argument to a tag call is a symbol, it will be joined to the tag to produce a namespace:tag combination. It is easier to show this than describe it.

    xml.SOAP :Envelope do ... end
    

    Just put a space before the colon in a namespace to produce the right form for builder (e.g. “SOAP:Envelope” => “xml.SOAP :Envelope”)

  • XmlMarkup builds the markup in any object (called a target) that accepts the << method. If no target is given, then XmlMarkup defaults to a string target.

    Examples:

    xm = Builder::XmlMarkup.new
    result = xm.title("yada")
    # result is a string containing the markup.
    
    buffer = ""
    xm = Builder::XmlMarkup.new(buffer)
    # The markup is appended to buffer (using <<)
    
    xm = Builder::XmlMarkup.new(STDOUT)
    # The markup is written to STDOUT (using <<)
    
    xm = Builder::XmlMarkup.new
    x2 = Builder::XmlMarkup.new(:target=>xm)
    # Markup written to +x2+ will be send to +xm+.
    
  • Indentation is enabled by providing the number of spaces to indent for each level as a second argument to XmlBuilder.new. Initial indentation may be specified using a third parameter.

    Example:

    xm = Builder.new(:ident=>2)
    # xm will produce nicely formatted and indented XML.
    
    xm = Builder.new(:indent=>2, :margin=>4)
    # xm will produce nicely formatted and indented XML with 2
    # spaces per indent and an over all indentation level of 4.
    
    builder = Builder::XmlMarkup.new(:target=>$stdout, :indent=>2)
    builder.name { |b| b.first("Jim"); b.last("Weirich) }
    # prints:
    #     <name>
    #       <first>Jim</first>
    #       <last>Weirich</last>
    #     </name>
    
  • The instance_eval implementation which forces self to refer to the message receiver as self is now obsolete. We now use normal block calls to execute the markup block. This means that all markup methods must now be explicitly send to the xml builder. For instance, instead of

    xml.div { strong("text") }
    

    you need to write:

    xml.div { xml.strong("text") }
    

    Although more verbose, the subtle change in semantics within the block was found to be prone to error. To make this change a little less cumbersome, the markup block now gets the markup object sent as an argument, allowing you to use a shorter alias within the block.

    For example:

    xml_builder = Builder::XmlMarkup.new
    xml_builder.div { |xml|
      xml.stong("text")
    }
    

Direct Known Subclasses

XmlEvents

Instance Method Summary collapse

Methods inherited from XmlBase

#<<, #method_missing, #nil?, #tag!, #text!

Methods inherited from BlankSlate

hide

Constructor Details

#initialize(options = {}) ⇒ XmlMarkup

Create an XML markup builder. Parameters are specified by an option hash.

:target=>target_object

Object receiving the markup. out must respond to the << operator. The default is a plain string target.

:indent=>indentation

Number of spaces used for indentation. The default is no indentation and no line breaks.

:margin=>initial_indentation_level

Amount of initial indentation (specified in levels, not spaces).


175
176
177
178
179
180
# File 'lib/action_view/vendor/builder/xmlmarkup.rb', line 175

def initialize(options={})
  indent = options[:indent] || 0
  margin = options[:margin] || 0
  super(indent, margin)
  @target = options[:target] || ""
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method in the class Builder::XmlBase

Instance Method Details

#cdata!(text) ⇒ Object

Surrounds the given text with a CDATA tag

For example:

xml.cdata! "blah blah blah"
    # => <![CDATA[blah blah blah]]>

248
249
250
251
# File 'lib/action_view/vendor/builder/xmlmarkup.rb', line 248

def cdata!(text)
  _ensure_no_block block_given?
  _special("<![CDATA[", "]]>", text, nil)
end

#comment!(comment_text) ⇒ Object


187
188
189
190
# File 'lib/action_view/vendor/builder/xmlmarkup.rb', line 187

def comment!(comment_text)
  _ensure_no_block block_given?
  _special("<!-- ", " -->", comment_text, nil)
end

#declare!(inst, *args, &block) ⇒ Object

Insert an XML declaration into the XML markup.

For example:

xml.declare! :ELEMENT, :blah, "yada"
    # => <!ELEMENT blah "yada">

198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
# File 'lib/action_view/vendor/builder/xmlmarkup.rb', line 198

def declare!(inst, *args, &block)
  _indent
  @target << "<!#{inst}"
  args.each do |arg|
	case arg
	when String
	  @target << %{ "#{arg}"}
	when Symbol
	  @target << " #{arg}"
	end
  end
  if block_given?
	@target << " ["
	_newline
	_nested_structures(block)
	@target << "]"
  end
  @target << ">"
  _newline
end

#instruct!(directive_tag = :xml, attrs = {}) ⇒ Object

Insert a processing instruction into the XML markup. E.g.

For example:

xml.instruct!
    #=> <?xml version="1.0" encoding="UTF-8"?>
xml.instruct! :aaa, :bbb=>"ccc"
    #=> <?aaa bbb="ccc"?>

228
229
230
231
232
233
234
235
236
237
238
239
240
# File 'lib/action_view/vendor/builder/xmlmarkup.rb', line 228

def instruct!(directive_tag=:xml, attrs={})
  _ensure_no_block block_given?
  if directive_tag == :xml
	a = { :version=>"1.0", :encoding=>"UTF-8" }
	attrs = a.merge attrs
  end
  _special(
	"<?#{directive_tag}",
	"?>",
	nil,
	attrs,
	[:version, :encoding, :standalone])
end

#target!Object

Return the target of the builder.


183
184
185
# File 'lib/action_view/vendor/builder/xmlmarkup.rb', line 183

def target!
  @target
end