pfeed 0.1.0

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/app/models/pfeed_delivery.rb

@@ -0,0 +1,4 @@
+class PfeedDelivery < ActiveRecord::Base
+  belongs_to :pfeed_receiver, :polymorphic => true
+  belongs_to :pfeed_item
+end

data/app/models/pfeed_item.rb

@@ -0,0 +1,172 @@
+class PfeedItem < ActiveRecord::Base
+
+  serialize :data, Hash
+  serialize :participants, Array
+   
+  belongs_to :originator, :polymorphic => true
+  belongs_to :participant, :polymorphic => true
+
+  has_many :pfeed_deliveries, :dependent => :destroy   
+  
+  attr_accessor :temp_references # this is an temporary Hash to hold references to temporary Objects 
+  
+  def self.log(ar_obj,method_name,method_name_in_past_tense,returned_result,*args_supplied_to_method,&block_supplied_to_method)
+
+     #puts "#{ar_obj.class.to_s},#{method_name},#{method_name_in_past_tense},#{returned_result},#{args_supplied_to_method.length}"
+
+    # optional :if => :test, or :unless => :test
+    if if_cond = ar_obj.pfeed_options[:if]
+      return unless ar_obj.send(if_cond)
+    elsif unless_cond = ar_obj.pfeed_options[:unless]
+      return if ar_obj.send(unless_cond)
+    end
+
+    raise ArgumentError, "originator object must to be saved" if ar_obj.new_record?
+     
+      temp_references = Hash.new
+      temp_references[:originator] = ar_obj
+      temp_references[:participant] = nil
+      temp_references[:participant] = args_supplied_to_method[0] if args_supplied_to_method && args_supplied_to_method.length >= 1 && args_supplied_to_method[0].class < ActiveRecord::Base
+
+      pfeed_class_name = "#{ar_obj.class.to_s.underscore}_#{method_name_in_past_tense}".camelize # may be I could use .classify
+      constructor_options = { :originator_id => temp_references[:originator].id , :originator_type => temp_references[:originator].class.to_s , :participant_id => (temp_references[:participant] ? temp_references[:participant].id : nil) , :participant_type => (temp_references[:participant] ? temp_references[:participant].class.to_s : nil) } # there is a reason why I didnt use {:originator => temp_references[:originator]} , if originator is new record it might get saved here un intentionally
+
+
+      p_item = new_pfeed_item(pfeed_class_name, constructor_options, temp_references)
+      p_item.pack_data(method_name,method_name_in_past_tense,returned_result,*args_supplied_to_method,&block_supplied_to_method)
+
+
+      p_item.save!
+      #puts "Trying to deliver to #{ar_obj}  #{ar_obj.pfeed_audience_hash[method_name.to_sym]}"
+      p_item.attempt_delivery(ar_obj,ar_obj.pfeed_audience_hash[method_name.to_sym])   # attempting the delivery of the feed
+  end  
+  
+  @@dj = (defined? Delayed) == "constant" && (instance_methods.include? 'send_later') #this means Delayed_job exists , so make use of asynchronous delivery of pfeed
+
+  def attempt_delivery (ar_obj,method_name_arr)
+    return if method_name_arr.empty?
+
+    if @@dj
+      send_later(:deliver,ar_obj,method_name_arr)  
+    else  # regular instant delivery
+      send(:deliver,ar_obj,method_name_arr)    
+    end
+  end
+
+  def deliver(ar_obj,method_name_arr)
+    method_name_arr.map { |method_name|
+      ar_obj.send(method_name)
+    }.flatten.uniq.map {|o| deliver_to(o) }.compact
+  end
+
+  def deliver_to(result_obj)
+    return nil unless result_obj != nil && begin
+        result_obj.is_pfeed_receiver
+      rescue NoMethodError
+        raise NoMethodError, "you must use the receives_pfeed macro for class: #{result_obj.class}"
+      end
+
+    if !result_obj.new_record?
+      delivery = PfeedDelivery.new
+      delivery.pfeed_item = self
+      delivery.pfeed_receiver = result_obj
+      delivery.save!
+    end
+
+    return result_obj
+  end
+
+  def accessible?
+    true 
+  end
+
+  def view_template_name 
+    "#{self.class.to_s.underscore}".split("/").last
+  end
+  
+  def audience
+    # return list of objects to whom feed gets delivered
+  end
+  
+  def pack_data(method_name,method_name_in_past_tense,returned_result,*args_supplied_to_method,&block_supplied_to_method) 
+    self.data = {} if ! self.data
+    action_string = method_name_in_past_tense.humanize.downcase
+    hash_to_be_merged = {:action_string => action_string, :originator_identity => guess_identification(originator)}
+
+    if current_user = Thread.current[:current_user]
+      hash_to_be_merged.merge!(:current_user_identity => guess_identification(current_user))
+    end
+    
+    self.data.merge!  hash_to_be_merged
+  end
+  
+  IDENTIFICATIONS = {}
+  def guess_identification(ar_obj)
+    if identifier = ar_obj.respond_to?(:pfeed_options) && ar_obj.pfeed_options[:pfeed_identification]
+      return ar_obj.send(identifier)
+    end
+
+    if attribute = IDENTIFICATIONS[ar_obj.class]
+      if (identi = ar_obj.read_attribute(attribute)).blank?
+        identi = ar_obj.send(attribute) rescue nil
+      end
+      return identi if identi
+    end
+
+    possible_attributes = ["username","login","name","company_name","first_name","last_name","login_name","login_id","given_name","nick_name","nick","short_name"]
+    
+    possible_attributes = self.data[:config][:identifications] + possible_attributes if self.data[:config] && self.data[:config][:identifications] && self.data[:config][:identifications].is_a?(Array)
+    matched_name = ar_obj.attribute_names & possible_attributes # intersection of two sets
+
+    identi = nil
+    matched_name.each do |attribute|
+      result = ar_obj.read_attribute(attribute)
+      next unless result.present? && result.kind_of?(String)
+      IDENTIFICATIONS[ar_obj.class] = attribute
+      identi = result 
+      break
+    end
+
+    if identi.blank?
+      possible_attributes.each do |attribute|
+        next unless ar_obj.respond_to? attribute
+        result = ar_obj.send(attribute) rescue nil
+        next unless result.present? && result.kind_of?(String)
+        IDENTIFICATIONS[ar_obj.class] = attribute
+        identi = result 
+        break 
+      end
+    end
+    
+    identi =  "#{ar_obj.class.to_s}(\##{ar_obj.id})" if identi.blank?
+    identi
+  end  
+
+  # look for custom pfeed class, with or withour Pfeed:: prefix
+  CUSTOM_CLASSES = {}
+  def self.new_pfeed_item(pfeed_class_name, constructor_options, temp_references)
+    if (klass = CUSTOM_CLASSES[pfeed_class_name]).nil?
+      retried = false
+      begin
+        #puts "Attempting to create object of  #{pfeed_class_name} "
+        klass = pfeed_class_name.constantize
+        (CUSTOM_CLASSES[pfeed_class_name] = klass).new(
+          constructor_options.merge(:temp_references => temp_references))
+      rescue NameError
+        unless retried
+          CUSTOM_CLASSES[pfeed_class_name] = false
+          retried = true
+          pfeed_class_name = "Pfeeds::"+pfeed_class_name
+          retry
+        end
+        PfeedItem.new(constructor_options) 
+      end   
+    else
+      if !klass
+        PfeedItem.new(constructor_options) 
+      else
+        klass.new(constructor_options) 
+      end
+    end
+  end
+end

