temporal_tables 0.6.10 → 0.7.0

data/lib/temporal_tables/temporal_adapter.rb

@@ -1,176 +1,183 @@
 module TemporalTables
-	module TemporalAdapter
-		def create_table(table_name, options = {}, &block)
-			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
-						t.column :updated_by, TemporalTables.updated_by_type
-					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 = {})
-			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"
-
-				for c in columns(table_name)
-					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)
-			if table_exists?(temporal_name(table_name))
-				drop_temporal_triggers table_name
-				drop_table_without_temporal temporal_name(table_name)
-			end
-		end
-
-		def drop_table(table_name, options = {})
-			super table_name, options
-
-			if table_exists?(temporal_name(table_name))
-				super temporal_name(table_name), options
-			end
-		end
-
-		def rename_table(name, new_name)
-			if table_exists?(temporal_name(name))
-				drop_temporal_triggers name
-			end
-
-			super name, new_name
-
-			if table_exists?(temporal_name(name))
-				super temporal_name(name), temporal_name(new_name)
-				create_temporal_triggers new_name
-			end
-		end
-
-		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
-		end
-
-		def remove_column(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
-		end
-
-		def change_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
-				# Don't need to update triggers here...
-			end
-		end
-
-		def rename_column(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
-		end
-
-		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))
-
-				super temporal_name(table_name), column_name, options.except(:unique).merge(name: idx_name)
-			end
-		end
-
-		def remove_index(table_name, options = {})
-			super table_name, options
-
-			if table_exists?(temporal_name(table_name))
-				idx_name = temporal_index_name(index_name(table_name, options))
-
-				super temporal_name(table_name), :name => idx_name
-			end
-		end
-
-		def create_temporal_indexes(table_name)
-			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
-			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)
-			raise "Rails version not supported" unless Rails::VERSION::MAJOR == 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
-		end
-	end
+  module TemporalAdapter
+    def create_table(table_name, options = {}, &block)
+      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
+            t.column :updated_by, TemporalTables.updated_by_type
+          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 = {})
+      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"
+
+        for c in columns(table_name)
+          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)
+      if table_exists?(temporal_name(table_name))
+        drop_temporal_triggers table_name
+        drop_table_without_temporal temporal_name(table_name)
+      end
+    end
+
+    def drop_table(table_name, options = {})
+      super table_name, options
+
+      if table_exists?(temporal_name(table_name))
+        super temporal_name(table_name), options
+      end
+    end
+
+    def rename_table(name, new_name)
+      if table_exists?(temporal_name(name))
+        drop_temporal_triggers name
+      end
+
+      super name, new_name
+
+      if table_exists?(temporal_name(name))
+        super temporal_name(name), temporal_name(new_name)
+        create_temporal_triggers new_name
+      end
+    end
+
+    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
+    end
+
+    def remove_column(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
+    end
+
+    def change_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
+        # Don't need to update triggers here...
+      end
+    end
+
+    def rename_column(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
+    end
+
+    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))
+
+        super temporal_name(table_name), column_name, options.except(:unique).merge(name: idx_name)
+      end
+    end
+
+    def remove_index(table_name, options = {})
+      super table_name, options
+
+      if table_exists?(temporal_name(table_name))
+        idx_name = temporal_index_name(index_name(table_name, options))
+
+        super temporal_name(table_name), :name => idx_name
+      end
+    end
+
+    def create_temporal_indexes(table_name)
+      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
+      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)
+      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
+    end
+  end
 end

data/lib/temporal_tables/temporal_class.rb

@@ -1,103 +1,103 @@
 module TemporalTables
