contextr 0.0.1 → 0.0.2

data/History.txt

@@ -1,3 +1,11 @@
++++ 0.0.2 2007-05-08
+
++ 1 major change:
+  + Changed the wrapper execution order to a hopefulle more natural ordering
+  + Added documentation
++ 1 minor change:
+  + finished transition from unit tests to rspec based specification
+
 +++ 0.0.1 2007-05-08
 
 + 1 major enhancement:

data/LICENSE.txt

@@ -41,8 +41,8 @@ You can redistribute it and/or modify it under either the terms of the GPL
      software (possibly commercial).  But some files in the distribution
      are not written by the author, so that they are not under this terms.
 
-     They are ./tasks/annotations.rb and all files under the ./ext directory.  
-     See each file for the copying condition.
+     They are ./tasks/annotations.rb and all files under the lib/ext 
+     directory. See each file for the copying condition.
 
   5. The scripts and library files supplied as input to or produced as 
      output from the software do not automatically fall under the

data/Manifest.txt

@@ -6,19 +6,21 @@ README.txt
 Rakefile
 examples/education.rb
 examples/fibonacci.rb
-ext/dynamic.rb
-ext/method_nature.rb
 lib/contextr.rb
 lib/contextr/contextr.rb
+lib/contextr/layer.rb
 lib/contextr/version.rb
 lib/core_ext/class.rb
 lib/core_ext/module.rb
 lib/core_ext/proc.rb
+lib/ext/dynamic.rb
+lib/ext/method_nature.rb
 rake/group_spec_task.rb
 rake/specific_group_spec_task.rb
 scripts/txt2html
 setup.rb
 spec/contextr/contextr_api_spec.rb
+spec/contextr/contextr_functional_spec.rb
 spec/core_ext/module_spec.rb
 spec/core_ext/proc_spec.rb
 spec/spec_helper.rb

data/README.txt

@@ -1,5 +1,4 @@
-ContextR
-========
+= ContextR
 
 A context-oriented programming library for Ruby. 
 
@@ -7,11 +6,45 @@ Inspired by ContextL (Pascal Costanza) and ContextS (Robert Hirschfeld) with
 thanks to Christian Neukirchen for giving the name and lots of ideas.
 
 For more information see 
+- http://contextr.rubyforge.org/
 - http://www.contextr.org/ or 
 - http://www.swa.hpi.uni-potsdam.de/cop/
 
-This code is published under the same license as Ruby. See LICENSE for more 
+This code is published under the same license as Ruby. See LICENSE.txt for more 
 information.
 
 (c) 2007 - Gregor Schmidt - Berlin, Germany
 
+= Usage
+
+  require 'rubygems'
+  require 'contextr'
+
+  class A
+    def a
+      puts "a"
+    end
+ 
+    layer :foo
+
+    foo.post :a do | n |
+      n.return_value += "_with_context"
+    end
+  end
+
+  A.new.a      # => "a"
+
+  ContextR::with_layers( :foo ) do
+    A.new.a    # => "a_with_context"
+  end
+
+= Starting Points
+
+For a more detailed description
+- visit the project homepage at RubyForge[http://contextr.rubyforge.org/]
+- have a look at the +examples+ folder in the ContextR distribution
+
+For detailed API descriptions have a look at the following classes and modules
+- Class
+- ContextR::LayerInClass 
+- ContextR::ClassMethods

data/examples/education.rb

@@ -2,8 +2,6 @@ require "rubygems"
 require "contextr" 
 
 class Person
-  layer :address, :education
-
   attr_accessor :name, :address, :university
 
   def initialize name, address, university
@@ -15,19 +13,9 @@ class Person
   def to_s
     "Name: #{name}"
   end
-
-  address.post :to_s do | n |
-    n.return_value += "; Address: #{address}"
-  end
-
-  education.post :to_s do | n |
-    n.return_value += ";\n[Education] #{university}"
-  end
 end
 
 class University
-  layer :address
-
   attr_accessor :name, :address
 
   def initialize name, address
@@ -38,6 +26,22 @@ class University
   def to_s
     "Name: #{name}"
   end
+end
+
+class Person
+  layer :address, :education
+
+  address.post :to_s do | n |
+    n.return_value += "; Address: #{address}"
+  end
+
+  education.post :to_s do | n |
+    n.return_value += ";\n[Education] #{university}"
+  end
+end
+
+class University
+  layer :address
 
   address.post :to_s do | n |
     n.return_value += "; Address: #{address}"
@@ -50,15 +54,15 @@ somePerson = Person.new( "Gregor Schmidt", "Berlin", hpi )
 
 puts 
 puts somePerson
-ContextR::with_layers :address do
+ContextR::with_layers :education do
   puts 
   puts somePerson
 
-  ContextR::with_layers :education do
+  ContextR::with_layers :address do
     puts 
     puts somePerson
 
-    ContextR::without_layers :address do
+    ContextR::without_layers :education do
       puts 
       puts somePerson
     end

data/lib/contextr.rb

@@ -1,13 +1,15 @@
+#--
 # TODO: get rid of this workaround to avoid double loading on `rake test`
+#++
 unless Object.const_defined? "ContextR"
   require 'rubygems'
   require 'active_support'
 
-  Dir[File.join(File.dirname(__FILE__), '../ext/**/*.rb')].sort.each { |lib| require lib }
+  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 }
 
 end
 unless Dynamic.variables.include?( :layers )
-  Dynamic.variable( :layers => [ ContextR::DefaultLayer ] )
+  Dynamic.variable( :layers => [ ContextR::layer_by_symbol( :default ) ] )
 end

data/lib/contextr/contextr.rb

@@ -1,19 +1,25 @@
 module ContextR
-  @@genid = 0
-  class << self
-    def gensym( name, kind = "", postfix = "_%05d_" )
-      @@genid += 1
-      ( "_#{name}_#{kind}#{postfix}" % @@genid ).intern
-    end
-
-    def symbolize( layer_klass )
-      layer_klass.namespace_free_name.gsub( "Layer", "" ).downcase.to_sym
-    end
-
-    def layerize( layer_symbol )
-      "#{layer_symbol}_layer".camelize
-    end
 
+  # This module is mixed into ContextR module, so that all public methods
+  # are available via
+  #   ContextR::current_layers
+  #   ContextR::with_layers( layer_name, ... ) { ... }
+  #   ContextR::without_layers( layer_name, ... ) { ... }
+  module ClassMethods
+    # allows the explicit activation of layers within a block context
+    #
+    #   ContextR::with_layers( :foo, :bar ) do
+    #     ContextR::current_layers            # => [:default, :foo, :bar]
+    #
+    #     ContextR::with_layers( :baz ) do
+    #       ContextR::current_layers          # => [:default, :foo, :bar, :baz]
+    #     end
+    #
+    #   end
+    # 
+    # :call-seq:
+    #   with_layers( layer_name, ... ) { ... }
+    #
     def with_layers( *layer_symbols, &block )
       layers = layer_symbols.collect do | layer_symbol |
         ContextR.layer_by_name( ContextR.layerize( layer_symbol ) )
@@ -21,6 +27,20 @@ module ContextR
       Dynamic.let( { :layers => Dynamic[:layers] | layers }, &block )
     end
 
+    # allows the explicit deactivation of layers within a block context
+    # 
+    #   ContextR::with_layers( :foo, :bar ) do
+    #     ContextR::current_layers            # => [:default, :foo, :bar]
+    #
+    #     ContextR::without_layers( :foo ) do
+    #       ContextR::current_layers          # => [:default, :bar]
+    #     end
+    #
+    #   end
+    #
+    # :call-seq:
+    #   without_layers( layer_name, ... ) { ... }
+    #
     def without_layers( *layer_symbols, &block )
       layers = layer_symbols.collect do | layer_symbol |
         ContextR.layer_by_name( ContextR.layerize( layer_symbol ) )
@@ -28,11 +48,30 @@ module ContextR
       Dynamic.let( { :layers => Dynamic[:layers] - layers }, &block )
     end
 
-    def layer_by_symbol( layer_symbol )
+    # returns the names of the currently activated layers
+    #
+    #   ContextR::current_layers              # => [:default]
+    #
+    #   ContextR::with_layers :foo do
+    #     ContextR::current_layers            # => [:default, :foo]
+    #   end
+    def current_layers
+      Dynamic[:layers].collect{ | layer_class | self.symbolize( layer_class ) }
+    end
+
+    def symbolize( layer_klass ) # :nodoc:
+      layer_klass.namespace_free_name.gsub( "Layer", "" ).downcase.to_sym
+    end
+
+    def layerize( layer_symbol ) # :nodoc:
+      "#{layer_symbol}_layer".camelize
+    end
+    
+    def layer_by_symbol( layer_symbol ) # :nodoc:
       layer_by_name( layerize( layer_symbol ) )
     end
 
-    def layer_by_name( layer_name )
+    def layer_by_name( layer_name ) # :nodoc:
       unless ContextR.const_defined?( layer_name )
         ContextR::module_eval( 
             "class #{layer_name} < Layer; end", __FILE__, __LINE__ )
@@ -41,377 +80,11 @@ module ContextR
       ContextR.const_get( layer_name )
     end
 
-    def current_layer
+    def current_layer # :nodoc:
       Layer.compose( Dynamic[:layers] )
     end
-  end
-
-
-  class Layer # its role as base instance of all layers
-    class << self
-      attr_accessor_with_default_setter :base_layers, :combined_layers do 
-        Hash.new
-      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
-      end
-
-      def inherited( new_base_layer )
-        unless new_base_layer.name.empty?
-          base_layers[ContextR::symbolize( new_base_layer )] = new_base_layer
-        end
-      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 # 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] = ContextualizedMethod.new( 
-                      ContextR::Layer.core_methods[ extended_class ][ key ] )
-            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 |
-          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
-      end
-    end
-  end
 
-  class LayerInClass # its public interface
-    attr_accessor :contextualized_class
-    attr_accessor :layer
-
-    def initialize( contextualized_class, layer )
-      self.contextualized_class = contextualized_class 
-      self.layer = layer
-    end
-
-    def pre( method_name, &block )
-      layer.methods_of( self.contextualized_class )[method_name].pres << 
-          block.to_unbound_method( self.contextualized_class )
-      nil
-    end
-    def post( method_name, &block )
-      layer.methods_of( self.contextualized_class )[method_name].posts <<
-          block.to_unbound_method( self.contextualized_class )
-      nil
-    end
-    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 ExtendedObject
-    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
-    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
-        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 )
-        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.pop.call( nature )
-        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.pop.call( nature )
-          end
-        end
-        nature.return_value
-      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.pop.call( nature )
-        end
-        combinded_posts.call( nature ) unless nature.break
-
-        nature.return_value
-      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.pop.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.reverse.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.pop.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.each do | bound_post |
-          bound_post.call( nature )
-          break if nature.break
-        end
-      end
-    end
   end
 
-  class DefaultLayer < Layer; end
+  extend ClassMethods
 end