Empact-roxml 2.5.1 → 2.5.2

data/History.txt

@@ -1,3 +1,28 @@
+== 3.0 ???
+
+* major enhancements
+
+  * Remove previously deprecated functionality
+  * Error on any unrecognized options
+  * Normalize hash declaration syntax:
+    * for :key => '@string', string is taken to be the :from argument
+    * for :key => {:from => '@string', :as => Type}, the arguments are just the same as a regular declaration
+
+* minor enhancements
+
+  * Include 't' and 'f' in the list of possible boolean values, since rails uses them
+  * Remove :attrs hash syntax.  Not particularly helpful & somewhat obfuscatory.  Use :key, :value instead.
+  * Default attrs ending in '_at' to DateTime.  This can be overriden via :as
+  * Default attrs ending in '_on' to Date.  This can be overriden via :as
+
+== 2.5.2 (March 12, 2009)
+
+* minor enhancements
+
+  * Remove dependency on an Object#try which conflicted with ActiveSupport 2.3's version
+  * Document the :to_xml option for attr references
+  * Require active_support directly,  as it's less brittle and plays nicer with other libraries
+
 == 2.5.1 (March 2, 2009)
 
 * minor enhancements

data/Manifest.txt

@@ -21,7 +21,6 @@ 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
@@ -46,7 +45,6 @@ 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
@@ -83,7 +81,6 @@ 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
@@ -91,7 +88,6 @@ 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

data/README.rdoc

@@ -1,5 +1,15 @@
-ROXML Ruby Object to XML mapping library. For more information
-visit http://roxml.rubyforge.org
+ROXML Ruby Object to XML mapping library.
+
+For more information visit:
+
+    http://roxml.rubyforge.org/rdoc/
+    http://empact.github.com/roxml/
+    http://rubyforge.org/projects/roxml/
+
+Progress on this project is (more or less) tracked at:
+
+    http://www.pivotaltracker.com/project/4109
+
 
 =Quick Start Guide
 

data/examples/posts.rb

@@ -8,7 +8,7 @@ class Post
   xml_reader :hash, :from => :attr
   xml_reader :description, :from => :attr
   xml_reader :tag, :from => :attr
-  xml_reader :time, :from => :attr, :as => DateTime
+  xml_reader :created_at, :from => '@time'
   xml_reader :others, :from => :attr, :as => Integer
   xml_reader :extended, :from => :attr
 end

data/examples/twitter.rb

@@ -21,7 +21,7 @@ class Status
   
   xml_reader :id, :as => Integer
   xml_reader :text
-	xml_reader :created_at, :as => Time
+	xml_reader :created_at # This defaults to :as => DateTime, due to the '_at'
 	xml_reader :source
 	xml_reader :truncated?
 	xml_reader :in_reply_to_status_id, :as => Integer

data/lib/roxml.rb

@@ -8,84 +8,26 @@ require 'uri'
 end
 
 module ROXML # :nodoc:
-  VERSION = '2.5.1'
+  VERSION = '2.5.2'
 
   def self.included(base) # :nodoc:
-    base.extend ClassMethods::Accessors,
-                ClassMethods::Declarations,
-                ClassMethods::Operations
     base.class_eval do
-      include InstanceMethods::Accessors,
-              InstanceMethods::Construction,
-              InstanceMethods::Conversions
+      extend  ClassMethods::Accessors,
+              ClassMethods::Declarations,
+              ClassMethods::Operations
+      include InstanceMethods
     end
   end
 
   module InstanceMethods # :nodoc:
-    # Instance method equivalents of the Class method accessors
-    module Accessors # :nodoc:all
-      # Provides access to ROXML::ClassMethods::Accessors::tag_name directly from an instance of a ROXML class
-      def tag_name
-        self.class.tag_name
-      end
-      deprecate :tag_name => 'use class.tag_name instead'
-
-      # Provides access to ROXML::ClassMethods::Accessors::tag_refs directly from an instance of a ROXML class
-      def tag_refs
-        self.class.tag_refs_without_deprecation
-      end
-      deprecate :tag_refs => :roxml_attrs
-    end
-
-    module Construction
-      # xml_initialize is called at the end of the #from_xml operation on objects
-      # where xml_construct is not in place. Override xml_initialize in order to establish
-      # post-import behavior.  For example, you can use xml_initialize to map xml attribute
-      # values into the object standard initialize function, thus enabling a ROXML object
-      # to freely be either xml-backed or instantiated directly via #new.
-      # An example of this follows:
-      #
-      #  class Measurement
-      #    include ROXML
-      #
-      #    xml_reader :units, :from => :attr
-      #    xml_reader :value, :from => :content
-      #
-      #    def xml_initialize
-      #      # the object is instantiated, and all xml attributes are imported
-      #      # and available, i.e., value and units below are the same value and units
-      #      # found in the xml via the xml_reader declarations above.
-      #      initialize(value, units)
-      #    end
-      #
-      #    def initialize(value, units = 'pixels')
-      #      @value = Float(value)
-      #      @units = units.to_s
-      #      if @units.starts_with? 'hundredths-'
-      #        @value /= 100
-      #        @units = @units.split('hundredths-')[1]
-      #      end
-      #    end
-      #  end
-      #
-      # #xml_initialize may be written to take arguments, in which case extra arguments
-      # from from_xml will be passed into the function.
-      #
-      def xml_initialize # :nodoc:
-      end
-      deprecate :xml_initialize => :after_parse
-    end
-
-    module Conversions
-      # Returns a LibXML::XML::Node or a REXML::Element representing this object
-      def to_xml(name = nil)
-        returning XML::Node.new((name || self.class.tag_name).to_s) do |root|
-          self.class.roxml_attrs.each do |attr|
-            ref = attr.to_ref(self)
-            v = ref.to_xml
-            unless v.nil?
-              ref.update_xml(root, v)
-            end
+    # Returns a LibXML::XML::Node or a REXML::Element representing this object
+    def to_xml(name = self.class.tag_name)
+      returning XML::Node.new(name.to_s) do |root|
+        self.class.roxml_attrs.each do |attr|
+          ref = attr.to_ref(self)
+          value = ref.to_xml
+          unless value.nil?
+            ref.update_xml(root, value)
           end
         end
       end
@@ -169,13 +111,19 @@ module ROXML # :nodoc:
       # but in this case an underscored version of the name is applied, for convenience.
       def xml_convention(to_proc_able = nil, &block)
         raise ArgumentError, "conventions are already set" if @roxml_naming_convention
-        raise ArgumentError, "only one conventions can be set" if to_proc_able.respond_to?(:to_proc) && block_given?
-        @roxml_naming_convention = to_proc_able.try(:to_proc)
-        @roxml_naming_convention = block if block_given?
+        @roxml_naming_convention =
+          if to_proc_able
+            raise ArgumentError, "only one conventions can be set" if block_given?
+            to_proc_able.to_proc
+          elsif block_given?
+            block
+          end
       end
 
       def roxml_naming_convention # :nodoc:
-        (@roxml_naming_convention || superclass.try(:roxml_naming_convention)).freeze
+        (@roxml_naming_convention || begin
+          superclass.roxml_naming_convention if superclass.respond_to?(:roxml_naming_convention)
+        end).freeze
       end
 
       # Declares a reference to a certain xml element, whether an attribute, a node,
@@ -269,7 +217,7 @@ module ROXML # :nodoc:
       #
       #   xml_reader :counts, :as => [Integer]
       #
-      # Even an array of :text nodes can be specified with :as => []
+      # Even an array of text nodes can be specified with :as => []
       #
       #   xml_reader :quotes, :as => []
       #
@@ -320,7 +268,7 @@ module ROXML # :nodoc:
       # a collection of key-value pairs represented in your xml.  You create a hash declaration by
       # passing a hash mapping as the type argument.  A few examples:
       #
-      # ===== Hash of :texts
+      # ===== Hash of element contents
       # For xml such as this:
       #
       #    <dictionary>
@@ -439,30 +387,30 @@ module ROXML # :nodoc:
       # [:else] Default value for attribute, if missing from the xml on .from_xml
       # [:required] If true, throws RequiredElementMissing when the element isn't present
       # [:frozen] If true, all results are frozen (using #freeze) at parse-time.
