chrono_model 3.0.1 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 222db0e6673e7171d44dac2163b5048ebf6b459c18fa2a2609a3051fce8c6591
-  data.tar.gz: 871fdf28717c85267e6b783f1f2d6ba3a24b1261e974e53a25de28d745bc8579
+  metadata.gz: 6465bfc1eca17fb499f1826a7b938969bc7306b388ac93bce746a09c75a2c1a4
+  data.tar.gz: 6958a3018c4a29dbd4b81a56c60bc02d4fc8696780b62fe1ec8778725152e12d
 SHA512:
-  metadata.gz: 0bf942259052f134ea38de898307a65f20a6b448d8e8ff99a09ae06cd751f9834e1eb22abd4498c880005b8fc91f44ecebea4702be8c174570c50027dce13a75
-  data.tar.gz: 2b894f82a0cb9687d59dca9c3427a854cf6dc02191a08df71a215dfc577a8d1dd58632d44eb179395f097aa7d2391a7c738968d0f4c68f16cc14fffd2d18e034
+  metadata.gz: 4f0cf88eb3e21ec2cee85ba744a426e5ab125a71c18e4c7cbe31b45cbb5198f8f8dcbd1e17b87766cf3b386ebaf789fcb9dfd5190bb7e47bf61c3d9824fda490
+  data.tar.gz: e852d433e7d5c28f69e50511d0f094ae16fcb0f28cfc825273485c607b6e5fb2adc6d9cc82f0ec78c680c6e07392f296bfa27afcfe54d05595c3ac04a1a9e2cb

data/README.md

@@ -1,8 +1,6 @@
 # Temporal database system on PostgreSQL using [updatable views][pg-updatable-views], [table inheritance][pg-table-inheritance] and [INSTEAD OF triggers][pg-instead-of-triggers].
 
 [![Build Status][build-status-badge]][build-status]
-[![Code Climate][code-analysis-badge]][code-analysis]
-[![Test Coverage][test-coverage-badge]][test-coverage]
 [![Gem Version][gem-version-badge]][gem-version]
 [![Inlinedocs][docs-analysis-badge]][docs-analysis]
 
@@ -67,24 +65,19 @@ All timestamps are _forcibly_ stored in as UTC, bypassing the
 * PostgreSQL >= 9.4
 * The `btree_gist` PostgreSQL extension
 
-With Homebrew:
-
-    brew install postgres
-
-With apt:
-
-    apt-get install postgresql-11
-
 ## Installation
 
 Add this line to your application's Gemfile:
 
-    gem 'chrono_model'
+```ruby
+gem 'chrono_model'
+```
 
 And then execute:
 
-    $ bundle
-
+```sh
+$ bundle
+```
 
 ## Configuration
 
@@ -99,10 +92,83 @@ development:
 Configure Active Record in your `config/application.rb` to use the `:sql` schema
 format:
 
