roxml 3.1.2 → 3.1.3

data/History.txt

@@ -1,3 +1,17 @@
+== 3.1.3 (October 30, 2009)
+
+* minor enhancements
+
+  * Add support for local-name() reference reading via :namespace => '*'
+    (ala http://techrageo.us/2008/11/01/wildcard-namespaces-in-xpath/)
+
+* bug fixes
+
+  * attributes collected :as => [] were previously output improperly,
+    as a single attribute on a single node
+  * don't output crazy, context-less namespaces and local-name xpaths
+    when trying to output namespaced attributes
+
 == 3.1.2 (October 18, 2009)
 
 * minor enhancements

data/README.rdoc

@@ -95,7 +95,9 @@ in this case.
 
 === Namespace Support
 
-Namespaces are supported via the xml_namespace declaration and the :from and :namespace attr options.  See spec/xml/namespace_spec.rb for usage.
+Namespaced nodes are supported via the xml_namespace and xml_namespaces declarations and the :from and :namespace attr options.  See spec/xml/namespace_spec.rb for usage.
+
+Note that ROXML does not currently support outputting namespaced nodes.  This is planned for a future version.
 
 == Manipulation
 

data/TODO

@@ -2,6 +2,8 @@ Planned:
 
 v 3.2
 
+  * Support outputting namespaced attrs
+
   * Consider class_inheritable_attribute rather than superclass.try stuff.
 
   * Do some benchmarking

data/VERSION

@@ -1 +1 @@
-3.1.2
+3.1.3

data/lib/roxml.rb

@@ -5,7 +5,7 @@ require 'roxml/definition'
 require 'roxml/xml'
 
 module ROXML # :nodoc:
-  VERSION = '3.1.1'
+  VERSION = '3.1.3'
 
   def self.included(base) # :nodoc:
     base.class_eval do
@@ -22,6 +22,7 @@ module ROXML # :nodoc:
     # Returns an XML object representing this object
     def to_xml(params = {})
       params.reverse_merge!(:name => self.class.tag_name, :namespace => self.class.roxml_namespace)
+      params[:namespace] = nil if ['*', 'xmlns'].include?(params[:namespace])
       XML::Node.create([params[:namespace], params[:name]].compact.join(':')).tap do |root|
         refs = (self.roxml_references.present? \
           ? self.roxml_references \

data/lib/roxml/definition.rb

@@ -15,7 +15,7 @@ module ROXML
   end
 
   class Definition # :nodoc:
-    attr_reader :name, :type, :wrapper, :hash, :blocks, :accessor, :to_xml, :attr_name, :namespace
+    attr_reader :name, :sought_type, :wrapper, :hash, :blocks, :accessor, :to_xml, :attr_name, :namespace
     bool_attr_reader :name_explicit, :array, :cdata, :required, :frozen
 
     def initialize(sym, opts = {}, &block)
@@ -43,9 +43,9 @@ module ROXML
       @array = opts[:as].is_a?(Array)
       @blocks = collect_blocks(block, opts[:as])
 
-      @type = extract_type(opts[:as])
-      if @type.respond_to?(:roxml_tag_name)
-        opts[:from] ||= @type.roxml_tag_name
+      @sought_type = extract_type(opts[:as])
+      if @sought_type.respond_to?(:roxml_tag_name)
+        opts[:from] ||= @sought_type.roxml_tag_name
       end
 
       if opts[:from] == :content
@@ -53,12 +53,12 @@ module ROXML
       elsif opts[:from] == :name
         opts[:from] = '*'
       elsif opts[:from] == :attr
-        @type = :attr
+        @sought_type = :attr
         opts[:from] = nil
       elsif opts[:from] == :name
         opts[:from] = '*'
       elsif opts[:from].to_s.starts_with?('@')
-        @type = :attr
+        @sought_type = :attr
         opts[:from].sub!('@', '')
       end
 
@@ -83,13 +83,13 @@ module ROXML
 
     def hash
       if hash?
-        @type.wrapper ||= name
-        @type
+        @sought_type.wrapper ||= name
+        @sought_type
       end
     end
 
     def hash?
-      @type.is_a?(HashDefinition)
+      @sought_type.is_a?(HashDefinition)
     end
 
     def name?
@@ -109,11 +109,11 @@ module ROXML
     end
 
     def to_ref(inst)
-      case type
+      case sought_type
       when :attr          then XMLAttributeRef
       when :text          then XMLTextRef
       when HashDefinition then XMLHashRef
-      when Symbol         then raise ArgumentError, "Invalid type argument #{type}"
+      when Symbol         then raise ArgumentError, "Invalid type argument #{sought_type}"
       else                     XMLObjectRef
       end.new(self, inst)
     end

data/lib/roxml/xml/references.rb

@@ -7,24 +7,22 @@ module ROXML
   #
   class XMLRef # :nodoc:
     attr_reader :opts
-    delegate :required?, :array?, :blocks, :accessor, :default, :wrapper, :to => :opts
+    delegate :required?, :array?, :accessor, :default, :wrapper, :to => :opts
 
     def initialize(opts, instance)
       @opts = opts
       @instance = instance
     end
 
+    def blocks
+      opts.blocks || []
+    end
+
     def to_xml(instance)
       val = instance.__send__(accessor)
       opts.to_xml.respond_to?(:call) ? opts.to_xml.call(val) : val
     end
 
-    def update_xml(xml, value)
-      returning wrap(xml) do |xml|
-        write_xml(xml, value)
-      end
-    end
-
     def name
       opts.name_explicit? ? opts.name : conventionize(opts.name)
     end
@@ -52,14 +50,12 @@ module ROXML
     end
 
     def namespacify(what)
-      return "#{opts.namespace}:#{what}" if opts.namespace
-
-      namespace = @instance.class.roxml_namespace || @default_namespace
-      if namespace && what.present? && !what.include?(':') && (opts.namespace != false)
-        "#{namespace}:#{what}"
-      else
-        what
+      if what.to_s.present? && !what.to_s.include?(':') && opts.namespace != false
+        [opts.namespace, @instance.class.roxml_namespace, @default_namespace].each do |namespace|
+          return opts.namespace == '*' ? "*[local-name()='#{what}']" : "#{namespace}:#{what}" if namespace
+        end
       end
+      what
     end
 
     def apply_blocks(val)
@@ -95,11 +91,11 @@ module ROXML
       array?
     end
 
-    def wrap(xml)
+    def wrap(xml, opts = {:always_create => false})
       wrap_with = @auto_vals ? auto_wrapper : wrapper
 
       return xml if !wrap_with || xml.name == wrap_with
-      if child = xml.children.find {|c| c.name == wrap_with }
+      if !opts[:always_create] && (child = xml.children.find {|c| c.name == wrap_with })
        return child
       end
       xml.add_child(XML::Node.create(wrap_with.to_s))
@@ -134,13 +130,23 @@ module ROXML
   #   XMLTextRef
   #  </element>
   class XMLAttributeRef < XMLRef # :nodoc:
-  private
     # Updates the attribute in the given XML block to
     # the value provided.
-    def write_xml(xml, value)
-      xml.attributes[name] = value.to_s
+    def update_xml(xml, values)
+      if array?
+        values.each do |value|
+          wrap(xml, :always_create => true).tap do |node|
+            node.attributes[name] = value.to_s
+          end
+        end
+      else
+        wrap(xml).tap do |xml|
+          xml.attributes[name] = values.to_s
+        end
+      end
     end
 
+  private
     def fetch_value(xml)
       nodes_in(xml) do |node|
         node.value
@@ -161,23 +167,25 @@ module ROXML
   class XMLTextRef < XMLRef # :nodoc:
     delegate :cdata?, :content?, :name?, :to => :opts
 
-  private
     # Updates the text in the given _xml_ block to
     # the _value_ provided.
-    def write_xml(xml, value)
-      if content?
-        add(xml, value)
-      elsif name?
-        xml.name = value
-      elsif array?
-        value.each do |v|
-          add(xml.add_child(XML::Node.create(xpath_name)), v)
+    def update_xml(xml, value)
+      wrap(xml).tap do |xml|
+        if content?
+          add(xml, value)
+        elsif name?
+          xml.name = value
+        elsif array?
+          value.each do |v|
+            add(xml.add_child(XML::Node.create(name)), v)
+          end
+        else
+          add(xml.add_child(XML::Node.create(name)), value)
         end
-      else
-        add(xml.add_child(XML::Node.create(xpath_name)), value)
       end
     end
 
+  private
     def fetch_value(xml)
       if content? || name?
         value =
@@ -222,17 +230,19 @@ module ROXML
       true
     end
 
-  private
     # Updates the composed XML object in the given XML block to
     # the value provided.
-    def write_xml(xml, value)
-      value.each_pair do |k, v|
-        node = xml.add_child(XML::Node.create(hash.wrapper))
-        @key.update_xml(node, k)
-        @value.update_xml(node, v)
+    def update_xml(xml, value)
+      wrap(xml).tap do |xml|
+        value.each_pair do |k, v|
+          node = xml.add_child(XML::Node.create(hash.wrapper))
+          @key.update_xml(node, k)
+          @value.update_xml(node, v)
+        end
       end
     end
 
+  private
     def fetch_value(xml)
       nodes_in(xml) do |node|
         [@key.value_in(node), @value.value_in(node)]
@@ -270,32 +280,34 @@ module ROXML
   end
 
   class XMLObjectRef < XMLTextRef # :nodoc:
-    delegate :type, :to => :opts
+    delegate :sought_type, :to => :opts
 
-  private
     # Updates the composed XML object in the given XML block to
     # the value provided.
-    def write_xml(xml, value)
-      params = {:name => name, :namespace => opts.namespace}
-      if array?
-        value.each do |v|
-          xml.add_child(v.to_xml(params))
+    def update_xml(xml, value)
+      wrap(xml).tap do |xml|
+        params = {:name => name, :namespace => opts.namespace}
+        if array?
+          value.each do |v|
+            xml.add_child(v.to_xml(params))
+          end
+        elsif value.is_a?(ROXML)
+          xml.add_child(value.to_xml(params))
+        else
+          node = XML::Node.create(name)
+          node.content = value.to_xml
+          xml.add_child(node)
         end
-      elsif value.is_a?(ROXML)
-        xml.add_child(value.to_xml(params))
-      else
-        node = XML::Node.create(xpath_name)
-        node.content = value.to_xml
-        xml.add_child(node)
       end
     end
 
+  private
     def fetch_value(xml)
       nodes_in(xml) do |node|
-        if type.respond_to? :from_xml
-          type.from_xml(node)
+        if sought_type.respond_to? :from_xml
+          sought_type.from_xml(node)
         else
-          type.new(node)
+          sought_type.new(node)
         end
       end
     end

data/roxml.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{roxml}
-  s.version = "3.1.2"
+  s.version = "3.1.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Ben Woosley", "Zak Mandhro", "Anders Engstrom", "Russ Olsen"]
-  s.date = %q{2009-10-18}
+  s.date = %q{2009-10-30}
   s.description = %q{ROXML is a Ruby library designed to make it easier for Ruby developers to work with XML.
 Using simple annotations, it enables Ruby classes to be mapped to XML. ROXML takes care
 of the marshalling and unmarshalling of mapped attributes so that developers can focus on
@@ -30,7 +30,6 @@ RESTful applications, Web Services, and XML-RPC.
      "Rakefile",
      "TODO",
      "VERSION",
-     "config/website.yml",
      "examples/amazon.rb",
      "examples/current_weather.rb",
      "examples/dashed_elements.rb",
@@ -69,7 +68,9 @@ RESTful applications, Web Services, and XML-RPC.
      "spec/xml/attributes_spec.rb",
      "spec/xml/namespace_spec.rb",
      "spec/xml/namespaces_spec.rb",
+     "spec/xml/object_spec.rb",
      "spec/xml/parser_spec.rb",
+     "spec/xml/text_spec.rb",
      "tasks/rdoc.rake",
      "tasks/rspec.rake",
      "tasks/test.rake",
@@ -147,7 +148,9 @@ RESTful applications, Web Services, and XML-RPC.
      "spec/xml/attributes_spec.rb",
      "spec/xml/namespace_spec.rb",
      "spec/xml/namespaces_spec.rb",
+     "spec/xml/object_spec.rb",
      "spec/xml/parser_spec.rb",
+     "spec/xml/text_spec.rb",
      "test/load_test.rb",
      "test/mocks/dictionaries.rb",
      "test/mocks/mocks.rb",

data/spec/definition_spec.rb

@@ -87,7 +87,7 @@ describe ROXML::Definition do
       it "should means array of texts" do
         opts = ROXML::Definition.new(:authors, :as => [])
         opts.array?.should be_true
-        opts.type.should == :text
+        opts.sought_type.should == :text
       end
     end
 
@@ -98,7 +98,7 @@ describe ROXML::Definition do
 
       it "should store type" do
         opts = ROXML::Definition.new(:name, :as => RoxmlClass)
-        opts.type.should == RoxmlClass
+        opts.sought_type.should == RoxmlClass
       end
     end
 
@@ -111,7 +111,7 @@ describe ROXML::Definition do
 
       it "should accept type" do
         opts = ROXML::Definition.new(:name, :as => OctalInteger)
-        opts.type.should == OctalInteger
+        opts.sought_type.should == OctalInteger
       end
     end
 
@@ -134,8 +134,8 @@ describe ROXML::Definition do
         end
 
         it "should have hash definition" do
-          {@opts.hash.key.type => @opts.hash.key.name}.should == @hash_args[:key]
-          {@opts.hash.value.type => @opts.hash.value.name}.should == @hash_args[:value]
+          {@opts.hash.key.sought_type => @opts.hash.key.name}.should == @hash_args[:key]
+          {@opts.hash.value.sought_type => @opts.hash.value.name}.should == @hash_args[:value]
         end
 
         it "should not represent an array" do
@@ -196,7 +196,7 @@ describe ROXML::Definition do
         end
 
         it "should be normal otherwise" do
-          @opts.type.should == :text
+          @opts.sought_type.should == :text
           @opts.blocks.size.should == 1
         end
       end
@@ -392,7 +392,7 @@ describe ROXML::Definition do
   describe ":from" do
     describe "attribute reference", :shared => true do
       it "should be interpreted as :attr" do
-        @opts.type.should == :attr
+        @opts.sought_type.should == :attr
       end
 
       it "should strip '@' from name" do

data/spec/xml/attributes_spec.rb

@@ -3,21 +3,20 @@ require 'spec/spec_helper'
 describe ROXML::XMLAttributeRef do
   before do
     @xml = ROXML::XML::Parser.parse %(
-    <myxml>
-      <node name="first" />
-      <node name="second" />
-      <node name="third" />
-    </myxml>
-    )
+<myxml>
+  <node name="first" />
+  <node name="second" />
+  <node name="third" />
+</myxml>)
   end
-  
+
   context "plain vanilla" do
     before do
       @ref = ROXML::XMLAttributeRef.new(OpenStruct.new(:name => 'name', :wrapper => 'node', :array? => false), RoxmlObject.new)
     end
 
     it "should return one instance" do
-      @ref.send(:fetch_value, @xml).should == "first"
+      @ref.value_in(@xml).should == "first"
     end
     it "should output one instance"
   end
@@ -28,9 +27,45 @@ describe ROXML::XMLAttributeRef do
     end
 
     it "should collect all instances" do
-      @ref.send(:fetch_value, @xml).should == ["first", "second", "third"]
+      @ref.value_in(@xml).should == ["first", "second", "third"]
     end
 
-    it "should output all instances"
+    it "should output all instances" do
+      xml = ROXML::XML::Node.create('myxml')
+      @ref.update_xml(xml, ["first", "second", "third"])
+      xml.to_s.squeeze(' ').should == @xml.root.to_s.squeeze(' ')
+    end
+  end
+  
+  context "when the namespaces are different" do
+    before do
+      @xml = ROXML::XML::Parser.parse %(
+      <document>
+      <myxml xmlns="http://example.com/three" xmlns:one="http://example.com/one" xmlns:two="http://example.com/two">
+        <one:node name="first" />
+        <two:node name="second" />
+        <node name="third" />
+      </myxml>
+      </document>
+      )
+    end
+
+    context "with :namespace => '*'" do
+      before do
+        @ref = ROXML::XMLAttributeRef.new(OpenStruct.new(:name => 'name', :wrapper => 'node', :array? => true, :namespace => '*'), RoxmlObject.new)
+      end
+
+      it "should collect all instances" do
+        pending "Test bug?"
+        @ref.value_in(@xml).should == ["first", "second", "third"]
+      end
+
+      it "should output all instances with namespaces" do
+        pending "Full namespace write support"
+        xml = ROXML::XML::Node.create('result')
+        @ref.update_xml(xml, ["first", "second", "third"])
+        xml.should == @xml.root
+      end
+    end
   end
 end

data/spec/xml/namespace_spec.rb

@@ -51,6 +51,7 @@ EOS
       it "should reproduce the input xml" do
         output = ROXML::XML::Document.new
         output.root = VApp.from_xml(@xml).to_xml
+        pending "Full namespace write support"
         output.should == ROXML::XML::Parser.parse(@xml)
       end
     end

data/spec/xml/namespaces_spec.rb

@@ -11,6 +11,7 @@ describe ROXML, "#xml_namespaces" do
 
        xml_reader :bike_tires, :as => [], :from => '@name', :in => 'bobsbike:tire'
        xml_reader :car_tires, :as => [], :from => '@name', :in => 'alicesauto:tire'
+       xml_reader :tires, :as => [], :from => '@name', :in => 'tire', :namespace => '*'
      end
 
     before do
@@ -22,7 +23,7 @@ describe ROXML, "#xml_namespaces" do
          </inventory>
        }
     end
