multi_xml 0.5.5 → 0.7.0

data/lib/multi_xml/parsers/rexml.rb

@@ -1,10 +1,13 @@
-require 'rexml/document' unless defined?(REXML::Document)
+require "rexml/document" unless defined?(REXML::Document)
 
 module MultiXml
   module Parsers
-    module Rexml #:nodoc:
+    module Rexml # :nodoc:
       extend self
-      def parse_error; ::REXML::ParseException; end
+
+      def parse_error
+        ::REXML::ParseException
+      end
 
       # Parse an XML Document IO into a simple hash using REXML
       #
@@ -12,11 +15,9 @@ module MultiXml
       #   XML Document IO to parse
       def parse(xml)
         doc = REXML::Document.new(xml)
-        if doc.root
-          merge_element!({}, doc.root)
-        else
-          raise REXML::ParseException, "The document #{doc.to_s.inspect} does not have a valid root"
-        end
+        raise(REXML::ParseException, "The document #{doc.to_s.inspect} does not have a valid root") unless doc.root
+
+        merge_element!({}, doc.root)
       end
 
       private
@@ -39,7 +40,7 @@ module MultiXml
         hash = get_attributes(element)
 
         if element.has_elements?
-          element.each_element {|child| merge_element!(hash, child) }
+          element.each_element { |child| merge_element!(hash, child) }
           merge_texts!(hash, element) unless empty_content?(element)
           hash
         else
@@ -54,13 +55,12 @@ module MultiXml
       # element::
       #   XML element whose texts are to me merged into the hash
       def merge_texts!(hash, element)
-        unless element.has_text?
-          hash
-        else
+        if element.has_text?
           # must use value to prevent double-escaping
-          texts = ''
-          element.texts.each { |t| texts << t.value }
+          texts = element.texts.map(&:value).join
           merge!(hash, MultiXml::CONTENT_ROOT, texts)
+        else
+          hash
         end
       end
 
@@ -76,7 +76,7 @@ module MultiXml
       # value::
       #   Value to be associated with key.
       def merge!(hash, key, value)
-        if hash.has_key?(key)
+        if hash.key?(key)
           if hash[key].instance_of?(Array)
             hash[key] << value
           else
@@ -97,7 +97,7 @@ module MultiXml
       #   XML element to extract attributes from.
       def get_attributes(element)
         attributes = {}
-        element.attributes.each { |n,v| attributes[n] = v }
+        element.attributes.each { |n, v| attributes[n] = v }
         attributes
       end
 

data/lib/multi_xml/version.rb

@@ -1,3 +1,3 @@
 module MultiXml
-  VERSION = "0.5.5" unless defined?(MultiXML::VERSION)
+  VERSION = Gem::Version.create("0.7.0")
 end

data/lib/multi_xml.rb

@@ -1,77 +1,84 @@
-require 'base64'
-require 'bigdecimal'
-require 'date'
-require 'stringio'
-require 'time'
-require 'yaml'
-
-module MultiXml
+require "bigdecimal"
+require "date"
+require "stringio"
+require "time"
+require "yaml"
+
+module MultiXml # rubocop:disable Metrics/ModuleLength
   class ParseError < StandardError; end
+
+  class NoParserError < StandardError; end
+
   class DisallowedTypeError < StandardError
     def initialize(type)
-      super "Disallowed type attribute: #{type.inspect}"
+      super("Disallowed type attribute: #{type.inspect}")
     end
   end
 
-  REQUIREMENT_MAP = [
-    ['ox', :ox],
-    ['libxml', :libxml],
-    ['nokogiri', :nokogiri],
-    ['rexml/document', :rexml]
-  ] unless defined?(REQUIREMENT_MAP)
+  unless defined?(REQUIREMENT_MAP)
+    REQUIREMENT_MAP = [
+      ["ox", :ox],
+      ["libxml", :libxml],
+      ["nokogiri", :nokogiri],
+      ["rexml/document", :rexml],
+      ["oga", :oga]
+    ].freeze
+  end
 
-  CONTENT_ROOT = '__content__'.freeze unless defined?(CONTENT_ROOT)
+  CONTENT_ROOT = "__content__".freeze unless defined?(CONTENT_ROOT)
 
   unless defined?(PARSING)