data/app/models/pfeeds/user_updated_attribute.rb

@@ -0,0 +1,14 @@
+class Pfeeds::UserUpdatedAttribute < PfeedItem
+  
+  def pack_data(method_name,method_name_in_past_tense,returned_result,*args_supplied_to_method,&block_supplied_to_method) 
+     super
+     self.data = {} if ! self.data
+     attribute_name = args_supplied_to_method[0].to_s.humanize
+     hash_to_be_merged = {:attribute_name => attribute_name}
+
+     self.data.merge!  hash_to_be_merged
+   end
+ 
+end
+
+

data/app/views/pfeeds/_pfeed.html.erb

@@ -0,0 +1,14 @@
+<ul class="pfeed_container">
+  <li>
+  <%=
+    begin
+      render(:partial => "pfeeds/#{pfeed.view_template_name}", :object => pfeed)
+    rescue
+      "<!-- error in #{pfeed.view_template_name}: #{$!.to_s.split("\n").join("-->\n<!--")} -->"
+    end
+  %>
+  </li>
+</ul>
+
+
+

data/app/views/pfeeds/_pfeed_item.html.erb

@@ -0,0 +1,3 @@
+<%= pfeed_item.guess_identification(pfeed_item.originator) -%>
+ <%= pfeed_item.data[:action_string] -%>
+ about <%= time_ago_in_words(pfeed_item.created_at) -%> ago  

data/app/views/pfeeds/_user_updated_attribute.html.erb

@@ -0,0 +1,4 @@
+
+<font color="blue"><%= user_updated_attribute.guess_identification(user_updated_attribute.originator) %></font>
+<%= user_updated_attribute.data[:action_string] %> <%= user_updated_attribute.data[:attribute_name] %>
+about <%= time_ago_in_words(user_updated_attribute.created_at) %> ago 

