phenomenal 0.11.11.24.4 → 0.99.0

data/LICENSE

@@ -23,5 +23,5 @@ Year : 2011-2012
 Students names,sections :
                            - Poncelet Thibault (SINF22MS)
                            - Vigneron Loic (SINF22MS)
-Date : May 1, 2011
+Start date : May 1, 2011
 

data/README

@@ -1,4 +1,3 @@
-Build gem command: 
-  gem build phenomenal.gemspec
-Test gem command: 
-  rake test
+Phenomenal Gem is a context-oriented framework implemented in Ruby that allows context-oriented programming in Ruby and Ruby on Rails applications. 
+
+See www.phenomenal-gem.com for more details

data/Rakefile

@@ -6,3 +6,6 @@ end
 
 desc "Run tests"
 task :default => :test
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new('spec')

data/lib/phenomenal.rb

@@ -1,11 +1,24 @@
 # Load the gem files in the system
 module Phenomenal end
+#Relationships
+require_relative "./phenomenal/relationships/context_relationships.rb"
+require_relative "./phenomenal/relationships/feature_relationships.rb"
+require_relative "./phenomenal/relationships/relationships_store.rb"
+require_relative "./phenomenal/relationships/relationships_manager.rb"
+require_relative "./phenomenal/relationships/relationship.rb"
+require_relative "./phenomenal/relationships/requirement.rb"
+require_relative "./phenomenal/relationships/implication.rb"
+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"
 require_relative "./phenomenal/proc.rb"
-require_relative "./phenomenal/dsl.rb"
-
 
+# DSL
+require_relative "./phenomenal/relationships/dsl.rb"
+require_relative "./phenomenal/dsl.rb"

data/lib/phenomenal/adaptation.rb

@@ -1,14 +1,16 @@
 # Represent a method adaptation for a particular context
 class  Phenomenal::Adaptation
   attr_accessor :context, :klass, :method_name, :implementation, :src_file,
-                :src_line
+                :src_line,:instance_adaptation
                 
-  def initialize(context,klass, method_name, implementation)
+  def initialize(context,klass, method_name,instance_adapatation,implementation)
     @context = context
     @klass = klass
     @method_name = method_name
     @implementation = implementation
+    @instance_adaptation=instance_adapatation
     
+    check_validity
     # Save the source location if any, this is used to find again the adaptation
     # in a ctxt_proceed call. It always exists except for method directly
     # implemented in C -> Not a problem because these one never use ctxt_proceed
@@ -31,9 +33,7 @@ class  Phenomenal::Adaptation
     end
   end
   
-  #TODO check for better implem
-  #TODO we are forced to keep unBoundMethod bind code, 
-  #     so allow user to use unbound meth?
+  # IMPROVE check for better implementation
   # Bind the implementation corresponding to this adaptation to 'instance' when
   # instance_method or to implementation klass when class method 
   def bind(instance,*args,&block)
@@ -52,18 +52,28 @@ class  Phenomenal::Adaptation
     end
   end
   
-  # True if the adapted method is an instance method
-  def instance_adaptation?
-    klass.instance_methods.include?(method_name)
-  end
-  
   #True if the adaptation concern the class n_klass and method n_method
-  def concern?(klass,method_name)
-    self.klass==klass && self.method_name==method_name
+  def concern?(klass,method_name,instance_adaptation)
+    self.klass==klass && 
+    self.method_name==method_name && 
+    self.instance_adaptation==instance_adaptation
   end
 
+  alias_method :instance_adaptation?, :instance_adaptation
+  
   # String representation
   def to_s
    ":#{context.name} => #{klass.name}.#{method_name} :: #{src_file}:#{src_line}"
   end
+  
+  private
+  def check_validity
+    if klass.instance_methods.include?(method_name) && !instance_adaptation? ||
+      !klass.instance_methods.include?(method_name) &&  instance_adaptation?
+      Phenomenal::Logger.instance.error(
+        "Illegal adaptation for context: #{context}" +
+        " for #{klass.name}.#{method_name}, type mismatch"
+      )
+    end
+  end
 end

data/lib/phenomenal/context.rb

@@ -1,47 +1,72 @@
 # Represent a first class context
 class Phenomenal::Context
+  include Phenomenal::ContextRelationships
   @@total_activations = 0
-  
-  def self.create(*args,&block)
-    if args.length==1
-      if !Phenomenal::Manager.instance.context_defined?(args[0])
-        context = Phenomenal::Context.new(args[0])     
+  def self.create(context,*contexts,nested,closest_feature,&block)
+    manager = Phenomenal::Manager.instance
+    contexts.insert(0,context)
+    if contexts.length==1
+      if !manager.context_defined?(context)
+        context = self.new(context) 
+      else
+        context = manager.find_context(context)
+        if !context.instance_of?(self)
+          Phenomenal::Logger.instance.error(
+            "Only #{self.name} can be used with this keyword"
+          )
+        end
       end
-      context.add_adaptations(&block)
     else #Combined contexts
-      #TODO
+      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
+      else
+        context = manager.find_context(*contexts)
+      end
     end
+    context.add_adaptations(&block)
+    context
   end
   
-  def self.create_feature(*args,&block)
-    context = self.create(*args,&block)
-    context.persistent=true
-  end
-   
-  attr_accessor :activation_age, :activation_frequency, :priority, :adaptations, 
-    :activation_count, :persistent, :required, :implied, :guessed, :is_implied, :is_required
+  attr_accessor :activation_age, :activation_frequency, :adaptations, 
+    :activation_count, :parent,:forgotten
   attr_reader :manager,:name
   
-  def initialize(name=nil, priority=nil,persistent=false,manager=nil)
-    @persistent = persistent
+  def initialize(name=nil, manager=nil)
     @manager = manager || Phenomenal::Manager.instance
     @name = name
-    @priority = priority
     @activation_age = 0
     @activation_count = 0
     @adaptations = Array.new
     @manager.register_context(self)
-    @implied = Array.new
-    @is_implied = {}
-    @required = Array.new
-    @is_required = {}
-    @guessed = Array.new
+    @parent=nil
+    @forgotten=false
   end
   
   # Unregister the context from the context manager,
   # This context shoudn't be used after.
   # The context has to be inactive before being forgetted
-  # TODO Find a way to avoid the use of forgeted context (use forgeted flag?)
+  # TODO handle relationships references
   def forget
     if active?
       Phenomenal::Logger.instance.error(
@@ -49,24 +74,26 @@ class Phenomenal::Context
       )
     else
       manager.unregister_context(self)
+      forgotten=true
     end
   end
   
   # Add a new method adaptation to the context
   # Return the adaptation just created
-  def add_adaptation(klass, method_name,umeth=nil, &implementation)
+  def add_adaptation(klass, method_name,instance,umeth=nil, &implementation)
     if umeth
       implementation = umeth
+      instance = klass.instance_methods.include?(method_name)
     end
-    if adaptations.find{ |i| i.concern?(klass,method_name) }
+    if adaptations.find{ |i| i.concern?(klass,method_name,instance) }
       Phenomenal::Logger.instance.error(
         "Error: Illegal duplicated adaptation in context: #{self} for " + 
         "#{klass.name}:#{method_name}"
       )
     else
-      if klass.instance_methods.include?(method_name)
+      if klass.instance_methods.include?(method_name) && instance
         method = klass.instance_method(method_name)
-      elsif klass.methods.include?(method_name)
+      elsif klass.methods.include?(method_name) && !instance
         method = klass.method(method_name)
       else
         Phenomenal::Logger.instance.error(
@@ -85,17 +112,31 @@ class Phenomenal::Context
       end
       
       adaptation = Phenomenal::Adaptation.new(
-        self, klass, method_name, implementation
+        self, klass, method_name,instance, implementation
       )
       adaptations.push(adaptation)
       manager.register_adaptation(adaptation)
       adaptation
     end
   end
+  
+  # Catch nested context calls and transform them in nested contexts creation
+  def context(context,*contexts,&block)
+    check_validity
+    Phenomenal::Context.create(self,context,*contexts,true,self,&block)
+  end
+  alias_method :phen_context,:context
+  
+  # Catch nested feature calls and transform them in nested contexts creation
+  def feature(feature,*features, &block)
+    check_validity
+    Phenomenal::Feature.create(self,feature,*features,true,self,&block)
+  end
+  alias_method :phen_feature,:feature
 
   # Add multiple adaptations at definition time
   def add_adaptations(&block)
-    instance_eval(&block)
+    instance_eval(&block) if block
   end
   
   # Set the current adapted class for the next adapt calls
@@ -105,41 +146,18 @@ class Phenomenal::Context
   
   # Adapt a method for @current_adapted_class
   def adapt(method,&block)
-    add_adaptation(@current_adapted_class,method,&block)
+    add_adaptation(@current_adapted_class,method,true,&block)
   end
-
-
-  # Requires
-  def requires(*args)
-    args.each do |context|
-      if !required.include?(context)
-        required.push(context)
-      end
-    end
-  end
-
-  # Implies
-  def implies(*args)
-    args.each do |context|
-      if !implies.include?(context)
-        implied.push(context)
-      end
-    end
+  
+  # Adapt a method for @current_adapted_class
+  def adapt_klass(method,&block)
+    add_adaptation(@current_adapted_class,method,false,&block)
   end
 
-  # Guess 
-  def guess(*args)
-    args.each do |context|
-      if !guessed.include?(context)
-        guessed.push(context)
-      end
-    end
-  end
-  
   # Remove a method adaptation from the context
-  def remove_adaptation(klass,method_name)
+  def remove_adaptation(klass,method_name,instance)
     adaptation_index =
-      adaptations.find_index{ |i| i.concern?(klass, method_name) }
+      adaptations.find_index{ |i| i.concern?(klass, method_name,instance) }
     if !adaptation_index
       Phenomenal::Logger.instance.error(
         "Error: Illegal deleting of an inexistent adaptation in context: " +
@@ -153,75 +171,20 @@ class Phenomenal::Context
   
   # Activate the context
   def activate
-#TODO
-#    check_required
-#    activate_implicated
-#    activate_guessed
-    @@total_activations = @@total_activations+1
-    self.activation_age = @@total_activations
+    check_validity
+    @@total_activations +=1
+    self.activation_age =@@total_activations
     self.activation_count = self.activation_count+1
     manager.activate_context(self)
     self
-  end
-  
-  def check_required
-    required.each do |context_name|
-      context = manager.find_context(context_name)
-      if !context.active?
-        context.is_required[self.__id__] = self
-        Phenomenal::Logger.instance.error(
-          "Error: Required context #{context_name} not active."
-        )
-      end
-    end
-  end
-  
-  def activate_implicated
-    activated = Array.new
-    begin
-      implicated.each do |context_name|
-        context  = manager.find_context(context_name)
-        if !context.active?
-          context.activate
-          context.is_implied[self.__id__] = self
-          activated.push
-        end
-      end
-    rescue PhenomenalError => error
-      activated.reverse.each do |context|
-        context.deactivate
-      end
-      Phenomenal::Logger.instance.error(
-          "Error: Implication not satisfied for context #{name} : \n"+error
-        )
-    end
-  end
-  
-  def activate_guessed 
-    begin
-      implicated.each do |context_name|
-        context  = manager.find_context(context_name)
-        if !context.active?
-          context.activate
-        end
-      end
-    rescue PhenomenalError # Don't care of error in case of guess
-    end
-  end
-  
-  
-  
-  def can_activate
-    #TODO for exclude relations
-    true
-  end
-  
-  
+  end  
   
   # Deactivate the context
-  def deactivate
+  def deactivate(caller_context=nil)
+    check_validity
     was_active = active?
     if self.activation_count>0
+      #Deactivation
       self.activation_count =  self.activation_count-1
     end
     if was_active && !active?
@@ -230,25 +193,26 @@ class Phenomenal::Context
     self
   end
   
-  def can_deactivate
-    #TODO for other relations
-    true
-  end
-  
   # True if the context is active
   def active?
     activation_count>0
   end
   
+  # True if the context has just became active
+  def just_activated?
+    activation_count==1
+  end
+  
+  # True if the context is anonymous
+  def anonymous?
+    name.nil?
+  end
+  
   # Return the activation age of the context:
   #  The age counter minus the age counter when the context was activated
   #  for the last time
   def age
-    if activation_age == 0
-      @@total_activations
-    else
-      @@total_activations-activation_age
-    end
+    @@total_activations-activation_age
   end
   
   # Return context informations:
@@ -256,21 +220,50 @@ class Phenomenal::Context
   #   - List of the adaptations
   #   - Active state
   #   - Activation age
-  def informations
+  #   - Activation count
+  def information
     {
       :name=>name,
       :adaptations=>adaptations,
       :active=>active?,
-      :activation_age=>age
+      :age=>age,
+      :activation_count=>activation_count,
+      :type=>self.class.name
     }
   end
   
+  # Return the closest parent feature of the context
+  def parent_feature
+    p = parent
+    while p!=nil && !p.is_a?(Phenomenal::Feature) do
+      p=p.parent
+    end
+    if p.nil?
+      manager.default_context
+    else
+      p
+    end
+  end
+  
   # String representation of the context
   def to_s
     if name
       name.to_s
+    elsif self==manager.default_context
+      "'Default context'"
+    elsif manager.combined_contexts[self]
+       "'Combined context : #{manager.combined_contexts[self].flatten}'"
     else
-      "Anonymous context"
+      "'Anonymous context'"
+    end
+  end
+  
+  private
+  def check_validity
+    if forgotten
+      Phenomenal::Logger.instance.error(
+        "Action not allowed anymore when context has been forgotten"
+      )
     end
   end
 end