low_card_tables 1.0.3 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d4726bf4540f04b58951e79af67b8285c96dd72a
-  data.tar.gz: 7441e6bc347ab79f261d2c8f0f7750ffc158d7f9
+  metadata.gz: 930fa1a9dafbd8e32e72961f024beb1754c13254
+  data.tar.gz: 034fc44ed55f2ede181f09edaf7e7d27b494fe5d
 SHA512:
-  metadata.gz: 4bfb76855df51f47da3d892abfb1902f28ad4e28fdba754f16c2b575459e31c0b4ce07edac02a5695e8806bbb9fc7e7fc0c3076239f707dacd8a5069496f63cf
-  data.tar.gz: 443b4f355b6e785909d5984fe74257c28564b8f0efe63163c87410f0c14fe7c9ae364e80f63ed046e35a65afa7b287ad9c5adddcfcbfe37399775659bbfbbe22
+  metadata.gz: 5013b79fe4902ec65b05914c92b33c6330873144bfff2bf73eb0710fc0efde02f41d16d15afa2bd81bf9cf22053ca66de28d6a38e38cc17606ec9b83ef7b59c6
+  data.tar.gz: 38ae46cc876311d8e15b6a6616439955d2d696b7e1e72b9f23790e8eb79fcce3b1f3a0f31e15b604d7824b58365da71c6efc5341bc7a0d438a6e5784232ec3b1

data/.travis.yml

@@ -1,9 +1,10 @@
 rvm:
     - "1.8.7"
-    - "1.9.3"
-    - "2.0.0"
-    - "2.1.2"
-    - "jruby-1.7.15"
+    - "1.9.3-p551"
+    - "2.0.0-p598"
+    - "2.1.5"
+    - "2.2.0"
+    - "jruby-1.7.19"
 env:
     # Sadly, Travis seems to have a version of SQLite < 3.7.11 installed on many of its workers;
     # this prevents activerecord-import from working, since those versions of the SQLite engine
@@ -15,65 +16,88 @@ env:
     - LOW_CARD_TABLES_AR_TEST_VERSION=3.1.12 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=mysql
     - LOW_CARD_TABLES_AR_TEST_VERSION=3.1.12 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=postgres
     # - LOW_CARD_TABLES_AR_TEST_VERSION=3.1.12 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=sqlite
-    - LOW_CARD_TABLES_AR_TEST_VERSION=3.2.19 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=mysql
-    - LOW_CARD_TABLES_AR_TEST_VERSION=3.2.19 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=postgres
-    # - LOW_CARD_TABLES_AR_TEST_VERSION=3.2.19 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=sqlite
-    - LOW_CARD_TABLES_AR_TEST_VERSION=4.0.10 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=mysql
-    - LOW_CARD_TABLES_AR_TEST_VERSION=4.0.10 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=postgres
-    # - LOW_CARD_TABLES_AR_TEST_VERSION=4.0.10 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=sqlite
-    - LOW_CARD_TABLES_AR_TEST_VERSION=4.1.6 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=mysql
-    - LOW_CARD_TABLES_AR_TEST_VERSION=4.1.6 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=postgres
-    # - LOW_CARD_TABLES_AR_TEST_VERSION=4.1.6 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=sqlite
+    - LOW_CARD_TABLES_AR_TEST_VERSION=3.2.21 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=mysql
+    - LOW_CARD_TABLES_AR_TEST_VERSION=3.2.21 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=postgres
+    # - LOW_CARD_TABLES_AR_TEST_VERSION=3.2.21 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=sqlite
+    - LOW_CARD_TABLES_AR_TEST_VERSION=4.0.13 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=mysql
+    - LOW_CARD_TABLES_AR_TEST_VERSION=4.0.13 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=postgres
+    # - LOW_CARD_TABLES_AR_TEST_VERSION=4.0.13 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=sqlite
+    - LOW_CARD_TABLES_AR_TEST_VERSION=4.1.9 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=mysql
+    - LOW_CARD_TABLES_AR_TEST_VERSION=4.1.9 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=postgres
+    # - LOW_CARD_TABLES_AR_TEST_VERSION=4.1.9 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=sqlite
+    - LOW_CARD_TABLES_AR_TEST_VERSION=4.2.0 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=mysql
+    - LOW_CARD_TABLES_AR_TEST_VERSION=4.2.0 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=postgres
+    # - LOW_CARD_TABLES_AR_TEST_VERSION=4.2.0 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=sqlite
 before_script:
-    - export JRUBY_OPTS="-J-Xmx256m -J-Xms256m $JRUBY_OPTS"
+    - export JRUBY_OPTS="-J-Xmx512m -J-Xms512m $JRUBY_OPTS"
     - mysql -e 'create database myapp_test;'
     - psql -c 'create database myapp_test;' -U postgres
 matrix:
     exclude:
         # ActiveRecord 4.x doesn't support Ruby 1.8.7
         -   rvm: 1.8.7
-            env: LOW_CARD_TABLES_AR_TEST_VERSION=4.0.10 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=mysql
+            env: LOW_CARD_TABLES_AR_TEST_VERSION=4.0.13 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=mysql
         -   rvm: 1.8.7
-            env: LOW_CARD_TABLES_AR_TEST_VERSION=4.0.10 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=postgres
+            env: LOW_CARD_TABLES_AR_TEST_VERSION=4.0.13 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=postgres
         -   rvm: 1.8.7
-            env: LOW_CARD_TABLES_AR_TEST_VERSION=4.0.10 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=sqlite
+            env: LOW_CARD_TABLES_AR_TEST_VERSION=4.0.13 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=sqlite
         -   rvm: 1.8.7
-            env: LOW_CARD_TABLES_AR_TEST_VERSION=4.1.6 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=mysql
+            env: LOW_CARD_TABLES_AR_TEST_VERSION=4.1.9 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=mysql
         -   rvm: 1.8.7
-            env: LOW_CARD_TABLES_AR_TEST_VERSION=4.1.6 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=postgres
+            env: LOW_CARD_TABLES_AR_TEST_VERSION=4.1.9 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=postgres
         -   rvm: 1.8.7
