columns_on_demand 4.3.0 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 8ea8794dded2d78daf705ceaab6df85b8a150fcb
-  data.tar.gz: 0549493f7b65d99480413e6a24d5016d76984251
+SHA256:
+  metadata.gz: 1883a4021dfc69d3c3ce1b12c02f14cfb8d5ad40b7dcf0e382c638ebe20528f1
+  data.tar.gz: b9da84f7409d34203123dc0c9a2c9ed59ed65004cfb08994ad4f13be1e1bad83
 SHA512:
-  metadata.gz: 7f984d613b9eeccb2d14fab83e1dd6948a970d3b482876e6095a6605674bf80b8878afd4ec19b8206a4c830341e3b05ac52a7fb30d40f08ff7edfb8198e630da
-  data.tar.gz: ae1a56951d46b3703d3156d2275a099a0de958139c6b978c5805064ce28f7b2ddb361458b6462388346cf580de233bfbc95d9f1228694bd5989e40095a80f70f
+  metadata.gz: 25931accb7f33e305383400d6d780d119508298a3ae4baa66fdc374daaf459f47cee7fd7390de790af785075ef7a62b53bd6d79716269487e989952d6979a4c2
+  data.tar.gz: 5477645b767cbc9bf7f9acff349b6fd7c515980905921137f49f8e335c4ed937b89b2cd689f802fd5b296b5129ae1e73899303dd438265af22ca06e36335a3c7

data/.travis.yml

@@ -0,0 +1,14 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+dist: bionic
+rvm:
+  - 2.6
+services:
+  - postgresql
+  - mysql
+before_script:
+  - createdb -U postgres columns_on_demand_test
+  - mysqladmin -u root create columns_on_demand_test
+script: ./test_all.sh

data/Gemfile

@@ -1,6 +1,6 @@
 source "http://rubygems.org"
 
-# Declare your gem's dependencies in transaction_isolation_level.gemspec.
+# Declare your gem's dependencies in columns_on_demand.gemspec.
 # Bundler will treat runtime dependencies like base dependencies, and
 # development dependencies will be added by default to the :development group.
 gemspec
@@ -11,4 +11,4 @@ gemspec
 # your gem to rubygems.org.
 
 gem 'rails', ENV['RAILS_VERSION']
-gem 'nokogiri', '~> 1.6.7.2'
+gem 'sqlite3', ENV['SQLITE3_VERSION']

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2008-2009 Will Bryant, Sekuda Ltd
+Copyright (c) 2008-2018 Will Bryant, Sekuda Ltd
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -21,10 +21,7 @@ Compatibility
 
 Supports mysql, mysql2, postgresql, and sqlite3.
 
-Currently tested against Rails 4.2.3, 4.1.12, 4.0.13, 3.2.18, on Ruby 2.1.5.
-
-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.
+Currently tested against Rails 6.1.0.rc1, 6.0.3.4, 5.2.4.4, 5.1.7, and 5.0.7.2, with older gem versions compatible with earlier Rails versions.
 
 
 Example
@@ -53,5 +50,7 @@ Thanks
 
 * Tim Connor (@tlconnor)
 * Tobias Matthies (@tobmatth)
+* Phil Ross (@philr)
+* Jens Schmidt (@w3dot0)
 
-Copyright (c) 2008-2015 Will Bryant, Sekuda Ltd, released under the MIT license
+Copyright (c) 2008-2020 Will Bryant, Sekuda Ltd, released under the MIT license

data/columns_on_demand.gemspec

@@ -19,16 +19,7 @@ pages since they are not stored wholly in the record's page itself.
 
 Although this plugin is mainly used for BLOB and TEXT columns, it will actually
 work on all types - and is just as useful for large string fields etc.
-
-
-Compatibility
-=============
-
-Supports mysql, mysql2, postgresql, and sqlite3.
-
-Currently tested against Rails 3.2.18, 4.0.8, and 4.1.4, on Ruby 2.0.0.
 EOF
-  gem.has_rdoc     = false
   gem.author       = "Will Bryant"
   gem.email        = "will.bryant@gmail.com"
   gem.homepage     = "http://github.com/willbryant/columns_on_demand"
