phenomenal 0.11.11.24.4 → 0.99.0

data/lib/phenomenal/dsl.rb

@@ -8,17 +8,16 @@ module Phenomenal::DSL
         Phenomenal::Context.new(name,priority)     
       end
       # Define context with adaptations
-      def phen_context(*args,&block)
-        Phenomenal::Context.create(*args,&block)
+      def phen_context(context,*contexts,&block)
+        Phenomenal::Context.create(context,*contexts,false,nil,&block)
       end
-      #TODO check kernel repond to method
-      alias_method :context, :phen_context
+      Phenomenal::DSL.phen_alias(:context,klass)
       
       # Define context with adaptations
-      def phen_feature(*args,&block)
-        Phenomenal::Context.create_feature(*args,&block)
+      def phen_feature(context,*contexts,&block)
+        Phenomenal::Feature.create(context,*contexts,false,nil,&block)
       end
-      alias_method :feature, :phen_feature
+      Phenomenal::DSL.phen_alias(:feature,klass)
       
       
       # Forget Context
@@ -29,14 +28,26 @@ 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, &implementation
+          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
         )
       end
       
       # Remove Adaptation
       def phen_remove_adaptation(context,klass,method_name) 
         Phenomenal::Manager.instance.find_context(context).remove_adaptation(
-          klass,method_name
+          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
         )
       end
       
@@ -44,13 +55,13 @@ module Phenomenal::DSL
       def phen_activate_context(context)
         Phenomenal::Manager.instance.find_context(context).activate
       end
-      alias_method :activate_context, :phen_activate_context
+      Phenomenal::DSL.phen_alias(:activate_context,klass)
       
       # Deactivate Context
       def phen_deactivate_context(context)
         Phenomenal::Manager.instance.find_context(context).deactivate   
       end
-      alias_method :deactivate_context, :phen_deactivate_context
+      Phenomenal::DSL.phen_alias(:deactivate_context,klass)
       
       # Context is active?
       def phen_context_active?(context)
@@ -58,8 +69,8 @@ module Phenomenal::DSL
       end
       
       # Context informations
-      def phen_context_informations(context)
-        Phenomenal::Manager.instance.find_context(context).informations
+      def phen_context_information(context)
+        Phenomenal::Manager.instance.find_context(context).information
       end
       
       # Default Context
@@ -76,13 +87,29 @@ module Phenomenal::DSL
       def phen_proceed(*args,&block)
         Phenomenal::Manager.instance.proceed(caller,self,*args,&block)
       end
-      alias_method :proceed, :phen_proceed
+      Phenomenal::DSL.phen_alias(:proceed,klass)
 
       # 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/feature.rb

@@ -0,0 +1,8 @@
+class Phenomenal::Feature < Phenomenal::Context
+  include Phenomenal::FeatureRelationships
+
+  def initialize(name=nil,manager=nil)
+    super(name,manager)
+    initialize_relationships
+  end
+end

data/lib/phenomenal/logger.rb

@@ -20,7 +20,6 @@ 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
+  attr_accessor :active_adaptations, :deployed_adaptations, :contexts, 
+:default_context, :combined_contexts, :shared_contexts, :rmanager
   
   # 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.__id__]=context
+    contexts[context]=context
   end
   
   # Unregister a context (forget)
@@ -30,7 +30,17 @@ class Phenomenal::Manager
         "Default context can only be forgotten when alone"
       )
     else
-      contexts.delete(context.__id__)
+      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
       init_default() if context==default_context
     end
   end
@@ -38,10 +48,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)
+      i.concern?(adaptation.klass,adaptation.method_name,adaptation.instance_adaptation?)
     end
     if adaptation.context!=default_context && !default_adaptation
-      save_default_adaptation(adaptation.klass, adaptation.method_name)
+      save_default_adaptation(adaptation.klass, adaptation.method_name,adaptation.instance_adaptation?)
     end
     activate_adaptation(adaptation) if adaptation.context.active?
   end
@@ -54,7 +64,23 @@ 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
@@ -63,19 +89,30 @@ class Phenomenal::Manager
   
   # Deactivate the adaptations (undeploy if needed)
   def deactivate_context(context)
-    context.adaptations.each{ |i| 
-    deactivate_adaptation(i) }
+    #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
   end
   
   # Call the old implementation of the method 'caller.caller_method'
   def proceed(calling_stack,instance,*args,&block)
     calling_adaptation = find_adapatation(calling_stack)
-    #TODO Problems will appears if proceed called in a file where
+    # IMPROVE Problems will appears if proceed called in a file where
     # adaptations are defined but not in one of them=> how to check?
-    #TODO Problems will also appears if two adaptations are defined on the same
+    # IMPROVE 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.method_name,calling_adaptation.instance_adaptation?)
     calling_adaptation_index = adaptations_stack.find_index(calling_adaptation)
 
     next_adaptation = adaptations_stack[calling_adaptation_index+1]
@@ -94,15 +131,38 @@ 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)
+  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)
     find=nil