-            env: LOW_CARD_TABLES_AR_TEST_VERSION=4.1.6 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=sqlite
+            env: LOW_CARD_TABLES_AR_TEST_VERSION=4.1.9 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=sqlite
+        -   rvm: 1.8.7
+            env: LOW_CARD_TABLES_AR_TEST_VERSION=4.2.0 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=mysql
+        -   rvm: 1.8.7
+            env: LOW_CARD_TABLES_AR_TEST_VERSION=4.2.0 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=postgres
+        -   rvm: 1.8.7
+            env: LOW_CARD_TABLES_AR_TEST_VERSION=4.2.0 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=sqlite
         # There's a bug in ActiveRecord 3.1.x that makes it incompatible with Ruby 2.x
-        -   rvm: 2.0.0
+        -   rvm: 2.0.0-p598
             env: LOW_CARD_TABLES_AR_TEST_VERSION=3.1.12 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=mysql
-        -   rvm: 2.0.0
+        -   rvm: 2.0.0-p598
             env: LOW_CARD_TABLES_AR_TEST_VERSION=3.1.12 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=postgres
-        -   rvm: 2.0.0
+        -   rvm: 2.0.0-p598
             env: LOW_CARD_TABLES_AR_TEST_VERSION=3.1.12 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=sqlite
-        -   rvm: 2.1.2
+        -   rvm: 2.1.5
             env: LOW_CARD_TABLES_AR_TEST_VERSION=3.1.12 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=mysql
-        -   rvm: 2.1.2
+        -   rvm: 2.1.5
             env: LOW_CARD_TABLES_AR_TEST_VERSION=3.1.12 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=postgres
-        -   rvm: 2.1.2
+        -   rvm: 2.1.5
             env: LOW_CARD_TABLES_AR_TEST_VERSION=3.1.12 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=sqlite
-        # The activerecord-import gem currently doesn't support JRuby JDBC adapters with anything but MySQL
-        -   rvm: jruby-1.7.15
-            env: LOW_CARD_TABLES_AR_TEST_VERSION=3.0.20 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=postgres
-        -   rvm: jruby-1.7.15
+        -   rvm: 2.2.0
+            env: LOW_CARD_TABLES_AR_TEST_VERSION=3.1.12 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=mysql
+        -   rvm: 2.2.0
             env: LOW_CARD_TABLES_AR_TEST_VERSION=3.1.12 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=postgres
-        -   rvm: jruby-1.7.15
-            env: LOW_CARD_TABLES_AR_TEST_VERSION=3.2.19 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=postgres
-        -   rvm: jruby-1.7.15
-            env: LOW_CARD_TABLES_AR_TEST_VERSION=4.0.10 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=postgres
-        -   rvm: jruby-1.7.15
-            env: LOW_CARD_TABLES_AR_TEST_VERSION=4.1.6 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=postgres
-        -   rvm: jruby-1.7.15
-            env: LOW_CARD_TABLES_AR_TEST_VERSION=3.0.20 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=sqlite
-        -   rvm: jruby-1.7.15
+        -   rvm: 2.2.0
             env: LOW_CARD_TABLES_AR_TEST_VERSION=3.1.12 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=sqlite
-        -   rvm: jruby-1.7.15
-            env: LOW_CARD_TABLES_AR_TEST_VERSION=3.2.19 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=sqlite
-        -   rvm: jruby-1.7.15
-            env: LOW_CARD_TABLES_AR_TEST_VERSION=4.0.10 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=sqlite
-        -   rvm: jruby-1.7.15
-            env: LOW_CARD_TABLES_AR_TEST_VERSION=4.1.6 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=sqlite
+        # The activerecord-import gem currently doesn't support JRuby JDBC adapters with anything but MySQL
+        # -   rvm: jruby-1.7.15
+        #     env: LOW_CARD_TABLES_AR_TEST_VERSION=3.0.20 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=postgres
+        # -   rvm: jruby-1.7.15
+        #     env: LOW_CARD_TABLES_AR_TEST_VERSION=3.1.12 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=postgres
+        # -   rvm: jruby-1.7.15
+        #     env: LOW_CARD_TABLES_AR_TEST_VERSION=3.2.21 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=postgres
+        # -   rvm: jruby-1.7.15
+        #     env: LOW_CARD_TABLES_AR_TEST_VERSION=4.0.13 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=postgres
+        # -   rvm: jruby-1.7.15
+        #     env: LOW_CARD_TABLES_AR_TEST_VERSION=4.1.9 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=postgres
+        # -   rvm: jruby-1.7.15
+        #     env: LOW_CARD_TABLES_AR_TEST_VERSION=3.0.20 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=sqlite
+        # -   rvm: jruby-1.7.15
+        #     env: LOW_CARD_TABLES_AR_TEST_VERSION=3.1.12 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=sqlite
+        # -   rvm: jruby-1.7.15
+        #     env: LOW_CARD_TABLES_AR_TEST_VERSION=3.2.21 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=sqlite
+        # -   rvm: jruby-1.7.15
+        #     env: LOW_CARD_TABLES_AR_TEST_VERSION=4.0.13 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=sqlite
+        # -   rvm: jruby-1.7.15
+        #     env: LOW_CARD_TABLES_AR_TEST_VERSION=4.1.9 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=sqlite
+
+    allow_failures:
+        # As of this writing (2015-02-18), activerecord-jdbc doesn't support ActiveRecord 4.2.x
+        # completely.
+        -   rvm: jruby-1.7.19
+            env: LOW_CARD_TABLES_AR_TEST_VERSION=4.2.0 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=mysql
+        -   rvm: jruby-1.7.19
+            env: LOW_CARD_TABLES_AR_TEST_VERSION=4.2.0 LOW_CARD_TABLES_TRAVIS_CI_DATABASE_TYPE=postgres

data/CHANGES.md

@@ -1,5 +1,13 @@
 # `low_card_tables` Changelog
 
