# class 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:¶ ↑

- 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(: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")
      }

### 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).

:quote => :single

  Use single quotes for attributes rather than double quotes.

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

Calls superclass method Builder::XmlBase.new

    # File lib/builder/xmlmarkup.rb, line 189
    def initialize(options={})
      indent = options[:indent] || 0
      margin = options[:margin] || 0
      @quote = (options[:quote] == :single) ? "'" : '"'
      @explicit_nil_handling = options[:explicit_nil_handling]
      super(indent, margin)
      @target = options[:target] || ""
    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 269
    def cdata!(text)
      _ensure_no_block ::Kernel::block_given?
      _special("<![CDATA[", "]]>", text.gsub(']]>', ']]]]><![CDATA[>'), nil)
    end

comment!(comment_text) click to toggle source

    # File lib/builder/xmlmarkup.rb, line 203
    def comment!(comment_text)
      _ensure_no_block ::Kernel::block_given?
      _special("<!-- ", " -->", comment_text, nil)
    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 214
    def declare!(inst, *args, &block)
      _indent
      @target << "<!#{inst}"
      args.each do |arg|
        case arg
        when ::String
          @target << %Q{ "#{arg}"} # " WART
        when ::Symbol
          @target << " #{arg}"
        end
      end
      if ::Kernel::block_given?
        @target << " ["
        _newline
        _nested_structures(block)
        @target << "]"
      end
      @target << ">"
      _newline
    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 247
    def instruct!(directive_tag=:xml, attrs={})
      _ensure_no_block ::Kernel::block_given?
      if directive_tag == :xml
        a = { :version=>"1.0", :encoding=>"UTF-8" }
        attrs = a.merge attrs
        @encoding = attrs[:encoding].downcase
      end
      _special(
        "<?#{directive_tag}",
        "?>",
        nil,
        attrs,
        [:version, :encoding, :standalone])
    end

target!() click to toggle source

Return the target of the builder.

    # File lib/builder/xmlmarkup.rb, line 199
    def target!
      @target
    end

### Private Instance Methods

_attr_value(value) click to toggle source

    # File lib/builder/xmlmarkup.rb, line 320
    def _attr_value(value)
      case value
      when ::Symbol
        value.to_s
      else
        _escape_attribute(value.to_s)
      end
    end

_end_tag(sym) click to toggle source

Insert an ending tag.

    # File lib/builder/xmlmarkup.rb, line 304
    def _end_tag(sym)
      @target << "</#{sym}>"
    end

_ensure_no_block(got_block) click to toggle source

    # File lib/builder/xmlmarkup.rb, line 329
    def _ensure_no_block(got_block)
      if got_block
        ::Kernel::raise IllegalBlockError.new(
          "Blocks are not allowed on XML instructions"
        )
      end
    end

_insert_attributes(attrs, order=[]) click to toggle source

Insert the attributes (given in the hash).

    # File lib/builder/xmlmarkup.rb, line 309
    def _insert_attributes(attrs, order=[])
      return if attrs.nil?
      order.each do |k|
        v = attrs[k]
        @target << %Q{ #{k}=#{@quote}#{_attr_value(v)}#{@quote}} if v
      end
      attrs.each do |k, v|
        @target << %Q{ #{k}=#{@quote}#{_attr_value(v)}#{@quote}} unless order.member?(k) # " WART
      end
    end

_special(open, close, data=nil, attrs=nil, order=[]) click to toggle source

Insert special instruction.

    # File lib/builder/xmlmarkup.rb, line 285
    def _special(open, close, data=nil, attrs=nil, order=[])
      _indent
      @target << open
      @target << data if data
      _insert_attributes(attrs, order) if attrs
      @target << close
      _newline
    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. <br/>

    # File lib/builder/xmlmarkup.rb, line 296
    def _start_tag(sym, attrs, end_too=false)
      @target << "<#{sym}"
      _insert_attributes(attrs)
      @target << "/" if end_too
      @target << ">"
    end

_text(text) click to toggle source

Insert text directly in to the builder's target.

    # File lib/builder/xmlmarkup.rb, line 280
    def _text(text)
      @target << text
    end