jordi-xml_struct 0.1.3 → 0.2.0

data/README.markdown

@@ -4,13 +4,12 @@
 
   XML Struct attempts to make accessing small, well-formed XML structures
 convenient, by using dot notation (`foo.bar`) to represent both attributes
-and child elements whenever possible, as well as by converting string values
-onto native objects (`Fixnum`, `Float`, etc).
+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 is a bit different.
+way. This one aims to be a bit different.
 
 ## Example usage
 
@@ -35,10 +34,10 @@ way. This one is a bit different.
     recipe = XMLStruct.new io_with_recipe_xml_shown_above
 
     recipe.name                      => "bread"
-    recipe.title == "Basic bread"    => true
+    recipe.title                     => "Basic bread"
 
     recipe.ingredients.is_a?(Array)  => true
-    recipe.ingredients.first.amount  => 8
+    recipe.ingredients.first.amount  => "8" # Not a Fixnum. Too hard. :(
 
     recipe.instructions.easy?        => true
 
@@ -101,9 +100,9 @@ level. For example:
   With the same file from the `Collection auto-folding` section above, you
 also get this (courtesy of `ActiveSupport`'s `Inflector`):
 
-    student.courses == student.course => true
+    student.courses.first == student.course.first => true
 
-### Collection proxy:
+### Collection proxy
 
   Sometimes, collections are expressed with a container element in XML:
 
@@ -121,25 +120,10 @@ all methods it doesn't contain to the collection below, so you get:
 
     student.courses.collect { |c| c.downcase.to_sym } => [:math, :biology]
 
-### Attribute auto "type-casting"
+### Question mark notation
 
-  Attribute strings that look like integers are promoted via `to_i`, and
-similarly floats via `to_f`. Strings that look like booleans are also
-promoted, but only if called by their question mark names (such as
-`enabled?`.)
-
-  At first, elements appear to do the same, but they don't, really. (I'd like
-to, but one can't define methods on, say `5`, or `-1.2`.) So in the case of
-the following XML:
-
-    <thing><name>Foo</name></thing>
-
-  While `thing.name == 'Foo'` is `true`, `thing.name => <XMLStruct ...>`. The
-consequence is that you can call `String` methods on `thing.name` (such as
-`upcase`, or `==`), but if you assign it to a new variable, you will not get
-a `String` object. To do that, call `thing.name.to_obj`, which will return
-you the auto type-casted (see above) version of `thing.name`, in this case
-`"Foo"`.
+  Strings that look like booleans are "booleanized" if called by their
+question mark names (such as `enabled?`)
 
 ### Slow
 

data/TODO

@@ -1,4 +1,3 @@
 * Make use of libxml if it's available, then fallback to REXML
 * Refactor so as to not do things recursively
-* Detect more types, such as dates and timestamps
 * Remove ActiveSupport dependency

data/WHATSNEW

@@ -1,3 +1,13 @@
+* 0.2.0 (2008-10-13):
+  - Broke backwards compatibility
+  - XMLRecord.new now returns decorated String or Array objects, so that
+    access to elements, attributes, and "collection" values is consistent
+  - While Strings are no longer auto-typecast to float or int, they now
+    have, whenever possible, a question-mark form, which attemps to
+    returns booleans for strings like "Yes" and "false"
+  - XMLRecord.new can now take a filename or a file object
+  - Added more tests
+
 * 0.1.3 (2008-10-10):
   - Switched tests to use test/spec
   - Added XMLStruct#to_obj to return the corresponding Ruby object value

data/lib/xml_struct.rb

@@ -2,156 +2,94 @@ require 'rubygems'
 require 'activesupport'
 require 'rexml/document'
 
-class XMLStruct
+module XMLStruct; end
 
-  include Comparable
+require File.join(File.dirname(__FILE__), 'xml_struct', 'blankish_slate')
+require File.join(File.dirname(__FILE__), 'xml_struct', 'collection_proxy')
+require File.join(File.dirname(__FILE__), 'xml_struct', 'string')
+require File.join(File.dirname(__FILE__), 'xml_struct', 'common_behaviours')
 
-  # Returns an XMLStruct object
+module XMLStruct
+
+  # Returns a String or Array object representing the given XML, decorated
+  # with methods to access attributes and/or child elements.
   def self.new(duck)
-    duck.is_a?(REXML::Element) ? super : new(REXML::Document.new(duck).root)
+    case duck
+      when ::String        : return new(File.open(duck))
+      when ::IO            : return new(REXML::Document.new(duck).root)
+      when REXML::Element  : return new_decorated_obj(duck)
+      when REXML::Elements : return duck.map { |dee| new_decorated_obj(dee) }
+      else raise "Don't know how to start from '#{duck.class}' object."
+    end
   end
 
   # Takes any REXML::Element object, and converts it recursively into
-  # the corresponding tree of XMLStruct objects
-  def initialize(raw)
-    @attributes, @children, @raw = {}, {}, raw
-    @value = __get_value_from_raw_element @raw
-
-    @raw.each_element    { |el|   __set_child el.name, self.class.new(el) }
-    @raw.attributes.each { |n, v| __set_attribute n, v                    }
-  end
-
-  # Returns the raw REXML::Element object used to build this XMLStruct
-  def to_raw_xml
-    @raw
-  end
-
-  # Returns the Ruby value to which we pass missing methods
-  def to_obj
-    @value
-  end
-
-  # An XMLStruct is blank when it has a blank value, no child elements,
-  # and no attributes. For example:
-  #
-  #    <blank_element></blank_element>
-  def blank?
-    to_obj.blank? && @children.blank? && @attributes.blank?
-  end
-
-  # XMLStruct objects are compared according to their values
-  def <=>(other)
-    to_obj <=> other
-  end
-
-  # Array-notation access to elements and attributes. It comes handy 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 hash keys, which are useful to reach attributes named
-  # the same as elements in the same level (which are otherwise prioritized)
-  #
-  # All of this is a lot easier to exampling by example:
-  #
-  #   <article id="main_article" author="j-random">
-  #     <author>J. Random Hacker</author>
-  #   </article>
-  #
-  #   article.id                 => 9314390         # Object#id gets called
-  #   article[:id]               => "main_article"  # id attribute
-  #   article[:author]           => <XMLStruct ...> # <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)
-    unless name.is_a? Hash
-      return @children[name.to_sym]   if @children[name.to_sym]
-      return @attributes[name.to_sym] if @attributes[name.to_sym]
-    end
-
-    raise 'one and only one key allowed' if name.size != 1
+  # the corresponding tree of decorated objects.
+  def self.new_decorated_obj(xml)
+    obj = if xml.text.blank? &&
+             xml.elements.map { |e| e.name }.uniq.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]
-      else raise %{ Invalid key :#{param.to_s}.
-        Use one of :element, :child, :attr, or :attribute }.squish!
+      CollectionProxy.new new(xml.elements)
+    else
+      case
+        when (not xml.text.blank?)  : xml.text.to_s
+        when (xml.cdatas.size >= 1) : xml.cdatas.first.to_s
+        else ''
+      end.extend String
     end