+## 1.1.0, 2015-02-18
+
+* The [single-table inheritance](http://api.rubyonrails.org/classes/ActiveRecord/Base.html#label-Single+table+inheritance) type-discrimination column — by default called `type` — can now be part of a low-cardinality table itself. This elegantly allows you to use STI without consuming the very large amounts of space required by Rails' default implementation, where it stores the name of the class in every single row.
+* Fixed issues where you couldn't use `low_card_tables` with an ActiveRecord class that was at anything but the leaf of a [single-table inheritance](http://api.rubyonrails.org/classes/ActiveRecord/Base.html#label-Single+table+inheritance) hierarchy.
+* Ensured that you can query a column containing a string or symbol with a query that's a string or a symbol, and it all works fine.
+* Added support for `WHERE` clauses on a low-card table containing an array (`.where(:my_low_card_column => [ :foo, :bar ])`).
+* Added support for ActiveRecord 4.2.x, and bumped versions on the CI configuration.
+
 ## 1.0.3, 2014-09-22
 
 * Fixed an issue where, if a table that owned a low-card table was declared a namespace (_e.g._, `module Foo; class Bar < ActiveRecord::Base; has_low_card_table :status; end; end`), the call to `has_low_card_table` would fail with an error (trying to call `+` on `nil`).

data/Gemfile

@@ -15,3 +15,8 @@ end
 if version_spec
   gem("activerecord", version_spec)
 end
+
+# gem 'pry'
+# gem 'pry-byebug'
+# gem 'pry-rescue'
+# gem 'pry-stack_explorer'

data/lib/low_card_tables/has_low_card_table/base.rb

@@ -60,6 +60,18 @@ module LowCardTables
       extend ActiveSupport::Concern
 
 
+      def ensure_proper_type
+        if (assn = self.class.association_for_inheritance_column)
+          superclass = self.class.superclass
+          unless (superclass == ::ActiveRecord::Base) || (superclass.abstract_class?)
+            lco = send(assn.association_name)
+            lco.send(:write_attribute, self.class.inheritance_column, self.class.sti_name)
+          end
+        else
+          super
+        end
+      end
+
       module ClassMethods
         # Several methods go straight to the LowCardAssociationsManager.
         delegate :has_low_card_table, :_low_card_association, :_low_card_update_collapsed_rows, :low_card_value_collapsing_update_scheme, :to => :_low_card_associations_manager
@@ -70,6 +82,94 @@ module LowCardTables
           true
         end
 
+        def association_for_inheritance_column
+          _low_card_associations_manager.association_containing_method_named(inheritance_column)
+        end
+
+        def descends_from_active_record?
+          out = super
+
+          if out && (self != ::ActiveRecord::Base) && (! superclass.abstract_class?) && (superclass != ::ActiveRecord::Base)
+            out = false if association_for_inheritance_column
+          end
+
+          out
+        end
+
+        def type_condition(table = arel_table)
+          if (association = association_for_inheritance_column)
+            sti_names  = ([self] + descendants).map { |model| model.sti_name }
+
+            ids = association.low_card_class.low_card_ids_matching(inheritance_column => sti_names).to_a
+            table[association.foreign_key_column_name].in(ids)
+          else
+            if ::ActiveRecord::Base.method(:type_condition).arity.abs >= 1
+              super
+            else
+              super()
+            end
+          end
+        end
+
+        def discriminate_class_for_record(record, call_super = true)
+          if (! record[inheritance_column])
+            if (association = association_for_inheritance_column)
+              foreign_key = record[association.foreign_key_column_name]
+
+              foreign_key = association.low_card_class.low_card_type_cast_id(foreign_key)
+              low_card_row = association.low_card_class.low_card_row_for_id(foreign_key)
+              type = low_card_row.send(inheritance_column)
+
+              return _low_card_find_sti_class(type) if type
+            end
+          end
+
+          super(record) if call_super
+        end
+
+        if ::LowCardTables::VersionSupport.sti_uses_discriminate_class_for_record?
+          def _low_card_find_sti_class(type)
+            find_sti_class(type)
+          end
+        else
+          def _low_card_find_sti_class(type_name)
+            return self if type_name.blank?
+
+            begin
+              if store_full_sti_class
+                ActiveSupport::Dependencies.constantize(type_name)
+              else
+                compute_type(type_name)
+              end
+            rescue NameError
+              raise ::ActiveRecord::SubclassNotFound,
+                "The single-table inheritance mechanism failed to locate the subclass: '#{type_name}'. " +
+                "This error is raised because the column '#{inheritance_column}' is reserved for storing the class in case of inheritance. " +
+                "Please rename this column if you didn't intend it to be used for storing the inheritance class " +
+                "or overwrite #{name}.inheritance_column to use another column for that information."
+            end
+          end
+
+          def instantiate(record)
+            sti_class = discriminate_class_for_record(record, false)
+            if sti_class
+              record_id = sti_class.primary_key && record[sti_class.primary_key]
+
+              if defined?(::ActiveRecord::IdentityMap) && ::ActiveRecord::IdentityMap.enabled? && record_id
+                instance = use_identity_map(sti_class, record_id, record)
+              else
+                instance = sti_class.allocate
+                instance.init_with('attributes' => record)
+                instance
+              end
+
+              instance
+            else
+              super
+            end
+          end
+        end
+
         # The LowCardAssociationsManager keeps track of which low-card tables this table refers to; see its
         # documentation for more information.
         def _low_card_associations_manager

data/lib/low_card_tables/has_low_card_table/low_card_associations_manager.rb

@@ -45,6 +45,13 @@ module LowCardTables
         @model_class._low_card_dynamic_method_manager.sync_methods!
       end
 
+      def association_containing_method_named(method_name)
+        out = @associations.detect do |low_card_association|
+          low_card_association.class_method_name_to_low_card_method_name_map[method_name]
+        end
+        out || superclass_low_card_associations_manager.try(:association_containing_method_named, method_name)
+      end
+
       # Called when someone has called ::ActiveRecord::Base#reset_column_information on the low-card model in question.
       # This simply tells the LowCardDynamicMethodManager to sync the methods on this model class, thus updating the
       # set of delegated methods to match the new columns.
@@ -60,7 +67,9 @@ module LowCardTables
 
       # Just like _low_card_association, but returns nil when an association is not found, rather than raising an error.
       def maybe_low_card_association(name)
-        @associations.detect { |a| a.association_name.to_s.strip.downcase == name.to_s.strip.downcase }
+        out = @associations.detect { |a| a.association_name.to_s.strip.downcase == name.to_s.strip.downcase }
+        out ||= superclass_low_card_associations_manager.maybe_low_card_association(name) if superclass_low_card_associations_manager
+        out
       end
 
       # Updates all foreign keys that the given model_instance has to their correct values, given the set of attributes
@@ -71,6 +80,10 @@ module LowCardTables
         @associations.each do |association|
           association.update_foreign_key!(model_instance)
         end
+
+        if superclass_low_card_associations_manager
+          superclass_low_card_associations_manager.low_card_update_foreign_keys!(model_instance)
+        end
       end
 
       DEFAULT_COLLAPSING_UPDATE_VALUE = 10_000
@@ -113,6 +126,20 @@ module LowCardTables
         end
       end
 
+      # Returns the LowCardAssociationsManager for the model class's superclass, if there is one. This is used for
+      # supporting STI.
+      def superclass_low_card_associations_manager
+        @superclass_low_card_associations_manager ||= begin
+          model_superclass = @model_class.superclass
+          if model_superclass.respond_to?(:_low_card_associations_manager)
+            model_superclass._low_card_associations_manager
+          else
+            :none
+          end
+        end
+        @superclass_low_card_associations_manager unless @superclass_low_card_associations_manager == :none
+      end
+
       private
       # Makes sure that +model_instance+ is an instance of the model class this LowCardAssociationsManager is for.
       def ensure_correct_class!(model_instance)

data/lib/low_card_tables/has_low_card_table/low_card_dynamic_method_manager.rb

@@ -32,7 +32,11 @@ module LowCardTables
 
         method_data = @method_delegation_map[method_name.to_s]
         unless method_data
-          raise NameError, "Whoa -- we're trying to call a delegated low-card method #{method_name.inspect} on #{object}, of class #{object.class}, but somehow the LowCardDynamicMethodManager has no knowledge of that method?!? We know about: #{@method_delegation_map.keys.sort.inspect}"
+          if superclass_low_card_dynamic_method_manager
+            return superclass_low_card_dynamic_method_manager.run_low_card_method(object, method_name, args)
+          else
+            raise NameError, "Whoa -- we're trying to call a delegated low-card method #{method_name.inspect} on #{object}, of class #{object.class}, but somehow the LowCardDynamicMethodManager has no knowledge of that method?!? We know about: #{@method_delegation_map.keys.sort.inspect}"
+          end
         end
 
         (association, association_method_name) = method_data
@@ -53,6 +57,18 @@ module LowCardTables
         end
       end
 
+      # Returns the effective association and method that we delegate the given method to. This is very close to
+      # identical to @method_delegation_map; the only difference is that it delegates to the +model_class+'s superclass
+      # as appropriate, too.
+      def effective_method_delegation_for(method_name)
+        method_name = method_name.to_s
+        out = @method_delegation_map[method_name]
+        if (! out) && superclass_low_card_dynamic_method_manager
+          out = superclass_low_card_dynamic_method_manager.effective_method_delegation_for(method_name)
+        end
+        out
+      end
+
       # Given a base ::ActiveRecord::Relation scope (which can of course just be a model class itself), and a set of
       # query constraints as passed into ::ActiveRecord::Relation#where (which must be a Hash -- for the other forms
       # of #where, our override of ::ActiveRecord::Relation#where doesn't call this method but just passes through to
@@ -83,7 +99,7 @@ module LowCardTables
         #   to that association; the constraints in the Hash use key names that are the actual low-card column names
         #   (i.e., we translate them from whatever delegated method names were present in the referring class)
         query_hash.each do |query_key, query_value|
-          low_card_delegation = @method_delegation_map[query_key.to_s]
+          low_card_delegation = effective_method_delegation_for(query_key)
 
           # Does this constraint even mention a low-card column or association name?
           if low_card_delegation
@@ -192,6 +208,20 @@ yourself, using #{association.low_card_class.name}#ids_matching.}
         @model_class._low_card_associations_manager.associations
       end
 
+      # Returns the LowCardDynamicMethodManager for the model class's superclass, if there is one. This is used for
+      # supporting STI.
+      def superclass_low_card_dynamic_method_manager
+        @superclass_low_card_dynamic_method_manager ||= begin
+          model_superclass = @model_class.superclass
+          if model_superclass.respond_to?(:_low_card_dynamic_method_manager)
+            model_superclass._low_card_dynamic_method_manager
+          else
+            :none
+          end
+        end
+        @superclass_low_card_dynamic_method_manager unless @superclass_low_card_dynamic_method_manager == :none
+      end
+
       # Makes sure the given object is an instance of the class we're handling dynamic methods for.
       def ensure_correct_class!(object)
         unless object.kind_of?(@model_class)

data/lib/low_card_tables/low_card_table/base.rb

@@ -19,6 +19,7 @@ module LowCardTables
       # Set up cache-policy inheritance -- see HasCacheExpiration for more details.
       included do
         low_card_cache_policy_inherits_from ::LowCardTables
+        self.inheritance_column = '_sti_on_low_card_tables_should_never_be_used'
       end
 
       # This method is a critical entry point from the rest of the low-card system. For example, given our usual
@@ -57,7 +58,25 @@ module LowCardTables
       # instead of #_low_card_row_matches_any_hash? or #_low_card_row_matches_hash?, if its semantics work better for
       # your purposes, since its behavior will affect those methods as well.
       def _low_card_column_matches?(key, value)
-        self[key.to_s] == value
+        my_value = self[key.to_s]
+
+        if value.kind_of?(Array)
+          if my_value && my_value.kind_of?(Symbol)
+            my_value = my_value.to_s
+          end
+
+          value = value.map { |m| if m.kind_of?(Symbol) then m.to_s else m end }
+          value.include?(my_value)
+        else
+          value_sym = value.kind_of?(Symbol)
+          my_value_sym = my_value.kind_of?(Symbol)
+
+          if (value_sym != my_value_sym) && value && my_value
+            my_value.to_s.eql?(value.to_s)
+          else
+            my_value.eql?(value)
+          end
+        end
       end
 
       # This method is called from methods like #low_card_rows_matching, when passed a block -- its job is simply to
@@ -173,7 +192,7 @@ on this object, and it will save, but make sure you understand ALL the implicati
         # Gems or by client code, since many of the names are pretty generic (e.g., +all_rows+).
         [ :all_rows, :row_for_id, :rows_for_ids, :rows_matching, :ids_matching, :find_ids_for, :find_or_create_ids_for,
           :find_rows_for, :find_or_create_rows_for, :flush_cache!, :referring_models, :value_column_names, :referred_to_by,
-          :collapse_rows_and_update_referrers!, :ensure_has_unique_index!, :remove_unique_index! ].each do |delegated_method_name|
+          :collapse_rows_and_update_referrers!, :ensure_has_unique_index!, :remove_unique_index!, :type_cast_id ].each do |delegated_method_name|
           define_method("low_card_#{delegated_method_name}") do |*args|
             _low_card_row_manager.send(delegated_method_name, *args)
           end

