doxo-roxml 2.5.3

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

@@ -0,0 +1,84 @@
+require 'rexml/document'
+
+module ROXML
+  module XML # :nodoc:all
+    Document = REXML::Document
+    Node = REXML::Element
+
+    module Error
+      def self.reset_handler
+        # noop
+      end
+    end
+    [REXML::ParseException, REXML::UndefinedNamespaceException, REXML::Validation::ValidationException].each do |exception|
+      exception.send(:include, Error)
+    end
+
+    class Node
+      class << self
+        def new_cdata(content)
+          REXML::CData.new(content)
+        end
+      end
+
+      alias_attribute :content, :text
+
+      def search(xpath)
+        begin
+          REXML::XPath.match(self, xpath)
+        rescue Exception => ex
+          raise ex, xpath
+        end
+      end
+
+      def add_child(element)
+        if element.is_a?(REXML::CData)
+          REXML::CData.new(element, true, self)
+        else
+          add_element(element)
+        end
+      end
+
+      def ==(other)
+        to_s == other.to_s
+      end
+    end
+
+    class Parser
+      class << self
+        def parse(source)
+          REXML::Document.new(source, :ignore_whitespace_nodes => :all)
+        end
+
+        def parse_file(path) #:nodoc:
+          path = path.sub('file:', '') if path.starts_with?('file:')
+          parse(open(path))
+        end
+
+        def parse_io(path) #:nodoc:
+          parse(path)
+        end
+
+        def register_error_handler(&block)
+        end
+      end
+      ParseError = REXML::ParseException
+    end
+
+    class Document
+      delegate :search, :to => :root
+
+      def root=(node)
+        raise ArgumentError, "Root is already defined" if root
+        add(node)
+      end
+
+      def save(destination, opts = {:formatter => REXML::Formatters::Default.new})
+        self << REXML::XMLDecl.new unless xml_decl != REXML::XMLDecl.default # always output xml declaration
+        File.open(destination, "w") do |f|
+          opts[:formatter].write(self, f)
+        end
+      end
+    end
+  end
+end

data/lib/roxml/xml/references.rb

