redis-timeline 0.1.4

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,141 @@
+timeline
+===========
+
+Redis backed timelines in your app.
+
+Features
+--------
+
+* store your timeline in Redis.
+
+Examples
+--------
+
+The simple way...
+
+    class Post < ActiveRecord::Base
+      include Timeline::Track
+
+      track :new_post
+
+    end
+
+By default, track fires in the `after_create` callback of your model and uses `self` as the object and `creator` as the actor.
+
+You can specify these options explicity...
+
+    class Comment < ActiveRecord::Base
+      include Timeline::Track
+      belongs_to :author, class_name: "User"
+      belongs_to :post
+
+      track :new_comment,
+        on: :update,
+        actor: :author,
+        target: :post,
+        followers: :post_participants
+
+      delegate :participants, to: :post, prefix: true
+    end
+
+Parameters
+----------
+
+`track` accepts the following parameters...
+
+the first param is the verb name.
+
+The rest all fit neatly in an options hash.
+
+* `on:` [ActiveModel callback]
+  You use it to specify whether you want the timeline activity created after a create, update or destroy.
+  Default: :create
+
+* `actor:` [the method that specifies the object that took this action]
+  In the above example, comment.author is this object.
+  Default: :creator, so make sure this exists if you don't specify a method here
+
+* `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.
+
+* `extra_fields:` [accepts an array of method names that you would like to cache the value of in your timeline]
+  Defaults to nil.
+
+* `if:` symbol or proc/lambda lets you put conditions on when to track.
+
+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 'timeline'
+
+Or install it by hand:
+
+    gem install 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/tasks/timeline_tasks.rake

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

data/lib/timeline.rb

@@ -0,0 +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 Config
+  extend Helpers
+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,30 @@
+module Timeline::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")
+          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(:resque, :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/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/track.rb

@@ -0,0 +1,92 @@
+module Timeline::Track
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def track(name, options={})
+      @name = name
+      @callback = options.delete :on
+      @callback ||= :create
+      @actor = options.delete :actor
+      @actor ||= :creator
+      @object = options.delete :object
+      @target = options.delete :target
+      @followers = options.delete :followers
+      @followers ||= :followers
+      @extra_fields = options.delete :extra_fields
+
+      method_name = "track_#{@name}_after_#{@callback}".to_sym
+      define_activity_method method_name, actor: @actor, object: @object, target: @target, followers: @followers, verb: name, extra_fields: @extra_fields
+
+      send "after_#{@callback}".to_sym, method_name, if: options.delete(:if)
+    end
+
+    private
+      def define_activity_method(method_name, options={})
+        define_method method_name do
+          actor = send(options[:actor])
+          object = !options[:object].nil? ? send(options[:object].to_sym) : self
+          target = !options[:target].nil? ? send(options[:target].to_sym) : nil
+          followers = actor.send(options[:followers].to_sym)
+          add_activity activity(verb: options[:verb], actor: actor, object: object, target: target, extra_fields: options[:extra_fields]), followers
+        end
+      end
+  end
+
+  protected
+    def activity(options={})
+      {
+        verb: options[:verb],
+        actor: options_for(options[:actor]),
+        object: options_for(options[:object]),
+        target: options_for(options[:target]),
+        created_at: Time.now
+      }.merge(add_extra_fields(options[:extra_fields]))
+    end
+
+    def add_activity(activity_item, followers)
+      redis_add "global:activity", activity_item
+      add_activity_to_user(activity_item[:actor][:id], activity_item)
+      add_activity_by_user(activity_item[:actor][:id], activity_item)
+      add_activity_to_followers(followers, activity_item) if followers.any?
+    end
+
+    def add_activity_to_user(user_id, activity_item)
+      redis_add "user:id:#{user_id}:activity", activity_item
+    end
+
+    def add_activity_by_user(user_id, activity_item)
+      redis_add "user:id:#{user_id}:posts", activity_item
+    end
+
+    def add_activity_to_followers(followers, activity_item)
+      followers.each { |follower| add_activity_to_user(follower.id, activity_item) }
+    end
+
+    def add_extra_fields(extra_fields)
+      if !extra_fields.nil? and extra_fields.any?
+        extras = {}
+        extra_fields.each do |value|
+          extras[value] = send(value)
+        end
+        extras
+      else
+        {}
+      end
+    end
+
+    def redis_add(list, activity_item)
+      Timeline.redis.lpush list, Timeline.encode(activity_item)
+    end
+
+    def options_for(target)
+      if !target.nil?
+        {
+          id: target.id,
+          class: target.class.to_s,
+          display_name: target.to_s
+        }
+      else
+        nil
+      end
+    end
+end

data/lib/timeline/version.rb

@@ -0,0 +1,3 @@
+module Timeline
+  VERSION = "0.1.4"
+end

data/spec/activity_spec.rb

@@ -0,0 +1,12 @@
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe Timeline::Activity do
+  describe "initialized with json" do
+    let(:json) { MultiJson.encode({ id: "1", verb: "new_post"}) }
+
+    it "returns a Hashie-fied object" do
+      Timeline::Activity.new(json).id.should == "1"
+      Timeline::Activity.new(json).verb.should == "new_post"
+    end
+  end
+end

data/spec/actor_spec.rb

@@ -0,0 +1,23 @@
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+class User
+  include Timeline::Actor
+
+  attr_accessor :id
+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
+
+    describe ".timeline" do
+      subject { @user.timeline }
+
+      it { should == [] }
+    end
+  end
+end

data/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

data/spec/spec_helper.rb

@@ -0,0 +1,38 @@
+require File.expand_path(File.join(File.dirname(__FILE__), %w[.. lib timeline]))
+dir = File.dirname(File.expand_path(__FILE__))
+
+RSpec.configure do |config|
+
+end
+
+#
+# make sure we can run redis
+#
+
+if !system("which redis-server")
+  puts '', "** can't find `redis-server` in your path"
+  puts "** try running `sudo rake install`"
+  abort ''
+end
+
+
+#
+# start our own redis when the tests start,
+# kill it when they end
+#
+
+at_exit do
+  next if $!
+
+  exit_code = RSpec::Runner.autorun
+
+  pid = `ps -A -o pid,command | grep [r]edis-test`.split(" ")[0]
+  puts "Killing test redis server..."
+  `rm -f #{dir}/dump.rdb`
+  Process.kill("KILL", pid.to_i)
+  exit exit_code
+end
+
+puts "Starting redis for testing at localhost:9736..."
+`redis-server #{dir}/redis-test.conf`
+Timeline.redis = 'localhost:9736'

