seymour 0.0.7 → 0.0.8

data/.gitignore

@@ -6,3 +6,5 @@ spec/dummy/log/*.log
 spec/dummy/tmp/
 tmp/
 .rspec
+Gemfile.lock
+Gemfile.local

data/.travis.yml

@@ -0,0 +1,7 @@
+rvm:
+  - 1.9.2
+  - ree
+
+before_script: "sh -c 'cd spec/dummy && bundle exec rake db:migrate'"
+
+gemfile: Gemfile.ci

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## 0.0.8 (2012-2-06)
+
+* travis build status; clean Gemfile dependencies
+* Move rails initialization to railtie
+* Added support for zunionstore and zinterstore
+* extract redis list object from feed
+* feed class method 'key' to define key override
+
+## 0.0.7 (2011-12-04)
+
+* Support for zset feeds
+* Extract redis methods to store module
+* Rails generator for basic feed
+
 ## 0.0.6 (2011-10-24)
 
 * Ruby 1.8.7 compatiblity

data/Gemfile

@@ -1,23 +1,21 @@
-source "http://rubygems.org"
+source :rubygems
 
-# Declare your gem's dependencies in seymour.gemspec.
-# Bundler will treat runtime dependencies like base dependencies, and
-# development dependencies will be added by default to the :development group.
 gemspec
+gem 'redis-namespace', :git => "git://github.com/defunkt/redis-namespace.git"
 
 # Declare any dependencies that are still in development here instead of in
 # your gemspec. These might include edge Rails or gems from your path or
 # Git. Remember to move these dependencies to your gemspec before releasing
 # your gem to rubygems.org.
 
-# To use debugger
-group :test, :development do
-  gem 'ruby-debug19', :require => 'ruby-debug', :platform => :ruby_19
-  gem 'ruby-debug', :platform => :ruby_18
-  gem 'guard'
-  gem 'guard-rspec'
-  gem 'rb-fsevent' # Makes guard better
-  gem 'growl_notify' # Makes guard better
-  gem 'launchy'
-  gem 'yard'
-end
+# # To use debugger
+# group :development do
+#   gem 'ruby-debug19', :require => 'ruby-debug', :platform => :ruby_19
+#   gem 'ruby-debug', :platform => :ruby_18
+#   gem 'guard'
+#   gem 'guard-rspec'
+#   gem 'rb-fsevent' # Makes guard better
+#   gem 'growl_notify' # Makes guard better
+#   gem 'launchy'
+#   gem 'yard'
+# end

data/Gemfile.ci

@@ -0,0 +1,4 @@
+source :rubygems
+
+gemspec
+gem 'redis-namespace', :git => "git://github.com/defunkt/redis-namespace.git"

data/README.md

@@ -5,6 +5,9 @@ Feed me activities, Seymour, please!
 Seymour is a library for distributing activity items to  Redis-backed activity feeds
 in a Rails application.
 
+[![Build Status](https://secure.travis-ci.org/rossta/seymour.png)](http://travis-ci.org/rossta/seymour)
+
+
 ## Install
 
 In your Gemfile

data/lib/seymour.rb

@@ -1,10 +1,12 @@
 require "seymour/version"
 require "seymour/redis"
+require "seymour/store"
 require "seymour/feed"
 require "seymour/acts_as_activity"
 require "seymour/distributable"
 require "seymour/renderable"
 require "seymour/render_controller"
+require 'seymour/railtie' if defined?(Rails)
 
 module Seymour
   extend self

data/lib/seymour/acts_as_activity.rb

@@ -14,5 +14,3 @@ module Seymour
 
   end
 end
-
-ActiveRecord::Base.send :include, Seymour::ActsAsActivity

data/lib/seymour/feed.rb

@@ -4,79 +4,55 @@ module Seymour
     attr_accessor :owner
 
     class << self
-      @@feed_classes = []
+
+      def key(&block)
+        define_method('key_to_store', &block)
+      end
 
       def distribute(activity)
         activity.distribute
       end
 
       def inherited(subclass)
-        @@feed_classes << subclass
+        feed_classes << subclass
       end
 
       def feed_classes
-        @@feed_classes
+        @@feed_classes ||= []
       end
-    end
-
-    def initialize(owner)
-      @owner = owner
-    end
 
-    def activity_ids
-      redis.lrange(key, 0, max_size).map{|id| id.to_i }
-    end
-
-    def push(activity)
-      perform_push(activity.id) if should_push?(activity)
-    end
-
-    def bulk_push(activities)
-      activities.each do |activity|
-        push(activity)
+      def store(store_type)
+        @store_type = "seymour/store/#{store_type}".camelize.constantize
       end
-    end
 
-    def remove(activity)
-      remove_id activity.id
+      def store_type
+        @store_type ||= Seymour::Store::List
+      end
     end
 
-    def remove_id(activity_id)
-      redis.lrem(key, 0, activity_id)
+    def initialize(owner)
+      @owner = owner
     end
 
-    def sort!(options = {})
-      sort({ :order => "DESC", :store => key }.merge(options)) # replaces itself with sorted list
-    end
+    delegate  :key, :key=, :push, :sort, :sort!, :insert_and_order, :bulk_push,
+              :remove, :remove_id, :remove_all, :ids, :activity_ids, :to => :store
 
-    def sort(options = {})
-      redis.sort(key, options)
-    end
+    delegate  :union, :intersect, :to => :store
 
-    def sorted_push(activities)
-      bulk_push(activities)
-      sort!
+    def store
+      @store ||= self.class.store_type.new(key_to_store)
     end
-    alias_method :insert_and_order, :sorted_push
 
     protected
 
-    def redis
-      @redis ||= Seymour.redis
-    end
-
-    def remove_all
-      redis.del(key)
+    def key_to_store
+      "#{owner_name}:#{id_for_key}/#{feed_name}"
     end
 
     def owner_name
       owner.class.name
     end
 
-    def key
-      "#{owner.class.name}:#{id_for_key}/#{feed_name}"
-    end
-
     def id_for_key
       owner.id
     end
@@ -85,17 +61,5 @@ module Seymour
       self.class.name.downcase
     end
 
-    def max_size
-      100
-    end
-
-    def should_push?(activity)
-      !activity_ids.include?(activity.id)
-    end
-
-    def perform_push(id)
-      redis.lpush(key, id)
-      redis.ltrim(key, 0, max_size)
-    end
   end
 end

data/lib/seymour/railtie.rb

@@ -0,0 +1,20 @@
+module Seymour
+  class Railtie < Rails::Railtie
+    config.app_generators.integration_tool :rspec
+    config.app_generators.test_framework   :rspec
+
+    generators do
+      require 'generators/seymour/feed/feed_generator'
+    end
+
+    rake_tasks do
+      require 'seymour/tasks/seymour_tasks'
+    end
+
+    initializer "seymour.acts_as_activity" do
+      ActiveSupport.on_load :active_record do
+        include ActsAsActivity
+      end
+    end
+  end
+end

data/lib/seymour/redis.rb

@@ -1,12 +1,17 @@
 require 'redis-namespace'
 
 module Seymour
+
+  module Redis
+    
+  end
+
   ## Courtesy of resque
   # 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 = ::Redis.respond_to?(:connect) ? ::Redis.connect : "localhost:6379"
     self.redis
   end
 
@@ -21,20 +26,20 @@ module Seymour
     case server
     when String
       if server =~ /redis\:\/\//
-        redis = Redis.connect(:url => server, :thread_safe => true)
+        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,
+        redis = ::Redis.new(:host => host, :port => port,
           :thread_safe => true, :db => db)
       end
       namespace ||= :seymour
 
-      @redis = Redis::Namespace.new(namespace, :redis => redis)
-    when Redis::Namespace
+      @redis = ::Redis::Namespace.new(namespace, :redis => redis)
+    when ::Redis::Namespace
       @redis = server
     else
-      @redis = Redis::Namespace.new(:seymour, :redis => server)
+      @redis = ::Redis::Namespace.new(:seymour, :redis => server)
     end
   end
 end

data/lib/seymour/store.rb

@@ -0,0 +1,7 @@
+module Seymour
+  module Store
+  end
+end
+require 'seymour/store/base'
+require 'seymour/store/list'
+require 'seymour/store/zset'

data/lib/seymour/store/base.rb

@@ -0,0 +1,35 @@
+module Seymour
+  module Store
+    class Base
+      attr_accessor :key
+
+      def initialize(key, options = {})
+        @key = key
+        @options = options
+      end
+
+      def redis
+        @redis ||= Seymour.redis
+      end
+
+      def activity_ids
+        ids
+      end
+
+      def max_size
+        100
+      end
+
+      def bulk_push(activities)
+        activities.each do |activity|
+          push(activity)
+        end
+      end
+
+      def remove(activity)
+        remove_id(activity.id)
+      end
+
+    end
+  end
+end

data/lib/seymour/store/list.rb

@@ -0,0 +1,104 @@
+module Seymour
+  module Store
+    class List < Seymour::Store::Base
+
+      def ids
+        redis.lrange(key, 0, max_size).map(&:to_i)
+      end
+
+      def push(activity)
+        perform_push(activity.id) if should_push?(activity)
+      end
+
+      def remove_id(id)
+        redis.lrem(key, 0, id)
+      end
+
+      def remove_all
+        redis.del(key)
+      end
+
+      def sort!(options = {})
+        sort({ :order => "DESC", :store => key }.merge(options)) # replaces itself with sorted list
+      end
+
+      def sort(options = {})
+        redis.sort(key, options)
+      end
+
+      def sorted_push(activities)
+        bulk_push(activities)
+        sort!
+      end
+      alias_method :insert_and_order, :sorted_push
+
+      private
+
+      def perform_push(id)
+        redis.lpush(key, id)
+        redis.ltrim(key, 0, max_size)
+      end
+
+      def should_push?(activity)
+        !activity_ids.include?(activity.id)
+      end
+
+      # def llen
+      #   redis.llen(@key)
+      # end
+      #
+      # def rpop
+      #   redis.rpop(@key)
+      # end
+      #
+      # def rpoplpush(destination)
+      #   if destination.is_a?(RedisList)
+      #     redis.rpoplpush(@key, destination.key)
+      #     destination.trim_to_max_size
+      #   else
+      #     redis.rpoplpush(@key, destination)
+      #   end
+      # end
+      #
+      # def lpush(val)
+      #   redis.lpush(@key, val)
+      #   trim_to_max_size
+      # end
+      #
+      # def push_multi(elements)
+      #   redis.pipelined do
+      #     elements.each { |element| redis.rpush(@key, element) }
+      #   end
+      # end
+      #
+      # def lrange(start_index, end_index)
+      #   arr = redis.lrange(@key, start_index, end_index)
+      #   typecast arr
+      # end
+      #
+      # def all
+      #   lrange(0, -1)
+      # end
+      #
+      # def ltrim(start_index, end_index)
+      #   redis.ltrim(@key, start_index, end_index)
+      # rescue => ex
+      #   raise unless ex.message =~ /no such key/
+      # end
+      #
+      # def trim_to_max_size
+      #   if max_size
+      #     redis.ltrim(@key, 0, max_size - 1)
+      #   end
+      # end
+      #
+      # def lrem(value, count = 1)
+      #   redis.lrem(@key, count, value)
+      # end
+      #
+      # def max_size
+      #   @options[:max_size]
+      # end
+    end
+  end
+end

data/lib/seymour/store/zset.rb

@@ -0,0 +1,75 @@
+module Seymour
+  module Store
+    class Zset < Seymour::Store::Base
+
+      def push(activity, score = activity.score)
+        redis.zadd(key, score, activity.id)
+      end
+
+      def ids
+        redis.zrevrange(key, 0, max_size).map(&:to_i)
+      end
+
+      def remove_id(id)
+        redis.zrem(key, id)
+      end
+
+      def union_keys(keys, options = {})
+        redis.zunionstore key, keys, options
+      end
+
+      def union(feeds, options = { :exclude_options => true })
+        redis.zunionstore key, feeds.map(&:key), options
+      end
+
+      def intersect(feeds, options = {})
+        redis.zinterstore key, feeds.map(&:key), options
+      end
+
+      # def zadd(score, member)
+      #   redis.zadd(@key, score, member)
+      # end
+
+      # def zrange(range_start, range_end)
+      #   typecast redis.zrange(@key, range_start, range_end)
+      # end
+      #
+      # def zrem(member)
+      #   redis.zrem(@key, member)
+      # end
+      #
+      # def zincrby(increment, member)
+      #   redis.zincrby(@key, increment, member)
+      # end
+      #
+      # def zincr(member)
+      #   zincrby(1, member)
+      # end
+      #
+      # def zrevrange(range_start, range_end)
+      #   typecast redis.zrevrange(@key, range_start, range_end)
+      # end
+      #
+      # def zrangebyscore(min, max)
+      #   typecast redis.zrangebyscore(@key, min, max)
+      # end
+      #
+      # def zcard
+      #   redis.zcard(@key)
+      # end
+      #
+      # def zscore(member)
+      #   redis.zscore(@key, member).to_f
+      # end
+      #
+      # def zremrangebyscore(min, max)
+      #   redis.zremrangebyscore(@key, min, max)
+      # end
+      #
+      # def zremrangebyrank(start, _end)
+      #   redis.zremrangebyrank(@key, start, _end)
+      # end
+
+    end
+  end
+end