patriarch 0.2.2 → 0.2.3

data/.gitignore

@@ -1,4 +1,4 @@
-redis_reclip_cleaner.rb
+Guardfile
 spec/dummy
 stats.svg
 *.gem

data/lib/generators/patriarch/templates/authorization_service.rb

@@ -1,6 +1,5 @@
-class Patriarch::Services::<%= class_name %>::AuthorizationService < Patriarch::AuthorizationService
-  def grant?(transaction_item)
-    # Insert authorization logic here ...    
-    true
+class Patriarch::Services::<%= class_name %>::AuthorizationService < Patriarch::AuthorizationService 
+  def grant?(transac)
+    super
   end
 end

data/lib/patriarch/authorization_service.rb

@@ -5,8 +5,54 @@ module Patriarch
     include Singleton
 
     # override if necessary
-    def grant?(*args)
-      true
+    def grant?(transac)
+      # Insert authorization logic here ...    
+      if verify_types(transac)
+        true
+      else
+        raise "that behaviour is not authorized"
+      end
+      #true
+    end
+
+    def verify_types(transac)
+      actor_model       = transac.actor.class
+      actor_model_sym   = actor_model.name.underscore.to_sym 
+
+      target_model      = transac.target.class
+      target_model_sym  = target_model.name.underscore.to_sym
+      
+      medium_model      = transac.medium.class
+      medium_model_sym  = medium_model.name.underscore.to_sym
+
+      behaviour = transac.relation_type.to_s.sub(/undo_/,'').underscore.to_sym
+      auths = []
+
+      if transac.tripartite?
+        # Verif for actor
+        auths << actor_model.patriarch_behaviours[behaviour][:on].map{ |b_sym| b_sym.to_s.underscore.to_sym }.include?(target_model_sym)
+        auths << actor_model.patriarch_behaviours[behaviour][:via].map{ |b_sym| b_sym.to_s.underscore.to_sym }.include?(medium_model_sym)      
+
+        # Verif for target
+        auths << target_model.patriarch_behaviours[behaviour][:by].map{ |b_sym| b_sym.to_s.underscore.to_sym }.include?(actor_model_sym)
+        auths << target_model.patriarch_behaviours[behaviour][:via].map{ |b_sym| b_sym.to_s.underscore.to_sym }.include?(medium_model_sym) 
+
+        # Verif for medium
+        auths << medium_model.patriarch_behaviours[behaviour][:medium_between].map{ |dual_sym_tab| dual_sym_tab.map{ |b_sym| b_sym.to_s.underscore.to_sym } }.include?( 
+          [actor_model_sym, target_model_sym]
+        )
+        # cas particulier
+      else
+        auths << actor_model.patriarch_behaviours[behaviour][:on].map{ |b_sym| b_sym.to_s.underscore.to_sym }.include?(target_model_sym)
+        auths << target_model.patriarch_behaviours[behaviour][:by].map{ |b_sym| b_sym.to_s.underscore.to_sym }.include?(actor_model_sym)             
+      end
+
+
+      if auths.include? false
+        false 
+      else
+        true
+      end
     end
   end
 end

data/lib/patriarch/behaviours.rb

@@ -36,16 +36,16 @@ module Patriarch
               Patriarch::ToolServices::RedisExtractorService.instance.
                 get_models_from_ids(self,acted_on_model.to_s.classify.constantize,raw_tool_method_name,options)
             end
-            if options[:relation_type_alias]
-              alias_for_classic = classic_tool_method_name.sub(relation_type.to_s, options[:relation_type_alias].to_s)
+            if options[:as]
+              alias_for_classic = classic_tool_method_name.sub(relation_type.to_s, options[:as].to_s)
               alias_method alias_for_classic, classic_tool_method_name 
             end 
 
             define_method(raw_tool_method_name) do |options={}|
               Patriarch::ToolServices::RedisExtractorService.instance.get_ids_from_sorted_set(self,redis_key,options)              
             end
-            if options[:relation_type_alias]
-              alias_for_raw = raw_tool_method_name.sub(relation_type.to_s, options[:relation_type_alias].to_s)
+            if options[:as]
+              alias_for_raw = raw_tool_method_name.sub(relation_type.to_s, options[:as].to_s)
               alias_method alias_for_raw, raw_tool_method_name
             end             
           end
@@ -69,8 +69,8 @@ module Patriarch
               Patriarch::ToolServices::RedisExtractorService.instance.
                 get_models_from_ids(self,targetted_by_model.to_s.classify.constantize,raw_tool_method_name,options)
             end
-            if options[:relation_type_alias]
-              progressive_present_relation_type_alias = (Verbs::Conjugator.conjugate options[:relation_type_alias], :aspect => :progressive).split(/ /).last              
+            if options[:as]
+              progressive_present_relation_type_alias = (Verbs::Conjugator.conjugate options[:as], :aspect => :progressive).split(/ /).last              
               alias_for_classic = classic_tool_method_name.sub(progressive_present_relation_type,progressive_present_relation_type_alias)
               alias_method alias_for_classic,  classic_tool_method_name
             end
@@ -78,8 +78,8 @@ module Patriarch
             define_method(raw_tool_method_name) do |options={}|
               Patriarch::ToolServices::RedisExtractorService.instance.get_ids_from_sorted_set(self,redis_key,options)              
             end
-            if options[:relation_type_alias]
-              progressive_present_relation_type_alias = (Verbs::Conjugator.conjugate options[:relation_type_alias], :aspect => :progressive).split(/ /).last              
+            if options[:as]
+              progressive_present_relation_type_alias = (Verbs::Conjugator.conjugate options[:as], :aspect => :progressive).split(/ /).last              
               alias_for_raw = raw_tool_method_name.sub(progressive_present_relation_type,progressive_present_relation_type_alias)
               alias_method alias_for_raw,  raw_tool_method_name
             end            
@@ -89,7 +89,6 @@ module Patriarch
         end
       end      
 
-
       def complete_custom_active_module_tripartite(module_to_complete,relation_type,acted_on_model_list,via_model_list,options={})
         module_to_complete.class_eval do
 
@@ -97,31 +96,54 @@ module Patriarch
             via_model_list.each do |via_model|
 
               # Compute names based on conventions
-              classic_tool_method_name = "#{acted_on_model.to_s.tableize}_i_#{relation_type.to_s}_via_#{via_model.to_s.tableize}"
-              raw_tool_method_name = classic_tool_method_name + "_ids"
-              redis_key = "patriarch_" + classic_tool_method_name
+              # fallen_angels_i_praise_via_love_letters
+              target_classic_tool_method_name = "#{acted_on_model.to_s.tableize}_i_#{relation_type.to_s}_via_#{via_model.to_s.tableize}"
+              target_raw_tool_method_name = target_classic_tool_method_name + "_ids"
+
+              # love_letters_i_use_to_praise_fallen_angels
+              medium_classic_tool_method_name = "#{via_model.to_s.tableize}_i_use_to_#{relation_type.to_s}_#{acted_on_model.to_s.tableize}"
+              medium_raw_tool_method_name = medium_classic_tool_method_name + "_ids"              
+              
+              redis_key = "patriarch_" + target_classic_tool_method_name
 
               # Define methods with the pattern : items_i_like that returns models and items_i_like_ids that return
               # Redis key has the same radical as the method in class by convention (but has a patriarch_ prefix to avoid collisions with other gems)
-              define_method(classic_tool_method_name) do |options={}|
+              define_method(target_classic_tool_method_name) do |options={}|
                 Patriarch::ToolServices::RedisExtractorService.instance.
-                  get_models_from_ids(self,acted_on_model.to_s.classify.constantize,raw_tool_method_name,options.merge({:tripartite => true}))
+                  get_models_from_ids(self,acted_on_model.to_s.classify.constantize,target_raw_tool_method_name,options.merge({:tripartite => true}))
               end
-              if options[:relation_type_alias]
-                alias_for_classic = classic_tool_method_name.sub(relation_type.to_s, options[:relation_type_alias].to_s)
-                alias_method alias_for_classic, classic_tool_method_name 
+              if options[:as]
+                alias_for_classic = target_classic_tool_method_name.sub(relation_type.to_s, options[:as].to_s)
+                alias_method alias_for_classic, target_classic_tool_method_name 
               end 
 
-              define_method(raw_tool_method_name) do |options={}|
-                Patriarch::ToolServices::RedisExtractorService.instance.get_ids_from_sorted_set(self,redis_key,options.merge({:tripartite => true, :protagonist_type  => :actor}))
-                # triplet is by convention [actor,target,medium]
-                # TODO Marshallize true items instead of some crappy convention ...
+              define_method(target_raw_tool_method_name) do |options={}|
+                Patriarch::ToolServices::RedisExtractorService.instance.get_ids_from_sorted_set(self,redis_key,options.merge({:tripartite => true, :protagonist_type  => :target}))
               end
-              if options[:relation_type_alias]
-                alias_for_raw = raw_tool_method_name.sub(relation_type.to_s, options[:relation_type_alias].to_s)
-                alias_method alias_for_raw, raw_tool_method_name
+              if options[:as]
+                alias_for_target_raw = target_raw_tool_method_name.sub(relation_type.to_s, options[:as].to_s)
+                alias_method alias_for_target_raw, target_raw_tool_method_name
               end                    
 
+              #
+              define_method(medium_classic_tool_method_name) do |options={}|
+                Patriarch::ToolServices::RedisExtractorService.instance.
+                  get_models_from_ids(self,via_model.to_s.classify.constantize,medium_raw_tool_method_name,options.merge({:tripartite => true}))
+              end
+              if options[:as]
+                alias_for_medium_classic = medium_classic_tool_method_name.sub(relation_type.to_s, options[:as].to_s)
+                alias_method alias_for_medium_classic, medium_classic_tool_method_name 
+              end 
+              #
+
+              define_method(medium_raw_tool_method_name) do |options={}|
+                Patriarch::ToolServices::RedisExtractorService.instance.get_ids_from_sorted_set(self,redis_key,options.merge({:tripartite => true, :protagonist_type  => :medium}))
+              end
+              if options[:as]
+                alias_for_medium_raw = medium_raw_tool_method_name.sub(relation_type.to_s, options[:as].to_s)
+                alias_method alias_for_medium_raw, medium_raw_tool_method_name
+              end                
+
             end
           end
 
@@ -135,35 +157,45 @@ module Patriarch
             via_model_list.each do |via_model|
               # Compute names based on conventions    
               progressive_present_relation_type = (Verbs::Conjugator.conjugate relation_type.to_sym, :aspect => :progressive).split(/ /).last
-              classic_tool_method_name = "#{targetted_by_model.to_s.tableize}_#{progressive_present_relation_type}_me_via_#{via_model.to_s.tableize}"
-              raw_tool_method_name = classic_tool_method_name + "_ids"
-              redis_key = "patriarch_" + classic_tool_method_name
-
-              # Define methods with the pattern : items_i_like that returns models and items_i_like_ids that return
-              # Redis key has the same radical as the method in class by convention (but has a patriarch_ prefix to avoid collisions with other gems)
-              define_method(classic_tool_method_name) do |options={}|
+              
+              actor_classic_tool_method_name  = "#{targetted_by_model.to_s.tableize}_#{progressive_present_relation_type}_me_via_#{via_model.to_s.tableize}"
+              actor_raw_tool_method_name      = actor_classic_tool_method_name + "_ids"
+              
+              #"love_letters_used_by_monsters_to_praise_me"
+              medium_classic_tool_method_name = "#{via_model.to_s.tableize}_used_by_#{targetted_by_model.to_s.tableize}_to_#{relation_type.to_s}_me"
+              medium_raw_tool_method_name     = medium_classic_tool_method_name + "_ids"
+              
+              redis_key = "patriarch_" + actor_classic_tool_method_name
+
+              define_method(actor_classic_tool_method_name) do |options={}|
                 Patriarch::ToolServices::RedisExtractorService.instance.
-                  get_models_from_ids(self,targetted_by_model.to_s.classify.constantize,raw_tool_method_name,options.merge({:tripartite => true}))
+                  get_models_from_ids(self,targetted_by_model.to_s.classify.constantize,actor_raw_tool_method_name,options.merge({:tripartite => true}))
               end
-              if options[:relation_type_alias]
-                progressive_present_relation_type_alias = (Verbs::Conjugator.conjugate options[:relation_type_alias], :aspect => :progressive).split(/ /).last              
-                alias_for_classic = classic_tool_method_name.sub(progressive_present_relation_type,progressive_present_relation_type_alias)
-                alias_method alias_for_classic,  classic_tool_method_name
+              if options[:as]
+                progressive_present_relation_type_alias = (Verbs::Conjugator.conjugate options[:as], :aspect => :progressive).split(/ /).last              
+                alias_for_actor_classic = actor_classic_tool_method_name.sub(progressive_present_relation_type,progressive_present_relation_type_alias)
+                alias_method alias_for_actor_classic,  actor_classic_tool_method_name
               end
 
-
-              define_method(raw_tool_method_name) do |options={}|
-                Patriarch::ToolServices::RedisExtractorService.instance.get_ids_from_sorted_set(self,redis_key,options.merge({:tripartite => true , :protagonist_type  => :target}))
-                
-                # triplet is by convention [actor,target,medium]
-                # TODO Marshallize true items instead of some crappy convention ...
+              define_method(actor_raw_tool_method_name) do |options={}|
+                Patriarch::ToolServices::RedisExtractorService.instance.get_ids_from_sorted_set(self,redis_key,options.merge({:tripartite => true , :protagonist_type  => :actor}))
               end
-              if options[:relation_type_alias]
-                progressive_present_relation_type_alias = (Verbs::Conjugator.conjugate options[:relation_type_alias], :aspect => :progressive).split(/ /).last              
-                alias_for_raw = raw_tool_method_name.sub(progressive_present_relation_type,progressive_present_relation_type_alias)
-                alias_method alias_for_raw,  raw_tool_method_name
+              if options[:as]
+                progressive_present_relation_type_alias = (Verbs::Conjugator.conjugate options[:as], :aspect => :progressive).split(/ /).last              
+                alias_for_actor_raw = actor_raw_tool_method_name.sub(progressive_present_relation_type,progressive_present_relation_type_alias)
+                alias_method alias_for_actor_raw,  actor_raw_tool_method_name
               end        
 
+              define_method(medium_classic_tool_method_name) do |options={}|
+                Patriarch::ToolServices::RedisExtractorService.instance.
+                  get_models_from_ids(self,via_model.to_s.classify.constantize,medium_raw_tool_method_name,options.merge({:tripartite => true}))
+              end   
+              #TODO add alias there
+              # FIXME id in it is wrong ...
+              define_method(medium_raw_tool_method_name) do |options={}|
+                Patriarch::ToolServices::RedisExtractorService.instance.get_ids_from_sorted_set(self,redis_key,options.merge({:tripartite => true , :protagonist_type  => :medium}))
+              end            
+
             end
           end
 
@@ -210,19 +242,29 @@ module Patriarch
 
     module ClassMethods
 
-      def add_behaviour(behaviour,options)
+      def check_add_behaviour_syntax(behaviour,options)
         if options[:medium_between] || options[:via]
-          add_tripartite_behaviour(behaviour,options)
+          check_tripartite_add_behaviour_syntax(behaviour,options)
         elsif options[:on] || options[:by]
-          add_bipartite_behaviour(behaviour,options)
-        else
-          raise AddBehaviourSyntaxError, "syntax is wrong, declaration does not suplly enough arguments declared with right options"
+          check_bipartite_add_behaviour_syntax(behaviour,options)
         end
       end
 
-      def add_tripartite_behaviour(behaviour,options)
-        behaviour = behaviour.to_s.underscore
+      def check_bipartite_add_behaviour_syntax(behaviour,options)
+        # Either you add a behaviour on another model or allow a behaviour on you by another model
+        unless options[:by].nil? ^ options[:on].nil?
+          raise AddBehaviourSyntaxError, "you must not define a behaviour as active (using on) and passive at the same time (using by)"
+        end
+      
+        # as option should be a string or symbol 
+        if options[:as]
+          unless [Symbol,String].include?(options[:as].class) 
+            raise AddBehaviourSyntaxError, "as option should be a string or symbol"
+          end        
+        end
+      end        
 
+      def check_tripartite_add_behaviour_syntax(behaviour,options)
         # Xor on options :medium_between and :via, disparate cases ...
         unless options[:medium_between].nil? ^ options[:via].nil?
           raise AddBehaviourSyntaxError, "you must not define a behaviour as active (using on) and passive at the same time (using by)"
@@ -239,222 +281,220 @@ module Patriarch
           end
         end
 
-        complete_module_options = {}
         if options[:as]
           # as option should be a string or symbol 
           unless [Symbol,String].include?(options[:as].class) 
             raise AddBehaviourSyntaxError, "as option should be a string or symbol"
           end
-          complete_module_options.merge! :relation_type_alias => options[:as]
         end
+      end
 
-        methods_mod = Module.new do; end
-        methods_mod.const_set(:Behaviour,behaviour)
+      def add_behaviour(behaviour,options)
+        if options[:medium_between] || options[:via]
+          add_tripartite_behaviour(behaviour,options)
+        elsif options[:on] || options[:by]
+          add_bipartite_behaviour(behaviour,options)
+        else
+          raise AddBehaviourSyntaxError, "syntax is wrong, declaration does not suplly enough arguments declared with right options"
+        end
+      end
+
+      def add_aliases_for_functionnalities(module_to_complete,behaviour,options)
         if options[:as]
-          methods_mod.const_set(:BehaviourAlias,options[:as].to_sym)
-        end          
+          behaviour_alias = options[:as].to_s
+        end
 
         if options[:undo_as]
-          methods_mod.const_set(:UndoBehaviourAlias,options[:undo_as].to_sym)
-        end          
+          behaviour_undo_alias = options[:undo_as].to_s
+        end
+
+        if options[:on] 
+          module_to_complete.instance_eval do
+            # add behaviour_alias
+            if options[:as]            
+              alias_method behaviour_alias, behaviour
+            end
 
+            # add undo_behaviour_alias
+            if options[:undo_as]            
+              alias_method behaviour_undo_alias, Patriarch.undo(behaviour)
+            end              
+          end
+        end              
+      end
 
-        # Target on Actor cases
-        if options[:via]
-          # Actor case
-          if options[:on]
-            methods_mod.instance_eval do
-              # Defines the hook thing ...
-              # TODO
-              def self.included(klass)
-                klass.extend ActiveModel::Callbacks
-                klass.send(:define_model_callbacks, self.const_get(:Behaviour).to_sym, Patriarch.undo(self.const_get(:Behaviour)).to_sym)
-              end 
+      def add_functionnalities_for_bipartite(module_to_complete,behaviour,options)
+        module_to_complete.instance_eval do
 
-              # behave
-              define_method(methods_mod.const_get(:Behaviour).to_sym) do |entity,via_entity,options={}|
-                run_callbacks methods_mod.const_get(:Behaviour).to_sym do
-                  "Patriarch::Services::#{methods_mod.const_get(:Behaviour).classify}::ManagerService".constantize.instance.resolve(self,entity,via_entity,options)   
-                end
-              end
-              if options[:as]            
-                alias_method methods_mod.const_get(:BehaviourAlias), methods_mod.const_get(:Behaviour).to_sym
-              end              
-
-              # undo_behave
-              define_method(Patriarch.undo(methods_mod.const_get(:Behaviour)).to_sym) do |entity,via_entity,options={}|
-                run_callbacks Patriarch.undo(methods_mod.const_get(:Behaviour)).to_sym do
-                  "Patriarch::Services::#{(Patriarch.undo(methods_mod.const_get(:Behaviour))).classify}::ManagerService".constantize.instance.resolve(self,entity,via_entity,options)   
-                end
-              end
-              if options[:undo_as]            
-                alias_method methods_mod.const_get(:UndoBehaviourAlias), Patriarch.undo(methods_mod.const_get(:Behaviour))
-              end        
+          instance_eval do
+            (class << self; self; end).send(:define_method,:included) do |klass|
+              klass.extend ActiveModel::Callbacks
+              klass.send(:define_model_callbacks, behaviour, Patriarch.undo(behaviour))
+            end
+          end
 
+          # behave
+          define_method(behaviour) do |entity,options={}|
+            run_callbacks behaviour do
+              "Patriarch::Services::#{behaviour.classify}::ManagerService".constantize.instance.resolve(self,entity,options)   
             end
+          end
 
-            acted_on_model_list = Array(options[:on])
-            via_model_list = Array(options[:via])
-            Patriarch::Behaviours.complete_custom_active_module_tripartite(methods_mod,behaviour,acted_on_model_list,via_model_list,complete_module_options)            
-            #Target case
-          elsif options[:by]
-            targetted_by_model_list = Array(options[:by])          
-            via_model_list = Array(options[:via])                      
-            Patriarch::Behaviours.complete_custom_passive_module_tripartite(methods_mod,behaviour,targetted_by_model_list,via_model_list,complete_module_options)
+          # undo_behave
+          define_method(Patriarch.undo(behaviour).to_sym) do |entity,options={}|
+            run_callbacks Patriarch.undo(behaviour).to_sym do
+              "Patriarch::Services::#{(Patriarch.undo(behaviour)).classify}::ManagerService".constantize.instance.resolve(self,entity,options)   
+            end
           end
-        # Medium case
-        elsif options[:medium_between]
-          # Define tool_methods_here ...
-        end
 
-        # Finally ...
-        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)
+        end # instance_eval
+      end
+
+      def add_functionnalities_for_tripartite(module_to_complete,behaviour,options)
+        module_to_complete.instance_eval do
+
+          instance_eval do
+            (class << self; self; end).send(:define_method,:included) do |klass|
+              klass.extend ActiveModel::Callbacks
+              klass.send(:define_model_callbacks, behaviour, Patriarch.undo(behaviour))
+            end
+          end
+
+          # behave
+          define_method(behaviour) do |via_entity,entity,options={}|
+            run_callbacks behaviour.to_sym do
+              "Patriarch::Services::#{behaviour.classify}::ManagerService".constantize.instance.resolve(self,entity,via_entity,options)   
+            end
+          end
+
+
+          # undo_behave
+          define_method(Patriarch.undo(behaviour)) do |via_entity,entity,options={}|
+            run_callbacks Patriarch.undo(behaviour).to_sym do
+              "Patriarch::Services::#{Patriarch.undo(behaviour).classify}::ManagerService".constantize.instance.resolve(self,entity,via_entity,options)   
+            end
+          end
+
+        end # instance_eval
+      end
+
+      def register_bipartite_behaviour(behaviour,options)
+        self.patriarch_behaviours ||= { }
+        #self.patriarch_behaviours[behaviour.underscore.to_sym] ||= { :on => [], :by =>[] }
+        self.patriarch_behaviours[behaviour.underscore.to_sym] ||= { }
+        self.patriarch_behaviours[behaviour.underscore.to_sym][:on] ||= []
+        self.patriarch_behaviours[behaviour.underscore.to_sym][:by] ||= []         
+
+        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 
+      end
+
+      def register_tripartite_behaviour(behaviour,options)
         # TODO disjonction register tripartite
         # register the behaviour we just added
+        behaviour = behaviour.underscore.to_sym
+
         self.patriarch_behaviours ||= { }
-        self.patriarch_behaviours[behaviour.underscore.to_sym]  ||= {}      
+        self.patriarch_behaviours[behaviour]  ||= {}             
         
         if options[:via]
           #self.patriarch_behaviours[behaviour.underscore.to_sym] ||= { :on => [], :by => [], :via => [] }
-          self.patriarch_behaviours[behaviour.underscore.to_sym][:on] ||= []
-          self.patriarch_behaviours[behaviour.underscore.to_sym][:by] ||= [] 
-          self.patriarch_behaviours[behaviour.underscore.to_sym][:via] ||= [] 
+          self.patriarch_behaviours[behaviour][:on] ||= []
+          self.patriarch_behaviours[behaviour][:by] ||= [] 
+          self.patriarch_behaviours[behaviour][:via] ||= [] 
         elsif options[:medium_between]
           #self.patriarch_behaviours[behaviour.underscore.to_sym] ||= { :medium_between => [] }
-          self.patriarch_behaviours[behaviour.underscore.to_sym][:medium_between] ||= []          
+          self.patriarch_behaviours[behaviour][: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!
+            self.patriarch_behaviours[behaviour][:on] << options[:on]
+            self.patriarch_behaviours[behaviour][:on].uniq!
+            self.patriarch_behaviours[behaviour][: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!
+            self.patriarch_behaviours[behaviour][:by] << options[:by]
+            self.patriarch_behaviours[behaviour][:by].uniq!
+            self.patriarch_behaviours[behaviour][: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!    
+            self.patriarch_behaviours[behaviour][:via] << options[:via]
+            self.patriarch_behaviours[behaviour][:via].uniq!
+            self.patriarch_behaviours[behaviour][: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]
+          self.patriarch_behaviours[behaviour][:medium_between] << options[:medium_between]
+          self.patriarch_behaviours[behaviour][:medium_between].uniq!
+          self.patriarch_behaviours[behaviour][:medium_between]
         end    
       end
 
-      def add_bipartite_behaviour(behaviour,options)
-        # add_behaviour :like, :by => bla,  :on => [:item,:user] || :community, :as => :aimer, :reverse_as => :haïr ...
-        
+      def add_tripartite_behaviour(behaviour,options)
         behaviour = behaviour.to_s.underscore
 
-        # Xor on options :on and :by, is what is needed, raise an exception otherwise
-        unless options[:by].nil? ^ options[:on].nil?
-          raise AddBehaviourSyntaxError, "you must not define a behaviour as active (using on) and passive at the same time (using by)"
-        end
+        check_add_behaviour_syntax(behaviour,options)
 
         methods_mod = Module.new do; end
-        methods_mod.const_set(:Behaviour,behaviour)
-        if options[:as]
-          methods_mod.const_set(:BehaviourAlias,options[:as].to_sym)
-        end          
-        if options[:undo_as]
-          methods_mod.const_set(:UndoBehaviourAlias,options[:undo_as].to_sym)
-        end              
-
-        if options[:on] 
-          # Adds active methods and defines the hook to set callbacks on them
-          methods_mod.instance_eval do
-
-            # Defines the hook thing ...
-            # TODO
-            def self.included(klass)
-              klass.extend ActiveModel::Callbacks
-              klass.send(:define_model_callbacks, self.const_get(:Behaviour).to_sym, Patriarch.undo(self.const_get(:Behaviour)).to_sym)
-            end 
 
-            # like
-            define_method(methods_mod.const_get(:Behaviour).to_sym) do |entity,options={}|
-              run_callbacks methods_mod.const_get(:Behaviour).to_sym do
-                "Patriarch::Services::#{methods_mod.const_get(:Behaviour).classify}::ManagerService".constantize.instance.resolve(self,entity,options)   
-              end
-            end
-            if options[:as]            
-              alias_method methods_mod.const_get(:BehaviourAlias), methods_mod.const_get(:Behaviour).to_sym
-            end
-
-            # undo_like
-            define_method(Patriarch.undo(methods_mod.const_get(:Behaviour)).to_sym) do |entity,options={}|
-              run_callbacks Patriarch.undo(methods_mod.const_get(:Behaviour)).to_sym do
-                "Patriarch::Services::#{(Patriarch.undo(methods_mod.const_get(:Behaviour))).classify}::ManagerService".constantize.instance.resolve(self,entity,options)   
-              end
-            end
-            if options[:undo_as]            
-              alias_method methods_mod.const_get(:UndoBehaviourAlias), Patriarch.undo(methods_mod.const_get(:Behaviour))
-            end              
-
-            # Not used / not tested, added this method "en passant"
-            # FIX requirements with users
-            # likes?
-            define_method((Verbs::Conjugator.conjugate methods_mod.const_get(:Behaviour).to_sym, :person => :third).split(/ /).last) do |entity|
-              self.send("#{entity.class.name.tableize}_i_#{methods_mod.const_get(:Behaviour)}_ids").include? entity.id
-            end
+        # Target on Actor cases
+        if options[:via]
+          # Actor case
+          if options[:on]    
+            add_functionnalities_for_tripartite(methods_mod,behaviour,options)            
+            add_aliases_for_functionnalities(methods_mod,behaviour,options)   
+            acted_on_model_list = Array(options[:on])
+            via_model_list = Array(options[:via])
+            Patriarch::Behaviours.complete_custom_active_module_tripartite(methods_mod,behaviour,acted_on_model_list,via_model_list,options)            
+            #Target case
+          elsif options[:by]
+            targetted_by_model_list = Array(options[:by])          
+            via_model_list = Array(options[:via])                      
+            Patriarch::Behaviours.complete_custom_passive_module_tripartite(methods_mod,behaviour,targetted_by_model_list,via_model_list,options)
           end
+        # Medium case
+        elsif options[:medium_between]
+          # Define tool_methods_here ...
         end
 
-        if options[:by]
-          methods_mod.instance_eval do
-            # reverse_of_likes? 
-            # TODO find naming convention and build general ...
-            # define_method(:reverse_of_likes) do |entity|
-            #  progressive_present_relation_type = (Verbs::Conjugator.conjugate methods_mod.const_get(:Behaviour).to_sym, :aspect => :progressive).split(/ /).last
-            #  self.send("#{entity.class.name.tableize}_#{progressive_present_relation_type}_me_ids").include? entity.id
-            #end
-          end
-        end
+        # Finally ...
+        include methods_mod
+        # include in which we can overwite the methods of the previous custom module included there ...
+        include "Patriarch::Behaviours::#{behaviour.classify}::ToolsMethods".constantize
+        # register behaviour we just added
+        register_tripartite_behaviour(behaviour,options)        
+      end
 
-        complete_module_options = {}
-        if options[:as]
-          # as option should be a string or symbol 
-          unless [Symbol,String].include?(options[:as].class) 
-            raise AddBehaviourSyntaxError, "as option should be a string or symbol"
-          end
-          complete_module_options.merge! :relation_type_alias => options[:as]
-        end
+      def add_bipartite_behaviour(behaviour,options)
+        # add_behaviour :like, :by => bla,  :on => [:item,:user] || :community, :as => :aimer, :reverse_as => :haïr ...
+        
+        behaviour = behaviour.to_s.underscore
+
+        check_add_behaviour_syntax(behaviour,options)
 
+        methods_mod = Module.new do; end
 
         if options[:on] 
+          # Adds active methods and defines the hook to set callbacks on them
+          add_functionnalities_for_bipartite(methods_mod,behaviour,options)
+          add_aliases_for_functionnalities(methods_mod,behaviour,options)  
           acted_on_model_list = Array(options[:on])
-          Patriarch::Behaviours.complete_custom_active_module_bipartite(methods_mod,behaviour,acted_on_model_list,complete_module_options)
+          Patriarch::Behaviours.complete_custom_active_module_bipartite(methods_mod,behaviour,acted_on_model_list,options)                  
         else
           targetted_by_model_list = Array(options[:by])          
-          Patriarch::Behaviours.complete_custom_passive_module_bipartite(methods_mod,behaviour,targetted_by_model_list,complete_module_options)
+          Patriarch::Behaviours.complete_custom_passive_module_bipartite(methods_mod,behaviour,targetted_by_model_list,options)
         end
 
-        # Finally ...
-        self.send(:include,methods_mod)
+        # Finally includes the custom module
+        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)
-
+        include "Patriarch::Behaviours::#{behaviour.classify}::ToolsMethods".constantize
         # register the behaviour we just added
-        self.patriarch_behaviours ||= { }
-        #self.patriarch_behaviours[behaviour.underscore.to_sym] ||= { :on => [], :by =>[] }
-        self.patriarch_behaviours[behaviour.underscore.to_sym] ||= { }
-        self.patriarch_behaviours[behaviour.underscore.to_sym][:on] ||= []
-        self.patriarch_behaviours[behaviour.underscore.to_sym][:by] ||= []         
-
-        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          
+        register_bipartite_behaviour(behaviour,options)
       end
     end
 

data/lib/patriarch/dao_services/bipartite_relationship_builder_service.rb

@@ -25,6 +25,9 @@ class Patriarch::DAOServices::BipartiteRelationshipBuilderService < Patriarch::S
     l   = lambda { actor_dao.delete transaction_item.target_id }
     ll  = lambda { target_dao.delete transaction_item.actor_id }
 
+    # p "#{l.inspect} is deleting on key #{actor_dao.key} : #{transaction_item.target_type} #{transaction_item.target_id}"
+    # p "#{ll.inspect} is deleting on key #{target_dao.key} : #{transaction_item.actor_type} #{transaction_item.actor_id}"
+
     transaction_item.add_to_queue l
     transaction_item.add_to_queue ll
   end

data/lib/patriarch/tool_services/redis_cleaner_service.rb

@@ -6,7 +6,7 @@ class Patriarch::ToolServices::RedisCleanerService < Patriarch::Service
     options = { :transac => transac }
 
     calling_entity.class.patriarch_behaviours.keys.each do |behaviour|
-      clean_behaviour(calling_entity,behaviour,options)
+      transac.steps << clean_behaviour(calling_entity,behaviour)
     end
 
     transac
@@ -47,7 +47,7 @@ class Patriarch::ToolServices::RedisCleanerService < Patriarch::Service
             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)
+              calling_entity.send(Patriarch.undo(behaviour.to_s).underscore,medium_for_behaviour,target_i_behaved_on,options)
             end
           end
         end
@@ -64,7 +64,7 @@ class Patriarch::ToolServices::RedisCleanerService < Patriarch::Service
               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)
+              actor_that_behaved_on_me.send(Patriarch.undo(behaviour.to_s).underscore,medium_for_behaviour,calling_entity,options)
             end
           end
         end
@@ -92,7 +92,15 @@ class Patriarch::ToolServices::RedisCleanerService < Patriarch::Service
     options = { :transac => transac, :stop_execution => true}
 
     if my_behaviours.include? behaviour.to_s.underscore.to_sym
-
+      # 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]
+        targetted_by_models.each do |targetted_by_model|
+          calling_entity.send("#{targetted_by_model.to_s.tableize}_#{progressive_present_behaviour}_me").each do |target_that_behaved_on_me|
+            target_that_behaved_on_me.send(Patriarch.undo(behaviour.to_s).underscore,calling_entity,options)
+          end
+        end
+      end
       # 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]
@@ -103,15 +111,7 @@ class Patriarch::ToolServices::RedisCleanerService < Patriarch::Service
         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]
-        targetted_by_models.each do |targetted_by_model|
-          calling_entity.send("#{targetted_by_model.to_s.tableize}_#{progressive_present_behaviour}_me").each do |target_that_behaved_on_me|
-            target_that_behaved_on_me.send(Patriarch.undo(behaviour.to_s).underscore,calling_entity,options)
-          end
-        end
-      end
+
     end # if my_behaviours.include?
 
     transac

data/lib/patriarch/tool_services/redis_extractor_service.rb

@@ -36,16 +36,16 @@ class Patriarch::ToolServices::RedisExtractorService < Patriarch::Service
             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]}          
+          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] }          
+          elsif options[:protagonist_type] == :medium
+            result.map!{ |triplet_id| triplet_id[2] }          
           end
         end
       end

data/lib/patriarch/transaction.rb

@@ -1,6 +1,7 @@
 module Patriarch
   class Transaction
     attr_reader  :id, :steps, :current_step_number
+    attr_writer  :steps
     attr_reader  :type
 
     forwarded_methods_syms =  [:relation_type,:actor_type,:target_type,:medium_type,
@@ -47,7 +48,13 @@ module Patriarch
       begin
         $redis.multi do
           steps.each do |step|
-            step.execute
+            if step.is_a? TransactionStep
+              step.execute
+            elsif step.is_a? Transaction
+              step.steps.each do |nested_step|
+                nested_step.execute
+              end
+            end
           end
         end
       rescue Redis::BaseError => e #TODO find redis exception

data/lib/patriarch/version.rb

@@ -1,3 +1,3 @@
 module Patriarch
-  VERSION = "0.2.2"
+  VERSION = "0.2.3"
 end

data/patriarch.gemspec

@@ -19,10 +19,10 @@ Gem::Specification.new do |spec|
   
   # Dependencies needed for testing
 	spec.add_development_dependency "rspec"
+  spec.add_development_dependency "guard-rspec"  
   spec.add_development_dependency "activerecord"  
   spec.add_development_dependency "sqlite3"  
-  # TODO run with autotest/guard
-
+  
   # Other options ...
 	spec.files         = `git ls-files`.split($\)
   spec.executables   = spec.files.grep(%r{^bin/}).map{ |f| File.basename(f) }

data/spec/lib/patriarch/behaviours_spec.rb

@@ -1,11 +1,15 @@
 require 'spec_helper'
 
 describe Patriarch::Behaviours do
+
+
   describe '#add_behaviour' do
+
     let(:monster)      { Monster.create }
     let(:fallen_angel) { FallenAngel.create }
     let(:love_letter)  { LoveLetter.create }
 
+
     context 'on a bipartite' do
 
       before(:all) do
@@ -160,6 +164,14 @@ describe Patriarch::Behaviours do
           monster.should          respond_to("#{"fallen_angel".pluralize}_i_praise_via_#{"love_letter".pluralize}_ids")
         end      
 
+        it "defines instances methods to retrieve instances of medium model instances used by actor model" do
+          monster.should           respond_to("#{"love_letter".pluralize}_i_use_to_praise_#{"fallen_angel".pluralize}")
+        end      
+
+        it "defines instances methods to retrieve ids of medium model instances used by actor model" do
+          monster.should           respond_to("#{"love_letter".pluralize}_i_use_to_praise_#{"fallen_angel".pluralize}_ids")
+        end              
+
         it "defines instances methods to retrieve model instances having relationships with target model" do
           progressive_praise = (Verbs::Conjugator.conjugate :praise, :aspect => :progressive).split(/ /).last
           fallen_angel.should     respond_to("#{"monster".pluralize}_#{progressive_praise}_me_via_#{"love_letter".pluralize}")
@@ -170,6 +182,19 @@ describe Patriarch::Behaviours do
           fallen_angel.should     respond_to("#{"monster".pluralize}_#{progressive_praise}_me_via_#{"love_letter".pluralize}_ids")
         end
 
+        it "defines instances methods to retrieve instances of medium model instances having relationships with target model" do  
+          fallen_angel.should     respond_to("#{"love_letter".pluralize}_used_by_#{"monster".pluralize}_to_praise_me")       
+        end
+
+        it "defines instances methods to retrieve ids of medium model instances having relationships with target model" do  
+          fallen_angel.should     respond_to("#{"love_letter".pluralize}_used_by_#{"monster".pluralize}_to_praise_me_ids")       
+        end
+
+        # TODO define_alias also ...
+        it "defines instances methods to retrieve ids of model instances entities behaviouring via medium model" do
+          pending('lazyness')
+        end
+
         it "defines behaviour instance method on actor model" do
           monster.should          respond_to(:praise)
         end
@@ -219,15 +244,32 @@ describe Patriarch::Behaviours do
       
       context 'implements methods that' do 
         it 'lets transaction build without running' do
-          monster.praise(fallen_angel, love_letter, :stop_execution => true).should be_an_instance_of(Patriarch::Transaction)
+          monster.praise(love_letter, fallen_angel, :stop_execution => true).should be_an_instance_of(Patriarch::Transaction)
         end
 
         it 'lets undo transaction build without running' do
-          monster.praise(fallen_angel, love_letter, :stop_execution => true).should be_an_instance_of(Patriarch::Transaction)
+          monster.praise(love_letter, fallen_angel, :stop_execution => true).should be_an_instance_of(Patriarch::Transaction)
         end
 
         # prepare examples to test both alias and normal methods ...
         shared_examples 'instances have behaviour working' do
+
+          it "allows actor to remember id of the medium used to behave on target" do                 
+            monster.love_letters_i_use_to_praise_fallen_angels_ids.should == [love_letter.id]
+          end
+          
+          it "allows actor to remember instance of the medium used to behave on target" do
+            monster.love_letters_i_use_to_praise_fallen_angels.should == [love_letter]
+          end
+
+          it "allows target to remember id of the medium used to behave on him" do
+            fallen_angel.love_letters_used_by_monsters_to_praise_me_ids.should == [love_letter.id]
+          end
+
+          it "allows target to remember instance of the medium used to behave on him" do
+            fallen_angel.love_letters_used_by_monsters_to_praise_me.should == [love_letter]
+          end
+
           it "allows actor to remember target id" do 
             monster.fallen_angels_i_praise_via_love_letters_ids.should == [fallen_angel.id]
           end
@@ -246,19 +288,36 @@ describe Patriarch::Behaviours do
         end
 
         context 'when doing direct behaviour' do
-          before(:all) { monster.praise fallen_angel,love_letter }          
+          before(:all) { monster.praise love_letter,fallen_angel }          
           it_has_behavior 'instances have behaviour working' 
-          after(:all) { monster.undo_praise fallen_angel,love_letter }             
+          after(:all) { monster.undo_praise love_letter,fallen_angel }             
         end        
 
         context 'when doing behaviour via alias method' do 
-          before(:all) { monster.flatter fallen_angel,love_letter }       
+          before(:all) { monster.flatter love_letter,fallen_angel }       
           it_has_behavior 'instances have behaviour working' 
-          after(:all) { monster.undo_praise fallen_angel,love_letter }
+          after(:all) { monster.undo_praise love_letter,fallen_angel }
         end         
 
         # prepare examples to test both undo alias and undo normal methods ...
         shared_examples 'instances have undo behaviour working' do
+
+          it "erase medium id used to behave on target from actor's memory" do
+            monster.love_letters_i_use_to_praise_fallen_angels_ids.should be_empty
+          end
+
+          it "erase medium instance used to behave on target from actor's memory" do
+            monster.love_letters_i_use_to_praise_fallen_angels.should be_empty            
+          end          
+
+          it "erase medium id used to behave on target from target's memory" do
+            fallen_angel.love_letters_used_by_monsters_to_praise_me_ids.should be_empty            
+          end          
+
+          it "erase medium instance used to behave on target from target's memory" do
+            fallen_angel.love_letters_used_by_monsters_to_praise_me.should be_empty               
+          end                   
+
           it "erase target id from actor's memory" do 
             monster.fallen_angels_i_praise_via_love_letters_ids.should be_empty
           end
@@ -278,16 +337,16 @@ describe Patriarch::Behaviours do
 
         context 'when directly undoing behaviour' do
           before(:all) do
-            monster.praise fallen_angel,love_letter
-            monster.undo_praise fallen_angel,love_letter
+            monster.praise love_letter, fallen_angel
+            monster.undo_praise love_letter, fallen_angel
           end
           it_has_behavior 'instances have undo behaviour working' 
         end
 
         context 'when undoing behaviour via undo alias' do
           before(:all) do
-            monster.praise fallen_angel,love_letter
-            monster.despise fallen_angel,love_letter
+            monster.praise love_letter,fallen_angel
+            monster.despise love_letter,fallen_angel
           end
           it_has_behavior 'instances have undo behaviour working' 
         end
@@ -307,4 +366,32 @@ describe Patriarch::Behaviours do
       FallenAngell.add_behaviour   :praise, :medium_between => [:monsterr,:fallenAngell]
     end
   end
+
+  context 'when using behaviour on entities that do not allow it' do
+
+    before(:all) do
+      class Monsterr < Monster; end
+      class FallenAngell < FallenAngel; end        
+      class LoveLetterr < LoveLetter; end        
+      Monsterr.add_behaviour       :like, :on => [:fallenAngell], :as => :love, :undo_as => :hate
+      FallenAngell.add_behaviour   :like, :by => [:monsterr]    , :as => :love
+
+      Monsterr.add_behaviour       :praise, :on => [:fallenAngell], :via => [:love_letter]
+      FallenAngell.add_behaviour   :praise, :by => [:monsterr],     :via => [:love_letter]
+      LoveLetterr.add_behaviour    :praise, :medium_between => [:monsterr,:fallenAngell]     
+    end
+
+    it "shall fail for bipartite" do
+      expect{ Monsterr.create.like(LoveLetterr.create) }.to raise_error
+    end
+
+    it "shall fail for triparite with unauthorized medium class instances" do 
+      expect{ Monsterr.create.praise(Monsterr.create,FallenAngell.create) }.to raise_error
+    end
+
+    it "shall fail for triparite with unauthorized target class instances" do 
+      expect{ Monsterr.create.praise(LoveLetterr.create,Monsterr.create) }.to raise_error
+    end    
+  end
+
 end # desc Patriarch::Behaviours

data/spec/lib/patriarch/destroy_entity_spec.rb

@@ -43,7 +43,7 @@ describe 'entities including Patriarch::Behaviours #destroy' do
     end
     
     # This works with ActiveRecord as expected
-    it "rollbacks redis clean" do
+    it "prevents redis clean" do
       f = FallenAngel.create
       m = Monster.create
       f.lure m
@@ -56,27 +56,4 @@ describe 'entities including Patriarch::Behaviours #destroy' do
     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

@@ -9,14 +9,15 @@ describe Patriarch::ToolServices::RedisCleanerService.instance do
     FallenAngel.add_behaviour   :like, :by => [:monster]
 
     # Tripartite behaviour ...
-    FallenAngel.add_behaviour   :praise, :on => [:monster],     :via => [:loveLetter]
-    Monster.add_behaviour       :praise, :by => [:fallenAngel], :via => [:loveLetter]
+    FallenAngel.add_behaviour   :praise, :by => [:monster],     :via => [:loveLetter]
+    Monster.add_behaviour       :praise, :on => [: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 }
+  let(:fallen_angel) { FallenAngel.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 }
@@ -26,8 +27,8 @@ describe Patriarch::ToolServices::RedisCleanerService.instance do
     it "removes presence into other sets for each behaviour" do
       f = FallenAngel.create
       m = Monster.create
-      f.lure m
       m.like f
+      f.lure m      
       instance.clean_all(f).execute
       f.monsters_i_lure.should be_empty
       f.monsters_liking_me.should be_empty
@@ -56,17 +57,17 @@ describe Patriarch::ToolServices::RedisCleanerService.instance do
     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
+      m = Monster.create
+      m.praise love_letter,fallen_angel
+      instance.clean_behaviour(m,:praise).execute
+      fallen_angel.monsters_praising_me_via_love_letters.include?(m).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
+      m = Monster.create
+      m.praise love_letter,fallen_angel
+      instance.clean_behaviour(m,:praise).execute
+      m.fallen_angels_i_praise_via_love_letters.include?(monster).should be_false
     end        
 
     it "runs within a unique transaction" do

data/spec/spec_helper.rb

@@ -53,26 +53,15 @@ class LoveLetter  < ActiveRecord::Base; include Patriarch::Behaviours; end
 # Setting standalone database to run tests
 ActiveRecord::Base.establish_connection(
   :adapter  => "sqlite3",
-  :database => ":memory:"
+  :database => ":memory:" #":memory:"
 )
 
 # Load minimal schema for database
 
-ActiveRecord::Schema.define do
-
-  create_table "fallen_angels", :force => true do |t|
-    t.datetime "created_at", :null => false
-    t.datetime "updated_at", :null => false
-  end
-
-  create_table "love_letters", :force => true do |t|
-    t.datetime "created_at", :null => false
-    t.datetime "updated_at", :null => false
+capture(:stdout) do
+  ActiveRecord::Schema.define do
+    create_table "fallen_angels", :force => true
+    create_table "love_letters", :force => true 
+    create_table "monsters", :force => true 
   end
-
-  create_table "monsters", :force => true do |t|
-    t.datetime "created_at", :null => false
-    t.datetime "updated_at", :null => false
-  end
-
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: patriarch
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-08 00:00:00.000000000 Z
+date: 2012-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: verbs
-  requirement: &8230400 !ruby/object:Gem::Requirement
+  requirement: &17816280 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *8230400
+  version_requirements: *17816280
 - !ruby/object:Gem::Dependency
   name: railties
-  requirement: &8229980 !ruby/object:Gem::Requirement
+  requirement: &17815860 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *8229980
+  version_requirements: *17815860
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &8229560 !ruby/object:Gem::Requirement
+  requirement: &17815420 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *8229560
+  version_requirements: *17815420
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &8229140 !ruby/object:Gem::Requirement
+  requirement: &17814980 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,21 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *8229140
+  version_requirements: *17814980
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: &17814500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *17814500
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &8228720 !ruby/object:Gem::Requirement
+  requirement: &17813840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +76,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *8228720
+  version_requirements: *17813840
 - !ruby/object:Gem::Dependency
   name: sqlite3
-  requirement: &8228300 !ruby/object:Gem::Requirement
+  requirement: &17813220 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,7 +87,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *8228300
+  version_requirements: *17813220
 description: Patriach is about adding behaviours on the fly to good old active record
   models.
 email: