husc 0.2.1 → 0.2.2

data/vendor/bundle/gems/nokogiri-1.10.7/lib/nokogiri/xml/document.rb

@@ -1,285 +0,0 @@
-module Nokogiri
-  module XML
-    ##
-    # Nokogiri::XML::Document is the main entry point for dealing with
-    # XML documents.  The Document is created by parsing an XML document.
-    # See Nokogiri::XML::Document.parse() for more information on parsing.
-    #
-    # For searching a Document, see Nokogiri::XML::Searchable#css and
-    # Nokogiri::XML::Searchable#xpath
-    #
-    class Document < Nokogiri::XML::Node
-      # I'm ignoring unicode characters here.
-      # See http://www.w3.org/TR/REC-xml-names/#ns-decl for more details.
-      NCNAME_START_CHAR = "A-Za-z_"
-      NCNAME_CHAR       = NCNAME_START_CHAR + "\\-.0-9"
-      NCNAME_RE         = /^xmlns(:[#{NCNAME_START_CHAR}][#{NCNAME_CHAR}]*)?$/
-
-      ##
-      # Parse an XML file.
-      #
-      # +string_or_io+ may be a String, or any object that responds to
-      # _read_ and _close_ such as an IO, or StringIO.
-      #
-      # +url+ (optional) is the URI where this document is located.
-      #
-      # +encoding+ (optional) is the encoding that should be used when processing
-      # the document.
-      #
-      # +options+ (optional) is a configuration object that sets options during
-      # parsing, such as Nokogiri::XML::ParseOptions::RECOVER. See the
-      # Nokogiri::XML::ParseOptions for more information.
-      #
-      # +block+ (optional) is passed a configuration object on which
-      # parse options may be set.
-      #
-      # By default, Nokogiri treats documents as untrusted, and so
-      # does not attempt to load DTDs or access the network. See
-      # Nokogiri::XML::ParseOptions for a complete list of options;
-      # and that module's DEFAULT_XML constant for what's set (and not
-      # set) by default.
-      #
-      # Nokogiri.XML() is a convenience method which will call this method.
-      #
-      def self.parse string_or_io, url = nil, encoding = nil, options = ParseOptions::DEFAULT_XML
-        options = Nokogiri::XML::ParseOptions.new(options) if Integer === options
-        # Give the options to the user
-        yield options if block_given?
-
-        if empty_doc?(string_or_io)
-          if options.strict?
-            raise Nokogiri::XML::SyntaxError.new("Empty document")
-          else
-            return encoding ? new.tap { |i| i.encoding = encoding } : new
-          end
-        end
-
-        doc = if string_or_io.respond_to?(:read)
-          url ||= string_or_io.respond_to?(:path) ? string_or_io.path : nil
-          read_io(string_or_io, url, encoding, options.to_i)
-        else
-          # read_memory pukes on empty docs
-          read_memory(string_or_io, url, encoding, options.to_i)
-        end
-
-        # do xinclude processing
-        doc.do_xinclude(options) if options.xinclude?
-
-        return doc
-      end
-
-      # A list of Nokogiri::XML::SyntaxError found when parsing a document
-      attr_accessor :errors
-
-      def initialize *args # :nodoc:
-        @errors     = []
-        @decorators = nil
-      end
-
-      ##
-      # Create an element with +name+, and optionally setting the content and attributes.
-      #
-      #   doc.create_element "div" # <div></div>
-      #   doc.create_element "div", :class => "container" # <div class='container'></div>
-      #   doc.create_element "div", "contents" # <div>contents</div>
-      #   doc.create_element "div", "contents", :class => "container" # <div class='container'>contents</div>
-      #   doc.create_element "div" { |node| node['class'] = "container" } # <div class='container'></div>
-      #
-      def create_element name, *args, &block
-        elm = Nokogiri::XML::Element.new(name, self, &block)
-        args.each do |arg|
-          case arg
-          when Hash
-            arg.each { |k,v|
-              key = k.to_s
-              if key =~ NCNAME_RE
-                ns_name = key.split(":", 2)[1]
-                elm.add_namespace_definition ns_name, v
-              else
-                elm[k.to_s] = v.to_s
-              end
-            }
-          else
-            elm.content = arg
-          end
-        end
-        if ns = elm.namespace_definitions.find { |n| n.prefix.nil? or n.prefix == '' }
-          elm.namespace = ns
-        end
-        elm
-      end
-
-      # Create a Text Node with +string+
-      def create_text_node string, &block
-        Nokogiri::XML::Text.new string.to_s, self, &block
-      end
-
-      # Create a CDATA Node containing +string+
-      def create_cdata string, &block
-        Nokogiri::XML::CDATA.new self, string.to_s, &block
-      end
-
-      # Create a Comment Node containing +string+
-      def create_comment string, &block
-        Nokogiri::XML::Comment.new self, string.to_s, &block
-      end
-
-      # The name of this document.  Always returns "document"
-      def name
-        'document'
-      end
-
-      # A reference to +self+
-      def document
-        self
-      end
-
-      ##
-      # Recursively get all namespaces from this node and its subtree and
-      # return them as a hash.
-      #
-      # For example, given this document:
-      #
-      #   <root xmlns:foo="bar">
-      #     <bar xmlns:hello="world" />
-      #   </root>
-      #
-      # This method will return:
-      #
-      #   { 'xmlns:foo' => 'bar', 'xmlns:hello' => 'world' }
-      #
-      # WARNING: this method will clobber duplicate names in the keys.
-      # For example, given this document:
-      #
-      #   <root xmlns:foo="bar">
-      #     <bar xmlns:foo="baz" />
-      #   </root>
-      #
-      # The hash returned will look like this: { 'xmlns:foo' => 'bar' }
-      #
-      # Non-prefixed default namespaces (as in "xmlns=") are not included
-      # in the hash.
-      #
-      # Note that this method does an xpath lookup for nodes with
-      # namespaces, and as a result the order may be dependent on the
-      # implementation of the underlying XML library.
-      #
-      def collect_namespaces
-        xpath("//namespace::*").inject({}) do |hash, ns|
-          hash[["xmlns",ns.prefix].compact.join(":")] = ns.href if ns.prefix != "xml"
-          hash
-        end
-      end
-
-      # Get the list of decorators given +key+
-      def decorators key
-        @decorators ||= Hash.new
-        @decorators[key] ||= []
-      end
-
-      ##
-      # Validate this Document against it's DTD.  Returns a list of errors on
-      # the document or +nil+ when there is no DTD.
-      def validate
-        return nil unless internal_subset
-        internal_subset.validate self
-      end
-
-      ##
-      # Explore a document with shortcut methods. See Nokogiri::Slop for details.
-      #
-      # Note that any nodes that have been instantiated before #slop!
-      # is called will not be decorated with sloppy behavior. So, if you're in
-      # irb, the preferred idiom is:
-      #
-      #   irb> doc = Nokogiri::Slop my_markup
-      #
-      # and not
-      #
-      #   irb> doc = Nokogiri::HTML my_markup
-      #   ... followed by irb's implicit inspect (and therefore instantiation of every node) ...
-      #   irb> doc.slop!
-      #   ... which does absolutely nothing.
-      #
-      def slop!
-        unless decorators(XML::Node).include? Nokogiri::Decorators::Slop
-          decorators(XML::Node) << Nokogiri::Decorators::Slop
-          decorate!
-        end
-
-        self
-      end
-
-      ##
-      # Apply any decorators to +node+
-      def decorate node
-        return unless @decorators
-        @decorators.each { |klass,list|
-          next unless node.is_a?(klass)
-          list.each { |moodule| node.extend(moodule) }
-        }
-      end
-
-      alias :to_xml :serialize
-      alias :clone :dup
-
-      # Get the hash of namespaces on the root Nokogiri::XML::Node
-      def namespaces
-        root ? root.namespaces : {}
-      end
-
-      ##
-      # Create a Nokogiri::XML::DocumentFragment from +tags+
-      # Returns an empty fragment if +tags+ is nil.
-      def fragment tags = nil
-        DocumentFragment.new(self, tags, self.root)
-      end
-
-      undef_method :swap, :parent, :namespace, :default_namespace=
-      undef_method :add_namespace_definition, :attributes
-      undef_method :namespace_definitions, :line, :add_namespace
-
-      def add_child node_or_tags
-        raise "A document may not have multiple root nodes." if (root && root.name != 'nokogiri_text_wrapper') && !(node_or_tags.comment? || node_or_tags.processing_instruction?)
-        node_or_tags = coerce(node_or_tags)
-        if node_or_tags.is_a?(XML::NodeSet)
-          raise "A document may not have multiple root nodes." if node_or_tags.size > 1
-          super(node_or_tags.first)
-        else
-          super
-        end
-      end
-      alias :<< :add_child
-
-      ##
-      # +JRuby+
-      # Wraps Java's org.w3c.dom.document and returns Nokogiri::XML::Document
-      def self.wrap document
-        raise "JRuby only method" unless Nokogiri.jruby?
-        return wrapJavaDocument(document)
-      end
-
-      ##
-      # +JRuby+
-      # Returns Java's org.w3c.dom.document of this Document.
-      def to_java
-        raise "JRuby only method" unless Nokogiri.jruby?
-        return toJavaDocument()
-      end
-
-      private
-      def self.empty_doc? string_or_io
-        string_or_io.nil? ||
-          (string_or_io.respond_to?(:empty?) && string_or_io.empty?) ||
-          (string_or_io.respond_to?(:eof?) && string_or_io.eof?)
-      end
-
-      # @private
-      IMPLIED_XPATH_CONTEXTS = [ '//'.freeze ].freeze # :nodoc:
-
-      def inspect_attributes
-        [:name, :children]
-      end
-    end
-  end
-end

data/vendor/bundle/gems/nokogiri-1.10.7/lib/nokogiri/xml/document_fragment.rb

@@ -1,160 +0,0 @@
-module Nokogiri
-  module XML
-    class DocumentFragment < Nokogiri::XML::Node
-      ##
-      #  Create a new DocumentFragment from +tags+.
-      #
-      #  If +ctx+ is present, it is used as a context node for the
-      #  subtree created, e.g., namespaces will be resolved relative
-      #  to +ctx+.
-      def initialize document, tags = nil, ctx = nil
-        return self unless tags
-
-        children = if ctx
-                     # Fix for issue#490
-                     if Nokogiri.jruby?
-                       # fix for issue #770
-                       ctx.parse("<root #{namespace_declarations(ctx)}>#{tags}</root>").children
-                     else
-                       ctx.parse(tags)
-                     end
-                   else
-                     XML::Document.parse("<root>#{tags}</root>") \
-                       .xpath("/root/node()")
-                   end
-        children.each { |child| child.parent = self }
-      end
-
-      if Nokogiri.uses_libxml?
-        def dup
-          new_document = document.dup
-          new_fragment = self.class.new(new_document)
-          children.each do |child|
-            child.dup(1, new_document).parent = new_fragment
-          end
-          new_fragment
-        end
-      end
-
-      ###
-      # return the name for DocumentFragment
-      def name
-        '#document-fragment'
-      end
-
-      ###
-      # Convert this DocumentFragment to a string
-      def to_s
-        children.to_s
-      end
-
-      ###
-      # Convert this DocumentFragment to html
-      # See Nokogiri::XML::NodeSet#to_html
-      def to_html *args
-        if Nokogiri.jruby?
-          options = args.first.is_a?(Hash) ? args.shift : {}
-          if !options[:save_with]
-            options[:save_with] = Node::SaveOptions::NO_DECLARATION | Node::SaveOptions::NO_EMPTY_TAGS | Node::SaveOptions::AS_HTML
-          end
-          args.insert(0, options)
-        end
-        children.to_html(*args)
-      end
-
-      ###
-      # Convert this DocumentFragment to xhtml
-      # See Nokogiri::XML::NodeSet#to_xhtml
-      def to_xhtml *args
-        if Nokogiri.jruby?
-          options = args.first.is_a?(Hash) ? args.shift : {}
-          if !options[:save_with]
-            options[:save_with] = Node::SaveOptions::NO_DECLARATION | Node::SaveOptions::NO_EMPTY_TAGS | Node::SaveOptions::AS_XHTML
-          end
-          args.insert(0, options)
-        end
-        children.to_xhtml(*args)
-      end
-
-      ###
-      # Convert this DocumentFragment to xml
-      # See Nokogiri::XML::NodeSet#to_xml
-      def to_xml *args
-        children.to_xml(*args)
-      end
-
-      ###
-      # call-seq: css *rules, [namespace-bindings, custom-pseudo-class]
-      #
-      # Search this fragment for CSS +rules+. +rules+ must be one or more CSS
-      # selectors. For example:
-      #
-      # For more information see Nokogiri::XML::Searchable#css
-      def css *args
-        if children.any?
-          children.css(*args) # 'children' is a smell here
-        else
-          NodeSet.new(document)
-        end
-      end
-
-      #
-      #  NOTE that we don't delegate #xpath to children ... another smell.
-      #  def xpath ; end
-      #
-
-      ###
-      # call-seq: search *paths, [namespace-bindings, xpath-variable-bindings, custom-handler-class]
-      #
-      # Search this fragment for +paths+. +paths+ must be one or more XPath or CSS queries.
-      #
-      # For more information see Nokogiri::XML::Searchable#search
-      def search *rules
-        rules, handler, ns, binds = extract_params(rules)
-
-        rules.inject(NodeSet.new(document)) do |set, rule|
-          set += if rule =~ Searchable::LOOKS_LIKE_XPATH
-                   xpath(*([rule, ns, handler, binds].compact))
-                 else
-                   children.css(*([rule, ns, handler].compact)) # 'children' is a smell here
-                 end
-        end
-      end
-
-      alias :serialize :to_s
-
-      class << self
-        ####
-        # Create a Nokogiri::XML::DocumentFragment from +tags+
-        def parse tags
-          self.new(XML::Document.new, tags)
-        end
-      end
-
-      # A list of Nokogiri::XML::SyntaxError found when parsing a document
-      def errors
-        document.errors
-      end
-
-      def errors= things # :nodoc:
-        document.errors = things
-      end
-
-      private
-
-      # fix for issue 770
-      def namespace_declarations ctx
-        ctx.namespace_scopes.map do |namespace|
-          prefix = namespace.prefix.nil? ? "" : ":#{namespace.prefix}"
-          %Q{xmlns#{prefix}="#{namespace.href}"}
-        end.join ' '
-      end
-
-      def coerce data
-        return super unless String === data
-
-        document.fragment(data).children
-      end
-    end
-  end
-end

data/vendor/bundle/gems/nokogiri-1.10.7/lib/nokogiri/xml/dtd.rb

@@ -1,32 +0,0 @@
-module Nokogiri
-  module XML
-    class DTD < Nokogiri::XML::Node
-      undef_method :attribute_nodes
-      undef_method :values
-      undef_method :content
-      undef_method :namespace
-      undef_method :namespace_definitions
-      undef_method :line if method_defined?(:line)
-
-      def keys
-        attributes.keys
-      end
-
-      def each
-        attributes.each do |key, value|
-          yield([key, value])
-        end
-      end
-
-      def html_dtd?
-        name.casecmp('html').zero?
-      end
-
-      def html5_dtd?
-        html_dtd? &&
-          external_id.nil? &&
-          (system_id.nil? || system_id == 'about:legacy-compat')
-      end
-    end
-  end
-end

data/vendor/bundle/gems/nokogiri-1.10.7/lib/nokogiri/xml/element_content.rb

@@ -1,36 +0,0 @@
-module Nokogiri
-  module XML
-    ###
-    # Represents the allowed content in an Element Declaration inside a DTD:
-    #
-    #   <?xml version="1.0"?><?TEST-STYLE PIDATA?>
-    #   <!DOCTYPE staff SYSTEM "staff.dtd" [
-    #      <!ELEMENT div1 (head, (p | list | note)*, div2*)>
-    #   ]>
-    #   </root>
-    #
-    # ElementContent represents the tree inside the <!ELEMENT> tag shown above
-    # that lists the possible content for the div1 tag.
-    class ElementContent
-      # Possible definitions of type
-      PCDATA  = 1
-      ELEMENT = 2
-      SEQ     = 3
-      OR      = 4
-
-      # Possible content occurrences
-      ONCE    = 1
-      OPT     = 2
-      MULT    = 3
-      PLUS    = 4
-
-      attr_reader :document
-
-      ###
-      # Get the children of this ElementContent node
-      def children
-        [c1, c2].compact
-      end
-    end
-  end
-end

data/vendor/bundle/gems/nokogiri-1.10.7/lib/nokogiri/xml/element_decl.rb

@@ -1,13 +0,0 @@
-module Nokogiri
-  module XML
-    class ElementDecl < Nokogiri::XML::Node
-      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/gems/nokogiri-1.10.7/lib/nokogiri/xml/entity_decl.rb

@@ -1,19 +0,0 @@
-module Nokogiri
-  module XML
-    class EntityDecl < Nokogiri::XML::Node
-      undef_method :attribute_nodes
-      undef_method :attributes
-      undef_method :namespace
-      undef_method :namespace_definitions
-      undef_method :line if method_defined?(:line)
-
-      def self.new name, doc, *args
-        doc.create_entity(name, *args)
-      end
-
-      def inspect
-        "#<#{self.class.name}:#{sprintf("0x%x", object_id)} #{to_s.inspect}>"
-      end
-    end
-  end
-end

data/vendor/bundle/gems/nokogiri-1.10.7/lib/nokogiri/xml/entity_reference.rb

@@ -1,18 +0,0 @@
-module Nokogiri
-  module XML
-    class EntityReference < Nokogiri::XML::Node
-      def children
-        # libxml2 will create a malformed child node for predefined
-        # entities. because any use of that child is likely to cause a
-        # segfault, we shall pretend that it doesn't exist.
-        #
-        # see https://github.com/sparklemotion/nokogiri/issues/1238 for details
-        NodeSet.new(document)
-      end
-
-      def inspect_attributes
-        [:name]
-      end
-    end
-  end
-end

data/vendor/bundle/gems/nokogiri-1.10.7/lib/nokogiri/xml/namespace.rb

@@ -1,13 +0,0 @@
-module Nokogiri
-  module XML
-    class Namespace
-      include Nokogiri::XML::PP::Node
-      attr_reader :document
-
-      private
-      def inspect_attributes
-        [:prefix, :href]
-      end
-    end
-  end
-end

data/vendor/bundle/gems/nokogiri-1.10.7/lib/nokogiri/xml/node/save_options.rb

@@ -1,61 +0,0 @@
-module Nokogiri
-  module XML
-    class Node
-      ###
-      # Save options for serializing nodes
-      class SaveOptions
-        # Format serialized xml
-        FORMAT          = 1
-        # Do not include declarations
-        NO_DECLARATION  = 2
-        # Do not include empty tags
-        NO_EMPTY_TAGS   = 4
-        # Do not save XHTML
-        NO_XHTML        = 8
-        # Save as XHTML
-        AS_XHTML        = 16
-        # Save as XML
-        AS_XML          = 32
-        # Save as HTML
-        AS_HTML         = 64
-
-        if Nokogiri.jruby?
-          # Save builder created document
-          AS_BUILDER    = 128
-          # the default for XML documents
-          DEFAULT_XML  = AS_XML # https://github.com/sparklemotion/nokogiri/issues/#issue/415
-          # the default for HTML document
-          DEFAULT_HTML = NO_DECLARATION | NO_EMPTY_TAGS | AS_HTML
-        else
-          # the default for XML documents
-          DEFAULT_XML  = FORMAT | AS_XML
-          # the default for HTML document
-          DEFAULT_HTML = FORMAT | NO_DECLARATION | NO_EMPTY_TAGS | AS_HTML
-        end
-        # the default for XHTML document
-        DEFAULT_XHTML = FORMAT | NO_DECLARATION | NO_EMPTY_TAGS | AS_XHTML
-
-        # Integer representation of the SaveOptions
-        attr_reader :options
-
-        # Create a new SaveOptions object with +options+
-        def initialize options = 0; @options = options; end
-
-        constants.each do |constant|
-          class_eval %{
-            def #{constant.downcase}
-              @options |= #{constant}
-              self
-            end
-
-            def #{constant.downcase}?
-              #{constant} & @options == #{constant}
-            end
-          }
-        end
-
-        alias :to_i :options
-      end
-    end
-  end
-end