phenomenal 0.9.0 → 0.11.11.24.3

data/test/test_cop_composition.rb

@@ -0,0 +1,84 @@
+require_relative "../lib/phenomenal.rb"
+require_relative "./test_classes.rb"
+require "test/unit"
+
+class TestCopComposition < Test::Unit::TestCase
+  def setup
+    phen_define_context(:screening)
+    phen_add_adaptation(:screening,Phone,:advertise) do |a_call|
+      phen_proceed(a_call)+" with screening"
+    end
+    phen_define_context(:test)
+  end
+
+  def teardown
+    while phen_context_active?(:test) do
+      phen_deactivate_context(:test)
+    end
+    phen_forget_context(:test)
+
+    while phen_context_active?(:screening) do
+      phen_deactivate_context(:screening)
+    end
+    phen_forget_context(:screening)
+  end
+
+  def test_invalid_proceed
+    assert_raise(Phenomenal::Error, %( 
+      Proceed cannot be used outside adaptation of
+     other methods)) {phen_proceed}
+  end
+
+  def test_simple_composition_noargs
+    prefix = "It's a nice "
+    suffix = "simple composition"
+    composed = prefix+suffix
+    inst = TestClass.new(prefix)
+    phen_add_adaptation(:test,String,:to_s) {phen_proceed+suffix}
+    assert(inst.to_s==prefix,
+      "The base to_s method of String must have its default behaviour")
+    phen_activate_context(:test)
+    assert(inst.to_s==composed,
+      %(The adapted to_s method of String must had '#{suffix}'
+         at the end of the string))
+  end
+
+  def test_simple_composition_args
+    str="Nice String!"
+    inst= TestClass.new(str)
+    phen_add_adaptation(:test,String,:eql?) do | str |
+      if phen_proceed(str)
+        "OK"
+      else
+        "KO"
+      end
+    end
+    assert(inst.eql?(str),
+      "The base eql? method of String must have its default behaviour")
+    phen_activate_context(:test)
+    assert(inst.eql?(str)=="OK",
+      %(The adapted eql? method of String must return 'OK' if the two string
+        are equal))
+    assert(inst.eql?(str+str)=="KO",
+      %(The adapted eql? method of String must return 'KO' if the two string
+        are not equal))
+  end
+
+  def test_nested_activation
+    phone = Phone.new
+    call = Call.new("Alice")
+    phone.receive(call)
+
+    assert((phone.advertise(call))=="ringtone",
+  	  "Default behaviour should be expressed")
+  	 phen_activate_context(:screening)
+  	 assert((phone.advertise(call))=="ringtone with screening",
+  	  %(Screening information should be overlaid over the default ringtone
+  	  advertisement'.))
+  	  phen_deactivate_context(:screening)
+  	 assert((phone.advertise(call))=="ringtone",
+  	  "Default behaviour should be expressed")
+
+  end
+end
+

data/test/test_cop_conflictpolicy.rb

@@ -0,0 +1,177 @@
+require_relative "../lib/phenomenal.rb"
+require_relative "./test_classes.rb"
+require "test/unit"
+
+class TestCopConflictPolicy < Test::Unit::TestCase
+  def setup
+    phen_define_context(:screening)
+    phen_add_adaptation(:screening,Phone,:advertise) do |a_call|
+      phen_proceed(a_call)+" with screening"
+    end
+
+    phen_define_context(:quiet)
+    phen_add_adaptation(:quiet,Phone,:advertise){|a_call| "vibrator" }
+
+  end
+
+  def teardown
+    while phen_context_active?(:screening) do
+      phen_deactivate_context(:screening)
+    end
+    phen_forget_context(:screening)
+
+    while phen_context_active?(:quiet) do
+      phen_deactivate_context(:quiet)
+    end
+    phen_forget_context(:quiet)
+    phen_change_conflict_policy { |a,b| no_resolution_conflict_policy(a,b) }
+  end
+
+  def test_no_resolution_policy
+    assert_nothing_raised(Phenomenal::Error,"The first context have to be
+      activated without any problem"){phen_activate_context(:screening)}
+    assert_raise(Phenomenal::Error,"In the default policy, a second context
+      that adapt the same method and is not the default one cannot
+      be activated"){phen_activate_context(:quiet)}
+  end
+
+  def test_protocol_age_policy
+    assert(phen_context_informations(
+      phen_default_context)[:activation_age].kind_of?(Fixnum),
+      "Contexts should have the age property")
+  end
+
+  def test_activation_age_policy
+    phen_change_conflict_policy { |a,b| age_conflict_policy(a,b) }
+    puts "llll #{phen_default_context.class}"
+    assert(phen_context_active?(phen_default_context), 
+      "Default context should normally be active")
+    assert(!phen_context_active?(:screening), "Context1 should be inactive")
+    assert(!phen_context_active?(:quiet),"Context2 should be inactive")
+
+    phen_activate_context(:screening)
+    assert(phen_context_informations(:screening)[:activation_age] <
+            phen_context_informations(phen_default_context)[:activation_age],
+            "screening context has been activated more recently than default")
+
+    phen_activate_context(:quiet)
+    assert(phen_context_informations(:quiet)[:activation_age] <
+            phen_context_informations(:screening)[:activation_age],
+            "quiet context has been activated more recently than screening")
+    assert(phen_context_informations(:screening)[:activation_age] <
+            phen_context_informations(phen_default_context)[:activation_age],
+            "quiet context has still been activated more recently than default")
+    phen_deactivate_context(:quiet)
+    phen_deactivate_context(:screening)
+    phen_activate_context(:screening)
+    assert(phen_context_informations(:screening)[:activation_age] <
+            phen_context_informations(:quiet)[:activation_age],
+            "screening context has now been activated more recently than quiet")
+  end
+
+  def test_conflicting_activation_age_policy
+    phen_change_conflict_policy { |a,b| age_conflict_policy(a,b) }
+    assert_nothing_raised(Phenomenal::Error,"The first context have to be
+      activated without any problem"){phen_activate_context(:screening)}
+    assert_nothing_raised(Phenomenal::Error,"In the age policy, a second context
+      that adapt the same method and is not the default one should
+      be activated without error"){phen_activate_context(:quiet)}
+  end
+
+  def test_interleaved_activation_age_policy
+    phen_change_conflict_policy { |a,b| age_conflict_policy(a,b) }
+    phone = Phone.new
+    call = Call.new("Alice")
+    phone.receive(call)
+
+    assert((phone.advertise(call))=="ringtone",
+  	  "Default behaviour should be expressed --> ringtone")
+
+    phen_activate_context(:quiet)
+    assert((phone.advertise(call))=="vibrator",
+     "Call advertisement should adapt to quiet context")
+
+    phen_activate_context(:screening)
+    assert((phone.advertise(call))=="vibrator with screening",
+     "Screening information should be overlaid over quiet context behaviour
+      (vibrator)")
+
+    phen_deactivate_context(:quiet)
+    assert((phone.advertise(call))=="ringtone with screening",
+     "Screening information should be overlaid over default context behaviour
+      (ringtone)")
+
+    phen_deactivate_context(:screening)
+     assert((phone.advertise(call))=="ringtone",
+     "Call advertisement should be reverted to the default")
+  end
+
+  def test_nested_activation_age_policy
+    phen_change_conflict_policy { |a,b| age_conflict_policy(a,b) }
+    phone = Phone.new
+    call = Call.new("Alice")
+    phone.receive(call)
+
+    assert((phone.advertise(call))=="ringtone",
+	    "Default behaviour should be expressed --> ringtone")
+
+    phen_activate_context(:quiet)
+    assert((phone.advertise(call))=="vibrator",
+     "Call advertisement should adapt to quiet context")
+
+    phen_activate_context(:screening)
+    assert((phone.advertise(call))=="vibrator with screening",
+     "Screening information should be overlaid over quiet context behaviour
+      (vibrator)")
+
+    phen_deactivate_context(:screening)
+    assert((phone.advertise(call))=="vibrator",
+     "Call advertisement should be reverted to that of quiet context")
+
+    phen_deactivate_context(:quiet)
+     assert((phone.advertise(call))=="ringtone",
+     "Call advertisement should be reverted to the default")
+  end
+
+  def test_4_level_age_policy
+    phen_change_conflict_policy { |a,b| age_conflict_policy(a,b) }
+    phen_define_context(:level1)
+    phen_add_adaptation(:level1,TestClass,:print) do |arg|
+      phen_proceed(arg) + " 1 -> ARG1: #{arg.to_s}"
+    end
+
+    phen_define_context(:level2)
+    phen_add_adaptation(:level2,TestClass,:print) do |arg|
+      phen_proceed(arg) + " 2 -> ARG2: #{arg.to_s}"
+    end
+
+    phen_define_context(:level3)
+    phen_add_adaptation(:level3,TestClass,:print) do |arg|
+      phen_proceed(arg) + " 3 -> ARG3: #{arg.to_s}"
+    end
+
+    phen_define_context(:level4)
+    phen_add_adaptation(:level4,TestClass,:print) do |arg|
+      phen_proceed(arg) + " 4 -> ARG4: #{arg.to_s}"
+    end
+    t = TestClass.new("Foo")
+    assert(t.print("bar")=="0 -> ARG: bar",
+	    "Default behaviour should be expressed")
+    phen_activate_context(:level1)
+    phen_activate_context(:level2)
+    phen_activate_context(:level3)
+    phen_activate_context(:level4)
+    assert(t.print("bar")==
+    "0 -> ARG: bar 1 -> ARG1: bar 2 -> ARG2: bar 3 -> ARG3: bar 4 -> ARG4: bar",
+	    "Composed behaviour should be expressed")
+    phen_deactivate_context(:level1)
+    phen_forget_context(:level1)
+    phen_deactivate_context(:level2)
+    phen_forget_context(:level2)
+    phen_deactivate_context(:level3)
+    phen_forget_context(:level3)
+    phen_deactivate_context(:level4)
+    phen_forget_context(:level4)
+  end
+end
+

data/test/test_cop_infrastructure.rb

@@ -0,0 +1,129 @@
+require_relative "../lib/phenomenal.rb"
+require "test/unit"
+
+class TestCopInfrastructure < Test::Unit::TestCase
+  def setup
+    @cm = Phenomenal::Manager.instance
+  end
+
+  def test_protocol
+    context = Phenomenal::Context.new(:test)
+    assert(Phenomenal::Context, "The class Phenomenal::Context doesn't exist")
+    assert(@cm, "The class @cm exist")
+    assert_respond_to(context, :activate, "The activate method doesn't exist")
+    assert_respond_to(context, :deactivate,
+      "The deactivate method doesn't exist")
+    assert_respond_to(context, :active?, "The is_active method doesn't exist")
+    @cm.unregister_context(context)
+  end
+
+  def test_creation
+    context = Phenomenal::Context.new(:test)
+    assert_kind_of(Phenomenal::Context, context,
+      "A fresh instance should be contexts indeed")
+    assert(
+      (context.active?.is_a?(TrueClass) || context.active?.is_a?(FalseClass)),
+      "The context should be either active (true) or inactive (false).")
+    assert(!context.active?, "A fresh context should not be initially active.")
+    @cm.unregister_context(context)
+  end
+
+  def test_activation
+    context_name=:test
+    context = Phenomenal::Context.new(context_name)
+    assert(!context.active?, "A fresh context should not be initially active.")
+    assert_equal(context,context.activate,
+      "Phenomenal::Context activation should return the context")
+    assert(context.active?,
+      "Activation should leave the context in an active state")
+    assert_equal(context,context.deactivate,
+      "Phenomenal::Context deactivation should return the context")
+    assert(!context.active?,
+      "Deactivation should leave the context in an inactive state")
+      @cm.unregister_context(context)
+  end
+
+  def test_redundant_activation
+    context = Phenomenal::Context.new(:test)
+    assert(!context.active?, "A fresh context should not be initially active.")
+    10.times { context.activate }
+    assert(context.active?,
+      "Activation should leave the context in an active state")
+    9.times { context.deactivate }
+    assert(context.active?,
+      "Should stay active for fewer deactivations than activations")
+    context.deactivate
+    assert(!context.active?,
+      "Should become inactive after matching number of deactivations")
+      @cm.unregister_context(context)
+  end
+
+  def test_redundant_deactivation
+    context = Phenomenal::Context.new(:test)
+    assert(!context.active?, "A fresh context should not be initially active.")
+	  3.times { context.activate }
+	  assert(context.active?,
+	    "Activation should leave the context in an active state")
+	  9.times { context.deactivate }
+    assert(!context.active?,
+      "More deactivation than activation leave the context inactive")
+    context.activate
+    assert(context.active?,
+      "Deactivation does not accumulate once the context is already inactive")
+	  context.deactivate
+	  assert(!context.active?,
+	    "Deactivation does not accumulate once the context is already inactive")
+	    @cm.unregister_context(context)
+  end
+
+  def test_context_name
+    context_name = :test
+    context = Phenomenal::Context.new(context_name)
+    assert_respond_to(context, :name, "Contexts should have a name")
+    assert_equal(context_name,context.name,
+      "A fresh context should be the definition name")
+      @cm.unregister_context(context)
+  end
+
+  def test_default
+   assert_nothing_raised(Phenomenal::Error,"Default context should exist"){
+    @cm.default_context.informations[:name]}
+
+    assert(@cm.default_context.active?,
+      "The default context should normally be active")
+  end
+
+  def test_default_forget
+    old_informations = @cm.default_context.informations
+    assert_respond_to(@cm, :unregister_context,
+      "Method to drop unneeded contexts should exist")
+    assert(@cm.default_context.active?,
+      "The default context should be initialy active")
+    assert_raise(Phenomenal::Error,
+      "An active context cannot be thrown away"){
+      @cm.default_context.forget }
+	  @cm.default_context.deactivate
+    assert(!@cm.default_context.active?, "Default should be inactive")
+    assert_nothing_raised(Phenomenal::Error,
+      "It should be possible to forget an inactive context"){
+      @cm.default_context.forget }
+  	assert_nothing_raised(Phenomenal::Error,
+  	  %(Default context assumptions should hold for freshly
+  	  created default context)){
+  	  @cm.default_context.activate }
+  	  #TODO
+		#assert(old_informations[:creation_time]!=
+		  #@cm.context_informations(:default)[:creation_time],
+		  #"Fresh default context should not be the default context just forgotten")
+		assert(@cm.default_context.activate, "Default should be active")
+	end
+
+  def test_adaptation_api
+    assert_respond_to(@cm, :register_adaptation,
+      "Phenomenal::Context manager should allow to adapt methods")
+
+    assert_respond_to(@cm, :unregister_adaptation,
+      "Phenomenal::Context manager should allow to deadapt methods")
+  end
+end
+

data/test_declaration.rb

@@ -0,0 +1,18 @@
+require_relative 'lib/phenomenal.rb'
+class TestClass
+  def print(p)
+  end
+end
+
+class Phenomenal::TestDeclaration
+  act_as_context :persistent
+
+  adaptations_for TestClass
+  adapt :print  do |p|
+    puts p
+  end
+end
+
+Phenomenal::Manager.instance.find_context("Phenomenal::TestDeclaration").activate
+puts Phenomenal::Manager.instance.find_context("Phenomenal::TestDeclaration").persistent
+TestClass.new.print("plop")

metadata

@@ -2,7 +2,7 @@
 name: phenomenal
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.9.0
+  version: 0.11.11.24.3
 platform: ruby
 authors: 
 - Loic Vigneron - Thibault Poncelet
@@ -10,21 +10,16 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-24 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: rspec
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        version: "2.5"
-  type: :development
-  version_requirements: *id001
-description: A context oriented programming framework for Ruby
-email: team@phenomenal-gem.com
+date: 2011-10-07 00:00:00 Z
+dependencies: []
+
+description: |
+  Build gem command: 
+    gem build phenomenal.gemspec
+  Test gem command: 
+    rake test
+
+email: thibault.poncelet@student.uclouvain.be - loic.vigneron@student.uclouvain.be
 executables: []
 
 extensions: []
@@ -32,48 +27,27 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- test/test_cop_conflictpolicy.rb
+- test/test_cop_infrastructure.rb
+- test/test_classes.rb
+- test/test_cop_composition.rb
+- test/test_cop_adaptation.rb
+- README
+- phenomenal.gemspec
+- LICENSE
+- test_declaration.rb
+- demo_dsl.rb
+- demo_age.rb
+- demo.rb
 - lib/phenomenal/manager.rb
-- lib/phenomenal/feature.rb
 - lib/phenomenal/proc.rb
 - lib/phenomenal/conflict_policies.rb
 - lib/phenomenal/dsl.rb
-- lib/phenomenal/version.rb
-- lib/phenomenal/relationships/implication.rb
-- lib/phenomenal/relationships/relationships_store.rb
-- lib/phenomenal/relationships/relationship.rb
-- lib/phenomenal/relationships/requirement.rb
-- lib/phenomenal/relationships/dsl.rb
-- lib/phenomenal/relationships/relationships_manager.rb
-- lib/phenomenal/relationships/context_relationships.rb
-- lib/phenomenal/relationships/suggestion.rb
-- lib/phenomenal/relationships/feature_relationships.rb
 - lib/phenomenal/context.rb
 - lib/phenomenal/logger.rb
 - lib/phenomenal/adaptation.rb
 - lib/phenomenal.rb
-- LICENSE
 - Rakefile
-- README
-- spec/spec_helper.rb
-- spec/feature_spec.rb
-- spec/context_spec.rb
-- spec/behavior/composition_spec.rb
-- spec/behavior/combined_contexts_spec.rb
-- spec/behavior/adaptation_spec.rb
-- spec/behavior/open_context.rb
-- spec/behavior/conflict_policy_spec.rb
-- spec/behavior/relationships_spec.rb
-- spec/test_classes.rb
-- spec/manager_spec.rb
-- spec/adaptation_spec.rb
-- spec/relationships/relationships_store_spec.rb
-- spec/relationships/relationship_spec.rb
-- spec/relationships/feature_relationships_spec.rb
-- spec/relationships/dsl_spec.rb
-- spec/relationships/context_relationships_spec.rb
-- spec/relationships/relationships_manager_spec.rb
-- spec/dsl_spec.rb
-- spec/proc_spec.rb
 homepage: http://www.phenomenal-gem.com
 licenses: []
 
@@ -100,25 +74,10 @@ rubyforge_project:
 rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
-summary: A context oriented programming framework for Ruby
+summary: A context oriented programing framework for ruby
 test_files: 
-- spec/spec_helper.rb
-- spec/feature_spec.rb
-- spec/context_spec.rb
-- spec/behavior/composition_spec.rb
-- spec/behavior/combined_contexts_spec.rb
-- spec/behavior/adaptation_spec.rb
-- spec/behavior/open_context.rb
-- spec/behavior/conflict_policy_spec.rb
-- spec/behavior/relationships_spec.rb
-- spec/test_classes.rb
-- spec/manager_spec.rb
-- spec/adaptation_spec.rb
-- spec/relationships/relationships_store_spec.rb
-- spec/relationships/relationship_spec.rb
-- spec/relationships/feature_relationships_spec.rb
-- spec/relationships/dsl_spec.rb
-- spec/relationships/context_relationships_spec.rb
-- spec/relationships/relationships_manager_spec.rb
-- spec/dsl_spec.rb
-- spec/proc_spec.rb
+- test/test_cop_conflictpolicy.rb
+- test/test_cop_infrastructure.rb
+- test/test_classes.rb
+- test/test_cop_composition.rb
+- test/test_cop_adaptation.rb