-	# This is mixed into all History classes.
-	module TemporalClass
-		def self.included(base)
-			base.class_eval do
-				base.extend ClassMethods
-
-				self.table_name += "_h"
-
-				cattr_accessor :visited_associations
-				@@visited_associations = []
-
-				# The at_value field stores the time from the query that yielded
-				# this record.
-				attr_accessor :at_value
-
-				class << self
-					prepend STIWithHistory
-
-					delegate :at, to: :all
-				end
-
-				# 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!
-					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
-								)
-							)
-						end
-					end
-				end
-			end
-		end
-
-		module STIWithHistory
-			def sti_name
-				super.sub /History$/, ""
-			end
-
-			def find_sti_class(type_name)
-				type_name += "History" unless type_name =~ /History\Z/
-
-				begin
-					super
-				rescue ActiveRecord::SubclassNotFound
-					superclass.send(:find_sti_class, type_name)
-				end
-			end
-		end
-
-		module ClassMethods
-			def orig_class
-				name.sub(/History$/, "").constantize
-			end
-
-			def descends_from_active_record?
-				superclass.descends_from_active_record?
-			end
-
-			def build_temporal_constraint(at_value)
-				arel_table[:eff_to].gteq(at_value).and(
-					arel_table[:eff_from].lteq(at_value)
-				)
-			end
-		end
-
-		def orig_class
-			self.class.orig_class
-		end
-
-		def orig_id
-			attributes[orig_class.primary_key]
-		end
-
-		def orig_obj
-			@orig_obj ||= orig_class.find_by_id orig_id
-		end
-
-		def prev
-			@prev ||= history.where(self.class.arel_table[:eff_from].lt(eff_from)).last
-		end
-
-		def next
-			@next ||= history.where(self.class.arel_table[:eff_from].gt(eff_from)).first
-		end
-	end
+  # This is mixed into all History classes.
+  module TemporalClass
+    def self.included(base)
+      base.class_eval do
+        base.extend ClassMethods
+
+        self.table_name += "_h"
+
+        cattr_accessor :visited_associations
+        @@visited_associations = []
+
+        # The at_value field stores the time from the query that yielded
+        # this record.
+        attr_accessor :at_value
+
+        class << self
+          prepend STIWithHistory
+
+          delegate :at, to: :all
+        end
+
+        # 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!
+          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
+                )
+              )
+            end
+          end
+        end
+      end
+    end
+
+    module STIWithHistory
+      def sti_name
+        super.sub /History$/, ""
+      end
+
+      def find_sti_class(type_name)
+        type_name += "History" unless type_name =~ /History\Z/
+
+        begin
+          super
+        rescue ActiveRecord::SubclassNotFound
+          superclass.send(:find_sti_class, type_name)
+        end
+      end
+    end
+
+    module ClassMethods
+      def orig_class
+        name.sub(/History$/, "").constantize
+      end
+
+      def descends_from_active_record?
+        superclass.descends_from_active_record?
+      end
+
+      def build_temporal_constraint(at_value)
+        arel_table[:eff_to].gteq(at_value).and(
+          arel_table[:eff_from].lteq(at_value)
+        )
+      end
+    end
+
+    def orig_class
+      self.class.orig_class
+    end
+
+    def orig_id
+      attributes[orig_class.primary_key]
+    end
+
+    def orig_obj
+      @orig_obj ||= orig_class.find_by_id orig_id
+    end
+
+    def prev
+      @prev ||= history.where(self.class.arel_table[:eff_from].lt(eff_from)).last
+    end
+
+    def next
+      @next ||= history.where(self.class.arel_table[:eff_from].gt(eff_from)).first
+    end
+  end
 end

data/lib/temporal_tables/version.rb

@@ -1,3 +1,3 @@
 module TemporalTables
-	VERSION = "0.6.10"
+  VERSION = "0.7.0"
 end

data/lib/temporal_tables/whodunnit.rb

@@ -1,19 +1,19 @@
 module TemporalTables
-	module Whodunnit
-		def self.included(base)
-			base.class_eval do
-				include InstanceMethods
+  module Whodunnit
+    def self.included(base)
+      base.class_eval do
+        include InstanceMethods
 
-				before_validation :set_updated_by
-			end
-		end
-	 
-		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
-			end
-		end
-	end
+        before_validation :set_updated_by
+      end
+    end
+
+    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
+      end
+    end
+  end
 end