patriarch 0.0.1 → 0.0.2

data/lib/generators/patriarch/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Explain the generator
+
+Example:
+    rails generate judge Thing
+
+    This will create:
+        what/will/it/create

data/lib/generators/patriarch/patriarch_generator.rb

@@ -0,0 +1,69 @@
+class PatriarchGenerator < 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
+
+  public
+  def init_directories
+    empty_directory "lib/patriarch/services/#{behaviour.underscore.downcase}"
+    empty_directory "lib/patriarch/services/#{undo(behaviour.underscore.downcase)}"
+    template "empty_behaviour_module.rb", "lib/patriarch/services/#{behaviour.underscore.downcase}.rb"   
+    template "tools_methods.rb", "lib/patriarch/behaviours/#{behaviour.underscore.downcase}/tools_methods.rb"
+  end
+
+  def generate_services
+    create_services(behaviour)
+    # implémenter un switch ici, plus zoli ...
+    self.class.send(:define_method,:class_name) do
+      undo(behaviour).classify
+    end
+    create_undo_services(behaviour)
+  end
+
+  private
+    def class_name
+      behaviour.classify
+    end
+
+    def create_services(behaviour)
+      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"
+
+      template "manager_service.rb", "lib/patriarch/services/#{behaviour_str}/manager_service.rb"
+                
+      template "service.rb", "lib/patriarch/services/#{behaviour_str}/service.rb"    
+
+
+      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)
+      undo_behaviour_str = 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"
+
+      template "manager_service.rb", "lib/patriarch/services/#{undo_behaviour_str}/manager_service.rb"
+                
+      template "undo_service.rb", "lib/patriarch/services/#{undo_behaviour_str}/service.rb"    
+
+      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
+
+
+    def undo(str)
+      undo = "undo_" 
+      undo << str
+      undo 
+    end
+
+end

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

@@ -0,0 +1,6 @@
+class Patriarch::Services::<%= class_name %>::AfterManagerService < Patriarch::ManagerService 
+  def resolve(transac)
+    # Manages what happens after the service call
+    Patriarch::Services::<%= class_name %>::AfterService.instance.call(transac) if true
+  end
+end

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

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

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

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

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

@@ -0,0 +1,6 @@
+class Patriarch::Services::<%= class_name %>::BeforeManagerService < Patriarch::ManagerService 
+  def resolve(transac)
+    # Manages what happens after the service call
+    Patriarch::Services::<%= class_name %>::BeforeService.instance.call(transac) if true
+  end
+end

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

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

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

@@ -0,0 +1,2 @@
+module Patriarch::Services::<%= class_name %>
+end

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

@@ -0,0 +1,29 @@
+class Patriarch::Services::<%= class_name %>::ManagerService < Patriarch::ManagerService
+  # Return true or false
+  def resolve(actor, target, transac = nil)
+    
+    # On plante le "drapeau" transac_first_step pour signifier le début
+    if 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.add_step(:<%= class_name.underscore.to_sym %>,actor,target)          
+
+    callbacks_were_completed = false
+
+    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
+
+    # Si tout s'est bien passé et que les callbacks ont été exécutés
+    transac.execute if (transac_first_step && callbacks_were_completed)
+  end
+end

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

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

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

@@ -0,0 +1,3 @@
+module Patriarch::Behaviours::<%= class_name %>::ToolsMethods
+  # You can override tool methods here
+end 

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

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

data/lib/patriarch/authorization_service.rb

@@ -0,0 +1,10 @@
+require 'singleton'
+
+class Patriarch::AuthorizationService
+  include Singleton
+
+  # override if necessary
+  def grant?(*args)
+    true
+  end
+end

data/lib/patriarch/behaviours.rb

@@ -0,0 +1,160 @@
+#require 'patriarch/behaviours/own'
+#require 'patriarch/behaviours/subscribe'
+#require 'patriarch/behaviours/tagging'
+#require 'patriarch/behaviours/join'
+
+module Patriarch
+  module Behaviours
+
+    class AddBehaviourSyntaxError < Exception ; end
+
+    class << self
+
+      def complete_custom_active_module(module_to_complete,relation_type,acted_on_model_list)
+        module_to_complete.class_eval do
+
+          acted_on_model_list.each do |acted_on_model|
+
+            # Compute names based on conventions
+            classic_tool_method_name = "#{acted_on_model.to_s.tableize}_i_#{relation_type.to_s}"
+            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)
+            end
+
+            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_passive_module(module_to_complete,relation_type,targetted_by_model_list)
+        module_to_complete.class_eval do
+
+          targetted_by_model_list.each do |targetted_by_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"
+            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)
+            end
+
+            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 undo(str)
+        undo = "undo_" 
+        undo << str
+        undo 
+      end
+
+      def included(klass)
+        klass.extend ClassMethods
+        klass.extend ActiveModel::Callbacks
+        class << klass;
+          attr_accessor :patriarch_behaviours
+        end
+      end
+    end
+
+    module ClassMethods
+      def add_behaviours(*behaviours)
+      end
+
+      def add_behaviour(behaviour,options)
+        # add_behaviour :like, :by => bla,  :on => [:item,:user] || :community, :as => :aimer, :reverse_as => :haïr ...
+        
+        behaviour = behaviour.to_s.downcase
+
+        # Ou exclusif sur les options on et by
+        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.const_set(:Behaviour,behaviour)
+
+        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::Behaviours.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)   
+              end
+            end
+
+            # undo_like
+            define_method(Patriarch::Behaviours.undo(methods_mod.const_get(:Behaviour)).to_sym) do |entity,options={}|
+              run_callbacks Patriarch::Behaviours.undo(methods_mod.const_get(:Behaviour)).to_sym do
+                "Patriarch::Services::#{(Patriarch::Behaviours.undo(methods_mod.const_get(:Behaviour))).classify}::ManagerService".constantize.instance.resolve(self,entity)   
+              end
+            end
+
+            # 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
+          end
+        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
+
+        if options[:on] 
+          acted_on_model_list = Array(options[:on])
+          Patriarch::Behaviours.complete_custom_active_module(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)
+        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)
+
+        # register the behaviour we just added
+        self.patriarch_behaviours ||= []
+        self.patriarch_behaviours = self.patriarch_behaviours << behaviour.to_sym
+      end
+    end
+
+  end # Behaviours
+end # Patriarch

data/lib/patriarch/dao_services/bipartite_relationship_builder_service.rb

@@ -0,0 +1,43 @@
+class Patriarch::DAOServices::BipartiteRelationshipBuilderService < Patriarch::Service
+  def create(transaction_item)
+    # t => changer nom pour différencier de la date créée pour le Patriarch::Transaction 
+    t = Time.now.to_f
+    dao_tab = Patriarch::DAOServices::RetrieverService.instance.call(transaction_item)
+    
+    # Go hash plz
+    actor_dao = dao_tab[:actor]
+    target_dao = dao_tab[:target]
+
+    l   = build_lambda_for_create(actor_dao,transaction_item.target_id,t)
+    ll   = build_lambda_for_create(target_dao,transaction_item.actor_id,t)
+ 
+    # 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
+
+  def destroy(transaction_item)
+    dao_tab = Patriarch::DAOServices::RetrieverService.instance.call(transaction_item)
+    
+    # Go hash plz
+    actor_dao = dao_tab[:actor]
+    target_dao = dao_tab[:target]
+    
+    l   = lambda { actor_dao.delete transaction_item.target_id }
+    ll  = lambda { target_dao.delete 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
+
+  protected
+
+  def build_lambda_for_create(dao,id,time)
+    if dao.is_a? Redis::SortedSet
+      return lambda { dao.add id, time }
+    else
+      return lambda { dao.add id }
+    end
+  end
+end

data/lib/patriarch/dao_services/redis_mapper_service.rb

@@ -0,0 +1,41 @@
+class Patriarch::DAOServices::RedisMapperService < Patriarch::Service
+  def call(transac,protagonist_type)
+    
+    # Getting symbols here ...
+    relation_type     = transac.relation_type
+    actor_type        = transac.actor_type
+    target_type       = transac.target_type
+  
+    relation_type_str = sanitize_relation_type(relation_type.to_s)
+
+    if protagonist_type == :actor
+      redis_config_for_actor_on(target_type,relation_type_str)
+    else
+      redis_config_for_target_by(actor_type,relation_type_str)
+    end
+  end
+
+
+  def redis_config_for_actor_on(model_name,relation_type_str)
+    # example : items_i_like ...    
+    { 
+      :type => "sorted_set", :key => "patriarch_#{model_name.to_s.tableize}_i_#{relation_type_str}"
+    }
+  end
+
+  def redis_config_for_target_by(model_name,relation_type_str)
+    # example : items_liking_me ...
+    { 
+      :type => "sorted_set", :key => "patriarch_#{model_name.to_s.tableize}_#{progressive_present(relation_type_str)}_me"
+    }
+  end  
+
+  def progressive_present(behaviour_verb)
+    # like becomes => liking
+    (Verbs::Conjugator.conjugate behaviour_verb.to_sym, :aspect => :progressive).split(/ /).last
+  end
+
+  def sanitize_relation_type(relation_type)
+    relation_type.sub(/^undo_/,'')
+  end
+end

data/lib/patriarch/dao_services/retriever_service.rb

@@ -0,0 +1,51 @@
+class InvalidRedisTypeException < Exception
+end
+
+class Patriarch::DAOServices::RetrieverService < Patriarch::Service
+  # go hash
+  def call(transaction_item)     
+    result = {}
+      result[:actor]  = instantiate_DAO_for_actor(transaction_item)
+      result[:target] = instantiate_DAO_for_target(transaction_item)
+    result  
+  end
+
+  protected
+
+  def get_DAO_info_for_actor(transaction_item)
+    Patriarch::DAOServices::RedisMapperService.instance.call(transaction_item,:actor)
+  end
+
+  def get_DAO_info_for_target(transaction_item)
+    Patriarch::DAOServices::RedisMapperService.instance.call(transaction_item,:target)
+  end
+
+  def instantiate_DAO_for_actor(transaction_item)
+    dao_info = get_DAO_info_for_actor(transaction_item) 
+    actor_id = transaction_item.actor_id
+    actor_type = transaction_item.actor_type
+    
+    if Redis.constants.map(&:to_s).include?("#{dao_info[:type].camelize}")
+      redis_dao_class = "Redis::#{dao_info[:type].camelize}".constantize
+    else
+      raise InvalidRedisTypeException
+    end
+
+    redis_dao_class.new("#{actor_type}:#{actor_id}:#{dao_info[:key]}")
+  end
+  
+
+  def instantiate_DAO_for_target(transaction_item)
+    dao_info = get_DAO_info_for_target(transaction_item)
+    target_id = transaction_item.target_id
+    target_type = transaction_item.target_type  
+
+    if Redis.constants.map(&:to_s).include?("#{dao_info[:type].camelize}")
+      redis_dao_class = "Redis::#{dao_info[:type].camelize}".constantize
+    else
+      raise InvalidRedisTypeException
+    end
+    redis_dao_class.new("#{target_type}:#{target_id}:#{dao_info[:key]}")    
+  end
+end
+

data/lib/patriarch/manager_service.rb

@@ -0,0 +1,15 @@
+require 'singleton'
+
+# Interface avec les couches les plus hautes
+class Patriarch::ManagerService
+  include Singleton
+
+  # /!\ Changer l'architecture ici, l'idée est là
+  #def resolve(*args, options={})
+    # Traitement des options
+    # ...
+
+    # Traitement normal
+  #  after_resolve(*args)
+  #end
+end

data/lib/patriarch/service.rb

@@ -0,0 +1,5 @@
+require 'singleton'
+
+class Judge::Service
+  include Singleton 
+end

data/lib/patriarch/tool_services/redis_cleaner.rb

@@ -0,0 +1,47 @@
+class Patriarch::ToolServices::RedisExtractorService < Patriarch::Service
+  def clean_reclip_id(reclip_id)
+    # Go get the hash of this reclip to clean depencies
+    reclip_hash = Redis::HashKey.new("reclip:#{reclip_id}")
+
+    # Clean dependencies on the recliped_on entity, the recliper entity and the reclipped item
+
+    recliped_on_sorted_set =     Redis::SortedSet.new("#{reclip_hash['recliped_on_type'].downcase}:#{reclip_hash['recliped_on_id']}:redis_reclipeds_on_me")
+    recliper_sorted_set    =     Redis::SortedSet.new("#{reclip_hash['recliper_type'].downcase}:#{reclip_hash['recliper_id']}:redis_reclipeds_by_me")
+    item_reclip_ids_sorted_set = Redis::SortedSet.new("item:#{reclip_hash['recliped_item_id']}:redis_reclips_of_me")
+
+    $redis.multi do 
+      recliped_on_sorted_set.delete reclip_id              # recliped_on is cleaned
+      recliper_sorted_set.delete reclip_id                 # recliper is cleaned
+      reclip_hash.del                                      # hash is deleted properly
+      item_reclip_ids_sorted_set.delete reclip_id                     # item_key is cleaned from this reclip_id
+    end
+  end
+
+  def clean_reclip_for_item_before_delete(item)
+    item_reclip_ids = Redis::SortedSet.new("item:#{item.id}:redis_reclips_of_me")
+
+    # For each reclip involving our item
+    item_reclip_ids.members.each do |reclip_id|
+      clean_reclip_id(reclip_id)
+    end          
+  end
+
+  def clean_reclip_for_group_before_delete(group)
+    # Goal here is to clean reclipeds_on_me dependencies and reclipeds_by_me before the group dies
+
+    # reclipeds_on_me
+    reclipeds_on_me_sorted_set = group.redis_reclipeds_on_me
+
+    reclipeds_on_me_sorted_set.members.each do |reclip_id|
+      clean_reclip_id(reclip_id)
+    end
+
+
+    # reclipeds_by_me
+    reclipeds_by_me_sorted_set = group.redis_reclipeds_by_me
+    
+    reclipeds_by_me_sorted_set.members.each do |reclip_id|
+      clean_reclip_id(reclip_id)
+    end
+  end
+end  

data/lib/patriarch/tool_services/redis_extractor_service.rb

@@ -0,0 +1,37 @@
+class Patriarch::ToolServices::RedisExtractorService < Patriarch::Service
+  def get_ids_from_sorted_set(calling_entity,redis_key,options={})
+    from = options[:from] || 0
+    limit = options[:limit] || :infinity
+    
+    if limit == :infinity
+      to = -1
+    else  
+      to = from + limit -1
+    end 
+
+    dao = Redis::SortedSet.new("#{calling_entity.class.name.downcase}:#{calling_entity.id}:#{redis_key}")
+
+    if options[:with_scores] 
+      # Do not use this anymore, go take the right redis objects not using this kind of methods ...
+      # DEGOLASSE
+      Redis::SortedSet.new
+      ids_with_scores_from_redis = dao.revrange(from,to,:with_scores => true) || []
+      ids_with_scores_from_redis.map{ |id,score| [id.to_i,score] } 
+    else
+      ids_from_redis = dao.revrange(from,to) || []
+      ids_from_redis.map &:to_i
+    end
+  end 
+
+  def get_models_from_ids(calling_entity,model,get_id_method,options={})        
+    if options[:with_scores] 
+      ids_with_scores_from_redis = calling_entity.send(get_id_method,options)
+      ids_with_scores_from_redis.map! do |id,score|
+        [model.find(id),score]
+      end
+    else
+      ids_from_redis = calling_entity.send(get_id_method,options)
+      model.find(ids_from_redis)
+    end
+  end
+end      

data/lib/patriarch/transaction.rb

@@ -0,0 +1,68 @@
+class Patriarch::Transaction
+  attr_reader  :id, :steps, :current_step_number
+  attr_reader  :type
+
+  forwarded_methods_syms =  [:relation_type,:actor_type,:target_type,:actor_id,:target_id,
+                             :context,:actor,:target]
+
+  # Forward methods that are not this transaction's job to step object
+  forwarded_methods_syms.each do |method_sym|
+    define_method(method_sym) do
+      current_step.send(method_sym)
+    end
+  end
+
+
+  # id => go $redis.incr
+  def initialize(type,id) #relation_type,actor,target,
+    @type = type 
+    @id = id 
+    @steps = []
+    @current_step_number = 0
+  end
+
+  # Initializes a new step and stores it in the steps array right away
+  # A step matches a "like", "follow", "own", etc.
+  # Register that we went a step further into the transaction processus
+  # Medium is nil by default (bipartite transactions does not require more than target/actor)
+  def add_step(relation_type,actor,target,medium=nil)
+    # Initializes a new step and stores it in the steps array right away
+    new_step = Patriarch::TransactionStep.new(relation_type,actor,target,medium)
+    
+    # if initilization failed we should not move forward ...
+    raise PatriarchTransactionStepInstanciationException unless new_step
+
+    # Register that we went a step further into the transaction processus
+    @steps << new_step 
+    @current_step_number += 1
+  end
+
+  # Executes the calls to redis in one block here.
+  def execute
+    $redis.multi do
+      steps.each do |step|
+        step.execute
+      end
+    end
+  end
+
+  def transaction_queue
+    transaction_queue = []
+    steps.each do |step|
+      transaction_queue.concat(step.queue)
+    end
+    transaction_queue
+  end
+
+  def add_to_queue(proc)
+    current_step.add_to_queue(proc)
+  end
+
+  alias :queue :transaction_queue
+
+  protected
+
+  def current_step
+    steps[current_step_number-1]
+  end
+end

data/lib/patriarch/transaction_services/transaction_manager_service.rb

@@ -0,0 +1,13 @@
+require 'singleton'
+
+class PatriarchTransactionStepInstanciationException < Exception
+end
+
+class Patriarch::TransactionServices::TransactionManagerService < Patriarch::ManagerService
+  # Fill with logic to manage ressources with transactions ...
+  # Can registers transactions and so on ...
+  def new_transaction(type)
+    id = Time.now.to_f
+    Patriarch::Transaction.new(type,id)
+  end
+end

data/lib/patriarch/transaction_step.rb

@@ -0,0 +1,39 @@
+class Patriarch::TransactionStep
+  attr_accessor :context, :queue
+
+  def initialize(relation_type,actor,target,medium)
+    @context = { 
+      :relation_type  => relation_type,
+      :actor_type     => actor.class.name.underscore.to_sym,
+      :target_type    => target.class.name.underscore.to_sym,
+      :actor_id       => actor.id,
+      :target_id      => target.id,
+    }
+    @queue = []
+  end
+
+  # defines access methods to context fields letting it be encapsulated nicely
+  [:relation_type,:actor_type,:target_type,:actor_id,:target_id].each do |context_key|
+    define_method(context_key) do
+      context[context_key]
+    end
+  end
+
+  def actor
+    actor_type.to_s.camelize.constantize.find actor_id
+  end
+
+  def target
+    target_type.to_s.camelize.constantize.find target_id
+  end
+
+  def execute
+    queue.each do |redis_instruction|
+      redis_instruction.call
+    end
+  end
+
+  def add_to_queue(proc)
+    queue << proc
+  end
+end

data/lib/patriarch/version.rb

@@ -1,3 +1,3 @@
 module Patriarch
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/patriarch.gemspec

@@ -6,12 +6,15 @@ Gem::Specification.new do |spec|
   spec.email         = ["hugo@blackbid.co"]
   spec.description   = %q{Patriach is about adding behaviours on the fly to good old active record models.}
   spec.summary       = %q{Manage relationships between instances of your models easily}
-  spec.homepage      = "https://github.com/blackbirdco"
+  spec.homepage      = "https://github.com/giglemad/patriarch"
 	
 	spec.platform      = Gem::Platform::RUBY
 	spec.licenses 		 = ['MIT']
+	
+	spec.add_development_dependency "rspec"
+	spec.add_runtime_dependency     "redis-objects"
 
-  spec.files         = `git ls-files`.split($\)
+	spec.files         = `git ls-files`.split($\)
   spec.executables   = spec.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.name          = "patriarch"

data/spec/lib/patriarch/add_behaviour_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+
+describe Patriarch::Behaviours do
+  
+  # setup with empty fake klasses here
+  
+  class ModelClass; 
+    include Patriarch::Behaviours
+  end
+  
+  class ModelKlass; 
+   include Patriarch::Behaviours
+  end
+
+  ModelClass.add_behaviour :like, :on => [:modelKlass]
+  ModelKlass.add_behaviour :like, :by => [:modelClass]
+
+
+  context "when adding a behaviour" do
+    it "should implement basic tool methods" do
+      progressive_like = (Verbs::Conjugator.conjugate :like, :aspect => :progressive).split(/ /).last
+      ModelClass.new.should respond_to("#{"model_klass".pluralize}_i_like")
+      ModelClass.new.should respond_to("#{"model_klass".pluralize}_i_like_ids")
+      ModelKlass.new.should respond_to("#{"model_class".pluralize}_#{progressive_like}_me")
+      ModelKlass.new.should respond_to("#{"model_class".pluralize}_#{progressive_like}_me_ids")
+    end
+
+    it "should implement actions only on model being added behaviours with ':on' options" do
+      mc = ModelClass.new
+      mk = ModelKlass.new
+      mc.should respond_to(:like)
+      mc.should respond_to(:undo_like)
+      mk.should_not respond_to(:like)
+      mk.should_not respond_to(:undo_like)
+    end
+  end
+
+  context "when using an added behaviour" do
+    User.add_behaviour :smoke, :on => [:User]
+    User.add_behaviour :smoke, :by => [:User]
+
+    before(:all) do
+      @userA = create_user
+      @userB = create_user
+      @userA.smoke @userB         
+    end
+
+    it "shall play the transaction nicely" do 
+      @userA.users_i_smoke.should == [@userB]
+      @userB.users_smoking_me.should == [@userA]
+      
+      @userA.users_i_smoke_ids.should == [@userB.id]
+      @userB.users_smoking_me_ids.should == [@userA.id]
+    end
+
+    it "shall play reverse transaction nicely" do
+      @userA.undo_smoke @userB
+      @userA.users_i_smoke.include?(@userB).should be_false
+      @userB.users_smoking_me.include?(@userA).should be_false
+
+      
+      
+     # @userA.users_i_smoke_ids.should be_empty
+      #@userB.users_smoking_me_ids.should be_empty
+    end
+
+    after(:all) do
+      @userA.undo_smoke @userB   
+    end 
+  end
+end

data/spec/lib/patriarch/bipartite_relationship_builder_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Patriarch::DAOServices::BipartiteRelationshipBuilderService do
+  before(:each) do
+    @instance = Patriarch::DAOServices::BipartiteRelationshipBuilderService.instance
+    @user = create_user
+    @item = create_item(@user)
+    @transac ||= Patriarch::TransactionServices::TransactionManagerService.instance.new_transaction(:like)
+    @transac.add_step(:like,@user,@item)
+  end
+
+  it "shall insert processable lambdas into queues when create is called" do
+    # Stubs the DAO retriever service so it gives DAO arrays back
+    dao_sample = { 
+      :actor => Redis::SortedSet.new("user:1:redis_likes"), 
+      :target => Redis::Set.new("item:1:redis_liker_users")
+    }
+    Patriarch::DAOServices::RetrieverService.instance.stub(:call).with(any_args()).and_return(dao_sample)
+    
+    expect{
+      @instance.create(@transac)
+    }.to change{ @transac.transaction_queue.select{ |queue_element| queue_element.is_a? Proc}.size }.by(2)
+  
+    expect{
+      @transac.transaction_queue.each{ |proc| proc.call }
+    }.to change{ $redis.keys.size}.by(2)
+  end
+
+  it "shall insert processable lambdas into queues when destroy is called" do
+    # Stubs the DAO retriever service so it gives DAO arrays back
+    dao_sample = { 
+      :actor => Redis::SortedSet.new("user:1:redis_likes"), 
+      :target => Redis::Set.new("item:1:redis_liker_users")
+    }
+    Patriarch::DAOServices::RetrieverService.instance.stub(:call).with(any_args()).and_return(dao_sample)
+    
+
+    expect{
+      @instance.destroy(@transac)
+    }.to change{ @transac.transaction_queue.select{ |queue_element| queue_element.is_a? Proc}.size }.by(2)
+
+    expect{
+      @transac.transaction_queue.each{ |proc| proc.call }
+    }.to change{ $redis.info["total_commands_processed"].to_i}.by(3)
+  end
+
+  after(:each) do
+    $redis.del "user:#{@user.id}:redis_likes"
+    $redis.del "item:#{@item.id}:redis_liker_users"
+  end
+end

data/spec/lib/patriarch/clean_reclip_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe "reclip cleaner" do
+  before (:each) do
+    @recliper_user = create_user
+    @item = create_item(create_user)
+    @recliped_on_user = create_user
+    @recliper_user.reclip(@item,@recliped_on_user)
+    @reclip_id = @item.reclips_of_me_reclips_ids.first
+  end
+
+  it "shall clean reclips everywhere when given a single item" do
+    Patriarch::Behaviours::Reclip.clean_reclip_id(@reclip_id)
+
+    @recliped_on_user.reclipeds_on_me_reclips_ids.include?(@reclip_id).should be_false
+    @recliper_user.reclipeds_by_me_reclips_ids.include?(@reclip_id).should be_false
+    @item.reclips_of_me_reclips_ids.include?(@reclip_id).should be_false
+  end
+
+  it "shall clean all the reclip stuff (on him, by him) of a given user properly" do
+    pending('like the test above but in the adequate loop')
+  end
+
+  it "shall clean all the reclip stuff (on him, by him) of a given group properly" do
+    pending('like the test above but in the adequate loop')
+  end
+
+  it "shall clean all the reclip stuff of a given item properly" do
+    pending('like the test above but in the adequate loop')
+  end
+end

data/spec/lib/patriarch/like_service_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Patriarch::Services do
+  before (:each) do
+    @user = create_user
+    @item = create_item(@user)
+  end
+
+  context "LikeService" do
+    it "should register like informations properly" do
+      # Wrong way of doing tests, test should not know about what's inside ...
+      Patriarch::Services::Like::ManagerService.instance.resolve(@user,@item)
+      Redis::SortedSet.new("user:#{@user.id}:redis_likes").members.include?(@item.id.to_s).should be_true
+      Redis::SortedSet.new("item:#{@item.id}:redis_liker_users").members.include?(@user.id.to_s).should be_true    
+    end
+  end
+
+end

data/spec/lib/patriarch/reclip_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe "reclip" do
+  before (:each) do
+    @recliper_user = create_user
+    @item = create_item(create_user)
+    @recliped_on_user = create_user
+  end
+
+  it "stores informations in redis properly" do
+    @recliper_user.reclip(@item,@recliped_on_user)
+    
+    # Guy being recliped on remembers it
+    @recliped_on_user.reclipeds_on_me.should == [@item]
+    # Recliper remembers the reclip it did
+    @recliper_user.reclipeds_by_me.should == [@item]
+    
+    # Item    
+    @recliper_user.reclipeds_by_me.should have(1).reclip_hash
+  end
+
+  it "only updates information when clipped twice" do 
+    @recliper_user.reclip(@item,@recliped_on_user)
+    old_time = @recliper_user.reclipeds_by_me(:with_scores => true).first[1]
+    @recliper_user.reclip(@item,@recliped_on_user)
+    new_time = @recliper_user.reclipeds_by_me(:with_scores => true).first[1]
+
+    new_time.should_not eq(old_time)
+
+    # Guy being recliped on remembers it
+    @recliped_on_user.reclipeds_on_me.should == [@item]
+    # Recliper remembers the reclip it did
+    @recliper_user.reclipeds_by_me.should == [@item]
+    
+    # Item    
+    @recliper_user.reclipeds_by_me.should have(1).reclip_hash    
+  end
+
+end

data/spec/lib/patriarch/redis_mapper_service_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Patriarch::DAOServices::RedisMapperService do
+  before(:each) do
+    @instance = Patriarch::DAOServices::RedisMapperService.instance
+    @context = {:relation_type => :like, :actor_type => :user, :target_type => :item, 
+    :actor_id => 1, :target_id => 1}
+    @transaction_item = double()
+    @transaction_item.stub(:context).and_return(@context)
+  end
+
+  it "shall retrieve right DAO information" do
+    @instance.call(@transaction_item,:actor).should eq({:type => "sorted_set", :key => "redis_likes"})
+    @instance.call(@transaction_item,:target).should eq({:type => "sorted_set", :key => "redis_liker_users"})
+  end
+end
+
+
+    
+    

data/spec/lib/patriarch/retriever_service_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Patriarch::DAOServices::RetrieverService do
+  before(:each) do
+    @instance = Patriarch::DAOServices::RetrieverService.instance
+    @context = {:relation_type => :like, :actor_type => :user, :target_type => :item, 
+    :actor_id => 1, :target_id => 1}
+    @transaction_item = double()
+    @transaction_item.stub(:actor_id).and_return(@context[:actor_id])
+    @transaction_item.stub(:actor_type).and_return(@context[:actor_type])
+    @transaction_item.stub(:target_type).and_return(@context[:target_type])
+    @transaction_item.stub(:target_id).and_return(@context[:target_id])        
+  end
+
+  it "shall return nice Redis::Object instances" do
+    Patriarch::DAOServices::RedisMapperService.instance.should_receive(:call).twice.with(any_args()).and_return({:type => "sorted_set", :key =>"abc"})
+    dao_tab = @instance.call(@transaction_item)
+
+    dao_tab[:actor].key.should == "user:1:abc"
+    dao_tab[:actor].is_a?(Redis::SortedSet).should be_true
+
+    dao_tab[:target].key.should == "item:1:abc"
+    dao_tab[:target].is_a?(Redis::SortedSet).should be_true
+  end
+
+
+  it "shall reject types that are not suited" do
+    Patriarch::DAOServices::RedisMapperService.instance.should_receive(:call).with(any_args()).and_return({:type => "sorted", :key =>"abc"})
+    expect{
+      @instance.call(@transaction_item)
+    }.to raise_error(InvalidRedisTypeException)
+  end  
+end
+
+
+    
+    

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: patriarch
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,29 @@ autorequire:
 bindir: bin
 cert_chain: []
 date: 2012-11-25 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &23131200 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *23131200
+- !ruby/object:Gem::Dependency
+  name: redis-objects
+  requirement: &23130660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *23130660
 description: Patriach is about adding behaviours on the fly to good old active record
   models.
 email:
@@ -24,10 +46,42 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- lib/generators/patriarch/USAGE
+- lib/generators/patriarch/patriarch_generator.rb
+- lib/generators/patriarch/templates/after_manager_service.rb
+- lib/generators/patriarch/templates/after_service.rb
+- lib/generators/patriarch/templates/authorization_service.rb
+- lib/generators/patriarch/templates/before_manager_service.rb
+- lib/generators/patriarch/templates/before_service.rb
+- lib/generators/patriarch/templates/empty_behaviour_module.rb
+- lib/generators/patriarch/templates/manager_service.rb
+- lib/generators/patriarch/templates/service.rb
+- lib/generators/patriarch/templates/tools_methods.rb
+- lib/generators/patriarch/templates/undo_service.rb
 - lib/patriarch.rb
+- lib/patriarch/authorization_service.rb
+- lib/patriarch/behaviours.rb
+- lib/patriarch/dao_services/.DAOinstancier.rb.swp
+- lib/patriarch/dao_services/bipartite_relationship_builder_service.rb
+- lib/patriarch/dao_services/redis_mapper_service.rb
+- lib/patriarch/dao_services/retriever_service.rb
+- lib/patriarch/manager_service.rb
+- lib/patriarch/service.rb
+- lib/patriarch/tool_services/redis_cleaner.rb
+- lib/patriarch/tool_services/redis_extractor_service.rb
+- lib/patriarch/transaction.rb
+- lib/patriarch/transaction_services/transaction_manager_service.rb
+- lib/patriarch/transaction_step.rb
 - lib/patriarch/version.rb
 - patriarch.gemspec
-homepage: https://github.com/blackbirdco
+- spec/lib/patriarch/add_behaviour_spec.rb
+- spec/lib/patriarch/bipartite_relationship_builder_spec.rb
+- spec/lib/patriarch/clean_reclip_spec.rb
+- spec/lib/patriarch/like_service_spec.rb
+- spec/lib/patriarch/reclip_spec.rb
+- spec/lib/patriarch/redis_mapper_service_spec.rb
+- spec/lib/patriarch/retriever_service_spec.rb
+homepage: https://github.com/giglemad/patriarch
 licenses:
 - MIT
 post_install_message: 
@@ -52,4 +106,11 @@ rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Manage relationships between instances of your models easily
-test_files: []
+test_files:
+- spec/lib/patriarch/add_behaviour_spec.rb
+- spec/lib/patriarch/bipartite_relationship_builder_spec.rb
+- spec/lib/patriarch/clean_reclip_spec.rb
+- spec/lib/patriarch/like_service_spec.rb
+- spec/lib/patriarch/reclip_spec.rb
+- spec/lib/patriarch/redis_mapper_service_spec.rb
+- spec/lib/patriarch/retriever_service_spec.rb