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.
![[+]](../images/find.png "show/hide quicksearch"){kind=small}
xm.em("emphasized") # => <em>emphasized</em>
xm.em { xmm.b("emp & bold") } # => <em><b>emph & 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>
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 <, > and & 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(:indent=>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")
}
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). |
| :escape_attrs=>OBSOLETE | The :escape_attrs option is no longer supported by builder (and will be quietly ignored). String attribute values are now automatically escaped. If you need unescaped attribute values (perhaps you are using entities in the attribute values), then give the value as a Symbol. This allows much finer control over escaping attribute values. |
# File lib/builder/xmlmarkup.rb, line 185
185: def initialize(options={})
186: indent = options[:indent] || 0
187: margin = options[:margin] || 0
188: super(indent, margin)
189: @target = options[:target] || ""
190: end
Insert a CDATA section into the XML markup.
For example:
xml.cdata!("text to be included in cdata")
#=> <![CDATA[text to be included in cdata]]>
# File lib/builder/xmlmarkup.rb, line 259
259: def cdata!(text)
260: _ensure_no_block block_given?
261: _special("<![CDATA[", "]]>", text, nil)
262: end
Insert an XML declaration into the XML markup.
For example:
xml.declare! :ELEMENT, :blah, "yada"
# => <!ELEMENT blah "yada">
# File lib/builder/xmlmarkup.rb, line 208
208: def declare!(inst, *args, &block)
209: _indent
210: @target << "<!#{inst}"
211: args.each do |arg|
212: case arg
213: when String
214: @target << %{ "#{arg}"} # " WART
215: when Symbol
216: @target << " #{arg}"
217: end
218: end
219: if block_given?
220: @target << " ["
221: _newline
222: _nested_structures(block)
223: @target << "]"
224: end
225: @target << ">"
226: _newline
227: end
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"?>
# File lib/builder/xmlmarkup.rb, line 238
238: def instruct!(directive_tag=:xml, attrs={})
239: _ensure_no_block block_given?
240: if directive_tag == :xml
241: a = { :version=>"1.0", :encoding=>"UTF-8" }
242: attrs = a.merge attrs
243: end
244: _special(
245: "<?#{directive_tag}",
246: "?>",
247: nil,
248: attrs,
249: [:version, :encoding, :standalone])
250: end
# File lib/builder/xmlmarkup.rb, line 310
310: def _attr_value(value)
311: case value
312: when Symbol
313: value.to_s
314: else
315: _escape_quote(value.to_s)
316: end
317: end
Insert an ending tag.
# File lib/builder/xmlmarkup.rb, line 294
294: def _end_tag(sym)
295: @target << "</#{sym}>"
296: end
# File lib/builder/xmlmarkup.rb, line 319
319: def _ensure_no_block(got_block)
320: if got_block
321: fail IllegalBlockError,
322: "Blocks are not allowed on XML instructions"
323: end
324: end
Insert the attributes (given in the hash).
# File lib/builder/xmlmarkup.rb, line 299
299: def _insert_attributes(attrs, order=[])
300: return if attrs.nil?
301: order.each do |k|
302: v = attrs[k]
303: @target << %{ #{k}="#{_attr_value(v)}"} if v # " WART
304: end
305: attrs.each do |k, v|
306: @target << %{ #{k}="#{_attr_value(v)}"} unless order.member?(k) # " WART
307: end
308: end
Insert special instruction.
# File lib/builder/xmlmarkup.rb, line 275
275: def _special(open, close, data=nil, attrs=nil, order=[])
276: _indent
277: @target << open
278: @target << data if data
279: _insert_attributes(attrs, order) if attrs
280: @target << close
281: _newline
282: end
Start an XML tag. If end_too is true, then the start tag is also
the end tag (e.g.
# File lib/builder/xmlmarkup.rb, line 286
286: def _start_tag(sym, attrs, end_too=false)
287: @target << "<#{sym}"
288: _insert_attributes(attrs)
289: @target << "/" if end_too
290: @target << ">"
291: end
Disabled; run with --debug to generate this.
Generated with the Darkfish Rdoc Generator 1.1.6.
# File lib/builder/xmlmarkup.rb, line 197 197: def comment!(comment_text) 198: _ensure_no_block block_given? 199: _special("<!-- ", " -->", comment_text, nil) 200: end