patriarch 0.1.0 → 0.2.0

data/.gitignore

@@ -1,5 +1,6 @@
 redis_reclip_cleaner.rb
 spec/dummy
+stats.svg
 *.gem
 *.rbc
 *.swp

data/lib/patriarch/behaviours.rb

@@ -1,13 +1,25 @@
 require 'verbs'
 require 'patriarch'
 
+
 module Patriarch
+
+  # Patriarch::Behaviours is meant to be included into any class we want to enhance with Patriarch handled behaviours
+  # Thus it defines the +included+ hook so we enhance the class in which it is included freely and add to 
+  # it some class methods defined into Patriarch::Behaviours::ClassMethods
+  # We define there the +add_behaviour+ method that does three things : 
+  # * it generates an anonymous module containing tool methods defined ad-hoc in function of the arguments supplied
+  # * it includes another module that lives into a generated file in lib/ allowing us to override existing methods or add new ones if we wish
+  # * it defines instance methods for the class allowing instances to call behaviour actions
   module Behaviours
 
+    # Exception raised when +add_behaviour+ declaration in a class has wrong syntax
     class AddBehaviourSyntaxError < Exception ; end
+    class AddBehaviourDependencyError < Exception ; end    
 
     class << self
 
+      # Helper function to complete the anonymous module we include later in the process in the enhanced model class
       def complete_custom_active_module_bipartite(module_to_complete,relation_type,acted_on_model_list)
         module_to_complete.class_eval do
 
@@ -123,7 +135,25 @@ module Patriarch
 
       def included(klass)
         klass.extend ClassMethods
-        klass.extend ActiveModel::Callbacks
+        #klass.extend ActiveModel::Callbacks
+        unless klass.respond_to?(:before_destroy) && klass.respond_to?(:after_destroy)
+          raise AddBehaviourDependencyError, "class #{klass.name} including Patriarch::Behaviours does not support callbacks"
+        end
+
+        klass.class_eval do
+          
+          before_destroy :compute_redis_dependencies
+          def compute_redis_dependencies
+            @redis_destroy_transac_object = Patriarch::ToolServices::RedisCleanerService.instance.clean_all(self)
+          end
+
+          after_destroy  :clean_redis_dependencies
+          def clean_redis_dependencies
+            @redis_destroy_transac_object.execute
+          end
+
+        end
+
         class << klass;
           # not sure if should add an alias like behaviours here
           # might override other behaviour methods from other namespaces
@@ -213,7 +243,34 @@ module Patriarch
         self.send(:include,methods_mod)
         # include in which we can overwite the methods of the previous custom module included there ...
         self.send(:include,"Patriarch::Behaviours::#{behaviour.classify}::ToolsMethods".constantize)
+        # TODO disjonction register tripartite
+        # register the behaviour we just added
+        self.patriarch_behaviours ||= { }
+        
+        if options[:via]
+          self.patriarch_behaviours[behaviour.underscore.to_sym] ||= { :on => [], :by => [], :via => [] }
+        elsif options[:medium_between]
+          self.patriarch_behaviours[behaviour.underscore.to_sym] ||= { :medium_between => [] }
+        end 
 
+        if options[:via]
+          if options[:on]
+            self.patriarch_behaviours[behaviour.underscore.to_sym][:on] << options[:on]
+            self.patriarch_behaviours[behaviour.underscore.to_sym][:on].uniq!
+            self.patriarch_behaviours[behaviour.underscore.to_sym][:on].flatten!
+          elsif options[:by]
+            self.patriarch_behaviours[behaviour.underscore.to_sym][:by] << options[:by]
+            self.patriarch_behaviours[behaviour.underscore.to_sym][:by].uniq!
+            self.patriarch_behaviours[behaviour.underscore.to_sym][:by].flatten!
+          end
+            self.patriarch_behaviours[behaviour.underscore.to_sym][:via] << options[:via]
+            self.patriarch_behaviours[behaviour.underscore.to_sym][:via].uniq!
+            self.patriarch_behaviours[behaviour.underscore.to_sym][:via].flatten!    
+        elsif options[:medium_between]
+          self.patriarch_behaviours[behaviour.underscore.to_sym][:medium_between] << options[:medium_between]
+          self.patriarch_behaviours[behaviour.underscore.to_sym][:medium_between].uniq!
+          self.patriarch_behaviours[behaviour.underscore.to_sym][:medium_between]
+        end    
       end
 
       def add_bipartite_behaviour(behaviour,options)
@@ -288,7 +345,6 @@ module Patriarch
         self.send(:include,"Patriarch::Behaviours::#{behaviour.classify}::ToolsMethods".constantize)
 
         # register the behaviour we just added
-        # TODO disjonction bi/tripart
         self.patriarch_behaviours ||= { }
         self.patriarch_behaviours[behaviour.underscore.to_sym] ||= { :on => [], :by =>[] }
         if options[:on] 

data/lib/patriarch/dao_services/retriever_service.rb

@@ -48,8 +48,6 @@ class Patriarch::DAOServices::RetrieverService < Patriarch::Service
     medium_id = transaction_item.medium_id
     medium_type = transaction_item.medium_type
     
