Builder::XmlMarkup

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 { xm.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 { xm.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:

 
    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>

Public Class Methods

new(options={}) click to toggle source

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

:target=>target_object

Object receiving the markup. target_object must respond to the <<(a_string) operator and return itself. The default target 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 186
186:     def initialize(options={})
187:       indent = options[:indent] || 0
188:       margin = options[:margin] || 0
189:       super(indent, margin)
190:       @target = options[:target] || ""
191:     end

Public Instance Methods

cdata!(text) click to toggle source

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 264
264:     def cdata!(text)
265:       _ensure_no_block ::Kernel::block_given?
266:       _special("<![CDATA[", "]]>", text, nil)
267:     end
comment!(comment_text) click to toggle source
     # File lib/builder/xmlmarkup.rb, line 198
198:     def comment!(comment_text)
199:       _ensure_no_block ::Kernel::block_given?
200:       _special("<!-- ", " -->", comment_text, nil)
201:     end
declare!(inst, *args, &block) click to toggle source

Insert an XML declaration into the XML markup.

For example:

  xml.declare! :ELEMENT, :blah, "yada"
      # => <!ELEMENT blah "yada">
     # File lib/builder/xmlmarkup.rb, line 209
209:     def declare!(inst, *args, &block)
210:       _indent
211:       @target << "<!#{inst}"
212:       args.each do |arg|
213:         case arg
214:         when ::String
215:           @target << %{ "#{arg}"} # " WART
216:         when ::Symbol
217:           @target << " #{arg}"
218:         end
219:       end
220:       if ::Kernel::block_given?
221:         @target << " ["
222:         _newline
223:         _nested_structures(block)
224:         @target << "]"
225:       end
226:       @target << ">"
227:       _newline
228:     end
instruct!(directive_tag=:xml, attrs={}) click to toggle source

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"?>

Note: If the encoding is setup to “UTF-8” and the value of $KCODE is “UTF8”, then builder will emit UTF-8 encoded strings rather than the entity encoding normally used.

     # File lib/builder/xmlmarkup.rb, line 242
242:     def instruct!(directive_tag=:xml, attrs={})
243:       _ensure_no_block ::Kernel::block_given?
244:       if directive_tag == :xml
245:         a = { :version=>"1.0", :encoding=>"UTF-8" }
246:         attrs = a.merge attrs
247:         @encoding = attrs[:encoding].downcase
248:       end
249:       _special(
250:         "<?#{directive_tag}",
251:         "?>",
252:         nil,
253:         attrs,
254:         [:version, :encoding, :standalone])
255:     end
target!() click to toggle source

Return the target of the builder.

     # File lib/builder/xmlmarkup.rb, line 194
194:     def target!
195:       @target
196:     end

Private Instance Methods

_attr_value(value) click to toggle source
     # File lib/builder/xmlmarkup.rb, line 315
315:     def _attr_value(value)
316:       case value
317:       when ::Symbol
318:         value.to_s
319:       else
320:         _escape_quote(value.to_s)
321:       end
322:     end
_end_tag(sym) click to toggle source

Insert an ending tag.

     # File lib/builder/xmlmarkup.rb, line 299
299:     def _end_tag(sym)
300:       @target << "</#{sym}>"
301:     end
_ensure_no_block(got_block) click to toggle source
     # File lib/builder/xmlmarkup.rb, line 324
324:     def _ensure_no_block(got_block)
325:       if got_block
326:         ::Kernel::raise IllegalBlockError.new(
327:           "Blocks are not allowed on XML instructions"
328:         )
329:       end
330:     end
_insert_attributes(attrs, order=[]) click to toggle source

Insert the attributes (given in the hash).

     # File lib/builder/xmlmarkup.rb, line 304
304:     def _insert_attributes(attrs, order=[])
305:       return if attrs.nil?
306:       order.each do |k|
307:         v = attrs[k]
308:         @target << %{ #{k}="#{_attr_value(v)}"} if v # " WART
309:       end
310:       attrs.each do |k, v|
311:         @target << %{ #{k}="#{_attr_value(v)}"} unless order.member?(k) # " WART
312:       end
313:     end
_special(open, close, data=nil, attrs=nil, order=[]) click to toggle source

Insert special instruction.

     # File lib/builder/xmlmarkup.rb, line 280
280:     def _special(open, close, data=nil, attrs=nil, order=[])
281:       _indent
282:       @target << open
283:       @target << data if data
284:       _insert_attributes(attrs, order) if attrs
285:       @target << close
286:       _newline
287:     end
_start_tag(sym, attrs, end_too=false) click to toggle source

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 291
291:     def _start_tag(sym, attrs, end_too=false)
292:       @target << "<#{sym}"
293:       _insert_attributes(attrs)
294:       @target << "/" if end_too
295:       @target << ">"
296:     end
_text(text) click to toggle source

Insert text directly in to the builder’s target.

     # File lib/builder/xmlmarkup.rb, line 275
275:     def _text(text)
276:       @target << text
277:     end

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.