patriarch 0.0.4 → 0.1.0

data/lib/patriarch/dao_services/bipartite_relationship_builder_service.rb

@@ -2,11 +2,9 @@ require "redis/objects/sorted_sets"
 
 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]
 
@@ -21,14 +19,12 @@ class Patriarch::DAOServices::BipartiteRelationshipBuilderService < Patriarch::S
   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

data/lib/patriarch/dao_services/redis_mapper_service.rb

@@ -5,31 +5,68 @@ class Patriarch::DAOServices::RedisMapperService < Patriarch::Service
     relation_type     = transac.relation_type
     actor_type        = transac.actor_type
     target_type       = transac.target_type
+    medium_type       = transac.medium_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)
+    if transac.tripartite?
+      if protagonist_type == :actor
+        redis_tripartite_config_for_actor(target_type,medium_type,relation_type_str)
+      elsif protagonist_type == :target
+        redis_tripartite_config_for_target(actor_type,medium_type,relation_type_str)
+      elsif protagonist_type == :medium
+       redis_tripartite_config_for_medium(actor_type,target_type,relation_type_str)
+      end 
     else
-      redis_config_for_target_by(actor_type,relation_type_str)
+      if protagonist_type == :actor
+        redis_bipartite_config_for_actor(target_type,relation_type_str)
+      elsif protagonist_type == :target
+        redis_bipartite_config_for_target(actor_type,relation_type_str)
+      end
     end
   end
 
-
-  def redis_config_for_actor_on(model_name,relation_type_str)
+  def redis_bipartite_config_for_actor(target_model_name,relation_type_str)
     # example : items_i_like ...    
     { 
-      :type => "sorted_set", :key => "patriarch_#{model_name.to_s.tableize}_i_#{relation_type_str}"
+      :type => "sorted_set", 
+      :key => "patriarch_#{target_model_name.to_s.tableize}_i_#{relation_type_str}"
     }
   end
 
-  def redis_config_for_target_by(model_name,relation_type_str)
+  def redis_bipartite_config_for_target(actor_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"
+      :type => "sorted_set", 
+      :key => "patriarch_#{actor_model_name.to_s.tableize}_#{progressive_present(relation_type_str)}_me"
     }
   end  
 
+  def redis_tripartite_config_for_actor(target_model_name,medium_model_name,relation_type_str)
+    { 
+      :type => "sorted_set", 
+      :key => "patriarch_#{target_model_name.to_s.tableize}_i_#{relation_type_str}_via_#{medium_model_name.to_s.tableize}",
+      :options => { :marshal => true }
+    }
+  end
+  
+  def redis_tripartite_config_for_medium(actor_model_name,target_model_name,relation_type_str)
+    { 
+      :type => "sorted_set", 
+      :key => "patriarch_#{actor_model_name.to_s.tableize}_#{progressive_present(relation_type_str)}_#{target_model_name.to_s.tableize}_via_me",
+      :options => { :marshal => true }      
+    }       
+  end
+
+  def redis_tripartite_config_for_target(actor_model_name,medium_model_name,relation_type_str)
+    # example : items_praising_me_via_comments
+    { 
+      :type => "sorted_set", 
+      :key => "patriarch_#{actor_model_name.to_s.tableize}_#{progressive_present(relation_type_str)}_me_via_#{medium_model_name.to_s.tableize}",
+      :options => { :marshal => true }      
+    }       
+  end
+
   def progressive_present(behaviour_verb)
     # like becomes => liking
     (Verbs::Conjugator.conjugate behaviour_verb.to_sym, :aspect => :progressive).split(/ /).last

data/lib/patriarch/dao_services/retriever_service.rb

@@ -7,8 +7,11 @@ 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[:actor]  = instantiate_DAO_for_actor(transaction_item)
+    result[:target] = instantiate_DAO_for_target(transaction_item)
+    if transaction_item.tripartite?
+      result[:medium] = instantiate_DAO_for_medium(transaction_item)    
+    end
     result  
   end
 
@@ -21,6 +24,10 @@ class Patriarch::DAOServices::RetrieverService < Patriarch::Service
   def get_DAO_info_for_target(transaction_item)
     Patriarch::DAOServices::RedisMapperService.instance.call(transaction_item,:target)
   end
+  
+  def get_DAO_info_for_medium(transaction_item)
+    Patriarch::DAOServices::RedisMapperService.instance.call(transaction_item,:medium)
+  end
 
   def instantiate_DAO_for_actor(transaction_item)
     dao_info = get_DAO_info_for_actor(transaction_item) 
@@ -33,9 +40,24 @@ class Patriarch::DAOServices::RetrieverService < Patriarch::Service
       raise InvalidRedisTypeException, "Redis constants available were #{Redis::Objects.constants} and supplied type was #{dao_info[:type]}"
     end
 