+    float_proc = proc { |float| float.to_f }
+    datetime_proc = proc { |time| Time.parse(time).utc rescue DateTime.parse(time).utc } # rubocop:disable Style/RescueModifier
+
     PARSING = {
-      'symbol'       => Proc.new{|symbol| symbol.to_sym},
-      'date'         => Proc.new{|date| Date.parse(date)},
-      'datetime'     => Proc.new{|time| Time.parse(time).utc rescue DateTime.parse(time).utc},
-      'integer'      => Proc.new{|integer| integer.to_i},
-      'float'        => Proc.new{|float| float.to_f},
-      'decimal'      => Proc.new{|number| BigDecimal(number)},
-      'boolean'      => Proc.new{|boolean| !%w(0 false).include?(boolean.strip)},
-      'string'       => Proc.new{|string| string.to_s},
-      'yaml'         => Proc.new{|yaml| YAML::load(yaml) rescue yaml},
-      'base64Binary' => Proc.new{|binary| ::Base64.decode64(binary)},
-      'binary'       => Proc.new{|binary, entity| parse_binary(binary, entity)},
-      'file'         => Proc.new{|file, entity| parse_file(file, entity)},
-    }
-
-    PARSING.update(
-      'double'   => PARSING['float'],
-      'dateTime' => PARSING['datetime']
-    )
+      "symbol" => proc { |symbol| symbol.to_sym },
+      "date" => proc { |date| Date.parse(date) },
+      "datetime" => datetime_proc,
+      "dateTime" => datetime_proc,
+      "integer" => proc { |integer| integer.to_i },
+      "float" => float_proc,
+      "double" => float_proc,
+      "decimal" => proc { |number| BigDecimal(number) },
+      "boolean" => proc { |boolean| !%w[0 false].include?(boolean.strip) },
+      "string" => proc { |string| string.to_s },
+      "yaml" => proc { |yaml| YAML.load(yaml) rescue yaml }, # rubocop:disable Style/RescueModifier
+      "base64Binary" => proc { |binary| base64_decode(binary) },
+      "binary" => proc { |binary, entity| parse_binary(binary, entity) },
+      "file" => proc { |file, entity| parse_file(file, entity) }
+    }.freeze
+  end
+
+  unless defined?(TYPE_NAMES)
+    TYPE_NAMES = {
+      "Symbol" => "symbol",
+      "Integer" => "integer",
+      "BigDecimal" => "decimal",
+      "Float" => "float",
+      "TrueClass" => "boolean",
+      "FalseClass" => "boolean",
+      "Date" => "date",
+      "DateTime" => "datetime",
+      "Time" => "datetime",
+      "Array" => "array",
+      "Hash" => "hash"
+    }.freeze
   end
 
-  TYPE_NAMES = {
-    'Symbol'     => 'symbol',
-    'Fixnum'     => 'integer',
-    'Bignum'     => 'integer',
-    'BigDecimal' => 'decimal',
-    'Float'      => 'float',
-    'TrueClass'  => 'boolean',
-    'FalseClass' => 'boolean',
-    'Date'       => 'date',
-    'DateTime'   => 'datetime',
-    'Time'       => 'datetime',
-    'Array'      => 'array',
-    'Hash'       => 'hash'
-  } unless defined?(TYPE_NAMES)
-
-  DISALLOWED_XML_TYPES = %w(symbol yaml)
+  DISALLOWED_XML_TYPES = %w[symbol yaml].freeze
 
   DEFAULT_OPTIONS = {
-    :typecast_xml_value => true,
-    :disallowed_types => DISALLOWED_XML_TYPES,
-    :symbolize_keys => false
-  }
+    typecast_xml_value: true,
+    disallowed_types: DISALLOWED_XML_TYPES,
+    symbolize_keys: false
+  }.freeze
 
   class << self
     # Get the current parser class.
     def parser
       return @parser if defined?(@parser)
-      self.parser = self.default_parser
+
+      self.parser = default_parser
       @parser
     end
 
@@ -83,15 +90,16 @@ module MultiXml
       return :ox if defined?(::Ox)
       return :libxml if defined?(::LibXML)
       return :nokogiri if defined?(::Nokogiri)
+      return :oga if defined?(::Oga)
 
       REQUIREMENT_MAP.each do |library, parser|
