contextr 0.1.9 → 1.0.0

data/lib/contextr/class_methods.rb

@@ -9,9 +9,9 @@ module ContextR # :nodoc:
     end
 
     def stored_module_definitions
-      @stored_module_definitions ||= Hash.new do |hash, key|
-        hash[key] = Hash.new do |hash, key|
-          hash[key] = Module.new
+      @stored_module_definitions ||= Hash.new do |layer_hash, layer|
+        layer_hash[layer] = Hash.new do |extended_modules_hash, x_module|
+          extended_modules_hash[x_module] = Module.new
         end
       end
     end
@@ -40,17 +40,25 @@ module ContextR # :nodoc:
       if stack.size == 1
         stack.pop.call(*arguments, &block)
       else
-        stack.pop.__send__(method_name, *arguments) do | action, *rest_args |
+        stack.pop.__send__(method_name, *arguments) do |action, *rest_args|
           case action
           when :receiver
             receiver
           when :block
+            block
+          when :block!
             block.call(*rest_args)
+          when :block=
+            block = rest_args.first
+          when :block_given?
+            !block.nil?
           when :next
+            rest_args.shift unless method_name == :method_missing
             call_methods_stack(stack, receiver, method_name, rest_args, block)
           else 
-            raise ArgumentError.new("Use only :receiver, :block or :next " +
-                                    "as first argument.")
+            raise ArgumentError, "Use only :receiver, :block, :block_given?, " +
+                                 ":block!, :block=, or :next " +
+                                 "as first argument."
           end
         end
       end

data/lib/contextr/core_ext/module.rb

@@ -27,10 +27,11 @@ class Module
   def in_layer(layer_symbol, &block)
     extension = ContextR::stored_module_definitions[layer_symbol][self]
 
-    extension.module_eval(&block) if block_given?
+    return_value = extension.module_eval(&block) if block_given?
 
     ContextR::layer_by_symbol(layer_symbol).add_method_collection(self, 
                                                                   extension) 
-    extension
+
+    block_given? ? return_value : extension
   end
 end

data/lib/contextr/event_machine.rb

@@ -52,20 +52,20 @@ module ContextR
       end
 
       def observe_method_added(modul)
-        modul.class_eval(%Q{
-          def self.method_added_with_contextr_listener(name)
-            ContextR::EventMachine::on_method_added(self, name)
-            method_added_without_contextr_listener(name)
-          end
-          unless self.methods.include? "method_added"
-            def self.method_added(name); end
-          end
-          class << self
-            alias_method_chain(:method_added, :contextr_listener)
-          end
-        }, __FILE__, __LINE__)
+        modul.extend(ContextRListener)
       end
     end
     self.extend(ClassMethods)
+
+    module ContextRListener
+      def method_added(name)
+        ContextR::EventMachine::on_method_added(self, name)
+        super
+      end
+      def include(modul)
+        modul.instance_method.each { |m| method_added(m) }
+        super
+      end
+    end
   end
 end

data/lib/contextr/inner_class.rb

@@ -13,7 +13,7 @@ module ContextR
       # hide +instance_eval+ or any method beginning with "__".
       def hide(name)
         if instance_methods.include?(name.to_s) and
-          name !~ /^(__|instance_eval)/
+          name !~ /^(__|extend)/
           @hidden_methods ||= {}
           @hidden_methods[name.to_sym] = instance_method(name)
           undef_method name
@@ -40,8 +40,12 @@ module ContextR
     
     instance_methods.each { |m| hide(m) }
 
-    def method_missing(method_name, *rest_args)
-      yield(:next, *rest_args)
+    def method_missing(*rest_args)
+      if block_given?
+        yield(:next, *rest_args)
+      else
+        super
+      end
     end
   end
 end

data/lib/contextr/layer.rb

@@ -1,5 +1,17 @@
 module ContextR # :nodoc:
-  class Layer # :nodoc: all
+  class Layer
+    def activated
+      nil
+    end
+    def deactivated
+      nil
+    end
+    def inspect
+      "ContextR::layer(:#{ContextR::symbol_by_layer(self)})"
+    end
+    alias_method :to_s, :inspect
+
+  # :nodoc: all
     def definitions
       @definitions ||= {}
     end
@@ -38,11 +50,9 @@ module ContextR # :nodoc:
 
     def context_proxy_for_module(receiver, methods_module)
       proxies[methods_module] ||= begin
-        c = Class.new(ContextR::InnerClass)
-        c.class_eval(%Q{
-          include ObjectSpace._id2ref(#{methods_module.object_id})
-        }, __FILE__, __LINE__)
-        c.new
+        p = ContextR::InnerClass.new.extend(methods_module)
+        class << p; hide(:extend); end
+        p
       end
     end
 
@@ -70,7 +80,7 @@ module ContextR # :nodoc:
                                     version)
     end
 
