Empact-roxml 2.1 → 2.2

data/lib/roxml/extensions/array.rb

@@ -0,0 +1,5 @@
+require File.join(File.dirname(__FILE__), 'array/conversions')
+
+class Array #:nodoc:
+  include ROXML::CoreExtensions::Array::Conversions
+end

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

@@ -0,0 +1,27 @@
+require File.join(File.dirname(__FILE__), '../deprecation')
+
+module ROXML
+  module CoreExtensions
+    module Array #:nodoc:
+      module Conversions
+        # Translates an array into a hash, where each element of the array is
+        # an array with 2 elements:
+        #
+        #   >> [[:key, :value], [1, 2], ['key', 'value']].to_h
+        #   => {:key => :value, 1 => 2, 'key' => 'value'}
+        #
+        def to_hash
+          inject({}) do |result, (k, v)|
+            result[k] = v
+            result
+          end
+        end
+
+        def to_h #:nodoc:
+          ActiveSupport::Deprecation.warn "Please use #to_hash instead"
+          to_hash
+        end
+      end
+    end
+  end
+end

data/lib/roxml/extensions/deprecation.rb

@@ -0,0 +1,15 @@
+require 'active_support'
+require 'active_support/version'
+
+module ActiveSupport # :nodoc:all
+  if VERSION::MAJOR <= 2 && VERSION::MINOR <= 1
+    module Deprecation
+      class << self
+        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
+  end
+end

data/lib/roxml/extensions/string.rb

@@ -0,0 +1,22 @@
+require File.join(File.dirname(__FILE__), 'string/conversions')
+require File.join(File.dirname(__FILE__), 'string/iterators')
+
+class String #:nodoc:
+  include ROXML::CoreExtensions::String::Conversions
+  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
+    ActiveSupport::Deprecation.warn "This method will be removed from Object please use String#to_utf instead via explicit #to_s"
+    to_s.to_utf
+  end
+
+  # Deprecated in favor of explicit #to_s.to_latin
+  def to_latin
+    ActiveSupport::Deprecation.warn "This method will be removed from Object please use String#to_latin instead via explicit #to_s"
+    to_s.to_latin
+  end
+end

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

@@ -0,0 +1,44 @@
+module ROXML
+  module CoreExtensions #:nodoc:
+    module String
+      # Extension of String class to handle conversion from/to
+      # UTF-8/ISO-8869-1
+      module Conversions
+        require 'iconv'
+
+        #
+        # Return an utf-8 representation of this string.
+        #
+        def to_utf
+          begin
+            Iconv.new("utf-8", "iso-8859-1").iconv(to_s)
+          rescue Iconv::IllegalSequence
+            STDERR << "!! Failed converting from UTF-8 -> ISO-8859-1 (#{self}). Already the right charset?"
+            self
+          end
+        end
+
+        #
+        # Convert this string to iso-8850-1
+        #
+        def to_latin
+          begin
+            Iconv.new("iso-8859-1", "utf-8").iconv(to_s)
+          rescue Iconv::IllegalSequence
+            STDERR << "!! Failed converting from ISO-8859-1 -> UTF-8 (#{self}). Already the right charset?"
+            self
+          end
+        end
+      end
+    end
+  end
+end
+
+class Object
+end
+
+class String
+  def between(separator, &block)
+    split(separator).collect(&block).join(separator)
+  end
+end

data/lib/roxml/extensions/string/iterators.rb

@@ -0,0 +1,12 @@
+module ROXML
+  module CoreExtensions
+    module String #:nodoc:
+      module Iterators
+        # Allows you to iterate over and modify the sub-strings between _separator_.  Returns the joined result of the modification.
+        def between(separator, &block)
+          split(separator).collect(&block).join(separator)
+        end
+      end
+    end
+  end
+end

data/lib/roxml/options.rb

@@ -2,7 +2,7 @@ module ROXML
   HASH_KEYS = [:attrs, :key, :value].freeze
   TYPE_KEYS = [:attr, :text, :hash, :content].freeze
 
-  class HashDesc # ::nodoc::
+  class HashDesc # :nodoc:
     attr_reader :key, :value, :wrapper
 
     def initialize(opts, wrapper)
@@ -78,25 +78,24 @@ module ROXML
     end
   end
 
-  class Opts # ::nodoc::
-    attr_reader :type, :hash
+  class Opts # :nodoc:
+    attr_reader :name, :type, :hash, :blocks
 
-    def initialize(sym, *args)
+    def initialize(sym, *args, &block)
       @opts = extract_options!(args)
 
       @opts.reverse_merge!(:from => sym.to_s, :as => [], :else => nil, :in => nil)
       @opts[:as] = [*@opts[:as]]
       @type = extract_type(args)
