xml-object 0.9.7 → 0.9.8

data/README.rdoc

@@ -3,23 +3,19 @@
 (This is inspired by Python's +xml_objectify+)
 
 XMLObject attempts to make the accessing of small, well-formed XML structures
-convenient, by using dot notation to represent both attributes and child
-elements whenever possible.
-
-XML parsing libraries (in general) have interfaces that are useful when one
-is using XML for its intended purpose, but cumbersome when one always sends
-the same XML structure, and always process all of it in the same way. This
-one aims to be a bit different.
-
-At the moment, I aim for compatibility with Ruby 1.8, 1.9, and JRuby 1.1.
+convenient, by providing a syntax that fits well in most Ruby programs.
 
 == Dependencies
 
 None outside of Ruby, though some optional gems add additional features. See
-below on "Adapters" and "Collection pluralization".
+more below.
+
+At the moment, I aim for compatibility with Ruby 1.8, 1.9, and JRuby 1.1.
 
 == Installation instructions
 
+From Rubyforge's gem server:
+
   gem install xml-object
 
 Or from Github's gem server:
@@ -32,6 +28,8 @@ Both are the same, and are loaded the same way:
 
 == Example usage
 
+  recipe.xml is as follows:
+
   <recipe name="bread" prep_time="5 mins" cook_time="3 hours">
     <title>Basic bread</title>
     <ingredient amount="8" unit="dL">Flour</ingredient>
@@ -50,7 +48,7 @@ Both are the same, and are loaded the same way:
   </recipe>
 
   require 'xml-object'
-  recipe = XMLObject.new io_with_recipe_xml_shown_above
+  recipe = XMLObject.new(File.open('recipe.xml'))
 
   recipe.name                      => "bread"
   recipe.title                     => "Basic bread"
@@ -74,89 +72,91 @@ the issue of passing a data-structure over the network, and/or between two
 different languages. Tools like +JSON+ or +YAML+ are a much better fit for
 this kind of job, but one doesn't always have that luxury.
 
-== Caveats
+== Features & Problems
 
-The dot notation is used as follows. For the given file:
+=== Adapters
 
-  <outer id="root" name="foo">
+XMLObject supports different adapters to do the actual XML parsing. It ships
+with +REXML+, +Hpricot+, and +LibXML+ adapters. By default, the +REXML+
+adapter is used.
+
+To use a different adapter than the +REXML+ default:
+
+  require 'xml-object'                  # Require XMLObject first
+  require 'xml-object/adapters/hpricot'
+  require 'xml-object/adapters/libxml'
+
+=== Access to elements and attributes
+
+XMLObject uses dot notation (foo.bar) for both elements and attributes, with
+a few rules, and with an array notation fallback for invalid method names
+or other tricky situations. For example, with the given file:
+
+  <outer object_id="root" name="foo">
     <name>Outer Element</name>
   </outer>
 
 +outer.name+ is the +name+ *element*. Child elements are always looked up
-first, then attributes. To access the attribute in the case of ambiguity, use
+first, then attributes. To access the attribute in case of ambiguity, use
 outer[:attr => 'name'].
 
-+outer.id+ is really Object#id, because all of the object methods are
-preserved (this is on purpose). To access the attribute +id+, use
-outer[:attr => 'id'], or outer['id'] since there's no element/attribute
-ambiguity.
++outer.object_id+ is really Object#object_id, because all of the object
+methods are preserved (this is on purpose). To access the attribute
++object_id+, use outer[:attr => 'object_id'] (or just outer['object_id'],
+since there's no element/attribute ambiguity there).
 
-== Features & Problems
+=== Question notation
 
-=== Adapters
-
-XMLObject supports different adapters to do the actual XML parsing. It ships
-with +REXML+, +Hpricot+, +JREXML+, and +LibXML+ adapters. By default, the
-+REXML+ adapter is used.
-
-To use a different adapter than the +REXML+ default:
-
-  require 'xml-object'                  # Require XMLObject first
-  require 'xml-object/adapters/hpricot' # (Under MRI or JRuby)
-  require 'xml-object/adapters/libxml'  # (Under MRI only)
-  require 'xml-object/adapters/jrexml'  # (Under Jruby only)
+Elements or attributes that look like booleans are "booleanized" if called by
+their question names (such as +enabled?+)
 
 === Collection auto-folding
 
-Similar to XmlSimple, XMLObject folds same named elements at the same level.
-For example:
+Like XmlSimple, XMLObject folds same-named elements found at the same level,
+like so:
 
   <student>
     <name>Bob</name>
-    <course>Math</course>
-    <course>Biology</course>
+    <course>Math</course>     |
+    <course>Biology</course>  | => 'course' becomes an Array
   </student>
 
   student = XMLObject.new(xml_file)
 
-  student.course.is_a? Array       => true
+  student.course.is_a?(Array)      => true
   student.course.first == 'Math'   => true
   student.course.last  == 'Biology => true
 
 === Collection pluralization
 
-With the same file from the +Collection auto-folding+ section above, you also
-get this:
+With the same file as in the example above:
 
   student.courses.first == student.course.first => true
 
 Note that the pluralization algorithm is just tacking an 's' at the end of
 the singular, unless +ActiveSupport+ is installed, in which case you get
-irregular plurals, as well as the ability to teach the +Inflector+ about
+proper plurals, as well as the ability to teach the +Inflector+ about
 new ones.
 
 === Collection proxy
 
 Sometimes, collections are expressed with a container element in XML:
 
-  <student>
-    <name>Bob</name>
-    <courses>
-      <course>Math</course>
-      <course>Biology</course>
-    </courses>
-  </student>
+  <author>
+    <name>John</name>
+    <publications>
+      <book>Math 101</book>
+      <book>Biology 101</book>
+    </publications>
+  </author>
 
 In this case, since the container element +courses+ has no text element of
-its own, and it only has elements of one name under it, it delegates all
-methods it doesn't contain to the collection below, so you get:
-
-  student.courses.collect { |c| c.downcase.to_sym } => [:math, :biology]
+its own (attributes are ok), and it only has elements of one name under it,
+it delegates all methods to the collection below, so you get:
 
-=== Question mark notation
+  author.publications == author.publications.books => true
 
-Strings that look like booleans are "booleanized" if called by their question
-mark names (such as +enabled?+)
+  author.publications.map { |b| b.downcase } => ['math 101', 'biology 101']
 
 === Recursive
 
@@ -167,9 +167,22 @@ on the TODO list.
 
 === Incomplete
 
-It most likely doesn't work with a ton of features of complex XML files. I'll
-always try to accomodate those, as long as they don't make the basic usage
-more complex. As usual, patches welcome.
+It most likely doesn't work with a ton of features of complex XML files (see
+the caveats section). I'll always try to accomodate those, as long as they
+don't make the basic usage more complex. As usual, patches welcome.
+
+== Caveats
+
+=== Adapter specific
+
+==== Hpricot adapter
+
+While XMLObject doesn't yet aim to support namespaces, they seem to, for the
+most part, work. That is, unless you're using the Hpricot adapter.
+
+==== LibXML adapter
+
+The LibXML adapter will not return the 'xmlns' attribute.
 
 == Legal
 

data/TODO

@@ -1 +1,8 @@
 * Refactor so as to not do things recursively
+* Implement #inspect, #pp
+* Decide if NameError is indeed better than nil?
+* Decide if Element text should be stripped
+* See if namespaces are a possibility.
+* See if we can sort out Hpricot not folding namespaces.
+* Figure out a way to fix the 'xmlns' problem in LibXML, remove entry from
+  caveats in README.rdoc

data/WHATSNEW

@@ -1,3 +1,16 @@
+* 0.9.8 (2008-10-23):
+  - Much improved test suite. More granular, better coverage, much faster
+  - The collection proxy behaviour is now a lot faster when called in a loop
+  - Collection Proxies are a lot more transparent
+  - Reduced memory footprint of instantiated XMLObject trees
+  - Calling elements, attributes, question methods or pluralized collections
+    (anything, really) that's not there raises NameError instead of just
+    returning nil
+  - Removed #rb (wasn't really all that useful)
+  - The [:sym => 'foo'] notation now only supports :attr and :elem
+  - The question method notation is a bit more strict
+  - JREXML adapter removed. It barely sped up REXML under JRuby
+
 * 0.9.7 (2008-10-20):
   - LibXML adapter added
   - JREXML "adapter" added, as well as JREXML support during tests and

data/lib/xml-object.rb

@@ -3,15 +3,12 @@ begin; require 'activesupport'; rescue Exception, StandardError; nil; end
 
 $:.unshift File.join(File.dirname(__FILE__), 'xml-object')
 
-require 'core_ext'
 require 'adapters'
 require 'adapters/rexml'
 require 'array_notation'
-require 'blankish_slate'
 require 'collection_proxy'
 require 'element'
 require 'method_missing_dispatchers'
-require 'string'
 
 module XMLObject
   # Returns a String or Array object representing the given XML, decorated
@@ -29,16 +26,16 @@ module XMLObject
   # Takes any Element object, and converts it recursively into
   # the corresponding tree of decorated objects.
   def self.new_decorated_obj(xml) # :nodoc:
-    obj = if xml.value.blank? &&
-             xml.children.collect { |e| e.name }.uniq.size == 1
+    obj = if ( (xml.value !~ /\S/) && (xml.children.size > 1) &&
+               xml.children.collect { |e| e.name }.uniq.size == 1 )
 
-      CollectionProxy.new new(xml.children)
+      CollectionProxy.new xml.children[0].name.to_sym
     else
       # Teach our string to behave like and XML Element
-      xml.value.extend String, Element
+      xml.value.extend Element
     end
 
-    obj.instance_variable_set :@__adapted_element, xml
+    obj.instance_variable_set :@__raw_xml, xml.raw
 
     xml.children.each   { |child| add_child(obj, child.name, new(child)) }
     xml.attributes.each { |name, value|  add_attribute(obj, name, value) }
@@ -71,7 +68,7 @@ module XMLObject
   def self.add_attribute(obj, name, attr_value) # :nodoc:
 
     attributes = obj.instance_variable_get :@__attributes
-    attributes[(key = name.to_sym)] = attr_value.squish.extend String
+    attributes[(key = name.to_sym)] = attr_value.strip.gsub(/\s+/, ' ')
 
     obj.instance_variable_set :@__attributes, attributes
     attr_value

data/lib/xml-object/adapters.rb

@@ -1,4 +1,9 @@
 module XMLObject # :nodoc:
+
+  class << self # :nodoc:
+    attr_accessor :adapter # :nodoc:
+  end
+
   module Adapters # :nodoc:
     module Base # :nodoc:
       class Element # :nodoc:
@@ -7,18 +12,13 @@ module XMLObject # :nodoc:
         def initialize(*args)
 
           @children = @element_nodes.map { |node| self.class.new(node) }
-
-          @value = case
-            when (not text_value.blank?)  then text_value
-            when (not cdata_value.blank?) then cdata_value
-            else ''
-          end
+          @value = (not (text_value !~ /\S/)) ? text_value : cdata_value
         end
 
         private ###########################################################
 
         def text_value
-          @text_nodes.reject { |n| n.blank? }.join
+          @text_nodes.reject { |n| n !~ /\S/ }.join
         end
 
         def cdata_value

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

@@ -8,9 +8,8 @@ module XMLObject::Adapters::Hpricot
   def self.new(duck)
     case
       when duck.is_a?(::Hpricot::Elem) then Element.new(duck)
-      when duck.is_a?(::String)        then new(::Hpricot::XML(duck).root)
-      when duck.respond_to?(:read)     then new(duck.read)
-      when duck.respond_to?(:to_s)     then new(duck.to_s)
+      when duck.respond_to?(:read) then new(::Hpricot::XML(duck.read).root)
+      when duck.respond_to?(:to_s) then new(::Hpricot::XML(duck.to_s).root)
       else raise "Don't know how to deal with '#{duck.class}' object"
     end
   end
@@ -36,6 +35,4 @@ module XMLObject::Adapters::Hpricot
   end
 end
 
-def XMLObject.adapter # :nodoc:
-  XMLObject::Adapters::Hpricot
-end
+::XMLObject.adapter = ::XMLObject::Adapters::Hpricot

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

@@ -7,10 +7,10 @@ module XMLObject::Adapters::LibXML
   def self.new(duck)
     case
       when duck.is_a?(::LibXML::XML::Node) then Element.new(duck)
-      when duck.is_a?(::String)
-        then new(::LibXML::XML::Parser.string(duck).parse.root)
-      when duck.respond_to?(:read) then new(duck.read)
-      when duck.respond_to?(:to_s) then new(duck.to_s)
+      when duck.respond_to?(:read)
+        then new(::LibXML::XML::Parser.string(duck.read).parse.root)
+      when duck.respond_to?(:to_s)
+        then new(::LibXML::XML::Parser.string(duck.to_s).parse.root)
       else raise "Don't know how to deal with '#{duck.class}' object"
     end
   end
@@ -33,6 +33,4 @@ module XMLObject::Adapters::LibXML
   end
 end
 
-def XMLObject.adapter # :nodoc:
-  XMLObject::Adapters::LibXML
-end
+::XMLObject.adapter = ::XMLObject::Adapters::LibXML

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

@@ -7,9 +7,10 @@ module XMLObject::Adapters::REXML
   def self.new(duck)
     case
       when duck.is_a?(::REXML::Element) then Element.new(duck)
-      when duck.is_a?(::String)    then new(::REXML::Document.new(duck).root)
-      when duck.respond_to?(:read) then new(duck.read)
-      when duck.respond_to?(:to_s) then new(duck.to_s)
+      when duck.respond_to?(:read)
+        then new(::REXML::Document.new(duck.read).root)
+      when duck.respond_to?(:to_s)
+        then new(::REXML::Document.new(duck.to_s).root)
       else raise "Don't know how to deal with '#{duck.class}' object"
     end
   end
@@ -35,6 +36,4 @@ module XMLObject::Adapters::REXML
   end
 end
 
-def XMLObject.adapter # :nodoc:
-  XMLObject::Adapters::REXML
-end
+::XMLObject.adapter = ::XMLObject::Adapters::REXML

data/lib/xml-object/array_notation.rb

@@ -18,27 +18,28 @@ module XMLObject::ArrayNotation
   #   article[:author]           => "J. Random Hacker" # <author> element
   #   article[:attr => 'author'] => "j-random"         # author attribute
   #
-  # Valid keys for the hash notation in the example above are +:attr+,
-  # +:attribute+, +:child+, and +:element+.
-  def [](name)
-    return @__target[name] if @__target && name.is_a?(Numeric)
+  # 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 name.is_a? Hash
-      key = name.to_s.to_sym
+      unless ( (key == :elem) || (:attr == key) )
+        raise NameError.new("Invalid key :#{key.to_s}. Use :elem or :attr")
+      end
 
-      return @__children[key]   if @__children.has_key?(key)
-      return @__attributes[key] if @__attributes.has_key?(key)
-    end
-
-    raise 'one and only one key allowed' if name.size != 1
+      value = (key == :elem) ? @__children[name] : @__attributes[name]
+      value.nil? ? raise(NameError.new(name.to_s)) : value
+    else
+      key = duck.to_s.to_sym
 
-    case (param = name.keys.first.to_sym)
-      when :element   then @__children[name.values.first.to_sym]
-      when :child     then @__children[name.values.first.to_sym]
-      when :attr      then @__attributes[name.values.first.to_sym]
-      when :attribute then @__attributes[name.values.first.to_sym]
-      else raise %{ Invalid key :#{param.to_s}.
-        Use one of :element, :child, :attr, or :attribute }.squish!
+      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
 end

data/lib/xml-object/collection_proxy.rb

@@ -1,14 +1,35 @@
-class XMLObject::CollectionProxy < XMLObject::BlankishSlate # :nodoc:
-  def initialize(target)
-    @__children, @__attributes, @__target = {}, {}, target
+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...
+
+    undef_method meth_sym unless ( (meth_str =~ /^__/)        ||
+                                   (meth_str =~ /^instance_/) ||
+                                   (meth_sym == :extend)      ||
+                                   (meth_sym == :nil?)        ||
+                                   (meth_sym == :object_id) )
+  end
+
+  def initialize(target_kid_key) # :nodoc:
+    @__children, @__attributes, @__target_kid = {}, {}, target_kid_key
   end
 
   private ##################################################################
 
   def method_missing(m, *a, &b) # :nodoc:
-    dp = __question_dispatch(m, *a, &b)
-    dp = __dot_notation_dispatch(m, *a, &b) if dp.nil?
-    dp = @__target.__send__(m, *a, &b) if @__target.respond_to?(m) && dp.nil?
-    dp
+    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)
+
+      unless dispatched.nil?
+        # 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
+
+    dispatched.nil? ? raise(NameError.new(m.to_s)) : dispatched
   end
 end

data/lib/xml-object/element.rb

@@ -6,16 +6,17 @@ module XMLObject::Element
   end
 
   # The raw, unadapted XML object. Whatever this is, it really depends on
-  # the current_adapter.
+  # the currently chosen adapter.
   def raw_xml
-    @__adapted_element.raw if @__adapted_element
+    @__raw_xml
   end
 
   private ##################################################################
 
   def method_missing(m, *a, &b) # :nodoc:
-    dp = __question_dispatch(m, *a, &b)
-    dp = __dot_notation_dispatch(m, *a, &b) if dp.nil?
-    dp
+    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
 end

data/lib/xml-object/method_missing_dispatchers.rb

@@ -3,7 +3,7 @@ module XMLObject::MethodMissingDispatchers # :nodoc:
   private ##################################################################
 
   def __question_dispatch(meth, *args, &block)
-    return unless meth.to_s.match(/\?$/) && args.empty? && block.nil?
+    return nil unless meth.to_s.match(/\?$/) && args.empty? && block.nil?
 
     method_sans_question = meth.to_s.chomp('?').to_sym
 
@@ -14,7 +14,7 @@ module XMLObject::MethodMissingDispatchers # :nodoc:
         else nil
       end
 
-      unless bool.nil? # Fun, eh?
+      unless bool.nil?
         instance_eval %{ def #{meth}; #{bool ? 'true' : 'false'}; end }
       end
 
@@ -23,7 +23,7 @@ module XMLObject::MethodMissingDispatchers # :nodoc:
   end
 
   def __dot_notation_dispatch(meth, *args, &block)
-    return unless args.empty? && block.nil?
+    return nil unless args.empty? && block.nil?
 
     if @__children.has_key?(meth)
       instance_eval %{ def #{meth}; @__children[%s|#{meth}|]; end }
@@ -33,11 +33,20 @@ module XMLObject::MethodMissingDispatchers # :nodoc:
       instance_eval %{ def #{meth}; @__attributes[%s|#{meth}|]; end }
       @__attributes[meth]
 
-    elsif @__children.has_key?(singular = meth.to_s.singularize.to_sym) &&
+    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

data/xml-object.gemspec

@@ -2,12 +2,11 @@ Gem::Specification.new do |gem|
   gem.rubyforge_project = 'xml-object'
 
   gem.name     = 'xml-object'
-  gem.version  = '0.9.7'
-  gem.date     = '2008-10-20'
-  gem.author   = 'Jordi Bunster'
-  gem.email    = 'jordi@bunster.org'
   gem.homepage = 'http://github.com/jordi/xml-object'
 
+  gem.version, gem.date = '0.9.8', '2008-10-23'
+  gem.author, gem.email = 'Jordi Bunster', 'jordi@bunster.org'
+
   gem.summary     = "The Rubyista's way to do quick XML sit-ups"
   gem.description = %{ XMLObject is a library for reading (not writing) XML.
     It is particularly suited for cases where one is dealing with small
@@ -24,21 +23,13 @@ Gem::Specification.new do |gem|
     lib/xml-object
     lib/xml-object/adapters
     lib/xml-object/adapters/hpricot.rb
-    lib/xml-object/adapters/jrexml.rb
     lib/xml-object/adapters/libxml.rb
     lib/xml-object/adapters/rexml.rb
     lib/xml-object/adapters.rb
     lib/xml-object/array_notation.rb
-    lib/xml-object/blankish_slate.rb
     lib/xml-object/collection_proxy.rb
-    lib/xml-object/core_ext
-    lib/xml-object/core_ext/hash.rb
-    lib/xml-object/core_ext/nil_class.rb
-    lib/xml-object/core_ext/string.rb
-    lib/xml-object/core_ext.rb
     lib/xml-object/element.rb
     lib/xml-object/method_missing_dispatchers.rb
-    lib/xml-object/string.rb
     lib/xml-object.rb
     xml-object.gemspec
   ]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: xml-object
 version: !ruby/object:Gem::Version 
-  version: 0.9.7
+  version: 0.9.8
 platform: ruby
 authors: 
 - Jordi Bunster
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-10-20 00:00:00 -04:00
+date: 2008-10-23 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -31,21 +31,13 @@ files:
 - lib/xml-object
 - lib/xml-object/adapters
 - lib/xml-object/adapters/hpricot.rb
-- lib/xml-object/adapters/jrexml.rb
 - lib/xml-object/adapters/libxml.rb
 - lib/xml-object/adapters/rexml.rb
 - lib/xml-object/adapters.rb
 - lib/xml-object/array_notation.rb
-- lib/xml-object/blankish_slate.rb
 - lib/xml-object/collection_proxy.rb
-- lib/xml-object/core_ext
-- lib/xml-object/core_ext/hash.rb
-- lib/xml-object/core_ext/nil_class.rb
-- lib/xml-object/core_ext/string.rb
-- lib/xml-object/core_ext.rb
 - lib/xml-object/element.rb
 - lib/xml-object/method_missing_dispatchers.rb
-- lib/xml-object/string.rb
 - lib/xml-object.rb
 - xml-object.gemspec
 has_rdoc: true

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

@@ -1,10 +0,0 @@
-require 'jrexml'
-require File.join(File.dirname(__FILE__), 'rexml')
-
-module XMLObject::Adapters
-  JREXML = REXML
-end
-
-def XMLObject.adapter # :nodoc:
-  XMLObject::Adapters::JREXML
-end

data/lib/xml-object/blankish_slate.rb

@@ -1,10 +0,0 @@
-class XMLObject::BlankishSlate # :nodoc:
-
-  instance_methods.each do |m|
-    undef_method m unless m =~ /^__/        ||
-                          m =~ /respond_to/ ||
-                          m =~ /extend/     ||
-                          m =~ /object_id/  ||
-                          m =~ /^instance_/
-  end
-end

data/lib/xml-object/core_ext.rb

@@ -1,3 +0,0 @@
-require 'core_ext/hash'
-require 'core_ext/nil_class'
-require 'core_ext/string'

data/lib/xml-object/core_ext/hash.rb

@@ -1,5 +0,0 @@
-class Hash
-  def blank?
-    size.zero?
-  end unless {}.respond_to? :blank?
-end

data/lib/xml-object/core_ext/nil_class.rb

@@ -1,5 +0,0 @@
-class NilClass
-  def blank?
-    true
-  end unless nil.respond_to? :blank?
-end

data/lib/xml-object/core_ext/string.rb

@@ -1,19 +0,0 @@
-class String
-  def blank?
-    self !~ /\S/
-  end unless ''.respond_to? :blank?
-
-  def squish
-    dup.squish!
-  end unless ''.respond_to? :squish
-
-  def squish!
-    strip!
-    gsub! /\s+/, ' '
-    self
-  end unless ''.respond_to? :squish!
-
-  def singularize
-    self.chomp 's'
-  end unless ''.respond_to? :singularize
-end

data/lib/xml-object/string.rb

@@ -1,24 +0,0 @@
-module XMLObject::String
-
-  # Attempts to detect wether this String is really an integer or float,
-  # and returns accordingly. If not, just returns the string.
-  def rb
-    result = case
-      when (self !~ /\S/)                          then ''
-      when match(/[a-zA-Z]/)                       then ::String.new(self)
-      when match(/^[+-]?\d+$/)                     then self.to_i
-      when match(/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)$/) then self.to_f
-      else ::String.new(self)
-    end
-
-    @__rb ||= result
-  end
-
-  # A decorated String is blank when it has a blank value, no child
-  # elements, and no attributes. For example:
-  #
-  #    <blank_element></blank_element>
-  def blank?
-    (self !~ /\S/) && @__children.blank? && @__attributes.blank?
-  end
-end