paritytimeline 0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 19db87a66812a801cff06086f49018f30f6133de
+  data.tar.gz: ba8b8ff4dbba4b63b7c3c55f10f77407792dc63c
+SHA512:
+  metadata.gz: c213c9aa2bcedd59cbc3ad53dadb732e9125879d9ac71055ab9603ef23c2f4aaf54fadf78b79620cf78be97a31011c2c2d3f0b2d4a0a035bf71c302b1e3dc73e
+  data.tar.gz: c3784e1b7803c9e8fa67a89289295e20527316120cafbdf32a1621fbc97dd615cde30b12263911773e7aa2f6b880d73b6af2286c1918bcc80afad9ceb2ab8ce8

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2012 Felix Clack
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,152 @@
+redis-timeline
+===========
+
+[![Build Status](https://travis-ci.org/felixclack/redis-timeline.png?branch=master)](https://travis-ci.org/felixclack/redis-timeline)
+
+Redis backed timelines in your app.
+
+<a href="mailto:felixclack+pairwithme@gmail.com" title="Pair program with me!">
+  <img src="http://pairprogramwith.me/badge.png"
+        alt="Pair program with me!" />
+</a>
+
+Features
+--------
+
+* store your timeline in Redis.
+
+Examples
+--------
+
+The simple way...
+
+    class PostsController < ApplicationController
+      include Timeline::ControllerHelper
+
+    end
+
+Instead doing on the callback we explicity mention when we want to track the activity
+
+You can specify these options ...
+
+    class PostsController < ApplicationController
+      include Timeline::ControllerHelper
+      belongs_to :author, class_name: "User"
+      belongs_to :post
+
+      track :new_comment,
+        actor: :author,
+        followers: :post_participants,
+        object: [:body],
+        on: :update,
+        target: :post
+
+      delegate :participants, to: :post, prefix: true
+      def create
+      @post=Post.new(params[:post])
+        respond_to do |format|
+          if @post.save!
+            track_timeline_activity(:new_post,actor: current_user,followers: current_user.followers,target: @post.comment,object: @post) 
+            format.html { redirect_to(posts_path , :notice => 'Post was successfully created.') }
+          else
+            format.html { redirect_to(posts_path , :notice => @post.errors.full_messages) }
+            format.json { render json: @post.errors, status: :unprocessable_entity }
+          end
+
+        end
+      end
+    end
+
+Parameters
+----------
+
+`track` accepts the following parameters...
+
+the first param is the verb name.
+
+The rest all fit neatly in an options hash.
+
+* `actor:` [the method that specifies the object that took this action]
+  In the above example, comment.author is this object.
+  
+
+* `object:` defaults to self, which is good most of the time.
+  You can override it if you need to
+
+* `target:` [related to the `:object` method above. In the example this is the post related to the comment]
+  default: nil
+
+* `followers:` [who should see this story in their timeline. This references a method on the actor]
+  Defaults to the method `followers` defined by Timeline::Actor.
+
+
+Display a timeline
+------------------
+
+To retrieve a timeline for a user...
+
+    class User < ActiveRecord::Base
+      include Timeline::Actor
+    end
+
+The timeline objects are just hashes that are extended by [Hashie](http://github.com/intridea/hashie) to provide method access to the keys.
+
+    user = User.find(1)
+    user.timeline # => [<Timeline::Activity verb='new_comment' ...>]
+
+Requirements
+------------
+
+* redis
+* active_support
+* hashie
+
+Install
+-------
+
+Install redis.
+
+Add to your Gemfile:
+
+    gem 'redis-timeline'
+
+Or install it by hand:
+
+    gem install redis-timeline
+
+Setup your redis instance. For a Rails app, something like this...
+
+    # in config/initializers/redis.rb
+
+    Timeline.redis = "localhost:6379/timeline"
+
+Author
+------
+
+Original author: Felix Clack
+
+License
+-------
+
+(The MIT License)
+
+Copyright (c) 2012 Felix Clack
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,38 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Timeline'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task :default => :test

data/lib/redis_timeline.rb

@@ -0,0 +1,21 @@
+require 'active_support/concern'
+require 'action_controller'
+require 'multi_json'
+require 'hashie'
+require 'timeline/config'
+require 'timeline/helpers'
+require 'timeline/track'
+require 'timeline/actor'
+require 'timeline/activity'
+
+
+module Timeline
+  extend Config
+  extend Helpers
+end
+
+require 'timeline/controller_helper'
+require 'timeline/notification_helper'
+
+ActionController::Base.send :include, Timeline::ControllerHelper
+ActionController::Base.send :include, Timeline::NotificationHelper

data/lib/tasks/timeline_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :timeline do
+#   # Task goes here
+# end

data/lib/timeline/activity.rb

@@ -0,0 +1,11 @@
+require 'active_model'
+
+module Timeline
+  class Activity < Hashie::Mash
+    extend ActiveModel::Naming
+
+    def to_partial_path
+      "timelines/#{verb}"
+    end
+  end
+end

data/lib/timeline/actor.rb

@@ -0,0 +1,36 @@
+module Timeline
+  module Actor
+    extend ActiveSupport::Concern
+
+    included do
+      def timeline(options={})
+        ::Timeline.get_list(timeline_options(options)).map do |item|
+          ::Timeline::Activity.new ::Timeline.decode(item)
+        end
+      end
+
+      def followers
+        []
+      end
+
+      private
+        def timeline_options(options)
+          defaults = { list_name: "user:id:#{self.id}:activity", start: 0, end: 19 }
+          if options.is_a? Hash
+            defaults.merge!(options)
+          elsif options.is_a? Symbol
+            case options
+            when :global
+              defaults.merge!(list_name: "global:activity")
+            when :posts
+              defaults.merge!(list_name: "user:id:#{self.id}:posts")
+            when :mentions
+              defaults.merge!(list_name: "user:id:#{self.id}:mentions")
+            when :notifications
+              defaults.merge!(list_name: "user:id:#{self.id}:notification")
+            end
+          end
+        end
+    end
+  end
+end

data/lib/timeline/config.rb

@@ -0,0 +1,42 @@
+require 'redis/namespace'
+
+module Timeline
+  module Config
+
+    # Accepts:
+    #   1. A 'hostname:port' String
+    #   2. A 'hostname:port:db' String (to select the Redis db)
+    #   3. A 'hostname:port/namespace' String (to set the Redis namespace)
+    #   4. A Redis URL String 'redis://host:port'
+    #   5. An instance of `Redis`, `Redis::Client`, `Redis::DistRedis`,
+    #      or `Redis::Namespace`.
+    def redis=(server)
+      case server
+      when String
+        if server =~ /redis\:\/\//
+          redis = Redis.connect(:url => server, :thread_safe => true)
+        else
+          server, namespace = server.split('/', 2)
+          host, port, db = server.split(':')
+          redis = Redis.new(:host => host, :port => port,
+            :thread_safe => true, :db => db)
+        end
+        namespace ||= :timeline
+
+        @redis = Redis::Namespace.new(namespace, :redis => redis)
+      when Redis::Namespace
+        @redis = server
+      else
+        @redis = Redis::Namespace.new(:timeline, :redis => server)
+      end
+    end
+
+    # Returns the current Redis connection. If none has been created, will
+    # create a new one.
+    def redis
+      return @redis if @redis
+      self.redis = Redis.respond_to?(:connect) ? Redis.connect : "localhost:6379"
+      self.redis
+    end
+  end
+end

data/lib/timeline/controller_helper.rb

@@ -0,0 +1,153 @@
+module Timeline
+ 
+  module ControllerHelper
+    def self.included(base)
+      base.send :include, InstanceMethods
+    end
+
+    module InstanceMethods
+      def track_timeline_activity(name, options={})
+        @name = name
+        @start_value = 0
+        @limit_records = (options[:limit_records] && options[:limit_records] > 30) ? options[:limit_records] : 30
+        @limit_days = (options[:limit_days] && options[:limit_days] > 30) ? options[:limit_days] : 30
+        @actor = options.delete :actor
+        @actor ||= :creator
+        @object = options.delete :object
+        @target = options.delete :target
+        @followers = options.delete :followers
+        @friends = options.delete :friends
+        @mentionable = options.delete :mentionable
+       
+        @fields_for = {}
+        @extra_fields ||= nil
+        @merge_similar = options[:merge_similar] == true ? true : false
+        options[:verb] = name
+
+        add_activity(activity(verb: options[:verb]))
+      end 
+
+      # track_timeline_activity(:new_coupon,actor: :user,object: :coupon_code,followers: :followers)
+      
+      protected
+   
+      def activity(options={})
+        {
+          verb: options[:verb],
+          actor: options_for(@actor),
+          object: options_for(@object),
+          target: options_for(@target),
+          created_at: Time.now
+        }
+      end
+
+      def add_activity(activity_item)
+        redis_add "global:activity", activity_item
+        redis_add "global:activity:#{activity_item[:verb]}", activity_item
+        add_activity_to_user(activity_item[:actor][:id], activity_item)
+        add_activity_by_user(activity_item[:actor][:id], activity_item)
+        add_mentions(activity_item)
+        add_activity_to_followers(activity_item) if @followers.any?
+        add_activity_to_friends(activity_item) if @friends.any?
+      end
+
+      def add_activity_by_user(user_id, activity_item)
+        redis_add "user:id:#{user_id}:posts", activity_item
+      end
+
+      def add_activity_to_user(user_id, activity_item)
+        redis_add "user:id:#{user_id}:activity", activity_item
+      end
+
+      def add_activity_to_users_friends(user_id, activity_item)
+        redis_add "user:id:#{user_id}:activity:friends", activity_item
+      end
+
+      def add_activity_to_followers(activity_item)
+        @followers.each { |follower| add_activity_to_user(follower.id, activity_item) }
+      end
+
+      def add_activity_to_friends(activity_item)
+        @friends.each { |friend| add_activity_to_users_friends(friend, activity_item) }
+      end
+
+      def add_mentions(activity_item)
+        return unless @mentionable and @object.send(@mentionable)
+        @object.send(@mentionable).scan(/@\w+/).each do |mention|
+          if user = @actor.class.find_by_username(mention[1..-1])
+            add_mention_to_user(user.id, activity_item)
+          end
+        end
+      end
+
+      def add_mention_to_user(user_id, activity_item)
+        redis_add "user:id:#{user_id}:mentions", activity_item
+      end
+
+      def extra_fields_for(object)
+        return {} unless @fields_for.has_key?(object.class.to_s.downcase.to_sym)
+        @fields_for[object.class.to_s.downcase.to_sym].inject({}) do |sum, method|
+          sum[method.to_sym] = @object.send(method.to_sym)
+          sum
+        end
+      end
+
+      def options_for(target)
+        if !target.nil?
+          {
+            id: target.id,
+            class: target.class.to_s,
+            display_name: target.to_s
+          }.merge(extra_fields_for(target))
+        else
+          nil
+        end
+      end
+
+      def redis_add(list, activity_item)
+        Timeline.redis.lpush list, Timeline.encode(activity_item)
+        trim_activities list
+      end
+
+      def trim_activities(list)
+        return if (Timeline.redis.llen list) < @limit_records
+        last_record = get_record(list, -1)
+        return if (last_record && last_record["created_at"]) > Time.now - @limit_days.days
+        trim_old_activities(list)
+      end
+
+      def get_record(list, index)
+        last_record = Timeline.redis.lindex list, index
+        last_record = Timeline.decode(last_record) if last_record
+      end
+
+      def trim_old_activities(list)
+        Timeline.redis.ltrim list , 0 , get_trim_index(list, (Timeline.redis.llen list) - 1)
+      end
+
+      def get_trim_index(list, index)
+        return @limit_records if index < @limit_records
+        record = get_record(list, index)
+        if record && (record["created_at"] < Time.now - @limit_days.days)
+          return get_trim_index(list, index - 5)
+        else
+          return index
+        end
+      end
+
+      def set_object(object)
+        case
+        when object.is_a?(Symbol)
+          send(object)
+        when object.is_a?(Array)
+          @fields_for[self.class.to_s.downcase.to_sym] = object
+          self
+        else
+          self
+        end
+      end
+    end
+  end
+
+     
+end

data/lib/timeline/helpers.rb

@@ -0,0 +1,23 @@
+module Timeline
+  module Helpers
+    class DecodeException < StandardError; end
+
+    def encode(object)
+      ::MultiJson.encode(object)
+    end
+
+    def decode(object)
+      return unless object
+
+      begin
+        ::MultiJson.decode(object)
+      rescue ::MultiJson::DecodeError => e
+        raise DecodeException, e
+      end
+    end
+
+    def get_list(options={})
+      Timeline.redis.lrange options[:list_name], options[:start], options[:end]
+    end
+  end
+end

data/lib/timeline/notification_helper.rb

@@ -0,0 +1,98 @@
+module Timeline
+ 
+  module NotificationHelper
+    def self.included(base)
+      base.send :include, InstanceMethods
+    end
+
+    module InstanceMethods
+      def track_notification(name, options={})
+        @name = name
+        @actor = options[:actor]
+        @object = options[:object]
+        @target = options[:target]
+        @followers = set_follower(options[:followers])
+        @mentionable = options[:mentionable]
+        @read = options[:read] || false
+
+        add_activity_to_subscribed_user(@followers,notification_activity) if @followers.present?
+        add_mentions(notification_activity)
+      end
+
+      def add_activity_to_subscribed_user(followers, activity_item)
+        followers.each do |follower|
+          add_to_redis "user:id:#{follower.id}:notification", activity_item
+          trim_notification "user:id:#{follower.id}:notification"
+        end
+      end
+
+      def add_to_redis(list, activity_item)
+        Timeline.redis.lpush list, Timeline.encode(activity_item)
+      end
+
+      def trim_notification(list)
+        Timeline.redis.ltrim list, 0, 29
+      end
+
+      def add_mentions(activity_item)
+        return unless @mentionable
+        @mentionable.each do |mention|
+          if user = @actor.class.where("coalesce(display_name, login) = ?",mention)
+            add_activity_to_subscribed_user(user, activity_item)
+          end
+        end
+      end
+
+      def set_as_read_notification(user, read, options= {})
+        notifications = get_unread_notification(user, options)
+        notifications.each do |index, notification|
+          Timeline.redis.lset("user:id:#{user.id}:notification",index, Timeline.encode(reset_read_activity(notification, read)))
+        end
+      end
+
+      def get_unread_notification(user, options= {})
+        result = {}
+        Timeline.redis.lrange("user:id:#{user.id}:notification", options[:start] || 0, options[:end] || 10).each_with_index do |item, index|
+          data = Timeline.decode(item)
+          result.merge!(index => data) unless data["read"]
+        end
+        result
+      end
+
+
+      private
+        def notification_activity
+          {
+            verb: @name,
+            actor: @actor,
+            object: @object,
+            target: @target,
+            created_at: Time.now,
+            read: @read
+          }
+        end
+
+        def set_follower(follower)
+          if follower.is_a?(Array)
+            follower
+          elsif follower.present?
+            [follower]
+          else
+            []
+          end
+        end
+
+       def reset_read_activity(activity, read)
+        {
+          verb: activity["verb"],
+          actor: activity["actor"],
+          object: activity["object"],
+          target: activity["target"],
+          created_at: activity["created_at"],
+          read: read
+        }
+      end
+
+    end
+  end
+end