@@ -41,8 +32,8 @@ EOF
 
   gem.add_dependency "activerecord"
   gem.add_development_dependency "rake"
-  gem.add_development_dependency "mysql"
   gem.add_development_dependency "mysql2"
   gem.add_development_dependency "pg"
   gem.add_development_dependency "sqlite3"
+  gem.add_development_dependency "byebug"
 end

data/lib/columns_on_demand.rb

@@ -5,43 +5,18 @@ module ColumnsOnDemand
       self.columns_to_load_on_demand = columns_to_load_on_demand.empty? ? blob_and_text_columns : columns_to_load_on_demand.collect(&:to_s)
 
       extend ClassMethods
-      include InstanceMethods
+      prepend InstanceMethods
 
       class <<self
-        unless ActiveRecord::VERSION::MAJOR > 3 ||
-              (ActiveRecord.const_defined?(:AttributeMethods) &&
-               ActiveRecord::AttributeMethods::const_defined?(:Serialization) &&
-               ActiveRecord::AttributeMethods::Serialization::const_defined?(:Attribute))
-          alias_method_chain :define_read_method_for_serialized_attribute, :columns_on_demand
-        end
-        alias_method_chain :reset_column_information,        :columns_on_demand
-      end
-      alias_method_chain   :attributes,                      :columns_on_demand
-      alias_method_chain   :attribute_names,                 :columns_on_demand
-      alias_method_chain   :read_attribute,                  :columns_on_demand
-      alias_method_chain   :read_attribute_before_type_cast, :columns_on_demand
-      if ActiveRecord::AttributeMethods::Read.instance_methods.include?(:_read_attribute)
-        alias_method_chain :_read_attribute,                 :columns_on_demand
-      end
-      alias_method_chain   :missing_attribute,               :columns_on_demand
-      alias_method_chain   :reload,                          :columns_on_demand
-      if ActiveRecord::AttributeMethods::Dirty.instance_methods.include?(:attribute_changed_in_place?)
-        alias_method_chain :attribute_changed_in_place?,     :columns_on_demand
-      elsif ActiveRecord::AttributeMethods::Dirty.instance_methods.include?(:changed_attributes)
-        alias_method_chain :changed_in_place?,               :columns_on_demand
+        alias reset_column_information_without_columns_on_demand reset_column_information
+        alias reset_column_information reset_column_information_with_columns_on_demand
       end
     end
     
     def reset_column_information_with_columns_on_demand
-      @columns_to_select = nil
+      @columns_to_select = @columns_to_load_by_default = nil
       reset_column_information_without_columns_on_demand
     end
-    
-    def define_read_method_for_serialized_attribute_with_columns_on_demand(attr_name)
-      define_read_method_for_serialized_attribute_without_columns_on_demand(attr_name)
-      scope = method_defined?(:generated_attribute_methods) ? generated_attribute_methods : self
-      scope.module_eval("def #{attr_name}_with_columns_on_demand; ensure_loaded('#{attr_name}'); #{attr_name}_without_columns_on_demand; end; alias_method_chain :#{attr_name}, :columns_on_demand", __FILE__, __LINE__)      
-    end
 
     def blob_and_text_columns
       columns.inject([]) do |blob_and_text_columns, column|
@@ -54,13 +29,17 @@ module ColumnsOnDemand
   module ClassMethods
     # this is the method API as called by ActiveRecord 2.x.  we also call it ourselves above in our ActiveRecord 3 extensions.
     def default_select(qualified)
-      @columns_to_select ||= (columns.collect(&:name) - columns_to_load_on_demand).collect {|attr_name| connection.quote_column_name(attr_name)}
+      @columns_to_select ||= columns_to_load_by_default.collect {|attr_name| connection.quote_column_name(attr_name)}
       if qualified
         quoted_table_name + '.' + @columns_to_select.join(", #{quoted_table_name}.")
       else
         @columns_to_select.join(", ")
       end
     end
+
+    def columns_to_load_by_default
+      @columns_to_load_by_default ||= Set.new(columns.collect(&:name) - columns_to_load_on_demand)
+    end
   end
   
   module InstanceMethods
