roxml 2.4.1 → 2.4.2

data/lib/roxml.rb

@@ -1,9 +1,12 @@
-%w(extensions/active_support extensions/deprecation extensions/array extensions/string options xml).each do |file|
-  require File.join(File.dirname(__FILE__), 'roxml', file)
+$LOAD_PATH.unshift(File.dirname(__FILE__)) unless
+  $LOAD_PATH.include?(File.dirname(__FILE__)) || $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__)))
+
+%w(extensions definition xml).each do |file|
+  require File.join('roxml', file)
 end
 
 module ROXML # :nodoc:
-  VERSION = '2.4.1'
+  VERSION = '2.4.2'
 
   def self.included(base) # :nodoc:
     base.extend ClassMethods::Accessors,
@@ -108,6 +111,28 @@ module ROXML # :nodoc:
         @roxml_tag_name = name
       end
 
+      # Sets the namemespace for attributes and elements of this class.  You can override
+      # this value on individual elements via the :from option
+      #
+      # Example:
+      #  class Book
+      #   xml_namespace :aws
+      #
+      #   xml_reader :default_namespace
+      #   xml_reader :different_namespace, :from => 'different:namespace'
+      #   xml_reader :no_namespace, :from => ':no_namespace'
+      #  end
+      #
+      # <aws:book xmlns:aws="http://www.aws.com/aws" xmlns:different="http://www.aws.com/different">
+      #   <aws:default_namespace>value</aws:default_namespace>
+      #   <different:namespace>value</different:namespace>
+      #   <no_namespace>value</no_namespace>
+      # </aws:book>
+      #
+      def xml_namespace(namespace)
+        @roxml_namespace = namespace.to_s
+      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
       # the roxml default names for this object to suit this convention.  For example,
@@ -410,14 +435,14 @@ module ROXML # :nodoc:
       #
       # == Other options
       # [:from] The name by which the xml value will be found, either an attribute or tag name in XML.  Default is sym, or the singular form of sym, in the case of arrays and hashes.
-      # [:as] :cdata for character data; :integer, Integer, :float, Float to coerce to Integer or Float respectively
+      # [:as] one or more of the following: :cdata for character data; Integer, Float, Date, Time or DateTime to coerce to the respective type
       # [:in] An optional name of a wrapping tag for this XML accessor
       # [:else] Default value for attribute, if missing
       # [:required] If true, throws RequiredElementMissing when the element isn't present
       # [:frozen] If true, all results are frozen (using #freeze) at parse-time.
       #
       def xml_reference(writable, sym, type_and_or_opts = :text, opts = nil, &block)
-        opts = Opts.new(sym, *[type_and_or_opts, opts].compact, &block)
+        opts = Definition.new(sym, *[type_and_or_opts, opts].compact, &block)
 
         add_accessor(opts, writable)
       end
@@ -512,6 +537,10 @@ module ROXML # :nodoc:
         @roxml_tag_name || superclass.try(:roxml_tag_name)
       end
 
+      def roxml_namespace # :nodoc:
+        @roxml_namespace || superclass.try(:roxml_namespace)
+      end
+
       # Returns array of internal reference objects, such as attributes
       # and composed XML objects
       def roxml_attrs
@@ -544,7 +573,7 @@ module ROXML # :nodoc:
       # See also: xml_initialize
       #
       def from_xml(data, *initialization_args)
-        xml = (data.kind_of?(XML::Node) ? data : XML::Parser.parse(data).root)
+        xml = XML::Node.from(data)
 
         unless xml_construction_args_without_deprecation.empty?
           args = xml_construction_args_without_deprecation.map do |arg|

data/lib/roxml/{options.rb → definition.rb}

