methodchain 0.3.1 → 0.4.0

data/README

@@ -1,5 +1,5 @@
 == Summary
-methodchain - ruby helpers for method chaining: chain, tap, then, else
+methodchain - ruby helpers for method chaining: chain, tap, then, else, and, or
 Easy ways to navigate around nil without creating local variables.
 
 == Author and License
@@ -14,6 +14,8 @@ Licensed under the MIT license
 
 ==== new way
   name = person.then {|p| p.name}
+  # or
+  name = person.then {name}
 
 not a huge savings. But sometimes the person variable is actually a function call, and then we must save it in a variable first.
 
@@ -29,10 +31,36 @@ not a huge savings. But sometimes the person variable is actually a function cal
   @phone = find(:first).then {phone}   # => nil
   
 We have reduced a line of code and removed a local variable.
-#then and #else can return a default value instead of evaluating a block
+##else is the opposite of #then, and the two methods can be used together
+
+  'a'.then{'b'} #=> 'b'
+  nil.then{'b'}.else{'c'} #=> 'c'
+
+==== message sending
+The normal conditional for ##then and ##else is self
+
+  if self # inside MethodChain#then
+    # evaluate block
+  end
+
+##then and ##else allow message sending as the conditional.  See more examples of message sending with the MethodChain#chain examples below
+
+  "not empty".then(:empty?) {"N/A"} # => "not empty"
+           "".then(:empty?) {"N/A"} # => "N/A"
+
+=== ##and, ##or
+==== old way
+Return a default value or the original value depending on whether multiple conditions are met
+  Person = Struct.new(:phone )
+  blank = Person.new('') # or {:phone => nil}
+  blank.phone && (not blank.phone.empty?) ? blank.phone : "N/A" # => "N/A"
+  p = Person.new('123')
+  p.phone && (not p.phone.empty?) ? p.phone : "N/A" # => "123"
+
+==== new way
+  blank.phone.and {not empty?} || "N/A" # => "N/A"
+  p.phone.and {not empty?} || "N/A" # => "123"
 
-  '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.

data/Rakefile

@@ -89,7 +89,7 @@ namespace :readme do
     doc.at('#description').search('pre').each do |ex|
       #select {|elem| elem.inner_html =~ /class |module /}.each do |ex|
       # add coderay and undo what rdoc has done in the example code
