phenomenal 1.1.0 → 1.1.1

data/README.md

@@ -1,4 +1,4 @@
-Phenomenal Gem
+Phenomenal Gem [![Build Status](https://secure.travis-ci.org/phenomenal/phenomenal.png)](http://travis-ci.org/phenomenal/phenomenal)
 ===
 Phenomenal Gem is a context-oriented framework implemented in Ruby that allows context-oriented programming in Ruby and Ruby on Rails applications. 
 

data/lib/phenomenal.rb

@@ -14,11 +14,16 @@ require_relative "./phenomenal/relationships/suggestion.rb"
 
 # Core
 require_relative "./phenomenal/adaptation.rb"
-require_relative "./phenomenal/conflict_policies.rb"
+
 require_relative "./phenomenal/context.rb"
 require_relative "./phenomenal/feature.rb"
 require_relative "./phenomenal/logger.rb"
-require_relative "./phenomenal/manager.rb"
+
+#Manager
+require_relative "./phenomenal/manager/adaptations_management.rb"
+require_relative "./phenomenal/manager/contexts_management.rb"
+require_relative "./phenomenal/manager/conflict_policies.rb"
+require_relative "./phenomenal/manager/manager.rb"
 
 # Viewer
 require_relative "./phenomenal/viewer/graphical.rb"

data/lib/phenomenal/context.rb

@@ -7,12 +7,24 @@ class Phenomenal::Context
     :activation_count, :parent, :forgotten
   attr_reader :manager,:name
   
-  def self.create(context,*contexts,nested,closest_feature,&block)
-    manager = Phenomenal::Manager.instance
-    contexts.insert(0,context)
-    if contexts.length==1
+  # Class metods
+  class << self
+    def create(context,*contexts,nested,closest_feature,&block)
+      manager = Phenomenal::Manager.instance
+      contexts.insert(0,context)
+      if contexts.length==1
+        context = find_or_create_simple_context(manager,context)
+      else #Combined contexts
+        context = find_or_create_combined_context(manager,contexts,nested,closest_feature)
+      end
+      context.add_adaptations(&block)
+      context
+    end
+    
+    private
+    def find_or_create_simple_context(manager,context)
       if !manager.context_defined?(context)
-        context = self.new(context) 
+        self.new(context) 
       else
         context = manager.find_context(context)
         if !context.instance_of?(self)
@@ -20,31 +32,13 @@ class Phenomenal::Context
             "Only #{self.name} can be used with this keyword."
           )
         end
+        context
       end
-    else #Combined contexts
+    end
+    
+    def find_or_create_combined_context(manager,contexts,nested,closest_feature)
       if !manager.context_defined?(*contexts) # New combined context
-        context = self.new
-        context.parent=closest_feature # Set parent
-        instances = Array.new
-        first = contexts.first
-        contexts.each do |c|
-          # Use the object instance if already available
-          # otherwise create it
-          if manager.context_defined?(c)
-            c = manager.find_context(c) 
-            if !nested && c!=first && !c.instance_of?(self)
-              Phenomenal::Logger.instance.error(
-                "Only #{self.name} can be used with this keyword."
-              )
-            end
-          else
-            c = self.new(c) 
-          end
-          instances.push(c)
-          manager.shared_contexts[c]= Array.new if !manager.shared_contexts[c]
-          manager.shared_contexts[c].push(context)
-        end
-        manager.combined_contexts[context] = instances
+        context = create_combined_context(manager,contexts,nested,closest_feature)
       else
         context = manager.find_context(*contexts)
         if !context.instance_of?(self)
@@ -53,11 +47,37 @@ class Phenomenal::Context
           )
         end
       end
+      context
+    end
+    
+    def create_combined_context(manager,contexts,nested,closest_feature)
+      context = self.new
+      context.parent=closest_feature # Set parent
+      instances = Array.new
+      first = contexts.first
+      contexts.each do |c|
+        # Use the object instance if already available
+        # otherwise create it
+        if manager.context_defined?(c)
+          c = manager.find_context(c) 
+          if !nested && c!=first && !c.instance_of?(self)
+            Phenomenal::Logger.instance.error(
+              "Only #{self.name} can be used with this keyword."
+            )
+          end
+        else
+          c = self.new(c) 
+        end
+        instances.push(c)
+        manager.shared_contexts[c]= Array.new if !manager.shared_contexts[c]
+        manager.shared_contexts[c].push(context)
+      end
+      manager.combined_contexts[context] = instances
+      context
     end
-    context.add_adaptations(&block)
-    context
   end
   
+  # Instance methods
   def initialize(name=nil, manager=nil)
     @manager = manager || Phenomenal::Manager.instance
     @name = name
@@ -94,7 +114,6 @@ class Phenomenal::Context
     end
     if umeth
       implementation = umeth
-      instance = klass.instance_methods.include?(method_name)
     end
     if adaptations.find{ |i| i.concern?(klass,method_name,instance) }
       Phenomenal::Logger.instance.error(

data/lib/phenomenal/manager/adaptations_management.rb

@@ -0,0 +1,134 @@
+module Phenomenal::AdaptationsManagement
+  attr_accessor :active_adaptations, :deployed_adaptations
+  
+  # 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?)
+    end
+    if adaptation.context!=default_context && !default_adaptation
+      save_default_adaptation(adaptation.klass, adaptation.method_name,adaptation.instance_adaptation?)
+    end
+    activate_adaptation(adaptation) if adaptation.context.active?
+  end
+  
+  # Unregister an adaptation for a registered context
+  def unregister_adaptation(adaptation)
+    deactivate_adaptation(adaptation) if adaptation.context.active?
+  end
+  
+  # Call the old implementation of the method 'caller.caller_method'
+  def proceed(calling_stack,instance,*args,&block)
+    calling_adaptation = find_adaptation(calling_stack)
+    # IMPROVE 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
+    # 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_index = adaptations_stack.find_index(calling_adaptation)
+    next_adaptation = adaptations_stack[calling_adaptation_index+1]
+    next_adaptation.bind(instance,*args, &block)
+  end
+  
+  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?)
+  end
+  
+  # Deactivate the adaptation and redeploy the adaptations if necessary
+  def deactivate_adaptation(adaptation)
+    active_adaptations.delete(adaptation)
+    if deployed_adaptations.include?(adaptation)
+      deployed_adaptations.delete(adaptation)
+      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,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)
+    end
+  end
+  
+  # Deploy the adaptation
+  def deploy_adaptation(adaptation)
+    to_undeploy = deployed_adaptations.find do |i|
+                          i.concern?(adaptation.klass,adaptation.method_name,adaptation.instance_adaptation?)
+                        end
+    if to_undeploy!=adaptation # if new adaptation
+      deployed_adaptations.delete(to_undeploy)
+      deployed_adaptations.push(adaptation)
+      adaptation.deploy
+    end
+  end
+  
+  # Save the default adaptation of a method, ie: the initial method
+  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,instance,method)
+  end
+  
+  # Return the adaptation that math the calling_stack, on the basis of the
+  # file and the line number --> proceed is always called under an
+  # adaptation definition
+  def find_adaptation(calling_stack)
+    call_file,call_line = parse_stack(calling_stack)
+    match = nil
+    relevant_adaptations(call_file).each do |adaptation|
+      if adaptation.src_line <= call_line # Find first matching line
+        match = adaptation
+        break
+      end
+    end
+
+    if  match==nil
+      Phenomenal::Logger.instance.error(
+        "Inexistant adaptation for proceed call at #{call_file}:#{call_line}"
+      )
+    end
+    match
+  end
+  
+  # Parse calling stack to find the calling line and file
+  def parse_stack(calling_stack)
+    source = calling_stack[0]
+    source_info = source.scan(/(.+\.rb):(\d+)/)[0]
+    call_file = source_info[0]
+    call_line = source_info[1].to_i
+    [call_file,call_line]
+  end
+  
+  # Gets the relevants adaptations for a file in DESC order of line number
+  def relevant_adaptations(call_file)
+    relevants = active_adaptations.select{ |i| i.src_file == call_file }
+    # Sort by src_line DESC order
+    relevants.sort!{ |a,b| b.src_line <=> a.src_line }
+  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
+  end
+  
+  # Return the adaptations for a particular method sorted with the
+  # conflict policy
+  def sorted_adaptations_for(klass,method_name,instance)
+    relevants =
+      active_adaptations.find_all { |i| i.concern?(klass, method_name,instance) }
+    relevants.sort!{|a,b| conflict_policy(a.context,b.context)}
+  end
+end