-    def  register_callbacks(cclass, mmodule)
+    def register_callbacks(cclass, mmodule)
       {:on_wrapper_method_added => mmodule,
        :on_class_method_added   => cclass }.each do | callback, klass |
        ContextR::EventMachine.register(self, callback, 

data/lib/contextr/public_api.rb

@@ -17,8 +17,14 @@ module ContextR
     def with_layers(*layer_symbols, &block)
       layers = layer_symbols.collect do |layer_symbol|
         layer_by_symbol(layer_symbol)
-      end
-      layered_do(active_layers_as_classes - layers + layers, block)
+      end.reverse
+      layers_being_activated = layers - active_layers_as_classes
+      layers_being_activated.each { |l| l.activated }
+
+      return_value = layered_do(layers | active_layers_as_classes, block)
+
+      layers_being_activated.each { |l| l.deactivated }
+      return_value
     end
     alias with_layer with_layers
 
@@ -40,7 +46,13 @@ module ContextR
       layers = layer_symbols.collect do |layer_symbol|
         layer_by_symbol(layer_symbol)
       end
-      layered_do(active_layers_as_classes - layers, block)
+      layers_being_deactivated = layers & active_layers_as_classes
+      layers_being_deactivated.each { |l| l.deactivated }
+
+      return_value = layered_do(active_layers_as_classes - layers, block)
+
+      layers_being_deactivated.each { |l| l.activated }
+      return_value
     end
     alias without_layer without_layers
 
@@ -54,6 +66,35 @@ module ContextR
       layers_as_classes.collect { |layer| symbol_by_layer(layer) }
     end
 
+    # returns the layer, defined by the given name. If passed a block, it will
+    # instance_eval it on the layer and return its value instead. The latter
+    # may be used to define the activated and deactived methods for a layer.
+    #
+    #   ContextR::layer(:log) do
+    #     def logger
+    #       @logger ||= Logger.new
+    #     end
+    #     def activated
+    #       logger.log("Logging active")
+    #     end
+    #     def deactivated
+    #       logger.log("Logging inactive")
+    #     end
+    #   end
+    #
+    #   # will call activated before executing the block
+    #   # and deactivated afterwards
+    #   ContextR::with_layer(:log) do
+    #     1 + 1
+    #   end
+    #
+    def layer(name, &block)
+      if block_given?
+        layer_by_symbol(name).instance_eval(&block)
+      else
+        layer_by_symbol(name)
+      end
+    end
   end
   self.extend(PublicApi)
 end

data/lib/contextr/version.rb

@@ -1,8 +1,8 @@
 module ContextR #:nodoc:
   module VERSION #:nodoc:
-    MAJOR = 0
-    MINOR = 1
-    TINY  = 9
+    MAJOR = 1
+    MINOR = 0
+    TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/ext/active_support_subset.rb

@@ -1,49 +1,4 @@
 unless Object.const_defined? "ActiveSupport"
-  class Module
-    # Encapsulates the common pattern of:
-    #
-    #   alias_method :foo_without_feature, :foo
-    #   alias_method :foo, :foo_with_feature
-    #
-    # With this, you simply do:
-    #
-    #   alias_method_chain :foo, :feature
-    #
-    # And both aliases are set up for you.
-    #
-    # Query and bang methods (foo?, foo!) keep the same punctuation:
-    #
-    #   alias_method_chain :foo?, :feature
-    #
-    # is equivalent to
-    #
-    #   alias_method :foo_without_feature?, :foo?
-    #   alias_method :foo?, :foo_with_feature?
-    #
-    # so you can safely chain foo, foo?, and foo! with the same feature.
-    def alias_method_chain(target, feature)
-      # Strip out punctuation on predicates or bang methods since
-      # e.g. target?_without_feature is not a valid method name.
-      aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
-      yield(aliased_target, punctuation) if block_given?
-     
-      with_method = "#{aliased_target}_with_#{feature}#{punctuation}"
-      without_method = "#{aliased_target}_without_#{feature}#{punctuation}"
-     
-      alias_method without_method, target
-      alias_method target, with_method
-     
-      case
-        when public_method_defined?(without_method)
-          public target
-        when protected_method_defined?(without_method)
-          protected target
-        when private_method_defined?(without_method)
-          private target
-      end
-    end
-  end
-
   # The Inflector transforms words from singular to plural, class names to 
   # table names, modularized class names to ones without, and class names to 
   # foreign keys. The default inflections for pluralization, singularization, 

data/spec/contextr_spec.rb

@@ -52,6 +52,25 @@ class Ordering
   end
 end
 
+class ExceptionExample
+  def secure
+    insecure
+  rescue RuntimeError
+    "caught in secure method"
+  end
+
+  def insecure
+    raise "insecure action failed"
+  end
+
+  in_layer :security do
+    def insecure
+      super
+    rescue RuntimeError
+      "caught in security layer"
+    end
+  end
+end
 
 describe "A contextified object" do
   before do
@@ -77,19 +96,19 @@ describe "A contextified object" do
   end
 
   it "should show specific behaviour down the whole stack for all layers" do
-    ContextR::with_layers :education, :address do
+    ContextR::with_layers :address, :education do
       @student.to_s.should == "Gregor Schmidt (Berlin), HPI (Potsdam)"
     end
   end
 
   it "should take care of layer activation odering" do
-    ContextR::with_layers :education do
-      ContextR::with_layers :address do
+    ContextR::with_layers :address do
+      ContextR::with_layers :education do
         @student.to_s.should == "Gregor Schmidt (Berlin), HPI (Potsdam)"
       end
     end
-    ContextR::with_layers :address do
-      ContextR::with_layers :education do
+    ContextR::with_layers :education do
+      ContextR::with_layers :address do
         @student.to_s.should == "Gregor Schmidt, HPI (Potsdam) (Berlin)"
       end
     end
@@ -97,9 +116,9 @@ describe "A contextified object" do
 
   it "should avoid double activation, but update ordering" do
     ContextR::with_layers :education, :address do
-      ContextR::active_layers.should == [:education, :address]
+      ContextR::active_layers.should == [:address, :education]
       ContextR::with_layer :education do
-        ContextR::active_layers.should == [:address, :education]
+        ContextR::active_layers.should == [:education, :address]
       end
     end
   end
@@ -219,4 +238,75 @@ describe "ContextR" do
       ContextR::layers.sort_by{ |s| s.to_s }.should include(layer)
     end
   end
+
+  it "should return a layer on #layer(:name)" do
+    ContextR::layer(:log).should == ContextR::layer_by_symbol(:log)
+  end
+  it "should execute the block given to #layer(:name)" do
+    lambda do
+      ContextR::layer(:log) do
+        def moo
+          "moo"
+        end
+      end.should == nil 
+    end.should_not raise_error
+
+    ContextR::layer(:log).moo == "moo"
+  end
+
+  it "should execute activated for all layers on activation" do
+    ContextR::layer(:log) do
+      def activated 
+        raise "activated"
+      end
+    end
+
+    lambda do
+      ContextR::with_layer(:log) { 1 + 1 }
+    end.should raise_error(RuntimeError, "activated")
+
+    ContextR::layer(:log) do
+      def activated 
+        nil 
+      end
+    end
+  end
+
+  it "should execute deactivated for all layers on deactivation" do
+    ContextR::layer(:log) do
+      def deactivated 
+        raise "deactivated"
+      end
+    end
+
+    lambda do
+      ContextR::with_layer(:log) { 1 + 1 }
+    end.should raise_error(RuntimeError, "deactivated")
+
+    ContextR::layer(:log) do
+      def deactivated 
+        nil 
+      end
+    end
+  end
+end
+
+describe "ContextR" do
+  it "should propagate exceptions into outer layers first" do
+
+    instance = ExceptionExample.new
+
+    instance.secure.should == "caught in secure method"
+
+    ContextR::with_layer :security do
+      instance.secure.should == "caught in security layer"
+    end
+  end
+end
+
+describe ContextR::Layer do
+  it "should give a nice, self-referencing output on inspect and to_s" do
+    eval(ContextR::layer(:log).inspect).should == ContextR::layer(:log)
+    eval(ContextR::layer(:log).to_s).should == ContextR::layer(:log)
+  end
 end

data/test/{test_class_side.mkd → class_side.mkd}

@@ -1,5 +1,3 @@
-**TODO: Update to use new in\_layer API**
-
 In Ruby there are multiple ways of defining behaviour on the class side. That
 are messages that are send to the class, not to the instance. Class side 
 behaviour is often useful for functional methods, i.e. methods that do not
@@ -128,8 +126,6 @@ different methods of defining class side behaviour.
 Using `def self.method_name`
 ----------------------------
 
-**TODO: Allow def self.method\_name to add class side behaviour**
-
 Okay, we won't get rid of the modules, used to encapsulate the 
 context-dependent behaviour, so the extension is a bit noisier, than the 
 basic notation.
@@ -144,9 +140,8 @@ basic notation.
       end
     end
 
-But we can use the same principles, like we did for the instance side. Simply
-use a hash to tell extend, that the module should only be used in a certain
-layer.
+But we can use the same principles, like we did for the instance side - just in
+side the singleton class.
 
     example do
       result_of(SimpleMath.pi) == 3.14159265
@@ -170,9 +165,7 @@ manage the extension.
             "Euler's constant"
           end
         end
-      end
 
-      class << self
         in_layer :german do
           def e
             "Eulersche Zahl"
@@ -196,12 +189,12 @@ manage the extension.
 Using a module
 --------------
 
-Hey, this is what we did all the time, so it is only natural to have the same
-syntax to extend a class using in module for context-dependent behaviour. But
-for the sake of completeness, I will attach another example.
+It is only natural to have the same syntax to extend a class using in module 
+for context-dependent behaviour. But for the sake of completeness, I will 
+attach another example.
 
     class SimpleMath
-      class << self
+      module ClassMethods
         in_layer :exact_computation do
           def golden_ratio
             sleep(0.01) # In real life this would take a bit longer,