constant_table_saver 3.0.1 → 4.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 250b25d7f3fefffc880e4f1ed9bd349aaa9ed601
+  data.tar.gz: bc75e2890206f99c0b0bdd049921afca4a55b492
+SHA512:
+  metadata.gz: 7d580056718eac74024e54d0cca28c0219551b9407e6d2540fa753117fd4c8e41d77c99180c009197c7a3e26432a2efaa05894c3a3d4c5de62a5717708be1237
+  data.tar.gz: baebaf8845f8ca7de92ea243bca01e5e69624d79f293b6b9415e80db9da39c2acbb54d9acf03baf700e2933a40bca563eabcf14de5f9eccd00f3c2aacf98a1a1

data/lib/constant_table_saver.rb

@@ -1,4 +1,5 @@
 require 'active_record/fixtures' # so we can hook it & reset our cache afterwards
+require 'active_support/core_ext/object/to_param'
 
 module ConstantTableSaver
   module BaseMethods
@@ -7,16 +8,15 @@ module ConstantTableSaver
       class_attribute :constant_table_options, :instance_writer => false
       self.constant_table_options = options
       
-      if ActiveRecord::VERSION::MAJOR > 2
-        require 'active_support/core_ext/object/to_param'
+      if ActiveRecord::VERSION::MAJOR == 3
         extend ActiveRecord3ClassMethods
       else
-        extend ActiveRecord2ClassMethods
+        extend ActiveRecord4ClassMethods
       end
       extend ClassMethods
       extend NameClassMethods if constant_table_options[:name]
       
-      klass = defined?(Fixtures) ? Fixtures : ActiveRecord::Fixtures
+      klass = defined?(ActiveRecord::FixtureSet) ? ActiveRecord::FixtureSet : ActiveRecord::Fixtures
       class <<klass
         # normally, create_fixtures method gets called exactly once - but unfortunately, it
         # loads the class and does a #respond_to?, which causes us to load and cache before
@@ -45,7 +45,55 @@ module ConstantTableSaver
     # plugin on if the table isn't really constant!
     def reset_constant_record_cache!
       @constant_record_methods.each {|method_id| (class << self; self; end;).send(:remove_method, method_id)} if @constant_record_methods
-      @cached_records = @cached_records_by_id = @constant_record_methods = @cached_blank_scope = nil
+      @cached_records = @cached_records_by_id = @constant_record_methods = @cached_blank_scope = @find_by_sql = nil
+    end
+  end
+
+  module ActiveRecord4ClassMethods
+    def find_by_sql(sql, binds = [])
+      @find_by_sql ||= {}
+      @find_by_sql[:all]   ||= all.to_sql
+      @find_by_sql[:id]    ||= relation.where(relation.table[primary_key].eq(connection.substitute_at(columns_hash[primary_key], 1))).limit(1).to_sql
+      @find_by_sql[:oldid] ||= relation.where(relation.table[primary_key].eq(connection.substitute_at(columns_hash[primary_key], 1))).
+                                         order(relation.table[primary_key].asc).limit(1).to_sql # used by 4.0
+      @find_by_sql[:first] ||= relation.order(relation.table[primary_key].asc).limit(1).to_sql
+      @find_by_sql[:last]  ||= relation.order(relation.table[primary_key].desc).limit(1).to_sql
+
+      _sql = sanitize_sql(sql)
+      _sql = _sql.to_sql if sql.respond_to?(:to_sql)
+
+      if binds.empty?
+        if _sql == @find_by_sql[:all]
+          return @cached_records ||= super(relation.to_sql).each(&:freeze)
+        elsif _sql == @find_by_sql[:first]
+          return [relation.to_a.first].compact
+        elsif _sql == @find_by_sql[:last]
+          return [relation.to_a.last].compact
+        end
+
+      elsif (_sql == @find_by_sql[:id] || _sql == @find_by_sql[:oldid]) &&
+            binds.length == 1 &&
+            binds.first.first.is_a?(ActiveRecord::ConnectionAdapters::Column) &&
+            binds.first.first.name == primary_key
+        @cached_records_by_id ||= relation.to_a.index_by {|record| record.id.to_param}
+        return [@cached_records_by_id[binds.first.last.to_param]].compact
+      end
+
+      super
+    end
+
+    def relation
+      super.tap do |s|
+        class << s
+          # we implement find_some here because we'd have to use partial string matching to catch
+          # this case in find_by_sql, which would be ugly.  (we do the other cases in find_by_sql
+          # because it's simpler & the only place to catch things like association find queries.)
+          def find_some(ids)
+            return super if @values.present? # special cases such as offset and limit
+            ids.collect {|id| find_one(id)}
+          end
+        end
+      end
     end
   end
 