data/spec/timeline_spec.rb

@@ -0,0 +1,12 @@
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe Timeline do
+  it("can set a redis instance") { Timeline.should respond_to(:redis=) }
+  it("has a namespace, timeline") { Timeline.redis.namespace.should == :timeline }
+
+  it "sets the namespace through a url-like string" do
+    Timeline.redis = 'localhost:9736/namespace'
+    Timeline.redis.namespace.should == 'namespace'
+  end
+end
+

data/spec/track_spec.rb

@@ -0,0 +1,126 @@
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+require 'active_model'
+
+class Post
+  extend ActiveModel::Callbacks
+
+  define_model_callbacks :create
+  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 Comment
+  extend ActiveModel::Callbacks
+
+  define_model_callbacks :create
+  attr_accessor :id, :creator_id
+
+  include Timeline::Track
+
+  track :new_comment, extra_fields: [:post_name, :post_id]
+
+  def initialize(options={})
+    @creator_id = options.delete :creator_id
+  end
+
+  def save
+    run_callbacks :create
+    true
+  end
+
+  def post_id
+    1
+  end
+
+  def post_name
+    "My Post"
+  end
+
+  def creator
+    User.find(creator_id)
+  end
+
+  def to_s
+    "Comment"
+  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
+  let(:creator) { User.new(id: 1) }
+  let(:post) { Post.new(creator_id: creator.id, name: "New post") }
+
+  describe "included in an ActiveModel-compliant class" do
+    it "tracks on create by default" do
+      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", followers: []))
+      post.save
+    end
+
+    it "adds the activity to the global timeline set" do
+      post.save
+      creator.timeline(:global).last.should be_kind_of(Timeline::Activity)
+    end
+
+    it "adds the activity to the actor's timeline" do
+      post.save
+      creator.timeline.last.should be_kind_of(Timeline::Activity)
+    end
+
+    it "cc's the actor's followers by default" do
+      follower = User.new(id: 2)
+      User.any_instance.should_receive(:followers).and_return([follower])
+      post.save
+      follower.timeline.last.verb.should == "new_post"
+      follower.timeline.last.actor.id.should == 1
+    end
+  end
+
+  describe "with extra_fields" do
+    let(:comment) { Comment.new(creator_id: creator.id, id: 1) }
+
+    it "stores the extra fields in the timeline" do
+      comment.save
+      creator.timeline.first.should respond_to :post_id
+    end
+  end
+end

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification
+name: redis-timeline
+version: !ruby/object:Gem::Version
+  version: 0.1.4
+  prerelease: 
+platform: ruby
+authors:
+- Felix Clack
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70257572121320 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70257572121320
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: &70257572120820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70257572120820
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: &70257572120440 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70257572120440
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: &70257572119960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70257572119960
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: &70257572119500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70257572119500
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &70257572118860 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70257572118860
+description: ''
+email:
+- felixclack@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/tasks/timeline_tasks.rake
+- lib/timeline/activity.rb
+- lib/timeline/actor.rb
+- lib/timeline/config.rb
+- lib/timeline/helpers.rb
+- lib/timeline/track.rb
+- lib/timeline/version.rb
+- lib/timeline.rb
+- MIT-LICENSE
+- Rakefile
+- README.md
+- spec/activity_spec.rb
+- spec/actor_spec.rb
+- spec/dump.rdb
+- spec/redis-test.conf
+- spec/spec_helper.rb
+- spec/timeline_spec.rb
+- spec/track_spec.rb
+homepage: http://felixclack.github.com/timeline
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Redis backed timeline for your activity feeds.
+test_files:
+- spec/activity_spec.rb
+- spec/actor_spec.rb
+- spec/dump.rdb
+- spec/redis-test.conf
+- spec/spec_helper.rb
+- spec/timeline_spec.rb
+- spec/track_spec.rb