@@ -1,63 +1,7 @@
-module ROXML
-  HASH_KEYS = [:attrs, :key, :value].freeze
-  TYPE_KEYS = [:attr, :text, :hash, :content].freeze
-
-  class HashDesc # :nodoc:
-    attr_reader :key, :value, :wrapper
-
-    def initialize(opts, wrapper)
-      unless (invalid_keys = opts.keys - HASH_KEYS).empty?
-        raise ArgumentError, "Invalid Hash description keys: #{invalid_keys.join(', ')}"
-      end
-
-      @wrapper = wrapper
-      if opts.has_key? :attrs
-        @key   = to_hash_args(opts, :attr, opts[:attrs][0])
-        @value = to_hash_args(opts, :attr, opts[:attrs][1])
-      else
-        @key = to_hash_args opts, *fetch_element(opts, :key)
-        @value = to_hash_args opts, *fetch_element(opts, :value)
-      end
-    end
+require File.join(File.dirname(__FILE__), 'hash_definition')
 
-  private
-    def fetch_element(opts, what)
-      case opts[what]
-      when Hash
-        raise ArgumentError, "Hash #{what} is over-specified: #{opts[what].inspect}" unless opts[what].keys.one?
-        type = opts[what].keys.first
-        [type, opts[what][type]]
-      when :content
-        [:content, opts[:name]]
-      when :name
-        [:name, '*']
-      when String
-        [:text, opts[what]]
-      when Symbol
-        [:text, opts[what]]
-      else
-        raise ArgumentError, "unrecognized hash parameter: #{what} => #{opts[what]}"
-      end
-    end
-
-    def to_hash_args(args, type, name)
-      args = [args] unless args.is_a? Array
-
-      if args.one? && !(args.first.keys & HASH_KEYS).empty?
-        opts = {type => name}
-        if type == :content
-          opts[:type] = :text
-          (opts[:as] ||= []) << :content
-        end
-        Opts.new(name, opts)
-      else
-        opts = args.extract_options!
-        raise opts.inspect
-      end
-    end
-  end
-
-  class Opts # :nodoc:
+module ROXML
+  class Definition # :nodoc:
     attr_reader :name, :type, :hash, :blocks, :accessor, :to_xml
 
     class << self
@@ -75,6 +19,7 @@ module ROXML
       @opts = extract_options!(args)
       @default = @opts.delete(:else)
       @to_xml = @opts.delete(:to_xml)
+      @name_explicit = @opts.has_key?(:from)
 
       if @opts.has_key?(:readonly)
         raise ArgumentError, "There is no 'readonly' option. You probably mean to use :frozen => true"
@@ -114,7 +59,7 @@ module ROXML
     end
 
     def hash
-      @hash ||= HashDesc.new(@opts.delete(:hash), name) if hash?
+      @hash ||= HashDefinition.new(@opts.delete(:hash), name) if hash?
     end
 
     def hash?
@@ -125,6 +70,10 @@ module ROXML
       @name == '*'
     end
 
+    def name_explicit?
+      @name_explicit
+    end
+
     def content?
       @type == :content
     end
@@ -167,57 +116,80 @@ module ROXML
     end
 
   private
+    def self.all(items, &block)
+      array = items.is_a?(Array)
+      results = (array ? items : [items]).map do |item|
+        yield item
+      end
+
+      array ? results : results.first
+    end
+
     BLOCK_TO_FLOAT = lambda do |val|
-      if val.is_a? Array
-        val.collect do |v|
-          Float(v)
-        end
-      else
-        Float(val)
+      all(val) do |v|
+        Float(v) unless blank_string?(v)
       end
     end
 
     BLOCK_TO_INT = lambda do |val|
-      if val.is_a? Array
-        val.collect do |v|
-          Integer(v)
-        end
+      all(val) do |v|
+        Integer(v) unless blank_string?(v)
+      end
+    end
+
+    def self.fetch_bool(value, default)
+      value = value.try(:downcase)
+      if %w{true yes 1}.include? value
+        true
+      elsif %w{false no 0}.include? value
+        false
       else
-        Integer(val)
+        default
       end
     end
 