-    puts "#{medium_type} - #{medium_id}"
-
     if Redis::Objects.constants.map(&:to_s).include?("#{dao_info[:type].pluralize.camelize}")
       redis_dao_class = "Redis::#{dao_info[:type].camelize}".constantize
     else

data/lib/patriarch/tool_services/redis_cleaner_service.rb

@@ -1,39 +1,94 @@
 class Patriarch::ToolServices::RedisCleanerService < Patriarch::Service
   
   # Shall be tested before implementation ...  
-  def clean_all(calling_entity)
-    calling_entity.patriarch_behaviours.keys.each do |behaviour|
-      clean_behaviour(calling_entity,behaviour)
+  def clean_all(calling_entity,options={})
+    transac = options[:transac] || Patriarch::TransactionServices::TransactionManagerService.instance.new_transaction("clean_all".to_sym)
+    options = { :transac => transac }
+
+    calling_entity.class.patriarch_behaviours.keys.each do |behaviour|
+      clean_behaviour(calling_entity,behaviour,options)
     end
+
+    transac
   end
 
-  def clean_behaviour(calling_entity,behaviour)
+  def clean_behaviour(calling_entity,behaviour,options={})
     my_behaviours = calling_entity.class.patriarch_behaviours
     
     if my_behaviours.include? behaviour.to_s.underscore.to_sym
-      if my_behaviours[behaviour.to_s.underscore.to_sym][:medium_between]
-        clean_tripartite_behaviour(calling_entity,behaviour)
+      if my_behaviours[behaviour.to_s.underscore.to_sym][:medium_between] || my_behaviours[behaviour.to_s.underscore.to_sym][:via]
+        clean_tripartite_behaviour(calling_entity,behaviour,options)
       else
-        clean_bipartite_behaviour(calling_entity,behaviour)
+        clean_bipartite_behaviour(calling_entity,behaviour,options)
       end
     end
   end
 
-  def clean_bipartite_behaviour(calling_entity,behaviour)
-    #
-    # FIXME Shall clean in one blow, need to prevent transaction from "propagating"
+
+#Copiepat
+  def clean_tripartite_behaviour(calling_entity,behaviour,options={})
+    my_behaviours = calling_entity.class.patriarch_behaviours
     
-    # → → → include option to transmit transaction and prevent it from execute
+    # Compute names based on conventions    
+    progressive_present_behaviour = 
+      (Verbs::Conjugator.conjugate behaviour.to_s.underscore.to_sym, :aspect => :progressive).split(/ /).last
+
+    transac = options[:transac] || Patriarch::TransactionServices::TransactionManagerService.instance.new_transaction("clean_#{behaviour.to_s}".to_sym)
+    options = { :transac => transac, :stop_execution => true}
+
+    if my_behaviours.include? behaviour.to_s.underscore.to_sym
+
+      # Dealing with active behaviour
+      if my_behaviours[behaviour.to_s.underscore.to_sym][:on]
+        acted_on_models = my_behaviours[behaviour.to_s.underscore.to_sym][:on]
+        via_models      = my_behaviours[behaviour.to_s.underscore.to_sym][:via]
+        acted_on_models.each do |acted_on_model|
+          via_models.each do |via_model|
+            calling_entity.send("#{acted_on_model.to_s.tableize}_i_#{behaviour.to_s}_via_#{via_model.to_s.tableize}", :with_medium => true).each do |tripartite_hash|
+              target_i_behaved_on  = Array(acted_on_model.to_s.classify.constantize.find(tripartite_hash[:target])).first
+              medium_for_behaviour = Array(via_model.to_s.classify.constantize.find(tripartite_hash[:medium])).first
+              calling_entity.send(Patriarch.undo(behaviour.to_s).underscore,target_i_behaved_on,medium_for_behaviour,options)
+            end
+          end
+        end
+      end
+      
+      # Dealing with passive behaviour
+      if my_behaviours[behaviour.to_s.underscore.to_sym][:by]
+        targetted_by_models = my_behaviours[behaviour.to_s.underscore.to_sym][:by]
+        via_models      = my_behaviours[behaviour.to_s.underscore.to_sym][:via]        
+        targetted_by_models.each do |targetted_by_model|
+          via_models.each do |via_model|          
+            calling_entity.send("#{targetted_by_model.to_s.tableize}_#{progressive_present_behaviour}_me_via_#{via_model.to_s.tableize}", :with_medium => true).each do |tripartite_hash|
+              #
+              actor_that_behaved_on_me = Array(targetted_by_model.to_s.classify.constantize.find(tripartite_hash[:actor])).first
+              medium_for_behaviour = Array(via_model.to_s.classify.constantize.find(tripartite_hash[:medium])).first
+              #
+              actor_that_behaved_on_me.send(Patriarch.undo(behaviour.to_s).underscore,calling_entity,medium_for_behaviour,options)
+            end
+          end
+        end
+      end
+
+      # Dealing with medium behaviour
+      if my_behaviours[behaviour.to_s.underscore.to_sym][:medium_between]
+        #do nothing, we do not take care of data relative to medium ...
+      end      
+    end # if my_behaviours.include?
+
+    transac  
+  end #clean_tripartite_behaviour
+
+
 
