unread 0.1.2 → 0.2.0

data/.travis.yml

@@ -3,7 +3,6 @@ rvm:
   - 1.8.7
   - 1.9.3
 gemfile:
-  - ci/Gemfile.rails-2.3.x
   - ci/Gemfile.rails-3.0.x
   - ci/Gemfile.rails-3.1.x
   - ci/Gemfile.rails-3.2.x
@@ -11,4 +10,4 @@ env:
   - DB=sqlite
   - DB=mysql
 before_script:
-  - "mysql -e 'create database myapp_test;' >/dev/null"
+  - "mysql -e 'create database myapp_test;' >/dev/null"

data/Gemfile

@@ -1,4 +1,4 @@
-source "http://rubygems.org"
+source "https://rubygems.org"
 
 # Specify your gem's dependencies in unread.gemspec
 gemspec

data/README.md

@@ -4,7 +4,7 @@ Unread
 Ruby gem to manage read/unread status of ActiveRecord objects - and it's fast.
 
 [![Build Status](https://secure.travis-ci.org/ledermann/unread.png)](http://travis-ci.org/ledermann/unread)
-
+[![Code Climate](https://codeclimate.com/github/ledermann/unread.png)](https://codeclimate.com/github/ledermann/unread)
 
 ## Features
 
@@ -19,7 +19,7 @@ Ruby gem to manage read/unread status of ActiveRecord objects - and it's fast.
 ## Requirements
 
 * Ruby 1.8.7 or 1.9.3
-* Rails >= 2.3.6 (including 3.0, 3.1, 3.2)
+* Rails 3 (including 3.0, 3.1, 3.2). The use with Rails 2.3 there is a branch named "rails2"
 * Tested with SQLite and MySQL
 * Needs a timestamp field in your models (like created_at or updated_at) with a database index on it
 
@@ -28,38 +28,24 @@ Ruby gem to manage read/unread status of ActiveRecord objects - and it's fast.
 
 Step 1: Add this to your Gemfile:
 
-    gem 'unread'
+```ruby
+gem 'unread'
+```
 
 and run
 
-    bundle
+```shell
+bundle
+```
 
 
-Step 2: Add this migration:
+Step 2: Generate and run the migration:
 
-```ruby
-class CreateReadMarks < ActiveRecord::Migration
-  def self.up
-    create_table :read_marks, :force => true do |t|
-      t.integer  :readable_id
-      t.integer  :user_id,       :null => false
-      t.string   :readable_type, :null => false, :limit => 20
-      t.datetime :timestamp
-    end
-
-    add_index :read_marks, [:user_id, :readable_type, :readable_id]
-  end
-
-  def self.down
-    drop_table :read_marks
-  end
-end
+```shell
+rails g unread:migration
+rake db:migrate
 ```
 
-  and run the migration:
-
-    rake db:migrate
-
 
 ## Usage
 
@@ -122,7 +108,7 @@ current_user = User.find(42)
 Message.unread_by(current_user)
 ```
 
-Generated query: 
+Generated query:
 
 ```sql
 SELECT messages.*
@@ -148,4 +134,4 @@ There are two other gems/plugins doing a similar job:
 Unfortunately, both of them have a lack of performance, because they calculate the unread records doing a `find(:all)`, which should be avoided for a large amount of records. This gem is based on a timestamp algorithm and therefore it's very fast.
 
 
-Copyright (c) 2010-2013 [Georg Ledermann](http://www.georg-ledermann.de), released under the MIT license
+Copyright (c) 2010-2013 [Georg Ledermann](http://www.georg-ledermann.de), released under the MIT license

data/Rakefile

@@ -12,4 +12,4 @@ Rake::TestTask.new(:test) do |t|
   t.libs << 'test'
   t.pattern = 'test/**/*_test.rb'
   t.verbose = true
-end
+end

data/changelog.md

@@ -1,3 +1,9 @@
+0.2.0 - WIP
+
+* Support for Rails 2 dropped
+* Refactoring
+* Added migration generator
+
 0.1.2 - 2013/01/27
 
 * Scopes: Improved parameter check
@@ -39,8 +45,8 @@
 
 0.0.2 - 2011/06/23
 
-* Fixed scoping for ActiveRecord 2.x 
+* Fixed scoping for ActiveRecord 2.x
 
 0.0.1 - 2011/06/23
 
-* Released as Gem
+* Released as Gem

data/ci/Gemfile.rails-3.0.x

@@ -3,5 +3,5 @@ source :rubygems
 gem 'activerecord', '~> 3.0.10'
 gem 'sqlite3'
 gem 'mysql2', '~> 0.2.11'
-gem 'mocha', "~> 0.12.8"
-gem 'rake'
+gem 'timecop'
+gem 'rake'

data/ci/Gemfile.rails-3.1.x

@@ -3,5 +3,5 @@ source :rubygems
 gem 'activerecord', '~> 3.1.1'
 gem 'sqlite3'
 gem 'mysql2', '>= 0.3.6'
-gem 'mocha', "~> 0.12.8"
-gem 'rake'
+gem 'timecop'
+gem 'rake'

data/ci/Gemfile.rails-3.2.x

@@ -3,5 +3,5 @@ source :rubygems
 gem 'activerecord', '~> 3.2.1'
 gem 'sqlite3'
 gem 'mysql2', '>= 0.3.6'
-gem 'mocha', "~> 0.12.8"
-gem 'rake'
+gem 'timecop'
+gem 'rake'

data/lib/app/models/read_mark.rb

@@ -1,26 +1,17 @@
 class ReadMark < ActiveRecord::Base
   belongs_to :readable, :polymorphic => true
   attr_accessible :readable_id, :user_id, :readable_type, :timestamp
-  
+
   validates_presence_of :user_id, :readable_type
-  
-  scope_method = ActiveRecord::VERSION::MAJOR < 3 ? :named_scope : :scope
-  
-  send scope_method, :global, :conditions => { :readable_id => nil }
-  send scope_method, :single, :conditions => 'readable_id IS NOT NULL'
-  send scope_method, :readable_type, lambda { |readable_type | { :conditions => { :readable_type => readable_type }}}
-  send scope_method, :user,          lambda { |user|           { :conditions => { :user_id => user.id }}}
-  send scope_method, :older_than,    lambda { |timestamp|      { :conditions => [ 'timestamp < ?', timestamp] }}
+
+  scope :global, where(:readable_id => nil)
+  scope :single, where('readable_id IS NOT NULL')
+  scope :older_than, lambda { |timestamp| where([ 'timestamp < ?', timestamp]) }
 
   # Returns the class defined by ActsAsReadable::acts_as_reader
   def self.reader_class
-    user_association = reflect_on_all_associations(:belongs_to).find { |assoc| assoc.name == :user }
-    user_association.try(:klass)
+    reflect_on_all_associations(:belongs_to).find { |assoc| assoc.name == :user }.try(:klass)
   end
-  
-  if respond_to?(:class_attribute)
-    class_attribute :readable_classes
-  else
-    class_inheritable_accessor :readable_classes
-  end
-end
+
+  class_attribute :readable_classes
+end

data/lib/generators/unread/migration/migration_generator.rb

@@ -0,0 +1,23 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+module Unread
+  class MigrationGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+
+    desc "Generates migration for read_markers"
+    source_root File.expand_path('../templates', __FILE__)
+
+    def create_migration_file
+      migration_template 'migration.rb', 'db/migrate/unread_migration'
+    end
+
+    def self.next_migration_number(dirname)
+      if ActiveRecord::Base.timestamped_migrations
+        Time.now.utc.strftime("%Y%m%d%H%M%S")
+      else
+        "%.3d" % (current_migration_number(dirname) + 1)
+      end
+    end
+  end
+end

data/lib/generators/unread/migration/templates/migration.rb

@@ -0,0 +1,16 @@
+class UnreadMigration < ActiveRecord::Migration
+  def self.up
+    create_table :read_marks, :force => true do |t|
+      t.integer  :readable_id
+      t.integer  :user_id,       :null => false
+      t.string   :readable_type, :null => false, :limit => 20
+      t.datetime :timestamp
+    end
+
+    add_index :read_marks, [:user_id, :readable_type, :readable_id]
+  end
+
+  def self.down
+    drop_table :read_marks
+  end
+end

data/lib/unread/acts_as_readable.rb

@@ -2,95 +2,90 @@ module Unread
   def self.included(base)
     base.extend ActsAsReadable
   end
-  
+
   module ActsAsReadable
     def acts_as_reader
       ReadMark.belongs_to :user, :class_name => self.to_s
-      
+
       has_many :read_marks, :dependent => :delete_all, :foreign_key => 'user_id', :inverse_of => :user
-      
+
       after_create do |user|
+        # We assume that a new user should not be tackled by tons of old messages
+        # created BEFORE he signed up.
+        # Instead, the new user starts with zero unread messages
         (ReadMark.readable_classes || []).each do |klass|
           klass.mark_as_read! :all, :for => user
         end
       end
-      
+
       include ReaderInstanceMethods
     end
-    
+
     def acts_as_readable(options={})
-      if respond_to?(:class_attribute)
-        class_attribute :readable_options
-      else
-        class_inheritable_accessor :readable_options
-      end
+      class_attribute :readable_options
 
-      options.reverse_merge!({ :on => :updated_at })
+      options.reverse_merge!(:on => :updated_at)
       self.readable_options = options
-      
+
       has_many :read_marks, :as => :readable, :dependent => :delete_all
-      
+
       ReadMark.readable_classes ||= []
-      ReadMark.readable_classes << self unless ReadMark.readable_classes.map(&:name).include?(self.name)
-      
-      scope_method = ActiveRecord::VERSION::MAJOR < 3 ? :named_scope : :scope
-      
-      send scope_method, :unread_by, lambda { |user| 
+      ReadMark.readable_classes << self unless ReadMark.readable_classes.include?(self)
+
+      scope :join_read_marks, lambda { |user|
         assert_reader(user)
 
-        result = { :joins => "LEFT JOIN read_marks ON read_marks.readable_type  = '#{self.base_class.name}'
-                                                  AND read_marks.readable_id    = #{self.table_name}.id
-                                                  AND read_marks.user_id        = #{user.id}
-                                                  AND read_marks.timestamp     >= #{self.table_name}.#{readable_options[:on]}",
-                   :conditions => 'read_marks.id IS NULL' }
+        joins "LEFT JOIN read_marks ON read_marks.readable_type  = '#{self.base_class.name}'
+                                   AND read_marks.readable_id    = #{self.table_name}.id
+                                   AND read_marks.user_id        = #{user.id}
+                                   AND read_marks.timestamp     >= #{self.table_name}.#{readable_options[:on]}"
+      }
+
+      scope :unread_by, lambda { |user|
+        result = join_read_marks(user).
+                 where('read_marks.id IS NULL')
+
         if global_time_stamp = user.read_mark_global(self).try(:timestamp)
-          result[:conditions] += " AND #{self.table_name}.#{readable_options[:on]} > '#{global_time_stamp.to_s(:db)}'"
+          result = result.where("#{self.table_name}.#{readable_options[:on]} > '#{global_time_stamp.to_s(:db)}'")
         end
+
         result
       }
-      
-      send scope_method, :with_read_marks_for, lambda { |user| 
-        assert_reader(user)
-      
-        { :select => "#{self.table_name}.*, read_marks.id AS read_mark_id",
-          :joins => "LEFT JOIN read_marks ON read_marks.readable_type  = '#{self.base_class.name}'
-                                         AND read_marks.readable_id    = #{self.table_name}.id
-                                         AND read_marks.user_id        = #{user.id}
-                                         AND read_marks.timestamp     >= #{self.table_name}.#{readable_options[:on]}" }
+
+      scope :with_read_marks_for, lambda { |user|
+        join_read_marks(user).select("#{self.table_name}.*, read_marks.id AS read_mark_id")
       }
+
       extend ReadableClassMethods
       include ReadableInstanceMethods
     end
   end
-  
+
   module ReadableClassMethods
     def mark_as_read!(target, options)
-      raise ArgumentError unless target == :all || target.is_a?(Array)
-      
       user = options[:for]
       assert_reader(user)
-      
+
       if target == :all
-        reset_read_marks!(user)
-      elsif target.is_a?(Array)  
-        ReadMark.transaction do
-          target.each do |obj|
-            raise ArgumentError unless obj.is_a?(self)
-        
-            rm = ReadMark.user(user).readable_type(self.base_class.name).find_by_readable_id(obj.id) ||
-                 user.read_marks.build(:readable_id => obj.id, :readable_type => self.base_class.name)
-            rm.timestamp = obj.send(readable_options[:on])
-            rm.save!
-          end
+        reset_read_marks_for_user(user)
+      elsif target.is_a?(Array)
+        mark_array_as_read(target, user)
+      else
+        raise ArgumentError
+      end
+    end
+
+    def mark_array_as_read(array, user)
+      ReadMark.transaction do
+        array.each do |obj|
+          raise ArgumentError unless obj.is_a?(self)
+
+          rm = obj.read_marks.where(:user_id => user.id).first || obj.read_marks.build(:user_id => user.id)
+          rm.timestamp = obj.send(readable_options[:on])
+          rm.save!
         end
       end
     end
-    
-    def set_read_mark(user, timestamp)
-      rm = user.read_mark_global(self) || user.read_marks.build(:readable_type => self.base_class.name)
-      rm.timestamp = timestamp
-      rm.save!
-    end    
 
     # A scope with all items accessable for the given user
     # It's used in cleanup_read_marks! to support a filtered cleanup
@@ -107,64 +102,69 @@ module Unread
 
     def cleanup_read_marks!
       assert_reader_class
-      
+
       ReadMark.reader_class.find_each do |user|
         ReadMark.transaction do
-          # Get the timestamp of the oldest unread item the user has access to
-          oldest_timestamp = read_scope(user).unread_by(user).minimum(readable_options[:on])
-
-          if oldest_timestamp
-            # Delete markers OLDER than this timestamp and move the global timestamp for this user
-            user.read_marks.readable_type(self.base_class.name).single.older_than(oldest_timestamp).delete_all
-            set_read_mark(user, oldest_timestamp - 1.second)
+          if oldest_timestamp = read_scope(user).unread_by(user).minimum(readable_options[:on])
+            # There are unread items, so update the global read_mark for this user to the oldest
+            # unread item and delete older read_marks
+            update_read_marks_for_user(user, oldest_timestamp)
           else
-            # There is no unread item, so mark all as read (which deletes all markers)
-            mark_as_read!(:all, :for => user)
+            # There is no unread item, so deletes all markers and move global timestamp
+            reset_read_marks_for_user(user)
           end
         end
       end
     end
-    
-    def reset_read_marks!(user = :all)
-      assert_reader_class
 
+    def update_read_marks_for_user(user, timestamp)
+      # Delete markers OLDER than the given timestamp
+      user.read_marks.where(:readable_type => self.base_class.name).single.older_than(timestamp).delete_all
+
+      # Change the global timestamp for this user
+      rm = user.read_mark_global(self) || user.read_marks.build(:readable_type => self.base_class.name)
+      rm.timestamp = timestamp - 1.second
+      rm.save!
+    end
+
+    def reset_read_marks_for_all
       ReadMark.transaction do
-        if user == :all
-          ReadMark.delete_all :readable_type => self.base_class.name
-      
-          ReadMark.connection.execute("
-            INSERT INTO read_marks (user_id, readable_type, timestamp)
-            SELECT id, '#{self.base_class.name}', '#{Time.now.to_s(:db)}'
-            FROM #{ReadMark.reader_class.table_name}
-          ")
-        else
-          ReadMark.delete_all :readable_type => self.base_class.name, :user_id => user.id
-          ReadMark.create!    :readable_type => self.base_class.name, :user_id => user.id, :timestamp => Time.now
-        end
+        ReadMark.delete_all :readable_type => self.base_class.name
+        ReadMark.connection.execute <<-EOT
+          INSERT INTO read_marks (user_id, readable_type, timestamp)
+          SELECT id, '#{self.base_class.name}', '#{Time.now.to_s(:db)}'
+          FROM #{ReadMark.reader_class.table_name}
+        EOT
       end
-      true
     end
-    
+
+    def reset_read_marks_for_user(user)
+      assert_reader(user)
+
+      ReadMark.transaction do
+        ReadMark.delete_all :readable_type => self.base_class.name, :user_id => user.id
+        ReadMark.create!    :readable_type => self.base_class.name, :user_id => user.id, :timestamp => Time.now
+      end
+    end
+
     def assert_reader(user)
       assert_reader_class
-      
+
       raise ArgumentError, "Class #{user.class.name} is not registered by acts_as_reader!" unless user.is_a?(ReadMark.reader_class)
       raise ArgumentError, "The given user has no id!" unless user.id
     end
-    
+
     def assert_reader_class
-      unless ReadMark.reader_class
-        raise RuntimeError, 'There is no class using acts_as_reader!'
-      end
+      raise RuntimeError, 'There is no class using acts_as_reader!' unless ReadMark.reader_class
     end
   end
-  
-  module ReadableInstanceMethods 
+
+  module ReadableInstanceMethods
     def unread?(user)
       if self.respond_to?(:read_mark_id)
         # For use with scope "with_read_marks_for"
         return false if self.read_mark_id
-        
+
         if global_timestamp = user.read_mark_global(self.class).try(:timestamp)
           self.send(readable_options[:on]) > global_timestamp
         else
@@ -174,11 +174,11 @@ module Unread
         self.class.unread_by(user).exists?(self)
       end
     end
-    
+
     def mark_as_read!(options)
       user = options[:for]
       self.class.assert_reader(user)
-      
+
       ReadMark.transaction do
         if unread?(user)
           rm = read_mark(user) || read_marks.build(:user_id => user.id)
@@ -189,15 +189,15 @@ module Unread
     end
 
     def read_mark(user)
-      read_marks.user(user).first
+      read_marks.where(:user_id => user.id).first
     end
   end
-  
+
   module ReaderInstanceMethods
     def read_mark_global(klass)
       instance_var_name = "@read_mark_global_#{klass.name.gsub('::','_')}"
       instance_variable_get(instance_var_name) || begin # memoize
-        obj = self.read_marks.readable_type(klass.base_class.name).global.first
+        obj = self.read_marks.where(:readable_type => klass.base_class.name).global.first
         instance_variable_set(instance_var_name, obj)
       end
     end

data/lib/unread/version.rb

@@ -1,3 +1,3 @@
 module Unread
-  VERSION = '0.1.2'
+  VERSION = '0.2.0'
 end

data/test/database.yml

@@ -4,5 +4,5 @@ sqlite:
 mysql:
   adapter: mysql2
   database: myapp_test
-  username: 
+  username:
   encoding: utf8

data/test/schema.rb

@@ -2,14 +2,14 @@ ActiveRecord::Schema.define(:version => 0) do
   create_table :readers, :force => true do |t|
     t.string :name
   end
-  
+
   create_table :emails, :force => true do |t|
     t.string :subject
     t.text :content
     t.datetime :created_at
     t.datetime :updated_at
   end
-  
+
   create_table :read_marks, :force => true do |t|
     t.integer  :readable_id
     t.integer  :user_id,       :null => false
@@ -17,4 +17,4 @@ ActiveRecord::Schema.define(:version => 0) do
     t.datetime :timestamp
   end
   add_index :read_marks, [:user_id, :readable_type, :readable_id]
-end
+end

data/test/test_helper.rb

@@ -2,7 +2,7 @@ require 'test/unit'
 require 'active_support'
 require 'active_support/test_case'
 require 'active_record'
-require 'unread'
+require 'timecop'
 
 configs = YAML.load_file(File.dirname(__FILE__) + '/database.yml')
 ActiveRecord::Base.configurations = configs
@@ -12,6 +12,8 @@ ActiveRecord::Base.establish_connection(db_name)
 ActiveRecord::Migration.verbose = false
 load(File.dirname(__FILE__) + "/schema.rb")
 
+require 'unread'
+
 class Reader < ActiveRecord::Base
   acts_as_reader
 end
@@ -20,4 +22,4 @@ class Email < ActiveRecord::Base
   acts_as_readable :on => :updated_at
 end
 
-puts "Testing with ActiveRecord #{ActiveRecord::VERSION::STRING}"
+puts "Testing with ActiveRecord #{ActiveRecord::VERSION::STRING}"

data/test/unread_test.rb

@@ -9,21 +9,21 @@ class UnreadTest < ActiveSupport::TestCase
     wait
     @email2 = Email.create!
   end
-  
+
   def teardown
     Reader.delete_all
     Email.delete_all
     ReadMark.delete_all
   end
-  
+
   def test_schema_has_loaded_correctly
     assert_equal [@email1, @email2], Email.all
   end
-  
+
   def test_readable_classes
     assert_equal [ Email ], ReadMark.readable_classes
   end
-  
+
   def test_reader_class
     assert_equal Reader, ReadMark.reader_class
   end
@@ -31,37 +31,37 @@ class UnreadTest < ActiveSupport::TestCase
   def test_scope
     assert_equal [@email1, @email2], Email.unread_by(@reader)
     assert_equal [@email1, @email2], Email.unread_by(@other_reader)
-    
+
     assert_equal 2, Email.unread_by(@reader).count
     assert_equal 2, Email.unread_by(@other_reader).count
   end
-  
+
   def test_with_read_marks_for
     @email1.mark_as_read! :for => @reader
-    
+
     emails = Email.with_read_marks_for(@reader).all
 
     assert emails[0].read_mark_id.present?
     assert emails[1].read_mark_id.nil?
-    
+
     assert_equal false, emails[0].unread?(@reader)
     assert_equal true, emails[1].unread?(@reader)
   end
-  
+
   def test_scope_param_check
     [ 42, nil, 'foo', :foo, {} ].each do |not_a_reader|
       assert_raise(ArgumentError) { Email.unread_by(not_a_reader)}
       assert_raise(ArgumentError) { Email.with_read_marks_for(not_a_reader)}
     end
-    
+
     unsaved_reader = Reader.new
     assert_raise(ArgumentError) { Email.unread_by(unsaved_reader)}
     assert_raise(ArgumentError) { Email.with_read_marks_for(unsaved_reader)}
   end
-  
+
   def test_scope_after_reset
     @email1.mark_as_read! :for => @reader
-    
+
     assert_equal [@email2], Email.unread_by(@reader)
     assert_equal 1, Email.unread_by(@reader).count
   end
@@ -69,12 +69,12 @@ class UnreadTest < ActiveSupport::TestCase
   def test_unread_after_create
     assert_equal true, @email1.unread?(@reader)
     assert_equal true, @email1.unread?(@other_reader)
-    
+
     assert_raise(ArgumentError) {
       @email1.unread?(42)
     }
   end
-  
+
   def test_unread_after_update
     @email1.mark_as_read! :for => @reader
     wait
@@ -82,86 +82,84 @@ class UnreadTest < ActiveSupport::TestCase
 
     assert_equal true, @email1.unread?(@reader)
   end
-  
+
   def test_mark_as_read
     @email1.mark_as_read! :for => @reader
-    
+
     assert_equal false, @email1.unread?(@reader)
     assert_equal [@email2], Email.unread_by(@reader)
-    
+
     assert_equal true, @email1.unread?(@other_reader)
     assert_equal [@email1, @email2], Email.unread_by(@other_reader)
-    
+
     assert_equal 1, @reader.read_marks.single.count
     assert_equal @email1, @reader.read_marks.single.first.readable
   end
-  
+
   def test_mark_as_read_multiple
     assert_equal true, @email1.unread?(@reader)
     assert_equal true, @email2.unread?(@reader)
-    
+
     Email.mark_as_read! [ @email1, @email2 ], :for => @reader
-    
+
     assert_equal false, @email1.unread?(@reader)
     assert_equal false, @email2.unread?(@reader)
   end
-  
+
   def test_mark_as_read_with_marked_all
     wait
-    
+
     Email.mark_as_read! :all, :for => @reader
     @email1.mark_as_read! :for => @reader
-    
+
     assert_equal [], @reader.read_marks.single
   end
-  
+
   def test_mark_as_read_twice
     @email1.mark_as_read! :for => @reader
     @email1.mark_as_read! :for => @reader
-    
+
     assert_equal 1, @reader.read_marks.single.count
   end
-  
+
   def test_mark_all_as_read
     Email.mark_as_read! :all, :for => @reader
     assert_equal Time.now.to_s, @reader.read_mark_global(Email).try(:timestamp).to_s
-    
+
     assert_equal [], @reader.read_marks.single
     assert_equal 0, ReadMark.single.count
     assert_equal 2, ReadMark.global.count
   end
-  
+
   def test_cleanup_read_marks
     assert_equal 0, @reader.read_marks.single.count
-    
+
     @email1.mark_as_read! :for => @reader
-    
+
     assert_equal [@email2], Email.unread_by(@reader)
     assert_equal 1, @reader.read_marks.single.count
-    
-    Email.cleanup_read_marks!    
-    
+
+    Email.cleanup_read_marks!
+
     @reader.reload
     assert_equal 0, @reader.read_marks.single.count
   end
-  
+
   def test_cleanup_read_marks_not_delete_from_other_readables
     other_read_mark = @reader.read_marks.create! :readable_type => 'Foo', :readable_id => 42, :timestamp => 5.years.ago
     Email.cleanup_read_marks!
     assert_equal true, ReadMark.exists?(other_read_mark.id)
   end
-  
+
   def test_reset_read_marks_for_all
-    Email.reset_read_marks!
-    
+    Email.reset_read_marks_for_all
+
     assert_equal 0, ReadMark.single.count
     assert_equal 2, ReadMark.global.count
   end
-  
+
 private
   def wait
-    # Skip one second
-    now = Time.now + 1.second
-    Time.stubs(:now).returns(now)
+    Timecop.travel(1.minute)
   end
-end
+end

data/unread.gemspec

@@ -17,11 +17,11 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
-  
-  s.add_dependency 'activerecord', '>= 2.3.6'
-  
+
+  s.add_dependency 'activerecord', '>= 3'
+
   s.add_development_dependency 'rake'
-  s.add_development_dependency 'mocha', "~> 0.12.8"
+  s.add_development_dependency 'timecop'
   s.add_development_dependency 'sqlite3'
   s.add_development_dependency 'mysql2'
-end
+end

metadata

@@ -2,14 +2,14 @@
 name: unread
 version: !ruby/object:Gem::Version
   prerelease: 
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Georg Ledermann
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-27 00:00:00.000000000 Z
+date: 2013-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   prerelease: false
@@ -17,7 +17,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 2.3.6
+        version: '3'
     none: false
   type: :runtime
   name: activerecord
@@ -25,7 +25,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 2.3.6
+        version: '3'
     none: false
 - !ruby/object:Gem::Dependency
   prerelease: false
@@ -47,17 +47,17 @@ dependencies:
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.12.8
+        version: '0'
     none: false
   type: :development
-  name: mocha
+  name: timecop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.12.8
+        version: '0'
     none: false
 - !ruby/object:Gem::Dependency
   prerelease: false
@@ -106,11 +106,12 @@ files:
 - README.md
 - Rakefile
 - changelog.md
-- ci/Gemfile.rails-2.3.x
 - ci/Gemfile.rails-3.0.x
 - ci/Gemfile.rails-3.1.x
 - ci/Gemfile.rails-3.2.x
 - lib/app/models/read_mark.rb
+- lib/generators/unread/migration/migration_generator.rb
+- lib/generators/unread/migration/templates/migration.rb
 - lib/unread.rb
 - lib/unread/acts_as_readable.rb
 - lib/unread/version.rb

data/ci/Gemfile.rails-2.3.x

@@ -1,7 +0,0 @@
-source :rubygems
-
-gem 'activerecord', '~> 2.3.14'
-gem 'sqlite3'
-gem 'mysql2', '~> 0.2.11'
-gem 'mocha', "~> 0.12.8"
-gem 'rake'