Empact-roxml 2.0

data/lib/roxml/array.rb

@@ -0,0 +1,15 @@
+class Array
+  # 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_h
+    returning({}) do |result|
+      each do |(k, v)|
+        result[k] = v
+      end
+    end
+  end
+end

data/lib/roxml/options.rb

@@ -0,0 +1,175 @@
+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_ref(opts, :attr, opts[:attrs][0])
+        @value = to_ref(opts, :attr, opts[:attrs][1])
+      else
+        @key = to_ref opts, *fetch_element(opts, :key)
+        @value = to_ref 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?
+        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_ref(args, type, name)
+      case type
+      when :attr
+        XMLAttributeRef.new(nil, to_hash_args(args, type, name))
+      when :text
+        XMLTextRef.new(nil, to_hash_args(args, type, name))
+      when Symbol
+        XMLTextRef.new(nil, 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
+
+      if args.one? && !(args.only.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.to_s
+      end
+    end
+  end
+
+  class Opts # ::nodoc::
+    attr_reader :type, :hash
+
+    def initialize(sym, *args)
+      @opts = extract_options!(args)
+
+      @opts.reverse_merge!(:from => sym.to_s, :as => [], :else => nil, :in => nil)
+      @opts[:as] = [*@opts[:as]]
+      @type = extract_type(args)
+
+      @name = @opts[:from].to_s
+    end
+
+    def name=(n)
+      @name = n.to_s
+    end
+
+    def name
+      enumerable? ? @name.singularize : @name
+    end
+
+    def hash
+      @hash ||= HashDesc.new(@opts.delete(:hash), name) if hash?
+    end
+
+    def default
+      @opts[:else]
+    end
+
+    def enumerable?
+      hash? || array?
+    end
+
+    def hash?
+      @type == :hash
+    end
+
+    def content?
+      @type == :content
+    end
+
+    def array?
+      @opts[:as].include? :array
+    end
+
+    def cdata?
+      @opts[:as].include? :cdata
+    end
+
+    def wrapper
+      @opts[:in]
+    end
+
+  private
+    def extract_options!(args)
+      opts = args.extract_options!
+      unless (opts.keys & HASH_KEYS).empty?
+        args.push(opts)
+        opts = {}
+      end
+      opts
+    end
+
+    def extract_type(args)
+      types = (@opts.keys & TYPE_KEYS)
+      # type arg
+      if args.one? && types.empty?
+        if args.only.is_a? Array
+          @opts[:as] << :array
+          return args.only.only
+        elsif args.only.is_a? Hash
+          @opts[:hash] = args.only
+          return :hash
+        else
+          return args.only
+        end
+      end
+
+      unless args.empty?
+        raise ArgumentError, "too many arguments (#{(args + types).join(', ')}).  Should be name, type, and " +
+                             "an options hash, with the type and options optional"
+      end
+
+      # type options
+      if types.one?
+        @opts[:from] = @opts.delete(types.only)
+        types.only
+      elsif types.empty?
+        :text
+      else
+        raise ArgumentError, "more than one type option specified: #{types.join(', ')}"
+      end
+    end
+  end
+end

data/lib/roxml/string.rb

@@ -0,0 +1,35 @@
+# Extension of String class to handle conversion from/to
+# UTF-8/ISO-8869-1
+class Object
+  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
+
+class String
+  def between(separator, &block)
+    split(separator).collect(&block).join(separator)
+  end
+end

data/lib/roxml/xml.rb

@@ -0,0 +1,243 @@
+module ROXML
+  unless const_defined? 'XML_PARSER'
+    begin
+      require 'libxml'
+      XML_PARSER = 'libxml'
+    rescue LoadError
+      XML_PARSER = 'rexml'
+    end
+  end
+  require File.join(File.dirname(__FILE__), 'xml', XML_PARSER)
+
+  #
+  # Internal base class that represents an XML - Class binding.
+  #
+  class XMLRef # ::nodoc::
+    attr_reader :accessor, :name, :array, :default, :block, :wrapper
+
+    def initialize(accessor, args, &block)
+      @accessor = accessor
+      @array = args.array?
+      @name = args.name
+      @default = args.default
+      @block = block
+      @wrapper = args.wrapper
+    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
+    end
+
+    def name?
+      false
+    end
+
+  private
+    def xpath
+      wrapper ? "#{wrapper}#{xpath_separator}#{name}" : name.to_s
+    end
+
+    def wrap(xml)
+      (wrapper && xml.name != wrapper) ? xml.child_add(XML::Node.new_element(wrapper)) : xml
+    end
+  end
+
+  # Interal class representing an XML attribute binding
+  #
+  # In context:
+  #  <element attribute="XMLAttributeRef">
+  #   XMLTextRef
+  #  </element>
+  class XMLAttributeRef < XMLRef # ::nodoc::
+    # Updates the attribute in the given XML block to
+    # the value provided.
+    def update_xml(xml, value)
+      xml.attributes[name] = value.to_utf
+      xml
+    end
+
+    def value(xml)
+      parent = wrap(xml)
+      val = xml.attributes[name] || default
+      block ? block.call(val) : val
+    end
+
+  private
+    def xpath_separator
+      '@'
+    end
+  end
+
+  # Interal class representing XML content text binding
+  #
+  # In context:
+  #  <element attribute="XMLAttributeRef">
+  #   XMLTextRef
+  #  </element>
+  class XMLTextRef < XMLRef # ::nodoc::
+    attr_reader :cdata, :content
+
+    def initialize(accessor, args, &block)
+      super(accessor, args, &block)
+      @content = args.content?
+      @cdata = args.cdata?
+    end
+
+    # 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)
+      elsif name?
+        parent.name = value
+      elsif array
+        value.each do |v|
+          add(parent.child_add(XML::Node.new_element(name)), v)
+        end
+      else
+        add(parent.child_add(XML::Node.new_element(name)), value)
+      end
+      xml
+    end
+
+    def value(xml)
+      val = if content
+        xml.content.strip
+      elsif name?
+        xml.name
+      elsif array
+        arr = 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))
+      else
+        dest.content = value.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
+
+    # Updates the composed XML object in the given XML block to
+    # the value provided.
+    def update_xml(xml, value)
+      parent = wrap(xml)
+      value.each_pair do |k, v|
+        node = add_node(parent)
+        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
+      end
+      vals.to_h
+    end
+
+  private
+    def add_node(xml)
+      xml.child_add(XML::Node.new_element(hash.wrapper))
+    end
+  end
+
+  class XMLObjectRef < XMLTextRef # ::nodoc::
+    attr_reader :klass
+
+    def initialize(accessor, args, &block)
+      super(accessor, args, &block)
+      @klass = args.type
+    end
+
+    # 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))
+      else
+        value.each do |v|
+          parent.child_add(v.to_xml(name))
+        end
+      end
+      xml
+    end
+
+    def value(xml)
+      val = unless array
+        if child = xml.search(xpath).first
+          instantiate(child)
+        end
+      else
+        arr = xml.search(xpath).collect do |e|
+          instantiate(e)
+        end
+        arr unless arr.empty?
+      end || default
+      block ? block.call(val) : val
+    end
+
+  private
+    def instantiate(elem)
+      if klass.respond_to? :parse
+        klass.parse(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
+      end
+    end
+  end
+end