wrap 0.4.2 → 0.4.3

data/README

@@ -0,0 +1,58 @@
+NAME
+  wrap
+
+SYNOPSIS
+  non-sucking :before and :after filers for any ruby class
+
+DESCRIPTION
+  yes yes, active_support does this.  but crapily.  with actice_support you'll
+  need to do this
+
+
+    class Record
+      include ActiveSupport::Callbacks
+      define_callbacks :save
+
+      def save
+        run_callbacks :save do
+          puts "- save"
+        end
+      end
+    end
+
+  but hey, if a subclass forgets to call 'super' or doesn't manually run
+  'run_callbacks' the codez are *screwed*.  that sux.  why not this?
+
+
+    class Record
+      include Wrap
+
+      wrap :save
+    end
+
+
+  yes, it's that simple.  you can now do
+
+    class SubRecord < Record
+      before :save do
+        special_sauce
+      end
+      
+      def save
+        no_special_sauce
+      end
+    end
+
+  did you get that?  the :before and :after hooks will be called no matter
+  what the subclass does.  the method will be wrapped, period.  no special
+  work required.  of course, if the sublcass messes with 'method_added' their
+  will be hell to pay.  that's the price for simplicity.
+
+  the callbacks are very close, but not identical to active_supports.  you can
+  return 'false' to halt the chain, but you can also simply call 'halt!'.
+  another neat trick is that :before callbacks will be called with the
+  arguments to the wrapped method itself iff possible and :after callbacks
+  will be called with the result of the wrapped method, iff possible.
+
+  the test suite reads pretty damn clean.  have a go.
+

data/lib/wrap.rb

@@ -5,7 +5,7 @@
 ##
 #
   class << Wrap
-    Version = '0.4.2' unless defined?(Version)
+    Version = '0.4.3' unless defined?(Version)
 
     def version
       Version
