Empact-roxml 2.5.1 → 2.5.2

data/lib/roxml/extensions.rb

@@ -1,3 +1,6 @@
-%w(active_support deprecation array string).each do |file|
+require 'rubygems'
+require 'active_support'
+
+%w(deprecation array string).each do |file|
   require File.join(File.dirname(__FILE__), 'extensions', file)
 end

data/lib/roxml/extensions/array/conversions.rb

@@ -2,29 +2,6 @@ module ROXML
   module CoreExtensions
     module Array #:nodoc:all
       module Conversions
-        # Translates an array into a hash, where each element of the array is
-        # an array with 2 elements:
-        #
-        #   >> [[:key, :value], [1, 2], ['key', 'value']].to_h
-        #   => {:key => :value, 1 => 2, 'key' => 'value'}
-        #
-        def to_hash
-          hash = 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
-          hash
-        end
-
-        def to_h #:nodoc:
-          to_hash
-        end
-        deprecate :to_h => :to_hash
-
         def apply_to(val)
           # Only makes sense for arrays of blocks... maybe better outside Array...
           inject(val) {|val, block| block.call(val) }

data/lib/roxml/extensions/deprecation.rb

@@ -7,7 +7,7 @@ module ActiveSupport # :nodoc:all
   module Deprecation
     class << self
       def warn_with_internals_exclusion(message = nil, callstack = caller)
