active_record-mti 0.3.2 → 0.4.0.pre.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 781df2afedf44dd2bdcc4014d8d2e165ebea29eaccea9360573941df5a937ef4
-  data.tar.gz: 544c4507ae2c1bbc25b59414b97579ac5cfe52b2c449fe7739ee17366bc76866
+  metadata.gz: e639bd5df85ba2ea0f83ed1b43b4429dd1a40ee627e2a43e17d329ce64c85486
+  data.tar.gz: 7c2103fc368f13f065a2004accfe8f0b83808446c12cc074c30b5bc588bb8f81
 SHA512:
-  metadata.gz: e70e8399e5c11b8b8d33fb914debaa072e5e9c7fad8e99aea01385426460a8d461e807be2b7dcea9a8d9aac3108607ad8c3ce17f2bcaacd295ab71b0487451f8
-  data.tar.gz: f51d31db93ba3c77d026eb673b4315e7e2d927584505eaea7c28e855aaf6978302ad2b05ec9dacd225cd5802bfbe46119033edc70cb7d65018e7c86c7dc12a0a
+  metadata.gz: b19553d393bf02d1292215d8d36bacdddb8d1f5901e8e0e184a4a3cb0e9b488c8d6f73fe9c827ad306742b60c206f6f55cd87641d455b7937eaaf0a1496905ed
+  data.tar.gz: ab4c52d72f15bef11c1ed261546bd43175a6f7a084e5b29f31c8cdf0bd3d0dd1de2ad8f2e67b5653baff6b8a783b7ce1d290a3400ec192d3623fd7256658d037

data/CHANGELOG.md

@@ -1,13 +1,15 @@
 # ActiveRecord::MTI
 
-## 0.3.2 _(July 15th 2018)_
-- 0.3.1 Yanked due to failing specs in spec matrix
-- Fixed issue causing fails
-
-## 0.3.1 ~_(July 15th 2018)_~ YANKED
+## 0.4.0 _(Unreleased)_
+- Major overhaul to improve injection hiegine and performance
+  - Refactored to improve inheritance detection at boot
+  - Simplified a lot of the core inheritence logic
+  - Improved Registry of parent/child tables
+- Removed `uses_mti`
+
+## 0.3.0 _(Unreleased)_
 - Greatly improved future-proofing injection strategy.
   - No longer overwriting (and maintaining) ActiveRecord Calculation sub-routines.