-    # Shall provide an option (:hard) that justs get the job done without heavey transaction stuff if performances
-    # are aching. Not now, for we have a transaction protecting us we go this way
+  def clean_bipartite_behaviour(calling_entity,behaviour,options={})
     my_behaviours = calling_entity.class.patriarch_behaviours
     
     # Compute names based on conventions    
     progressive_present_behaviour = 
       (Verbs::Conjugator.conjugate behaviour.to_s.underscore.to_sym, :aspect => :progressive).split(/ /).last
 
-    transac = Patriarch::TransactionServices::TransactionManagerService.instance.new_transaction("clean_#{behaviour.to_s}".to_sym)
+    transac = options[:transac] || Patriarch::TransactionServices::TransactionManagerService.instance.new_transaction("clean_#{behaviour.to_s}".to_sym)
     options = { :transac => transac, :stop_execution => true}
 
     if my_behaviours.include? behaviour.to_s.underscore.to_sym
@@ -59,6 +114,6 @@ class Patriarch::ToolServices::RedisCleanerService < Patriarch::Service
       end
     end # if my_behaviours.include?
 
-    transac.execute
-  end # #clean_behaviour
+    transac
+  end # #clean_bipartite_behaviour
 end  # class Patriarch ...

data/lib/patriarch/tool_services/redis_extractor_service.rb

@@ -24,21 +24,34 @@ class Patriarch::ToolServices::RedisExtractorService < Patriarch::Service
       result = ids_from_redis      
     end
 
-    if options[:tripartite]
-      if options[:with_scores]
-        if options[:protagonist_type] == :actor
-          result.map!{ |triplet_id_with_score| [triplet_id_with_score.first[0],tuple.last]}
-        elsif options[:protagonist_type] == :target
-          result.map!{ |triplet_id_with_score| [triplet_id_with_score.first[1],tuple.last]}
-        end
-      else
-        if options[:protagonist_type] == :actor
-          result.map!{ |triplet_id| triplet_id[0] }
-        elsif options[:protagonist_type] == :target
-          result.map!{ |triplet_id| triplet_id[1] }
+    #TODO Document me ...
+    if options[:with_medium]
+      # obv tripartite, particular case so we don't need scores here
+      result.map!{ |triplet_id| {:actor => triplet_id[0].to_i, :target => triplet_id[1].to_i, :medium => triplet_id[2].to_i}  }   
+      return result        
+    else 
+      if options[:tripartite]
+        if options[:with_scores]
+          if options[:protagonist_type] == :actor
+            result.map!{ |triplet_id_with_score| [triplet_id_with_score.first[0],tuple.last]}
+          elsif options[:protagonist_type] == :target
+            result.map!{ |triplet_id_with_score| [triplet_id_with_score.first[1],tuple.last]}
+          #elsif options[:protagonist_type] == :medium
+          #  result.map!{ |triplet_id_with_score| [triplet_id_with_score.first[2],tuple.last]}          
+          end
+        else
+          if options[:protagonist_type] == :actor
+            result.map!{ |triplet_id| triplet_id[0] }
+          elsif options[:protagonist_type] == :target
+            result.map!{ |triplet_id| triplet_id[1] }
+          #elsif options[:protagonist_type] == :medium
+          #  result.map!{ |triplet_id| triplet_id[2] }          
+          end
         end
       end
-    end
+    end      
+
+    # Add an option to handle cases where we need to retrieve medium as well ...
 
     result.map! do |x| 
       if x.is_a? Array
@@ -52,6 +65,11 @@ class Patriarch::ToolServices::RedisExtractorService < Patriarch::Service
   end 
 
   def get_models_from_ids(calling_entity,model,get_id_method,options={})        
+    if options[:with_medium]
+      id_hash_from_redis = calling_entity.send(get_id_method,options)
+      return id_hash_from_redis
+    end
+
     if options[:with_scores] 
       ids_with_scores_from_redis = calling_entity.send(get_id_method,options)
       ids_with_scores_from_redis.map! do |id,score|

data/lib/patriarch/transaction.rb

@@ -40,11 +40,18 @@ module Patriarch
     end
 
     # Executes the calls to redis in one block here.
+    #--
+    # XXX Take care when decoupling redis logoc from gem later
+    #++
     def execute
-      $redis.multi do
-        steps.each do |step|
-          step.execute
+      begin
+        $redis.multi do
+          steps.each do |step|
+            step.execute
+          end
         end
+      rescue Redis::BaseError => e #TODO find redis exception
+        raise ActiveRecord::Rollback, "redis error #{e.class.name} occured hence triggered transaction rollback"
       end
     end
 

data/lib/patriarch/transaction_step.rb

@@ -46,4 +46,4 @@ module Patriarch
       queue << proc
     end
   end
-end
+end

data/lib/patriarch/version.rb