@@ -110,23 +158,21 @@ module ConstantTableSaver
           # this so we have to shove in the instance variables.
           #
           # it will be clear that this was a very problematic ActiveRecord refactoring.
-          if ActiveRecord::VERSION::MINOR > 0
-            def belongs_to_record_scopes
-              @belongs_to_record_scopes ||= to_a.each_with_object({}) do |record, results|
-                scope_that_belongs_to_will_want = where(table[primary_key].eq(record.id))
-                scope_that_belongs_to_will_want.instance_variable_set("@loaded", true)
-                scope_that_belongs_to_will_want.instance_variable_set("@records", [record])
-                results[scope_that_belongs_to_will_want.to_sql] = scope_that_belongs_to_will_want
-              end.freeze
-            end
-
-            def merge(other)
-              if belongs_to_record_scope = belongs_to_record_scopes[other.to_sql]
-                return belongs_to_record_scope
-              end
+          def belongs_to_record_scopes
+            @belongs_to_record_scopes ||= to_a.each_with_object({}) do |record, results|
+              scope_that_belongs_to_will_want = where(table[primary_key].eq(record.id))
+              scope_that_belongs_to_will_want.instance_variable_set("@loaded", true)
+              scope_that_belongs_to_will_want.instance_variable_set("@records", [record])
+              results[scope_that_belongs_to_will_want.to_sql] = scope_that_belongs_to_will_want
+            end.freeze
+          end
 
-              super other
+          def merge(other)
+            if belongs_to_record_scope = belongs_to_record_scopes[other.to_sql]
+              return belongs_to_record_scope
             end
+
+            super other
           end
         
         private
@@ -141,45 +187,7 @@ module ConstantTableSaver
       end
     end
   end
-  
-  module ActiveRecord2ClassMethods
-    def find(*args)
-      options = args.last if args.last.is_a?(Hash)
-      return super unless options.blank? || options.all? {|k, v| v.nil?}
-      scope_options = scope(:find)
-      return super unless scope_options.blank? || scope_options.all? {|k, v| v.nil?}
-
-      args.pop unless options.nil?
 
-      @cached_records ||= super(:all, :order => primary_key).each(&:freeze)
-      @cached_records_by_id ||= @cached_records.index_by {|record| record.id.to_param}
-
-      case args.first
-        when :first then @cached_records.first
-        when :last  then @cached_records.last
-        when :all   then @cached_records.dup # shallow copy of the array
-        else
-          expects_array = args.first.kind_of?(Array)
-          return args.first if expects_array && args.first.empty?
-          ids = expects_array ? args.first : args
-          ids = ids.flatten.compact.uniq
-
-          case ids.size
-            when 0
-              raise ::ActiveRecord::RecordNotFound, "Couldn't find #{name} without an ID"
-            when 1
-              result = @cached_records_by_id[ids.first.to_param] || raise(::ActiveRecord::RecordNotFound, "Couldn't find #{name} with ID=#{ids.first}")
-              expects_array ? [result] : result
-            else
-              ids.collect {|id| @cached_records_by_id[id.to_param]}.tap do |results|
-                results.compact!
-                raise(::ActiveRecord::RecordNotFound, "Couldn't find all #{name.pluralize} with IDs #{ids.join ','} (found #{results.size} results, but was looking for #{ids.size}") unless results.size == ids.size
-              end
-          end
-      end
-    end
-  end
-  
   module NameClassMethods
     def define_named_record_methods
       @constant_record_methods = [] # dummy so respond_to? & method_missing don't call us again if reading an attribute causes another method_missing

data/lib/constant_table_saver/version.rb

@@ -1,3 +1,3 @@
 module ConstantTableSaver
-  VERSION = '3.0.1'
+  VERSION = '4.0.0'
 end

data/test/activerecord_count_queries.rb