-    if context.class!=Phenomenal::Context
+    if !context.kind_of?(Phenomenal::Context)
       a = contexts.find{|k,v| v.name==context}
       if a
         find = a[1]
       end
     else
-      find = context if contexts.has_key?(context.__id__)
+      find = context if contexts.has_key?(context)
     end
     if find
       find
@@ -112,24 +172,43 @@ class Phenomenal::Manager
       )
     end
   end
-  # 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__)
+  
+  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
     else
-      contexts.find{|k,v| v.name==context}!=nil
+      Phenomenal::Logger.instance.error(
+        "Multiple definition of combined context #{contexts}"
+      )
     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)
+    redeploy_adaptation(adaptation.klass,adaptation.method_name,adaptation.instance_adaptation?)
   end
   
   # Deactivate the adaptation and redeploy the adaptations if necessary
@@ -137,14 +216,14 @@ class Phenomenal::Manager
     active_adaptations.delete(adaptation)
     if deployed_adaptations.include?(adaptation)
       deployed_adaptations.delete(adaptation)
-      redeploy_adaptation(adaptation.klass,adaptation.method_name)
+      redeploy_adaptation(adaptation.klass,adaptation.method_name,adaptation.instance_adaptation?)
     end
   end
   
   # Redeploy the adaptations concerning klass.method_name according to the
   # conflict policy
-  def redeploy_adaptation(klass, method_name)
-    to_deploy = resolve_conflict(klass,method_name)
+  def redeploy_adaptation(klass, method_name,instance)
+    to_deploy = resolve_conflict(klass,method_name,instance)
     # 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)
@@ -154,7 +233,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)
+                          i.concern?(adaptation.klass,adaptation.method_name,adaptation.instance_adaptation?)
                         end
     if to_undeploy!=adaptation # if new adaptation
       deployed_adaptations.delete(to_undeploy)
@@ -164,13 +243,13 @@ class Phenomenal::Manager
   end
   
   # Save the default adaptation of a method, ie: the initial method
-  def save_default_adaptation(klass, method_name)
-    if klass.instance_methods.include?(method_name)
+  def save_default_adaptation(klass, method_name,instance)
+    if instance
       method = klass.instance_method(method_name)
     else
       method = klass.method(method_name)
     end
-    adaptation = default_context.add_adaptation(klass,method_name,method)
+    adaptation = default_context.add_adaptation(klass,method_name,instance,method)
   end
   
   # Return the adaptation that math the calling_stack, on the basis of the
@@ -202,15 +281,15 @@ class Phenomenal::Manager
   end
   
    # Return the best adaptation according to the resolution policy
-  def resolve_conflict(klass,method_name)
-    sorted_adaptations_for(klass,method_name).first
+  def resolve_conflict(klass,method_name,instance)
+    sorted_adaptations_for(klass,method_name,instance).first
   end
   
   # Return the adaptations for a particular method sorted with the
   # conflict policy
-  def sorted_adaptations_for(klass,method_name)
+  def sorted_adaptations_for(klass,method_name,instance)
     relevant_adaptations =
-      active_adaptations.find_all { |i| i.concern?(klass, method_name) }
+      active_adaptations.find_all { |i| i.concern?(klass, method_name,instance) }
     relevant_adaptations.sort!{|a,b| conflict_policy(a,b)}
   end
   
@@ -221,7 +300,7 @@ class Phenomenal::Manager
   
    # Set the default context
   def init_default
-    self.default_context= Phenomenal::Context.new(nil,nil,true,self)
+    self.default_context= Phenomenal::Feature.new(nil,self)
     self.default_context.activate
   end
 
@@ -230,6 +309,9 @@ 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/lib/phenomenal/relationships/context_relationships.rb

@@ -0,0 +1,22 @@
+module Phenomenal::ContextRelationships
+  def requires(context,*contexts)
+    contexts = contexts.push(context)
+    contexts.each do |target|
+      self.parent_feature.requirements_for(self,{:on=>target})
+    end
+  end
+  
+  def implies(context,*contexts)
+    contexts = contexts.push(context)
+    contexts.each do |target|
+      self.parent_feature.implications_for(self,{:on=>target})
+    end
+  end
+  
+  def suggests(context,*contexts)
+    contexts = contexts.push(context)
+    contexts.each do |target|
+      self.parent_feature.suggestions_for(self,{:on=>target})
+    end
+  end
+end

data/lib/phenomenal/relationships/dsl.rb

@@ -0,0 +1,18 @@
+module Phenomenal::DSL
+  def self.define_relationships(klass)
+    klass.class_eval do
+      # Requirements
+      def requirements_for(source,targets)
+        Phenomenal::Manager.instance.default_context.requirements_for(source,targets)
+      end
+       # Implications
+      def implications_for(source,targets)
+        Phenomenal::Manager.instance.default_context.implications_for(source,targets)
+      end
+       # Suggestions
+      def suggestions_for(source,targets)
+        Phenomenal::Manager.instance.default_context.suggestions_for(source,targets)
+      end
+    end
+  end
+end