contextr 0.0.3 → 0.1.0

data/LICENSE.txt

@@ -1,57 +0,0 @@
-ContextR is copyrighted free software by Gregor Schmidt <ruby@schmidtwisser.de>.
-You can redistribute it and/or modify it under either the terms of the GPL
-(see COPYING file), or the conditions below:
-
-  1. You may make and give away verbatim copies of the source form of the
-     software without restriction, provided that you duplicate all of the
-     original copyright notices and associated disclaimers.
-
-  2. You may modify your copy of the software in any way, provided that
-     you do at least ONE of the following:
-
-       a) place your modifications in the Public Domain or otherwise
-          make them Freely Available, such as by posting said
-          modifications to Usenet or an equivalent medium, or by allowing
-          the author to include your modifications in the software.
-
-       b) use the modified software only within your corporation or
-          organization.
-
-       c) rename any non-standard executables so the names do not conflict
-          with standard executables, which must also be provided.
-
-       d) make other distribution arrangements with the author.
-
-  3. You may distribute the software in object code or executable
-     form, provided that you do at least ONE of the following:
-
-       a) distribute the executables and library files of the software,
-          together with instructions (in the manual page or equivalent)
-          on where to get the original distribution.
-
-       b) accompany the distribution with the machine-readable source of
-          the software.
-
-       c) give non-standard executables non-standard names, with
-          instructions on where to get the original software distribution.
-
-       d) make other distribution arrangements with the author.
-
-  4. You may modify and include the part of the software into any other
-     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 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
-     copyright of the software, but belong to whomever generated them, 
-     and may be sold commercially, and may be aggregated with this
-     software.
-
-  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
-     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
-     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-     PURPOSE.
-

data/examples/education.rb

@@ -1,71 +0,0 @@
-require "rubygems"
-require "contextr" 
-
-class Person
-  attr_accessor :name, :address, :university
-
-  def initialize name, address, university
-    self.name = name
-    self.address = address
-    self.university = university
-  end
-
-  def to_s
-    "Name: #{name}"
-  end
-end
-
-class University
-  attr_accessor :name, :address
-
-  def initialize name, address
-    self.name = name
-    self.address = address
-  end
-
-  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}"
-  end
-end
-
-
-hpi = University.new( "Hasso-Plattner-Institut", "Potsdam" )
-somePerson = Person.new( "Gregor Schmidt", "Berlin", hpi )
-
-puts 
-puts somePerson
-ContextR::with_layers :education do
-  puts 
-  puts somePerson
-
-  ContextR::with_layers :address do
-    puts 
-    puts somePerson
-
-    ContextR::without_layers :education do
-      puts 
-      puts somePerson
-    end
-  end
-end
-puts 

data/examples/fibonacci.rb

@@ -1,124 +0,0 @@
-require "rubygems"
-require "contextr" 
-
-require 'test/unit'
-require 'benchmark'
-
-class Fibonacci
-  class << self
-    def compute fixnum
-      if fixnum == 1 or fixnum == 0
-        fixnum
-      elsif fixnum < 0
-        raise ArgumentError, "Fibonacci not defined for negative numbers"
-      else
-        compute(fixnum - 1) + compute(fixnum - 2)
-      end
-    end
-  
-    layer :fib_pre_post, :fib_wrap
-    attr_accessor :cache
-
-    fib_pre_post.pre :compute do | nature |
-      self.cache ||= {}
-      if self.cache.key? nature.arguments.first
-        nature.break! self.cache[nature.arguments.first]
-      end
-    end
-
-    fib_pre_post.post :compute do | nature |
-      self.cache[nature.arguments.first] = nature.return_value
-    end
-    
-    fib_wrap.wrap :compute do | nature |
-      self.cache ||= {}
-      if self.cache.key? nature.arguments.first
-        nature.return_value = self.cache[nature.arguments.first]
-      else
-        nature.call_next
-        self.cache[nature.arguments.first] = nature.return_value
-      end
-    end
-  end
-end
-
-class Fixnum
-  def fibonacci
-    if self == 1 or self == 0
-      self
-    elsif self < 0
-      raise ArgumentError, "Fibonacci not defined for negative numbers"
-    else
-      old_fib, fib = 0, 1
-      for i in 2..self
-        fib, old_fib = old_fib + fib, fib
-      end
-      fib
-    end
-  end
-end
-
-class FibonacciTest < Test::Unit::TestCase
-  def setup
-    Fibonacci.cache = {}
-  end
-  
-  def test_basic_function
-    Benchmark.bm(20) do |x|
-      x.report("Recursive:") {
-        assert_equal       0, Fibonacci.compute(  0 )
-        assert_equal       1, Fibonacci.compute(  1 )
-        assert_equal       1, Fibonacci.compute(  2 )
-        assert_equal      55, Fibonacci.compute( 10 )
-        assert_equal    6765, Fibonacci.compute( 20 )
-        # The following are too hard for the simple solution
-        assert_equal  75_025, 25.fibonacci
-        assert_equal 9227465, 35.fibonacci
-        assert_equal 280571172992510140037611932413038677189525,
-                              200.fibonacci
-        assert_equal 176023680645013966468226945392411250770384383304492191886725992896575345044216019675,
-                              400.fibonacci
-      }
-    end
-  end
-  
-  def test_layered_function_with_pre_post
-    Benchmark.bm(20) do |x|
-      x.report("Layered Pre/Post:") {
-        ContextR.with_layers :fib_pre_post do
-          assert_equal       0, Fibonacci.compute(  0 )
-          assert_equal       1, Fibonacci.compute(  1 )
-          assert_equal       1, Fibonacci.compute(  2 )
-          assert_equal      55, Fibonacci.compute( 10 )
-          assert_equal    6765, Fibonacci.compute( 20 )
-          assert_equal  75_025, Fibonacci.compute( 25 )
-          assert_equal 9227465, Fibonacci.compute( 35 )
-          assert_equal 280571172992510140037611932413038677189525,
-                                Fibonacci.compute( 200 )
-          assert_equal 176023680645013966468226945392411250770384383304492191886725992896575345044216019675,
-          Fibonacci.compute( 400 )
-        end
-      }
-    end
-  end
-  
-  def test_layered_function_with_wrap
-    Benchmark.bm(20) do |x|
-      x.report("Layered Wrap:") {
-        ContextR.with_layers :fib_wrap do
-          assert_equal       0, Fibonacci.compute(  0 )
-          assert_equal       1, Fibonacci.compute(  1 )
-          assert_equal       1, Fibonacci.compute(  2 )
-          assert_equal      55, Fibonacci.compute( 10 )
-          assert_equal    6765, Fibonacci.compute( 20 )
-          assert_equal  75_025, Fibonacci.compute( 25 )
-          assert_equal 9227465, Fibonacci.compute( 35 )
-          assert_equal 280571172992510140037611932413038677189525,
-                                Fibonacci.compute( 200 )
-          assert_equal 176023680645013966468226945392411250770384383304492191886725992896575345044216019675,
-                                Fibonacci.compute( 400 )
-        end
-      }
-    end
-  end
-end

data/examples/with_current_context.rb

@@ -1,29 +0,0 @@
-require "rubygems"
-require "contextr" 
-
-class A
-  class << self
-    def a
-      "a"
-    end
-
-    layer :foo
-
-    foo.post :a do | n | 
-      n.return_value << " post"
-    end
-  end
-end
-
-ContextR::add_context_sensor do
-  [:foo]
-end
-
-puts A.a    # => "a"
-ContextR::with_layer :foo do
-  puts A.a  # => "a post"
-end
-ContextR::with_current_context do
-  puts A.a  # => "a post"
-end
-puts A.a    # => "a"

data/lib/contextr/contextr.rb

@@ -1,160 +0,0 @@
-module ContextR
-
-  # 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 ) )
-      end
-      Dynamic.let( { :layers => Dynamic[:layers] | layers }, &block )
-    end
-    alias with_layer with_layers
-
-    # allows the explicit activation of layers
-    # 
-    #   ContextR::activate_layers( :foo, :bar )
-    #   ContextR::current_layers            # => [:default, :foo, :bar]
-    #
-    # :call-seq:
-    #   deactivate_layers( layer_name, ... )
-    #
-    def activate_layers( *layer_symbols )
-      layers = layer_symbols.collect do | layer_symbol |
-        ContextR.layer_by_name( ContextR.layerize( layer_symbol ) )
-      end
-      Dynamic[:layers] |= layers
-    end
-    alias activate_layer activate_layers
-
-    # 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 ) )
-      end
-      Dynamic.let( { :layers => Dynamic[:layers] - layers }, &block )
-    end
-    alias without_layer without_layers
-
-    # allows the explicit deactivation of layers
-    # 
-    #   ContextR::activate_layers( :foo, :bar )
-    #   ContextR::current_layers            # => [:default, :foo, :bar]
-    #
-    #   ContextR::deactivate_layers( :foo )
-    #   ContextR::current_layers            # => [:default, :bar]
-    #
-    # :call-seq:
-    #   deactivate_layers( layer_name, ... )
-    #
-    def deactivate_layers( *layer_symbols )
-      layers = layer_symbols.collect do | layer_symbol |
-        ContextR.layer_by_name( ContextR.layerize( layer_symbol ) )
-      end
-      Dynamic[:layers] -= layers
-    end
-    alias deactivate_layer deactivate_layers
-
-    # 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
-
-    # allows the registration of context sensors. These are blocks that are
-    # called on with_current_context and should return a list of layers, that
-    # should be activated.
-    # 
-    #   ContextR::add_context_sensor do
-    #     # some clever code computes some layers to activate
-    #     [ :foo ]
-    #   end
-    #
-    # :call-seq:
-    #   add_context_sensor() { ... }
-    #
-    def add_context_sensor &block
-      @sensors ||= []
-      @sensors << block
-    end
-
-    # asks all sensors to compute the current context, e.g. layers that should
-    # be active, and executes the given block in the context. It works basically
-    # like with_layers
-    # 
-    # :call-seq:
-    #   with_current_context() { ... }
-    #
-    def with_current_context(&block) 
-      layers = @sensors.inject([]) do | akku, sensor |
-        akku | sensor.call
-      end
-      ContextR::with_layers(*layers) do
-        block.call
-      end
-    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 ) # :nodoc:
-      unless ContextR.const_defined?( layer_name )
-        ContextR::module_eval( 
-            "class #{layer_name} < Layer; end", __FILE__, __LINE__ )
-        # ContextR.const_set( layer_name, Class.new( ContextR::Layer ) )
-      end
-      ContextR.const_get( layer_name )
-    end
-
-    def current_layer # :nodoc:
-      Layer.compose( Dynamic[:layers] )
-    end
-
-  end
-
-  extend ClassMethods
-end

data/lib/core_ext/class.rb

@@ -1,29 +0,0 @@
-# ContextR extends Class to allow the definition of context-dependent behaviour.
-# 
-# After registering a layer within in class, it is accessable via its name,
-# to add behaviour to methods.
-class Class 
-  # register a layer to be used within a class body
-  def layer( *layer_keys )
-    layer_keys.each do | layer_key |
-      layer_key = layer_key.to_s.downcase.to_sym
-      layer_name = ContextR::layerize( layer_key )
-      layer = ContextR.layer_by_name( layer_name )
-      layer_in_class = ContextR::LayerInClass.new( self, layer )
-
-      define_private_class_method( layer_key ) do
-        layer_in_class
-      end
-    end
-    
-    nil
-  end
-
-protected
-  def define_private_class_method( symbol, &block ) # :nodoc:
-    (class << self; self; end).instance_eval do
-      define_method( symbol, block )
-      private symbol 
-    end
-  end
-end