rediline 0.0.1

data/.gitignore

@@ -0,0 +1,3 @@
+.DS_Store
+.bundle/
+

data/.rvmrc

@@ -0,0 +1,2 @@
+rvm use 1.9.2@rediline
+rvm_gemset_create_on_use_flag=1

data/Gemfile

@@ -0,0 +1,19 @@
+source "http://rubygems.org"
+
+gem "redis", '2.0.7'
+gem "redis-namespace", '0.10.0'
+gem "json"
+gem "i18n"
+gem "activesupport", "~> 3.0.0"
+gem "activemodel", '~> 3.0.0'
+
+group :development do
+  gem "jeweler"
+end
+
+group :test do  
+  gem "rspec", '~> 2.0.0.beta'
+  gem "rspec-rails", '~> 2.0.0.beta'
+  gem "mocha", '0.9.8'
+  gem "timecop", '0.3.5'
+end

data/Gemfile.lock

@@ -0,0 +1,63 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.0.0)
+      activesupport (= 3.0.0)
+      builder (~> 2.1.2)
+      i18n (~> 0.4.1)
+    activesupport (3.0.0)
+    builder (2.1.2)
+    diff-lcs (1.1.2)
+    gemcutter (0.6.1)
+    git (1.2.5)
+    i18n (0.4.1)
+    jeweler (1.4.0)
+      gemcutter (>= 0.1.0)
+      git (>= 1.2.5)
+      rubyforge (>= 2.0.0)
+    json (1.4.6)
+    json_pure (1.4.6)
+    mocha (0.9.8)
+      rake
+    nokogiri (1.4.3.1)
+    rack (1.2.1)
+    rack-test (0.5.4)
+      rack (>= 1.0)
+    rake (0.8.7)
+    redis (2.0.7)
+    redis-namespace (0.10.0)
+      redis (< 3.0.0)
+    rspec (2.0.0.beta.18)
+      rspec-core (= 2.0.0.beta.18)
+      rspec-expectations (= 2.0.0.beta.18)
+      rspec-mocks (= 2.0.0.beta.18)
+    rspec-core (2.0.0.beta.18)
+    rspec-expectations (2.0.0.beta.18)
+      diff-lcs (>= 1.1.2)
+    rspec-mocks (2.0.0.beta.18)
+    rspec-rails (2.0.0.beta.18)
+      rspec (>= 2.0.0.beta.14)
+      webrat (>= 0.7.0)
+    rubyforge (2.0.4)
+      json_pure (>= 1.1.7)
+    timecop (0.3.5)
+    webrat (0.7.1)
+      nokogiri (>= 1.2.0)
+      rack (>= 1.0)
+      rack-test (>= 0.5.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activemodel (~> 3.0.0)
+  activesupport (~> 3.0.0)
+  i18n
+  jeweler
+  json
+  mocha (= 0.9.8)
+  redis (= 2.0.7)
+  redis-namespace (= 0.10.0)
+  rspec (~> 2.0.0.beta)
+  rspec-rails (~> 2.0.0.beta)
+  timecop (= 0.3.5)

data/README.md

@@ -0,0 +1,143 @@
+# RediLine
+*Redis Backed Timeline*
+
+Rediline is a ruby library which intends to allow you to create timelines for your users in ruby.
+
+## Installation
+
+Add the following to your Gemfile :
+
+    gem "rediline"
+
+Bundle install it and you're done, it's installed.
+
+## Configuring the user model
+
+Your user model should look like the following :
+
+    class User < ActiveRecord::Base
+        include Redline::User
+
+        rediline :timeline do
+            list :egocentric do
+                [user]
+            end
+        end
+    end
+
+This will create a timeline which will be called "timeline", with one list named "egocentric".  
+In this list, you must return an array of all the users which will see the event created there.
+
+For exemple, if your users have friends, you could do the following :
+
+    class User < ActiveRecord::Base
+        include Redline::User
+
+        rediline :timeline do
+            list :egocentric do
+                [user]
+            end
+            
+            list :public do
+                user.friends.all
+            end
+        end
+    end
+
+With this, any of your users will have two lists : an "egocentric" one, which will contain all the actions made by this same user.  
+And a "public" one, which will contain all the actions made by this user's friends.
+
+You can retrieve a list's actions with the each method.
+
+    User.first.timeline.each(:egocentric) do |action|
+        p action.inspect
+    end
+
+## Configuring the objects models and triggering events
+
+You can potentially trigger events in any kind of model, whether they are linked to an ORM or not.  
+However, when including `Rediline::Object`, your model should be compatible with `ActiveModel::Callbacks`.
+
+Here's what your model could look like :
+
+    class Post < ActiveRecord::Base
+        include Redline::Object
+        
+        redline :timeline,
+            :user => :owner,
+            :verb => :created,
+            :when => :after_create
+    end
+
+An after_create event will be added to this model and triggered every time a new post is created.  
+By default, we rely on the "user" method. But you can overwrite it to anything else like we do with "owner" here.
+
+You can also use procs to define the values.
+
+    class Post < ActiveRecord::Base
+        include Redline::Object
+        
+        redline :timeline,
+            :user => lambda {|post| post.owner },
+            :verb => :created,
+            :when => :after_create
+    end
+
+## Configuration
+
+By default, we use localhost:6379 as the redis server with the namespace "rediline".  
+However, you can change that.
+
+Rediline has a redis setter which can be given a string or a Redis object.  
+This means if you're already using Redis in your app, Rediline can re-use the existing connection.
+
+String: `Rediline.redis = 'localhost:6379'`  
+Redis: `Resque.redis = $redis`
+
+In a rails app, I have an initializer in `config/initializers/rediline.rb` where I load `config/rediline.yml` and set the redis information appropriately.
+
+My rediline.yml file is the following :
+
+    development:
+        host: localhost
+        port: 6379
+    test:
+        host: localhost
+        port: 6379
+
+And the initializer :
+
+    rediline_config = YAML::load(Rails.root.join('config', 'rediline.yml').read)[Rails.env]
+    Rediline.redis = Redis.new(
+        :host => rediline_config['host'],
+        :port => rediline_config['port'],
+        :password => rediline_config['password']
+    )
+
+## Development
+
+Want to hack on Rediline?
+
+First clone the repo and run the tests:
+
+    git clone git://github.com/dmathieu/rediline.git
+    cd rediline
+    bundle install
+    rake test
+
+If the tests do not pass make sure you have Redis installed
+correctly.
+
+
+## Contributing
+
+Once you've made your great commits:
+
+1. [Fork][1] Rediline
+2. Create a topic branch - `git checkout -b my_branch`
+3. Push to your branch - `git push origin my_branch`
+4. Create an [Issue][2] with a link to your branch
+5. That's it!
+
+[1]: http://help.github.com/forking/
+[2]: http://github.com/dmathieu/rediline/issues

data/Rakefile

@@ -0,0 +1,34 @@
+# encoding: UTF-8
+require "rubygems"
+require "bundler/setup"
+
+#
+# The rspec tasks
+#
+require 'rspec/core'
+require 'rspec/core/rake_task'
+task :default => :spec
+RSpec::Core::RakeTask.new(:spec)
+
+#
+# Jeweler
+#
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "rediline"
+    gemspec.summary = "Redis Backed Timeline"
+    gemspec.description = "Timeline library"
+    gemspec.email = "42@dmathieu.com"
+    gemspec.homepage = "http://github.com/dmathieu/rediline"
+    gemspec.authors = ["Damien MATHIEU"]
+    
+    gemspec.add_dependency "redis", '2.0.7'
+    gemspec.add_dependency "redis-namespace", '0.10.0'
+    gemspec.add_dependency "json"
+    gemspec.add_dependency "i18n"
+    gemspec.add_dependency "activesupport", "3.0.0"
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/init.rb

@@ -0,0 +1,4 @@
+require "rubygems"
+require "bundler/setup"
+
+require 'rediline'

data/lib/rediline.rb

@@ -0,0 +1,16 @@
+# encoding: UTF-8
+
+require 'active_model'
+
+require 'redis/namespace'
+require 'rediline/redis'
+require 'rediline/entry'
+require 'rediline/timeline'
+require 'rediline/object'
+require 'rediline/user'
+
+module Rediline
+  extend Rediline::Redis
+  
+  
+end

data/lib/rediline/entry.rb

@@ -0,0 +1,65 @@
+require 'json'
+require 'active_support/core_ext'
+
+module Rediline
+  
+  class Entry
+    attr_reader   :content
+    
+    def initialize(content)
+      @content = parse(content)
+      @objects = {}
+    end
+    
+    def to_json
+      @content.to_json
+    end
+    
+    def method_missing(name, *args)
+      return content[name] if content.include?(name)
+      if content.include?(:"#{name}_object") && content.include?(:"#{name}_object")
+        return @objects[name] ||= content[:"#{name}_object"].constantize.find(content[:"#{name}_id"])
+      end
+      super
+    end
+    
+    def respond_to?(name, *args)
+      return true if content.include?(name.to_s)
+      return true if content.include?("#{name}_object") && content.include?("#{name}_object")
+      super
+    end
+    
+    private
+    def parse(string)
+      if string.is_a?(String)
+        string = JSON.parse(string).symbolize_keys
+        
+        [:user_id, :user_object, :object_id, :object_object, :verb].each do |f|
+          raise "invalid content : missing field #{f}" if string[f].nil?
+        end
+      else
+        string.symbolize_keys!
+        
+        [:user, :object, :verb].each do |f|
+          raise "invalid content : missing field #{f}" if string[f].nil?
+        end
+        string[:created_at] =  string[:created_at].nil? ? Time.now.utc.to_s : string[:created_at].to_s
+        
+        object = string[:object]
+        string.keys.each do |k|
+          string[k] = string[k].call(object) if string[k].is_a?(Proc)
+          
+          case string[k]
+            when String, Symbol, Numeric
+              next
+            else
+              string[:"#{k}_object"] = string[k].class.to_s
+              string[:"#{k}_id"] = string[k].id.to_s
+              string.delete k
+          end
+        end
+      end
+      string
+    end
+  end
+end

data/lib/rediline/object.rb

@@ -0,0 +1,57 @@
+module Rediline
+  module Object
+    
+    def self.included(model)
+      model.send(:extend, ClassMethods)
+      
+      model.class_eval do
+        private
+        def rediline_key(field_name, entry, type, user=nil)
+          raise "no entry provided" if entry.nil?
+          user = entry.user if user.nil?
+          "#{field_name.to_s}:#{user.class.to_s}.#{user.id.to_s}:#{type}"
+        end
+
+        def rediline_insert!(entry, key)
+          Rediline.redis.del(key) unless Rediline.redis.type(key) == 'list'
+          Rediline.redis.rpush(key, entry.to_json)
+        end
+      end
+    end
+    
+    module ClassMethods
+      def rediline(field_name, attrs)
+        attrs.symbolize_keys!
+        callback = attrs.delete :when
+        
+        define_method "rediline_#{callback}" do
+          if attrs.frozen?
+            entry = Rediline::Entry.new(attrs.dup)
+          else
+            attrs[:object] = self
+            case attrs[:user]
+              when Symbol, String
+                attrs[:user] = send(attrs[:user])
+              when Proc
+                attrs[:user] = attrs[:user].call(self)
+              when nil
+                attrs[:user] = send(:user)
+            end
+            attrs.freeze
+            entry = Rediline::Entry.new(attrs.dup)
+          end
+          
+          entry.user.send(field_name).lists.each_pair do |k, v|
+            v.each do |user|
+              rediline_insert! entry, rediline_key(field_name, entry, k, user)
+            end
+          end
+          
+          true
+        end
+        send(callback, "rediline_#{callback}")
+      end
+      
+    end
+  end
+end

data/lib/rediline/redis.rb

@@ -0,0 +1,35 @@
+module Rediline
+  
+  module Redis
+    
+    # Accepts:
+    #   1. A 'hostname:port' string
+    #   2. A 'hostname:port:db' string (to select the Redis db)
+    #   3. An instance of `Redis`, `Redis::Client`, or `Redis::Namespace`.
+    def redis=(server)
+      case server
+        when String
+          host, port, db = server.split(':')
+          redis = ::Redis.new(:host => host, :port => port,
+            :thread_safe => true, :db => db)
+          @redis = ::Redis::Namespace.new(:rediline, :redis => redis)
+        when ::Redis, ::Redis::Client
+          @redis = ::Redis::Namespace.new(:rediline, :redis => server)
+        when ::Redis::Namespace
+          @redis = server
+        when nil
+          @redis = nil
+        else
+          raise "I don't know what to do with #{server.inspect}"
+        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 = 'localhost:6379'
+      self.redis
+    end
+  end
+end

data/lib/rediline/timeline.rb

@@ -0,0 +1,7 @@
+require 'rediline/timeline/user'
+
+module Rediline
+  module Timeline
+    
+  end
+end

data/lib/rediline/timeline/user.rb

@@ -0,0 +1,42 @@
+module Rediline
+  module Timeline
+    class User
+      attr_reader    :field_name, :user, :block, :lists
+
+      def initialize(field_name, user, block)
+        @field_name, @user, @block = field_name, user
+        @lists = {}
+        instance_eval(&block)
+      end
+      
+      def each(type)
+        raise "you must provide a block" unless block_given?
+        (0..count(type)-1).each do |i|
+          data = Rediline.redis.lindex(key(type), i)
+          yield Rediline::Entry.new(data)
+        end
+      end
+
+      def to_a(type)
+        result = Array.new
+        self.each(type) do |entry|
+          result << entry
+        end
+        result
+      end
+
+      def count(type)
+        Rediline.redis.llen(key(type))
+      end
+      
+      def list(name, &block)
+        @lists[name] = instance_eval(&block)
+      end
+      
+      private
+      def key(type)
+        "#{field_name.to_s}:#{@user.class.to_s}.#{@user.id.to_s}:#{type}"
+      end
+    end
+  end
+end

data/lib/rediline/user.rb

@@ -0,0 +1,15 @@
+module Rediline
+  module User
+    
+    def self.included(model)
+      model.extend(ClassMethods)
+    end
+    module ClassMethods
+      def rediline(field_name, &block)
+        define_method field_name.to_sym do
+          Rediline::Timeline::User.new(field_name.to_sym, self, block)
+        end
+      end
+    end
+  end
+end

data/rediline.gemspec

@@ -0,0 +1,89 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{rediline}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Damien MATHIEU"]
+  s.date = %q{2010-09-23}
+  s.description = %q{Timeline library}
+  s.email = %q{42@dmathieu.com}
+  s.extra_rdoc_files = [
+    "README.md"
+  ]
+  s.files = [
+    ".gitignore",
+     ".rvmrc",
+     "Gemfile",
+     "Gemfile.lock",
+     "README.md",
+     "Rakefile",
+     "VERSION",
+     "init.rb",
+     "lib/rediline.rb",
+     "lib/rediline/entry.rb",
+     "lib/rediline/object.rb",
+     "lib/rediline/redis.rb",
+     "lib/rediline/timeline.rb",
+     "lib/rediline/timeline/user.rb",
+     "lib/rediline/user.rb",
+     "rediline.gemspec",
+     "spec/entry_spec.rb",
+     "spec/object_spec.rb",
+     "spec/redis_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/support/timeline.rb",
+     "spec/support/timeline_owner.rb",
+     "spec/support/user.rb",
+     "spec/timeline/user_spec.rb",
+     "spec/timeline_spec.rb",
+     "spec/user_spec.rb"
+  ]
+  s.homepage = %q{http://github.com/dmathieu/rediline}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Redis Backed Timeline}
+  s.test_files = [
+    "spec/entry_spec.rb",
+     "spec/object_spec.rb",
+     "spec/redis_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/support/timeline.rb",
+     "spec/support/timeline_owner.rb",
+     "spec/support/user.rb",
+     "spec/timeline/user_spec.rb",
+     "spec/timeline_spec.rb",
+     "spec/user_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<redis>, ["= 2.0.7"])
+      s.add_runtime_dependency(%q<redis-namespace>, ["= 0.10.0"])
+      s.add_runtime_dependency(%q<json>, [">= 0"])
+      s.add_runtime_dependency(%q<i18n>, [">= 0"])
+      s.add_runtime_dependency(%q<activesupport>, ["= 3.0.0"])
+    else
+      s.add_dependency(%q<redis>, ["= 2.0.7"])
+      s.add_dependency(%q<redis-namespace>, ["= 0.10.0"])
+      s.add_dependency(%q<json>, [">= 0"])
+      s.add_dependency(%q<i18n>, [">= 0"])
+      s.add_dependency(%q<activesupport>, ["= 3.0.0"])
+    end
+  else
+    s.add_dependency(%q<redis>, ["= 2.0.7"])
+    s.add_dependency(%q<redis-namespace>, ["= 0.10.0"])
+    s.add_dependency(%q<json>, [">= 0"])
+    s.add_dependency(%q<i18n>, [">= 0"])
+    s.add_dependency(%q<activesupport>, ["= 3.0.0"])
+  end
+end
+

data/spec/entry_spec.rb

@@ -0,0 +1,127 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe Rediline::Entry do
+  
+  it 'should initialize' do
+    lambda do
+      Rediline::Entry.new valid_hash
+    end.should_not raise_error
+  end
+  
+  it 'should initialize with a hash' do
+    lambda do
+      Rediline::Entry.new valid_hash
+    end.should_not raise_error
+  end
+  
+  describe 'when initializing with a string' do
+    [:object_object, :object_id, :user_object, :user_id, :verb].each do |f|
+      it "should require a #{f}" do
+        c = valid_json
+        c.delete f
+        lambda do
+          Rediline::Entry.new c.to_json
+        end.should raise_error "invalid content : missing field #{f}"
+      end
+      
+      it "should define the #{f} attribute" do
+        entry = Rediline::Entry.new valid_json.to_json
+        entry.send(f).should_not be_nil
+      end
+    end
+    
+    [:object, :user].each do |o|
+      it "should not have any #{o} object in its content" do
+        entry = Rediline::Entry.new valid_json.to_json
+        entry.content[o].should be_nil
+      end
+    end
+  end
+  
+  describe 'when initializing with a hash' do
+    [:object, :user, :verb].each do |f|
+      it "should require a #{f}" do
+        c = valid_hash
+        c.delete f
+        lambda do
+          Rediline::Entry.new c
+        end.should raise_error "invalid content : missing field #{f}"
+      end
+      
+      it "should define the #{f} attribute" do
+        entry = Rediline::Entry.new valid_hash
+        entry.send(f).should_not be_nil
+      end
+    end
+    
+    [:object, :user].each do |o|
+      it "should not have any #{o} object in its content" do
+        entry = Rediline::Entry.new valid_json.to_json
+        entry.content[o].should be_nil
+      end
+    end
+    
+    it 'should allow us to define an other object' do
+      c = valid_hash
+      c[:second_object] = TestingTimelineObject.new(666)
+      entry = Rediline::Entry.new c
+      entry.second_object.should be_kind_of(TestingTimelineObject)
+      entry.second_object.id.should eql('666')
+    end
+    
+    it 'should allow us to define an other object as a proc' do
+      c = valid_hash
+      c[:second_object] = lambda {|o| o.id }
+      entry = Rediline::Entry.new c
+      entry.second_object.should eql(42)
+    end
+  end
+  
+  describe 'creation date' do
+    it 'should define the creation date' do
+      Timecop.freeze(Time.now) do
+        entry = Rediline::Entry.new valid_hash
+        entry.created_at.should eql(Time.now.utc.to_s)
+      end
+    end
+    
+    it 'should be possible to define our own creation date' do
+      Timecop.freeze(Time.now) do
+        c = valid_hash
+        c[:created_at] = Date.new(2010, 01, 01).to_s
+        entry = Rediline::Entry.new c
+        entry.created_at.should eql(Date.new(2010, 01, 01).to_s)
+      end
+    end
+  end
+  
+  describe 'to_json' do
+    it 'should return the attributes in json' do
+      entry = Rediline::Entry.new valid_hash
+      entry.to_json.should be_kind_of(String)
+      json = JSON.parse(entry.to_json)
+      valid_json.each_pair do |k, v|
+        valid_json[k].to_s.should eql(json[k.to_s])
+      end
+    end
+  end
+  
+  def valid_hash
+    {
+      :object => TestingTimelineObject.new(42),
+      :user => User.new(1),
+      :verb => :created
+    }
+  end
+  
+  def valid_json
+    {
+      :object_object => "TestingTimelineObject",
+      :object_id => 42,
+      :user_object => "User",
+      :user_id => 1,
+      :verb => :created
+    }
+  end
+end

data/spec/object_spec.rb

@@ -0,0 +1,99 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe Rediline::Object do
+  before :each do
+    @object = TestingTimelineObject.new(1, User.new(1))
+    @entry = Rediline::Entry.new(valid_log)
+  end
+  
+  it 'should have the rediline method' do
+    TestingTimelineObject.respond_to?(:rediline).should be_true
+  end
+  
+  [:after_create, :before_destroy].each do |c|
+    it "should create the #{c} callback" do
+      @object.respond_to?("rediline_#{c}".to_sym).should be_true
+    end
+    
+    it 'should not fail to call the callback' do
+      lambda do
+        @object.send("rediline_#{c}".to_sym)
+      end.should_not raise_error
+    end
+    
+    it 'should add the log for the egocentric list' do
+      length = User.new(1).timeline.count(:egocentric)
+      @object.send("rediline_#{c}".to_sym)
+      User.new(1).timeline.count(:egocentric).should eql(length + 1)
+    end
+    
+    it 'should add the logs for the public list' do
+      length1 = User.new(15).timeline.count(:public)
+      length2 = User.new(16).timeline.count(:public)
+      @object.send("rediline_#{c}".to_sym)
+      User.new(15).timeline.count(:public).should eql(length1 + 1)
+      User.new(16).timeline.count(:public).should eql(length2 + 1)
+    end
+    
+    describe 'not default user field' do
+      before :each do
+        @object = TestingTimelineObjectWithOwner.new(1, User.new(1))
+      end
+      
+      it 'should not fail to call the callback' do
+        lambda do
+          @object.send("rediline_#{c}".to_sym)
+        end
+      end
+      
+      it 'should add the log for the egocentric list' do
+        length = User.new(1).timeline.count(:egocentric)
+        @object.send("rediline_#{c}".to_sym)
+        User.new(1).timeline.count(:egocentric).should eql(length + 1)
+      end
+
+      it 'should add the logs for the public list' do
+        length1 = User.new(15).timeline.count(:public)
+        length2 = User.new(16).timeline.count(:public)
+        @object.send("rediline_#{c}".to_sym)
+        User.new(15).timeline.count(:public).should eql(length1 + 1)
+        User.new(16).timeline.count(:public).should eql(length2 + 1)
+      end
+    end
+  end
+  
+  describe 'rediline_key' do
+    it 'should return the timeline\'s key' do
+      @object.send(:rediline_key, :timeline, @entry, :egocentric).should eql('timeline:User.1:egocentric')
+    end
+    
+    it 'should define a different user' do
+      @object.send(:rediline_key, :timeline, @entry, :egocentric, User.new(15)).should eql('timeline:User.15:egocentric')
+    end
+  end
+  
+  describe 'rediline_insert!' do
+    it 'should delete the key if it was not a list' do
+      Rediline.redis.set "testing", "string key"
+      lambda do
+        @object.send(:rediline_insert!, {:test => true}, "testing")
+      end.should_not raise_error
+      Rediline.redis.type("testing").should eql('list')
+    end
+
+    it 'should push a new key to the list' do
+      length = Rediline.redis.llen("testing")
+      @object.send(:rediline_insert!, {:test => true}, "testing")
+      Rediline.redis.llen("testing").should eql(length + 1)
+    end
+  end
+  
+  def valid_log
+    {
+      :object => @object,
+      :user => User.new(1),
+      :verb => :created
+    }
+  end
+end

data/spec/redis_spec.rb

@@ -0,0 +1,63 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe Rediline do
+  
+  describe 'redis=' do
+    it 'should define a redis server with a string' do
+      lambda do
+        Rediline.redis = 'localhost:6379'
+      end.should_not raise_error
+    end
+    it 'should define a redis server with a string/db' do
+      lambda do
+        Rediline.redis = 'localhost:6379:dmathieu'
+      end.should_not raise_error
+    end
+    
+    it 'should define a redis server with a Redis object' do
+      lambda do
+        Rediline.redis = ::Redis.new(:host => 'localhost', :port => '6379',
+          :thread_safe => true, :db => 'dmathieu')
+      end.should_not raise_error
+    end
+    
+    it 'should define a redis server with a Redis::Client object' do
+      lambda do
+        Rediline.redis = ::Redis::Client.new(:host => 'localhost', :port => '6379',
+          :thread_safe => true, :db => 'dmathieu')
+      end.should_not raise_error
+    end
+    
+    it 'should define a redis server with a Redis::Namespace object' do
+      lambda do
+        redis = ::Redis.new(:host => 'localhost', :port => '6379',
+          :thread_safe => true, :db => 'dmathieu')
+        Rediline.redis = ::Redis::Namespace.new(:dmathieu, :redis => redis)
+      end.should_not raise_error
+    end
+    
+    it 'should close the connection' do
+      lambda do
+        Rediline.redis = nil
+      end.should_not raise_error
+    end
+    
+    it 'should not know what to do with that' do
+      lambda do
+        Rediline.redis = Rediline::Redis
+      end.should raise_error
+    end
+  end
+  
+  describe 'redis' do
+    it 'should return the redis object' do
+      Rediline.redis.should be_kind_of Redis::Namespace
+    end
+    
+    it 'should initialize a new redis object' do
+      Rediline.redis = nil
+      Rediline.redis.should be_kind_of Redis::Namespace
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+# encoding: UTF-8
+require 'rediline'
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+require 'rspec'
+require 'timecop'
+require 'mocha'

data/spec/support/timeline.rb

@@ -0,0 +1,34 @@
+class TestingTimelineObject
+  extend ActiveModel::Callbacks
+  define_model_callbacks :create, :destroy
+  include Rediline::Object
+  
+  rediline :timeline,
+    :user => :user,
+    :verb => :created,
+    :when => :after_create
+  rediline :timeline,
+      :user => lambda {|o| o.user },
+      :verb => :destroyed,
+      :when => :before_destroy
+  
+  attr_reader   :id, :user
+  def initialize(id, user=nil)
+    @id, @user = id, user
+  end
+  
+  def self.find(id, user=nil)
+    self.new(id, user)
+  end
+  
+  def create
+    _run_create_callbacks do
+      # Your create action methods here
+    end
+  end
+  def destroy
+    _run_destroy_callbacks do
+      # Your destroy action methods here
+    end
+  end
+end

data/spec/support/timeline_owner.rb

@@ -0,0 +1,34 @@
+class TestingTimelineObjectWithOwner
+  extend ActiveModel::Callbacks
+  define_model_callbacks :create, :destroy
+  include Rediline::Object
+  
+  rediline :timeline,
+    :user => :owner,
+    :verb => :created,
+    :when => :after_create
+  rediline :timeline,
+      :user => :owner,
+      :verb => :created,
+      :when => :before_destroy
+  
+  attr_reader   :id, :owner
+  def initialize(id, owner=nil)
+    @id, @owner = id, owner
+  end
+  
+  def self.find(id, owner=nil)
+    self.new(id, owner)
+  end
+  
+  def create
+    _run_create_callbacks do
+      # Your create action methods here
+    end
+  end
+  def destroy
+    _run_destroy_callbacks do
+      # Your destroy action methods here
+    end
+  end
+end

data/spec/support/user.rb

@@ -0,0 +1,20 @@
+class User
+  include Rediline::User
+  rediline :timeline do
+    list :egocentric do
+      [user]
+    end
+    list :public do
+      [User.new(15), User.new(16)]
+    end
+  end
+  
+  attr_reader   :id
+  def initialize(id)
+    @id = id
+  end
+  
+  def self.find(id)
+    self.new(id)
+  end
+end

data/spec/timeline/user_spec.rb

@@ -0,0 +1,71 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe Rediline::Timeline::User do
+  before :each do
+    @timeline = User.new(1).timeline
+  end
+  
+  describe 'lists' do
+    it 'should have defined the egocentric list' do
+      @timeline.lists.should_not be_empty
+    end
+    it 'should have the egocentric list with one user' do
+      @timeline.lists[:egocentric].length.should eql(1)
+    end
+    it 'should have the public list with two users' do
+      @timeline.lists[:public].length.should eql(2)
+    end
+    
+    it 'should be able to add a new list' do
+      @timeline.lists[:testing].should be_nil
+      @timeline.list(:testing) { [user] }
+      @timeline.lists[:testing].should_not be_nil
+    end
+  end
+  
+  describe 'each' do
+    it 'should require a block' do
+      lambda do
+        @timeline.each(:egocentric)
+      end.should raise_error 'you must provide a block'
+    end
+    
+    it 'should loop through the list' do
+      @timeline.each(:egocentric) do |entry|
+        entry.should be_kind_of(Rediline::Entry)
+      end
+    end
+    
+    [:object, :user].each do |o|
+      it "should not have any #{o} in it\'s values" do
+        @timeline.each(:egocentric) do |entry|
+          entry.content[o].should be_nil
+        end
+      end
+    end
+  end
+  
+  describe 'to_a' do
+    it 'should return an array' do
+      @timeline.to_a(:egocentric).should be_kind_of(Array)
+    end
+    it 'should have the entries' do
+      @timeline.to_a(:egocentric).each do |entry|
+        entry.should be_kind_of(Rediline::Entry)
+      end
+    end
+  end
+  
+  describe 'count' do
+    it 'should return an integer' do
+      @timeline.count(:egocentric).should be_kind_of(Integer)
+    end
+  end
+  
+  describe 'key' do
+    it 'should return the timeline\'s key' do
+      @timeline.send(:key, :egocentric).should eql('timeline:User.1:egocentric')
+    end
+  end
+end

data/spec/timeline_spec.rb

@@ -0,0 +1,6 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe Rediline::Timeline do
+  
+end

data/spec/user_spec.rb

@@ -0,0 +1,13 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe Rediline::User do
+  
+  it 'should have the timeline method' do
+    User.new(1).respond_to?(:timeline).should eql(true)
+  end
+    
+  it 'should return a timeline object' do
+    User.new(1).timeline.should be_kind_of(Rediline::Timeline::User)
+  end
+end

metadata

@@ -0,0 +1,169 @@
+--- !ruby/object:Gem::Specification 
+name: rediline
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Damien MATHIEU
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-23 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: redis
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        - 7
+        version: 2.0.7
+  type: :runtime
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: redis-namespace
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 10
+        - 0
+        version: 0.10.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: json
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: i18n
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *id005
+description: Timeline library
+email: 42@dmathieu.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- .gitignore
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- VERSION
+- init.rb
+- lib/rediline.rb
+- lib/rediline/entry.rb
+- lib/rediline/object.rb
+- lib/rediline/redis.rb
+- lib/rediline/timeline.rb
+- lib/rediline/timeline/user.rb
+- lib/rediline/user.rb
+- rediline.gemspec
+- spec/entry_spec.rb
+- spec/object_spec.rb
+- spec/redis_spec.rb
+- spec/spec_helper.rb
+- spec/support/timeline.rb
+- spec/support/timeline_owner.rb
+- spec/support/user.rb
+- spec/timeline/user_spec.rb
+- spec/timeline_spec.rb
+- spec/user_spec.rb
+has_rdoc: true
+homepage: http://github.com/dmathieu/rediline
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 1586793397385962776
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Redis Backed Timeline
+test_files: 
+- spec/entry_spec.rb
+- spec/object_spec.rb
+- spec/redis_spec.rb
+- spec/spec_helper.rb
+- spec/support/timeline.rb
+- spec/support/timeline_owner.rb
+- spec/support/user.rb
+- spec/timeline/user_spec.rb
+- spec/timeline_spec.rb
+- spec/user_spec.rb