@@ -72,13 +51,17 @@ module ColumnsOnDemand
       !columns_to_load_on_demand.include?(attr_name) || @attributes.key?(attr_name) || new_record? || columns_loaded.include?(attr_name)
     end
 
-    def attributes_with_columns_on_demand
-      load_attributes(*columns_to_load_on_demand.reject {|attr_name| column_loaded?(attr_name)})
-      attributes_without_columns_on_demand
+    def attributes
+      loaded_attributes = @attributes.keys
+      if loaded_attributes.size == self.class.columns_to_load_by_default.size &&
+         loaded_attributes.size == (self.class.columns_to_load_by_default & loaded_attributes).size
+        load_attributes(*columns_to_load_on_demand.reject {|attr_name| column_loaded?(attr_name)})
+      end
+      super
     end
 
-    def attribute_names_with_columns_on_demand
-      (attribute_names_without_columns_on_demand + columns_to_load_on_demand).uniq.sort
+    def attribute_names
+      (super + columns_to_load_on_demand).uniq.sort
     end
     
     def load_attributes(*attr_names)
@@ -87,42 +70,13 @@ module ColumnsOnDemand
       values = self.class.connection.select_rows(
         "SELECT #{attr_names.collect {|attr_name| self.class.connection.quote_column_name(attr_name)}.join(", ")}" +
         "  FROM #{self.class.quoted_table_name}" +
-        " WHERE #{self.class.connection.quote_column_name(self.class.primary_key)} = #{self.class.quote_value(id, self.class.columns_hash[self.class.primary_key])}")
+        " WHERE #{self.class.connection.quote_column_name(self.class.primary_key)} = #{self.class.connection.quote(id)}")
       row = values.first || raise(ActiveRecord::RecordNotFound, "Couldn't find #{self.class.name} with ID=#{id}")
 
       attr_names.each_with_index do |attr_name, i|
         columns_loaded << attr_name
         value = row[i]
-
-        if @attributes.respond_to?(:write_from_database)
-          # activerecord 4.2 or later, which make it easy to replicate the normal typecasting and deserialization logic
-          @attributes.write_from_database(attr_name, value)
-
-        elsif coder = self.class.serialized_attributes[attr_name]
-          # activerecord 4.1 or earlier, with a serialized column
-          # for some database adapters, @column_types_override gets populated with type data from query used to load the record originally.
-          # this is fine, but unfortunately some special-case "decorate_columns" code in ActiveRecord will wrap those types in serialization
-          # objects, and it does this for each column listed in @serialized_column_names *even if they are not present in the query results*.
-          # as a result it unfortunately overrides the normal @column_type with a @column_type_override with a nil @column, which explodes
-          # when it tries to run the typecast.  make it use the normal @column_type value, since we know that we've loading the regular column.
-          @column_types_override.delete(attr_name) if @column_types_override
-
-          if ActiveRecord.const_defined?(:AttributeMethods) &&
-             ActiveRecord::AttributeMethods::const_defined?(:Serialization) &&
-             ActiveRecord::AttributeMethods::Serialization::const_defined?(:Attribute)
-            # in 3.2 @attributes has a special Attribute struct to help cache both serialized and unserialized forms
-            @attributes[attr_name] = ActiveRecord::AttributeMethods::Serialization::Attribute.new(coder, value, :serialized)
-          elsif ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR == 1
-            # from 3.1 it has the deserialized form
-            @attributes[attr_name] = coder.load value
-          else
-            # in 2.3 an 3.0, @attributes has the serialized form
-            @attributes[attr_name] = value
-          end
-        else
-          # activerecord 4.1 or earlier, with a regular unserialized column
-          @attributes[attr_name] = value
-        end
+        @attributes.write_from_database(attr_name, value)
       end
     end
 
@@ -130,39 +84,49 @@ module ColumnsOnDemand
       load_attributes(attr_name.to_s) unless column_loaded?(attr_name.to_s)
     end
 
