methodchain 0.2.2 → 0.3.0

data/README

@@ -7,20 +7,6 @@ Copyright (c) 2008 Greg Weber, http://gregweber.info
 Licensed under the MIT license
 
 == Examples
-=== ##tap
-if you don't already know about this method, look it up on the net.  The tap included here allows message sending.
-
-==== old way
-  arr = [1]
-  arr.compact! # => nil
-  arr.first # => 1
-
-==== normal ##tap (still valid)
-  [1].tap {|arr| arr.compact!}.first # => 1
-
-==== new ##tap
-  [1].tap(:compact!).first # => 1
-
 === ##then and ##else
 ==== old way
   person = nil
@@ -36,8 +22,8 @@ not a huge savings. But sometimes the person variable is actually a function cal
     # do some expensive database queries
   end
 
-  location = find(:first)
-  @phone = location && location.phone   # => nil
+  person = find(:first)
+  @phone = person && person.phone   # => nil
 
 ==== new way
   @phone = find(:first).then {phone}   # => nil
@@ -48,7 +34,36 @@ We have reduced a line of code and removed a local variable.
   'a'.then('b') #=> 'b'
   nil.then('b').else('c') #=> 'c'
 
+=== ##tap
+if you don't already know about this method, look it up on the net.  The tap included here allows message sending.
+
+==== old way
+  arr = [1]
+  arr.compact! # => nil
+  arr.first # => 1
+
+==== normal ##tap (still valid)
+  [1].tap {|arr| arr.compact!}.first # => 1
+
+==== new ##tap
+  [1].tap(:compact!).first # => 1
+
+==== normal ##tap (still valid)
+  [1].tap {|arr| arr.compact!}.tap {|arr| arr * 2}.first # => 1
+
+==== new ##tap
+  [1].tap( :compact!, [:*, 2] ).first # => 1
+
+You can also pass Procs as arguments
+  [1].tap( :compact!, lambda{|arr| arr * 2} ).first # => 1
+
+
 === ##chain
+chain is like tap, but instead of always returning self, it will return the result of the method call.
+  [1].chain(:first) == [1].first
+
+But there is an important difference- chain guards against certain results (by default it guards against nil and false)
+
 ==== old way
   customer = nil
   customer && customer.order && customer.order.id
@@ -60,7 +75,7 @@ note that this is equivalent to
 
   customer.then {order}.then {id}
 
-=== ##chain - Custom guards, multiple arguments, and procs
+=== ##chain - Custom guards, multiple arguments, and Procs
 ==== old way - guarding against zero
   value = 0
 
@@ -76,7 +91,7 @@ note that this is equivalent to
 ==== new way
   value.chain(:abs, [:*, 20]) {|s| s == 0 }   # => 0
 
-procs can be used, so this is equivalent to
+Procs can be used, so this is equivalent to
   value.chain(:abs, lambda {|n| n * 20 }) {|s| s == 0 } # => 0
 
 == Usage
@@ -88,14 +103,45 @@ procs can be used, so this is equivalent to
 
 === selectively import MethodChain methods
 
-  require 'methodchain/not_included'
+  require 'methodchain/not-included'
+
+You can then include methodchain into selected classes, or you can use the module-import gem to include only certain methods
+
+  gem install module-import
+
+  require 'module-import'
+  class Object
+    import MethodChain, :chain  # I only want Object#chain
+  end
+
+import will still load all the private methods from the module:
+- yield_or_eval
+- send_as_function
+- send_as_functions
+
+
+==== not into Object
+To import nothing into the Object namespace
+  require 'methodchain/no-import'
+
+Then include where needed:
+  class MyObject
+    include MethodChain
+  end
 
-not_included will load the MethodChain module without including it anywhere.
-Already have your own version of tap? use the module-import gem to decide what to include
 
 == Implementation
-* There are no proxy objects and no use of method_missing- these are simply function calls, so it should be fast.
-* A helper method called yield_or_eval is also exposed.  This method allows the two different block forms {|p| p.name} and {name}, where the first form yields self and the second form is called using instance_eval.
+There are no proxy objects and no use of method_missing- these are simply function calls, so it should be fast.
+
+private methods:
+* yield_or_eval: allows the two different block forms {|p| p.name} and {name}, where the first form yields self and the second form is called using instance_eval.
+* send_as_function: allows symbols and arrays to be sent as messages, and calls yield_or_eval on Proc arguments
+* send_as_functions:
+
+  def send_arguments_as_functions *args
+    args.each {|arg| send_as_function arg}
+    self
+  end
 
 == Install
 gem install methodchain