-  
+
     it "should remap default namespaces" do
       Tires.from_xml(@xml).car_tires.should =~ ['super slick racing tire', 'all weather tire']
     end
@@ -30,6 +31,12 @@ describe ROXML, "#xml_namespaces" do
     it "should remap prefix namespaces" do
       Tires.from_xml(@xml).bike_tires.should == ['skinny street']
     end
+
+    context "with namespace-indifferent option" do
+      it "should return all tires" do
+        Tires.from_xml(@xml).tires.should =~ ['super slick racing tire', 'all weather tire', 'skinny street']
+      end
+    end
   end
 
   context "when an included namespace is not defined in the xml" do

data/spec/xml/object_spec.rb

@@ -0,0 +1,82 @@
+require 'spec/spec_helper'
+
+describe ROXML::XMLObjectRef do
+  class SubObject
+    include ROXML
+
+    xml_reader :value, :from => :attr
+
+    def initialize(value = nil)
+      @value = value
+    end
+  end
+
+  before do
+    @xml = ROXML::XML::Parser.parse %(
+<myxml>
+  <node>
+    <name value="first" />
+    <name value="second" />
+    <name value="third" />
+  </node>
+</myxml>)
+  end
+
+  context "plain vanilla" do
+    before do
+      @ref = ROXML::XMLObjectRef.new(OpenStruct.new(:name => 'name', :wrapper => 'node', :array? => false, :sought_type => SubObject), RoxmlObject.new)
+    end
+
+    it "should return one instance" do
+      @ref.value_in(@xml).value.should == "first"
+    end
+    it "should output one instance"
+  end
+  
+  context "with :as => []" do
+    before do
+      @ref = ROXML::XMLObjectRef.new(OpenStruct.new(:name => 'name', :wrapper => 'node', :array? => true, :sought_type => SubObject), RoxmlObject.new)
+    end
+
+    it "should collect all instances" do
+      @ref.value_in(@xml).map(&:value).should == ["first", "second", "third"]
+    end
+
+    it "should output all instances" do
+      xml = ROXML::XML::Node.create('myxml')
+      @ref.update_xml(xml, ["first", "second", "third"].map {|value| SubObject.new(value) })
+      xml.to_s.squeeze(' ').should == @xml.root.to_s.squeeze(' ')
+    end
+  end
+  
+  context "when the namespaces are different" do
+    before do
+      @xml = ROXML::XML::Parser.parse %(
+      <myxml xmlns="http://example.com/three" xmlns:one="http://example.com/one" xmlns:two="http://example.com/two">
+        <node>
+          <one:name>first</one:name>
+          <two:name>second</two:name>
+          <name>third</name>
+        </node>
+      </myxml>)
+    end
+
+    context "with :namespace => '*'" do
+      before do
+        @ref = ROXML::XMLObjectRef.new(OpenStruct.new(:name => 'name', :wrapper => 'node', :array? => true, :namespace => '*', :sought_type => SubObject), RoxmlObject.new)
+      end
+
+      it "should collect all instances" do
+        pending "Test bug?"
+        @ref.value_in(@xml).map(&:value).should == ["first", "second", "third"]
+      end
+
+      it "should output all instances with namespaces" do
+        pending "Full namespace write support"
+        xml = ROXML::XML::Node.create('myxml')
+        @ref.update_xml(xml, ["first", "second", "third"].map {|value| SubObject.new(value) })
+        xml.should == @xml.root
+      end
+    end
+  end
+end

