daslabs 0.4.0

data/vendor/cache/ruby/2.5.0/gems/nokogiri-1.8.2/lib/nokogiri/html/entity_lookup.rb

@@ -0,0 +1,13 @@
+module Nokogiri
+  module HTML
+    class EntityDescription < Struct.new(:value, :name, :description); end
+
+    class EntityLookup
+      ###
+      # Look up entity with +name+
+      def [] name
+        (val = get(name)) && val.value
+      end
+    end
+  end
+end

data/vendor/cache/ruby/2.5.0/gems/nokogiri-1.8.2/lib/nokogiri/html/sax/parser.rb

@@ -0,0 +1,62 @@
+module Nokogiri
+  module HTML
+    ###
+    # Nokogiri lets you write a SAX parser to process HTML but get HTML
+    # correction features.
+    #
+    # See Nokogiri::HTML::SAX::Parser for a basic example of using a
+    # SAX parser with HTML.
+    #
+    # For more information on SAX parsers, see Nokogiri::XML::SAX
+    module SAX
+      ###
+      # This class lets you perform SAX style parsing on HTML with HTML
+      # error correction.
+      #
+      # Here is a basic usage example:
+      #
+      #   class MyDoc < Nokogiri::XML::SAX::Document
+      #     def start_element name, attributes = []
+      #       puts "found a #{name}"
+      #     end
+      #   end
+      #
+      #   parser = Nokogiri::HTML::SAX::Parser.new(MyDoc.new)
+      #   parser.parse(File.read(ARGV[0], mode: 'rb'))
+      #
+      # For more information on SAX parsers, see Nokogiri::XML::SAX
+      class Parser < Nokogiri::XML::SAX::Parser
+        ###
+        # Parse html stored in +data+ using +encoding+
+        def parse_memory data, encoding = 'UTF-8'
+          raise ArgumentError unless data
+          return unless data.length > 0
+          ctx = ParserContext.memory(data, encoding)
+          yield ctx if block_given?
+          ctx.parse_with self
+        end
+
+        ###
+        # Parse given +io+
+        def parse_io io, encoding = 'UTF-8'
+          check_encoding(encoding)
+          @encoding = encoding
+          ctx = ParserContext.io(io, ENCODINGS[encoding])
+          yield ctx if block_given?
+          ctx.parse_with self
+        end
+
+        ###
+        # Parse a file with +filename+
+        def parse_file filename, encoding = 'UTF-8'
+          raise ArgumentError unless filename
+          raise Errno::ENOENT unless File.exist?(filename)
+          raise Errno::EISDIR if File.directory?(filename)
+          ctx = ParserContext.file(filename, encoding)
+          yield ctx if block_given?
+          ctx.parse_with self
+        end
+      end
+    end
+  end
+end

data/vendor/cache/ruby/2.5.0/gems/nokogiri-1.8.2/lib/nokogiri/html/sax/parser_context.rb

@@ -0,0 +1,16 @@
+module Nokogiri
+  module HTML
+    module SAX
+      ###
+      # Context for HTML SAX parsers.  This class is usually not instantiated
+      # by the user.  Instead, you should be looking at
+      # Nokogiri::HTML::SAX::Parser
+      class ParserContext < Nokogiri::XML::SAX::ParserContext
+        def self.new thing, encoding = 'UTF-8'
+          [:read, :close].all? { |x| thing.respond_to?(x) } ?  super :
+            memory(thing, encoding)
+        end
+      end
+    end
+  end
+end

data/vendor/cache/ruby/2.5.0/gems/nokogiri-1.8.2/lib/nokogiri/html/sax/push_parser.rb

@@ -0,0 +1,36 @@
+module Nokogiri
+  module HTML
+    module SAX
+      class PushParser
+        
+        # The Nokogiri::HTML::SAX::Document on which the PushParser will be
+        # operating
+        attr_accessor :document
+        
+        def initialize(doc = HTML::SAX::Document.new, file_name = nil, encoding = 'UTF-8')
+          @document = doc
+          @encoding = encoding
+          @sax_parser = HTML::SAX::Parser.new(doc, @encoding)
+
+          ## Create our push parser context
+          initialize_native(@sax_parser, file_name, encoding)
+        end
+        
+        ###
+        # Write a +chunk+ of HTML to the PushParser.  Any callback methods
+        # that can be called will be called immediately.
+        def write chunk, last_chunk = false
+          native_write(chunk, last_chunk)
+        end
+        alias :<< :write
+
+        ###
+        # Finish the parsing.  This method is only necessary for
+        # Nokogiri::HTML::SAX::Document#end_document to be called.
+        def finish
+          write '', true
+        end
+      end
+    end
+  end
+end