@@ -1,19 +1,6 @@
-if ActiveRecord::VERSION::MAJOR < 3 || (ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR < 1)
-  # proudly stolen from ActiveRecord's test suite, with addition of BEGIN and COMMIT
-  ActiveRecord::Base.connection.class.class_eval do
-    IGNORED_SQL = [/^PRAGMA/, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/, /^SELECT @@ROWCOUNT/, /^SAVEPOINT/, /^ROLLBACK TO SAVEPOINT/, /^RELEASE SAVEPOINT/, /SHOW FIELDS/, /^BEGIN$/, /^COMMIT$/]
-
-    def execute_with_query_record(sql, name = nil, &block)
-      $queries_executed ||= []
-      $queries_executed << sql unless IGNORED_SQL.any? { |r| sql =~ r }
-      execute_without_query_record(sql, name, &block)
-    end
-
-    alias_method_chain :execute, :query_record
-  end
-elsif ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR < 2
+if ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR < 2
   # this is from 3.1's test suite.  ugly.
-  class ActiveRecord::SQLCounter
+  class SQLCounter
     cattr_accessor :ignored_sql
     self.ignored_sql = [/^PRAGMA (?!(table_info))/, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/, /^SELECT @@ROWCOUNT/, /^SAVEPOINT/, /^ROLLBACK TO SAVEPOINT/, /^RELEASE SAVEPOINT/, /^SHOW max_identifier_length/, /^BEGIN/, /^COMMIT/]
 
@@ -21,10 +8,14 @@ elsif ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR < 2
     # ignored SQL.  This ignored SQL is for Oracle.
     ignored_sql.concat [/^select .*nextval/i, /^SAVEPOINT/, /^ROLLBACK TO/, /^\s*select .* from all_triggers/im]
 
-    def initialize
+    def self.clear_log
       $queries_executed = []
     end
 
+    def initialize
+      $queries_executed.clear
+    end
+
     def call(name, start, finish, message_id, values)
       sql = values[:sql]
 
@@ -36,10 +27,10 @@ elsif ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR < 2
       end
     end
   end
-  ActiveSupport::Notifications.subscribe('sql.active_record', ActiveRecord::SQLCounter.new)
+  ActiveSupport::Notifications.subscribe('sql.active_record', SQLCounter.new)
 else
   # this is from 3.2's test suite.  ugly.
-  class ActiveRecord::SQLCounter
+  class SQLCounter
     cattr_accessor :ignored_sql
     self.ignored_sql = [/^PRAGMA (?!(table_info))/, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/, /^SELECT @@ROWCOUNT/, /^SAVEPOINT/, /^ROLLBACK TO SAVEPOINT/, /^RELEASE SAVEPOINT/, /^SHOW max_identifier_length/, /^BEGIN/, /^COMMIT/]
 
@@ -52,6 +43,10 @@ else
 
     attr_reader :ignore
 
+    def self.clear_log
+      self.log.clear
+    end
+
     def initialize(ignore = self.class.ignored_sql)
       @ignore   = ignore
     end
@@ -66,5 +61,5 @@ else
     end
   end
 
-  ActiveSupport::Notifications.subscribe('sql.active_record', ActiveRecord::SQLCounter.new)
+  ActiveSupport::Notifications.subscribe('sql.active_record', SQLCounter.new)
 end

data/test/constant_table_saver_test.rb

@@ -9,11 +9,7 @@ class ConstantPie < ActiveRecord::Base
   set_table_name "pies"
   constant_table
   
-  if defined?(named_scope)
-    named_scope :filled_with_unicorn, :conditions => {:filling => 'unicorn'}
-  else
-    scope :filled_with_unicorn, :conditions => {:filling => 'unicorn'}
-  end
+  scope :filled_with_unicorn, -> { where(:filling => 'unicorn') }
   
   def self.with_unicorn_filling_scope
     with_scope(:find => {:conditions => {:filling => 'unicorn'}}) { yield }
@@ -40,32 +36,45 @@ class IngredientForConstantPie < ActiveRecord::Base
   belongs_to :pie, :class_name => "ConstantPie"
 end
 
-class ConstantTableSaverTest < ActiveRecord::TestCase
+class ConstantTableSaverTest < ActiveSupport::TestCase
   fixtures :all
   
-  setup do
+  def setup
     ConstantPie.reset_constant_record_cache!
   end
 
