phenomenal 0.9.0 → 0.11.11.24.3

data/spec/behavior/adaptation_spec.rb

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

data/spec/behavior/combined_contexts_spec.rb

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

data/spec/behavior/composition_spec.rb

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

data/spec/behavior/conflict_policy_spec.rb

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

data/spec/behavior/open_context.rb

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

data/spec/behavior/relationships_spec.rb

@@ -1,249 +0,0 @@
-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

data/spec/context_spec.rb

@@ -1,268 +0,0 @@
-require "spec_helper"
-
-describe Phenomenal::Context do
-  
-  before :each do
-    @context = Phenomenal::Context.new(:test)
-    @context2 = Phenomenal::Context.new(:test2)
-  end
-  
-  after :each  do
-    force_forget_context(@context)
-    force_forget_context(@context2)
-  end
-  
-  it "should exist" do
-     @context.should be_an_instance_of(Phenomenal::Context)
-  end  
-  
-  it "should accept adaptations" do
-    @context.should respond_to :add_adaptation
-  end
-  
-  it "should accept removing of adaptations" do
-    @context.should respond_to :remove_adaptation
-  end
-  
-  describe "#name" do
-    it "should have a name" do
-      @context.should respond_to :name
-    end
-    
-    it "should keep it's initial name" do
-      @context.name.should == :test
-    end
-    
-    it "should be anonymous if the name wasn't set" do
-      Phenomenal::Context.new.name.should be_nil
-    end
-    
-    it "should be anonymous if it is the default context" do
-      Phenomenal::Manager.instance.default_context.name.should be_nil
-    end
-  end
-  
-  describe ".create" do
-    pending "TODO"
-  end
-  
-  describe "#forget" do
-    pending "TODO"
-  end
-  
-  describe "#add_adaptation" do
-    pending "TODO"
-  end
-  
-  describe "#remove_adaptation" do
-    pending "TODO"
-  end
-  
-  describe "#context" do
-    pending "TODO"
-    
-    describe "#phen_context" do
-      it "should be an alias of #context" do
-       Phenomenal::Context.instance_method(:context).should==Phenomenal::Context.instance_method(:phen_context)
-      end
-    end
-  end
-  
-  describe "#feature" do
-    pending "TODO"
-    
-    describe "#phen_feature" do
-      it "should be an alias of #feature" do
-       Phenomenal::Context.instance_method(:feature).should==Phenomenal::Context.instance_method(:phen_feature)
-      end
-    end
-  end
-  
-  describe "#add_adaptations" do
-    pending "TODO"
-  end
-  
-  describe "#adapatations_for" do
-    pending "TODO"
-  end
-  
-  describe "#adapt" do
-    pending "TODO"
-  end
-  
-  describe "#adapt_klass" do
-    pending "TODO"
-  end
-  
-  
-  describe "(de)activation of contexts" do
-    it "should initially not be active" do
-      @context.active?.should be_false
-    end
-    
-    describe "#activate" do
-      it "should be activatable" do
-        @context.should respond_to :activate
-      end
-      
-      it "should activate the context" do
-        @context.activate
-        @context.active?.should be_true
-      end
-      
-      it "should increment activation count" do
-        @context.activate
-        @context.activation_count.should == 1
-        @context.activate
-        @context.activation_count.should == 2
-      end
-      
-      it "should reset activation age" do
-       @context.activate
-       @context.age.should == 0
-       @context2.activate
-      @context.age.should == 1
-      end  
-      
-      it "should return the context on activation" do
-        @context.should be @context.activate 
-      end
-    end
-    
-    describe "#deactivate" do
-      it "should be deactivatable" do 
-        @context.should respond_to :deactivate
-      end
-      
-      it "should return the context on deactivation" do
-        @context.should be @context.deactivate 
-      end
-      it "should be inactive after deactivation" do
-        @context.activate
-        @context.deactivate
-        @context.active?.should be_false
-      end
-    end
-    
-    describe "Redundant (de)activations " do
-      before :each do
-       10.times { @context.activate }
-      end
-      
-      it "should stay active with fewer deactivations than activations" do
-        9.times { @context.deactivate }
-        @context.active?.should be true
-      end
-      
-      it "should became inactive with same deactivations than activations" do
-        10.times { @context.deactivate }
-        @context.active?.should be false
-      end
-      
-      it "should stay inactive with more deactivations than activations" do
-        15.times { @context.deactivate }
-        @context.active?.should be false
-      end
-      
-      it "should not accumulate once the context is inactive" do 
-        15.times { @context.deactivate }
-        @context.activate
-        @context.active?.should be true
-      end
-    end
-    
-    describe "#just_activated?" do
-      it "should be false if the context is inactive" do
-        @context.just_activated?.should be_false
-      end
-      
-      it "should be true if the context has becamed active at the very prior activation" do
-        @context.activate
-        @context.just_activated?.should be_true
-      end
-      
-      it "should be false again for the following activations" do
-        @context.activate.activate
-        @context.just_activated?.should be_false
-      end
-    end
-  end
-  
-  describe "#anonymous?" do
-    after do
-      force_forget_context(@context3)
-    end
-    it "should be true when the context has no name" do
-      @context3 = Phenomenal::Context.new
-      @context3.anonymous?.should be_true
-    end
-    
-    it "should be false when the context has a name" do
-      @context.anonymous?.should be_false
-    end
-    
-    it "should be true for the default context" do
-      Phenomenal::Manager.instance.default_context.anonymous?.should be_true
-    end
-  end
-  
-  describe "#information" do
-    it "should have all and only 6 defined fields " do
-      @context.information.should have(6).items
-    end
-    it "should have a matching :name field" do
-      @context.information[:name].should==:test
-      default = Phenomenal::Manager.instance.default_context
-      default.information[:name].should be_nil
-    end
-    it "should have a matching :adaptation field" do
-      @context.information[:adaptations].should==@context.adaptations
-    end
-    it "should have a matching :active field" do
-      @context.information[:active].should be_false
-      @context.activate 
-      @context.information[:active].should be_true
-    end
-    it "should have a matching :age field" do
-      @context.activate
-      @context.information[:age].should==0
-      @context2.activate
-      @context.information[:age].should==1
-      @context2.information[:age].should==0
-    end
-    it "should have a matching :activation_count field" do
-      @context.information[:activation_count].should==0
-      @context.activate
-      @context.information[:activation_count].should==1
-    end
-    after do
-      force_forget_context(@feature)
-    end
-    it "should have a matching :type field" do
-      @context.information[:type].should=="Phenomenal::Context"
-      @feature = Phenomenal::Feature.new
-      @feature.information[:type].should=="Phenomenal::Feature"
-    end
-    
-      
-  end
-  describe "#parent_feature" do
-    it "should be the default feature parent for simple contexts" do
-      c = context :b
-      c.parent_feature.should be Phenomenal::Manager.instance.default_context
-      c.forget
-    end
-    
-    it "should be the closest feature for in-feature contexts" do
-      c=nil
-      f = feature :f do
-        c=context :c do
-        end
-      end
-      c.parent_feature.should be f
-      c.forget
-      f.forget
-    end
-  end
-end
-