-    def changed_in_place_with_columns_on_demand?(attr_name)
-      column_loaded?(attr_name) && changed_in_place_without_columns_on_demand?(attr_name)
+    def changed_in_place?(attr_name)
+      column_loaded?(attr_name) && super(attr_name)
+    end
+
+    def attribute_changed_in_place?(attr_name)
+      column_loaded?(attr_name) && super(attr_name)
+    end
+
+    def read_attribute(attr_name, &block)
+      ensure_loaded(attr_name)
+      super(attr_name, &block)
     end
 
-    def attribute_changed_in_place_with_columns_on_demand?(attr_name)
-      column_loaded?(attr_name) && attribute_changed_in_place_without_columns_on_demand?(attr_name)
+    def read_attribute_before_type_cast(attr_name)
+      ensure_loaded(attr_name)
+      super(attr_name)
     end
 
-    def read_attribute_with_columns_on_demand(attr_name, &block)
+    def _read_attribute(attr_name, &block)
       ensure_loaded(attr_name)
-      read_attribute_without_columns_on_demand(attr_name, &block)
+      super(attr_name, &block)
     end
 
-    def read_attribute_before_type_cast_with_columns_on_demand(attr_name)
+    def write_attribute(attr_name, value)
       ensure_loaded(attr_name)
-      read_attribute_before_type_cast_without_columns_on_demand(attr_name)
+      super(attr_name, value)
     end
 
-    def _read_attribute_with_columns_on_demand(attr_name, &block)
+    def _write_attribute(attr_name, value)
       ensure_loaded(attr_name)
-      _read_attribute_without_columns_on_demand(attr_name, &block)
+      super(attr_name, value)
     end
 
-    def missing_attribute_with_columns_on_demand(attr_name, *args)
+    def missing_attribute(attr_name, *args)
       if columns_to_load_on_demand.include?(attr_name)
         load_attributes(attr_name)
       else
-        missing_attribute_without_columns_on_demand(attr_name, *args)
+        super(attr_name, *args)
       end
     end
 
-    def reload_with_columns_on_demand(*args)
-      reload_without_columns_on_demand(*args).tap do
+    def reload(*args)
+      super(*args).tap do
         columns_loaded.clear
         columns_to_load_on_demand.each do |attr_name|
           if @attributes.respond_to?(:reset)
@@ -177,37 +141,45 @@ module ColumnsOnDemand
     end
   end
 
-  module RelationMethodsArity2
-    def build_select_with_columns_on_demand(arel, selects)
-      if (selects.empty? || selects == [table[Arel.star]] || selects == ['*']) && klass < ColumnsOnDemand::InstanceMethods
-        build_select_without_columns_on_demand(arel, [default_select(true)])
-      else
-        build_select_without_columns_on_demand(arel, selects)
-      end
-    end
-  end
-
-  module RelationMethodsArity1
-    def build_select_with_columns_on_demand(arel)
+  module RelationMethods
+    def build_select(arel)
       if (select_values.empty? || select_values == [table[Arel.star]] || select_values == ['*']) && klass < ColumnsOnDemand::InstanceMethods
         arel.project(*arel_columns([default_select(true)]))
       else
-        build_select_without_columns_on_demand(arel)        
+        super(arel)
       end
     end
   end
 end
 
 ActiveRecord::Base.send(:extend, ColumnsOnDemand::BaseMethods)
-
-if ActiveRecord.const_defined?(:Relation)
-  if ActiveRecord::Relation.instance_method(:build_select).arity == 1
-    # 4.2.1 and above
-    ActiveRecord::Relation.send(:include, ColumnsOnDemand::RelationMethodsArity1)
-  else
-    # 4.2.0 and below
-    ActiveRecord::Relation.send(:include, ColumnsOnDemand::RelationMethodsArity2)
+ActiveRecord::Relation.send(:prepend, ColumnsOnDemand::RelationMethods)
+
+# work around ActiveRecord 5.0 and 5.1 converting uninitialized attributes to value nil on save
+# (due to dirty.rb mapping @attributes).  this is not only a problem for columns_on_demand as it
+# means that a MissingAttributeError will never be raised after save, but we suffer more.
+# ActiveRecord 4.2's Attribute doesn't have forgetting_assignment (or this problem).
+if ActiveRecord.const_defined?(:Attribute) && ActiveRecord::Attribute.uninitialized(nil, nil).try(:forgetting_assignment).try(:initialized?)
+  module ActiveRecord
+    class Attribute # :nodoc:
+      class Uninitialized < Attribute # :nodoc:
+        def forgetting_assignment
+          dup
+        end
+      end
+    end
   end
