temporal_tables 0.7.1 → 1.0.2

data/lib/temporal_tables/temporal_adapter.rb

@@ -1,39 +1,45 @@
+# frozen_string_literal: true
+
 module TemporalTables
-  module TemporalAdapter
-    def create_table(table_name, options = {}, &block)
+  module TemporalAdapter # rubocop:disable Metrics/ModuleLength
+    def create_table(table_name, **options, &block) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
       if options[:temporal_bypass]
-        super table_name, options, &block
+        super(table_name, **options, &block)
       else
         skip_table = TemporalTables.skipped_temporal_tables.include?(table_name.to_sym) || table_name.to_s =~ /_h$/
 
-        super table_name, options do |t|
+        super(table_name, **options) do |t|
           block.call t
 
           if TemporalTables.add_updated_by_field && !skip_table
-            updated_by_already_exists = t.columns.any? { |c| c.name == "updated_by" }
+            updated_by_already_exists = t.columns.any? { |c| c.name == 'updated_by' }
             if updated_by_already_exists
-              puts "consider adding #{table_name} to TemporalTables skip_table"
+              puts "consider adding #{table_name} to TemporalTables skip_table" # rubocop:disable Rails/Output
             else
-              t.column :updated_by, TemporalTables.updated_by_type
+              t.column(:updated_by, TemporalTables.updated_by_type)
             end
           end
         end
 
         if options[:temporal] || (TemporalTables.create_by_default && !skip_table)
-          add_temporal_table table_name, options
+          add_temporal_table table_name, **options
         end
       end
     end
 
-    def add_temporal_table(table_name, options = {})
-      create_table temporal_name(table_name), options.merge(id: false, primary_key: "history_id", temporal_bypass: true) do |t|
-        t.integer   :id
-        t.datetime :eff_from, :null => false, limit: 6
-        t.datetime :eff_to,   :null => false, limit: 6, :default => "9999-12-31"
+    def add_temporal_table(table_name, **options) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      create_table(
+        temporal_name(table_name),
+        **options.merge(id: false, primary_key: 'history_id', temporal_bypass: true)
+      ) do |t|
+        t.column :id, options.fetch(:id, :integer) if options[:id] != false
+        t.datetime :eff_from, null: false, limit: 6
+        t.datetime :eff_to,   null: false, limit: 6, default: '9999-12-31'
+
+        columns(table_name).each do |c|
+          next if c.name == 'id'
 
-        for c in columns(table_name)
-          next if c.name == "id"
-          t.send c.type, c.name, :limit => c.limit
+          t.send c.type, c.name, limit: c.limit
         end
       end
 
@@ -49,106 +55,108 @@ module TemporalTables
     end
 
     def remove_temporal_table(table_name)
-      if table_exists?(temporal_name(table_name))
-        drop_temporal_triggers table_name
-        drop_table_without_temporal temporal_name(table_name)
-      end
+      return unless table_exists?(temporal_name(table_name))
+
+      drop_temporal_triggers table_name
+      drop_table_without_temporal temporal_name(table_name)
     end
 
-    def drop_table(table_name, options = {})
-      super table_name, options
+    def drop_table(table_name, **options)
+      super(table_name, **options)
 
-      if table_exists?(temporal_name(table_name))
-        super temporal_name(table_name), options
-      end
+      super(temporal_name(table_name), **options) if table_exists?(temporal_name(table_name))
     end
 
     def rename_table(name, new_name)
-      if table_exists?(temporal_name(name))
-        drop_temporal_triggers name
-      end
+      drop_temporal_triggers name if table_exists?(temporal_name(name))
 
       super name, new_name
 
-      if table_exists?(temporal_name(name))
-        super temporal_name(name), temporal_name(new_name)
-        create_temporal_triggers new_name
-      end
+      return unless table_exists?(temporal_name(name))
+
+      super(temporal_name(name), temporal_name(new_name))
+      create_temporal_triggers new_name
     end
 
-    def add_column(table_name, column_name, type, options = {})
-      super table_name, column_name, type, options
+    def add_column(table_name, column_name, type, **options)
+      super(table_name, column_name, type, **options)
 
-      if table_exists?(temporal_name(table_name))
-        super temporal_name(table_name), column_name, type, options
-        create_temporal_triggers table_name
-      end
+      return unless table_exists?(temporal_name(table_name))
+
+      super temporal_name(table_name), column_name, type, **options
+      create_temporal_triggers table_name
     end
 
-    def remove_column(table_name, *column_names)
-      super table_name, *column_names
+    def remove_columns(table_name, *column_names, **options)
+      super(table_name, *column_names, **options)
 
-      if table_exists?(temporal_name(table_name))
-        super temporal_name(table_name), *column_names
-        create_temporal_triggers table_name
-      end
+      return unless table_exists?(temporal_name(table_name))
+
+      super temporal_name(table_name), *column_names, **options
+      create_temporal_triggers table_name
     end
 
-    def change_column(table_name, column_name, type, options = {})
-      super table_name, column_name, type, options
+    def remove_column(table_name, column_name, type = nil, **options)
+      super(table_name, column_name, type, **options)
 
-      if table_exists?(temporal_name(table_name))
-        super temporal_name(table_name), column_name, type, options
-        # Don't need to update triggers here...
-      end
+      return unless table_exists?(temporal_name(table_name))
+
+      super temporal_name(table_name), column_name, type, **options
+      create_temporal_triggers table_name
+    end
+
+    def change_column(table_name, column_name, type, **options)
+      super(table_name, column_name, type, **options)
+
+      return unless table_exists?(temporal_name(table_name))
+
+      super temporal_name(table_name), column_name, type, **options
+      # Don't need to update triggers here...
     end
 
     def rename_column(table_name, column_name, new_column_name)
-      super table_name, column_name, new_column_name
+      super(table_name, column_name, new_column_name)
 
-      if table_exists?(temporal_name(table_name))
-        super temporal_name(table_name), column_name, new_column_name
-        create_temporal_triggers table_name
-      end
+      return unless table_exists?(temporal_name(table_name))
+
+      super temporal_name(table_name), column_name, new_column_name
+      create_temporal_triggers table_name
     end
 
-    def add_index(table_name, column_name, options = {})
-      super table_name, column_name, options
+    def add_index(table_name, column_name, **options)
+      super(table_name, column_name, **options)
 
-      if table_exists?(temporal_name(table_name))
-        column_names = Array.wrap(column_name)
-        idx_name = temporal_index_name(options[:name] || index_name(table_name, :column => column_names))
+      return unless table_exists?(temporal_name(table_name))
 
-        super temporal_name(table_name), column_name, options.except(:unique).merge(name: idx_name)
-      end
+      idx_name = temporal_index_name(options[:name] || index_name(table_name, column: column_name))
+      super temporal_name(table_name), column_name, **options.except(:unique).merge(name: idx_name)
     end
 
-    def remove_index(table_name, options = {})
-      super table_name, options
+    def remove_index(table_name, column_name = nil, **options)
+      super(table_name, column_name, **options)
 
-      if table_exists?(temporal_name(table_name))
-        idx_name = temporal_index_name(index_name(table_name, options))
+      return unless table_exists?(temporal_name(table_name))
 
-        super temporal_name(table_name), :name => idx_name
-      end
+      idx_name = temporal_index_name(options[:name] || index_name_for_remove(table_name, column_name, options))
+      super temporal_name(table_name), column_name, name: idx_name
     end
 
-    def create_temporal_indexes(table_name)
+    def create_temporal_indexes(table_name) # rubocop:disable Metrics/MethodLength
       indexes = ActiveRecord::Base.connection.indexes(table_name)
 
       indexes.each do |index|
         index_name = temporal_index_name(index.name)
 
