active_record-mti 0.3.0.pre.rc1 → 0.3.0.pre.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: aed8fa7772f145269a995f4e2d139ebbb8670023
-  data.tar.gz: c40c16ae6a90a66aa9dc3aa6839fe9678761218b
+  metadata.gz: d60ec74fdc811ec4b99d12daed96d8d44989026b
+  data.tar.gz: 5e11732fcfec73c329050915107a088876886b37
 SHA512:
-  metadata.gz: 520d9654c833f837d3cb93e2320cfb44e86c18802f3d4df1e4b2edccbbec9b9621b257c372eb0ac0dfe288c92135d07593cb3af80c910bd3679a50319efd1562
-  data.tar.gz: 7e51e4286a33db38af13e12ee6a5bb05f43519b4d8cb7e2be1bbfeef71c46caa370a25d691e80eccf9f61871717c0d130f4861f370c7d4aadcbd8e1639edb1ee
+  metadata.gz: 62ce99ba9014e671d53c84b1bab0ac37de5dc7ee3317767b27b3dcc8084b6f544b0a1ffe25674a83723b9f8ee8e19d4ccc0fa22ee728df9b21d2186075ee8ecf
+  data.tar.gz: 8fac323f73f8d83aeb417a28243c711ff3073d58a541179aaa5ccb9f985fe2329917c286368a17b9d50426304eb10d3661352ad6f0b1896ed4106e6e17bfdaa7

data/README.md

@@ -27,26 +27,27 @@ Or install it yourself as:
 
 ### Application Code
 
-ActiveRecord queries work as usual with the following differences:
-
-* You need to specify which model represents the base of your multi table inheritance tree. To do so, add `uses_mti` to the model definition of the base class.
-* The default query of "*" is changed to include the OID of each row for subclass discrimination. The default select will be `SELECT "accounts"."tableoid" AS tableoid, "accounts".*` (for example)
+In most cases, you shouldn't have to do anything beyond installing the gem. `ActiveRecord::MTI` will do it's best to determine the nature of inheritance in your models. If your models map to their own tables, `ActiveRecord::MTI` will step in and make sure inheritance is treated appropriately. Otherwise it will gracefully aquiece to `ActiveRecord`'s built-in `STI`.
 
 ```ruby
 class Account < ::ActiveRecord::Base
-  uses_mti
-
+  # ...
 end
 
 class User < Account
-
+  # ...
 end
 
 class Developer < Account
-
+  # ...
 end
 ```
 
+`ActiveRecord` queries work as usual with the following differences:
+
+- The default query of "\*" is changed to include the OID of each row for subclass discrimination. The default select will be `SELECT "accounts"."tableoid" AS tableoid, "accounts".*` (for example)
+
+Note
 ### Migrations
 
 In your migrations define a table to inherit from another table:

data/lib/active_record/mti/calculations.rb

@@ -1,20 +1,19 @@
 module ActiveRecord
   module MTI
     module Calculations
-      extend ActiveSupport::Concern
 
       private
 
       def perform_calculation(*args)
-        result = swap_and_restore_tableoid_cast(true) do
+        swap_and_restore_tableoid_cast(true) do
           super
         end
       end
 
-      def swap_and_restore_tableoid_cast(value, &block)
+      def swap_and_restore_tableoid_cast(value)
         orignal_value = Thread.current['skip_tableoid_cast']
         Thread.current['skip_tableoid_cast'] = value
-        return_value = yield
+        return_value = yield if block_given?
         Thread.current['skip_tableoid_cast'] = orignal_value
         return return_value
       end

data/lib/active_record/mti/connection_adapters/postgresql/schema_statements.rb

@@ -21,13 +21,13 @@ module ActiveRecord
               options.delete(:primary_key)
             end
 
-            if schema = options.delete(:schema)
+            if (schema = options.delete(:schema))
               # If we specify a schema then we only create it if it doesn't exist
               # and we only force create it if only the specific schema is in the search path
               table_name = %Q("#{schema}"."#{table_name}")
             end
 
-            if inherited_table = options.delete(:inherits)
+            if (inherited_table = options.delete(:inherits))
               # options[:options] = options[:options].sub("INHERITS", "() INHERITS") if td.columns.empty?
               options[:options] = [%Q(INHERITS ("#{inherited_table}")), options[:options]].compact.join
             end

data/lib/active_record/mti/inheritance.rb

@@ -1,183 +1,126 @@
-require 'active_support/concern'
-
 module ActiveRecord
   # == Multi-Table Inheritance
   module MTI
     module Inheritance
