rexle 0.9.5 → 0.9.6

data/lib/rexle.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby
+#!/usr/bin/ruby
 
 # file: rexle.rb
 
@@ -6,48 +6,21 @@ require 'rexml/document'
 require 'rexleparser'
 require 'dynarex-parser'
 require 'polyrex-parser'
-require 'cgi'
 include REXML
 
-# modifications:
-# 20-Oct-2012: feature: added Rexle::Element#texts which is the equivalent
-#                 of REXML::Element#texts
-# 10-Sep-2012: bug fix: Removed code from method pretty_print in order to
-#                 get the XML displayed properly
-# 23-Aug-2012: feature: implemented xpath function contains()
-# 17-Aug-2012: bug fix: pretty print now ignores text containing empty space
-# 16-Aug-2012: the current element's text (if its not empty) is now returned 
-#                from its children method
-# 15-Aug-2012: feature: xpath containing child:: now supported
-# 13-Aug-2012: bug fix: xpath can now handle the name() function
-# 11-Aug-2012: bug fix: separated the max() method from 1 line into 3 
-#                and that fixed it
-# 08-Aug-2012: feature: added Element#insert_before and Element#insert_after
-# 19-Jul-2012: Changed children to elements where appropriate
-# 15-Jul-2012: bug fix: self.root.value is no longer appended
-#                 to the body if there are no child elements
-# 19-Jun-2012: a bug fix for .//*[@class]
-# 17-Jun-2012: a couple of new xpath things are supported '.' and '|'
-# 15-Apr-2012: bug fix: New element names are typecast as string
-# 16-Mar-2012: bug fix: Element names which contain a colon can now be selected
-#                in the xpath.
-# 22-Feb-2012: bug resolution: Deactivated the PolyrexParser; using RexleParser instead
-# 14-Jan-2012: Implemented Rexle::Elements#each
-# 21-Dec-2011: Bug fix: xpath modified to allow querying from the actual 
-# root rather than the 1st child element from the root
 
 module XMLhelper
 
   def doc_print(children)
-    
-    body = (children.nil? or children.empty? or children.is_an_empty_string? ) ? '' : scan_print(children).join
+
+    body = children.empty? ? self.root.value : scan_print(children).join
     a = self.root.attributes.to_a.map{|k,v| "%s='%s'" % [k,v]}
     "<%s%s>%s</%s>" % [self.root.name, a.empty? ? '' : ' ' + a.join(' '), body, self.root.name]
   end
 
   def doc_pretty_print(children)
 
-    body = pretty_print(children,2).join
+    body = children.empty? ? self.value : pretty_print(children,2).join
     a = self.root.attributes.to_a.map{|k,v| "%s='%s'" % [k,v]}
     ind = "\n  "   
     "<%s%s>%s%s%s</%s>" % [self.root.name, a.empty? ? '' : ' ' + a.join(' '), ind, body, "\n", self.root.name]
@@ -56,24 +29,18 @@ module XMLhelper
   def scan_print(nodes)
 
     nodes.map do |x|
-
+      #puts 'x: ' + x.class.to_s #+ ' name: ' + x.name.to_s 
       if x.is_a? Rexle::Element then
-        if x.name.chr != '!' then
+        unless x.name == '![' then
           a = x.attributes.to_a.map{|k,v| "%s='%s'" % [k,v]}      
           tag = x.name + (a.empty? ? '' : ' ' + a.join(' '))
 
-          if x.value.length > 0 or (x.children.length > 0 and not x.children.is_an_empty_string?) then
-            out = ["<%s>" % tag]
-            #out << x.value unless x.value.nil? || x.value.empty?
-            out << scan_print(x.children)
-            out << "</%s>" % x.name
-          else
-            out = ["<%s/>" % tag]
-          end
-        elsif x.name == '!-' then
-          "<!--%s-->" % x.value
-        else
-          "<![CDATA[%s]]>" % x.value      
+          out = ["<%s>" % tag]
+          out << x.value unless x.value.nil? || x.value.empty?
+          out << scan_print(x.children)
+          out << "</%s>" % x.name
+        else    
+          "<![CDATA[%s]]>" % x.value
         end      
       elsif x.is_a? String then
         x
@@ -84,24 +51,19 @@ module XMLhelper
 
   def pretty_print(nodes, indent='0')
     indent = indent.to_i