-        warn_without_internals_exclusion(message, callstack.reject {|line| line =~  /\/roxml(-[\d\.]+)?\/lib\// })
+        warn_without_internals_exclusion(message, callstack.reject {|line| line =~  /\/roxml(-[\d\.]+)?\/lib\// || line.include?('lib/roxml.rb') })
       end
       alias_method_chain :warn, :internals_exclusion
 

data/lib/roxml/extensions/string.rb

@@ -2,20 +2,5 @@ require File.join(File.dirname(__FILE__), 'string/conversions')
 require File.join(File.dirname(__FILE__), 'string/iterators')
 
 class String #:nodoc:
-  include ROXML::CoreExtensions::String::Conversions
   include ROXML::CoreExtensions::String::Iterators
-end
-
-class Object #:nodoc:
-  # Deprecated in favor of explicit #to_s.to_utf
-  def to_utf
-    ActiveSupport::Deprecation.warn "This method will be removed from Object please use String#to_utf instead via explicit #to_s"
-    to_s.to_utf
-  end
-
-  # Deprecated in favor of explicit #to_s.to_latin
-  def to_latin
-    ActiveSupport::Deprecation.warn "This method will be removed from Object please use String#to_latin instead via explicit #to_s"
-    to_s.to_latin
-  end
 end

data/lib/roxml/extensions/string/conversions.rb

@@ -1,41 +1,3 @@
-module ROXML
-  module CoreExtensions #:nodoc:
-    module String
-      # Extension of String class to handle conversion from/to
-      # UTF-8/ISO-8869-1
-      module Conversions
-        require 'iconv'
-
-        #
-        # Return an utf-8 representation of this string.
-        #
-        def to_utf
-          begin
-            Iconv.new("utf-8", "iso-8859-1").iconv(to_s)
-          rescue Iconv::IllegalSequence
-            STDERR << "!! Failed converting from UTF-8 -> ISO-8859-1 (#{self}). Already the right charset?"
-            self
-          end
-        end
-        deprecate :to_utf
-
-        #
-        # Convert this string to iso-8850-1
-        #
-        def to_latin
-          begin
-            Iconv.new("iso-8859-1", "utf-8").iconv(to_s)
-          rescue Iconv::IllegalSequence
-            STDERR << "!! Failed converting from ISO-8859-1 -> UTF-8 (#{self}). Already the right charset?"
-            self
-          end
-        end
-        deprecate :to_latin
-      end
-    end
-  end
-end
-
 class String
   def between(separator, &block)
     split(separator).collect(&block).join(separator)

data/lib/roxml/hash_definition.rb

@@ -1,60 +1,25 @@
 module ROXML
-  HASH_KEYS = [:attrs, :key, :value].freeze
-  TYPE_KEYS = [:attr, :text, :hash, :content].freeze
-
   class HashDefinition # :nodoc:
     attr_reader :key, :value
     attr_accessor :wrapper
 
     def initialize(opts)
-      unless (invalid_keys = opts.keys - HASH_KEYS).empty?
-        raise ArgumentError, "Invalid Hash description keys: #{invalid_keys.join(', ')}"
-      end
+      opts.assert_valid_keys(:key, :value)
 
-      if opts.has_key? :attrs
-        ActiveSupport::Deprecation.warn(":as => {:attrs} is going away in 3.0.  Use explicit :key and :value instead.")
-        @key   = to_hash_args(opts, :from => "@#{opts[:attrs][0]}")
-        @value = to_hash_args(opts, :from => "@#{opts[:attrs][1]}")
-      else
-        @key = to_hash_args opts, fetch_element(opts, :key)
-        @value = to_hash_args opts, fetch_element(opts, :value)
-      end
+      @key = Definition.new(nil, to_definition_options(opts, :key))
+      @value = Definition.new(nil, to_definition_options(opts, :value))
     end
 
   private
-    def fetch_element(opts, what)
+    def to_definition_options(opts, what)
       case opts[what]
       when Hash
-        if opts[what].keys.one?
-          ActiveSupport::Deprecation.warn(":as => {:key => {Type => 'name'} ... } is going away in 3.0.  Use explicit :key => {:from => 'name', :as => Type} instead.")
-          type = opts[what].keys.first
-          case type
-          when :attr
-            {:from => "@#{opts[what][type]}"}
-          when :text
-            {:from => opts[what][type]}
-          else
-            {:as => type, :from => opts[what][type]}
-          end
-        else
-          opts[what]
-        end
+        opts[what]
       when String, Symbol
         {:from => opts[what]}
       else
         raise ArgumentError, "unrecognized hash parameter: #{what} => #{opts[what]}"
       end
     end
-
-    def to_hash_args(args, opts)
-      args = [args] unless args.is_a? Array
-
-      if args.one? && !(args.first.keys & HASH_KEYS).empty?
-        Definition.new(nil, opts)
-      else
-        opts = args.extract_options!
-        raise opts.inspect
-      end
-    end
   end
 end

data/lib/roxml/xml/references.rb

@@ -6,7 +6,7 @@ module ROXML
   # Internal base class that represents an XML - Class binding.
   #
   class XMLRef # :nodoc:
-    delegate :required?, :array?, :blocks, :accessor, :variable_name, :default, :to => :opts
+    delegate :required?, :array?, :blocks, :accessor, :default, :to => :opts
 
     def initialize(opts, instance)
       @opts = opts
@@ -48,8 +48,9 @@ module ROXML
     attr_reader :opts
 
     def conventionize(what)
-      if !what.blank? && @instance.try(:class).try(:roxml_naming_convention).respond_to?(:call)
-        URI.unescape(@instance.class.roxml_naming_convention.call(URI.escape(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
@@ -120,7 +121,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_without_deprecation
+      xml.attributes[name] = value.to_s
     end
 
     def fetch_value(xml)
@@ -179,7 +180,7 @@ module ROXML
         nodes_in(xml) do |nodes|
           if array?
             nodes.collect do |e|
-              e.content.strip.to_latin_without_deprecation
+              e.content.strip
             end
           else
             nodes.first.content
@@ -190,9 +191,9 @@ module ROXML
 
     def add(dest, value)
       if cdata?
-        dest.child_add(XML::Node.new_cdata(value.to_s.to_utf_without_deprecation))
+        dest.child_add(XML::Node.new_cdata(value.to_s))
       else
-        dest.content = value.to_s.to_utf_without_deprecation
+        dest.content = value.to_s
       end
     end
   end
@@ -231,7 +232,7 @@ module ROXML
           super(kvp)
         end
       end
-      vals.to_hash if vals
+      to_hash(vals) if vals
     end
 
     def freeze(vals)
@@ -242,6 +243,17 @@ module ROXML
         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:

data/roxml.gemspec

@@ -2,15 +2,15 @@
 
 Gem::Specification.new do |s|
   s.name = %q{roxml}
-  s.version = "2.5.1"
+  s.version = "2.5.2"
 
   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-02}
+  s.date = %q{2009-03-12}
   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/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/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/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.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"]
@@ -18,7 +18,7 @@ Gem::Specification.new do |s|
   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_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"]
+  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_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

data/spec/definition_spec.rb

@@ -17,141 +17,132 @@ describe ROXML::Definition do
     end
   end
 
-  describe "hash options declaration", :shared => true do
-    it "should represent a hash" do
-      @opts.hash?.should be_true
+  describe "DateTime reference", :shared => true do
+    it "should return nil on empty string" do
+      @subject.blocks.first.call("  ").should be_nil
     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]
+    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
 
-    it "should not represent an array" do
-      @opts.array?.should be_false
+    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 "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
+  describe "Date reference", :shared => true do
+    it "should return nil on empty string" do
+      @subject.blocks.first.call("  ").should be_nil
+    end
 
-      it "should be deprecated"
+    it "should return a time version of the string" do
+      @subject.blocks.first.call("September 3rd, 1970").to_s == "1970-09-03"
     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
+    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 "[:text] means array of texts" do
-        opts = ROXML::Definition.new(:authors, [:text])
-        opts.array?.should be_true
-        opts.type.should == :text
+  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
 
-      it "[:attr] means array of attrs" do
-        opts = ROXML::Definition.new(:authors, [:attr])
-        opts.array?.should be_true
-        opts.type.should == :attr
+    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
 
-      it "[Object] means array of objects" do
-        opts = ROXML::Definition.new(:authors, [Hash])
+  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 == Hash
+        opts.type.should == :text
       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"
+    describe "=> RoxmlClass" do
+      class RoxmlClass
+        include ROXML
       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"
+      it "should store type" do
+        opts = ROXML::Definition.new(:name, :as => RoxmlClass)
+        opts.type.should == RoxmlClass
       end
+    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 => '.'}}
+    describe "=> NonRoxmlClassWithFromXmlDefined" do
+      class OctalInteger
+        def self.from_xml(val)
+          new(Integer(val.content))
         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
+      it "should accept type" do
+        opts = ROXML::Definition.new(:name, :as => OctalInteger)
+        opts.type.should == OctalInteger
       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
+    describe "=> NonRoxmlClass" do
+      it "should fail with a warning" do
+        proc { ROXML::Definition.new(:authors, :as => Module) }.should raise_error(ArgumentError)
       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?"]
+    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 => {:attr => :name},
-                                                             :value => :value})
+          @opts = ROXML::Definition.new(:attributes, :as => {:key => '@name',
+                                                             :value => 'value'})
           @hash_args = {:key => {:attr => 'name'},
                         :value => {:text => 'value'}}
         end
@@ -161,8 +152,8 @@ describe ROXML::Definition do
 
       describe "hash with String class for type" do
         before do
-          @opts = ROXML::Definition.new(:attributes, :as => {:key => {String => 'name'},
-                                                             :value => {String => 'value'}})
+          @opts = ROXML::Definition.new(:attributes, :as => {:key => 'name',
+                                                             :value => 'value'})
           @hash_args = {:key => {:text => 'name'}, :value => {:text => 'value'}}
         end
 
@@ -171,7 +162,7 @@ describe ROXML::Definition do
 
       describe "hash with attr key and content val" do
         before do
-          @opts = ROXML::Definition.new(:attributes, :as => {:key => {:attr => :name},
+          @opts = ROXML::Definition.new(:attributes, :as => {:key => '@name',
                                                              :value => :content})
           @hash_args = {:key => {:attr => 'name'}, :value => {:text => '.'}}
         end
@@ -179,27 +170,14 @@ describe ROXML::Definition do
         it_should_behave_like "hash options declaration"
       end
 
-      describe "hash of attrs" do
+      describe "hash with names as keys and content vals" do
         before do
-          @hash_args = {:key => {:attr => 'name'}, :value => {:attr => 'value'}}
-          @opts = ROXML::Definition.new(:attributes, :as => {:attrs => [:name, :value]})
+          @opts = ROXML::Definition.new(:attributes, :as => {:key => :name,
+                                                             :value => :content})
+          @hash_args = {:key => {:text => '*'}, :value => {:text => '.'}}
         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
 
@@ -221,8 +199,11 @@ describe ROXML::Definition do
 
       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
+
+      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
@@ -236,7 +217,11 @@ describe ROXML::Definition do
         end
       end
 
-      describe ":as => Integer", :shared => true do
+      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
@@ -258,25 +243,11 @@ describe ROXML::Definition do
         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
+      describe "Float" do
         before do
-          @definition = ROXML::Definition.new(:intvalue, :as => :integer)
+          @definition = ROXML::Definition.new(:floatvalue, :as => Float)
         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
@@ -296,24 +267,6 @@ describe ROXML::Definition do
         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)
@@ -408,35 +361,17 @@ describe ROXML::Definition do
       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
+        before do
+          @subject = ROXML::Definition.new(:datevalue, :as => Date)
         end
+        it_should_behave_like "Date reference"
       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
+        before do
+          @subject = ROXML::Definition.new(:datevalue, :as => DateTime)
         end
+        it_should_behave_like "DateTime reference"
       end
 
       it "should prohibit multiple shorthands" do
@@ -481,19 +416,11 @@ describe ROXML::Definition do
       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).content?.should be_false
         ROXML::Definition.new(:author, :from => :content).content?.should == true
       end
 
@@ -521,13 +448,13 @@ describe ROXML::Definition 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
+        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, :content).send(:"#{@option}?").should be_false
+        ROXML::Definition.new(:author, :from => :content).send(:"#{@option}?").should be_false
       end
     end
 
@@ -539,8 +466,8 @@ describe ROXML::Definition do
       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
+        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