contextr 0.1.1 → 0.1.9

data.tar.gz.sig

@@ -1,2 +1,2 @@
-j�@k�=�<	�I4c� 
5���Q�`�ߵf�jsQ6a����aasL!�BE]̓�GqH䅘Q���s�/d�
%y e,�M�[E�,S�ꥇ�L5�����Ldo�����{�	-�Y�����4���2�G7�8��	r�K�x��_��%�6����)_�b���/�e�]��/A�2�Z*^�
-�l��g��V��S1%#�@��w�l����W�/�v
+&�3��Q��<��o;\ؿ}0�`Y�G��(��%���z$9P�#��xj���O�N0*�kKK@\!�P�J3�ŵQ�S�$�Ds�
K�f�/@� ��o0f��Sz�)ٓ/?f#�&bD��186� o�M�GU�Ha��;��uq�{�:�f)���D�W�ŭ��"5ǹ7֦�m��X9s쬽��X�&�m�
+=����ȄJN�r��'���"kU{�v�nS̹��=��s#{>��㴯/<u�h�jQBN8(G	,z8

data/History.txt

@@ -1,3 +1,11 @@
+== 0.1.9 2007-11-30
+
+* this is a review release
+  * documentation is not yet complete
+* major changes
+  * documentation website
+  * again a new api
+
 == 0.1.1 2007-09-17
 
 * major changes

data/Manifest.txt

@@ -11,6 +11,7 @@ lib/contextr/core_ext.rb
 lib/contextr/core_ext/module.rb
 lib/contextr/core_ext/object.rb
 lib/contextr/event_machine.rb
+lib/contextr/inner_class.rb
 lib/contextr/layer.rb
 lib/contextr/modules/mutex_code.rb
 lib/contextr/modules/unique_id.rb
@@ -23,10 +24,24 @@ setup.rb
 spec/contextr_spec.rb
 spec/spec.opts
 spec/spec_helper.rb
+test/lib/example_test.rb
+test/lib/literate_markaby_test.rb
+test/lib/literate_maruku_test.rb
+test/test_class_side.mkd
 test/test_class_side.rb
 test/test_contextr.rb
+test/test_dynamic_scope.mkd
+test/test_dynamic_scope.rb
+test/test_dynamics.mkd
 test/test_dynamics.rb
+test/test_hello_world.mkd
+test/test_hello_world.rb
 test/test_helper.rb
+test/test_introduction.mkd
 test/test_introduction.rb
+test/test_layer_state.mkd
 test/test_layer_state.rb
+test/test_meta_api.mkd
+test/test_meta_api.rb
+test/test_ordering.mkd
 test/test_ordering.rb

data/Rakefile

@@ -107,8 +107,8 @@ task :website => [:website_generate, :website_upload, :publish_docs]
 desc 'Release the website and new gem version'
 task :deploy => [:check_version, :website, :release] do
   puts "Remember to create SVN tag:"
-  puts "svn copy svn+ssh://#{rubyforge_username}@rubyforge.org/var/svn/#{PATH}/trunk " +
-    "svn+ssh://#{rubyforge_username}@rubyforge.org/var/svn/#{PATH}/tags/REL-#{VERS} "
+  puts "svn copy svn+ssh://rubyforge.org/var/svn/#{PATH}/trunk " +
+    "svn+ssh://rubyforge.org/var/svn/#{PATH}/tags/contextr-#{VERS} "
   puts "Suggested comment:"
   puts "Tagging release #{CHANGES}"
 end

data/lib/contextr.rb

@@ -11,7 +11,8 @@ end
 
 # the basic library code
 %w{public_api class_methods layer 
-   event_machine core_ext version}.each { | file | 
+   event_machine core_ext version
+   inner_class}.each { | file | 
       require File.dirname(__FILE__) + "/contextr/#{file}" }
 
 unless Dynamic.variables.include?( :layers )

data/lib/contextr/class_methods.rb

@@ -2,17 +2,17 @@ module ContextR # :nodoc:
   module ClassMethods # :nodoc:
     include MutexCode
 
-    def const_missing(const_name)
-      if const_name.to_s =~ /.*Layer$/
-        self.const_set(const_name, Class.new(ContextR::Layer))
-      else
-        super
+    def stored_core_methods
+      @stored_core_methods ||= Hash.new do |hash, key|
+        hash[key] = Hash.new
       end
     end
 
-    def stored_core_methods
-      @stored_core_methods ||= Hash.new do | hash, key |
-        hash[key] = Hash.new
+    def stored_module_definitions
+      @stored_module_definitions ||= Hash.new do |hash, key|
+        hash[key] = Hash.new do |hash, key|
+          hash[key] = Module.new
+        end
       end
     end
 
@@ -25,24 +25,22 @@ module ContextR # :nodoc:
     end
 
     def layers_as_classes
-      constants.select { |l| l =~ /.+Layer$/ }.collect { |l| 
-        l.scan(/(.+)Layer/).first.first.underscore.to_sym
-      }
+      @layers.values
     end
 
     def symbol_by_layer(lay)
-      lay.to_s.gsub( /^ContextR::(.*)Layer$/, '\1' ).underscore.to_sym
+      @layers.index(lay)
     end
 
     def layer_by_symbol(sym)
-      "ContextR::#{sym.to_s.camelize}Layer".constantize
+      @layers[sym] ||= ContextR::Layer.new
     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 |
+        stack.pop.__send__(method_name, *arguments) do | action, *rest_args |
           case action
           when :receiver
             receiver
@@ -62,7 +60,9 @@ module ContextR # :nodoc:
                               method_name, arguments, block)
       proxies = []
       active_layers_as_classes.each do |layer|
-        proxies += layer.context_proxies(contextified_class, method_name)
+        proxies += layer.context_proxies(receiver, 
+                                         contextified_class, 
+                                         method_name)
       end.compact 
 
       proxies << core_proxy(receiver, contextified_class, method_name) 
@@ -104,6 +104,10 @@ module ContextR # :nodoc:
     def meta_method?(method_name)
       method_name.to_s =~ /method_added(_with(out)?_contextr_listener)?/
     end
+
+    def self.extended(base)
+      base.instance_variable_set(:@layers, {})
+    end
   end
   self.extend(ClassMethods)
 end

data/lib/contextr/core_ext/module.rb

@@ -1,41 +1,16 @@
-#--
-# The aliasing of these methods is done in a class_eval block to avoid code
-# documentation by RDoc.
-#++
-Module.class_eval do
-  alias_method :include_without_layers, :include 
-end
-
 class Module
-  protected
-  def include_with_layers(associations) # :nodoc:
-    associations.each do | modul, layer |
-      ContextR::layer_by_symbol(layer).add_method_collection(self, modul)
-    end
-    self
-  end
-
-  # call-seq:
-  #    include(module, ...)    => self
-  #    include(module => layer_qualifier, ...)    => self
-  # 
-  # Invokes <code>Module.append_features</code> on each parameter in turn.
+  #  Adds context-dependent behaviour to instances. 
   #
-  # If called with a hash, adds the module to the given layer. The behaviour 
-  # is associated with the class side of the object.
-  #
-  #    module Mod
-  #      def name
-  #        "Hello from #{yield(:next)}.\n"
-  #      end
-  #    end
-  #    
   #    class Klass
   #      def name
   #        "Klass"
   #      end
   #
-  #      include Mod => :hello
+  #      in_layer :hello do
+  #        def name
+  #          "Hello from #{super}.\n"
+  #        end
+  #      end
   #    end
   #    
   #    k = Klass.new
@@ -45,13 +20,17 @@ class Module
   #    end
   #    k.name                    #=> "Klass.\n"
   #
-  def include(*args)
-    args.first.is_a?(Module) ? include_without_layers(*args) : 
-                               include_with_layers(*args)
-  end
-end
+  # Note: in_layer automatically generates the inner module
+  # and attaches it to the given layer. It is guaranteed, that the inner module
+  # used for method definitons will always be the same for any layer x class
+  # combination.
+  def in_layer(layer_symbol, &block)
+    extension = ContextR::stored_module_definitions[layer_symbol][self]
+
+    extension.module_eval(&block) if block_given?
 
-Module.class_eval do
-  private :include
-  private :include_with_layers
+    ContextR::layer_by_symbol(layer_symbol).add_method_collection(self, 
+                                                                  extension) 
+    extension
+  end
 end

data/lib/contextr/core_ext/object.rb

@@ -1,71 +1,4 @@
-#--
-# The aliasing of these methods is done in a class_eval block to avoid code
-# documentation by RDoc.
-#++
-Object.class_eval do
-  alias_method :extend_without_layers, :extend   
-end
-
-class Object
-  def extend_with_layers(associations) # :nodoc:
-    klass = class << self; self; end
-    associations.each do | modul, layer |
-      ContextR::layer_by_symbol(layer).add_method_collection(klass, modul)
-    end
-    self
-  end
-
-  # call-seq:
-  #    obj.extend(module, ...)    => obj
-  #    obj.extend(module => layer_qualifier, ...)    => obj
-  # 
-  # Adds to _obj_ the instance methods from each module given as a
-  # parameter.
-  #    
-  #    module Mod
-  #      def hello
-  #        "Hello from Mod.\n"
-  #      end
-  #    end
-  #    
-  #    class Klass
-  #      def hello
-  #        "Hello from Klass.\n"
-  #      end
-  #    end
-  #    
-  #    k = Klass.new
-  #    k.hello         #=> "Hello from Klass.\n"
-  #    k.extend(Mod)   #=> #<Klass:0x401b3bc8>
-  #    k.hello         #=> "Hello from Mod.\n"
-  #
-  # If called with a hash, adds the module to the given layer. The behaviour 
-  # is associated with the class side of the object.
-  #
-  #    module Mod
-  #      def name
-  #        "Hello from #{yield(:next)}.\n"
-  #      end
-  #    end
-  #    
-  #    class Klass
-  #      def name
-  #        "Klass"
-  #      end
-  #    end
-  #    
-  #    k = Klass.new
-  #    k.extend(Mod => :hello)   #=> #<Klass:0x401b3bc8>
-  #    k.name                    #=> "Klass.\n"
-  #    ContextR::with_layer :hello do
-  #      k.name                  #=> "Hello from Klass.\n"
-  #    end
-  #    k.name                    #=> "Klass.\n"
-  def extend(*args)
-    args.first.is_a?(Module) ? extend_without_layers(*args) : 
-                               extend_with_layers(*args)
-  end
-
+class Object #:nodoc:
   def behavioural_class #:nodoc:
     if self.kind_of?(Module)
       class << self; self; end

data/lib/contextr/event_machine.rb

@@ -4,7 +4,7 @@ module ContextR
       include UniqueId 
 
       def listeners 
-        @listeners ||= { :method_added => {} }
+        @listeners ||= {:method_added => {}}
       end
 
       def register(listener, callback, options)
@@ -20,8 +20,8 @@ module ContextR
 
       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 )
+        self.listeners[:method_added][modul].to_a.each do |listener, method|
+          listener.send(method, modul, name, version)
         end 
       end
 

data/lib/contextr/inner_class.rb

@@ -0,0 +1,47 @@
+module ContextR
+  class InnerClass # :nodoc:
+    #--
+    # Copyright 2004, 2006 by Jim Weirich (jim@weirichhouse.org).
+    # All rights reserved.
+
+    # Permission is granted for use, copying, modification, distribution,
+    # and distribution of modified versions of this work as long as the
+    # above copyright notice is included.
+    #++
+    class << self
+      # Hide the method named +name+ in the BlankSlate class.  Don't
+      # hide +instance_eval+ or any method beginning with "__".
+      def hide(name)
+        if instance_methods.include?(name.to_s) and
+          name !~ /^(__|instance_eval)/
+          @hidden_methods ||= {}
+          @hidden_methods[name.to_sym] = instance_method(name)
+          undef_method name
+        end
+      end
+
+      def find_hidden_method(name)
+        @hidden_methods ||= {}
+        @hidden_methods[name] || superclass.find_hidden_method(name)
+      end
+
+      # Redefine a previously hidden method so that it may be called on a blank
+      # slate object.
+      def reveal(name)
+        bound_method = nil
+        unbound_method = find_hidden_method(name)
+        fail "Don't know how to reveal method '#{name}'" unless unbound_method
+        define_method(name) do |*args|
+          bound_method ||= unbound_method.bind(self)
+          bound_method.call(*args)
+        end
+      end
+    end
+    
+    instance_methods.each { |m| hide(m) }
+
+    def method_missing(method_name, *rest_args)
+      yield(:next, *rest_args)
+    end
+  end
+end

data/lib/contextr/layer.rb

@@ -1,88 +1,82 @@
 module ContextR # :nodoc:
   class Layer # :nodoc: all
-    module ClassMethods
-      def definitions
-        @definitions ||= {}
-      end
-      def proxies
-        @proxies ||= {}
-      end
+    def definitions
+      @definitions ||= {}
+    end
+    def proxies
+      @proxies ||= {}
+    end
 
-      def add_method_collection(contextified_class, methods_module)
-        definitions[contextified_class] ||= []
-        definitions[contextified_class].delete(methods_module)
-        definitions[contextified_class].push(methods_module)
+    def add_method_collection(contextified_class, methods_module)
+      definitions[contextified_class] ||= []
+      definitions[contextified_class].delete(methods_module)
+      definitions[contextified_class].push(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)
+      (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 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
-        else
-          []
+    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
+      else
+        []
       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
-
-      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
+    def context_proxies(receiver, contextified_class, method_name)
+      methods_modules_containing_method(contextified_class, method_name).
+        collect do | methods_module | 
+          context_proxy_for_module(receiver, methods_module) 
+        end.reverse
+    end
 
-      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
+    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
       end
+    end
 
-      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
+    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
+    end
 
-      def replace_core_method(contextified_class, method_name, version)
-        ContextR::observe_core_method(contextified_class, method_name.to_sym,
-                                      version)
+    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.select do |contextified_class|
+        contextified_class.instance_methods.include?(method_name.to_s)
+      end.each do | contextified_class |
+        replace_core_method(contextified_class, method_name, 0)
       end
+    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
+    def replace_core_method(contextified_class, method_name, version)
+      ContextR::observe_core_method(contextified_class, method_name.to_sym,
+                                    version)
     end
-    
-    self.extend(ClassMethods)
-    
-    def self.inherited(klass)
-      klass.extend(ClassMethods)
+
+    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
 end