Add to the timeline

Author: felixclack

.gitignore

@@ -0,0 +1 @@
+spec/*.rdb

lib/timeline.rb

@@ -1,7 +1,14 @@
+require 'active_support'
+require 'multi_json'
+require 'hashie'
 require 'timeline/config'
+require 'timeline/helpers'
 require 'timeline/track'
+require 'timeline/actor'
+require 'timeline/activity'
 
 module Timeline
-  extend Timeline::Config
+  extend Config
+  extend Helpers
 end
 

lib/timeline/activity.rb

@@ -0,0 +1,9 @@
+module Timeline
+  class Activity
+    # include Hashie::Extensions::MethodAccess
+
+    def initialize(options={})
+      Timeline.decode options
+    end
+  end
+end

lib/timeline/actor.rb

@@ -0,0 +1,9 @@
+module Timeline::Actor
+  extend ActiveSupport::Concern
+
+  included do
+    def timeline(options={})
+      Timeline.get_list options
+    end
+  end
+end

lib/timeline/helpers.rb

@@ -0,0 +1,32 @@
+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={})
+      defaults = { list_name: "global: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")
+        end
+      end
+      Timeline.redis.lrange defaults[:list_name], defaults[:start], defaults[:end]
+    end
+  end
+end

lib/timeline/track.rb

@@ -1,5 +1,3 @@
-require 'active_support'
-
 module Timeline::Track
   extend ActiveSupport::Concern
 
@@ -9,6 +7,7 @@ def track(name, options={})
       @callback = options.delete :on
       @callback ||= :create
       @actor = options.delete :actor
+      @subject = options.delete :subject
 
       method_name = "track_#{@name}_after_#{@callback}".to_sym
       define_activity_method method_name
@@ -19,26 +18,38 @@ def track(name, options={})
     private
       def define_activity_method(method_name)
         define_method method_name do
-          actor = @actor || self
-          add_activity self.activity(@name, actor)
+          actor = !@actor.nil? ? send(@actor) : creator
+          subject = !@subject.nil? ? send(@subject.to_sym) : self
+          add_activity self.activity(@name, actor, subject)
         end
       end
-
   end
 
   protected
-    def activity(name, actor)
+    def activity(name, actor, subject)
       {
         activity_type: name,
         actor: {
           actor_id: actor.id,
-          actor_subject: actor.class.to_s,
-          url: actor.to_param
+          actor_class: actor.class.to_s,
+          url: actor.to_param,
+          title: actor.to_s
+        },
+        subject: {
+          subject_id: subject.id,
+          subject_class: subject.class.to_s,
+          url: subject.to_param,
+          title: subject.to_s
         }
       }
     end
 
     def add_activity(activity_item)
-      Timeline.redis.sadd :global, activity_item
+      redis_add "global:activity", activity_item
+      redis_add "user:id:#{activity_item[:actor][:actor_id]}:activity", activity_item
+    end
+
+    def redis_add(list, activity_item)
+      Timeline.redis.lpush list, Timeline.encode(activity_item)
     end
 end

spec/activity_spec.rb

@@ -0,0 +1,5 @@
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe Timeline::Activity do
+
+end

spec/actor_spec.rb

@@ -0,0 +1,15 @@
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+class User
+  include Timeline::Actor
+end
+
+describe Timeline::Actor do
+  describe "when included" do
+    before { @user = User.new }
+
+    it "defines a timeline association" do
+      @user.should respond_to :timeline
+    end
+  end
+end

spec/redis-test.conf

@@ -0,0 +1,115 @@
+# Redis configuration file example
+
+# By default Redis does not run as a daemon. Use 'yes' if you need it.
+# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
+daemonize yes
+
+# When run as a daemon, Redis write a pid file in /var/run/redis.pid by default.
+# You can specify a custom pid file location here.
+pidfile ./spec/redis-test.pid
+
+# Accept connections on the specified port, default is 6379
+port 9736
+
+# If you want you can bind a single interface, if the bind option is not
+# specified all the interfaces will listen for connections.
+#
+# bind 127.0.0.1
+
+# Close the connection after a client is idle for N seconds (0 to disable)
+timeout 300
+
+# Save the DB on disk:
+#
+#   save <seconds> <changes>
+#
+#   Will save the DB if both the given number of seconds and the given
+#   number of write operations against the DB occurred.
+#
+#   In the example below the behaviour will be to save:
+#   after 900 sec (15 min) if at least 1 key changed
+#   after 300 sec (5 min) if at least 10 keys changed
+#   after 60 sec if at least 10000 keys changed
+save 900 1
+save 300 10
+save 60 10000
+
+# The filename where to dump the DB
+dbfilename dump.rdb
+
+# For default save/load DB in/from the working directory
+# Note that you must specify a directory not a file name.
+dir ./spec/
+
+# Set server verbosity to 'debug'
+# it can be one of:
+# debug (a lot of information, useful for development/testing)
+# notice (moderately verbose, what you want in production probably)
+# warning (only very important / critical messages are logged)
+loglevel debug
+
+# Specify the log file name. Also 'stdout' can be used to force
+# the demon to log on the standard output. Note that if you use standard
+# output for logging but daemonize, logs will be sent to /dev/null
+logfile stdout
+
+# Set the number of databases. The default database is DB 0, you can select
+# a different one on a per-connection basis using SELECT <dbid> where
+# dbid is a number between 0 and 'databases'-1
+databases 16
+
+################################# REPLICATION #################################
+
+# Master-Slave replication. Use slaveof to make a Redis instance a copy of
+# another Redis server. Note that the configuration is local to the slave
+# so for example it is possible to configure the slave to save the DB with a
+# different interval, or to listen to another port, and so on.
+
+# slaveof <masterip> <masterport>
+
+################################## SECURITY ###################################
+
+# Require clients to issue AUTH <PASSWORD> before processing any other
+# commands.  This might be useful in environments in which you do not trust
+# others with access to the host running redis-server.
+#
+# This should stay commented out for backward compatibility and because most
+# people do not need auth (e.g. they run their own servers).
+
+# requirepass foobared
+
+################################### LIMITS ####################################
+
+# Set the max number of connected clients at the same time. By default there
+# is no limit, and it's up to the number of file descriptors the Redis process
+# is able to open. The special value '0' means no limts.
+# Once the limit is reached Redis will close all the new connections sending
+# an error 'max number of clients reached'.
+
+# maxclients 128
+
+# Don't use more memory than the specified amount of bytes.
+# When the memory limit is reached Redis will try to remove keys with an
+# EXPIRE set. It will try to start freeing keys that are going to expire
+# in little time and preserve keys with a longer time to live.
+# Redis will also try to remove objects from free lists if possible.
+#
+# If all this fails, Redis will start to reply with errors to commands
+# that will use more memory, like SET, LPUSH, and so on, and will continue
+# to reply to most read-only commands like GET.
+#
+# WARNING: maxmemory can be a good idea mainly if you want to use Redis as a
+# 'state' server or cache, not as a real DB. When Redis is used as a real
+# database the memory usage will grow over the weeks, it will be obvious if
+# it is going to use too much memory in the long run, and you'll have the time
+# to upgrade. With maxmemory after the limit is reached you'll start to get
+# errors for write operations, and this may even lead to DB inconsistency.
+
+# maxmemory <bytes>
+
+############################### ADVANCED CONFIG ###############################
+
+# Glue small output buffers together in order to send small replies in a
+# single TCP packet. Uses a bit more CPU but most of the times it is a win
+# in terms of number of queries per second. Use 'yes' if unsure.
+glueoutputbuf yes

spec/track_spec.rb

@@ -4,32 +4,70 @@
 
 class Post
   extend ActiveModel::Callbacks
-  extend ActiveModel::Serialization
 
   define_model_callbacks :create
-  attr_accessor :id, :to_param
+  attr_accessor :id, :to_param, :creator_id, :name
 
   include Timeline::Track
   track :new_post
 
+  def initialize(options={})
+    @creator_id = options.delete :creator_id
+    @name = options.delete :name
+  end
+
   def save
     run_callbacks :create
     true
   end
+
+  def creator
+    User.find(creator_id)
+  end
+
+  def to_s
+    name
+  end
+end
+
+class User
+  include Timeline::Actor
+  attr_accessor :id, :to_param
+
+  def initialize(options={})
+    @id = options.delete :id
+  end
+
+  class << self
+    def find user_id
+      User.new(id: user_id)
+    end
+  end
 end
 
 describe Timeline::Track do
-  describe "included in an AR class" do
-    before { @post = Post.new }
+  let(:creator) { User.new(id: 1) }
+  let(:post) { Post.new(creator_id: creator.id, name: "New post") }
 
+  describe "included in an AR class" do
     it "tracks on create by default" do
-      @post.should_receive(:track_new_post_after_create)
-      @post.save
+      post.should_receive(:track_new_post_after_create)
+      post.save
+    end
+
+    it "uses the creator as the actor by default" do
+      post.should_receive(:creator).and_return(mock("User", id: 1, to_param: "1"))
+      post.save
     end
 
     it "adds the activity to the global timeline set" do
-      Timeline.redis.should_receive(:sadd).with(:global, kind_of(Hash))
-      @post.save
+      post.save
+      creator.timeline(:global).first.should include(post.to_s)
+    end
+
+    it "adds the activity to the actor's timeline" do
+      post.save
+      creator.timeline.last.should include(post.to_s)
     end
   end
 end