data/db/migrate/0000_create_pfeed_items.rb

@@ -0,0 +1,18 @@
+class CreatePfeedItems < ActiveRecord::Migration
+   def self.up
+   create_table :pfeed_items do |t|
+     t.string  :type
+     t.integer :originator_id
+     t.string :originator_type
+     t.integer :participant_id
+     t.string :participant_type
+     t.text   :data
+     t.datetime :expiry
+     t.timestamps
+   end
+ end
+
+ def self.down
+   drop_table :pfeed_items
+ end
+end

data/db/migrate/0001_create_pfeed_deliveries.rb

@@ -0,0 +1,15 @@
+class CreatePfeedDeliveries < ActiveRecord::Migration
+  def self.up
+   
+    create_table :pfeed_deliveries do |t|
+     t.integer :pfeed_receiver_id
+     t.string :pfeed_receiver_type
+     t.integer :pfeed_item_id
+     t.timestamps
+   end
+  end
+
+  def self.down
+     drop_table :pfeed_deliveries
+  end
+end

data/init.rb

@@ -0,0 +1,18 @@
+# Author: Er Abhishek Parolkar
+
+require File.dirname(__FILE__) + '/lib/pfeed'
+require File.dirname(__FILE__) + '/lib/pfeed_utils'
+ActiveRecord::Base.send(:include, ParolkarInnovationLab::SocialNet)
+
+ActionController::Base.helper do
+  def pfeed_content(pfeed)  #FIXME: interesting idea , but currently un-supported
+    controller.send('render_to_string',
+      :partial => "pfeeds/#{pfeed.view_template_name}.html.erb", :locals => {:object => pfeed})
+  end
+
+  def pfeed_item_url(pfeed_item)
+    # same as: polymorphic_url pfeed_item.originator
+    # but no need to query the database
+    send(pfeed_item.originator_type.underscore + '_url', pfeed_item.originator_id)
+  end
+end

data/install.rb

@@ -0,0 +1 @@
+# Install hook code here

data/lib/generator/pfeed_customization/USAGE

@@ -0,0 +1,10 @@
+Description:
+    Explain the generator
+
+Example:
+    rails generate pfeed_customization user create
+
+    This will create:
+        app/model/pfeeds/user_created.rb
+        app/views/pfeeds/_user_created.html.erb
+

data/lib/generator/pfeed_customization/pfeed_customization_generator.rb

@@ -0,0 +1,29 @@
+class PfeedCustomizationGenerator < Rails::Generators::Base
+  attr_reader :past_classname
+  attr_reader :past_varname
+
+  source_root File.expand_path('../templates', __FILE__)
+  argument :model, :type => :string, :required => true 
+  argument :action_name, :type => :string,:required => true
+
+  def initialize_pfeed_customization
+    raise "#{model.to_s.classify} must define '#{action_name.underscore}' method" unless model.to_s.classify.constantize.methods.include? action_name.underscore
+    
+    @model = model
+    @current_action = action_name.to_s.underscore
+    @past_action = ParolkarInnovationLab::SocialNet::PfeedUtils.attempt_pass_tense(@current_action)
+    @past = @model.downcase + '_' + @past_action
+    @past_classname = @model.capitalize + @past_action.capitalize
+    @past_varname = @model.downcase + '_' + @past_action.downcase
+    @model_filename =  @past + '.rb'
+    @view_filename = '_' + @past + '.html.erb'
+  end
+
+  def manifest
+    template('pfeed_model.rb', "app/models/pfeeds/#{@model_filename}")
+    template('pfeed_view.html.erb', "app/views/pfeeds/#{@view_filename}")
+   
+  end
+
+
+end

data/lib/generator/pfeed_customization/templates/pfeed_model.rb

@@ -0,0 +1,5 @@
+class Pfeeds::<%= past_classname %> < PfeedItem
+   def pack_data(method_name,method_name_in_past_tense,returned_result,*args_supplied_to_method,&block_supplied_to_method) 
+     super
+   end
+ end  

data/lib/generator/pfeed_customization/templates/pfeed_view.html.erb

@@ -0,0 +1,5 @@
+<%%= <%= past_varname %>.guess_identification(<%= past_varname %>.originator)%>
+
+<%%= <%= past_varname %>.data[:action_string] %>
+
+about <%%= time_ago_in_words(<%= past_varname %>.created_at) %> ago  

data/lib/pfeed.rb

@@ -0,0 +1,29 @@
+# Author: Er Abhishek Parolkar
+if defined?(Rails)
+  module AuditTrail
+    require "rails"
+    require 'rubygems'
+    require 'rails'
+    require 'active_record'
+    require 'action_controller'
+    require 'active_support'
+    require 'pfeed/pfeed'
+  end
+end
+
+
+
+ActiveRecord::Base.send(:include, ParolkarInnovationLab::SocialNet)
+
+ActionController::Base.helper do
+  def pfeed_content(pfeed)  #FIXME: interesting idea , but currently un-supported
+    controller.send('render_to_string',
+      :partial => "pfeeds/#{pfeed.view_template_name}.html.erb", :locals => {:object => pfeed})
+  end
+
+  def pfeed_item_url(pfeed_item)
+    # same as: polymorphic_url pfeed_item.originator
+    # but no need to query the database
+    send(pfeed_item.originator_type.underscore + '_url', pfeed_item.originator_id)
+  end
+end

data/lib/pfeed/pfeed.rb

@@ -0,0 +1,102 @@
+#snippet: https://gist.github.com/89e92409ca9016d2d919
+
+module ParolkarInnovationLab
+  module SocialNet
+    def self.included(base)
+      base.extend ParolkarInnovationLab::SocialNet::ClassMethods
+    end
+    
+    module ClassMethods
+                  
+      def emits_pfeeds arg_hash # {:on => [] , :for => [:itself , :all_in_its_class], :identified_by => :name, :if => :passes_test?}
+        arg_hash.assert_valid_keys(:on,:for,:if,:unless,:identified_by)
+        [:on, :for].each do |argument|
+          raise ArgumentError, "Expected an argument: #{argument}" if !arg_hash[argument]
+        end
+
+        include ParolkarInnovationLab::SocialNet::InstanceMethods
+ 
+        method_name_array = [*arg_hash[:on]]
+        class_inheritable_hash :pfeed_audience_hash
+        
+        method_name_array.each{|method_name| register_pfeed_audience(method_name,[*arg_hash[:for]].compact)  }
+
+        class_inheritable_hash :pfeed_options
+        write_inheritable_hash :pfeed_options, arg_hash.slice(:if,:unless,:identified_by)
+
+        
+
+        method_name_array.each { |method_name|
+          method, symbol = method_name.to_s.split /(\!|\?)/
+          symbol = '' if symbol.nil?
+                    
+          method_to_define = method + '_with_pfeed' + symbol
+          method_to_be_called = method + '_without_pfeed' + symbol
+          eval %[
+               
+             module ::ParolkarInnovationLab::SocialNet::PfeedTemp::#{self.to_s} 
+              def #{method_to_define}(*a, &b)
+                returned_result = #{method_to_be_called}(*a , &b)
+                method_name_in_past_tense = "#{ParolkarInnovationLab::SocialNet::PfeedUtils.attempt_pass_tense(method)}"
+                PfeedItem.log(self,"#{method_name}",method_name_in_past_tense,returned_result,*a,&b) 
+                returned_result
+              end
+             end    
+          ] 
+            
+        }
+        
+        #TODO : Pfeed.log(self,"#{method_name}",method_name_in_past_tense,returned_result,*a,*b)  : this is to be done in a different thread in bg to boost performance & also needs exception handling such that parent call never breaks
+        
+        include "::ParolkarInnovationLab::SocialNet::PfeedTemp::#{self.to_s}".constantize # why this? because "define_method((method + '_with_pfeed' + symbol).to_sym) do |*a , &b|" generates syntax error in ruby < 1.8.7 
+        
+        method_name_array.each { |method_name|
+          method, symbol = method_name.to_s.split /(\!|\?)/
+          symbol = '' if symbol.nil?
+          alias_method_chain (method + symbol), :pfeed
+        }
+         
+        has_many :pfeed_items , :as => :originator , :dependent => :destroy   #when originator is deleted the pfeed_items gets destroyed too
+         
+          
+      end
+     
+      def receives_pfeed
+        has_many :pfeed_deliveries , :as => :pfeed_receiver 
+        has_many :pfeed_inbox, :class_name => 'PfeedItem', :foreign_key => "pfeed_item_id" , :through => :pfeed_deliveries , :source => :pfeed_item
+
+	write_inheritable_attribute(:is_pfeed_receiver,true)
+        class_inheritable_reader :is_pfeed_receiver
+      end
+    
+      def register_pfeed_audience(method_name,audience_arr)
+         write_inheritable_hash(:pfeed_audience_hash, { method_name.to_sym => audience_arr }) # this does a merge
+      end
+    end
+    
+    module PfeedTemp
+      # Required for temporarily injecting new methods
+    end  
+    module InstanceMethods
+    
+      def itself
+	self
+      end
+      def all_in_its_class
+        self.class.find :all
+      end    
+      
+      def pfeed_recent_item_timestamp  
+        self.pfeed_deliveries.last.created_at
+      rescue
+        nil
+      end
+      
+      private
+        #let private methods come here
+    end
+  end
+end
+
+
+