-  test "it caches find(:all) results" do
-    @pies = StandardPie.find(:all)
+  def assert_queries(num = 1)
+    ::SQLCounter.clear_log
+    yield
+  ensure
+    assert_equal num, ::SQLCounter.log.size, "#{::SQLCounter.log.size} instead of #{num} queries were executed.#{::SQLCounter.log.size == 0 ? '' : "\nQueries:\n#{::SQLCounter.log.join("\n")}"}"
+  end
+
+  def assert_no_queries(&block)
+    assert_queries(0, &block)
+  end
+
+  DEPRECATED_FINDERS = ActiveRecord::VERSION::MAJOR == 3 || (ActiveRecord::VERSION::MAJOR == 4 && ActiveRecord::VERSION::MINOR == 0)
+
+  test "it caches all() results" do
+    @pies = StandardPie.all.to_a
     assert_queries(1) do
-      assert_equal @pies.collect(&:attributes), ConstantPie.find(:all).collect(&:attributes)
+      assert_equal @pies.collect(&:attributes), ConstantPie.all.to_a.collect(&:attributes)
     end
     assert_no_queries do
-      assert_equal @pies.collect(&:attributes), ConstantPie.find(:all).collect(&:attributes)
+      assert_equal @pies.collect(&:attributes), ConstantPie.all.to_a.collect(&:attributes)
     end
   end
 
-  test "it caches all() results" do
-    @pies = StandardPie.all
+  test "it caches find(:all) results" do
+    @pies = StandardPie.find(:all).to_a
     assert_queries(1) do
-      assert_equal @pies.collect(&:attributes), ConstantPie.all.collect(&:attributes)
+      assert_equal @pies.collect(&:attributes), ConstantPie.find(:all).to_a.collect(&:attributes)
     end
     assert_no_queries do
-      assert_equal @pies.collect(&:attributes), ConstantPie.all.collect(&:attributes)
+      assert_equal @pies.collect(&:attributes), ConstantPie.find(:all).to_a.collect(&:attributes)
     end
-  end
+  end if DEPRECATED_FINDERS
 
   test "it caches find(id) results" do
     @pie = StandardPie.find(1)
@@ -96,7 +105,7 @@ class ConstantTableSaverTest < ActiveRecord::TestCase
     assert_no_queries do
       assert_equal @pie.attributes, ConstantPie.find(:first).attributes
     end
-  end
+  end if DEPRECATED_FINDERS
 
   test "it caches first() results" do
     @pie = StandardPie.first
@@ -116,7 +125,7 @@ class ConstantTableSaverTest < ActiveRecord::TestCase
     assert_no_queries do
       assert_equal @pie.attributes, ConstantPie.find(:last).attributes
     end
-  end
+  end if DEPRECATED_FINDERS
   
   test "it caches last() results" do
     @pie = StandardPie.last
@@ -129,9 +138,9 @@ class ConstantTableSaverTest < ActiveRecord::TestCase
   end
   
   test "it caches belongs_to association find queries" do
-    @standard_pie_ingredients = IngredientForStandardPie.all
+    @standard_pie_ingredients = IngredientForStandardPie.all.to_a
     @standard_pies = @standard_pie_ingredients.collect(&:pie)
-    @constant_pie_ingredients = IngredientForConstantPie.all
+    @constant_pie_ingredients = IngredientForConstantPie.all.to_a
     assert_queries(1) do # doesn't need to make 3 queries for 3 pie assocations!
       assert_equal @standard_pies.collect(&:attributes), @constant_pie_ingredients.collect(&:pie).collect(&:attributes)
     end
@@ -141,46 +150,68 @@ class ConstantTableSaverTest < ActiveRecord::TestCase
   end
   
   test "it isn't affected by scopes active at the time of first load" do
-    assert_equal 0, ConstantPie.filled_with_unicorn.all.size
-    assert_equal 0, ConstantPie.with_unicorn_filling_scope { ConstantPie.all.length }
-    assert_equal StandardPie.all.size, ConstantPie.all.size
+    assert_equal 0, ConstantPie.filled_with_unicorn.all.to_a.size
+    assert_equal 0, ConstantPie.with_unicorn_filling_scope { ConstantPie.all.to_a.length } if DEPRECATED_FINDERS
+    assert_equal StandardPie.all.to_a.size, ConstantPie.all.to_a.size
   end
   
   test "it isn't affected by relational algebra active at the time of first load" do