-      extend ActiveSupport::Concern
-
-      included do
-        @@mti_tableoids = {}
-        scope :discern_inheritance, -> {
 
-        }
+      def self.prepended(subclass)
+        subclass.extend(ClassMethods)
+        class << subclass
+          class_attribute :mti_type_column
+          class_attribute :tableoid_column
+        end
       end
 
       module ClassMethods
+        def has_tableoid_column?
+          tableoid_column != false
+        end
 
-        @uses_mti = nil
-        @mti_setup = false
-        @mti_type_column = nil
-
-        def uses_mti(custom_table_name = nil, inheritance_column = nil)
-          self.inheritance_column = inheritance_column
-
-          @uses_mti = true
-          @tableoid_column = nil
+        def inherited(subclass)
+          super
+          subclass.using_multi_table_inheritance?
         end
 
-        def using_multi_table_inheritance?(klass = self)
-          klass.uses_mti?
+        def uses_mti(*args)
+          # ActiveRecord::MTI.logger.
+          warn "DEPRECATED - `uses_mti` is no longer needed (nor has any effect)"
         end
 
-        def uses_mti?
-          inheritance_check = check_inheritance_of(@table_name) unless @mti_setup
+        def using_multi_table_inheritance?
+          mti = ActiveRecord::MTI::Registry.tableoid?(self)
+          return (mti != false) unless mti == nil
 
-          if @uses_mti.nil? && @uses_mti = inheritance_check
-            descendants.each do |d|
-              d.uses_mti?
+          if (mti = check_inheritance_of(@table_name))
+            if (self != base_class && self.table_name == base_class.table_name)
+              mti = false
+            else
+              mti = detect_tableoid(table_name)
             end
           end
 
-          @uses_mti
-        end
+          ActiveRecord::MTI::Registry[self] = mti
 
-        def has_tableoid_column?
-          @tableoid_column != false
-        end
-
-        def mti_type_column
-          @mti_type_column
-        end
+          descendants.each do |d|
+            d.using_multi_table_inheritance?
+          end
 
-        def mti_type_column=(value)
-          @mti_type_column = value
+          return mti && mti != false
         end
 
         private
 
-        def check_inheritance_of(table_name)
-          ActiveRecord::MTI.logger.debug "Trying to check inheritance of table with no table name (#{self})" unless table_name
-          return nil unless table_name
-
-          ActiveRecord::MTI.logger.debug "Checking inheritance for #{table_name}"
+        def check_inheritance_of(table_name, table_schema = 'public')
+          ActiveRecord::MTI.logger.debug("Trying to check inheritance of table with no table name (#{self})") and return nil unless table_name
+          ActiveRecord::MTI.logger.debug "Checking inheritance for #{table_schema}.#{table_name}"
 
           result = connection.execute <<-SQL
             SELECT EXISTS (
               SELECT 1
-              FROM      pg_catalog.pg_inherits AS i
-              LEFT JOIN pg_catalog.pg_rewrite  AS r    ON r.ev_class = 'public.#{table_name}'::regclass::oid
-              LEFT JOIN pg_catalog.pg_depend   AS d    ON d.objid    = r.oid
-              LEFT JOIN pg_catalog.pg_class    AS cl_d ON cl_d.oid   = d.refobjid
-              WHERE inhrelid  = COALESCE(cl_d.relname, 'public.#{table_name}')::regclass::oid
-              OR    inhparent = COALESCE(cl_d.relname, 'public.#{table_name}')::regclass::oid
+                FROM pg_catalog.pg_inherits       AS i
+                  JOIN information_schema.tables  AS t ON t.table_schema = '#{table_schema}' AND t.table_name = '#{table_name}'
+                  LEFT JOIN pg_catalog.pg_rewrite AS r ON r.ev_class     = t.table_name::regclass::oid
+                  LEFT JOIN pg_catalog.pg_depend  AS d ON d.objid        = r.oid
+                  LEFT JOIN pg_catalog.pg_class   AS c ON c.oid          = d.refobjid
+                WHERE i.inhrelid  = COALESCE(c.relname, t.table_name)::regclass::oid
+                  OR i.inhparent = COALESCE(c.relname, t.table_name)::regclass::oid
             ) AS uses_inheritance;
           SQL
 
-          uses_inheritance = ActiveRecord::MTI.testify(result.try(:first)['uses_inheritance'])
-
-          register_tableoid(table_name) if uses_inheritance
-
-          @mti_setup = true
-          # Some versions of PSQL return {"?column?"=>"t"}
-          # instead of {"exists"=>"t"}, so we're saying screw it,
-          # just give me the first value of whatever is returned
-
-          # Ensure a boolean is returned
-          return uses_inheritance == true
+          return ActiveRecord::MTI.testify(result.try(:first)['uses_inheritance']) == true
         end
 