@@ -0,0 +1,299 @@
+module ROXML
+  class RequiredElementMissing < Exception # :nodoc:
+  end
+  
+  #
+  # Internal base class that represents an XML - Class binding.
+  #
+  class XMLRef # :nodoc:
+    delegate :required?, :array?, :blocks, :accessor, :default, :to => :opts
+
+    def initialize(opts, instance)
+      @opts = opts
+      @instance = instance
+    end
+
+    def to_xml
+      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
+
+    def xpath_name
+      if !opts.name_explicit? && namespace = @instance.class.roxml_namespace
+        "#{namespace}:#{name}"
+      else
+        name
+      end
+    end
+
+    def value_in(xml)
+      xml = XML::Node.from(xml)
+      value = fetch_value(xml)
+      value = default if value.nil?
+
+      freeze(apply_blocks(value))
+    end
+
+  private
+    attr_reader :opts
+
+    def conventionize(what)
+      convention ||= @instance.class.respond_to?(:roxml_naming_convention) && @instance.class.roxml_naming_convention
+      if !what.blank? && convention.respond_to?(:call)
+        URI.unescape(convention.call(URI.escape(what, /\/|::/)))
+      else
+        what
+      end
+    end
+
+    def wrapper
+      conventionize(opts.wrapper)
+    end
+
+    def apply_blocks(val)
+      begin
+        blocks.apply_to(val)
+      rescue Exception => ex
+        raise ex, "#{accessor}: #{ex.message}"
+      end
+    end
+
+    def freeze(val)
+      if opts.frozen?
+        val.each(&:freeze) if val.is_a?(Enumerable)
+        val.freeze
+      else
+        val
+      end
+    end
+
+    def xpath
+      wrapper ? "#{wrapper}/#{xpath_name}" : xpath_name.to_s
+    end
+
+    def auto_xpath
+      "#{conventionize(opts.name.pluralize)}/#{xpath_name}" if array?
+    end
+
+    def wrap(xml)
+      return xml if !wrapper || xml.name == wrapper
+      if child = xml.children.find {|c| c.name == wrapper }
+       return child
+      end
+      xml.add_child(XML::Node.new(wrapper.to_s))
+    end
+
+    def nodes_in(xml)
+      vals = xml.search(xpath)
+
+      if (opts.hash? || opts.array?) && vals.empty? && !wrapper && auto_xpath
+        vals = xml.search(auto_xpath)
+        @auto_vals = !vals.empty?
+      end
+
+      if vals.empty?
+        raise RequiredElementMissing, "#{name} from #{xml} for #{accessor}" if required?
+        default
+      else
+        yield(vals)
+      end
+    end
+  end
+
+  # Interal class representing an XML attribute binding
+  #
+  # In context:
+  #  <element attribute="XMLAttributeRef">
+  #   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
+    end
+
+    def fetch_value(xml)
+      nodes_in(xml) do |nodes|
+        nodes.first.value
+      end
+    end
+
+    def xpath_name
+      "@#{name}"
+    end
+  end
+
+  # Interal class representing XML content text binding
+  #
+  # In context:
+  #  <element attribute="XMLAttributeRef">
+  #   XMLTextRef
+  #  </element>
+  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.new(name)), v)
+        end
+      else
+        add(xml.add_child(XML::Node.new(name)), value)
+      end
+    end
+
+    def fetch_value(xml)
+      if content? || name?
+        value =
+          if content?
+            xml.content.to_s.strip
+          elsif name?
+            xml.name
+          end
+
+        if value.empty?
+          raise RequiredElementMissing, "#{name} from #{xml} for #{accessor}" if required?
+          default
+        else
+          value
+        end
+      else
+        nodes_in(xml) do |nodes|
+          if array?
+            nodes.collect do |e|
+              e.content.strip
+            end
+          else
+            nodes.first.content
+          end
+        end
+      end
+    end
+
+    def add(dest, value)
+      if cdata?
+        dest.child_add(XML::Node.new_cdata(value.to_s))
+      else
+        dest.content = value.to_s
+      end
+    end
+  end
+
+  class XMLHashRef < XMLTextRef # :nodoc:
+    delegate :hash, :to => :opts
+
+    def initialize(opts, inst)
+      super(opts, inst)
+      @key = opts.hash.key.to_ref(inst)
+      @value = opts.hash.value.to_ref(inst)
+    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.child_add(XML::Node.new(hash.wrapper))
+        @key.update_xml(node, k)
+        @value.update_xml(node, v)
+      end
+    end
+
+    def fetch_value(xml)
+      nodes_in(xml) do |nodes|
+        nodes.collect do |e|
+          [@key.value_in(e), @value.value_in(e)]
+        end
+      end
+    end
+
+    def apply_blocks(vals)
+      unless blocks.empty?
+        vals.collect! do |kvp|
+          super(kvp)
+        end
+      end
+      to_hash(vals) if vals
+    end
+
+    def freeze(vals)
+      if opts.frozen?
+        vals.each_pair{|k, v| k.freeze; v.freeze }
+        vals.freeze
+      else
+        vals
+      end
+    end
+
+    def to_hash(array)
+      hash = array.inject({}) do |result, (k, v)|
+        result[k] ||= []
+        result[k] << v
+        result
+      end
+      hash.each_pair do |k, v|
+        hash[k] = v.first if v.one?
+      end
+    end
+  end
+
+  class XMLObjectRef < XMLTextRef # :nodoc:
+    delegate :type, :to => :opts
+
+  private
+    # Updates the composed XML object in the given XML block to
+    # the value provided.
+    def write_xml(xml, value)
+      if array?
+        value.each do |v|
+          xml.child_add(v.to_xml(name))
+        end
+      elsif value.is_a?(ROXML)
+        xml.child_add(value.to_xml(name))
+      else
+        node = XML::Node.new(name)
+        node.content = value.to_xml
+        xml.child_add(node)
+      end
+    end
+
+    def fetch_value(xml)
+      nodes_in(xml) do |nodes|
+        unless array?
+          instantiate(nodes.first)
+        else
+          nodes.collect do |e|
+            instantiate(e)
+          end
+        end
+      end
+    end
+
+    def instantiate(elem)
+      if type.respond_to? :from_xml
+        type.from_xml(elem)
+      else
+        type.new(elem)
+      end
+    end
+  end
+end

data/roxml.gemspec

@@ -0,0 +1,50 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{roxml}
+  s.version = "2.5.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-03-22}
+  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/active_record.rb", "examples/amazon.rb", "examples/current_weather.rb", "examples/dashed_elements.rb", "examples/library.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/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/library_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/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/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_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}
+  s.summary = %q{Ruby Object to XML mapping library}
+  s.test_files = ["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_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"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    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>, [">= 1.0.0"])
+      s.add_development_dependency(%q<newgem>, [">= 1.3.0"])
+      s.add_development_dependency(%q<sqlite3-ruby>, [">= 1.2.4"])
+      s.add_development_dependency(%q<activerecord>, [">= 2.2.2"])
+      s.add_development_dependency(%q<hoe>, [">= 1.8.0"])
+    else
+      s.add_dependency(%q<activesupport>, [">= 2.1.0"])
+      s.add_dependency(%q<libxml-ruby>, [">= 1.0.0"])
+      s.add_dependency(%q<newgem>, [">= 1.3.0"])
+      s.add_dependency(%q<sqlite3-ruby>, [">= 1.2.4"])
+      s.add_dependency(%q<activerecord>, [">= 2.2.2"])
+      s.add_dependency(%q<hoe>, [">= 1.8.0"])
+    end
+  else
+    s.add_dependency(%q<activesupport>, [">= 2.1.0"])
+    s.add_dependency(%q<libxml-ruby>, [">= 1.0.0"])
+    s.add_dependency(%q<newgem>, [">= 1.3.0"])
+    s.add_dependency(%q<sqlite3-ruby>, [">= 1.2.4"])
+    s.add_dependency(%q<activerecord>, [">= 2.2.2"])
+    s.add_dependency(%q<hoe>, [">= 1.8.0"])
+  end
+end

