contextr 0.1.9 → 1.0.0

data/History.txt

@@ -1,3 +1,11 @@
+== 1.0.0 2008-04-01
+
+* this is the first stable release
+* major changes
+  * updated documentation
+  * added more meta programming hooks
+  * no further API changes to expect until version 2.0
+
 == 0.1.9 2007-11-30
 
 * this is a review release

data/Manifest.txt

@@ -5,6 +5,8 @@ Manifest.txt
 README.txt
 Rakefile
 examples/README
+examples/employer.rb
+examples/node.rb
 lib/contextr.rb
 lib/contextr/class_methods.rb
 lib/contextr/core_ext.rb
@@ -24,24 +26,17 @@ setup.rb
 spec/contextr_spec.rb
 spec/spec.opts
 spec/spec_helper.rb
+test/class_side.mkd
+test/dynamic_scope.mkd
+test/dynamics.mkd
+test/hello_world.mkd
+test/introduction.mkd
+test/layer_state.mkd
 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/meta_api.mkd
+test/method_missing.mkd
+test/ordering.mkd
+test/restrictions.mkd
 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/README.txt

@@ -6,7 +6,6 @@ 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/
 

data/examples/employer.rb

@@ -0,0 +1,229 @@
+require File.dirname(__FILE__) + "/../lib/contextr"
+
+module EasyInitializerMixin
+  def initialize(options = {})
+    options.each do |key, value| 
+      self.send("#{key}=", value)
+    end
+  end
+end
+
+class Employer  
+  attr_accessor :name
+  include EasyInitializerMixin
+end
+class Person  
+  attr_accessor :name, :employer
+  include EasyInitializerMixin
+end
+
+
+class Employer  
+  def to_s    
+    "Employer\n" +    
+    "Name: %s" % self.name  
+  end
+end
+class Person  
+  def to_s    
+    "Person\n" +    
+    "Name: %s" % self.name  
+  end
+end
+
+class Person  
+  in_layer :employment do
+    def to_s      
+      super + "\n%s" % yield(:receiver).employer
+    end  
+  end
+end
+
+class Employer  
+  attr_accessor :address  
+  in_layer :detailed_info do   
+    def to_s      
+      super + "\n" + 
+      "Address: %s" % yield(:receiver).address     
+    end  
+  end
+end
+class Person  
+  attr_accessor :address  
+  in_layer :detailed_info do   
+    def to_s      
+      super + "\n" + 
+      "Address: %s" % yield(:receiver).address     
+    end  
+  end
+end
+
+vub = Employer.new
+vub.name = "Vrije Universiteit Brussel"
+vub.address = "Brussels"
+pascal = Person.new
+pascal.name = "Pascal"
+pascal.employer = vub
+pascal.address = "Brussels"
+
+puts vub
+puts
+puts pascal
+puts " - - - - - - - - "
+
+ContextR::with_layer :employment do
+  puts vub
+  puts
+  puts pascal
+  puts " - - - - - - - - "
+end
+
+ContextR::with_layer :detailed_info do
+  puts vub
+  puts
+  puts pascal
+  puts " - - - - - - - - "
+
+  ContextR::with_layer :employment do
+    puts vub
+    puts
+    puts pascal
+    puts " - - - - - - - - "
+  end
+end
+
+describe ContextR do
+  it "should show all currently active layers" do
+    ContextR::with_layer :employment do
+      ContextR::active_layers.should == [:employment]
+
+      ContextR::with_layer :detailed_info do
+        ContextR::active_layers.should == 
+                        [:detailed_info, :employment]
+      end
+  
+      ContextR::active_layers.should == [:employment]
+    end
+  end
+
+  it "should show all layers ever used" do
+    ContextR::layers.should == [:employment, :detailed_info]
+  end
+end
+
+describe ContextR do
+  it "should list all extended methods" do
+    Person.in_layer(:employment).instance_methods.should == ["to_s"]
+    Employer.in_layer(:employment).instance_methods.should be_empty
+  end
+end
+
+
+describe ContextR do
+  it "should execute later layers first, earlier layers later" do
+    ContextR::with_layer :detailed_info do
+      ContextR::with_layer :employment do
+
+        ContextR::active_layers.should ==
+                                    [:employment, :detailed_info]
+      end
+    end
+
+    ContextR::with_layer :detailed_info, :employment do
+
+      ContextR::active_layers.should ==
+                                    [:employment, :detailed_info]
+    end
+  end
+end
+
+describe ContextR do          
+  it "should hide deactivated layers" do
+    ContextR::with_layer :detailed_info, :employment do
+                              
+      ContextR::active_layers.should ==
+                                    [:employment, :detailed_info]
+                              
+      ContextR::without_layer :employment do
+        ContextR::active_layers.should == [:detailed_info]
+      end                     
+                              
+      ContextR::without_layer :detailed_info do
+        ContextR::active_layers.should == [:employment]
+      end
+    end
+  end
+end
+
+describe ContextR do
+  it "should update order at repetitive activation" do
+    ContextR::with_layer :detailed_info, :employment do
+                           
+      ContextR::active_layers.should == [:employment, :detailed_info]
+                           
+      ContextR::with_layer :detailed_info do
+        ContextR::active_layers.should == [:detailed_info, :employment]
+      end                  
+                           
+      ContextR::with_layer :employment do
+        ContextR::active_layers.should == [:employment, :detailed_info]
+      end
+    end                               
+  end 
+end 
+
+describe ContextR do
+  it "should activate layer, even when they were explicitly deactivated" do
+    ContextR::with_layer :detailed_info, :employment do
+      ContextR::without_layer :employment do
+        ContextR::with_layer :employment do
+          ContextR::active_layers.should == [:employment, :detailed_info]
+        end
+      end
+    end
+  end
+end 
+
+describe ContextR do
+  def step(index, *layers)
+    @step += 1
+    @step.should == index
+    ContextR::active_layers.should == layers
+  end
+
+  def task_one
+    @mutex.lock
+    ContextR::with_layer :employment do
+      step(2, :employment, :detailed_info)
+      @mutex.unlock
+      sleep(0.1)
+      @mutex.lock
+      step(4, :employment, :detailed_info)
+    end
+    @mutex.unlock
+  end
+  
+  def task_two
+    @mutex.lock
+    step(3, :detailed_info)
+    @mutex.unlock
+  end
+
+  before do
+    @mutex = Mutex.new
+    @step = 0
+  end
+  
+  it "should consider dynamic scope" do
+    ContextR::with_layer :detailed_info do
+      step(1, :detailed_info)
+    
+      one = Thread.new { task_one }
+      two = Thread.new { task_two }
+      
+      one.join
+      two.join
+      step(5, :detailed_info)
+    end
+  end
+end