-  end
-
-  def method_missing(method, *args, &block) # :nodoc:
-
-    if method.to_s.match(/\?$/) && args.empty? && block.nil?
-      boolish = send(method.to_s.chomp('?').to_sym).to_s
 
-      %w[ true yes t y ].include? boolish.downcase
+    obj.instance_variable_set :@__raw_xml, xml
 
-    elsif to_obj.blank? && (@children.size == 1) &&
-      (single_child = @children.values.first).respond_to?(method)
-
-      single_child.send method, *args, &block
-    else
-      to_obj.send method, *args, &block
-    end
-  end
+    xml.each_element    { |child| add_child(obj, child.name, new(child)) }
+    xml.attributes.each { |name, value|  add_attribute(obj, name, value) }
 
-  def inspect # :nodoc:
-    %{ #<#{self.class.to_s} value=#{to_obj.inspect} (#{to_obj.class.to_s})
-         attributes=[#{@attributes.keys.map(&:to_s).join(', ') }]
-         children=[#{@children.keys.map(&:to_s).join(', ')     }]> }.squish
+    obj.extend CommonBehaviours
   end
 
-  private
+  private ##################################################################
 
-  def __set_child(name, element) # :nodoc:
-    key = name.to_sym
+  # 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)
+    key      = name.to_sym
+    children = obj.instance_variable_get :@__children
 
-    @children[key] = if @children[key]
+    children[key] = if children[key]
 
-      unless respond_to?((plural_key = key.to_s.pluralize).to_sym)
-        instance_eval %{ def #{plural_key}; @children[:#{key.to_s}]; end }
+      unless obj.respond_to?((plural_key = key.to_s.pluralize).to_sym)
+        obj.instance_eval %{
+          def #{plural_key}; @__children[:#{key.to_s}]; end }
       end
 
-      @children[key] = [ @children[key] ] unless @children[key].is_a? Array
-      @children[key] << element
+      children[key] = [ children[key] ] unless children[key].is_a? Array
+      children[key] << element
     else
-      unless respond_to? key
-        instance_eval %{ def #{key.to_s}; @children[:#{key.to_s}]; end }
+      unless obj.respond_to? key
+        obj.instance_eval %{
+          def #{key.to_s}; @__children[:#{key.to_s}]; end }
       end
 
       element
     end
-  end
 
-  def __set_attribute(name, attribute) # :nodoc:
-    obj = __get_object_from_string(attribute)
-    @attributes[(key = name.to_sym)] = obj.is_a?(String) ? obj.squish : obj
-
-    unless respond_to? key
-      instance_eval %{ def #{key.to_s}; @attributes[:#{key.to_s}]; end }
-    end
+    obj.instance_variable_set :@__children, children
+    element
   end
 
-  def __get_value_from_raw_element(raw) # :nodoc:
-    str = case
-      when raw.has_text? && !raw.text.blank? : raw.text
-      else (raw.cdatas.first.to_s rescue '')
-    end
+  # Decorates the given object 'obj' with a method 'name' that returns the
+  # given 'attr_value'.
+  def self.add_attribute(obj, name, attr_value) # :nodoc:
 
-    __get_object_from_string str
-  end
+    attributes = obj.instance_variable_get :@__attributes
+    attributes[(key = name.to_sym)] = attr_value.squish.extend String
 
-  def __get_object_from_string(str) # :nodoc:
-    case
-      when str.blank?              : nil
-      when str.match(/[a-zA-Z]/)   : str
-      when str.match(/^[+-]?\d+$/) : str.to_i
-      when str.match(/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)$/) : str.to_f
-      else str
+    unless obj.respond_to? key
+      obj.instance_eval %{
+        def #{key.to_s}; @__attributes[:#{key.to_s}]; end }
     end
+
+    obj.instance_variable_set :@__attributes, attributes
+    attr_value
   end
 end

data/lib/xml_struct/blankish_slate.rb

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

data/lib/xml_struct/collection_proxy.rb

@@ -0,0 +1,10 @@
+class XMLStruct::CollectionProxy < XMLStruct::BlankishSlate
+  def initialize(target)
+    @__children, @__attributes, @__target = {}, {}, target
+  end
+
+  def method_missing(m, *a, &b) # :nodoc:
+    answer = __question_answer(m, *a, &b)
+    answer.nil? ? (@__target.__send__(m, *a, &b) if @__target) : answer
+  end
+end

data/lib/xml_struct/common_behaviours.rb

@@ -0,0 +1,53 @@
+module XMLStruct::CommonBehaviours
+
+  # Detect an existing method being called in question form:
+  def __question_answer(method, *args, &block)
+    if method.to_s.match(/\?$/) && args.empty? && block.nil?
+      boolish = __send__(method.to_s.chomp('?').to_sym).to_s
+
+      return true  if %w[ true yes t y ].include? boolish.downcase
+      return false if %w[ false no f n ].include? boolish.downcase
+    end
+  end
+
+  # Array-notation access to elements and attributes. It comes handy 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 hash keys, which are useful to reach attributes named
+  # the same as elements in the same level (which otherwise go first)
+  #
+  # All of this is a lot easier to exampling by example:
+  #
+  #   <article id="main_article" author="j-random">
+  #     <author>J. Random Hacker</author>
+  #   </article>
+  #
+  #   article.id                 => 9314390         # Object#id gets called
+  #   article[:id]               => "main_article"  # id attribute
+  #   article[:author]           => <XMLStruct ...> # <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)
+
+    unless name.is_a? Hash
+      return @__children[name.to_sym]   if @__children[name.to_sym]
+      return @__attributes[name.to_sym] if @__attributes[name.to_sym]
+    end
+
+    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]
+      else raise %{ Invalid key :#{param.to_s}.
+        Use one of :element, :child, :attr, or :attribute }.squish!
+    end
+  end
+end

data/lib/xml_struct/string.rb

@@ -0,0 +1,31 @@
+module XMLStruct::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/)                          : nil
+      when match(/[a-zA-Z]/)                       : ::String.new(self)
+      when match(/^[+-]?\d+$/)                     : self.to_i
+      when match(/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)$/) : self.to_f
+      else ::String.new(self)
+    end
+  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
+
+  def method_missing(m, *a, &b) # :nodoc:
+    __question_answer(m, *a, &b)
+  end
+end

data/test/samples/lorem.xml

@@ -5,7 +5,7 @@
 
   <!-- unambiguous element/attribute access test -->
   <sed do="eiusmod attributus">
-    <do>eiusmod elementus</do>
+    <do price="$8">eiusmod elementus</do>
   </sed>
 
   <!-- Blank test -->

data/test/samples/recipe.xml

@@ -0,0 +1,16 @@
+<recipe name="bread" prep_time="5 mins" cook_time="3 hours">
+  <title>Basic bread</title>
+  <ingredient amount="8" unit="dL">Flour</ingredient>
+  <ingredient amount="10" unit="grams">Yeast</ingredient>
+  <ingredient amount="4" unit="dL" state="warm">Water</ingredient>
+  <ingredient amount="1" unit="teaspoon">Salt</ingredient>
+  <instructions easy="yes" hard="false">
+    <step>Mix all ingredients together.</step>
+    <step>Knead thoroughly.</step>
+    <step>Cover with a cloth, and leave for one hour in warm room.</step>
+    <step>Knead again.</step>
+    <step>Place in a bread baking tin.</step>
+    <step>Cover with a cloth, and leave for one hour in warm room.</step>
+    <step>Bake in the oven at 180(degrees)C for 30 minutes.</step>
+  </instructions>
+</recipe>

data/test/test_helper.rb

@@ -23,7 +23,8 @@ def xml_file(name_symbol)
 end
 
 require 'digest/md5'
-{ :lorem => '6dc88e269000db3be599fca3367e2aa5' }.each do |file_key, md5|
+{ :lorem  => '9062c0f294383435d5b04ce6d67b6d61',
+  :recipe => '6087ab42049273d123d473093b04ab12' }.each do |file_key, md5|
 
   unless Digest::MD5.hexdigest(xml_file(file_key).read) == md5
     raise "Sample test file #{file_key.to_s}.xml doesn't match expected MD5"

data/test/xml_struct_test.rb

@@ -1,5 +1,50 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
+describe 'The XML Struct module' do
+
+  def setup
+    @filename = File.join(File.dirname(__FILE__), 'samples', 'recipe.xml')
+    @file     = File.open @filename
+    @recipe   = XMLStruct.new xml_file(:recipe)
+  end
+
+  it 'should know how to run "new" with a filename given' do
+    XMLStruct.new(@filename).name.should == @recipe.name
+  end
+
+  it 'should know how to run "new" with a file given' do
+    XMLStruct.new(@file).name.should == @recipe.name
+  end
+
+  it 'should raise an exception when given something else to "new"' do
+    should.raise(RuntimeError) { XMLStruct.new(8) }
+  end
+end
+
+describe 'README Recipe' do
+
+  def setup
+    @recipe = XMLStruct.new xml_file(:recipe)
+  end
+
+  it 'should have name and title as "bread" and "Basic bread"' do
+    @recipe.name.should  == "bread"
+    @recipe.title.should == "Basic bread"
+  end
+
+  it 'should treat "recipe.ingredients" as an Array' do
+    @recipe.ingredients.is_a?(Array).should.be true
+    @recipe.ingredients.first.amount.to_i.should == 8
+  end
+
+  it 'should have 7 easy instructions' do
+    @recipe.instructions.easy?.should.be true
+    @recipe.instructions.steps.size.should == 7
+    @recipe.instructions.first.upcase.should ==
+      "MIX ALL INGREDIENTS TOGETHER."
+  end
+end
+
 describe 'XML Struct' do
 
   include RubyProf::Test if defined? RubyProf::Test
@@ -8,18 +53,18 @@ describe 'XML Struct' do
     @lorem = XMLStruct.new xml_file(:lorem)
   end
 
-  it 'should be an XMLStruct' do
-    @lorem.should.be.an.instance_of XMLStruct
+  it 'should be an instance of XMLStruct::String' do
+    @lorem.should.be.an.instance_of ::String
   end
 
-  it 'should be blank if devoid of children, attributes and value' do
+  it 'be blank if devoid of children, attributes and value' do
     @lorem.ipsum.should.be.blank
   end
 
-  it 'should not be blank when value, children, or attributes are present' do
-    @lorem.dolor.should.not.be.blank
-    @lorem.sit.should.not.be.blank
-    @lorem.ut.should.not.be.blank
+  it 'not be blank when value, children, or attributes are present' do
+    [ @lorem.dolor, @lorem.sit, @lorem.ut ].each do |xr|
+      xr.should.not.be.blank
+    end
   end
 
   it 'should allow access to attributes named like invalid methods' do
@@ -27,11 +72,11 @@ describe 'XML Struct' do
   end
 
   it 'should allow access to elements named like invalid methods' do
-    'veniam'.should == @lorem['_minim']
+    @lorem['_minim'].should == 'veniam'
   end
 
   it 'should provide unambiguous access to elements named like attributes' do
-    'eiusmod elementus'.should == @lorem.sed[:element => 'do']
+    @lorem.sed[:element => 'do'].should == 'eiusmod elementus'
   end
 
   it 'should provide unambiguous access to attributes named like elements' do
@@ -39,18 +84,18 @@ describe 'XML Struct' do
   end
 
   it 'should return elements first when using dot notation' do
-    @lorem.sed[:element => 'do'].should == @lorem.sed.do
+    @lorem.sed.do.should == @lorem.sed[:element => 'do']
   end
 
-  it 'should return elements first when using array notation and string key' do
+  it 'should return elements first when using [] with string key' do
     @lorem.sed['do'].should == @lorem.sed[:element => 'do']
   end
 
-  it 'should return elements first when using array notation and symbol key' do
+  it 'should return elements first when using [] with symbol key' do
     @lorem.sed[:do].should == @lorem.sed[:element => 'do']
   end
 
-  it 'should raise exception when unkown keys are used in hash-in-array mode' do
+  it 'should raise exception when unkown keys are used in [{}] mode' do
     should.raise(RuntimeError) { @lorem[:foo => 'bar'] }
   end
 
@@ -68,16 +113,21 @@ describe 'XML Struct' do
 
   it 'should convert integer-looking attribute strings to integers' do
     @lorem.consecteturs.each do |c|
-      c['id'].is_a?(Numeric).should.be true
+      c['id'].rb.is_a?(Numeric).should.be true
     end
   end
 
   it 'should convert float-looking attribute strings to floats' do
     @lorem.consecteturs.each do |c|
-      c.capacity.is_a?(Float).should.be true
+      c.capacity.rb.is_a?(Float).should.be true
     end
   end
 
+  it 'should not convert strings with more than numbers to Fixnum' do
+    @lorem.sed.do.price.rb.should == @lorem.sed.do.price
+    @lorem.sed.do.price.rb.should.not == 8
+  end
+
   it 'should convert bool-looking attribute strings to bools when asked' do
     @lorem.consecteturs.each { |c| c.enabled?.should == !!(c.enabled?) }
   end
@@ -88,31 +138,31 @@ describe 'XML Struct' do
   end
 
   it 'should pass forth methods to single array child when empty valued' do
-    @lorem.cupidatats.slice(0).should.be @lorem.cupidatats.cupidatat.slice(0)
+    @lorem.cupidatats[0].should == @lorem.cupidatats.cupidatat[0]
   end
 
   it 'should not pass methods to single array child if not empty valued' do
-    @lorem.voluptate.slice(0).should.not.be @lorem.voluptate.esse.slice(0)
+    should.raise(RuntimeError) { @lorem.voluptate[0] }
   end
 
   it 'should be valued as its text when text first and CDATA exist' do
-    'Laboris'.should == @lorem.ullamco
+    @lorem.ullamco.should == 'Laboris'
   end
 
   it 'should have the value of its first CDATA when multiple exist' do
-    'mollit'.should == @lorem.deserunt
+    @lorem.deserunt.should == 'mollit'
   end
 
   it 'should squish whitespace in string attribute values' do
-    'dolor'.should == @lorem.irure.metadata
+    @lorem.irure.metadata.should == 'dolor'
   end
 
   it 'should not squish whitespace in string element values' do
-    "  \n\t\t\treprehenderit  ".should == @lorem.irure
+    @lorem.irure.should == "  \n\t\t\treprehenderit  "
   end
 
   it 'should not squish whitespace in CDATA values' do
-    "\t foo\n".should == @lorem
+    @lorem.should == "\t foo\n"
   end
 
   it 'should have a working inspect function' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: jordi-xml_struct
 version: !ruby/object:Gem::Version 
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors: 
 - Jordi Bunster
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-10-10 00:00:00 -07:00
+date: 2008-10-13 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -37,8 +37,12 @@ files:
 - WHATSNEW
 - lib
 - lib/jordi-xml_struct.rb
+- lib/xml_struct
+- lib/xml_struct/blankish_slate.rb
+- lib/xml_struct/collection_proxy.rb
+- lib/xml_struct/common_behaviours.rb
+- lib/xml_struct/string.rb
 - lib/xml_struct.rb
-- xml_struct.gemspec
 has_rdoc: true
 homepage: http://github.com/jordi/xml_struct
 post_install_message: 
@@ -70,6 +74,7 @@ test_files:
 - test
 - test/samples
 - test/samples/lorem.xml
+- test/samples/recipe.xml
 - test/test_helper.rb
 - test/vendor
 - test/vendor/test-spec

data/xml_struct.gemspec

@@ -1,69 +0,0 @@
-Gem::Specification.new do |s|
-  s.name        = 'xml_struct'
-  s.version     = '0.1.3'
-  s.date        = '2008-10-10'
-
-  s.author      = 'Jordi Bunster'
-  s.email       = 'jordi@bunster.org'
-  s.homepage    = 'http://github.com/jordi/xml_struct'
-
-  s.add_dependency 'activesupport', '>= 2.1.1'
-
-  s.summary     = "The Rubyista's way to do quick XML sit-ups"
-  s.description = %{ This 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.
-
-                     It is slow and not devoid of caveats, but has a very
-                     pleasant, Ruby-like syntax. }.strip!.gsub! /\s+/, ' '
-
-  s.test_files  = %w[ test
-                      test/samples
-                      test/samples/lorem.xml
-                      test/test_helper.rb
-                      test/vendor
-                      test/vendor/test-spec
-                      test/vendor/test-spec/bin
-                      test/vendor/test-spec/bin/specrb
-                      test/vendor/test-spec/examples
-                      test/vendor/test-spec/examples/stack.rb
-                      test/vendor/test-spec/examples/stack_spec.rb
-                      test/vendor/test-spec/lib
-                      test/vendor/test-spec/lib/test
-                      test/vendor/test-spec/lib/test/spec
-                      test/vendor/test-spec/lib/test/spec/dox.rb
-                      test/vendor/test-spec/lib/test/spec/rdox.rb
-                      test/vendor/test-spec/lib/test/spec/should-output.rb
-                      test/vendor/test-spec/lib/test/spec/version.rb
-                      test/vendor/test-spec/lib/test/spec.rb
-                      test/vendor/test-spec/Rakefile
-                      test/vendor/test-spec/README
-                      test/vendor/test-spec/ROADMAP
-                      test/vendor/test-spec/SPECS
-                      test/vendor/test-spec/test
-                      test/vendor/test-spec/test/spec_dox.rb
-                      test/vendor/test-spec/test/spec_flexmock.rb
-                      test/vendor/test-spec/test/spec_mocha.rb
-                      test/vendor/test-spec/test/spec_nestedcontexts.rb
-                      test/vendor/test-spec/test/spec_new_style.rb
-                      test/vendor/test-spec/test/spec_should-output.rb
-                      test/vendor/test-spec/test/spec_testspec.rb
-                      test/vendor/test-spec/test/spec_testspec_order.rb
-                      test/vendor/test-spec/test/test_testunit.rb
-                      test/vendor/test-spec/TODO
-                      test/xml_struct_test.rb ]
-
-  s.files = %w[ MIT-LICENSE
-                README.markdown
-                Rakefile
-                TODO
-                WHATSNEW
-                lib
-                lib/jordi-xml_struct.rb
-                lib/xml_struct.rb
-                xml_struct.gemspec ]
-
-  s.has_rdoc         = true
-  s.extra_rdoc_files = %w[ README.markdown        ]
-  s.rdoc_options     = %w[ --main README.markdown ]
-end