-    redis_dao_class.new("#{actor_type}:#{actor_id}:#{dao_info[:key]}")
+    redis_dao_class.new("#{actor_type}:#{actor_id}:#{dao_info[:key]}",dao_info[:options])
   end
   
+  def instantiate_DAO_for_medium(transaction_item)
+    dao_info = get_DAO_info_for_medium(transaction_item) 
+    medium_id = transaction_item.medium_id
+    medium_type = transaction_item.medium_type
+    
+    puts "#{medium_type} - #{medium_id}"
+
+    if Redis::Objects.constants.map(&:to_s).include?("#{dao_info[:type].pluralize.camelize}")
+      redis_dao_class = "Redis::#{dao_info[:type].camelize}".constantize
+    else
+      raise InvalidRedisTypeException, "Redis constants available were #{Redis::Objects.constants} and supplied type was #{dao_info[:type]}"
+    end
+
+    redis_dao_class.new("#{medium_type}:#{medium_id}:#{dao_info[:key]}",dao_info[:options])
+  end  
 
   def instantiate_DAO_for_target(transaction_item)
     dao_info = get_DAO_info_for_target(transaction_item)
@@ -47,7 +69,7 @@ class Patriarch::DAOServices::RetrieverService < Patriarch::Service
     else
       raise InvalidRedisTypeException, "Redis constants available were #{Redis::Objects.constants} and supplied type was #{dao_info[:type]}"
     end
-    redis_dao_class.new("#{target_type}:#{target_id}:#{dao_info[:key]}")    
+    redis_dao_class.new("#{target_type}:#{target_id}:#{dao_info[:key]}",dao_info[:options])    
   end
 end
 

data/lib/patriarch/dao_services/tripartite_relationship_builder_service.rb

@@ -0,0 +1,51 @@
+require "redis/objects/sorted_sets"
+
+class Patriarch::DAOServices::TripartiteRelationshipBuilderService < Patriarch::Service
+  def create(transaction_item)
+    t = Time.now.to_f
+    dao_tab = Patriarch::DAOServices::RetrieverService.instance.call(transaction_item)
+    
+    actor_dao = dao_tab[:actor]
+    target_dao = dao_tab[:target]
+    medium_dao = dao_tab[:medium]    
+
+    protagonist_ids = [transaction_item.actor_id,transaction_item.target_id,transaction_item.medium_id]
+
+    l    = build_lambda_for_create(actor_dao,protagonist_ids,t)
+    ll   = build_lambda_for_create(target_dao,protagonist_ids,t)
+    lll  = build_lambda_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
+    transaction_item.add_to_queue ll
+    transaction_item.add_to_queue lll    
+  end
+
+  def destroy(transaction_item)
+    dao_tab = Patriarch::DAOServices::RetrieverService.instance.call(transaction_item)
+    
+    actor_dao = dao_tab[:actor]
+    target_dao = dao_tab[:target]
+    medium_dao = dao_tab[:medium]    
+    
+    protagonist_ids = [transaction_item.actor_id,transaction_item.target_id,transaction_item.medium_id]
+
+    l   = lambda { actor_dao.delete protagonist_ids }
+    ll  = lambda { target_dao.delete protagonist_ids }
+    lll = lambda { medium_dao.delete protagonist_ids }
+
+    transaction_item.add_to_queue l
+    transaction_item.add_to_queue ll
+    transaction_item.add_to_queue lll    
+  end
+
+  protected
+
+  def build_lambda_for_create(dao,ids,time)
+    if dao.is_a? Redis::SortedSet
+      return lambda { dao.add ids, time }
+    else
+      return lambda { dao.add ids }
+    end
+  end
+end

data/lib/patriarch/manager_service.rb

@@ -3,14 +3,5 @@ require 'singleton'
 module Patriarch
   class 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
 end

data/lib/patriarch/tool_services/redis_cleaner_service.rb