-        begin
-          require library
-          return parser
-        rescue LoadError
-          next
-        end
+        require library
+        return parser
+      rescue LoadError
+        next
       end
+      raise(NoParserError,
+        "No XML parser detected. If you're using Rubinius and Bundler, try adding an XML parser to your Gemfile (e.g. libxml-ruby, nokogiri, or rubysl-rexml). For more information, see https://github.com/sferik/multi_xml/issues/42.")
     end
 
     # Set the XML parser utilizing a symbol, string, or class.
@@ -101,15 +109,16 @@ module MultiXml
     # * <tt>:nokogiri</tt>
     # * <tt>:ox</tt>
     # * <tt>:rexml</tt>
+    # * <tt>:oga</tt>
     def parser=(new_parser)
       case new_parser
       when String, Symbol
         require "multi_xml/parsers/#{new_parser.to_s.downcase}"
-        @parser = MultiXml::Parsers.const_get("#{new_parser.to_s.split('_').map{|s| s.capitalize}.join('')}")
+        @parser = MultiXml::Parsers.const_get(new_parser.to_s.split("_").collect(&:capitalize).join.to_s)
       when Class, Module
         @parser = new_parser
       else
-        raise "Did not recognize your parser specification. Please specify either a symbol or a class."
+        raise("Did not recognize your parser specification. Please specify either a symbol or a class.")
       end
     end
 
@@ -122,25 +131,26 @@ module MultiXml
     # <tt>:disallowed_types</tt> :: Types to disallow from being typecasted. Defaults to `['yaml', 'symbol']`. Use `[]` to allow all types.
     #
     # <tt>:typecast_xml_value</tt> :: If true, won't typecast values for parsed document
-    def parse(xml, options={})
-      xml ||= ''
+    def parse(xml, options = {}) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      xml ||= ""
 
       options = DEFAULT_OPTIONS.merge(options)
 
-      xml.strip! if xml.respond_to?(:strip!)
+      xml = xml.strip if xml.respond_to?(:strip)
       begin
         xml = StringIO.new(xml) unless xml.respond_to?(:read)
 
         char = xml.getc
         return {} if char.nil?
+
         xml.ungetc(char)
 
         hash = undasherize_keys(parser.parse(xml) || {})
-        hash = options[:typecast_xml_value] ? typecast_xml_value(hash, options[:disallowed_types]) : hash
+        hash = typecast_xml_value(hash, options[:disallowed_types]) if options[:typecast_xml_value]
       rescue DisallowedTypeError
         raise
-      rescue parser.parse_error => error
-        raise ParseError, error.message, error.backtrace
+      rescue parser.parse_error => e
+        raise(ParseError, e.message, e.backtrace)
       end
       hash = symbolize_keys(hash) if options[:symbolize_keys]
       hash
@@ -148,38 +158,42 @@ module MultiXml
 
     # This module decorates files with the <tt>original_filename</tt>
     # and <tt>content_type</tt> methods.
-    module FileLike #:nodoc:
+    module FileLike # :nodoc:
       attr_writer :original_filename, :content_type
 
       def original_filename
-        @original_filename || 'untitled'
+        @original_filename || "untitled"
       end
 
       def content_type
-        @content_type || 'application/octet-stream'
+        @content_type || "application/octet-stream"
       end
     end
 
     private
 
     # TODO: Add support for other encodings
-    def parse_binary(binary, entity) #:nodoc:
-      case entity['encoding']
-      when 'base64'
-        Base64.decode64(binary)
+    def parse_binary(binary, entity) # :nodoc:
+      case entity["encoding"]
+      when "base64"
+        base64_decode(binary)
       else
         binary
       end
     end
 
     def parse_file(file, entity)
-      f = StringIO.new(Base64.decode64(file))
+      f = StringIO.new(base64_decode(file))
       f.extend(FileLike)
-      f.original_filename = entity['name']
-      f.content_type = entity['content_type']
+      f.original_filename = entity["name"]
+      f.content_type = entity["content_type"]
       f
     end
 
+    def base64_decode(input)
+      input.unpack1("m")
+    end
+
     def symbolize_keys(params)
       case params
       when Hash
@@ -187,7 +201,7 @@ module MultiXml
           result.merge(key.to_sym => symbolize_keys(value))
         end
       when Array
-        params.map{|value| symbolize_keys(value)}
+        params.collect { |value| symbolize_keys(value) }
       else
         params
       end
@@ -196,27 +210,27 @@ module MultiXml
     def undasherize_keys(params)
       case params
       when Hash
-        params.inject({}) do |hash, (key, value)|
-          hash[key.to_s.tr('-', '_')] = undasherize_keys(value)
+        params.each_with_object({}) do |(key, value), hash|
+          hash[key.to_s.tr("-", "_")] = undasherize_keys(value)
           hash
         end
       when Array
-        params.map{|value| undasherize_keys(value)}
+        params.collect { |value| undasherize_keys(value) }
       else
         params
       end
     end
 
-    def typecast_xml_value(value, disallowed_types=nil)
+    def typecast_xml_value(value, disallowed_types = nil) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
       disallowed_types ||= DISALLOWED_XML_TYPES
 
       case value
       when Hash
-        if value.include?('type') && !value['type'].is_a?(Hash) && disallowed_types.include?(value['type'])
-          raise DisallowedTypeError, value['type']
+        if value.include?("type") && !value["type"].is_a?(Hash) && disallowed_types.include?(value["type"])
+          raise(DisallowedTypeError, value["type"])
         end
 
-        if value['type'] == 'array'
+        if value["type"] == "array"
 
           # this commented-out suggestion helps to avoid the multiple attribute
           # problem, but it breaks when there is only one item in the array.
@@ -227,29 +241,31 @@ module MultiXml
 
           # This attempt fails to consider the order that the detect method
           # retrieves the entries.
-          #_, entries = value.detect {|key, _| key != 'type'}
+          # _, entries = value.detect {|key, _| key != 'type'}
 
           # This approach ignores attribute entries that are not convertable
           # to an Array which allows attributes to be ignored.
-          _, entries = value.detect {|k, v| k != 'type' && (v.is_a?(Array) || v.is_a?(Hash)) }
+          _, entries = value.detect { |k, v| k != "type" && (v.is_a?(Array) || v.is_a?(Hash)) }
 
-          if entries.nil? || (entries.is_a?(String) && entries.strip.empty?)
+          case entries
+          when NilClass
             []
+          when String
+            [] if entries.strip.empty?
+          when Array
+            entries.collect { |entry| typecast_xml_value(entry, disallowed_types) }
+          when Hash
+            [typecast_xml_value(entries, disallowed_types)]
           else
-            case entries
-            when Array
-              entries.map {|entry| typecast_xml_value(entry, disallowed_types)}
-            when Hash
-              [typecast_xml_value(entries, disallowed_types)]
-            else
-              raise "can't typecast #{entries.class.name}: #{entries.inspect}"
-            end
+            raise("can't typecast #{entries.class.name}: #{entries.inspect}")
           end
-        elsif value.has_key?(CONTENT_ROOT)
+
+        elsif value.key?(CONTENT_ROOT)
           content = value[CONTENT_ROOT]
-          if block = PARSING[value['type']]
+          block = PARSING[value["type"]]
+          if block
             if block.arity == 1
-              value.delete('type') if PARSING[value['type']]
+              value.delete("type") if PARSING[value["type"]]
               if value.keys.size > 1
                 value[CONTENT_ROOT] = block.call(content)
                 value
@@ -260,37 +276,36 @@ module MultiXml
               block.call(content, value)
             end
           else
-            value.keys.size > 1 ? value : content
+            (value.keys.size > 1) ? value : content
           end
-        elsif value['type'] == 'string' && value['nil'] != 'true'
-          ''
+        elsif value["type"] == "string" && value["nil"] != "true"
+          ""
         # blank or nil parsed values are represented by nil
-        elsif value.empty? || value['nil'] == 'true'
+        elsif value.empty? || value["nil"] == "true"
           nil
         # If the type is the only element which makes it then
         # this still makes the value nil, except if type is
         # a XML node(where type['value'] is a Hash)
-        elsif value['type'] && value.size == 1 && !value['type'].is_a?(Hash)
+        elsif value["type"] && value.size == 1 && !value["type"].is_a?(Hash)
           nil
         else
