jordi-xml-object 0.9.5 → 0.9.6

data/README.rdoc

@@ -6,10 +6,22 @@ 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.
+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.
+
+== Installation instructions
+
+  gem install xml-object
+
+Or from Github's gem server:
+
+  gem install jordi-xml-object --source http://gems.github.com
+
+Both are the same, and are loaded the same way:
+
+  require 'xml-object'
 
 == Example usage
 
@@ -44,15 +56,11 @@ way. This one aims to be a bit different.
   recipe.instructions.first.upcase => "MIX ALL INGREDIENTS TOGETHER."
   recipe.instructions.steps.size   => 7
 
-== Installation instructions
-
-    sudo gem install jordi-xml-object --source http://gems.github.com
-
 == Motivation
 
-XML is an *extensible* markup language. It is extensible because it is
-meant to define markup languages for *any* type of document, so new tags
-are needed depending on the problem domain.
+XML is an *extensible* markup language. It is extensible because it is meant
+to define markup languages for *any* type of document, so new tags are needed
+depending on the problem domain.
 
 Sometimes, however, XML ends up being used to solve a much simpler problem:
 the issue of passing a data-structure over the network, and/or between two
@@ -68,8 +76,8 @@ The dot notation is used as follows. For the given file:
   </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 outer[:attr => 'name'].
+first, then attributes. To access the attribute in the 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
@@ -80,73 +88,77 @@ ambiguity.
 
 === Collection auto-folding
 
-Similar to XmlSimple, XMLObject folds same named elements at the same
-level. For example:
+Similar to XmlSimple, XMLObject folds same named elements at the same level.
+For example:
 
-    <student>
-      <name>Bob</name>
-      <course>Math</course>
-      <course>Biology</course>
-    </student>
+  <student>
+    <name>Bob</name>
+    <course>Math</course>
+    <course>Biology</course>
+  </student>
 
-    student = XMLObject.new(xml_file)
+  student = XMLObject.new(xml_file)
 
-    student.course.is_a? Array       => true
-    student.course.first == 'Math'   => true
-    student.course.last  == 'Biology => 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 (courtesy of +ActiveSupport+'s +Inflector+):
+With the same file from the +Collection auto-folding+ section above, you also
+get this:
 
-    student.courses.first == student.course.first => true
+  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
+new ones.
 
 === Collection proxy
 
-  Sometimes, collections are expressed with a container element in XML:
+Sometimes, collections are expressed with a container element in XML:
 
-    <student>
-      <name>Bob</name>
-      <courses>
-        <course>Math</course>
-        <course>Biology</course>
-      </courses>
-    </student>
+  <student>
+    <name>Bob</name>
+    <courses>
+      <course>Math</course>
+      <course>Biology</course>
+    </courses>
+  </student>
 
-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:
+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]
+  student.courses.collect { |c| c.downcase.to_sym } => [:math, :biology]
 
 === Question mark notation
 
-Strings that look like booleans are "booleanized" if called by their
-question mark names (such as +enabled?+)
+Strings that look like booleans are "booleanized" if called by their question
+mark names (such as +enabled?+)
 
 === Adapters
 
 XMLObject supports different adapters to do the actual XML parsing. It ships
-with +REXML+ and +Hpricot+ adapters. If +Hpricot+ is detected it gets used,
-otherwise +REXML+ is used as a fallback.
+with +REXML+ and +Hpricot+ adapters. By default, the +REXML+ adapter is used.
+To use the +Hpricot+ adapter:
+
+  require 'xml-object/adapters/hpricot'
 
 === Recursive
 
 The design of the adapters assumes parsing of the objects recursively. Deep
 files are bound to throw +SystemStackError+, but for the kinds of files I
-need to read, things are working fine so far. In any case, stream parsing
-is on the TODO list.
+need to read, things are working fine so far. In any case, stream parsing is
+on the TODO list.
 
 === Incomplete
 
-It most likely doesn't work with a ton of features of complex XML files. I
-will 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. I'll
+always try to accomodate those, as long as they don't make the basic usage
+more complex. As usual, patches welcome.
 
 == Legal
 
 Copyright (c) 2008 Jordi Bunster, released under the MIT license
-
-
-

data/TODO

@@ -1,3 +1,2 @@
-* Make use of libxml if it's available, then fallback to REXML
 * Refactor so as to not do things recursively
-* Remove ActiveSupport dependency
+* Write LibXML2 adapter

data/WHATSNEW

@@ -1,3 +1,31 @@
+* 0.9.6 (2008-10-??):
+  - Ruby 1.9 compatibility
+  - XMLObject no longer requires ActiveSupport. Note that proper array
+    pluralization still depends on ActiveSupport's Inflector, so if it's not
+    there, we just pluralize things by tacking 's' at the end.
+  - XMLObject no longer tries to load Hpricot by default (too cumbersome
+    to test). Use "require 'xml-object/adapters/hpricot'" to enable the
+    Hpricot adapter.
+  - Backwards compatible change. For the following XML:
+
+      <foo>
+        <bar>
+        <bez>
+      </foo>
+
+      <foos>Yipes!</foos>
+
+    before:
+
+      xml.foos => # The <foo> "array"
+
+    now:
+
+      xml.foos => # The <foos> element
+
+    It proved too expensive to support that edge case, and for no good
+    reason.
+
 * 0.9.5 (2008-10-15):
   - Project renamed to XMLObject, to match project name at Rubyforge.
     The other names were taken. :(

data/lib/jordi-xml-object.rb

@@ -1 +1 @@
-require 'xml-object'
+require File.expand_path(File.join(File.dirname(__FILE__), 'xml-object'))

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

@@ -1,47 +1,51 @@
+require 'hpricot'
+
 module XMLObject::Adapters::Hpricot
 
   # Can take a String of XML data, or anything that responds to
   # either +read+ or +to_s+.
   def self.new(duck)
     case
-      when duck.is_a?(::Hpricot::Elem) : Element.new(duck)
-      when duck.is_a?(::String)        : new(::Hpricot::XML(duck).root)
-      when duck.respond_to?(:read)     : new(duck.read)
-      when duck.respond_to?(:to_s)     : new(duck.to_s)
+      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)
       else raise "Don't know how to deal with '#{duck.class}' object"
     end
   end
 
   private ##################################################################
 
-  class Element # :nodoc:
-    attr_reader :raw, :name, :value, :attributes, :children
+  class Element < XMLObject::Adapters::Base::Element # :nodoc:
+    def initialize(xml)
+      self.raw, self.name, self.attributes = xml, xml.name, xml.attributes
+      self.children = xml.children.select { |e| e.elem? }.map do |raw_xml|
+        self.class.new(raw_xml)
+      end
 
-    def text_value(raw)
-      raw.children.select do |e|
+      self.value = case
+        when (not text_value(xml).blank?)  then text_value(xml)
+        when (not cdata_value(xml).blank?) then cdata_value(xml)
+        else ''
+      end
+    end
+
+    private ################################################################
+
+    def text_value(xml)
+      xml.children.select do |e|
         (e.class == ::Hpricot::Text) && !e.to_s.blank?
       end.join.to_s
     end
 
-    def cdata_value(raw)
-      raw.children.select do |e|
+    def cdata_value(xml)
+      xml.children.select do |e|
         (e.class == ::Hpricot::CData) && !e.to_s.blank?
       end.first.to_s
     end
-
-    def initialize(xml)
-      @raw, @name, @attributes, @children = xml, xml.name, {}, []
-
-      @attributes = xml.attributes
-      xml.children.select { |e| e.elem? }.each do |e|
-        @children << self.class.new(e)
-      end
-
-      @value = case
-        when (not text_value(@raw).blank?)  : text_value(@raw)
-        when (not cdata_value(@raw).blank?) : cdata_value(@raw)
-        else ''
-      end
-    end
   end
-end
+end
+
+def XMLObject.adapter # :nodoc:
+  XMLObject::Adapters::Hpricot
+end

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

@@ -1,34 +1,35 @@
+require 'rexml/document'
+
 module XMLObject::Adapters::REXML
-  require 'rexml/document'
 
   # Can take a String of XML data, or anything that responds to
   # either +read+ or +to_s+.
   def self.new(duck)
     case
-      when duck.is_a?(::REXML::Element) : Element.new(duck)
-      when duck.is_a?(::String)    : new(::REXML::Document.new(duck).root)
-      when duck.respond_to?(:read) : new(duck.read)
-      when duck.respond_to?(:to_s) : new(duck.to_s)
+      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)
       else raise "Don't know how to deal with '#{duck.class}' object"
     end
   end
 
   private ##################################################################
 
-  class Element # :nodoc:
-    attr_reader :raw, :name, :value, :attributes, :children
-
+  class Element < XMLObject::Adapters::Base::Element # :nodoc:
     def initialize(xml)