-      ex.swap("<coderay lang='ruby'>#{ex.inner_html.gsub('&quot;', '"').gsub('&gt;','>')}</coderay>")
+      ex.swap("<coderay lang='ruby'>#{ex.inner_html.gsub('&quot;', '"').gsub('&gt;','>').gsub('&lt;', '<')}</coderay>")
     end
     puts doc.at('#description').to_html
   end
@@ -134,7 +134,7 @@ require 'rake/gempackagetask'
 spec = Gem::Specification.new do |s|
   s.name = project
   s.rubyforge_project = project
-  s.version = "0.3.1"
+  s.version = "0.4.0"
   s.author = "Greg Weber"
   s.email = "greg@gregweber.info"
   s.homepage = "http://projects.gregweber.info/#{project}"

data/doc/created.rid

@@ -1 +1 @@
-Mon, 17 Mar 2008 08:17:16 -0500
+Mon, 24 Mar 2008 13:06:03 -0500

data/lib/methodchain/not-included.rb

@@ -48,24 +48,59 @@ public
     (send_as_function (messages.shift)).chain(*messages, &guard)
   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"))
+  # return self if self or a guard evaluates to false,
+  # otherwise return the evaluation of the block
+  def then *guards, &block
+    if guards.empty? 
+      return self if not self
     else
-      self
+      guards.each do |cond|
+        return self if not send_as_function(cond)
+      end
     end
+
+    block_given? ? yield_or_eval(&block) : self
+  end
+
+  # return self if self or a guard evaluates to true
+  # otherwise return the evaluation of the block
+  def else *guards, &block
+    if guards.empty? 
+      return self if self
+    else
+      guards.each do |cond|
+        return self if send_as_function(cond)
+      end
+    end
+
+    block_given? ? yield_or_eval(&block) : self
   end
 
-  # the inverse of then
-  def else arg=nil, &block
-    if self
-      self
+  # with no guards, is equivalent to self && yield_or_eval(&block) && self
+  # same as: <tt>self.then(*guards, &block) && self</tt>
+  def and *guards, &block
+    if guards.empty? 
+      return self if not self
     else
-      block_given? ? (yield_or_eval(&block)) : (arg || (fail \
-        ArgumentError, "#else must be called with an argument or a bloc"))
+      guards.each do |cond|
+        return self if not send_as_function(cond)
+      end
     end
+
+    block_given? ? (yield_or_eval(&block) && self) : self
+  end
+
+  # with no guards, is equivalent to <tt>self || (yield_or_eval(&block) && self)</tt>
+  # same as: <tt>self.else(*guards, &block) && self</tt>
+  def or *guards, &block
+    if guards.empty? 
+      return self if self
+    else
+      guards.each do |cond|
+        return self if send_as_function(cond)
+      end
+    end
+
+    block_given? ? yield_or_eval(&block) : self
   end
 end

data/spec/methodchain_spec.rb

@@ -1,5 +1,8 @@
 require File.dirname(__FILE__) + '/../lib/methodchain'
 
+#TODO
+# test message sending with #and and #or
+
 describe "#chain" do
   it "should return self when no arguments or just a block are given" do
     [nil,'a'].each do |var|
@@ -88,30 +91,76 @@ describe "#tap" do
   end
 end
 
+describe "Object#and" do
+  it "should return self or a value that evaluates to false" do
+    [true,'testing'].each do |val|
+      val.and {false}.should == false
+      val.and {'a'}.should == val
+    end
+    [false,nil].each do |val|
+      val.and {false}.should == val
+      val.and {nil}.should == val
+      val.and {true}.should == val
+    end
+  end
+end
+
+describe "Object#or" do
+  it "should return self or a value that evaluates to false" do
+    [true,'testing'].each do |val|
+      val.or {false}.should == val
+      val.or {'a'}.should == val
+    end
+    [false,nil].each do |val|
+      val.or {false}.should == false
+      val.or {nil}.should == nil
+      val.or {true}.should == true
+    end
+  end
+end
 def test_then_else *vals
   bool = !!vals.first
   same,opp = bool ? [:then,:else] : [:else,:then]
 
-  it "should return self if self evaluates to #{!bool}" do
+  it "should return self if no conditions are given and self evaluates to #{!bool}" do
     vals.each do |val|
       val.send(opp).should == val
-      val.send(opp,'aye').should == val
-      val.send(opp,'aye') {|a,b,c| a}.should == val
       val.send(opp) {|a,b,c| a}.should == val
     end
   end
 
+  it "should return self if no block is given" do
+    vals.each do |val|
+      val.send(same, proc{self}).should == val
+      val.send(same, proc{not self}).should == val
+      val.send(opp, proc{self}).should == val
+      val.send(opp, proc{not self}).should == val
+
+      lambda{val.send(same, proc{fail})}.should raise_error
+      lambda{val.send(opp, proc{fail})}.should raise_error
+    end
+  end
+
   it "if self evaluates to #{bool} ##{same} should yield self to a block if one is given, and return that block's value" do
     vals.each do |val|
       val.send(same)   {|v| v.should == val; 'foo'}.should == 'foo'
-      val.send(same,1) {|v| v.should == val; 'foo'}.should == 'foo'
     end
   end
 
-  it "should validate arguments if self evaluates to #{bool}" do
-    vals.each {|val| lambda{val.send(same)}.should raise_error(ArgumentError)}
-    vals.each {|val| lambda{val.send(same){|a,b|}}.should raise_error(ArgumentError)}
-    vals.each {|val| lambda{val.send(same){|a,*b|}}.should raise_error(ArgumentError)}
+  it "if self evaluates to #{!bool} ##{opp} should yield self to a block if one is given, and return that block's value" do
+    vals.each do |val|
+      val.send(opp) {|v| v.should == val; 'foo'}.should == val
+    end
+  end
+
+  it "should test conditions" do
+    vals.each do |val|
+      val.send(same, proc{self}) {"test"}.should == "test"
+      val.send(same, proc{not self}) {fail}.should == val
+
+      val.send(opp, proc{self}) {fail}.should == val
+      val.send(opp, proc{not self}) {"test"}.should == "test"
+    end
   end
 end
 

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: methodchain
 version: !ruby/object:Gem::Version 
-  version: 0.3.1
-date: 2008-03-17 00:00:00 -05:00
+  version: 0.4.0
+date: 2008-03-24 00:00:00 -05:00
 summary: convenience methods for method chaining
 require_paths: 
 - lib