phenomenal 0.9.0 → 0.11.11.24.3

data/lib/phenomenal/dsl.rb

@@ -8,16 +8,17 @@ module Phenomenal::DSL
         Phenomenal::Context.new(name,priority)     
       end
       # Define context with adaptations
-      def phen_context(context,*contexts,&block)
-        Phenomenal::Context.create(context,*contexts,false,nil,&block)
+      def phen_context(*args,&block)
+        Phenomenal::Context.create(*args,&block)
       end
-      Phenomenal::DSL.phen_alias(:context,klass)
+      #TODO check kernel repond to method
+      alias_method :context, :phen_context
       
       # Define context with adaptations
-      def phen_feature(context,*contexts,&block)
-        Phenomenal::Feature.create(context,*contexts,false,nil,&block)
+      def phen_feature(*args,&block)
+        Phenomenal::Context.create_feature(*args,&block)
       end
-      Phenomenal::DSL.phen_alias(:feature,klass)
+      alias_method :feature, :phen_feature
       
       
       # Forget Context
@@ -28,26 +29,14 @@ module Phenomenal::DSL
       # Add adaptation
       def phen_add_adaptation(context,klass, method_name, &implementation)
         Phenomenal::Manager.instance.find_context(context).add_adaptation(
-          klass, method_name,true, &implementation
-        )
-      end
-      
-      def phen_add_class_adaptation(context,klass, method_name, &implementation)
-        Phenomenal::Manager.instance.find_context(context).add_adaptation(
-          klass, method_name,false, &implementation
+          klass, method_name, &implementation
         )
       end
       
       # Remove Adaptation
       def phen_remove_adaptation(context,klass,method_name) 
         Phenomenal::Manager.instance.find_context(context).remove_adaptation(
-          klass,method_name,true
-        )
-      end
-      
-      def phen_remove_class_adaptation(context,klass,method_name) 
-        Phenomenal::Manager.instance.find_context(context).remove_adaptation(
-          klass,method_name,false
+          klass,method_name
         )
       end
       
@@ -55,13 +44,13 @@ module Phenomenal::DSL
       def phen_activate_context(context)
         Phenomenal::Manager.instance.find_context(context).activate
       end
-      Phenomenal::DSL.phen_alias(:activate_context,klass)
+      alias_method :activate_context, :phen_activate_context
       
       # Deactivate Context
       def phen_deactivate_context(context)
         Phenomenal::Manager.instance.find_context(context).deactivate   
       end
-      Phenomenal::DSL.phen_alias(:deactivate_context,klass)
+      alias_method :deactivate_context, :phen_deactivate_context
       
       # Context is active?
       def phen_context_active?(context)
@@ -69,8 +58,8 @@ module Phenomenal::DSL
       end
       
       # Context informations
-      def phen_context_information(context)
-        Phenomenal::Manager.instance.find_context(context).information
+      def phen_context_informations(context)
+        Phenomenal::Manager.instance.find_context(context).informations
       end
       
       # Default Context
@@ -87,29 +76,13 @@ module Phenomenal::DSL
       def phen_proceed(*args,&block)
         Phenomenal::Manager.instance.proceed(caller,self,*args,&block)
       end
-      Phenomenal::DSL.phen_alias(:proceed,klass)
+      alias_method :proceed, :phen_proceed
 
       # Change conflict resolution policy (for the proceed call)
       def phen_change_conflict_policy(&block)
         Phenomenal::Manager.instance.change_conflict_policy(&block) 
       end
     end
-    # Add relationships specific DSL
-    define_relationships(klass)
-  end
-  
-  private
-  def self.phen_alias(method,klass)
-    if Kernel.respond_to? method
-      Phenomenal::Logger.instance.warn(
-        "The Phenomenal DSL keyword #{method} wasn't defined, use"+
-        " phen_#{method} instead"
-      )
-    else
-      klass.class_eval do
-        alias_method method, "phen_#{method}"
-      end
-    end
   end
 end
 

data/lib/phenomenal/logger.rb

@@ -20,6 +20,7 @@ class Phenomenal::Logger
   end
   
   def error(msg)
+    logger.error(msg)
     raise(Phenomenal::Error, msg)
   end
   

data/lib/phenomenal/manager.rb

@@ -4,8 +4,8 @@ class Phenomenal::Manager
   include Singleton
   include Phenomenal::ConflictPolicies
   
