cli-nasa 0.1.0

data/vendor/bundle/ruby/2.7.0/gems/multi_xml-0.6.0/lib/multi_xml/parsers/libxml.rb

@@ -0,0 +1,33 @@
+require 'libxml' unless defined?(LibXML)
+require 'multi_xml/parsers/libxml2_parser'
+
+module MultiXml
+  module Parsers
+    module Libxml #:nodoc:
+      include Libxml2Parser
+      extend self
+
+      def parse_error
+        ::LibXML::XML::Error
+      end
+
+      def parse(xml)
+        node_to_hash(LibXML::XML::Parser.io(xml).parse.root)
+      end
+
+    private
+
+      def each_child(node, &block)
+        node.each_child(&block)
+      end
+
+      def each_attr(node, &block)
+        node.each_attr(&block)
+      end
+
+      def node_name(node)
+        node.name
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/multi_xml-0.6.0/lib/multi_xml/parsers/libxml2_parser.rb

@@ -0,0 +1,72 @@
+module MultiXml
+  module Parsers
+    module Libxml2Parser #:nodoc:
+      # Convert XML document to hash
+      #
+      # node::
+      #   The XML node object to convert to a hash.
+      #
+      # hash::
+      #   Hash to merge the converted element into.
+      def node_to_hash(node, hash = {}) # rubocop:disable AbcSize, CyclomaticComplexity, MethodLength, PerceivedComplexity
+        node_hash = {MultiXml::CONTENT_ROOT => ''}
+
+        name = node_name(node)
+
+        # Insert node hash into parent hash correctly.
+        case hash[name]
+        when Array
+          hash[name] << node_hash
+        when Hash
+          hash[name] = [hash[name], node_hash]
+        when NilClass
+          hash[name] = node_hash
+        end
+
+        # Handle child elements
+        each_child(node) do |c|
+          if c.element?
+            node_to_hash(c, node_hash)
+          elsif c.text? || c.cdata?
+            node_hash[MultiXml::CONTENT_ROOT] << c.content
+          end
+        end
+
+        # Remove content node if it is empty
+        if node_hash[MultiXml::CONTENT_ROOT].strip.empty?
+          node_hash.delete(MultiXml::CONTENT_ROOT)
+        end
+
+        # Handle attributes
+        each_attr(node) do |a|
+          key = node_name(a)
+          v = node_hash[key]
+          node_hash[key] = (v ? [a.value, v] : a.value)
+        end
+
+        hash
+      end
+
+      # Parse an XML Document IO into a simple hash.
+      # xml::
+      #   XML Document IO to parse
+      def parse(_)
+        raise(NotImplementedError.new("inheritor should define #{__method__}"))
+      end
+
+    private
+
+      def each_child(*)
+        raise(NotImplementedError.new("inheritor should define #{__method__}"))
+      end
+
+      def each_attr(*)
+        raise(NotImplementedError.new("inheritor should define #{__method__}"))
+      end
+
+      def node_name(*)
+        raise(NotImplementedError.new("inheritor should define #{__method__}"))
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/multi_xml-0.6.0/lib/multi_xml/parsers/nokogiri.rb

@@ -0,0 +1,35 @@
+require 'nokogiri' unless defined?(Nokogiri)
+require 'multi_xml/parsers/libxml2_parser'
+
+module MultiXml
+  module Parsers
+    module Nokogiri #:nodoc:
+      include Libxml2Parser
+      extend self
+
+      def parse_error
+        ::Nokogiri::XML::SyntaxError
+      end
+
+      def parse(xml)
+        doc = ::Nokogiri::XML(xml)
+        raise(doc.errors.first) unless doc.errors.empty?
+        node_to_hash(doc.root)
+      end
+
+    private
+
+      def each_child(node, &block)
+        node.children.each(&block)
+      end
+
+      def each_attr(node, &block)
+        node.attribute_nodes.each(&block)
+      end
+
+      def node_name(node)
+        node.node_name
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/multi_xml-0.6.0/lib/multi_xml/parsers/oga.rb

@@ -0,0 +1,73 @@
+require 'oga' unless defined?(Oga)
+require 'multi_xml/parsers/libxml2_parser'
+
+module MultiXml
+  module Parsers
+    module Oga #:nodoc:
+      include Libxml2Parser
+      extend self
+
+      def parse_error
+        LL::ParserError
+      end
+
+      def parse(io)
+        document = ::Oga.parse_xml(io)
+        node_to_hash(document.children[0])
+      end
+
+      def node_to_hash(node, hash = {}) # rubocop:disable AbcSize, CyclomaticComplexity, MethodLength, PerceivedComplexity
+        node_hash = {MultiXml::CONTENT_ROOT => ''}
+
+        name = node_name(node)
+
+        # Insert node hash into parent hash correctly.
+        case hash[name]
+        when Array
+          hash[name] << node_hash
+        when Hash
+          hash[name] = [hash[name], node_hash]
+        when NilClass
+          hash[name] = node_hash
+        end
+
+        # Handle child elements
+        each_child(node) do |c|
+          if c.is_a?(::Oga::XML::Element)
+            node_to_hash(c, node_hash)
+          elsif c.is_a?(::Oga::XML::Text) || c.is_a?(::Oga::XML::Cdata)
+            node_hash[MultiXml::CONTENT_ROOT] << c.text
+          end
+        end
+
+        # Remove content node if it is empty
+        if node_hash[MultiXml::CONTENT_ROOT].strip.empty?
+          node_hash.delete(MultiXml::CONTENT_ROOT)
+        end
+
+        # Handle attributes
+        each_attr(node) do |a|
+          key = node_name(a)
+          v = node_hash[key]
+          node_hash[key] = (v ? [a.value, v] : a.value)
+        end
+
+        hash
+      end
+
+    private
+
+      def each_child(node, &block)
+        node.children.each(&block)
+      end
+
+      def each_attr(node, &block)
+        node.attributes.each(&block)
+      end
+
+      def node_name(node)
+        node.name
+      end
+    end # Oga
+  end # Parsers
+end # MultiXml

data/vendor/bundle/ruby/2.7.0/gems/multi_xml-0.6.0/lib/multi_xml/parsers/ox.rb

@@ -0,0 +1,91 @@
+require 'ox' unless defined?(Ox)
+
+# Each MultiXml parser is expected to parse an XML document into a Hash. The
+# conversion rules are:
+#
+# - Each document starts out as an empty Hash.
+#
+# - Reading an element created an entry in the parent Hash that has a key of
+#   the element name and a value of a Hash with attributes as key value
+#   pairs. Children are added as described by this rule.
+#
+# - Text and CDATE is stored in the parent element Hash with a key of
+#   MultiXml::CONTENT_ROOT and a value of the text itself.
+#
+# - If a key already exists in the Hash then the value associated with the key
+#   is converted to an Array with the old and new value in it.
+#
+# - Other elements such as the xml prolog, doctype, and comments are ignored.
+#
+
+module MultiXml
+  module Parsers
+    module Ox #:nodoc:
+      extend self
+
+      def parse_error
+        Exception
+      end
+
+      def parse(io)
+        handler = Handler.new
+        ::Ox.sax_parse(handler, io, :convert_special => true)
+        handler.doc
+      end
+
+      class Handler
+        attr_accessor :stack
+
+        def initialize
+          @stack = []
+        end
+
+        def doc
+          @stack[0]
+        end
+
+        def attr(name, value)
+          append(name, value) unless @stack.empty?
+        end
+
+        def text(value)
+          append(MultiXml::CONTENT_ROOT, value)
+        end
+
+        def cdata(value)
+          append(MultiXml::CONTENT_ROOT, value)
+        end
+
+        def start_element(name)
+          @stack.push({}) if @stack.empty?
+          h = {}
+          append(name, h)
+          @stack.push(h)
+        end
+
+        def end_element(_)
+          @stack.pop
+        end
+
+        def error(message, line, column)
+          raise(Exception.new("#{message} at #{line}:#{column}"))
+        end
+
+        def append(key, value)
+          key = key.to_s
+          h = @stack.last
+          if h.key?(key)
+            v = h[key]
+            if v.is_a?(Array)
+              v << value
+            else
+              h[key] = [v, value]
+            end
+          else
+            h[key] = value
+          end
+        end
+      end # Handler
+    end # Ox
+  end # Parsers
+end # MultiXml

data/vendor/bundle/ruby/2.7.0/gems/multi_xml-0.6.0/lib/multi_xml/parsers/rexml.rb

@@ -0,0 +1,113 @@
+require 'rexml/document' unless defined?(REXML::Document)
+
+module MultiXml
+  module Parsers
+    module Rexml #:nodoc:
+      extend self
+
+      def parse_error
+        ::REXML::ParseException
+      end
+
+      # Parse an XML Document IO into a simple hash using REXML
+      #
+      # xml::
+      #   XML Document IO to parse
+      def parse(xml)
+        doc = REXML::Document.new(xml)
+        raise(REXML::ParseException.new("The document #{doc.to_s.inspect} does not have a valid root")) unless doc.root
+        merge_element!({}, doc.root)
+      end
+
+    private
+
+      # Convert an XML element and merge into the hash
+      #
+      # hash::
+      #   Hash to merge the converted element into.
+      # element::
+      #   XML element to merge into hash
+      def merge_element!(hash, element)
+        merge!(hash, element.name, collapse(element))
+      end
+
+      # Actually converts an XML document element into a data structure.
+      #
+      # element::
+      #   The document element to be collapsed.
+      def collapse(element)
+        hash = get_attributes(element)
+
+        if element.has_elements?
+          element.each_element { |child| merge_element!(hash, child) }
+          merge_texts!(hash, element) unless empty_content?(element)
+          hash
+        else
+          merge_texts!(hash, element)
+        end
+      end
+
+      # Merge all the texts of an element into the hash
+      #
+      # hash::
+      #   Hash to add the converted element to.
+      # element::
+      #   XML element whose texts are to me merged into the hash
+      def merge_texts!(hash, element)
+        if element.has_text?
+          # must use value to prevent double-escaping
+          texts = ''
+          element.texts.each { |t| texts << t.value }
+          merge!(hash, MultiXml::CONTENT_ROOT, texts)
+        else
+          hash
+        end
+      end
+
+      # Adds a new key/value pair to an existing Hash. If the key to be added
+      # already exists and the existing value associated with key is not
+      # an Array, it will be wrapped in an Array. Then the new value is
+      # appended to that Array.
+      #
+      # hash::
+      #   Hash to add key/value pair to.
+      # key::
+      #   Key to be added.
+      # value::
+      #   Value to be associated with key.
+      def merge!(hash, key, value)
+        if hash.key?(key)
+          if hash[key].instance_of?(Array)
+            hash[key] << value
+          else
+            hash[key] = [hash[key], value]
+          end
+        elsif value.instance_of?(Array)
+          hash[key] = [value]
+        else
+          hash[key] = value
+        end
+        hash
+      end
+
+      # Converts the attributes array of an XML element into a hash.
+      # Returns an empty Hash if node has no attributes.
+      #
+      # element::
+      #   XML element to extract attributes from.
+      def get_attributes(element)
+        attributes = {}
+        element.attributes.each { |n, v| attributes[n] = v }
+        attributes
+      end
+
+      # Determines if a document element has text content
+      #
+      # element::
+      #   XML element to be checked.
+      def empty_content?(element)
+        element.texts.join.strip.empty?
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/multi_xml-0.6.0/lib/multi_xml/version.rb

@@ -0,0 +1,45 @@
+module MultiXml
+  module Version
+  module_function
+
+    # @return [Integer]
+    def major
+      0
+    end
+
+    # @return [Integer]
+    def minor
+      6
+    end
+
+    # @return [Integer]
+    def patch
+      0
+    end
+
+    # @return [Integer, NilClass]
+    def pre
+      nil
+    end
+
+    # @return [Hash]
+    def to_h
+      {
+        :major => major,
+        :minor => minor,
+        :patch => patch,
+        :pre => pre,
+      }
+    end
+
+    # @return [Array]
+    def to_a
+      [major, minor, patch, pre].compact
+    end
+
+    # @return [String]
+    def to_s
+      to_a.join('.')
+    end
+  end
+end