+end
 
-  ActiveRecord::Relation.alias_method_chain :build_select, :columns_on_demand
+# same for 5.2
+if ActiveModel.const_defined?(:Attribute) && ActiveModel::Attribute.uninitialized(nil, nil).try(:forgetting_assignment).try(:initialized?)
+  module ActiveModel
+    class Attribute # :nodoc:
+      class Uninitialized < Attribute # :nodoc:
+        def forgetting_assignment
+          dup
+        end
+      end
+    end
+  end
 end

data/lib/columns_on_demand/version.rb

@@ -1,3 +1,3 @@
 module ColumnsOnDemand
-  VERSION = '4.3.0'
+  VERSION = '6.0.0'
 end

data/test/columns_on_demand_test.rb

@@ -43,7 +43,11 @@ class ColumnsOnDemandTest < ActiveSupport::TestCase
   end
 
   fixtures :all
-  self.use_transactional_fixtures = true
+  if respond_to?(:use_transactional_tests=)
+    self.use_transactional_tests = true
+  else
+    self.use_transactional_fixtures = true
+  end
   
   test "it lists explicitly given columns for loading on demand" do
     assert_equal ["file_data", "processing_log", "original_filename"], Explicit.columns_to_load_on_demand
@@ -54,11 +58,11 @@ class ColumnsOnDemandTest < ActiveSupport::TestCase
   end
   
   test "it selects all the other columns for loading eagerly" do
-    assert_match /\W*id\W*, \W*results\W*, \W*processed_at\W*/, Explicit.default_select(false)
-    assert_match /\W*explicits\W*.results/, Explicit.default_select(true)
+    assert_match(/\W*id\W*, \W*results\W*, \W*processed_at\W*/, Explicit.default_select(false))
+    assert_match(/\W*explicits\W*.results/, Explicit.default_select(true))
     
-    assert_match /\W*id\W*, \W*original_filename\W*, \W*processed_at\W*/, Implicit.default_select(false)
-    assert_match /\W*implicits\W*.original_filename/, Implicit.default_select(true)
+    assert_match(/\W*id\W*, \W*original_filename\W*, \W*processed_at\W*/, Implicit.default_select(false))
+    assert_match(/\W*implicits\W*.original_filename/, Implicit.default_select(true))
   end
   
   test "it doesn't load the columns_to_load_on_demand straight away when finding the records" do
@@ -92,10 +96,10 @@ class ColumnsOnDemandTest < ActiveSupport::TestCase
 
     record = Implicit.first
     assert_not_loaded record, "file_data"
-    assert_equal nil, record.file_data
+    assert_nil record.file_data
     assert_loaded record, "file_data"
     assert_no_queries do
-      assert_equal nil, record.file_data
+      assert_nil record.file_data
     end
   end
   
@@ -132,6 +136,25 @@ class ColumnsOnDemandTest < ActiveSupport::TestCase
       assert !attributes["processing_log"].blank?
     end
   end
+
+  test "it doesn't load the column when generating #attributes if not included in the select() list" do
+    attributes = Implicit.select("id, original_filename").first.attributes
+    assert_equal "somefile.txt", attributes["original_filename"]
+    assert !attributes.has_key?("file_data")
+  end
+
+  test "it loads the column when generating #attributes if included in the select() list" do
+    attributes = Implicit.select("id, original_filename, file_data").first.attributes
+    assert_equal "somefile.txt", attributes["original_filename"]
+    assert_equal "This is the file data!", attributes["file_data"]
+  end
+
+  test "it loads the column when changing its value" do
+    record = Implicit.first
+    record.file_data = 'This is the new file data!'
+    assert_equal "This is the file data!", record.file_data_was
+    assert_equal ["This is the file data!", "This is the new file data!"], record.changes[:file_data]
+  end
   
   test "it loads the column when generating #to_json" do
     ActiveRecord::Base.include_root_in_json = true