-      # [:cdata] True for values which should be input from or output as cdata elements
-      #
-      def xml_attr(sym, type_and_or_opts = nil, opts = nil, &block)
-        returning Definition.new(sym, *[type_and_or_opts, opts].compact, &block) do |attr|
-          if roxml_attrs.map(&:accessor).include? attr.accessor
-            raise "Accessor #{attr.accessor} is already defined as XML accessor in class #{self.name}"
+      # [:cdata] true for values which should be input from or output as cdata elements
+      # [:to_xml] this proc is applied to the attributes value outputting the instance via #to_xml
+      #
+      def xml_attr(*syms, &block)
+        opts = syms.extract_options!
+        syms.map do |sym|
+          returning Definition.new(sym, opts, &block) do |attr|
+            if roxml_attrs.map(&:accessor).include? attr.accessor
+              raise "Accessor #{attr.accessor} is already defined as XML accessor in class #{self.name}"
+            end
+            @roxml_attrs << attr
           end
-          @roxml_attrs << attr
         end
       end
 
-      def xml(sym, writable = false, type_and_or_opts = nil, opts = nil, &block) #:nodoc:
-        send(writable ? :xml_accessor : :xml_reader, sym, type_and_or_opts, opts, &block)
-      end
-      deprecate :xml => "use xml_attr, xml_reader, or xml_accessor instead"
-
       # Declares a read-only xml reference. See xml_attr for details.
       #
       # Note that while xml_reader does not create a setter for this attribute,
       # its value can be modified indirectly via methods.  For more complete
       # protection, consider the :frozen option.
-      def xml_reader(sym, type_and_or_opts = nil, opts = nil, &block)
-        attr = xml_attr sym, type_and_or_opts, opts, &block
-        add_reader(attr)
+      def xml_reader(*syms, &block)
+        xml_attr(*syms, &block).each do |attr|
+          add_reader(attr)
+        end
       end
 
       # Declares a writable xml reference. See xml_attr for details.
@@ -470,45 +418,22 @@ module ROXML # :nodoc:
       # Note that while xml_accessor does create a setter for this attribute,
       # you can use the :frozen option to prevent its value from being
       # modified indirectly via methods.
-      def xml_accessor(sym, type_and_or_opts = nil, opts = nil, &block)
-        attr = xml_attr sym, type_and_or_opts, opts, &block
-        add_reader(attr)
-        attr_writer(attr.variable_name)
-      end
-
-      # This method is deprecated, please use xml_initialize instead
-      def xml_construct(*args) # :nodoc:
-        present_tags = tag_refs_without_deprecation.map(&:accessor)
-        missing_tags = args - present_tags
-        unless missing_tags.empty?
-          raise ArgumentError, "All construction tags must be declared first using xml, " +
-                               "xml_reader, or xml_accessor. #{missing_tags.join(', ')} is missing. " +
-                               "#{present_tags.join(', ')} are declared."
+      def xml_accessor(*syms, &block)
+        xml_attr(*syms, &block).each do |attr|
+          add_reader(attr)
+          attr_writer(attr.attr_name)
         end
-        @xml_construction_args = args
       end
-      deprecate :xml_construct => :xml_initialize
 
     private
       def add_reader(attr)
         define_method(attr.accessor) do
-          instance_variable_get("@#{attr.variable_name}")
+          instance_variable_get(attr.instance_variable_name)
         end
       end
     end
 
     module Accessors
-      def xml_construction_args # :nodoc:
-        @xml_construction_args ||= []
-      end
-      deprecate :xml_construction_args
-
-      # A helper which enables us to detect when the xml_name has been explicitly set
-      def xml_name? #:nodoc:
-        @roxml_tag_name
-      end
-      deprecate :xml_name?
-
       # Returns the tag name (also known as xml_name) of the class.
       # If no tag name is set with xml_name method, returns default class name
       # in lowercase.
@@ -526,24 +451,23 @@ module ROXML # :nodoc:
       end
 
       def roxml_tag_name # :nodoc:
-        @roxml_tag_name || superclass.try(:roxml_tag_name)
+        @roxml_tag_name || begin
+          superclass.roxml_tag_name if superclass.respond_to?(:roxml_tag_name)
+        end
       end
 
       def roxml_namespace # :nodoc:
-        @roxml_namespace || superclass.try(:roxml_namespace)
+        @roxml_namespace || begin
+          superclass.roxml_namespace if superclass.respond_to?(:roxml_namespace)
+        end
       end
 
       # Returns array of internal reference objects, such as attributes
       # and composed XML objects
       def roxml_attrs
         @roxml_attrs ||= []
-        (@roxml_attrs + (superclass.try(:roxml_attrs) || [])).freeze
-      end
-
-      def tag_refs # :nodoc:
-        roxml_attrs.map {|a| a.to_ref(nil) }
+        (@roxml_attrs + (superclass.respond_to?(:roxml_attrs) ? superclass.roxml_attrs : [])).freeze
       end
-      deprecate :tag_refs => :roxml_attrs
     end
 
     module Operations
@@ -569,32 +493,18 @@ module ROXML # :nodoc:
       def from_xml(data, *initialization_args)
         xml = XML::Node.from(data)
 
-        unless xml_construction_args_without_deprecation.empty?
-          args = xml_construction_args_without_deprecation.map do |arg|
-             roxml_attrs.find {|attr| attr.accessor == arg }
-          end.map {|attr| attr.to_ref(self).value_in(xml) }
-          new(*args)
-        else
-          returning new(*initialization_args) do |inst|
-            roxml_attrs.each do |attr|
-              value = attr.to_ref(inst).value_in(xml)
-              setter = :"#{attr.variable_name}="
-              inst.respond_to?(setter) \
-                ? inst.send(setter, value) \
-                : inst.instance_variable_set("@#{attr.variable_name}", value)
-            end
-            inst.try(:after_parse)
+        returning new(*initialization_args) do |inst|
+          roxml_attrs.each do |attr|
+            value = attr.to_ref(inst).value_in(xml)
+            inst.respond_to?(attr.setter) \
+              ? inst.send(attr.setter, value) \
+              : inst.instance_variable_set(attr.instance_variable_name, value)
           end
+          inst.send(:after_parse) if inst.respond_to?(:after_parse, true)
         end
       rescue ArgumentError => e
         raise e, e.message + " for class #{self}"
       end
-
-      # Deprecated in favor of #from_xml
-      def parse(data) # :nodoc:
-        from_xml(data)
-      end
-      deprecate :parse => :from_xml
     end
   end
 end

data/lib/roxml/definition.rb

@@ -12,47 +12,39 @@ end
 
 module ROXML
   class Definition # :nodoc:
-    attr_reader :name, :type, :wrapper, :hash, :blocks, :accessor, :to_xml
+    attr_reader :name, :type, :wrapper, :hash, :blocks, :accessor, :to_xml, :attr_name
     bool_attr_reader :name_explicit, :array, :cdata, :required, :frozen
 
-    class << self
-      def silence_xml_name_warning?
-        @silence_xml_name_warning || (ROXML.const_defined?('SILENCE_XML_NAME_WARNING') && ROXML::SILENCE_XML_NAME_WARNING)
-      end
-
-      def silence_xml_name_warning!
-        @silence_xml_name_warning = true
-      end
-    end
-
-    def initialize(sym, *args, &block)
-      @accessor = sym
-      if @accessor.to_s.ends_with?('_on')
-        ActiveSupport::Deprecation.warn "In 3.0, attributes with names ending with _on will default to Date type, rather than :text"
-      end
-      if @accessor.to_s.ends_with?('_at')
-        ActiveSupport::Deprecation.warn "In 3.0, attributes with names ending with _at will default to DateTime type, rather than :text"
-      end
+    def initialize(sym, opts = {}, &block)
+      opts.assert_valid_keys(:from, :in, :as,
+                             :else, :required, :frozen, :cdata, :to_xml)
+      @default = opts.delete(:else)
+      @to_xml = opts.delete(:to_xml)
+      @name_explicit = opts.has_key?(:from) && opts[:from].is_a?(String)
+      @cdata = opts.delete(:cdata)
+      @required = opts.delete(:required)
+      @frozen = opts.delete(:frozen)
+      @wrapper = opts.delete(:in)
 
-      opts = extract_options!(args)
-      opts[:as] ||= :bool if @accessor.to_s.ends_with?('?')
+      @accessor = sym.to_s
+      opts[:as] ||=
+        if @accessor.ends_with?('?')
+          :bool
+        elsif @accessor.ends_with?('_on')
+          Date
+        elsif @accessor.ends_with?('_at')
+          DateTime
+        end
 
-      @array = opts[:as].is_a?(Array) || extract_from_as(opts, :array, "Please use [] around your usual type declaration")
+      @array = opts[:as].is_a?(Array)
       @blocks = collect_blocks(block, opts[:as])
 
-      if opts.has_key?(:readonly)
-        raise ArgumentError, "There is no 'readonly' option. You probably mean to use :frozen => true"
-      end
-
-      @type = extract_type(args, opts)
-      if @type.try(:xml_name_without_deprecation?)
-        unless self.class.silence_xml_name_warning?
-          warn "WARNING: As of 2.3, a breaking change has been in the naming of sub-objects. " +
-               "ROXML now considers the xml_name of the sub-object before falling back to the accessor name of the parent. " +
-               "Use :from on the parent declaration to override this behavior. Set ROXML::SILENCE_XML_NAME_WARNING to avoid this message."
-          self.class.silence_xml_name_warning!
-        end
-        opts[:from] ||= @type.tag_name
+      @type = extract_type(opts[:as])
+      if @type.respond_to?(:roxml_tag_name)
+        # "WARNING: As of 2.3, a breaking change has been in the naming of sub-objects. " +
+        # "ROXML now considers the xml_name of the sub-object before falling back to the accessor name of the parent. " +
+        # "Use :from on the parent declaration to override this behavior. Set ROXML::SILENCE_XML_NAME_WARNING to avoid this message."
+        opts[:from] ||= @type.roxml_tag_name
       end
 
       if opts[:from] == :content
@@ -62,12 +54,15 @@ module ROXML
       elsif opts[:from] == :attr
         @type = :attr
         opts[:from] = nil
+      elsif opts[:from] == :name
+        opts[:from] = '*'
       elsif opts[:from].to_s.starts_with?('@')
         @type = :attr
         opts[:from].sub!('@', '')
       end
 
-      @name = (opts[:from] || variable_name).to_s
+      @attr_name = accessor.to_s.chomp('?')
+      @name = (opts[:from] || @attr_name).to_s
       @name = @name.singularize if hash? || array?
       if hash? && (hash.key.name? || hash.value.name?)
         @name = '*'
@@ -76,8 +71,12 @@ module ROXML
       raise ArgumentError, "Can't specify both :else default and :required" if required? && @default
     end
 
-    def variable_name
-      accessor.to_s.chomp('?')
+    def instance_variable_name
+      :"@#{attr_name}"
+    end
+
+    def setter
+      :"#{attr_name}="
     end
 
     def hash
@@ -127,23 +126,11 @@ module ROXML
       array ? results : results.first
     end
 
-    BLOCK_TO_FLOAT = lambda do |val|
-      all(val) do |v|
-        Float(v) unless v.blank?
-      end
-    end
-
-    BLOCK_TO_INT = lambda do |val|
-      all(val) do |v|
-        Integer(v) unless v.blank?
-      end
-    end
-
     def self.fetch_bool(value, default)
-      value = value.try(:downcase)
-      if %w{true yes 1}.include? value
+      value = value.to_s.downcase
+      if %w{true yes 1 t}.include? value
         true
-      elsif %w{false no 0}.include? value
+      elsif %w{false no 0 f}.include? value
         false
       else
         default