-
-    nodes.select(){|x| x.is_a? Rexle::Element or x.strip.length > 0}
-        .map.with_index do |x, i|
-
+    nodes.map.with_index do |x, i|
       if x.is_a? Rexle::Element then
         unless x.name == '![' then
-          #return ["<%s/>" % x.name] if x.value = ''
           a = x.attributes.to_a.map{|k,v| "%s='%s'" % [k,v]}      
-          a ||= [] 
           tag = x.name + (a.empty? ? '' : ' ' + a.join(' '))
 
-          start = i > 0 ? ("\n" + '  ' * (indent - 1)) : ''          
-          ind1 = x.children.grep(Rexle::Element).length > 0 ? 
-            ("\n" + '  ' * indent) : ''
+          ind1 = x.children.length > 0 ? ("\n" + '  ' * indent) : ''
+          start = i > 0 ? ("\n" + '  ' * (indent - 1)) : ''
           out = ["%s<%s>%s" % [start, tag, ind1]]
 
+          out << x.value.sub(/^[\n\s]+$/,'') unless x.value.nil? || x.value.empty?
           out << pretty_print(x.children, (indent + 1).to_s.clone)
-          ind2 = ind1.length > 0 ? ("\n" + '  ' * (indent - 1)) : ''
+          ind2 = x.children.length > 0 ? ("\n" + '  ' * (indent - 1)) : ''
           out << "%s</%s>" % [ind2, x.name]
         else    
           "<![CDATA[%s]]>" % x.value
@@ -119,10 +81,6 @@ class Rexle
   include XMLhelper
 
   attr_reader :prefixes
-
-  def self.version()
-    '0.9.xx'
-  end
   
   def initialize(x=nil)
     super()
@@ -134,144 +92,85 @@ class Rexle
         Array: proc {|x| x},
         :"REXML::Document" =>  proc {|x| scan_doc x.root}
       }
-      
-      doc_node = ['doc','',{}]
-  
 
       @a = procs[x.class.to_s.to_sym].call(x)
-      @doc = scan_element(*(doc_node << @a))
+      @doc = scan_element(*@a)      
       
       # fetch the namespaces
       @prefixes = []
       if @doc.root.attributes then
-
+        #puts 'attrs : '  + @doc.root.attributes.inspect
         xmlns = @doc.root.attributes.select {|k,v| k[/^xmlns:/]}
         @prefixes = xmlns.keys.map{|x| x[/\w+$/]}
       end
+    end
+    
+  end
+
+  def xpath(path, &blk)
+
+    # is it a function
+    fn_match = path.match(/^(\w+)\(([^\)]+)\)$/)
 
+    #    Array: proc {|x| x.flatten.compact}, 
+    if (fn_match and fn_match.captures.first[/^(attribute|@)/]) or fn_match.nil? then 
+      procs = {
+        Array: proc {|x| block_given? ? x : x.flatten }, 
+        String: proc {|x| x},
+        :"Rexle::Element" => proc {|x| [x]}
+      }
+      bucket = []
+      result = @doc.xpath(path, bucket, &blk)
+
+      procs[result.class.to_s.to_sym].call(result)
+      
+    else
+      #puts 'fn ' + fn_match.captures.inspect
+      m, xpath_value = fn_match.captures
+      method(m.to_sym).call(xpath_value)
     end
 
+
   end
-  
-  def xpath(path,  &blk)
-    @doc.xpath(path,  &blk)
-  end  
 
   class Element
     include XMLhelper
     
     attr_accessor :name, :value, :parent
-    attr_reader :child_lookup, :child_elements
-    
-    alias original_clone clone
+    attr_reader :child_lookup
 
     def initialize(name=nil, value='', attributes={}, rexle=nil)
       @rexle = rexle      
       super()
-      @name, @value, @attributes = name.to_s, value, attributes
+      @name, @value, @attributes = name, value, attributes
       raise "Element name must not be blank" unless name
       @child_elements = []
       @child_lookup = []
     end
 