data/vendor/cache/ruby/2.5.0/gems/nokogiri-1.8.2/lib/nokogiri/syntax_error.rb

@@ -0,0 +1,4 @@
+module Nokogiri
+  class SyntaxError < ::StandardError
+  end
+end

data/vendor/cache/ruby/2.5.0/gems/nokogiri-1.8.2/lib/nokogiri/version.rb

@@ -0,0 +1,109 @@
+module Nokogiri
+  # The version of Nokogiri you are using
+  VERSION = '1.8.2'
+
+  class VersionInfo # :nodoc:
+    def jruby?
+      ::JRUBY_VERSION if RUBY_PLATFORM == "java"
+    end
+
+    def engine
+      defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'mri'
+    end
+
+    def loaded_parser_version
+      LIBXML_PARSER_VERSION.
+        scan(/^(\d+)(\d\d)(\d\d)(?!\d)/).first.
+        collect(&:to_i).
+        join(".")
+    end
+
+    def compiled_parser_version
+      LIBXML_VERSION
+    end
+
+    def libxml2?
+      defined?(LIBXML_VERSION)
+    end
+
+    def libxml2_using_system?
+      ! libxml2_using_packaged?
+    end
+
+    def libxml2_using_packaged?
+      NOKOGIRI_USE_PACKAGED_LIBRARIES
+    end
+
+    def warnings
+      return [] unless libxml2?
+
+      if compiled_parser_version != loaded_parser_version
+        ["Nokogiri was built against LibXML version #{compiled_parser_version}, but has dynamically loaded #{loaded_parser_version}"]
+      else
+        []
+      end
+    end
+
+    def to_hash
+      hash_info = {}
+      hash_info['warnings']              = []
+      hash_info['nokogiri']              = Nokogiri::VERSION
+      hash_info['ruby']                  = {}
+      hash_info['ruby']['version']       = ::RUBY_VERSION
+      hash_info['ruby']['platform']      = ::RUBY_PLATFORM
+      hash_info['ruby']['description']   = ::RUBY_DESCRIPTION
+      hash_info['ruby']['engine']        = engine
+      hash_info['ruby']['jruby']         = jruby? if jruby?
+
+      if libxml2?
+        hash_info['libxml']              = {}
+        hash_info['libxml']['binding']   = 'extension'
+        if libxml2_using_packaged?
+          hash_info['libxml']['source']  = "packaged"
+          hash_info['libxml']['libxml2_path'] = NOKOGIRI_LIBXML2_PATH
+          hash_info['libxml']['libxslt_path'] = NOKOGIRI_LIBXSLT_PATH
+          hash_info['libxml']['libxml2_patches'] = NOKOGIRI_LIBXML2_PATCHES
+          hash_info['libxml']['libxslt_patches'] = NOKOGIRI_LIBXSLT_PATCHES
+        else
+          hash_info['libxml']['source']  = "system"
+        end
+        hash_info['libxml']['compiled']  = compiled_parser_version
+        hash_info['libxml']['loaded']    = loaded_parser_version
+        hash_info['warnings']            = warnings
+      elsif jruby?
+        hash_info['xerces']   = Nokogiri::XERCES_VERSION
+        hash_info['nekohtml'] = Nokogiri::NEKO_VERSION
+      end
+
+      hash_info
+    end
+
+    def to_markdown
+      begin
+        require 'psych'
+      rescue LoadError
+      end
+      require 'yaml'
+      "# Nokogiri (#{Nokogiri::VERSION})\n" +
+      YAML.dump(to_hash).each_line.map { |line| "    #{line}" }.join
+    end
+
+    # FIXME: maybe switch to singleton?
+    @@instance = new
+    @@instance.warnings.each do |warning|
+      warn "WARNING: #{warning}"
+    end
+    def self.instance; @@instance; end
+  end
+
+  # More complete version information about libxml
+  VERSION_INFO = VersionInfo.instance.to_hash
+
+  def self.uses_libxml? # :nodoc:
+    VersionInfo.instance.libxml2?
+  end
+
+  def self.jruby? # :nodoc:
+    VersionInfo.instance.jruby?
+  end
+end

