Empact-roxml 2.3.1 → 2.4.0

data/lib/roxml/extensions/active_support.rb

@@ -3,30 +3,55 @@ require 'active_support/core_ext/symbol'
 require 'active_support/core_ext/blank'
 require 'active_support/core_ext/duplicable'
 require 'active_support/core_ext/array/extract_options'
+
+class Array #:nodoc:
+  include ActiveSupport::CoreExtensions::Array::ExtractOptions
+end
+
 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/module/attribute_accessors'
 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 'active_support/multibyte'
+require 'active_support/core_ext/string'
+class String
+  # This conflicts with builder, unless builder is required first, which we don't want to force on people
+  undef_method :to_xs if method_defined?(:to_xs)
+end
 
 require 'extensions/enumerable'
 require 'extensions/array'
 
-class Module
+class Module #:nodoc:
   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
+
+class Object #:nodoc:
+  unless method_defined?(:try)
+    # Taken from the upcoming ActiveSupport 2.3
+    #
+    # Tries to send the method only if object responds to it. Return +nil+ otherwise.
+    # It will also forward any arguments and/or block like Object#send does.
+    #
+    # ==== Example :
+    #
+    # # Without try
+    # @person ? @person.name : nil
+    #
+    # With try
+    # @person.try(:name)
+    #
+    # # try also accepts arguments/blocks for the method it is trying
+    # Person.try(:find, 1)
+    # @people.try(:map) {|p| p.name}
+    def try(method, *args, &block)
+      send(method, *args, &block) if respond_to?(method, true)
+    end
+  end
 end

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

@@ -9,16 +9,26 @@ module ROXML
         #   => {:key => :value, 1 => 2, 'key' => 'value'}
         #
         def to_hash
-          inject({}) do |result, (k, v)|
-            result[k] = v
+          hash = inject({}) do |result, (k, v)|
+            result[k] ||= []
+            result[k] << v
             result
           end
+          hash.each_pair do |k, v|
+            hash[k] = v.only if v.one?
+          end
+          hash
         end
 
         def to_h #:nodoc:
           to_hash
         end
         deprecate :to_h => :to_hash
+
+        def apply_to(val)
+          # Only makes sense for arrays of blocks... maybe better outside Array...
+          inject(val) {|val, block| block.call(val) }
+        end
       end
     end
   end

data/lib/roxml/extensions/deprecation.rb

@@ -8,7 +8,7 @@ module ActiveSupport # :nodoc:all
     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."
+          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
@@ -16,10 +16,10 @@ module ActiveSupport # :nodoc:all
 
     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."
+        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})"
+          when Symbol then "#{warning}. (use #{message} instead)"
+          when String then "#{warning}. (#{message})"
           else warning
         end
       end

data/lib/roxml/options.rb

@@ -12,27 +12,19 @@ module ROXML
 
       @wrapper = wrapper
       if opts.has_key? :attrs
-        @key   = to_ref(opts, :attr, opts[:attrs][0])
-        @value = to_ref(opts, :attr, opts[:attrs][1])
+        @key   = to_hash_args(opts, :attr, opts[:attrs][0])
+        @value = to_hash_args(opts, :attr, opts[:attrs][1])
       else
-        @key = to_ref opts, *fetch_element(opts, :key)
-        @value = to_ref opts, *fetch_element(opts, :value)
+        @key = to_hash_args opts, *fetch_element(opts, :key)
+        @value = to_hash_args opts, *fetch_element(opts, :value)
       end
     end
 
-    def types
-      [@key.class, @value.class]
-    end
-
-    def names
-      [@key.name, @value.name]
-    end
-
   private
     def fetch_element(opts, what)
       case opts[what]
       when Hash
-        raise ArgumentError, "Hash #{what} is over-specified: #{opts[what].pp_s}" unless opts[what].keys.one?
+        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
@@ -48,19 +40,6 @@ module ROXML
       end
     end
 
-    def to_ref(args, type, name)
-      case type
-      when :attr
-        XMLAttributeRef.new(to_hash_args(args, type, name))
-      when :text
-        XMLTextRef.new(to_hash_args(args, type, name))
-      when Symbol
-        XMLTextRef.new(to_hash_args(args, type, name))
-      else
-        raise ArgumentError, "Missing key description #{{:type => type, :name => name}.pp_s}"
-      end
-    end
-
     def to_hash_args(args, type, name)
       args = [args] unless args.is_a? Array
 
@@ -73,13 +52,13 @@ module ROXML
         Opts.new(name, opts)
       else
         opts = args.extract_options!
-        raise opts.to_s
+        raise opts.inspect
       end
     end
   end
 
   class Opts # :nodoc:
-    attr_reader :name, :type, :hash, :blocks, :default, :accessor
+    attr_reader :name, :type, :hash, :blocks, :accessor, :to_xml
 
     class << self
       def silence_xml_name_warning?
@@ -95,6 +74,11 @@ module ROXML
       @accessor = sym
       @opts = extract_options!(args)
       @default = @opts.delete(:else)
+      @to_xml = @opts.delete(:to_xml)
+
+      if @opts.has_key?(:readonly)
+        raise ArgumentError, "There is no 'readonly' option. You probably mean to use :frozen => true"
+      end
 
       @opts.reverse_merge!(:as => [], :in => nil)
       @opts[:as] = [*@opts[:as]]
@@ -102,7 +86,7 @@ module ROXML
       @type = extract_type(args)
       @opts[:as] << :bool if @accessor.to_s.ends_with?('?')
 
-      if @type.respond_to?(:xml_name?) && @type.xml_name?
+      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. " +
@@ -122,7 +106,7 @@ module ROXML
         @name = '*'
       end
 
-      raise ArgumentError, "Can't specify both :else default and :required" if required? && default
+      raise ArgumentError, "Can't specify both :else default and :required" if required? && @default
     end
 
     def variable_name
@@ -137,6 +121,10 @@ module ROXML
       @type == :hash
     end
 
+    def name?
+      @name == '*'
+    end
+
     def content?
       @type == :content
     end
@@ -157,6 +145,27 @@ module ROXML
       @opts[:required]
     end
 
+    def freeze?
+      @opts[:frozen]
+    end
+
+    def default
+      @default ||= [] if array?
+      @default ||= {} if hash?
+      @default.duplicable? ? @default.dup : @default
+    end
+
+    def to_ref(inst)
+      case 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(self, inst)
+    end
+
   private
     BLOCK_TO_FLOAT = lambda do |val|
       if val.is_a? Array

data/lib/roxml/xml.rb

@@ -16,23 +16,16 @@ module ROXML
   # Internal base class that represents an XML - Class binding.
   #
   class XMLRef # :nodoc:
-    delegate :name, :required?, :array?, :wrapper, :blocks, :accessor, :variable_name, :to => :opts
-    alias_method :xpath_name, :name
+    delegate :required?, :array?, :blocks, :accessor, :variable_name, :default, :to => :opts
 
-    def initialize(opts)
+    def initialize(opts, instance)
       @opts = opts
+      @instance = instance
     end
 
-    # Reads data from the XML element and populates the instance
-    # accordingly.
-    def populate(xml, instance)
-      data = value(xml)
-      instance.instance_variable_set("@#{variable_name}", data)
-      instance
-    end
-
-    def name?
-      false
+    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)
@@ -41,34 +34,79 @@ module ROXML
       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(xml)
+    def value_in(xml)
       value = fetch_value(xml)
-      if value.blank?
-        raise RequiredElementMissing if required?
-        value = default
-      end
-      apply_blocks(value)
+      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.each {|block| val = block[val] }
-      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)
-      (wrapper && xml.name != wrapper) ? xml.child_add(XML::Node.new_element(wrapper)) : 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
 
@@ -87,8 +125,9 @@ module ROXML
     end
 
     def fetch_value(xml)
-      attr = xml.search(xpath).first
-      attr && attr.value
+      nodes_in(xml) do |nodes|
+        nodes.first.value
+      end
     end
 
     def xpath_name
@@ -103,11 +142,7 @@ module ROXML
   #   XMLTextRef
   #  </element>
   class XMLTextRef < XMLRef # :nodoc:
-    delegate :cdata?, :content?, :to => :opts
-
-    def name?
-      name == '*'
-    end
+    delegate :cdata?, :content?, :name?, :to => :opts
 
   private
     # Updates the text in the given _xml_ block to
@@ -127,17 +162,30 @@ module ROXML
     end
 
     def fetch_value(xml)
-      if content?
-        xml.content.strip
-      elsif name?
-        xml.name
-      elsif array?
-        xml.search(xpath).collect do |e|
-          e.content.strip.to_latin if e.content
+      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
+        else
+          value
         end
       else
-        child = xml.search(xpath).first
-        child.content if child
+        nodes_in(xml) do |nodes|
+          if array?
+            nodes.collect do |e|
+              e.content.strip.to_latin
+            end
+          else
+            nodes.first.content
+          end
+        end
       end
     end
 
@@ -153,9 +201,10 @@ module ROXML
   class XMLHashRef < XMLTextRef # :nodoc:
     delegate :hash, :to => :opts
 
-    def default
-      result = super
-      result.nil? ? {} : result
+    def initialize(opts, inst)
+      super(opts, inst)
+      @key = opts.hash.key.to_ref(inst)
+      @value = opts.hash.value.to_ref(inst)
     end
 
   private
@@ -164,14 +213,16 @@ module ROXML
     def write_xml(xml, value)
       value.each_pair do |k, v|
         node = xml.child_add(XML::Node.new_element(hash.wrapper))
-        hash.key.update_xml(node, k)
-        hash.value.update_xml(node, v)
+        @key.update_xml(node, k)
+        @value.update_xml(node, v)
       end
     end
 
     def fetch_value(xml)
-      xml.search(xpath).collect do |e|
-        [hash.key.value(e), hash.value.value(e)]
+      nodes_in(xml) do |nodes|
+        nodes.collect do |e|
+          [@key.value_in(e), @value.value_in(e)]
+        end
       end
     end
 
@@ -183,6 +234,15 @@ module ROXML
       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:
@@ -192,23 +252,27 @@ module ROXML
     # Updates the composed XML object in the given XML block to
     # the value provided.
     def write_xml(xml, value)
-      unless array?
-        xml.child_add(value.to_xml(name))
-      else
+      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)
-      unless array?
-        if child = xml.search(xpath).first
-          instantiate(child)
-        end
-      else
-        xml.search(xpath).collect do |e|
-          instantiate(e)
+      nodes_in(xml) do |nodes|
+        unless array?
+          instantiate(nodes.first)
+        else
+          nodes.collect do |e|
+            instantiate(e)
+          end
         end
       end
     end