-      @raw, @name, @attributes, @children = xml, xml.name, {}, []
-
-      @attributes = xml.attributes
-      xml.each_element { |e| @children << self.class.new(e) }
+      self.raw, self.name, self.attributes = xml, xml.name, xml.attributes
+      self.children = xml.elements.map { |raw_xml| self.class.new(raw_xml) }
 
-      @value = case
-        when (not xml.text.blank?)  : xml.text.to_s
-        when (xml.cdatas.size >= 1) : xml.cdatas.first.to_s
+      self.value = case
+        when (not xml.text.blank?) then xml.text.to_s
+        when (xml.cdatas.any?)     then xml.cdatas.first.to_s
         else ''
       end
     end
   end
 end
+
+def XMLObject.adapter # :nodoc:
+  XMLObject::Adapters::REXML
+end

data/lib/xml-object/adapters.rb

@@ -0,0 +1,9 @@
+module XMLObject # :nodoc:
+  module Adapters # :nodoc:
+    module Base # :nodoc:
+      class Element # :nodoc:
+        attr_accessor :raw, :name, :value, :attributes, :children # :nodoc:
+      end
+    end
+  end
+end

data/lib/xml-object/array_notation.rb

@@ -24,7 +24,7 @@ module XMLObject::ArrayNotation
     return @__target[name] if @__target && name.is_a?(Numeric)
 
     unless name.is_a? Hash
-      key = name.to_sym
+      key = name.to_s.to_sym
 
       return @__children[key]   if @__children.has_key?(key)
       return @__attributes[key] if @__attributes.has_key?(key)
@@ -33,10 +33,10 @@ module XMLObject::ArrayNotation
     raise 'one and only one key allowed' if name.size != 1
 
     case (param = name.keys.first.to_sym)
-      when :element   : @__children[name.values.first.to_sym]
-      when :child     : @__children[name.values.first.to_sym]
-      when :attr      : @__attributes[name.values.first.to_sym]
-      when :attribute : @__attributes[name.values.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!
     end

data/lib/xml-object/blankish_slate.rb

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

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

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

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

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

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

@@ -0,0 +1,19 @@
+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/core_ext.rb

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

data/lib/xml-object/element.rb

@@ -0,0 +1,21 @@
+module XMLObject::Element
+  def self.extended(obj) # :nodoc:
+    obj.instance_variable_set :@__children,   {}
+    obj.instance_variable_set :@__attributes, {}
+    obj
+  end
+
+  # The raw, unadapted XML object. Whatever this is, it really depends on
+  # the current_adapter.
+  def raw_xml
+    @__adapted_element.raw if @__adapted_element
+  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
+  end
+end

data/lib/xml-object/method_missing_dispatchers.rb

@@ -7,10 +7,10 @@ module XMLObject::MethodMissingDispatchers # :nodoc:
 
     method_sans_question = meth.to_s.chomp('?').to_sym
 
-    if boolish = __send__(method_sans_question).downcase
+    if boolish = __send__(method_sans_question)
       bool = case
-        when %w[ true yes t y ].include?(boolish) : true
-        when %w[ false no f n ].include?(boolish) : false
+        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
 
@@ -25,19 +25,19 @@ module XMLObject::MethodMissingDispatchers # :nodoc:
   def __dot_notation_dispatch(meth, *args, &block)
     return unless args.empty? && block.nil?
 
-    if @__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]
-
-    elsif @__children.has_key?(meth)
+    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?(singular = meth.to_s.singularize.to_sym) &&
+          @__children[singular].is_a?(Array)
+
+      instance_eval %{ def #{meth}; @__children[%s|#{singular}|]; end }
+      @__children[singular]
     end
   end
 end

data/lib/xml-object/string.rb

@@ -1,20 +1,17 @@
 module XMLObject::String
-  def self.extended(obj) # :nodoc:
-    obj.instance_variable_set :@__children,   {}
-    obj.instance_variable_set :@__attributes, {}
-    obj
-  end
 
   # Attempts to detect wether this String is really an integer or float,
   # and returns accordingly. If not, just returns the string.
   def rb
-    @__rb ||= case
-      when (self !~ /\S/)                          : ''
-      when match(/[a-zA-Z]/)                       : ::String.new(self)
-      when match(/^[+-]?\d+$/)                     : self.to_i
-      when match(/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)$/) : self.to_f
+    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
@@ -24,12 +21,4 @@ module XMLObject::String
   def blank?
     (self !~ /\S/) && @__children.blank? && @__attributes.blank?
   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
-  end
 end

data/lib/xml-object.rb

@@ -1,33 +1,28 @@
-require 'rubygems'
-require 'activesupport'
+begin; require 'rubygems';      rescue Exception, StandardError; nil; end
+begin; require 'activesupport'; rescue Exception, StandardError; nil; end
 
-module XMLObject
-
-  unless defined?(BASE_DIR) # Slow call
-    BASE_DIR = File.join(File.dirname(__FILE__), 'xml-object')
-  end
+module XMLObject # :nodoc:
+  VERSION = '0.9.6'
+end
 
-  require File.join(BASE_DIR, 'default_adapter')
-  require File.join(BASE_DIR, 'method_missing_dispatchers')
-  require File.join(BASE_DIR, 'array_notation')
-  require File.join(BASE_DIR, 'blankish_slate')
-  require File.join(BASE_DIR, 'collection_proxy')
-  require File.join(BASE_DIR, 'string')
+require 'core_ext'
 
-  def self.adapter=(adapter_module)
-    @adapter = adapter_module
-  end
-
-  def self.adapter
-    @adapter ||= Adapters::Default
-  end
+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
   # with methods to access attributes and/or child elements.
   def self.new(duck)
     case duck
-      when adapter::Element : new_decorated_obj(duck)
-      when Array            : duck.map { |d| new_decorated_obj(d) }
+      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
@@ -36,28 +31,29 @@ module XMLObject
 
   # Takes any Element object, and converts it recursively into
   # the corresponding tree of decorated objects.
-  def self.new_decorated_obj(xml)
+  def self.new_decorated_obj(xml) # :nodoc:
     obj = if xml.value.blank? &&
              xml.children.collect { |e| e.name }.uniq.size == 1
 
       CollectionProxy.new new(xml.children)
     else
-      xml.value.extend String # Teach our string to behave like XML
+      # Teach our string to behave like and XML Element
+      xml.value.extend String, Element
     end
 
-    obj.instance_variable_set :@__raw_xml, xml
+    obj.instance_variable_set :@__adapted_element, xml
 
     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).extend(MethodMissingDispatchers)
+    obj.extend ArrayNotation, MethodMissingDispatchers
   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)
+  def self.add_child(obj, name, element) # :nodoc:
     key      = name.to_sym
     children = obj.instance_variable_get :@__children
 

data/xml-object.gemspec

@@ -1,10 +1,9 @@
 Gem::Specification.new do |gem|
-  gem.add_dependency 'activesupport'
-
-  gem.name    = 'xml-object'
-  gem.version = '0.9.5'
-  gem.date    = '2008-10-15'
+  gem.rubyforge_project = 'xml-object'
 
+  gem.name     = 'xml-object'
+  gem.version  = '0.9.6'
+  gem.date     = '2008-10-19'
   gem.author   = 'Jordi Bunster'
   gem.email    = 'jordi@bunster.org'
   gem.homepage = 'http://github.com/jordi/xml-object'
@@ -26,10 +25,16 @@ Gem::Specification.new do |gem|
     lib/xml-object/adapters
     lib/xml-object/adapters/hpricot.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/default_adapter.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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: jordi-xml-object
 version: !ruby/object:Gem::Version 
-  version: 0.9.5
+  version: 0.9.6
 platform: ruby
 authors: 
 - Jordi Bunster
@@ -9,18 +9,10 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-10-15 00:00:00 -07:00
+date: 2008-10-19 00:00:00 -07:00
 default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: activesupport
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-    version: 
+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.
 email: jordi@bunster.org
 executables: []
@@ -40,10 +32,16 @@ files:
 - lib/xml-object/adapters
 - lib/xml-object/adapters/hpricot.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/default_adapter.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
@@ -73,7 +71,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   version: 
 requirements: []
 
-rubyforge_project: 
+rubyforge_project: xml-object
 rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2

data/lib/xml-object/default_adapter.rb

@@ -1,15 +0,0 @@
-module XMLObject # :nodoc:
-  module Adapters # :nodoc:
-    ADAPTERS_PATH = File.join(File.dirname(__FILE__), 'adapters')
-
-    Default = begin
-      require 'hpricot'
-      require File.join(ADAPTERS_PATH, 'hpricot')
-      Hpricot
-    rescue LoadError
-      require File.join(ADAPTERS_PATH, 'rexml')
-      REXML
-    end
-  end
-end
-