@@ -1,3 +1,3 @@
 module Patriarch
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/patriarch.gemspec

@@ -14,12 +14,14 @@ Gem::Specification.new do |spec|
 
   # Main dependencies
   spec.add_runtime_dependency     "verbs"
-  spec.add_runtime_dependency     "rails"
   spec.add_runtime_dependency     "railties"
-
+  spec.add_runtime_dependency     "activerecord"
+  
   # Dependencies needed for testing
 	spec.add_development_dependency "rspec"
-  # TODO run with autotest
+  spec.add_development_dependency "activerecord"  
+  spec.add_development_dependency "sqlite3"  
+  # TODO run with autotest/guard
 
   # Other options ...
 	spec.files         = `git ls-files`.split($\)

data/spec/lib/patriarch/behaviours_spec.rb

@@ -3,19 +3,17 @@ require 'spec_helper'
 describe Patriarch::Behaviours do
   describe '#add_behaviour' do
 
-    let(:monster)      { Monster.new }
-    let(:fallen_angel) { FallenAngel.new }
-    let(:love_letter)  { LoveLetter.new }
+    let(:monster)      { Monster.create }
+    let(:fallen_angel) { FallenAngel.create }
+    let(:love_letter)  { LoveLetter.create }
 
 
 
     context 'on a bipartite' do
 
-      before do 
-        # Monster is the actor model and FallenAngel the target model here
+      before(:all) do
         Monster.add_behaviour       :like, :on => [:fallenAngel] 
         FallenAngel.add_behaviour   :like, :by => [:monster]
-        monster.like fallen_angel
       end
 
       context "call from a model including Patriarch::Behaviours" do
@@ -82,9 +80,11 @@ describe Patriarch::Behaviours do
           monster.undo_like(fallen_angel, :stop_execution => true).should be_an_instance_of(Patriarch::Transaction)
         end      
 
-        before(:all) { monster.like fallen_angel }
+       
 
         context 'when doing behaviour' do
+          before(:all) { monster.like fallen_angel }          
+
           it "allows actor to remember target id" do 
             monster.fallen_angels_i_like_ids.should == [fallen_angel.id]
           end
@@ -100,38 +100,43 @@ describe Patriarch::Behaviours do
           it "allows target to remember actor instance" do 
             fallen_angel.monsters_liking_me.should == [monster]
           end      
+
+          after(:all) { monster.undo_like fallen_angel }              
         end
 
         context 'when undoing behaviour' do
+          before(:all) do 
+            monster.like fallen_angel  
+            monster.undo_like fallen_angel 
+          end          
+
           it "erase target id from actor's memory" do 
-            monster.fallen_angels_i_like_ids.should == [fallen_angel.id]
+            monster.fallen_angels_i_like_ids.should be_empty
           end
 
           it "erase target instance from actor's memory" do 
-            monster.fallen_angels_i_like.should == [fallen_angel]
+            monster.fallen_angels_i_like.should be_empty
           end
           
           it "erase actor id from target's memory" do 
-            fallen_angel.monsters_liking_me_ids.should == [monster.id]        
+            fallen_angel.monsters_liking_me_ids.should be_empty    
           end
 
           it "erase actor instance from target's memory" do 
-            fallen_angel.monsters_liking_me.should == [monster]
-          end     
+            fallen_angel.monsters_liking_me.should be_empty
+          end             
         end
 
-        after(:all) { monster.undo_like fallen_angel }
       end 
     end # context bipartite
 
     context 'on a tripartite' do
 
-      before do 
+      before(:all) do 
         # Monster is the actor model and FallenAngel the target model here
         Monster.add_behaviour       :praise, :on => [:fallenAngel], :via => [:loveLetter]
         FallenAngel.add_behaviour   :praise, :by => [:monster], :via => [:loveLetter]
         LoveLetter.add_behaviour    :praise, :medium_between => [:monster,:fallenAngel]
-        monster.praise(fallen_angel,love_letter)
       end
 
       context "call from a model including Patriarch::Behaviours" do
@@ -187,9 +192,11 @@ describe Patriarch::Behaviours do
           monster.praise(fallen_angel, love_letter, :stop_execution => true).should be_an_instance_of(Patriarch::Transaction)
         end
 
-        before(:all) { monster.praise fallen_angel,love_letter }
+
 
         context 'when doing behaviour' do
+          before(:all) { monster.praise fallen_angel,love_letter }
+          
           it "allows actor to remember target id" do 
             monster.fallen_angels_i_praise_via_love_letters_ids.should == [fallen_angel.id]
           end
@@ -205,27 +212,34 @@ describe Patriarch::Behaviours do
           it "allows target to remember actor instance" do 
             fallen_angel.monsters_praising_me_via_love_letters.should == [monster]
           end      
+          
+          after(:all) { monster.undo_praise fallen_angel,love_letter }          
         end
 
         context 'when undoing behaviour' do
+          before(:all) do
+            monster.praise fallen_angel,love_letter
+            monster.undo_praise fallen_angel,love_letter
+          end
+
           it "erase target id from actor's memory" do 
