phenomenal 0.9.0

data/lib/phenomenal/relationships/implication.rb

@@ -0,0 +1,35 @@
+class Phenomenal::Implication < Phenomenal::Relationship  
+  attr_accessor :activation_counter
+  def initialize(source,target,feature)
+    super(source,target,feature)
+    @activation_counter=0
+  end
+  
+  def activate_feature
+    if source.active?
+      target.activate
+      activation_counter+=1
+    end
+  end
+  
+  def deactivate_feature
+    if activation_counter>0
+      target.deactivate
+      activation_coutner-=1
+    end
+  end
+  
+  def activate_context(context)
+    if source==context
+      target.activate
+    end
+  end
+  
+  def deactivate_context(context)
+    if source==context
+      target.deactivate
+    else
+      source.deactivate
+    end
+  end
+end

data/lib/phenomenal/relationships/relationship.rb

@@ -0,0 +1,42 @@
+class Phenomenal::Relationship
+  attr_accessor :source,:target,:manager,:feature
+  
+  def initialize(source,target,feature)
+    @source=source
+    @target=target
+    @manager=Phenomenal::Manager.instance
+    @feature=feature
+    refresh
+  end
+  
+  def ==(other)
+    self.class==other.class && 
+    self.source==other.source && 
+    self.target==other.target &&
+    self.feature==other.feature
+  end
+  
+  def refresh
+    s = manager.context_defined?(source)
+    self.source=s if !s.nil?
+    
+    t = manager.context_defined?(target)
+    self.target=t if !t.nil?
+  end
+  
+  def activate_context(context)
+  end
+  
+  def deactivate_context(context)
+  end
+  
+  def activate_feature
+  end
+  
+  def deactivate_feature
+  end
+
+  def to_s
+    "#{self.class.name} between #{source.class.name}:#{source} and #{target.class.name}:#{target}"
+  end
+end

data/lib/phenomenal/relationships/relationships_manager.rb

@@ -0,0 +1,63 @@
+require 'singleton'
+
+class Phenomenal::RelationshipsManager
+  include Singleton
+  
+  attr_accessor :relationships
+  
+  def activate_relationships(context)
+    # Step 1: Import the new relationships for a feature
+    if context.is_a?(Phenomenal::Feature)
+      import_relationships(context)
+    end
+    # Step 2: Apply relationships
+    relationships.get_for(context).each do |relationship|
+      relationship.activate_context(context)
+    end
+  end
+  
+  def deactivate_relationships(context)
+    # Step 1: Unapply relationships
+    relationships.get_for(context).each do |relationship|
+      relationship.deactivate_context(context)
+    end
+    # Step 2: Remove relationships
+    if context.is_a?(Phenomenal::Feature)
+      remove_relationships(context)
+    end
+  end
+  
+  # Called when a context is defined in the manager
+  def update_relationships_references(context)
+    relationships.update_references(context)
+  end
+  
+  private
+  def import_relationships(feature)
+    begin
+      feature.relationships.each do |relationship|
+        relationship.refresh # Update references
+        relationship.activate_feature # Activate relationship
+        relationships.add(relationship)
+      end
+    rescue Phenomenal::Error => m
+      feature.deactivate
+      Phenomenal::Logger.instance.debug(
+        "Unable to activate the feature #{feature} \n #{m}"
+      )
+    end
+  end
+  
+  def remove_relationships(feature)
+    feature.relationships.each do |relationship|
+      if relationships.include?(relationship)
+        relationship.deactivate_feature
+        relationships.remove(relationship)
+      end
+    end
+  end
+  
+  def initialize
+    @relationships = Phenomenal::RelationshipsStore.new
+  end
+end

data/lib/phenomenal/relationships/relationships_store.rb

@@ -0,0 +1,73 @@
+class Phenomenal::RelationshipsStore
+  attr_accessor :sources, :targets
+  
+  def initialize
+    @sources = {}
+    @targets = {}
+  end
+  
+  def add(relationship)
+    if @sources[relationship.source].nil?
+      @sources[relationship.source] = Array.new 
+    end
+    @sources[relationship.source].push(relationship)
+    
+    if @targets[relationship.target].nil?
+      @targets[relationship.target] = Array.new 
+    end
+    @targets[relationship.target].push(relationship)
+  end
+  
+  def remove(relationship)
+    @sources[relationship.source].delete(relationship) if @sources[relationship.source] # In case of rollback
+    @targets[relationship.target].delete(relationship) if @targets[relationship.target]
+  end
+  
+  def include?(relationship)
+    if @sources[relationship.source]
+      @sources[relationship.source].include?(relationship)
+    else
+      false
+    end
+  end
+  
+  def update_references(context)
+    # Do nothing when anonymous, references are already valid
+    return if context.anonymous?
+    # Update sources 
+    @sources[context.name].each do |relationship|
+      relationship.source=context
+    end
+    @sources[context]=@source.delete(context.name)
+    # Update targets
+    @targets[context.name].each do |relationship|
+      relationship.target=context
+    end
+    @targets[context]=@targets.delete(context.name)
+  end
+  
+  def get_for(context)
+    get_for_source(context).concat(get_for_target(context))
+  end
+  
+  private
+  # Return an array of relationships
+  def get_for_source(source)
+    rel = @sources[source]
+    if rel.nil?
+      Array.new
+    else
+      rel
+    end
+  end
+  
+  # Return an array of relationships
+  def get_for_target(target)
+    rel = @targets[target]
+    if rel.nil?
+      Array.new
+    else
+      rel
+    end
+  end
+end

