chrono_model 1.2.2 → 2.0.0

data/lib/chrono_model/adapter/migrations.rb

@@ -1,16 +1,17 @@
+# frozen_string_literal: true
+
 module ChronoModel
   class Adapter < ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
-
     module Migrations
       # Creates the given table, possibly creating the temporal schema
       # objects if the `:temporal` option is given and set to true.
       #
-      def create_table(table_name, options = {})
+      def create_table(table_name, **options)
         # No temporal features requested, skip
         return super unless options[:temporal]
 
         if options[:id] == false
-          logger.warn "ChronoModel: Temporal Temporal tables require a primary key."
+          logger.warn 'ChronoModel: Temporal Temporal tables require a primary key.'
           logger.warn "ChronoModel: Adding a `__chrono_id' primary key to #{table_name} definition."
 
           options[:id] = '__chrono_id'
@@ -26,8 +27,12 @@ module ChronoModel
 
       # If renaming a temporal table, rename the history and view as well.
       #
-      def rename_table(name, new_name)
-        return super unless is_chrono?(name)
+      def rename_table(name, new_name, **options)
+        unless is_chrono?(name)
+          return super(name, new_name) if method(:rename_table).super_method.arity == 2
+
+          return super
+        end
 
         clear_cache!
 
@@ -63,38 +68,35 @@ module ChronoModel
       # features on the given table. Please note that you'll lose your history
       # when demoting a temporal table to a plain one.
       #
-      def change_table(table_name, options = {}, &block)
+      def change_table(table_name, **options, &block)
         transaction do
-
           # Add an empty proc to support calling change_table without a block.
           #
-          block ||= proc { }
+          block ||= proc {}
 
-          case options[:temporal]
-          when true
-            if !is_chrono?(table_name)
+          if options[:temporal]
+            unless is_chrono?(table_name)
               chrono_make_temporal_table(table_name, options)
             end
 
             drop_and_recreate_public_view(table_name, options) do
-              super table_name, options, &block
+              super(table_name, **options, &block)
             end
 
-          when false
+          else
             if is_chrono?(table_name)
               chrono_undo_temporal_table(table_name)
             end
 
-            super table_name, options, &block
+            super(table_name, **options, &block)
           end
-
         end
       end
 
       # If dropping a temporal table, drops it from the temporal schema
       # adding the CASCADE option so to delete the history, view and triggers.
       #
-      def drop_table(table_name, *)
+      def drop_table(table_name, **options)
         return super unless is_chrono?(table_name)
 
         on_temporal_schema { execute "DROP TABLE #{table_name} CASCADE" }
@@ -102,39 +104,10 @@ module ChronoModel
         chrono_drop_trigger_functions_for(table_name)
       end
 
-      # If adding an index to a temporal table, add it to the one in the
-      # temporal schema and to the history one. If the `:unique` option is
-      # present, it is removed from the index created in the history table.
-      #
-      def add_index(table_name, column_name, options = {})
-        return super unless is_chrono?(table_name)
-
-        transaction do
-          on_temporal_schema { super }
-
-          # 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 }
-        end
-      end
-
-      # If removing an index from a temporal table, remove it both from the
-      # temporal and the history schemas.
-      #
-      def remove_index(table_name, *)
-        return super unless is_chrono?(table_name)
-
-        transaction do
-          on_temporal_schema { super }
-          on_history_schema { super }
-        end
-      end
-
       # If adding a column to a temporal table, creates it in the table in
       # the temporal schema and updates the triggers.
       #
-      def add_column(table_name, *)
+      def add_column(table_name, column_name, type, **options)
         return super unless is_chrono?(table_name)
 
         transaction do
@@ -166,8 +139,9 @@ module ChronoModel
       # view, then change the column from the table in the temporal schema and
       # eventually recreate the triggers.
       #
-      def change_column(table_name, *)
+      def change_column(table_name, column_name, type, **options)
         return super unless is_chrono?(table_name)
+
         drop_and_recreate_public_view(table_name) { super }
       end
 
@@ -175,6 +149,7 @@ module ChronoModel
       #
       def change_column_default(table_name, *)
         return super unless is_chrono?(table_name)
+
         on_temporal_schema { super }
       end
 
