constant_table_saver 4.2.0 → 5.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e2578ce8faa60c69b0c71cac907a097168fefcda
-  data.tar.gz: 8b53a074ed7d5f9d919de2b0de4e8d1a8cbb8140
+  metadata.gz: c0478d2577af80dc5fc4c7bf860321b72c49e2c1
+  data.tar.gz: 27060f22739b2cdb8a0cbf36f56ebe186e9b6333
 SHA512:
-  metadata.gz: ce00c64f33fe8a7aee4291579ecddd24d5d18f0aadaeafbaf4d7cd3b7074f11c8a32e97c154d9e6a769fb7b664e18bb08343bfe72c0dd642b5c1419dfea247ec
-  data.tar.gz: bd8e42cdf8dc69619c13b195799fe886c0d41873ed061229c95b37c3ec30fda113ed9964871d5781bf829e0ff3504158a481525253673332bf649774406f7d39
+  metadata.gz: 3784c8649039aca241ae5e3b87b4b94d219c4c159d91b79d261dc1af3fa7795e4368e4ab97535290c0fec3c759d3729a5959988012bb7f10cd7d0b915fd854f2
+  data.tar.gz: 559071bc2fbadd429c6c2634a1f3eb71e27258c9dc260c38a60681527adf3b8436b4945a932cf83b7bc1e9e2c5898132879a87adc34a729a18486d8bd144ae6a

data/README

@@ -11,10 +11,9 @@ named after the name field you specify.
 Compatibility
 =============
 
-Currently tested against Rails 4.2 (up to 4.2.3), 4.1 (up to 4.1.12), 4.0 (up to 4.0.13), and 3.2 (3.2.18), on Ruby 2.1.5.
+Currently tested against Rails 5.1 (5.1.0beta2) and 5.0 (up to 5.0.2) and 4.2 (up to 4.2.7), on Ruby 2.3.4.
 
-Was also previously tested compatible with 2.3.14, 3.0.17, and 3.1.8 on Ruby 2.0.0
-or 1.8.7 as appropriate, and may still work for them.
+For earlier versions of Rails, use an older version of the gem.
 
 
 Example

data/constant_table_saver.gemspec

@@ -16,10 +16,9 @@ named after the name field you specify.
 Compatibility
 =============
 
-Currently tested against Rails 4.2 (up to 4.2.3), 4.1 (up to 4.1.12), 4.0 (up to 4.0.13), and 3.2 (3.2.18), on Ruby 2.1.5.
+Currently tested against Rails 5.1 (5.1.0beta2) and 5.0 (up to 5.0.2) and 4.2 (up to 4.2.7), on Ruby 2.3.4.
 
-Was also previously tested compatible with 2.3.14, 3.0.17, and 3.1.8 on Ruby 2.0.0
-or 1.8.7 as appropriate, and may still work for them.
+For earlier versions of Rails, use an older version of the gem.
 EOF
   gem.has_rdoc     = false
   gem.author       = "Will Bryant"

data/lib/constant_table_saver/version.rb

@@ -1,3 +1,3 @@
 module ConstantTableSaver
-  VERSION = '4.2.0'
+  VERSION = '5.1.0'
 end

data/lib/constant_table_saver.rb

@@ -7,11 +7,13 @@ module ConstantTableSaver
       options.assert_valid_keys(:name, :name_prefix, :name_suffix)
       class_attribute :constant_table_options, :instance_writer => false
       self.constant_table_options = options
+
+      @constant_record_methods = nil
       
-      if ActiveRecord::VERSION::MAJOR == 3
-        extend ActiveRecord3ClassMethods
-      else
+      if ActiveRecord::VERSION::MAJOR == 4
         extend ActiveRecord4ClassMethods
+      else
+        extend ActiveRecord5ClassMethods
       end
       extend ClassMethods
       extend NameClassMethods if constant_table_options[:name]
@@ -27,8 +29,10 @@ module ConstantTableSaver
         def reset_cache_with_constant_tables(*args)
           reset_cache_without_constant_tables(*args).tap     { ConstantTableSaver.reset_all_caches }
         end
-        alias_method_chain :create_fixtures, :constant_tables
-        alias_method_chain :reset_cache,     :constant_tables
+        alias :create_fixtures_without_constant_tables :create_fixtures
+        alias :create_fixtures :create_fixtures_with_constant_tables
+        alias :reset_cache_without_constant_tables :reset_cache
+        alias :reset_cache :reset_cache_with_constant_tables
       end unless klass.respond_to?(:create_fixtures_with_constant_tables)
     end
   end
@@ -47,6 +51,69 @@ module ConstantTableSaver
       @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 = @find_by_sql = nil
     end