@@ -156,8 +179,31 @@ class ColumnsOnDemandTest < ActiveSupport::TestCase
 
     assert_not_loaded record, "file_data"
     assert_equal "New file data", record.file_data
+    assert_not_equal old_object_id, record.file_data.object_id
   end
   
+  test "it does not think the column has been loaded if a reloaded instance that has not loaded the attribute is saved" do
+    record = Implicit.first
+    record.file_data = "New file data"
+    record.save!
+
+    record.reload
+    record.save!
+
+    assert_equal "New file data", record.file_data
+  end
+
+  test "it does not think the column has been loaded if a fresh instance that has not loaded the attribute is saved" do
+    record = Implicit.first
+    record.file_data = "New file data"
+    record.save!
+
+    record = Implicit.find(record.id)
+    record.save!
+
+    assert_equal "New file data", record.file_data
+  end
+
   test "it doesn't override custom select() finds" do
     record = Implicit.select("id, file_data").first
     klass = ActiveRecord.const_defined?(:MissingAttributeError) ? ActiveRecord::MissingAttributeError : ActiveModel::MissingAttributeError
@@ -194,42 +240,7 @@ class ColumnsOnDemandTest < ActiveSupport::TestCase
     assert_equal "This is the file data!", record.file_data # check it doesn't raise
   end
   
-  test "it updates the select strings when columns are changed and the column information is reset" do
-    ActiveRecord::Schema.define(:version => 1) do
-      create_table :dummies, :force => true do |t|
-        t.string   :some_field
-        t.binary   :big_field
-      end
-    end
-
-    class Dummy < ActiveRecord::Base
-      columns_on_demand
-    end
-
-    assert_match /\W*id\W*, \W*some_field\W*/, Dummy.default_select(false)
-
-    ActiveRecord::Schema.define(:version => 2) do
-      create_table :dummies, :force => true do |t|
-        t.string   :some_field
-        t.binary   :big_field
-        t.string   :another_field
-      end
-    end
-
-    assert_match /\W*id\W*, \W*some_field\W*/, Dummy.default_select(false)
-    Dummy.reset_column_information
-    assert_match /\W*id\W*, \W*some_field\W*, \W*another_field\W*/, Dummy.default_select(false)
-  end
-  
   test "it handles STI models" do
-    ActiveRecord::Schema.define(:version => 1) do
-      create_table :stis, :force => true do |t|
-        t.string   :type
-        t.string   :some_field
-        t.binary   :big_field
-      end
-    end
-
     class Sti < ActiveRecord::Base
       columns_on_demand
     end
@@ -238,8 +249,8 @@ class ColumnsOnDemandTest < ActiveSupport::TestCase
       columns_on_demand :some_field
     end
 
-    assert_match /\W*id\W*, \W*type\W*, \W*some_field\W*/, Sti.default_select(false)
-    assert_match /\W*id\W*, \W*type\W*, \W*big_field\W*/,  StiChild.default_select(false)
+    assert_match(/\W*id\W*, \W*type\W*, \W*some_field\W*/, Sti.default_select(false))
+    assert_match(/\W*id\W*, \W*type\W*, \W*big_field\W*/,  StiChild.default_select(false))
   end
   
   test "it works on child records loaded from associations" do
@@ -279,9 +290,9 @@ class ColumnsOnDemandTest < ActiveSupport::TestCase
     
     assert !ValidatedImplicit.new(:original_filename => "test.txt").valid?
     instance = ValidatedImplicit.create!(:original_filename => "test.txt", :file_data => "test file data", :results => "test results")
-    instance.update_attributes!({}) # file_data and results are already loaded
+    assert instance.valid? # file_data and results are already loaded
     new_instance = ValidatedImplicit.find(instance.id)