data/lib/low_card_tables/low_card_table/row_manager.rb

@@ -115,6 +115,15 @@ module LowCardTables
         rows_for_ids(id)
       end
 
+      def type_cast_id(id)
+        column = @low_card_model.columns_hash[@low_card_model.primary_key]
+        if column.respond_to?(:type_cast_from_database)
+          column.type_cast_from_database(id)
+        else
+          column.type_cast(id)
+        end
+      end
+
       # Given a single Hash specifying zero or more constraints for low-card rows (i.e., mapping zero or more columns
       # of the low-card table to specific values for those columns), returns a (possibly empty) Array of IDs of
       # low-card rows that match those constraints.
@@ -327,7 +336,6 @@ but we got back these rows:
           column_name = column.name.to_s.strip.downcase
 
           use = true
-          use = false if column.primary
           use = false if column_names_to_skip.include?(column_name)
           use
         end
@@ -531,6 +539,13 @@ equivalent of 'LOCK TABLE'(s) in your database.}
       # metadata and shouldn't play a direct role in the low-card system).
       def column_names_to_skip
         @column_names_to_skip ||= begin
+          primary_keys = if @low_card_model.respond_to?(:primary_keys)
+            Array(@low_card_model.primary_keys)
+          else
+            Array(@low_card_model.primary_key)
+          end
+
+          primary_keys +
           COLUMN_NAMES_TO_ALWAYS_SKIP +
           Array(@low_card_model.low_card_options[:exclude_column_names] || [ ]).map { |n| n.to_s.strip.downcase }
         end
