phenomenal 0.9.0 → 0.11.11.24.3

data/lib/phenomenal/feature.rb

@@ -1,8 +0,0 @@
-class Phenomenal::Feature < Phenomenal::Context
-  include Phenomenal::FeatureRelationships
-
-  def initialize(name=nil,manager=nil)
-    super(name,manager)
-    initialize_relationships
-  end
-end

data/lib/phenomenal/relationships/context_relationships.rb

@@ -1,22 +0,0 @@
-module Phenomenal::ContextRelationships
-  def requires(context,*contexts)
-    contexts = contexts.push(context)
-    contexts.each do |target|
-      self.parent_feature.requirements_for(self,{:on=>target})
-    end
-  end
-  
-  def implies(context,*contexts)
-    contexts = contexts.push(context)
-    contexts.each do |target|
-      self.parent_feature.implications_for(self,{:on=>target})
-    end
-  end
-  
-  def suggests(context,*contexts)
-    contexts = contexts.push(context)
-    contexts.each do |target|
-      self.parent_feature.suggestions_for(self,{:on=>target})
-    end
-  end
-end

data/lib/phenomenal/relationships/dsl.rb

@@ -1,18 +0,0 @@
-module Phenomenal::DSL
-  def self.define_relationships(klass)
-    klass.class_eval do
-      # Requirements
-      def requirements_for(source,targets)
-        Phenomenal::Manager.instance.default_context.requirements_for(source,targets)
-      end
-       # Implications
-      def implications_for(source,targets)
-        Phenomenal::Manager.instance.default_context.implications_for(source,targets)
-      end
-       # Suggestions
-      def suggestions_for(source,targets)
-        Phenomenal::Manager.instance.default_context.suggestions_for(source,targets)
-      end
-    end
-  end
-end

data/lib/phenomenal/relationships/feature_relationships.rb

@@ -1,42 +0,0 @@
-module Phenomenal::FeatureRelationships 
-  attr_accessor :relationships
-  
-  def initialize_relationships
-    @relationships = Array.new
-  end
-  
-  def requirements_for(source,targets)
-    add_relationship(source,targets,Phenomenal::Requirement)
-  end  
-  
-  def implications_for(source,targets)
-    add_relationship(source,targets,Phenomenal::Implication)
-  end  
-  
-  def suggestions_for(source,targets)
-    add_relationship(source,targets,Phenomenal::Suggestion)
-  end  
-  
-  private 
-  def add_relationship(source,targets,type)
-    targets[:on]=Array.new.push(targets[:on]) if !targets[:on].is_a?(Array)
-    
-    if targets[:on].nil?
-      Phenomenal::Logger.instance.error(
-        "Invalid relationship, missing target context"
-      )
-    end
-    targets[:on].each do |target|      
-      r = type.new(source,target,self)
-      if relationships.find{|o| o==r}.nil?
-        relationships.push(r)
-        if self.active?
-          r.refresh
-          manager.rmanager.relationships.add(r)
-          r.activate_feature 
-        end
-      end
-    end
-    
-  end
-end

data/lib/phenomenal/relationships/implication.rb

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

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

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

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

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

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

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

data/spec/adaptation_spec.rb

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