multi_xml 0.5.5 → 0.6.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: add5ff8df4d736d143b1d83c38c5f1b8b35d21cd
+  data.tar.gz: ec8e8a3657ff340a9a4abefa2561e44dfee8371d
+SHA512:
+  metadata.gz: 1cb437e88276aa09e33c5b10a1e32bbf181ecae9543976ab13acc4ca458b00b1315a59f1e3e1cd95fd24e47559a85058585578ba16441ac83c98ffa81c5ee902
+  data.tar.gz: 1931768faabe059174c01e24d12f9b1c8bcc0c9717891ec9ba9098f55c98535ad2a0efab7dcc4bfd756a569f137bf86e4b45b652a182652e6a468393103de9f5

data/CONTRIBUTING.md

@@ -16,8 +16,10 @@ Here are some ways *you* can contribute:
 * by refactoring code
 * by resolving [issues][]
 * by reviewing patches
+* [financially][gittip]
 
 [issues]: https://github.com/sferik/multi_xml/issues
+[gittip]: https://www.gittip.com/sferik/
 
 ## Submitting an Issue
 We use the [GitHub issue tracker][issues] to track bugs and features. Before
@@ -35,12 +37,12 @@ Ideally, a bug report should include a pull request with failing specs.
 3. Add specs for your unimplemented feature or bug fix.
 4. Run `bundle exec rake spec`. If your specs pass, return to step 3.
 5. Implement your feature or bug fix.
-6. Run `bundle exec rake spec`. If your specs fail, return to step 5.
+6. Run `bundle exec rake`. If your specs fail, return to step 5.
 7. Run `open coverage/index.html`. If your changes are not completely covered
    by your tests, return to step 3.
 8. Add documentation for your feature or bug fix.
-9. Run `bundle exec rake doc:yard`. If your changes are not 100% documented, go
-   back to step 8.
+9. Run `bundle exec rake verify_measurements`. If your changes are not 100%
+   documented, go back to step 8.
 10. Add, commit, and push your changes.
 11. [Submit a pull request.][pr]
 

data/README.md

@@ -1,10 +1,10 @@
 # MultiXML
 
-[![Gem Version](https://badge.fury.io/rb/multi_xml.png)][gem]
-[![Build Status](https://secure.travis-ci.org/sferik/multi_xml.png?branch=master)][travis]
-[![Dependency Status](https://gemnasium.com/sferik/multi_xml.png?travis)][gemnasium]
-[![Code Climate](https://codeclimate.com/github/sferik/multi_xml.png)][codeclimate]
-[![Coverage Status](https://coveralls.io/repos/sferik/multi_xml/badge.png?branch=master)][coveralls]
+[![Gem Version](http://img.shields.io/gem/v/multi_xml.svg)][gem]
+[![Build Status](http://img.shields.io/travis/sferik/multi_xml.svg)][travis]
+[![Dependency Status](http://img.shields.io/gemnasium/sferik/multi_xml.svg)][gemnasium]
+[![Code Climate](http://img.shields.io/codeclimate/github/sferik/multi_xml.svg)][codeclimate]
+[![Coverage Status](http://img.shields.io/coveralls/sferik/multi_xml.svg)][coveralls]
 
 [gem]: https://rubygems.org/gems/multi_xml
 [travis]: http://travis-ci.org/sferik/multi_xml
@@ -17,16 +17,6 @@ A generic swappable back-end for XML parsing
 ## Installation
     gem install multi_xml
 
-To ensure the code you're installing hasn't been tampered with, it's
-recommended that you verify the signature. To do this, you need to add my
-public key as a trusted certificate (you only need to do this once):
-
-    gem cert --add <(curl -Ls https://raw.github.com/sferik/multi_xml/master/certs/sferik.pem)
-
-Then, install the gem with the high security trust policy:
-
-    gem install multi_xml -P HighSecurity
-
 ## Documentation
 [http://rdoc.info/gems/multi_xml][documentation]
 
@@ -55,6 +45,10 @@ MultiXml.parse('<tag>This is the contents</tag>') # Parsed using Nokogiri
 MultiXml.parser = :rexml
 MultiXml.parser = MultiXml::Parsers::Rexml # Same as above
 MultiXml.parse('<tag>This is the contents</tag>') # Parsed using REXML
+
+MultiXml.parser = :oga
+MultiXml.parser = MultiXml::Parsers::Oga # Same as above
+MultiXml.parse('<tag>This is the contents</tag>') # Parsed using Oga
 ```
 The `parser` setter takes either a symbol or a class (to allow for custom XML
 parsers) that responds to `.parse` at the class level.
@@ -68,10 +62,14 @@ then Nokogiri, and finally REXML.
 This library aims to support and is [tested against][travis] the following Ruby
 implementations:
 
-* Ruby 1.8.7
-* Ruby 1.9.2
 * Ruby 1.9.3
 * Ruby 2.0.0
+* Ruby 2.1
+* Ruby 2.2
+* Ruby 2.3
+* [JRuby 9000][jruby]
+
+[jruby]: http://jruby.org/
 
 If something doesn't work on one of these interpreters, it's a bug.
 

data/lib/multi_xml.rb

@@ -5,73 +5,78 @@ require 'stringio'
 require 'time'
 require 'yaml'
 
-module MultiXml
+module MultiXml # rubocop:disable ModuleLength
   class ParseError < StandardError; end
+  class NoParserError < StandardError; end
   class DisallowedTypeError < StandardError
     def initialize(type)
       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)
 
   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 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 RescueModifier
+      'base64Binary' => proc { |binary| ::Base64.decode64(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
-  }
+    :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,6 +88,7 @@ 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
@@ -92,6 +98,7 @@ module MultiXml
           next
         end
       end
+      raise(NoParserError.new("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 +108,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,12 +130,12 @@ 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={})
+    def parse(xml, options = {}) # rubocop:disable AbcSize, CyclomaticComplexity, MethodLength, 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)
 
@@ -140,7 +148,7 @@ module MultiXml
       rescue DisallowedTypeError
         raise
       rescue parser.parse_error => error
-        raise ParseError, error.message, error.backtrace
+        raise(ParseError, error.message, error.backtrace) # rubocop:disable RaiseArgs
       end
       hash = symbolize_keys(hash) if options[:symbolize_keys]
       hash
@@ -160,7 +168,7 @@ module MultiXml
       end
     end
 
-    private
+  private
 
     # TODO: Add support for other encodings
     def parse_binary(binary, entity) #:nodoc:
@@ -187,7 +195,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
@@ -197,23 +205,23 @@ module MultiXml
       case params
       when Hash
         params.inject({}) do |hash, (key, value)|
-          hash[key.to_s.tr('-', '_')] = undasherize_keys(value)
+          hash[key.to_s.tr('-'.freeze, '_'.freeze)] = 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 AbcSize, CyclomaticComplexity, MethodLength, 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']
+          raise(DisallowedTypeError.new(value['type']))
         end
 
         if value['type'] == 'array'
@@ -227,27 +235,29 @@ 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']]
               if value.keys.size > 1
@@ -283,14 +293,13 @@ module MultiXml
           xml_value['file'].is_a?(StringIO) ? xml_value['file'] : xml_value
         end
       when Array
-        value.map!{|i| typecast_xml_value(i, disallowed_types)}
+        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

data/lib/multi_xml/parsers/libxml.rb

@@ -5,15 +5,18 @@ module MultiXml
   module Parsers
     module Libxml #:nodoc:
       include Libxml2Parser
-
       extend self
 
-      def parse_error() ::LibXML::XML::Error end
+      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

data/lib/multi_xml/parsers/libxml2_parser.rb

@@ -8,16 +8,19 @@ module MultiXml
       #
       # hash::
       #   Hash to merge the converted element into.
-      def node_to_hash(node, hash={})
+      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 then hash[name] << node_hash
-          when Hash  then hash[name] = [hash[name], node_hash]
-          when nil   then hash[name] = node_hash
+        when Array
+          hash[name] << node_hash
+        when Hash
+          hash[name] = [hash[name], node_hash]
+        when NilClass
+          hash[name] = node_hash
         end
 
         # Handle child elements
@@ -37,12 +40,8 @@ module MultiXml
         # Handle attributes
         each_attr(node) do |a|
           key = node_name(a)
-
-          node_hash[key] = if v = node_hash[key]
-                             [a.value, v]
-                           else
-                             a.value
-                           end
+          v = node_hash[key]
+          node_hash[key] = (v ? [a.value, v] : a.value)
         end
 
         hash
@@ -51,23 +50,22 @@ module MultiXml
       # Parse an XML Document IO into a simple hash.
       # xml::
       #   XML Document IO to parse
-      def parse(xml)
-        raise NotImplementedError, "inheritor should define #{__method__}"
+      def parse(_)
+        raise(NotImplementedError.new("inheritor should define #{__method__}"))
       end
 
-      # :stopdoc:
-      private
+    private
 
-      def each_child(*args)
-        raise NotImplementedError, "inheritor should define #{__method__}"
+      def each_child(*)
+        raise(NotImplementedError.new("inheritor should define #{__method__}"))
       end
 
-      def each_attr(*args)
-        raise NotImplementedError, "inheritor should define #{__method__}"
+      def each_attr(*)
+        raise(NotImplementedError.new("inheritor should define #{__method__}"))
       end
 
-      def node_name(*args)
-        raise NotImplementedError, "inheritor should define #{__method__}"
+      def node_name(*)
+        raise(NotImplementedError.new("inheritor should define #{__method__}"))
       end
     end
   end