-          xml_value = value.inject({}) do |hash, (k, v)|
+          xml_value = value.each_with_object({}) do |(k, v), hash|
             hash[k] = typecast_xml_value(v, disallowed_types)
             hash
           end
 
           # Turn {:files => {:file => #<StringIO>} into {:files => #<StringIO>} so it is compatible with
           # how multipart uploaded files from HTML appear
-          xml_value['file'].is_a?(StringIO) ? xml_value['file'] : xml_value
+          (xml_value["file"].is_a?(StringIO)) ? xml_value["file"] : xml_value
         end
       when Array
-        value.map!{|i| typecast_xml_value(i, disallowed_types)}
-        value.length > 1 ? value : value.first
+        value.map! { |i| typecast_xml_value(i, disallowed_types) }
+        (value.length > 1) ? value : value.first
       when String
         value
       else
-        raise "can't typecast #{value.class.name}: #{value.inspect}"
+        raise("can't typecast #{value.class.name}: #{value.inspect}")
       end
     end
   end
-
 end

metadata

@@ -1,111 +1,79 @@
 --- !ruby/object:Gem::Specification
 name: multi_xml
 version: !ruby/object:Gem::Version
-  version: 0.5.5
-  prerelease: 
+  version: 0.7.0
 platform: ruby
 authors:
-- Erik Michaels-Ober
-autorequire: 
-bindir: bin
-cert_chain:
-- !binary |-
-  LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSURMakNDQWhhZ0F3SUJB
-  Z0lCQURBTkJna3Foa2lHOXcwQkFRVUZBREE5TVE4d0RRWURWUVFEREFaelpt
-  VnkKYVdzeEZUQVRCZ29Ka2lhSmsvSXNaQUVaRmdWbmJXRnBiREVUTUJFR0Nn
-  bVNKb21UOGl4a0FSa1dBMk52YlRBZQpGdzB4TXpBeU1ETXhNREF5TWpkYUZ3
-  MHhOREF5TURNeE1EQXlNamRhTUQweER6QU5CZ05WQkFNTUJuTm1aWEpwCmF6
-  RVZNQk1HQ2dtU0pvbVQ4aXhrQVJrV0JXZHRZV2xzTVJNd0VRWUtDWkltaVpQ
-  eUxHUUJHUllEWTI5dE1JSUIKSWpBTkJna3Foa2lHOXcwQkFRRUZBQU9DQVE4
-  QU1JSUJDZ0tDQVFFQWwweDVkeDh1S3hpN1Rrckl1eUJVVEpWQgp2MW85M25V
-  QjlqL3k0TTk2Z1Yycll3QWNpMUpQQnNlTmQ2RnliempvM1lHdUhsN0VRSHVT
-  SE5hZjFwMmx4ZXcvCnk2MEpYSUpCQmdQY0RLL0tDUDROVUhvZm0wamZvWUQr
-  SDV1TkpmSENOcTcvWnNUeE90RTNSYTkyczBCQ01UcG0Kd0JNTWxXUjVNdGRF
-  aElZdUJPNFhobmVqWWdIMEwvN0JMMmx5bW50Vm5zci9hZ2RRb29qUUNOMUlR
-  bXNSSnZyUgpkdVpSTzN0WnZvSW8xcEJjNEpFZWhEdXFDZXlCZ1BMT3FNb0t0
-  UWxvbGQxVFFzMWtXVUJLN0tXTUZFaEtDL0tnCnp5ektSSFFvOXlEWXdPdllu
-  Z29CTFkrVC9sd0NUNGR5c3NkaHpSYmZueEFoYUt1NFNBc3NJd2FDMDF5Vm93
-  SUQKQVFBQm96a3dOekFKQmdOVkhSTUVBakFBTUIwR0ExVWREZ1FXQkJTMHJ1
-  RGZSYWs1Y2kxT3BETlgvWmRERWtJcwppVEFMQmdOVkhROEVCQU1DQkxBd0RR
-  WUpLb1pJaHZjTkFRRUZCUUFEZ2dFQkFISFNNcy9NUDBzT2FMa0V2NEpvCnp2
-  a20zcW41QTZ0MHZhSHg3NzRjbWVqeU1VKzV3eVN4UmV6c3BMN1VMaDlOZXVL
-  Mk9oVStPZTNUcHFyQWc1VEsKUjhHUUlMblZ1MkZlbUdBNnNBa1BEbGNQdGdB
-  NmllSTE5UFpPRjZIVkxtYy9JRC9kUC9OZ1pXV3pFZXFRS21jSwoyK0hNK1NF
-  RURoWmtTY1lla3c0Wk9lMTY0WnRaRzgxNm9BdjV4MHBHaXRTSWt1bVVwN1Y4
-  aUVaLzZlaHI3WTllClhPZzRlZXVuNUwvSmptakFSb1cya05kdmtSRDNjMkVl
-  U0xxV3ZRUnNCbHlwSGZoczZKSnVMbHlaUEdoVTNSL3YKU2YzbFZLcEJDV2dS
-  cEdUdnk0NVhWcEIrNTl5MzNQSm1FdVExUFRFT1l2UXlhbzlVS01BQWFBTi83
-  cVdRdGpsMApobHc9Ci0tLS0tRU5EIENFUlRJRklDQVRFLS0tLS0K
-date: 2013-08-06 00:00:00.000000000 Z
+- Erik Berlin
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-04-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: bigdecimal
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :development
+        version: '3.1'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
-description: Provides swappable XML backends utilizing LibXML, Nokogiri, Ox, or REXML.
-email: sferik@gmail.com
+        version: '3.1'
+description:
+email:
+- sferik@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .yardopts
+- ".rspec"
+- ".rubocop.yml"
+- ".yardopts"
 - CHANGELOG.md
 - CONTRIBUTING.md
+- Gemfile
 - LICENSE.md
 - README.md
 - Rakefile
-- multi_xml.gemspec
+- lib/multi_xml.rb
 - lib/multi_xml/parsers/libxml.rb
 - lib/multi_xml/parsers/libxml2_parser.rb
 - lib/multi_xml/parsers/nokogiri.rb
+- lib/multi_xml/parsers/oga.rb
 - lib/multi_xml/parsers/ox.rb
 - lib/multi_xml/parsers/rexml.rb
 - lib/multi_xml/version.rb
-- lib/multi_xml.rb
-- spec/helper.rb
-- spec/multi_xml_spec.rb
-- spec/parser_shared_example.rb
-- spec/speed.rb
 homepage: https://github.com/sferik/multi_xml
 licenses:
 - MIT
-post_install_message: 
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/sferik/multi_xml
+  source_code_uri: https://github.com/sferik/multi_xml
+  changelog_uri: https://github.com/sferik/multi_xml/blob/master/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 3.1.4
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.5
+      version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 1.8.23
-signing_key: 
-specification_version: 3
-summary: A generic swappable back-end for XML parsing
-test_files:
-- spec/helper.rb
-- spec/multi_xml_spec.rb
-- spec/parser_shared_example.rb
-- spec/speed.rb
-has_rdoc: 
+rubygems_version: 3.5.9
+signing_key:
+specification_version: 4
+summary: Provides swappable XML backends utilizing LibXML, Nokogiri, Ox, or REXML.
+test_files: []

data/multi_xml.gemspec

@@ -1,24 +0,0 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'multi_xml/version'
-
-Gem::Specification.new do |spec|
-  spec.add_development_dependency 'bundler', '~> 1.0'
-  spec.author = "Erik Michaels-Ober"
-  spec.cert_chain = ['certs/sferik.pem']
-  spec.description = %q{Provides swappable XML backends utilizing LibXML, Nokogiri, Ox, or REXML.}
-  spec.email = 'sferik@gmail.com'
-  spec.files = %w(.yardopts CHANGELOG.md CONTRIBUTING.md LICENSE.md README.md Rakefile multi_xml.gemspec)
-  spec.files += Dir.glob("lib/**/*.rb")
-  spec.files += Dir.glob("spec/**/*")
-  spec.homepage = 'https://github.com/sferik/multi_xml'
-  spec.licenses = ['MIT']
-  spec.name = 'multi_xml'
-  spec.require_paths = ['lib']
-  spec.required_rubygems_version = '>= 1.3.5'
-  spec.signing_key = File.expand_path("~/.gem/private_key.pem") if $0 =~ /gem\z/
-  spec.summary = %q{A generic swappable back-end for XML parsing}
-  spec.test_files = Dir.glob("spec/**/*")
-  spec.version = MultiXml::VERSION
-end