-    assert_equal 0, ConstantPie.filled_with_unicorn.all.size
-    assert_equal 0, ConstantPie.where(:filling => 'unicorn').all.length
-    assert_equal 2, ConstantPie.where("filling LIKE 'Tasty%'").all.length
-    assert_equal StandardPie.all.size, ConstantPie.all.size
-  end if ActiveRecord::VERSION::MAJOR > 2
+    assert_equal 0, ConstantPie.filled_with_unicorn.all.to_a.size
+    assert_equal 0, ConstantPie.where(:filling => 'unicorn').all.to_a.length
+    assert_equal 2, ConstantPie.where("filling LIKE 'Tasty%'").all.to_a.length
+    assert_equal StandardPie.all.to_a.size, ConstantPie.all.to_a.size
+  end
   
   test "prevents the returned records from modification" do
-    @pie = ConstantPie.find(:first)
+    @pie = ConstantPie.first
     assert @pie.frozen?
-    assert !StandardPie.find(:first).frozen?
+    assert !StandardPie.first.frozen?
   end
   
   test "isn't affected by modifying the returned result arrays" do
-    @pies = ConstantPie.all
+    @pies = ConstantPie.all.to_a
     @pies.reject! {|pie| pie.filling =~ /Steak/}
-    assert_equal StandardPie.all.collect(&:attributes), ConstantPie.all.collect(&:attributes)
+    assert_equal StandardPie.all.to_a.collect(&:attributes), ConstantPie.all.to_a.collect(&:attributes)
+  end
+
+  test "it doesn't cache find queries on scopes with options" do
+    @pies = StandardPie.select("id").all.to_a
+    @pie = StandardPie.select("id").find(1)
+    @second_pie = StandardPie.select("id").find(2)
+    assert_queries(3) do
+      assert_equal @pies.collect(&:attributes), ConstantPie.select("id").all.collect(&:attributes)
+      assert_equal @pie.attributes, ConstantPie.select("id").find(1).attributes
+      assert_equal [@pie, @second_pie].collect(&:attributes), ConstantPie.select("id").find([1, 2]).collect(&:attributes)
+    end
+    assert_queries(3) do
+      assert_equal @pies.collect(&:attributes), ConstantPie.select("id").all.collect(&:attributes)
+      assert_equal @pie.attributes, ConstantPie.select("id").find(1).attributes
+      assert_equal [@pie, @second_pie].collect(&:attributes), ConstantPie.select("id").find([1, 2]).collect(&:attributes)
+    end
   end
   
   test "it doesn't cache find queries with options" do
-    @pies = StandardPie.find(:all, :lock => true)
-    @pie = StandardPie.find(1, :lock => true)
-    assert_queries(2) do
-      assert_equal @pies.collect(&:attributes), ConstantPie.find(:all, :lock => true).collect(&:attributes)
-      assert_equal @pie.attributes, ConstantPie.find(1, :lock => true).attributes
+    @pies = StandardPie.all(:select => "id").to_a
+    @pie = StandardPie.find(1, :select => "id")
+    assert_queries(3) do
+      assert_equal @pies.collect(&:attributes), ConstantPie.all(:select => "id").collect(&:attributes)
+      assert_equal @pies.collect(&:attributes), ConstantPie.find(:all, :select => "id").collect(&:attributes)
+      assert_equal @pie.attributes, ConstantPie.find(1, :select => "id").attributes
     end
-    assert_queries(2) do
-      assert_equal @pies.collect(&:attributes), ConstantPie.find(:all, :lock => true).collect(&:attributes)
-      assert_equal @pie.attributes, ConstantPie.find(1, :lock => true).attributes
+    assert_queries(3) do
+      assert_equal @pies.collect(&:attributes), ConstantPie.all(:select => "id").collect(&:attributes)
+      assert_equal @pies.collect(&:attributes), ConstantPie.find(:all, :select => "id").collect(&:attributes)
+      assert_equal @pie.attributes, ConstantPie.find(1, :select => "id").attributes
     end
-  end
+  end if DEPRECATED_FINDERS
   
   test "it passes the options preventing caching to the underlying query methods" do
-    assert_equal nil, ConstantPie.find(:first, :conditions => {:filling => 'unicorn'})
-    assert_equal [],  ConstantPie.find(:all,   :conditions => {:filling => 'unicorn'})
+    assert_equal nil, ConstantPie.where(:filling => 'unicorn').first
+    assert_equal nil, ConstantPie.first(:conditions => {:filling => 'unicorn'}) if DEPRECATED_FINDERS
+    assert_equal nil, ConstantPie.find(:first, :conditions => {:filling => 'unicorn'}) if DEPRECATED_FINDERS
+    assert_equal [],  ConstantPie.where(:filling => 'unicorn').all
+    assert_equal [],  ConstantPie.all(:conditions => {:filling => 'unicorn'}) if DEPRECATED_FINDERS
+    assert_equal [],  ConstantPie.find(:all,   :conditions => {:filling => 'unicorn'}) if DEPRECATED_FINDERS
   end
   
   test "it creates named class methods if a :name option is given" do