-  attr_accessor :active_adaptations, :deployed_adaptations, :contexts, 
-:default_context, :combined_contexts, :shared_contexts, :rmanager
+  attr_accessor :active_adaptations, :deployed_adaptations, 
+    :contexts, :default_context
   
   # Register a new context 
   def register_context(context)
@@ -20,7 +20,7 @@ class Phenomenal::Manager
         " If you want to have named context it has to be a globally unique name"
       )
     end
-    contexts[context]=context
+    contexts[context.__id__]=context
   end
   
   # Unregister a context (forget)
@@ -30,17 +30,7 @@ class Phenomenal::Manager
         "Default context can only be forgotten when alone"
       )
     else
-      contexts.delete(context)
-      
-      # Forgot combined contexts
-      combined_contexts.delete(context)
-      if shared_contexts[context]
-        shared_contexts[context].each do |c|
-          c.forget
-        end
-      end
-      
-      # Restore default context
+      contexts.delete(context.__id__)
       init_default() if context==default_context
     end
   end
@@ -48,10 +38,10 @@ class Phenomenal::Manager
   # Register a new adaptation for a registered context
   def register_adaptation(adaptation)
     default_adaptation = default_context.adaptations.find do|i| 
-      i.concern?(adaptation.klass,adaptation.method_name,adaptation.instance_adaptation?)
+      i.concern?(adaptation.klass,adaptation.method_name)
     end
     if adaptation.context!=default_context && !default_adaptation
-      save_default_adaptation(adaptation.klass, adaptation.method_name,adaptation.instance_adaptation?)
+      save_default_adaptation(adaptation.klass, adaptation.method_name)
     end
     activate_adaptation(adaptation) if adaptation.context.active?
   end
@@ -64,23 +54,7 @@ class Phenomenal::Manager
   # Activate the context 'context' and deploy the related adaptation
   def activate_context(context)
     begin
-      # Relationships managment
-      rmanager.activate_relationships(context) if context.just_activated?
-      
-      # Activation of adaptations
       context.adaptations.each{ |i| activate_adaptation(i) }
-      #puts "activation of #{context}"
-      if shared_contexts[context]
-        #puts "trigger activation of #{shared_contexts[context].first.information}"
-        shared_contexts[context].each do |combined_context|
-          need_activation=true
-          combined_contexts[combined_context].each do |shared_context|
-            need_activation=false if !shared_context.active?
-          end
-          combined_context.activate if need_activation
-        end
-      end
-      
     rescue Phenomenal::Error
       context.deactivate # rollback the deployed adaptations
       raise # throw up the exception
@@ -89,30 +63,19 @@ class Phenomenal::Manager
   
   # Deactivate the adaptations (undeploy if needed)
   def deactivate_context(context)
-    #Relationships managment
-    rmanager.deactivate_relationships(context)
-    #Adaptations deactivation
-    context.adaptations.each do |i| 
-      deactivate_adaptation(i) 
-    end
-    if shared_contexts[context]
-      shared_contexts[context].each do |combined_context|
-        while combined_context.active? do
-         combined_context.deactivate
-        end
-      end
-    end
+    context.adaptations.each{ |i| 
+    deactivate_adaptation(i) }
   end
   
   # Call the old implementation of the method 'caller.caller_method'
   def proceed(calling_stack,instance,*args,&block)
     calling_adaptation = find_adapatation(calling_stack)
-    # IMPROVE Problems will appears if proceed called in a file where
+    #TODO Problems will appears if proceed called in a file where
     # adaptations are defined but not in one of them=> how to check?
-    # IMPROVE Problems will also appears if two adaptations are defined on the same
+    #TODO Problems will also appears if two adaptations are defined on the same
     # line using the ';' some check needed at add_adaptation ?
     adaptations_stack = sorted_adaptations_for(calling_adaptation.klass,  
-      calling_adaptation.method_name,calling_adaptation.instance_adaptation?)
+      calling_adaptation.method_name)
     calling_adaptation_index = adaptations_stack.find_index(calling_adaptation)
 
     next_adaptation = adaptations_stack[calling_adaptation_index+1]
@@ -131,38 +94,15 @@ class Phenomenal::Manager
   # currently registered.
   # The 'context' parameter can be either a reference to a context instance or
   # a Symbol with the name of a named (not anonymous) context.