data/lib/phenomenal/{conflict_policies.rb → manager/conflict_policies.rb}

@@ -1,6 +1,5 @@
 # Context conflict resolution policies
 module Phenomenal::ConflictPolicies
-  
   # Prefer not default adaptation, error if two not default ones
     def no_resolution_conflict_policy(context1,context2)
       if context1==default_context()
@@ -18,4 +17,16 @@ module Phenomenal::ConflictPolicies
     def age_conflict_policy(context1, context2)
        context1.age <=> context2.age
     end
+    
+    # Resolution policy
+    def conflict_policy(context1, context2)
+      age_conflict_policy(context1, context2)
+    end
+
+    # Change the conflict resolution policy.
+    # These can be ones from the ConflictPolicies module or other ones
+    # Other one should return -1 or +1 following the resolution order
+    def change_conflict_policy (&block)
+      self.class.class_eval{define_method(:conflict_policy,&block)}
+    end
 end

data/lib/phenomenal/manager/contexts_management.rb

@@ -0,0 +1,171 @@
+module Phenomenal::ContextsManagement
+  attr_accessor :contexts, :default_context, :combined_contexts, :shared_contexts
+  
+  # Register a new context 
+  def register_context(context)
+    if context_defined?(context)
+      Phenomenal::Logger.instance.error(
+        "The context #{context} is already registered"
+      )
+    end
+    if context.name && context_defined?(context.name)
+      Phenomenal::Logger.instance.error(
+        "There is already a context with name: #{context.name}." + 
+        " If you want to have named context it has to be a globally unique name"
+      )
+    end
+    # Update the relationships that concern this context
+    rmanager.update_relationships_references(context)
+    # Store the context at its ID
+    contexts[context]=context
+  end
+  
+  # Unregister a context (forget)
+  def unregister_context(context)
+    if context==default_context && contexts.size>1
+      Phenomenal::Logger.instance.error(
+        "Default context can only be forgotten when alone"
+      )
+    else
+      contexts.delete(context)
+      unregister_combined_contexts(context)
+      # Restore default context
+      init_default() if context==default_context
+    end
+  end
+  
+  
+  
+  # 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) }
+      # Activate combined contexts
+      activate_combined_contexts(context)
+    rescue Phenomenal::Error
+      context.deactivate # rollback the deployed adaptations
+      raise # throw up the exception
+    end
+  end
+  
+  # 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
+    deactivate_combined_contexts(context)
+  end
+  
+  # Return the corresponding context (or combined context) or raise an error 
+  # if the context isn't 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' (or combined 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
+  def unregister_combined_contexts(context)
+    # Forgot combined contexts
+    combined_contexts.delete(context)
+    if shared_contexts[context]
+      shared_contexts[context].each do |c|
+        c.forget
+      end
+    end
+  end
+  
+  def activate_combined_contexts(context)
+    if shared_contexts[context]
+      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
+  end
+  
+  def deactivate_combined_contexts(context)
+    if shared_contexts[context]
+      shared_contexts[context].each do |combined_context|
+        while combined_context.active? do
+         combined_context.deactivate
+        end
+      end
+    end
+  end
+  
+  def find_simple_context(context)
+    find=nil
+    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)
+    end
+    if find
+      find
+    else
+      Phenomenal::Logger.instance.error(
+        "Unknown context #{context}"
+      )
+    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
+    else
+      Phenomenal::Logger.instance.error(
+        "Multiple definition of combined context #{contexts}"
+      )
+    end
+  end
+end

data/lib/phenomenal/manager/manager.rb

@@ -0,0 +1,29 @@
+require 'singleton'
+# This class manage the different contexts in the system and their interactions
+class Phenomenal::Manager
+  include Singleton
+  include Phenomenal::ConflictPolicies
+  include Phenomenal::AdaptationsManagement
+  include Phenomenal::ContextsManagement
+  
+  attr_accessor :rmanager
+  
+  # PRIVATE METHODS
+  private
+   # Set the default context
+  def init_default
+    self.default_context= Phenomenal::Feature.new(nil,self)
+    self.default_context.activate
+  end
+
+  # Private constructor because this is a singleton object
+  def initialize
+    @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

@@ -2,23 +2,28 @@
 # define relationships
 module Phenomenal::ContextRelationships
   def requires(context,*contexts)
-    contexts = contexts.push(context)
-    contexts.each do |target|
+    set_context_relationship(context,contexts) do |target|
       self.parent_feature.requirements_for(self,{:on=>target})
     end
   end
   
   def implies(context,*contexts)
-    contexts = contexts.push(context)
-    contexts.each do |target|
+    set_context_relationship(context,contexts) do |target|
       self.parent_feature.implications_for(self,{:on=>target})
     end
   end
   
   def suggests(context,*contexts)
+    set_context_relationship(context,contexts) do |target|
+      self.parent_feature.suggestions_for(self,{:on=>target})
+    end
+  end
+  
+  private
+  def set_context_relationship(context,contexts)
     contexts = contexts.push(context)
     contexts.each do |target|
-      self.parent_feature.suggestions_for(self,{:on=>target})
+      yield(target)
     end
   end
 end

data/lib/phenomenal/relationships/feature_relationships.rb

@@ -23,6 +23,7 @@ module Phenomenal::FeatureRelationships
   alias_method :phen_suggestions_for,:suggestions_for
   
   private 
+  # Create the new relationships and add them to the runtime system
   def add_relationship(source,targets,type)
     targets[:on]=Array.new.push(targets[:on]) if !targets[:on].is_a?(Array)
     if targets[:on].nil?
@@ -34,12 +35,18 @@ module Phenomenal::FeatureRelationships
       r = type.new(source,target,self)
       if relationships.find{|o| o==r}.nil?
         relationships.push(r)
-        if self.active?
-          r.refresh
-          manager.rmanager.relationships.add(r)
-          r.activate_feature 
-        end
+        set_relationship(r)
       end
     end
   end
+  
+  # Refresh the references (replace symbol by actual object reference)
+  # And activate the relationship if the associated feature is already active
+  def set_relationship(relationship)
+    if self.active?
+      relationship.refresh
+      manager.rmanager.relationships.add(relationship)
+      relationship.activate_feature 
+    end
+  end
 end

data/lib/phenomenal/relationships/relationships_store.rb

@@ -37,39 +37,34 @@ class Phenomenal::RelationshipsStore
     # Do nothing when anonymous, references are already valid
     return if context.anonymous?
     # Update sources
-    if not @sources[context.name].nil?
-      @sources[context.name].each do |relationship|
-        relationship.source=context
-      end
-      @sources[context]=@source.delete(context.name)
+    set_references(@sources,context) do
+      relationship.source=context
     end
     # Update targets
-    if not @targets[context.name].nil?
-      @targets[context.name].each do |relationship|
-        relationship.target=context
-      end
-      @targets[context]=@targets.delete(context.name)
+    set_references(@sources,context) do
+      relationship.target=context 
     end
   end
   