-            monster.fallen_angels_i_praise_via_love_letters_ids.should == [fallen_angel.id]
+            monster.fallen_angels_i_praise_via_love_letters_ids.should be_empty
           end
 
           it "erase target instance from actor's memory" do 
-            monster.fallen_angels_i_praise_via_love_letters.should == [fallen_angel]
+            monster.fallen_angels_i_praise_via_love_letters.should be_empty
           end
           
           it "erase actor id from target's memory" do 
-            fallen_angel.monsters_praising_me_via_love_letters_ids.should == [monster.id]        
+            fallen_angel.monsters_praising_me_via_love_letters_ids.should be_empty  
           end
 
           it "erase actor instance from target's memory" do 
-            fallen_angel.monsters_praising_me_via_love_letters.should == [monster]
+            fallen_angel.monsters_praising_me_via_love_letters.should be_empty
           end     
         end
 
-        after(:all) { monster.undo_praise fallen_angel,love_letter }
+
       end
     end # context tripartite
 

data/spec/lib/patriarch/dao_services/bipartite_relationship_builder_spec.rb

@@ -2,8 +2,8 @@ require 'spec_helper'
 
 describe Patriarch::DAOServices::BipartiteRelationshipBuilderService do
   
-  let(:monster)       { Monster.new }
-  let(:fallen_angel)  { FallenAngel.new }
+  let(:monster)       { Monster.create }
+  let(:fallen_angel)  { FallenAngel.create }
   let(:instance)      { Patriarch::DAOServices::BipartiteRelationshipBuilderService.instance }
 
   before(:each) do

data/spec/lib/patriarch/dao_services/tripartite_relationship_builder_spec.rb

@@ -2,9 +2,9 @@ require 'spec_helper'
 
 describe Patriarch::DAOServices::TripartiteRelationshipBuilderService do
   
-  let(:monster)       { Monster.new }
-  let(:fallen_angel)  { FallenAngel.new }
-  let(:love_letter)   { LoveLetter.new }
+  let(:monster)       { Monster.create }
+  let(:fallen_angel)  { FallenAngel.create }
+  let(:love_letter)   { LoveLetter.create }
   let(:instance)      { Patriarch::DAOServices::TripartiteRelationshipBuilderService.instance }
 
   before(:each) do

data/spec/lib/patriarch/destroy_entity_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe 'entities including Patriarch::Behaviours #destroy' do
+
+  before(:all) do
+    Monster.add_behaviour       :lure, :by => [:fallenAngel]
+    FallenAngel.add_behaviour   :lure, :on => [:monster]
+    Monster.add_behaviour       :like, :on => [:fallenAngel] 
+    FallenAngel.add_behaviour   :like, :by => [:monster]
+
+    # Tripartite behaviour ...
+    FallenAngel.add_behaviour   :praise, :on => [:monster],     :via => [:loveLetter]
+    Monster.add_behaviour       :praise, :by => [:fallenAngel], :via => [:loveLetter]
+    LoveLetter.add_behaviour    :praise, :medium_between  =>  [:fallenAngel,:monster]
+  end
+
+  let(:monster)      { Monster.create }
+  let(:beast)        { Monster.create }
+  let(:love_letter)  { LoveLetter.create }
+
+  it "performs redis clean callbacks when other callbacks are ok" do
+    f = FallenAngel.create
+    m = Monster.create
+    f.lure m
+    m.like f
+    f.destroy
+    f.monsters_i_lure.should be_empty
+    f.monsters_liking_me.should be_empty
+    m.fallen_angels_i_like.include?(f).should be_false
+    m.fallen_angels_luring_me.include?(f).should be_false
+  end
+
+  context ' when another callback fails' do
+  
+    # they do not trigger a rollback when they return false
+    before(:all) do
+      FallenAngel.class_eval do
+        around_destroy  :callback_fail
+        def callback_fail
+          raise ActiveRecord::Rollback, "a callback failed" unless @redis_destroy_transac_object.nil?
+        end
+      end
+    end
+    
+    # This works with ActiveRecord as expected
+    it "rollbacks redis clean" do
+      f = FallenAngel.create
+      m = Monster.create
+      f.lure m
+      m.like f
+      f.destroy
+      f.monsters_i_lure.should == [m]
+      f.monsters_liking_me.should == [m]
+      m.fallen_angels_i_like.include?(f).should be_true
+      m.fallen_angels_luring_me.include?(f).should be_true
+    end
+  end
+  
+  context "when redis transaction fails" do
+    before(:all) do
+      FallenAngel.class_eval do
+        around_destroy  :callback_fail
+        def callback_fail
+          # This will trigger Redis::CommandError if executed ...
+          proc = Proc.new  { $redis.hset "lal", "lil", 3 }
+          proc_ = Proc.new { $redis.get "lal" }            
+          @redis_destroy_transac_object.add_to_queue proc
+          @redis_destroy_transac_object.add_to_queue proc_ 
+          puts @redis_destroy_transac_object.inspect         
+        end
+      end
+    end
+
+    it "rollbacks sql transaction" do
+      f = FallenAngel.create
+      m = Monster.create
+      f.lure m
+      f.destroy #should fail
+      f.destroyed?.should be_false
+    end
+  end
+end