-        def register_tableoid(table_name)
+        def detect_tableoid(table_name, table_schema = 'public')
 
           tableoid_query = connection.execute(<<-SQL
-            SELECT '#{table_name}'::regclass::oid AS tableoid, (SELECT EXISTS (
-              SELECT 1
+            SELECT 1 AS has_tableoid_column, t.table_name::regclass::oid as tableoid
               FROM   pg_catalog.pg_attribute
-              WHERE  attrelid = '#{table_name}'::regclass
+              JOIN   information_schema.tables t ON t.table_schema = '#{table_schema}' AND t.table_name = '#{table_name}'
+              WHERE  attrelid = t.table_name::regclass
               AND    attname  = 'tableoid'
-              AND    NOT attisdropped
-            )) AS has_tableoid_column
+              AND    NOT attisdropped;
           SQL
           ).first
-          tableoid = tableoid_query['tableoid']
-          @tableoid_column = ActiveRecord::MTI.testify(tableoid_query['has_tableoid_column'])
+
+          tableoid = tableoid_query.try(:[], 'tableoid') || false
+          self.tableoid_column = ActiveRecord::MTI.testify(tableoid_query.try(:[], 'has_tableoid_column'))
 
           if (has_tableoid_column?)
-            ActiveRecord::MTI.logger.debug "#{table_name} has tableoid column! (#{tableoid})"
+            ActiveRecord::MTI.logger.debug "#{table_schema}.#{table_name} has tableoid column! (#{tableoid})"
             add_tableoid_column
-            @mti_type_column = arel_table[:tableoid]
+            self.mti_type_column = arel_table[:tableoid]
           else
-            @mti_type_column = nil
+            self.mti_type_column = nil
           end
 
-          Inheritance.add_mti(tableoid, self)
+          tableoid
         end
 
         # Called by +instantiate+ to decide which class to use for a new
         # record instance. For single-table inheritance, we check the record
         # for a +type+ column and return the corresponding class.
         def discriminate_class_for_record(record)
-          if using_multi_table_inheritance?(base_class)
-            find_mti_class(record) || base_class
-          elsif using_single_table_inheritance?(record)
-            find_sti_class(record[inheritance_column])
+          if using_multi_table_inheritance?
+            ActiveRecord::MTI::Registry.find_mti_class(record['tableoid']) || self
           else
             super
           end
         end
 
-        # Search descendants for one who's table_name is equal to the returned tableoid.
-        # This indicates the class of the record
-        def find_mti_class(record)
-          if (has_tableoid_column?)
-            Inheritance.find_mti(record['tableoid'])
-          else
-            self
-          end
-        end
-
         # Type condition only applies if it's STI, otherwise it's
         # done for free by querying the inherited table in MTI
         def type_condition(table = arel_table)
-          if using_multi_table_inheritance?
-            nil
-          else
-            sti_column = table[inheritance_column]
-            sti_names  = ([self] + descendants).map { |model| model.sti_name }
-
-            sti_column.in(sti_names)
-          end
+          return nil if using_multi_table_inheritance?
+          super
         end
 
         def add_tableoid_column
           if self.respond_to? :attribute
-            self.attribute :tableoid, get_integer_oid_class.new
+            self.attribute :tableoid, ActiveRecord::MTI.oid_class.new
           else
-            columns.unshift ActiveRecord::ConnectionAdapters::PostgreSQLColumn.new('tableoid', nil, ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::OID::Integer.new, "oid", false)
+            columns.unshift ActiveRecord::ConnectionAdapters::PostgreSQLColumn.new('tableoid', nil, ActiveRecord::MTI.oid_class.new, "oid", false)
           end
         end
-
-        # Rails decided to make a breaking change in it's 4.x series :P
-        def get_integer_oid_class
-          ::ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Integer
-        rescue NameError
-          begin
-            ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::OID::Integer
-          rescue NameError
-            ::ActiveModel::Type::Integer
-          end
-        end
-
       end
-
-      def self.add_mti(tableoid, klass)
-        @@mti_tableoids[tableoid.to_s.to_sym] = klass
-      end
-
-      def self.find_mti(tableoid)
-        @@mti_tableoids[tableoid.to_s.to_sym]
-      end
-
     end
   end
 end

data/lib/active_record/mti/model_schema.rb

@@ -1,35 +1,15 @@
 module ActiveRecord
   module MTI
     module ModelSchema
-      extend ActiveSupport::Concern
 
+      def self.prepended(base)
+        base.extend(ClassMethods)
+      end
 
       module ClassMethods