+  # Return all relationships for 'context'
   def get_for(context)
-    get_for_source(context).concat(get_for_target(context))
+    array_for(@sources,context).concat(array_for(@targets,context))
   end
   
   private
-  # Return an array of relationships
-  def get_for_source(source)
-    rel = @sources[source]
-    if rel.nil?
-      Array.new
-    else
-      rel
+  # Set the references for 'context' (according to 'block')
+  def set_references(contexts,context,&block)
+    if !contexts[context.name].nil?
+      contexts[context.name].each do |relationship|
+        yield
+      end
+      contexts[context]=contexts.delete(context.name)
     end
   end
   
   # Return an array of relationships
-  def get_for_target(target)
-    rel = @targets[target]
+  def array_for(contexts,context)
+    rel = contexts[context]
     if rel.nil?
       Array.new
     else

data/lib/phenomenal/version.rb

@@ -1,3 +1,3 @@
 module Phenomenal
-  VERSION = "1.1.0"
+  VERSION = "1.1.1"
 end

data/lib/phenomenal/viewer/graphical.rb

@@ -14,8 +14,8 @@ class Phenomenal::Viewer::Graphical
   def initialize(destination_file)
     if !@@graphviz
       Phenomenal::Logger.instance.error(
-        "The 'ruby-graphviz' gem isn't available. Please install it to generate graphic visualitations\n"+
-        " Otherwise use the text version"
+        "The 'ruby-graphviz' gem isn't available. Please install it to generate graphic visualisations\n"+
+        " Otherwise use the text version: phen_textual_view"
       )
     end
     
@@ -29,16 +29,10 @@ class Phenomenal::Viewer::Graphical
   end
   
   def generate()
-    # Create main graph
-    self.main_graph = GraphViz::new("")
-    # Default options
-    self.main_graph[:compound] = "true"
-    self.main_graph.edge[:lhead] = ""
-    self.main_graph.edge[:ltail] = ""
-    self.main_graph.edge[:fontsize]=10.0
+    set_options()
     # Add nodes to the graph
     self.manager.contexts.each do |key,context|
-      if not self.feature_nodes.include?(context) and not @context_nodes.include?(context)
+      if !feature_nodes.include?(context) && !context_nodes.include?(context)
         add_node_for(context)
       end
     end
@@ -46,71 +40,99 @@ class Phenomenal::Viewer::Graphical
     self.manager.contexts.each do |key,context|
       add_edges_for(context)
     end
-    self.main_graph.output( :png => self.destination_file )
+    self.main_graph.output(:png => destination_file)
   end
   
   private
+  def set_options
+    # Create main graph
+    self.main_graph = GraphViz::new("")
+    # Default options
+    self.main_graph[:compound] = "true"
+    self.main_graph.edge[:lhead] = ""
+    self.main_graph.edge[:ltail] = ""
+    self.main_graph.edge[:fontsize] = 10.0
+  end
+  
   def add_edges_for(context)
     if context.is_a?(Phenomenal::Feature)
       context.relationships.each do |relationship|
         # Get source and destionation node
-        ltail=""
-        lhead=""
         relationship.refresh
-        if self.feature_nodes.include?(relationship.source)
-          source_node=self.r_feature_nodes[relationship.source]
-          ltail="cluster_#{relationship.source.to_s}"
-        else 
-          source_node=self.context_nodes[relationship.source]
-        end
-        if self.feature_nodes.include?(relationship.target)
-          target_node=self.r_feature_nodes[relationship.target]
-          lhead="cluster_#{relationship.target.to_s}"
-        else
-          target_node=self.context_nodes[relationship.target]
-        end
-        # Define graph container
-        s_parent_feature=relationship.source.parent_feature
-        t_parent_feature=relationship.target.parent_feature
-        if s_parent_feature==t_parent_feature && s_parent_feature!=self.manager.default_context
-          graph=self.feature_nodes[relationship.source.parent_feature]
-        else
-          graph=self.main_graph
-        end
+        source_node,ltail = node(relationship.source)
+        target_node,lhead = node(relationship.target)
+        # Get graph container
+        graph = graph_container(relationship)
         # Add edge
