Empact-roxml 2.2 → 2.3.0

data/README.rdoc

@@ -91,7 +91,8 @@ The result of the block above is stored, rather than the actual value parsed fro
 == Construction
 
 Complicated initialization may require action on multiple attributes of an object.  As such, you can
-use xml_construct to cause your ROXML object to call its own constructor.  For example:
+define method xml_initialize to perform initialization after instantiation and parsing, including
+causing your ROXML object to call its own constructor, as in the following:
 
   class Measurement
     include ROXML
@@ -99,15 +100,18 @@ use xml_construct to cause your ROXML object to call its own constructor.  For e
     xml_reader :units, :attr
     xml_reader :value, :content
 
-    xml_construct :value, :units
+    def xml_initialize
+      # xml attributes of self are already valid
+      initialize(value, units)
+    end
 
     def initialize(value, units)
       # translate units & value into metric, for example
     end
   end
 
-Will, on parse, read all listed xml attributes (units and value, in this case), then call initialize
-with the arguments listed after the xml_construct call.
+One important use of this approach is to make ROXML object which may or may not include an xml backing,
+which may be used via _new_ construction as well as _from_xml_ construction.
 
 == Selecting a parser
 

data/Rakefile

@@ -1,6 +1,5 @@
 # Rake libraries used
 require "rubygems"
-require "rails_plugin_package_task"
 require "rake/rdoctask"
 require "rake/contrib/rubyforgepublisher"
 require "rake/contrib/publisher"
@@ -24,17 +23,6 @@ Rake::RDocTask.new do |rd|
   rd.options << '--main' << 'README.rdoc' << '--title' << 'ROXML Documentation'
 end
 
-Rake::RailsPluginPackageTask.new(spec.name, spec.version) do |p|
-  p.package_files = FileList[
-    "lib/**/*.rb", "*.txt", "README.rdoc", "Rakefile",
-    "rake/**/*", "test/**/*.rb", "test/**/*.xml"]
-  p.plugin_files = FileList["rails_plugin/**/*"]
-  p.extra_links = {"Project page" => spec.homepage,
-                   "Author: Zak Mandhro" => 'http://rubyforge.org/users/zakmandhro/'}
-  p.verbose = true
-end
-task :rails_plugin=>:clobber
-
 desc "Publish Ruby on Rails plug-in on RubyForge"
 task :release_plugin=>:rails_plugin do |task|
   pub = Rake::SshDirPublisher.new("#{RubyForgeConfig[:user_name]}@rubyforge.org",
@@ -63,6 +51,9 @@ end
 @test_files = 'test/unit/*_test.rb'
 desc "Test ROXML using the default parser selection behavior"
 task :test do
+  module ROXML
+    SILENCE_XML_NAME_WARNING = true
+  end
   require 'lib/roxml'
   require 'rake/runtest'
   Rake.run_tests @test_files
@@ -99,8 +90,6 @@ Rake::PackageTask.new(spec.name, spec.version) do |p|
     "rake/**/*","test/**/*.rb", "test/**/*.xml", "html/**/*"]
 end
 
-desc "Create the plugin package"
-
 task :package=>:rdoc
 task :rdoc=>:test
 

data/lib/roxml.rb

@@ -1,20 +1,15 @@
-require 'rubygems'
-require 'extensions/enumerable'
-require 'extensions/array'
-require 'extensions/object'
-require 'activesupport'
-
-%w(extensions/array extensions/string options xml).each do |file|
+%w(extensions/active_support extensions/deprecation extensions/array extensions/string options xml).each do |file|
   require File.join(File.dirname(__FILE__), 'roxml', file)
 end
 
 module ROXML # :nodoc:
   def self.included(base) # :nodoc:
-    base.extend ClassMethods::Declarations
     base.extend ClassMethods::Accessors
+    base.extend ClassMethods::Declarations
     base.extend ClassMethods::Operations
     base.class_eval do
       include InstanceMethods::Accessors
+      include InstanceMethods::Construction
       include InstanceMethods::Conversions
     end
   end
@@ -33,6 +28,44 @@ module ROXML # :nodoc:
       end
     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, :attr
+      #    xml_reader :value, :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
+      end
+    end
+
     module Conversions
       # Returns a LibXML::XML::Node or a REXML::Element representing this object
       def to_xml(name = nil)
@@ -50,11 +83,16 @@ module ROXML # :nodoc:
   # This class defines the annotation methods that are mixed into your
   # Ruby classes for XML mapping information and behavior.
   #
-  # See xml_name, xml_construct, xml, xml_reader and xml_accessor for
+  # See xml_name, xml_initialize, xml, xml_reader and xml_accessor for
   # available annotations.
   #
   module ClassMethods # :nodoc:
     module Declarations
+      # A helper which enables us to detect when the xml_name has been explicitly set
+      def xml_name? #:nodoc:
+        @xml_name
+      end
+
       # Sets the name of the XML element that represents this class. Use this
       # to override the default lowercase class name.
       #
@@ -66,13 +104,68 @@ module ROXML # :nodoc:
       # Without the xml_name annotation, the XML mapped tag would have been "bookwithpublisher".
       #
       def xml_name(name)
+        @xml_name = true
         @tag_name = name
       end
 
       # Declares an accesser to a certain xml element, whether an attribute, a node,
-      # or a typed collection of nodes
+      # or a typed collection of nodes.  Typically you should call xml_reader or xml_accessor
+      # rather than calling this method directly, but the instructions below apply to both.
+      #
+      # == Sym Option
+      # [sym]   Symbol representing the name of the accessor.
+      #
+      # === Default naming
+      # This name will be the default node or attribute name searched for,
+      # if no other is declared.  For example,
+      #
+      #  xml_reader   :bob, :from => 'bob'
+      #  xml_accessor :pony, :attr => 'pony'
+      #
+      # are equivalent to:
+      #
+      #  xml_reader   :bob
+      #  xml_accessor :pony, :attr
+      #
+      # === Boolean attributes
+      # If the name ends in a ?, ROXML will attempt to coerce the value to true or false,
+      # with True, TRUE, true and 1 mapping to true and False, FALSE, false and 0 mapping
+      # to false, as shown below:
+      #
+      #  xml_reader :desirable?
+      #  xml_reader :bizzare?, :attr => 'BIZZARE'
+      #
+      #  x = #from_xml(%{
+      #    <object BIZZARE="1">
+      #      <desirable>False</desirable>
+      #    </object>
+      #  })
+      #  x.desirable?
+      #  => false
+      #  x.bizzare?
+      #  => true
+      #
+      # If an unexpected value is encountered, the attribute will be set to nil,
+      # unless you provide a block, in which case the block will recived
+      # the actual unexpected value.
+      #
+      #  #from_xml(%{
+      #    <object>
+      #      <desirable>Dunno</desirable>
+      #    </object>
+      #  }).desirable?
+      #  => nil
+      #
+      #  xml_reader :strange? do |val|
+      #    val.upcase
+      #  end
       #
-      # [sym]   Symbol representing the name of the accessor
+      #  #from_xml(%{
+      #    <object>
+      #      <strange>Dunno</strange>
+      #    </object>
+      #  }).strange?
+      #  => DUNNO
       #
       # == Type options
       # All type arguments may be used as the type argument to indicate just type,
@@ -258,6 +351,8 @@ module ROXML # :nodoc:
       # For hash types, the block recieves the key and value as arguments, and they should
       # be returned as an array of [key, value]
       #
+      # For array types, the entire array is passed in, and must be returned in the same fashion.
+      #
       # === Block Shorthands
       #
       # Alternatively, you may use block shorthands to specify common coercions, such that:
@@ -281,16 +376,16 @@ module ROXML # :nodoc:
       def xml(sym, writable = false, type_and_or_opts = :text, opts = nil, &block)
         opts = Opts.new(sym, *[type_and_or_opts, opts].compact, &block)
 
-        tag_refs << case opts.type
+        ref = case opts.type
         when :attr    then XMLAttributeRef
         when :content then XMLTextRef
         when :text    then XMLTextRef
         when :hash    then XMLHashRef
         when Symbol   then raise ArgumentError, "Invalid type argument #{opts.type}"
         else               XMLObjectRef
-        end.new(sym, opts)
+        end.new(opts)
 
-        add_accessor(sym, writable, opts.array?, opts.default)
+        add_accessor(ref, writable)
       end
 
       # Declares a read-only xml reference. See xml for details.
@@ -303,40 +398,38 @@ module ROXML # :nodoc:
         xml sym, true, type_and_or_opts, opts, &block
       end
 
-      # On parse, call the target object's initialize function with the listed arguments
+      # This method is deprecated, please use xml_initialize instead
       def xml_construct(*args)
-        if missing_tag = args.detect {|arg| !tag_refs.map(&:name).include?(arg.to_s) }
+        present_tags = tag_refs.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_tag} is missing. " +
-                               tag_refs.map(&:name).join(', ') + ' are declared.'
+                               "xml_reader, or xml_accessor. #{missing_tags.join(', ')} is missing. " +
+                               "#{present_tags.join(', ')} are declared."
         end
         @xml_construction_args = args
       end
+      deprecate :xml_construct => :xml_initialize
 
     private
-      def assert_accessor(name)
-        @tag_accessors ||= []
-        raise "Accessor #{name} is already defined as XML accessor in class #{self}" if @tag_accessors.include?(name)
-        @tag_accessors << name
-      end
-
-      def add_accessor(name, writable, as_array, default = nil)
-        assert_accessor(name)
-        unless instance_methods.include?(name)
-          default ||= Array.new if as_array
+      def add_accessor(ref, writable)
+        if tag_refs.map(&:accessor).include? ref.accessor
+          raise "Accessor #{ref.accessor} is already defined as XML accessor in class #{self.name}"
+        end
+        tag_refs << ref
 
-          define_method(name) do
-            val = instance_variable_get("@#{name}")
-            if val.nil?
-              val = default.duplicable? ? default.dup : default
-              instance_variable_set("@#{name}", val)
-            end
-            val
+        define_method(ref.accessor) do
+          result = instance_variable_get("@#{ref.variable_name}")
+          if result.nil?
+            result = ref.default
+            instance_variable_set("@#{ref.variable_name}", result)
           end
+          result
         end
-        if writable && !instance_methods.include?("#{name}=")
-          define_method("#{name}=") do |v|
-            instance_variable_set("@#{name}", v)
+
+        if writable && !instance_methods.include?("#{ref.accessor}=")
+          define_method("#{ref.accessor}=") do |v|
+            instance_variable_set("@#{ref.accessor}", v)
           end
         end
       end
@@ -346,7 +439,7 @@ module ROXML # :nodoc:
       def xml_construction_args # :nodoc:
         @xml_construction_args ||= []
       end
-
+      deprecate :xml_construction_args
 
       # 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
@@ -358,7 +451,7 @@ module ROXML # :nodoc:
       # Returns array of internal reference objects, such as attributes
       # and composed XML objects
       def tag_refs
-        @xml_refs ||= []
+        @xml_refs ||= superclass.respond_to?(:tag_refs) ? superclass.tag_refs.clone : []
       end
     end
 
@@ -375,14 +468,17 @@ module ROXML # :nodoc:
       # or
       #  book = Book.from_xml("<book><name>Beyond Java</name></book>")
       #
-      # See also: xml_construct
+      # _initialization_args_ passed into from_xml will be passed into
+      # the object #xml_initialize method.
+      #
+      # See also: xml_initialize
       #
-      def from_xml(data)
+      def from_xml(data, *initialization_args)
         xml = (data.kind_of?(XML::Node) ? data : XML::Parser.parse(data).root)
 
-        unless xml_construction_args.empty?
-          args = xml_construction_args.map do |arg|
-             tag_refs.find {|ref| ref.name == arg.to_s }
+        unless xml_construction_args_without_deprecation.empty?
+          args = xml_construction_args_without_deprecation.map do |arg|
+             tag_refs.find {|ref| ref.accessor == arg }
           end.map {|ref| ref.value(xml) }
           new(*args)
         else
@@ -390,15 +486,16 @@ module ROXML # :nodoc:
             tag_refs.each do |ref|
               ref.populate(xml, inst)
             end
+            inst.send(:xml_initialize, *initialization_args)
           end
         end
       end
 
       # Deprecated in favor of #from_xml
       def parse(data)
-        ActiveSupport::Deprecation.warn '#parse has been deprecated, please use #from_xml instead'
         from_xml(data)
       end
+      deprecate :parse => :from_xml
     end
   end
 end

data/lib/roxml/extensions/active_support.rb

@@ -0,0 +1,30 @@
+require 'rubygems'
+require 'active_support/core_ext/blank'
+require 'active_support/core_ext/duplicable'
+require 'active_support/core_ext/array/extract_options'
+require 'active_support/core_ext/hash/reverse_merge'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/module/aliasing'
+require 'active_support/core_ext/object/misc' # returning
+require 'active_support/inflector'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/string/starts_ends_with'
+
+require 'extensions/array'
+
+class Module
+  include ActiveSupport::CoreExtensions::Module if ActiveSupport::CoreExtensions.const_defined? :Module
+end
+
+class String #:nodoc:
+  include ActiveSupport::CoreExtensions::String::Inflections
+  include ActiveSupport::CoreExtensions::String::StartsEndsWith
+end
+
+class Array #:nodoc:
+  include ActiveSupport::CoreExtensions::Array::ExtractOptions
+end
+
+class Hash #:nodoc:
+  include ActiveSupport::CoreExtensions::Hash::ReverseMerge
+end

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

@@ -1,5 +1,3 @@
-require File.join(File.dirname(__FILE__), '../deprecation')
-
 module ROXML
   module CoreExtensions
     module Array #:nodoc:
@@ -18,9 +16,9 @@ module ROXML
         end
 
         def to_h #:nodoc:
-          ActiveSupport::Deprecation.warn "Please use #to_hash instead"
           to_hash
         end
+        deprecate :to_h => :to_hash
       end
     end
   end

data/lib/roxml/extensions/deprecation.rb

@@ -1,15 +1,28 @@
-require 'active_support'
+require 'active_support/core_ext/kernel/reporting'
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/deprecation'
 require 'active_support/version'
 
 module ActiveSupport # :nodoc:all
-  if VERSION::MAJOR <= 2 && VERSION::MINOR <= 1
-    module Deprecation
-      class << self
+  module Deprecation
+    class << self
+      if VERSION::MAJOR <= 2 && VERSION::MINOR <= 1
         def deprecation_message(callstack, message = nil)
           message ||= "You are using deprecated behavior which will be removed from the next major or minor release."
           "DEPRECATION WARNING: #{message}. #{deprecation_caller_message(callstack)}"
         end
       end
     end
+
+    module ClassMethods
+      def deprecated_method_warning(method_name, message=nil)
+        warning = "#{method_name} is deprecated and will be removed from the next major or minor release."
+        case message
+          when Symbol then "#{warning} (use #{message} instead)"
+          when String then "#{warning} (#{message})"
+          else warning
+        end
+      end
+    end
   end
 end

data/lib/roxml/extensions/string.rb

@@ -6,7 +6,6 @@ class String #:nodoc:
   include ROXML::CoreExtensions::String::Iterators
 end
 
-require File.join(File.dirname(__FILE__), 'deprecation')
 class Object #:nodoc:
   # Deprecated in favor of explicit #to_s.to_utf
   def to_utf

data/lib/roxml/options.rb

@@ -51,11 +51,11 @@ module ROXML
     def to_ref(args, type, name)
       case type
       when :attr
-        XMLAttributeRef.new(nil, to_hash_args(args, type, name))
+        XMLAttributeRef.new(to_hash_args(args, type, name))
       when :text
-        XMLTextRef.new(nil, to_hash_args(args, type, name))
+        XMLTextRef.new(to_hash_args(args, type, name))
       when Symbol
-        XMLTextRef.new(nil, to_hash_args(args, type, name))
+        XMLTextRef.new(to_hash_args(args, type, name))
       else
         raise ArgumentError, "Missing key description #{{:type => type, :name => name}.pp_s}"
       end
@@ -79,14 +79,41 @@ module ROXML
   end
 
   class Opts # :nodoc:
-    attr_reader :name, :type, :hash, :blocks
+    attr_reader :name, :type, :hash, :blocks, :default, :accessor
+
+    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
       @opts = extract_options!(args)
+      @default = @opts.delete(:else)
 
-      @opts.reverse_merge!(:from => sym.to_s, :as => [], :else => nil, :in => nil)
+      @opts.reverse_merge!(:as => [], :in => nil)
       @opts[:as] = [*@opts[:as]]
+
       @type = extract_type(args)
+      @opts[:as] << :bool if @accessor.to_s.ends_with?('?')
+
+      if @type.respond_to?(:xml_name?) && @type.xml_name?
+        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
+      else
+        @opts[:from] ||= variable_name
+      end
+
       @blocks = collect_blocks(block, @opts[:as])
 
       @name = @opts[:from].to_s
@@ -98,12 +125,12 @@ module ROXML
       raise ArgumentError, "Can't specify both :else default and :required" if required? && default
     end
 
-    def hash
-      @hash ||= HashDesc.new(@opts.delete(:hash), name) if hash?
+    def variable_name
+      accessor.to_s.ends_with?('?') ? accessor.to_s.chomp('?') : accessor.to_s
     end
 
-    def default
-      @opts[:else]
+    def hash
+      @hash ||= HashDesc.new(@opts.delete(:hash), name) if hash?
     end
 
     def hash?
@@ -131,17 +158,69 @@ module ROXML
     end
 
   private
+    BLOCK_TO_FLOAT = lambda do |val|
+      if val.is_a? Array
+        val.collect do |v|
+          Float(v)
+        end
+      else
+        Float(val)
+      end
+    end
+
+    BLOCK_TO_INT = lambda do |val|
+      if val.is_a? Array
+        val.collect do |v|
+          Integer(v)
+        end
+      else
+        Integer(val)
+      end
+    end
+
+    TRUE_VALS = %w{TRUE True true 1}
+    FALSE_VALS = %w{FALSE False false 0}
+
     BLOCK_SHORTHANDS = {
-      :integer => lambda {|val| Integer(val) },
-      Integer  => lambda {|val| Integer(val) },
-      :float   => lambda {|val| Float(val) },
-      Float    => lambda {|val| Float(val) }
+      :integer => BLOCK_TO_INT,
+      Integer  => BLOCK_TO_INT,
+      :float   => BLOCK_TO_FLOAT,
+      Float    => BLOCK_TO_FLOAT,
+      :bool    => nil,
+      :bool_standalone => lambda do |val|
+        if TRUE_VALS.include? val
+          true
+        elsif FALSE_VALS.include? val
+          false
+        else
+          nil
+        end
+      end,
+
+      :bool_combined => lambda do |val|
+        if TRUE_VALS.include? val
+          true
+        elsif FALSE_VALS.include? val
+          false
+        else
+          val
+        end
+      end
     }
 
     def collect_blocks(block, as)
       shorthands = as & BLOCK_SHORTHANDS.keys
-      raise ArgumentError, "multiple block shorthands supplied #{shorthands.map(&:to_s).join(', ')}" if shorthands.size > 1
-      [BLOCK_SHORTHANDS[shorthands.first], block].compact
+      if shorthands.size > 1
+        raise ArgumentError, "multiple block shorthands supplied #{shorthands.map(&:to_s).join(', ')}"
+      end
+
+      shorthand = shorthands.first
+      if shorthand == :bool
+        # if a second block is present, and we can't coerce the xml value
+        # to bool, we need to be able to pass it to the user-provided block
+        shorthand = block ? :bool_combined : :bool_standalone
+      end
+      [BLOCK_SHORTHANDS[shorthand], block].compact
     end
 
     def extract_options!(args)

data/lib/roxml/xml.rb

@@ -16,20 +16,18 @@ module ROXML
   # Internal base class that represents an XML - Class binding.
   #
   class XMLRef # :nodoc:
-    attr_reader :accessor
-    delegate :name, :required?, :array?, :default, :wrapper, :blocks, :to => :opts
+    delegate :name, :required?, :array?, :wrapper, :blocks, :accessor, :variable_name, :to => :opts
     alias_method :xpath_name, :name
 
-    def initialize(accessor, args)
-      @accessor = accessor
-      @opts = args
+    def initialize(opts)
+      @opts = opts
     end
 
     # Reads data from the XML element and populates the instance
     # accordingly.
     def populate(xml, instance)
       data = value(xml)
-      instance.instance_variable_set("@#{accessor}", data) if data
+      instance.instance_variable_set("@#{variable_name}", data)
       instance
     end
 
@@ -43,6 +41,11 @@ module ROXML
       end
     end
 
+    def default
+      @default ||= @opts.default || (@opts.array? ? Array.new : nil)
+      @default.duplicable? ? @default.dup : @default
+    end
+
     def value(xml)
       value = fetch_value(xml)
       if value.blank?
@@ -56,7 +59,7 @@ module ROXML
     attr_reader :opts
 
     def apply_blocks(val)
-      blocks.each {|block| val = block[*val] } unless blocks.empty?
+      blocks.each {|block| val = block[val] }
       val
     end
 
@@ -133,7 +136,7 @@ module ROXML
           e.content.strip.to_latin if e.content
         end
       else
-        child = xml.search(name).first
+        child = xml.search(xpath).first
         child.content if child
       end
     end
@@ -150,6 +153,11 @@ module ROXML
   class XMLHashRef < XMLTextRef # :nodoc:
     delegate :hash, :to => :opts
 
+    def default
+      result = super
+      result.nil? ? {} : result
+    end
+
   private
     # Updates the composed XML object in the given XML block to
     # the value provided.
@@ -173,7 +181,7 @@ module ROXML
           super(kvp)
         end
       end
-      vals.to_hash
+      vals.to_hash if vals
     end
   end
 

data/lib/roxml/xml/rexml.rb

@@ -1,3 +1,5 @@
+require 'rexml/document'
+
 module ROXML
   module XML # :nodoc:all
     Document = REXML::Document

data/roxml.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name = "roxml"
   s.summary = "Ruby Object to XML mapping library"
-  s.version = "2.2"
+  s.version = "2.3.0"
   s.homepage = "http://roxml.rubyforge.org"
   s.platform = Gem::Platform::RUBY
   s.authors = ["Ben Woosley", "Zak Mandhro", "Anders Engstrom", "Russ Olsen"]
@@ -13,6 +13,7 @@ Gem::Specification.new do |s|
     'Rakefile',
     'roxml.gemspec',
     'lib/roxml.rb',
+    'lib/roxml/extensions/active_support.rb',
     'lib/roxml/extensions/array.rb',
     'lib/roxml/extensions/array/conversions.rb',
     'lib/roxml/extensions/string.rb',
@@ -66,7 +67,7 @@ Gem::Specification.new do |s|
     'test/unit/xml_text_test.rb']
   s.requirements << 'none'
   s.add_dependency 'extensions', '>= 0.6.0'
-  s.add_development_dependency('Empact-rails-plugin-package-task', '>= 0.1') if s.respond_to?(:add_development_dependency)
+  s.add_dependency 'activesupport', '>= 2.0.0'
   s.require_path = 'lib'
   s.test_files = [
     'test/unit/options_test.rb',

data/test/fixtures/book_with_depth.xml

@@ -1,4 +1,4 @@
-<book ISDN="0201710897">
+<book ISBN="0201710897">
   <title>The PickAxe</title>
   <description><![CDATA[Probably the best Ruby book out there]]></description>
   <author>David Thomas, Andrew Hunt, Dave Thomas</author>

data/test/mocks/mocks.rb

@@ -72,7 +72,10 @@ class Measurement
 
   xml_reader :units, :attr
   xml_reader :value, :content
-  xml_construct :value, :units
+
+  def xml_initialize
+    initialize(value, units)
+  end
 
   def initialize(value, units = 'pixels')
     @value = Float(value)
@@ -83,6 +86,10 @@ class Measurement
     end
   end
 
+  def to_s
+    "#{value} #{units}"
+  end
+
   def ==(other)
     other.units == @units && other.value == @value
   end
@@ -244,7 +251,7 @@ class PersonWithMother
 
   xml_name :person
   xml_reader :name
-  xml_reader :mother, PersonWithMother
+  xml_reader :mother, PersonWithMother, :from => 'mother'
 end
 
 class PersonWithGuardedMother
@@ -261,4 +268,4 @@ class PersonWithMotherOrMissing
   xml_reader :age, :attr, :else => 21
   xml_reader :name, :else => 'Anonymous'
   xml_reader :mother, PersonWithMotherOrMissing, :else => Person.new
-end
+end

data/test/test_helper.rb

@@ -1,5 +1,4 @@
 require "lib/roxml"
-require "test/unit"
 require 'test/mocks/mocks'
 require 'test/mocks/dictionaries'
 

data/test/unit/xml_construct_test.rb

@@ -1,19 +1,77 @@
 require File.join(File.dirname(__FILE__), '..', 'test_helper')
 
-class TestXMLAttribute < Test::Unit::TestCase
+class MeasurementWithXmlConstruct
+  include ROXML
+
+  xml_reader :units, :attr
+  xml_reader :value, :content
+
+  xml_construct_without_deprecation :value, :units
+
+  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
+
+  def ==(other)
+    other.units == @units && other.value == @value
+  end
+end
+
+class BookWithDepthWithXmlConstruct
+  include ROXML
+
+  xml_reader :isbn, :attr => 'ISBN'
+  xml_reader :title
+  xml_reader :description, :as => :cdata
+  xml_reader :author
+  xml_reader :depth, MeasurementWithXmlConstruct
+end
+
+class InheritedBookWithDepthWithXmlConstruct < Book
+  xml_reader :depth, MeasurementWithXmlConstruct
+end
+
+class TestXMLConstruct < Test::Unit::TestCase
+  def test_is_deprecated
+    assert_deprecated do
+      MeasurementWithXmlConstruct.xml_construction_args
+    end
+  end
+
   def test_initialize_is_run
-    m = Measurement.from_xml('<measurement units="hundredths-meters">1130</measurement>')
+    m = MeasurementWithXmlConstruct.from_xml('<measurement units="hundredths-meters">1130</measurement>')
     assert_equal 11.3, m.value
     assert_equal 'meters', m.units
   end
 
   def test_initialize_is_run_for_nested_type
-    b = BookWithDepth.from_xml(fixture(:book_with_depth))
+    b = BookWithDepthWithXmlConstruct.from_xml(fixture(:book_with_depth))
     assert_equal Measurement.new(11.3, 'meters'), b.depth
   end
 
   def test_initialize_is_run_for_nested_type_with_inheritance
-    b = InheritedBookWithDepth.from_xml(fixture(:book_with_depth))
+    b = InheritedBookWithDepthWithXmlConstruct.from_xml(fixture(:book_with_depth))
     assert_equal Measurement.new(11.3, 'meters'), b.depth
   end
+
+  def test_xml_name_uses_accessor_not_name
+    assert_nothing_raised do
+      Class.new do
+        include ROXML
+
+        xml_reader :bar, :attr => 'Foo'
+        xml_reader :foo, :text => 'Foo'
+        xml_reader :baz, :attr => 'Bar'
+
+        xml_construct_without_deprecation :baz, :bar, :foo
+        def initialize(baz, bar, foo)
+        end
+      end
+    end
+  end
 end

data/test/unit/xml_hash_test.rb

@@ -47,4 +47,19 @@ class TestXMLHash < Test::Unit::TestCase
     assert_equal Hash, dict.definitions.class
     assert_equal @contents, dict.definitions
   end
+
+  def test_it_should_gracefully_handle_empty_hash
+    dict = Class.new do
+      include ROXML
+
+      xml_reader :missing_hash, {:key => :name, :value => :content}, :in => 'EmptyDictionary'
+    end
+
+    assert_equal({}, dict.from_xml(%{
+      <dict>
+        <EmptyDictionary>
+        </EmptyDictionary>
+      </dict>
+    }).missing_hash)
+  end
 end

data/test/unit/xml_name_test.rb

@@ -1,6 +1,80 @@
 require File.join(File.dirname(__FILE__), '..', 'test_helper')
 
+#      Parent        |    Child
+#  :from  | no :from |
+# -------------------|--------------
+#  :from  | xml_name | xml_name-d
+#  value  |  value   |
+# -------------------|--------------
+#  :from  | parent's |
+#  value  | accessor | un-xml_name-d
+#         |  name    |
+
+class Child
+  include ROXML
+end
+
+class NamedChild
+  include ROXML
+
+  xml_name :xml_name_of_child
+end
+
+class ParentOfNamedChild
+  include ROXML
+
+  xml_name :parent
+  xml_accessor :child_accessor_name, NamedChild
+end
+
+class ParentOfNamedChildWithFrom
+  include ROXML
+
+  xml_name :parent
+  xml_accessor :child_accessor_name, NamedChild, :from => 'child_from_name'
+end
+
+class ParentOfUnnamedChild
+  include ROXML
+
+  xml_name :parent
+  xml_accessor :child_accessor_name, Child
+end
+
+class ParentOfUnnamedChildWithFrom
+  include ROXML
+
+  xml_name :parent
+  xml_accessor :child_accessor_name, Child, :from => 'child_from_name'
+end
+
 class TestXMLName < Test::Unit::TestCase
+  def test_from_always_dominates_attribute_name_xml_name_or_not
+    parent = ParentOfNamedChildWithFrom.new
+    parent.child_accessor_name = Child.new
+
+    assert_equal "<parent><child_from_name/></parent>", parent.to_xml.to_s.gsub(/[\n ]/, '')
+
+    parent = ParentOfUnnamedChildWithFrom.new
+    parent.child_accessor_name = Child.new
+
+    assert_equal "<parent><child_from_name/></parent>", parent.to_xml.to_s.gsub(/[\n ]/, '')
+  end
+
+  def test_attribute_name_comes_from_the_xml_name_value_if_present
+    parent = ParentOfNamedChild.new
+    parent.child_accessor_name = Child.new
+
+    assert_equal "<parent><xml_name_of_child/></parent>", parent.to_xml.to_s.gsub(/[\n ]/, '')
+  end
+
+  def test_attribute_name_comes_from_parent_accessor_by_default
+    parent = ParentOfUnnamedChild.new
+    parent.child_accessor_name = Child.new
+
+    assert_equal "<parent><child_accessor_name/></parent>", parent.to_xml.to_s.gsub(/[\n ]/, '')
+  end
+
   def test_named_books_picked_up
     named = Library.from_xml(fixture(:library))
     assert named.books

data/test/unit/xml_namespace_test.rb

@@ -18,6 +18,7 @@ class TestXMLNamespaces < Test::Unit::TestCase
   end
 
   def test_that_rexml_follows_nameless_default_namespace
+    require 'rexml/document'
     xml = REXML::Document.new(
       '<container xmlns="http://fakenamespace.org"><node>Yeah, content</node></container>')
 

data/test/unit/xml_text_test.rb

@@ -21,6 +21,17 @@ class TestXMLText < Test::Unit::TestCase
                  BookWithAuthors.from_xml(fixture(:book_with_authors)).authors.sort
   end
 
+  def test_empty_array_result_returned_properly
+    empty_array = Class.new do
+      include ROXML
+
+      xml_reader :missing_array, [:text], :from => 'missing'
+    end
+
+    obj = empty_array.from_xml('<empty_array></empty_array>')
+    assert_equal [], obj.missing_array
+  end
+
   def test_text_modification
     person = Person.from_xml(fixture(:person))
     assert_equal("Ben Franklin", person.name)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: Empact-roxml
 version: !ruby/object:Gem::Version 
-  version: "2.2"
+  version: 2.3.0
 platform: ruby
 authors: 
 - Ben Woosley
@@ -24,6 +24,15 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 0.6.0
     version: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.0
+    version: 
 description: 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.
 email: ben.woosley@gmail.com
 executables: []
@@ -38,6 +47,7 @@ files:
 - Rakefile
 - roxml.gemspec
 - lib/roxml.rb
+- lib/roxml/extensions/active_support.rb
 - lib/roxml/extensions/array.rb
 - lib/roxml/extensions/array/conversions.rb
 - lib/roxml/extensions/string.rb