rexle 0.9.4 → 0.9.5

data/lib/rexle.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/ruby
+#!/usr/bin/env ruby
 
 # file: rexle.rb
 
@@ -6,20 +6,48 @@ 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.empty? ? self.root.value : scan_print(children).join
+    
+    body = (children.nil? or children.empty? or children.is_an_empty_string? ) ? '' : 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 = children.empty? ? self.value : pretty_print(children,2).join
+    body = 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]
@@ -28,16 +56,27 @@ module XMLhelper
   def scan_print(nodes)
 
     nodes.map do |x|
-      unless x.name == '![' then
-        a = x.attributes.to_a.map{|k,v| "%s='%s'" % [k,v]}      
-        tag = x.name + (a.empty? ? '' : ' ' + a.join(' '))
-
-        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
+
+      if x.is_a? Rexle::Element then
+        if x.name.chr != '!' 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      
+        end      
+      elsif x.is_a? String then
+        x
       end
     end
 
@@ -45,21 +84,30 @@ module XMLhelper
 
   def pretty_print(nodes, indent='0')
     indent = indent.to_i
-    nodes.map.with_index do |x, i|
-      unless x.name == '![' then
-        a = x.attributes.to_a.map{|k,v| "%s='%s'" % [k,v]}      
-        tag = x.name + (a.empty? ? '' : ' ' + a.join(' '))
-
-        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 = x.children.length > 0 ? ("\n" + '  ' * (indent - 1)) : ''
-        out << "%s</%s>" % [ind2, x.name]
-      else    
-        "<![CDATA[%s]]>" % x.value
+
+    nodes.select(){|x| x.is_a? Rexle::Element or x.strip.length > 0}
+        .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) : ''
+          out = ["%s<%s>%s" % [start, tag, ind1]]
+
+          out << pretty_print(x.children, (indent + 1).to_s.clone)
+          ind2 = ind1.length > 0 ? ("\n" + '  ' * (indent - 1)) : ''
+          out << "%s</%s>" % [ind2, x.name]
+        else    
+          "<![CDATA[%s]]>" % x.value
+        end
+      elsif x.is_a? String then
+        x.sub(/^[\n\s]+$/,'')
       end
     end
 
@@ -70,108 +118,224 @@ end
 class Rexle
   include XMLhelper
 
+  attr_reader :prefixes
+
+  def self.version()
+    '0.9.xx'
+  end
+  
   def initialize(x=nil)
     super()
 
+    # what type of input is it? Is it a string, array, or REXML doc?
     if x then
       procs = {
-	      String: proc {|x| parse_string(x)},
-	      Array: proc {|x| x},
-	      :"REXML::Document" =>  proc {|x| scan_doc x.root}
+        String: proc {|x| parse_string(x)},
+        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(*a)      
-    end
-    
-  end
-
-  def xpath(path, &blk)
-
-    # is it a function
-    fn_match = path.match(/^(\w+)\(([^\)]+)\)$/)
+      @a = procs[x.class.to_s.to_sym].call(x)
+      @doc = scan_element(*(doc_node << @a))
+      
+      # fetch the namespaces
+      @prefixes = []
+      if @doc.root.attributes then
 
-    #    Array: proc {|x| x.flatten.compact}, 
-    if 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)
+        xmlns = @doc.root.attributes.select {|k,v| k[/^xmlns:/]}
+        @prefixes = xmlns.keys.map{|x| x[/\w+$/]}
+      end
 
-      procs[result.class.to_s.to_sym].call(result)
-      
-    else
-      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
+    attr_reader :child_lookup, :child_elements
+    
+    alias original_clone clone
 
-    def initialize(name=nil, value='', attributes={})
+    def initialize(name=nil, value='', attributes={}, rexle=nil)
+      @rexle = rexle      
       super()
-      @name, @value, @attributes = name, value, attributes
+      @name, @value, @attributes = name.to_s, value, attributes
       raise "Element name must not be blank" unless name
       @child_elements = []
       @child_lookup = []
     end
 
