xml-object 0.9.8 → 0.9.9

data/WHATSNEW

@@ -1,3 +1,6 @@
+* 0.9.9 (2008-12-18):
+  - Bugfix for the new faster-than-nokogiri Hpricot version (broke the API)
+
 * 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

data/lib/xml-object.rb

@@ -5,43 +5,40 @@ $:.unshift File.join(File.dirname(__FILE__), 'xml-object')
 
 require 'adapters'
 require 'adapters/rexml'
-require 'array_notation'
+require 'properties'
 require 'collection_proxy'
 require 'element'
-require 'method_missing_dispatchers'
 
 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)
+  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)
+      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 ##################################################################
 
-  # Takes any Element object, and converts it recursively into
+  # Takes any adapter Element object, and converts it recursively into
   # the corresponding tree of decorated objects.
   def self.new_decorated_obj(xml) # :nodoc:
-    obj = if ( (xml.value !~ /\S/) && (xml.children.size > 1) &&
-               xml.children.collect { |e| e.name }.uniq.size == 1 )
+    # 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.children[0].name.to_sym
+      CollectionProxy.new xml # This is an empty array wrap
     else
-      # Teach our string to behave like and XML Element
-      xml.value.extend Element
+      Element.new xml # This one is an actual element
     end
 
-    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 }
 
-    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 some new tricks:
-    obj.extend ArrayNotation, MethodMissingDispatchers
+    # 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
@@ -65,12 +62,11 @@ module XMLObject
 
   # Decorates the given object 'obj' with a method 'name' that returns the
   # given 'attr_value'.
-  def self.add_attribute(obj, name, attr_value) # :nodoc:
-
+  def self.add_attribute(obj, name, value) # :nodoc:
     attributes = obj.instance_variable_get :@__attributes
-    attributes[(key = name.to_sym)] = attr_value.strip.gsub(/\s+/, ' ')
+    attributes[key = name.to_sym] = value.strip.gsub /\s+/, ' '
 
     obj.instance_variable_set :@__attributes, attributes
-    attr_value
+    value
   end
 end

data/lib/xml-object/adapters.rb

@@ -18,7 +18,7 @@ module XMLObject # :nodoc:
         private ###########################################################
 
         def text_value
-          @text_nodes.reject { |n| n !~ /\S/ }.join
+          @text_value_memo ||= @text_nodes.reject { |n| n !~ /\S/ }.join
         end
 
         def cdata_value

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

@@ -7,9 +7,10 @@ module XMLObject::Adapters::Hpricot
   # either +read+ or +to_s+.
   def self.new(duck)
     case
-      when duck.is_a?(::Hpricot::Elem) then Element.new(duck)
-      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)
+      when duck.respond_to?(:read)
+        then Element.new(::Hpricot::XML(duck.read).root)
+      when duck.respond_to?(:to_s)
+        then Element.new(::Hpricot::XML(duck.to_s).root)
       else raise "Don't know how to deal with '#{duck.class}' object"
     end
   end
@@ -18,17 +19,18 @@ module XMLObject::Adapters::Hpricot
 
   class Element < XMLObject::Adapters::Base::Element # :nodoc:
     def initialize(xml)
-      @raw, @name, @attributes = xml, xml.name, xml.attributes
+      @raw, @name = xml, xml.name
+      @attributes = xml.attributes || {}
 
       @element_nodes = xml.children.select { |c| c.elem? }
 
       @text_nodes = xml.children.select do |c|
         c.text? && !c.is_a?(::Hpricot::CData)
-      end.map { |c| c.to_s }
+      end.map! { |c| c.to_s }
 
       @cdata_nodes = xml.children.select do |c|
         c.is_a? ::Hpricot::CData
-      end.map { |c| c.to_s }
+      end.map! { |c| c.to_s }
 
       super
     end

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

@@ -6,11 +6,10 @@ module XMLObject::Adapters::LibXML
   # either +read+ or +to_s+.
   def self.new(duck)
     case
-      when duck.is_a?(::LibXML::XML::Node) then Element.new(duck)
       when duck.respond_to?(:read)
-        then new(::LibXML::XML::Parser.string(duck.read).parse.root)
+        then Element.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)
+        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
@@ -23,8 +22,8 @@ module XMLObject::Adapters::LibXML
 
       @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|
+      @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
 

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

@@ -6,11 +6,10 @@ module XMLObject::Adapters::REXML
   # either +read+ or +to_s+.
   def self.new(duck)
     case
-      when duck.is_a?(::REXML::Element) then Element.new(duck)
       when duck.respond_to?(:read)
-        then new(::REXML::Document.new(duck.read).root)
+        then Element.new(::REXML::Document.new(duck.read).root)
       when duck.respond_to?(:to_s)
-        then new(::REXML::Document.new(duck.to_s).root)
+        then Element.new(::REXML::Document.new(duck.to_s).root)
       else raise "Don't know how to deal with '#{duck.class}' object"
     end
   end
@@ -25,11 +24,11 @@ module XMLObject::Adapters::REXML
 
       @text_nodes = xml.children.select do |child|
         child.class == ::REXML::Text
-      end.collect { |child| child.to_s }
+      end.map! { |child| child.to_s }
 
       @cdata_nodes = xml.children.select do |child|
         child.class == ::REXML::CData
-      end.collect { |child| child.to_s }
+      end.map! { |child| child.to_s }
 
       super
     end

data/lib/xml-object/collection_proxy.rb

@@ -3,15 +3,16 @@ 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) )
+    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
+  def initialize(xml) # :nodoc:
+    @__children, @__attributes = {}, {}
+    @__target_kid = xml.children[0].name.to_sym
   end
 
   private ##################################################################
@@ -23,13 +24,13 @@ class XMLObject::CollectionProxy # :nodoc:
     if dispatched.nil? && @__children[@__target_kid].respond_to?(m)
       dispatched = @__children[@__target_kid].__send__(m, *a, &b)
 
-      unless dispatched.nil?
+      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
 
-    dispatched.nil? ? raise(NameError.new(m.to_s)) : dispatched
+    (nil == dispatched) ? raise(NameError.new(m.to_s)) : dispatched
   end
 end

data/lib/xml-object/element.rb

@@ -1,8 +1,10 @@
 module XMLObject::Element
-  def self.extended(obj) # :nodoc:
-    obj.instance_variable_set :@__children,   {}
-    obj.instance_variable_set :@__attributes, {}
-    obj
+  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

data/lib/xml-object/{array_notation.rb → properties.rb}

@@ -1,4 +1,5 @@
-module XMLObject::ArrayNotation
+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
@@ -42,4 +43,54 @@ module XMLObject::ArrayNotation
       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

data/xml-object.gemspec

@@ -1,11 +1,9 @@
-Gem::Specification.new do |gem|
-  gem.rubyforge_project = 'xml-object'
+XMLOBJECT_GEMSPEC = Gem::Specification.new do |gem|
+  gem.name     = gem.rubyforge_project = 'xml-object'
+  gem.homepage = 'http://xml-object.rubyforge.org'
 
-  gem.name     = 'xml-object'
-  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.version, gem.date  = '0.9.9', '2008-12-18'
+  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.
@@ -13,6 +11,10 @@ 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.has_rdoc = !!(gem.extra_rdoc_files = %w[ README.rdoc ])
+  gem.rdoc_options += %w[
+    --title XMLObject --main README.rdoc --inline-source ]
+
   gem.files = %w[
     MIT-LICENSE
     README.rdoc
@@ -26,16 +28,10 @@ Gem::Specification.new do |gem|
     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/collection_proxy.rb
     lib/xml-object/element.rb
-    lib/xml-object/method_missing_dispatchers.rb
+    lib/xml-object/properties.rb
     lib/xml-object.rb
     xml-object.gemspec
   ]
-
-  gem.has_rdoc = !!(gem.extra_rdoc_files = %w[ README.rdoc ])
-  gem.rdoc_options << '--title' << 'XMLObject'   <<
-                      '--main'  << 'README.rdoc' <<
-                      '--inline-source'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: xml-object
 version: !ruby/object:Gem::Version 
-  version: 0.9.8
+  version: 0.9.9
 platform: ruby
 authors: 
 - Jordi Bunster
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-10-23 00:00:00 -04:00
+date: 2008-12-18 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -34,14 +34,13 @@ files:
 - 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/collection_proxy.rb
 - lib/xml-object/element.rb
-- lib/xml-object/method_missing_dispatchers.rb
+- lib/xml-object/properties.rb
 - lib/xml-object.rb
 - xml-object.gemspec
 has_rdoc: true
-homepage: http://github.com/jordi/xml-object
+homepage: http://xml-object.rubyforge.org
 post_install_message: 
 rdoc_options: 
 - --title
@@ -66,7 +65,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: xml-object
-rubygems_version: 1.3.0
+rubygems_version: 1.3.1
 signing_key: 
 specification_version: 2
 summary: The Rubyista's way to do quick XML sit-ups

data/lib/xml-object/method_missing_dispatchers.rb

@@ -1,52 +0,0 @@
-module XMLObject::MethodMissingDispatchers # :nodoc:
-
-  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