rasantiago-tiny_xpath_helper 0.1.3 → 0.1.4

data/README.rdoc

@@ -26,17 +26,53 @@ If you just want the first match, use #first
   => "one"
 
 A slightly more elaborate API is available as #find_xpath
-  >> xpath.find_xpath( 'node/@style', :format => :xml, :find => :first )
+  >> xpath.find_xpath( 'node/@style', :format => :rexml, :find => :first )
   => style='first'
 
-Where :format can be :text (returns a string), or :xml (returns a REXML element),
+Where :format can be :text (returns a string), or :rexml (returns a REXML element),
 and :find can be :first or :all
+  >> xpath.find_xpath( 'node/@style', :format => :rexml, :find => :all )
+  => [style='first']
 
-  >> xpath.find_xpath( 'node/@style', :format => :xml, :find => :all )
+If you only need to set :format, you may pass just the symbol instead of an options hash
+This is especially convenient using the [] syntax since a bug in ruby1.8
+prevents using => inside of []
+  >> xpath[ 'node/@style', :rexml ]
   => [style='first']
 
-The output from :format => :xml is suitable for passing to another TinyXPathHelper
-  >> node_tree = xpath.find_xpath( 'node/three', :format => :xml )
+If you want to filter the output, you can pass something that can be to_proc'd as :format
+(Note that this acts on the string value of the element, not the REXML node)
+  >> xpath[ 'node/@style', :to_i ]
+  => [0]
+
+  >> xpath[ 'node/@style', :length ]
+  => [5]
+
+  >> xpath[ 'node', lambda{|x| x.strip.split(//) } ]
+  => [["o", "n", "e"], ["t", "w", "o"], ["t", "h", "r", "e", "e"]]
+
+
+You can also pass a block, which will get called on the entire return value, but
+only if at least one element is found
+  >> xpath.all( 'node' ){ |nodes| nodes.count } # nodes is an array
+  => 3
+
+  >> xpath.first( 'node' ){ |node| node.reverse } # node is a string
+  => "eno"
+
+  >> xpath.all( 'node', &:count )
+  => 3
+
+  >> xpath.all( 'nothing' ){ |nodes| raise "this will not run" }
+  => []
+  
+There's no shortcut for the case where you want to run something over the array of matching REXML nodes.
+Just use Array#map for that.
+  >> xpath[ 'node', :rexml ].map(&:name)
+  => ['node', 'node', 'node']
+
+The output from :format => :rexml is suitable for passing to another TinyXPathHelper
+  >> node_tree = xpath.find_xpath( 'node/three', :format => :rexml )
   >> deeper_xpath = TinyXPathHelper.new( node_tree )
   >> deeper_xpath[ 'b/@beta' ]
   => ["true"]

data/lib/tiny_xpath_helper.rb

@@ -13,22 +13,35 @@ class TinyXPathHelper
     @options.dup
   end
 
-  def find_xpath(xpath_expr, options = {})
-    self.class.find_xpath_from( node, xpath_expr, default_options.update(options) )
+  def with_options(*options)
+    r = default_options
+
+    options.each do |option|
+      if not Hash === option
+        option = {:format => option}
+      end
+      r.update(option)
+    end
+
+    return r
+  end
+
+  def find_xpath(xpath_expr, options = {}, &blk)
+    self.class.find_xpath_from( node, xpath_expr, with_options(options), &blk)
   end
 
-  def first(xpath_expr, options = {})
-    self.find_xpath( xpath_expr, default_options.update(options).update(:find => :first) )
+  def first(xpath_expr, options = {}, &blk)
+    self.find_xpath( xpath_expr, with_options(options, :find => :first), &blk)
   end
   alias at first
 
-  def all(xpath_expr, options = {})
-    self.find_xpath( xpath_expr, default_options.update(options).update(:find => :all) )
+  def all(xpath_expr, options = {}, &blk)
+    self.find_xpath( xpath_expr, with_options(options, :find => :all), &blk)
   end
   alias [] all
 
   def self.io_stream_classes
-    [ IOStream ] rescue [ IO, StringIO ] # thoughtbot-paperclip fixes the ducktype mess here
+    [ IOStream ] rescue [ IO, StringIO ] # thoughtbot-paperclip fixes the ducktype mess in StringIO
   end
 
   def self.classes_that_are_xmlish
@@ -77,31 +90,44 @@ class TinyXPathHelper
 
     count = options[:find] || :first
 
-    if format == :text
-      filter = lambda{|node| node && xml_node_to_text(node) }
-    elsif format == :xml
-      filter = lambda{|node| node }
+    filter1 = self.method(:xml_node_to_text)
+    filter2 = nil
+
+    if format == :xml or format == :rexml
+      filter1 = nil
+    elsif format == :text
+      filter2 = nil
+    elsif format.respond_to? :to_proc
+      filter2 = format.to_proc
     else
       raise "I don't know the format #{format.inspect}"
     end
 
-    if count == :all
-      val = REXML::XPath.match(element, path).map do |node|
-        filter.call( node )
-      end
+
+    if count   == :all
+      elements = REXML::XPath.match(element, path)
+
     elsif count == :first
-      val = filter.call(
-        REXML::XPath.first(element, path)
-      )
+      elements  = [ REXML::XPath.first(element, path) ].compact # Haskell hacker wishing for the Maybe monad
+
     else 
       raise "I don't know how to find #{count.inspect}"
     end
 
-    if(blk)
-      return val if val == nil or val == []
-      return blk.call(val)
+    elements = elements.map(&filter1).map(&filter2)
+
+    if count == :all
+      r = elements
+    elsif count == :first
+      r = elements.first
     end
-    return val
+
+    if(blk and elements.length > 0)
+      return blk.call( r )
+    end
+
+    return r
+
   end
 
 end

data/tiny_xpath_helper.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{tiny_xpath_helper}
-  s.version = "0.1.3"
+  s.version = "0.1.4"
 
   s.authors = ["Jesse Wolfe"]
   s.date = %q{2009-06-01}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rasantiago-tiny_xpath_helper
 version: !ruby/object:Gem::Version 
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors: 
 - Jesse Wolfe