@@ -182,6 +157,7 @@ module ChronoModel
       #
       def change_column_null(table_name, *)
         return super unless is_chrono?(table_name)
+
         on_temporal_schema { super }
       end
 
@@ -189,54 +165,56 @@ module ChronoModel
       # view, then drop the column from the table in the temporal schema and
       # eventually recreate the triggers.
       #
-      def remove_column(table_name, *)
+      def remove_column(table_name, column_name, type = nil, **options)
         return super unless is_chrono?(table_name)
+
         drop_and_recreate_public_view(table_name) { super }
       end
 
       private
-        # In destructive changes, such as removing columns or changing column
-        # types, the view must be dropped and recreated, while the change has
-        # to be applied to the table in the temporal schema.
-        #
-        def drop_and_recreate_public_view(table_name, opts = {})
-          transaction do
-            options = chrono_metadata_for(table_name).merge(opts)
-
-            execute "DROP VIEW #{table_name}"
 
-            on_temporal_schema { yield }
+      # In destructive changes, such as removing columns or changing column
+      # types, the view must be dropped and recreated, while the change has
+      # to be applied to the table in the temporal schema.
+      #
+      def drop_and_recreate_public_view(table_name, opts = {}, &block)
+        transaction do
+          options = chrono_metadata_for(table_name).merge(opts)
 
-            # Recreate the triggers
-            chrono_public_view_ddl(table_name, options)
-          end
-        end
+          execute "DROP VIEW #{table_name}"
 
-        def chrono_make_temporal_table(table_name, options)
-          # Add temporal features to this table
-          #
-          if !primary_key(table_name)
-            execute "ALTER TABLE #{table_name} ADD __chrono_id SERIAL PRIMARY KEY"
-          end
+          on_temporal_schema(&block)
 
-          execute "ALTER TABLE #{table_name} SET SCHEMA #{TEMPORAL_SCHEMA}"
-          on_history_schema { chrono_history_table_ddl(table_name) }
+          # Recreate the triggers
           chrono_public_view_ddl(table_name, options)
-          chrono_copy_indexes_to_history(table_name)
+        end
+      end
 
-          # Optionally copy the plain table data, setting up history
-          # retroactively.
-          #
-          if options[:copy_data]
-            chrono_copy_temporal_to_history(table_name, options)
-          end
+      def chrono_make_temporal_table(table_name, options)
+        # Add temporal features to this table
+        #
+        unless primary_key(table_name)
+          execute "ALTER TABLE #{table_name} ADD __chrono_id SERIAL PRIMARY KEY"
         end
 
-        def chrono_copy_temporal_to_history(table_name, options)
-          seq  = on_history_schema { serial_sequence(table_name, primary_key(table_name)) }
-          from = options[:validity] || '0001-01-01 00:00:00'
+        execute "ALTER TABLE #{table_name} SET SCHEMA #{TEMPORAL_SCHEMA}"
+        on_history_schema { chrono_history_table_ddl(table_name) }
+        chrono_public_view_ddl(table_name, options)
+        chrono_copy_indexes_to_history(table_name)
+
+        # Optionally copy the plain table data, setting up history
+        # retroactively.
+        #
+        return unless options[:copy_data]
+
+        chrono_copy_temporal_to_history(table_name, options)
+      end
+
+      def chrono_copy_temporal_to_history(table_name, options)
+        seq  = on_history_schema { pk_and_sequence_for(table_name).last.to_s }
+        from = options[:validity] || '0001-01-01 00:00:00'
 
-          execute %[
+        execute %[
               INSERT INTO #{HISTORY_SCHEMA}.#{table_name}
               SELECT *,
                 nextval('#{seq}')        AS hid,
@@ -244,39 +222,38 @@ module ChronoModel
                 timezone('UTC', now())   AS recorded_at
               FROM #{TEMPORAL_SCHEMA}.#{table_name}
           ]
-        end
-
-        # Removes temporal features from this table
-        #
-        def chrono_undo_temporal_table(table_name)
-          execute "DROP VIEW #{table_name}"
+      end
 
-          chrono_drop_trigger_functions_for(table_name)
+      # Removes temporal features from this table
+      #
+      def chrono_undo_temporal_table(table_name)
+        execute "DROP VIEW #{table_name}"
 
-          on_history_schema { execute "DROP TABLE #{table_name}" }
+        chrono_drop_trigger_functions_for(table_name)
 
-          default_schema = select_value 'SELECT current_schema()'
-          on_temporal_schema do
-            if primary_key(table_name) == '__chrono_id'
-              execute "ALTER TABLE #{table_name} DROP __chrono_id"
-            end
+        on_history_schema { execute "DROP TABLE #{table_name}" }
 
-            execute "ALTER TABLE #{table_name} SET SCHEMA #{default_schema}"
+        default_schema = select_value 'SELECT current_schema()'
+        on_temporal_schema do
+          if primary_key(table_name) == '__chrono_id'
+            execute "ALTER TABLE #{table_name} DROP __chrono_id"
           end
+
+          execute "ALTER TABLE #{table_name} SET SCHEMA #{default_schema}"
         end
+      end
 
-        # Renames a table and its primary key sequence name
-        #
-        def rename_table_and_pk(name, new_name)
-          seq     = serial_sequence(name, primary_key(name))
-          new_seq = seq.sub(name.to_s, new_name.to_s).split('.').last
+      # Renames a table and its primary key sequence name
+      #
+      def rename_table_and_pk(name, new_name)
+        seq     = pk_and_sequence_for(name).last.to_s
+        new_seq = seq.sub(name.to_s, new_name.to_s).split('.').last
 
-          execute "ALTER SEQUENCE #{seq}  RENAME TO #{new_seq}"
-          execute "ALTER TABLE    #{name} RENAME TO #{new_name}"
-        end
+        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/legacy.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module ChronoModel
+  class Adapter
+    module MigrationsModules
+      module Legacy
+        # If adding an index to a temporal table, add it to the one in the
+        # temporal schema and to the history one. If the `:unique` option is
+        # present, it is removed from the index created in the history table.
+        #
+        def add_index(table_name, column_name, options = {})
+          return super unless is_chrono?(table_name)
+
+          transaction do
+            on_temporal_schema { super }
+
+            # 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) }
+          end
+        end
+
+        # If removing an index from a temporal table, remove it both from the
+        # temporal and the history schemas.
+        #
+        def remove_index(table_name, options = {})
+          return super unless is_chrono?(table_name)
+
+          transaction do
+            on_temporal_schema { super }
+
+            on_history_schema { super }
+          end
+        end
+      end
+    end
+  end
+end
+
+ChronoModel::Adapter::Migrations.include ChronoModel::Adapter::MigrationsModules::Legacy

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module ChronoModel
+  class Adapter
+    module MigrationsModules
+      module Stable
+        # If adding an index to a temporal table, add it to the one in the
+        # temporal schema and to the history one. If the `:unique` option is
+        # present, it is removed from the index created in the history table.
+        #
+        def add_index(table_name, column_name, **options)
+          return super unless is_chrono?(table_name)
+
+          transaction do
+            on_temporal_schema { super }
+
+            # 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) }
+          end
+        end
+
+        # If removing an index from a temporal table, remove it both from the
+        # temporal and the history schemas.
+        #
+        def remove_index(table_name, column_name = nil, **options)
+          return super unless is_chrono?(table_name)
+
+          transaction do
+            on_temporal_schema { super }
+
+            on_history_schema { super }
+          end
+        end
+      end
+    end
+  end
+end
+
+ChronoModel::Adapter::Migrations.include ChronoModel::Adapter::MigrationsModules::Stable

data/lib/chrono_model/adapter/tsrange.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 module ChronoModel
   class Adapter < ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
-
     module TSRange
       # HACK: Redefine tsrange parsing support, as it is broken currently.
       #
@@ -26,16 +27,31 @@ module ChronoModel
           extracted = extract_bounds(value)
 
           from = Conversions.string_to_utc_time extracted[:from]
-          to   = Conversions.string_to_utc_time extracted[:to  ]
+          to   = Conversions.string_to_utc_time extracted[:to]
 
           [from, to]
         end
 
         def extract_bounds(value)
           from, to = value[1..-2].split(',')
+
+          from_bound =
+            if value[1] == ',' || from == '-infinity'
+              nil
+            else
+              from[1..-2]
+            end
+
+          to_bound =
+            if value[-2] == ',' || to == 'infinity'
+              nil
+            else
+              to[1..-2]
+            end
+
           {
-            from:          (value[1] == ',' || from == '-infinity') ? nil : from[1..-2],
-            to:            (value[-2] == ',' || to == 'infinity') ? nil : to[1..-2],
+            from: from_bound,
+            to: to_bound
           }
         end
       end
@@ -52,6 +68,5 @@ module ChronoModel
         end
       end
     end
-
   end
 end

data/lib/chrono_model/adapter/upgrade.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 module ChronoModel
   class Adapter < ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
-
     module Upgrade
       def chrono_upgrade!
         chrono_ensure_schemas
@@ -9,112 +10,109 @@ module ChronoModel
       end
 
       private
-        # Locate tables needing a structure upgrade
-        #
-        def chrono_tables_needing_upgrade
-          tables = { }
-
-          on_temporal_schema { self.tables }.each do |table_name|
-            next unless is_chrono?(table_name)
-            metadata = chrono_metadata_for(table_name)
-            version = metadata['chronomodel']
-
-            if version.blank?
-              tables[table_name] = { version: nil, priority: 'CRITICAL' }
-            elsif version != VERSION
-              tables[table_name] = { version: version, priority: 'LOW' }
-            end
-          end
 
-          return tables
-        end
+      # Locate tables needing a structure upgrade
+      #
+      def chrono_tables_needing_upgrade
+        tables = {}
 
-        # Emit a warning about tables needing an upgrade
-        #
-        def chrono_upgrade_warning
-          upgrade = chrono_tables_needing_upgrade.map do |table, desc|
-            "#{table} - priority: #{desc[:priority]}"
-          end.join('; ')
-
-          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: 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}"
+        on_temporal_schema { self.tables }.each do |table_name|
+          next unless is_chrono?(table_name)
+
+          metadata = chrono_metadata_for(table_name)
+          version = metadata['chronomodel']
+
+          if version.blank?
+            tables[table_name] = { version: nil, priority: 'CRITICAL' }
+          elsif version != VERSION
+            tables[table_name] = { version: version, priority: 'LOW' }
+          end
         end
 
-        # Upgrades existing structure for each table, if required.
-        #
-        def chrono_upgrade_structure!
-          transaction do
+        tables
+      end
+
+      # Emit a warning about tables needing an upgrade
+      #
+      def chrono_upgrade_warning
+        upgrade = chrono_tables_needing_upgrade.map do |table, desc|
+          "#{table} - priority: #{desc[:priority]}"
+        end.join('; ')
 
-            chrono_tables_needing_upgrade.each do |table_name, desc|
+        return if upgrade.empty?
 
-              if desc[:version].blank?
-                logger.info "ChronoModel: Upgrading legacy PG 9.0 table #{table_name} to #{VERSION}"
-                chrono_upgrade_from_postgres_9_0(table_name)
-                logger.info "ChronoModel: legacy #{table_name} upgrade complete"
-              else
-                logger.info "ChronoModel: upgrading #{table_name} from #{desc[:version]} to #{VERSION}"
-                chrono_create_view_for(table_name)
-                logger.info "ChronoModel: #{table_name} upgrade complete"
-              end
+        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: 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}"
+      end
 
+      # Upgrades existing structure for each table, if required.
+      #
+      def chrono_upgrade_structure!
+        transaction do
+          chrono_tables_needing_upgrade.each do |table_name, desc|
+            if desc[:version].blank?
+              logger.info "ChronoModel: Upgrading legacy PG 9.0 table #{table_name} to #{VERSION}"
+              chrono_upgrade_from_postgres_v90(table_name)
+              logger.info "ChronoModel: legacy #{table_name} upgrade complete"
+            else
+              logger.info "ChronoModel: upgrading #{table_name} from #{desc[:version]} to #{VERSION}"
+              chrono_public_view_ddl(table_name)
+              logger.info "ChronoModel: #{table_name} upgrade complete"
             end
           end
-        rescue => e
-          message = "ChronoModel structure upgrade failed: #{e.message}. Please drop dependent objects first and then run ChronoModel.upgrade! again."
-
-          # Quite important, output it also to stderr.
-          #
-          logger.error message
-          $stderr.puts message
         end
+      rescue StandardError => e
+        message = "ChronoModel structure upgrade failed: #{e.message}. Please drop dependent objects first and then run ChronoModel.upgrade! again."
 
-        def chrono_upgrade_from_postgres_9_0(table_name)
-          # roses are red
-          # violets are blue
-          # and this is the most boring piece of code ever
-          history_table = "#{HISTORY_SCHEMA}.#{table_name}"
-          p_pkey = primary_key(table_name)
+        # Quite important, output it also to stderr.
+        #
+        logger.error message
+        warn message
+      end
 
-          execute "ALTER TABLE #{history_table} ADD COLUMN validity tsrange;"
-          execute """
-              UPDATE #{history_table} SET validity = tsrange(valid_from,
+      def chrono_upgrade_from_postgres_v90(table_name)
+        # roses are red
+        # violets are blue
+        # and this is the most boring piece of code ever
+        history_table = "#{HISTORY_SCHEMA}.#{table_name}"
+        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 "DROP INDEX #{history_table}_temporal_on_valid_from;"
-          execute "DROP INDEX #{history_table}_temporal_on_valid_from_and_valid_to;"
-          execute "DROP INDEX #{history_table}_temporal_on_valid_to;"
-          execute "DROP INDEX #{history_table}_inherit_pkey"
-          execute "DROP INDEX #{history_table}_recorded_at"
-          execute "DROP INDEX #{history_table}_instance_history"
-          execute "ALTER TABLE #{history_table} DROP CONSTRAINT #{table_name}_valid_from_before_valid_to;"
-          execute "ALTER TABLE #{history_table} DROP CONSTRAINT #{table_name}_timeline_consistency;"
-          execute "DROP RULE #{table_name}_upd_first ON #{table_name};"
-          execute "DROP RULE #{table_name}_upd_next ON #{table_name};"
-          execute "DROP RULE #{table_name}_del ON #{table_name};"
-          execute "DROP RULE #{table_name}_ins ON #{table_name};"
-          execute "DROP TRIGGER history_ins ON #{TEMPORAL_SCHEMA}.#{table_name};"
-          execute "DROP FUNCTION #{TEMPORAL_SCHEMA}.#{table_name}_ins();"
-          execute "ALTER TABLE #{history_table} DROP COLUMN valid_from;"
-          execute "ALTER TABLE #{history_table} DROP COLUMN valid_to;"
-
-          execute "CREATE EXTENSION IF NOT EXISTS btree_gist;"
-
-          chrono_create_view_for(table_name)
-          on_history_schema { add_history_validity_constraint(table_name, p_pkey) }
-          on_history_schema { chrono_create_history_indexes_for(table_name, p_pkey) }
-        end
+            );
+        SQL
+
+        execute "DROP INDEX #{history_table}_temporal_on_valid_from;"
+        execute "DROP INDEX #{history_table}_temporal_on_valid_from_and_valid_to;"
+        execute "DROP INDEX #{history_table}_temporal_on_valid_to;"
+        execute "DROP INDEX #{history_table}_inherit_pkey"
+        execute "DROP INDEX #{history_table}_recorded_at"
+        execute "DROP INDEX #{history_table}_instance_history"
+        execute "ALTER TABLE #{history_table} DROP CONSTRAINT #{table_name}_valid_from_before_valid_to;"
+        execute "ALTER TABLE #{history_table} DROP CONSTRAINT #{table_name}_timeline_consistency;"
+        execute "DROP RULE #{table_name}_upd_first ON #{table_name};"
+        execute "DROP RULE #{table_name}_upd_next ON #{table_name};"
+        execute "DROP RULE #{table_name}_del ON #{table_name};"
+        execute "DROP RULE #{table_name}_ins ON #{table_name};"
+        execute "DROP TRIGGER history_ins ON #{TEMPORAL_SCHEMA}.#{table_name};"
+        execute "DROP FUNCTION #{TEMPORAL_SCHEMA}.#{table_name}_ins();"
+        execute "ALTER TABLE #{history_table} DROP COLUMN valid_from;"
+        execute "ALTER TABLE #{history_table} DROP COLUMN valid_to;"
+
+        execute 'CREATE EXTENSION IF NOT EXISTS btree_gist;'
+
+        chrono_public_view_ddl(table_name)
+        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