patriarch 0.2.5 → 0.2.6

data/lib/patriarch.rb

@@ -13,6 +13,8 @@ module Patriarch
     autoload :InstallGenerator,                     'generators/patriarch/install_generator'
   end
 
+  autoload :RedisInstruction,                       'patriarch/redis_instruction'  
+
   autoload :Service,																'patriarch/service'
 	autoload :Transaction,														'patriarch/transaction'
 	autoload :TransactionStep,                        'patriarch/transaction_step'

data/lib/patriarch/authorization_service.rb

@@ -12,58 +12,27 @@ module Patriarch
     # Since type verification is an eternal we implement grant in the mother class and let daughter classes
     # call it with super and benefit from verify_types or bypass it completely and override the function
     def grant?(transac)
-      if check_types(transac)
-        true
-      else
-        raise Patriarch::ForbiddenBehaviourException, "that behaviour is not authorized"
-      end
+      check_types(transac) || raise(Patriarch::ForbiddenBehaviourException, "that behaviour is not authorized")
     end
 
-    # When declaring behaviours in model thanks to add_behaviour helper we enforce that ONLY the behaviour declared
+    # When declaring behaviours in model thanks to add_behaviour helper we enforce that ONLY the declared behaviours
     # are authorized. We hence verify that when a behaviour is called.
     # For example User could be able to like Items and thus be blessed with #like as an instance method.
-    # But then we can tell any user instance to like any object, this method denies these behaviours.
+    # But then we can call like upon from any user instance to like any object, this method prevents it.
     # @transac [Patriarch::Transaction] the transaction to be authorized (or not)
     def check_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
-
+      protagonists_models = transac.protagonists_models
       behaviour = transac.relation_type.to_s.sub(/undo_/,'').underscore.to_sym
       auths = []
 
-      if transac.tripartite?
-        # Verification 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)      
-
-        # Verification 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) 
-
-        # Verification for medium
-        # Pay attention here since add_behaviour syntax is different when being a medium
-        auths << medium_model.patriarch_behaviours[behaviour][:medium_between].map do |dual_sym_tab| 
-            dual_sym_tab.map{ |b_sym| b_sym.to_s.underscore.to_sym } 
-          end.include?( 
-            [actor_model_sym, target_model_sym] 
-          )
-      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)             
+      # See register behaviour to see how it is implemented. 
+      # TODO Couplage trop grand ici. 
+      protagonists_models.each do |protagonist_model|
+        auths << protagonist_model.patriarch_behaviours[behaviour].include?(protagonists_models)
       end
-
-
-      if auths.include? false
-        false 
-      else
-        true
-      end
-    end
-  end
-end
+      
+      !auths.include?(false)
+    end # def check_types
+  
+  end # class AuthorizationService 
+end # module Patriarch

data/lib/patriarch/behaviours.rb

@@ -347,7 +347,7 @@ module Patriarch
         end
 
         if options[:on]
-          module_to_complete.instance_eval do
+          module_to_complete.class_eval do
             # add behaviour_alias
             if options[:as]
               alias_method behaviour_alias, behaviour
@@ -365,15 +365,15 @@ module Patriarch
       # @param [String] behaviour
       # Add basic behaviours calls to models in bipartite situations
       def add_functionality_for_bipartite(anon_module,behaviour)
-        anon_module.instance_eval do
-
-          instance_eval do
-            # in instance_eval situations, there is no scope change so if we want to define included as a "self" method
-            # we are obliged to use this
-            (class << self; self; end).send(:define_method,:included) do |klass|
-              klass.extend ActiveModel::Callbacks
-              klass.send(:define_model_callbacks, behaviour, Patriarch.undo(behaviour))
-            end
+        anon_module.class_eval do
+
+          # use define_method to get otherwise out of scope variables
+          # usage of self.send(:define_method,:included) would fail as it would declare included
+          # as a method available to class including this module not as an override of the included
+          # hook
+          (class << self; self; end).send(:define_method,:included) do |klass|
+            klass.extend ActiveModel::Callbacks
+            klass.send(:define_model_callbacks, behaviour, Patriarch.undo(behaviour))
           end
 
           # behave
@@ -390,22 +390,22 @@ module Patriarch
             end
           end
 
-        end # instance_eval
+        end # class_eval
       end
 
       # @param [Module] anon_module
       # @param [String] behaviour
       # Add basic behaviours calls to models in tripartite situations
       def add_functionality_for_tripartite(anon_module,behaviour)
-        anon_module.instance_eval do
-
-          instance_eval do
-            # in instance_eval situations, there is no scope change so if we want to define included as a "self" method
-            # we are obliged to use this
-            (class << self; self; end).send(:define_method,:included) do |klass|
-              klass.extend ActiveModel::Callbacks
-              klass.send(:define_model_callbacks, behaviour, Patriarch.undo(behaviour))
-            end
+        anon_module.class_eval do
+
+          # use define_method to get otherwise out of scope variables
+          # usage of self.send(:define_method,:included) would fail as it would declare included
+          # as a method available to class including this module not as an override of the included
+          # hook
+          (class << self; self; end).send(:define_method,:included) do |klass|
+            klass.extend ActiveModel::Callbacks
+            klass.send(:define_model_callbacks, behaviour, Patriarch.undo(behaviour))
           end
 
           # behave
@@ -415,7 +415,6 @@ module Patriarch
             end
           end
 
-
           # undo_behave
           define_method(Patriarch.undo(behaviour)) do |via_entity,entity,options={}|
             run_callbacks Patriarch.undo(behaviour).to_sym do
@@ -423,7 +422,7 @@ module Patriarch
             end
           end
 
-        end # instance_eval
+        end # class_eval
       end
 
       # @param [String] behaviour
@@ -434,19 +433,14 @@ module Patriarch
         behaviour = behaviour.underscore.to_sym
 
         self.patriarch_behaviours ||= { }
-        #self.patriarch_behaviours[behaviour.underscore.to_sym] ||= { :on => [], :by =>[] }
-        self.patriarch_behaviours[behaviour] ||= { }
-        self.patriarch_behaviours[behaviour][:on] ||= []
-        self.patriarch_behaviours[behaviour][:by] ||= []
+        self.patriarch_behaviours[behaviour] ||= []
 
-        if options[:on]
-          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][:by] << options[:by]
-          self.patriarch_behaviours[behaviour][:by].uniq!
-          self.patriarch_behaviours[behaviour][:by].flatten!
+        Array(options[:on]).each do |target_class_sym|
+          self.patriarch_behaviours[behaviour] << [self,target_class_sym.to_s.classify.constantize]
+        end
+
+        Array(options[:by]).each do |actor_class_sym|          
+          self.patriarch_behaviours[behaviour] << [actor_class_sym.to_s.classify.constantize,self]
         end
       end
 
@@ -458,35 +452,28 @@ module Patriarch
         behaviour = behaviour.underscore.to_sym
 
         self.patriarch_behaviours ||= { }
-        self.patriarch_behaviours[behaviour]  ||= {}
+        self.patriarch_behaviours[behaviour]  ||= []
 
-        if options[:via]
-          #self.patriarch_behaviours[behaviour.underscore.to_sym] ||= { :on => [], :by => [], :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][:medium_between] ||= []
-        end
+        Array(options[:via]).each do |medium_class_sym|
+          Array(options[:on]).each do |target_class_sym|
+            target_class = target_class_sym.to_s.classify.constantize
+            medium_class = medium_class_sym.to_s.classify.constantize
+            self.patriarch_behaviours[behaviour] << [self, target_class, medium_class]
+          end
 
-        if options[:via]
-          if options[:on]
-            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][:by] << options[:by]
-            self.patriarch_behaviours[behaviour][:by].uniq!
-            self.patriarch_behaviours[behaviour][:by].flatten!
+          Array(options[:by]).each do |actor_class_sym|
+            actor_class  = actor_class_sym.to_s.classify.constantize
+            medium_class = medium_class_sym.to_s.classify.constantize
+            self.patriarch_behaviours[behaviour] << [actor_class, self, medium_class]
           end
-            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][:medium_between] << options[:medium_between]
-          self.patriarch_behaviours[behaviour][:medium_between].uniq!
-          self.patriarch_behaviours[behaviour][:medium_between]
+        end
+
+        # FIXME should support enumerations of medium betweens like this
+        # [[actor1,target1],[actor2,target2]]
+        if options[:medium_between]
+          actor_class  = options[:medium_between].first.to_s.classify.constantize
+          target_class = options[:medium_between].last.to_s.classify.constantize
+          self.patriarch_behaviours[behaviour] << [actor_class, target_class, self]
         end
       end
 
@@ -558,7 +545,7 @@ module Patriarch
         # register the behaviour we just added
         register_bipartite_behaviour(behaviour,options)
       end
-    end
+    end # module Class Methods
 
   end # Behaviours
 end # Patriarch

data/lib/patriarch/dao_services/bipartite_relationship_builder_service.rb

@@ -16,13 +16,9 @@ class Patriarch::DAOServices::BipartiteRelationshipBuilderService < Patriarch::S
     actor_dao = dao_tab[:actor]
     target_dao = dao_tab[:target]
 
-    l   = build_ostruct_for_create(actor_dao,transaction_item.target_id,t)
-    ll   = build_ostruct_for_create(target_dao,transaction_item.actor_id,t)
+    l   = build_struct_for_create(actor_dao,transaction_item.target_id,t)
+    ll   = build_struct_for_create(target_dao,transaction_item.actor_id,t)
 
-    p "#{l.inspect} is creating on key #{actor_dao.key} : #{transaction_item.target_type} #{transaction_item.target_id}"
-    p "#{ll.inspect} is creating on key #{target_dao.key} : #{transaction_item.actor_type} #{transaction_item.actor_id}"    
- 
-    # care about that, should be encapsulated into a beautiful add_to_queue method
     transaction_item.add_to_queue l
     transaction_item.add_to_queue ll
   end
@@ -36,10 +32,8 @@ class Patriarch::DAOServices::BipartiteRelationshipBuilderService < Patriarch::S
     actor_dao = dao_tab[:actor]
     target_dao = dao_tab[:target]
 
-    #l   = proc { actor_dao.delete transaction_item.target_id }
-    #ll  = proc { target_dao.delete transaction_item.actor_id }
-    l  = OpenStruct.new(:method_sym => :delete ,:dao => actor_dao, :args => [transaction_item.target_id])
-    ll = OpenStruct.new(:method_sym => :delete ,:dao => target_dao, :args => [transaction_item.actor_id])
+    l  = Patriarch::RedisInstruction.new(actor_dao,:delete,[transaction_item.target_id])
+    ll = Patriarch::RedisInstruction.new(target_dao,:delete ,[transaction_item.actor_id])
 
     transaction_item.add_to_queue l
     transaction_item.add_to_queue ll
@@ -49,14 +43,12 @@ class Patriarch::DAOServices::BipartiteRelationshipBuilderService < Patriarch::S
   # @param [Redis::Objects] dao
   # @param [Array] ids
   # @param [Time] time
-  # Returns ostruct objects that store parameters to execute a redis operation
-  def build_ostruct_for_create(dao,id,time)
+  # Returns Patriarch::RedisInstruction (structs) objects that store parameters to execute a redis operation
+  def build_struct_for_create(dao,id,time)
     if dao.is_a? Redis::SortedSet
-      return OpenStruct.new(:method_sym => :add ,:dao => dao, :args => [id,time])
-      # return lambda { dao.add ids, time }
+      return Patriarch::RedisInstruction.new(dao,:add,[id,time])
     else
-      return OpenStruct.new(:method_sym => :add ,:dao => dao, :args => [id])      
-      # return lambda { dao.add ids }
+      return Patriarch::RedisInstruction.new(dao,:add,[id])      
     end
   end  
 end

data/lib/patriarch/dao_services/tripartite_relationship_builder_service.rb

@@ -20,9 +20,9 @@ class Patriarch::DAOServices::TripartiteRelationshipBuilderService < Patriarch::
 
     protagonist_ids = [transaction_item.actor_id,transaction_item.target_id,transaction_item.medium_id]
 
-    l    = build_ostruct_for_create(actor_dao,protagonist_ids,t)
-    ll   = build_ostruct_for_create(target_dao,protagonist_ids,t)
-    lll  = build_ostruct_for_create(medium_dao,protagonist_ids,t)
+    l    = build_struct_for_create(actor_dao,protagonist_ids,t)
+    ll   = build_struct_for_create(target_dao,protagonist_ids,t)
+    lll  = build_struct_for_create(medium_dao,protagonist_ids,t)
 
     # care about that, should be encapsulated into a beautiful add_to_queue method
     transaction_item.add_to_queue l
@@ -46,9 +46,9 @@ class Patriarch::DAOServices::TripartiteRelationshipBuilderService < Patriarch::
     #ll  = lambda { target_dao.delete protagonist_ids }
     #lll = lambda { medium_dao.delete protagonist_ids }
 
-    l   = OpenStruct.new(:method_sym => :delete ,:dao => actor_dao, :args => [protagonist_ids])
-    ll  = OpenStruct.new(:method_sym => :delete ,:dao => target_dao, :args => [protagonist_ids])
-    lll = OpenStruct.new(:method_sym => :delete ,:dao => medium_dao, :args => [protagonist_ids])
+    l   = Patriarch::RedisInstruction.new(actor_dao ,:delete,[protagonist_ids])
+    ll  = Patriarch::RedisInstruction.new(target_dao,:delete,[protagonist_ids])
+    lll = Patriarch::RedisInstruction.new(medium_dao,:delete,[protagonist_ids])
     
     transaction_item.add_to_queue l
     transaction_item.add_to_queue ll
@@ -59,14 +59,12 @@ class Patriarch::DAOServices::TripartiteRelationshipBuilderService < Patriarch::
   # @param [Redis::Objects] dao
   # @param [Array] ids
   # @param [Time] time
-  # Returns ostruct objects that store parameters to execute a redis operation
-  def build_ostruct_for_create(dao,ids,time)
+  # Returns Patriarch::RedisInstruction (structs) objects that store parameters to execute a redis operation
+  def build_struct_for_create(dao,ids,time)
     if dao.is_a? Redis::SortedSet
-      return OpenStruct.new(:method_sym => :add ,:dao => dao, :args => [ids,time])
-      # return lambda { dao.add ids, time }
-    else
-      return OpenStruct.new(:method_sym => :add ,:dao => dao, :args => [ids])      
-      # return lambda { dao.add ids }
+      return Patriarch::RedisInstruction.new(dao,:add,[ids,time])
+    else                                          
+      return Patriarch::RedisInstruction.new(dao,:add,[ids])      
     end
   end
 end

data/lib/patriarch/redis_instruction.rb

@@ -0,0 +1,8 @@
+module Patriarch
+  RedisInstruction = Struct.new(:dao,:method_sym,:args)
+  class RedisInstruction 
+    def execute
+      dao.send(method_sym,*args)
+    end
+  end
+end

data/lib/patriarch/tool_services/redis_cleaner_service.rb

@@ -29,102 +29,105 @@ class Patriarch::ToolServices::RedisCleanerService < Patriarch::Service
     behaviour_symbol = behaviour.to_s.underscore.to_sym
 
     if my_behaviours.include? behaviour_symbol
-      if my_behaviours[behaviour_symbol][:medium_between] || my_behaviours[behaviour_symbol][:via]
+      if my_behaviours[behaviour_symbol].first.size == 3
         clean_tripartite_behaviour(calling_entity,behaviour,options)
-      else
+      elsif my_behaviours[behaviour_symbol].first.size == 2
         clean_bipartite_behaviour(calling_entity,behaviour,options)
+      else
+        raise "Bad Behaviour declaration occured, no doublet or triplet are registered"
       end
     end
   end
 
+
   #:nodoc:
   def clean_tripartite_behaviour(calling_entity,behaviour,options={})
-    my_behaviours = calling_entity.class.patriarch_behaviours
-    behaviour_symbol = behaviour.to_s.underscore.to_sym
-
-    # Compute names based on conventions
-    progressive_present_behaviour =
-      (Verbs::Conjugator.conjugate behaviour_symbol, :aspect => :progressive).split(/ /).last
+    my_class = calling_entity.class
+    tripartite_behaviour = my_class.patriarch_behaviours[behaviour.to_s.underscore.to_sym]
 
     transac = options[:transac] || Patriarch::TransactionServices::TransactionManagerService.instance.new_transaction("clean_#{behaviour.to_s}".to_sym)
     options = { :transac => transac, :stop_execution => true}
+      
+    tripartite_behaviour.each do |protagonists|
+      clean_tripartite_behaviour_for_actor(calling_entity,behaviour,protagonists,options)  if protagonists.first  == my_class
+      clean_tripartite_behaviour_for_target(calling_entity,behaviour,protagonists,options) if protagonists.second == my_class
+      clean_tripartite_behaviour_for_medium(calling_entity,behaviour,protagonists,options) if protagonists.third  == my_class
+    end      
 
-    if my_behaviours.include? behaviour_symbol
+    transac
+  end #clean_tripartite_behaviour
 
-      # Dealing with active behaviour
-      if my_behaviours[behaviour_symbol][:on]
-        acted_on_models = my_behaviours[behaviour_symbol][:on]
-        via_models      = my_behaviours[behaviour_symbol][: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,medium_for_behaviour,target_i_behaved_on,options)
-            end
-          end
-        end
-      end
+  #:nodoc:
+  def clean_bipartite_behaviour(calling_entity,behaviour,options={})
+    my_class = calling_entity.class
+    bipartite_behaviour = my_class.patriarch_behaviours[behaviour.to_s.underscore.to_sym]
 
-      # Dealing with passive behaviour
-      if my_behaviours[behaviour_symbol][:by]
-        targetted_by_models = my_behaviours[behaviour_symbol][:by]
-        via_models      = my_behaviours[behaviour_symbol][: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,medium_for_behaviour,calling_entity,options)
-            end
-          end
-        end
-      end
+    transac = options[:transac] || Patriarch::TransactionServices::TransactionManagerService.instance.new_transaction("clean_#{behaviour.to_s}".to_sym)
+    options = { :transac => transac, :stop_execution => true}
 
-      # Dealing with medium behaviour
-      if my_behaviours[behaviour_symbol][:medium_between]
-        #do nothing, we do not take care of data relative to medium ...
-      end
-    end # if my_behaviours.include?
+    bipartite_behaviour.each do |protagonists|
+      clean_bipartite_behaviour_for_actor(calling_entity,behaviour,protagonists,options)  if protagonists.first  == my_class
+      clean_bipartite_behaviour_for_target(calling_entity,behaviour,protagonists,options) if protagonists.second == my_class
+    end  
 
     transac
-  end #clean_tripartite_behaviour
+  end # #clean_bipartite_behaviour
 
-  #:nodoc:
-  def clean_bipartite_behaviour(calling_entity,behaviour,options={})
-    my_behaviours = calling_entity.class.patriarch_behaviours
+  protected
+
+  def clean_bipartite_behaviour_for_actor(calling_entity,behaviour,protagonists,options)
+    acted_on_model = protagonists.second
+    calling_entity.send("#{acted_on_model.to_s.tableize}_i_#{behaviour.to_s}").each do |target_i_behaved_on|
+      calling_entity.send(Patriarch.undo(behaviour.to_s).underscore,target_i_behaved_on,options)
+    end   
+  end
+
+  def clean_bipartite_behaviour_for_target(calling_entity,behaviour,protagonists,options)
+    # Dealing with passive behaviour
     behaviour_symbol = behaviour.to_s.underscore.to_sym
 
     # Compute names based on conventions
     progressive_present_behaviour =
       (Verbs::Conjugator.conjugate behaviour_symbol, :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}
+    targetted_by_model = protagonists.first
+    calling_entity.send("#{targetted_by_model.to_s.tableize}_#{progressive_present_behaviour}_me").each do |actor_that_behaved_on_me|
+      actor_that_behaved_on_me.send(Patriarch.undo(behaviour.to_s).underscore,calling_entity,options)
+    end    
+  end
 
-    if my_behaviours.include? behaviour_symbol
-      # Dealing with passive behaviour
-      if my_behaviours[behaviour_symbol][:by]
-        targeted_by_models = my_behaviours[behaviour_symbol][:by]
-        targeted_by_models.each do |targeted_by_model|
-          calling_entity.send("#{targeted_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_symbol][:on]
-        acted_on_models = my_behaviours[behaviour_symbol][:on]
-        acted_on_models.each do |acted_on_model|
-          calling_entity.send("#{acted_on_model.to_s.tableize}_i_#{behaviour.to_s}").each do |target_i_behaved_on|
-            calling_entity.send(Patriarch.undo(behaviour.to_s).underscore,target_i_behaved_on,options)
-          end
-        end
-      end
-    end # if my_behaviours.include?
+  def clean_tripartite_behaviour_for_actor(calling_entity,behaviour,protagonists,options)
+    # Dealing with active behaviour
+    acted_on_model = protagonists.second
+    via_model      = protagonists.third
+    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.find(tripartite_hash[:target])).first
+      medium_for_behaviour = Array(via_model.find(tripartite_hash[:medium])).first
+      calling_entity.send(Patriarch.undo(behaviour.to_s).underscore,medium_for_behaviour,target_i_behaved_on,options)
+    end
+  end
 
-    transac
-  end # #clean_bipartite_behaviour
-end  # class Patriarch ...
+  def clean_tripartite_behaviour_for_target(calling_entity,behaviour,protagonists,options)
+    # Dealing with passive behaviour
+    behaviour_symbol = behaviour.to_s.underscore.to_sym
+
+    # Compute names based on conventions
+    progressive_present_behaviour =
+      (Verbs::Conjugator.conjugate behaviour_symbol, :aspect => :progressive).split(/ /).last
+
+    targetted_by_model = protagonists.first
+    via_model          = protagonists.third
+    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.find(tripartite_hash[:actor])).first
+      medium_for_behaviour = Array(via_model.find(tripartite_hash[:medium])).first
+      actor_that_behaved_on_me.send(Patriarch.undo(behaviour.to_s).underscore,medium_for_behaviour,calling_entity,options)
+    end
+  end 
+
+  def clean_tripartite_behaviour_for_medium(calling_entity,behaviour,protagonists,options)
+    # do nothing. Not implemented yet.
+    # TODO sort this bizarre thing
+    # Previous version comment said => #do nothing, we do not take care of data relative to medium ...
+  end
+
+end  # class Patriarch ...

data/lib/patriarch/tool_services/redis_extractor_service.rb

@@ -86,6 +86,7 @@ class Patriarch::ToolServices::RedisExtractorService < Patriarch::Service
       if x.is_a? Array
         x[0].to_i
         x
+        # FIXME Bullshit détecté ici
       else 
         x.to_i
       end

data/lib/patriarch/transaction.rb

@@ -15,7 +15,7 @@ module Patriarch
 
     forwarded_methods_syms =  [:relation_type,:actor_type,:target_type,:medium_type,
                                :actor_id,:target_id,:medium_id, 
-                               :context,:actor,:target,:medium]
+                               :context,:actor,:target,:medium,:protagonists_models]
 
     # Forward methods that are not this transaction's job to step object
     forwarded_methods_syms.each do |method_sym|

data/lib/patriarch/transaction_step.rb

@@ -43,22 +43,25 @@ module Patriarch
       target_type.to_s.camelize.constantize.find target_id
     end
 
+    def protagonists_models 
+      # By convention always actor, target, model for tripartite and 
+      # actor, model for bipartite
+      [actor,target,medium].compact.map(&:class)
+    end
+
     # execute the redis instructions embedded into this step against
     # instructions are a dao, a method to call upon and its argument embedded into a OpenStruct
     # before Patriarch 0.2.5, was embedded directly in a proc, was a complete failure for unknown reasons
     # Patriach::Transaction use this method on each of the steps it registered within a multi block
     def execute
-      queue.each do |redis_ostruct_instruction|
-        os = redis_ostruct_instruction
-        dao, method_sym, args = [os.dao,os.method_sym,os.args]
-        dao.send(method_sym,*args)
-        # deprecated, remove this : redis_instruction.call 
+      queue.each do |redis_struct_instruction|
+        redis_struct_instruction.execute
       end
     end
 
-    # @param [OpenStruct] ostruct dao with parameters and method to call embedded here to be processed later
-    def add_to_queue(ostruct)
-      queue << ostruct
+    # @param [Patriarch::RedisInstruction] ostruct dao with parameters and method to call embedded here to be processed later
+    def add_to_queue(struct)
+      queue << struct
     end
   end
 end

data/lib/patriarch/version.rb

@@ -1,3 +1,3 @@
 module Patriarch
-  VERSION = "0.2.5"
+  VERSION = "0.2.6"
 end

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

@@ -22,7 +22,7 @@ describe Patriarch::DAOServices::BipartiteRelationshipBuilderService do
   it "shall insert processable lambdas into queues when create is called" do
     expect{
       instance.create(@transac)
-    }.to change{ @transac.transaction_queue.select{ |queue_element| queue_element.is_a? OpenStruct}.size }.by(2)
+    }.to change{ @transac.transaction_queue.select{ |queue_element| queue_element.is_a? Patriarch::RedisInstruction}.size }.by(2)
   
     expect{
       @transac.transaction_queue.each do |redis_ostruct_instruction|
@@ -36,7 +36,7 @@ describe Patriarch::DAOServices::BipartiteRelationshipBuilderService do
   it "shall insert processable lambdas into queues when destroy is called" do
     expect{
       instance.destroy(@transac)
-    }.to change{ @transac.transaction_queue.select{ |queue_element| queue_element.is_a? OpenStruct}.size }.by(2)
+    }.to change{ @transac.transaction_queue.select{ |queue_element| queue_element.is_a? Patriarch::RedisInstruction}.size }.by(2)
 
     expect{
       @transac.transaction_queue.each do |redis_ostruct_instruction|

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

@@ -24,7 +24,7 @@ describe Patriarch::DAOServices::TripartiteRelationshipBuilderService do
   it "shall insert processable lambdas into queues when create is called" do
     expect{
       instance.create(@transac)
-    }.to change{ @transac.transaction_queue.select{ |queue_element| queue_element.is_a? OpenStruct}.size }.by(3)
+    }.to change{ @transac.transaction_queue.select{ |queue_element| queue_element.is_a? Patriarch::RedisInstruction}.size }.by(3)
   
     expect{
       @transac.transaction_queue.each do |redis_ostruct_instruction| 
@@ -38,7 +38,7 @@ describe Patriarch::DAOServices::TripartiteRelationshipBuilderService do
   it "shall insert processable lambdas into queues when destroy is called" do
     expect{
       instance.destroy(@transac)
-    }.to change{ @transac.transaction_queue.select{ |queue_element| queue_element.is_a? OpenStruct}.size }.by(3)
+    }.to change{ @transac.transaction_queue.select{ |queue_element| queue_element.is_a? Patriarch::RedisInstruction}.size }.by(3)
 
     expect{
       @transac.transaction_queue.each do |redis_ostruct_instruction|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: patriarch
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.2.6
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-09 00:00:00.000000000 Z
+date: 2013-05-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: verbs
@@ -166,6 +166,7 @@ files:
 - lib/patriarch/dao_services/retriever_service.rb
 - lib/patriarch/dao_services/tripartite_relationship_builder_service.rb
 - lib/patriarch/manager_service.rb
+- lib/patriarch/redis_instruction.rb
 - lib/patriarch/service.rb
 - lib/patriarch/tool_services/redis_cleaner_service.rb
 - lib/patriarch/tool_services/redis_extractor_service.rb