Class: Builder::XmlMarkup
- Inherits:
-
XmlBase
- Object
- BlankSlate
- XmlBase
- Builder::XmlMarkup
- Defined in:
- lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/builder-3.2.4/lib/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 { xm.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 { 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 <, > 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") }
Direct Known Subclasses
Instance Method Summary collapse
-
#cdata!(text) ⇒ Object
Insert a CDATA section into the XML markup.
- #cdata_value!(open, text) ⇒ Object
- #comment!(comment_text) ⇒ Object
-
#declare!(inst, *args, &block) ⇒ Object
Insert an XML declaration into the XML markup.
-
#initialize(options = {}) ⇒ XmlMarkup
constructor
Create an XML markup builder.
-
#instruct!(directive_tag = :xml, attrs = {}) ⇒ Object
Insert a processing instruction into the XML markup.
-
#target! ⇒ Object
Return the target of the builder.
Methods inherited from XmlBase
#<<, #explicit_nil_handling?, #method_missing, #nil?, #tag!, #text!
Methods inherited from BlankSlate
find_hidden_method, hide, reveal
Constructor Details
#initialize(options = {}) ⇒ XmlMarkup
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.
190 191 192 193 194 195 196 197 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/builder-3.2.4/lib/builder/xmlmarkup.rb', line 190 def initialize(={}) indent = [:indent] || 0 margin = [:margin] || 0 @quote = ([:quote] == :single) ? "'" : '"' @explicit_nil_handling = [:explicit_nil_handling] super(indent, margin) @target = [:target] || "".dup 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
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]]>
270 271 272 273 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/builder-3.2.4/lib/builder/xmlmarkup.rb', line 270 def cdata!(text) _ensure_no_block ::Kernel::block_given? _special("<![CDATA[", "]]>", text.gsub(']]>', ']]]]><![CDATA[>'), nil) end |
#cdata_value!(open, text) ⇒ Object
275 276 277 278 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/builder-3.2.4/lib/builder/xmlmarkup.rb', line 275 def cdata_value!(open, text) _ensure_no_block ::Kernel::block_given? _special("<#{open}>", "</#{open}>", "<![CDATA[#{text.gsub(']]>', ']]]]><![CDATA[>')}]]>", nil) end |
#comment!(comment_text) ⇒ Object
204 205 206 207 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/builder-3.2.4/lib/builder/xmlmarkup.rb', line 204 def comment!(comment_text) _ensure_no_block ::Kernel::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">
215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/builder-3.2.4/lib/builder/xmlmarkup.rb', line 215 def declare!(inst, *args, &block) _indent @target << "<!#{inst}" args.each do |arg| case arg when ::String @target << %{ "#{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 = {}) ⇒ 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"?>
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.
248 249 250 251 252 253 254 255 256 257 258 259 260 261 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/builder-3.2.4/lib/builder/xmlmarkup.rb', line 248 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! ⇒ Object
Return the target of the builder.
200 201 202 |
# File 'lib/rubypitaya/app-template/vendor/bundle/ruby/3.1.0/gems/builder-3.2.4/lib/builder/xmlmarkup.rb', line 200 def target! @target end |