liszt 0.0.7 → 0.1.0

data/.gitignore

@@ -2,13 +2,11 @@
 log/*.log
 pkg/
 doc/
-test/dummy_2.3/db/*.sqlite3
-test/dummy_2.3/log/*.log
-test/dummy_2.3/tmp/
-test/dummy_3.1/db/*.sqlite3
-test/dummy_3.1/log/*.log
-test/dummy_3.1/tmp/
+test/app/log/*.log
+test/app/tmp/
 .yardoc/
 .rvmrc
 /tags
 /dump.rdb
+coverage/
+Gemfile.lock

data/Gemfile

@@ -1,8 +1,7 @@
 source "http://rubygems.org"
 
-gem 'rails', '3.1.0'
-gem 'sqlite3'
-gem 'shoulda-context'
+gem 'activerecord', '~> 3.1.0'
+gem 'simplecov'
 
 # Specify your gem's dependencies in has_rank.gemspec
 gemspec

data/Rakefile

@@ -2,12 +2,6 @@
 
 require 'bundler/gem_tasks'
 
-desc "Install gems for Rails 2.3.14 and Rails 3.1.0"
-task :install_bundle do
-  system "bundle install --gemfile Gemfile"
-  system "bundle install --gemfile Gemfile.rails2"
-end
-
 begin
   require 'yard'
   YARD::Rake::YardocTask.new
@@ -23,29 +17,4 @@ Rake::TestTask.new(:test) do |t|
   t.verbose = false
 end
 
-def execute(cmd)
-  Dir.chdir "test/dummy_2.3"
-  system "env RAILS_ENV=test BUNDLE_GEMFILE=../../Gemfile.rails2 bundle exec #{cmd}"
-  Dir.chdir "../dummy_3.1"
-  system "env RAILS_ENV=test BUNDLE_GEMFILE=../../Gemfile bundle exec #{cmd}"
-  Dir.chdir "../.."
-end
-
-desc "Create and migrate the test databases for Rails 2.3.14 and Rails 3.1.0"
-task :set_up_test_dbs do
-  execute "rake db:create"
-  execute "rake db:migrate"
-end
-
-desc "Open console in Rails 2.3.14 app"
-task :console_rails_2 do
-  Dir.chdir("test/dummy_2.3")
-  system("env RAILS_ENV=test BUNDLE_GEMFILE=../../Gemfile.rails2 bundle exec script/console")
-end
-
-desc "Run tests on Rails 2.3.14"
-task :test_rails_2 do
-  system("env BUNDLE_GEMFILE=Gemfile.rails2 bundle exec rake test")
-end
-
-task :default => [:test, :test_rails_2]
+task :default => :test

data/lib/liszt/redis_list.rb

@@ -79,9 +79,11 @@ module Liszt
     # Push the given id onto the bottom of the list.
     # @param [Fixnum] id
     def push!(id)
-      redis.rpop(@key)
-      redis.rpush(@key, id)
-      redis.rpush(@key, '*')
+      redis.multi do
+        redis.rpop(@key)
+        redis.rpush(@key, id)
+        redis.rpush(@key, '*')
+      end
     end
 
     # Remove the given id from the list.
@@ -92,8 +94,10 @@ module Liszt
 
     # Clear all items from the list.
     def clear
-      redis.del(@key)
-      redis.rpush(@key, '*')
+      redis.multi do
+        redis.del(@key)
+        redis.rpush(@key, '*')
+      end
     end
 
     # Return the number of ids in the list, or nil if it's uninitialized.

data/lib/liszt/version.rb

@@ -1,3 +1,3 @@
 module Liszt
-  VERSION = "0.0.7"
+  VERSION = "0.1.0"
 end

data/lib/liszt.rb

@@ -2,26 +2,38 @@ require "liszt/version"
 require "liszt/instantizeable"
 require "liszt/redis_list"
 
+require "active_record"
+
 module Liszt
-  mattr_accessor :redis
+  class << self
+    attr_accessor :redis
+
+    def merge_id_lists(canonical, modified, append = false)
+      if append
+        (modified + (canonical - modified)) & canonical
+      else
+        ((canonical - modified) + modified) & canonical
+      end
+    end
+  end
 
   # Set up a scoped ordering for this model.
   #
-  # Liszt currently only supports one type of ranking per model. It also doesn't
-  # currently support re-sorting lists when a scope changes. The assumption is
-  # that attributes used as scopes won't change after creation.
+  # Liszt currently only supports one type of ranking per model. It also
+  # doesn't currently support re-sorting lists when a scope changes. The
+  # assumption is that attributes used as scopes won't change after creation.
   #
-  # The other major limitation at the moment is that scopes can't be <tt>nil</tt>.
-  # If a record has nil for a scope value, its associated list will never have
-  # any items in it.
+  # The other major limitation at the moment is that scopes can't be
+  # <tt>nil</tt>.  If a record has nil for a scope value, its associated list
+  # will never have any items in it.
   #
   # @param [Hash] options
   # @option options [Symbol, Array] :scope The attribute or attributes to use
   #   as list constraints.
   # @option options [Hash] :conditions Any extra constraints to impose.
-  # @option options [Proc] :sort_by A lambda to pass into initialize_list! the first
-  #   time an item is added to an uninitialized list. It has the same semantics as
-  #   <tt>Enumerable#sort_by</tt>.
+  # @option options [Proc] :sort_by A lambda to pass into initialize_list! the
+  #   first time an item is added to an uninitialized list. It has the same
+  #   semantics as <tt>Enumerable#sort_by</tt>.
   def acts_as_liszt(options = {})
     extend Instantizeable
     extend ClassMethods
@@ -49,21 +61,20 @@ module Liszt
     end
 
     def initialize_list!(obj={}, &block)
-      objects = find(:all, :conditions => liszt_query(obj))
+      objects = liszt_relation(obj).to_a
 
       # If the caller provided a block, or if they passed in a default
       # with the :sort_by option, sort the objects by that block's
       # output before populating the list with their ids. If not, put
       # the objects in descending order by id.
-      ids = if block_given?
-              objects.sort_by(&block).map(&:id)
-            else
-              if @liszt_sort_by
-                objects.sort_by(&@liszt_sort_by).map(&:id)
-              else
-                objects.map(&:id).sort.reverse
-              end
-            end
+      ids = case
+        when block_given?
+          objects.sort_by(&block).map(&:id)
+        when @liszt_sort_by
+          objects.sort_by(&@liszt_sort_by).map(&:id)
+        else
+          objects.map(&:id).sort.reverse
+        end
 
       ordered_list(obj).clear_and_populate!(ids)
       ids
@@ -87,27 +98,45 @@ module Liszt
 
     def ordered_list_items(obj={}, opts={})
       force_refresh = opts.delete(:force_refresh) || false
-      was_initialized = ordered_list_initialized?(obj)
-      ids = ordered_list_ids(obj)
-
-      # If ordered_list_ids just did the initialization, we can trust that
-      # the list of ids is accurate and ignore the force_refresh flag.
-      if force_refresh and was_initialized
-        objs = find(:all, {:conditions => liszt_query(obj)}.merge(opts))
-        real_ids = objs.map(&:id)
-        unlisted_ids = real_ids - ids
-        if unlisted_ids.count > 0
-          ids = ordered_list(obj).clear_and_populate!(unlisted_ids + ids)
-        end
+      previously_initialized = ordered_list_initialized?(obj)
+
+      # If the list isn't initialized already, we can trust ordered_list_ids to
+      # do the initialization correctly and ignore the force_refresh flag.
+      if force_refresh && previously_initialized
+        refresh_ordered_list(obj)
       else
-        objs = find(:all, {:conditions => ['id in (?)', ids]}.merge(opts))
+        list_ids = ordered_list_ids(obj)
+        records  = where('id in (?)', list_ids).to_a
+        records.sort_by { |obj| list_ids.index(obj.id) }
+      end
+    end
+
+    # Synchronizes the ordered list with the database, returning the relevant
+    # records in order.
+    def refresh_ordered_list(obj={})
+      list_ids   = ordered_list_ids(obj)
+      records    = liszt_relation(obj).to_a
+      real_ids   = records.map(&:id)
+      merged_ids = Liszt.merge_id_lists(
+                     real_ids, list_ids, @liszt_append_new_items)
+
+      if merged_ids != list_ids
+        ordered_list(obj).clear_and_populate!(merged_ids)
       end
 
-      objs.sort_by { |obj| ids.index(obj.id) }
+      records.sort_by { |obj| merged_ids.index(obj.id) }
     end
 
-    def clear_list(obj={})
-      ordered_list(obj).clear
+    # Update the given object's list with the given ids. Returns the final list
+    # of ids, which may be different from the given list if the given list was
+    # inconsistent with the database.
+    def update_ordered_list(obj, new_ids)
+      records    = ordered_list_items(obj, force_refresh: true)
+      real_ids   = records.map(&:id)
+      merged_ids = Liszt.merge_id_lists(
+                     real_ids, new_ids, @liszt_append_new_items)
+
+      ordered_list(obj).clear_and_populate!(merged_ids)
     end
 
     def meets_list_conditions?(obj={})
@@ -115,6 +144,7 @@ module Liszt
     end
 
     private
+
     # Return the key for the Redis list that includes the given object.
     def liszt_key(obj={})
       key = "liszt:#{table_name}"
@@ -124,9 +154,9 @@ module Liszt
       key
     end
 
-    # Return the query that retrieves objects eligible to be
-    # in the list that includes the given object.
-    def liszt_query(obj={})
+    # Return a relation/scope containing objects eligible to be in the list
+    # that includes the given object.
+    def liszt_relation(obj={})
       if @liszt_query.nil?
         query = ['1 = 1']
 
@@ -147,7 +177,7 @@ module Liszt
         @liszt_query = query
       end
 
-      @liszt_query + @liszt_scope.map { |scope| obj[scope] }
+      where(@liszt_query + @liszt_scope.map { |scope| obj[scope] })
     end
   end
 
@@ -155,7 +185,7 @@ module Liszt
     def self.included(base)
       base.class_eval do
         after_create :add_to_list
-        after_update :update_list
+        after_update :add_to_or_remove_from_list
         after_destroy :remove_from_list
       end
     end
@@ -170,16 +200,12 @@ module Liszt
           end
         end
       else
-        if self.class.liszt_sort_by
-          initialize_list! &self.class.liszt_sort_by
-        else
-          initialize_list!
-        end
+        initialize_list!
       end
       true
     end
 
-    def update_list
+    def add_to_or_remove_from_list
       if meets_list_conditions?
         add_to_list
       else
@@ -211,4 +237,5 @@ module Liszt
   end
 end
 
+# @@ TODO: use an actual railtie
 ActiveRecord::Base.extend Liszt

data/liszt.gemspec

@@ -16,9 +16,13 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = %w{lib}
 
-  s.add_runtime_dependency 'rails', '>= 2.3.2'
-  s.add_runtime_dependency 'redis'
+  s.add_runtime_dependency "activerecord", ">= 3.0.0"
+  s.add_runtime_dependency "redis"
 
-  s.add_development_dependency 'yard'
-  s.add_development_dependency 'rdiscount'
+  s.add_development_dependency "minitest"
+  s.add_development_dependency "pry"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rdiscount"
+  s.add_development_dependency "sqlite3"
+  s.add_development_dependency "yard"
 end

data/test/fixtures/groups.yml

@@ -0,0 +1,14 @@
+one:
+  id: 1
+  is_foo: true
+  is_bar: 
+
+two:
+  id: 2
+  is_foo: true
+  is_bar: 
+
+three:
+  id: 3
+  is_foo: true
+  is_bar: 

data/test/liszt_test.rb

@@ -1,59 +1,56 @@
 require 'test_helper'
 
-class LisztTest < ActiveSupport::TestCase
-  fixtures :groups
-  fixtures :people
-
-  setup do
+describe Liszt do
+  before do
     Liszt.redis.flushall
   end
 
-  context "before initialization" do
-    should "not be initialized" do
+  describe "before initialization" do
+    it "isn't initialized" do
       assert !people(:nelson).ordered_list_initialized?
     end
 
-    should "initialize successfully" do
-      assert_nothing_raised { people(:nelson).initialize_list! }
+    it "initializes successfully" do
+      people(:nelson).initialize_list!
       assert people(:nelson).ordered_list_initialized?
     end
 
-    should "auto-initialize successfully" do
-      assert_nothing_raised { people(:nelson).ordered_list_ids }
+    it "auto-initializes successfully" do
+      people(:nelson).ordered_list_ids
       assert people(:nelson).ordered_list_initialized?
     end
   end
 
-  context "after initialization" do
-    setup do
+  describe "after initialization" do
+    before do
       people(:nelson).initialize_list!(&:id)
       @id = people(:nelson).id
       @current_list = Person.ordered_list_ids(people(:nelson))
     end
 
-    context "basic functionality" do
-      should "move to top" do
+    describe "basic functionality" do
+      it "moves to top" do
         people(:nelson).move_to_top!
         @current_list.delete(@id)
         @current_list.unshift(@id)
         assert_equal people(:nelson).ordered_list_ids, @current_list
       end
 
-      should "move up" do
+      it "moves up" do
         old_index = people(:nelson).ordered_list_ids.index(@id)
         people(:nelson).move_up!
         @current_list.swap(old_index, old_index - 1)
         assert_equal people(:nelson).ordered_list_ids, @current_list
       end
 
-      should "move down" do
+      it "moves down" do
         old_index = people(:nelson).ordered_list_ids.index(@id)
         people(:nelson).move_down!
         @current_list.swap(old_index, old_index + 1)
         assert_equal people(:nelson).ordered_list_ids, @current_list
       end
 
-      should "move to bottom" do
+      it "moves to bottom" do
         people(:nelson).move_to_bottom!
         @current_list.delete(@id)
         @current_list.push(@id)
@@ -61,73 +58,213 @@ class LisztTest < ActiveSupport::TestCase
       end
     end
 
-    context "ActiveRecord hooks" do
-      setup do
+    describe "ActiveRecord hooks" do
+      before do
         Person.initialize_list!(:group_id => 1, :is_male => true)
         @person = Person.new(:name => "John Smith", :group_id => 1, :is_male => true)
       end
 
-      should "not be in list before saving" do
+      it "isn't in list before saving" do
         assert !@person.ordered_list_items.include?(@person)
       end
 
-      should "be in list after saving" do
+      it "is in list after saving" do
         @person.save
         assert @person.ordered_list_items.include?(@person)
       end
 
-      should "be removed from list after deletion" do
+      it "is removed from list after deletion" do
         @person.save
         @person.destroy
         assert !@person.ordered_list_items.include?(@person)
       end
     end
 
-    context "options" do
-      setup do
+    describe "options" do
+      before do
         Person.initialize_list!(:group_id => 1, :is_male => true)
         @person = Person.new(:name => "John Smith", :group_id => 1, :is_male => true)
       end
 
-      should "not confirm the list when force_refresh is nil" do
+      it "doesn't confirm the list when force_refresh is nil" do
         @person.save
         @person.remove_from_list
         assert !@person.ordered_list_items.include?(@person)
         assert !@person.ordered_list_ids.include?(@person.id)
       end
 
-      should "confirm the list when force_refresh is true" do
+      it "confirms the list when force_refresh is true" do
         @person.save
         @person.remove_from_list
         assert @person.ordered_list_items(:force_refresh => true).include?(@person)
         assert @person.ordered_list_ids.include?(@person.id)
       end
 
-      should "pass any other options through to the ActiveRecord query" do
+      it "removes incorrect items from the list when force_refresh is true" do
         @person.save
-        assert @person.ordered_list_items(:limit => 2).count == 2
+        @person.ordered_list.push(12314231)
+        assert @person.ordered_list_ids.include?(12314231)
+        @person.ordered_list_items
+        assert @person.ordered_list_ids.include?(12314231)
+        @person.ordered_list_items(:force_refresh => true)
+        refute @person.ordered_list_ids.include?(12314231)
       end
     end
   end
 
-  context "auto-initialization" do
-    setup do
-      Group.acts_as_liszt :sort_by => lambda { |o| o.id }
-    end
-
-    should "sort a newly initialized list with the given proc" do
+  describe "auto-initialization" do
+    it "sorts a newly initialized list with the given proc" do
       assert !Group.ordered_list_initialized?
       Group.initialize_list!
       assert Group.ordered_list_initialized?
       assert_equal Group.ordered_list_ids, [1, 2, 3]
     end
 
-    should "sort a newly auto-initialized list with the given proc" do
-      g = Group.new
+    it "sorts a newly auto-initialized (by record creation) list" do
+      g = Group.new(is_foo: true, is_bar: nil)
       assert !Group.ordered_list_initialized?
       g.save
       assert Group.ordered_list_initialized?
       assert_equal Group.ordered_list_ids, [1, 2, 3, g.id]
     end
+
+    it "sorts a newly auto-initialized (by querying) list" do
+      assert !Group.ordered_list_initialized?
+      Group.ordered_list_items
+      assert Group.ordered_list_initialized?
+      assert_equal Group.ordered_list_ids, [1, 2, 3]
+    end
+
+    it "sorts by id descending if there is no proc" do
+      nelson = people(:nelson)
+      refute nelson.ordered_list_initialized?
+      Person.create!(group_id: nelson.group_id, is_male: nelson.is_male)
+      assert nelson.ordered_list_initialized?
+      nelson.ordered_list_ids.must_equal nelson.ordered_list_ids.sort.reverse
+    end
+  end
+
+  describe "with :conditions and :append_new_items" do
+    before do
+      Group.initialize_list!
+      assert Group.ordered_list_initialized?
+      assert_equal Group.ordered_list_ids, [1, 2, 3]
+    end
+
+    it "appends records that meet the conditions" do
+      Group.create!(is_foo: true, is_bar: true)
+      assert_equal Group.ordered_list_ids, [1, 2, 3]
+
+      Group.create!(is_foo: false, is_bar: nil)
+      assert_equal Group.ordered_list_ids, [1, 2, 3]
+
+      g = Group.create!(is_foo: true, is_bar: nil)
+      assert_equal Group.ordered_list_ids, [1, 2, 3, g.id]
+    end
+
+    it "inserts/removes records if an update changes the conditions" do
+      g = Group.create!(is_foo: true, is_bar: nil)
+      assert_equal Group.ordered_list_ids, [1, 2, 3, g.id]
+      g.update_attributes is_bar: true
+      assert_equal Group.ordered_list_ids, [1, 2, 3]
+      g.update_attributes is_bar: nil
+      assert_equal Group.ordered_list_ids, [1, 2, 3, g.id]
+    end
+  end
+
+  describe ".update_ordered_list" do
+    before do
+      @nelson = people(:nelson)
+      @nelson.initialize_list!
+      @id1, @id2, @id3, @id4 = @nelson.ordered_list_ids
+    end
+
+    it "reorders the elements based on the given list" do
+      retval = @nelson.update_ordered_list [@id4, @id3, @id2, @id1]
+      retval.must_equal [@id4, @id3, @id2, @id1]
+      @nelson.ordered_list_ids.must_equal [@id4, @id3, @id2, @id1]
+    end
+
+    describe "when the existing list is missing elements from the db" do
+      before do
+        @nelson.ordered_list.remove @id3
+        @nelson.ordered_list_ids.must_equal [@id1, @id2, @id4]
+      end
+
+      describe "and the user also didn't provide them" do
+        it "prepends those elements to the list" do
+          retval = @nelson.update_ordered_list [@id4, @id2, @id1]
+          retval.must_equal [@id3, @id4, @id2, @id1]
+          @nelson.ordered_list_ids.must_equal [@id3, @id4, @id2, @id1]
+        end
+      end
+
+      describe "and the user provided them as part of their ordering" do
+        it "adds those elements where the user provided them" do
+          @nelson.update_ordered_list [@id4, @id2, @id3, @id1]
+          @nelson.ordered_list_ids.must_equal [@id4, @id2, @id3, @id1]
+        end
+      end
+
+      describe "and the user provided one but not another" do
+        before do
+          @nelson.ordered_list.remove @id2
+        end
+
+        it "prepends only the one that wasn't provided" do
+          @nelson.update_ordered_list [@id4, @id2, @id1]
+          @nelson.ordered_list_ids.must_equal [@id3, @id4, @id2, @id1]
+        end
+      end
+    end
+
+    describe "when the existing list contains extra elements" do
+      before do
+        @nelson.ordered_list << 123
+      end
+
+      it "removes those elements from the list" do
+        @nelson.update_ordered_list [@id4, @id3, @id2, @id1]
+        @nelson.ordered_list_ids.must_equal [@id4, @id3, @id2, @id1]
+      end
+
+      it "ignores those elements if given by the user" do
+        @nelson.update_ordered_list [@id4, @id3, 123, @id2, @id1]
+        @nelson.ordered_list_ids.must_equal [@id4, @id3, @id2, @id1]
+      end
+    end
+
+    describe "when the list given by the user omits needed elements" do
+      it "prepends them to the list" do
+        @nelson.update_ordered_list [@id4, @id3, @id1]
+        @nelson.ordered_list_ids.must_equal [@id2, @id4, @id3, @id1]
+      end
+    end
+
+    describe "when the list given by the user contains nonexistent elements" do
+      it "ignores them and calls back" do
+        @nelson.update_ordered_list [@id4, @id3, 123, @id2, @id1]
+        @nelson.ordered_list_ids.must_equal [@id4, @id3, @id2, @id1]
+      end
+    end
+  end
+
+  describe ".update_ordered_list with :append_new_items" do
+    it "appends missing elements to the list" do
+      group = groups(:one)
+      group.initialize_list!
+      id1, id2, id3 = group.ordered_list_ids
+
+      group.ordered_list.remove id2
+      group.ordered_list_ids.must_equal [id1, id3]
+
+      group.update_ordered_list [id3, id1]
+
+      group.ordered_list_ids.must_equal [id3, id1, id2]
+
+      group.update_ordered_list [id1, id2]
+
+      group.ordered_list_ids.must_equal [id1, id2, id3]
+    end
   end
 end