data/lib/phenomenal/relationships/requirement.rb

@@ -0,0 +1,26 @@
+class Phenomenal::Requirement < Phenomenal::Relationship
+  def activate_feature
+    check_requirement
+  end
+  
+  def activate_context(context)
+    if(source==context)
+      check_requirement
+    end
+  end
+  
+  def deactivate_context(context)
+    if(target==context)
+      source.deactivate
+    end
+  end
+  
+  private
+  def check_requirement
+    if source.active? && !target.active?
+      Phenomenal::Logger.instance.error(
+        "Requirement of #{target} for #{source} is not satisfied"
+      )
+    end
+  end
+end

data/lib/phenomenal/relationships/suggestion.rb

@@ -0,0 +1,41 @@
+class Phenomenal::Suggestion < Phenomenal::Relationship
+  attr_accessor :activation_counter
+  
+  def initialize(source,target,feature)
+    super(source,target,feature)
+    @activation_counter=0
+  end
+  
+  def activate_feature
+    begin
+      if source.active?
+        target.activate
+        self.activation_counter+=1
+      end
+    rescue
+    end
+  end
+  
+  def deactivate_feature
+    begin
+      if activation_counter>0
+        target.deactivate
+        self.activation_coutner-=1
+      end
+    rescue
+    end
+  end
+  
+  
+  def activate_context(context)
+    if source==context
+      target.activate
+    end
+  end
+  
+  def deactivate_context(context)
+    if source==context
+      target.deactivate
+    end
+  end
+end

data/lib/phenomenal/version.rb

@@ -0,0 +1,3 @@
+module Phenomenal
+  VERSION = "0.9.0"
+end

data/spec/adaptation_spec.rb

@@ -0,0 +1,64 @@
+require "spec_helper"
+describe Phenomenal::Adaptation do
+  before :each do
+   define_test_classes
+  end
+  
+  describe "#deploy" do
+    it "should be able to deploy itself in instances to override default implementation" do
+      adaptation = Phenomenal::Adaptation.new(nil,TestString,:length,true,Proc.new{-1})
+      t = TestString.new("1234")
+      t.length.should == 4
+      expect {adaptation.deploy}.to_not raise_error
+      t.length.should == -1
+    end
+    
+    it "should be able to deploy itself in classes to override default implementation" do
+      TestString.name.should == "TestString"
+      adaptation = Phenomenal::Adaptation.new(nil,TestString,:name,false,Proc.new{"TEST"})
+      expect {adaptation.deploy}.to_not raise_error
+      TestString.name.should == "TEST"
+    end
+  end
+  
+  describe "#bind" do
+    it "should be possible to temporary bind adapation as instance methods" do
+      adaptation = Phenomenal::Adaptation.new(nil,TestString,:length,true,Proc.new{-10})
+      t = TestString.new("1234")
+      t.length.should == -1
+      adaptation.bind(t).should == -10
+      t.length.should == -1
+    end
+    
+    it "should be possible to temporary bind adapatation as class methods" do
+      TestString.name.should == "TEST"
+      adaptation = Phenomenal::Adaptation.new(nil,TestString,:name,false,Proc.new{"TEST2"})
+      adaptation.bind(TestString).should == "TEST2"
+      TestString.name.should == "TEST"
+    end
+  end
+  
+  describe "#instance_adaptation?" do
+    it "should return true if the method is a instance method" do
+      adaptation = Phenomenal::Adaptation.new(nil,TestString,:length,true,Proc.new{-10})
+      adaptation.instance_adaptation?.should be_true
+    end
+    
+    it "should return false if the method is a class method" do
+      adaptation = Phenomenal::Adaptation.new(nil,TestString,:name,false,Proc.new{"TEST2"})
+      adaptation.instance_adaptation?.should be_false
+    end
+  end
+  
+  describe "#concern" do
+   it "should return true if the adaptation concern the class n_klass and method n_method and is instance method if instance=true" do
+     adaptation = Phenomenal::Adaptation.new(nil,TestString,:length,true,Proc.new{-10})
+     adaptation.concern?(TestString,:length,true).should be_true
+   end
+   
+   it "should return false if the adaptation doesn't concern the class n_klass and method n_method and is instance method if instance=true" do
+     adaptation = Phenomenal::Adaptation.new(nil,TestString,:size,true,Proc.new{-10})
+     adaptation.concern?(TestString,:length,true).should be_false
+   end
+  end
+end

data/spec/behavior/adaptation_spec.rb

@@ -0,0 +1,5 @@
+require "spec_helper"
+
+describe "Simple adaptations" do
+  pending "TODO"
+end

data/spec/behavior/combined_contexts_spec.rb

@@ -0,0 +1,5 @@
+require "spec_helper"
+
+describe "Combined contexts" do
+  pending "TODO"
+end

data/spec/behavior/composition_spec.rb

@@ -0,0 +1,5 @@
+require "spec_helper"
+
+describe "Composition of adaptations" do
+  pending "TODO"
+end

data/spec/behavior/conflict_policy_spec.rb

@@ -0,0 +1,5 @@
+require "spec_helper"
+
+describe "Conflict policies" do
+  pending "TODO"
+end

data/spec/behavior/open_context.rb

@@ -0,0 +1,5 @@
+require "spec_helper"
+
+describe "Open context facilities" do
+  pending "TODO"
+end

data/spec/behavior/relationships_spec.rb

@@ -0,0 +1,249 @@
+require "spec_helper"
+
+describe "Relationships" do
+  before :each do
+    @manager = Phenomenal::Manager.instance
+    @feature = Phenomenal::Feature.new(:feature)
+    @context_names = [:a,:b,:c,:d,:e,:f,:g]
+    @context_names.each do |name|
+      @feature.context(name)
+    end
+    
+  end
+  
+  after :each  do
+    force_forget_context(@feature)
+    @context_names.each do |name|
+      force_forget_context(name)
+    end
+    @manager.default_context.deactivate
+    @manager.default_context.forget
+  end
+  
+  describe Phenomenal::Feature do
+    it "should be able to add requirements for contexts" do
+      @feature.should respond_to :requirements_for
+      @feature.method(:requirements_for).arity.should be(2),
+      "Bad arity, should be 2"
+    end
+    it "should be able to add implications for contexts" do
+      @feature.should respond_to :implications_for
+      @feature.method(:implications_for).arity.should be(2),
+      "Bad arity, should be 2"
+    end
+    it "should be able to add suggestions for contexts" do
+      @feature.should respond_to :suggestions_for
+      @feature.method(:suggestions_for).arity.should be(2),
+      "Bad arity, should be 2"
+    end
+    
+    describe "Requirements" do
+      it "should store requirements" do
+        @feature.requirements_for :a, :on=>[:b,:c,:d]
+        @feature.requirements_for :a, :on=>:e
+        @feature.relationships.should have(4).items
+      end
+      
+      it "should avoid activation with missing requirements" do
+        @feature.requirements_for :a, :on=>[:b,:c]
+        phen_activate_context(:feature)
+        expect {phen_activate_context(:a)}.to raise_error Phenomenal::Error
+        phen_context_active?(:a).should be_false
+      end
+      
+      it "should allow activation with all requirements" do
+        phen_activate_context(:feature)
+        phen_activate_context(:b)
+        phen_activate_context(:c)
+        expect {phen_activate_context(:a)}.to_not raise_error
+        phen_context_active?(:a).should be_true
+      end
+      
+      it "should deactivate source when target requirement is deactivated" do
+        @feature.requirements_for :a, :on=>[:b,:c]
+        phen_activate_context(:feature)
+        phen_activate_context(:b)
+        phen_activate_context(:c)
+        phen_activate_context(:a)
+        expect {phen_deactivate_context(:b)}.to_not raise_error
+        phen_context_active?(:a).should be_false
+      end
+      
+      it "should avoid feature activation when adding a not satisfied requirement" do
+        @feature.requirements_for :a, :on=>[:b,:c]
+        phen_activate_context(:a)
+        expect{phen_activate_context(:feature)}.to_not raise_error
+        phen_context_active?(:feature).should be_false
+      end
+      
+      after do
+        @manager.default_context.deactivate
+        @manager.default_context.forget
+      end
+      it "should be possible to add requirements to the default context" do
+        requirements_for :a, :on=>[:b,:c,:d]
+        requirements_for :a, :on=>:e
+        @manager.default_context.relationships.should have(4).items
+      end
+      
+      it "should be possible to put requirements in the nested contexts" do
+        feature :feature do 
+          context :a do
+            requires :b
+          end
+        end
+        @feature.relationships.should have(1).items
+      end
+      
+      it "should be possible to put requirements in combined nested contexts" do
+        feature :feature do 
+          context :a,:b do
+            requires :c,:d,:e
+          end
+        end
+        @feature.relationships.should have(3).items
+      end
+    end
+    describe "Implications" do
+      it "should store implications" do
+        @feature.implications_for :a, :on=>[:b,:c,:d]
+        @feature.implications_for :a, :on=>:e
+        @feature.relationships.should have(4).items
+      end
+      
+      it "should activate target when source is activated" do
+        @feature.implications_for :a, :on=>:b
+        @feature.activate
+        expect {phen_activate_context(:a)}.to_not raise_error
+        phen_context_active?(:a).should be_true
+        phen_context_active?(:b).should be_true
+      end
+      
+      it "should deactivate target when source is deactivated" do
+        @feature.implications_for :a, :on=>:b
+        @feature.activate
+        phen_activate_context(:a)
+        phen_deactivate_context(:a)
+        phen_context_active?(:b).should be_false
+      end
+      
+      it "should deactivate source when target is deactivated" do
+        @feature.implications_for :a, :on=>:b
+        @feature.activate
+        phen_activate_context(:a)
+        phen_deactivate_context(:b)
+        phen_context_active?(:a).should be_false
+      end
+      
+      it "should be possible to put implications in the nested contexts" do
+        feature :feature do 
+          context :a do
+            implies :b
+          end
+        end
+        @feature.relationships.should have(1).items
+      end
+      
+      it "should be possible to put implications in combined nested contexts" do
+        feature :feature do 
+          context :a,:b do
+            implies :c,:d,:e
+          end
+        end
+        @feature.relationships.should have(3).items
+      end
+    end
+    
+    describe "Suggestions" do
+      it "should be working on the default feature" do
+        suggestions_for :a,:on=>:b
+        @manager.default_context.relationships.should have(1).items
+        context(:a).active?.should be_false
+        context(:b).active?.should be_false
+        expect {activate_context :a}.to_not raise_error
+        context(:a).active?.should be_true
+        context(:b).active?.should be_true
+        expect {deactivate_context :a}.to_not raise_error
+        context(:a).active?.should be_false
+        context(:b).active?.should be_false
+        #TODO forget default
+      end
+      
+      it "should be possible to add relationships on active features" do
+        context(:a).active?.should be_false
+        context(:b).active?.should be_false
+        expect {activate_context :a}.to_not raise_error
+        suggestions_for :a,:on=>:b
+        @manager.default_context.relationships.should have(1).items
+        context(:a).active?.should be_true
+        context(:b).active?.should be_true
+        expect {deactivate_context :a}.to_not raise_error
+        context(:a).active?.should be_false
+        context(:b).active?.should be_false
+      end
+      
+      it "should apply the relationship on the activation of the feature that contain it" do
+        context(:a).active?.should be_false
+        context(:b).active?.should be_false
+        expect {activate_context :a}.to_not raise_error
+        @feature.suggestions_for :a,:on=>:b
+        context(:a).active?.should be_true
+        context(:b).active?.should be_false
+        expect {activate_context @feature}.to_not raise_error
+        context(:a).active?.should be_true
+        context(:b).active?.should be_true
+        expect {deactivate_context @feature}.to_not raise_error
+        context(:a).active?.should be_true
+        context(:b).active?.should be_false
+      end
+      
+      it "should store suggestions" do
+        @feature.suggestions_for :a, :on=>[:b,:c,:d]
+        @feature.suggestions_for :a, :on=>:e
+        @feature.relationships.should have(4).items
+      end
+      
+      it "should activate target when source is activated" do
+        @feature.suggestions_for :a, :on=>:b
+        @feature.activate
+        expect {phen_activate_context(:a)}.to_not raise_error
+        phen_context_active?(:a).should be_true
+        phen_context_active?(:b).should be_true
+      end
+      
+      it "should deactivate target when source is deactivated" do
+        @feature.suggestions_for :a, :on=>:b
+        @feature.activate
+        phen_activate_context(:a)
+        phen_deactivate_context(:a)
+        phen_context_active?(:b).should be_false
+      end
+      
+      it "should not deactivate source when target is deactivated" do
+        @feature.suggestions_for :a, :on=>:b
+        @feature.activate
+        phen_activate_context(:a)
+        phen_deactivate_context(:b)
+        phen_context_active?(:a).should be_true
+      end
+      
+      it "should be possible to put suggestions in the nested contexts" do
+        feature :feature do 
+          context :a do
+            suggests :b
+          end
+        end
+        @feature.relationships.should have(1).items
+      end
+      
+      it "should be possible to put suggestions in combined nested contexts" do
+        feature :feature do 
+          context :a,:b do
+            suggests :c,:d,:e
+          end
+        end
+        @feature.relationships.should have(3).items
+      end
+    end
+  end
+end