patriarch 0.0.4 → 0.1.0

data/.gitignore

@@ -1,3 +1,4 @@
+redis_reclip_cleaner.rb
 spec/dummy
 *.gem
 *.rbc

data/README.md

@@ -1,6 +1,27 @@
 # Patriarch
 
-TODO: Write a gem description
+N-N tables are often a pain to deal with in SQL especially when you want to
+- have a lot of different N-N relations
+- have a fast API with a lot of calls
+
+A solution is to use Redis to store the results of the joins in a simple way. For instance
+a user likes many items → Let's store the items ids liked into a redis_key
+an item is liked by many users → reverse logic
+
+
+The complexity also increases as you add callbacks. Let's say you provide users with the
+behaviour "like" and "subscribe". You may want to trigger "subscribe" right after "like" was performed
+and keep track of all this in one transaction.
+
+
+Patriarch allows you to handle all of this in a matter of seconds and 
+- gathers all of the redis calls in one transaction object that stores a redis queue ready to be processed
+- rollbacks SQL destroy transaction if redis database dropped while processing the instruction queue to clean data relative
+to SQL rows destroyed. Reduces possibilities of painful database incoherences
+
+# What Patriarch is not 
+
+Patriarch is not a replacement for SQL
 
 ## Installation
 
@@ -10,7 +31,7 @@ Add this line to your application's Gemfile:
 
 And then execute:
 
-    $ bundle
+    $ bundle update
 
 Or install it yourself as:
 
@@ -18,7 +39,26 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+First include it into your model:
+
+    class User < ActiveRecord::Base
+      include Patriarch::Behaviours
+    end
+
+### Initializing files for a behaviour
+
+Just type in: 
+
+    rails generate patriach:behaviour BEHAVIOUR
+
+### Bipartite relations
+
+Add a behaviour in a simple way and write this just below the include:
+
+    add_behaviour :on => [Model1,Model2] # add active_behaviour performed on instances of model1, model2
+    add_behaviour :by => [Model3]        # add passive_behaviour performed on us by instances of model3
+
+It works like belongs_to and has_many helpers of active record, you need to include declarations in both models
 
 ## Contributing
 

data/lib/generators/patriarch/behaviour_generator.rb

@@ -0,0 +1,117 @@
+require "rails/generators"
+require "redis/objects/sorted_sets"
+
+module Patriarch
+  module Generators
+    class BehaviourGenerator < Rails::Generators::Base
+      source_root File.expand_path('../templates', __FILE__)
+      
+      desc "Generate files needed to implement the BEHAVIOUR you specified. Don't forget to add declarations into models"
+    
+      argument :behaviour, :type => :string
+      argument :behaviour_type, :type => :string, :optional => true, :default => "bipartite"
+
+      public
+
+      def fail_if_bad_syntax
+        if behaviour_type != "bipartite" && behaviour_type != "tripartite"
+          # Pleasedon't, qualify an exception here
+          raise Exception, "bad syntax behaviour_type must be bipartite or tripartite"
+        end 
+      end
+
+      def init_directories_for_behaviour
+        empty_directory "lib/patriarch/services/#{behaviour.underscore.downcase}"
+        empty_directory "lib/patriarch/services/#{Patriarch.undo(behaviour.underscore.downcase)}"
+      end
+
+      def customize_basic_files 
+        template "empty_behaviour_module.rb", "lib/patriarch/behaviours/#{behaviour.underscore.downcase}.rb"   
+        template "empty_service_module.rb", "lib/patriarch/services/#{behaviour.underscore.downcase}.rb"         
+        template "tools_methods.rb", "lib/patriarch/behaviours/#{behaviour.underscore.downcase}/tools_methods.rb"
+      end
+    
+      def ensure_autoload
+        # Autoload declaration insertion for services
+        insert_into_file "lib/patriarch/services.rb", :after => "  module Services\n" do
+          "    autoload :#{class_name}, 'patriarch/services/#{behaviour.underscore.downcase}.rb'\n"
+        end
+    
+        insert_into_file "lib/patriarch/services.rb", :after => "  module Services\n" do
+          "    autoload :#{undo_class_name}, 'patriarch/services/#{behaviour.underscore.downcase}.rb'\n"
+        end
+    
+        # Autoload declaration insertion for behaviours (no undo needed ...)
+        insert_into_file "lib/patriarch/behaviours.rb", :after => "  module Behaviours\n" do
+          "    autoload :#{class_name}, 'patriarch/behaviours/#{behaviour.underscore.downcase}.rb'\n"
+        end
+    
+        # load File.expand_path('lib/patriarch/behaviours.rb', __FILE__)
+      end
+    
+      def generate_services
+        create_services(behaviour,behaviour_type)
+        # implémenter un switch ici, plus zoli ...
+        self.class.send(:define_method,:class_name) do
+          Patriarch.undo(behaviour).classify
+        end
+        create_undo_services(behaviour,behaviour_type)
+        self.class.send(:define_method,:class_name) do
+          behaviour.classify
+        end
+      end
+    
+      private
+        def class_name
+          behaviour.classify
+        end
+    
+        def undo_class_name
+          Patriarch.undo(behaviour).classify
+        end
+    
+        def create_services(behaviour,behaviour_type)
+          behaviour_str = behaviour.underscore.downcase
+          template "authorization_service.rb", "lib/patriarch/services/#{behaviour_str}/authorization_service.rb"
+          
+          template "before_manager_service.rb", "lib/patriarch/services/#{behaviour_str}/before_manager_service.rb"
+          template "before_service.rb", "lib/patriarch/services/#{behaviour_str}/before_service.rb"
+    
+
+          
+          if behaviour_type == "tripartite"  
+            template "service-tripartite.rb", "lib/patriarch/services/#{behaviour_str}/service.rb"  
+            template "manager_service-tripartite.rb", "lib/patriarch/services/#{behaviour_str}/manager_service.rb"     
+          elsif behaviour_type == "bipartite"          
+            template "service.rb", "lib/patriarch/services/#{behaviour_str}/service.rb"  
+            template "manager_service.rb", "lib/patriarch/services/#{behaviour_str}/manager_service.rb"            
+          end
+
+          template "after_manager_service.rb", "lib/patriarch/services/#{behaviour_str}/after_manager_service.rb"
+          template "after_service.rb", "lib/patriarch/services/#{behaviour_str}/after_service.rb"
+        end
+    
+        def create_undo_services(behaviour,behaviour_type)
+          undo_behaviour_str = Patriarch.undo(behaviour).underscore.downcase
+    
+          template "authorization_service.rb", "lib/patriarch/services/#{undo_behaviour_str}/authorization_service.rb"
+          
+          template "before_manager_service.rb", "lib/patriarch/services/#{undo_behaviour_str}/before_manager_service.rb"
+          template "before_service.rb", "lib/patriarch/services/#{undo_behaviour_str}/before_service.rb"
+          
+          # Please don't go another generator if necessary or do other functions
+          if behaviour_type == "tripartite"                      
+            template "undo_service-tripartite.rb", "lib/patriarch/services/#{undo_behaviour_str}/service.rb" 
+            template "manager_service-tripartite.rb", "lib/patriarch/services/#{undo_behaviour_str}/manager_service.rb"               
+          elsif behaviour_type == "bipartite"
+            template "undo_service.rb", "lib/patriarch/services/#{undo_behaviour_str}/service.rb"  
+            template "manager_service.rb", "lib/patriarch/services/#{undo_behaviour_str}/manager_service.rb"            
+          end
+
+          template "after_manager_service.rb", "lib/patriarch/services/#{undo_behaviour_str}/after_manager_service.rb"
+          template "after_service.rb", "lib/patriarch/services/#{undo_behaviour_str}/after_service.rb"
+        end
+    
+    end # BehaviourGenerator
+  end # Generators
+end # Patriarch

data/lib/generators/patriarch/install_generator.rb

@@ -1,11 +1,28 @@
 require "rails/generators"
-
-class InstallGenerator < Rails::Generators::Base
-  source_root File.expand_path('../templates', __FILE__)
-  
-  desc "Installs the gem"
-
-  def init_directories
-    copy_file "empty_behaviours_declaration.rb", "lib/patriarch/behaviours.rb"
-  end
-end # InstallGenerator
+module Patriarch
+  module Generators  
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path('../templates', __FILE__)
+      
+      desc "Installs the gem"
+    
+      def init_directories
+        copy_file "empty_behaviours_declaration.rb", "lib/patriarch/behaviours.rb"
+      end
+      
+      def copy_compulsory_files
+        copy_file "empty_behaviours_declaration.rb", "lib/patriarch/behaviours.rb"
+        copy_file "empty_services_declaration.rb", "lib/patriarch/services.rb" 
+      end
+   
+      def build_initializer
+        create_file "config/initializers/patriarch.rb" do 
+          "require 'patriarch'\n\n"+
+          "load File.expand_path('../../../lib/patriarch/behaviours.rb', __FILE__)\n" + 
+          "load File.expand_path('../../../lib/patriarch/services.rb', __FILE__)"
+        end
+      end
+ 
+    end # InstallGenerator
+  end # Generators
+end # Patriarch

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

@@ -1,6 +1,7 @@
 class Patriarch::Services::<%= class_name %>::AfterManagerService < Patriarch::ManagerService 
   def resolve(transac)
-    # Manages what happens after the service call
+    # Manages what happens after the service call, it allows you to be independant
+    # from active_models callback if you wish to do so
     Patriarch::Services::<%= class_name %>::AfterService.instance.call(transac) if true
   end
 end

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

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

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

@@ -1,6 +1,7 @@
 class Patriarch::Services::<%= class_name %>::BeforeManagerService < Patriarch::ManagerService 
   def resolve(transac)
-    # Manages what happens after the service call
+    # Manages what happens after the service call, it allows you to be independant
+    # from active_models callback if you wish to do so
     Patriarch::Services::<%= class_name %>::BeforeService.instance.call(transac) if true
   end
 end

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

@@ -1,6 +1,6 @@
 class Patriarch::Services::<%= class_name %>::BeforeService < Patriarch::Service
   def call(transac,options={})
-    # Add after service logic here and return the corresponding boolean
+    # Add after service logic here and return the boolean corresponding to success (or not)
     true
   end
 end

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

@@ -1,5 +1,7 @@
 module Patriarch
   module Behaviours
     # Autoloads declaration will be inserted here
+    # Do not modify indentation or anything else since it would mess up
+    # the generator when it tries to insert autoload declarations
   end
 end

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

@@ -1,5 +1,7 @@
 module Patriarch
   module Services
     # Autoloads declaration will be inserted here
+    # Do not modify indentation or anything else since it would mess up
+    # the generator when it tries to insert autoload declarations
   end
 end

data/lib/generators/patriarch/templates/manager_service-tripartite.rb

@@ -0,0 +1,36 @@
+class Patriarch::Services::<%= class_name %>::ManagerService < Patriarch::ManagerService
+  # Return true or false
+  def resolve(actor, target, medium, options={})
+    
+    # Flag initialized only if first add_step
+    # It allows you to insert other behaviours into the callbacks without quitting the transaction
+    # A like of an user on an item can trigger a subscribe to an item for instance 
+    # It means it will rollback if follow is not performed correctly 
+
+    if options[:transac]
+      transac_first_step = false
+    else
+      transac_first_step = true
+    end
+
+    transac = options[:transac] || Patriarch::TransactionServices::TransactionManagerService.instance.new_transaction(:<%= class_name.underscore.to_sym %>)
+    transac.add_step(:<%= class_name.underscore.to_sym %>,actor,target,medium)          
+
+    callbacks_were_completed = false
+
+    # Before logic not implemented yet here, to come in further releases
+    if Patriarch::Services::<%= class_name %>::AuthorizationService.instance.grant?(transac)
+      Patriarch::Services::<%= class_name %>::Service.instance.call(transac)
+      if Patriarch::Services::<%= class_name %>::AfterManagerService.instance.resolve(transac)
+        callbacks_were_completed = true
+      end
+    end
+
+    # In some cases we want to interrupt the transaction before it executes and just play with
+    # the transaction object  
+    return transac if options[:stop_execution]
+
+    # If everything went smoothly
+    transac.execute if (transac_first_step && callbacks_were_completed)
+  end
+end

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

@@ -1,29 +1,36 @@
 class Patriarch::Services::<%= class_name %>::ManagerService < Patriarch::ManagerService
   # Return true or false
-  def resolve(actor, target, transac = nil)
+  def resolve(actor, target, options={})
     
-    # On plante le "drapeau" transac_first_step pour signifier le début
-    if transac
+    # Flag initialized only if first add_step
+    # It allows you to insert other behaviours into the callbacks without quitting the transaction
+    # A like of an user on an item can trigger a subscribe to an item for instance 
+    # It means it will rollback if follow is not performed correctly 
+
+    if options[:transac]
       transac_first_step = false
     else
       transac_first_step = true
     end
 
-    transac ||= Patriarch::TransactionServices::TransactionManagerService.instance.new_transaction(:<%= class_name.underscore.to_sym %>)
-    # Do not listen Loïc anymore ... DO NOT MOVE, LikeAuthorizationService needs us to build 
-    # a transaction step
+    transac = options[:transac] || Patriarch::TransactionServices::TransactionManagerService.instance.new_transaction(:<%= class_name.underscore.to_sym %>)
     transac.add_step(:<%= class_name.underscore.to_sym %>,actor,target)          
 
     callbacks_were_completed = false
 
+    # Before logic not implemented yet here, to come in further releases
     if Patriarch::Services::<%= class_name %>::AuthorizationService.instance.grant?(transac)
-     Patriarch::Services::<%= class_name %>::Service.instance.call(transac)
+      Patriarch::Services::<%= class_name %>::Service.instance.call(transac)
       if Patriarch::Services::<%= class_name %>::AfterManagerService.instance.resolve(transac)
         callbacks_were_completed = true
       end
     end
 
-    # Si tout s'est bien passé et que les callbacks ont été exécutés
+    # In some cases we want to interrupt the transaction before it executes and just play with
+    # the transaction object  
+    return transac if options[:stop_execution]
+
+    # If everything went smoothly
     transac.execute if (transac_first_step && callbacks_were_completed)
   end
 end

data/lib/generators/patriarch/templates/service-tripartite.rb

@@ -0,0 +1,5 @@
+class Patriarch::Services::<%= class_name %>::Service < Patriarch::Service
+  def call(transaction_item)
+    Patriarch::DAOServices::TripartiteRelationshipBuilderService.instance.create(transaction_item)
+  end 
+end

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

@@ -1,5 +1,5 @@
 class Patriarch::Services::<%= class_name %>::Service < Patriarch::Service
   def call(transaction_item)
-      Patriarch::DAOServices::BipartiteRelationshipBuilderService.instance.create(transaction_item)
+    Patriarch::DAOServices::BipartiteRelationshipBuilderService.instance.create(transaction_item)
   end 
 end

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

@@ -1,3 +1,4 @@
 module Patriarch::Behaviours::<%= class_name %>::ToolsMethods
-  # You can override tool methods here
+  # You can override tool methods here or add your own, this module is included by default into
+  # models having behaviour <%= class_name %>
 end 

data/lib/generators/patriarch/templates/undo_service-tripartite.rb

@@ -0,0 +1,5 @@
+class Patriarch::Services::<%= class_name %>::Service < Patriarch::Service
+  def call(transaction_item)
+    Patriarch::DAOServices::TripartiteRelationshipBuilderService.instance.destroy(transaction_item)
+  end 
+end

data/lib/patriarch/behaviours.rb

@@ -8,7 +8,7 @@ module Patriarch
 
     class << self
 
-      def complete_custom_active_module(module_to_complete,relation_type,acted_on_model_list)
+      def complete_custom_active_module_bipartite(module_to_complete,relation_type,acted_on_model_list)
         module_to_complete.class_eval do
 
           acted_on_model_list.each do |acted_on_model|
@@ -33,7 +33,7 @@ module Patriarch
         end
       end
 
-      def complete_custom_passive_module(module_to_complete,relation_type,targetted_by_model_list)
+      def complete_custom_passive_module_bipartite(module_to_complete,relation_type,targetted_by_model_list)
         module_to_complete.class_eval do
 
           targetted_by_model_list.each do |targetted_by_model|
@@ -54,15 +54,80 @@ module Patriarch
             define_method(raw_tool_method_name) do |options={}|
               Patriarch::ToolServices::RedisExtractorService.instance.get_ids_from_sorted_set(self,redis_key,options)              
             end
-          
+
           end
+
         end
       end      
 
+
+      def complete_custom_active_module_tripartite(module_to_complete,relation_type,acted_on_model_list,via_model_list)
+        module_to_complete.class_eval do
+
+          acted_on_model_list.each do |acted_on_model|
+            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
+
+              # 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={}|
+                Patriarch::ToolServices::RedisExtractorService.instance.
+                  get_models_from_ids(self,acted_on_model.to_s.classify.constantize,raw_tool_method_name,options.merge({:tripartite => true}))
+              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 ...
+              end
+
+            end
+          end
+
+        end        
+      end
+
+      def complete_custom_passive_module_tripartite(module_to_complete,relation_type,targetted_by_model_list,via_model_list)
+        module_to_complete.class_eval do
+
+          targetted_by_model_list.each do |targetted_by_model|
+            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={}|
+                Patriarch::ToolServices::RedisExtractorService.instance.
+                  get_models_from_ids(self,targetted_by_model.to_s.classify.constantize,raw_tool_method_name,options.merge({:tripartite => true}))
+              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 ...
+              end
+            end
+          end
+
+        end
+      end       
+
       def included(klass)
         klass.extend ClassMethods
         klass.extend ActiveModel::Callbacks
         class << klass;
+          # not sure if should add an alias like behaviours here
+          # might override other behaviour methods from other namespaces
+          # but patriarch is damn heavy here
           attr_accessor :patriarch_behaviours
         end
       end
@@ -71,17 +136,97 @@ module Patriarch
     module ClassMethods
 
       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_tripartite_behaviour(behaviour,options)
+        behaviour = behaviour.to_s.underscore
+
+        # 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)"
+        end        
+
+        if options[:via]
+          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        
+        else
+          medium_between_option = options[:medium_between]
+          unless medium_between_option.is_a?(Array) && medium_between_option.size == 2
+            raise AddBehaviourSyntaxError, "syntax with medium medium_between requires that you provide an array of two symbols/strings"
+          end
+        end
+
+
+        methods_mod = Module.new do; end
+        methods_mod.const_set(:Behaviour,behaviour)
+
+        # 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 
+
+              # 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
+
+              # 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
+            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)            
+            #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)
+          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
+
+      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.downcase
+        behaviour = behaviour.to_s.underscore
 
-        # Ou exclusif sur les options on et by
+        # 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
 
-        methods_mod = Module.new do;
-        end
+        methods_mod = Module.new do; end
         methods_mod.const_set(:Behaviour,behaviour)
 
         if options[:on] 
@@ -98,17 +243,19 @@ module Patriarch
             # 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)   
+                "Patriarch::Services::#{methods_mod.const_get(:Behaviour).classify}::ManagerService".constantize.instance.resolve(self,entity,options)   
               end
             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)   
+                "Patriarch::Services::#{(Patriarch.undo(methods_mod.const_get(:Behaviour))).classify}::ManagerService".constantize.instance.resolve(self,entity,options)   
               end
             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
@@ -129,10 +276,10 @@ module Patriarch
 
         if options[:on] 
           acted_on_model_list = Array(options[:on])
-          Patriarch::Behaviours.complete_custom_active_module(methods_mod,behaviour,acted_on_model_list)
+          Patriarch::Behaviours.complete_custom_active_module_bipartite(methods_mod,behaviour,acted_on_model_list)
         else
           targetted_by_model_list = Array(options[:by])          
-          Patriarch::Behaviours.complete_custom_passive_module(methods_mod,behaviour,targetted_by_model_list)
+          Patriarch::Behaviours.complete_custom_passive_module_bipartite(methods_mod,behaviour,targetted_by_model_list)
         end
 
         # Finally ...
@@ -141,8 +288,18 @@ module Patriarch
         self.send(:include,"Patriarch::Behaviours::#{behaviour.classify}::ToolsMethods".constantize)
 
         # register the behaviour we just added
-        self.patriarch_behaviours ||= []
-        self.patriarch_behaviours = self.patriarch_behaviours << behaviour.to_sym
+        # TODO disjonction bi/tripart
+        self.patriarch_behaviours ||= { }
+        self.patriarch_behaviours[behaviour.underscore.to_sym] ||= { :on => [], :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
     end