anaphoric_case 0.0.2 → 0.0.3

data/lib/anaphoric_case/version.rb

@@ -1,3 +1,3 @@
 module AnaphoricCase
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/lib/anaphoric_case.rb

@@ -6,6 +6,7 @@ module AnaphoricCase
     # @private
     attr_accessor :__nest 
 
+    # @private
     def switch_stack
       Thread.current[:__switch_stack] ||= []
     end
@@ -27,7 +28,10 @@ module Kernel
   #   a different value, which will become the return value of #aif
   def aif result = true, &block
     if result
-      unless block.nil? then result = block.call(*[result].slice(0,block.arity)) end
+      unless block.nil?
+        new_result = block.call(*[result].slice(0,block.arity))
+        return new_result
+      end
       return result
     end
     false
@@ -51,6 +55,9 @@ module Kernel
   # the cheapest thing.
   # @param [Object] object - 
   #   parameter of all +on+ calls will be compared to this object using +===+
+  #   @note if you plan on passing an object which could be nil to the method,
+  #     you should call {Object#nil?} on it as your first +on+ condition as otherwise
+  #     it will always match the first one.
   # @yield A block during which the +on+ method will be available - the block is required.
   #   The block is always executed in the context of the receiver of the +switch+ method
   #   so most of the time this is +self+ but if you call +switch+ with an explicit receiver
@@ -69,11 +76,18 @@ module Kernel
         # the current switch block in this thread
         it = AnaphoricCase.switch_stack.last.instance_eval { @it }
 
+        # when the subsumption operator is used in these classes
+        # it basically means "equal" so we ignore it these cases
+        if (it and [Kernel, Fixnum, String,
+            Bignum, Float, Symbol].include? result.method(:===).owner)
+          result_simple = true
+        end
+
         begin
           if it and (result === it or result == true)
             result = Kernel.aif it, &block
             throw :result, result if result
-          elsif result and not it
+          elsif result and (not it or result_simple)
             result = Kernel.aif result, &block
             throw :result, result if result
           end

data/spec/anaphoric_case_spec.rb

@@ -4,14 +4,14 @@ require 'anaphoric_case'
 require 'timeout'
 
 describe "it is an anaphoric case" do
-  
+
   before :all do
-    class Harness
-      def initialize 
+    class Fixture
+      def initialize
         @array = [1,2,3,4,5]
         @hash = { :bacon => "cheese", :pie => "sky", :snoopy => "pizza" }
         @string = "That is quite a mustache you've got there, sheriff."
-        @snitch = 0 
+        @snitch = 0
       end
 
       def count
@@ -19,7 +19,7 @@ describe "it is an anaphoric case" do
       end
 
       def flavors thing
-        @hash[thing] 
+        @hash[thing]
       end
 
       def compliment
@@ -47,7 +47,7 @@ describe "it is an anaphoric case" do
   end
 
   before :each do
-    @test = Harness.new
+    @test = Fixture.new
   end
 
   profile :all do
@@ -109,7 +109,7 @@ describe "it is an anaphoric case" do
 
     it "can execute anaphoric blocks using on" do
       res = switch do
-        on(false) { |it| it.blah_blah } #this would raise an error if it was ever called 
+        on(false) { |it| it.blah_blah } #this would raise an error if it was ever called
         on(1) { |it| it + 1 }
       end
       res.should == 2
@@ -119,13 +119,13 @@ describe "it is an anaphoric case" do
       res = switch do
         on false
         on nil
-        on { 5 } 
+        on { 5 }
       end
       res.should == 5
       
       res = switch do
         on 1
-        on { 1 } 
+        on { 1 }
       end
       res.should == 1
     end
@@ -151,7 +151,7 @@ describe "it is an anaphoric case" do
       @test.count.slice!(0,3)
       @test.instance_eval(&test_test).should == [4,5]
       @test.count.concat [1,1,1,1]
-      @test.instance_eval(&test_test).should == [4,5,1,1,1,1] 
+      @test.instance_eval(&test_test).should == [4,5,1,1,1,1]
     end
 
     it "can look in an object if it's not within it" do
@@ -167,25 +167,52 @@ describe "it is an anaphoric case" do
       lambda { switch }.should raise_error ArgumentError, "switch requires a block"
     end
 
+    it "executes in a closure" do
+      blah_blah = 57
+      switch do
+        on(blah_blah < 56) { raise "no!!" }
+        on(blah_blah == 57) { blah_blah = "ok"}
+      end
+      blah_blah.should == "ok"
+
+      module Thingy
+        def thing_method arg
+          arg = switch do
+            on (arg == 5) { arg = "poop" }
+          end
+        end
+      end
+
+      class Boosh
+        include Thingy
+      end
+
+      farts = nil
+      Boosh.new.instance_eval do
+        farts = thing_method(5)
+      end
+      farts.should == "poop"
+    end
+
     it "can't call on from outside of switch block" do
       lambda { on }.should raise_error NameError
 
       # ensure the on method is defined the next time
       # we call it
-      flag = false 
+      flag = false
       t1 = Thread.new do
         switch do
           on false
-          flag = true 
+          flag = true
           sleep 0.1
           on true
         end
         flag = false
       end
-      
+
       Timeout.timeout(1) { loop until flag == true }
 
-      # should transform the uncaught :throw error into a NameError 
+      # should transform the uncaught :throw error into a NameError
       (self.respond_to? :on).should be true #it's defined in the thread
       lambda { on }.should raise_error NameError, "on without associated switch"
 
@@ -195,11 +222,11 @@ describe "it is an anaphoric case" do
     end
 
     it "can raise past the (internal) throw" do
-      lambda do 
+      lambda do
         switch do
-          on { |a,b,c| raise ArgumentError } 
+          on { |a,b,c| raise ArgumentError }
         end
-      end.should raise_error ArgumentError 
+      end.should raise_error ArgumentError
     end
 
     it "can nest safely" do
@@ -225,17 +252,38 @@ describe "it is an anaphoric case" do
       res.should == 5
     end
 
-    it "can be called with explicit receiver" do 
+    it "can be called with explicit receiver" do
       # this makes it act a little bit like "tap"
       res = @test.switch do
         on (flavors :lime) { |it| it.blah } #would raise
-        on (flavors :snoopy) 
+        on (flavors :snoopy)
         on { raise 'terribly awry'}
       end
 
       res.should == "pizza"
     end
 
+    it "can be called in the context of BasicObject if you prefix it" do
+      @basic = BasicObject.new
+      res = nil
+      test = @test
+      @basic.instance_eval do
+        res = ::Kernel.switch do
+          on (test.flavors :lime) { |it| nothing }
+          on (test.flavors :snoopy)
+        end
+      end
+      res.should == "pizza"
+      
+      lambda do
+        @basic.instance_eval do
+          res = switch do
+            on 1
+          end
+        end
+      end.should raise_error NoMethodError
+    end
+
     it "can act like a regular case statement if called with a parameter" do
       test = lambda do |test_obj|
         res = switch test_obj do
@@ -257,7 +305,7 @@ describe "it is an anaphoric case" do
           # its is @test.compliment
           switch it do
             #it is STILL @test.compliment
-            on(/mustache/) { |thing| false } 
+            on(/mustache/) { |thing| false }
             #return false to fall through
           end
         end
@@ -265,29 +313,70 @@ describe "it is an anaphoric case" do
         # which means this should NOT match
         on(/baron/) { |it| it.blah }
         # but this should.
-        on(/sheriff/) { |it| it + "okay" } 
+        on(/sheriff/) { |it| it + "okay" }
       end
       res.should == remember + "okay"
     end
 