data/vendor/cache/ruby/2.5.0/gems/nokogiri-1.8.2/lib/nokogiri/xml.rb

@@ -0,0 +1,75 @@
+require 'nokogiri/xml/pp'
+require 'nokogiri/xml/parse_options'
+require 'nokogiri/xml/sax'
+require 'nokogiri/xml/searchable'
+require 'nokogiri/xml/node'
+require 'nokogiri/xml/attribute_decl'
+require 'nokogiri/xml/element_decl'
+require 'nokogiri/xml/element_content'
+require 'nokogiri/xml/character_data'
+require 'nokogiri/xml/namespace'
+require 'nokogiri/xml/attr'
+require 'nokogiri/xml/dtd'
+require 'nokogiri/xml/cdata'
+require 'nokogiri/xml/text'
+require 'nokogiri/xml/document'
+require 'nokogiri/xml/document_fragment'
+require 'nokogiri/xml/processing_instruction'
+require 'nokogiri/xml/node_set'
+require 'nokogiri/xml/syntax_error'
+require 'nokogiri/xml/xpath'
+require 'nokogiri/xml/xpath_context'
+require 'nokogiri/xml/builder'
+require 'nokogiri/xml/reader'
+require 'nokogiri/xml/notation'
+require 'nokogiri/xml/entity_decl'
+require 'nokogiri/xml/entity_reference'
+require 'nokogiri/xml/schema'
+require 'nokogiri/xml/relax_ng'
+
+module Nokogiri
+  class << self
+    ###
+    # Parse XML.  Convenience method for Nokogiri::XML::Document.parse
+    def XML thing, url = nil, encoding = nil, options = XML::ParseOptions::DEFAULT_XML, &block
+      Nokogiri::XML::Document.parse(thing, url, encoding, options, &block)
+    end
+  end
+
+  module XML
+    # Original C14N 1.0 spec canonicalization
+    XML_C14N_1_0 =       0
+    # Exclusive C14N 1.0 spec canonicalization
+    XML_C14N_EXCLUSIVE_1_0 =     1
+    # C14N 1.1 spec canonicalization
+    XML_C14N_1_1 = 2
+    class << self
+      ###
+      # Parse an XML document using the Nokogiri::XML::Reader API.  See
+      # Nokogiri::XML::Reader for mor information
+      def Reader string_or_io, url = nil, encoding = nil, options = ParseOptions::STRICT
+
+        options = Nokogiri::XML::ParseOptions.new(options) if Integer === options
+        # Give the options to the user
+        yield options if block_given?
+
+        if string_or_io.respond_to? :read
+          return Reader.from_io(string_or_io, url, encoding, options.to_i)
+        end
+        Reader.from_memory(string_or_io, url, encoding, options.to_i)
+      end
+
+      ###
+      # Parse XML.  Convenience method for Nokogiri::XML::Document.parse
+      def parse thing, url = nil, encoding = nil, options = ParseOptions::DEFAULT_XML, &block
+        Document.parse(thing, url, encoding, options, &block)
+      end
+
+      ####
+      # Parse a fragment from +string+ in to a NodeSet.
+      def fragment string
+        XML::DocumentFragment.parse(string)
+      end
+    end
+  end
+end

data/vendor/cache/ruby/2.5.0/gems/nokogiri-1.8.2/lib/nokogiri/xml/attr.rb

@@ -0,0 +1,14 @@
+module Nokogiri
+  module XML
+    class Attr < Node
+      alias :value :content
+      alias :to_s :content
+      alias :content= :value=
+
+      private
+      def inspect_attributes
+        [:name, :namespace, :value]
+      end
+    end
+  end
+end

data/vendor/cache/ruby/2.5.0/gems/nokogiri-1.8.2/lib/nokogiri/xml/attribute_decl.rb

@@ -0,0 +1,18 @@
+module Nokogiri
+  module XML
+    ###
+    # Represents an attribute declaration in a DTD
+    class AttributeDecl < Nokogiri::XML::Node
+      undef_method :attribute_nodes
+      undef_method :attributes
+      undef_method :content
+      undef_method :namespace
+      undef_method :namespace_definitions
+      undef_method :line if method_defined?(:line)
+
+      def inspect
+        "#<#{self.class.name}:#{sprintf("0x%x", object_id)} #{to_s.inspect}>"
+      end
+    end
+  end
+end

