video_chat_get 0.1.9 → 0.2.0

data/vendor/bundle/ruby/2.5.0/gems/nokogiri-1.10.9/lib/nokogiri/html/entity_lookup.rb

@@ -1,13 +0,0 @@
-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/bundle/ruby/2.5.0/gems/nokogiri-1.10.9/lib/nokogiri/html/sax/parser.rb

@@ -1,62 +0,0 @@
-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/bundle/ruby/2.5.0/gems/nokogiri-1.10.9/lib/nokogiri/html/sax/parser_context.rb

@@ -1,16 +0,0 @@
-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/bundle/ruby/2.5.0/gems/nokogiri-1.10.9/lib/nokogiri/html/sax/push_parser.rb

@@ -1,36 +0,0 @@
-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/bundle/ruby/2.5.0/gems/nokogiri-1.10.9/lib/nokogiri/syntax_error.rb

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

data/vendor/bundle/ruby/2.5.0/gems/nokogiri-1.10.9/lib/nokogiri/version.rb

@@ -1,109 +0,0 @@
-module Nokogiri
-  # The version of Nokogiri you are using
-  VERSION = "1.10.9"
-
-  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/bundle/ruby/2.5.0/gems/nokogiri-1.10.9/lib/nokogiri/xml.rb

@@ -1,75 +0,0 @@
-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/bundle/ruby/2.5.0/gems/nokogiri-1.10.9/lib/nokogiri/xml/attr.rb

@@ -1,14 +0,0 @@
-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/bundle/ruby/2.5.0/gems/nokogiri-1.10.9/lib/nokogiri/xml/attribute_decl.rb

@@ -1,18 +0,0 @@
-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/bundle/ruby/2.5.0/gems/nokogiri-1.10.9/lib/nokogiri/xml/builder.rb

@@ -1,446 +0,0 @@
-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
-          klassname = "::" + (self.class.name.split("::")[0..-2] + ["Document"]).join("::")
-          klass = begin
-                    Object.const_get(klassname)
-                  rescue NameError
-                    Nokogiri::XML::Document
-                  end
-          @parent = @doc = klass.new
-        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