-    def xpath(xpath_value, rlist=[], &blk)
+    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()
+      if @rexle then
+        prefix = @rexle.prefixes.find {|x| x == @name[/^(\w+):/,1] } if @rexle.prefixes.is_a? Array
+        prefix ? @name.sub(prefix + ':', '') : @name
+      else
+        @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)
 
-      raw_path, raw_condition = xpath_value.sub(/^\/(?!\/)/,'').match(/([^\[]+)(\[[^\]]+\])?/).captures 
-      remaining_path = ($').to_s
-      a_path = raw_path.split('/')
+      # 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)
+
+      #remove any pre'fixes
+     #@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!(/^attribute::/,'*/attribute::')
+      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
+      
       condition = raw_condition if a_path.length <= 1
 
       if raw_path[0,2] == '//' then
-        s = a_path[2] || ''
-        condition = raw_condition
-      elsif raw_path == 'text()' then      
+        s = ''
+      elsif raw_path == 'text()'        
         a_path.shift
         return @value
       else
-        attribute = xpath_value[/^attribute::(.*)/,1] 
-        return @attributes[attribute.to_sym] if attribute and @attributes and @attributes.has_key?(attribute.to_sym)
- 
+
+        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)
         s = a_path.shift
       end      
 
       # isolate the xpath to return just the path to the current element
-      elmnt_path = s[/^([\w\*]+\[[^\]]+\])|[\/]+{,2}[^\/]+/]
-      element_part = elmnt_path[/(^@?[^\[]+)?/,1] if elmnt_path
 
+      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
+          element_name = element_part[/^[\w:\*\.]+/]
         else
-          condition = element_part
+
+          condition = xpath_value[/^\[/] ? xpath_value : element_part
           element_name = nil
         end
 
       end
 
+      #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 = []
 
-      attr_search = format_condition(condition) if condition and condition.length > 0
+      if raw_path[0,2] == '//' then
 
-      if raw_path[0,2] == '//'
-        return_elements = scan_match(self, element_name, attr_search, condition, rlist) 
-        return (xpath_value[/text\(\)$/] ? return_elements.map(&:value) : return_elements)
-      end
+        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
+
+      elsif (raw_path == '.' or raw_path == self.name) and attr_search.nil? then
+        return  [self]
+      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))
+        end
 
-      return_elements = @child_lookup.map.with_index.select do |x|
-        x[0][0] == element_name or element_name == '*'
       end
-        
+
       if return_elements.length > 0 then
 
         if (a_path + [remaining_path]).join.empty? then
@@ -180,10 +344,13 @@ class Rexle
         else
 
           rlist << return_elements.map.with_index do |x,i| 
+
             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? Array then
+            if rtn_element.is_a? Hash then
+              rtn_element
+            elsif 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
@@ -192,15 +359,17 @@ 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)
@@ -209,19 +378,31 @@ class Rexle
 
       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
 
     def add_element(item)
-      @child_lookup << [item.name, item.attributes, item.value]
-      @child_elements << item
-      # add a reference from this element (the parent) to the child
-      item.parent = self
-      item
+      if item.is_a? Rexle::Element then
+        @child_lookup << [item.name, item.attributes, item.value]
+        @child_elements << item
+        # add a reference from this element (the parent) to the child
+        item.parent = self
+        item        
+      elsif item.is_a? String then
+        @child_lookup << item
+        @child_elements << item             
+      elsif item.is_a? Rexle then
+        self.add_element(item.root)
+      end
     end    
 
     def inspect()
+      if self.xml.length > 30 then
       "%s ... </>" % self.xml[/<[^>]+>/]
+      else
+        self.xml
+      end  
     end
     
     alias add add_element
@@ -240,11 +421,29 @@ class Rexle
     end
 
     def add_text(s) @value = s; self end
-    def attribute(key) @attributes[key.to_sym] end  
+    
+    def attribute(key) 
+      key = key.to_sym if key.is_a? String
+      @attributes[key].gsub('&lt;','<').gsub('&gt;','>')
+    end  
+    
     def attributes() @attributes end    
-    def children() @child_elements end    
-    def children=(a) @child_elements = a 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 delete(obj=nil)
       if obj then
         i = @child_elements.index(obj)
@@ -254,17 +453,30 @@ class Rexle
       end
     end
 