-        unless temporal_index_exists?(table_name, index_name)
-          add_index(
-            temporal_name(table_name),
-            index.columns, {
-              # exclude unique constraints for temporal tables
-              :name   => index_name,
-              :length => index.lengths,
-              :order  => index.orders
-          })
-        end
+        next if temporal_index_exists?(table_name, index_name)
+
+        add_index(
+          temporal_name(table_name),
+          index.columns,
+          # exclude unique constraints for temporal tables
+          name: index_name,
+          length: index.lengths,
+          order: index.orders
+        )
       end
     end
 
@@ -156,33 +164,21 @@ module TemporalTables
       "#{table_name}_h"
     end
 
-    def create_temporal_triggers(table_name)
-      raise NotImplementedError, "create_temporal_triggers is not implemented"
+    def create_temporal_triggers(_table_name)
+      raise NotImplementedError, 'create_temporal_triggers is not implemented'
     end
 
-    def drop_temporal_triggers(table_name)
-      raise NotImplementedError, "drop_temporal_triggers is not implemented"
+    def drop_temporal_triggers(_table_name)
+      raise NotImplementedError, 'drop_temporal_triggers is not implemented'
     end
 
     # It's important not to increase the length of the returned string.
     def temporal_index_name(index_name)
-      index_name.to_s.sub(/^index/, "ind_h").sub(/_ix(\d+)$/, '_hi\1')
+      index_name.to_s.sub(/^index/, 'ind_h').sub(/_ix(\d+)$/, '_hi\1')
     end
 
     def temporal_index_exists?(table_name, index_name)
-      case Rails::VERSION::MAJOR
-      when 5
-        case Rails::VERSION::MINOR
-        when 0
-          index_name_exists?(temporal_name(table_name), index_name, false)
-        else
-          index_name_exists?(temporal_name(table_name), index_name)
-        end
-      when 6
-        index_name_exists?(temporal_name(table_name), index_name)
-      else
-        raise "Rails version not supported"
-      end
+      index_name_exists?(temporal_name(table_name), index_name)
     end
   end
 end