-
-        # Computes the table name, (re)sets it internally, and returns it.
-        def reset_table_name #:nodoc:
-          self.table_name = if abstract_class?
-            superclass == Base ? nil : superclass.table_name
-          elsif superclass.abstract_class?# || superclass.using_multi_table_inheritance?
-            superclass.table_name || compute_table_name
-          else
-            compute_table_name
-          end
-        end
-
         # Computes and returns a table name according to default conventions.
         def compute_table_name
-          base = base_class
-          if self == base
-            # Nested classes are prefixed with singular parent table name.
-            if parent < Base && !parent.abstract_class?
-              contained = parent.table_name
-              contained = contained.singularize if parent.pluralize_table_names
-              contained += '_'
-            end
-
-            "#{full_table_name_prefix}#{contained}#{undecorated_table_name(name)}#{full_table_name_suffix}"
-          elsif uses_mti?
+          if self != base_class
             # Nested classes are prefixed with singular parent table name.
             if superclass < Base && !superclass.abstract_class?
               contained = superclass.table_name
@@ -37,30 +17,39 @@ module ActiveRecord
               contained += '/'
             end
 
-            "#{full_table_name_prefix}#{contained}#{decorated_table_name(name)}#{full_table_name_suffix}"
+            potential_table_name = "#{full_table_name_prefix}#{contained}#{decorated_table_name(name)}#{full_table_name_suffix}"
+
+            if check_inheritance_of(potential_table_name)
+              potential_table_name
+            else
+              superclass.table_name
+            end
           else
-            # STI subclasses always use their superclass' table.
-            superclass.table_name
+            super
           end
         end
 
-        def full_table_name_prefix #:nodoc:
-          (parents.detect{ |p| p.respond_to?(:table_name_prefix) } || self).table_name_prefix
-        end
-
         def full_table_name_suffix #:nodoc:
-          (parents.detect {|p| p.respond_to?(:table_name_suffix) } || self).table_name_suffix
+          super
+        rescue NoMethodError
+          full_table_name_rescue(:table_name_suffix)
         end
 
         private
 
+        def full_table_name_rescue(which)
+          (parents.detect{ |p| p.respond_to?(which) } || self).send(which)
+        end
+
         # Guesses the table name, but does not decorate it with prefix and suffix information.
         def decorated_table_name(class_name = base_class.name)
+          super
+        rescue NoMethodError
           table_name = class_name.to_s.underscore
           pluralize_table_names ? table_name.pluralize : table_name
         end
-
       end
+
     end
   end
 end

data/lib/active_record/mti/query_methods.rb

@@ -1,7 +1,6 @@
 module ActiveRecord
   module MTI
     module QueryMethods
-      extend ActiveSupport::Concern
 
       def build_arel
         select_by_tableoid = select_values.delete(:tableoid) == :tableoid
@@ -21,28 +20,16 @@ module ActiveRecord
 
       def tableoid?(klass)
         !Thread.current['skip_tableoid_cast'] &&
-        @klass.using_multi_table_inheritance? &&
-        @klass.has_tableoid_column?
-      end
-
-      def tableoid_project?(klass)
-        tableoid?(klass) &&
-        (group_values - [:tableoid]).any?
-      end
-
-      def tableoid_group?(klass)
-        tableoid?(klass) &&
-        group_values.any?
+        klass.using_multi_table_inheritance? &&
+        klass.has_tableoid_column?
       end
 
       def tableoid_project(klass)
-        # Arel::Nodes::NamedFunction.new('CAST', [klass.arel_table[:tableoid].as('regclass')])
-        # Arel::Nodes::NamedFunction.new('CAST', [@klass.arel_table['tableoid::regclass'].as('regclass')])
-        @klass.mti_type_column.as('tableoid')
+        klass.mti_type_column.as('tableoid')
       end
 
       def tableoid_group(klass)
-        @klass.mti_type_column
+        klass.mti_type_column
       end
 
     end

data/lib/active_record/mti/registry.rb

@@ -0,0 +1,23 @@
+module ActiveRecord
+  module MTI
+    module Registry
+
+      mattr_accessor :tableoids
+      self.tableoids = { ActiveRecord::Base => false }
+
+      def self.[]=(klass, tableoid)
+        ActiveRecord::MTI.logger.debug "Adding #{klass} to MTI list with #{tableoid}"
+        tableoids[klass] = tableoid
+      end
+
+      def self.find_mti_class(tableoid)
+        tableoids.key(tableoid)
+      end
+
+      def self.tableoid?(klass)
+        tableoids[klass]
+      end
+
+    end
+  end
+end

data/lib/active_record/mti/schema_dumper.rb

