husc 0.1.0

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

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

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

@@ -0,0 +1,60 @@
+module Nokogiri
+  module XML
+    module SAX
+      ###
+      # PushParser can parse a document that is fed to it manually.  It
+      # must be given a SAX::Document object which will be called with
+      # SAX events as the document is being parsed.
+      #
+      # Calling PushParser#<< writes XML to the parser, calling any SAX
+      # callbacks it can.
+      #
+      # PushParser#finish tells the parser that the document is finished
+      # and calls the end_document SAX method.
+      #
+      # Example:
+      #
+      #   parser = PushParser.new(Class.new(XML::SAX::Document) {
+      #     def start_document
+      #       puts "start document called"
+      #     end
+      #   }.new)
+      #   parser << "<div>hello<"
+      #   parser << "/div>"
+      #   parser.finish
+      class PushParser
+
+        # The Nokogiri::XML::SAX::Document on which the PushParser will be
+        # operating
+        attr_accessor :document
+
+        ###
+        # Create a new PushParser with +doc+ as the SAX Document, providing
+        # an optional +file_name+ and +encoding+
+        def initialize(doc = XML::SAX::Document.new, file_name = nil, encoding = 'UTF-8')
+          @document = doc
+          @encoding = encoding
+          @sax_parser = XML::SAX::Parser.new(doc)
+
+          ## Create our push parser context
+          initialize_native(@sax_parser, file_name)
+        end
+
+        ###
+        # Write a +chunk+ of XML 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::XML::SAX::Document#end_document to be called.
+        def finish
+          write '', true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+module Nokogiri
+  module XML
+    class << self
+      ###
+      # Create a new Nokogiri::XML::Schema object using a +string_or_io+
+      # object.
+      def Schema string_or_io
+        Schema.new(string_or_io)
+      end
+    end
+
+    ###
+    # Nokogiri::XML::Schema is used for validating XML against a schema
+    # (usually from an xsd file).
+    #
+    # == Synopsis
+    #
+    # Validate an XML document against a Schema.  Loop over the errors that
+    # are returned and print them out:
+    #
+    #   xsd = Nokogiri::XML::Schema(File.read(PO_SCHEMA_FILE))
+    #   doc = Nokogiri::XML(File.read(PO_XML_FILE))
+    #
+    #   xsd.validate(doc).each do |error|
+    #     puts error.message
+    #   end
+    #
+    # The list of errors are Nokogiri::XML::SyntaxError objects.
+    class Schema
+      # Errors while parsing the schema file
+      attr_accessor :errors
+
+      ###
+      # Create a new Nokogiri::XML::Schema object using a +string_or_io+
+      # object.
+      def self.new string_or_io
+        from_document Nokogiri::XML(string_or_io)
+      end
+
+      ###
+      # Validate +thing+ against this schema.  +thing+ can be a
+      # Nokogiri::XML::Document object, or a filename.  An Array of
+      # Nokogiri::XML::SyntaxError objects found while validating the
+      # +thing+ is returned.
+      def validate thing
+        if thing.is_a?(Nokogiri::XML::Document) 
+          validate_document(thing) 
+        elsif File.file?(thing)
+          validate_file(thing)
+        else
+          raise ArgumentError, "Must provide Nokogiri::Xml::Document or the name of an existing file"
+        end
+      end
+
+      ###
+      # Returns true if +thing+ is a valid Nokogiri::XML::Document or
+      # file.
+      def valid? thing
+        validate(thing).length == 0
+      end
+    end
+  end
+end

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