+      @blocks = collect_blocks(block, @opts[:as])
 
       @name = @opts[:from].to_s
-    end
-
-    def name=(n)
-      @name = n.to_s
-    end
+      @name = @name.singularize if hash? || array?
+      if hash? && (hash.key.name? || hash.value.name?)
+        @name = '*'
+      end
 
-    def name
-      enumerable? ? @name.singularize : @name
+      raise ArgumentError, "Can't specify both :else default and :required" if required? && default
     end
 
     def hash
@@ -107,10 +106,6 @@ module ROXML
       @opts[:else]
     end
 
-    def enumerable?
-      hash? || array?
-    end
-
     def hash?
       @type == :hash
     end
@@ -131,7 +126,24 @@ module ROXML
       @opts[:in]
     end
 
+    def required?
+      @opts[:required]
+    end
+
   private
+    BLOCK_SHORTHANDS = {
+      :integer => lambda {|val| Integer(val) },
+      Integer  => lambda {|val| Integer(val) },
+      :float   => lambda {|val| Float(val) },
+      Float    => lambda {|val| Float(val) }
+    }
+
+    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
+    end
+
     def extract_options!(args)
       opts = args.extract_options!
       unless (opts.keys & HASH_KEYS).empty?

data/lib/roxml/xml.rb

@@ -2,26 +2,27 @@ module ROXML
   unless const_defined? 'XML_PARSER'
     begin
       require 'libxml'
-      XML_PARSER = 'libxml'
+      XML_PARSER = 'libxml' # :nodoc:
     rescue LoadError
-      XML_PARSER = 'rexml'
+      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::
-    attr_reader :accessor, :name, :array, :default, :block, :wrapper
+  class XMLRef # :nodoc:
+    attr_reader :accessor
+    delegate :name, :required?, :array?, :default, :wrapper, :blocks, :to => :opts
+    alias_method :xpath_name, :name
 
-    def initialize(accessor, args, &block)
+    def initialize(accessor, args)
       @accessor = accessor
-      @array = args.array?
-      @name = args.name
-      @default = args.default
-      @block = block
-      @wrapper = args.wrapper
+      @opts = args
     end
 
     # Reads data from the XML element and populates the instance
@@ -36,9 +37,31 @@ module ROXML
       false
     end
 
+    def update_xml(xml, value)
+      returning wrap(xml) do |xml|
+        write_xml(xml, value)
+      end
+    end
+
+    def value(xml)
+      value = fetch_value(xml)
+      if value.blank?
+        raise RequiredElementMissing if required?
+        value = default
+      end
+      apply_blocks(value)
+    end
+
   private
+    attr_reader :opts
+
+    def apply_blocks(val)
+      blocks.each {|block| val = block[*val] } unless blocks.empty?
+      val
+    end
+
     def xpath
-      wrapper ? "#{wrapper}#{xpath_separator}#{name}" : name.to_s
+      wrapper ? "#{wrapper}/#{xpath_name}" : xpath_name.to_s
     end
 
     def wrap(xml)
@@ -52,23 +75,21 @@ module ROXML
   #  <element attribute="XMLAttributeRef">
   #   XMLTextRef
   #  </element>
-  class XMLAttributeRef < XMLRef # ::nodoc::
+  class XMLAttributeRef < XMLRef # :nodoc:
+  private
     # Updates the attribute in the given XML block to
     # the value provided.
-    def update_xml(xml, value)
-      xml.attributes[name] = value.to_utf
-      xml
+    def write_xml(xml, value)
+      xml.attributes[name] = value.to_s.to_utf
     end
 
-    def value(xml)
-      parent = wrap(xml)
-      val = xml.attributes[name] || default
-      block ? block.call(val) : val
+    def fetch_value(xml)
+      attr = xml.search(xpath).first
+      attr && attr.value
     end
 
-  private
-    def xpath_separator
-      '@'
+    def xpath_name
+      "@#{name}"
     end
   end
 
@@ -78,165 +99,117 @@ module ROXML
   #  <element attribute="XMLAttributeRef">
   #   XMLTextRef
   #  </element>
-  class XMLTextRef < XMLRef # ::nodoc::
-    attr_reader :cdata, :content
+  class XMLTextRef < XMLRef # :nodoc:
+    delegate :cdata?, :content?, :to => :opts
 
-    def initialize(accessor, args, &block)
-      super(accessor, args, &block)
-      @content = args.content?
-      @cdata = args.cdata?
+    def name?
+      name == '*'
     end
 
+  private
     # Updates the text in the given _xml_ block to
     # the _value_ provided.