+    it "can operate first-truthy with a parameter" do
+      amazing_proc = proc { |t| true if t.first == false }
+      mixed = lambda do
+        switch @test.count do |arr|
+          on arr.empty?   { |it| it } # equal to arr
+          on arr.first    { |it| it } # equal to arr.first
+          on(amazing_proc){ |it| it } # equal to arr
+          on { "zomg, not this!" }
+        end
+      end
+
+      try_it = proc do
+        mixed.call.should == 1
+        @test.count.clear
+        mixed.call.should == []
+        @test.count << false
+        mixed.call.should == [false]
+        @test.count.clear
+        @test.count << nil
+        mixed.call.should == "zomg, not this!"
+      end
+
+      try_it.call
+
+      @test.count.replace [1,2,3,4,5] #reset it
+
+      # you can acheieve the same functionality by calling it in context
+      # without a parameter
+
+      mixed = lambda do
+        @test.count.switch do
+          on(empty?) { self }
+          on(first)  { |it| it }
+          on(amazing_proc.call(self)) { self }
+          on { "zomg, not this!" }
+        end
+      end
+
+      try_it.call
+    end
+
     it "can be called both with and without a parameter" do
       res = switch do
         # there is no default __it__
-        on @test.compliment =~ /sheriff/ do |it| 
+        on @test.compliment =~ /sheriff/ do |it|
           # it here is "43" the place where sheriff occures
           switch it do |ot|
             on(ot > 43)  { raise 'ohnoes' }
-            on(ot < 43)  { raise 'ohnoes again'} 
+            on(ot < 43)  { raise 'ohnoes again'}
             # this will signal completion
             on(ot == 43) { 'okay!' }
           end
         end
-        # so this will not run 
+        # so this will not run
         on(@test.compliment =~ /baron/) { |it| it.blah }
       end
 
       res.should == 'okay!'
-      
+
       res = switch @test.compliment do
         # this will match
         on /mustache/ do |it|
@@ -297,7 +386,7 @@ describe "it is an anaphoric case" do
           end
         end
       end
-      
+
       #so the result of the entire block is the last truthy thing
       res.should == /poor/
 
@@ -322,7 +411,7 @@ describe "it is an anaphoric case" do
             on /that/ do
               switch "thing" do
                 on /thing/ do
-                  "foogle bear" 
+                  "foogle bear"
                 end
               end
             end
@@ -339,7 +428,7 @@ describe "it is an anaphoric case" do
       t1 = Thread.new do
         res1 = switch "this" do
           on /this/ do
-            switch "that" do 
+            switch "that" do
               on(/that/) { "that" }
             end
           end
@@ -408,7 +497,7 @@ describe "it is an anaphoric case" do
 
     it "threads?" do
       res1, res2, res3 = nil, nil, nil
-        
+
       t1 = Thread.new do
         res1 = switch do
           on(@test.flavors :lime)
@@ -431,11 +520,11 @@ describe "it is an anaphoric case" do
         res3 = switch do
           on false
           on nil
-          sleep 0.1 
+          sleep 0.1
           on true
         end
       end
-      
+
       Timeout.timeout 1 do
         loop do
           t = [t1.status, t2.status, t3.status]
@@ -445,14 +534,8 @@ describe "it is an anaphoric case" do
       end
 
       res1.should == "pizza"
-      res2.should == [1,2,3,4,5] 
+      res2.should == [1,2,3,4,5]
       res3.should == true
     end
   end
 end
-        
-        
-      
-    
-
-    

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: anaphoric_case
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,12 +9,12 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-15 00:00:00.000000000 -05:00
+date: 2011-09-29 00:00:00.000000000 -05:00
 default_executable: 
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &3997360 !ruby/object:Gem::Requirement
+  requirement: &10086020 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -22,10 +22,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *3997360
+  version_requirements: *10086020
 - !ruby/object:Gem::Dependency
   name: simplecov
-  requirement: &3997150 !ruby/object:Gem::Requirement
+  requirement: &10085810 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -33,10 +33,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *3997150
+  version_requirements: *10085810
 - !ruby/object:Gem::Dependency
   name: rspec-prof
-  requirement: &3996940 !ruby/object:Gem::Requirement
+  requirement: &10085600 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -44,10 +44,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *3996940
+  version_requirements: *10085600
 - !ruby/object:Gem::Dependency
   name: i18n
-  requirement: &3996730 !ruby/object:Gem::Requirement
+  requirement: &10085390 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -55,7 +55,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *3996730
+  version_requirements: *10085390
 description: ! "You have twenty or so methods, and you want to call the first one
   that returns something other than nil,\n  If the dog is on fire, put it out."
 email: