roxml 2.4.3 → 2.5.0

data/lib/roxml/xml.rb

@@ -4,6 +4,10 @@ module ROXML
       require 'libxml'
       XML_PARSER = 'libxml' # :nodoc:
     rescue LoadError
+      warn <<WARNING
+ROXML is unable to locate libxml on your system, and so is falling back to
+the much slower REXML.  It's best to check this out and get libxml working if possible.
+WARNING
       XML_PARSER = 'rexml' # :nodoc:
     end
   end
@@ -13,15 +17,20 @@ module ROXML
   module XML
     class Node
       def self.from(data)
-        if data.is_a?(XML::Node)
+        case data
+        when XML::Node
           data
-        elsif data.is_a?(File) || data.is_a?(IO)
+        when XML::Document
+          data.root
+        when File, IO
           Parser.parse_io(data).root
-        elsif (defined?(URI) && data.is_a?(URI::Generic)) ||
-              (defined?(Pathname) && data.is_a?(Pathname))
-          Parser.parse_file(data.to_s).root
         else
-          Parser.parse(data).root
+          if (defined?(URI) && data.is_a?(URI::Generic)) ||
+             (defined?(Pathname) && data.is_a?(Pathname))
+            Parser.parse_file(data.to_s).root
+          else
+            Parser.parse(data).root
+          end
         end
       end
     end

data/lib/roxml/xml/parsers/libxml.rb

@@ -5,13 +5,14 @@ module ROXML
     Document = LibXML::XML::Document
     Node = LibXML::XML::Node
     Parser = LibXML::XML::Parser
+    Error = LibXML::XML::Error
 
     module NamespacedSearch
       def search(xpath)
         begin
-          if default_namespace && !xpath.include?(':')
+          if namespaces.default && !xpath.include?(':')
             find(namespaced(xpath),
-                 in_default_namespace(default_namespace.href))
+                 in_default_namespace(namespaces.default.href))
           else
             find(xpath)
           end
@@ -40,15 +41,17 @@ module ROXML
       include NamespacedSearch
 
     private
-      delegate :default_namespace, :to => :root
+      delegate :namespaces, :to => :root
     end
 
     class Node
       include NamespacedSearch
 
-    private
-      def default_namespace
-        @default_namespace ||= namespace && namespace.find {|n| n.to_s.nil? }
+      class << self
+        def new_with_entity_escaping(name, content = nil, namespace = nil)
+          new_without_entity_escaping(name, content && CGI.escapeHTML(content), namespace)
+        end
+        alias_method_chain :new, :entity_escaping
       end
     end
 

data/lib/roxml/xml/parsers/rexml.rb

@@ -11,7 +11,7 @@ module ROXML
           REXML::CData.new(content)
         end
 
-        def new_element(name)
+        def new(name)
           name = name.id2name if name.is_a? Symbol
           REXML::Element.new(name)
         end

data/lib/roxml/xml/references.rb

@@ -36,13 +36,11 @@ module ROXML
       end
     end
 
-    def default
-      @default ||= @opts.default || (@opts.array? ? Array.new : nil)
-      @default.duplicable? ? @default.dup : @default
-    end
-
     def value_in(xml)
+      xml = XML::Node.from(xml)
       value = fetch_value(xml)
+      value = default if value.nil?
+
       freeze(apply_blocks(value))
     end
 
@@ -51,7 +49,6 @@ module ROXML
 
     def conventionize(what)
       if !what.blank? && @instance.try(:class).try(:roxml_naming_convention).respond_to?(:call)
-        require 'uri'
         URI.unescape(@instance.class.roxml_naming_convention.call(URI.escape(what, /\/|::/)))
       else
         what
@@ -71,7 +68,7 @@ module ROXML
     end
 
     def freeze(val)
-      if opts.freeze?
+      if opts.frozen?
         val.each(&:freeze) if val.is_a?(Enumerable)
         val.freeze
       else
@@ -92,7 +89,7 @@ module ROXML
       if child = xml.children.find {|c| c.name == wrapper }
        return child
       end
-      xml.child_add(XML::Node.new_element(wrapper))
+      xml.child_add(XML::Node.new(wrapper))
     end
 
     def nodes_in(xml)
@@ -123,7 +120,7 @@ module ROXML
     # Updates the attribute in the given XML block to
     # the value provided.
     def write_xml(xml, value)
-      xml.attributes[name] = value.to_s.to_utf
+      xml.attributes[name] = value.to_s.to_utf_without_deprecation
     end
 
     def fetch_value(xml)
@@ -156,10 +153,10 @@ module ROXML
         xml.name = value
       elsif array?
         value.each do |v|