-    new_instance.update_attributes!({}) # file_data and results aren't loaded yet, but will be loaded to validate
+    assert new_instance.valid? # file_data and results aren't loaded yet, but will be loaded to validate
   end
   
   test "it works with serialized columns" do
@@ -322,3 +333,38 @@ class ColumnsOnDemandTest < ActiveSupport::TestCase
     assert_equal select_sql, reference_sql
   end
 end
+
+class ColumnsOnDemandSchemaTest < ActiveSupport::TestCase
+  if respond_to?(:use_transactional_tests=)
+    self.use_transactional_tests = false
+  else
+    self.use_transactional_fixtures = false
+  end
+
+  test "it updates the select strings when columns are changed and the column information is reset" do
+    ActiveRecord::Schema.define(:version => 1) do
+      create_table :dummies, :force => true do |t|
+        t.string   :some_field
+        t.binary   :big_field
+      end
+    end
+
+    class Dummy < ActiveRecord::Base
+      columns_on_demand
+    end
+
+    assert_match(/\W*id\W*, \W*some_field\W*/, Dummy.default_select(false))
+
+    ActiveRecord::Schema.define(:version => 2) do
+      create_table :dummies, :force => true do |t|
+        t.string   :some_field
+        t.binary   :big_field
+        t.string   :another_field
+      end
+    end
+
+    assert_match(/\W*id\W*, \W*some_field\W*/, Dummy.default_select(false))
+    Dummy.reset_column_information
+    assert_match(/\W*id\W*, \W*some_field\W*, \W*another_field\W*/, Dummy.default_select(false))
+  end
+end

data/test/schema.rb

@@ -27,4 +27,10 @@ ActiveRecord::Schema.define(:version => 0) do
   create_table :serializings, :force => true do |t|
     t.binary   :data
   end
+
+  create_table :stis, :force => true do |t|
+    t.string   :type
+    t.string   :some_field
+    t.binary   :big_field
+  end
 end

data/test_all.sh

@@ -0,0 +1,19 @@
+#!/bin/sh
+
+set -e
+
+for version in 5.0.7.2 5.1.7 5.2.4.4
+do
+	RAILS_VERSION=$version SQLITE3_VERSION=1.3.9 bundle update rails sqlite3
+	RAILS_ENV=sqlite3 bundle exec rake
+	RAILS_ENV=postgresql bundle exec rake
+	RAILS_ENV=mysql2 bundle exec rake
+done
+
+for version in 6.0.3.4 6.1.0.rc1
+do
+	RAILS_VERSION=$version SQLITE3_VERSION=1.4.1 bundle update rails sqlite3
+	RAILS_ENV=sqlite3 bundle exec rake
+	RAILS_ENV=postgresql bundle exec rake
+	RAILS_ENV=mysql2 bundle exec rake
+done

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: columns_on_demand
 version: !ruby/object:Gem::Version
-  version: 4.3.0
+  version: 6.0.0
 platform: ruby
 authors:
 - Will Bryant
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-06-07 00:00:00.000000000 Z
+date: 2020-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -39,7 +39,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: mysql
+  name: mysql2
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -53,7 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: mysql2
+  name: pg
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -67,7 +67,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: pg
+  name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -81,7 +81,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: sqlite3
+  name: byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -108,20 +108,13 @@ description: |
 
   Although this plugin is mainly used for BLOB and TEXT columns, it will actually
   work on all types - and is just as useful for large string fields etc.
-
-
-  Compatibility
-  =============
-
-  Supports mysql, mysql2, postgresql, and sqlite3.
-
-  Currently tested against Rails 3.2.18, 4.0.8, and 4.1.4, on Ruby 2.0.0.
 email: will.bryant@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".travis.yml"
 - Gemfile
 - MIT-LICENSE
 - README.md
@@ -138,11 +131,12 @@ files:
 - test/fixtures/parents.yml
 - test/schema.rb
 - test/test_helper.rb
+- test_all.sh
 homepage: http://github.com/willbryant/columns_on_demand
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -157,9 +151,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.5
-signing_key: 
+rubygems_version: 3.0.3
+signing_key:
 specification_version: 4
 summary: Lazily loads large columns on demand.
 test_files: