roxml 2.5.3 → 3.1.0

data/.gitignore

@@ -0,0 +1,7 @@
+spec/**/*.xml
+rdoc
+build
+doc
+Rake.config
+pkg
+.project

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "vendor/override_rake_task"]
+	path = vendor/override_rake_task
+	url = git://github.com/Empact/override_rake_task.git

data/History.txt

@@ -1,3 +1,40 @@
+== 3.1 (October 16, 2009)
+
+* major enhancements
+
+  * Add support for registering XML namespace prefixes via the xml_namespaces method
+
+* bug fix
+
+  * References to arrays of attributes were only returning the first.  No more.
+
+== 3.0 (October 14, 2009)
+
+* major enhancements
+
+  * Add Nokogiri support
+  * Remove previously deprecated functionality
+  * Remove REXML support
+  * 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
+  * Don't require rubygems within the library
+  * Don't mess with the load path
+
+== 2.5.4 (October 4, 2009)
+
+* bug fix
+
+  * Rely on REXML's #add_child and LibXML's <<, rather than #child_add which had been removed from REXML and deprecated from LibXML
+
 == 2.5.3 (March 22, 2009)
 
 * minor enhancement
@@ -27,7 +64,7 @@
 
 * major enhancements
 
-   * support for mapping ActiveRecord classes.  See examples/active_record.rb.
+   * support for mapping ActiveRecord classes.  See examples/rails.rb.
    * .from_xml will now use the setter for the declared variable, if one is available,
      rather than directly setting the instance variable
    * All declaration type arguments are now supported via the :as parameter, e.g. :as => [MyType].  Other uses are deprecated.

data/README.rdoc

@@ -6,10 +6,9 @@ For more information visit:
     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
+Please submit bugs here:
 
+    http://github.com/Empact/roxml/issues
 
 =Quick Start Guide
 
@@ -94,6 +93,10 @@ Note: In the above example, _xml_name_ annotation tells ROXML to set the element
 name to "book" for mapping to XML. The default is XML element name is the class name in lowercase; "bookwithpublisher"
 in this case.
 
+=== Namespace Support
+
+Namespaces are supported via the xml_namespace declaration and the :from and :namespace attr options.  See spec/xml/namespace_spec.rb for usage.
+
 == Manipulation
 
 Extending the above examples, say you want to parse a book's page count and have it available as an Integer.
@@ -147,11 +150,11 @@ which may be used via _new_ construction as well as _from_xml_ construction.
 
 == Selecting a parser
 
-By default, ROXML will use LibXML if it is available, or otherwise REXML.  If you'd like to
+By default, ROXML will use Nokogiri if it is available, followed by LibXML.  If you'd like to
 explicitly require one or the other, you may do the following:
 
   module ROXML
-    XML_PARSER = 'libxml' # or 'rexml'
+    XML_PARSER = 'nokogiri' # or 'libxml'
   end
   require 'roxml'
 

data/Rakefile

@@ -1,51 +1,55 @@
-module Enumerable
-  undef_method(:one?)
-end if [].respond_to?(:one?)
+require 'rake'
 
 ENV['RUBY_FLAGS'] = '-W1'
 
-%w[rubygems rake rake/clean fileutils newgem rubigen].each { |f| require f }
-require File.expand_path(File.dirname(__FILE__) + '/lib/roxml')
-
 # Generate all the Rake tasks
 # Run 'rake -T' to see list of generated tasks (from gem root directory)
-$hoe = Hoe.new('roxml', ROXML::VERSION) do |p|
-  p.author = ["Ben Woosley", "Zak Mandhro", "Anders Engstrom", "Russ Olsen"]
-  p.email = "ben.woosley@gmail.com"
-  p.url = "http://roxml.rubyforge.org"
-  p.changes              = File.read("History.txt").split(/^==/)[1].strip
-  p.rubyforge_name       = p.name
-  p.extra_deps         = [
-   ['activesupport','>= 2.1.0'],
-   ['libxml-ruby', '>= 1.0.0']
-  ]
-  p.extra_dev_deps = [
-    ['newgem', ">= #{::Newgem::VERSION}"],
-    ['sqlite3-ruby', '>= 1.2.4' ],
-    ['activerecord', '>= 2.2.2' ]
-  ]
-
-  p.summary = "Ruby Object to XML mapping library"
-  p.description = <<EOF
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  gem.name = 'roxml'
+  gem.rubyforge_project = "roxml"
+  gem.summary = "Ruby Object to XML mapping library"
+  gem.description = <<EOF
 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.
 EOF
+  gem.email = "ben.woosley@gmail.com"
+  gem.homepage = "http://roxml.rubyforge.org"
+  gem.authors = ["Ben Woosley", "Zak Mandhro", "Anders Engstrom", "Russ Olsen"]
 
-  p.test_globs = 'test/unit/*_test.rb'
-  p.clean_globs |= %w[**/.DS_Store tmp *.log]
-  path = (p.rubyforge_name == p.name) ? p.rubyforge_name : "\#{p.rubyforge_name}/\#{p.name}"
-  p.remote_rdoc_dir = File.join(path.gsub(/^#{p.rubyforge_name}\/?/,''), 'rdoc')
-  p.rsync_args = '-av --delete --ignore-errors'
-end
+  gem.extra_rdoc_files = ["History.txt", "Manifest.txt", "README.rdoc"]
 
-require 'newgem/tasks' # load /tasks/*.rake
+  gem.add_dependency 'activesupport', '>= 2.1.0'
+  gem.add_dependency 'nokogiri', '>= 1.3.3'
+
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "sqlite3-ruby", '>= 1.2.4'
+  gem.add_development_dependency "activerecord", '>= 2.2.2'
+end
+Jeweler::GemcutterTasks.new
+Jeweler::RubyforgeTasks.new do |rubyforge|
+  rubyforge.doc_task = "rdoc"
+end
 
 Dir['tasks/**/*.rake'].each { |t| load t }
 
 task :default => [:test, :spec]
+task :all => [:libxml, :nokogiri]
+task :libxml => ['test:libxml', 'spec:libxml']
+task :nokogiri => ['test:nokogiri', 'spec:nokogiri']
+
+# $hoe = Hoe.new('roxml', ROXML::VERSION) do |p|
+#   p.changes              = File.read("History.txt").split(/^==/)[1].strip
+# 
+#   p.test_globs = 'test/unit/*_test.rb'
+#   p.clean_globs |= %w[**/.DS_Store tmp *.log]
+#   path = (p.rubyforge_name == p.name) ? p.rubyforge_name : "\#{p.rubyforge_name}/\#{p.name}"
+#   p.remote_rdoc_dir = File.join(path.gsub(/^#{p.rubyforge_name}\/?/,''), 'rdoc')
+#   p.rsync_args = '-av --delete --ignore-errors'
+# end
 
 ## Provide the username used to upload website etc.
 #RubyForgeConfig = {
@@ -73,11 +77,6 @@ task :default => [:test, :spec]
 #  pub.upload()
 #end
 #
-#desc "Install the gem"
-#task :install => [:package] do
-#  sh %{sudo gem install pkg/#{spec.name}-#{spec.version}}
-#end
-
 #desc "Create the ZIP package"
 #Rake::PackageTask.new(spec.name, spec.version) do |p|
 #  p.need_zip = true

data/TODO

@@ -1,62 +1,39 @@
 Planned:
 
-v 3.0
- * remove deprecated functionality
-
- * Automatically use Date or DateTime for accessors ending in '_on' and '_at', respectively
-
- * Clarify API via seperation of concerns.  :as for Type, :from and :in for location,
-   All other options as named options, e.g. :cdata => true rather than :as => :cdata.
-   A few not so great examples...:
-
-     xml_reader :some_objce, MyObject
-     xml_reader :size, :attr, :as => Integer
-     xml_reader :count, :attr, :as => Integer
-
-   become:
-
-     xml_reader :some_object, :as => MyObject
-     xml_reader :count, :size, :as => Integer, :from => :attr
-
-   This will significantly simplify the internals and will also cleanly split
-   element type, location, name and options, for a more predictable API.
-
-   It also enables multiple declarations on a single call, ala attr_*
-
-     xml_reader :count, :size, :number, :as => Integer, :from => :attr
+v 3.1
 
- * Consider class_inheritable_attribute rather than superclass.try stuff.
+  * Add xml_namespaces to allow declaration of distinct prefx/url namespace pairs
 
- * Do some benchmarking
+  * Consider class_inheritable_attribute rather than superclass.try stuff.
 
-v 3.1
+  * Do some benchmarking
 
- * Back with http://xml-object.rubyforge.org/doc/ to minimize need for specifications?
+  * Back with http://xml-object.rubyforge.org/doc/ to minimize need for specifications?
 
- * Commandeer #parse to use opposite #from_xml, but in an unrooted, collection-friendly fashion,
+  * Commandeer #parse to use opposite #from_xml, but in an unrooted, collection-friendly fashion,
    ala HappyMapper's parse
 
 v 3.x
 
- * :self => true for sending method_missing to this attribute?
+  * :self => true for sending method_missing to this attribute?
 
- * :attributes extensions ala HappyMapper?
+  * :attributes extensions ala HappyMapper?
 
- * Add xml_attrs helper to share :in declarations between several attributes. E.g.:
+  * Add xml_attrs helper to share :in declarations between several attributes. E.g.:
 
      xml_reader :count, :in => 'Attributes', :as => Integer
      xml_reader :something_else, :in => 'Attributes', :as => Date
 
-  becomes:
+    becomes:
 
     xml_attrs :in => 'Attributes' do |xml|
       xml.reader  :count, :as => Integer
       xml.reader  :something_else, :as => Date
     end
 
- * Ensure (perhaps optionally) that references are unambiguous. That is error/warn
+  * Ensure (perhaps optionally) that references are unambiguous. That is error/warn
    a singular specification has multiple possible node references
 
- * Use lazy evaluation to minimize parsing time for large files
+  * Use lazy evaluation to minimize parsing time for large files
 
 

data/VERSION

@@ -0,0 +1 @@
+3.1.0

data/examples/amazon.rb

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
-require File.expand_path(File.dirname(__FILE__) + '/../spec/spec_helper')
+require 'spec/spec_helper'
 
 # The document `pita.xml` contains both a default namespace and the 'georss'
 # namespace (for the 'point' xml_reader).
@@ -12,10 +12,10 @@ module PITA
   class Item < Base
     xml_reader :asin, :from => 'ASIN'
     xml_reader :detail_page_url, :from => 'DetailPageURL'
-    xml_reader :manufacturer, :in => './'
+    xml_reader :manufacturer, :in => 'ItemAttributes'
     # this is the only xml_reader that exists in a different namespace, so it
     # must be explicitly specified
-    xml_reader :point, :from => 'georss:point'
+    xml_reader :point, :namespace => 'georss'
   end
 
   class ItemSearchResponse < Base
@@ -26,8 +26,10 @@ module PITA
 end
 
 unless defined?(Spec)
-  item = PITA::ItemSearchResponse.from_xml(xml_for('amazon'))
-  item.items.each do |i|
-    puts i.asin, i.detail_page_url, i.manufacturer, ''
+  response = PITA::ItemSearchResponse.from_xml(xml_for('amazon'))
+  p response.total_results
+  p response.total_pages 
+  response.items.each do |i|
+    puts i.asin, i.detail_page_url, i.manufacturer, i.point, ''
   end
 end

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/{active_record.rb → rails.rb}

@@ -1,9 +1,9 @@
 #!/usr/bin/env ruby
-require File.expand_path(File.dirname(__FILE__) + '/../spec/spec_helper')
+require 'spec/spec_helper'
 require 'sqlite3'
 require 'activerecord'
 
-DB_PATH = File.join(File.dirname(__FILE__), 'active_record.sqlite3')
+DB_PATH = 'spec/examples/rails.sqlite3'
 ActiveRecord::Base.establish_connection(
   :adapter  => 'sqlite3',
   :database => DB_PATH

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

@@ -1,91 +1,30 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__)) unless
-  $LOAD_PATH.include?(File.dirname(__FILE__)) || $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__)))
-
 require 'uri'
+require 'active_support'
 
-%w(extensions definition xml).each do |file|
-  require File.join('roxml', file)
-end
+require 'lib/roxml/definition'
+require 'lib/roxml/xml'
 
 module ROXML # :nodoc:
-  VERSION = '2.5.3'
+  VERSION = '3.1.0'
 
   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 an XML object representing this object
+    def to_xml(name = self.class.tag_name)
+      XML::Node.create(name.to_s).tap do |root|
+        self.class.roxml_attrs.each do |attr|
+          ref = attr.to_ref(self)
+          value = ref.to_xml(self)
+          unless value.nil?
+            ref.update_xml(root, value)
           end
         end
       end
@@ -123,7 +62,7 @@ module ROXML # :nodoc:
       #
       #   xml_reader :default_namespace
       #   xml_reader :different_namespace, :from => 'different:namespace'
-      #   xml_reader :no_namespace, :from => ':no_namespace'
+      #   xml_reader :no_namespace, :from => 'no_namespace', :namespace => false
       #  end
       #
       # <aws:book xmlns:aws="http://www.aws.com/aws" xmlns:different="http://www.aws.com/different">
@@ -135,6 +74,44 @@ module ROXML # :nodoc:
       def xml_namespace(namespace)
         @roxml_namespace = namespace.to_s
       end
+      
+      # Sets up a mapping of namespace prefixes to hrefs, to be used by this class.
+      # These namespace prefixes are independent of what appears in the xml, only
+      # the namespace hrefs themselves need to match
+      #
+      # Example:
+      #  class Tires
+      #    include ROXML
+      #
+      #    xml_namespaces \
+      #      :bobsbike => 'http://bobsbikes.example.com',
+      #      :alicesauto => 'http://alicesautosupply.example.com/'
+      #
+      #    xml_reader :bike_tires, :as => [], :from => '@name', :in => 'bobsbike:tire'
+      #    xml_reader :car_tires, :as => [], :from => '@name', :in => 'alicesauto:tire'
+      #  end
+      #
+      #  >> xml = %{
+      #    <?xml version="1.0"?>
+      #    <inventory xmlns="http://alicesautosupply.example.com/" xmlns:bike="http://bobsbikes.example.com">
+      #     <tire name="super slick racing tire" />
+      #     <tire name="all weather tire" />
+      #     <bike:tire name="skinny street" />
+      #    </inventory>
+      #  }
+      #  >> Tires.from_xml(xml).bike_tires
+      #  => ['skinny street']
+      #
+      def xml_namespaces(namespaces)
+        @roxml_namespaces = namespaces.inject({}) do |all, (prefix, href)|
+          all[prefix.to_s] = href.to_s
+          all
+        end
+      end
+
+      def roxml_namespaces # :nodoc:
+        @roxml_namespaces || {}
+      end
 
       # Most xml documents have a consistent naming convention, for example, the node and
       # and attribute names might appear in CamelCase. xml_convention enables you to adapt
@@ -275,7 +252,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 => []
       #
@@ -326,7 +303,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>
@@ -409,11 +386,11 @@ module ROXML # :nodoc:
       # as in the examples below.
       #
       # :text is equivalent to :from => accessor_name, and you should specify the
-      # actual node name if it differs, as in the case of :author below.
+      # actual node name (and, optionally, a namespace) if it differs, as in the case of :author below.
       #
       # Example:
       #  class Book
-      #    xml_reader :author, :from => 'Author
+      #    xml_reader :author, :from => 'Author'
       #    xml_accessor :description, :cdata => true
       #    xml_reader :title
       #  end
@@ -445,31 +422,31 @@ 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
+      # [: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(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}"
+      # [:namespace] (false) disables or (string) overrides the default namespace declared with xml_namespace
+      #
+      def xml_attr(*syms, &block)
+        opts = syms.extract_options!
+        syms.map do |sym|
+          Definition.new(sym, opts, &block).tap 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.
@@ -477,45 +454,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.
@@ -550,11 +504,6 @@ module ROXML # :nodoc:
         @roxml_attrs ||= []
         (@roxml_attrs + (superclass.respond_to?(:roxml_attrs) ? superclass.roxml_attrs : [])).freeze
       end
-
-      def tag_refs # :nodoc:
-        roxml_attrs.map {|a| a.to_ref(nil) }
-      end
-      deprecate :tag_refs => :roxml_attrs
     end
 
     module Operations
@@ -580,32 +529,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.send(:after_parse) if inst.respond_to?(:after_parse, true)
+        new(*initialization_args).tap 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