-  def find_context(context, *contexts)
-    if contexts.length==0
-      find_simple_context(context)
-    else #Combined contexts
-      contexts.insert(0,context)
-      find_combined_context(contexts)
-    end
-  end
-  
-  # Check wether context 'context' exist in the context manager
-  # Context can be either the context name or the context instance itself
-  # Return the context if found, or nil otherwise
-  def context_defined?(context, *contexts)
-    c=nil
-    begin
-      c = find_context(context,*contexts)
-    rescue Phenomenal::Error
-      return nil
-    end
-    return c
-  end
-  # ==== Private methods ==== #
-  private
-  def find_simple_context(context)
+  def find_context(context)
     find=nil
-    if !context.kind_of?(Phenomenal::Context)
+    if context.class!=Phenomenal::Context
       a = contexts.find{|k,v| v.name==context}
       if a
         find = a[1]
       end
     else
-      find = context if contexts.has_key?(context)
+      find = context if contexts.has_key?(context.__id__)
     end
     if find
       find
@@ -172,43 +112,24 @@ class Phenomenal::Manager
       )
     end
   end
-  
-  def find_combined_context(contexts)
-    list=Array.new
-    contexts.each do |c|
-      # Use the object instance if already available
-      # otherwise use the symbol name
-      c = find_simple_context(c) if context_defined?(c)
-      if shared_contexts[c]==nil
-        list.clear
-        break
-      elsif list.length==0
-        # clone otherwise list.clear empty shared_contexts[c]
-        list=shared_contexts[c].clone 
-      else
-          list=shared_contexts[c].find_all{|i| list.include?(i) } 
-      end
-    end
-    if list.length==0
-      Phenomenal::Logger.instance.error(
-        "Unknown combined context #{contexts}"
-      )
-    elsif list.length==1
-      return list.first
+  # Check wether context 'context' exist in the context manager
+  # Context can be either the context name or the context instance itself
+  def context_defined?(context)
+    if context.class==Phenomenal::Context
+      contexts.has_key?(context.__id__)
     else
-      Phenomenal::Logger.instance.error(
-        "Multiple definition of combined context #{contexts}"
-      )
+      contexts.find{|k,v| v.name==context}!=nil
     end
   end
-  
+  # ==== Private methods ==== #
+  private
   # Activate the adaptation and redeploy the adaptations to take the new one
   # one in account
   def activate_adaptation(adaptation)
     if !active_adaptations.include?(adaptation)
       active_adaptations.push(adaptation)
     end
-    redeploy_adaptation(adaptation.klass,adaptation.method_name,adaptation.instance_adaptation?)
+    redeploy_adaptation(adaptation.klass,adaptation.method_name)
   end
   
   # Deactivate the adaptation and redeploy the adaptations if necessary
@@ -216,14 +137,14 @@ class Phenomenal::Manager
     active_adaptations.delete(adaptation)
     if deployed_adaptations.include?(adaptation)
       deployed_adaptations.delete(adaptation)
-      redeploy_adaptation(adaptation.klass,adaptation.method_name,adaptation.instance_adaptation?)
+      redeploy_adaptation(adaptation.klass,adaptation.method_name)
     end
   end
   
   # Redeploy the adaptations concerning klass.method_name according to the
   # conflict policy
-  def redeploy_adaptation(klass, method_name,instance)
-    to_deploy = resolve_conflict(klass,method_name,instance)
+  def redeploy_adaptation(klass, method_name)
+    to_deploy = resolve_conflict(klass,method_name)
     # Do nothing when to_deploy==nil to break at default context deactivation
     if !deployed_adaptations.include?(to_deploy) && to_deploy!=nil
       deploy_adaptation(to_deploy)
@@ -233,7 +154,7 @@ class Phenomenal::Manager
   # Deploy the adaptation
   def deploy_adaptation(adaptation)
     to_undeploy = deployed_adaptations.find do |i|
-                          i.concern?(adaptation.klass,adaptation.method_name,adaptation.instance_adaptation?)
+                          i.concern?(adaptation.klass,adaptation.method_name)
                         end
     if to_undeploy!=adaptation # if new adaptation
       deployed_adaptations.delete(to_undeploy)
@@ -243,13 +164,13 @@ class Phenomenal::Manager
   end
   
   # Save the default adaptation of a method, ie: the initial method
-  def save_default_adaptation(klass, method_name,instance)
-    if instance
+  def save_default_adaptation(klass, method_name)
+    if klass.instance_methods.include?(method_name)
       method = klass.instance_method(method_name)
     else
       method = klass.method(method_name)
     end
-    adaptation = default_context.add_adaptation(klass,method_name,instance,method)
+    adaptation = default_context.add_adaptation(klass,method_name,method)
   end
   
   # Return the adaptation that math the calling_stack, on the basis of the
@@ -281,15 +202,15 @@ class Phenomenal::Manager
   end
   
    # Return the best adaptation according to the resolution policy
-  def resolve_conflict(klass,method_name,instance)
-    sorted_adaptations_for(klass,method_name,instance).first
+  def resolve_conflict(klass,method_name)
+    sorted_adaptations_for(klass,method_name).first
   end
   
   # Return the adaptations for a particular method sorted with the
   # conflict policy
-  def sorted_adaptations_for(klass,method_name,instance)
+  def sorted_adaptations_for(klass,method_name)
     relevant_adaptations =
-      active_adaptations.find_all { |i| i.concern?(klass, method_name,instance) }
+      active_adaptations.find_all { |i| i.concern?(klass, method_name) }
     relevant_adaptations.sort!{|a,b| conflict_policy(a,b)}
   end
   
@@ -300,7 +221,7 @@ class Phenomenal::Manager
   
    # Set the default context
   def init_default
-    self.default_context= Phenomenal::Feature.new(nil,self)
+    self.default_context= Phenomenal::Context.new(nil,nil,true,self)
     self.default_context.activate
   end
 
@@ -309,9 +230,6 @@ class Phenomenal::Manager
     @contexts = Hash.new
     @deployed_adaptations = Array.new
     @active_adaptations = Array.new
-    @combined_contexts = Hash.new
-    @shared_contexts = Hash.new
-    @rmanager = Phenomenal::RelationshipsManager.instance
     init_default()
   end
 end

data/phenomenal.gemspec

@@ -0,0 +1,15 @@
+Gem::Specification.new do |s|
+   s.name = "phenomenal"
+   s.summary = "A context oriented programing framework for ruby"
+   s.description = File.read(File.join(File.dirname(__FILE__),'README'))
+   s.version = "0.11.11.24.3"
+   s.authors = "Loic Vigneron - Thibault Poncelet"
+   s.email = "thibault.poncelet@student.uclouvain.be - loic.vigneron@student.uclouvain.be"
+   s.date = "2011-10-07"
+   s.platform = Gem::Platform::RUBY
+   s.required_ruby_version = '>=1.9.2'
+   s.files = Dir['**/**']
+   s.has_rdoc = false
+   s.test_files = Dir['test/*.rb']
+   s.homepage    = "http://www.phenomenal-gem.com"
+end

data/{spec → test}/test_classes.rb

@@ -1,7 +1,4 @@
 # Define the test classes
-class TestString < String
-end
-
 class TestClass < String
   @klass_inst_var = 2
   @@klass_var = 1

data/test/test_cop_adaptation.rb

@@ -0,0 +1,168 @@
+require_relative "../lib/phenomenal.rb"
+require_relative "./test_classes.rb"
+require "test/unit"
+
+class TestCopAdaptation < Test::Unit::TestCase
+  def setup
+    phen_define_context(:quiet)
+    phen_define_context(:offHook)
+    phen_add_adaptation(:quiet,Phone,:advertise){|a_call| "vibrator" }
+    phen_add_adaptation(:offHook,Phone,:advertise) do |a_call|
+                                                      "call waiting signal"
+                                                    end
+    phen_define_context(:test)
+    phen_add_adaptation(:test,TestClass,:to_s) do
+      @value + " @access " + value + " attr_accessor_access"
+    end
+
+    phen_define_context(:test_2)
+    phen_add_adaptation(:test_2,TestClass,:klass_var_access) do
+      @@klass_var+1
+    end
+
+    phen_define_context(:test_3)
+    phen_add_adaptation(:test_3,TestClass,:klass_inst_var_access) do
+      @klass_inst_var+1
+    end
+  end
+
+  def teardown
+    while phen_context_active?(:quiet) do
+      phen_deactivate_context(:quiet)
+    end
+    phen_forget_context(:quiet)
+
+    while phen_context_active?(:offHook) do
+      phen_deactivate_context(:offHook)
+    end
+    phen_forget_context(:offHook)
+
+    while phen_context_active?(:test) do
+      phen_deactivate_context(:test)
+    end
+    phen_forget_context(:test)
+
+    while phen_context_active?(:test_2) do
+      phen_deactivate_context(:test_2)
+    end
+    phen_forget_context(:test_2)
+
+    while phen_context_active?(:test_3) do
+      phen_deactivate_context(:test_3)
+    end
+    phen_forget_context(:test_3)
+  end
+
+  def test_overriding_adaptation
+    phone = Phone.new
+    call = Call.new("Bob")
+  	phone.receive(call)
+  	assert((phone.advertise(call))=="ringtone",
+  	  "Default behaviour should be expressed")
+  	phen_activate_context(:quiet)
+  	assert((phone.advertise(call))=="vibrator",
+  	  "Behavior adapted to quiet environments should be expressed")
+  	phen_deactivate_context(:quiet)
+  	assert((phone.advertise(call))=="ringtone",
+  	  "Default behaviour should be expressed")
+	end
+
+  def test_conflicting_adaptation
+    assert_raise(Phenomenal::Error,
+      "A context cannot have two different adaptations for the same method.")do
+        phen_add_adaptation(:quiet,Phone,:advertise) do |a_call|
+                                                        "call waiting signal"
+                                                      end
+      end
+  end
+
+  def test_invalid_adaptation
+    phen_define_context(:temp)
+    assert_raise(Phenomenal::Error,
+      "Adaptation of inexistent methods should be forbidden.") do
+        phen_add_adaptation(:temp,Phone,:phonyAdvertise){|a_call| "vibrator"}
+      phen_activate_context(:temp)
+     end
+    phen_forget_context(:temp)
+  end
+
+  def test_conflicting_activation
+    assert(!phen_context_active?(:quiet))
+    assert_nothing_raised(Phenomenal::Error,
+      "Shoud be OK to activate the quiet context") do 
+        phen_activate_context(:quiet) 
+      end
+    assert(phen_context_active?(:quiet))
+    assert(!phen_context_active?(:offHook))
+    assert_raise(Phenomenal::Error,
+      "Should conflict with currently active quiet context") do
+        phen_activate_context(:offHook)
+      end
+    assert(!phen_context_active?(:offHook),
+      "Should not be mistakenly activated after error")
+  end
+
+  def test_runtime_adding_removing_adaptation
+    phone = Phone.new
+    call = Call.new("Bob")
+  	phone.receive(call)
+    phen_activate_context(:quiet)
+    assert(phen_context_active?(:quiet))
+    assert_nothing_raised("Should be ok to remove an active adaptation") do
+      phen_remove_adaptation(:quiet,Phone,:advertise)
+    end
+    assert((phone.advertise(call))=="ringtone",
+  	  "Default behaviour should be expressed")
+    assert_nothing_raised("Should be ok to add an active adaptation") do
+      phen_add_adaptation(:quiet,Phone,:advertise){|a_call| "vibrator" }
+    end
+    assert((phone.advertise(call))=="vibrator",
+      "Adapted behaviour should be expressed")
+    assert_nothing_raised("Should be ok to deactivate the context") do
+      phen_deactivate_context(:quiet)
+    end
+    assert((phone.advertise(call))=="ringtone",
+  	  "Default behaviour should be expressed")
+  end
+
+  def test_instance_variable_access
+    t = TestClass.new("VAR")
+    assert("VAR"==t.to_s, %(Default to_s should acess var and return
+                            string value))
+    phen_activate_context(:test)
+    assert("VAR @access VAR attr_accessor_access"==t.to_s, %(Adapted to_s should
+             acess both instance var and accessor meth and return string value))
+    phen_deactivate_context(:test)
+    assert("VAR"==t.to_s, %(Default to_s should acess var and return
+    string value))
+  end
+
+  def test_class_variable_access
+    assert(1==TestClass.klass_var_access, %(Default meth should acess var and
+                                            return val))
+    phen_activate_context(:test_2)
+
+    # Doesn't work:  Adaptations doesn't have access to class variables
+    # Seems to be a Ruby bug
+    #TODO
+
+    #assert(2==TestClass.klass_var_access, %(Adapted meth should
+    #         acess klass variable and return its value +1))
+    phen_deactivate_context(:test_2)
+     assert(1==TestClass.klass_var_access, %(Default meth should acess var and
+                                            return val))
+  end
+
+  def test_class_instance_variable_access
+    assert(2==TestClass.klass_inst_var_access, %(Default meth should acess var
+                                            and return val))
+    phen_activate_context(:test_3)
+
+    assert(3==TestClass.klass_inst_var_access, %(Adapted meth should
+             acess klass variable and return its value +1))
+    phen_deactivate_context(:test_3)
+     assert(2==TestClass.klass_inst_var_access, %(Default meth should acess var
+                                                  and return string value))
+  end
+end
+