data/spec/xml/text_spec.rb

@@ -0,0 +1,71 @@
+require 'spec/spec_helper'
+
+describe ROXML::XMLTextRef do
+  before do
+    @xml = ROXML::XML::Parser.parse %(
+<myxml>
+  <node>
+    <name>first</name>
+    <name>second</name>
+    <name>third</name>
+  </node>
+</myxml>)
+  end
+
+  context "plain vanilla" do
+    before do
+      @ref = ROXML::XMLTextRef.new(OpenStruct.new(:name => 'name', :wrapper => 'node', :array? => false), RoxmlObject.new)
+    end
+
+    it "should return one instance" do
+      @ref.value_in(@xml).should == "first"
+    end
+    it "should output one instance"
+  end
+  
+  context "with :as => []" do
+    before do
+      @ref = ROXML::XMLTextRef.new(OpenStruct.new(:name => 'name', :wrapper => 'node', :array? => true), RoxmlObject.new)
+    end
+
+    it "should collect all instances" do
+      @ref.value_in(@xml).should == ["first", "second", "third"]
+    end
+
+    it "should output all instances" do
+      xml = ROXML::XML::Node.create('myxml')
+      @ref.update_xml(xml, ["first", "second", "third"])
+      xml.to_s.squeeze(' ').should == @xml.root.to_s.squeeze(' ')
+    end
+  end
+  
+  context "when the namespaces are different" do
+    before do
+      @xml = ROXML::XML::Parser.parse %(
+      <myxml xmlns="http://example.com/three" xmlns:one="http://example.com/one" xmlns:two="http://example.com/two">
+        <node>
+          <one:name>first</one:name>
+          <two:name>second</two:name>
+          <name>third</name>
+        </node>
+      </myxml>)
+    end
+
+    context "with :namespace => '*'" do
+      before do
+        @ref = ROXML::XMLTextRef.new(OpenStruct.new(:name => 'name', :wrapper => 'node', :array? => true, :namespace => '*'), RoxmlObject.new)
+      end
+
+      it "should collect all instances" do
+        @ref.value_in(@xml).should == ["first", "second", "third"]
+      end
+
+      it "should output all instances with namespaces" do
+        pending "Full namespace write support"
+        xml = ROXML::XML::Node.create('myxml')
+        @ref.update_xml(xml, ["first", "second", "third"])
+        xml.should == @xml.root
+      end
+    end
+  end
+end

data/test/unit/definition_test.rb

@@ -4,26 +4,26 @@ class TestDefinition < ActiveSupport::TestCase
   def assert_hash(opts, kvp)
     assert opts.hash?
     assert !opts.array?
-    assert_equal kvp, {opts.hash.key.type => opts.hash.key.name,
-                       opts.hash.value.type => opts.hash.value.name}
+    assert_equal kvp, {opts.hash.key.sought_type => opts.hash.key.name,
+                       opts.hash.value.sought_type => opts.hash.value.name}
   end
 
   def test_empty_array_means_as_array_for_text
     opts = ROXML::Definition.new(:authors, :as => [])
     assert opts.array?
-    assert_equal :text, opts.type
+    assert_equal :text, opts.sought_type
   end
 
   def test_attr_in_array_means_as_array_for_attr
     opts = ROXML::Definition.new(:authors, :as => [], :from => :attr)
     assert opts.array?
-    assert_equal :attr, opts.type
+    assert_equal :attr, opts.sought_type
   end
 
   def test_block_shorthand_in_array_means_array
     opts = ROXML::Definition.new(:intarray, :as => [Integer])
     assert opts.array?
-    assert_equal :text, opts.type
+    assert_equal :text, opts.sought_type
     assert 1, opts.blocks.size
   end
 
@@ -87,13 +87,13 @@ class TestDefinition < ActiveSupport::TestCase
   def test_from_attr_is_supported
     opts = ROXML::Definition.new(:count, :from => :attr)
     assert_equal "count", opts.name
-    assert_equal :attr, opts.type
+    assert_equal :attr, opts.sought_type
   end
 
   def test_from_at_name_is_supported
     opts = ROXML::Definition.new(:count, :from => "@COUNT")
     assert_equal "COUNT", opts.name
-    assert_equal :attr, opts.type
+    assert_equal :attr, opts.sought_type
   end
 
   def test_multiple_shorthands_raises
@@ -164,11 +164,11 @@ class TestDefinition < ActiveSupport::TestCase
   end
 
   def test_as_supports_generic_roxml_types
-    assert_equal RoxmlObject, ROXML::Definition.new(:type, :as => RoxmlObject).type
+    assert_equal RoxmlObject, ROXML::Definition.new(:type, :as => RoxmlObject).sought_type
   end
 
   def test_as_supports_generic_roxml_types_in_arrays
-    assert_equal RoxmlObject, ROXML::Definition.new(:types, :as => [RoxmlObject]).type
+    assert_equal RoxmlObject, ROXML::Definition.new(:types, :as => [RoxmlObject]).sought_type
   end
 
   def test_default_works
@@ -195,24 +195,24 @@ class TestDefinition < ActiveSupport::TestCase
     opts = ROXML::Definition.new(:author, :from => :content)
     assert opts.content?
     assert_equal '.', opts.name
-    assert_equal :text, opts.type
+    assert_equal :text, opts.sought_type
   end
 
   def test_content_symbol_as_target_is_translated_to_string
     opts = ROXML::Definition.new(:content, :from => :attr)
     assert_equal 'content', opts.name
-    assert_equal :attr, opts.type
+    assert_equal :attr, opts.sought_type
   end
 
   def test_attr_is_accepted_as_from
-    assert_equal :attr, ROXML::Definition.new(:author, :from => :attr).type
-    assert_equal :attr, ROXML::Definition.new(:author, :from => '@author').type
+    assert_equal :attr, ROXML::Definition.new(:author, :from => :attr).sought_type
+    assert_equal :attr, ROXML::Definition.new(:author, :from => '@author').sought_type
   end
 
   def test_attr_is_a_recognized_type
     opts = ROXML::Definition.new(:author, :from => :attr)
     assert_equal 'author', opts.name
-    assert_equal :attr, opts.type
+    assert_equal :attr, opts.sought_type
   end
 end
 
@@ -230,6 +230,6 @@ class HashDefinitionTest < ActiveSupport::TestCase
   def test_content_detected_as_from
     opts = ROXML::Definition.new(:hash, :as => {:key => :content, :value => :name})
     assert_equal '.', opts.hash.key.name
-    assert_equal :text, opts.hash.key.type
+    assert_equal :text, opts.hash.key.sought_type
   end
 end

data/test/unit/deprecations_test.rb

@@ -4,7 +4,7 @@ class TestDeprecation < ActiveSupport::TestCase
   def test_as_array_not_deprecated
     assert_not_deprecated do
       opts = ROXML::Definition.new(:name, :as => [])
-      assert_equal :text, opts.type
+      assert_equal :text, opts.sought_type
       assert opts.array?
     end
   end

data/test/unit/xml_hash_test.rb

@@ -108,7 +108,7 @@ class TestXMLHash < ActiveSupport::TestCase
     assert_not_deprecated do
       opts = ROXML::Definition.new(:name, :as => {:key => :name, :value => {:from => 'value', :as => OctalInteger}})
       assert opts.hash?
-      assert_equal OctalInteger, opts.hash.value.type
+      assert_equal OctalInteger, opts.hash.value.sought_type
       assert_equal 'value', opts.hash.value.name
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: roxml
 version: !ruby/object:Gem::Version 
-  version: 3.1.2
+  version: 3.1.3
 platform: ruby
 authors: 
 - Ben Woosley
@@ -12,7 +12,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-18 00:00:00 -04:00
+date: 2009-10-30 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -89,7 +89,6 @@ files:
 - Rakefile
 - TODO
 - VERSION
-- config/website.yml
 - examples/amazon.rb
 - examples/current_weather.rb
 - examples/dashed_elements.rb
@@ -128,7 +127,9 @@ files:
 - spec/xml/attributes_spec.rb
 - spec/xml/namespace_spec.rb
 - spec/xml/namespaces_spec.rb
+- spec/xml/object_spec.rb
 - spec/xml/parser_spec.rb
+- spec/xml/text_spec.rb
 - tasks/rdoc.rake
 - tasks/rspec.rake
 - tasks/test.rake
@@ -227,7 +228,9 @@ test_files:
 - spec/xml/attributes_spec.rb
 - spec/xml/namespace_spec.rb
 - spec/xml/namespaces_spec.rb
+- spec/xml/object_spec.rb
 - spec/xml/parser_spec.rb
+- spec/xml/text_spec.rb
 - test/load_test.rb
 - test/mocks/dictionaries.rb
 - test/mocks/mocks.rb

data/config/website.yml

@@ -1,2 +0,0 @@
-host: empact@rubyforge.org
-remote_dir: /var/www/gforge-projects/roxml