-    def update_xml(xml, value)
-      parent = wrap(xml)
-      if content
-        add(parent, value)
+    def write_xml(xml, value)
+      if content?
+        add(xml, value)
       elsif name?
-        parent.name = value
-      elsif array
+        xml.name = value
+      elsif array?
         value.each do |v|
-          add(parent.child_add(XML::Node.new_element(name)), v)
+          add(xml.child_add(XML::Node.new_element(name)), v)
         end
       else
-        add(parent.child_add(XML::Node.new_element(name)), value)
+        add(xml.child_add(XML::Node.new_element(name)), value)
       end
-      xml
     end
 
-    def value(xml)
-      val = if content
+    def fetch_value(xml)
+      if content?
         xml.content.strip
       elsif name?
         xml.name
-      elsif array
-        arr = xml.search(xpath).collect do |e|
+      elsif array?
+        xml.search(xpath).collect do |e|
           e.content.strip.to_latin if e.content
         end
-        arr unless arr.empty?
       else
         child = xml.search(name).first
         child.content if child
       end
-      val = default unless val && !val.blank?
-      block ? block.call(val) : val
-    end
-
-    def name?
-      name == '*'
-    end
-
-  private
-    def xpath_separator
-      '/'
     end
 
     def add(dest, value)
-      if cdata
-        dest.child_add(XML::Node.new_cdata(value.to_utf))
+      if cdata?
+        dest.child_add(XML::Node.new_cdata(value.to_s.to_utf))
       else
-        dest.content = value.to_utf
+        dest.content = value.to_s.to_utf
       end
     end
   end
 
-  class XMLHashRef < XMLTextRef # ::nodoc::
-    attr_reader :hash
-
-    def initialize(accessor, args, &block)
-      super(accessor, args, &block)
-      @hash = args.hash
-      if @hash.key.name? || @hash.value.name?
-        @name = '*'
-      end
-    end
+  class XMLHashRef < XMLTextRef # :nodoc:
+    delegate :hash, :to => :opts
 
+  private
     # Updates the composed XML object in the given XML block to
     # the value provided.
-    def update_xml(xml, value)
-      parent = wrap(xml)
+    def write_xml(xml, value)
       value.each_pair do |k, v|
-        node = add_node(parent)
+        node = xml.child_add(XML::Node.new_element(hash.wrapper))
         hash.key.update_xml(node, k)
         hash.value.update_xml(node, v)
       end
-      xml
     end
 
-    def value(xml)
-      vals = xml.search(xpath).collect do |e|
-        [@hash.key.value(e), @hash.value.value(e)]
-      end
-      if block
-        vals.collect! do |(key, val)|
-          block.call(key, val)
-        end
+    def fetch_value(xml)
+      xml.search(xpath).collect do |e|
+        [hash.key.value(e), hash.value.value(e)]
       end
-      vals.to_h
     end
 
-  private
-    def add_node(xml)
-      xml.child_add(XML::Node.new_element(hash.wrapper))
+    def apply_blocks(vals)
+      unless blocks.empty?
+        vals.collect! do |kvp|
+          super(kvp)
+        end
+      end
+      vals.to_hash
     end
   end
 
-  class XMLObjectRef < XMLTextRef # ::nodoc::
-    attr_reader :klass
-
-    def initialize(accessor, args, &block)
-      super(accessor, args, &block)
-      @klass = args.type
-    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 update_xml(xml, value)
-      parent = wrap(xml)
-      unless array
-        parent.child_add(value.to_xml(name))
+    def write_xml(xml, value)
+      unless array?
+        xml.child_add(value.to_xml(name))
       else
         value.each do |v|
-          parent.child_add(v.to_xml(name))
+          xml.child_add(v.to_xml(name))
         end
       end
-      xml
     end
 
-    def value(xml)
-      val = unless array
+    def fetch_value(xml)
+      unless array?
         if child = xml.search(xpath).first
           instantiate(child)
         end
       else
-        arr = xml.search(xpath).collect do |e|
+        xml.search(xpath).collect do |e|
           instantiate(e)
         end
-        arr unless arr.empty?
-      end || default
-      block ? block.call(val) : val
+      end
     end
 
-  private
     def instantiate(elem)
-      if klass.respond_to? :parse
-        klass.parse(elem)
+      if type.respond_to? :from_xml
+        type.from_xml(elem)
       else
-        klass.new(elem)
-      end
-    end
-  end
-
-  #
-  # Returns an XML::Node representing this object.
-  #
-  def to_xml(name = nil)
-    returning XML::Node.new_element(name || tag_name) do |root|
-      tag_refs.each do |ref|
-        if v = __send__(ref.accessor)
-          ref.update_xml(root, v)
-        end
+        type.new(elem)
       end
     end
   end