data/spec/lib/patriarch/tool_services/redis_cleaner_service_spec.rb

@@ -2,8 +2,21 @@ require 'spec_helper'
 
 describe Patriarch::ToolServices::RedisCleanerService.instance do
 
-  let(:monster)      { Monster.new }
-  let(:beast)        { Monster.new }
+  before(:all) do
+    Monster.add_behaviour       :lure, :by => [:fallenAngel]
+    FallenAngel.add_behaviour   :lure, :on => [:monster]
+    Monster.add_behaviour       :like, :on => [:fallenAngel] 
+    FallenAngel.add_behaviour   :like, :by => [:monster]
+
+    # Tripartite behaviour ...
+    FallenAngel.add_behaviour   :praise, :on => [:monster],     :via => [:loveLetter]
+    Monster.add_behaviour       :praise, :by => [:fallenAngel], :via => [:loveLetter]
+    LoveLetter.add_behaviour    :praise, :medium_between  =>  [:fallenAngel,:monster]
+  end
+
+  let(:monster)      { Monster.create }
+  let(:beast)        { Monster.create }
+  let(:love_letter)  { LoveLetter.create }
   # Wrong usage when summoning several times fallen_angel within tests; bad knowledge of 
   # let is in cause i think
   # let(:fallen_angel) { FallenAngel.new }
@@ -11,35 +24,56 @@ describe Patriarch::ToolServices::RedisCleanerService.instance do
 
   context "#clean_all" do
     it "removes presence into other sets for each behaviour" do
-      pending("implement this")
-    end
-
-    it "removes presence into other set for a given behaviour" do
-      pending("implement this")
+      f = FallenAngel.create
+      m = Monster.create
+      f.lure m
+      m.like f
+      instance.clean_all(f).execute
+      f.monsters_i_lure.should be_empty
+      f.monsters_liking_me.should be_empty
+      m.fallen_angels_i_like.include?(f).should be_false
+      m.fallen_angels_luring_me.include?(f).should be_false
     end
   end 
 
   context "#clean_behaviour" do
     it "removes given behaviour binds on self" do
-      f = FallenAngel.new
-      f.lure Monster.new
-      instance.clean_behaviour(f,:lure)
+      f = FallenAngel.create
+      f.lure Monster.create
+      instance.clean_behaviour(f,:lure).execute
       f.monsters_i_lure.should be_empty
     end
 
     it "removes given behaviour binds on other entities" do
-      f = FallenAngel.new
-      f.lure Monster.new      
-      instance.clean_behaviour(f,:lure)
-      beast.fallen_angels_luring_me.include?(f).should be_false
-      monster.fallen_angels_luring_me.include?(f).should be_false      
+      f = FallenAngel.create
+      m = Monster.create
+      b = Monster.create
+      f.lure m
+      f.lure b    
+      instance.clean_behaviour(f,:lure).execute
+      b.fallen_angels_luring_me.include?(f).should be_false
+      m.fallen_angels_luring_me.include?(f).should be_false      
     end
 
+    it "removes given tripartite behaviour binds on other entities" do
+      f = FallenAngel.create
+      f.praise monster,love_letter
+      instance.clean_behaviour(f,:praise).execute
+      monster.fallen_angels_praising_me_via_love_letters.include?(f).should be_false
+    end    
+
+    it "removes given tripartite behaviour binds on self" do
+      f = FallenAngel.create
+      f.praise monster,love_letter
+      instance.clean_behaviour(f,:praise).execute
+      f.monsters_i_praise_via_love_letters.include?(monster).should be_false
+    end        
+
     it "runs within a unique transaction" do
-      f = FallenAngel.new
-      10.times { |t| f.lure Monster.new }
+      f = FallenAngel.create
+      10.times { |t| f.lure Monster.create }
       before_count = Patriarch::TransactionServices::TransactionManagerService.instance.count
-        instance.clean_behaviour(f,:lure)
+        instance.clean_behaviour(f,:lure).execute
       after_count = Patriarch::TransactionServices::TransactionManagerService.instance.count
       (after_count - before_count).should eq(1)
     end

data/spec/lib/patriarch/transaction_spec.rb

@@ -2,9 +2,9 @@ require 'spec_helper'
 
 describe Patriarch::Transaction do
   
-  let(:monster)         { Monster.new }
-  let(:fallen_angel)    { FallenAngel.new }
-  let(:love_letter)     { LoveLetter.new }
+  let(:monster)         { Monster.create }
+  let(:fallen_angel)    { FallenAngel.create }
+  let(:love_letter)     { LoveLetter.create }
   let(:transaction_step){ Patriarch::TransactionStep.new(:pick_up,monster,fallen_angel,love_letter)  }
   let(:transaction)     { Patriarch::Transaction.new(:transaction_test,42) }
 

data/spec/lib/patriarch/transaction_step_spec.rb

@@ -2,21 +2,21 @@ require 'spec_helper'
 
 describe Patriarch::TransactionStep do
   
-  let(:monster)         { Monster.new }
-  let(:fallen_angel)    { FallenAngel.new }
-  let(:love_letter)     { LoveLetter.new }
+  let(:monster)         { Monster.create }
+  let(:fallen_angel)    { FallenAngel.create }
+  let(:love_letter)     { LoveLetter.create }
   let(:transaction_step){ Patriarch::TransactionStep.new(:pick_up,monster,fallen_angel,love_letter)  }
 
   it "#actor returns the actor instance" do
-    transaction_step.actor.should == [monster] 
+    transaction_step.actor.should == monster 
   end
 
   it "#medium returns the medium instance" do
-    transaction_step.medium.should == [love_letter] 
+    transaction_step.medium.should == love_letter 
   end
 
   it "#target returns the target instance" do
-    transaction_step.target.should == [fallen_angel] 
+    transaction_step.target.should == fallen_angel 
   end 
 
   it "#add_to_queue appends proc to queue" do 
@@ -24,6 +24,6 @@ describe Patriarch::TransactionStep do
     q = Proc.new { p "do_nothing"}
     transaction_step.add_to_queue p
     transaction_step.add_to_queue q
-    transaction_step.queue.should ==[p,q]
+    transaction_step.queue.should == [p,q]
   end
 end

data/spec/spec_helper.rb

@@ -6,24 +6,17 @@ require 'redis/objects'
 require 'redis/objects/hashes'
 require 'redis/objects/sorted_sets'
 
+# Test if we do not need to load gems loaded through dev dependencies into gemspecs
 require 'patriarch'
-require 'active_model'
+require 'active_record'
 require 'action_view'
 require 'rails/generators'
 require 'rspec/autorun'
 
-#require File.expand_path("../../lib/generators/patriarch/behaviour_generator", __FILE__)
-
 RSpec.configure do |config|
-  # ## Mock Framework
-  #
-  # If you prefer to use mocha, flexmock or RR, uncomment the appropriate line:
-  #
-  # config.mock_with :mocha
-  # config.mock_with :flexmock
-  # config.mock_with :rr
 end
 
+# Setting up redis-database
 $redis=Redis.new(:host => 'localhost', :port => 6379, :db => 8)
 $redis.flushdb
 
@@ -34,118 +27,51 @@ puts "Cleaning previous dummy"
 `yes|rm -r #{dummy_location + "/*"}` 
 
 # Destroy previously initialized files in dummy, clean up !
-puts "Generating files to be tested in a dummy"
 
-puts "Installing gem .."
-Patriarch::Generators::InstallGenerator.start(%w(fake_arg),:destination_root => dummy_location) 
+puts "Gem set up ..."
+capture(:stdout) { Patriarch::Generators::InstallGenerator.start(%w(fake_arg),:destination_root => dummy_location) }
 
-# Initialize files in dummy :)
+puts "Storing files created during behaviour generation in a dummy repository"
 # Capture prevents stdout outputs from code between curly braces to be displayed
-# This avoid polluting user interface 
-Patriarch::Generators::BehaviourGenerator.start(%w(like),{:destination_root => dummy_location}) 
-Patriarch::Generators::BehaviourGenerator.start(%w(lure),{:destination_root => dummy_location}) 
-Patriarch::Generators::BehaviourGenerator.start(%w(praise tripartite),{:destination_root => dummy_location}) 
+# This avoid polluting user interface with file generators output
+capture(:stdout) { Patriarch::Generators::BehaviourGenerator.start(%w(like),{:destination_root => dummy_location}) }
+capture(:stdout) { Patriarch::Generators::BehaviourGenerator.start(%w(lure),{:destination_root => dummy_location}) }
+capture(:stdout) { Patriarch::Generators::BehaviourGenerator.start(%w(praise tripartite),{:destination_root => dummy_location}) }
 
-#Enhance load_path with dummy located files ...
+# Enhance load_path with dummy located files ...
 $LOAD_PATH << File.expand_path("../../spec/dummy/lib", __FILE__)
-$LOAD_PATH << File.expand_path("../../lib", __FILE__)
 
-# load files living in the dummy using initilizer like in a rails situation 
+# Load files living in the dummy using an initilizer to mimic rails behaviour
 require File.expand_path("../../spec/dummy/config/initializers/patriarch", __FILE__)
 
-class Monster
-  attr_reader :id
-  
-  class << self 
-    attr_accessor :count, :object_mapping
-  end
-
-  self.count = 1
-  self.object_mapping = {}
-  
-  def initialize
-    @id = self.class.count
-    self.class.count += 1
-    self.class.object_mapping.merge!({@id => self.object_id})
-  end
-
-  def self.find(ids)
-    ids = Array(ids)
-    result = []
-    ids.each do |id|
-      object_ref = self.object_mapping[id]
-      record = ObjectSpace._id2ref(object_ref)
-      result << record unless record.nil?
-    end
-    result
-  end
-end
+# We define 3 similar classes to play tests
+class Monster     < ActiveRecord::Base; include Patriarch::Behaviours; end
+class FallenAngel < ActiveRecord::Base; include Patriarch::Behaviours; end
+class LoveLetter  < ActiveRecord::Base; include Patriarch::Behaviours; end
 