data/vendor/cache/ruby/2.5.0/gems/nokogiri-1.8.2/lib/nokogiri/xml/builder.rb

@@ -0,0 +1,443 @@
+module Nokogiri
+  module XML
+    ###
+    # Nokogiri builder can be used for building XML and HTML documents.
+    #
+    # == Synopsis:
+    #
+    #   builder = Nokogiri::XML::Builder.new do |xml|
+    #     xml.root {
+    #       xml.products {
+    #         xml.widget {
+    #           xml.id_ "10"
+    #           xml.name "Awesome widget"
+    #         }
+    #       }
+    #     }
+    #   end
+    #   puts builder.to_xml
+    #
+    # Will output:
+    #
+    #   <?xml version="1.0"?>
+    #   <root>
+    #     <products>
+    #       <widget>
+    #         <id>10</id>
+    #         <name>Awesome widget</name>
+    #       </widget>
+    #     </products>
+    #   </root>
+    #
+    #
+    # === Builder scope
+    #
+    # The builder allows two forms.  When the builder is supplied with a block
+    # that has a parameter, the outside scope is maintained.  This means you
+    # can access variables that are outside your builder.  If you don't need
+    # outside scope, you can use the builder without the "xml" prefix like
+    # this:
+    #
+    #   builder = Nokogiri::XML::Builder.new do
+    #     root {
+    #       products {
+    #         widget {
+    #           id_ "10"
+    #           name "Awesome widget"
+    #         }
+    #       }
+    #     }
+    #   end
+    #
+    # == Special Tags
+    #
+    # The builder works by taking advantage of method_missing.  Unfortunately
+    # some methods are defined in ruby that are difficult or dangerous to
+    # remove.  You may want to create tags with the name "type", "class", and
+    # "id" for example.  In that case, you can use an underscore to
+    # disambiguate your tag name from the method call.
+    #
+    # Here is an example of using the underscore to disambiguate tag names from
+    # ruby methods:
+    #
+    #   @objects = [Object.new, Object.new, Object.new]
+    #
+    #   builder = Nokogiri::XML::Builder.new do |xml|
+    #     xml.root {
+    #       xml.objects {
+    #         @objects.each do |o|
+    #           xml.object {
+    #             xml.type_   o.type
+    #             xml.class_  o.class.name
+    #             xml.id_     o.id
+    #           }
+    #         end
+    #       }
+    #     }
+    #   end
+    #   puts builder.to_xml
+    #
+    # The underscore may be used with any tag name, and the last underscore
+    # will just be removed.  This code will output the following XML:
+    #
+    #   <?xml version="1.0"?>
+    #   <root>
+    #     <objects>
+    #       <object>
+    #         <type>Object</type>
+    #         <class>Object</class>
+    #         <id>48390</id>
+    #       </object>
+    #       <object>
+    #         <type>Object</type>
+    #         <class>Object</class>
+    #         <id>48380</id>
+    #       </object>
+    #       <object>
+    #         <type>Object</type>
+    #         <class>Object</class>
+    #         <id>48370</id>
+    #       </object>
+    #     </objects>
+    #   </root>
+    #
+    # == Tag Attributes
+    #
+    # Tag attributes may be supplied as method arguments.  Here is our
+    # previous example, but using attributes rather than tags:
+    #
+    #   @objects = [Object.new, Object.new, Object.new]
+    #
+    #   builder = Nokogiri::XML::Builder.new do |xml|
+    #     xml.root {
+    #       xml.objects {
+    #         @objects.each do |o|
+    #           xml.object(:type => o.type, :class => o.class, :id => o.id)
+    #         end
+    #       }
+    #     }
+    #   end
+    #   puts builder.to_xml
+    #
+    # === Tag Attribute Short Cuts
+    #
+    # A couple attribute short cuts are available when building tags.  The
+    # short cuts are available by special method calls when building a tag.
+    #
+    # This example builds an "object" tag with the class attribute "classy"
+    # and the id of "thing":
+    #
+    #   builder = Nokogiri::XML::Builder.new do |xml|
+    #     xml.root {
+    #       xml.objects {
+    #         xml.object.classy.thing!
+    #       }
+    #     }
+    #   end
+    #   puts builder.to_xml
+    #
+    # Which will output:
+    #
+    #   <?xml version="1.0"?>
+    #   <root>
+    #     <objects>
+    #       <object class="classy" id="thing"/>
+    #     </objects>
+    #   </root>
+    #
+    # All other options are still supported with this syntax, including
+    # blocks and extra tag attributes.
+    #
+    # == Namespaces
+    #
+    # Namespaces are added similarly to attributes.  Nokogiri::XML::Builder
+    # assumes that when an attribute starts with "xmlns", it is meant to be
+    # a namespace:
+    #
+    #   builder = Nokogiri::XML::Builder.new { |xml|
+    #     xml.root('xmlns' => 'default', 'xmlns:foo' => 'bar') do
+    #       xml.tenderlove
+    #     end
+    #   }
+    #   puts builder.to_xml
+    #
+    # Will output XML like this:
+    #
+    #   <?xml version="1.0"?>
+    #   <root xmlns:foo="bar" xmlns="default">
+    #     <tenderlove/>
+    #   </root>
+    #
+    # === Referencing declared namespaces
+    #
+    # Tags that reference non-default namespaces (i.e. a tag "foo:bar") can be
+    # built by using the Nokogiri::XML::Builder#[] method.
+    #
+    # For example:
+    #
+    #   builder = Nokogiri::XML::Builder.new do |xml|
+    #     xml.root('xmlns:foo' => 'bar') {
+    #       xml.objects {
+    #         xml['foo'].object.classy.thing!
+    #       }
+    #     }
+    #   end
+    #   puts builder.to_xml
+    #
+    # Will output this XML:
+    #
+    #   <?xml version="1.0"?>
+    #   <root xmlns:foo="bar">
+    #     <objects>
+    #       <foo:object class="classy" id="thing"/>
+    #     </objects>
+    #   </root>
+    #
+    # Note the "foo:object" tag.
+    #
+    # == Document Types
+    #
+    # To create a document type (DTD), access use the Builder#doc method to get
+    # the current context document.  Then call Node#create_internal_subset to
+    # create the DTD node.
+    #
+    # For example, this Ruby:
+    #
+    #   builder = Nokogiri::XML::Builder.new do |xml|
+    #     xml.doc.create_internal_subset(
+    #       'html',
+    #       "-//W3C//DTD HTML 4.01 Transitional//EN",
+    #       "http://www.w3.org/TR/html4/loose.dtd"
+    #     )
+    #     xml.root do
+    #       xml.foo
+    #     end
+    #   end
+    #   
+    #   puts builder.to_xml
+    #
+    # Will output this xml:
+    #
+    #   <?xml version="1.0"?>
+    #   <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+    #   <root>
+    #     <foo/>
+    #   </root>
+    #
+    class Builder
+      # The current Document object being built
+      attr_accessor :doc
+
+      # The parent of the current node being built
+      attr_accessor :parent
+
+      # A context object for use when the block has no arguments
+      attr_accessor :context
+
+      attr_accessor :arity # :nodoc:
+
+      ###
+      # Create a builder with an existing root object.  This is for use when
+      # you have an existing document that you would like to augment with
+      # builder methods.  The builder context created will start with the
+      # given +root+ node.
+      #
+      # For example:
+      #
+      #   doc = Nokogiri::XML(open('somedoc.xml'))
+      #   Nokogiri::XML::Builder.with(doc.at('some_tag')) do |xml|
+      #     # ... Use normal builder methods here ...
+      #     xml.awesome # add the "awesome" tag below "some_tag"
+      #   end
+      #
+      def self.with root, &block
+        new({}, root, &block)
+      end
+
+      ###
+      # Create a new Builder object.  +options+ are sent to the top level
+      # Document that is being built.
+      #
+      # Building a document with a particular encoding for example:
+      #
+      #   Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |xml|
+      #     ...
+      #   end
+      def initialize options = {}, root = nil, &block
+
+        if root
+          @doc    = root.document
+          @parent = root
+        else
+          namespace     = self.class.name.split('::')
+          namespace[-1] = 'Document'
+          @doc          = eval(namespace.join('::')).new
+          @parent       = @doc
+        end
+
+        @context  = nil
+        @arity    = nil
+        @ns       = nil
+
+        options.each do |k,v|
+          @doc.send(:"#{k}=", v)
+        end
+
+        return unless block_given?
+
+        @arity = block.arity
+        if @arity <= 0
+          @context = eval('self', block.binding)
+          instance_eval(&block)
+        else
+          yield self
+        end
+
+        @parent = @doc
+      end
+
+      ###
+      # Create a Text Node with content of +string+
+      def text string
+        insert @doc.create_text_node(string)
+      end
+
+      ###
+      # Create a CDATA Node with content of +string+
+      def cdata string
+        insert doc.create_cdata(string)
+      end
+
+      ###
+      # Create a Comment Node with content of +string+
+      def comment string
+        insert doc.create_comment(string)
+      end
+
+      ###
+      # Build a tag that is associated with namespace +ns+.  Raises an
+      # ArgumentError if +ns+ has not been defined higher in the tree.
+      def [] ns
+        if @parent != @doc
+          @ns = @parent.namespace_definitions.find { |x| x.prefix == ns.to_s }
+        end
+        return self if @ns
+
+        @parent.ancestors.each do |a|
+          next if a == doc
+          @ns = a.namespace_definitions.find { |x| x.prefix == ns.to_s }
+          return self if @ns
+        end
+
+        @ns = { :pending => ns.to_s }
+        return self
+      end
+
+      ###
+      # Convert this Builder object to XML
+      def to_xml(*args)
+        if Nokogiri.jruby?
+          options = args.first.is_a?(Hash) ? args.shift : {}
+          if !options[:save_with]
+            options[:save_with] = Node::SaveOptions::AS_BUILDER
+          end
+          args.insert(0, options)
+        end
+        @doc.to_xml(*args)
+      end
+
+      ###
+      # Append the given raw XML +string+ to the document
+      def << string
+        @doc.fragment(string).children.each { |x| insert(x) }
+      end
+
+      def method_missing method, *args, &block # :nodoc:
+        if @context && @context.respond_to?(method)
+          @context.send(method, *args, &block)
+        else
+          node = @doc.create_element(method.to_s.sub(/[_!]$/, ''),*args) { |n|
+            # Set up the namespace
+            if @ns.is_a? Nokogiri::XML::Namespace
+              n.namespace = @ns
+              @ns = nil
+            end
+          }
+
+          if @ns.is_a? Hash
+            node.namespace = node.namespace_definitions.find { |x| x.prefix == @ns[:pending] }
+            if node.namespace.nil?
+              raise ArgumentError, "Namespace #{@ns[:pending]} has not been defined"
+            end
+            @ns = nil
+          end
+
+          insert(node, &block)
+        end
+      end
+
+      private
+      ###
+      # Insert +node+ as a child of the current Node
+      def insert(node, &block)
+        node = @parent.add_child(node)
+        if block_given?
+          old_parent = @parent
+          @parent    = node
+          @arity ||= block.arity
+          if @arity <= 0
+            instance_eval(&block)
+          else
+            block.call(self)
+          end
+          @parent = old_parent
+        end
+        NodeBuilder.new(node, self)
+      end
+
+      class NodeBuilder # :nodoc:
+        def initialize node, doc_builder
+          @node = node
+          @doc_builder = doc_builder
+        end
+
+        def []= k, v
+          @node[k] = v
+        end
+
+        def [] k
+          @node[k]
+        end
+
+        def method_missing(method, *args, &block)
+          opts = args.last.is_a?(Hash) ? args.pop : {}
+          case method.to_s
+          when /^(.*)!$/
+            @node['id'] = $1
+            @node.content = args.first if args.first
+          when /^(.*)=/
+            @node[$1] = args.first
+          else
+            @node['class'] =
+              ((@node['class'] || '').split(/\s/) + [method.to_s]).join(' ')
+            @node.content = args.first if args.first
+          end
+
+          # Assign any extra options
+          opts.each do |k,v|
+            @node[k.to_s] = ((@node[k.to_s] || '').split(/\s/) + [v]).join(' ')
+          end
+
+          if block_given?
+            old_parent = @doc_builder.parent
+            @doc_builder.parent = @node
+            value = @doc_builder.instance_eval(&block)
+            @doc_builder.parent = old_parent
+            return value
+          end
+          self
+        end
+      end
+    end
+  end
+end