xml-mapping 0.8.1 → 0.9.1

data/lib/xml/mapping/core_classes_mapping.rb

@@ -0,0 +1,32 @@
+class String
+  def self.load_from_xml(xml, options={:mapping=>:_default})
+    xml.text
+  end
+
+  def fill_into_xml(xml, options={:mapping=>:_default})
+    xml.text = self
+  end
+
+  def text
+    self
+  end
+end
+
+
+class Numeric
+  def self.load_from_xml(xml, options={:mapping=>:_default})
+    begin
+      Integer(xml.text)
+    rescue ArgumentError
+      Float(xml.text)
+    end
+  end
+
+  def fill_into_xml(xml, options={:mapping=>:_default})
+    xml.text = self.to_s
+  end
+
+  def text
+    self.to_s
+  end
+end

data/lib/xml/mapping/standard_nodes.rb

@@ -9,21 +9,21 @@ module XML
     # 
     #   text_node :_attrname_, _path_ [, :default_value=>_obj_]
     #                                 [, :optional=>true]
+    #                                 [, :mapping=>_m_]
     #
     # Node that maps an XML node's text (the element's first child
     # text node resp. the attribute's value) to a (string) attribute
-    # of the mapped object. Since TextNode inherits from
-    # SingleAttributeNode, the first argument to the node factory
-    # function is the attribute name (as a symbol). Handling of
-    # <tt>:default_value</tt> and <tt>:optional</tt> option arguments
-    # (if given) is also provided by the superclass -- see there for
-    # details.
+    # of the mapped object. _path_ (an XPath expression) locates the
+    # XML node, _attrname_ (a symbol) names the
+    # attribute. <tt>:default_value</tt> is the default value,
+    # :optional=>true is equivalent to :default_value=>nil (see
+    # superclass documentation for details). <tt>_m_</tt> is the
+    # mapping; it defaults to the current default mapping
     class TextNode < SingleAttributeNode
-      # Initializer. _path_ (a string, the 2nd argument to the node
-      # factory function) is the XPath expression that locates the
-      # mapped node in the XML.
-      def initialize_impl(path)
+      def initialize(*args)
+        path,*args = super(*args)
         @path = XML::XXPath.new(path)
+        args
       end
       def extract_attr_value(xml) # :nodoc:
         default_when_xpath_err{ @path.first(xml).text }
@@ -37,13 +37,16 @@ module XML
     # 
     #   numeric_node :_attrname_, _path_ [, :default_value=>_obj_]
     #                                    [, :optional=>true]
+    #                                    [, :mapping=>_m_]
     #
     # Like TextNode, but interprets the XML node's text as a number
     # (Integer or Float, depending on the nodes's text) and maps it to
     # an Integer or Float attribute.
     class NumericNode < SingleAttributeNode
-      def initialize_impl(path)
+      def initialize(*args)
+        path,*args = super(*args)
         @path = XML::XXPath.new(path)
+        args
       end
       def extract_attr_value(xml) # :nodoc:
         txt = default_when_xpath_err{ @path.first(xml).text }
@@ -67,10 +70,9 @@ module XML
     class SubObjectBaseNode < SingleAttributeNode
       # processes the keyword arguments :class, :marshaller, and
       # :unmarshaller (_args_ is ignored). When this initiaizer
-      # returns, @options[:marshaller] and @options[:unmarshaller] are
-      # set to procs that marshal/unmarshal a Ruby object to/from an
-      # XML tree according to the keyword arguments that were passed
-      # to the initializer:
+      # returns, @marshaller and @unmarshaller are set to procs that
+      # marshal/unmarshal a Ruby object to/from an XML tree according
+      # to the keyword arguments that were passed to the initializer:
       #
       # You either supply a :class argument with a class implementing
       # XML::Mapping -- in that case, the subtree will be mapped to an
@@ -89,37 +91,50 @@ module XML
       #
       # If both :class and :marshaller/:unmarshaller arguments are
       # supplied, the latter take precedence.
-      def initialize_impl(*args)
+      def initialize(*args)
+        args = super(*args)
+
+        @sub_mapping = @options[:sub_mapping] || @mapping
+        @marshaller, @unmarshaller = @options[:marshaller], @options[:unmarshaller]
+
         if @options[:class]