-```rb
+```ruby
 config.active_record.schema_format = :sql
 ```
 
+## Database Permissions (PostgreSQL)
+
+ChronoModel creates and manages data in the `temporal` and `history` schemas. Your application database user needs appropriate privileges on these schemas and their objects.
+
+### Required Privileges
+
+Grant the following privileges to your application database user (replace `app_user` with your actual username):
+
+```sql
+-- Schema access
+GRANT USAGE ON SCHEMA temporal TO app_user;
+GRANT USAGE ON SCHEMA history TO app_user;
+
+-- Table privileges for existing objects
+GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA temporal TO app_user;
+GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA history TO app_user;
+
+-- Sequence privileges for existing objects
+GRANT USAGE, SELECT, UPDATE ON ALL SEQUENCES IN SCHEMA temporal TO app_user;
+GRANT USAGE, SELECT, UPDATE ON ALL SEQUENCES IN SCHEMA history TO app_user;
+
+-- Default privileges for future objects
+ALTER DEFAULT PRIVILEGES IN SCHEMA temporal GRANT SELECT, INSERT, UPDATE, DELETE ON TABLES TO app_user;
+ALTER DEFAULT PRIVILEGES IN SCHEMA history GRANT SELECT, INSERT, UPDATE, DELETE ON TABLES TO app_user;
+ALTER DEFAULT PRIVILEGES IN SCHEMA temporal GRANT USAGE, SELECT, UPDATE ON SEQUENCES TO app_user;
+ALTER DEFAULT PRIVILEGES IN SCHEMA history GRANT USAGE, SELECT, UPDATE ON SEQUENCES TO app_user;
+```
+
+### Quick Diagnostics
+
+You can verify your privileges are correctly set up by running these queries as your application user:
+
+```sql
+-- Check schema access
+SELECT 
+  schema_name,
+  has_schema_privilege(current_user, schema_name, 'USAGE') AS has_usage
+FROM information_schema.schemata 
+WHERE schema_name IN ('temporal', 'history');
+
+-- Check table privileges (run after creating temporal tables)
+SELECT 
+  schemaname,
+  tablename,
+  has_table_privilege(current_user, schemaname||'.'||tablename, 'SELECT') AS has_select,
+  has_table_privilege(current_user, schemaname||'.'||tablename, 'INSERT') AS has_insert,
+  has_table_privilege(current_user, schemaname||'.'||tablename, 'UPDATE') AS has_update,
+  has_table_privilege(current_user, schemaname||'.'||tablename, 'DELETE') AS has_delete
+FROM pg_tables 
+WHERE schemaname IN ('temporal', 'history');
+
+-- Check sequence privileges (run after creating temporal tables)
+SELECT 
+  schemaname,
+  sequencename,
+  has_sequence_privilege(current_user, schemaname||'.'||sequencename, 'USAGE') AS has_usage,
+  has_sequence_privilege(current_user, schemaname||'.'||sequencename, 'SELECT') AS has_select,
+  has_sequence_privilege(current_user, schemaname||'.'||sequencename, 'UPDATE') AS has_update
+FROM pg_sequences 
+WHERE schemaname IN ('temporal', 'history');
+```
+
+### Troubleshooting
+
+If you encounter these symptoms, check your database permissions:
+
+- **`ActiveRecord::UnknownPrimaryKey`** errors on temporalized models
+- **`Model.chrono?` returns `false`** for models that should be temporal
+- **Unexpected primary key or temporalization issues** during schema operations
+- **Permission denied errors** when ChronoModel tries to access temporal/history objects
+
+These issues often indicate insufficient privileges on the `temporal` and `history` schemas. Run the diagnostic queries above to identify missing privileges, then apply the appropriate `GRANT` statements.
+
 ## Schema creation
 
 ChronoModel hooks all `ActiveRecord::Migration` methods to make them temporal
@@ -121,7 +187,7 @@ view and all the trigger machinery. Every other housekeeping of the temporal
 structure is handled behind the scenes by the other schema statements. E.g.:
 
  * `rename_table`  - renames tables, views, sequences, indexes and triggers
- * `drop_table`    - drops the temporal table and all dependant objects
+ * `drop_table`    - drops the temporal table and all dependent objects
  * `add_column`    - adds the column to the current table and updates triggers
  * `rename_column` - renames the current table column and updates the triggers
  * `remove_column` - removes the current table column and updates the triggers
@@ -151,8 +217,7 @@ the `:validity` option:
 change_table :your_table, temporal: true, copy_data: true, validity: '1977-01-01'
 ```
 
-Please note that `change_table` requires you to use *old_style* `up` and
-`down` migrations. It cannot work with Rails 3-style `change` migrations.
+Please note that `change_table` requires you to use `up` and `down` migrations.
 
 
 ## Selective Journaling
@@ -192,10 +257,12 @@ occur (see https://github.com/ifad/chronomodel/issues/71).
 In such cases, ensure to add `no_journal: %w( your_counter_cache_column_name )`
 to your `create_table`. Example:
 
-    create_table 'sections', temporal: true, no_journal: %w( articles_count ) do |t|
-      t.string :name
-      t.integer :articles_count, default: 0
-    end
+```ruby
+create_table 'sections', temporal: true, no_journal: %w[articles_count] do |t|
+  t.string :name
+  t.integer :articles_count, default: 0
+end
+```
 
 ## Data querying
 
@@ -282,12 +349,12 @@ cannot be deleted.
 
 ChronoModel currently performs upgrades by dropping and re-creating the views
 that give access to current data. If you have built other database objects on
-these views, the upgrade cannot be performed automatically as the dependant
+these views, the upgrade cannot be performed automatically as the dependent
 objects must be dropped first.
 
 When booting, ChronoModel will issue a warning in your logs about the need of
 a structure upgrade. Structure usually changes across versions. In this case,
-you need to set up a rake task that drops your dependant objects, runs
+you need to set up a rake task that drops your dependent objects, runs
 ChronoModel.upgrade! and then re-creates them.
 
 A migration system should be introduced, but it is seen as overkill for now,
@@ -304,7 +371,9 @@ You need to connect as  a database superuser, because specs need to create the
 
 To run the full test suite, use
 
-    rake
+```sh
+$ rake
+```
 
 SQL queries are logged to `spec/debug.log`. If you want to see them in your
 output, set the `VERBOSE=true` environment variable.
@@ -313,7 +382,9 @@ Some tests check the nominal execution of rake tasks within a test Rails app,
 and those are quite time consuming. You can run the full ChronoModel tests
 only against ActiveRecord by using
 
-    rspec spec/chrono_model
+```sh
+$ rspec spec/chrono_model
+```
 
 Ensure to run the full test suite before pushing.
 
@@ -328,10 +399,6 @@ Ensure to run the full test suite before pushing.
    of an object at a specific point in time within the application could
    lead to inaccuracies.
 
- * Rails 4+ support requires disabling tsrange parsing support, as it
-   [is broken][r4-tsrange-broken] and [incomplete][r4-tsrange-incomplete]
-   as of now, mainly due to a [design clash with ruby][pg-tsrange-and-ruby].
-
  * The triggers and temporal indexes cannot be saved in schema.rb. The AR
    schema dumper is quite basic, and it isn't (currently) extensible.
    As we're using many database-specific features, Chronomodel forces the
@@ -350,9 +417,6 @@ Ensure to run the full test suite before pushing.
 
  * Foreign keys are not supported. [See issue #174][gh-issue-174]
 
- * There may be unexpected results when combining eager loading and joins.
-  [See issue #186][gh-issue-186]
-
  * Global ID ignores historical objects. [See issue #192][gh-issue-192]
 
  * Different historical objects are considered the identical. [See issue
@@ -362,6 +426,12 @@ Ensure to run the full test suite before pushing.
    creates a new record for each modification. This will lead to increased
    storage requirements and bloated history
 
+ * `*_by_sql` query methods are not supported. [See issue #313][gh-issue-313]
+
+ * `self.table_name` must be set before `include ChronoModel::TimeMachine`.
+   [See issue #336][gh-issue-336]
+
+
 ## Contributing
 
  1. Fork it
@@ -386,14 +456,10 @@ This software is Made in Italy :it: :smile:.
 
 [build-status]: https://github.com/ifad/chronomodel/actions
 [build-status-badge]: https://github.com/ifad/chronomodel/actions/workflows/ruby.yml/badge.svg
-[code-analysis]: https://codeclimate.com/github/ifad/chronomodel/maintainability
-[code-analysis-badge]: https://api.codeclimate.com/v1/badges/cdee7327938dc2eaff99/maintainability
 [docs-analysis]: https://inch-ci.org/github/ifad/chronomodel
 [docs-analysis-badge]: https://inch-ci.org/github/ifad/chronomodel.svg?branch=master
 [gem-version]: https://rubygems.org/gems/chrono_model
 [gem-version-badge]: https://badge.fury.io/rb/chrono_model.svg
-[test-coverage]: https://codeclimate.com/github/ifad/chronomodel
-[test-coverage-badge]: https://codeclimate.com/github/ifad/chronomodel/badges/coverage.svg
 
 [delorean-image]: https://i.imgur.com/DD77F4s.jpg
 
@@ -412,7 +478,6 @@ This software is Made in Italy :it: :smile:.
 [pg-exclusion-constraints]: https://www.postgresql.org/docs/9.4/sql-createtable.html#SQL-CREATETABLE-EXCLUDE
 [pg-btree-gist]: https://www.postgresql.org/docs/9.4/btree-gist.html
 [pg-comment]: https://www.postgresql.org/docs/9.4/sql-comment.html
-[pg-tsrange-and-ruby]: https://bugs.ruby-lang.org/issues/6864
 [pg-ctes]: https://www.postgresql.org/docs/9.4/queries-with.html
 [pg-cte-optimization-fence]: https://www.postgresql.org/message-id/201209191305.44674.db@kavod.com
 [pg-cte-opt-out-fence]: https://www.postgresql.org/message-id/CAHyXU0zpM5+Dsb_pKxDmm-ZoWUAt=SkHHaiK_DBqcmtxTas6Nw@mail.gmail.com
@@ -420,15 +485,13 @@ This software is Made in Italy :it: :smile:.
 [pg-json-func]: https://www.postgresql.org/docs/9.4/functions-json.html
 [pg-json-opclass]: https://github.com/ifad/chronomodel/blob/master/sql/json_ops.sql
 
-[r4-tsrange-broken]: https://github.com/rails/rails/pull/13793#issuecomment-34608093
-[r4-tsrange-incomplete]: https://github.com/rails/rails/issues/14010
-
 [cm-readme-sql]: https://github.com/ifad/chronomodel/blob/master/README.sql
 [cm-timemachine]: https://github.com/ifad/chronomodel/blob/master/lib/chrono_model/time_machine.rb
 [cm-cte-impl]: https://github.com/ifad/chronomodel/commit/18f4c4b
 
 [gh-pzac]: https://github.com/pzac
 [gh-issue-174]: https://github.com/ifad/chronomodel/issues/174
-[gh-issue-186]: https://github.com/ifad/chronomodel/issues/186
 [gh-issue-192]: https://github.com/ifad/chronomodel/issues/192
 [gh-issue-206]: https://github.com/ifad/chronomodel/issues/206
+[gh-issue-313]: https://github.com/ifad/chronomodel/issues/313
+[gh-issue-336]: https://github.com/ifad/chronomodel/issues/336

data/lib/active_record/connection_adapters/chronomodel_adapter.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'chrono_model'
+require_relative '../../chrono_model'
 
 module ActiveRecord
   # TODO: Remove when dropping Rails < 7.2 compatibility

data/lib/active_record/tasks/chronomodel_database_tasks.rb

@@ -32,7 +32,7 @@ module ActiveRecord
         args = ['-c', '-f', target.to_s]
         args << chronomodel_configuration[:database]
 
-        run_cmd 'pg_dump', args, 'dumping data'
+        run_cmd_with_compatibility('pg_dump', args, 'dumping data')
       end
 
       def data_load(source)
@@ -41,7 +41,7 @@ module ActiveRecord
         args = ['-f', source]
         args << chronomodel_configuration[:database]
 
-        run_cmd 'psql', args, 'loading data'
+        run_cmd_with_compatibility('psql', args, 'loading data')
       end
 
       private
@@ -50,6 +50,19 @@ module ActiveRecord
         @chronomodel_configuration ||= @configuration_hash
       end
 
+      # TODO: replace `run_cmd_with_compatibility` with `run_cmd` and remove when dropping Rails < 8.1 support
+      # Compatibility method to handle Rails version differences in run_cmd signature
+      # Rails < 8.1: run_cmd(cmd, args, action)
+      # Rails >= 8.1: run_cmd(cmd, *args, **opts)
+      def run_cmd_with_compatibility(cmd, args, action_description)
+        # Check if run_cmd method accepts keyword arguments (new signature)
+        if method(:run_cmd).parameters.any? { |type, _name| type == :rest }
+          run_cmd(cmd, *args)
+        else
+          run_cmd(cmd, args, action_description)
+        end
+      end
+
       # If a schema search path is defined in the configuration file, it will
       # be used by the database tasks class to dump only the specified search
       # path. Here we add also ChronoModel's temporal and history schemas to

data/lib/chrono_model/adapter/ddl.rb

@@ -55,12 +55,12 @@ module ChronoModel
         parent = "#{TEMPORAL_SCHEMA}.#{table}"
         p_pkey = primary_key(parent)
 
-        execute <<-SQL.squish
-            CREATE TABLE #{table} (
-              hid         BIGSERIAL PRIMARY KEY,
-              validity    tsrange NOT NULL,
-              recorded_at timestamp NOT NULL DEFAULT timezone('UTC', now())
-            ) INHERITS ( #{parent} )
+        execute <<~SQL.squish
+          CREATE TABLE #{table} (
+            hid         BIGSERIAL PRIMARY KEY,
+            validity    tsrange NOT NULL,
+            recorded_at timestamp NOT NULL DEFAULT timezone('UTC', now())
+          ) INHERITS (#{parent})
         SQL
 
         add_history_validity_constraint(table, p_pkey)
@@ -85,11 +85,11 @@ module ChronoModel
         execute <<-SQL.strip_heredoc # rubocop:disable Rails/SquishedSQLHeredocs,Rails/StripHeredoc
             CREATE OR REPLACE FUNCTION chronomodel_#{table}_insert() RETURNS TRIGGER AS $$
                 BEGIN
-                    #{insert_sequence_sql(pk, current)} INTO #{current} ( #{pk}, #{fields} )
-                    VALUES ( NEW.#{pk}, #{values} );
+                    #{insert_sequence_sql(pk, current)} INTO #{current} (#{pk}, #{fields})
+                    VALUES (NEW.#{pk}, #{values});
 
-                    INSERT INTO #{history} ( #{pk}, #{fields}, validity )
-                    VALUES ( NEW.#{pk}, #{values}, tsrange(timezone('UTC', now()), NULL) );
+                    INSERT INTO #{history} (#{pk}, #{fields}, validity)
+                    VALUES (NEW.#{pk}, #{values}, tsrange(timezone('UTC', now()), NULL));
 
                     RETURN NEW;
                 END;
@@ -150,7 +150,7 @@ module ChronoModel
                     _new := row(#{journal.map { |c| "NEW.#{c}" }.join(', ')});
 
                     IF _old IS NOT DISTINCT FROM _new THEN
-                        UPDATE ONLY #{current} SET ( #{fields} ) = ( #{values} ) WHERE #{pk} = OLD.#{pk};
+                        UPDATE ONLY #{current} SET (#{fields}) = (#{values}) WHERE #{pk} = OLD.#{pk};
                         RETURN NEW;
                     END IF;
 
@@ -160,16 +160,16 @@ module ChronoModel
                     #{"SELECT hid INTO _hid FROM #{history} WHERE #{pk} = OLD.#{pk} AND lower(validity) = _now;" unless ENV['CHRONOMODEL_NO_SQUASH']}
 
                     IF _hid IS NOT NULL THEN
-                        UPDATE #{history} SET ( #{fields} ) = ( #{values} ) WHERE hid = _hid;
+                        UPDATE #{history} SET (#{fields}) = (#{values}) WHERE hid = _hid;
                     ELSE
                         UPDATE #{history} SET validity = tsrange(lower(validity), _now)
                         WHERE #{pk} = OLD.#{pk} AND upper_inf(validity);
 
-                        INSERT INTO #{history} ( #{pk}, #{fields}, validity )
-                            VALUES ( OLD.#{pk}, #{values}, tsrange(_now, NULL) );
+                        INSERT INTO #{history} (#{pk}, #{fields}, validity)
+                            VALUES (OLD.#{pk}, #{values}, tsrange(_now, NULL));
                     END IF;
 
-                    UPDATE ONLY #{current} SET ( #{fields} ) = ( #{values} ) WHERE #{pk} = OLD.#{pk};
+                    UPDATE ONLY #{current} SET (#{fields}) = (#{values}) WHERE #{pk} = OLD.#{pk};
 
                     RETURN NEW;
                 END;
@@ -234,7 +234,6 @@ module ChronoModel
                     INSERT
         SQL
       end
-      # private
     end
   end
 end

data/lib/chrono_model/adapter/indexes.rb

@@ -24,15 +24,13 @@ module ChronoModel
           temporal_index_names(table, range, options)
 
         chrono_alter_index(table, options) do
-          execute <<-SQL.squish
-            CREATE INDEX #{range_idx} ON #{table} USING gist ( #{range} )
-          SQL
+          execute "CREATE INDEX #{range_idx} ON #{table} USING gist (#{range})"
 
           # Indexes used for precise history filtering, sorting and, in history
           # tables, by UPDATE / DELETE triggers.
           #
-          execute "CREATE INDEX #{lower_idx} ON #{table} ( lower(#{range}) )"
-          execute "CREATE INDEX #{upper_idx} ON #{table} ( upper(#{range}) )"
+          execute "CREATE INDEX #{lower_idx} ON #{table} (lower(#{range}))"
+          execute "CREATE INDEX #{upper_idx} ON #{table} (upper(#{range}))"
         end
       end
 
@@ -53,9 +51,9 @@ module ChronoModel
         id   = options[:id] || primary_key(table)
 
         chrono_alter_constraint(table, options) do
-          execute <<-SQL.squish
+          execute <<~SQL.squish
             ALTER TABLE #{table} ADD CONSTRAINT #{name}
-              EXCLUDE USING gist ( #{id} WITH =, #{range} WITH && )
+              EXCLUDE USING gist (#{id} WITH =, #{range} WITH &&)
           SQL
         end
       end
@@ -64,7 +62,7 @@ module ChronoModel
         name = timeline_consistency_constraint_name(table)
 
         chrono_alter_constraint(table, options) do
-          execute <<-SQL.squish
+          execute <<~SQL.squish
             ALTER TABLE #{table} DROP CONSTRAINT #{name}
           SQL
         end
@@ -81,9 +79,9 @@ module ChronoModel
       def chrono_create_history_indexes_for(table, p_pkey)
         add_temporal_indexes table, :validity, on_current_schema: true
 
-        execute "CREATE INDEX #{table}_inherit_pkey     ON #{table} ( #{p_pkey} )"
-        execute "CREATE INDEX #{table}_recorded_at      ON #{table} ( recorded_at )"
-        execute "CREATE INDEX #{table}_instance_history ON #{table} ( #{p_pkey}, recorded_at )"
+        execute "CREATE INDEX #{table}_inherit_pkey     ON #{table} (#{p_pkey})"
+        execute "CREATE INDEX #{table}_recorded_at      ON #{table} (recorded_at)"
+        execute "CREATE INDEX #{table}_instance_history ON #{table} (#{p_pkey}, recorded_at)"
       end
 
       # Rename indexes on history schema
@@ -144,10 +142,10 @@ module ChronoModel
             #
             columns = Array.wrap(index.columns).join(', ')
 
-            execute %[
-                CREATE INDEX #{index.name} ON #{table_name}
-                USING #{index.using} ( #{columns} )
-              ], 'Copy index from temporal to history'
+            execute <<~SQL.squish, 'Copy index from temporal to history'
+              CREATE INDEX #{index.name} ON #{table_name}
+              USING #{index.using} (#{columns})
+            SQL
           end
         end
       end

data/lib/chrono_model/adapter/migrations.rb

@@ -84,7 +84,7 @@ module ChronoModel
             end
 
           else
-            if is_chrono?(table_name)
+            if is_chrono?(table_name) && options[:temporal] == false
               chrono_undo_temporal_table(table_name)
             end
 
@@ -214,14 +214,14 @@ module ChronoModel
         seq  = on_history_schema { pk_and_sequence_for(table_name).last.to_s }
         from = options[:validity] || '0001-01-01 00:00:00'
 
-        execute %[
-              INSERT INTO #{HISTORY_SCHEMA}.#{table_name}
-              SELECT *,
-                nextval('#{seq}')        AS hid,
-                tsrange('#{from}', NULL) AS validity,
-                timezone('UTC', now())   AS recorded_at
-              FROM #{TEMPORAL_SCHEMA}.#{table_name}
-          ]
+        execute <<~SQL.squish
+          INSERT INTO #{HISTORY_SCHEMA}.#{table_name}
+          SELECT *,
+            nextval('#{seq}')        AS hid,
+            tsrange('#{from}', NULL) AS validity,
+            timezone('UTC', now())   AS recorded_at
+          FROM #{TEMPORAL_SCHEMA}.#{table_name}
+        SQL
       end
 
       # Removes temporal features from this table
@@ -252,8 +252,6 @@ module ChronoModel
         execute "ALTER SEQUENCE #{seq}  RENAME TO #{new_seq}"
         execute "ALTER TABLE    #{name} RENAME TO #{new_name}"
       end
-
-      # private
     end
   end
 end

data/lib/chrono_model/adapter/migrations_modules/stable.rb

@@ -17,7 +17,7 @@ module ChronoModel
             # Uniqueness constraints do not make sense in the history table
             options = options.dup.tap { |o| o.delete(:unique) } if options[:unique].present?
 
-            on_history_schema { super(table_name, column_name, **options) }
+            on_history_schema { super }
           end
         end
 

data/lib/chrono_model/adapter/upgrade.rb

@@ -42,7 +42,7 @@ module ChronoModel
         return if upgrade.empty?
 
         logger.warn 'ChronoModel: There are tables needing a structure upgrade, and ChronoModel structures need to be recreated.'
-        logger.warn 'ChronoModel: Please run ChronoModel.upgrade! to attempt the upgrade. If you have dependant database objects'
+        logger.warn 'ChronoModel: Please run ChronoModel.upgrade! to attempt the upgrade. If you have dependent database objects'
         logger.warn 'ChronoModel: the upgrade will fail and you have to drop the dependent objects, run .upgrade! and create them'
         logger.warn 'ChronoModel: again. Sorry. Some features or the whole library may not work correctly until upgrade is complete.'
         logger.warn "ChronoModel: Tables pending upgrade: #{upgrade}"
@@ -81,12 +81,12 @@ module ChronoModel
         p_pkey = primary_key(table_name)
 
         execute "ALTER TABLE #{history_table} ADD COLUMN validity tsrange;"
-        execute <<-SQL.squish
-            UPDATE #{history_table} SET validity = tsrange(valid_from,
-                CASE WHEN extract(year from valid_to) = 9999 THEN NULL
-                     ELSE valid_to
-                END
-            );
+        execute <<~SQL.squish
+          UPDATE #{history_table} SET validity = tsrange(valid_from,
+              CASE WHEN extract(year from valid_to) = 9999 THEN NULL
+                   ELSE valid_to
+              END
+          );
         SQL
 
         execute "DROP INDEX #{history_table}_temporal_on_valid_from;"
@@ -112,7 +112,6 @@ module ChronoModel
         on_history_schema { add_history_validity_constraint(table_name, p_pkey) }
         on_history_schema { chrono_create_history_indexes_for(table_name, p_pkey) }
       end
-      # private
     end
   end
 end

data/lib/chrono_model/adapter.rb

@@ -2,13 +2,12 @@
 
 require 'active_record/connection_adapters/postgresql_adapter'
 
-require 'chrono_model/adapter/migrations'
-require 'chrono_model/adapter/migrations_modules/stable'
+require_relative 'adapter/migrations'
+require_relative 'adapter/migrations_modules/stable'
 
-require 'chrono_model/adapter/ddl'
-require 'chrono_model/adapter/indexes'
-require 'chrono_model/adapter/tsrange'
-require 'chrono_model/adapter/upgrade'
+require_relative 'adapter/ddl'
+require_relative 'adapter/indexes'
+require_relative 'adapter/upgrade'
 
 module ChronoModel
   # This class implements all ActiveRecord::ConnectionAdapters::SchemaStatements
@@ -19,7 +18,6 @@ module ChronoModel
     include ChronoModel::Adapter::Migrations
     include ChronoModel::Adapter::DDL
     include ChronoModel::Adapter::Indexes
-    include ChronoModel::Adapter::TSRange
     include ChronoModel::Adapter::Upgrade
 
     # The schema holding current data
@@ -89,15 +87,10 @@ module ChronoModel
     # The default search path is included however, since the table
     # may reference types defined in other schemas, which result in their
     # names becoming schema qualified, which will cause type resolutions to fail.
-    #
-    # NOTE: This method is dynamically defined, see the source.
-    #
-    def column_definitions; end
-
-    define_method(:column_definitions) do |table_name|
-      return super(table_name) unless is_chrono?(table_name)
+    def column_definitions(table_name)
+      return super unless is_chrono?(table_name)
 
-      on_schema("#{TEMPORAL_SCHEMA},#{schema_search_path}", recurse: :ignore) { super(table_name) }
+      on_schema("#{TEMPORAL_SCHEMA},#{schema_search_path}", recurse: :ignore) { super }
     end
 
     # Evaluates the given block in the temporal schema.
@@ -172,7 +165,7 @@ module ChronoModel
     def chrono_metadata_set(view_name, metadata)
       comment = MultiJson.dump(metadata)
 
-      execute %( COMMENT ON VIEW #{view_name} IS #{quote(comment)} )
+      execute "COMMENT ON VIEW #{view_name} IS #{quote(comment)}"
     end
 
     def valid_table_definition_options

data/lib/chrono_model/conversions.rb

@@ -4,21 +4,6 @@ module ChronoModel
   module Conversions
     module_function
 
-    ISO_DATETIME = /\A(\d{4})-(\d\d)-(\d\d) (\d\d):(\d\d):(\d\d)(?:\.(\d+))?\z/
-
-    # rubocop:disable Style/PerlBackrefs
-    def string_to_utc_time(string)
-      return string if string.is_a?(Time)
-
-      return unless string =~ ISO_DATETIME
-
-      # .1 is .100000, not .000001
-      usec = $7.ljust(6, '0') unless $7.nil?
-
-      Time.utc $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, usec.to_i
-    end
-    # rubocop:enable Style/PerlBackrefs
-
     def time_to_utc_string(time)
       time.to_fs(:db) << '.' << format('%06d', time.usec)
     end

data/lib/chrono_model/db_console.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-require 'chrono_model/patches/db_console'
+require_relative 'patches/db_console'
 
 Rails::DBConsole.prepend ChronoModel::Patches::DBConsole::DbConfig

data/lib/chrono_model/patches/association.rb

@@ -11,10 +11,6 @@ module ChronoModel
     # on the join model's (:through association) one.
     #
     module Association
-      def skip_statement_cache?(*)
-        super || _chrono_target?
-      end
-
       # If the association class or the through association are ChronoModels,
       # then fetches the records from a virtual table using a subquery scope
       # to a specific timestamp.
@@ -36,6 +32,10 @@ module ChronoModel
 
       private
 
+      def skip_statement_cache?(*)
+        super || _chrono_target?
+      end
+
       def _chrono_record?
         owner.class.include?(ChronoModel::Patches::AsOfTimeHolder) && owner.as_of_time.present?
       end