contextr 0.0.3 → 0.1.0

data/lib/core_ext/module.rb

@@ -1,62 +0,0 @@
-class Module
-  # returns the name without namespace prefixes
-  #
-  #   module A
-  #     module B
-  #       module C
-  #       end
-  #     end
-  #   end
-  #   module C
-  #   end
-  #
-  #   A::B::C.name  # => "A::B::C"
-  #   C.name        # => "C"
-  #   A::B::C.namespace_free_name # => "C"
-  #   C.namespace_free_name       # => "C"
-  #
-  def namespace_free_name
-    self.name.match( /(\w*?)$/ )[1]
-  end
-
-  # allows the definition of an attr_accessor with a setter, that is used
-  # to set the instance variable if it is accessed before set.
-  #
-  #   class A
-  #     attr_accessor_with_default_setter :first_access { Time.now }
-  #   end
-  #  
-  #   A.new.first_access # => Wed May 09 18:23:36 0200 2007
-  #
-  #   a1 = A.new
-  #   a1.first_access    # => Wed May 09 18:23:38 0200 2007
-  #   a1.first_access    # => Wed May 09 18:23:38 0200 2007
-  #
-  #   a2 = A.new
-  #   a2.first_access = Time.now - 10.days
-  #   a2.first_access    # => Sun Apr 29 18:23:40 0200 2007
-  #
-  # :call-seq:
-  #   attr_accessor_with_default_setter(symbol, ...) { ... }
-  #
-  def attr_accessor_with_default_setter( *syms ) 
-    raise 'Default value in block required' unless block_given?
-    syms.each do | sym |
-      module_eval do
-        attr_writer( sym )
-        define_method( sym ) do | |
-          class << self; self; end.class_eval do 
-            attr_reader( sym )
-          end
-
-          if instance_variables.include? "@#{sym}"
-            instance_variable_get( "@#{sym}" )
-          else
-            instance_variable_set( "@#{sym}", yield )
-          end
-        end
-      end
-    end
-    nil
-  end
-end

data/lib/core_ext/proc.rb

@@ -1,53 +0,0 @@
-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( :_um_from_proc, &proc_object )
-    end
-
-    unbound_method = klass.instance_method( :_um_from_proc )
-
-    klass.class_eval do
-      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 |
-      this_proc.call( *arguments )
-      other_proc.call( *arguments )
-    end
-  end
-end

data/lib/ext/method_nature.rb

@@ -1,80 +0,0 @@
-# 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/rake/group_spec_task.rb

@@ -1,7 +0,0 @@
-class GroupSpecTask < Spec::Rake::SpecTask
-  def initialize(group)
-    super(group) do |t|
-      t.spec_files = FileList["spec/#{group}/*_spec.rb"]
-    end
-  end
-end

data/rake/specific_group_spec_task.rb

@@ -1,7 +0,0 @@
-class SpecificGroupSpecTask < Spec::Rake::SpecTask
-  def initialize(task, group)
-    super(task) do |t|
-      t.spec_files = FileList["spec/#{group}/#{task}_spec.rb"]
-    end
-  end
-end

data/spec/contextr/contextr_api_spec.rb

