acts_as_saveable 0.10.1

data/lib/acts_as_saveable/saver.rb

@@ -0,0 +1,131 @@
+module ActsAsSaveable
+  module Saver
+
+    def self.included(base)
+
+      # allow user to define these
+      aliases = {
+        :save_up_for    => [:likes, :upsaves, :up_saves],
+        :save_down_for  => [:dislikes, :downsaves, :down_saves],
+        :saved_on?      => [:saved_for?],
+        :saved_up_on?   => [:saved_up_for?],
+        :saved_down_on? => [:saved_down_for?],
+        :saved_as_when_saving_on => [:saved_as_when_saved_on, :saved_as_when_saving_for, :saved_as_when_saved_for],
+      }
+
+      base.class_eval do
+
+        has_many :saves, :class_name => 'ActsAsSaveable::Save', :as => :saver, :dependent => :destroy do
+          def saveables
+            includes(:saveable).map(&:saveable)
+          end
+        end
+
+        aliases.each do |method, links|
+          links.each do |new_method|
+            alias_method(new_method, method)
+          end
+        end
+
+      end
+
+    end
+
+    # saving
+    def saved args
+      args[:saveable].save_by args.merge({:saver => self})
+    end
+
+    def save_up_for model=nil, args={}
+      saved :saveable => model, :save_scope => args[:save_scope], :saved => true
+    end
+
+    def save_down_for model=nil, args={}
+      saved :saveable => model, :save_scope => args[:save_scope], :saved => false
+    end
+
+    def unsave_for model, args={}
+      model.unsaved :saver => self, :save_scope => args[:save_scope]
+    end
+
+    # results
+    def saved_on? saveable, args={}
+      saves = find_saves(:saveable_id => saveable.id, :saveable_type => saveable.class.base_class.name,
+                         :save_scope => args[:save_scope])
+      saves.size > 0
+    end
+
+    def saved_up_on? saveable, args={}
+      saves = find_saves(:saveable_id => saveable.id, :saveable_type => saveable.class.base_class.name,
+                         :save_scope => args[:save_scope], :save_flag => true)
+      saves.size > 0
+    end
+
+    def saved_down_on? saveable, args={}
+      saves = find_saves(:saveable_id => saveable.id, :saveable_type => saveable.class.base_class.name,
+                         :save_scope => args[:save_scope], :save_flag => false)
+      saves.size > 0
+    end
+
+    def saved_as_when_saving_on saveable, args={}
+      saved = find_saves(:saveable_id => saveable.id, :saveable_type => saveable.class.base_class.name,
+                         :save_scope => args[:save_scope]).select(:save_flag).last
+      return nil unless saved
+      return saved.save_flag
+    end
+
+    def find_saves extra_conditions = {}
+      saves.where(extra_conditions)
+    end
+
+    def find_up_saves args={}
+      find_saves :save_flag => true, :save_scope => args[:save_scope]
+    end
+
+    def find_down_saves args={}
+      find_saves :save_flag => false, :save_scope => args[:save_scope]
+    end
+
+    def find_saves_for_class klass, extra_conditions = {}
+      find_saves extra_conditions.merge({:saveable_type => klass.name})
+    end
+
+    def find_up_saves_for_class klass, args={}
+      find_saves_for_class klass, :save_flag => true, :save_scope => args[:save_scope]
+    end
+
+    def find_down_saves_for_class klass, args={}
+      find_saves_for_class klass, :save_flag => false, :save_scope => args[:save_scope]
+    end
+
+    # Including polymporphic relations for eager loading
+    def include_objects
+      ActsAsSaveable::Save.includes(:saveable)
+    end
+
+    def find_saved_items extra_conditions = {}
+      options = extra_conditions.merge :saver_id => id, :saver_type => self.class.base_class.name
+      include_objects.where(options).collect(&:saveable)
+    end
+
+    def find_up_saved_items extra_conditions = {}
+      find_saved_items extra_conditions.merge(:save_flag => true)
+    end
+
+    def find_down_saved_items extra_conditions = {}
+      find_saved_items extra_conditions.merge(:save_flag => false)
+    end
+
+    def get_saved klass, extra_conditions = {}
+      klass.joins(:saves_for).merge find_saves(extra_conditions)
+    end
+
+    def get_up_saved klass
+      klass.joins(:saves_for).merge find_up_saves
+    end
+
+    def get_down_saved klass
+      klass.joins(:saves_for).merge find_down_saves
+    end
+  end
+end