@@ -587,7 +602,9 @@ equivalent of 'LOCK TABLE'(s) in your database.}
         missing = missing.select do |missing_column_name|
           column = @low_card_model.columns.detect { |c| c.name.to_s.strip.downcase == missing_column_name.to_s.strip.downcase }
           if column && column.default
-            hash[column.name] = column.default
+            the_default = column.default
+            the_default = column.type_cast_from_database(the_default) if column.respond_to?(:type_cast_from_database)
+            hash[column.name] = the_default
             false
           else
             true

data/lib/low_card_tables/version.rb

@@ -1,4 +1,4 @@
 # Defines the current version of +low_card_tables+.
 module LowCardTables
-  VERSION = "1.0.3"
+  VERSION = "1.1.0"
 end

data/lib/low_card_tables/version_support.rb

@@ -23,6 +23,14 @@ module LowCardTables
         (::ActiveRecord::VERSION::MAJOR <= 3 && ::ActiveRecord::VERSION::MINOR == 0)
       end
 
+      def sti_uses_discriminate_class_for_record?
+        ::ActiveRecord::VERSION::MAJOR >= 4
+      end
+
+      def allows_static_scopes?
+        (::ActiveRecord::VERSION::MAJOR < 4) || (::ActiveRecord::VERSION::MINOR < 2)
+      end
+
       # Define a default scope on the class in question. This is only actually used from our specs.
       def define_default_scope(klass, conditions)
         if default_scopes_accept_a_block?

data/low_card_tables.gemspec

@@ -21,12 +21,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency "rake"
   s.add_development_dependency "rspec", "~> 2.14"
 
-  if (RUBY_VERSION =~ /^1\.9\./ || RUBY_VERSION =~ /^2\.0\./) && ((! defined?(RUBY_ENGINE)) || (RUBY_ENGINE != 'jruby'))
-    s.add_development_dependency "pry"
-    s.add_development_dependency "pry-debugger"
-    s.add_development_dependency "pry-stack_explorer"
-  end
-
   ar_version = ENV['LOW_CARD_TABLES_AR_TEST_VERSION']
   ar_version = ar_version.strip if ar_version
 
@@ -44,6 +38,7 @@ Gem::Specification.new do |s|
 
   ar_import_version = case ar_version
   when nil then nil
+  when /^4\.2\./ then '~> 0.7.0'
   when 'master', /^4\.0\./, /^4\.1\./ then '~> 0.4.1'
   when /^3\.0\./ then '~> 0.2.11'
   when /^3\.1\./, /^3\.2\./ then '~> 0.3.1'
@@ -56,13 +51,21 @@ Gem::Specification.new do |s|
     s.add_dependency("activerecord-import")
   end
 
+  # i18n released an 0.7.0 that's incompatible with Ruby 1.8.
+  if RUBY_VERSION =~ /^1\.8\./
+    s.add_development_dependency 'i18n', '< 0.7.0'
+  end
+
   require File.expand_path(File.join(File.dirname(__FILE__), 'spec', 'low_card_tables', 'helpers', 'database_helper'))
   database_gem_name = LowCardTables::Helpers::DatabaseHelper.maybe_database_gem_name
 
   # Ugh. Later versions of the 'mysql2' gem are incompatible with AR 3.0.x; so, here, we explicitly trap that case
   # and use an earlier version of that Gem.
   if database_gem_name && database_gem_name == 'mysql2' && ar_version && ar_version =~ /^3\.0\./
-    s.add_development_dependency('mysql2', '~> 0.2.0')
+    s.add_development_dependency(database_gem_name, '~> 0.2.0')
+  # The 'pg' gem removed Ruby 1.8 compatibility as of 0.18.
+  elsif database_gem_name && database_gem_name == 'pg' && RUBY_VERSION =~ /^1\.8\./
+    s.add_development_dependency(database_gem_name, '< 0.18.0')
   else
     s.add_development_dependency(database_gem_name)
   end

data/spec/low_card_tables/helpers/database_helper.rb

@@ -79,6 +79,28 @@ module LowCardTables
                 :encoding => 'utf8'
               }
             }
+          when 'postgres', 'postgresql'
+            {
+              :require => 'activerecord-jdbcpostgresql-adapter',
+              :database_gem_name => 'activerecord-jdbcpostgresql-adapter',
+              :config => {
+                :adapter => 'postgresql',
+                :database => 'myapp_test',
+                :username => 'travis',
+                :encoding => 'utf8'
+              }
+            }
+          when 'sqlite'
+            {
+              :require => 'activerecord-jdbcsqlite3-adapter',
+              :database_gem_name => 'activerecord-jdbcsqlite3-adapter',
+              :config => {
+                :adapter => 'jdbcsqlite3',
+                :database => 'myapp_test',
+                :username => 'travis',
+                :encoding => 'utf8'
+              }
+            }
           when '', nil then nil
           else
             raise "Unknown Travis CI database type: #{dbtype.inspect}"
@@ -129,7 +151,7 @@ module LowCardTables
       end
 
       def invalid_config_file!
