xml-object 0.9.93 → 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0c18066558a35627d1903eff9a58c61e133429c0
+  data.tar.gz: 52e89eaf04ae675b033091bafe97fba86847aaaa
+SHA512:
+  metadata.gz: 7f9c6fe37eea43a4f073f7db584c29617334607f6b20b1fc1e2e18814a11e70a4f63ead949a9e227ecd58055d381affde99d0bd4776f1081bf94e9896ac72535
+  data.tar.gz: 3de060a2a3537d4008d518ba25ad6d4f178d4bb144f9e6c5b011cc5d9b217bbf719e66fde17bc22aa3aba797cd6622470388931a8c9679d216341c888d2324a5

data/README.rdoc

@@ -12,17 +12,7 @@ speedups. See more below.
 
 == Compatibility
 
-I've tested this release under:
-
-  Rubinius: 1.0.1 (REXML only, libxml-ruby might work if you can build it)
-  MRI:      1.9.2, 1.8.7, 1.8.6
-  REE:      1.8.7
-  JRuby:    1.5.2, 1.4.0 (both in 1.8.7 mode)
-
-And with the following optionals:
-
-  version 1.1.4 of libxml-ruby   (for faster execution)
-  version 2.3.8 of activesupport (for inflected plurals)
+See https://travis-ci.org/notlaforge/xml-object/
 
 == Installation instructions
 
@@ -180,4 +170,4 @@ The LibXML adapter will not return the 'xmlns' attribute.
 
 == Legal
 
-Copyright (c) 2008, 2009 Jordi Bunster, released under the MIT license
+Copyright (c) Jordi Bunster, released under the MIT license

data/WHATSNEW

@@ -1,4 +1,12 @@
-* 0.9.93 (?):
+* 1.0.0 (2016-04-07):
+  - Verified safe after http://blog.rubygems.org/2016/04/06/gem-replacement-vulnerability-and-mitigation.html
+  - Dropped ruby 1.8 (and JRuby in 1.8 mode)
+  - Moved tests to https://travis-ci.org/notlaforge/xml-object/
+  - Activesupport now required, but we only load the inflector
+    and none of the core extensions, so it won't infect your
+    code.
+
+* 0.9.93 (2010-08-26):
   - Rubinius support (tested with REXML only)
   - 1.9.2 support
 

data/lib/xml-object.rb

@@ -6,63 +6,63 @@ require 'xml-object/collection_proxy'
 require 'xml-object/element'
 
 module XMLObject
-  # Returns a String or Array object representing the given XML, decorated
-  # with methods to access attributes and/or child elements.
-  def self.new(duck) # :nodoc:
-    case duck
-      when @adapter::Element then new_decorated_obj duck
-      when Array             then duck.map! { |d| new_decorated_obj d }
-      else new @adapter.new(duck)
-    end
-  end
+	# Returns a String or Array object representing the given XML, decorated
+	# with methods to access attributes and/or child elements.
+	def self.new(duck) # :nodoc:
+		case duck
+			when @adapter::Element then new_decorated_obj duck
+			when Array             then duck.map! { |d| new_decorated_obj d }
+			else new @adapter.new(duck)
+		end
+	end
 
-  private ##################################################################
+	private ##################################################################
 
-  # Takes any adapter Element object, and converts it recursively into
-  # the corresponding tree of decorated objects.
-  def self.new_decorated_obj(xml) # :nodoc:
-    # More than one child, empty value, and all children with the same name?
-    obj = if xml.children.size > 1 && xml.value !~ /\S/ &&
+	# Takes any adapter Element object, and converts it recursively into
+	# the corresponding tree of decorated objects.
+	def self.new_decorated_obj(xml) # :nodoc:
+		# More than one child, empty value, and all children with the same name?
+		obj = if xml.children.size > 1 && xml.value !~ /\S/ &&
              xml.children.map { |c| c.name }.uniq.size == 1
 
-      CollectionProxy.new xml # This is an empty array wrap
-    else
-      Element.new xml # This one is an actual element
-    end
+			CollectionProxy.new xml # This is an empty array wrap
+		else
+			Element.new xml # This one is an actual element
+		end
 
-    xml.children.each   { |child| add_child obj, child.name, new(child) }
-    xml.attributes.each { |name, value|  add_attribute obj, name, value }
+		xml.children.each   { |child| add_child obj, child.name, new(child) }
+		xml.attributes.each { |name, value|  add_attribute obj, name, value }
 
-    # Let's teach our object how to access its XML elements and attributes
-    obj.extend Properties
-  end
+		# Let's teach our object how to access its XML elements and attributes
+		obj.extend Properties
+	end
 
-  # Decorates the given object 'obj' with a method 'name' that returns the
-  # given 'element'. If 'name' is already taken, takes care of the array
-  # folding behaviour.
-  def self.add_child(obj, name, element) # :nodoc:
-    key      = name.to_sym
-    children = obj.instance_variable_get :@__children
+	# Decorates the given object 'obj' with a method 'name' that returns the
+	# given 'element'. If 'name' is already taken, takes care of the array
+	# folding behaviour.
+	def self.add_child(obj, name, element) # :nodoc:
+		key      = name.to_sym
+		children = obj.instance_variable_get :@__children
 
-    children[key] = if children[key]
+		children[key] = if children[key]
 
-      children[key] = [ children[key] ] unless children[key].is_a? Array
-      children[key] << element
-    else
-      element
-    end
+			children[key] = [ children[key] ] unless children[key].is_a? Array
+			children[key] << element
+		else
+			element
+		end
 
-    obj.instance_variable_set :@__children, children
-    element
-  end
+		obj.instance_variable_set :@__children, children
+		element
+	end
 
-  # Decorates the given object 'obj' with a method 'name' that returns the
-  # given 'attr_value'.
-  def self.add_attribute(obj, name, value) # :nodoc:
-    attributes = obj.instance_variable_get :@__attributes
-    attributes[key = name.to_sym] = value.strip.gsub /\s+/, ' '
+	# Decorates the given object 'obj' with a method 'name' that returns the
+	# given 'attr_value'.
+	def self.add_attribute(obj, name, value) # :nodoc:
+		attributes = obj.instance_variable_get :@__attributes
+		attributes[key = name.to_sym] = value.strip.gsub /\s+/, ' '
 
-    obj.instance_variable_set :@__attributes, attributes
-    value
-  end
+		obj.instance_variable_set :@__attributes, attributes
+		value
+	end
 end

data/lib/xml-object/adapters.rb

@@ -1,29 +1,29 @@
 module XMLObject # :nodoc:
-  class << self # :nodoc:
-    attr_accessor :adapter # :nodoc:
-  end
+	class << self # :nodoc:
+		attr_accessor :adapter # :nodoc:
+	end
 
-  module Adapters # :nodoc:
-    module Base # :nodoc:
-      class Element # :nodoc:
-        attr_accessor :raw, :name, :value, :attributes, :children # :nodoc:
+	module Adapters # :nodoc:
+		module Base # :nodoc:
+			class Element # :nodoc:
+				attr_accessor :raw, :name, :value, :attributes, :children # :nodoc:
 
-        def initialize(*args)
+				def initialize(*args)
 
-          @children = @element_nodes.map { |node| self.class.new(node) }
-          @value = (not (text_value !~ /\S/)) ? text_value : cdata_value
-        end
+					@children = @element_nodes.map { |node| self.class.new(node) }
+					@value = (not (text_value !~ /\S/)) ? text_value : cdata_value
+				end
 
-        private ###########################################################
+				private ###########################################################
 
-        def text_value
-          @text_value_memo ||= @text_nodes.reject { |n| n !~ /\S/ }.join
-        end
+				def text_value
+					@text_value_memo ||= @text_nodes.reject { |n| n !~ /\S/ }.join
+				end
 
-        def cdata_value
-          @cdata_nodes.join
-        end
-      end
-    end
-  end
+				def cdata_value
+					@cdata_nodes.join
+				end
+			end
+		end
+	end
 end

data/lib/xml-object/adapters/libxml.rb

@@ -1,34 +1,34 @@
 require 'libxml' unless defined?(JRUBY_VERSION) # JRuby already has it...
 
 module XMLObject::Adapters::LibXML
-  # Can take a String of XML data, or anything that responds to
-  # either +read+ or +to_s+.
-  def self.new(duck)
-    case
-      when duck.respond_to?(:read)
-        then Element.new(::LibXML::XML::Parser.string(duck.read).parse.root)
-      when duck.respond_to?(:to_s)
-        then Element.new(::LibXML::XML::Parser.string(duck.to_s).parse.root)
-      else raise "Don't know how to deal with '#{duck.class}' object"
-    end
-  end
+	# Can take a String of XML data, or anything that responds to
+	# either +read+ or +to_s+.
+	def self.new(duck)
+		case
+			when duck.respond_to?(:read)
+				then Element.new(::LibXML::XML::Parser.string(duck.read).parse.root)
+			when duck.respond_to?(:to_s)
+				then Element.new(::LibXML::XML::Parser.string(duck.to_s).parse.root)
+			else raise "Don't know how to deal with '#{duck.class}' object"
+		end
+	end
 
-  private ##################################################################
+	private ##################################################################
 
-  class Element < XMLObject::Adapters::Base::Element # :nodoc:
-    def initialize(xml)
-      @raw, @name, @attributes = xml, xml.name, xml.attributes.to_h
+	class Element < XMLObject::Adapters::Base::Element # :nodoc:
+		def initialize(xml)
+			@raw, @name, @attributes = xml, xml.name, xml.attributes.to_h
 
-      @element_nodes = xml.children.select { |c| c.element? }
+			@element_nodes = xml.children.select { |c| c.element? }
 
-      @text_nodes  = xml.children.select { |c| c.text? }.map! { |c| c.to_s }
-      @cdata_nodes = xml.children.select { |c| c.cdata? }.map! do |c|
-        c.to_s.chomp(']]>').sub('<![CDATA[', '')
-      end
+			@text_nodes  = xml.children.select { |c| c.text? }.map! { |c| c.to_s }
+			@cdata_nodes = xml.children.select { |c| c.cdata? }.map! do |c|
+				c.to_s.chomp(']]>').sub('<![CDATA[', '')
+			end
 
-      super
-    end
-  end
+			super
+		end
+	end
 end
 
 ::XMLObject.adapter = ::XMLObject::Adapters::LibXML

data/lib/xml-object/adapters/rexml.rb

@@ -1,37 +1,37 @@
 require 'rexml/document'
 
 module XMLObject::Adapters::REXML
-  # Can take a String of XML data, or anything that responds to
-  # either +read+ or +to_s+.
-  def self.new(duck)
-    case
-      when duck.respond_to?(:read)
-        then Element.new(::REXML::Document.new(duck.read).root)
-      when duck.respond_to?(:to_s)
-        then Element.new(::REXML::Document.new(duck.to_s).root)
-      else raise "Don't know how to deal with '#{duck.class}' object"
-    end
-  end
-
-  private ##################################################################
-
-  class Element < XMLObject::Adapters::Base::Element # :nodoc:
-    def initialize(xml)
-      @raw, @name, @attributes = xml, xml.name, xml.attributes
-
-      @element_nodes = xml.elements
-
-      @text_nodes = xml.children.select do |child|
-        child.class == ::REXML::Text
-      end.map! { |child| child.to_s }
-
-      @cdata_nodes = xml.children.select do |child|
-        child.class == ::REXML::CData
-      end.map! { |child| child.to_s }
-
-      super
-    end
-  end
+	# Can take a String of XML data, or anything that responds to
+	# either +read+ or +to_s+.
+	def self.new(duck)
+		case
+			when duck.respond_to?(:read)
+				then Element.new(::REXML::Document.new(duck.read).root)
+			when duck.respond_to?(:to_s)
+				then Element.new(::REXML::Document.new(duck.to_s).root)
+			else raise "Don't know how to deal with '#{duck.class}' object"
+		end
+	end
+
+	private ##################################################################
+
+	class Element < XMLObject::Adapters::Base::Element # :nodoc:
+		def initialize(xml)
+			@raw, @name, @attributes = xml, xml.name, xml.attributes
+
+			@element_nodes = xml.elements
+
+			@text_nodes = xml.children.select do |child|
+				child.class == ::REXML::Text
+			end.map! { |child| child.to_s }
+
+			@cdata_nodes = xml.children.select do |child|
+				child.class == ::REXML::CData
+			end.map! { |child| child.to_s }
+
+			super
+		end
+	end
 end
 
 ::XMLObject.adapter = ::XMLObject::Adapters::REXML

data/lib/xml-object/collection_proxy.rb

@@ -1,37 +1,37 @@
 class XMLObject::CollectionProxy # :nodoc:
-  instance_methods.each do |m|
-    meth_str, meth_sym = m.to_s, m.to_sym # Ruby 1.8 and 1.9 differ, so...
+	instance_methods.each do |m|
+		meth_str, meth_sym = m.to_s, m.to_sym # Ruby 1.8 and 1.9 differ, so...
 
-    undef_method meth_sym unless meth_str =~ /^__/        ||
+		undef_method meth_sym unless meth_str =~ /^__/        ||
                                  meth_str =~ /^instance_/ ||
                                  meth_sym == :is_a?       ||
                                  meth_sym == :kind_of?    ||
                                  meth_sym == :extend      ||
                                  meth_sym == :nil?        ||
                                  meth_sym == :object_id
-  end
+	end
 
-  def initialize(xml) # :nodoc:
-    @__children, @__attributes = {}, {}
-    @__target_kid = xml.children[0].name.to_sym
-  end
+	def initialize(xml) # :nodoc:
+		@__children, @__attributes = {}, {}
+		@__target_kid = xml.children[0].name.to_sym
+	end
 
-  private ##################################################################
+	private ##################################################################
 
-  def method_missing(m, *a, &b) # :nodoc:
-    dispatched = __question_dispatch(m, *a, &b)
-    dispatched = __dot_notation_dispatch(m, *a, &b) if dispatched.nil?
+	def method_missing(m, *a, &b) # :nodoc:
+		dispatched = __question_dispatch(m, *a, &b)
+		dispatched = __dot_notation_dispatch(m, *a, &b) if dispatched.nil?
 
-    if dispatched.nil? && @__children[@__target_kid].respond_to?(m)
-      dispatched = @__children[@__target_kid].__send__(m, *a, &b)
+		if dispatched.nil? && @__children[@__target_kid].respond_to?(m)
+			dispatched = @__children[@__target_kid].__send__(m, *a, &b)
 
-      unless nil == dispatched
-        # All is fair in Love and War. And 100% coverage.
-        instance_eval \
-          %{ def #{m}(*a, &b); @__children[@__target_kid].#{m}(*a, &b); end }
-      end
-    end
+			unless nil == dispatched
+				# All is fair in Love and War. And 100% coverage.
+				instance_eval \
+					%{ def #{m}(*a, &b); @__children[@__target_kid].#{m}(*a, &b); end }
+			end
+		end
 
-    (nil == dispatched) ? raise(NameError.new(m.to_s)) : dispatched
-  end
+		(nil == dispatched) ? raise(NameError.new(m.to_s)) : dispatched
+	end
 end

data/lib/xml-object/element.rb

@@ -1,24 +1,24 @@
 module XMLObject::Element
-  def self.new(xml) # :nodoc:
-    element = xml.value
-    element.instance_variable_set :@__raw_xml,    xml.raw
-    element.instance_variable_set :@__children,   {}
-    element.instance_variable_set :@__attributes, {}
-    element.extend self
-  end
+	def self.new(xml) # :nodoc:
+		element = xml.value
+		element.instance_variable_set :@__raw_xml,    xml.raw
+		element.instance_variable_set :@__children,   {}
+		element.instance_variable_set :@__attributes, {}
+		element.extend self
+	end
 
-  # The raw, unadapted XML object. Whatever this is, it really depends on
-  # the currently chosen adapter.
-  def raw_xml
-    @__raw_xml
-  end
+	# The raw, unadapted XML object. Whatever this is, it really depends on
+	# the currently chosen adapter.
+	def raw_xml
+		@__raw_xml
+	end
 
-  private ##################################################################
+	private ##################################################################
 
-  def method_missing(m, *a, &b) # :nodoc:
-    dispatched = __question_dispatch(m, *a, &b)
-    dispatched = __dot_notation_dispatch(m, *a, &b) if dispatched.nil?
+	def method_missing(m, *a, &b) # :nodoc:
+		dispatched = __question_dispatch(m, *a, &b)
+		dispatched = __dot_notation_dispatch(m, *a, &b) if dispatched.nil?
 
-    dispatched.nil? ? raise(NameError.new(m.to_s)) : dispatched
-  end
+		dispatched.nil? ? raise(NameError.new(m.to_s)) : dispatched
+	end
 end

data/lib/xml-object/properties.rb

@@ -1,95 +1,97 @@
+require 'active_support/inflector'
+
 module XMLObject::Properties
-  # Array-bracket (+[]+) notation access to elements and attributes. Use
-  # when the element or attribute you need to reach is not reachable via dot
-  # notation (because it's not a valid method name, or because the method
-  # exists, such as +id+ or +class+).
-  #
-  # It also supports a hash key, which is used to reach attributes named
-  # the same as elements in the same depth level (which otherwise go first)
-  #
-  # All of this is a lot easier to explain by example:
-  #
-  #   <article id="main_article" author="j-random">
-  #     <author>J. Random Hacker</author>
-  #   </article>
-  #
-  #   article.id                 => 9314390            # Object#id
-  #   article[:id]               => "main_article"     # id attribute
-  #   article[:author]           => "J. Random Hacker" # <author> element
-  #   article[:attr => 'author'] => "j-random"         # author attribute
-  #
-  # Valid keys for the hash notation are +:attr+ and +:elem+.
-  def [](duck)
-    if @__target_kid && duck.is_a?(Numeric)
-      @__children[@__target_kid][duck]
-    elsif duck.is_a?(Hash)
-      raise NameError.new('only one key allowed') if duck.keys.size != 1
-      key, name = duck.keys[0].to_sym, duck.values[0].to_sym
-
-      unless ( (key == :elem) || (:attr == key) )
-        raise NameError.new("Invalid key :#{key.to_s}. Use :elem or :attr")
-      end
-
-      value = (key == :elem) ? @__children[name] : @__attributes[name]
-      value.nil? ? raise(NameError.new(name.to_s)) : value
-    else
-      key = duck.to_s.to_sym
-
-      case
-        when (not @__children[key].nil?)   then @__children[key]
-        when (not @__attributes[key].nil?) then @__attributes[key]
-        else raise NameError.new(key.to_s)
-      end
-    end
-  end
-
-  private ##################################################################
-
-  def __question_dispatch(meth, *args, &block)
-    return nil unless meth.to_s.match(/\?$/) && args.empty? && block.nil?
-
-    method_sans_question = meth.to_s.chomp('?').to_sym
-
-    if boolish = __send__(method_sans_question)
-      bool = case
-        when %w[ true yes t y ].include?(boolish.downcase) then true
-        when %w[ false no f n ].include?(boolish.downcase) then false
-        else nil
-      end
-
-      unless bool.nil?
-        instance_eval %{ def #{meth}; #{bool ? 'true' : 'false'}; end }
-      end
-
-      bool
-    end
-  end
-
-  def __dot_notation_dispatch(meth, *args, &block)
-    return nil unless args.empty? && block.nil?
-
-    if @__children.has_key?(meth)
-      instance_eval %{ def #{meth}; @__children[%s|#{meth}|]; end }
-      @__children[meth]
-
-    elsif @__attributes.has_key?(meth)
-      instance_eval %{ def #{meth}; @__attributes[%s|#{meth}|]; end }
-      @__attributes[meth]
-
-    elsif @__children.has_key?(naive_sing = meth.to_s.chomp('s').to_sym) &&
-          @__children[naive_sing].is_a?(Array)
-
-      instance_eval %{ def #{meth}; @__children[%s|#{naive_sing}|]; end }
-      @__children[naive_sing]
-
-    elsif defined?(ActiveSupport::Inflector)                            &&
-          @__children.has_key?(singular = meth.to_s.singularize.to_sym) &&
-          @__children[singular].is_a?(Array)
-
-      instance_eval %{ def #{meth}; @__children[%s|#{singular}|]; end }
-      @__children[singular]
-    else
-      nil
-    end
-  end
-end
+	# Array-bracket (+[]+) notation access to elements and attributes. Use
+	# when the element or attribute you need to reach is not reachable via dot
+	# notation (because it's not a valid method name, or because the method
+	# exists, such as +id+ or +class+).
+	#
+	# It also supports a hash key, which is used to reach attributes named
+	# the same as elements in the same depth level (which otherwise go first)
+	#
+	# All of this is a lot easier to explain by example:
+	#
+	#   <article id="main_article" author="j-random">
+	#     <author>J. Random Hacker</author>
+	#   </article>
+	#
+	#   article.id                 => 9314390            # Object#id
+	#   article[:id]               => "main_article"     # id attribute
+	#   article[:author]           => "J. Random Hacker" # <author> element
+	#   article[:attr => 'author'] => "j-random"         # author attribute
+	#
+	# Valid keys for the hash notation are +:attr+ and +:elem+.
+	def [](duck)
+		if @__target_kid && duck.is_a?(Numeric)
+			@__children[@__target_kid][duck]
+		elsif duck.is_a?(Hash)
+			raise NameError.new('only one key allowed') if duck.keys.size != 1
+			key, name = duck.keys[0].to_sym, duck.values[0].to_sym
+
+			unless ( (key == :elem) || (:attr == key) )
+				raise NameError.new("Invalid key :#{key.to_s}. Use :elem or :attr")
+			end
+
+			value = (key == :elem) ? @__children[name] : @__attributes[name]
+			value.nil? ? raise(NameError.new(name.to_s)) : value
+		else
+			key = duck.to_s.to_sym
+
+			case
+				when (not @__children[key].nil?)   then @__children[key]
+				when (not @__attributes[key].nil?) then @__attributes[key]
+				else raise NameError.new(key.to_s)
+			end
+		end
+	end
+
+	private ##################################################################
+
+	def __question_dispatch(meth, *args, &block)
+		return nil unless meth.to_s.match(/\?$/) && args.empty? && block.nil?
+
+		method_sans_question = meth.to_s.chomp('?').to_sym
+
+		if boolish = __send__(method_sans_question)
+			bool = case
+				when %w[ true yes t y ].include?(boolish.downcase) then true
+				when %w[ false no f n ].include?(boolish.downcase) then false
+				else nil
+			end
+
+			unless bool.nil?
+				instance_eval %{ def #{meth}; #{bool ? 'true' : 'false'}; end }
+			end
+
+			bool
+		end
+	end
+
+	def __dot_notation_dispatch(meth, *args, &block)
+		return nil unless args.empty? && block.nil?
+
+		if @__children.has_key?(meth)
+			instance_eval %{ def #{meth}; @__children[%s|#{meth}|]; end }
+			@__children[meth]
+
+		elsif @__attributes.has_key?(meth)
+			instance_eval %{ def #{meth}; @__attributes[%s|#{meth}|]; end }
+			@__attributes[meth]
+
+		elsif @__children.has_key?(naive_sing = meth.to_s.chomp('s').to_sym) &&
+					@__children[naive_sing].is_a?(Array)
+
+			instance_eval %{ def #{meth}; @__children[%s|#{naive_sing}|]; end }
+			@__children[naive_sing]
+
+		elsif (singular = ActiveSupport::Inflector.singularize(meth.to_s)) &&
+			@__children.has_key?(singular.to_sym) &&
+			@__children[singular.to_sym].is_a?(Array)
+
+			instance_eval %{ def #{meth}; @__children[%s|#{singular}|]; end }
+			@__children[singular.to_sym]
+		else
+			nil
+		end
+	end
+end

data/lib/xml-object/version.rb

@@ -1,4 +1,4 @@
 module XMLObject
-  VERSION  = '0.9.93'
-  LOCATION = File.dirname __FILE__ # :nodoc:
-end
+	VERSION  = '1.0.0'
+	LOCATION = File.dirname __FILE__ # :nodoc:
+end

data/xml-object.gemspec

@@ -1,4 +1,4 @@
-require 'lib/xml-object/version'
+require './lib/xml-object/version'
 
 Gem::Specification.new do |gem|
   gem.name    = 'xml-object'
@@ -12,7 +12,11 @@ Gem::Specification.new do |gem|
     documents of a known structure. While not devoid of caveats, it does
     have a very pleasant, idiomatic Ruby syntax. }.strip!.gsub! /\s+/, ' '
 
-  gem.required_ruby_version = '>= 1.8.6'
+  gem.required_ruby_version = '>= 1.9.3'
+
+  gem.add_dependency 'activesupport'
+  gem.add_development_dependency 'minitest'
+  gem.add_development_dependency 'rake'
 
   gem.has_rdoc         = true
   gem.extra_rdoc_files = %w[ README.rdoc MIT-LICENSE WHATSNEW ]
@@ -37,4 +41,4 @@ Gem::Specification.new do |gem|
     lib/xml-object.rb
     xml-object.gemspec
   ]
-end
+end

metadata

@@ -1,35 +1,68 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: xml-object
-version: !ruby/object:Gem::Version 
-  hash: 129
-  prerelease: false
-  segments: 
-  - 0
-  - 9
-  - 93
-  version: 0.9.93
+version: !ruby/object:Gem::Version
+  version: 1.0.0
 platform: ruby
-authors: 
+authors:
 - Jordi Bunster
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2010-08-26 00:00:00 -07:00
-default_executable: 
-dependencies: []
-
-description: XMLObject is a library for reading (not writing) XML. It is particularly suited for cases where one is dealing with small documents of a known structure. While not devoid of caveats, it does have a very pleasant, idiomatic Ruby syntax.
+date: 2016-04-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: XMLObject is a library for reading (not writing) XML. It is particularly
+  suited for cases where one is dealing with small documents of a known structure.
+  While not devoid of caveats, it does have a very pleasant, idiomatic Ruby syntax.
 email: jordi@bunster.org
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - README.rdoc
 - MIT-LICENSE
 - WHATSNEW
-files: 
+files:
 - MIT-LICENSE
 - README.rdoc
 - TODO
@@ -43,45 +76,32 @@ files:
 - lib/xml-object/properties.rb
 - lib/xml-object.rb
 - xml-object.gemspec
-has_rdoc: true
 homepage: 
 licenses: []
-
+metadata: {}
 post_install_message: 
-rdoc_options: 
+rdoc_options:
 - --title
 - XMLObject
 - --main
 - README.rdoc
 - --inline-source
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 59
-      segments: 
-      - 1
-      - 8
-      - 6
-      version: 1.8.6
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 2.0.14
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: The Rubyista's way to do quick XML sit-ups
 test_files: []
-