data/lib/acts_as_saveable/version.rb

@@ -0,0 +1,3 @@
+module ActsAsSaveable
+  VERSION = "0.10.1"
+end

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

@@ -0,0 +1,31 @@
+require 'rails/generators/migration'
+
+module ActsAsSaveable
+  class MigrationGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+
+    desc "Generates migration for saveable (saves table)"
+
+    def self.orm
+      Rails::Generators.options[:rails][:orm]
+    end
+
+    def self.source_root
+      File.join(File.dirname(__FILE__), 'templates', (orm.to_s unless orm.class.eql?(String)) )
+    end
+
+    def self.orm_has_migration?
+      [:active_record].include? orm
+    end
+
+    def self.next_migration_number(path)
+      Time.now.utc.strftime("%Y%m%d%H%M%S")
+    end
+
+    def create_migration_file
+      if self.class.orm_has_migration?
+        migration_template 'migration.rb', 'db/migrate/acts_as_saveable_migration.rb'
+      end
+    end
+  end
+end

data/lib/generators/acts_as_saveable/migration/templates/active_record/migration.rb

@@ -0,0 +1,27 @@
+class ActsAsSaveableMigration < ActiveRecord::Migration
+  def self.up
+    create_table :saves do |t|
+
+      t.references :saveable, :polymorphic => true
+      t.references :saver, :polymorphic => true
+
+      t.boolean :save_flag
+      t.string :save_scope
+      t.integer :save_weight
+
+      t.timestamps
+    end
+
+    if ActiveRecord::VERSION::MAJOR < 4
+      add_index :saves, [:saveable_id, :saveable_type]
+      add_index :saves, [:saver_id, :saver_type]
+    end
+
+    add_index :saves, [:saver_id, :saver_type, :save_scope]
+    add_index :saves, [:saveable_id, :saveable_type, :save_scope]
+  end
+
+  def self.down
+    drop_table :saves
+  end
+end

data/spec/saveable_saver_spec.rb

@@ -0,0 +1,21 @@
+require 'acts_as_saveable'
+require 'spec_helper'
+
+describe SaveableSaver do
+  it_behaves_like "a saveable_model" do
+    # TODO Replace with factories
+    let (:saver) { SaveableSaver.create(:name => 'i can saved!') }
+    let (:saver2) { SaveableSaver.create(:name => 'a new person') }
+    let (:saver3) { Saver.create(:name => 'another person') }
+    let (:saveable) { SaveableSaver.create(:name => 'a saving model') }
+    let (:saveable_cache) { SaveableCache.create(:name => 'saving model with cache') }
+  end
+
+  it_behaves_like "a saver_model" do
+    # TODO Replace with factories
+    let (:saver) { SaveableSaver.create(:name => 'i can saved!') }
+    let (:saver2) { SaveableSaver.create(:name => 'a new person') }
+    let (:saveable) { SaveableSaver.create(:name => 'a saving model') }
+    let (:saveable2) { SaveableSaver.create(:name => 'a 2nd saving model') }
+  end
+end

data/spec/saveable_spec.rb