-          add(xml.child_add(XML::Node.new_element(name)), v)
+          add(xml.child_add(XML::Node.new(name)), v)
         end
       else
-        add(xml.child_add(XML::Node.new_element(name)), value)
+        add(xml.child_add(XML::Node.new(name)), value)
       end
     end
 
@@ -182,7 +179,7 @@ module ROXML
         nodes_in(xml) do |nodes|
           if array?
             nodes.collect do |e|
-              e.content.strip.to_latin
+              e.content.strip.to_latin_without_deprecation
             end
           else
             nodes.first.content
@@ -193,9 +190,9 @@ module ROXML
 
     def add(dest, value)
       if cdata?
-        dest.child_add(XML::Node.new_cdata(value.to_s.to_utf))
+        dest.child_add(XML::Node.new_cdata(value.to_s.to_utf_without_deprecation))
       else
-        dest.content = value.to_s.to_utf
+        dest.content = CGI.escapeHTML(value.to_s.to_utf_without_deprecation)
       end
     end
   end
@@ -214,7 +211,7 @@ module ROXML
     # the value provided.
     def write_xml(xml, value)
       value.each_pair do |k, v|
-        node = xml.child_add(XML::Node.new_element(hash.wrapper))
+        node = xml.child_add(XML::Node.new(hash.wrapper))
         @key.update_xml(node, k)
         @value.update_xml(node, v)
       end
@@ -238,7 +235,7 @@ module ROXML
     end
 
     def freeze(vals)
-      if opts.freeze?
+      if opts.frozen?
         vals.each_pair{|k, v| k.freeze; v.freeze }
         vals.freeze
       else
@@ -261,7 +258,7 @@ module ROXML
       elsif value.is_a?(ROXML)
         xml.child_add(value.to_xml(name))
       else
-        node = XML::Node.new_element(name)
+        node = XML::Node.new(name)
         node.content = value.to_xml
         xml.child_add(node)
       end

data/roxml.gemspec

@@ -2,23 +2,23 @@
 
 Gem::Specification.new do |s|
   s.name = %q{roxml}
-  s.version = "2.4.3"
+  s.version = "2.5.0"
 
   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-02-01}
+  s.date = %q{2009-02-24}
   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 building first-class Ruby classes. As a result, ROXML simplifies the development of RESTful applications, Web Services, and XML-RPC.}
   s.email = %q{ben.woosley@gmail.com}
   s.extra_rdoc_files = ["History.txt", "Manifest.txt", "README.rdoc"]
