xml-mapping 0.8.1 → 0.9.1

data/lib/xml/xxpath.rb

@@ -1,7 +1,9 @@
-# xpath.rb -- XPath implementation for Ruby, including write access
-#  Copyright (C) 2004,2005 Olaf Klischat
+# xxpath -- XPath implementation for Ruby, including write access
+#  Copyright (C) 2004-2006 Olaf Klischat
 
 require 'rexml/document'
+require 'xml/rexml_ext'
+require 'xml/xxpath/steps'
 
 module XML
 
@@ -19,91 +21,34 @@ module XML
     def initialize(xpathstr)
       @xpathstr = xpathstr  # for error messages
 
-      xpathstr=xpathstr[1..-1] if xpathstr[0]==?/
+      # TODO: write a real XPath parser sometime
 
-      # TODO: avoid code duplications
-      #    maybe: build & create the procs using eval
+      xpathstr='/'+xpathstr if xpathstr[0] != ?/
 
       @creator_procs = [ proc{|node,create_new| node} ]
       @reader_proc = proc {|nodes| nodes}
-      xpathstr.split('/').reverse.each do |part|
-        prev_creator = @creator_procs[-1]
-        prev_reader = @reader_proc
-        case part
-        when /^(.*?)\[@(.*?)='(.*?)'\]$/
-          name,attr_name,attr_value = [$1,$2,$3]
-          @creator_procs << curr_creator = proc {|node,create_new|
-            prev_creator.call(Accessors.create_subnode_by_name_and_attr(node,create_new,
-                                                                        name,attr_name,attr_value),
-                              create_new)
-          }
-          @reader_proc = proc {|nodes|
-            next_nodes = Accessors.subnodes_by_name_and_attr(nodes,
-                                                             name,attr_name,attr_value)
-            if (next_nodes == [])
-              throw :not_found, [nodes,curr_creator]
-            else
-              prev_reader.call(next_nodes)
-            end
-          }
-        when /^(.*?)\[(.*?)\]$/
-          name,index = [$1,$2.to_i]
-          @creator_procs << curr_creator = proc {|node,create_new|
-            prev_creator.call(Accessors.create_subnode_by_name_and_index(node,create_new,
-                                                                         name,index),
-                              create_new)
-          }
-          @reader_proc = proc {|nodes|
-            next_nodes = Accessors.subnodes_by_name_and_index(nodes,
-                                                              name,index)
-            if (next_nodes == [])
-              throw :not_found, [nodes,curr_creator]
-            else
-              prev_reader.call(next_nodes)
-            end
-          }
-        when /^@(.*)$/
-          name = $1
-          @creator_procs << curr_creator = proc {|node,create_new|
-            prev_creator.call(Accessors.create_subnode_by_attr_name(node,create_new,name),
-                              create_new)
-          }
-          @reader_proc = proc {|nodes|
-            next_nodes = Accessors.subnodes_by_attr_name(nodes,name)
-            if (next_nodes == [])
-              throw :not_found, [nodes,curr_creator]
-            else
-              prev_reader.call(next_nodes)
-            end
-          }
-        when '*'
-          @creator_procs << curr_creator = proc {|node,create_new|
-            prev_creator.call(Accessors.create_subnode_by_all(node,create_new),
-                              create_new)
-          }
-          @reader_proc = proc {|nodes|
-            next_nodes = Accessors.subnodes_by_all(nodes)
-            if (next_nodes == [])
-              throw :not_found, [nodes,curr_creator]
-            else
-              prev_reader.call(next_nodes)
-            end
-          }
-        else
-          name = part
-          @creator_procs << curr_creator = proc {|node,create_new|
-            prev_creator.call(Accessors.create_subnode_by_name(node,create_new,name),
-                              create_new)
-          }
-          @reader_proc = proc {|nodes|
-            next_nodes = Accessors.subnodes_by_name(nodes,name)
-            if (next_nodes == [])
-              throw :not_found, [nodes,curr_creator]
-            else
-              prev_reader.call(next_nodes)
-            end
-          }
-        end
+      
+      part=nil; part_expected=true
+      xpathstr.split(/(\/+)/)[1..-1].reverse.each do |x|
+        if part_expected
+          part=x
+          part_expected = false
+          next
+        end
+        part_expected = true
+        axis = case x
+               when '/'
+                 :child
+               when '//'
+                 :descendant
+               else
+                 raise XXPathError, "XPath (#{xpathstr}): unknown axis: #{x}"
+               end
+        axis=:self if axis==:child and (part[0]==?. or part=~/^self::/)  # yuck
+
+        step = Step.compile(axis,part)
+        @creator_procs << step.creator(@creator_procs[-1])
+        @reader_proc = step.reader(@reader_proc, @creator_procs[-1])
       end
     end
 
@@ -167,188 +112,6 @@ module XML
       first(base_node,:create_new=>true)
     end
 
-
-    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.included(mod)
-          mod.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, half-way compatible
-      # with REXML's Element.
-      # REXML doesn't provide one...
-      #
-      # 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
-
-      # read accessors
-
-      for things in %w{name name_and_attr name_and_index attr_name all} do
-        self.module_eval <<-EOS
-          def self.subnodes_by_#{things}(nodes, *args)
-            nodes.map{|node| subnodes_by_#{things}_singlesrc(node,*args)}.flatten
-          end
-        EOS
-      end
-
-      def self.subnodes_by_name_singlesrc(node,name)
-        node.elements.select{|elt| elt.name==name}
-      end
-
-      def self.subnodes_by_name_and_attr_singlesrc(node,name,attr_name,attr_value)
-        node.elements.select{|elt| elt.name==name and elt.attributes[attr_name]==attr_value}
-      end
-
-      def self.subnodes_by_name_and_index_singlesrc(node,name,index)
-        index-=1
-        byname=subnodes_by_name_singlesrc(node,name)
-        if index>=byname.size
-          []
-        else
-          [byname[index]]
-        end
-      end
-
-      def self.subnodes_by_attr_name_singlesrc(node,name)
-        attr=Attribute.new(node,name,false)
-        if attr then [attr] else [] end
-      end
-
-      def self.subnodes_by_all_singlesrc(node)
-        node.elements.to_a
-      end
-
-
-      # write accessors
-
-      #  precondition: unless create_new, we know that a node with
-      #    exactly the requested attributes doesn't exist yet (else we
-      #    wouldn't have been called)
-      def self.create_subnode_by_name(node,create_new,name)
-        node.elements.add name
-      end
-
-      def self.create_subnode_by_name_and_attr(node,create_new,name,attr_name,attr_value)
-        if create_new
-          newnode = node.elements.add(name)
-        else
-          newnode = subnodes_by_name_singlesrc(node,name)[0]
-          if not(newnode) or newnode.attributes[attr_name]
-            newnode = node.elements.add(name)
-          end
-        end
-        newnode.attributes[attr_name]=attr_value
-        newnode
-      end
-
-      def self.create_subnode_by_name_and_index(node,create_new,name,index)
-        name_matches = subnodes_by_name_singlesrc(node,name)
-        if create_new and (name_matches.size >= index)
-          raise XXPathError, "XPath (#{@xpathstr}): #{name}[#{index}]: create_new and element already exists"
-        end
-        newnode = name_matches[0]
-        (index-name_matches.size).times do
-          newnode = node.elements.add name
-        end
-        newnode
-      end
-
-      def self.create_subnode_by_attr_name(node,create_new,name)
-        if create_new and node.attributes[name]
-          raise XXPathError, "XPath (#{@xpathstr}): @#{name}: create_new and attribute already exists"
-        end
-        Attribute.new(node,name,true)
-      end
-
-      def self.create_subnode_by_all(node,create_new)
-        node = node.elements.add
-        node.unspecified = true
-        node
-      end
-    end
   end
 
 end

data/lib/xml/xxpath/steps.rb

@@ -0,0 +1,345 @@
+# xxpath -- XPath implementation for Ruby, including write access
+#  Copyright (C) 2004-2006 Olaf Klischat
+
+module XML
+  class XXPath
+
+    # base class for XPath "steps". Steps contain an "axis" (e.g.
+    # "/", "//", i.e. the "child" resp. "descendants" axis), and
+    # a "node matcher" like "foo" or "@bar" or "foo[@bar='baz']", i.e. they
+    # match some XML nodes and don't match others (e.g. "foo[@bar='baz']"
+    # macthes all XML element nodes named "foo" that contain an attribute
+    # with name "bar" and value "baz").
+    #
+    # Steps can find out whether they match a given XML node
+    # (Step#matches?(node)), and they know how to create a matchingnode
+    # on a given base node (Step#create_on(node,create_new)).
+    class Step #:nodoc:
+      def self.inherited(subclass)
+        (@subclasses||=[]) << subclass
+      end
+
+      # create and return an instance of the right Step subclass for
+      # axis _axis_ (:child or :descendant atm.) and node matcher _string_
+      def self.compile axis, string
+        (@subclasses||=[]).each do |sc|
+          obj = sc.compile axis, string
+          return obj if obj
+        end
+        raise XXPathError, "can't compile XPath step: #{string}"
+      end
+
+      def initialize axis
+        @axis = axis
+      end
+
+      # return a proc that takes a list of nodes, finds all sub-nodes
+      # that are reachable from one of those nodes via _self_'s axis
+      # and match (see below) _self_, and calls _prev_reader_ on them
+      # (and returns the result).  When the proc doesn't find any such
+      # nodes, it throws <tt>:not_found,
+      # [nodes,creator_from_here]</tt>.
+      #
+      # Needed for compiling whole XPath expressions for reading.
+      #
+      # <tt>Step</tt> itself provides a generic default implementation
+      # which checks whether _self_ matches a given node by calling
+      # self.matches?(node). Subclasses must either implement such a
+      # _matches?_ method or override _reader_ to provide more
+      # specialized implementations for better performance.
+      def reader(prev_reader,creator_from_here)
+        proc {|nodes|
+          next_nodes = []
+          nodes.each do |node|
+            if node.respond_to? :each_on_axis
+              node.each_on_axis(@axis) do |subnode|
+                next_nodes << subnode if self.matches?(subnode)
+              end
+            end
+          end
+          if (next_nodes.empty?)
+            throw :not_found, [nodes,creator_from_here]
+          else
+            prev_reader.call(next_nodes)
+          end
+        }
+      end
+
+      # return a proc that takes a node, creates a sub-node matching
+      # _self_ on it, and then calls _prev_creator_ on that and
+      # returns the result.
+      #
+      # Needed for compiling whole XPath expressions for writing.
+      #
+      # <tt>Step</tt> itself provides a generic default
+      # implementation, subclasses may provide specialized
+      # implementations for better performance.
+      def creator(prev_creator)
+	if @axis==:child or @axis==:self
+	  proc {|node,create_new|
+	    prev_creator.call(self.create_on(node,create_new),
+			      create_new)
+	  }
+	else
+	  proc {|node,create_new|
+	    raise XXPathError, "can't create axis: #{@axis}"
+	  }
+	end
+      end
+    end
+
+
+    class AttrStep < Step #:nodoc:
+      def self.compile axis, string
+        /^(?:\.|self::\*)\[@(.*?)='(.*?)'\]$/ === string or return nil
+        self.new axis,$1,$2
+      end
+
+      def initialize(axis,attr_name,attr_value)
+        super(axis)
+        @attr_name,@attr_value = attr_name,attr_value
+      end
+
+      def matches? node
+        node.is_a?(REXML::Element) and node.attributes[@attr_name]==@attr_value
+      end
+
+      def create_on(node,create_new)
+        if create_new
+          raise XXPathError, "XPath: .[@'#{@attr_name}'='#{@attr_value}']: create_new but context node already exists"
+        end
+        # TODO: raise if node.attributes[@attr_name] already exists?
+        node.attributes[@attr_name]=@attr_value
+        node
+      end
+    end
+
+
+    class NameAndAttrStep < Step #:nodoc:
+      def self.compile axis, string
+        /^(.*?)\[@(.*?)='(.*?)'\]$/ === string or return nil
+        self.new axis,$1,$2,$3
+      end
+
+      def initialize(axis,name,attr_name,attr_value)
+        super(axis)
+        @name,@attr_name,@attr_value = name,attr_name,attr_value
+      end
+
+      def matches? node
+        node.is_a?(REXML::Element) and node.name==@name and node.attributes[@attr_name]==@attr_value
+      end
+
+      def create_on(node,create_new)
+        if create_new
+          newnode = node.elements.add(@name)
+        else
+          newnode = node.elements.select{|elt| elt.name==@name and not(elt.attributes[@attr_name])}[0]
+          if not(newnode)
+            newnode = node.elements.add(@name)
+          end
+        end
+        newnode.attributes[@attr_name]=@attr_value
+        newnode
+      end
+    end
+
+
+    class NameAndIndexStep < Step #:nodoc:
+      def self.compile axis, string
+        /^(.*?)\[(\d+)\]$/ === string or return nil
+        self.new axis,$1,$2.to_i
+      end
+
+      def initialize(axis,name,index)
+        super(axis)
+        @name,@index = name,index
+      end
+
+      def matches? node
+        raise XXPathError, "can't use #{@name}[#{@index}] on root node" if node.parent.nil?
+        node == node.parent.elements.select{|elt| elt.name==@name}[@index-1]
+      end
+
+      def create_on(node,create_new)
+        name_matches = node.elements.select{|elt| elt.name==@name}
+        if create_new and (name_matches.size >= @index)
+          raise XXPathError, "XPath: #{@name}[#{@index}]: create_new and element already exists"
+        end
+        newnode = name_matches[0]
+        (@index-name_matches.size).times do
+          newnode = node.elements.add @name
+        end
+        newnode
+      end
+
+      def reader(prev_reader,creator_from_here)
+        if @axis==:child
+          index = @index - 1
+          proc {|nodes|
+            next_nodes = []
+            nodes.each do |node|
+              byname=node.elements.select{|elt| elt.name==@name}
+              next_nodes << byname[index] if index<byname.size
+            end
+            if (next_nodes.empty?)
+              throw :not_found, [nodes,creator_from_here]
+            else
+              prev_reader.call(next_nodes)
+            end
+          }
+        else
+          super(prev_reader,creator_from_here)
+        end
+      end
+    end
+
+
+    class AttrNameStep < Step #:nodoc:
+      def self.compile axis, string
+        /^@(.*)$/ === string or return nil
+        self.new axis,$1
+      end
+
+      def initialize(axis,attr_name)
+        super(axis)
+        @attr_name = attr_name
+      end
+
+      def matches? node
+        node.class==XML::XXPath::Accessors::Attribute and node.name==@attr_name
+      end
+
+      def create_on(node,create_new)
+        if create_new and node.attributes[@attr_name]
+          raise XXPathError, "XPath (@#{@attr_name}): create_new and attribute already exists"
+        end
+        XML::XXPath::Accessors::Attribute.new(node,@attr_name,true)
+      end
+
+      def reader(prev_reader,creator_from_here)
+        if @axis==:child
+          proc {|nodes|
+            next_nodes = []
+            nodes.each do |node|
+              attr=XML::XXPath::Accessors::Attribute.new(node,@attr_name,false)
+              next_nodes << attr if attr
+            end
+            if (next_nodes.empty?)
+              throw :not_found, [nodes,creator_from_here]
+            else
+              prev_reader.call(next_nodes)
+            end
+          }
+        else
+          super(prev_reader,creator_from_here)
+        end
+      end
+    end
+
+
+    class AllElementsStep < Step #:nodoc:
+      def self.compile axis, string
+        '*'==string or return nil
+        self.new axis
+      end
+
+      def matches? node
+        node.is_a? REXML::Element
+      end
+
+      def create_on(node,create_new)
+        newnode = node.elements.add
+        newnode.unspecified = true
+        newnode
+      end
+    end
+
+
+    class ThisNodeStep < Step #:nodoc:
+      def self.compile axis, string
+        '.'==string or return nil
+        self.new axis
+      end
+
+      def matches? node
+        true
+      end
+
+      def create_on(node,create_new)
+        if create_new
+          raise XXPathError, "XPath: .: create_new and attribute already exists"
+        end
+        node
+      end
+    end
+
+
+    class AlternativeNamesStep < Step #:nodoc:
+      def self.compile axis, string
+        if string=~/\|/
+          self.new axis, string.split('|')
+        else
+          nil
+        end
+      end
+
+      def initialize(axis,names)
+        super(axis)
+        @names = names
+      end
+
+      def matches? node
+        node.is_a?(REXML::Element) and @names.inject(false){|prev,name| prev or node.name==name}
+      end
+
+      def create_on(node,create_new)
+        newnode = node.elements.add
+        newnode.unspecified = true
+        newnode
+      end
+    end
+
+
+    class TextNodesStep < Step #:nodoc:
+      def self.compile axis, string
+        'text()' == string or return nil
+        self.new axis
+      end
+
+      def matches? node
+        node.is_a? REXML::Text
+      end
+
+      def create_on(node,create_new)
+        node.add(REXML::Text.new(""))
+      end
+    end
+
+    class REXML::Text
+      # call-compatibility w/ REXML::Element
+      alias_method :text, :value
+      alias_method :text=, :value=
+    end
+
+
+    class NameStep < Step #:nodoc:
+      def self.compile axis, string
+        self.new axis,string
+      end
+
+      def initialize(axis,name)
+        super(axis)
+        @name = name
+      end
+
+      def matches? node
+        node.is_a?(REXML::Element) and node.name==@name
+      end
+
+      def create_on(node,create_new)
+        node.elements.add @name
+      end
+    end
+  end
+end