@@ -0,0 +1,230 @@
+module Nokogiri
+  module XML
+    #
+    #  The Searchable module declares the interface used for searching your DOM.
+    #
+    #  It implements the public methods `search`, `css`, and `xpath`,
+    #  as well as allowing specific implementations to specialize some
+    #  of the important behaviors.
+    #
+    module Searchable
+      # Regular expression used by Searchable#search to determine if a query
+      # string is CSS or XPath
+      LOOKS_LIKE_XPATH = /^(\.\/|\/|\.\.|\.$)/
+      
+      ###
+      # call-seq: search *paths, [namespace-bindings, xpath-variable-bindings, custom-handler-class]
+      #
+      # Search this object for +paths+. +paths+ must be one or more XPath or CSS queries:
+      #
+      #   node.search("div.employee", ".//title")
+      #
+      # A hash of namespace bindings may be appended:
+      #
+      #   node.search('.//bike:tire', {'bike' => 'http://schwinn.com/'})
+      #   node.search('bike|tire', {'bike' => 'http://schwinn.com/'})
+      #
+      # For XPath queries, a hash of variable bindings may also be
+      # appended to the namespace bindings. For example:
+      #
+      #   node.search('.//address[@domestic=$value]', nil, {:value => 'Yes'})
+      #
+      # Custom XPath functions and CSS pseudo-selectors may also be
+      # defined. To define custom functions create a class and
+      # implement the function you want to define.  The first argument
+      # to the method will be the current matching NodeSet.  Any other
+      # arguments are ones that you pass in.  Note that this class may
+      # appear anywhere in the argument list.  For example:
+      #
+      #   node.search('.//title[regex(., "\w+")]', 'div.employee:regex("[0-9]+")'
+      #     Class.new {
+      #       def regex node_set, regex
+      #         node_set.find_all { |node| node['some_attribute'] =~ /#{regex}/ }
+      #       end
+      #     }.new
+      #   )
+      #
+      # See Searchable#xpath and Searchable#css for further usage help.
+      def search *args
+        paths, handler, ns, binds = extract_params(args)
+
+        xpaths = paths.map(&:to_s).map do |path|
+          (path =~ LOOKS_LIKE_XPATH) ? path : xpath_query_from_css_rule(path, ns)
+        end.flatten.uniq
+
+        xpath(*(xpaths + [ns, handler, binds].compact))
+      end
+      alias :/ :search
+
+      ###
+      # call-seq: search *paths, [namespace-bindings, xpath-variable-bindings, custom-handler-class]
+      #
+      # Search this object for +paths+, and return only the first
+      # result. +paths+ must be one or more XPath or CSS queries.
+      #
+      # See Searchable#search for more information.
+      def at *args
+        search(*args).first
+      end
+      alias :% :at
+
+      ###
+      # call-seq: css *rules, [namespace-bindings, custom-pseudo-class]
+      #
+      # Search this object for CSS +rules+. +rules+ must be one or more CSS
+      # selectors. For example:
+      #
+      #   node.css('title')
+      #   node.css('body h1.bold')
+      #   node.css('div + p.green', 'div#one')
+      #
+      # A hash of namespace bindings may be appended. For example:
+      #
+      #   node.css('bike|tire', {'bike' => 'http://schwinn.com/'})
+      #
+      # Custom CSS pseudo classes may also be defined.  To define
+      # custom pseudo classes, create a class and implement the custom
+      # pseudo class you want defined.  The first argument to the
+      # method will be the current matching NodeSet.  Any other
+      # arguments are ones that you pass in.  For example:
+      #
+      #   node.css('title:regex("\w+")', Class.new {
+      #     def regex node_set, regex
+      #       node_set.find_all { |node| node['some_attribute'] =~ /#{regex}/ }
+      #     end
+      #   }.new)
+      #
+      # Note that the CSS query string is case-sensitive with regards
+      # to your document type. That is, if you're looking for "H1" in
+      # an HTML document, you'll never find anything, since HTML tags
+      # will match only lowercase CSS queries. However, "H1" might be
+      # found in an XML document, where tags names are case-sensitive
+      # (e.g., "H1" is distinct from "h1").
+      #
+      def css *args
+        rules, handler, ns, _ = extract_params(args)
+
+        css_internal self, rules, handler, ns
+      end
+
+      ##
+      # call-seq: css *rules, [namespace-bindings, custom-pseudo-class]
+      #
+      # Search this object for CSS +rules+, and return only the first
+      # match. +rules+ must be one or more CSS selectors.
+      #
+      # See Searchable#css for more information.
+      def at_css *args
+        css(*args).first
+      end
+
+      ###
+      # call-seq: xpath *paths, [namespace-bindings, variable-bindings, custom-handler-class]
+      #
+      # Search this node for XPath +paths+. +paths+ must be one or more XPath
+      # queries.
+      #
+      #   node.xpath('.//title')
+      #
+      # A hash of namespace bindings may be appended. For example:
+      #
+      #   node.xpath('.//foo:name', {'foo' => 'http://example.org/'})
+      #   node.xpath('.//xmlns:name', node.root.namespaces)
+      #
+      # A hash of variable bindings may also be appended to the namespace bindings. For example:
+      #
+      #   node.xpath('.//address[@domestic=$value]', nil, {:value => 'Yes'})
+      #
+      # Custom XPath functions may also be defined.  To define custom
+      # functions create a class and implement the function you want
+      # to define.  The first argument to the method will be the
+      # current matching NodeSet.  Any other arguments are ones that
+      # you pass in.  Note that this class may appear anywhere in the
+      # argument list.  For example:
+      #
+      #   node.xpath('.//title[regex(., "\w+")]', Class.new {
+      #     def regex node_set, regex
+      #       node_set.find_all { |node| node['some_attribute'] =~ /#{regex}/ }
+      #     end
+      #   }.new)
+      #
+      def xpath *args
+        paths, handler, ns, binds = extract_params(args)
+
+        xpath_internal self, paths, handler, ns, binds
+      end
+
+      ##
+      # call-seq: xpath *paths, [namespace-bindings, variable-bindings, custom-handler-class]
+      #
+      # Search this node for XPath +paths+, and return only the first
+      # match. +paths+ must be one or more XPath queries.
+      #
+      # See Searchable#xpath for more information.
+      def at_xpath *args
+        xpath(*args).first
+      end
+
+      private
+
+      def css_internal node, rules, handler, ns
+        xpath_internal node, css_rules_to_xpath(rules, ns), handler, ns, nil
+      end
+
+      def xpath_internal node, paths, handler, ns, binds
+        document = node.document
+        return NodeSet.new(document) unless document
+
+        if paths.length == 1
+          return xpath_impl(node, paths.first, handler, ns, binds)
+        end
+
+        NodeSet.new(document) do |combined|
+          paths.each do |path|
+            xpath_impl(node, path, handler, ns, binds).each { |set| combined << set }
+          end
+        end
+      end
+
+      def xpath_impl node, path, handler, ns, binds
+        ctx = XPathContext.new(node)
+        ctx.register_namespaces(ns)
+        path = path.gsub(/xmlns:/, ' :') unless Nokogiri.uses_libxml?
+
+        binds.each do |key,value|
+          ctx.register_variable key.to_s, value
+        end if binds
+
+        ctx.evaluate(path, handler)
+      end
+
+      def css_rules_to_xpath(rules, ns)
+        rules.map { |rule| xpath_query_from_css_rule(rule, ns) }
+      end
+
+      def xpath_query_from_css_rule rule, ns
+        self.class::IMPLIED_XPATH_CONTEXTS.map do |implied_xpath_context|
+          CSS.xpath_for(rule.to_s, :prefix => implied_xpath_context, :ns => ns)
+        end.join(' | ')
+      end
+
+      def extract_params params # :nodoc:
+        handler = params.find do |param|
+          ![Hash, String, Symbol].include?(param.class)
+        end
+        params -= [handler] if handler
+
+        hashes = []
+        while Hash === params.last || params.last.nil?
+          hashes << params.pop
+          break if params.empty?
+        end
+        ns, binds = hashes.reverse
+
+        ns ||= document.root ? document.root.namespaces : {}
+
+        [params, handler, ns, binds]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+module Nokogiri
+  module XML
+    ###
+    # This class provides information about XML SyntaxErrors.  These
+    # exceptions are typically stored on Nokogiri::XML::Document#errors.
+    class SyntaxError < ::Nokogiri::SyntaxError
+      attr_reader :domain
+      attr_reader :code
+      attr_reader :level
+      attr_reader :file
+      attr_reader :line
+      attr_reader :str1
+      attr_reader :str2
+      attr_reader :str3
+      attr_reader :int1
+      attr_reader :column
+
+      ###
+      # return true if this is a non error
+      def none?
+        level == 0
+      end
+
+      ###
+      # return true if this is a warning
+      def warning?
+        level == 1
+      end
+
+      ###
+      # return true if this is an error
+      def error?
+        level == 2
+      end
+
+      ###
+      # return true if this error is fatal
+      def fatal?
+        level == 3
+      end
+
+      def to_s
+        message = super.chomp
+        [location_to_s, level_to_s, message].
+          compact.join(": ").
+          force_encoding(message.encoding)
+      end
+
+      private
+
+      def level_to_s
+        case level
+        when 3 then "FATAL"
+        when 2 then "ERROR"
+        when 1 then "WARNING"
+        else nil
+        end
+      end
+
+      def nil_or_zero?(attribute)
+        attribute.nil? || attribute.zero?
+      end
+
+      def location_to_s
+        return nil if nil_or_zero?(line) && nil_or_zero?(column)
+        "#{line}:#{column}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Nokogiri
+  module XML
+    class Text < Nokogiri::XML::CharacterData
+      def content=(string)
+        self.native_content = string.to_s
+      end
+    end
+  end
+end