contextr 0.0.3 → 0.1.0

data/examples/ordering.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + "/../lib/contextr.rb"
+
+class AnyClass
+  def test
+    puts "base_method"
+  end
+
+  module InnerMethods
+    def test
+      puts "inner_pre"
+      yield(:next)
+      puts "inner_post"
+    end
+  end
+  include InnerMethods => :test
+
+  module OuterMethods
+    def test
+      puts "outer_pre"
+      yield(:next)
+      puts "outer_post"
+    end
+  end
+  include OuterMethods => :test
+end
+
+ContextR::with_layer :test do
+  AnyClass.new.test
+end

data/lib/contextr.rb

@@ -1,19 +1,19 @@
-#--
-# TODO: get rid of this workaround to avoid double loading on `rake test`
-#++
-unless Object.const_defined? "ContextR"
-  if RUBY_VERSION == "1.9.0"
-    require File.dirname(__FILE__) + '/activesupport/lib/active_support'
-  else
-    require 'rubygems'
-    require 'active_support'
-  end
+module ContextR
+end
 
-  Dir[File.join(File.dirname(__FILE__), 'ext/**/*.rb')].sort.each { |lib| require lib }
-  Dir[File.join(File.dirname(__FILE__), 'core_ext/**/*.rb')].sort.each { |lib| require lib }
-  Dir[File.join(File.dirname(__FILE__), 'contextr/**/*.rb')].sort.each { |lib| require lib }
+# vendor code by rails and Cristian Neukirchen and _why
+%w{active_support_subset dynamic}.each { |file|
+      require File.dirname(__FILE__) + "/ext/#{file}" }
+
+# modules that encapsulate certain simple aspects
+%w{mutex_code unique_id}.each { |file|
+      require File.dirname(__FILE__) + "/contextr/modules/#{file}" }
+
+# the basic library code
+%w{public_api class_methods layer 
+   event_machine core_ext version}.each { | file | 
+      require File.dirname(__FILE__) + "/contextr/#{file}" }
 
-end
 unless Dynamic.variables.include?( :layers )
-  Dynamic.variable( :layers => [ ContextR::layer_by_symbol( :default ) ] )
+  Dynamic.variable( :layers => [] )
 end

data/lib/contextr/class_methods.rb

@@ -0,0 +1,90 @@
+module ContextR
+  module ClassMethods
+    def const_missing(const_name)
+      if const_name.to_s =~ /.*Layer$/
+        self.const_set(const_name, Class.new(ContextR::Layer))
+      else
+        super
+      end
+    end
+
+    def stored_core_methods
+      @stored_core_methods ||= Hash.new do | hash, key |
+        hash[key] = Hash.new
+      end
+    end
+
+    def symbol_by_layer(lay)
+      lay.to_s.gsub( /^ContextR::(.*)Layer$/, '\1' ).underscore
+    end
+
+    def layer_by_symbol(sym)
+      "ContextR::#{sym.to_s.camelize}Layer".constantize
+    end
+
+    def call_methods_stack(stack, receiver, method_name, arguments, block)
+      if stack.size == 1
+        stack.pop.call(*arguments, &block)
+      else
+        stack.pop.send(method_name, *arguments) do | action, *rest_args |
+          case action
+          when :receiver
+            receiver
+          when :block
+            block.call(*rest_args)
+          when :next
+            call_methods_stack(stack, receiver, method_name, rest_args, block)
+          else 
+            raise ArgumentError.new("Use only :receiver, :block or :next " +
+                                    "as first argument.")
+          end
+        end
+      end
+    end
+
+    def on_core_method_called(receiver, contextified_class, 
+                              method_name, arguments, block)
+      proxies = []
+      layers.each do |layer|
+        proxies += layer.context_proxies(contextified_class, method_name)
+      end.compact 
+
+      proxies << core_proxy(receiver, contextified_class, method_name) 
+      call_methods_stack(proxies.reverse, receiver, 
+                         method_name, arguments, block)
+    end
+
+    def core_proxy(receiver, contextified_class, method_name)
+      ContextR::stored_core_methods[contextified_class][
+        method_name][:code].bind(receiver)
+    end
+
+    def observe_core_method(klass, method_name, version)
+      only_once do
+        klass.class_eval(%Q{
+            def #{method_name}(*arguments, &block)
+              ContextR::on_core_method_called(
+                self,
+                ObjectSpace._id2ref(#{klass.object_id}), 
+                :#{method_name},
+                arguments, block)
+            end
+          }, __FILE__, __LINE__) if save_core_method(klass, method_name, version)
+      end
+    end
+
+    def save_core_method(klass, method_name, version)
+      if !meta_method?(method_name) and 
+          (!stored_core_methods[klass].include?(method_name) or
+              stored_core_methods[klass][method_name][:version] < version)
+        stored_core_methods[klass][method_name] = 
+          { :version => version, :code => klass.instance_method(method_name) }
+      end
+    end
+
+    def meta_method?(method_name)
+      method_name.to_s =~ /method_added(_with(out)?_contextr_listener)?/
+    end
+  end
+  self.extend(ClassMethods)
+end

data/lib/contextr/core_ext.rb

@@ -0,0 +1,2 @@
+require File.dirname(__FILE__) + '/core_ext/object'
+require File.dirname(__FILE__) + '/core_ext/module'

data/lib/contextr/core_ext/module.rb

@@ -0,0 +1,18 @@
+class Module 
+  alias_method :include_without_layers, :include
+  def include_with_layers(associations)
+    if associations.delete(:class_side)
+      klass = class << self; self; end
+    else
+      klass = self
+    end
+    associations.each do | modul, layer |
+      ContextR::layer_by_symbol(layer).add_method_collection(klass, modul)
+    end
+  end
+
+  def include(*args)
+    args.first.is_a?(Module) ? include_without_layers(*args) : 
+                               include_with_layers(*args)
+  end
+end

data/lib/contextr/core_ext/object.rb

@@ -0,0 +1,9 @@
+class Object
+  def behavioural_class
+    if self.kind_of?(Module)
+      class << self; self; end
+    else
+      self.class
+    end
+  end
+end

data/lib/contextr/event_machine.rb

@@ -0,0 +1,71 @@
+module ContextR
+  class EventMachine
+    module ClassMethods
+      include UniqueId 
+
+      def listeners 
+        @listeners ||= { :method_added => {} }
+      end
+
+      def register(listener, callback, options)
+        observed = check_options_hash(options)
+        register_observers_on_demand(observed)
+        self.listeners[observed[:event]][observed[:module]][listener] = callback
+      end
+
+      def unregister(listener, *cumulated_options)
+        observed = check_options_hash(cumulated_options.last)
+        self.listeners[observed[:event]][observed[:module]].delete(listener)
+      end
+
+      def on_method_added(modul, name)
+        version = self.new_unique_id
+        self.listeners[:method_added][modul].each do | listener, method_name |
+          listener.send( method_name, modul, name, version )
+        end 
+      end
+
+      def check_options_hash(options)
+        observed = {}
+        observed[:event] = options[:on_event]
+        observed[:module] = options[:in_class] || options[:in_module]
+        [:event, :module].each do |key|
+          unless observed[key]
+            raise ArgumentError.new("Missing Argument in options Hash")
+          end
+        end
+        unless self.listeners.keys.include?(observed[:event])
+          raise ArgumentError.new("Unknown event `#{observed[:event]}`. " + 
+                  "Please use one of these: #{self.listeners.keys.join(', ')}")
+        end
+        observed
+      end
+
+      def register_observers_on_demand(observed)
+        unless self.listeners[observed[:event]].include?(observed[:module])
+          self.listeners[observed[:event]][observed[:module]] = {}
+          case observed[:event]
+          when :method_added
+            observe_method_added(observed[:module])
+          end
+        end
+      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__)
+      end
+    end
+    self.extend(ClassMethods)
+  end
+end

data/lib/contextr/layer.rb

@@ -1,410 +1,86 @@
 module ContextR