data/{rakefile → Rakefile}

@@ -66,7 +66,7 @@ task :release => [:test,:record,:rdoc,:website,:package] do
 end
 
 desc "update website"
-file :website => ['README','rakefile'] do
+file :website => ['README','Rakefile'] do
   Dir.chdir '/home/greg/sites/projects/' do
     (puts (run 'rake projects:update'))
     (puts (run 'rake deploy:rsync'))
@@ -99,13 +99,13 @@ namespace :readme do
   task :test do
     # grab example code from README
     cd_tmp do
-      example_file = "#{__DIR__}/example.rb"
+      example_file = "#{Dir.pwd}/example.rb"
 
       File.write(example_file, (
-        File.read("#{__DIR__}/lib/methodchain/not_included.rb") <<
+        File.read("#{__DIR__}/lib/methodchain/not-included.rb") <<
         "class Object; include MethodChain end\n" <<
         File.readlines('../README').grep(/^  / ).
-          reject {|l| l =~ /^\s*require/ or l.include?('Error')}.
+          reject {|l| l =~ /^\s*require/ or l.include?('Error') or l.include? 'gem install'}.
             join ))
 
       command = "ruby ../bin/xmpfilter -c #{example_file}"
@@ -122,7 +122,7 @@ task :record do
   unless `git diff`.chomp.empty?
     ARGV.clear
     puts "enter commit message"
-    (puts (run "git commit -a -m #{Kernel.gets}"))
+    (puts (run "git commit -a -m '#{Kernel.gets}'"))
     puts "committed! now pushing.. "
     (puts (run 'git push origin master'))
   end
@@ -134,13 +134,15 @@ require 'rake/gempackagetask'
 spec = Gem::Specification.new do |s|
   s.name = project
   s.rubyforge_project = project
-  s.version = "0.2.2"
+  s.version = "0.3.0"
   s.author = "Greg Weber"
   s.email = "greg@gregweber.info"
   s.homepage = "http://projects.gregweber.info/#{project}"
   s.platform = Gem::Platform::RUBY
   s.summary = "convenience methods for method chaining"
-  s.files = Dir['./**'] + Dir['*/**']
+  s.files = FileList.new('./**', '*/**') do |fl|
+             fl.exclude('pkg','pkg/*','tmp','tmp/*')
+           end
   s.require_path = "lib"
   s.has_rdoc = true
   s.extra_rdoc_files = ["README"]

data/coverage/-var-lib-gems-1_8-gems-rcov-0_8_0_2-lib-rcov_rb.html

@@ -556,7 +556,7 @@ span.run100 {
       </head>
       <body>
         <h3>C0 code coverage information</h3>
-        <p>Generated on Mon Mar 10 10:31:09 -0500 2008 with <a href='http://eigenclass.org/hiki.rb?rcov'>rcov 0.8.0</a>
+        <p>Generated on Thu Mar 13 11:28:30 -0500 2008 with <a href='http://eigenclass.org/hiki.rb?rcov'>rcov 0.8.0</a>
         </p>
         <hr /><pre><span class='marked0'>Code reported as executed by Ruby looks like this...
 </span><span class='marked1'>and this: this line is also marked as covered.

data/coverage/index.html

@@ -151,7 +151,7 @@ table.report tr.dark {
       </head>
       <body>
         <h3>C0 code coverage information</h3>
-        <p>Generated on Mon Mar 10 10:31:09 -0500 2008 with <a href='http://eigenclass.org/hiki.rb?rcov'>rcov 0.8.0</a>
+        <p>Generated on Thu Mar 13 11:28:29 -0500 2008 with <a href='http://eigenclass.org/hiki.rb?rcov'>rcov 0.8.0</a>
         </p>
         <hr />    <table class='report'>
       <thead>
@@ -167,21 +167,21 @@ table.report tr.dark {
         <tr class='light'>
           <td>TOTAL</td>
           <td class='lines_total'>
-            <tt>1038</tt>
+            <tt>1047</tt>
           </td>
           <td class='lines_code'>
-            <tt>637</tt>
+            <tt>645</tt>
           </td>
           <td>
             <table cellspacing='0' cellpadding='0' align='right'>
               <tr>
                 <td>
-                  <tt class='coverage_total'>9.2%</tt>&nbsp;</td>
+                  <tt class='coverage_total'>9.9%</tt>&nbsp;</td>
                 <td>
                   <table cellspacing='0' class='percent_graph' cellpadding='0' width='100'>
                     <tr>
-                      <td class='covered' width='9' />
-                      <td class='uncovered' width='91' />
+                      <td class='covered' width='10' />
+                      <td class='uncovered' width='90' />
                     </tr>
                   </table>
                 </td>
@@ -192,12 +192,12 @@ table.report tr.dark {
             <table cellspacing='0' cellpadding='0' align='right'>
               <tr>
                 <td>
-                  <tt class='coverage_code'>9.3%</tt>&nbsp;</td>
+                  <tt class='coverage_code'>10.4%</tt>&nbsp;</td>
                 <td>
                   <table cellspacing='0' class='percent_graph' cellpadding='0' width='100'>
                     <tr>
-                      <td class='covered' width='9' />
-                      <td class='uncovered' width='91' />
+                      <td class='covered' width='10' />
+                      <td class='uncovered' width='90' />
                     </tr>
                   </table>
                 </td>
@@ -296,10 +296,10 @@ table.report tr.dark {
             <a href='lib-methodchain-not_included_rb.html'>lib/methodchain/not_included.rb</a>
           </td>
           <td class='lines_total'>
-            <tt>58</tt>
+            <tt>67</tt>
           </td>
           <td class='lines_code'>
-            <tt>39</tt>
+            <tt>47</tt>
           </td>
           <td>
             <table cellspacing='0' cellpadding='0' align='right'>

data/coverage/lib-methodchain-not_included_rb.html

@@ -556,7 +556,7 @@ span.run100 {
       </head>
       <body>
         <h3>C0 code coverage information</h3>
-        <p>Generated on Mon Mar 10 10:31:09 -0500 2008 with <a href='http://eigenclass.org/hiki.rb?rcov'>rcov 0.8.0</a>
+        <p>Generated on Thu Mar 13 11:28:30 -0500 2008 with <a href='http://eigenclass.org/hiki.rb?rcov'>rcov 0.8.0</a>
         </p>
         <hr /><pre><span class='marked0'>Code reported as executed by Ruby looks like this...
 </span><span class='marked1'>and this: this line is also marked as covered.
@@ -580,10 +580,10 @@ span.run100 {
             <a href='lib-methodchain-not_included_rb.html'>lib/methodchain/not_included.rb</a>
           </td>
           <td class='lines_total'>
-            <tt>58</tt>
+            <tt>67</tt>
           </td>
           <td class='lines_code'>
-            <tt>39</tt>
+            <tt>47</tt>
           </td>
           <td>
             <table cellspacing='0' cellpadding='0' align='right'>
@@ -622,61 +622,70 @@ span.run100 {
     </table><pre><span class="inferred1"><a name="line1" /> 1 # :main: README
 </span><span class="marked0"><a name="line2" /> 2 module MethodChain
 </span><span class="inferred1"><a name="line3" /> 3 
-</span><span class="inferred0"><a name="line4" /> 4   # send a method, evaluate a block, but always return self
-</span><span class="marked1"><a name="line5" /> 5   def tap meth=nil, &amp;block
-</span><span class="marked0"><a name="line6" /> 6     __send__ meth if meth
-</span><span class="marked1"><a name="line7" /> 7     yield_or_eval &amp;block if block_given?
-</span><span class="marked0"><a name="line8" /> 8     self
-</span><span class="inferred1"><a name="line9" /> 9   end
-</span><span class="inferred0"><a name="line10" />10 
-</span><span class="inferred1"><a name="line11" />11   # method chaining with a guard.
-</span><span class="inferred0"><a name="line12" />12   # If no guard block is given then guard against nil and false
-</span><span class="inferred1"><a name="line13" />13   # *methods = [method] where
-</span><span class="inferred0"><a name="line14" />14   #   method = Message | Code
-</span><span class="inferred1"><a name="line15" />15   #   Message = Symbol | [Symbol, *arguments]
-</span><span class="inferred0"><a name="line16" />16   #   Code.to_proc = Proc
-</span><span class="marked1"><a name="line17" />17   def chain *methods, &amp;guard
-</span><span class="inferred0"><a name="line18" />18     return self if methods.empty? or not(
-</span><span class="marked1"><a name="line19" />19       (block_given? ? (yield_or_eval &amp;guard) : self))
-</span><span class="inferred0"><a name="line20" />20 
-</span><span class="marked1"><a name="line21" />21     case(meth = methods.shift)
-</span><span class="marked0"><a name="line22" />22     when Symbol then __send__ meth
-</span><span class="marked1"><a name="line23" />23     when Array  then __send__ *meth
-</span><span class="marked0"><a name="line24" />24     else             yield_or_eval &amp;meth
-</span><span class="marked1"><a name="line25" />25     end.chain(*methods, &amp;guard)
-</span><span class="inferred0"><a name="line26" />26   end
-</span><span class="inferred1"><a name="line27" />27 
-</span><span class="inferred0"><a name="line28" />28   # yield or eval based on the block arity
-</span><span class="marked1"><a name="line29" />29   def yield_or_eval &amp;block
-</span><span class="marked0"><a name="line30" />30     case block.arity
-</span><span class="inferred1"><a name="line31" />31     # ruby bug for -1
-</span><span class="marked0"><a name="line32" />32     when 0, -1 then instance_eval(&amp;block)
-</span><span class="marked1"><a name="line33" />33     when 1     then yield(self)
-</span><span class="marked0"><a name="line34" />34     else            raise ArgumentError, &quot;too many arguments required by block&quot;
-</span><span class="inferred1"><a name="line35" />35     end
-</span><span class="inferred0"><a name="line36" />36   end
-</span><span class="inferred1"><a name="line37" />37 
-</span><span class="inferred0"><a name="line38" />38   # return self if self evaluates to false, otherwise
-</span><span class="inferred1"><a name="line39" />39   # evaluate the block or return the default argument
-</span><span class="marked0"><a name="line40" />40   def then default=nil, &amp;block
-</span><span class="marked1"><a name="line41" />41     if self
-</span><span class="marked0"><a name="line42" />42       block_given? ? (yield_or_eval &amp;block) : (default || (fail \
-</span><span class="marked1"><a name="line43" />43         ArgumentError, &quot;#then must be called with an argument or a block&quot;))
-</span><span class="inferred0"><a name="line44" />44     else
-</span><span class="marked1"><a name="line45" />45       self
-</span><span class="inferred0"><a name="line46" />46     end
-</span><span class="inferred1"><a name="line47" />47   end
-</span><span class="inferred0"><a name="line48" />48 
-</span><span class="inferred1"><a name="line49" />49   # the inverse of then
-</span><span class="marked0"><a name="line50" />50   def else arg=nil, &amp;block
-</span><span class="marked1"><a name="line51" />51     if self
-</span><span class="marked0"><a name="line52" />52       self
+</span><span class="marked0"><a name="line4" /> 4   def tap meths=nil, &amp;block
+</span><span class="marked1"><a name="line5" /> 5     send_arguments_as_functions *meths if meths
+</span><span class="marked0"><a name="line6" /> 6     yield_or_eval(&amp;block) if block_given?
+</span><span class="marked1"><a name="line7" /> 7     self
+</span><span class="inferred0"><a name="line8" /> 8   end
+</span><span class="inferred1"><a name="line9" /> 9 
+</span><span class="inferred0"><a name="line10" />10   # method chaining with a guard.
+</span><span class="inferred1"><a name="line11" />11   # If no guard block is given then guard against nil and false
+</span><span class="inferred0"><a name="line12" />12   # *methods = [method] where
+</span><span class="inferred1"><a name="line13" />13   #   method = Message | Code
+</span><span class="inferred0"><a name="line14" />14   #   Message = Symbol | [Symbol, *arguments]
+</span><span class="inferred1"><a name="line15" />15   #   Code.to_proc = Proc
+</span><span class="marked0"><a name="line16" />16   def chain *meths, &amp;guard
+</span><span class="inferred1"><a name="line17" />17     return self if meths.empty? or not(
+</span><span class="marked0"><a name="line18" />18       (block_given? ? (yield_or_eval(&amp;guard)) : self))
+</span><span class="inferred1"><a name="line19" />19 
+</span><span class="marked0"><a name="line20" />20     (send_as_function (meths.shift)).chain(*meths, &amp;guard)
+</span><span class="inferred1"><a name="line21" />21   end
+</span><span class="inferred0"><a name="line22" />22 
+</span><span class="marked1"><a name="line23" />23   def send_as_function meth
+</span><span class="marked0"><a name="line24" />24     case meth
+</span><span class="marked1"><a name="line25" />25     when Symbol then __send__ meth
+</span><span class="marked0"><a name="line26" />26     when Array  then __send__(*meth)
+</span><span class="marked1"><a name="line27" />27     else             yield_or_eval(&amp;meth)
+</span><span class="inferred0"><a name="line28" />28     end
+</span><span class="marked1"><a name="line29" />29   end
+</span><span class="marked0"><a name="line30" />30   private :send_as_function
+</span><span class="inferred1"><a name="line31" />31 
+</span><span class="marked0"><a name="line32" />32   def send_arguments_as_functions *methods
+</span><span class="marked1"><a name="line33" />33     methods.each {|meth| send_as_function meth}
+</span><span class="marked0"><a name="line34" />34     self
+</span><span class="inferred1"><a name="line35" />35   end
+</span><span class="inferred0"><a name="line36" />36 
+</span><span class="inferred1"><a name="line37" />37   # yield or eval based on the block arity
+</span><span class="marked0"><a name="line38" />38   def yield_or_eval &amp;block
+</span><span class="marked1"><a name="line39" />39     case block.arity
+</span><span class="inferred0"><a name="line40" />40     # ruby bug for -1
+</span><span class="marked1"><a name="line41" />41     when 0, -1 then instance_eval(&amp;block)
+</span><span class="marked0"><a name="line42" />42     when 1     then yield(self)
+</span><span class="marked1"><a name="line43" />43     else            raise ArgumentError, &quot;too many arguments required by block&quot;
+</span><span class="inferred0"><a name="line44" />44     end
+</span><span class="inferred1"><a name="line45" />45   end
+</span><span class="inferred0"><a name="line46" />46 
+</span><span class="inferred1"><a name="line47" />47   # return self if self evaluates to false, otherwise
+</span><span class="inferred0"><a name="line48" />48   # evaluate the block or return the default argument
+</span><span class="marked1"><a name="line49" />49   def then default=nil, &amp;block
+</span><span class="marked0"><a name="line50" />50     if self
+</span><span class="marked1"><a name="line51" />51       block_given? ? (yield_or_eval(&amp;block)) : (default || (fail \
+</span><span class="marked0"><a name="line52" />52         ArgumentError, &quot;#then must be called with an argument or a block&quot;))
 </span><span class="inferred1"><a name="line53" />53     else
-</span><span class="marked0"><a name="line54" />54       block_given? ? (yield_or_eval &amp;block) : (arg || (fail \
-</span><span class="marked1"><a name="line55" />55         ArgumentError, &quot;#else must be called with an argument or a bloc&quot;))
-</span><span class="inferred0"><a name="line56" />56     end
-</span><span class="inferred1"><a name="line57" />57   end
-</span><span class="inferred0"><a name="line58" />58 end
+</span><span class="marked0"><a name="line54" />54       self
+</span><span class="inferred1"><a name="line55" />55     end
+</span><span class="inferred0"><a name="line56" />56   end
+</span><span class="inferred1"><a name="line57" />57 
+</span><span class="inferred0"><a name="line58" />58   # the inverse of then
+</span><span class="marked1"><a name="line59" />59   def else arg=nil, &amp;block
+</span><span class="marked0"><a name="line60" />60     if self
+</span><span class="marked1"><a name="line61" />61       self
+</span><span class="inferred0"><a name="line62" />62     else
+</span><span class="marked1"><a name="line63" />63       block_given? ? (yield_or_eval(&amp;block)) : (arg || (fail \
+</span><span class="marked0"><a name="line64" />64         ArgumentError, &quot;#else must be called with an argument or a bloc&quot;))
+</span><span class="inferred1"><a name="line65" />65     end
+</span><span class="inferred0"><a name="line66" />66   end
+</span><span class="inferred1"><a name="line67" />67 end
 </span></pre><hr />    <p>Generated using the <a href='http://eigenclass.org/hiki.rb?rcov'>rcov code coverage analysis tool for Ruby</a> version 0.8.0.</p><p>
           <a href='http://validator.w3.org/check/referer'>
             <img src='http://www.w3.org/Icons/valid-xhtml10' height='31' alt='Valid XHTML 1.0!' width='88' />

data/coverage/lib-methodchain_rb.html

@@ -556,7 +556,7 @@ span.run100 {
       </head>
       <body>
         <h3>C0 code coverage information</h3>
-        <p>Generated on Mon Mar 10 10:31:09 -0500 2008 with <a href='http://eigenclass.org/hiki.rb?rcov'>rcov 0.8.0</a>
+        <p>Generated on Thu Mar 13 11:28:30 -0500 2008 with <a href='http://eigenclass.org/hiki.rb?rcov'>rcov 0.8.0</a>
         </p>
         <hr /><pre><span class='marked0'>Code reported as executed by Ruby looks like this...
 </span><span class='marked1'>and this: this line is also marked as covered.

data/doc/created.rid

@@ -1 +1 @@
-Tue, 11 Mar 2008 13:49:16 -0500
+Sun, 16 Mar 2008 10:24:28 -0500

data/doc/fr_class_index.html

@@ -20,7 +20,6 @@
 <div id="index">
   <h1 class="section-bar">Classes</h1>
   <div id="index-entries">
-    <a href="classes/MethodChain.html">MethodChain</a><br />
   </div>
 </div>
 </body>

data/doc/fr_file_index.html

@@ -21,8 +21,6 @@
   <h1 class="section-bar">Files</h1>
   <div id="index-entries">
     <a href="files/README.html">README</a><br />
-    <a href="files/lib/methodchain_rb.html">lib/methodchain.rb</a><br />
-    <a href="files/lib/methodchain/not_included_rb.html">lib/methodchain/not_included.rb</a><br />
   </div>
 </div>
 </body>

data/doc/fr_method_index.html

@@ -20,11 +20,6 @@
 <div id="index">
   <h1 class="section-bar">Methods</h1>
   <div id="index-entries">
-    <a href="classes/MethodChain.html#M000002">chain (MethodChain)</a><br />
-    <a href="classes/MethodChain.html#M000005">else (MethodChain)</a><br />
-    <a href="classes/MethodChain.html#M000001">tap (MethodChain)</a><br />
-    <a href="classes/MethodChain.html#M000004">then (MethodChain)</a><br />
-    <a href="classes/MethodChain.html#M000003">yield_or_eval (MethodChain)</a><br />
   </div>
 </div>
 </body>

data/lib/methodchain.rb

@@ -1,4 +1,3 @@
-require File.dirname(__FILE__) + '/methodchain/not_included'
+require File.dirname(__FILE__) + '/methodchain/not-included'
 
-class Object # :nodoc:
-  include MethodChain end
+class Object; include MethodChain end

data/spec/methodchain_spec.rb

@@ -1,7 +1,7 @@
 require File.dirname(__FILE__) + '/../lib/methodchain'
 
 describe "#chain" do
-  it "should return self when no arguments are given" do
+  it "should return self when no arguments or just a block are given" do
     [nil,'a'].each do |var|
       var.chain.should == var
       var.chain {fail}.should == var
@@ -17,6 +17,12 @@ describe "#chain" do
   it "should send an array as a message with arguments" do
     [['a']].chain(:flatten, lambda{|arr| arr.push('b')}, [:join, ' ']).should == 'a b'
   end
+  it "should yield self to a block and return self if block has one argument" do
+    [true,false,'a'].each do |o|
+      o.chain {|s| s.should == o }.should == o
+      o.chain {|s| 'foo' }.should == o
+    end
+  end
 
   it "should guard the chain against nil and false" do
     nil.chain(:foo,:bar,:baz).should == nil
@@ -39,13 +45,28 @@ describe "#chain" do
 end
 
 describe "#tap" do
-  it "#tap should yield self to a block and return self if block has one argument" do
+  it "should return self when no arguments are given" do
+    [true,false,'a'].each do |o|
+      o.tap.should == o
+    end
+  end
+  it "should send symbols" do
+    [[]].tap(:flatten!).should == []
+  end
+  it "should send an array as a message with arguments" do
+    ['a','b'].tap( [:join, ' '] ).should == ['a','b']
+  end
+  it "should send procs" do
+    [].tap(lambda{|arr| arr.push('a'); 'blah'}).should == ['a']
+    [].tap(lambda{ push('a'); 'blah' }).should == ['a']
+  end
+  it "should yield self to a block and return self if block has one argument" do
     [true,false,'a'].each do |o|
       o.tap {|s| s.should == o }.should == o
       o.tap {|s| not s }.should == o
     end
   end
-  it "#tap should raise an error if a block has more than one argument" do
+  it "should raise an error if a block has more than one argument" do
     [true,false,'a'].each do |o|
       lambda{ o.tap {|s,a|} }.should raise_error(ArgumentError)
       lambda{ o.tap {|s,*args|} }.should raise_error(ArgumentError)

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: methodchain
 version: !ruby/object:Gem::Version 
-  version: 0.2.2
-date: 2008-03-11 00:00:00 -05:00
+  version: 0.3.0
+date: 2008-03-16 00:00:00 -05:00
 summary: convenience methods for method chaining
 require_paths: 
 - lib
@@ -31,11 +31,9 @@ authors:
 files: 
 - ./doc
 - ./lib
-- ./pkg
 - ./spec
+- ./Rakefile
 - ./README
-- ./rakefile
-- ./example.rb
 - ./coverage
 - doc/files
 - doc/index.html
@@ -47,12 +45,6 @@ files:
 - doc/classes
 - lib/methodchain
 - lib/methodchain.rb
-- pkg/methodchain-0.2.0.gem
-- pkg/methodchain-0.2.1.gem
-- pkg/methodchain-0.0.1.gem
-- pkg/methodchain-0.0.3.gem
-- pkg/methodchain-0.0.5.gem
-- pkg/methodchain-0.1.0.gem
 - spec/methodchain_spec.rb
 - coverage/lib-methodchain_rb.html
 - coverage/index.html

data/example.rb

@@ -1,90 +0,0 @@
-# :main: README
-module MethodChain
-
-  # send a method, evaluate a block, but always return self
-  def tap meth=nil, &block
-    __send__ meth if meth
-    yield_or_eval(&block) if block_given?
-    self
-  end
-
-  # method chaining with a guard.
-  # If no guard block is given then guard against nil and false
-  # *methods = [method] where
-  #   method = Message | Code
-  #   Message = Symbol | [Symbol, *arguments]
-  #   Code.to_proc = Proc
-  def chain *methods, &guard
-    return self if methods.empty? or not(
-      (block_given? ? (yield_or_eval(&guard)) : self))
-
-    case(meth = methods.shift)
-    when Symbol then __send__ meth
-    when Array  then __send__(*meth)
-    else             yield_or_eval(&meth)
-    end.chain(*methods, &guard)
-  end
-
-  # yield or eval based on the block arity
-  def yield_or_eval &block
-    case block.arity
-    # ruby bug for -1
-    when 0, -1 then instance_eval(&block)
-    when 1     then yield(self)
-    else            raise ArgumentError, "too many arguments required by block"
-    end
-  end
-
-  # return self if self evaluates to false, otherwise
-  # evaluate the block or return the default argument
-  def then default=nil, &block
-    if self
-      block_given? ? (yield_or_eval(&block)) : (default || (fail \
-        ArgumentError, "#then must be called with an argument or a block"))
-    else
-      self
-    end
-  end
-
-  # the inverse of then
-  def else arg=nil, &block
-    if self
-      self
-    else
-      block_given? ? (yield_or_eval(&block)) : (arg || (fail \
-        ArgumentError, "#else must be called with an argument or a bloc"))
-    end
-  end
-end
-class Object; include MethodChain end
-  arr = [1]
-  arr.compact! # => nil
-  arr.first # => 1
-  [1].tap {|arr| arr.compact!}.first # => 1
-  [1].tap(:compact!).first # => 1
-  person = nil
-  name = person ? person.name : nil
-  name = person.then {|p| p.name}
-  def find(*args)
-    # do some expensive database queries
-  end
-  location = find(:first)
-  @phone = location && location.phone   # => nil
-  @phone = find(:first).then {phone}   # => nil
-  
-  'a'.then('b') #=> 'b'
-  nil.then('b').else('c') #=> 'c'
-  customer = nil
-  customer && customer.order && customer.order.id
-  customer.chain(:order, :id)
-  customer.then {order}.then {id}
-  value = 0
-  result = if value == 0 then value else
-    tmp = value.abs
-    if tmp == 0 then tmp else
-      tmp * 20
-    end
-  end
-  result # => 0
-  value.chain(:abs, [:*, 20]) {|s| s == 0 }   # => 0
-  value.chain(:abs, lambda {|n| n * 20 }) {|s| s == 0 } # => 0