@@ -67,11 +67,14 @@
           end
 
           running_callbacks(#{ name.inspect }) do
-            begin
-              run_callbacks(:before, #{ name.inspect })
-              wrapped_#{ name }(*args, &block)
-            ensure
-              run_callbacks(:after, #{ name.inspect }) unless $!
+            catch(:halt) do
+              return false unless run_callbacks(:before, #{ name.inspect }, args)
+
+              begin
+                result = wrapped_#{ name }(*args, &block)
+              ensure
+                run_callbacks(:after, #{ name.inspect }, [result]) unless $!
+              end
             end
           end
         end
@@ -148,10 +151,7 @@
       end
 
       def initialize_callbacks!(name)
-        callbacks[name] ||= Map[
-          :before, [],
-          :after, []
-        ]
+        callbacks[name] ||= Map[ :before, [], :after, [] ]
         callbacks[name]
       end
 
@@ -191,7 +191,7 @@
         end
       end
 
-      def run_callbacks(which, name)
+      def run_callbacks(which, name, argv)
         which = which.to_s.to_sym
         name = name.to_s
         list = []
@@ -201,16 +201,24 @@
 
           if ancestor.callbacks.is_a?(Map) and ancestor.callbacks[name].is_a?(Map)
             callbacks = ancestor.callbacks[name][which]
-            list.unshift(*callbacks) if callbacks.is_a?(Array)
+            accumulate = (which == :before ? :unshift : :push)
+            list.send(accumulate, *callbacks) if callbacks.is_a?(Array)
           end
         end
 
-#p :which => list
         list.each do |callback|
-          cb = callback.respond_to?(:call) ? callback : proc{ send(callback.to_s.to_sym) }
-#p :cb => cb
-          instance_eval(&cb)
+          block = callback.respond_to?(:call) ? callback : proc{ send(callback.to_s.to_sym) }
+          args = argv.slice(0 .. (block.arity > 0 ? block.arity : -1))
+          result = instance_exec(*args, &block)
+          return false if result == false
         end
+
+        true
+      end
+
+      def halt!(*args)
+        value = args.size == 0 ? false : args.shift
+        throw(:halt, value)
       end
     end
   end

data/test/wrap_test.rb

@@ -1,6 +1,8 @@
 
 Testing Wrap do
 
+##
+#
   testing 'that wrap can be included in a class' do
     assert do
       Class.new do
@@ -9,7 +11,25 @@ Testing Wrap do
     end
   end
 
-  testing 'that a method can be wrapped before it is defined' do
+##
+#
+  testing 'that a method can be wrapped ***after*** it is defined' do
+    assert do
+      wrapped_class do
+        def foo() 42 end
+
+        assert{ new.foo() == 42 }
+
+        wrap :foo
+
+        assert{ new.foo() == 42 }
+      end
+    end
+  end
+
+##
+#
+  testing 'that a method can be wrapped ***before*** it is defined' do
     assert do
       wrapped_class do
         assert_raises(NoMethodError){ new.foo() }
@@ -21,20 +41,173 @@ Testing Wrap do
     end
   end
 
-  testing 'that a method can be wrapped after it is defined' do
+##
+#
+  testing 'that wrapping gives :before and :after goodness' do
     assert do
       wrapped_class do
-        def foo() 42 end
+        wrap :foo
 
-        assert{ new.foo() == 42 }
+        define_method(:foo){ accum.push(42) }
+
+        before(:foo){ accum.push(:before) }
+        after(:foo){ accum.push(:after) }
+
+        assert {
+          c = new
+          c.foo()
+          c.accum == [:before, 42, :after]
+        }
+      end
+    end
+  end
 
+##
+#
+  testing 'that callbacks are halted with "false" iff they return "false"' do
+    assert do
+      wrapped_class do
         wrap :foo
 
-        assert{ new.foo() == 42 }
+        define_method(:foo){ accum.push(42) }
+
+        before(:foo){ accum.push(:foo) }
+        before(:foo){ accum.push(:bar); return false}
+        before(:foo){ accum.push(:foobar) }
+
+        assert {
+          c = new
+          c.foo()
+          c.accum == [:foo, :bar]
+        }
+      end
+    end
+  end
+
+##
+#
+  testing 'that callbacks can be halted with "halt!"' do
+    assert do
+      wrapped_class do
+        wrap :foo
+
+        define_method(:foo){ accum.push(42) }
+
+        before(:foo){ accum.push(:foo) }
+        before(:foo){ accum.push(:bar); halt!}
+        before(:foo){ accum.push(:foobar) }
+
+        assert {
+          c = new
+          c.foo()
+          c.accum == [:foo, :bar]
+        }
+      end
+    end
+
+    assert do
+      wrapped_class do
+        wrap :foo
+
+        define_method(:foo){ accum.push(42) }
+
+        after(:foo){ accum.push(:foo) }
+        after(:foo){ accum.push(:bar); halt!}
+        after(:foo){ accum.push(:foobar) }
+
+        assert {
+          c = new
+          c.foo()
+          c.accum == [42, :foo, :bar]
+        }
       end
     end
   end
 
+##
+#
+  testing 'that :before callbacks are passed the number of args they can eat, and no more' do
+    c =
+      assert do
+        wrapped_class do
+          wrap :foo
+
+          define_method(:foo){|*a|}
+
+          before(:foo){|x| accum.push([x]) }
+          before(:foo){|x,y| accum.push([x,y]) }
+          before(:foo){|x,y,z| accum.push([x,y,z]) }
+        end
+      end
+    
+    assert do
+      o = c.new
+      o.foo(1,2,3)
+      assert o.accum === [[1], [1,2], [1,2,3]]
+      true
+    end
+  end
+
+##
+#
+  testing 'that :after callbacks are passed result of the method they follow, iff possible' do
+    c =
+      assert do
+        wrapped_class do
+          wrap :foo
+
+          define_method(:foo){ result = [1,2,3] }
+
+          after(:foo){ accum.push(:nada) }
+          after(:foo){|result| accum.push(result) }
+        end
+      end
+    
+    assert do
+      o = c.new
+      o.foo()
+      assert o.accum === [:nada, [1,2,3]]
+      true
+    end
+  end
+
+##
+#
+  testing 'that callbacks are inherited cleverly' do
+    c =
+      assert do
+        wrapped_class do
+          wrap :foo
+
+          define_method(:foo){}
+
+          before(:foo){ accum.push(:before_superclass) }
+          after(:foo){ accum.push(:after_superclass) }
+        end
+      end
+
+    assert do
+      o = c.new
+      o.foo()
+      assert o.accum === [:before_superclass, :after_superclass]
+    end
+
+    b =
+      assert do
+        Class.new(c) do
+          before(:foo){ accum.push(:before_subclass) }
+          after(:foo){ accum.push(:after_subclass) }
+        end
+      end
+
+    assert do
+      o = b.new
+      o.foo()
+      assert o.accum === [:before_superclass, :before_subclass,    :after_subclass, :after_superclass]
+    end
+  end
+
+
 private
   def wrapped_class(&block)
     tc = self
@@ -54,6 +227,10 @@ private
           end
         end
 
+        def accum
+          @accum ||= []
+        end
+
         module_eval(&block)
       end
 

data/wrap.gemspec

@@ -3,13 +3,14 @@
 
 Gem::Specification::new do |spec|
   spec.name = "wrap"
-  spec.version = "0.4.2"
+  spec.version = "0.4.3"
   spec.platform = Gem::Platform::RUBY
   spec.summary = "wrap"
   spec.description = "description: wrap kicks the ass"
 
   spec.files =
-["Rakefile",
+["README",
+ "Rakefile",
  "lib",
  "lib/wrap",
  "lib/wrap.rb",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wrap
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-27 00:00:00.000000000 Z
+date: 2011-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: map
-  requirement: &70233826961320 !ruby/object:Gem::Requirement
+  requirement: &70328097412480 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,13 +21,14 @@ dependencies:
         version: 4.7.1
   type: :runtime
   prerelease: false
-  version_requirements: *70233826961320
+  version_requirements: *70328097412480
 description: ! 'description: wrap kicks the ass'
 email: ara.t.howard@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- README
 - Rakefile
 - lib/wrap.rb
 - test/testing.rb