-    TRUE_VALS = %w{TRUE True true 1}
-    FALSE_VALS = %w{FALSE False false 0}
+    def self.blank_string?(value)
+      value.is_a?(String) && value.blank?
+    end
 
     BLOCK_SHORTHANDS = {
-      :integer => BLOCK_TO_INT,
+      :integer => BLOCK_TO_INT, # deprecated
       Integer  => BLOCK_TO_INT,
-      :float   => BLOCK_TO_FLOAT,
+      :float   => BLOCK_TO_FLOAT, # deprecated
       Float    => BLOCK_TO_FLOAT,
+      Date     => lambda do |val|
+        if defined?(Date)
+          all(val) {|v| Date.parse(v) unless blank_string?(v) }
+        end
+      end,
+      DateTime => lambda do |val|
+        if defined?(DateTime)
+          all(val) {|v| DateTime.parse(v) unless blank_string?(v) }
+        end
+      end,
+      Time     => lambda do |val|
+        if defined?(Time)
+          all(val) {|v| Time.parse(v) unless blank_string?(v) }
+        end
+      end,
+
       :bool    => nil,
       :bool_standalone => lambda do |val|
-        if TRUE_VALS.include? val
-          true
-        elsif FALSE_VALS.include? val
-          false
-        else
-          nil
+        all(val) do |v|
+          fetch_bool(v, nil)
         end
       end,
-
       :bool_combined => lambda do |val|
-        if TRUE_VALS.include? val
-          true
-        elsif FALSE_VALS.include? val
-          false
-        else
-          val
+        all(val) do |v|
+          fetch_bool(v, v)
         end
       end
     }
 
     def collect_blocks(block, as)
+      ActiveSupport::Deprecation.warn ":as => :float is deprecated.  Use :as => Float instead" if as.include?(:float)
+      ActiveSupport::Deprecation.warn ":as => :integer is deprecated.  Use :as => Integer instead" if as.include?(:integer)
+
       shorthands = as & BLOCK_SHORTHANDS.keys
       if shorthands.size > 1
         raise ArgumentError, "multiple block shorthands supplied #{shorthands.map(&:to_s).join(', ')}"

data/lib/roxml/extensions.rb

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

data/lib/roxml/hash_definition.rb

@@ -0,0 +1,59 @@
+module ROXML
+  HASH_KEYS = [:attrs, :key, :value].freeze
+  TYPE_KEYS = [:attr, :text, :hash, :content].freeze
+
+  class HashDefinition # :nodoc:
+    attr_reader :key, :value, :wrapper
+
+    def initialize(opts, wrapper)
+      unless (invalid_keys = opts.keys - HASH_KEYS).empty?
+        raise ArgumentError, "Invalid Hash description keys: #{invalid_keys.join(', ')}"
+      end
+
+      @wrapper = wrapper
+      if opts.has_key? :attrs
+        @key   = to_hash_args(opts, :attr, opts[:attrs][0])
+        @value = to_hash_args(opts, :attr, opts[:attrs][1])
+      else
+        @key = to_hash_args opts, *fetch_element(opts, :key)
+        @value = to_hash_args opts, *fetch_element(opts, :value)
+      end
+    end
+
+  private
+    def fetch_element(opts, what)
+      case opts[what]
+      when Hash
+        raise ArgumentError, "Hash #{what} is over-specified: #{opts[what].inspect}" unless opts[what].keys.one?
+        type = opts[what].keys.first
+        [type, opts[what][type]]
+      when :content
+        [:content, opts[:name]]
+      when :name
+        [:name, '*']
+      when String
+        [:text, opts[what]]
+      when Symbol
+        [:text, opts[what]]
+      else
+        raise ArgumentError, "unrecognized hash parameter: #{what} => #{opts[what]}"
+      end
+    end
+
+    def to_hash_args(args, type, name)
+      args = [args] unless args.is_a? Array
+
+      if args.one? && !(args.first.keys & HASH_KEYS).empty?
+        opts = {type => name}
+        if type == :content
+          opts[:type] = :text
+          (opts[:as] ||= []) << :content
+        end
+        Definition.new(name, opts)
+      else
+        opts = args.extract_options!
+        raise opts.inspect
+      end
+    end
+  end
+end