@@ -215,14 +246,14 @@ class ConstantTableSaverTest < ActiveRecord::TestCase
   end
   
   test "it raises the usual exception if asked for a nonexistant records" do
-    max_id = ConstantPie.all.collect(&:id).max
+    max_id = ConstantPie.all.to_a.collect(&:id).max
     assert_raises ActiveRecord::RecordNotFound do
       ConstantPie.find(max_id + 1)
     end
   end
   
   test "it raises the usual exception if asked for a mixture of present records and nonexistant records" do
-    max_id = ConstantPie.all.collect(&:id).max
+    max_id = ConstantPie.all.to_a.collect(&:id).max
     assert_raises ActiveRecord::RecordNotFound do
       ConstantPie.find([max_id, max_id + 1])
     end

data/test/test_helper.rb

@@ -1,24 +1,15 @@
-if File.exist?("../../../config/boot.rb")
-  require "../../../config/boot.rb"
-else
-  require 'rubygems'
-end
+require 'rubygems'
 
+gem 'minitest', (ENV['RAILS_VERSION'] =~ /^(3\.|4\.0)/ ? '~> 4.0' : nil)
 gem 'activesupport', ENV['RAILS_VERSION']
 gem 'activerecord',  ENV['RAILS_VERSION']
 
-require 'test/unit'
+require 'minitest/autorun'
 require 'active_support'
 require 'active_support/test_case'
 require 'active_record'
 require 'active_record/fixtures'
-
-begin
-  require 'ruby-debug'
-  Debugger.start
-rescue LoadError
-  # ruby-debug not installed, no debugging for you
-end
+require 'byebug' rescue nil
 
 RAILS_ENV = ENV['RAILS_ENV'] ||= 'test'
 
@@ -28,4 +19,10 @@ load(File.join(File.dirname(__FILE__), "/schema.rb"))
 ActiveSupport::TestCase.send(:include, ActiveRecord::TestFixtures) if ActiveRecord.const_defined?('TestFixtures')
 ActiveSupport::TestCase.fixture_path = File.join(File.dirname(__FILE__), "fixtures")
 
+ActiveRecord::Base.class_eval do
+  unless instance_methods.include?(:set_table_name)
+    eval "class << self; def set_table_name(x); self.table_name = x; end; end"
+  end
+end
+
 require File.expand_path(File.join(File.dirname(__FILE__), '../init')) # load the plugin

metadata

@@ -1,86 +1,75 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: constant_table_saver
-version: !ruby/object:Gem::Version 
-  hash: 5
-  prerelease: 
-  segments: 
-  - 3
-  - 0
-  - 1
-  version: 3.0.1
+version: !ruby/object:Gem::Version
+  version: 4.0.0
 platform: ruby
-authors: 
+authors:
 - Will Bryant
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2013-06-11 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2014-05-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: activerecord
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: rake
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: sqlite3
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id003
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |
   Loads all records from the table on first use, and thereafter returns the
   cached (and frozen) records for all find calls.
-  
+
   Optionally, creates class-level methods you can use to grab the records,
   named after the name field you specify.
-  
-  
+
+
   Compatibility
   =============
-  
+
   Currently tested against Rails 3.2.13, on Ruby 1.8.7 and 2.0.0p0.
   Was also tested compatible with 2.3.14, 3.0.17, and 3.1.8.
-
 email: will.bryant@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .gitignore
 - Gemfile
 - MIT-LICENSE
@@ -99,38 +88,29 @@ files:
 - test/test_helper.rb
 homepage: http://github.com/willbryant/constant_table_saver
 licenses: []
-
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.8.15
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
-summary: Caches the records from fixed tables, and provides convenience methods to get them.
-test_files: 
+specification_version: 4
+summary: Caches the records from fixed tables, and provides convenience methods to
+  get them.
+test_files:
 - test/activerecord_count_queries.rb
 - test/constant_table_saver_test.rb
 - test/database.yml