data/examples/node.rb

@@ -0,0 +1,213 @@
+require "rubygems"
+require "contextr"
+
+module Cop
+  # Fig. 3
+  class Node
+    attr_accessor :first, :op, :second
+
+    def initialize(values = {})
+      values.each do |key, value|
+        self.send("#{key}=", value)
+      end
+    end
+  end
+  class Leaf
+    attr_accessor :value
+    def initialize(value)
+      self.value = value
+    end
+  end
+
+  # Fig. 4
+  class ExampleTree
+    def initialize
+      @tree = Node.new(
+        :first => Node.new(
+          :first => Node.new(
+            :first => Leaf.new(1),
+            :op => :+,
+            :second => Leaf.new(2)),
+          :op => :*,
+          :second => Node.new(
+            :first => Leaf.new(3),
+            :op => :-,
+            :second => Leaf.new(4))),
+        :op => :/,
+        :second => Leaf.new(5))
+    end
+  end
+
+  # Fig. 5
+  class Node
+    def evaluate
+      # first.evaluate.send(op, second.evaluate.to_f)
+      first.evaluate.send(op, second.evaluate)
+    end
+    def print_prefix
+      "(#{op}#{first.print_prefix}#{second.print_prefix})"
+    end
+    def print_infix
+      "(#{first.print_infix}#{op}#{second.print_infix})"
+    end
+    def print_postfix
+      "(#{first.print_postfix}#{second.print_postfix}#{op})"
+    end
+  end
+
+  class Leaf
+    def evaluate
+      value
+    end
+    def print_infix
+      value.to_s
+    end
+    def print_postfix
+      value.to_s
+    end
+    def print_prefix
+      value.to_s
+    end
+  end
+
+  # Fig. 7
+  class ExampleTree
+    def show
+      puts @tree.print_infix
+      puts @tree.print_prefix
+      puts @tree.print_postfix
+      puts @tree.evaluate
+    end
+  end
+  ExampleTree.new.show
+
+  # Fig. 8
+  class Node
+    def accept(visitor)
+      visitor.visit(self)
+    end
+  end
+  class Leaf 
+    def accept(visitor)
+      visitor.visit(self)
+    end
+  end
+
+  # Fig. 9
+  class Visitor
+    def visit(node_or_leaf)
+      case node_or_leaf
+      when Node
+        visit_node(node_or_leaf)
+      when Leaf
+        visit_leaf(node_or_leaf)
+      end
+    end
+  end
+  class PrintPrefixVisitor < Visitor
+    def visit_leaf(leaf)
+      leaf.value.to_s
+    end
+    def visit_node(node)
+      "(#{node.op}#{node.first.accept(self)}#{node.second.accept(self)})"
+    end
+  end
+  class PrintInfixVisitor < Visitor
+    def visit_leaf(leaf)
+      leaf.value.to_s
+    end
+    def visit_node(node)
+      "(#{node.first.accept(self)}#{node.op}#{node.second.accept(self)})"
+    end
+  end
+  class PrintPostfixVisitor < Visitor
+    def visit_leaf(leaf)
+      leaf.value.to_s
+    end
+    def visit_node(node)
+      "(#{node.first.accept(self)}#{node.second.accept(self)}#{node.op})"
+    end
+  end
+  class EvaluateVisitor < Visitor
+    def visit_leaf(leaf)
+      leaf.value
+    end
+    def visit_node(node)
+      # node.first.accept(self).send(node.op, node.second.accept(self).to_f)
+      node.first.accept(self).send(node.op, node.second.accept(self))
+    end
+  end
+
+  # Fig. 10
+  class ExampleTree
+    def show_visitor
+      puts @tree.accept(PrintInfixVisitor.new)
+      puts @tree.accept(PrintPrefixVisitor.new)
+      puts @tree.accept(PrintPostfixVisitor.new)
+      puts @tree.accept(EvaluateVisitor.new)
+    end
+  end
+  ExampleTree.new.show_visitor
+
+  # Fig. 11
+  class Leaf
+    in_layer :print_prefix do
+      def to_s
+        yield(:receiver).value.to_s
+      end
+    end
+    in_layer :print_infix do
+      def to_s
+        yield(:receiver).value.to_s
+      end
+    end
+    in_layer :print_postfix do
+      def to_s
+        yield(:receiver).value.to_s
+      end
+    end
+    in_layer :evaluate do
+      def evaluate
+        yield(:receiver).value
+      end
+    end
+  end
+  class Node
+    in_layer :print_prefix do
+      def to_s
+        node = yield(:receiver)
+        "(#{node.op}#{node.first}#{node.second})"
+      end
+    end
+    in_layer :print_infix do
+      def to_s
+        node = yield(:receiver)
+        "(#{node.first}#{node.op}#{node.second})"
+      end
+    end
+    in_layer :print_postfix do
+      def to_s
+        node = yield(:receiver)
+        "(#{node.first}#{node.second}#{node.op})"
+      end
+    end
+    in_layer :evaluate do
+      def evaluate
+        node = yield(:receiver)
+        # node.first.evaluate.send(node.op, node.second.evaluate.to_f)
+        node.first.evaluate.send(node.op, node.second.evaluate)
+      end
+    end
+  end
+
+  # Fig. 12
+  class ExampleTree
+    def show_layers
+      ContextR::with_layer(:print_infix) { puts @tree }
+      ContextR::with_layer(:print_prefix) { puts @tree }
+      ContextR::with_layer(:print_postfix) { puts @tree }
+      ContextR::with_layer(:evaluate) { puts @tree.evaluate }
+    end
+  end
+  ExampleTree.new.show_layers
+end