+
+    def _to_sql_with_binds(sql, binds)
+      if sql.respond_to?(:to_sql)
+        # an arel object
+        connection.to_sql(sql, binds)
+      else
+        # a plain string
+        sql
+      end
+    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
+
+  module ActiveRecord5ClassMethods
+    def find_by_sql(sql, binds = [], preparable: nil, &block)
+      @find_by_sql ||= {
+        :all   => all.to_sql,
+        :id    => relation.where(relation.table[primary_key].eq(Arel::Nodes::BindParam.new)).limit(1).arel,
+        :first => relation.order(relation.table[primary_key].asc).limit(1).arel,
+        :last  => relation.order(relation.table[primary_key].desc).limit(1).arel,
+      }
+
+      @limit_one ||= ActiveRecord::Attribute.with_cast_value("LIMIT", 1, ActiveRecord::Type::Value.new)
+
+      _sql = _to_sql_with_binds(sql, binds)
+
+      if binds.empty?
+        if _sql == @find_by_sql[:all]
+          return @cached_records ||= super(relation.to_sql).each(&:freeze)
+        end
+
+      elsif binds.size == 1 &&
+            binds.last == @limit_one
+        if _sql == _to_sql_with_binds(@find_by_sql[:first], binds)
+          return [relation.to_a.first].compact
+        elsif _sql == _to_sql_with_binds(@find_by_sql[:last], binds)
+          return [relation.to_a.last].compact
+        end
+
+      elsif binds.size == 2 &&
+            binds.last == @limit_one &&
+            binds.first.is_a?(ActiveRecord::Relation::QueryAttribute) &&
+            binds.first.name == primary_key &&
+            _sql == _to_sql_with_binds(@find_by_sql[:id], binds) # we have to late-render the find(id) SQL because mysql2 on 4.1 and later requires the bind variables to render the SQL, and errors out with a nil dereference otherwise
+        @cached_records_by_id ||= relation.to_a.index_by {|record| record.id.to_param}
+        return [@cached_records_by_id[binds.first.value.to_param]].compact
+      end
+
+      super(sql, binds, preparable: preparable, &block)
+    end
   end
 
   module ActiveRecord4ClassMethods
@@ -81,121 +148,6 @@ module ConstantTableSaver
 
       super
     end
-
-    def _to_sql_with_binds(sql, binds)
-      if sql.respond_to?(:to_sql)
-        # an arel object
-        connection.to_sql(sql, binds)
-      else
-        # a plain string
-        sql
-      end
-    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
-
-  module ActiveRecord3ClassMethods
-    def scoped(options = nil)
-      return super if options
-      return super if respond_to?(:current_scoped_methods, true) && current_scoped_methods
-      return super if respond_to?(:current_scope, true) && current_scope
-      @cached_blank_scope ||= super.tap do |s|
-        class << s
-          def to_a
-            return @records if loaded?
-            super.each(&:freeze)
-          end
-          
-          def find(*args)
-            # annoyingly, the call to find to load a belongs_to passes :conditions => nil, which causes
-            # the base find method to apply_finder_options and construct an entire new scope, which is
-            # unnecessary and also means that it bypasses our find_one implementation (we don't interfere
-            # with scopes or finds that actually do apply conditions etc.), so we check as a special case
-            return find_with_ids(args.first) if args.length == 2 && args.last == {:conditions => nil}
-            super
-          end
-      
-          def find_first
-            # the normal scope implementation would cache this anyway, but we force a load of all records,
-            # since otherwise if the app used .first before using .all there'd be unnecessary queries
-            to_a.first
-          end
-        
-          def find_last
-            # as for find_first
-            to_a.last
-          end
-        
-          def find_one(id)
-            # see below re to_param
-            cached_records_by_id[id.to_param] || raise(::ActiveRecord::RecordNotFound, "Couldn't find #{name} with ID=#{id}")
-          end
-          
-          def find_some(ids)
-            # see below re to_param
-            ids.collect {|id| cached_records_by_id[id.to_param]}.tap do |results| # obviously since find_one caches efficiently, this isn't inefficient as it would be for real finds
-              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
-
-          # in Rails 3.1 the associations code was rewritten to generalise its sql generation to support
-          # more complex relationships (eg. nested :through associations).  however unfortunately, during
-          # this work the implementation of belongs_to associations was changed so that it no longer calls
-          # one of the basic find_ methods above; instead a vanilla target scope is constructed, a where()
-          # scope to add the constraint that the primary key = the FK value is constructed, the two are
-          # merged, and then #first is called on that scope.  frustratingly, all this complexity means that
-          # our find_ hooks above are no longer called when dereferencing a belongs_to association; they
-          # work fine and are used elsewhere, but we have to explicitly handle belongs_to target scope
-          # merging to avoid those querying, which is a huge PITA.  because we want to ensure that we don't
-          # end up accidentally caching other scope requests, we explicitly build a list of the possible
-          # ARel constrained scopes - indexing them by their expression in SQL so that we don't need to
-          # code in the list of all the possible ARel terms.  we then go one step further and make this
-          # cached scope pre-loaded using the record we already have - there's sadly no external way to do
-          # this so we have to shove in the instance variables.
-          #
-          # it will be clear that this was a very problematic ActiveRecord refactoring.
-          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
-
-            super other
-          end
-        
-        private
-          def cached_records_by_id
-            # we'd like to use the same as ActiveRecord's finder_methods.rb, which uses:
-            #  id = id.id if ActiveRecord::Base === id
-            # but referencing ActiveRecord::Base here segfaults my ruby 1.8.7
-            # (2009-06-12 patchlevel 174) [universal-darwin10.0]!  instead we use to_param.
-            @cached_records_by_id ||= all.index_by {|record| record.id.to_param}
-          end
-        end
-      end
-    end
   end
 
   module NameClassMethods