@@ -152,10 +139,16 @@ module ROXML
     
     CORE_BLOCK_SHORTHANDS = {
       # Core Shorthands
-      :integer => BLOCK_TO_INT, # deprecated
-      Integer  => BLOCK_TO_INT,
-      :float   => BLOCK_TO_FLOAT, # deprecated
-      Float    => BLOCK_TO_FLOAT,
+      Integer  => lambda do |val|
+        all(val) do |v|
+          Integer(v) unless v.blank?
+        end
+      end,
+      Float    => lambda do |val|
+        all(val) do |v|
+          Float(v) unless v.blank?
+        end
+      end,
       Fixnum   => lambda do |val|
         all(val) do |v|
           v.to_i unless v.blank?
@@ -203,9 +196,6 @@ module ROXML
     end
 
     def collect_blocks(block, as)
-      ActiveSupport::Deprecation.warn ":as => :float is deprecated.  Use :as => Float instead" if as == :float
-      ActiveSupport::Deprecation.warn ":as => :integer is deprecated.  Use :as => Integer instead" if as == :integer
-
       if as.is_a?(Array)
         unless as.one? || as.empty?
           raise ArgumentError, "multiple :as types (#{as.map(&:inspect).join(', ')}) is not supported.  Use a block if you want more complicated behavior."
@@ -220,104 +210,24 @@ module ROXML
         as = (block ? :bool_combined : :bool_standalone)
       end
       as = self.class.block_shorthands.fetch(as) do
-        unless as.respond_to?(:from_xml) || as.try(:first).respond_to?(:from_xml) || (as.is_a?(Hash) && !(as.keys & HASH_KEYS).empty?)
-          ActiveSupport::Deprecation.warn "#{as.inspect} is not a valid type declaration. ROXML will raise in this case in version 3.0" unless as.nil?
+        unless as.respond_to?(:from_xml) || (as.respond_to?(:first) && as.first.respond_to?(:from_xml)) || (as.is_a?(Hash) && !(as.keys & [:key, :value]).empty?)
+          raise ArgumentError, "Invalid :as argument #{as}" unless as.nil?
         end
         nil
       end
       [as, block].compact
     end
 
-    def extract_options!(args)
-      opts = args.extract_options!
-      unless (opts.keys & HASH_KEYS).empty?
-        args.push(opts)
-        opts = {}
-      end
-
-      @default = opts.delete(:else)
-      @to_xml = opts.delete(:to_xml)
-      @name_explicit = opts.has_key?(:from) && opts[:from].is_a?(String)
-      @cdata = opts.delete(:cdata)
-      @required = opts.delete(:required)
-      @frozen = opts.delete(:frozen)
-      @wrapper = opts.delete(:in)
-
-      @cdata ||= extract_from_as(opts, :cdata, "Please use :cdata => true")
-
-      if opts[:as].is_a?(Array) && opts[:as].size > 1
-        ActiveSupport::Deprecation.warn ":as should point to a single item. #{opts[:as].join(', ')} should be declared some other way."
-      end
-
-      opts
-    end
-
-    def extract_from_as(opts, entry, message)
-      # remove with deprecateds...
-      if [*opts[:as]].include?(entry)
-        ActiveSupport::Deprecation.warn ":as => #{entry.inspect} is deprecated. #{message}"
-        if opts[:as] == entry
-          opts[:as] = nil
-        else
-          opts[:as].delete(entry)
-        end
-        true
-      end
-    end
-
-    def extract_type(args, opts)
-      types = (opts.keys & TYPE_KEYS)
-      # type arg
-      if args.one? && types.empty?
-        type = args.first
-        if type.is_a? Array
-          ActiveSupport::Deprecation.warn "Array declarations should be passed as the :as parameter, for future release."
-          @array = true
-          return type.first || :text
-        elsif type.is_a? Hash
-          ActiveSupport::Deprecation.warn "Hash declarations should be passed as the :as parameter, for future release."
-          return HashDefinition.new(type)
-        elsif type == :content
-          ActiveSupport::Deprecation.warn ":content as a type declaration is deprecated.  Use :from => '.' or :from => :content instead"
-          opts[:from] = :content
-          return :text
-        elsif type == :attr
-          ActiveSupport::Deprecation.warn ":attr as a type declaration is deprecated.  Use :from => '@attr_name' or :from => :attr instead"
-          opts[:from].sub!('@', '') if opts[:from].to_s.starts_with?('@') # this is added back next line...
-          opts[:from] = opts[:from].nil? ? :attr : "@#{opts[:from]}"
-          return :attr
-        else
-          ActiveSupport::Deprecation.warn "Type declarations should be passed as the :as parameter, for future release."
-          return type
-        end
-      end
-
-      unless args.empty?
-        raise ArgumentError, "too many arguments (#{(args + types).join(', ')}).  Should be name, type, and " +
-                             "an options hash, with the type and options optional"
-      end
-
-      if opts[:as].is_a?(Hash)
-        return HashDefinition.new(opts[:as])
-      elsif opts[:as].respond_to?(:from_xml)
-        return opts[:as]
-      elsif opts[:as].is_a?(Array) && opts[:as].first.respond_to?(:from_xml)
+    def extract_type(as)
+      if as.is_a?(Hash)
+        return HashDefinition.new(as)
+      elsif as.respond_to?(:from_xml)
+        return as
+      elsif as.is_a?(Array) && as.first.respond_to?(:from_xml)
         @array = true
-        return opts[:as].first
-      end
-
-      # type options
-      if types.one?
-        opts[:from] = opts.delete(types.first)
-        if opts[:from] == :content
-          opts[:from] = 'content'
-          ActiveSupport::Deprecation.warn ":content is now a reserved as an alias for '.'. Use the string 'content' instead"
-        end
-        types.first
-      elsif types.empty?
-        :text
+        return as.first
       else
-        raise ArgumentError, "more than one type option specified: #{types.join(', ')}"
+        :text
       end
     end
   end