@@ -1,5 +1,3 @@
-require 'active_support/concern'
-
 # Modified SchemaDumper that knows how to dump
 # inherited tables. Key is that we have to dump parent
 # tables before we dump child tables (of course).
@@ -12,169 +10,68 @@ module ActiveRecord
   # output format (i.e., ActiveRecord::Schema).
   module MTI
     module SchemaDumper #:nodoc:
-      extend ActiveSupport::Concern
-
-
-      included do
-
-        private
-
-        def dumped_tables
-          @dumped_tables ||= []
-        end
-
-        # Output table and columns - but don't output columns that are inherited from
-        # a parent table.
-        #
-        # TODO: Qualify with the schema name IF the table is in a schema other than the first
-        # schema in the search path (not including the $user schema)
-        def table(table, stream)
-          return if already_dumped?(table)
-
-          if parent_table = @connection.parent_table(table)
-            table(parent_table, stream)
-            parent_column_names = @connection.columns(parent_table).map(&:name)
-          end
-
-          columns = @connection.columns(table)
-          begin
-            tbl = StringIO.new
-
-            # first dump primary key column
-            pk = @connection.primary_key(table)
-
-            tbl.print "  create_table #{remove_prefix_and_suffix(table).inspect}"
-            if parent_table
-              tbl.print %Q(, inherits: '#{parent_table}')
-            else
-              pkcol = columns.detect { |c| c.name == pk }
-              if pkcol
-                if pk != 'id'
-                  tbl.print %Q(, primary_key: '#{pk}')
-                elsif pkcol.sql_type == 'bigint'
-                  tbl.print ", id: :bigserial"
-                elsif pkcol.sql_type == 'uuid'
-                  tbl.print ", id: :uuid"
-                  tbl.print %Q(, default: #{pkcol.default_function.inspect})
-                end
-              else
-                tbl.print ", id: false"
-              end
-              tbl.print ", force: :cascade"
-            end
-            tbl.puts " do |t|"
-
-            # then dump all non-primary key columns
-            column_specs = columns.map do |column|
-              raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" unless @connection.valid_type?(column.type)
-              next if column.name == pk
-
-              # Except columns in parent table
-              next if parent_column_names && parent_column_names.include?(column.name)
-
-              @connection.column_spec(column, @types)
-            end.compact
-
-            # find all migration keys used in this table
-            keys = @connection.migration_keys
-
-            # figure out the lengths for each column based on above keys
-            lengths = keys.map { |key|
-              column_specs.map { |spec|
-                spec[key] ? spec[key].length + 2 : 0
-              }.max
-            }
-
-            # the string we're going to sprintf our values against, with standardized column widths
-            format_string = lengths.map{ |len| "%-#{len}s" }
-
-            # find the max length for the 'type' column, which is special
-            type_length = column_specs.map{ |column| column[:type].length }.max
 
-            # add column type definition to our format string
-            format_string.unshift "    t.%-#{type_length}s "
-
-            format_string *= ''
+      def dumped_tables
+        @dumped_tables ||= []
+      end
 
-            column_specs.each do |colspec|
-              values = keys.zip(lengths).map{ |key, len| colspec.key?(key) ? colspec[key] + ", " : " " * len }
-              values.unshift colspec[:type]
-              tbl.print((format_string % values).gsub(/,\s*$/, ''))
-              tbl.puts
-            end
+      # Output table and columns - but don't output columns that are inherited from
+      # a parent table.
+      def table(table, stream)
+        return if already_dumped?(table)
 
-            tbl.puts "  end"
-            tbl.puts
+        new_stream = StringIO.new
+        super(table, new_stream)
+        string = new_stream.string
 
-            indexes(table, tbl)
+        if (parent_table = @connection.parent_table(table))
+          table(parent_table, stream)
+          string = inject_inherits_for_create_table(string, table, parent_table)
+          string = remove_parent_table_columns(string, @connection.columns(parent_table))
 
-            tbl.rewind
-            stream.print tbl.read
-          rescue => e
-            stream.puts "# Could not dump table #{table.inspect} because of following #{e.class}"
-            stream.puts "#   #{e.message}"
-            stream.puts
-          end
+          pindexes = Hash[@connection.indexes(parent_table).map { |index| [index.columns, index] }]
+          cindexes = Hash[@connection.indexes(table).map { |index| [index.columns, index] }]
 
-          dumped_tables << table
-          stream
+          string = remove_parent_table_indexes(string, (pindexes & cindexes).values)
         end
 
-        # Output indexes but don't output indexes that are inherited from parent tables
-        # since those will be created by create_table.
-        def indexes(table, stream)
-          if (indexes = @connection.indexes(table)).any?
-            if parent_table = @connection.parent_table(table)
-              parent_indexes = @connection.indexes(parent_table)
-            end
-
-            indexes.delete_if {|i| is_parent_index?(i, parent_indexes) } if parent_indexes
-            return if indexes.empty?
-
-            add_index_statements = indexes.map do |index|
-              statement_parts = [
-                ('add_index ' + remove_prefix_and_suffix(index.table).inspect),
-                index.columns.inspect,
-                ('name: ' + index.name.inspect),
-              ]
-              statement_parts << 'unique: true' if index.unique
-
-              index_lengths = (index.lengths || []).compact
-              statement_parts << ('length: ' + Hash[index.columns.zip(index.lengths)].inspect) unless index_lengths.empty?
+        # We've done this table
+        dumped_tables << table
 
-              index_orders = (index.orders || {})
-              statement_parts << ('order: ' + index.orders.inspect) unless index_orders.empty?
-
-              statement_parts << ('where: ' + index.where.inspect) if index.where
-
-              statement_parts << ('using: ' + index.using.inspect) if index.using
-
-              statement_parts << ('type: ' + index.type.inspect) if index.type
+        stream.write string
+        stream
+      end
 
-              '  ' + statement_parts.join(', ')
-            end
+      def inject_inherits_for_create_table(string, table, parent_table)
+        tbl_start = "create_table #{remove_prefix_and_suffix(table).inspect}"
+        tbl_end = " do |t|"
+        tbl_inherit = ", inherits: '#{parent_table}'"
+        string.gsub!(/#{Regexp.escape(tbl_start)}.*#{Regexp.escape(tbl_end)}/, tbl_start + tbl_inherit + tbl_end)
+      end
 
-            stream.puts add_index_statements.sort.join("\n")
-            stream.puts
-          end
+      def remove_parent_table_columns(string, columns)
+        columns.each do |col|
+          string.gsub!(/\s+t\.\w+\s+("|')#{col.name}("|').*/, '')
         end
+        string
+      end
 
-
-        def remove_prefix_and_suffix(table)
-          table.gsub(/^(#{ActiveRecord::Base.table_name_prefix})(.+)(#{ActiveRecord::Base.table_name_suffix})$/,  "\\2")
+      def remove_parent_table_indexes(string, indexes)
+        indexes.each do |index|
+          string.gsub!(/\s*add_index .*name: #{Regexp.escape(index.name.inspect)}.*/, '') # Rails 4.x
+          string.gsub!(/\s+t\.index.*("|')#{index.name}("|').*/, '') # Rails 5.x
         end
+        string
+      end
 
-        def already_dumped?(table)
-          dumped_tables.include? table
-        end
+      def remove_prefix_and_suffix(table)
+        table.gsub(/^(#{ActiveRecord::Base.table_name_prefix})(.+)(#{ActiveRecord::Base.table_name_suffix})$/,  "\\2")
+      end
 
-        def is_parent_index?(index, parent_indexes)
-          parent_indexes.each do |pindex|
-            return true if pindex.columns == index.columns
-          end
-          return false
-        end
+      def already_dumped?(table)
+        dumped_tables.include? table
       end
+
     end
   end
 end

data/lib/active_record/mti/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module MTI
-    VERSION = '0.3.0-rc1'
+    VERSION = '0.3.0-rc2'
   end
 end

data/lib/active_record/mti.rb

@@ -1,7 +1,14 @@
 require 'active_record/mti/version'
+
+require 'active_support/all'
+
 require 'active_record'
 require 'active_record/connection_handling'
+
+require 'core_ext/hash'
+
 require 'active_record/mti/schema_dumper'
+require 'active_record/mti/registry'
 require 'active_record/mti/inheritance'
 require 'active_record/mti/model_schema'
 require 'active_record/mti/query_methods'
@@ -14,6 +21,24 @@ require 'active_record/mti/railtie' if defined?(Rails::Railtie)
 module ActiveRecord
   module MTI
 
+    # Rails likes to make breaking changes in it's minor versions (like 4.1 - 4.2) :P
+    mattr_accessor :oid_class
+
+    # Cannot assign default inside block because of rails 4.0
+    self.oid_class =
+      [
+        '::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::OID::Integer', # 4.0, 4.1
+        '::ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Integer', # 4.2
+        '::ActiveRecord::Type::Integer' # 5.0, 5.1
+      ].find(nil) { |klass|
+        begin
+          klass.constantize
+          true
+        rescue NameError
+          false
+        end
+      }.constantize
+
     class << self
       attr_writer :logger
 
@@ -30,13 +55,13 @@ module ActiveRecord
     end
 
     def self.load
-      ::ActiveRecord::Base.send                                  :include, Inheritance
-      ::ActiveRecord::Base.send                                  :include, ModelSchema
+      ::ActiveRecord::Base.send                                  :prepend, ModelSchema
+      ::ActiveRecord::Base.send                                  :prepend, Inheritance
       ::ActiveRecord::Relation.send                              :prepend, QueryMethods
       ::ActiveRecord::Relation.send                              :prepend, Calculations
       ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send :prepend, ConnectionAdapters::PostgreSQL::Adapter
-      ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send :include, ConnectionAdapters::PostgreSQL::SchemaStatements
-      ::ActiveRecord::SchemaDumper.send                          :include, SchemaDumper
+      ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send :prepend, ConnectionAdapters::PostgreSQL::SchemaStatements
+      ::ActiveRecord::SchemaDumper.send                          :prepend, SchemaDumper
     end
 
     def self.testify(value)

data/lib/core_ext/hash.rb

@@ -0,0 +1,7 @@
+class Hash
+
+  def &(other)
+    Hash[(self.keys & other.keys).zip(other.values_at(*(self.keys & other.keys)))]
+  end
+
+end

data/spec/active_record/mti/{inheritence_spec.rb → inheritance_spec.rb}

@@ -2,28 +2,33 @@ require 'spec_helper'
 
 describe ActiveRecord::MTI::Inheritance do
 
-  xit 'returns non-nil value when checking uses_mti?' do
-    # Mod = Class.new(User)
-    # expect(Mod.uses_mti?).to be(true)
+  it "creates a column even if class doesn't respond to :attribute" do
+    allow(Admin).to receive(:respond_to?).with(:attribute).and_return(false)
+
+    ActiveRecord::MTI::Registry.tableoids[Admin] = nil
+
+    expect(Admin.using_multi_table_inheritance?).to eq(true)
   end
 
   context 'class definition' do
 
     describe 'for classes that use MTI' do
       it "doesn't check inheritance multiple times" do
-        Admin.instance_variable_set(:@mti_setup, false)
-        expect(Admin).to receive(:check_inheritance_of).and_call_original.exactly(1).times
+        # Due to the anonymous class ("god = Class.new(Admin)") rspec can't properly distinquish
+        # between the two classes. So at most 2 times!
+        expect(Admin).to receive(:check_inheritance_of).and_call_original.at_most(2).times
 
         Admin.create(email: 'foo@bar.baz', god_powers: 3)
         Admin.create(email: 'foo2@bar.baz', god_powers: 3)
         Admin.create(email: 'foo24@bar.baz', god_powers: 3)
+        Admin.create(email: 'foo246@bar.baz', god_powers: 3)
 
       end
     end
 
     describe "for classes that don't use MTI" do
       it "doesn't check inheritance multiple times" do
-        Post.instance_variable_set(:@uses_mti, nil)
+        # ActiveRecord::MTI::Inheritance.register(Post, false)
         expect(Post).to receive(:check_inheritance_of).and_call_original.exactly(1).times
 
         Post.create(title: 'foo@bar.baz')
@@ -73,19 +78,34 @@ describe ActiveRecord::MTI::Inheritance do
         god = Class.new(Admin)
         expect(god.table_name).to eql(Admin.table_name)
       end
+
+      it 'infers the table_name when defined dynamically' do
+
+        class Scrub < ActiveRecord::Base
+          const_set(:All, Class.new(Scrub) do |klass|
+            class_eval <<-AAA
+              self.table_name = 'scrubs/all'
+            AAA
+          end)
+        end
+
+        expect(Scrub::All.table_name).to eq('scrubs/all')
+      end
     end
   end
 
   describe 'views' do
     before(:each) do
+
+      User.connection.execute <<-SQL
+        CREATE OR REPLACE VIEW "users_all"
+        AS SELECT * FROM "users"
+      SQL
+
       class UserView < User
         self.table_name = "users_all"
       end
 
-      UserView.connection.execute <<-SQL
-        CREATE OR REPLACE VIEW "users_all"
-        AS #{ User.all.to_sql }
-      SQL
     end
 
     if ActiveRecord::Base.connection.version >= Gem::Version.new('9.4')
@@ -99,10 +119,7 @@ describe ActiveRecord::MTI::Inheritance do
   describe 'dynamic class creation' do
     it 'infers the table_name from superclass not base_class' do
       God = Class.new(Admin)
-
-      Hacker = Class.new(Admin) do
-        uses_mti
-      end
+      Hacker = Class.new(Admin)
 
       expect(God.table_name).to eql(Admin.table_name)
       expect(Hacker.table_name).to eql('admin/hackers')

data/spec/active_record/mti/model_schema_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe ActiveRecord::MTI::ModelSchema do
+
+  it 'rescues suffix' do
+    f = ActiveRecord::ModelSchema::ClassMethods
+    allow_any_instance_of(f).to receive(:full_table_name_suffix).and_raise(NoMethodError)
+    expect( Admin.full_table_name_suffix ).to eq("")
+  end
+
+end

data/spec/active_record/mti/schema_dumper_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe ActiveRecord::MTI::SchemaDumper do
+
+  before(:each) do
+    ActiveRecord::SchemaMigration.create_table
+  end
+
+  let(:hacker_sql) {
+<<-FOO
+  create_table "admin/hackers", inherits: 'admins' do |t|
+  end
+FOO
+  }
+
+  it 'does not dump indexes for child table' do
+    stream = StringIO.new
+    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+
+    expect(stream.string).to include(hacker_sql)
+  end
+end

data/spec/active_record/sti/inheritance_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe ActiveRecord::Inheritance do
+
+  context 'class definition' do
+
+    describe 'for classes that use STI' do
+      it "doesn't check inheritance multiple times" do
+
+        Transportation::Military::Vehicle.create(color: :red)
+        Transportation::Military::Vehicle.create(color: :blue)
+        Transportation::Military::Vehicle.create(color: :green)
+        Transportation::Military::Vehicle.create(color: :gold)
+
+        vehicle = Transportation::Military::Vehicle.first
+        expect(vehicle.class.name).to eq('Transportation::Military::Vehicle')
+        expect(vehicle.color).to eq('red')
+
+      end
+    end
+
+  end
+
+end

data/spec/schema.rb

@@ -1,8 +1,8 @@
 ActiveRecord::Schema.define do
   self.verbose = false
 
-  create_table :users, force: true do |t|
-    t.string :email
+  create_table :users, schema: :public, force: true do |t|
+    t.string :email, index: :btree
     t.timestamps null: false
   end
 

data/spec/spec_helper.rb

@@ -25,7 +25,7 @@ ActiveRecord::Base.establish_connection db_config
 
 load File.dirname(__FILE__) + '/schema.rb'
 
-Dir[File.join(File.dirname(__FILE__), '..', 'spec', 'support', '**', '**.rb')].each do |f|
+Dir[ActiveRecord::MTI.root.join('spec', 'support', '**', '**.rb')].each do |f|
   require f
 end
 

data/spec/support/models.rb

@@ -12,7 +12,6 @@ class Post < ::ActiveRecord::Base
 end
 
 class User < ::ActiveRecord::Base
-  uses_mti
 
   has_many :posts
   has_many :comments
@@ -25,10 +24,15 @@ end
 
 module Transportation
   class Vehicle < ::ActiveRecord::Base
-    uses_mti
   end
 
   class Truck < Vehicle
     self.table_name = 'vehicles/trucks'
   end
+
+  module Military
+    class Vehicle < ::Transportation::Vehicle
+      self.inheritance_column = 'type'
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_record-mti
 version: !ruby/object:Gem::Version
-  version: 0.3.0.pre.rc1
+  version: 0.3.0.pre.rc2
 platform: ruby
 authors:
 - Dale Stevens
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-13 00:00:00.000000000 Z
+date: 2017-11-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -116,11 +116,16 @@ files:
 - lib/active_record/mti/query_methods.rb
 - lib/active_record/mti/querying.rb
 - lib/active_record/mti/railtie.rb
+- lib/active_record/mti/registry.rb
 - lib/active_record/mti/schema_dumper.rb
 - lib/active_record/mti/version.rb
+- lib/core_ext/hash.rb
 - spec/active_record/calculations_spec.rb
-- spec/active_record/mti/inheritence_spec.rb
+- spec/active_record/mti/inheritance_spec.rb
+- spec/active_record/mti/model_schema_spec.rb
+- spec/active_record/mti/schema_dumper_spec.rb
 - spec/active_record/mti_spec.rb
+- spec/active_record/sti/inheritance_spec.rb
 - spec/schema.rb
 - spec/spec_helper.rb
 - spec/support/models.rb
@@ -146,14 +151,17 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: Multi Table Inheritance for PostgreSQL in Rails
 test_files:
 - spec/active_record/calculations_spec.rb
-- spec/active_record/mti/inheritence_spec.rb
+- spec/active_record/mti/inheritance_spec.rb
+- spec/active_record/mti/model_schema_spec.rb
+- spec/active_record/mti/schema_dumper_spec.rb
 - spec/active_record/mti_spec.rb
+- spec/active_record/sti/inheritance_spec.rb
 - spec/schema.rb
 - spec/spec_helper.rb
 - spec/support/models.rb