-    def element(s) self.xpath(s).first  end
+    def element(s) 
+      r = self.xpath(s)
+      r.is_a?(Array) ? r.first : r
+    end
 
     def elements(s=nil)
       procs = {
-        NilClass: proc {Elements.new(@child_elements)},
+        NilClass: proc {Elements.new(@child_elements.select{|x| x.is_a? Rexle::Element })},
         String: proc {|x| @child_elements[x]}
       }
+
       procs[s.class.to_s.to_sym].call(s)      
     end
 
-    def root() self 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 root() self end #@rexle.root end
 
     def text(s='')
 
@@ -274,6 +486,7 @@ 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
@@ -283,10 +496,14 @@ class Rexle
 
       result
     end
+    
+    def texts()
+      [@value] + @child_elements.select {|x| x.is_a? String}
+    end
 
     def value=(raw_s)
 
-      @value = raw_s.to_s.clone
+      @value = String.new(raw_s.to_s.clone)
       escape_chars = %w(& &amp; < &lt; > &gt;).each_slice(2).to_a
       escape_chars.each{|x| @value.gsub!(*x)}
 
@@ -306,17 +523,27 @@ 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+|[!=]+|[@\w\.\/]+/)
-      raw_items = condition[1..-1].scan(/\'[^\']*\'|and|or|\d+|[!=<>]+|position\(\)|[@\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
-        return "i %s %s" % raw_items[1..-1]
+        rrr = "i %s %s" % [raw_items[1].gsub('&lt;','<').gsub('&gt;','>'), raw_items[-1]]
+        return rrr
       else
 
         andor_items = raw_items.map.with_index.select{|x,i| x[/\band\b|\bor\b/]}.map{|x| [x.last, x.last + 1]}.flatten
@@ -331,9 +558,10 @@ class Rexle
 
             if x.length >= 3 then
               x[1] = '==' if x[1] == '='
-              "h[:%s] %s %s" % x
+              "h[:'%s'] %s %s" % x
             else
-              x
+
+              x.join[/^(and|or)$/] ? x : ("h[:'%s']" % x)
             end
           end
 
@@ -344,6 +572,7 @@ 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
@@ -351,7 +580,7 @@ class Rexle
 
                   "e.xpath('#{path}').first.value == #{value}"
                 else
-                  "(name == '%s' and value %s %s)" % [x[0], x[1], x[2]]
+                  "(name == '%s' and value %s '%s')" % [x[0], x[1], x[2].sub(/^['"](.*)['"]$/,'\1')]
                 end
               else
                 "e.value %s %s" % [x[1], x[2]]
@@ -360,7 +589,7 @@ class Rexle
               x
             end
           end
-
+          
           return items.join(' ')
         end
       end
@@ -368,59 +597,47 @@ class Rexle
 
     end
 
-    def scan_match(nodes, element, attr_search, condition, rlist)
+    
+    def scan_match(node, path)
 
-      nodes.children.each.with_index do |x, i|
+      r = []
+      xpath2 = path[2..-1] 
+      xpath2.sub!(/^\*\//,'')
+      xpath2.sub!(/^\*/,self.name)
+      xpath2.sub!(/^\w+/,'').sub!(/^\//,'') if xpath2[/^\w+/] == self.name
+      
 
-        h = x.attributes
+      r << node.xpath(xpath2)
+      r << node.elements.map {|n| scan_match(n, path) if n.is_a? Rexle::Element}
+      r
+    end
 
+    # used by xpath function contains()
+    #
+    def scan_contents(node)
 
-        if element and not(element.empty?) then
-          if x.name == element
-            if attr_search then
-              rlist << x if h and eval(attr_search)
-            else
-              rlist << x 
-            end
-          end
-        else
+      a = []
+      a << node.text
 
-          if condition[/^@/] then
-            attribute = condition[/@(.*)/,1]
-            if h and h.has_key? attribute.to_sym then
-              rlist << h[attribute.to_sym]
-            end
-          else
-            rlist << x if h and eval(attr_search)
-          end
-        end
-    
-        x.xpath('//' + element.to_s + condition.to_s, rlist) unless x.children.empty?
+      node.elements.each do |child|
+        a.concat scan_contents(child)
       end
-      rlist
+      a
     end
-
+    
+    
     def filter(raw_element, i, attr_search, &blk)
 
       x = raw_element
       e = @child_elements[x.last]
-      h = x[0][1]  # <-- fetch the attributes
 
+      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      
+      
       if attr_search then
-        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
+        attribute_search(attr_search,e, h, i, &blk)
       else
 
         block_given? ? blk.call(e) : e
@@ -428,9 +645,28 @@ 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
@@ -439,6 +675,10 @@ class Rexle
     def [](i)
       @elements[i-1]
     end
+    
+    def each(&blk) @elements.each(&blk)  end
+    def to_a()     @elements             end
+      
   end # -- end of elements --
 
 
@@ -448,16 +688,17 @@ class Rexle
     
     if x then
       procs = {
-	      String: proc {|x| parse_string(x)},
-	      Array: proc {|x| x},
-	      :"REXML::Document" =>  proc {|x| scan_doc x.root}
+        String: proc {|x| parse_string(x)},
+        Array: proc {|x| x},
+        :"REXML::Document" =>  proc {|x| scan_doc x.root}
       }
       a = procs[x.class.to_s.to_sym].call(x)
     else    
       a = yield
     end
-
-    @doc = scan_element(*a)
+    doc_node = ['doc','',{}]
+    @a = procs[x.class.to_s.to_sym].call(x)
+    @doc = scan_element(*(doc_node << @a))
     self
   end
 
@@ -465,15 +706,22 @@ class Rexle
   def attribute(key) @doc.attribute(key) end
   def attributes() @doc.attributes end
   def add_element(element) @doc.root.add_element(element) end
+  def add_text(s) end
 
   alias add add_element
 
-  def delete(xpath) @doc.element(xpath).delete end
-  def element(xpath) @doc.element(xpath) end  
+  def delete(xpath)
+    e = @doc.element(xpath)
+    e.delete if e
+  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 end
+  def root() @doc.elements.first end
 
   def write(f) 
     f.write xml 
@@ -482,9 +730,11 @@ 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
 
@@ -501,26 +751,37 @@ 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| PolyrexParser.new(x).to_a},
+          'polyrex' => proc {|x| RexleParser.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)
 
-  def scan_element(name, value, attributes, *children)
-    element = Element.new(name, value, attributes)  
-    children.each{|x| element.add_element scan_element(*x)} if children
+    element = Element.new(name, value, attributes, self)  
+
+    if children then
+      children.each do |x|
+        if x.is_a? Array then
+          element.add_element scan_element(*x)        
+        elsif x.is_a? String
+          element.add_element x
+        end
+      end
+    end
     return element
   end
 
-  def count(path) @doc.xpath(path).flatten.compact.length end
-  def max(path) @doc.xpath(path).map(&:to_i).max end
   
   # scan a rexml doc
   #

metadata

@@ -1,57 +1,61 @@
 --- !ruby/object:Gem::Specification 
 name: rexle
 version: !ruby/object:Gem::Version 
-  version: 0.9.4
+  prerelease: 
+  version: 0.9.5
 platform: ruby
-authors: []
-
+authors: 
+- James Robertson
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2011-02-11 00:00:00 +00:00
-default_executable: 
+date: 2012-10-20 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rexleparser
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
         version: "0"
-    version: 
+  type: :runtime
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: dynarex-parser
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
         version: "0"
-    version: 
+  type: :runtime
+  version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   name: polyrex-parser
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
         version: "0"
-    version: 
-- !ruby/object:Gem::Dependency 
-  name: nokogiri
   type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rexle-builder
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
         version: "0"
-    version: 
+  type: :runtime
+  version_requirements: *id004
 description: 
 email: 
 executables: []
@@ -62,7 +66,6 @@ extra_rdoc_files: []
 
 files: 
 - lib/rexle.rb
-has_rdoc: true
 homepage: 
 licenses: []
 
@@ -72,23 +75,23 @@ rdoc_options: []
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
-summary: rexle
+summary: Rexle is a simple XML parser written purely in Ruby
 test_files: []