temporal_tables 0.8.1 → 1.0.1

data/lib/temporal_tables/temporal_adapter.rb

@@ -1,20 +1,22 @@
+# 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
@@ -25,16 +27,18 @@ module TemporalTables
       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|
-        if options[:id] != false
-          t.column :id, options.fetch(:id, :integer)
-        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"
+        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
         end
       end
@@ -51,106 +55,101 @@ 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
+      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
+      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
+      super(table_name, *column_names)
 
-      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
+      create_temporal_triggers table_name
     end
 
     def change_column(table_name, column_name, type, options = {})
-      super 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
-        # 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
+      # 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
+      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
+      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
+      super(table_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(index_name(table_name, options))
+      super temporal_name(table_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
 
@@ -158,33 +157,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_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.8.1"
+  VERSION = '1.0.1'
 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

data/lib/temporal_tables.rb

@@ -1,20 +1,21 @@
-require "temporal_tables/temporal_adapter"
-require "temporal_tables/connection_adapters/mysql_adapter"
-require "temporal_tables/connection_adapters/postgresql_adapter"
-require "temporal_tables/whodunnit"
-require "temporal_tables/temporal_class"
-require "temporal_tables/history_hook"
-require "temporal_tables/relation_extensions"
-require "temporal_tables/association_extensions"
-require "temporal_tables/join_extensions"
-require "temporal_tables/preloader_extensions"
-require "temporal_tables/reflection_extensions"
-require "temporal_tables/arel_table"
-require "temporal_tables/version"
+# frozen_string_literal: true
+
+require 'temporal_tables/temporal_adapter'
+require 'temporal_tables/connection_adapters/mysql_adapter'
+require 'temporal_tables/connection_adapters/postgresql_adapter'
+require 'temporal_tables/whodunnit'
+require 'temporal_tables/temporal_class'
+require 'temporal_tables/history_hook'
+require 'temporal_tables/relation_extensions'
+require 'temporal_tables/association_extensions'
+require 'temporal_tables/preloader_extensions'
+require 'temporal_tables/reflection_extensions'
+require 'temporal_tables/arel_table'
+require 'temporal_tables/version'
 
 module TemporalTables
   class Railtie < ::Rails::Railtie
-    initializer "temporal_tables.load" do
+    initializer 'temporal_tables.load' do
       # Iterating the subclasses will find any adapter implementations
       # which are in use by the rails app, and mixin the temporal functionality.
       # It's necessary to do this on the implementations in order for the
@@ -22,46 +23,55 @@ module TemporalTables
       ActiveRecord::ConnectionAdapters::AbstractAdapter.subclasses.each do |subclass|
         subclass.send :prepend, TemporalTables::TemporalAdapter
 
-        module_name = subclass.name.split("::").last
-        subclass.send :prepend, TemporalTables::ConnectionAdapters.const_get(module_name) if TemporalTables::ConnectionAdapters.const_defined?(module_name)
+        module_name = subclass.name.split('::').last
+        next unless TemporalTables::ConnectionAdapters.const_defined?(module_name)
+
+        subclass.send(
+          :prepend,
+          TemporalTables::ConnectionAdapters.const_get(module_name)
+        )
       end
 
-      ActiveRecord::Base.send :include, TemporalTables::Whodunnit
+      ActiveRecord::Base.include TemporalTables::Whodunnit
     end
   end
 
-  @@create_by_default = false
+  @create_by_default = false
   def self.create_by_default
-    @@create_by_default
+    @create_by_default
   end
+
   def self.create_by_default=(default)
-    @@create_by_default = default
+    @create_by_default = default
   end
 
-  @@skipped_temporal_tables = [:schema_migrations, :sessions, :ar_internal_metadata]
+  @skipped_temporal_tables = [:schema_migrations, :sessions, :ar_internal_metadata]
   def self.skip_temporal_table_for(*tables)
-    @@skipped_temporal_tables += tables
+    @skipped_temporal_tables += tables
   end
+
   def self.skipped_temporal_tables
-    @@skipped_temporal_tables.dup
+    @skipped_temporal_tables.dup
   end
 
-  @@add_updated_by_field = false
-  @@updated_by_type = :string
-  @@updated_by_proc = nil
+  @add_updated_by_field = false
+  @updated_by_type = :string
+  @updated_by_proc = nil
   def self.updated_by_type
-    @@updated_by_type
+    @updated_by_type
   end
+
   def self.updated_by_proc
-    @@updated_by_proc
+    @updated_by_proc
   end
+
   def self.add_updated_by_field(type = :string, &block)
     if block_given?
-      @@add_updated_by_field = true
-      @@updated_by_type = type
-      @@updated_by_proc = block
+      @add_updated_by_field = true
+      @updated_by_type = type
+      @updated_by_proc = block
     end
 
-    @@add_updated_by_field
+    @add_updated_by_field
   end
 end