data/test/constant_table_saver_test.rb

@@ -54,8 +54,6 @@ class ConstantTableSaverTest < ActiveSupport::TestCase
     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
@@ -66,16 +64,6 @@ class ConstantTableSaverTest < ActiveSupport::TestCase
     end
   end
 
-  test "it caches find(:all) results" do
-    @pies = StandardPie.find(:all).to_a
-    assert_queries(1) do
-      assert_equal @pies.collect(&:attributes), ConstantPie.find(:all).to_a.collect(&:attributes)
-    end
-    assert_no_queries do
-      assert_equal @pies.collect(&:attributes), ConstantPie.find(:all).to_a.collect(&:attributes)
-    end
-  end if DEPRECATED_FINDERS
-
   test "it caches find(id) results" do
     @pie = StandardPie.find(1)
     @other_pie = StandardPie.find(2)
@@ -100,16 +88,6 @@ class ConstantTableSaverTest < ActiveSupport::TestCase
     end
   end
 
-  test "it caches find(:first) results" do
-    @pie = StandardPie.find(:first)
-    assert_queries(1) do
-      assert_equal @pie.attributes, ConstantPie.find(:first).attributes
-    end
-    assert_no_queries do
-      assert_equal @pie.attributes, ConstantPie.find(:first).attributes
-    end
-  end if DEPRECATED_FINDERS
-
   test "it caches first() results" do
     @pie = StandardPie.first
     assert_queries(1) do
@@ -119,16 +97,6 @@ class ConstantTableSaverTest < ActiveSupport::TestCase
       assert_equal @pie.attributes, ConstantPie.first.attributes
     end
   end
-
-  test "it caches find(:last) results" do
-    @pie = StandardPie.find(:last)
-    assert_queries(1) do
-      assert_equal @pie.attributes, ConstantPie.find(:last).attributes
-    end
-    assert_no_queries do
-      assert_equal @pie.attributes, ConstantPie.find(:last).attributes
-    end
-  end if DEPRECATED_FINDERS
   
   test "it caches last() results" do
     @pie = StandardPie.last
@@ -154,7 +122,6 @@ class ConstantTableSaverTest < ActiveSupport::TestCase
   
   test "it isn't affected by scopes active at the time of first load" do
     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
   
@@ -193,28 +160,9 @@ class ConstantTableSaverTest < ActiveSupport::TestCase
     end
   end
   
-  test "it doesn't cache find queries with options" do
-    @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(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 if DEPRECATED_FINDERS
-  
   test "it passes the options preventing caching to the underlying query methods" do
-    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_nil nil, ConstantPie.where(:filling => 'unicorn').first
     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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: constant_table_saver
 version: !ruby/object:Gem::Version
-  version: 4.2.0
+  version: 5.1.0
 platform: ruby
 authors:
 - Will Bryant
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-06 00:00:00.000000000 Z
+date: 2017-04-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -63,10 +63,9 @@ description: |
   Compatibility
   =============
 
-  Currently tested against Rails 4.2 (up to 4.2.3), 4.1 (up to 4.1.12), 4.0 (up to 4.0.13), and 3.2 (3.2.18), on Ruby 2.1.5.
+  Currently tested against Rails 5.1 (5.1.0beta2) and 5.0 (up to 5.0.2) and 4.2 (up to 4.2.7), on Ruby 2.3.4.
 
-  Was also previously tested compatible with 2.3.14, 3.0.17, and 3.1.8 on Ruby 2.0.0
-  or 1.8.7 as appropriate, and may still work for them.
+  For earlier versions of Rails, use an older version of the gem.
 email: will.bryant@gmail.com
 executables: []
 extensions: []
@@ -109,7 +108,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Caches the records from fixed tables, and provides convenience methods to