-  - Improve order of grouping and projection so other gems have more information to work with. (Like [`DeletedAt`](https://github.com/TwilightCoders/deleted_at))
 - Instead of injecting at `build_select`, we're injecting at `build_arel` with one additional new sub-routine (`build_mti`)
   - `build_mti` sub-routine detects if an MTI projection is needed based on grouping and selecting from query being built.
 - No longer need to use `uses_mti`

data/README.md

@@ -1,18 +1,22 @@
-[![Version      ](https://img.shields.io/gem/v/active_record-mti.svg?maxAge=2592000)](https://rubygems.org/gems/active_record-mti)
+[![Version      ](https://img.shields.io/gem/v/active_record-mti.svg)](https://rubygems.org/gems/active_record-mti)
 [![Build Status ](https://travis-ci.org/TwilightCoders/active_record-mti.svg)](https://travis-ci.org/TwilightCoders/active_record-mti)
 [![Code Climate ](https://api.codeclimate.com/v1/badges/27b02e09b5da0a7ed2fc/maintainability)](https://codeclimate.com/github/TwilightCoders/active_record-mti/maintainability)
 [![Test Coverage](https://codeclimate.com/github/TwilightCoders/active_record-mti/badges/coverage.svg)](https://codeclimate.com/github/TwilightCoders/active_record-mti/coverage)
-[![Dependencies ](https://gemnasium.com/badges/github.com/TwilightCoders/active_record-mti.svg)](https://gemnasium.com/github.com/TwilightCoders/active_record-mti)
 
 # ActiveRecord::MTI
 
 ActiveRecord support for PostgreSQL's native inherited tables (multi-table inheritance)
 
-Compatible with ActiveRecord `4.0`, `4.1`, `4.2`, `5.0`, `5.1`
+# Requirements
 
-Confirmed production use in `4.2`
+- Ruby `2.3`+
+- ActiveRecord `4.2`+
 
-## Usage
+**Confirmed Rails `4.2` use in production**
+
+_Note: Be sure to check the builds to be sure your version is in-fact supported. The requirements are left unbounded on the upper constraint for posterity, but may not be gaurenteed to work._
+
+## Installation
 
 Add this line to your application's Gemfile:
 
@@ -26,29 +30,62 @@ Or install it yourself as:
 
     $ gem install active_record-mti
 
-### Application Code
-
-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`.
+## Usage
 
 ```ruby
 class Account < ::ActiveRecord::Base
+  # table_name is 'accounts'
   # ...
 end
 
 class User < Account
+  # table_name is 'account/users'
   # ...
 end
 
 class Developer < Account
+  # table_name is 'account/developers'
+  # ...
+end
+
+class Admin < User
+  self.table_name = 'admins'
+  # ...
+end
+
+class Hacker < Developer
+  # table_name is 'account/developer/hackers'
   # ...
 end
 ```
 
+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 acquiesce to `ActiveRecord`'s built-in `STI`. _(see Table Names section below)_.
+
+### Queries
+
 `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
+### Table Names
+
+Conventionally—to indicate the nature of inheritance—`ActiveRecord::MTI` expects the `table_name` of a child model to follow the `singular_parent_table_name/plural_child_table_name` pattern. As always, if you need to deviate from this, you can explicitly set the `table_name` as shown below, or configure `ActiveRecord::MTI` using the configure block.
+
+Note, `ActiveRecord::MTI` will fall back on the unnested `table_name` if it's unable to find the nested form, and short of that, it will use the superclass's `table_name`.
+
+### Configuration
+`ActiveRecord::MTI` can be configured using a configure block.
+
+```ruby
+# config/initializers/active_record_mti.rb
+
+ActiveRecord::MTI.configure do |config|
+  config.table_name_nesting = true
+  config.nesting_seperator = '/'
+  config.singular_parent = true
+end
+```
+
 ### Migrations
 
 In your migrations define a table to inherit from another table:
@@ -103,7 +140,7 @@ end
 
 ## Contributing
 
-1. Fork it ( https://github.com/[my-github-username]/active_record-mti/fork )
+1. Fork it ( https://github.com/TwilightCoders/active_record-mti/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/lib/active_record/mti.rb

@@ -1,81 +1,81 @@
 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'
-require 'active_record/mti/calculations'
-require 'active_record/mti/connection_adapters/postgresql/schema_statements'
-require 'active_record/mti/connection_adapters/postgresql/adapter'
-
 require 'active_record/mti/railtie' if defined?(Rails::Railtie)
 
+require 'registry'
+require 'active_record/mti/config'
+require 'active_record/mti/table'
+require 'core_ext/thread'
+
 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
-
-    class << self
-      attr_writer :logger
+    mattr_accessor :oid_class do
+      begin
+        ActiveModel::Type::Integer
+      rescue NameError
+        ActiveRecord::Type::Integer
+      end
+    end
 
-      def logger
-        @logger ||= Logger.new($stdout).tap do |log|
-          log.progname = self.name
-          log.level = Logger::INFO
-        end
+    def self.child_tables
+      @child_tables ||= create_registry(ChildTable, SQL_FOR_CHILD_TABLES).tap do |r|
+        r.index(:name, :oid, :inhparent)
       end
     end
 
-    def self.root
-      @root ||= Pathname.new(File.expand_path('../../', File.dirname(__FILE__)))
+    def self.parent_tables
+      @parent_tables ||= create_registry(ParentTable, SQL_FOR_PARENT_TABLES).tap do |r|
+        r.index(:oid, :name)
+      end
     end
 
-    def self.load
-      ::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 :prepend, ConnectionAdapters::PostgreSQL::SchemaStatements
-      ::ActiveRecord::SchemaDumper.send                          :prepend, SchemaDumper
+    def self.postgresql_version
+      @postgresql_version ||= Gem::Version.new(ActiveRecord::Base.connection.execute(<<-SQL, 'SCHEMA').to_a.first['server_version'])
+        SHOW server_version;
+      SQL
     end
 
-    def self.testify(value)
-      value == true || value == 't' || value == 1 || value == '1'
+    def self.[](key)
+      registry[key]
     end
 
-    private
+    def self.[]=(key, value)
+      if (self[key] && value != nil)
+        raise "Already assigned"
+      else
+        registry[key]=value
+      end
+    end
 
-    mattr_accessor :oid_class_candidates
+  private
 
-    # Cannot assign default inside block because of rails 4.0
-    self.oid_class_candidates = [
-      '::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::OID::Integer', # 4.0, 4.1
-      '::ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Integer', # 4.2
-      '::ActiveRecord::Type::Integer' # 5.0, 5.1
-    ]
+    def self.registry
+      @registry ||= {}
+    end
 
-    def self.find_oid_class
-      oid_class_candidates.find(nil) { |klass|
-        begin
-          klass.constantize
-          true
-        rescue NameError
-          false
-        end
-      }.constantize
+    def self.create_registry(klass, sql)
+      Registry.new(ActiveRecord::Base.connection.execute(sql).to_a.map do |row|
+        klass.new(*row.values).freeze
+      end)
     end
 
-    self.oid_class = self.find_oid_class
+    ChildTable  = Struct.new(:inhrelid, :inhparent, :inhseqno, :oid, :name, :parent_table_name)
+    ParentTable = Struct.new(:oid, :name)
+
+    SQL_FOR_CHILD_TABLES = (<<-SQL).gsub(/\s+/, " ").strip
+      SELECT "pg_inherits".*, "child".oid AS oid, "child".relname AS name, "parent".relname AS parent_table_name
+        FROM "pg_inherits"
+        JOIN "pg_class" AS "child" ON ("child".oid = "pg_inherits".inhrelid)
+        JOIN "pg_class" AS "parent" ON ("parent".oid = "pg_inherits".inhparent)
+    SQL
+
+    SQL_FOR_PARENT_TABLES = (<<-SQL).gsub(/\s+/, " ").strip
+      SELECT DISTINCT("pg_class".oid) AS oid, "pg_class".relname AS name
+        FROM "pg_class", "pg_inherits"
+        WHERE "pg_class".oid = "pg_inherits".inhparent
+    SQL
 
+    private_constant :ChildTable, :ParentTable, :SQL_FOR_CHILD_TABLES, :SQL_FOR_PARENT_TABLES
   end
 end

data/lib/active_record/mti/config.rb

@@ -0,0 +1,26 @@
+module ActiveRecord
+  module MTI
+    class << self
+      attr_accessor :configuration
+    end
+
+    DEFAULT_CONFIG = {
+      table_name_nesting: true,
+      nesting_seperator: '/',
+      singular_parent: true,
+      prefix_parent: true,
+      suffix_parent: false,
+      namespace_depth: 0 # -1 for all
+    }
+
+    def self.reset_configuration
+      self.configuration = OpenStruct.new(DEFAULT_CONFIG)
+    end
+
+    self.reset_configuration
+
+    def self.configure
+      yield(configuration)
+    end
+  end
+end

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

@@ -3,13 +3,6 @@ module ActiveRecord
     module ConnectionAdapters
       module PostgreSQL
         module Adapter
-
-          def version
-            Gem::Version.new exec_query(<<-SQL, 'SCHEMA').rows.first.first
-              SHOW server_version;
-            SQL
-          end
-
           def column_definitions(table_name) # :nodoc:
             exec_query(<<-SQL, 'SCHEMA').rows
               SELECT a.attname, format_type(a.atttypid, a.atttypmod),
@@ -22,7 +15,6 @@ module ActiveRecord
               ORDER BY a.attnum
             SQL
           end
-
         end
       end
     end

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

@@ -1,3 +1,4 @@
+require 'active_support/core_ext/hash/slice'
 require 'active_record/connection_adapters/postgresql_adapter'
 
 module ActiveRecord
@@ -5,6 +6,7 @@ module ActiveRecord
     module ConnectionAdapters
       module PostgreSQL
         module SchemaStatements
+
           # Creates a new table with the name +table_name+. +table_name+ may either
           # be a String or a Symbol.
           #
@@ -21,29 +23,27 @@ module ActiveRecord
               options.delete(:primary_key)
             end
 
-            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))
               # options[:options] = options[:options].sub("INHERITS", "() INHERITS") if td.columns.empty?
-              options[:options] = [%Q(INHERITS ("#{inherited_table}")), options[:options]].compact.join
+              options[:options] = [%(INHERITS ("#{inherited_table}")), options[:options]].compact.join
             end
 
             results = super(table_name, options)
 
             if inherited_table
               inherited_table_primary_key = primary_key(inherited_table)
-              execute %Q(ALTER TABLE "#{table_name}" ADD PRIMARY KEY ("#{inherited_table_primary_key}"))
+              execute %(ALTER TABLE "#{table_name}" ADD PRIMARY KEY ("#{inherited_table_primary_key}"))
 
               indexes(inherited_table).each do |index|
-                attributes = index.to_h.slice(:unique, :using, :where, :orders)
+                attributes = index_attributes(index)
 
                 # Why rails insists on being inconsistant with itself is beyond me.
                 attributes[:order] = attributes.delete(:orders)
 
+                if (index_name = build_index_name(attributes.delete(:name), inherited_table, table_name))
+                  attributes[:name] = index_name
+                end
+
                 add_index table_name, index.columns, attributes
               end
             end
@@ -51,16 +51,35 @@ module ActiveRecord
             results
           end
 
+          def index_attributes(index)
+            [:unique, :using, :where, :orders, :name].inject({}) do |hash, attribute|
+              hash.tap do |h|
+                h[attribute] = index.send(attribute)
+              end
+            end
+          end
+
+          def build_index_name(index_name, inherited_table, table_name)
+            return unless index_name
+            schema_name, index_name = index_name.match(/((?<schema>.*)\.)?(?<index>.*)/).captures
+            if (index_name.match(inherited_table.to_s))
+              index_name.gsub!(inherited_table.to_s, table_name.to_s)
+            else
+              index_name = "#{table_name}/#{index_name}"
+            end
+            [schema_name, index_name].compact.join('.')
+          end
+
           # Parent of inherited table
           def parent_tables(table_name)
-            result = exec_query(<<-SQL, "SCHEMA")
+            result = exec_query(<<-SQL, 'SCHEMA')
               SELECT pg_namespace.nspname, pg_class.relname
               FROM pg_catalog.pg_inherits
                 INNER JOIN pg_catalog.pg_class ON (pg_inherits.inhparent = pg_class.oid)
                 INNER JOIN pg_catalog.pg_namespace ON (pg_class.relnamespace = pg_namespace.oid)
               WHERE inhrelid = '#{table_name}'::regclass
             SQL
-            result.map{|a| a['relname']}
+            result.map { |a| a['relname'] }
           end
 
           def parent_table(table_name)

data/lib/active_record/mti/core_extension.rb

@@ -0,0 +1,170 @@
+require 'active_support/concern'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/string/inflections'
+
+require 'active_record/mti/relation'
+
+module ActiveRecord
+  module MTI
+    module CoreExtension
+
+      def self.prepended(base)
+        base.singleton_class.prepend(ClassMethods)
+      end
+
+      module ClassMethods #:nodoc:
+
+        def sti_or_mti?
+          !abstract_class? && self != base_class
+        end
+
+        def mti?
+          !mti_table.nil?
+        end
+
+        def mti_table
+          reset_mti_table unless defined?(@mti_table)
+          @mti_table
+        end
+
+        def mti_table_name
+          mti_table&.name
+        end
+
+        def reset_mti_information
+          # This might be "dangerous" if other gems have modified them as well.
+          # It might be more prudent to call "inherited" which calls this as a
+          # shared injection point, to play nice with other gems. (DeletedAt?)
+          reinitialize_relation_delegate_cache
+
+          # ActiveRecord::MTI.registry[mti_table&.oid] = self # maybe follow schema_cache pattern for this stuff
+          # connection.mti_cache.clear_table_cache!(table_name)
+          # ActiveRecord::MTI.delete(mti_table.oid)
+          ActiveRecord::MTI[mti_table.oid] = nil if mti?
+          @mti_table                       = nil
+          @columns_hash&.delete("tableoid")
+        end
+
+        def reset_column_information
+          super.tap do
+            reset_mti_information
+          end
+        end
+
+        def tableoid?
+          !Thread.currently?(:skip_tableoid_cast) && mti?
+        end
+
+        def tableoid
+          mti_table&.oid
+        end
+
+        def mti_table=(value)
+          # if defined?(@mti_table)
+          #   return if value == @mti_table
+          #   reset_column_information if connected?
+          # end
+
+          @mti_table = value
+
+          if mti_table
+            self.attribute :tableoid, ActiveRecord::MTI.oid_class.new
+
+            # TODO: Use the list to retrieve ActiveRecord_Relation?
+            ActiveRecord::MTI.registry[mti_table.oid] = self
+
+            @relation_delegate_cache.each do |klass, delegate|
+              delegate.prepend(::ActiveRecord::MTI::Relation)
+            end
+          end
+        end
+
+        def table_name=(value)
+          super.tap do
+            reset_mti_table if connected?
+          end
+        end
+
+        # NOTE: 5.0+ only
+        def load_schema!
+          super.tap do |attributes|
+            add_tableoid_column if mti?
+          end
+        end
+
+        def reset_mti_table
+          mti_table_name = defined?(@table_name) ? @table_name : compute_mti_table_name
+          # mti_table_name = @table_name || compute_mti_table_name
+          self.mti_table = ActiveRecord::MTI::Table.find(self, mti_table_name)
+        end
+
+        def compute_table_name
+          mti_table_name || superclass.mti_table_name || super
+        end
+
+        def compute_mti_table_name
+          # contained = (parent_name || '').split('::').join('/') { |part| part.downcase.singularize }
+          if superclass < ::ActiveRecord::Base && !superclass.abstract_class?
+            contained = superclass.table_name
+            contained = contained.singularize if superclass.pluralize_table_names
+            contained += '/'
+          end
+          "#{full_table_name_prefix}#{contained}#{undecorated_table_name(name)}#{full_table_name_suffix}"
+        end
+
+        # Returns +true+ if this does not need STI type condition. Returns
+        # +false+ if STI type condition needs to be applied.
+        # def descends_from_active_record?
+        #   a = mti?
+        #   b = super
+        #   c = superclass.respond_to?(:descends_from_active_record?) ? superclass.descends_from_active_record? : true
+        #   # !(a || b || c) || !(!b || c) || (a && b && c)
+        #   (!a && !b && c) || b
+        # 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 (mti_class = ::ActiveRecord::MTI[record.delete('tableoid')])
+            mti_class.discriminate_class_for_record(record)
+          else
+            super
+          end
+        end
+
+        # Type condition only applies if it's STI, otherwise it's
+        # done for free by querying the inherited table in MTI
+
+      protected
+
+        def add_tableoid_column
+          # missing_columns = (attributes.keys - @columns_hash.keys)
+          # [column_name, type, default, notnull, oid, fmod, collation, comment]
+          # field = ["tableoid", "integer", nil, false, 23, -1]
+          # column = connection.send(:new_column_from_field, table_name, field)
+          # Until support for 5.0 is dropped, we need this, because the internal API changed.
+          column = ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn.new(
+            'tableoid',
+            nil,
+            23,
+            false,
+            table_name,
+            nil
+          )
+
+          columns_hash["tableoid"] ||= column
+        end
+
+        def reinitialize_relation_delegate_cache
+          @relation_delegate_cache.each do |klass, delegate|
+            mangled_name = klass.name.gsub("::".freeze, "_".freeze)
+            remove_const(mangled_name)
+          end
+          initialize_relation_delegate_cache
+        end
+
+      end
+    end
+  end
+end