-        raise Errno::ENOENT, %{In order to run specs for LowCardTables, you need to create a file at:
+        raise InvalidDatabaseConfigurationError, %{In order to run specs for LowCardTables, you need to create a file at:
 
 #{config_file_path}
 

data/spec/low_card_tables/helpers/system_helpers.rb

@@ -16,12 +16,13 @@ module LowCardTables
         LowCardTables::VersionSupport.clear_schema_cache!(::ActiveRecord::Base)
       end
 
-      def define_model_class(name, table_name, &block)
-        model_class = Class.new(::ActiveRecord::Base)
+      def define_model_class(name, table_name, options = { }, &block)
+        superclass = options[:superclass] || ::ActiveRecord::Base
+        model_class = Class.new(superclass)
         ::Object.send(:remove_const, name) if ::Object.const_defined?(name)
         ::Object.const_set(name, model_class)
-        model_class.table_name = table_name
-        model_class.class_eval(&block)
+        model_class.table_name = table_name if table_name
+        model_class.class_eval(&block) if block
       end
 
       def create_standard_system_spec_tables!

data/spec/low_card_tables/system/basic_system_spec.rb

@@ -64,6 +64,20 @@ describe "LowCardTables basic operations" do
       user1_v2.donation_level.should == 3
     end
 
+    it "should let you set options via a scope, and create those correctly in #new" do
+      pending "This does not work yet, and it will require a major refactor of low_card_tables"
+      scope = User.where(:deleted => false, :deceased => true, :gender => 'male', :donation_level => 7)
+      user2 = scope.new
+      user2.name = 'User2'
+      user2.save!
+
+      user2_again = User.where(:name => 'User2').first
+      expect(user2_again.deleted).to be_false
+      expect(user2_again.deceased).to be_true
+      expect(user2_again.gender).to eq('male')
+      expect(user2_again.donation_level).to eq(7)
+    end
+
     it "should expose a low-card row, but not with an ID, when read in from the DB" do
       @user1.status.should be
       @user1.status.id.should_not be

data/spec/low_card_tables/system/options_system_spec.rb

@@ -101,9 +101,9 @@ describe "LowCardTables association options" do
     user1.deceased = false
     user1.gender = 'female'
 
-    start_time = Time.now.to_i
+    start_time = Time.now.to_f.floor
     user1.save!
-    end_time = Time.now.to_i
+    end_time = Time.now.to_f.ceil
 
     ::UserStatusExcludeCreatedUpdated.count.should == 1
     ::UserStatusExcludeCreatedUpdated.first.created_at.to_i.should >= start_time
@@ -126,6 +126,7 @@ describe "LowCardTables association options" do
     ::UserStatusExcludeCreatedUpdated.first.updated_at.to_i.should >= start_time
     ::UserStatusExcludeCreatedUpdated.first.updated_at.to_i.should <= end_time
   end
+
   context "with standard setup" do
     before :each do
       create_standard_system_spec_tables!

data/spec/low_card_tables/system/queries_system_spec.rb

@@ -55,6 +55,17 @@ describe "LowCardTables query support" do
     check_user_ids(::User.where(:deleted => false, :name => 'User2'), [ ])
   end
 
+  it "should allow 'where' clauses that use an array" do
+    check_user_ids(::User.where(:donation_level => [ 8, 10 ]), [ @user1, @user2, @user3, @user4, @user5 ])
+  end
+
+  it "should allow 'where' clauses to use a symbol or a string, and work fine either way" do
+    check_user_ids(::User.where(:gender => :male), [ @user4 ])
+    check_user_ids(::User.where(:gender => 'male'), [ @user4 ])
+    check_user_ids(::User.where(:gender => [ :male, :female ]), [ @user1, @user2, @user3, @user4, @user5 ])
+    check_user_ids(::User.where(:gender => [ 'male', 'female' ]), [ @user1, @user2, @user3, @user4, @user5 ])
+  end
+
   it "should allow 'where' clauses that use delegated properties with differently-prefixed names directly" do
     define_model_class(:User2, :lctables_spec_users) { has_low_card_table :status, :prefix => :foo, :class => ::UserStatus, :foreign_key => :user_status_id }
 
@@ -114,29 +125,31 @@ describe "LowCardTables query support" do
     check_user_ids(::User.bar, [ @user1, @user2, @user3, @user5, @user6 ])
   end
 
-  it "should blow up if you constrain on low-card foreign keys in a static scope" do
-    lambda do
-      LowCardTables::VersionSupport.define_default_scope(::User, nil)
-      class ::User < ::ActiveRecord::Base
-        scope :foo, where(:deleted => false)
-      end
-    end.should raise_error(LowCardTables::Errors::LowCardStaticScopeError, /user_status_id/mi)
+  if ::LowCardTables::VersionSupport.allows_static_scopes?
+    it "should blow up if you constrain on low-card foreign keys in a static scope" do
+      lambda do
+        LowCardTables::VersionSupport.define_default_scope(::User, nil)
+        class ::User < ::ActiveRecord::Base
+          scope :foo, where(:deleted => false)
+        end
+      end.should raise_error(LowCardTables::Errors::LowCardStaticScopeError, /user_status_id/mi)
+
+      lambda do
+        LowCardTables::VersionSupport.define_default_scope(::User, nil)
+        class ::User < ::ActiveRecord::Base
+          scope :foo, where(:user_status_id => ::UserStatus.low_card_ids_matching(:deleted => false))
+        end
+      end.should raise_error(LowCardTables::Errors::LowCardStaticScopeError, /user_status_id/mi)
+    end
+
 
-    lambda do
+    it "should not blow up if you constrain on other things in a static scope" do
       LowCardTables::VersionSupport.define_default_scope(::User, nil)
       class ::User < ::ActiveRecord::Base
-        scope :foo, where(:user_status_id => ::UserStatus.low_card_ids_matching(:deleted => false))
+        scope :foo, where(:name => %w{foo bar})
       end
-    end.should raise_error(LowCardTables::Errors::LowCardStaticScopeError, /user_status_id/mi)
-  end
-
 
-  it "should not blow up if you constrain on other things in a static scope" do
-    LowCardTables::VersionSupport.define_default_scope(::User, nil)
-    class ::User < ::ActiveRecord::Base
-      scope :foo, where(:name => %w{foo bar})
+      ::User.first.should be
     end
-
-    ::User.first.should be
   end
 end

data/spec/low_card_tables/system/sti_system_spec.rb

@@ -0,0 +1,178 @@
+require 'low_card_tables'
+require 'low_card_tables/helpers/database_helper'
+require 'low_card_tables/helpers/system_helpers'
+
+describe "LowCardTables STI support" do
+  include LowCardTables::Helpers::SystemHelpers
+
+  before :each do
+    @dh = LowCardTables::Helpers::DatabaseHelper.new
+    @dh.setup_activerecord!
+  end
+
+  context "with the 'type' column defined in a low-card table" do
+    before :each do
+      migrate do
+        drop_table :lctables_spec_account_statuses rescue nil
+        create_table :lctables_spec_account_statuses, :low_card => true do |t|
+          t.boolean :deleted, :null => false
+          t.string :type
+          t.integer :account_level
+        end
+
+        drop_table :lctables_spec_accounts rescue nil
+        create_table :lctables_spec_accounts do |t|
+          t.string :name, :null => false
+          t.integer :account_status_id, :null => false, :limit => 2
+        end
+      end
+
+      define_model_class(:AccountStatus, 'lctables_spec_account_statuses') { is_low_card_table }
+      define_model_class(:Account, 'lctables_spec_accounts') { has_low_card_table :status; self.inheritance_column = :type }
+      define_model_class(:AdminAccount, nil, :superclass => ::Account)
+      define_model_class(:AccountStatusBackdoor, 'lctables_spec_account_statuses') { self.inheritance_column = :_disabled_ }
+    end
+
+    it "should work normally" do
+      account1 = ::Account.new
+      account1.name = "account 1"
+      account1.deleted = false
+      account1.account_level = 10
+      account1.save!
+
+      account2 = ::AdminAccount.new
+      account2.name = "account 2"
+      account2.deleted = true
+      account2.account_level = 20
+      account2.save!
+
+      account1_again = ::Account.find(account1.id)
+      expect(account1_again.class).to eq(::Account)
+      expect(account1_again.name).to eq('account 1')
+      expect(account1_again.deleted).to eq(false)
+      expect(account1_again.account_level).to eq(10)
+
+      account2_again = ::Account.find(account2.id)
+      expect(account2_again.class).to eq(::AdminAccount)
+      expect(account2_again.name).to eq('account 2')
+      expect(account2_again.deleted).to eq(true)
+      expect(account2_again.account_level).to eq(20)
+
+      all_accounts = ::Account.all.to_a
+      expect(all_accounts.length).to eq(2)
+      account1 = all_accounts.detect { |a| a.id == account1.id }
+      account2 = all_accounts.detect { |a| a.id == account2.id }
+
+      admin_accounts = ::AdminAccount.all.to_a
+      expect(admin_accounts.length).to eq(1)
+      expect(admin_accounts.first.id).to eq(account2.id)
+
+      expect(account1.class.name).to eq('Account')
+      expect(account2.class.name).to eq('AdminAccount')
+
+      expect(::AccountStatusBackdoor.count).to eq(2)
+      asid = account1.account_status_id
+      status1 = ::AccountStatusBackdoor.find(asid)
+      expect(status1.deleted).to eq(false)
+      expect(status1.type).to eq(nil)
+      expect(status1.account_level).to eq(10)
+      status2 = ::AccountStatusBackdoor.find(account2.account_status_id)
+      expect(status2.deleted).to eq(true)
+      expect(status2.type).to eq('AdminAccount')
+      expect(status2.account_level).to eq(20)
+    end
+  end
+
+  context "with a normal table that uses STI, and has a low-card table" do
+    before :each do
+      migrate do
+        drop_table :lctables_spec_account_statuses rescue nil
+        create_table :lctables_spec_account_statuses, :low_card => true do |t|
+          t.boolean :deleted, :null => false
+          t.integer :account_level
+        end
+
+        drop_table :lctables_spec_accounts rescue nil
+        create_table :lctables_spec_accounts do |t|
+          t.string :name, :null => false
+          t.string :type
+          t.integer :account_status_id, :null => false, :limit => 2
+        end
+      end
+
+      define_model_class(:AccountStatus, 'lctables_spec_account_statuses') { is_low_card_table }
+      define_model_class(:Account, 'lctables_spec_accounts') { has_low_card_table :status; self.inheritance_column = :type }
+      define_model_class(:AccountStatusBackdoor, 'lctables_spec_account_statuses') { }
+    end
+
+    it "should work normally with the base table" do
+      account1 = ::Account.new
+      account1.name = "account 1"
+      account1.deleted = false
+      account1.account_level = 10
+      account1.save!
+
+      account2 = ::Account.new
+      account2.name = "account 2"
+      account2.deleted = true
+      account2.account_level = 20
+      account2.save!
+
+      account1_again = ::Account.find(account1.id)
+      expect(account1_again.name).to eq('account 1')
+      expect(account1_again.deleted).to eq(false)
+      expect(account1_again.account_level).to eq(10)
+
+      account2_again = ::Account.find(account2.id)
+      expect(account2_again.name).to eq('account 2')
+      expect(account2_again.deleted).to eq(true)
+      expect(account2_again.account_level).to eq(20)
+
+      expect(::AccountStatusBackdoor.count).to eq(2)
+      status1 = ::AccountStatusBackdoor.find(account1.account_status_id)
+      expect(status1.deleted).to eq(false)
+      expect(status1.account_level).to eq(10)
+      status2 = ::AccountStatusBackdoor.find(account2.account_status_id)
+      expect(status2.deleted).to eq(true)
+      expect(status2.account_level).to eq(20)
+    end
+
+    it "should work normally with the base table and a derived table" do
+      define_model_class(:AdminAccount, nil, :superclass => ::Account)
+
+      account1 = ::Account.new
+      account1.name = "account 1"
+      account1.deleted = false
+      account1.account_level = 10
+      account1.save!
+
+      account2 = ::AdminAccount.new
+      account2.name = "account 2"
+      account2.deleted = true
+      account2.account_level = 20
+      account2.save!
+
+      account1_again = ::Account.find(account1.id)
+      expect(account1_again.class).to eq(::Account)
+      expect(account1_again.name).to eq('account 1')
+      expect(account1_again.deleted).to eq(false)
+      expect(account1_again.account_level).to eq(10)
+
+      account2_again = ::Account.find(account2.id)
+      expect(account2_again.class.name).to eq('AdminAccount')
+      expect(account2_again.name).to eq('account 2')
+      expect(account2_again.deleted).to eq(true)
+      expect(account2_again.account_level).to eq(20)
+
+      expect(::AccountStatusBackdoor.count).to eq(2)
+      status1 = ::AccountStatusBackdoor.find(account1.account_status_id)
+      expect(status1.deleted).to eq(false)
+      expect(status1.account_level).to eq(10)
+      status2 = ::AccountStatusBackdoor.find(account2.account_status_id)
+      expect(status2.deleted).to eq(true)
+      expect(status2.account_level).to eq(20)
+
+      expect(::AdminAccount.where(:deleted => true).first.id).to eq(account2.id)
+    end
+  end
+end

data/spec/low_card_tables/unit/active_record/base_spec.rb

@@ -4,6 +4,7 @@ describe LowCardTables::ActiveRecord::Base do
   before :each do
     @klass = Class.new
     @klass.send(:include, LowCardTables::ActiveRecord::Base)
+    allow(@klass).to receive(:inheritance_column=).with('_sti_on_low_card_tables_should_never_be_used')
   end
 
   it "should include LowCardTables::LowCardTable::Base appropriately and respond to #is_low_card_table? appropriately" do

data/spec/low_card_tables/unit/has_low_card_table/low_card_dynamic_method_manager_spec.rb

@@ -2,7 +2,7 @@ require 'low_card_tables'
 
 describe LowCardTables::HasLowCardTable::LowCardDynamicMethodManager do
   before :each do
-    @model_class = double("model_class")
+    @model_class = double("model_class", :superclass => ::Object)
     @lcam = double("low_card_associations_manager")
     allow(@model_class).to receive(:_low_card_associations_manager).and_return(@lcam)
 

data/spec/low_card_tables/unit/low_card_table/base_spec.rb

@@ -3,6 +3,7 @@ require 'low_card_tables'
 describe LowCardTables::LowCardTable::Base do
   before :each do
     @test_class = Class.new
+    allow(@test_class).to receive(:inheritance_column=).with('_sti_on_low_card_tables_should_never_be_used')
     @test_class.send(:include, LowCardTables::LowCardTable::Base)
   end
 
@@ -112,6 +113,7 @@ describe LowCardTables::LowCardTable::Base do
       end
 
       test_class = Class.new
+      allow(test_class).to receive(:inheritance_column=).with('_sti_on_low_card_tables_should_never_be_used')
       test_class.send(:extend, mod)
       test_class.send(:include, LowCardTables::LowCardTable::Base)
 
@@ -163,6 +165,7 @@ ensure_has_unique_index! remove_unique_index!}.each do |method_name|
 
       # We need a new class -- because we need to make sure our module gets in there first
       @test_class = Class.new
+      allow(@test_class).to receive(:inheritance_column=).with('_sti_on_low_card_tables_should_never_be_used')
       @test_class.send(:include, @save_mod)
       @test_class.send(:include, LowCardTables::LowCardTable::Base)
 

data/spec/low_card_tables/unit/low_card_table/row_manager_spec.rb

@@ -88,20 +88,18 @@ describe LowCardTables::LowCardTable::RowManager do
       allow(@low_card_model).to receive(:reset_column_information)
       allow(@low_card_model).to receive(:table_exists?).and_return(true)
       allow(@low_card_model).to receive(:table_name).and_return("thetablename")
+      allow(@low_card_model).to receive(:primary_key).and_return('id')
 
       @table_unique_index = double("table_unique_index")
       allow(LowCardTables::LowCardTable::TableUniqueIndex).to receive(:new).with(@low_card_model).and_return(@table_unique_index)
 
       @column_id = double("column_id")
       allow(@column_id).to receive(:name).and_return("id")
-      allow(@column_id).to receive(:primary).and_return(true)
       @column_foo = double("column_foo")
       allow(@column_foo).to receive(:name).and_return("foo")
-      allow(@column_foo).to receive(:primary).and_return(false)
       allow(@column_foo).to receive(:default).and_return(nil)
       @column_bar = double("column_bar")
       allow(@column_bar).to receive(:name).and_return("bar")
-      allow(@column_bar).to receive(:primary).and_return(false)
       allow(@column_bar).to receive(:default).and_return('yohoho')
       allow(@low_card_model).to receive(:columns).and_return([ @column_id, @column_foo, @column_bar ])
 
@@ -332,7 +330,6 @@ describe LowCardTables::LowCardTable::RowManager do
         it "should accept hashes containing valid data, if it isn't found the first time through" do
           column_baz = double("column_bar")
           allow(column_baz).to receive(:name).and_return("baz")
-          allow(column_baz).to receive(:primary).and_return(false)
 
           columns_to_return = [
             [ @column_id, @column_foo, @column_bar ],
@@ -865,15 +862,12 @@ describe LowCardTables::LowCardTable::RowManager do
 
       it "should exclude primary keys, created/updated_at, and options-specified column names" do
         column_created_at = double("column_created_at")
-        allow(column_created_at).to receive(:primary).and_return(false)
         allow(column_created_at).to receive(:name).and_return("created_at")
 
         column_updated_at = double("column_updated_at")
-        allow(column_updated_at).to receive(:primary).and_return(false)
         allow(column_updated_at).to receive(:name).and_return("updated_at")
 
         column_skipped = double("column_skipped")
-        allow(column_skipped).to receive(:primary).and_return(false)
         allow(column_skipped).to receive(:name).and_return("FooFle")
 
         columns = [ @column_id, @column_foo, @column_bar, @column_created_at, @column_updated_at, @column_skipped ]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: low_card_tables
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.1.0
 platform: ruby
 authors:
 - Andrew Geweke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-22 00:00:00.000000000 Z
+date: 2015-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -169,6 +169,7 @@ files:
 - spec/low_card_tables/system/namespaced_models_system_spec.rb
 - spec/low_card_tables/system/options_system_spec.rb
 - spec/low_card_tables/system/queries_system_spec.rb
+- spec/low_card_tables/system/sti_system_spec.rb
 - spec/low_card_tables/system/validations_system_spec.rb
 - spec/low_card_tables/unit/active_record/base_spec.rb
 - spec/low_card_tables/unit/active_record/migrations_spec.rb
@@ -209,7 +210,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: '"Bitfields for ActiveRecord": instead of storing multiple columns with low
@@ -228,6 +229,7 @@ test_files:
 - spec/low_card_tables/system/namespaced_models_system_spec.rb
 - spec/low_card_tables/system/options_system_spec.rb
 - spec/low_card_tables/system/queries_system_spec.rb
+- spec/low_card_tables/system/sti_system_spec.rb
 - spec/low_card_tables/system/validations_system_spec.rb
 - spec/low_card_tables/unit/active_record/base_spec.rb
 - spec/low_card_tables/unit/active_record/migrations_spec.rb