@@ -1,126 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-class ContextRApiFoo
-  def non_contextified_method
-    "non_contextified_method"
-  end
-  def foo
-    "foo"
-  end
-end
-
-describe 'Each class' do
-  it 'should provide a method to enable a single layer' do
-    lambda do
-      class ContextRApiFoo 
-        layer :bar
-      end
-    end.should_not raise_error
-  end
-
-  it 'should provide a method to access these layers by name' do
-    begin
-      class ContextRApiFoo
-        bar
-      end
-    end.layer.should == ContextR::BarLayer
-  end
-end
-
-describe 'Each layer in a class' do
-  it 'should allow the definition of pre method wrappers ' +
-          'with `pre`' do
-    lambda do
-      class ContextRApiFoo
-        bar.pre :foo do
-          @pre_visited = true
-          @pre_count = ( @pre_count || 0 ) + 1
-        end
-      end
-    end.should_not raise_error
-  end
-  it 'should allow the definition of post method wrappers ' +
-          'with `post`' do
-    lambda do
-      class ContextRApiFoo
-        bar.post :foo do
-          @post_visited = true
-          @post_count = ( @post_count || 0 ) + 1
-        end
-      end
-    end.should_not raise_error
-  end
-  it 'should allow the definition of around method wrappers ' +
-          'with `around`' do
-    lambda do
-      class ContextRApiFoo
-        bar.around :foo do | method_nature |
-          @around_visited = true
-          @around_count = ( @around_count || 0 ) + 1
-          method_nature.call_next
-        end
-      end
-    end.should_not raise_error
-  end
-  it 'should allow the definition of around method wrappers ' +
-          'with `wrap`' do
-    lambda do
-      class ContextRApiFoo
-        bar.wrap :foo do | method_nature |
-          @around_visited = true
-          @around_count = ( @around_count || 0 ) + 1
-          method_nature.call_next
-        end
-      end
-    end.should_not raise_error
-  end
-end
-
-describe ContextR do
-  it "should activate layers with activate_layers" do
-    ContextR::activate_layers :foo
-    ContextR::current_layers.should include(:foo)
-  end
-
-  it "should activate multiple layers wiht activate_layers" do
-    ContextR::activate_layers :bar, :baz
-    ContextR::current_layers.should include(:foo)
-    ContextR::current_layers.should include(:bar)
-    ContextR::current_layers.should include(:baz)
-  end
-
-  it "should deactivate layers with activate_layers" do
-    ContextR::deactivate_layers :bar
-    ContextR::current_layers.should_not include(:bar)
-    ContextR::current_layers.should include(:foo)
-    ContextR::current_layers.should include(:baz)
-  end
-
-  it "should deactivate multiple layers wiht activate_layers" do
-    ContextR::deactivate_layers :foo, :baz
-    ContextR::current_layers.should_not include(:bar)
-    ContextR::current_layers.should_not include(:foo)
-    ContextR::current_layers.should_not include(:baz)
-  end
-
-  it "should allow the registration of context sensors" do
-    lambda do
-      ContextR::add_context_sensor do
-        [:foo]
-      end
-    end.should_not raise_error
-  end
-
-  it "should allow the use of with_current_context and use the sensors to " +
-     "compute it" do
-    ContextR::add_context_sensor do
-      [:bar]
-    end
-    lambda do
-      ContextR::with_current_context do
-        ContextR::current_layers.should include(:foo)
-        ContextR::current_layers.should include(:bar)
-      end
-    end.should_not raise_error
-  end
-end

data/spec/contextr/contextr_class_side_spec.rb

@@ -1,77 +0,0 @@
-require File.dirname(__FILE__) + "/../spec_helper.rb"
-
-class ContextRClassSide
-  class << self
-    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
-end
-
-describe "A contextified class" do
-  it "should run a simple method " + 
-          "*normally* when all layers are deactivated" do
-    ContextRClassSide.non_contextified_method.should == 
-        "non_contextified_method"
-  end
-
-  it "should run a simple method " +
-          "*normally* when any layer is activated" do
-    ContextR.with_layers( :simple_wrappers ) do
-      ContextRClassSide.non_contextified_method.should == 
-          "non_contextified_method"
-    end
-  end
-
-  %w{pre post around}.each do | qualifier |
-    it "should run a #{qualifier}-ed method " +
-            "*normally* when all layers are deactivated" do
-      ContextRClassSide.send( "#{qualifier}_wrapped_method" ).should == 
-            "#{qualifier}_wrapped_method"
-      ContextRClassSide.instance_variables.should_not include( 
-            "@#{qualifier}_wrapped_method_called" )
-    end
-
-    it "should run a #{qualifier}-ed method " +
-            "*normally* when any layer is activated" do
-      ContextR.with_layers( :dummy ) do
-        ContextRClassSide.send( "#{qualifier}_wrapped_method" ).should == 
-              "#{qualifier}_wrapped_method"
-        ContextRClassSide.instance_variables.should_not include( 
-              "@#{qualifier}_wrapped_method_called" )
-      end
-    end
-
-    it "should run a #{qualifier}-ed method with " +
-            "additional behaviour when a specific layer is activated" do
-      ContextR.with_layers( :simple_wrappers ) do
-        ContextRClassSide.send( "#{qualifier}_wrapped_method" ).should == 
-              "#{qualifier}_wrapped_method"
-        ContextRClassSide.instance_variables.should include( 
-              "@#{qualifier}_wrapped_method_called" )
-      end
-    end
-  end
-end

data/spec/contextr/contextr_functional_spec.rb

@@ -1,293 +0,0 @@
-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
-describe "An instance of a contextified class" do
-  before do
-    @instance = SimpleWrapperClass.new
-  end
-
-  it "should run a simple method " + 
-          "*normally* when all layers are deactivated" do
-    @instance.non_contextified_method.should == "non_contextified_method"
-  end
-
-  it "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 |
-    it "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
-
-    it "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
-
-    it "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
-
-    it "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 |
-  describe "#{qualifier.capitalize} wrappers within a method" do
-    before do
-      @instance = NestedLayerActivationClass.new
-    end
-    it "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
-    it "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
-
-    it "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
-
-    it "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