-          unless @options[:marshaller]
-            @options[:marshaller] = proc {|xml,value|
-              value.fill_into_xml(xml)
+          unless @marshaller
+            @marshaller = proc {|xml,value|
+              value.fill_into_xml xml, :mapping=>@sub_mapping
+              if xml.unspecified?
+                xml.name = value.class.root_element_name :mapping=>@sub_mapping
+                xml.unspecified = false
+              end
             }
           end
-          unless @options[:unmarshaller]
-            @options[:unmarshaller] = proc {|xml|
-              @options[:class].load_from_xml(xml)
+          unless @unmarshaller
+            @unmarshaller = proc {|xml|
+              @options[:class].load_from_xml xml, :mapping=>@sub_mapping
             }
           end
         end
 
-        unless @options[:marshaller]
-          @options[:marshaller] = proc {|xml,value|
-            value.fill_into_xml(xml)
+        unless @marshaller
+          @marshaller = proc {|xml,value|
+            value.fill_into_xml xml, :mapping=>@sub_mapping
             if xml.unspecified?
-              xml.name = value.class.root_element_name
+              xml.name = value.class.root_element_name :mapping=>@sub_mapping
               xml.unspecified = false
             end
           }
         end
-        unless @options[:unmarshaller]
-          @options[:unmarshaller] = proc {|xml|
-            XML::Mapping.load_object_from_xml(xml)
+        unless @unmarshaller
+          @unmarshaller = proc {|xml|
+            XML::Mapping.load_object_from_xml xml, :mapping=>@sub_mapping
           }
         end
+
+        args
       end
     end
 
+    require 'xml/mapping/core_classes_mapping'
+
     # Node factory function synopsis:
     # 
     #   object_node :_attrname_, _path_ [, :default_value=>_obj_]
@@ -127,6 +142,8 @@ module XML
     #                                   [, :class=>_c_]
     #                                   [, :marshaller=>_proc_]
     #                                   [, :unmarshaller=>_proc_]
+    #                                   [, :mapping=>_m_]
+    #                                   [, :sub_mapping=>_sm_]
     #
     # Node that maps a subtree in the source XML to a Ruby
     # object. :_attrname_ and _path_ are again the attribute name
@@ -140,15 +157,16 @@ module XML
     class ObjectNode < SubObjectBaseNode
       # Initializer. _path_ (a string denoting an XPath expression) is
       # the location of the subtree.
-      def initialize_impl(path)
-        super
-	@path = XML::XXPath.new(path)
+      def initialize(*args)
+        path,*args = super(*args)
+        @path = XML::XXPath.new(path)
+        args
       end
       def extract_attr_value(xml) # :nodoc:
-        @options[:unmarshaller].call(default_when_xpath_err{@path.first(xml)})
+        @unmarshaller.call(default_when_xpath_err{@path.first(xml)})
       end
       def set_attr_value(xml, value) # :nodoc:
-        @options[:marshaller].call(@path.first(xml,:ensure_created=>true), value)
+        @marshaller.call(@path.first(xml,:ensure_created=>true), value)
       end
     end
 
@@ -157,6 +175,7 @@ module XML
     #   boolean_node :_attrname_, _path_,
     #                _true_value_, _false_value_ [, :default_value=>_obj_]
     #                                            [, :optional=>true]
+    #                                            [, :mapping=>_m_]
     #
     # Node that maps an XML node's text (the element name resp. the
     # attribute value) to a boolean attribute of the mapped
@@ -168,9 +187,11 @@ module XML
     # represent the +false+ boolean value.
     class BooleanNode < SingleAttributeNode
       # Initializer.
-      def initialize_impl(path,true_value,false_value)
+      def initialize(*args)
+        path,true_value,false_value,*args = super(*args)
         @path = XML::XXPath.new(path)
         @true_value = true_value; @false_value = false_value
+        args
       end
       def extract_attr_value(xml) # :nodoc:
         default_when_xpath_err{ @path.first(xml).text==@true_value }
@@ -188,6 +209,8 @@ module XML
     #                     [, :class=>_c_]
     #                     [, :marshaller=>_proc_]
     #                     [, :unmarshaller=>_proc_]
+    #                     [, :mapping=>_m_]
+    #                     [, :sub_mapping=>_sm_]
     #
     # -or-
     #
@@ -233,38 +256,35 @@ module XML
     #    </bar>
     #   </foo>
     class ArrayNode < SubObjectBaseNode
-      # Initializer, delegates to do_initialize. Called with keyword
-      # arguments and either 1 or 2 paths; the hindmost path argument
-      # passed is delegated to _per_arrelement_path_; the preceding
-      # path argument (if present, "" by default) is delegated to
-      # _base_path_.
-      def initialize_impl(path,path2=nil)
-        super
-	if path2
-	  do_initialize(path,path2)
-	else
-	  do_initialize("",path)
-	end
-      end
-      # "Real" initializer.
-      def do_initialize(base_path,per_arrelement_path)
-	per_arrelement_path=per_arrelement_path[1..-1] if per_arrelement_path[0]==?/
-	@base_path = XML::XXPath.new(base_path)
-	@per_arrelement_path = XML::XXPath.new(per_arrelement_path)
-	@reader_path = XML::XXPath.new(base_path+"/"+per_arrelement_path)
+      # Initializer. Called with keyword arguments and either 1 or 2
+      # paths; the hindmost path argument passed is delegated to
+      # _per_arrelement_path_; the preceding path argument (if
+      # present, "" by default) is delegated to _base_path_.
+      def initialize(*args)
+        path,path2,*args = super(*args)
+        base_path,per_arrelement_path = if path2
+                                          [path,path2]
+                                        else
+                                          [".",path]
+                                        end
+        per_arrelement_path=per_arrelement_path[1..-1] if per_arrelement_path[0]==?/
+        @base_path = XML::XXPath.new(base_path)
+        @per_arrelement_path = XML::XXPath.new(per_arrelement_path)
+        @reader_path = XML::XXPath.new(base_path+"/"+per_arrelement_path)
+        args
       end
       def extract_attr_value(xml) # :nodoc:
         result = []
         default_when_xpath_err{@reader_path.all(xml)}.each do |elt|
-          result << @options[:unmarshaller].call(elt)
+          result << @unmarshaller.call(elt)
         end
         result
       end
       def set_attr_value(xml, value) # :nodoc:
-	base_elt = @base_path.first(xml,:ensure_created=>true)
-	value.each do |arr_elt|
-          @options[:marshaller].call(@per_arrelement_path.create_new(base_elt), arr_elt)
-	end
+        base_elt = @base_path.first(xml,:ensure_created=>true)
+        value.each do |arr_elt|
+          @marshaller.call(@per_arrelement_path.create_new(base_elt), arr_elt)
+        end
       end
     end
 
@@ -277,6 +297,8 @@ module XML
     #                     [, :class=>_c_]
     #                     [, :marshaller=>_proc_]
     #                     [, :unmarshaller=>_proc_]
+    #                     [, :mapping=>_m_]
+    #                     [, :sub_mapping=>_sm_]
     #
     # - or -
     #
@@ -296,45 +318,113 @@ module XML
     # to such a node, key_path_ names the node whose text becomes the
     # associated hash key.
     class HashNode < SubObjectBaseNode
-      # Initializer, delegates to do_initialize. Called with keyword
-      # arguments and either 2 or 3 paths; the hindmost path argument
-      # passed is delegated to _key_path_, the preceding path argument
-      # is delegated to _per_arrelement_path_, the path preceding that
-      # argument (if present, "" by default) is delegated to
-      # _base_path_. The meaning of the keyword arguments is the same
-      # as for ObjectNode.
-      def initialize_impl(path1,path2,path3=nil)
-        super
-        if path3
-          do_initialize(path1,path2,path3)
-        else
-          do_initialize("",path1,path2)
-        end
-      end
-      # "Real" initializer.
-      def do_initialize(base_path,per_hashelement_path,key_path)
-	per_hashelement_path=per_hashelement_path[1..-1] if per_hashelement_path[0]==?/
-	@base_path = XML::XXPath.new(base_path)
-	@per_hashelement_path = XML::XXPath.new(per_hashelement_path)
-	@key_path = XML::XXPath.new(key_path)
-	@reader_path = XML::XXPath.new(base_path+"/"+per_hashelement_path)
+      # Initializer. Called with keyword arguments and either 2 or 3
+      # paths; the hindmost path argument passed is delegated to
+      # _key_path_, the preceding path argument is delegated to
+      # _per_arrelement_path_, the path preceding that argument (if
+      # present, "" by default) is delegated to _base_path_. The
+      # meaning of the keyword arguments is the same as for
+      # ObjectNode.
+      def initialize(*args)
+        path1,path2,path3,*args = super(*args)
+        base_path,per_hashelement_path,key_path = if path3
+                                                    [path1,path2,path3]
+                                                  else
+                                                    ["",path1,path2]
+                                                  end
+        per_hashelement_path=per_hashelement_path[1..-1] if per_hashelement_path[0]==?/
+        @base_path = XML::XXPath.new(base_path)
+        @per_hashelement_path = XML::XXPath.new(per_hashelement_path)
+        @key_path = XML::XXPath.new(key_path)
+        @reader_path = XML::XXPath.new(base_path+"/"+per_hashelement_path)
+        args
       end
       def extract_attr_value(xml) # :nodoc:
         result = {}
         default_when_xpath_err{@reader_path.all(xml)}.each do |elt|
           key = @key_path.first(elt).text
-          value = @options[:unmarshaller].call(elt)
+          value = @unmarshaller.call(elt)
           result[key] = value
         end
         result
       end
       def set_attr_value(xml, value) # :nodoc:
-	base_elt = @base_path.first(xml,:ensure_created=>true)
-	value.each_pair do |k,v|
+        base_elt = @base_path.first(xml,:ensure_created=>true)
+        value.each_pair do |k,v|
           elt = @per_hashelement_path.create_new(base_elt)
-          @options[:marshaller].call(elt,v)
+          @marshaller.call(elt,v)
           @key_path.first(elt,:ensure_created=>true).text = k
-	end
+        end
+      end
+    end
+
+
+    class ChoiceNode < Node
+
+      def initialize(*args)
+        args = super(*args)
+        @choices = []
+        path=nil
+        args.each do |arg|
+          next if [:if,:then,:elsif].include? arg
+          if path.nil?
+            path = (if [:else,:default,:otherwise].include? arg
+                      :else
+                    else
+                      XML::XXPath.new arg
+                    end)
+          else
+            raise XML::MappingError, "node expected, found: #{arg.inspect}" unless Node===arg
+            @choices << [path,arg]
+
+            # undo what the node factory fcn did -- ugly ugly!  would
+            # need some way to lazy-evaluate arg (a proc would be
+            # simple but ugly for the user), and then use some
+            # mechanism (a flag with dynamic scope probably) to tell
+            # the node factory fcn not to add the node to the
+            # xml_mapping_nodes
+            @owner.xml_mapping_nodes(:mapping=>@mapping).delete arg 
+            path=nil
+          end
+        end
+
+        raise XML::MappingError, "node missing at end of argument list" unless path.nil?
+        raise XML::MappingError, "no choices were supplied" if @choices.empty?
+        
+        []
+      end
+
+      def xml_to_obj(obj,xml)
+        @choices.each do |path,node|
+          if path==:else or not(path.all(xml).empty?)
+            node.xml_to_obj(obj,xml)
+            return true
+          end
+        end
+        raise XML::MappingError, "xml_to_obj: no choice matched in: #{xml}"
+      end
+
+      def obj_to_xml(obj,xml)
+        @choices.each do |path,node|
+          if node.is_present_in? obj
+            node.obj_to_xml(obj,xml)
+            path.first(xml, :ensure_created=>true)
+            return true
+          end
+        end
+        # @choices[0][1].obj_to_xml(obj,xml)
+        raise XML::MappingError, "obj_to_xml: no choice present in object: #{obj.inspect}"
+      end
+
+      def obj_initializing(obj,mapping)
+        @choices[0][1].obj_initializing(obj,mapping)
+      end
+
+      # (overridden) true if at least one of our nodes is_present_in?
+      # obj.
+      def is_present_in? obj
+        # TODO: use Enumerable#any?
+        @choices.inject(false){|prev,(path,node)| prev or node.is_present_in?(obj)}
       end
     end
 

data/lib/xml/mapping/version.rb

@@ -1,8 +1,8 @@
 # xml-mapping -- bidirectional Ruby-XML mapper
-#  Copyright (C) 2004,2005 Olaf Klischat
+#  Copyright (C) 2004-2010 Olaf Klischat
 
 module XML
   module Mapping
-    VERSION = '0.8.1'
+    VERSION = '0.9.1'
   end
 end

data/lib/xml/rexml_ext.rb

@@ -0,0 +1,186 @@
+# xxpath -- XPath implementation for Ruby, including write access
+#  Copyright (C) 2004-2010 Olaf Klischat
+
+require 'rexml/document'
+
+module XML
+
+  class XXPath
+    module Accessors  #:nodoc:
+
+      # we need a boolean "unspecified?" attribute for XML nodes --
+      # paths like "*" oder (somewhen) "foo|bar" create "unspecified"
+      # nodes that the user must then "specify" by setting their text
+      # etc. (or manually setting unspecified=false)
+      #
+      # This is mixed into the REXML::Element and
+      # XML::XXPath::Accessors::Attribute classes.
+      module UnspecifiednessSupport
+
+        def unspecified?
+          @xml_xpath_unspecified ||= false
+        end
+
+        def unspecified=(x)
+          @xml_xpath_unspecified = x
+        end
+
+        def self.append_features(base)
+          return if base.included_modules.include? self # avoid aliasing methods more than once
+                                                        # (would lead to infinite recursion)
+          super
+          base.module_eval <<-EOS
+            alias_method :_text_orig, :text
+            alias_method :_textis_orig, :text=
+            def text
+              # we're suffering from the "fragile base class"
+              # phenomenon here -- we don't know whether the
+              # implementation of the class we get mixed into always
+              # calls text (instead of just accessing @text or so)
+              if unspecified?
+                "[UNSPECIFIED]"
+              else
+                _text_orig
+              end
+            end
+            def text=(x)
+              _textis_orig(x)
+              self.unspecified=false
+            end
+
+            alias_method :_nameis_orig, :name=
+            def name=(x)
+              _nameis_orig(x)
+              self.unspecified=false
+            end
+          EOS
+        end
+
+      end
+
+      class REXML::Element              #:nodoc:
+        include UnspecifiednessSupport
+      end
+
+      # attribute node, more or less call-compatible with REXML's
+      # Element.  REXML's Attribute class doesn't provide this...
+      #
+      # The all/first calls return instances of this class if they
+      # matched an attribute node.
+      class Attribute
+        attr_reader :parent, :name
+        attr_writer :name
+
+        def initialize(parent,name)
+          @parent,@name = parent,name
+        end
+
+        def self.new(parent,name,create)
+          if parent.attributes[name]
+            super(parent,name)
+          else
+            if create
+              parent.attributes[name] = "[unset]"
+              super(parent,name)
+            else
+              nil
+            end
+          end
+        end
+
+        # the value of the attribute.
+        def text
+          parent.attributes[@name]
+        end
+
+        def text=(x)
+          parent.attributes[@name] = x
+        end
+
+        def ==(other)
+          other.kind_of?(Attribute) and other.parent==parent and other.name==name
+        end
+
+        include UnspecifiednessSupport
+      end
+    end
+
+  end
+
+end
+
+
+
+
+
+
+class REXML::Parent
+  def each_on_axis_child
+    if respond_to? :attributes
+      attributes.each_key do |name|
+        yield XML::XXPath::Accessors::Attribute.new(self, name, false)
+      end
+    end
+    each_child do |c|
+      yield c
+    end
+  end
+
+  def each_on_axis_descendant(&block)
+    each_on_axis_child do |c|
+      block.call c
+      if REXML::Parent===c
+        c.each_on_axis_descendant(&block)
+      end
+    end
+  end
+
+  def each_on_axis_self
+    yield self
+  end
+
+  def each_on_axis(axis, &block)
+    send :"each_on_axis_#{axis}", &block
+  end
+end
+
+
+## hotfix for REXML bug #128 -- see http://trac.germane-software.com/rexml/ticket/128
+#   a working Element#write is required by several tests and
+#   documentation code snippets
+begin
+  # temporarily suppress warnings
+  class <<Kernel
+    alias_method :old_warn, :warn
+    def warn(msg)
+    end
+  end
+  begin
+    # detect bug
+    REXML::Element.new.write("",2)
+  ensure
+    # unsuppress
+    class <<Kernel
+      alias_method :warn, :old_warn
+    end
+  end
+rescue NameError
+  # bug is present -- fix it. I use Element#write in numerous tests and rdoc
+  #  inline code snippets. TODO: switch to REXML::Formatters there sometime.
+  class REXML::Element
+    def write(output=$stdout, indent=-1, transitive=false, ie_hack=false)
+      Kernel.warn("#{self.class.name}.write is deprecated.  See REXML::Formatters")
+      formatter = if indent > -1
+                    if transitive
+                      require "rexml/formatters/transitive"
+                      REXML::Formatters::Transitive.new( indent, ie_hack )
+                    else
+                      REXML::Formatters::Pretty.new( indent, ie_hack )
+                    end
+                  else
+                    REXML::Formatters::Default.new( ie_hack )
+                  end
+      formatter.write( self, output )
+    end
+  end
+end