phenomenal 0.9.0 → 0.11.11.24.3

data/LICENSE

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

data/README

@@ -1,3 +1,4 @@
-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
+Build gem command: 
+  gem build phenomenal.gemspec
+Test gem command: 
+  rake test

data/Rakefile

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

data/demo.rb

@@ -0,0 +1,24 @@
+require_relative 'lib/phenomenal.rb'
+class Foo
+  def initialize
+    @inst_var = "bar"
+  end
+  def print
+    "Base: " +@inst_var
+  end
+end
+
+pnml_define_context(:demo)
+pnml_add_adaptation(:demo, Foo, :print) do
+  pnml_proceed + " adaptation: "+ @inst_var
+end
+
+f = Foo.new
+puts f.print
+
+pnml_activate_context(:demo)
+puts f.print
+
+pnml_deactivate_context(:demo)
+puts f.print
+

data/demo_age.rb

@@ -0,0 +1,89 @@
+require_relative "./lib/phenomenal.rb"
+
+pnml_change_conflict_policy { |a,b| age_conflict_policy(a,b) }
+
+class Plop
+  @@klass_var  = "PPPP"
+  @klass_inst_var = "xD"
+  attr_accessor :test
+
+  def initialize
+    @test = ">BOR<"
+  end
+
+  def print(arg)
+    "0 -> Test: #{self.test} default Plop.print(arg): ARG: #{arg.to_s}"
+  end
+
+  def self.plop(arg)
+    "SELF 0 #{arg} KlassVar: #{@@klass_var} INSTKLS #{@klass_inst_var}"
+  end
+end
+
+pnml_define_context(:level1)
+
+pnml_add_adaptation(:level1,Plop,:print) do |arg|
+  pnml_proceed(arg) + "\n" + "1 -> level1 ARG1: #{arg.to_s}"
+end
+
+pnml_add_adaptation(:level1,Plop,:plop) do |arg|
+  pnml_proceed(arg) + "\n" + "1 -> SELF level1 ARG1: #{arg.to_s} INSTKLS #{@kls_var}"
+end
+
+pnml_define_context(:level2)
+
+pnml_add_adaptation(:level2,Plop,:print) do |arg|
+  pnml_proceed(arg) + "\n" + "2 -> level2 ARG2: #{arg.to_s}"
+end
+
+pnml_add_adaptation(:level2,Plop,:plop) do |arg|
+  pnml_proceed(arg) + "\n" + "2 -> SELF level2 ARG2: #{arg.to_s} INSTKLS #{@kls_inst_var}"
+end
+
+pnml_define_context(:level3)
+
+pnml_add_adaptation(:level3,Plop,:print) do |arg|
+  pnml_proceed(arg) + "\n" + "3 -> level3 ARG3: #{arg.to_s}"
+end
+
+pnml_define_context(:level4)
+
+pnml_add_adaptation(:level4,Plop,:print) do |arg|
+  pnml_proceed(arg) + "\n" + "4 -> TEST4: #{@test} level4 ARG4: #{arg.to_s}"
+end
+
+p = Plop.new
+
+puts "=============> LEVEL 0 <===============\n"+
+p.print("foo")+
+"\n======================================="
+
+pnml_activate_context(:level1)
+puts "=============> LEVEL 1 <===============\n"+
+p.print("foo1")+
+"\n======================================="
+
+pnml_activate_context(:level2)
+puts "=============> LEVEL 2 <===============\n"+
+p.print("foo2")+
+"\n======================================="
+
+pnml_activate_context(:level3)
+puts "=============> LEVEL 3 <===============\n"+
+p.print("foo3")+
+"\n======================================="
+p.test=">BAR<"
+pnml_activate_context(:level4)
+puts "=============> LEVEL 4 <===============\n"+
+p.print("foo4")+
+"\n======================================="
+
+pnml_deactivate_context(:level3)
+puts "=============> LEVEL 4 -3 <===============\n"+
+p.print("foo4-2")+
+"\n======================================="
+
+puts "\n\n========> LEVEL 4 -3 KLASS METH<===========\n"+
+ Plop.plop(">KLASS_METH_ARG<") +
+"\n======================================="
+

data/demo_dsl.rb

@@ -0,0 +1,28 @@
+require_relative 'lib/phenomenal.rb'
+class Foo
+  def initialize
+    @inst_var = "bar"
+  end
+  def print
+    "Base: " +@inst_var
+  end
+end
+
+context :Test do 
+  implies :plop
+  
+  adaptations_for Foo
+  adapt :print do 
+    pnml_proceed + "ADAPT"
+  end
+end
+
+f = Foo.new
+puts f.print
+
+pnml_activate_context(:Test)
+puts f.print
+
+pnml_deactivate_context(:Test)
+puts f.print
+

data/lib/phenomenal.rb

@@ -1,24 +1,11 @@
 # 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"
-
-# DSL
-require_relative "./phenomenal/relationships/dsl.rb"
 require_relative "./phenomenal/dsl.rb"
+
+

data/lib/phenomenal/adaptation.rb

@@ -1,16 +1,14 @@
 # Represent a method adaptation for a particular context
 class  Phenomenal::Adaptation
   attr_accessor :context, :klass, :method_name, :implementation, :src_file,
-                :src_line,:instance_adaptation
+                :src_line
                 
-  def initialize(context,klass, method_name,instance_adapatation,implementation)
+  def initialize(context,klass, method_name, 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
@@ -33,7 +31,9 @@ class  Phenomenal::Adaptation
     end
   end
   
-  # IMPROVE check for better implementation
+  #TODO check for better implem
+  #TODO we are forced to keep unBoundMethod bind code, 
+  #     so allow user to use unbound meth?
   # 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,28 +52,18 @@ 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,instance_adaptation)
-    self.klass==klass && 
-    self.method_name==method_name && 
-    self.instance_adaptation==instance_adaptation
+  def concern?(klass,method_name)
+    self.klass==klass && self.method_name==method_name
   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,72 +1,47 @@
 # Represent a first class context
 class Phenomenal::Context
-  include Phenomenal::ContextRelationships
   @@total_activations = 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
+  
+  def self.create(*args,&block)
+    if args.length==1
+      if !Phenomenal::Manager.instance.context_defined?(args[0])
+        context = Phenomenal::Context.new(args[0])     
       end
+      context.add_adaptations(&block)
     else #Combined contexts
-      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
+      #TODO
     end
-    context.add_adaptations(&block)
-    context
   end
   
-  attr_accessor :activation_age, :activation_frequency, :adaptations, 
-    :activation_count, :parent,:forgotten
+  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_reader :manager,:name
   
-  def initialize(name=nil, manager=nil)
+  def initialize(name=nil, priority=nil,persistent=false,manager=nil)
+    @persistent = persistent
     @manager = manager || Phenomenal::Manager.instance
     @name = name
+    @priority = priority
     @activation_age = 0
     @activation_count = 0
     @adaptations = Array.new
     @manager.register_context(self)
-    @parent=nil
-    @forgotten=false
+    @implied = Array.new
+    @is_implied = {}
+    @required = Array.new
+    @is_required = {}
+    @guessed = Array.new
   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 handle relationships references
+  # TODO Find a way to avoid the use of forgeted context (use forgeted flag?)
   def forget
     if active?
       Phenomenal::Logger.instance.error(
@@ -74,26 +49,24 @@ 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,instance,umeth=nil, &implementation)
+  def add_adaptation(klass, method_name,umeth=nil, &implementation)
     if umeth
       implementation = umeth
-      instance = klass.instance_methods.include?(method_name)
     end
-    if adaptations.find{ |i| i.concern?(klass,method_name,instance) }
+    if adaptations.find{ |i| i.concern?(klass,method_name) }
       Phenomenal::Logger.instance.error(
         "Error: Illegal duplicated adaptation in context: #{self} for " + 
         "#{klass.name}:#{method_name}"
       )
     else
-      if klass.instance_methods.include?(method_name) && instance
+      if klass.instance_methods.include?(method_name)
         method = klass.instance_method(method_name)
-      elsif klass.methods.include?(method_name) && !instance
+      elsif klass.methods.include?(method_name)
         method = klass.method(method_name)
       else
         Phenomenal::Logger.instance.error(
@@ -112,31 +85,17 @@ class Phenomenal::Context
       end
       
       adaptation = Phenomenal::Adaptation.new(
-        self, klass, method_name,instance, implementation
+        self, klass, method_name, 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) if block
+    instance_eval(&block)
   end
   
   # Set the current adapted class for the next adapt calls
@@ -146,18 +105,41 @@ class Phenomenal::Context
   
   # Adapt a method for @current_adapted_class
   def adapt(method,&block)
-    add_adaptation(@current_adapted_class,method,true,&block)
+    add_adaptation(@current_adapted_class,method,&block)
   end
-  
-  # Adapt a method for @current_adapted_class
-  def adapt_klass(method,&block)
-    add_adaptation(@current_adapted_class,method,false,&block)
+
+
+  # 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
+  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,instance)
+  def remove_adaptation(klass,method_name)
     adaptation_index =
-      adaptations.find_index{ |i| i.concern?(klass, method_name,instance) }
+      adaptations.find_index{ |i| i.concern?(klass, method_name) }
     if !adaptation_index
       Phenomenal::Logger.instance.error(
         "Error: Illegal deleting of an inexistent adaptation in context: " +
@@ -171,20 +153,75 @@ class Phenomenal::Context
   
   # Activate the context
   def activate
-    check_validity
-    @@total_activations +=1
-    self.activation_age =@@total_activations
+#TODO
+#    check_required
+#    activate_implicated
+#    activate_guessed
+    @@total_activations = @@total_activations+1
+    self.activation_age = @@total_activations
     self.activation_count = self.activation_count+1
     manager.activate_context(self)
     self
-  end  
+  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
+  
+  
   
   # Deactivate the context
-  def deactivate(caller_context=nil)
-    check_validity
+  def deactivate
     was_active = active?
     if self.activation_count>0
-      #Deactivation
       self.activation_count =  self.activation_count-1
     end
     if was_active && !active?
@@ -193,26 +230,25 @@ 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
-    @@total_activations-activation_age
+    if activation_age == 0
+      @@total_activations
+    else
+      @@total_activations-activation_age
+    end
   end
   
   # Return context informations:
@@ -220,50 +256,21 @@ class Phenomenal::Context
   #   - List of the adaptations
   #   - Active state
   #   - Activation age
-  #   - Activation count
-  def information
+  def informations
     {
       :name=>name,
       :adaptations=>adaptations,
       :active=>active?,
-      :age=>age,
-      :activation_count=>activation_count,
-      :type=>self.class.name
+      :activation_age=>age
     }
   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'"
-    end
-  end
-  
-  private
-  def check_validity
-    if forgotten
-      Phenomenal::Logger.instance.error(
-        "Action not allowed anymore when context has been forgotten"
-      )
+      "Anonymous context"
     end
   end
 end