@@ -0,0 +1,21 @@
+require 'acts_as_saveable'
+require 'spec_helper'
+
+describe ActsAsSaveable::Saveable do
+  it "should not be saveable" do
+    expect(NotSaveable).not_to be_saveable
+  end
+
+  it "should be saveable" do
+    expect(Saveable).to be_saveable
+  end
+
+  it_behaves_like "a saveable_model" do
+    # TODO Replace with factories
+    let (:saver) { Saver.create(:name =>'i can saved!') }
+    let (:saver2) { Saver.create(:name => 'a new person') }
+    let (:saver3) { Saver.create(:name => 'another person') }
+    let (:saveable) { Saveable.create(:name =>'a saving model') }
+    let (:saveable_cache) { SaveableCache.create(:name => 'saving model with cache') }
+  end
+end

data/spec/saver_spec.rb

@@ -0,0 +1,21 @@
+require 'acts_as_saveable'
+require 'spec_helper'
+
+describe ActsAsSaveable::Saver do
+
+  it "should not be a saver" do
+    expect(NotSaveable).not_to be_saveable
+  end
+
+  it "should be a saver" do
+    expect(Saveable).to be_saveable
+  end
+
+  it_behaves_like "a saver_model" do
+    # TODO Replace with factories
+    let (:saver) { Saver.create(:name => 'i can saved!') }
+    let (:saver2) { Saver.create(:name => 'a new person') }
+    let (:saveable) { Saveable.create(:name => 'a saving model') }
+    let (:saveable2) { Saveable.create(:name => 'a 2nd saving model') }
+  end
+end

data/spec/shared_example/saveable_model_spec.rb

@@ -0,0 +1,484 @@
+shared_examples "a saveable_model" do
+  it "should return false when a saved with no saver is saved" do
+    expect(saveable.save_by).to be false
+  end
+
+  it "should have one saved when saved" do
+    saveable.save_by :saver => saver, :saved => 'yes'
+    expect(saveable.saves_for.size).to eq(1)
+  end
+
+  it "should have one saved when saved on twice by the same person" do
+    saveable.save_by :saver => saver, :saved => 'yes'
+    saveable.save_by :saver => saver, :saved => 'no'
+    expect(saveable.saves_for.size).to eq(1)
+  end
+
+  it "should have two saves_for when saved on twice by the same person with duplicate paramenter" do
+    saveable.save_by :saver => saver, :saved => 'yes'
+    saveable.save_by :saver => saver, :saved => 'no', :duplicate => true
+    expect(saveable.saves_for.size).to eq(2)
+  end
+
+  it "should have one scoped saved when saving under an scope" do
+    saveable.save_by :saver => saver, :saved => 'yes', :save_scope => 'rank'
+    expect(saveable.find_saves_for(:save_scope => 'rank').size).to eq(1)
+  end
+
+  it "should have one saved when saved on twice using scope by the same person" do
+    saveable.save_by :saver => saver, :saved => 'yes', :save_scope => 'rank'
+    saveable.save_by :saver => saver, :saved => 'no', :save_scope => 'rank'
+    expect(saveable.find_saves_for(:save_scope => 'rank').size).to eq(1)
+  end
+
+  it "should have two saves_for when saving on two different scopes by the same person" do
+    saveable.save_by :saver => saver, :saved => 'yes', :save_scope => 'weekly_rank'
+    saveable.save_by :saver => saver, :saved => 'no', :save_scope => 'monthly_rank'
+    expect(saveable.saves_for.size).to eq(2)
+  end
+
+  it "should be callable with save_up" do
+    saveable.save_up saver
+    expect(saveable.get_up_saves.first.saver).to eq(saver)
+  end
+
+  it "should be callable with save_down" do
+    saveable.save_down saver
+    expect(saveable.get_down_saves.first.saver).to eq(saver)
+  end
+
+  it "should have 2 saves_for when saved on once by two different people" do
+    saveable.save_by :saver => saver
+    saveable.save_by :saver => saver2
+    expect(saveable.saves_for.size).to eq(2)
+  end
+
+  it "should have one true saved" do
+    saveable.save_by :saver => saver
+    saveable.save_by :saver => saver2, :saved => 'dislike'
+    expect(saveable.get_up_saves.size).to eq(1)
+  end
+
+  it "should have 2 false saves_for" do
+    saveable.save_by :saver => saver, :saved => 'no'
+    saveable.save_by :saver => saver2, :saved => 'dislike'
+    expect(saveable.get_down_saves.size).to eq(2)
+  end
+
+  it "should have been saved on by saver2" do
+    saveable.save_by :saver => saver2, :saved => true
+    expect(saveable.find_saves_for.first.saver.id).to be saver2.id
+  end
+
+  it "should count the saved as registered if this is the savers first saved" do
+    saveable.save_by :saver => saver
+    expect(saveable.save_registered?).to be true
+  end
+
+  it "should not count the saved as being registered if that saver has already saved and the saved has not changed" do
+    saveable.save_by :saver => saver, :saved => true
+    saveable.save_by :saver => saver, :saved => 'yes'
+    expect(saveable.save_registered?).to be false
+  end
+
+  it "should count the saved as registered if the saver has saved and the saved flag has changed" do
+    saveable.save_by :saver => saver, :saved => true
+    saveable.save_by :saver => saver, :saved => 'dislike'
+    expect(saveable.save_registered?).to be true
+  end
+
+  it "should count the saved as registered if the saver has saved and the saved weight has changed" do
+    saveable.save_by :saver => saver, :saved => true, :save_weight => 1
+    saveable.save_by :saver => saver, :saved => true, :save_weight => 2
+    expect(saveable.save_registered?).to be true
+  end
+
+  it "should be saved on by saver" do
+    saveable.save_by :saver => saver
+    expect(saveable.saved_on_by?(saver)).to be true
+  end
+
+  it "should be able to unsaved a saver" do
+    saveable.upsaved_by(saver)
+    saveable.unsave_by(saver)
+    expect(saveable.saved_on_by?(saver)).to be false
+  end
+
+  it "should unsaved a positive saved" do
+    saveable.save_by :saver => saver
+    saveable.unsaved :saver => saver
+    expect(saveable.find_saves_for.count).to eq(0)
+  end
+
+  it "should set the saveable to unregistered after unsaving" do
+    saveable.save_by :saver => saver
+    saveable.unsaved :saver => saver
+    expect(saveable.save_registered?).to be false
+  end
+
+  it "should unsaved a negative saved" do
+    saveable.save_by :saver => saver, :saved => 'no'
+    saveable.unsaved :saver => saver
+    expect(saveable.find_saves_for.count).to eq(0)
+  end
+
+  it "should unsaved only the from a single saver" do
+    saveable.save_by :saver => saver
+    saveable.save_by :saver => saver2
+    saveable.unsaved :saver => saver
+    expect(saveable.find_saves_for.count).to eq(1)
+  end
+
+  it "should be contained to instances" do
+    saveable2 = Saveable.new(:name => '2nd saveable')
+    saveable2.save
+
+    saveable.save_by :saver => saver, :saved => false
+    saveable2.save_by :saver => saver, :saved => true
+    saveable2.save_by :saver => saver, :saved => true
+
+    expect(saveable.save_registered?).to be true
+    expect(saveable2.save_registered?).to be false
+  end
+
+  it "should set default saved weight to 1 if not specified" do
+    saveable.upsave_by saver
+    expect(saveable.find_saves_for.first.save_weight).to eq(1)
+  end
+
+  describe "with cached saves_for" do
+
+    before(:each) do
+      clean_database
+      saver = Saver.new(:name => 'i can saved!')
+      saver.save
+
+      saveable = Saveable.new(:name => 'a saving model without a cache')
+      saveable.save
+
+      saveable_cache = SaveableCache.new(:name => 'saving model with cache')
+      saveable_cache.save
+    end
+
+    it "should not update cached saves_for if there are no columns" do
+      saveable.save_by :saver => saver
+    end
+
+    it "should update cached total saves_for if there is a total column" do
+      saveable_cache.cached_saves_total = 50
+      saveable_cache.save_by :saver => saver
+      expect(saveable_cache.cached_saves_total).to eq(1)
+    end
+
+    it "should update cached total saves_for when a saved up is removed" do
+      saveable_cache.save_by :saver => saver, :saved => 'true'
+      saveable_cache.unsaved :saver => saver
+      expect(saveable_cache.cached_saves_total).to eq(0)
+    end
+
+    it "should update cached total saves_for when a saved down is removed" do
+      saveable_cache.save_by :saver => saver, :saved => 'false'
+      saveable_cache.unsaved :saver => saver
+      expect(saveable_cache.cached_saves_total).to eq(0)
+    end
+
+    it "should update cached score saves_for if there is a score column" do
+      saveable_cache.cached_saves_score = 50
+      saveable_cache.save_by :saver => saver
+      expect(saveable_cache.cached_saves_score).to eq(1)
+      saveable_cache.save_by :saver => saver2, :saved => 'false'
+      expect(saveable_cache.cached_saves_score).to eq(0)
+      saveable_cache.save_by :saver => saver, :saved => 'false'
+      expect(saveable_cache.cached_saves_score).to eq(-2)
+    end
+
+    it "should update cached score saves_for when a saved up is removed" do
+      saveable_cache.save_by :saver => saver, :saved => 'true'
+      expect(saveable_cache.cached_saves_score).to eq(1)
+      saveable_cache.unsaved :saver => saver
+      expect(saveable_cache.cached_saves_score).to eq(0)
+    end
+
+    it "should update cached score saves_for when a saved down is removed" do
+      saveable_cache.save_by :saver => saver, :saved => 'false'
+      expect(saveable_cache.cached_saves_score).to eq(-1)
+      saveable_cache.unsaved :saver => saver
+      expect(saveable_cache.cached_saves_score).to eq(0)
+    end
+
+    it "should update cached weighted total if there is a weighted total column" do
+      saveable_cache.cached_weighted_total = 50
+      saveable_cache.save_by :saver => saver
+      expect(saveable_cache.cached_weighted_total).to eq(1)
+      saveable_cache.save_by :saver => saver2, :saved => 'false'
+      expect(saveable_cache.cached_weighted_total).to eq(2)
+    end
+
+    it "should update cached weighted total saves_for when a saved up is removed" do
+      saveable_cache.save_by :saver => saver, :saved => 'true', :save_weight => 3
+      expect(saveable_cache.cached_weighted_total).to eq(3)
+      saveable_cache.unsaved :saver => saver
+      expect(saveable_cache.cached_weighted_total).to eq(0)
+    end
+
+    it "should update cached weighted total saves_for when a saved down is removed" do
+      saveable_cache.save_by :saver => saver, :saved => 'false', :save_weight => 4
+      expect(saveable_cache.cached_weighted_total).to eq(4)
+      saveable_cache.unsaved :saver => saver
+      expect(saveable_cache.cached_weighted_total).to eq(0)
+    end
+
+    it "should update cached weighted score if there is a weighted score column" do
+      saveable_cache.cached_weighted_score = 50
+      saveable_cache.save_by :saver => saver, :save_weight => 3
+      expect(saveable_cache.cached_weighted_score).to eq(3)
+      saveable_cache.save_by :saver => saver2, :saved => 'false', :save_weight => 5
+      expect(saveable_cache.cached_weighted_score).to eq(-2)
+      # saver changes her saved from 3 to 5
+      saveable_cache.save_by :saver => saver, :save_weight => 5
+      expect(saveable_cache.cached_weighted_score).to eq(0)
+      saveable_cache.save_by :saver => saver3, :save_weight => 4
+      expect(saveable_cache.cached_weighted_score).to eq(4)
+    end
+
+    it "should update cached weighted score saves_for when a saved up is removed" do
+      saveable_cache.save_by :saver => saver, :saved => 'true', :save_weight => 3
+      expect(saveable_cache.cached_weighted_score).to eq(3)
+      saveable_cache.unsaved :saver => saver
+      expect(saveable_cache.cached_weighted_score).to eq(0)
+    end
+
+    it "should update cached weighted score saves_for when a saved down is removed" do
+      saveable_cache.save_by :saver => saver, :saved => 'false', :save_weight => 4
+      expect(saveable_cache.cached_weighted_score).to eq(-4)
+      saveable_cache.unsaved :saver => saver
+      expect(saveable_cache.cached_weighted_score).to eq(0)
+    end
+
+    it "should update cached weighted average if there is a weighted average column" do
+      saveable_cache.cached_weighted_average = 50.0
+      saveable_cache.save_by :saver => saver, :saved => 'true', :save_weight => 5
+      expect(saveable_cache.cached_weighted_average).to eq(5.0)
+      saveable_cache.save_by :saver => saver2, :saved => 'true', :save_weight => 3
+      expect(saveable_cache.cached_weighted_average).to eq(4.0)
+      # saver changes her saved from 5 to 4
+      saveable_cache.save_by :saver => saver, :saved => 'true', :save_weight => 4
+      expect(saveable_cache.cached_weighted_average).to eq(3.5)
+      saveable_cache.save_by :saver => saver3, :saved => 'true', :save_weight => 5
+      expect(saveable_cache.cached_weighted_average).to eq(4.0)
+    end
+
+    it "should update cached weighted average saves_for when a saved up is removed" do
+      saveable_cache.save_by :saver => saver, :saved => 'true', :save_weight => 5
+      saveable_cache.save_by :saver => saver2, :saved => 'true', :save_weight => 3
+      expect(saveable_cache.cached_weighted_average).to eq(4)
+      saveable_cache.unsaved :saver => saver
+      expect(saveable_cache.cached_weighted_average).to eq(3)
+    end
+
+    it "should update cached up saves_for if there is an up saved column" do
+      saveable_cache.cached_saves_up = 50
+      saveable_cache.save_by :saver => saver
+      saveable_cache.save_by :saver => saver
+      expect(saveable_cache.cached_saves_up).to eq(1)
+    end
+
+    it "should update cached down saves_for if there is a down saved column" do
+      saveable_cache.cached_saves_down = 50
+      saveable_cache.save_by :saver => saver, :saved => 'false'
+      expect(saveable_cache.cached_saves_down).to eq(1)
+    end
+
+    it "should update cached up saves_for when a saved up is removed" do
+      saveable_cache.save_by :saver => saver, :saved => 'true'
+      saveable_cache.unsaved :saver => saver
+      expect(saveable_cache.cached_saves_up).to eq(0)
+    end
+
+    it "should update cached down saves_for when a saved down is removed" do
+      saveable_cache.save_by :saver => saver, :saved => 'false'
+      saveable_cache.unsaved :saver => saver
+      expect(saveable_cache.cached_saves_down).to eq(0)
+    end
+
+    it "should select from cached total saves_for if there a total column" do
+      saveable_cache.save_by :saver => saver
+      saveable_cache.cached_saves_total = 50
+      expect(saveable_cache.count_saves_total).to eq(50)
+    end
+
+    it "should select from cached up saves_for if there is an up saved column" do
+      saveable_cache.save_by :saver => saver
+      saveable_cache.cached_saves_up = 50
+      expect(saveable_cache.count_saves_up).to eq(50)
+    end
+
+    it "should select from cached down saves_for if there is a down saved column" do
+      saveable_cache.save_by :saver => saver, :saved => 'false'
+      saveable_cache.cached_saves_down = 50
+      expect(saveable_cache.count_saves_down).to eq(50)
+    end
+
+    it "should select from cached weighted total if there is a weighted total column" do
+      saveable_cache.save_by :saver => saver, :saved => 'false'
+      saveable_cache.cached_weighted_total = 50
+      expect(saveable_cache.weighted_total).to eq(50)
+    end
+
+    it "should select from cached weighted score if there is a weighted score column" do
+      saveable_cache.save_by :saver => saver, :saved => 'false'
+      saveable_cache.cached_weighted_score = 50
+      expect(saveable_cache.weighted_score).to eq(50)
+    end
+
+    it "should select from cached weighted average if there is a weighted average column" do
+      saveable_cache.save_by :saver => saver, :saved => 'false'
+      saveable_cache.cached_weighted_average = 50
+      expect(saveable_cache.weighted_average).to eq(50)
+    end
+
+    it "should update cached total saves_for when saving under an scope" do
+      saveable_cache.save_by :saver => saver, :saved => 'true', :save_scope => 'rank'
+      expect(saveable_cache.cached_saves_total).to eq(1)
+    end
+
+    it "should update cached up saves_for when saving under an scope" do
+      saveable_cache.save_by :saver => saver, :saved => 'true', :save_scope => 'rank'
+      expect(saveable_cache.cached_saves_up).to eq(1)
+    end
+
+    it "should update cached total saves_for when a scoped saved down is removed" do
+      saveable_cache.save_by :saver => saver, :saved => 'true', :save_scope => 'rank'
+      saveable_cache.unsaved :saver => saver, :save_scope => 'rank'
+      expect(saveable_cache.cached_saves_total).to eq(0)
+    end
+
+    it "should update cached up saves_for when a scoped saved down is removed" do
+      saveable_cache.save_by :saver => saver, :saved => 'true', :save_scope => 'rank'
+      saveable_cache.unsaved :saver => saver, :save_scope => 'rank'
+      expect(saveable_cache.cached_saves_up).to eq(0)
+    end
+
+    it "should update cached down saves_for when downsaving under a scope" do
+      saveable_cache.save_by :saver => saver, :saved => 'false', :save_scope => 'rank'
+      expect(saveable_cache.cached_saves_down).to eq(1)
+    end
+
+    it "should update cached down saves_for when a scoped saved down is removed" do
+      saveable_cache.save_by :saver => saver, :saved => 'false', :save_scope => 'rank'
+      saveable_cache.unsaved :saver => saver, :save_scope => 'rank'
+      expect(saveable_cache.cached_saves_down).to eq(0)
+    end
+
+  end
+
+  describe "with scoped cached saves_for" do
+
+    it "should update cached total saves_for if there is a total column" do
+      saveable_cache.cached_scoped_test_saves_total = 50
+      saveable_cache.save_by :saver => saver, :save_scope => "test"
+      expect(saveable_cache.cached_scoped_test_saves_total).to eq(1)
+    end
+
+    it "should update cached total saves_for when a saved up is removed" do
+      saveable_cache.save_by :saver => saver, :saved => 'true', :save_scope => "test"
+      saveable_cache.unsaved :saver => saver, :save_scope => "test"
+      expect(saveable_cache.cached_scoped_test_saves_total).to eq(0)
+    end
+
+    it "should update cached total saves_for when a saved down is removed" do
+      saveable_cache.save_by :saver => saver, :saved => 'false', :save_scope => "test"
+      saveable_cache.unsaved :saver => saver, :save_scope => "test"
+      expect(saveable_cache.cached_scoped_test_saves_total).to eq(0)
+    end
+
+    it "should update cached score saves_for if there is a score column" do
+      saveable_cache.cached_scoped_test_saves_score = 50
+      saveable_cache.save_by :saver => saver, :save_scope => "test"
+      expect(saveable_cache.cached_scoped_test_saves_score).to eq(1)
+      saveable_cache.save_by :saver => saver2, :saved => 'false', :save_scope => "test"
+      expect(saveable_cache.cached_scoped_test_saves_score).to eq(0)
+      saveable_cache.save_by :saver => saver, :saved => 'false', :save_scope => "test"
+      expect(saveable_cache.cached_scoped_test_saves_score).to eq(-2)
+    end
+
+    it "should update cached score saves_for when a saved up is removed" do
+      saveable_cache.save_by :saver => saver, :saved => 'true', :save_scope => "test"
+      expect(saveable_cache.cached_scoped_test_saves_score).to eq(1)
+      saveable_cache.unsaved :saver => saver, :save_scope => "test"
+      expect(saveable_cache.cached_scoped_test_saves_score).to eq(0)
+    end
+
+    it "should update cached score saves_for when a saved down is removed" do
+      saveable_cache.save_by :saver => saver, :saved => 'false', :save_scope => "test"
+      expect(saveable_cache.cached_scoped_test_saves_score).to eq(-1)
+      saveable_cache.unsaved :saver => saver, :save_scope => "test"
+      expect(saveable_cache.cached_scoped_test_saves_score).to eq(0)
+    end
+
+    it "should update cached up saves_for if there is an up saved column" do
+      saveable_cache.cached_scoped_test_saves_up = 50
+      saveable_cache.save_by :saver => saver, :save_scope => "test"
+      saveable_cache.save_by :saver => saver, :save_scope => "test"
+      expect(saveable_cache.cached_scoped_test_saves_up).to eq(1)
+    end
+
+    it "should update cached down saves_for if there is a down saved column" do
+      saveable_cache.cached_scoped_test_saves_down = 50
+      saveable_cache.save_by :saver => saver, :saved => 'false', :save_scope => "test"
+      expect(saveable_cache.cached_scoped_test_saves_down).to eq(1)
+    end
+
+    it "should update cached up saves_for when a saved up is removed" do
+      saveable_cache.save_by :saver => saver, :saved => 'true', :save_scope => "test"
+      saveable_cache.unsaved :saver => saver, :save_scope => "test"
+      expect(saveable_cache.cached_scoped_test_saves_up).to eq(0)
+    end
+
+    it "should update cached down saves_for when a saved down is removed" do
+      saveable_cache.save_by :saver => saver, :saved => 'false', :save_scope => "test"
+      saveable_cache.unsaved :saver => saver, :save_scope => "test"
+      expect(saveable_cache.cached_scoped_test_saves_down).to eq(0)
+    end
+
+    it "should select from cached total saves_for if there a total column" do
+      saveable_cache.save_by :saver => saver, :save_scope => "test"
+      saveable_cache.cached_scoped_test_saves_total = 50
+      expect(saveable_cache.count_saves_total(false, "test")).to eq(50)
+    end
+
+    it "should select from cached up saves_for if there is an up saved column" do
+      saveable_cache.save_by :saver => saver, :save_scope => "test"
+      saveable_cache.cached_scoped_test_saves_up = 50
+      expect(saveable_cache.count_saves_up(false, "test")).to eq(50)
+    end
+
+    it "should select from cached down saves_for if there is a down saved column" do
+      saveable_cache.save_by :saver => saver, :saved => 'false', :save_scope => "test"
+      saveable_cache.cached_scoped_test_saves_down = 50
+      expect(saveable_cache.count_saves_down(false, "test")).to eq(50)
+    end
+
+  end
+
+  describe "sti models" do
+
+    it "should be able to saved on a saveable child of a non saveable sti model" do
+      saveable = SaveableChildOfStiNotSaveable.create(:name => 'sti child')
+
+      saveable.save_by :saver => saver, :saved => 'yes'
+      expect(saveable.saves_for.size).to eq(1)
+    end
+
+    it "should not be able to saved on a parent non saveable" do
+      expect(StiNotSaveable).not_to be_saveable
+    end
+
+    it "should be able to saved on a child when its parent is saveable" do
+      saveable = ChildOfStiSaveable.create(:name => 'sti child')
+
+      saveable.save_by :saver => saver, :saved => 'yes'
+      expect(saveable.saves_for.size).to eq(1)
+    end
+  end
+end