omg-activesupport 8.0.0.alpha1

data/lib/active_support/xml_mini/jdom.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+raise "JRuby is required to use the JDOM backend for XmlMini" unless RUBY_PLATFORM.include?("java")
+
+require "jruby"
+include Java
+
+require "active_support/core_ext/object/blank"
+
+java_import javax.xml.parsers.DocumentBuilder unless defined? DocumentBuilder
+java_import javax.xml.parsers.DocumentBuilderFactory unless defined? DocumentBuilderFactory
+java_import java.io.StringReader unless defined? StringReader
+java_import org.xml.sax.InputSource unless defined? InputSource
+java_import org.xml.sax.Attributes unless defined? Attributes
+java_import org.w3c.dom.Node unless defined? Node
+
+module ActiveSupport
+  module XmlMini_JDOM # :nodoc:
+    extend self
+
+    CONTENT_KEY = "__content__"
+
+    # Parse an XML Document string or IO into a simple hash using Java's jdom.
+    # data::
+    #   XML Document string or IO to parse
+    def parse(data)
+      if data.respond_to?(:read)
+        data = data.read
+      end
+
+      if data.blank?
+        {}
+      else
+        @dbf = DocumentBuilderFactory.new_instance
+        # secure processing of java xml
+        # https://archive.is/9xcQQ
+        @dbf.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false)
+        @dbf.setFeature("http://xml.org/sax/features/external-general-entities", false)
+        @dbf.setFeature("http://xml.org/sax/features/external-parameter-entities", false)
+        @dbf.setFeature(javax.xml.XMLConstants::FEATURE_SECURE_PROCESSING, true)
+        xml_string_reader = StringReader.new(data)
+        xml_input_source = InputSource.new(xml_string_reader)
+        doc = @dbf.new_document_builder.parse(xml_input_source)
+        merge_element!({ CONTENT_KEY => "" }, doc.document_element, XmlMini.depth)
+      end
+    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, depth)
+        raise "Document too deep!" if depth == 0
+        delete_empty(hash)
+        merge!(hash, element.tag_name, collapse(element, depth))
+      end
+
+      def delete_empty(hash)
+        hash.delete(CONTENT_KEY) if hash[CONTENT_KEY] == ""
+      end
+
+      # Actually converts an XML document element into a data structure.
+      #
+      # element::
+      #   The document element to be collapsed.
+      def collapse(element, depth)
+        hash = get_attributes(element)
+
+        child_nodes = element.child_nodes
+        if child_nodes.length > 0
+          (0...child_nodes.length).each do |i|
+            child = child_nodes.item(i)
+            merge_element!(hash, child, depth - 1) unless child.node_type == Node::TEXT_NODE
+          end
+          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)
+        delete_empty(hash)
+        text_children = texts(element)
+        if text_children.join.empty?
+          hash
+        else
+          # must use value to prevent double-escaping
+          merge!(hash, CONTENT_KEY, text_children.join)
+        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.has_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)
+        attribute_hash = {}
+        attributes = element.attributes
+        (0...attributes.length).each do |i|
+          attribute_hash[CONTENT_KEY] ||= ""
+          attribute_hash[attributes.item(i).name] = attributes.item(i).value
+        end
+        attribute_hash
+      end
+
+      # Determines if a document element has text content
+      #
+      # element::
+      #   XML element to be checked.
+      def texts(element)
+        texts = []
+        child_nodes = element.child_nodes
+        (0...child_nodes.length).each do |i|
+          item = child_nodes.item(i)
+          if item.node_type == Node::TEXT_NODE
+            texts << item.get_data
+          end
+        end
+        texts
+      end
+
+      # Determines if a document element has text content
+      #
+      # element::
+      #   XML element to be checked.
+      def empty_content?(element)
+        text = +""
+        child_nodes = element.child_nodes
+        (0...child_nodes.length).each do |i|
+          item = child_nodes.item(i)
+          if item.node_type == Node::TEXT_NODE
+            text << item.get_data.strip
+          end
+        end
+        text.strip.length == 0
+      end
+  end
+end

data/lib/active_support/xml_mini/libxml.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "libxml"
+require "active_support/core_ext/object/blank"
+require "stringio"
+
+module ActiveSupport
+  module XmlMini_LibXML # :nodoc:
+    extend self
+
+    # Parse an XML Document string or IO into a simple hash using libxml.
+    # data::
+    #   XML Document string or IO to parse
+    def parse(data)
+      if !data.respond_to?(:read)
+        data = StringIO.new(data || "")
+      end
+
+      if data.eof?
+        {}
+      else
+        LibXML::XML::Parser.io(data).parse.to_hash
+      end
+    end
+  end
+end
+
+module LibXML # :nodoc:
+  module Conversions # :nodoc:
+    module Document # :nodoc:
+      def to_hash
+        root.to_hash
+      end
+    end
+
+    module Node # :nodoc:
+      CONTENT_ROOT = "__content__"
+
+      # Convert XML document to hash.
+      #
+      # hash::
+      #   Hash to merge the converted element into.
+      def to_hash(hash = {})
+        node_hash = {}
+
+        # Insert node hash into parent hash correctly.
+        case hash[name]
+        when Array then hash[name] << node_hash
+        when Hash  then hash[name] = [hash[name], node_hash]
+        when nil   then hash[name] = node_hash
+        end
+
+        # Handle child elements
+        each_child do |c|
+          if c.element?
+            c.to_hash(node_hash)
+          elsif c.text? || c.cdata?
+            node_hash[CONTENT_ROOT] ||= +""
+            node_hash[CONTENT_ROOT] << c.content
+          end
+        end
+
+        # Remove content node if it is blank
+        if node_hash.length > 1 && node_hash[CONTENT_ROOT].blank?
+          node_hash.delete(CONTENT_ROOT)
+        end
+
+        # Handle attributes
+        each_attr { |a| node_hash[a.name] = a.value }
+
+        hash
+      end
+    end
+  end
+end
+
+# :enddoc:
+
+LibXML::XML::Document.include(LibXML::Conversions::Document)
+LibXML::XML::Node.include(LibXML::Conversions::Node)

data/lib/active_support/xml_mini/libxmlsax.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "libxml"
+require "active_support/core_ext/object/blank"
+require "stringio"
+
+module ActiveSupport
+  module XmlMini_LibXMLSAX # :nodoc:
+    extend self
+
+    # Class that will build the hash while the XML document
+    # is being parsed using SAX events.
+    class HashBuilder
+      include LibXML::XML::SaxParser::Callbacks
+
+      CONTENT_KEY   = "__content__"
+      HASH_SIZE_KEY = "__hash_size__"
+
+      attr_reader :hash
+
+      def current_hash
+        @hash_stack.last
+      end
+
+      def on_start_document
+        @hash = { CONTENT_KEY => +"" }
+        @hash_stack = [@hash]
+      end
+
+      def on_end_document
+        @hash = @hash_stack.pop
+        @hash.delete(CONTENT_KEY)
+      end
+
+      def on_start_element(name, attrs = {})
+        new_hash = { CONTENT_KEY => +"" }.merge!(attrs)
+        new_hash[HASH_SIZE_KEY] = new_hash.size + 1
+
+        case current_hash[name]
+        when Array then current_hash[name] << new_hash
+        when Hash  then current_hash[name] = [current_hash[name], new_hash]
+        when nil   then current_hash[name] = new_hash
+        end
+
+        @hash_stack.push(new_hash)
+      end
+
+      def on_end_element(name)
+        if current_hash.length > current_hash.delete(HASH_SIZE_KEY) && current_hash[CONTENT_KEY].blank? || current_hash[CONTENT_KEY] == ""
+          current_hash.delete(CONTENT_KEY)
+        end
+        @hash_stack.pop
+      end
+
+      def on_characters(string)
+        current_hash[CONTENT_KEY] << string
+      end
+
+      alias_method :on_cdata_block, :on_characters
+    end
+
+    attr_accessor :document_class
+    self.document_class = HashBuilder
+
+    def parse(data)
+      if !data.respond_to?(:read)
+        data = StringIO.new(data || "")
+      end
+
+      if data.eof?
+        {}
+      else
+        LibXML::XML::Error.set_handler(&LibXML::XML::Error::QUIET_HANDLER)
+        parser = LibXML::XML::SaxParser.io(data)
+        document = document_class.new
+
+        parser.callbacks = document
+        parser.parse
+        document.hash
+      end
+    end
+  end
+end

data/lib/active_support/xml_mini/nokogiri.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+begin
+  require "nokogiri"
+rescue LoadError => e
+  warn "You don't have nokogiri installed in your application. Please add it to your Gemfile and run bundle install"
+  raise e
+end
+require "active_support/core_ext/object/blank"
+require "stringio"
+
+module ActiveSupport
+  module XmlMini_Nokogiri # :nodoc:
+    extend self
+
+    # Parse an XML Document string or IO into a simple hash using libxml / nokogiri.
+    # data::
+    #   XML Document string or IO to parse
+    def parse(data)
+      if !data.respond_to?(:read)
+        data = StringIO.new(data || "")
+      end
+
+      if data.eof?
+        {}
+      else
+        doc = Nokogiri::XML(data)
+        raise doc.errors.first if doc.errors.length > 0
+        doc.to_hash
+      end
+    end
+
+    module Conversions # :nodoc:
+      module Document # :nodoc:
+        def to_hash
+          root.to_hash
+        end
+      end
+
+      module Node # :nodoc:
+        CONTENT_ROOT = "__content__"
+
+        # Convert XML document to hash.
+        #
+        # hash::
+        #   Hash to merge the converted element into.
+        def to_hash(hash = {})
+          node_hash = {}
+
+          # Insert node hash into parent hash correctly.
+          case hash[name]
+          when Array then hash[name] << node_hash
+          when Hash  then hash[name] = [hash[name], node_hash]
+          when nil   then hash[name] = node_hash
+          end
+
+          # Handle child elements
+          children.each do |c|
+            if c.element?
+              c.to_hash(node_hash)
+            elsif c.text? || c.cdata?
+              node_hash[CONTENT_ROOT] ||= +""
+              node_hash[CONTENT_ROOT] << c.content
+            end
+          end
+
+          # Remove content node if it is blank and there are child tags
+          if node_hash.length > 1 && node_hash[CONTENT_ROOT].blank?
+            node_hash.delete(CONTENT_ROOT)
+          end
+
+          # Handle attributes
+          attribute_nodes.each { |a| node_hash[a.node_name] = a.value }
+
+          hash
+        end
+      end
+    end
+
+    Nokogiri::XML::Document.include(Conversions::Document)
+    Nokogiri::XML::Node.include(Conversions::Node)
+  end
+end

data/lib/active_support/xml_mini/nokogirisax.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+begin
+  require "nokogiri"
+rescue LoadError => e
+  warn "You don't have nokogiri installed in your application. Please add it to your Gemfile and run bundle install"
+  raise e
+end
+require "active_support/core_ext/object/blank"
+require "stringio"
+
+module ActiveSupport
+  module XmlMini_NokogiriSAX # :nodoc:
+    extend self
+
+    # Class that will build the hash while the XML document
+    # is being parsed using SAX events.
+    class HashBuilder < Nokogiri::XML::SAX::Document
+      CONTENT_KEY   = "__content__"
+      HASH_SIZE_KEY = "__hash_size__"
+
+      attr_reader :hash
+
+      def current_hash
+        @hash_stack.last
+      end
+
+      def start_document
+        @hash = {}
+        @hash_stack = [@hash]
+      end
+
+      def end_document
+        raise "Parse stack not empty!" if @hash_stack.size > 1
+      end
+
+      def error(error_message)
+        raise error_message
+      end
+
+      def start_element(name, attrs = [])
+        new_hash = { CONTENT_KEY => +"" }.merge!(Hash[attrs])
+        new_hash[HASH_SIZE_KEY] = new_hash.size + 1
+
+        case current_hash[name]
+        when Array then current_hash[name] << new_hash
+        when Hash  then current_hash[name] = [current_hash[name], new_hash]
+        when nil   then current_hash[name] = new_hash
+        end
+
+        @hash_stack.push(new_hash)
+      end
+
+      def end_element(name)
+        if current_hash.length > current_hash.delete(HASH_SIZE_KEY) && current_hash[CONTENT_KEY].blank? || current_hash[CONTENT_KEY] == ""
+          current_hash.delete(CONTENT_KEY)
+        end
+        @hash_stack.pop
+      end
+
+      def characters(string)
+        current_hash[CONTENT_KEY] << string
+      end
+
+      alias_method :cdata_block, :characters
+    end
+
+    attr_accessor :document_class
+    self.document_class = HashBuilder
+
+    def parse(data)
+      if !data.respond_to?(:read)
+        data = StringIO.new(data || "")
+      end
+
+      if data.eof?
+        {}
+      else
+        document = document_class.new
+        parser = Nokogiri::XML::SAX::Parser.new(document)
+        parser.parse(data)
+        document.hash
+      end
+    end
+  end
+end

data/lib/active_support/xml_mini/rexml.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/kernel/reporting"
+require "active_support/core_ext/object/blank"
+require "stringio"
+
+module ActiveSupport
+  module XmlMini_REXML # :nodoc:
+    extend self
+
+    CONTENT_KEY = "__content__"
+
+    # Parse an XML Document string or IO into a simple hash.
+    #
+    # Same as XmlSimple::xml_in but doesn't shoot itself in the foot,
+    # and uses the defaults from Active Support.
+    #
+    # data::
+    #   XML Document string or IO to parse
+    def parse(data)
+      if !data.respond_to?(:read)
+        data = StringIO.new(data || "")
+      end
+
+      if data.eof?
+        {}
+      else
+        require_rexml unless defined?(REXML::Document)
+        doc = REXML::Document.new(data)
+
+        if doc.root
+          merge_element!({}, doc.root, XmlMini.depth)
+        else
+          raise REXML::ParseException,
+            "The document #{doc.to_s.inspect} does not have a valid root"
+        end
+      end
+    end
+
+    private
+      def require_rexml
+        silence_warnings { require "rexml/document" }
+      rescue LoadError => e
+        warn "You don't have rexml installed in your application. Please add it to your Gemfile and run bundle install"
+        raise e
+      end
+
+      # 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, depth)
+        raise REXML::ParseException, "The document is too deep" if depth == 0
+        merge!(hash, element.name, collapse(element, depth))
+      end
+
+      # Actually converts an XML document element into a data structure.
+      #
+      # element::
+      #   The document element to be collapsed.
+      def collapse(element, depth)
+        hash = get_attributes(element)
+
+        if element.has_elements?
+          element.each_element { |child| merge_element!(hash, child, depth - 1) }
+          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)
+        unless element.has_text?
+          hash
+        else
+          # must use value to prevent double-escaping
+          texts = +""
+          element.texts.each { |t| texts << t.value }
+          merge!(hash, CONTENT_KEY, texts)
+        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.has_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.blank?
+      end
+  end
+end