-  s.files = ["History.txt", "MIT-LICENSE", "Manifest.txt", "README.rdoc", "Rakefile", "TODO", "config/website.yml", "examples/amazon.rb", "examples/current_weather.rb", "examples/dashed_elements.rb", "examples/posts.rb", "examples/twitter.rb", "examples/xml/amazon.xml", "examples/xml/current_weather.xml", "examples/xml/dashed_elements.xml", "examples/xml/posts.xml", "examples/xml/twitter.xml", "lib/roxml.rb", "lib/roxml/definition.rb", "lib/roxml/extensions.rb", "lib/roxml/extensions/active_support.rb", "lib/roxml/extensions/array.rb", "lib/roxml/extensions/array/conversions.rb", "lib/roxml/extensions/deprecation.rb", "lib/roxml/extensions/string.rb", "lib/roxml/extensions/string/conversions.rb", "lib/roxml/extensions/string/iterators.rb", "lib/roxml/hash_definition.rb", "lib/roxml/xml.rb", "lib/roxml/xml/parsers/libxml.rb", "lib/roxml/xml/parsers/rexml.rb", "lib/roxml/xml/references.rb", "roxml.gemspec", "spec/examples/amazon_spec.rb", "spec/examples/current_weather_spec.rb", "spec/examples/dashed_elements_spec.rb", "spec/examples/post_spec.rb", "spec/examples/twitter_spec.rb", "spec/spec.opts", "spec/spec_helper.rb", "tasks/rspec.rake", "tasks/test.rake", "test/bugs/rexml_bugs.rb", "test/fixtures/book_malformed.xml", "test/fixtures/book_pair.xml", "test/fixtures/book_text_with_attribute.xml", "test/fixtures/book_valid.xml", "test/fixtures/book_with_authors.xml", "test/fixtures/book_with_contributions.xml", "test/fixtures/book_with_contributors.xml", "test/fixtures/book_with_contributors_attrs.xml", "test/fixtures/book_with_default_namespace.xml", "test/fixtures/book_with_depth.xml", "test/fixtures/book_with_octal_pages.xml", "test/fixtures/book_with_publisher.xml", "test/fixtures/book_with_wrapped_attr.xml", "test/fixtures/dictionary_of_attr_name_clashes.xml", "test/fixtures/dictionary_of_attrs.xml", "test/fixtures/dictionary_of_guarded_names.xml", "test/fixtures/dictionary_of_mixeds.xml", "test/fixtures/dictionary_of_name_clashes.xml", "test/fixtures/dictionary_of_names.xml", "test/fixtures/dictionary_of_texts.xml", "test/fixtures/library.xml", "test/fixtures/library_uppercase.xml", "test/fixtures/muffins.xml", "test/fixtures/nameless_ageless_youth.xml", "test/fixtures/node_with_attr_name_conflicts.xml", "test/fixtures/node_with_name_conflicts.xml", "test/fixtures/numerology.xml", "test/fixtures/person.xml", "test/fixtures/person_with_guarded_mothers.xml", "test/fixtures/person_with_mothers.xml", "test/mocks/dictionaries.rb", "test/mocks/mocks.rb", "test/release/dependencies_test.rb", "test/test_helper.rb", "test/unit/array_test.rb", "test/unit/definition_test.rb", "test/unit/freeze_test.rb", "test/unit/inheritance_test.rb", "test/unit/overriden_output_test.rb", "test/unit/roxml_test.rb", "test/unit/string_test.rb", "test/unit/to_xml_test.rb", "test/unit/xml_attribute_test.rb", "test/unit/xml_block_test.rb", "test/unit/xml_bool_test.rb", "test/unit/xml_construct_test.rb", "test/unit/xml_convention_test.rb", "test/unit/xml_hash_test.rb", "test/unit/xml_initialize_test.rb", "test/unit/xml_name_test.rb", "test/unit/xml_namespace_test.rb", "test/unit/xml_object_test.rb", "test/unit/xml_required_test.rb", "test/unit/xml_text_test.rb", "vendor/override_rake_task/README", "vendor/override_rake_task/init.rb", "vendor/override_rake_task/install.rb", "vendor/override_rake_task/lib/override_rake_task.rb", "website/index.html"]
+  s.files = ["History.txt", "MIT-LICENSE", "Manifest.txt", "README.rdoc", "Rakefile", "TODO", "config/website.yml", "examples/active_record.rb", "examples/amazon.rb", "examples/current_weather.rb", "examples/dashed_elements.rb", "examples/posts.rb", "examples/twitter.rb", "examples/xml/active_record.xml", "examples/xml/amazon.xml", "examples/xml/current_weather.xml", "examples/xml/dashed_elements.xml", "examples/xml/posts.xml", "examples/xml/twitter.xml", "lib/roxml.rb", "lib/roxml/definition.rb", "lib/roxml/extensions.rb", "lib/roxml/extensions/active_support.rb", "lib/roxml/extensions/array.rb", "lib/roxml/extensions/array/conversions.rb", "lib/roxml/extensions/deprecation.rb", "lib/roxml/extensions/string.rb", "lib/roxml/extensions/string/conversions.rb", "lib/roxml/extensions/string/iterators.rb", "lib/roxml/hash_definition.rb", "lib/roxml/xml.rb", "lib/roxml/xml/parsers/libxml.rb", "lib/roxml/xml/parsers/rexml.rb", "lib/roxml/xml/references.rb", "roxml.gemspec", "spec/definition_spec.rb", "spec/examples/active_record_spec.rb", "spec/examples/amazon_spec.rb", "spec/examples/current_weather_spec.rb", "spec/examples/dashed_elements_spec.rb", "spec/examples/post_spec.rb", "spec/examples/twitter_spec.rb", "spec/roxml_spec.rb", "spec/shared_specs.rb", "spec/spec.opts", "spec/spec_helper.rb", "spec/string_spec.rb", "spec/xml/parser_spec.rb", "tasks/rspec.rake", "tasks/test.rake", "test/bugs/rexml_bugs.rb", "test/fixtures/book_malformed.xml", "test/fixtures/book_pair.xml", "test/fixtures/book_text_with_attribute.xml", "test/fixtures/book_valid.xml", "test/fixtures/book_with_authors.xml", "test/fixtures/book_with_contributions.xml", "test/fixtures/book_with_contributors.xml", "test/fixtures/book_with_contributors_attrs.xml", "test/fixtures/book_with_default_namespace.xml", "test/fixtures/book_with_depth.xml", "test/fixtures/book_with_octal_pages.xml", "test/fixtures/book_with_publisher.xml", "test/fixtures/book_with_wrapped_attr.xml", "test/fixtures/dictionary_of_attr_name_clashes.xml", "test/fixtures/dictionary_of_attrs.xml", "test/fixtures/dictionary_of_guarded_names.xml", "test/fixtures/dictionary_of_mixeds.xml", "test/fixtures/dictionary_of_name_clashes.xml", "test/fixtures/dictionary_of_names.xml", "test/fixtures/dictionary_of_texts.xml", "test/fixtures/library.xml", "test/fixtures/library_uppercase.xml", "test/fixtures/muffins.xml", "test/fixtures/nameless_ageless_youth.xml", "test/fixtures/node_with_attr_name_conflicts.xml", "test/fixtures/node_with_name_conflicts.xml", "test/fixtures/numerology.xml", "test/fixtures/person.xml", "test/fixtures/person_with_guarded_mothers.xml", "test/fixtures/person_with_mothers.xml", "test/mocks/dictionaries.rb", "test/mocks/mocks.rb", "test/release/dependencies_test.rb", "test/test_helper.rb", "test/unit/definition_test.rb", "test/unit/deprecations_test.rb", "test/unit/to_xml_test.rb", "test/unit/xml_attribute_test.rb", "test/unit/xml_block_test.rb", "test/unit/xml_bool_test.rb", "test/unit/xml_construct_test.rb", "test/unit/xml_convention_test.rb", "test/unit/xml_hash_test.rb", "test/unit/xml_initialize_test.rb", "test/unit/xml_name_test.rb", "test/unit/xml_namespace_test.rb", "test/unit/xml_object_test.rb", "test/unit/xml_required_test.rb", "test/unit/xml_text_test.rb", "vendor/override_rake_task/README", "vendor/override_rake_task/init.rb", "vendor/override_rake_task/install.rb", "vendor/override_rake_task/lib/override_rake_task.rb", "website/index.html"]
   s.has_rdoc = true
   s.homepage = %q{http://roxml.rubyforge.org}
   s.rdoc_options = ["--main", "README.rdoc"]
   s.require_paths = ["lib"]
   s.rubyforge_project = %q{roxml}
-  s.rubygems_version = %q{1.3.1.xported}
+  s.rubygems_version = %q{1.3.1}
   s.summary = %q{Ruby Object to XML mapping library}
-  s.test_files = ["test/unit/freeze_test.rb", "test/unit/array_test.rb", "test/unit/xml_convention_test.rb", "test/unit/xml_object_test.rb", "test/unit/xml_required_test.rb", "test/unit/xml_bool_test.rb", "test/unit/roxml_test.rb", "test/unit/xml_name_test.rb", "test/unit/definition_test.rb", "test/unit/xml_construct_test.rb", "test/unit/string_test.rb", "test/unit/xml_namespace_test.rb", "test/unit/xml_text_test.rb", "test/unit/overriden_output_test.rb", "test/unit/xml_block_test.rb", "test/unit/xml_attribute_test.rb", "test/unit/inheritance_test.rb", "test/unit/xml_initialize_test.rb", "test/unit/xml_hash_test.rb", "test/unit/to_xml_test.rb"]
+  s.test_files = ["test/unit/xml_convention_test.rb", "test/unit/xml_object_test.rb", "test/unit/xml_required_test.rb", "test/unit/xml_bool_test.rb", "test/unit/xml_name_test.rb", "test/unit/definition_test.rb", "test/unit/xml_construct_test.rb", "test/unit/xml_namespace_test.rb", "test/unit/deprecations_test.rb", "test/unit/xml_text_test.rb", "test/unit/xml_block_test.rb", "test/unit/xml_attribute_test.rb", "test/unit/xml_initialize_test.rb", "test/unit/xml_hash_test.rb", "test/unit/to_xml_test.rb"]
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
@@ -26,15 +26,18 @@ Gem::Specification.new do |s|
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<activesupport>, [">= 2.1.0"])
+      s.add_runtime_dependency(%q<libxml-ruby>, [">= 0.8.6"])
       s.add_development_dependency(%q<newgem>, [">= 1.2.3"])
       s.add_development_dependency(%q<hoe>, [">= 1.8.0"])
     else
       s.add_dependency(%q<activesupport>, [">= 2.1.0"])
+      s.add_dependency(%q<libxml-ruby>, [">= 0.8.6"])
       s.add_dependency(%q<newgem>, [">= 1.2.3"])
       s.add_dependency(%q<hoe>, [">= 1.8.0"])
     end
   else
     s.add_dependency(%q<activesupport>, [">= 2.1.0"])
+    s.add_dependency(%q<libxml-ruby>, [">= 0.8.6"])
     s.add_dependency(%q<newgem>, [">= 1.2.3"])
     s.add_dependency(%q<hoe>, [">= 1.8.0"])
   end

data/spec/definition_spec.rb

@@ -0,0 +1,563 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+class RoxmlObject
+  include ROXML
+end
+
+describe ROXML::Definition do
+  describe "#name_explicit?" do
+    it "should indicate whether from option is present" do
+      ROXML::Definition.new(:element, :from => 'somewhere').name_explicit?.should be_true
+      ROXML::Definition.new(:element).name_explicit?.should be_false
+    end
+
+    it "should not consider name proxies as explicit" do
+      ROXML::Definition.new(:element, :from => :attr).name_explicit?.should be_false
+      ROXML::Definition.new(:element, :from => :content).name_explicit?.should be_false
+    end
+  end
+
+  describe "hash options declaration", :shared => true do
+    it "should represent a hash" do
+      @opts.hash?.should be_true
+    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]
+    end
+
+    it "should not represent an array" do
+      @opts.array?.should be_false
+    end
+  end
+
+  describe "types" do
+    describe ":content" do
+      it "should be recognized" do
+        ROXML::Definition.new(:author).content?.should be_false
+        ROXML::Definition.new(:author, :content).content?.should be_true
+      end
+
+      it "should be deprecated"
+    end
+
+    describe "array reference" do
+      it "[] means array of texts" do
+        opts = ROXML::Definition.new(:authors, [])
+        opts.array?.should be_true
+        opts.type.should == :text
+      end
+
+      it "[:text] means array of texts" do
+        opts = ROXML::Definition.new(:authors, [:text])
+        opts.array?.should be_true
+        opts.type.should == :text
+      end
+
+      it "[:attr] means array of attrs" do
+        opts = ROXML::Definition.new(:authors, [:attr])
+        opts.array?.should be_true
+        opts.type.should == :attr
+      end
+
+      it "[Object] means array of objects" do
+        opts = ROXML::Definition.new(:authors, [Hash])
+        opts.array?.should be_true
+        opts.type.should == Hash
+      end
+    end
+
+    describe "{}" do
+      describe "hash with attr key and text val" do
+        before do
+          @opts = ROXML::Definition.new(:attributes, {:key => {:attr => :name},
+                                         :value => :value})
+          @hash_args = {:key => {:attr => 'name'},
+                        :value => {:text => 'value'}}
+        end
+
+        it_should_behave_like "hash options declaration"
+      end
+
+      describe "hash with String class for type" do
+        before do
+          @opts = ROXML::Definition.new(:attributes, {:key => {String => 'name'},
+                                         :value => {String => 'value'}})
+          @hash_args = {:key => {:text => 'name'}, :value => {:text => 'value'}}
+        end
+
+        it_should_behave_like "hash options declaration"
+      end
+
+      describe "hash with attr key and content val" do
+        before do
+          @opts = ROXML::Definition.new(:attributes, {:key => {:attr => :name},
+                                         :value => :content})
+          @hash_args = {:key => {:attr => 'name'}, :value => {:text => '.'}}
+        end
+
+        it_should_behave_like "hash options declaration"
+      end
+
+      describe "hash of attrs" do
+        before do
+          @hash_args = {:key => {:attr => 'name'}, :value => {:attr => 'value'}}
+          @opts = ROXML::Definition.new(:attributes, {:attrs => [:name, :value]})
+        end
+
+        it_should_behave_like "hash options declaration"
+
+        describe "with options" do
+          before do
+            @hash_args = {:key => {:attr => 'dt'}, :value => {:attr => 'dd'}}
+            @opts = ROXML::Definition.new(:definitions, {:attrs => [:dt, :dd]},
+                                    :in => 'definitions')
+          end
+
+          it_should_behave_like "hash options declaration"
+
+          it "should not interfere with options" do
+            @opts.wrapper.should == 'definitions'
+          end
+        end
+      end
+    end
+  end
+
+  describe ":as" do
+    describe "=> :array" do
+      it "should be deprecated"
+    end
+
+    describe "=> []" do
+      it "should means array of texts" do
+        opts = ROXML::Definition.new(:authors, :as => [])
+        opts.array?.should be_true
+        opts.type.should == :text
+      end
+
+      it "should unescape xml entities" do
+        ROXML::Definition.new(:questions, :as => []).to_ref(RoxmlObject.new).value_in(%{
+          <xml>
+            <question>&quot;Wickard &amp; Filburn&quot; &gt;</question>
+            <question> &lt; McCulloch &amp; Maryland?</question>
+          </xml>
+        }).should == ["\"Wickard & Filburn\" >", "< McCulloch & Maryland?"]
+      end
+    end
+
+    describe "=> {}" do
+      describe "hash with attr key and text val" do
+        before do
+          @opts = ROXML::Definition.new(:attributes, :as => {:key => {:attr => :name},
+                                                             :value => :value})
+          @hash_args = {:key => {:attr => 'name'},
+                        :value => {:text => 'value'}}
+        end
+
+        it_should_behave_like "hash options declaration"
+      end
+
+      describe "hash with String class for type" do
+        before do
+          @opts = ROXML::Definition.new(:attributes, :as => {:key => {String => 'name'},
+                                                             :value => {String => 'value'}})
+          @hash_args = {:key => {:text => 'name'}, :value => {:text => 'value'}}
+        end
+
+        it_should_behave_like "hash options declaration"
+      end
+
+      describe "hash with attr key and content val" do
+        before do
+          @opts = ROXML::Definition.new(:attributes, :as => {:key => {:attr => :name},
+                                                             :value => :content})
+          @hash_args = {:key => {:attr => 'name'}, :value => {:text => '.'}}
+        end
+
+        it_should_behave_like "hash options declaration"
+      end
+
+      describe "hash of attrs" do
+        before do
+          @hash_args = {:key => {:attr => 'name'}, :value => {:attr => 'value'}}
+          @opts = ROXML::Definition.new(:attributes, :as => {:attrs => [:name, :value]})
+        end
+
+        it_should_behave_like "hash options declaration"
+
+        describe "with options" do
+          before do
+            @hash_args = {:key => {:attr => 'dt'}, :value => {:attr => 'dd'}}
+            @opts = ROXML::Definition.new(:definitions, :as => {:attrs => [:dt, :dd]},
+                                    :in => 'definitions')
+          end
+
+          it_should_behave_like "hash options declaration"
+
+          it "should not interfere with options" do
+            @opts.wrapper.should == 'definitions'
+          end
+        end
+      end
+    end
+
+    describe "for block shorthand" do
+      describe "in literal array" do
+        before do
+          @opts = ROXML::Definition.new(:intarray, :as => [Integer])
+        end
+
+        it "should be detected as array reference" do
+          @opts.array?.should be_true
+        end
+
+        it "should be normal otherwise" do
+          @opts.type.should == :text
+          @opts.blocks.size.should == 1
+        end
+      end
+
+      it "should have no blocks without a shorthand" do
+        ROXML::Definition.new(:count).blocks.should be_empty
+        ROXML::Definition.new(:count, :as => :bogus).blocks.should be_empty
+        ROXML::Definition.new(:count, :as => :foat).blocks.should be_empty # misspelled
+      end
+
+      describe "block shorthand type declaration", :shared => true do
+        it "should translate nil to nil" do
+          @definition.blocks.first.call(nil).should be_nil
+        end
+
+        it "should translate empty strings to nil" do
+          @definition.blocks.first.call("").should be_nil
+          @definition.blocks.first.call(" ").should be_nil
+        end
+      end
+
+      describe ":as => Integer", :shared => true do
+        it_should_behave_like "block shorthand type declaration"
+
+        it "should translate text to integers" do
+          @definition.blocks.first['3'].should == 3
+          @definition.blocks.first['792'].should == 792
+        end
+
+        it "should raise on non-integer values" do
+          proc { @definition.blocks.first['08'] }.should raise_error(ArgumentError)
+          proc { @definition.blocks.first['793.12'] }.should raise_error(ArgumentError)
+          proc { @definition.blocks.first['junk 11'] }.should raise_error(ArgumentError)
+          proc { @definition.blocks.first['11sttf'] }.should raise_error(ArgumentError)
+        end
+
+        context "when passed an array" do
+          it "should translate the array elements to integer" do
+            @definition.blocks.first.call(["792", "12", "328"]).should == [792, 12, 328]
+          end
+        end
+      end
+
+      describe "Integer" do
+        before do
+          @definition = ROXML::Definition.new(:intvalue, :as => Integer)
+        end
+
+        it_should_behave_like ":as => Integer"
+      end
+
+      describe ":integer" do
+        before do
+          @definition = ROXML::Definition.new(:intvalue, :as => :integer)
+        end
+
+        it_should_behave_like ":as => Integer"
+
+        it "should be deprecated"
+      end
+
+      describe ":as => Float", :shared => true do
+        it_should_behave_like "block shorthand type declaration"
+
+        it "should translate text to float" do
+          @definition.blocks.first['3'].should == 3.0
+          @definition.blocks.first['12.7'].should == 12.7
+        end
+
+        it "should raise on non-float values" do
+          proc { @definition.blocks.first['junk 11.3'] }.should raise_error(ArgumentError)
+          proc { @definition.blocks.first['11.1sttf'] }.should raise_error(ArgumentError)
+        end
+
+        context "when passed an array" do
+          it "should translate the array elements to integer" do
+            @definition.blocks.first.call(["792.13", "240", "3.14"]).should == [792.13, 240.0, 3.14]
+          end
+        end
+      end
+
+      describe ":float" do
+        before do
+          @definition = ROXML::Definition.new(:floatvalue, :as => :float)
+        end
+
+        it_should_behave_like ":as => Float"
+
+        it "should be deprecated"
+      end
+
+      describe "Float" do
+        before do
+          @definition = ROXML::Definition.new(:floatvalue, :as => Float)
+        end
+
+        it_should_behave_like ":as => Float"
+      end
+
+      describe "BigDecimal" do
+        before do
+          @definition = ROXML::Definition.new(:decimalvalue, :as => BigDecimal)
+        end
+
+        it_should_behave_like "block shorthand type declaration"
+
+        it "should translate text to decimal numbers" do
+          @definition.blocks.first['3'].should == BigDecimal.new("3.0")
+          @definition.blocks.first['0.3'].should == BigDecimal.new("0.3")
+        end
+
+        it "should extract what it can, and fall back to 0" do
+          @definition.blocks.first['junk 11'].should eql(BigDecimal.new("0"))
+          @definition.blocks.first['11sttf'].should eql(BigDecimal.new("11.0"))
+        end
+
+        context "when passed an array" do
+          it "should translate the array elements to integer" do
+            @definition.blocks.first.call(["12.1", "328.2"]).should == [BigDecimal.new("12.1"), BigDecimal.new("328.2")]
+          end
+        end
+      end
+
+      describe "Fixnum" do
+        before do
+          @definition = ROXML::Definition.new(:fixnumvalue, :as => Fixnum)
+        end
+
+        it_should_behave_like "block shorthand type declaration"
+
+        it "should translate text to integers" do
+          @definition.blocks.first['3'].should == 3
+          @definition.blocks.first['792'].should == 792
+          @definition.blocks.first['08'].should == 8
+          @definition.blocks.first['279.23'].should == 279
+        end
+
+        it "should extract whatever is possible and fall back to 0" do
+          @definition.blocks.first['junk 11'].should eql(0)
+          @definition.blocks.first['.?sttf'].should eql(0)
+          @definition.blocks.first['11sttf'].should eql(11)
+        end
+
+        context "when passed an array" do
+          it "should translate the array elements to integer" do
+            @definition.blocks.first.call(["792", "12", "328"]).should == [792, 12, 328]
+          end
+        end
+      end
+
+      describe ":bool" do
+        it "should boolify individual values" do
+          ROXML::Definition.new(:floatvalue, :as => :bool).blocks.first.call("1").should be_true
+          ROXML::Definition.new(:floatvalue, :as => :bool).blocks.first.call("True").should be_true
+          ROXML::Definition.new(:floatvalue, :as => :bool).blocks.first.call("Yes").should be_true
+        end
+
+        context "when an array is passed in" do
+          it "should boolify arrays of values" do
+            ROXML::Definition.new(:floatvalue, :as => :bool).blocks.first.call("0").should be_false
+            ROXML::Definition.new(:floatvalue, :as => :bool).blocks.first.call("false").should be_false
+            ROXML::Definition.new(:floatvalue, :as => :bool).blocks.first.call("nO").should be_false
+          end
+        end
+
+        context "when no value is detected" do
+          it "should return nil" do
+            ROXML::Definition.new(:floatvalue, :as => :bool).blocks.first.call("junk").should be_nil
+          end
+
+          context "when a literal block is available" do
+            it "should pass the value itself to the block"
+          end
+        end
+      end
+
+      describe "Time" do
+        it "should return nil on empty string" do
+          ROXML::Definition.new(:floatvalue, :as => Time).blocks.first.call("  ").should be_nil
+        end
+
+        it "should return a time version of the string" do
+          ROXML::Definition.new(:datevalue, :as => Time).blocks.first.call("12:31am").min.should == 31
+        end
+
+        context "when passed an array of values" do
+          it "should timify all of them" do
+            ROXML::Definition.new(:datevalue, :as => Time).blocks.first.call(["12:31am", "3:00pm", "11:59pm"]).map(&:min).should == [31, 0, 59]
+          end
+        end
+      end
+
+      describe "Date" do
+        it "should return nil on empty string" do
+          ROXML::Definition.new(:floatvalue, :as => Date).blocks.first.call("  ").should be_nil
+        end
+
+        it "should return a time version of the string" do
+          ROXML::Definition.new(:datevalue, :as => Date).blocks.first.call("September 3rd, 1970").to_s == "1970-09-03"
+        end
+
+        context "when passed an array of values" do
+          it "should timify all of them" do
+            ROXML::Definition.new(:datevalue, :as => Date).blocks.first.call(["September 3rd, 1970", "1776-07-04"]).map(&:to_s).should == ["1970-09-03", "1776-07-04"]
+          end
+        end
+      end
+
+      describe "DateTime" do
+        it "should return nil on empty string" do
+          ROXML::Definition.new(:floatvalue, :as => DateTime).blocks.first.call("  ").should be_nil
+        end
+
+        it "should return a time version of the string" do
+          ROXML::Definition.new(:datevalue, :as => DateTime).blocks.first.call("12:05pm, September 3rd, 1970").to_s == "1970-09-03T12:05:00+00:00"
+        end
+
+        context "when passed an array of values" do
+          it "should timify all of them" do
+            ROXML::Definition.new(:datevalue, :as => DateTime).blocks.first.call(["12:05pm, September 3rd, 1970", "3:00pm, May 22, 1700"]).map(&:to_s).should == ["1970-09-03T12:05:00+00:00", "1700-05-22T15:00:00+00:00"]
+          end
+        end
+      end
+
+      it "should prohibit multiple shorthands" do
+        proc { ROXML::Definition.new(:count, :as => [Float, Integer]) }.should raise_error(ArgumentError)
+      end
+
+      it "should stack block shorthands with explicit blocks" do
+        ROXML::Definition.new(:count, :as => Integer) {|val| val.to_i }.blocks.size.should == 2
+        ROXML::Definition.new(:count, :as => Float) {|val| val.object_id }.blocks.size.should == 2
+      end
+    end
+  end
+
+  describe ":from" do
+    describe "attribute reference", :shared => true do
+      it "should be interpreted as :attr" do
+        @opts.type.should == :attr
+      end
+
+      it "should strip '@' from name" do
+        @opts.name.should == 'attr_name'
+      end
+
+      it "should unescape xml entities" do
+        @opts.to_ref(RoxmlObject.new).value_in(%{
+          <question attr_name="&quot;Wickard &amp; Filburn&quot; &gt; / &lt; McCulloch &amp; Marryland?" />
+        }).should == "\"Wickard & Filburn\" > / < McCulloch & Marryland?"
+      end
+    end
+
+    context ":attr" do
+      before do
+        @opts = ROXML::Definition.new(:attr_name, :from => :attr)
+      end
+
+      it_should_behave_like "attribute reference"
+    end
+
+    context "@attribute_name" do
+      before do
+        @opts = ROXML::Definition.new(:attr_name, :from => '@attr_name')
+      end
+
+      it_should_behave_like "attribute reference"
+
+      describe "and with :attr" do
+        before do
+          @opts = ROXML::Definition.new(:attr_name, :attr, :from => '@attr_name')
+        end
+
+        it_should_behave_like "attribute reference"
+        it "should be deprecated"
+      end
+    end
+
+    describe ":content" do
+      it "should be recognized" do
+        ROXML::Definition.new(:author, :from => :content).content?.should == true
+      end
+
+      it "should be equivalent to :from => '.'" do
+        ROXML::Definition.new(:author, :from => '.').content?.should == true
+      end
+    end
+  end
+
+  describe ":in" do
+    context "as xpath" do
+      it "should pass through as wrapper" do
+        ROXML::Definition.new(:manufacturer, :in => './').wrapper.should == './'
+      end
+    end
+
+    context "as xpath" do
+      it "should pass through as wrapper" do
+        ROXML::Definition.new(:manufacturer, :in => 'wrapper').wrapper.should == 'wrapper'
+      end
+    end
+  end
+
+  describe "options" do
+
+    describe "boolean option", :shared => true do
+      it "should be recognized" do
+        ROXML::Definition.new(:author, :content, @option => true).respond_to?(:"#{@option}?")
+        ROXML::Definition.new(:author, :content, @option => true).send(:"#{@option}?").should be_true
+        ROXML::Definition.new(:author, :content, @option => false).send(:"#{@option}?").should be_false
+      end
+
+      it "should default to false" do
+        ROXML::Definition.new(:author, :content).send(:"#{@option}?").should be_false
+      end
+    end
+
+    describe ":required" do
+      before do
+        @option = :required
+      end
+
+      it_should_behave_like "boolean option"
+
+      it "should not be allowed together with :else" do
+        proc { ROXML::Definition.new(:author, :content, :required => true, :else => 'Johnny') }.should raise_error(ArgumentError)
+        proc { ROXML::Definition.new(:author, :content, :required => false, :else => 'Johnny') }.should_not raise_error
+      end
+    end
+
+    describe ":frozen" do
+      before do
+        @option = :frozen
+      end
+
+      it_should_behave_like "boolean option"
+    end
+
+    describe ":cdata" do
+      before do
+        @option = :cdata
+      end
+
+      it_should_behave_like "boolean option"
+    end
+  end
+end