-        edge=graph.add_edges(source_node,target_node,:ltail=>ltail,:lhead=>lhead)   
-        # Define edge label
-        if context!=self.manager.default_context
-          edge[:label]=context.to_s
-         end
-        # Define edge color
-        if self.rmanager.relationships.include?(relationship)
-          edge[:color]="red"
-        end
-        # Define arrow type
-        if relationship.is_a?(Phenomenal::Implication)
-          edge[:arrowhead]="normal"
-        elsif relationship.is_a?(Phenomenal::Suggestion)
-          edge[:arrowhead]="empty"
-        elsif relationship.is_a?(Phenomenal::Requirement)
-          edge[:arrowhead]="inv"
-        else
-        end
+        edge = graph.add_edges(source_node,target_node,:ltail=>ltail,:lhead=>lhead)   
+        # Define edge type
+        set_edge(context,edge,relationship)
       end
     end
   end
   
+  def node(feature)
+    if feature_nodes.include?(feature)
+      [r_feature_nodes[feature],"cluster_#{feature.to_s}"]
+    else 
+      [context_nodes[feature],""]
+    end
+  end
+  
+  def graph_container(relationship)
+    s_parent_feature=relationship.source.parent_feature
+    t_parent_feature=relationship.target.parent_feature
+    if s_parent_feature==t_parent_feature && s_parent_feature!=manager.default_context
+      feature_nodes[relationship.source.parent_feature]
+    else
+      main_graph
+    end
+  end
+  
+  def set_edge(context,edge,relationship)
+    # Define edge label
+    if context!=manager.default_context
+      edge[:label]=context.to_s
+     end
+    # Define edge color
+    if rmanager.relationships.include?(relationship)
+      edge[:color]="red"
+    end
+    # Define arrow type
+    if relationship.is_a?(Phenomenal::Implication)
+      edge[:arrowhead]="normal"
+    elsif relationship.is_a?(Phenomenal::Suggestion)
+      edge[:arrowhead]="empty"
+    elsif relationship.is_a?(Phenomenal::Requirement)
+      edge[:arrowhead]="inv"
+    else
+      Phenomenal::Logger.instance.error(
+        "This relationship hasn't been defined yet in the graphical viewer"
+      )
+    end
+  end
+  
   def add_node_for(context)
     # The default context is the first to be added to the main graph
-    if self.feature_nodes[context.parent_feature].nil? and context==self.manager.default_context 
-      current_graph=self.main_graph
+    if feature_nodes[context.parent_feature].nil? && context==manager.default_context 
+      current_graph=main_graph
     # Always add the parent_feature before the contexts inside
-    elsif @feature_nodes[context.parent_feature].nil?
-      self.add_node_for(context.parent_feature)
+    elsif feature_nodes[context.parent_feature].nil?
+      add_node_for(context.parent_feature)
     else
-      current_graph=self.feature_nodes[context.parent_feature]
+      current_graph=feature_nodes[context.parent_feature]
     end
     # Add node
+    node  = new_node_for(context,current_graph)
+    # Define node color
+    if context.active?
+      node[:color]="red"
+    else
+      node[:color]="black"
+    end
+  end
+  
+  def new_node_for(context,current_graph)
     if context.is_a?(Phenomenal::Feature)
       node=current_graph.add_graph("cluster_#{context.to_s}")
       node[:label]="#{context.to_s}"
@@ -122,15 +144,11 @@ class Phenomenal::Viewer::Graphical
       fr[:fixedsize]=true
       self.feature_nodes[context]=node
       self.r_feature_nodes[context]=fr
+      node
     else
       node=current_graph.add_nodes(context.to_s) 
       self.context_nodes[context]=node
     end
-    # Define node color
-    if context.active?
-      node[:color]="red"
-    else
-      node[:color]="black"
-    end
+    node
   end
 end

data/spec/integration/conflict_policy_spec.rb

@@ -107,7 +107,7 @@ describe "Conflict policies" do
     phone.advertise(call).should=="ringtone"
   end
   
-  it "should PPPPPPPPPPPPPPPPPPPP" do
+  it "should proceed adaptations in the rigth order" do
     phen_change_conflict_policy { |a,b| age_conflict_policy(a,b) }
     context(:level1)
     phen_add_adaptation(:level1,TestClass,:print) do |arg|

data/spec/spec_helper.rb

@@ -1,3 +1,11 @@
+require 'simplecov'
+if ENV["COVERAGE"]
+  SimpleCov.start do
+    add_filter "/spec/"
+    add_filter "/lib/phenomenal/viewer"
+  end
+end
+
 require 'rspec'
 require "phenomenal"
 require "test_classes.rb"

metadata

@@ -2,7 +2,7 @@
 name: phenomenal
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 1.1.0
+  version: 1.1.1
 platform: ruby
 authors: 
 - Loic Vigneron - Thibault Poncelet
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-04-17 00:00:00 Z
+date: 2012-05-09 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
@@ -32,9 +32,7 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- lib/phenomenal/manager.rb
 - lib/phenomenal/feature.rb
-- lib/phenomenal/conflict_policies.rb
 - lib/phenomenal/viewer/graphical.rb
 - lib/phenomenal/viewer/textual.rb
 - lib/phenomenal/viewer/dsl.rb
@@ -50,6 +48,10 @@ files:
 - lib/phenomenal/relationships/suggestion.rb
 - lib/phenomenal/relationships/feature_relationships.rb
 - lib/phenomenal/context.rb
+- lib/phenomenal/manager/manager.rb
+- lib/phenomenal/manager/conflict_policies.rb
+- lib/phenomenal/manager/adaptations_management.rb
+- lib/phenomenal/manager/contexts_management.rb
 - lib/phenomenal/logger.rb
 - lib/phenomenal/adaptation.rb
 - lib/phenomenal.rb

data/lib/phenomenal/manager.rb

@@ -1,316 +0,0 @@
-require 'singleton'
-# This class manage the different contexts in the system and their interactions
-class Phenomenal::Manager
-  include Singleton
-  include Phenomenal::ConflictPolicies
-  
-  attr_accessor :active_adaptations, :deployed_adaptations, :contexts, 
-  :default_context, :combined_contexts, :shared_contexts, :rmanager
-  
-  # Register a new context 
-  def register_context(context)
-    if context_defined?(context)
-      Phenomenal::Logger.instance.error(
-        "The context #{context} is already registered"
-      )
-    end
-    if context.name && context_defined?(context.name)
-      Phenomenal::Logger.instance.error(
-        "There is already a context with name: #{context.name}." + 
-        " If you want to have named context it has to be a globally unique name"
-      )
-    end
-    # Update the relationships that concern this context
-    rmanager.update_relationships_references(context)
-    # Store the context at its ID
-    contexts[context]=context
-  end
-  
-  # Unregister a context (forget)
-  def unregister_context(context)
-    if context==default_context && contexts.size>1
-      Phenomenal::Logger.instance.error(
-        "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
-      init_default() if context==default_context
-    end
-  end
-  
-  # 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?)
-    end
-    if adaptation.context!=default_context && !default_adaptation
-      save_default_adaptation(adaptation.klass, adaptation.method_name,adaptation.instance_adaptation?)
-    end
-    activate_adaptation(adaptation) if adaptation.context.active?
-  end
-  
-  # Unregister an adaptation for a registered context
-  def unregister_adaptation(adaptation)
-    deactivate_adaptation(adaptation) if adaptation.context.active?
-  end
-  
-  # 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
-    end
-  end
-  
-  # 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
-  end
-  
-  # Call the old implementation of the method 'caller.caller_method'
-  def proceed(calling_stack,instance,*args,&block)
-    calling_adaptation = find_adaptation(calling_stack)
-    # IMPROVE 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
-    # 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_index = adaptations_stack.find_index(calling_adaptation)
-    next_adaptation = adaptations_stack[calling_adaptation_index+1]
-    next_adaptation.bind(instance,*args, &block)
-  end
-  
-  # Change the conflict resolution policy.
-  # These can be ones from the ConflictPolicies module or other ones
-  # Other one should return -1 or +1 following the resolution order
-  def change_conflict_policy (&block)
-    self.class.class_eval{define_method(:conflict_policy,&block)}
-  end
-  
-  # Return the corresponding context (or combined context) or raise an error 
-  # if the context isn't 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' (or combined 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
-  
-  
-  # Resolution policy
-  def conflict_policy(context1, context2)
-    age_conflict_policy(context1, context2)
-  end
-
-  private
-  def find_simple_context(context)
-    find=nil
-    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)
-    end
-    if find
-      find
-    else
-      Phenomenal::Logger.instance.error(
-        "Unknown context #{context}"
-      )
-    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
-    else
-      Phenomenal::Logger.instance.error(
-        "Multiple definition of combined context #{contexts}"
-      )
-    end
-  end
-  
-  # 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?)
-  end
-  
-  # Deactivate the adaptation and redeploy the adaptations if necessary
-  def deactivate_adaptation(adaptation)
-    active_adaptations.delete(adaptation)
-    if deployed_adaptations.include?(adaptation)
-      deployed_adaptations.delete(adaptation)
-      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,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)
-    end
-  end
-  
-  # Deploy the adaptation
-  def deploy_adaptation(adaptation)
-    to_undeploy = deployed_adaptations.find do |i|
-                          i.concern?(adaptation.klass,adaptation.method_name,adaptation.instance_adaptation?)
-                        end
-    if to_undeploy!=adaptation # if new adaptation
-      deployed_adaptations.delete(to_undeploy)
-      deployed_adaptations.push(adaptation)
-      adaptation.deploy
-    end
-  end
-  
-  # Save the default adaptation of a method, ie: the initial method
-  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,instance,method)
-  end
-  
-  # Return the adaptation that math the calling_stack, on the basis of the
-  # file and the line number --> proceed is always called under an
-  # adaptation definition
-  def find_adaptation(calling_stack)
-    source = calling_stack[0]
-    source_info = source.scan(/(.+\.rb):(\d+)/)[0]
-    call_file = source_info[0]
-    call_line = source_info[1].to_i
-    i = 0
-    match = nil
-    relevants = active_adaptations.select{ |i| i.src_file == call_file }
-    # Sort by src_line DESC
-    relevants.sort!{ |a,b| b.src_line <=> a.src_line }
-    relevants.each do |adaptation|
-      if adaptation.src_line <= call_line # Find first matching line
-        match = adaptation
-        break
-      end
-    end
-
-    if  match==nil
-      Phenomenal::Logger.instance.error(
-        "Inexistant adaptation for proceed call at #{call_file}:#{call_line}"
-      )
-    end
-    match
-  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
-  end
-  
-  # Return the adaptations for a particular method sorted with the
-  # conflict policy
-  def sorted_adaptations_for(klass,method_name,instance)
-    relevant_adaptations =
-      active_adaptations.find_all { |i| i.concern?(klass, method_name,instance) }
-    relevant_adaptations.sort!{|a,b| conflict_policy(a.context,b.context)}
-  end
-  
-   # Set the default context
-  def init_default
-    self.default_context= Phenomenal::Feature.new(nil,self)
-    self.default_context.activate
-  end
-
-  # Private constructor because this is a singleton object
-  def initialize
-    @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