-class FallenAngel
-  attr_reader :id
-  
-  class << self 
-    attr_accessor :count, :object_mapping
-  end
+# Setting standalone database to run tests
+ActiveRecord::Base.establish_connection(
+  :adapter  => "sqlite3",
+  :database => ":memory:"
+)
 
-  self.count = 1
-  self.object_mapping = {}
-  
-  def initialize
-    @id = self.class.count
-    self.class.count += 1
-    self.class.object_mapping.merge!({@id => self.object_id})
-  end
+# Load minimal schema for database
 
-  def self.find(ids)
-    ids = Array(ids)
-    result = []
-    ids.each do |id|
-      object_ref = self.object_mapping[id]
-      record = ObjectSpace._id2ref(object_ref)
-      result << record unless record.nil?
-    end
-    result
-  end
-end
+ActiveRecord::Schema.define do
 
-class LoveLetter
-  attr_reader :id
-  
-  class << self 
-    attr_accessor :count, :object_mapping
+  create_table "fallen_angels", :force => true do |t|
+    t.datetime "created_at", :null => false
+    t.datetime "updated_at", :null => false
   end
 
-  self.count = 1
-  self.object_mapping = {}
-  
-  def initialize
-    @id = self.class.count
-    self.class.count += 1
-    self.class.object_mapping.merge!({@id => self.object_id})
+  create_table "love_letters", :force => true do |t|
+    t.datetime "created_at", :null => false
+    t.datetime "updated_at", :null => false
   end
 
-  def self.find(ids)
-    ids = Array(ids)
-    result = []
-    ids.each do |id|
-      object_ref = self.object_mapping[id]
-      record = ObjectSpace._id2ref(object_ref)
-      result << record unless record.nil?
-    end
-    result
+  create_table "monsters", :force => true do |t|
+    t.datetime "created_at", :null => false
+    t.datetime "updated_at", :null => false
   end
-end
-
-Monster.send(:include,Patriarch::Behaviours)
-FallenAngel.send(:include,Patriarch::Behaviours)
-LoveLetter.send(:include,Patriarch::Behaviours)
-
-Monster.add_behaviour       :like, :on => [:fallenAngel] 
-Monster.add_behaviour       :lure, :by => [:fallenAngel]
-FallenAngel.add_behaviour   :like, :by => [:monster]
-FallenAngel.add_behaviour   :lure, :on => [:monster]
 
-LoveLetter.add_behaviour  :praise, :medium_between => [:monster,:fallenAngel]
-Monster.add_behaviour     :praise, :on => [:fallenAngel], :via => [:LoveLetter]
-FallenAngel.add_behaviour :praise, :by => [:monster], :via => [:LoveLetter]
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: patriarch
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-30 00:00:00.000000000 Z
+date: 2012-12-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: verbs
-  requirement: &16105280 !ruby/object:Gem::Requirement
+  requirement: &12624080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *16105280
+  version_requirements: *12624080
 - !ruby/object:Gem::Dependency
-  name: rails
-  requirement: &16104860 !ruby/object:Gem::Requirement
+  name: railties
+  requirement: &12623660 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *16104860
+  version_requirements: *12623660
 - !ruby/object:Gem::Dependency
-  name: railties
-  requirement: &16104440 !ruby/object:Gem::Requirement
+  name: activerecord
+  requirement: &12623240 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,32 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *16104440
+  version_requirements: *12623240
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &16104020 !ruby/object:Gem::Requirement
+  requirement: &12622820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *12622820
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &12622400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *12622400
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &12621980 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,7 +76,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *16104020
+  version_requirements: *12621980
 description: Patriach is about adding behaviours on the fly to good old active record
   models.
 email:
@@ -106,6 +128,7 @@ files:
 - spec/lib/patriarch/behaviours_spec.rb
 - spec/lib/patriarch/dao_services/bipartite_relationship_builder_spec.rb
 - spec/lib/patriarch/dao_services/tripartite_relationship_builder_spec.rb
+- spec/lib/patriarch/destroy_entity_spec.rb
 - spec/lib/patriarch/redis_mapper_service_spec.rb
 - spec/lib/patriarch/retriever_service_spec.rb
 - spec/lib/patriarch/tool_services/redis_cleaner_service_spec.rb
@@ -142,6 +165,7 @@ test_files:
 - spec/lib/patriarch/behaviours_spec.rb
 - spec/lib/patriarch/dao_services/bipartite_relationship_builder_spec.rb
 - spec/lib/patriarch/dao_services/tripartite_relationship_builder_spec.rb
+- spec/lib/patriarch/destroy_entity_spec.rb
 - spec/lib/patriarch/redis_mapper_service_spec.rb
 - spec/lib/patriarch/retriever_service_spec.rb
 - spec/lib/patriarch/tool_services/redis_cleaner_service_spec.rb