data/lib/roxml/xml.rb

@@ -7,282 +7,25 @@ module ROXML
       XML_PARSER = 'rexml' # :nodoc:
     end
   end
-  require File.join(File.dirname(__FILE__), 'xml', XML_PARSER)
 
-  class RequiredElementMissing < Exception # :nodoc:
-  end
-
-  #
-  # Internal base class that represents an XML - Class binding.
-  #
-  class XMLRef # :nodoc:
-    delegate :required?, :array?, :blocks, :accessor, :variable_name, :default, :to => :opts
-
-    def initialize(opts, instance)
-      @opts = opts
-      @instance = instance
-    end
-
-    def to_xml
-      val = @instance.__send__(accessor)
-      opts.to_xml.respond_to?(:call) ? opts.to_xml.call(val) : val
-    end
-
-    def update_xml(xml, value)
-      returning wrap(xml) do |xml|
-        write_xml(xml, value)
-      end
-    end
-
-    def name
-      conventionize(opts.name)
-    end
-    alias_method :xpath_name, :name
-
-    def default
-      @default ||= @opts.default || (@opts.array? ? Array.new : nil)
-      @default.duplicable? ? @default.dup : @default
-    end
-
-    def value_in(xml)
-      value = fetch_value(xml)
-      freeze(apply_blocks(value))
-    end
-
-  private
-    attr_reader :opts
-
-    def conventionize(what)
-      if !what.blank? && @instance.try(:class).try(:roxml_naming_convention).respond_to?(:call)
-         @instance.class.roxml_naming_convention.call(what)
-      else
-        what
-      end
-    end
-
-    def wrapper
-      conventionize(opts.wrapper)
-    end
-
-    def apply_blocks(val)
-      blocks.apply_to(val)
-    end
-
-    def freeze(val)
-      if opts.freeze?
-        val.each(&:freeze) if val.is_a?(Enumerable)
-        val.freeze
-      else
-        val
-      end
-    end
-
-    def xpath
-      wrapper ? "#{wrapper}/#{xpath_name}" : xpath_name.to_s
-    end
-
-    def auto_xpath
-      "#{conventionize(opts.name.pluralize)}/#{xpath_name}" if array?
-    end
-
-    def wrap(xml)
-      return xml if !wrapper || xml.name == wrapper
-      if child = xml.children.find {|c| c.name == wrapper }
-       return child
-      end
-      xml.child_add(XML::Node.new_element(wrapper))
-    end
-
-    def nodes_in(xml)
-      vals = xml.search(xpath)
-
-      if (opts.hash? || opts.array?) && vals.empty? && !wrapper && auto_xpath
-        vals = xml.search(auto_xpath)
-        @auto_vals = !vals.empty?
-      end
-
-      if vals.empty?
-        raise RequiredElementMissing, "#{name} from #{xml} for #{accessor}" if required?
-        default
-      else
-        yield(vals)
-      end
-    end
-  end
-
-  # Interal class representing an XML attribute binding
-  #
-  # In context:
-  #  <element attribute="XMLAttributeRef">
-  #   XMLTextRef
-  #  </element>
-  class XMLAttributeRef < XMLRef # :nodoc:
-  private
-    # Updates the attribute in the given XML block to
-    # the value provided.
-    def write_xml(xml, value)
-      xml.attributes[name] = value.to_s.to_utf
-    end
-
-    def fetch_value(xml)
-      nodes_in(xml) do |nodes|
-        nodes.first.value
-      end
-    end
-
-    def xpath_name
-      "@#{name}"
-    end
-  end
-
-  # Interal class representing XML content text binding
-  #
-  # In context:
-  #  <element attribute="XMLAttributeRef">
-  #   XMLTextRef
-  #  </element>
-  class XMLTextRef < XMLRef # :nodoc:
-    delegate :cdata?, :content?, :name?, :to => :opts
-
-  private
-    # Updates the text in the given _xml_ block to
-    # the _value_ provided.
-    def write_xml(xml, value)
-      if content?
-        add(xml, value)
-      elsif name?
-        xml.name = value
-      elsif array?
-        value.each do |v|
-          add(xml.child_add(XML::Node.new_element(name)), v)
-        end
-      else
-        add(xml.child_add(XML::Node.new_element(name)), value)
-      end
-    end
-
-    def fetch_value(xml)
-      if content? || name?
-        value =
-          if content?
-            xml.content.to_s.strip
-          elsif name?
-            xml.name
-          end
-
-        if value.empty?
-          raise RequiredElementMissing, "#{name} from #{xml} for #{accessor}" if required?
-          default
+  require File.join(File.dirname(__FILE__), 'xml/parsers', XML_PARSER)
+
+  module XML
+    class Node
+      def self.from(data)
+        if data.is_a?(XML::Node)
+          data
+        elsif data.is_a?(File) || data.is_a?(IO)
+          Parser.parse_io(data).root
+        elsif (defined?(URI) && data.is_a?(URI::Generic)) ||
+              (defined?(Pathname) && data.is_a?(Pathname))
+          Parser.parse_file(data.to_s).root
         else
-          value
-        end
-      else
-        nodes_in(xml) do |nodes|
-          if array?
-            nodes.collect do |e|
-              e.content.strip.to_latin
-            end
-          else
-            nodes.first.content
-          end
+          Parser.parse(data).root
         end
       end
     end
-
-    def add(dest, value)
-      if cdata?
-        dest.child_add(XML::Node.new_cdata(value.to_s.to_utf))
-      else
-        dest.content = value.to_s.to_utf
-      end
-    end
   end
+end
 
-  class XMLHashRef < XMLTextRef # :nodoc:
-    delegate :hash, :to => :opts
-
-    def initialize(opts, inst)
-      super(opts, inst)
-      @key = opts.hash.key.to_ref(inst)
-      @value = opts.hash.value.to_ref(inst)
-    end
-
-  private
-    # Updates the composed XML object in the given XML block to
-    # the value provided.
-    def write_xml(xml, value)
-      value.each_pair do |k, v|
-        node = xml.child_add(XML::Node.new_element(hash.wrapper))
-        @key.update_xml(node, k)
-        @value.update_xml(node, v)
-      end
-    end
-
-    def fetch_value(xml)
-      nodes_in(xml) do |nodes|
-        nodes.collect do |e|
-          [@key.value_in(e), @value.value_in(e)]
-        end
-      end
-    end
-
-    def apply_blocks(vals)
-      unless blocks.empty?
-        vals.collect! do |kvp|
-          super(kvp)
-        end
-      end
-      vals.to_hash if vals
-    end
-
-    def freeze(vals)
-      if opts.freeze?
-        vals.each_pair{|k, v| k.freeze; v.freeze }
-        vals.freeze
-      else
-        vals
-      end
-    end
-  end
-
-  class XMLObjectRef < XMLTextRef # :nodoc:
-    delegate :type, :to => :opts
-
-  private
-    # Updates the composed XML object in the given XML block to
-    # the value provided.
-    def write_xml(xml, value)
-      if array?
-        value.each do |v|
-          xml.child_add(v.to_xml(name))
-        end
-      elsif value.is_a?(ROXML)
-        xml.child_add(value.to_xml(name))
-      else
-        node = XML::Node.new_element(name)
-        node.content = value.to_xml
-        xml.child_add(node)
-      end
-    end
-
-    def fetch_value(xml)
-      nodes_in(xml) do |nodes|
-        unless array?
-          instantiate(nodes.first)
-        else
-          nodes.collect do |e|
-            instantiate(e)
-          end
-        end
-      end
-    end
-
-    def instantiate(elem)
-      if type.respond_to? :from_xml
-        type.from_xml(elem)
-      else
-        type.new(elem)
-      end
-    end
-  end
-end
+require File.join(File.dirname(__FILE__), 'xml/references')