contextr 0.0.1 → 0.0.2

data/lib/core_ext/proc.rb

@@ -1,22 +1,48 @@
 class Proc
+
+  # Returns the Proc converted to an UnboundMethod within the the given Class
+  #
+  #   class A
+  #     def a
+  #       "a"
+  #     end
+  #   end
+  #
+  #   um_a = A.instance_method( :a )   # => #<UnboundMethod: A#a>
+  #   um_a.bind( A.new ).call          # => "a"
+  #
+  #   b = lambda do "b" end
+  #   um_b = b.to_unbound_method( A )  # => #<UnboundMethod: A#_um_from_proc>
+  #   um_b.bind( A.new ).call          # => "b"
+  #
   def to_unbound_method( klass )
     raise ArgumentError.new( "Only class objects allowed in parameter list" 
                                   ) unless klass.kind_of?( Class )
 
     proc_object = self
     klass.class_eval do
-      define_method( :_tmp_method_from_proc, &proc_object )
+      define_method( :_um_from_proc, &proc_object )
     end
 
-    unbound_method = klass.instance_method( :_tmp_method_from_proc )
+    unbound_method = klass.instance_method( :_um_from_proc )
 
     klass.class_eval do
-      undef_method( :_tmp_method_from_proc )
+      undef_method( :_um_from_proc )
     end
 
     unbound_method
   end
 
+  # joins to blocks into a new one, that forwards on excution the given 
+  # arguments.
+  #
+  #   a = lambda do print "a" end
+  #   b = lambda do print "b" end
+  #
+  #   ab = a + b
+  #
+  #   ab.call  # => "ab"
+  #
   def +( other_proc )
     this_proc = self
     lambda do | *arguments |

data/{ext → lib/ext}/dynamic.rb

@@ -1,3 +1,13 @@
+# This library was created by Christian Neukirchen in the context of 
+# EuRuKo 2005 and is licensed under the same terms as Ruby.
+#
+# It provides dynamically scoped variables. It is used within ContextR to 
+# store the current, thread-wide activated layers.
+#
+# For more information see the corresponding slides at
+# http://chneukirchen.org/talks/euruko-2005/chneukirchen-euruko2005-contextr.pdf
+#
+# (c) 2005 - Christian Neukirchen - http://chneukirchen.org
 module Dynamic
   class << self
     Thread.main[:DYNAMIC] = Hash.new { |hash, key|

data/lib/ext/method_nature.rb

@@ -0,0 +1,80 @@
+# This class was created by Christian Neukirchen in the context of 
+# EuRuKo 2005 and is licensed under the same terms as Ruby.
+#
+# It is used within ContextR to provide an interface to manipulate the calling
+# context within a method wrapper.
+#
+# For more information see the corresponding slides at
+# http://chneukirchen.org/talks/euruko-2005/chneukirchen-euruko2005-contextr.pdf
+#
+# (c) 2005 - Christian Neukirchen - http://chneukirchen.org
+#
+# ---
+#
+# It provides access
+# [+arguments+] to read and manipulate method's arguments.
+# [+return_value+] to read and manipulate the method's return value
+#
+class MethodNature < Struct.new(:arguments, :return_value, :break, :block)
+
+  # stops the execution of the following method wrappers and potentially the 
+  # core method.
+  #
+  #   class A
+  #     def a
+  #       "a"
+  #     end
+  #
+  #     layer :foo
+  #
+  #     foo.pre :a do | method_nature |
+  #       method_nature.break! "b"
+  #     end
+  #   end
+  #
+  #   A.new.a                        # => "a"
+  #   ContextR::with_layers :foo do
+  #     A.new.a                      # => "b"
+  #   end
+  #
+  # If it is called without parameter, the return value will not be changed.
+  #
+  # :call-seq:
+  #   break!
+  #   break!( return_value )
+  #
+  def break!( *value )
+    self.break = true
+    self.return_value = value.first unless value.empty?
+  end
+
+  # calls the next wrapper with an around method. It corresponds to a super call
+  # in an inheritance hierarchy.
+  #
+  # The example attaches to each method in the class A an around wrapper which 
+  # logs access.
+  #
+  #   class A
+  #     def a
+  #       "a"
+  #     end
+  #
+  #     layer :log
+  #
+  #     instance_methods.each do | method |
+  #
+  #       log.around method.to_sym do | method_nature |
+  #         logger.info "before #{self.class}##{method}"
+  #
+  #         method_nature.call_next
+  #
+  #         logger.info "after #{self.class}##{method}"
+  #       end
+  #     end
+  #
+  #   end
+  #
+  def call_next
+    block.call( *arguments )
+  end
+end

data/spec/contextr/contextr_api_spec.rb

@@ -76,42 +76,3 @@ context 'Each layer in a class' do
   end
 end
 
-context "An instance of a contextified class" do
-  setup do
-    @instance = ContextRApiFoo.new
-  end
-
-  specify "should run a simple method " + 
-          "*normally* when all layers are deactivated" do
-    @instance.non_contextified_method.should == "non_contextified_method"
-  end
-
-  specify "should run a simple method " +
-          "*normally* when any layer is activated" do
-    ContextR.with_layers( :bar ) do
-      @instance.non_contextified_method.should == "non_contextified_method"
-    end
-  end
-
-  specify "should run a contextified method " +
-          "*normally* when all layers are deactivated" do
-    @instance.foo.should == "foo"
-  end
-
-  specify "should run a contextified method " +
-          "*normally* when any layer is activated" do
-    ContextR.with_layers( :baz ) do
-      @instance.foo.should == "foo"
-    end
-  end
-
-  specify "should run a contextified method with " +
-          "additional behaviour when a specific layer is activated" do
-    ContextR.with_layers( :bar ) do
-      @instance.foo.should == "foo"
-    end
-    @instance.instance_variable_get( :@pre_visited ).should == true
-    @instance.instance_variable_get( :@post_visited ).should == true
-    @instance.instance_variable_get( :@around_visited ).should == true
-  end
-end

data/spec/contextr/contextr_functional_spec.rb

@@ -0,0 +1,294 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+class SimpleWrapperClass
+  def non_contextified_method
+    "non_contextified_method"
+  end
+  def pre_wrapped_method
+    "pre_wrapped_method"
+  end
+  def post_wrapped_method
+    "post_wrapped_method"
+  end
+  def around_wrapped_method
+    "around_wrapped_method"
+  end
+
+  layer :simple_wrappers, :dummy
+
+  simple_wrappers.pre :pre_wrapped_method do
+    @pre_wrapped_method_called = true
+  end
+  simple_wrappers.post :post_wrapped_method do
+    @post_wrapped_method_called = true
+  end
+  simple_wrappers.around :around_wrapped_method do | n |
+    @around_wrapped_method_called = true
+    n.call_next
+  end
+end
+context "An instance of a contextified class" do
+  setup do
+    @instance = SimpleWrapperClass.new
+  end
+
+  specify "should run a simple method " + 
+          "*normally* when all layers are deactivated" do
+    @instance.non_contextified_method.should == "non_contextified_method"
+  end
+
+  specify "should run a simple method " +
+          "*normally* when any layer is activated" do
+    ContextR.with_layers( :simple_wrappers ) do
+      @instance.non_contextified_method.should == "non_contextified_method"
+    end
+  end
+
+  %w{pre post around}.each do | qualifier |
+    specify "should run a #{qualifier}-ed method " +
+            "*normally* when all layers are deactivated" do
+      @instance.send( "#{qualifier}_wrapped_method" ).should == 
+            "#{qualifier}_wrapped_method"
+      @instance.instance_variables.should_not_include( 
+            "@#{qualifier}_wrapped_method_called" )
+    end
+
+    specify "should run a #{qualifier}-ed method " +
+            "*normally* when any layer is activated" do
+      ContextR.with_layers( :dummy ) do
+        @instance.send( "#{qualifier}_wrapped_method" ).should == 
+              "#{qualifier}_wrapped_method"
+        @instance.instance_variables.should_not_include( 
+              "@#{qualifier}_wrapped_method_called" )
+      end
+    end
+
+    specify "should run a #{qualifier}-ed method with " +
+            "additional behaviour when a specific layer is activated" do
+      ContextR.with_layers( :simple_wrappers ) do
+        @instance.send( "#{qualifier}_wrapped_method" ).should == 
+              "#{qualifier}_wrapped_method"
+        @instance.instance_variables.should_include( 
+              "@#{qualifier}_wrapped_method_called" )
+      end
+    end
+
+    specify "should run a #{qualifier}-ed method without additional " +
+            "behaviour when a specific layer is activated and afterwards " + 
+            "deactivated" do
+      ContextR.with_layers( :simple_wrappers ) do
+        ContextR.without_layers( :simple_wrappers ) do
+          @instance.send( "#{qualifier}_wrapped_method" ).should == 
+                "#{qualifier}_wrapped_method"
+          @instance.instance_variables.should_not_include( 
+                "@#{qualifier}_wrapped_method_called" )
+        end
+      end
+    end
+  end
+end
+
+class NestedLayerActivationClass
+  attr_accessor :execution
+  def initialize
+    @execution = []
+  end
+
+  def preed_method
+    @execution << "core"
+    "preed_method"
+  end
+
+  def posted_method
+    @execution << "core"
+    "posted_method"
+  end
+
+  def arounded_method
+    @execution << "core"
+    "arounded_method"
+  end
+
+  layer :outer_layer, :inner_layer
+
+  inner_layer.pre :preed_method do
+    @execution << "inner_layer"
+  end
+
+  outer_layer.pre :preed_method do
+    @execution << "outer_layer"
+  end
+
+  inner_layer.post :posted_method do
+    @execution << "inner_layer"
+  end
+
+  outer_layer.post :posted_method do
+    @execution << "outer_layer"
+  end
+
+  inner_layer.around :arounded_method do | n |
+    @execution << "inner_layer_pre"
+    n.call_next
+    @execution << "inner_layer_post"
+  end
+
+  outer_layer.around :arounded_method do | n |
+    @execution << "outer_layer_pre"
+    n.call_next
+    @execution << "outer_layer_post"
+  end
+
+  def contextualized_method
+    @execution << "core"
+    "contextualized_method"
+  end
+
+  layer :break_in_pre, :break_in_post, :break_in_around
+  layer :other_layer
+
+  break_in_pre.pre :contextualized_method do | n |
+    n.return_value = "contextualized_method"
+    @execution << "breaking_pre"
+    n.break!
+  end
+  break_in_post.post :contextualized_method do | n |
+    @execution << "breaking_post"
+    n.break!
+  end
+  break_in_around.around :contextualized_method do | n |
+    @execution << "breaking_around"
+    n.return_value = "contextualized_method"
+    n.break!
+    n.call_next
+  end
+
+  other_layer.pre :contextualized_method do | n |
+    @execution << "other_pre"
+  end
+  other_layer.post :contextualized_method do | n |
+    @execution << "other_post"
+  end
+  other_layer.around :contextualized_method do | n |
+    @execution << "other_around"
+    n.call_next
+  end
+
+  layer :multiple_pres, :multiple_posts, :multiple_arounds
+  multiple_pres.pre :contextualized_method do
+    @execution << "first_pre"
+  end
+  multiple_pres.pre :contextualized_method do
+    @execution << "second_pre"
+  end
+
+  multiple_posts.post :contextualized_method do
+    @execution << "first_post"
+  end
+  multiple_posts.post :contextualized_method do
+    @execution << "second_post"
+  end
+
+  multiple_arounds.around :contextualized_method do | n |
+    @execution << "first_around_pre"
+    n.call_next
+    @execution << "first_around_post"
+  end
+  multiple_arounds.around :contextualized_method do | n |
+    @execution << "second_around_pre"
+    n.call_next
+    @execution << "second_around_post"
+  end
+end
+
+pre_spec = lambda do | instance |
+  instance.execution.shift.should == "outer_layer"
+  instance.execution.shift.should == "inner_layer"
+  instance.execution.shift.should == "core"
+end
+post_spec = lambda do | instance |
+  instance.execution.shift.should == "core"
+  instance.execution.shift.should == "inner_layer"
+  instance.execution.shift.should == "outer_layer"
+end
+around_spec = lambda do | instance |
+  instance.execution.shift.should == "outer_layer_pre"
+  instance.execution.shift.should == "inner_layer_pre"
+  instance.execution.shift.should == "core"
+  instance.execution.shift.should == "inner_layer_post"
+  instance.execution.shift.should == "outer_layer_post"
+end
+
+pre_break_spec = lambda do | instance |
+  instance.execution.shift.should == "breaking_pre"
+end
+post_break_spec = lambda do | instance |
+  instance.execution.shift.should == "other_pre"
+  instance.execution.shift.should == "other_around"
+  instance.execution.shift.should == "core"
+  instance.execution.shift.should == "other_post"
+  instance.execution.shift.should == "breaking_post"
+end
+around_break_spec = lambda do | instance |
+  instance.execution.shift.should == "other_pre"
+  instance.execution.shift.should == "breaking_around"
+end
+
+pre_multiple_spec = lambda do | instance |
+  instance.execution.shift.should == "first_pre"
+  instance.execution.shift.should == "second_pre"
+  instance.execution.shift.should == "core"
+end
+post_multiple_spec = lambda do | instance |
+  instance.execution.shift.should == "core"
+  instance.execution.shift.should == "second_post"
+  instance.execution.shift.should == "first_post"
+end
+around_multiple_spec = lambda do | instance |
+  instance.execution.shift.should == "first_around_pre"
+  instance.execution.shift.should == "second_around_pre"
+  instance.execution.shift.should == "core"
+  instance.execution.shift.should == "second_around_post"
+  instance.execution.shift.should == "first_around_post"
+end
+
+%w{pre post around}.each do | qualifier |
+  context "#{qualifier.capitalize} wrappers within a method" do
+    setup do
+      @instance = NestedLayerActivationClass.new
+    end
+    specify "should run in the sequence of nesting, when using nested " +
+            "activation" do
+      ContextR::with_layers :outer_layer do
+        ContextR::with_layers :inner_layer do
+          @instance.send( "#{qualifier}ed_method" ).should == 
+                "#{qualifier}ed_method"
+        end
+      end
+      eval("#{qualifier}_spec").call( @instance )
+    end
+    specify "should run in the sequence of nesting, when using simultaneous " +
+            "activation" do
+      ContextR::with_layers :outer_layer, :inner_layer do
+        @instance.send( "#{qualifier}ed_method" ).should == 
+              "#{qualifier}ed_method"
+      end
+      eval("#{qualifier}_spec").call( @instance )
+    end
+
+    specify "should run in the sequence of definition within the same layer" do
+      ContextR::with_layers "multiple_#{qualifier}s".to_sym do
+        @instance.contextualized_method.should == "contextualized_method"
+      end
+      eval("#{qualifier}_multiple_spec").call( @instance )
+    end
+
+    specify "should be able to stop the execution with `break!`" do
+      ContextR::with_layers "break_in_#{qualifier}".to_sym, :other_layer do
+        @instance.contextualized_method.should == "contextualized_method"
+      end
+      eval("#{qualifier}_break_spec").call( @instance )
+    end
+  end
+end
+