@@ -0,0 +1,64 @@
+class Patriarch::ToolServices::RedisCleanerService < Patriarch::Service
+  
+  # Shall be tested before implementation ...  
+  def clean_all(calling_entity)
+    calling_entity.patriarch_behaviours.keys.each do |behaviour|
+      clean_behaviour(calling_entity,behaviour)
+    end
+  end
+
+  def clean_behaviour(calling_entity,behaviour)
+    my_behaviours = calling_entity.class.patriarch_behaviours
+    
+    if my_behaviours.include? behaviour.to_s.underscore.to_sym
+      if my_behaviours[behaviour.to_s.underscore.to_sym][:medium_between]
+        clean_tripartite_behaviour(calling_entity,behaviour)
+      else
+        clean_bipartite_behaviour(calling_entity,behaviour)
+      end
+    end
+  end
+
+  def clean_bipartite_behaviour(calling_entity,behaviour)
+    #
+    # FIXME Shall clean in one blow, need to prevent transaction from "propagating"
+    
+    # → → → include option to transmit transaction and prevent it from execute
+
+    # Shall provide an option (:hard) that justs get the job done without heavey transaction stuff if performances
+    # are aching. Not now, for we have a transaction protecting us we go this way
+    my_behaviours = calling_entity.class.patriarch_behaviours
+    
+    # Compute names based on conventions    
+    progressive_present_behaviour = 
+      (Verbs::Conjugator.conjugate behaviour.to_s.underscore.to_sym, :aspect => :progressive).split(/ /).last
+
+    transac = Patriarch::TransactionServices::TransactionManagerService.instance.new_transaction("clean_#{behaviour.to_s}".to_sym)
+    options = { :transac => transac, :stop_execution => true}
+
+    if my_behaviours.include? behaviour.to_s.underscore.to_sym
+
+      # Dealing with active behaviour
+      if my_behaviours[behaviour.to_s.underscore.to_sym][:on]
+        acted_on_models = my_behaviours[behaviour.to_s.underscore.to_sym][:on]
+        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
+      
+      # Dealing with passive behaviour
+      if my_behaviours[behaviour.to_s.underscore.to_sym][:by]
+        targetted_by_models = my_behaviours[behaviour.to_s.underscore.to_sym][:by]
+        targetted_by_models.each do |targetted_by_model|
+          calling_entity.send("#{targetted_by_model.to_s.tableize}_#{progressive_present_behaviour}_me").each do |target_that_behaved_on_me|
+            target_that_behaved_on_me.send(Patriarch.undo(behaviour.to_s).underscore,calling_entity,options)
+          end
+        end
+      end
+    end # if my_behaviours.include?
+
+    transac.execute
+  end # #clean_behaviour
+end  # class Patriarch ...

data/lib/patriarch/tool_services/redis_extractor_service.rb

@@ -9,17 +9,46 @@ class Patriarch::ToolServices::RedisExtractorService < Patriarch::Service
       to = from + limit -1
     end 
 
-    dao = Redis::SortedSet.new("#{calling_entity.class.name.underscore}:#{calling_entity.id}:#{redis_key}")
+    if options[:tripartite]
+      dao = Redis::SortedSet.new("#{calling_entity.class.name.underscore}:#{calling_entity.id}:#{redis_key}", :marshal => true)
+    else  
+      dao = Redis::SortedSet.new("#{calling_entity.class.name.underscore}:#{calling_entity.id}:#{redis_key}")
+    end
 
     if options[:with_scores] 
       # Do not use this anymore, go take the right redis objects not using this kind of methods ...
-      # DEGOLASSE
       ids_with_scores_from_redis = dao.revrange(from,to,:with_scores => true) || []
-      ids_with_scores_from_redis.map{ |id,score| [id.to_i,score] } 
+      result = ids_with_scores_from_redis
     else
       ids_from_redis = dao.revrange(from,to) || []
-      ids_from_redis.map &:to_i
+      result = ids_from_redis      
+    end
+
+    if options[:tripartite]
+      if options[:with_scores]
+        if options[:protagonist_type] == :actor
+          result.map!{ |triplet_id_with_score| [triplet_id_with_score.first[0],tuple.last]}
+        elsif options[:protagonist_type] == :target
+          result.map!{ |triplet_id_with_score| [triplet_id_with_score.first[1],tuple.last]}
+        end
+      else
+        if options[:protagonist_type] == :actor
+          result.map!{ |triplet_id| triplet_id[0] }
+        elsif options[:protagonist_type] == :target
+          result.map!{ |triplet_id| triplet_id[1] }
+        end
+      end
+    end
+
+    result.map! do |x| 
+      if x.is_a? Array
+        x[0].to_i
+        x
+      else 
+        x.to_i
+      end
     end
+    result
   end 
 
   def get_models_from_ids(calling_entity,model,get_id_method,options={})        

data/lib/patriarch/transaction.rb

@@ -3,18 +3,18 @@ module Patriarch
     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]
+    forwarded_methods_syms =  [:relation_type,:actor_type,:target_type,:medium_type,
+                               :actor_id,:target_id,:medium_id, 
+                               :context,:actor,:target,:medium]
 
     # Forward methods that are not this transaction's job to step object
     forwarded_methods_syms.each do |method_sym|
-      define_method(method_sym) do
+      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 
@@ -26,6 +26,7 @@ module Patriarch
     # 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)
+    # It is there for later support of tripartite transactions
     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)
@@ -47,6 +48,10 @@ module Patriarch
       end
     end
 
+    def tripartite?
+      !medium.nil?
+    end
+
     def transaction_queue
       transaction_queue = []
       steps.each do |step|

data/lib/patriarch/transaction_services/transaction_manager_service.rb

@@ -6,8 +6,17 @@ end
 class Patriarch::TransactionServices::TransactionManagerService < Patriarch::ManagerService
   # Fill with logic to manage ressources with transactions ...
   # Can registers transactions and so on ...
+  
+  attr_accessor :count
+
   def new_transaction(type)
     id = Time.now.to_f
+    incr_count
     Patriarch::Transaction.new(type,id)
   end
+
+  def incr_count
+    @count ||= 0
+    @count += 1
+  end
 end

data/lib/patriarch/transaction_step.rb

@@ -2,7 +2,7 @@ module Patriarch
   class TransactionStep
     attr_accessor :context, :queue
 
-    def initialize(relation_type,actor,target,medium)
+    def initialize(relation_type,actor,target,medium = nil)
       @context = { 
         :relation_type  => relation_type,
         :actor_type     => actor.class.name.underscore.to_sym,
@@ -10,16 +10,24 @@ module Patriarch
         :actor_id       => actor.id,
         :target_id      => target.id,
       }
+      if medium 
+        @context.merge! :medium_id => medium.id, :medium_type => medium.class.name.underscore.to_sym
+      end
       @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|
+    [:relation_type,:actor_type,:target_type,:medium_type,:actor_id,:target_id,:medium_id].each do |context_key|
       define_method(context_key) do
         context[context_key]
       end
     end
 
+    def medium
+      return nil unless medium_id && medium_type
+      medium_type.to_s.camelize.constantize.find medium_id
+    end
+
     def actor
       actor_type.to_s.camelize.constantize.find actor_id
     end

data/lib/patriarch/version.rb

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

data/lib/patriarch.rb

@@ -4,11 +4,16 @@ require "redis/objects"
 require "redis/objects/sorted_sets"
 require "rails/generators"
 
-
-require File.expand_path('../generators/patriarch/patriarch_generator',__FILE__)
+# TODO remove this
+# require File.expand_path('../generators/patriarch/behaviour_generator',__FILE__)
 
 module Patriarch
-	autoload :Service,																'patriarch/service'
+	module Generators
+    autoload :BehaviourGenerator,                   'generators/patriarch/behaviour_generator'
+    autoload :InstallGenerator,                     'generators/patriarch/install_generator'
+  end
+
+  autoload :Service,																'patriarch/service'
 	autoload :Transaction,														'patriarch/transaction'
 	autoload :TransactionStep,                        'patriarch/transaction_step'
 	autoload :AuthorizationService,										'patriarch/authorization_service'
@@ -17,12 +22,13 @@ module Patriarch
 
   module DAOServices	
 		autoload :BipartiteRelationshipBuilderService,  'patriarch/dao_services/bipartite_relationship_builder_service'
+    autoload :TripartiteRelationshipBuilderService, 'patriarch/dao_services/tripartite_relationship_builder_service'    
 		autoload :RedisMapperService,									  'patriarch/dao_services/redis_mapper_service'
 		autoload :RetrieverService,											'patriarch/dao_services/retriever_service'
 	end
 
 	module ToolServices
-		autoload :RedisCleaner,													'patriarch/tool_services/redis_cleaner'
+		autoload :RedisCleanerService,									'patriarch/tool_services/redis_cleaner_service'
 		autoload :RedisExtractorService,								'patriarch/tool_services/redis_extractor_service'	
 	end
 
@@ -38,4 +44,4 @@ module Patriarch
 
 end # Patriarch
 
-require File.expand_path('../patriarch/behaviours',__FILE__)
+require File.expand_path('../patriarch/behaviours',__FILE__)

data/patriarch.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
 	
 	spec.platform      = Gem::Platform::RUBY
 	spec.licenses 		 = ['MIT']
-	spec.post_install_message = "Thanks for installing!"
+	spec.post_install_message = "Thanks for installing Patriarch ! Since it's my first gem, please give some advice so i can improve it or even better : contribute"
 
   # Main dependencies
   spec.add_runtime_dependency     "verbs"
@@ -19,9 +19,7 @@ Gem::Specification.new do |spec|
 
   # Dependencies needed for testing
 	spec.add_development_dependency "rspec"
-  spec.add_development_dependency "fakeredis"
-  spec.add_development_dependency "autotest-rails"
-  spec.add_development_dependency "ZenTest" 
+  # TODO run with autotest
 
   # Other options ...
 	spec.files         = `git ls-files`.split($\)