-  # This is the public interface of a Layer within a class definition. Use it
-  # to add context-dependent behaviour. It is available after calling 
-  # +layer <em>layer_name</em>+ within a class body via 
-  # +<em>layer_name</em>+. Each wrapper block should expect an instance of
-  # MethodNature to manipulate arguments or return values.
-  #
-  #  class Foo
-  #    layer :any
-  #
-  #    def bar
-  #      "bar"
-  #    end
-  #
-  #    any.pre :bar do | n |
-  #      logger.info "Foo#bar called"
-  #    end
-  #  end
-  class LayerInClass
-    attr_accessor :contextualized_class, :layer # :nodoc:
-
-    def initialize( contextualized_class, layer ) # :nodoc:
-      self.contextualized_class = contextualized_class 
-      self.layer = layer
-    end
-
-    # Adds a pre-wrapper to a single method.
-    #
-    # :call-seq:
-    #   pre( method_name ) { | method_nature | ... }
-    #
-    def pre( method_name, &block )
-      layer.methods_of( self.contextualized_class )[method_name].pres << 
-          block.to_unbound_method( self.contextualized_class )
-      nil
-    end
-
-    # Adds a post-wrapper to a single method
-    #
-    # :call-seq:
-    #   post( method_name ) { | method_nature | ... }
-    #
-    def post( method_name, &block )
-      layer.methods_of( self.contextualized_class )[method_name].posts <<
-          block.to_unbound_method( self.contextualized_class )
-      nil
-    end
-
-    # Adds an around-wrapper to a single method
-    #
-    # :call-seq:
-    #   around( method_name ) { | method_nature | ... }
-    #
-    def around( method_name, &block )
-      layer.methods_of( self.contextualized_class )[method_name].arounds << 
-          block.to_unbound_method( self.contextualized_class )
-      nil
-    end
-
-    alias :wrap :around
-  end
-
-  class Layer # :nodoc:
-    # its role as base instance of all layers
-    class << self
-      attr_accessor_with_default_setter :base_layers, :combined_layers do 
-        Hash.new
+  class Layer
+    module ClassMethods
+      def definitions
+        @definitions ||= {}
       end
-
-      def core_methods
-        @core_methods ||= Hash.new do | hash, extended_class |
-          add_redefine_callback( extended_class )
-          hash[extended_class] = Hash.new do | class_hash, method_name |
-            um = extended_class.instance_method( method_name )
-            replace_core_method( extended_class, method_name )
-            class_hash[method_name] = um 
-          end
-        end
+      def proxies
+        @proxies ||= {}
       end
 
-      def inherited( new_base_layer )
-        unless new_base_layer.name.nil? or new_base_layer.name.empty?
-          base_layers[ContextR::symbolize( new_base_layer )] = new_base_layer
+      def add_method_collection(contextified_class, methods_module)
+        definitions[contextified_class] ||= []
+        definitions[contextified_class] |= [methods_module]
+        (methods_module.instance_methods & 
+         contextified_class.instance_methods).each do | method_name |
+          replace_core_method(contextified_class, method_name, 0)
         end
+        register_callbacks(contextified_class, methods_module)
       end
 
-      def compose( layers )
-        # TODO: Add better caching
-        combined_layers[ layers ] ||= 
-          layers.reverse.inject( nil ) do | akku, layer |
-            layer + akku
-          end
-      end
-
-    protected
-      def replace_core_method( extended_class, method_name )
-        num_of_args = extended_class.instance_method( method_name ).arity
-        arg_signature = case num_of_args <=> 0
-        when 0
-          ""
-        when 1
-          "%s" % Array.new( num_of_args ) { |i| "arg%d" % i }.join( ", " )
-        else 
-          "*arguments"
-        end
-        arg_call = arg_signature.empty? ? "" : ", " + arg_signature
-
-        extended_class.class_eval( %Q{
-          remove_method :#{method_name}
-          def #{method_name} #{arg_signature} 
-            ContextR::current_layer.extended( self ).send(
-                :#{method_name}#{arg_call} )
-          end
-        }, __FILE__, __LINE__ )
-      end
-
-      def add_redefine_callback( extended_class )
-        (class << extended_class; self; end).instance_eval do
-          define_method( :method_added ) do | method_name |
-            if ContextR::Layer.core_methods[extended_class].
-                  include?( method_name )
-              warn( caller.first + " : ContextR - Redefining already wrapped methods is not supported yet. Your changes _may_ have no effect." )
-            end
-          end
-        end
-      end
-    end
-  end
-
-  class Layer # :nodoc:
-    # its role as base class for all other layers
-    class << self
-      attr_accessor_with_default_setter :extended_classes do 
-        Hash.new do | classes, extended_class |
-          classes[extended_class] = Hash.new do | hash, key |
-              hash[key.to_sym] = ContextualizedMethod.new( 
-                  ContextR::Layer.core_methods[ extended_class ][ key.to_sym ] )
-            end
-          end
-      end
-      attr_accessor :extended_objects
-
-      def methods_of( extended_class )
-        self.extended_classes[extended_class]
-      end
-
-      def extended( object )
-        self.extended_objects ||= Hash.new do | cache, object |
-          object_class = if object.kind_of? Class
-            (class << object; self; end)
-          else
-            object.class
+      def methods_modules_containing_method(contextified_class, method_name)
+        if definitions.include?(contextified_class)
+          definitions[contextified_class].select do | methods_module | 
+            methods_module.instance_methods.include?(method_name.to_s) 
           end
-          cache[ object ] = 
-              ExtendedObject.new( object, self.methods_of( object_class ) )
-        end
-        self.extended_objects[object]
-      end
-
-      def + other_layer
-        if other_layer.nil?
-          self
         else
-          combined_layer = Class.new( Layer )
-          combined_layer.extended_classes = self.merge_extended_classes_with( 
-                other_layer.extended_classes )
-          combined_layer
+          []
         end
       end
 
-    protected
-
-      def merge_extended_classes_with( other_ec )
-        extended_classes.merge( other_ec ) do | extended_c, my_ms, other_ms | 
-          my_ms.merge( other_ms ) do | method_name, my_cm, other_cm |
-            my_cm + other_cm
-          end
-        end
+      def context_proxies(contextified_class, method_name)
+        methods_modules_containing_method(contextified_class, method_name).
+          collect do | methods_module | 
+            context_proxy_for_module(methods_module) 
+          end.reverse
       end
-    end
-  end
-
-  class ExtendedObject # :nodoc:
-    attr_accessor :proxied_object
-    attr_accessor :extended_methods
-    attr_accessor :behaviours
-
-    def initialize( proxied_object, extended_methods )
-      self.proxied_object = proxied_object
-      self.extended_methods = extended_methods
-      self.behaviours = {}
-    end
 
-    def send( method_name, *arguments )
-      ( self.behaviours[method_name] ||=
-          self.extended_methods[method_name].behaviour( self.proxied_object ) 
-      ).call( *arguments )
-    end
-  end
-
-  class ContextualizedMethod # :nodoc:
-    attr_accessor :core
-    attr_accessor :behaviour_cache
-
-    attr_accessor_with_default_setter :pres, :posts, :arounds do 
-      Array.new
-    end
-    
-    def initialize( unbound_core_method )
-      self.core = unbound_core_method
-      self.behaviour_cache = {} 
-    end
-
-    def + other_cm
-      new_cm = ContextualizedMethod.new( self.core )
-      new_cm.pres    = self.pres    + other_cm.pres
-      new_cm.posts   = self.posts   + other_cm.posts
-      new_cm.arounds = self.arounds + other_cm.arounds
-      new_cm
-    end
-
-    def behaviour( instance )
-      self.behaviour_cache[instance] ||= 
-          self.send( self.behaviour_name, instance )
-    end
-
-    def behaviour_name
-      wrappers = []
-      wrappers << "pres" unless self.pres.empty?
-      wrappers << "arounds" unless self.arounds.empty?
-      wrappers << "posts" unless self.posts.empty?
-
-      "behaviour_" + ( wrappers.empty? ? "without_wrappers" : 
-                                         "with_" + wrappers.join( "_and_" ) )
-    end
-
-    def behaviour_without_wrappers( instance )
-      self.core.bind( instance )
-    end
-
-    def behaviour_with_pres( instance )
-      combined_pres = self.combine_pres( instance )
-      bound_core = self.bind_core( instance )
-
-      lambda do | *arguments |
-        nature = MethodNature.new( arguments, nil, false )
-
-        combined_pres.call( nature )
-        unless nature.break
-          bound_core.call( *nature.arguments )
-        else
-          nature.return_value
+      def context_proxy_for_module(methods_module)
+        proxies[methods_module] ||= begin
+          c = Class.new 
+          c.class_eval(%Q{
+            include ObjectSpace._id2ref(#{methods_module.object_id})
+          }, __FILE__, __LINE__)
+          c.new
         end
       end
-    end
-
-    def behaviour_with_posts( instance )
-      bound_core = self.bind_core( instance )
-      combined_posts = self.combine_posts( instance )
-
-      lambda do | *arguments |
-        nature = MethodNature.new( arguments, nil, false )
-
-        nature.return_value = bound_core.call( *arguments )
-        combined_posts.call( nature )
-
-        nature.return_value
-      end
-    end
-
-    def behaviour_with_pres_and_posts( instance )
-      combined_pres = self.combine_pres( instance )
-      bound_core = self.bind_core( instance )
-      combined_posts = self.combine_posts( instance )
-
-      lambda do | *arguments |
-        nature = MethodNature.new( arguments, nil, false )
 
-        combined_pres.call( nature )
-        unless nature.break
-          nature.return_value = bound_core.call( *nature.arguments )
-          combined_posts.call( nature )
+      def on_class_method_added(contextified_class, method_name, version)
+        unless methods_modules_containing_method(contextified_class, 
+                                                 method_name).empty?
+          replace_core_method(contextified_class, method_name, version)
         end
-        nature.return_value
       end
-    end
-
-    def behaviour_with_arounds( instance )
-      bound_core = self.bind_core( instance )
-      bound_arounds = self.bind_arounds( instance )
 
-      lambda do | *arguments |
-        working_arounds = bound_arounds.clone
-        nature = MethodNature.new( arguments, nil, false)
-        nature.block = around_block( nature, working_arounds, bound_core )
-
-        catch( :break_in_around ) do
-          working_arounds.shift.call( nature )
+      def on_wrapper_method_added(methods_module, method_name, version)
+        self.definitions.collect do | each_class, each_methods_modules | 
+          if each_methods_modules.include?(methods_module)
+            each_class
+          end 
+        end.compact.each do | contextified_class |
+          replace_core_method(contextified_class, method_name, 0)
         end
-        nature.return_value
       end
-    end
 
-    def behaviour_with_pres_and_arounds( instance )
-      combined_pres = self.combine_pres( instance )
-      bound_core = self.bind_core( instance )
-      bound_arounds = self.bind_arounds( instance )
-
-      lambda do | *arguments |
-        nature = MethodNature.new( arguments, nil, false ) 
-
-        combined_pres.call( nature )
-        unless nature.break
-          working_arounds = bound_arounds.clone
-          nature.block = around_block( nature, working_arounds, bound_core )
-          catch( :break_in_around ) do
-            working_arounds.shift.call( nature )
-          end
-        end
-        nature.return_value
+      def replace_core_method(contextified_class, method_name, version)
+        ContextR::observe_core_method(contextified_class, method_name.to_sym,
+                                      version)
       end
-    end
-
-    def behaviour_with_arounds_and_posts( instance )
-      bound_core = self.bind_core( instance )
-      bound_arounds = self.bind_arounds( instance )
-      combined_posts = self.combine_posts( instance )
-
-      lambda do | *arguments |
-        working_arounds = bound_arounds.clone
-        nature = MethodNature.new( arguments, nil, false,
-                      around_block( nature, working_arounds, bound_core ) ) 
 
-        catch( :break_in_around ) do
-          working_arounds.shift.call( nature )
-        end
-        combinded_posts.call( nature ) unless nature.break
-
-        nature.return_value
-      end
+     def  register_callbacks(cclass, mmodule)
+       { :on_wrapper_method_added => mmodule,
+         :on_class_method_added   => cclass }.each do | callback, klass |
+         ContextR::EventMachine.register(self, callback, 
+                                         :on_event => :method_added,
+                                         :in_class => klass)
+       end
+     end
     end
-
-    def behaviour_with_pres_and_arounds_and_posts( instance )
-      combined_pres = self.combine_pres( instance )
-      bound_core = self.bind_core( instance )
-      bound_arounds = self.bind_arounds( instance )
-      combined_posts = self.combine_posts( instance )
-
-      lambda do | *arguments |
-        nature = MethodNature.new( arguments, nil, false ) 
-
-        combined_pres.call( nature )
-        unless nature.break
-          working_arounds = bound_arounds.clone
-          nature.block = around_block( nature, working_arounds, bound_core )
-          catch( :break_in_around ) do
-            working_arounds.shift.call( nature )
-          end
-          unless nature.break
-            combined_posts.call( nature )
-          end
-        end
-        nature.return_value
-      end
-    end
-
-
-    # helpers
-    def combine_pres( instance )
-      bound_pres = self.pres.collect { | p | p.bind( instance ) }
-      lambda do | nature |
-        bound_pres.each do | bound_pre |
-          bound_pre.call( nature )
-          break if nature.break
-        end
-      end
-    end
-
-    def bind_arounds( instance )
-      self.arounds.collect { | a | a.bind( instance ) }
-    end
-
-    def around_block( nature, bound_arounds, bound_core )
-      lambda do
-        unless bound_arounds.empty?
-          bound_arounds.shift.call( nature )
-          throw( :break_in_around ) if nature.break
-        else
-          nature.return_value = bound_core.call( *nature.arguments )
-        end
-      end
-    end
-
-    def bind_core( instance )
-      self.core.bind( instance )
-    end
-
-    def combine_posts( instance )
-      bound_posts = self.posts.collect { | p | p.bind( instance ) }
-      lambda do | nature |
-        bound_posts.reverse.each do | bound_post |
-          bound_post.call( nature )
-          break if nature.break
-        end
-        nature.return_value
-      end
+    
+    self.extend(ClassMethods)
+    
+    def self.inherited(klass)
+      klass.extend(ClassMethods)
     end
   end
 end
-