-    def contains(raw_args)
-      path, raw_val = raw_args.split(',',2)
-      val = raw_val.strip[/^["']?.*["']?$/]      
-      
-      anode = query_xpath(path)
-      return unless anode
-      a = scan_contents(anode.first)
-     
-      [a.grep(/#{val}/).length > 0]
-    end    
-    
-    def count(path)
-      length = query_xpath(path).flatten.compact.length
-      length
-    end
-    
-    def max(path) 
-      a = query_xpath(path).flatten.compact.map(&:to_i)
-      a.max 
-    end
-      
     def name()
+      #puts 'zzz : ' + @rexle.prefixes.inspect
+      #puts '@rexle : ' + @rexle.inspect
       if @rexle then
-        prefix = @rexle.prefixes.find {|x| x == @name[/^(\w+):/,1] } if @rexle.prefixes.is_a? Array
-        prefix ? @name.sub(prefix + ':', '') : @name
+  prefix = @rexle.prefixes.find {|x| x == @name[/^(\w+):/,1] } if @rexle.prefixes.is_a? Array
+  #puts 'ppp: ' + prefix.inspect
+  prefix ? @name.sub(prefix + ':', '') : @name
       else
-        @name
+  @name
       end
     end
     
-    def xpath(path, rlist=[], &blk)
-      r = filter_xpath(path, rlist=[], &blk)
-      r.is_a?(Array) ? r.compact : r      
-    end
-    
-    def filter_xpath(path, rlist=[], &blk)
-
-      # is it a function
-      fn_match = path.match(/^(\w+)\(["']?([^\)]*)["']?\)$/)
-
-      #    Array: proc {|x| x.flatten.compact}, 
-      if (fn_match and fn_match.captures.first[/^(attribute|@)/]) or fn_match.nil? then 
-        procs = {
-          Array: proc {|x| block_given? ? x : x.flatten.uniq }, 
-          String: proc {|x| x},
-          Hash: proc {|x| x},
-          TrueClass: proc{|x| x},
-          FalseClass: proc{|x| x},
-          :"Rexle::Element" => proc {|x| [x]}
-        }
-        bucket = []
-        raw_results = path.split('|').map do |xp|
-          query_xpath(xp, bucket, &blk)
-        end
-
-        #results = raw_results.inject(&:+)
-        results = raw_results.last
-        procs[results.class.to_s.to_sym].call(results) if results
-        
-      else
-        m, xpath_value = fn_match.captures        
-        xpath_value.empty? ? method(m.to_sym).call : method(m.to_sym).call(xpath_value) 
-      end
-
-    end    
-    
-    def query_xpath(raw_xpath_value, rlist=[], &blk)
+    def xpath(xpath_value, rlist=[], &blk)
 
-      #remove any pre'fixes
+      #remove any prefixes
      #@rexle.prefixes.each {|x| xpath_value.sub!(x + ':','') }
-      flag_func = false            
-
-      xpath_value = raw_xpath_value.sub('child::','./')
-      #xpath_value.sub!(/\.\/(?=[\/])/,'')
-
-      if xpath_value[/^[\w\/]+\s*=.*/] then        
-        flag_func = true
-
-        xpath_value.sub!(/^\w+\s*=.*/,'.[\0]')
-        xpath_value.sub!(/\/([\w]+\s*=.*)/,'[\1]')
-
-        #result = self.element xpath_value        
-        #return [(result.is_a?(Rexle::Element) ? true : false)]
-      end
-
+      
+      xpath_value.sub!(/^\[/,'*[')
       #xpath_value.sub!(/^attribute::/,'*/attribute::')
-      raw_path, raw_condition = xpath_value.sub(/^\.?\/(?!\/)/,'')\
-          .match(/([^\[]+)(\[[^\]]+\])?/).captures 
+      raw_path, raw_condition = xpath_value.sub(/^\/(?!\/)/,'').match(/([^\[]+)(\[[^\]]+\])?/).captures 
 
       remaining_path = ($').to_s
-      
-      r = raw_path[/([^\/]+)(?=\/\/)/,1] 
-      if r then
-        a_path = raw_path.split(/(?=\/\/)/,2)
-      else
-        a_path = raw_path.split('/',2)
-      end
-      
+      a_path = raw_path.split('/')     
       condition = raw_condition if a_path.length <= 1
 
       if raw_path[0,2] == '//' then
@@ -282,23 +181,20 @@ class Rexle
       else
 
         attribute = xpath_value[/^(attribute::|@)(.*)/,2] 
-
-        return @attributes  if attribute == '*'
-        return [@attributes[attribute.to_sym]] if attribute and @attributes and @attributes.has_key?(attribute.to_sym)
+        return [@attributes[attribute]] if attribute and @attributes and @attributes.has_key?(attribute)
+ 
         s = a_path.shift
       end      
 
       # isolate the xpath to return just the path to the current element
-
-      elmnt_path = s[/^([\w:\*]+\[[^\]]+\])|[\/]+{,2}[^\/]+/]
+      elmnt_path = s[/^([\w\*]+\[[^\]]+\])|[\/]+{,2}[^\/]+/]
       element_part = elmnt_path[/(^@?[^\[]+)?/,1] if elmnt_path
-      
+
       if element_part then
         unless element_part[/^@/] then
-          element_name = element_part[/^[\w:\*\.]+/]
+          element_name = element_part
         else
-
-          condition = xpath_value[/^\[/] ? xpath_value : element_part
+          condition = element_part
           element_name = nil
         end
 
@@ -306,32 +202,15 @@ class Rexle
 
       #element_name ||= '*'
       raw_condition = '' if condition
-      attr_search = format_condition(condition) if condition and condition.length > 0      
-      
-      attr_search2 = xpath_value[/^\[(.*)\]$/,1]
-      if attr_search2 then        
-        r4 = attribute_search(attr_search, self, self.attributes)
-        return r4
-      end      
-      
-      return_elements = []
-
-      if raw_path[0,2] == '//' then
 
-        regex = /\[(\d+)\]/
-        n = xpath_value[regex,1]
-        xpath_value.slice!(regex)
-        
-        rs = scan_match(self, xpath_value).flatten.compact
-        return n ? rs[n.to_i-1] : rs
+      attr_search = format_condition(condition) if condition and condition.length > 0
 
-      elsif (raw_path == '.' or raw_path == self.name) and attr_search.nil? then
-        return  [self]
+      if raw_path[0,2] == '//'
+        return scan_match(self, xpath_value)
       else
 
-        return_elements = @child_lookup.map.with_index.select do |x|    
-          (x[0][0] == element_name || element_name == '.') or \
-            (element_name == '*' && x[0].is_a?(Array))
+        return_elements = @child_lookup.map.with_index.select do |x|
+          x[0][0] == element_name or element_name == '*'
         end
 
       end
@@ -339,6 +218,7 @@ class Rexle
       if return_elements.length > 0 then
 
         if (a_path + [remaining_path]).join.empty? then
+
           rlist = return_elements.map.with_index {|x,i| filter(x, i+1, attr_search, &blk)}.compact
           rlist = rlist[0] if rlist.length == 1
         else
@@ -348,9 +228,7 @@ class Rexle
             rtn_element = filter(x, i+1, attr_search){|e| r = e.xpath(a_path.join('/') + raw_condition.to_s + remaining_path, &blk); (r || e) }
             next if rtn_element.nil? or (rtn_element.is_a? Array and rtn_element.empty?)
 
-            if rtn_element.is_a? Hash then
-              rtn_element
-            elsif rtn_element.is_a? Array then
+            if rtn_element.is_a? Array then
               rtn_element
             elsif (rtn_element.is_a? String) || (rtn_element.is_a?(Array) and not(rtn_element[0].is_a? String))
               rtn_element
@@ -359,26 +237,23 @@ class Rexle
             end
           end
           #
-
           rlist = rlist.flatten(1) unless rlist.length > 1 and rlist[0].is_a? Array
 
         end
-
         rlist.compact! if rlist.is_a? Array
 
       else
 
         # strip off the 1st element from the XPath
-        new_xpath = xpath_value[/^\/\/[\w:]+\/(.*)/,1]
-
+        new_xpath = xpath_value[/^\/\/\w+\/(.*)/,1]
+                
         if new_xpath then
           self.xpath(new_xpath + raw_condition.to_s + remaining_path, rlist,&blk)
         end
       end
-
+      
       rlist = rlist.flatten(1) unless not(rlist.is_a? Array) or (rlist.length > 1 and rlist[0].is_a? Array)
       rlist = [rlist] if rlist.is_a? Rexle::Element
-      rlist = (rlist.length > 0 ? true : false) if flag_func == true
       rlist
     end
 
@@ -398,11 +273,7 @@ class Rexle
     end    
 
     def inspect()
-      if self.xml.length > 30 then
       "%s ... </>" % self.xml[/<[^>]+>/]
-      else
-        self.xml
-      end  
     end
     
     alias add add_element
@@ -422,28 +293,11 @@ class Rexle
 
     def add_text(s) @value = s; self end
     
-    def attribute(key) 
-      key = key.to_sym if key.is_a? String
-      @attributes[key].gsub('&lt;','<').gsub('&gt;','>')
-    end  
-    
+    def attribute(key) @attributes[key] end  
     def attributes() @attributes end    
-      
-    def children()
-      return unless @value
-      r = (@value.empty? ? [] : [@value])  + @child_elements
-      def r.is_an_empty_string?()
-        self.length == 1 and self.first == ''
-      end      
-      
-      return r
-    end 
-    
-    def children=(a)   @child_elements = a   end
-    
-    def deep_clone() Rexle.new(self.xml).root end
-    def clone() Element.new(@name, @value, @attributes) end
-          
+    def children() @child_elements end    
+    def children=(a) @child_elements = a end
+
     def delete(obj=nil)
       if obj then
         i = @child_elements.index(obj)
@@ -453,14 +307,11 @@ class Rexle
       end
     end
 
-    def element(s) 
-      r = self.xpath(s)
-      r.is_a?(Array) ? r.first : r
-    end
+    def element(s) self.xpath(s).first  end
 
     def elements(s=nil)
       procs = {
-        NilClass: proc {Elements.new(@child_elements.select{|x| x.is_a? Rexle::Element })},
+        NilClass: proc {Elements.new(@child_elements)},
         String: proc {|x| @child_elements[x]}
       }
 
@@ -468,14 +319,7 @@ class Rexle
     end
 
     def doc_root() @rexle.root end
-    def each(&blk) 
-      @child_elements.each(&blk) #unless @child_elements.empty?
-    end
-    def has_elements?() !self.elements.empty? end
-    
-    def insert_after(node)   insert(node, 1)   end          
-    def insert_before(node)  insert(node)      end
-        
+    def each(&blk) @child_elements.each(&blk) end
     def root() self end #@rexle.root end
 
     def text(s='')
@@ -486,7 +330,6 @@ class Rexle
         e = self.element(s)
         result = e.value if e
       end
-      result = CGI.unescape_html result.to_s
  
       def result.unescape()
         s = self.clone
@@ -496,14 +339,10 @@ class Rexle
 
       result
     end
-    
-    def texts()
-      [@value] + @child_elements.select {|x| x.is_a? String}
-    end
 
     def value=(raw_s)
 
-      @value = String.new(raw_s.to_s.clone)
+      @value = raw_s.to_s.clone
       escape_chars = %w(& &amp; < &lt; > &gt;).each_slice(2).to_a
       escape_chars.each{|x| @value.gsub!(*x)}
 
@@ -523,27 +362,17 @@ class Rexle
       method(msg).call(self.children)
     end
 
-    alias to_s xml
 
     private
-    
-    def insert(node,offset=0)
-      i = parent.child_elements.index(self)
-      return unless i
-      parent.child_elements.insert(i+offset,node)
-      parent.child_lookup.insert(i+offset, [node.name, node.attributes, node.value])          
-      self
-    end      
 
     def format_condition(condition)
-
-      raw_items = condition[1..-1].scan(/\'[^\']*\'|\"[^\"]*\"|and|or|\d+|[!=<>]+|position\(\)|[@\w\.\/&;]+/)
+      #raw_items = condition[1..-1].scan(/\'[^\']*\'|and|or|\d+|[!=]+|[@\w\.\/]+/)
+      raw_items = condition[1..-1].scan(/\'[^\']*\'|and|or|\d+|[!=<>]+|position\(\)|[@\w\.\/]+/)
 
       if raw_items[0][/^\d+$/] then
         return raw_items[0].to_i
       elsif raw_items[0] == 'position()' then
-        rrr = "i %s %s" % [raw_items[1].gsub('&lt;','<').gsub('&gt;','>'), raw_items[-1]]
-        return rrr
+        return "i %s %s" % raw_items[1..-1]
       else
 
         andor_items = raw_items.map.with_index.select{|x,i| x[/\band\b|\bor\b/]}.map{|x| [x.last, x.last + 1]}.flatten
@@ -558,10 +387,9 @@ class Rexle
 
             if x.length >= 3 then
               x[1] = '==' if x[1] == '='
-              "h[:'%s'] %s %s" % x
+              "h['%s'] %s %s" % x
             else
-
-              x.join[/^(and|or)$/] ? x : ("h[:'%s']" % x)
+              x
             end
           end
 
@@ -572,7 +400,6 @@ class Rexle
           items = cons_items.map do |x| 
 
             if x.length >= 3 then
-
               x[1] = '==' if x[1] == '='
               if x[0] != '.' then
                 if x[0][/\//] then
@@ -580,7 +407,7 @@ class Rexle
 
                   "e.xpath('#{path}').first.value == #{value}"
                 else
-                  "(name == '%s' and value %s '%s')" % [x[0], x[1], x[2].sub(/^['"](.*)['"]$/,'\1')]
+                  "(name == '%s' and value %s %s)" % [x[0], x[1], x[2]]
                 end
               else
                 "e.value %s %s" % [x[1], x[2]]
@@ -589,7 +416,7 @@ class Rexle
               x
             end
           end
-          
+
           return items.join(' ')
         end
       end
@@ -598,46 +425,35 @@ class Rexle
     end
 
     
-    def scan_match(node, path)
-
-      r = []
-      xpath2 = path[2..-1] 
-      xpath2.sub!(/^\*\//,'')
-      xpath2.sub!(/^\*/,self.name)
-      xpath2.sub!(/^\w+/,'').sub!(/^\//,'') if xpath2[/^\w+/] == self.name
-      
+    def scan_match(node, xpath)
 
-      r << node.xpath(xpath2)
-      r << node.elements.map {|n| scan_match(n, path) if n.is_a? Rexle::Element}
+      r = node.xpath(xpath[2..-1])
+      r << node.children.map {|n| scan_match(n, xpath)}
+      #puts 'r: ' + r.inspect
       r
     end
-
-    # used by xpath function contains()
-    #
-    def scan_contents(node)
-
-      a = []
-      a << node.text
-
-      node.elements.each do |child|
-        a.concat scan_contents(child)
-      end
-      a
-    end
-    
     
     def filter(raw_element, i, attr_search, &blk)
 
       x = raw_element
       e = @child_elements[x.last]
 
-      return unless e.is_a? Rexle::Element
-      name, value = e.name, e.value if e.is_a? Rexle::Element
+      h = x[0][1]  # <-- fetch the attributes
 
-      h = x[0][1]  # <-- fetch the attributes      
-      
       if attr_search then
-        attribute_search(attr_search,e, h, i, &blk)
+        if attr_search.is_a? Fixnum then
+          block_given? ? blk.call(e) : e if i == attr_search 
+        elsif attr_search[/i\s[<>\=]\s\d+/] and eval(attr_search) then
+          block_given? ? blk.call(e) : e
+        elsif h and attr_search[/^h\[/] and eval(attr_search)
+          block_given? ? blk.call(e) : e
+        elsif attr_search[/^\(name ==/] and  e.child_lookup.select{|name, attributes, value| eval(attr_search) }.length > 0
+          block_given? ? blk.call(e) : e
+        elsif attr_search[/^e\.value/] and eval(attr_search)           
+          block_given? ? blk.call(e) : e
+        elsif attr_search[/^e\.xpath/] and eval(attr_search)           
+          block_given? ? blk.call(e) : e
+        end
       else
 
         block_given? ? blk.call(e) : e
@@ -645,28 +461,9 @@ class Rexle
 
     end
 
-    def attribute_search(attr_search, e, h, i=nil, &blk)
-      if attr_search.is_a? Fixnum then
-        block_given? ? blk.call(e) : e if i == attr_search 
-      elsif attr_search[/i\s[<>\=]\s\d+/] and eval(attr_search) then
-        block_given? ? blk.call(e) : e
-      elsif h and attr_search[/^h\[/] and eval(attr_search)
-        block_given? ? blk.call(e) : e
-      elsif attr_search[/^\(name ==/] and e.child_lookup.select{|name, attributes, value| eval(attr_search) }.length > 0
-        block_given? ? blk.call(e) : e
-      elsif attr_search[/^\(name ==/] and eval(attr_search) 
-        block_given? ? blk.call(e) : e          
-      elsif attr_search[/^e\.value/] and eval(attr_search)           
-        block_given? ? blk.call(e) : e
-      elsif attr_search[/^e\.xpath/] and eval(attr_search)           
-        block_given? ? blk.call(e) : e
-      end      
-    end
   end # -- end of element --
 
   class Elements
-    include Enumerable
-    
     def initialize(elements=[])
       super()
       @elements = elements
@@ -675,10 +472,6 @@ class Rexle
     def [](i)
       @elements[i-1]
     end
-    
-    def each(&blk) @elements.each(&blk)  end
-    def to_a()     @elements             end
-      
   end # -- end of elements --
 
 
@@ -696,9 +489,8 @@ class Rexle
     else    
       a = yield
     end
-    doc_node = ['doc','',{}]
-    @a = procs[x.class.to_s.to_sym].call(x)
-    @doc = scan_element(*(doc_node << @a))
+
+    @doc = scan_element(*a)
     self
   end
 
@@ -710,18 +502,14 @@ class Rexle
 
   alias add add_element
 
-  def delete(xpath)
-    e = @doc.element(xpath)
-    e.delete if e
-  end
-  
+  def delete(xpath) @doc.element(xpath).delete end
   def element(xpath) self.xpath(xpath).first end  
   def elements(s=nil) @doc.elements(s) end
   def name() @doc.root.name end
   def to_a() @a end
   def to_s(options={}) self.xml options end
   def text(xpath) @doc.text(xpath) end
-  def root() @doc.elements.first end
+  def root() @doc end
 
   def write(f) 
     f.write xml 
@@ -730,11 +518,9 @@ class Rexle
   def xml(options={})
     o = {pretty: false, declaration: true}.merge(options)
     msg = o[:pretty] == false ? :doc_print : :doc_pretty_print
-
     r = ''
     r = "<?xml version='1.0' encoding='UTF-8'?>\n" if o[:declaration] == true
     r << method(msg).call(self.root.children)
-
     r
   end
 
@@ -751,23 +537,20 @@ class Rexle
       if recordx_type then
         procs = {
           'dynarex' => proc {|x| DynarexParser.new(x).to_a},
-          'polyrex' => proc {|x| PolyrexParser.new(x).to_a},
-          'polyrex' => proc {|x| RexleParser.new(x).to_a}
+          'polyrex' => proc {|x| PolyrexParser.new(x).to_a}
         }
         procs[recordx_type].call(x)
       else
-
         RexleParser.new(x).to_a
       end
     else
-
       RexleParser.new(x).to_a
     end
 
   end
     
   def scan_element(name, value=nil, attributes=nil, *children)
-
+     #puts 'name : ' + name.inspect
     element = Element.new(name, value, attributes, self)  
 
     if children then
@@ -782,6 +565,14 @@ class Rexle
     return element
   end
 
+  def count(path)
+    #puts 'path : ' + path
+    length = @doc.xpath(path).flatten.compact.length
+    #puts 'length = ' + length
+    length
+  end
+  
+  def max(path) @doc.xpath(path).flatten.compact.map(&:to_i).max end
   
   # scan a rexml doc
   #

metadata

@@ -2,7 +2,7 @@
 name: rexle
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.9.5
+  version: 0.9.6
 platform: ruby
 authors: 
 - James Robertson
@@ -10,7 +10,8 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-10-20 00:00:00 Z
+date: 2011-07-19 00:00:00 +01:00
+default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rexleparser
@@ -46,7 +47,7 @@ dependencies:
   type: :runtime
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  name: rexle-builder
+  name: nokogiri
   prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
@@ -56,6 +57,17 @@ dependencies:
         version: "0"
   type: :runtime
   version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rexle-builder
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id005
 description: 
 email: 
 executables: []
@@ -66,6 +78,7 @@ extra_rdoc_files: []
 
 files: 
 - lib/rexle.rb
+has_rdoc: true
 homepage: 
 licenses: []
 
@@ -89,9 +102,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 1.5.2
 signing_key: 
 specification_version: 3
-summary: Rexle is a simple XML parser written purely in Ruby
+summary: rexle
 test_files: []