data/lib/temporal_tables/temporal_adapter_six_oh.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module TemporalTables
+  # The main difference here is the add_index method, which still uses
+  # the old options={} syntax
+  module TemporalAdapterSixOh # rubocop:disable Metrics/ModuleLength
+    def create_table(table_name, **options, &block) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+      if options[:temporal_bypass]
+        super(table_name, **options, &block)
+      else
+        skip_table = TemporalTables.skipped_temporal_tables.include?(table_name.to_sym) || table_name.to_s =~ /_h$/
+
+        super(table_name, **options) do |t|
+          block.call t
+
+          if TemporalTables.add_updated_by_field && !skip_table
+            updated_by_already_exists = t.columns.any? { |c| c.name == 'updated_by' }
+            if updated_by_already_exists
+              puts "consider adding #{table_name} to TemporalTables skip_table" # rubocop:disable Rails/Output
+            else
+              t.column(:updated_by, TemporalTables.updated_by_type)
+            end
+          end
+        end
+
+        if options[:temporal] || (TemporalTables.create_by_default && !skip_table)
+          add_temporal_table table_name, **options
+        end
+      end
+    end
+
+    def add_temporal_table(table_name, **options) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      create_table(
+        temporal_name(table_name),
+        **options.merge(id: false, primary_key: 'history_id', temporal_bypass: true)
+      ) do |t|
+        t.column :id, options.fetch(:id, :integer) if options[:id] != false
+        t.datetime :eff_from, null: false, limit: 6
+        t.datetime :eff_to,   null: false, limit: 6, default: '9999-12-31'
+
+        columns(table_name).each do |c|
+          next if c.name == 'id'
+
+          t.send c.type, c.name, limit: c.limit
+        end
+      end
+
+      if TemporalTables.add_updated_by_field && !column_exists?(table_name, :updated_by)
+        change_table table_name do |t|
+          t.column :updated_by, TemporalTables.updated_by_type
+        end
+      end
+
+      add_index temporal_name(table_name), [:id, :eff_to]
+      create_temporal_triggers table_name
+      create_temporal_indexes table_name
+    end
+
+    def remove_temporal_table(table_name)
+      return unless table_exists?(temporal_name(table_name))
+
+      drop_temporal_triggers table_name
+      drop_table_without_temporal temporal_name(table_name)
+    end
+
+    def drop_table(table_name, **options)
+      super(table_name, **options)
+
+      super(temporal_name(table_name), **options) if table_exists?(temporal_name(table_name))
+    end
+
+    def rename_table(name, new_name)
+      drop_temporal_triggers name if table_exists?(temporal_name(name))
+
+      super name, new_name
+
+      return unless table_exists?(temporal_name(name))
+
+      super(temporal_name(name), temporal_name(new_name))
+      create_temporal_triggers new_name
+    end
+
+    def add_column(table_name, column_name, type, **options)
+      super(table_name, column_name, type, **options)
+
+      return unless table_exists?(temporal_name(table_name))
+
+      super temporal_name(table_name), column_name, type, **options
+      create_temporal_triggers table_name
+    end
+
+    def remove_columns(table_name, *column_names, **options)
+      super(table_name, *column_names, **options)
+
+      return unless table_exists?(temporal_name(table_name))
+
+      super temporal_name(table_name), *column_names, **options
+      create_temporal_triggers table_name
+    end
+
+    def remove_column(table_name, column_name, type = nil, **options)
+      super(table_name, column_name, type, **options)
+
+      return unless table_exists?(temporal_name(table_name))
+
+      super temporal_name(table_name), column_name, type, **options
+      create_temporal_triggers table_name
+    end
+
+    def change_column(table_name, column_name, type, **options)
+      super(table_name, column_name, type, **options)
+
+      return unless table_exists?(temporal_name(table_name))
+
+      super temporal_name(table_name), column_name, type, **options
+      # Don't need to update triggers here...
+    end
+
+    def rename_column(table_name, column_name, new_column_name)
+      super(table_name, column_name, new_column_name)
+
+      return unless table_exists?(temporal_name(table_name))
+
+      super temporal_name(table_name), column_name, new_column_name
+      create_temporal_triggers table_name
+    end
+
+    def add_index(table_name, column_name, options = {})
+      super(table_name, column_name, options)
+
+      return unless table_exists?(temporal_name(table_name))
+
+      column_names = Array.wrap(column_name)
+      idx_name = temporal_index_name(options[:name] || index_name(table_name, column: column_names))
+      super temporal_name(table_name), column_name, options.except(:unique).merge(name: idx_name)
+    end
+
+    def remove_index(table_name, options = {})
+      super(table_name, options)
+
+      return unless table_exists?(temporal_name(table_name))
+
+      idx_name = temporal_index_name(index_name_for_remove(table_name, options))
+      super temporal_name(table_name), name: idx_name
+    end
+
+    def create_temporal_indexes(table_name) # rubocop:disable Metrics/MethodLength
+      indexes = ActiveRecord::Base.connection.indexes(table_name)
+
+      indexes.each do |index|
+        index_name = temporal_index_name(index.name)
+
+        next if temporal_index_exists?(table_name, index_name)
+
+        add_index(
+          temporal_name(table_name),
+          index.columns,
+          # exclude unique constraints for temporal tables
+          name: index_name,
+          length: index.lengths,
+          order: index.orders
+        )
+      end
+    end
+
+    def temporal_name(table_name)
+      "#{table_name}_h"
+    end
+
+    def create_temporal_triggers(_table_name)
+      raise NotImplementedError, 'create_temporal_triggers is not implemented'
+    end
+
+    def drop_temporal_triggers(_table_name)
+      raise NotImplementedError, 'drop_temporal_triggers is not implemented'
+    end
+
+    # It's important not to increase the length of the returned string.
+    def temporal_index_name(index_name)
+      index_name.to_s.sub(/^index/, 'ind_h').sub(/_ix(\d+)$/, '_hi\1')
+    end
+
+    def temporal_index_exists?(table_name, index_name)
+      index_name_exists?(temporal_name(table_name), index_name)
+    end
+  end
+end

data/lib/temporal_tables/temporal_class.rb

@@ -1,14 +1,16 @@
+# frozen_string_literal: true
+
 module TemporalTables
   # This is mixed into all History classes.
   module TemporalClass
-    def self.included(base)
+    def self.included(base) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
       base.class_eval do
         base.extend ClassMethods
 
-        self.table_name += "_h"
+        self.table_name += '_h'
 
         cattr_accessor :visited_associations
-        @@visited_associations = []
+        @visited_associations = []
 
         # The at_value field stores the time from the query that yielded
         # this record.
@@ -23,26 +25,27 @@ module TemporalTables
         # Iterates all associations, makes sure their history classes are
         # created and initialized, and modifies the associations to point
         # to the target classes' history classes.
-        def self.temporalize_associations!
+        def self.temporalize_associations! # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
           reflect_on_all_associations.dup.each do |association|
-            unless @@visited_associations.include?(association.name) || association.options[:polymorphic]
-              @@visited_associations << association.name
-
-              # Calling .history here will ensure that the history class
-              # for this association is created and initialized
-              clazz = association.class_name.constantize.history
-
-              # Recreate the association, updating it to point at the
-              # history class.  The foreign key is explicitly set since it's
-              # inferred from the class_name, but shouldn't be in this case.
-              send(association.macro, association.name,
-                association.options.merge(
-                  class_name:  clazz.name,
-                  foreign_key: association.foreign_key,
-                  primary_key: clazz.orig_class.primary_key
-                )
+            next if @visited_associations.include?(association.name) || association.options[:polymorphic]
+
+            @visited_associations << association.name
+
+            # Calling .history here will ensure that the history class
+            # for this association is created and initialized
+            clazz = association.class_name.constantize.history
+
+            # Recreate the association, updating it to point at the
+            # history class.  The foreign key is explicitly set since it's
+            # inferred from the class_name, but shouldn't be in this case.
+            send(
+              association.macro, association.name,
+              **association.options.merge(
+                class_name: clazz.name,
+                foreign_key: association.foreign_key,
+                primary_key: clazz.orig_class.primary_key
               )
-            end
+            )
           end
         end
       end
@@ -50,11 +53,11 @@ module TemporalTables
 
     module STIWithHistory
       def sti_name
-        super.sub /History$/, ""
+        super.sub(/History$/, '')
       end
 
       def find_sti_class(type_name)
-        type_name += "History" unless type_name =~ /History\Z/
+        type_name += 'History' unless type_name =~ /History\Z/
 
         begin
           super
@@ -66,12 +69,10 @@ module TemporalTables
 
     module ClassMethods
       def orig_class
-        name.sub(/History$/, "").constantize
+        name.sub(/History$/, '').constantize
       end
 
-      def descends_from_active_record?
-        superclass.descends_from_active_record?
-      end
+      delegate :descends_from_active_record?, to: :superclass
 
       def build_temporal_constraint(at_value)
         arel_table[:eff_to].gteq(at_value).and(
@@ -89,7 +90,7 @@ module TemporalTables
     end
 
     def orig_obj
-      @orig_obj ||= orig_class.find_by_id orig_id
+      @orig_obj ||= orig_class.find_by id: orig_id
     end
 
     def prev

data/lib/temporal_tables/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module TemporalTables
-  VERSION = "0.7.1"
+  VERSION = '1.0.2'
 end

data/lib/temporal_tables/whodunnit.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module TemporalTables
   module Whodunnit
     def self.included(base)
@@ -10,9 +12,9 @@ module TemporalTables
 
     module InstanceMethods
       def set_updated_by
-        if TemporalTables.updated_by_proc && respond_to?(:updated_by)
-          self.updated_by = TemporalTables.updated_by_proc.call(self)
-        end
+        return unless TemporalTables.updated_by_proc && respond_to?(:updated_by)
+
+        self.updated_by = TemporalTables.updated_by_proc.call(self)
       end
     end
   end