data/spec/definition_spec.rb

@@ -0,0 +1,490 @@
+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 "DateTime reference", :shared => true do
+    it "should return nil on empty string" do
+      @subject.blocks.first.call("  ").should be_nil
+    end
+
+    it "should return a time version of the string" do
+      @subject.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
+        @subject.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
+
+  describe "Date reference", :shared => true do
+    it "should return nil on empty string" do
+      @subject.blocks.first.call("  ").should be_nil
+    end
+
+    it "should return a time version of the string" do
+      @subject.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
+        @subject.blocks.first.call(["September 3rd, 1970", "1776-07-04"]).map(&:to_s).should == ["1970-09-03", "1776-07-04"]
+      end
+    end
+  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
+
+  describe "attr name" do
+    context "when ending with '_at'" do
+      context "and without an :as argument" do
+        before(:all) do
+          @subject = ROXML::Definition.new(:time_at)
+        end
+        it_should_behave_like "DateTime reference"
+      end
+    end
+
+    context "when ending with '_on'" do
+      context "and without an :as argument" do
+        before(:all) do
+          @subject = ROXML::Definition.new(:created_on)
+        end
+        it_should_behave_like "Date reference"
+      end
+    end
+  end
+
+  describe ":as" do
+    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
+    end
+
+    describe "=> RoxmlClass" do
+      class RoxmlClass
+        include ROXML
+      end
+
+      it "should store type" do
+        opts = ROXML::Definition.new(:name, :as => RoxmlClass)
+        opts.type.should == RoxmlClass
+      end
+    end
+
+    describe "=> NonRoxmlClassWithFromXmlDefined" do
+      class OctalInteger
+        def self.from_xml(val)
+          new(Integer(val.content))
+        end
+      end
+
+      it "should accept type" do
+        opts = ROXML::Definition.new(:name, :as => OctalInteger)
+        opts.type.should == OctalInteger
+      end
+    end
+
+    describe "=> NonRoxmlClass" do
+      it "should fail with a warning" do
+        proc { ROXML::Definition.new(:authors, :as => Module) }.should raise_error(ArgumentError)
+      end
+    end
+
+    describe "=> [NonRoxmlClass]" do
+      it "should raise" do
+        proc { ROXML::Definition.new(:authors, :as => [Module]) }.should raise_error(ArgumentError)
+      end
+    end
+
+    describe "=> {}" do
+      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 "hash with attr key and text val" do
+        before do
+          @opts = ROXML::Definition.new(:attributes, :as => {:key => '@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 => 'name',
+                                                             :value => '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 => '@name',
+                                                             :value => :content})
+          @hash_args = {:key => {:attr => 'name'}, :value => {:text => '.'}}
+        end
+
+        it_should_behave_like "hash options declaration"
+      end
+
+      describe "hash with names as keys and content vals" do
+        before do
+          @opts = ROXML::Definition.new(:attributes, :as => {:key => :name,
+                                                             :value => :content})
+          @hash_args = {:key => {:text => '*'}, :value => {:text => '.'}}
+        end
+
+        it_should_behave_like "hash options declaration"
+      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
+      end
+
+      it "should raise on unknown :as" do
+        proc { ROXML::Definition.new(:count, :as => :bogus) }.should raise_error(ArgumentError)
+        proc { ROXML::Definition.new(:count, :as => :foat) }.should raise_error(ArgumentError)
+      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 "Integer" do
+        before do
+          @definition = ROXML::Definition.new(:intvalue, :as => Integer)
+        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
+        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 "Float" do
+        before do
+          @definition = ROXML::Definition.new(:floatvalue, :as => Float)
+        end
+
+        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 "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
+        before do
+          @subject = ROXML::Definition.new(:datevalue, :as => Date)
+        end
+        it_should_behave_like "Date reference"
+      end
+
+      describe "DateTime" do
+        before do
+          @subject = ROXML::Definition.new(:datevalue, :as => DateTime)
+        end
+        it_should_behave_like "DateTime reference"
+      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"
+    end
+
+    describe ":content" do
+      it "should be recognized" do
+        ROXML::Definition.new(:author).content?.should be_false
+        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, :from => :content, @option => true).respond_to?(:"#{@option}?")
+        ROXML::Definition.new(:author, :from => :content, @option => true).send(:"#{@option}?").should be_true
+        ROXML::Definition.new(:author, :from => :content, @option => false).send(:"#{@option}?").should be_false
+      end
+
+      it "should default to false" do
+        ROXML::Definition.new(:author, :from => :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, :from => :content, :required => true, :else => 'Johnny') }.should raise_error(ArgumentError)
+        proc { ROXML::Definition.new(:author, :from => :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