temporal_tables 0.6.10 → 0.7.0

data/lib/temporal_tables/connection_adapters/mysql_adapter.rb

@@ -1,56 +1,56 @@
 module TemporalTables
-	module ConnectionAdapters
-		module AbstractMysqlAdapter
-			def drop_temporal_triggers(table_name)
-				execute "drop trigger #{table_name}_ai"
-				execute "drop trigger #{table_name}_au"
-				execute "drop trigger #{table_name}_ad"
-			end
-
-			def create_temporal_triggers(table_name)
-				column_names = columns(table_name).map(&:name)
-
-				execute %{
-					create trigger #{table_name}_ai after insert on #{table_name}
-					for each row
-					begin
-						set @current_time = utc_timestamp(6);
-
-						insert into #{temporal_name(table_name)} (#{column_names.join(', ')}, eff_from)
-						values (#{column_names.collect {|c| "new.#{c}"}.join(', ')}, @current_time);
-
-					end
-				}
-
-				execute %{
-					create trigger #{table_name}_au after update on #{table_name}
-					for each row
-					begin
-						set @current_time = utc_timestamp(6);
-
-						update #{temporal_name(table_name)} set eff_to = @current_time
-						where id = new.id
-						and eff_to = '9999-12-31';
-
-						insert into #{temporal_name(table_name)} (#{column_names.join(', ')}, eff_from)
-						values (#{column_names.collect {|c| "new.#{c}"}.join(', ')}, @current_time);
-
-					end
-				}
-
-				execute %{
-					create trigger #{table_name}_ad after delete on #{table_name}
-					for each row
-					begin
-						set @current_time = utc_timestamp(6);
-
-						update #{temporal_name(table_name)} set eff_to = @current_time
-						where id = old.id
-						and eff_to = '9999-12-31';
-
-					end
-				}
-			end
-		end
-	end
+  module ConnectionAdapters
+    module AbstractMysqlAdapter
+      def drop_temporal_triggers(table_name)
+        execute "drop trigger #{table_name}_ai"
+        execute "drop trigger #{table_name}_au"
+        execute "drop trigger #{table_name}_ad"
+      end
+
+      def create_temporal_triggers(table_name)
+        column_names = columns(table_name).map(&:name)
+
+        execute %{
+          create trigger #{table_name}_ai after insert on #{table_name}
+          for each row
+          begin
+            set @current_time = utc_timestamp(6);
+
+            insert into #{temporal_name(table_name)} (#{column_names.join(', ')}, eff_from)
+            values (#{column_names.collect {|c| "new.#{c}"}.join(', ')}, @current_time);
+
+          end
+        }
+
+        execute %{
+          create trigger #{table_name}_au after update on #{table_name}
+          for each row
+          begin
+            set @current_time = utc_timestamp(6);
+
+            update #{temporal_name(table_name)} set eff_to = @current_time
+            where id = new.id
+            and eff_to = '9999-12-31';
+
+            insert into #{temporal_name(table_name)} (#{column_names.join(', ')}, eff_from)
+            values (#{column_names.collect {|c| "new.#{c}"}.join(', ')}, @current_time);
+
+          end
+        }
+
+        execute %{
+          create trigger #{table_name}_ad after delete on #{table_name}
+          for each row
+          begin
+            set @current_time = utc_timestamp(6);
+
+            update #{temporal_name(table_name)} set eff_to = @current_time
+            where id = old.id
+            and eff_to = '9999-12-31';
+
+          end
+        }
+      end
+    end
+  end
 end

data/lib/temporal_tables/connection_adapters/postgresql_adapter.rb

@@ -1,81 +1,81 @@
 module TemporalTables
-	module ConnectionAdapters
-		module PostgreSQLAdapter
-			def drop_temporal_triggers(table_name)
-				execute "drop trigger #{table_name}_ai on #{table_name}"
-				execute "drop trigger #{table_name}_au on #{table_name}"
-				execute "drop trigger #{table_name}_ad on #{table_name}"
-			end
+  module ConnectionAdapters
+    module PostgreSQLAdapter
+      def drop_temporal_triggers(table_name)
+        execute "drop trigger #{table_name}_ai on #{table_name}"
+        execute "drop trigger #{table_name}_au on #{table_name}"
+        execute "drop trigger #{table_name}_ad on #{table_name}"
+      end
 
-			def create_temporal_triggers(table_name)
-				column_names = columns(table_name).map(&:name)
+      def create_temporal_triggers(table_name)
+        column_names = columns(table_name).map(&:name)
 
-				execute %{
-					create or replace function #{table_name}_ai() returns trigger as $#{table_name}_ai$
-						declare
-							cur_time timestamp without time zone;
-						begin
-							cur_time := localtimestamp;
+        execute %{
+          create or replace function #{table_name}_ai() returns trigger as $#{table_name}_ai$
+            declare
+              cur_time timestamp without time zone;
+            begin
+              cur_time := localtimestamp;
 
-							insert into #{temporal_name(table_name)} (#{column_list(column_names)}, eff_from)
-							values (#{column_names.collect {|c| "new.#{c}"}.join(', ')}, cur_time);
+              insert into #{temporal_name(table_name)} (#{column_list(column_names)}, eff_from)
+              values (#{column_names.collect {|c| "new.#{c}"}.join(', ')}, cur_time);
 
-							return null;
-						end
-					$#{table_name}_ai$ language plpgsql;
+              return null;
+            end
+          $#{table_name}_ai$ language plpgsql;
 
-					drop trigger if exists #{table_name}_ai on #{table_name};
-					create trigger #{table_name}_ai after insert on #{table_name}
-					for each row execute procedure #{table_name}_ai();
-				}
+          drop trigger if exists #{table_name}_ai on #{table_name};
+          create trigger #{table_name}_ai after insert on #{table_name}
+          for each row execute procedure #{table_name}_ai();
+        }
 
-				execute %{
-					create or replace function #{table_name}_au() returns trigger as $#{table_name}_au$
-						declare
-							cur_time timestamp without time zone;
-						begin
-							cur_time := localtimestamp;
+        execute %{
+          create or replace function #{table_name}_au() returns trigger as $#{table_name}_au$
+            declare
+              cur_time timestamp without time zone;
+            begin
+              cur_time := localtimestamp;
 
-							update #{temporal_name(table_name)} set eff_to = cur_time
-							where id = new.id
-								and eff_to = '9999-12-31';
+              update #{temporal_name(table_name)} set eff_to = cur_time
+              where id = new.id
+                and eff_to = '9999-12-31';
 
-							insert into #{temporal_name(table_name)} (#{column_list(column_names)}, eff_from)
-							values (#{column_names.collect {|c| "new.#{c}"}.join(', ')}, cur_time);
+              insert into #{temporal_name(table_name)} (#{column_list(column_names)}, eff_from)
+              values (#{column_names.collect {|c| "new.#{c}"}.join(', ')}, cur_time);
 
-							return null;
-						end
-					$#{table_name}_au$ language plpgsql;
+              return null;
+            end
+          $#{table_name}_au$ language plpgsql;
 
-					drop trigger if exists #{table_name}_au on #{table_name};
-					create trigger #{table_name}_au after update on #{table_name}
-					for each row execute procedure #{table_name}_au();
-				}
+          drop trigger if exists #{table_name}_au on #{table_name};
+          create trigger #{table_name}_au after update on #{table_name}
+          for each row execute procedure #{table_name}_au();
+        }
 
-				execute %{
-					create or replace function #{table_name}_ad() returns trigger as $#{table_name}_ad$
-						declare
-							cur_time timestamp without time zone;
-						begin
-							cur_time := localtimestamp;
+        execute %{
+          create or replace function #{table_name}_ad() returns trigger as $#{table_name}_ad$
+            declare
+              cur_time timestamp without time zone;
+            begin
+              cur_time := localtimestamp;
 
-							update #{temporal_name(table_name)} set eff_to = cur_time
-							where id = old.id
-								and eff_to = '9999-12-31';
+              update #{temporal_name(table_name)} set eff_to = cur_time
+              where id = old.id
+                and eff_to = '9999-12-31';
 
-							return null;
-						end
-					$#{table_name}_ad$ language plpgsql;
+              return null;
+            end
+          $#{table_name}_ad$ language plpgsql;
 
-					drop trigger if exists #{table_name}_ad on #{table_name};
-					create trigger #{table_name}_ad after delete on #{table_name}
-					for each row execute procedure #{table_name}_ad();
-				}
-			end
+          drop trigger if exists #{table_name}_ad on #{table_name};
+          create trigger #{table_name}_ad after delete on #{table_name}
+          for each row execute procedure #{table_name}_ad();
+        }
+      end
 
-			def column_list(column_names)
-				column_names.map { |c| "\"#{c}\"" }.join(', ')
-			end
-		end
-	end
+      def column_list(column_names)
+        column_names.map { |c| "\"#{c}\"" }.join(', ')
+      end
+    end
+  end
 end

data/lib/temporal_tables/history_hook.rb

@@ -1,50 +1,50 @@
 module TemporalTables
-	# This hooks in a "history" method to ActiveRecord::Base which will
-	# return the class's History class.  The history class extends the original
-	# class, but runs against the history table to provide temporal results.
-	#
-	#  class Person < ActiveRecord::Base
-	#    attr_accessible :name
-	#  end
-	#
-	#  Person         #=> Person(id: integer, name: string)
-	#  Person.history #=> PersonHistory(history_id: integer, id: integer, name: string, eff_from: datetime, eff_to: datetime)
-	module HistoryHook
-		def self.included(base)
-			base.class_eval do
-				# Return this class's history class.
-				# If it doesn't exist yet, create and initialize it, as well
-				# as all dependent classes (through associations).
-				def self.history
-					raise "Can't view history of history" if name =~ /History$/
+  # This hooks in a "history" method to ActiveRecord::Base which will
+  # return the class's History class.  The history class extends the original
+  # class, but runs against the history table to provide temporal results.
+  #
+  #  class Person < ActiveRecord::Base
+  #    attr_accessible :name
+  #  end
+  #
+  #  Person         #=> Person(id: integer, name: string)
+  #  Person.history #=> PersonHistory(history_id: integer, id: integer, name: string, eff_from: datetime, eff_to: datetime)
+  module HistoryHook
+    def self.included(base)
+      base.class_eval do
+        # Return this class's history class.
+        # If it doesn't exist yet, create and initialize it, as well
+        # as all dependent classes (through associations).
+        def self.history
+          raise "Can't view history of history" if name =~ /History$/
 
-					history_class = "#{name}History"
-					history_class.constantize
-				rescue NameError
-					# If the history class doesn't exist yet, create it
-					new_class = Class.new(self) do
-						include TemporalTables::TemporalClass
-					end
-					segments = history_class.split("::")
-					object_class = segments[0...-1].inject(Object) { |o, s| o.const_get(s) }
-					object_class.const_set segments.last, new_class
+          history_class = "#{name}History"
+          history_class.constantize
+        rescue NameError
+          # If the history class doesn't exist yet, create it
+          new_class = Class.new(self) do
+            include TemporalTables::TemporalClass
+          end
+          segments = history_class.split("::")
+          object_class = segments[0...-1].inject(Object) { |o, s| o.const_get(s) }
+          object_class.const_set segments.last, new_class
 
-					# Traverse associations and make sure they have
-					# history classes too.
-					history_class.constantize.temporalize_associations!
-					history_class.constantize
-				end	
-			end
-		end
+          # Traverse associations and make sure they have
+          # history classes too.
+          history_class.constantize.temporalize_associations!
+          history_class.constantize
+        end
+      end
+    end
 
-		# Returns a scope for the list of all history records for this 
-		# particular object.
-		def history
-			clazz = is_a?(TemporalTables::TemporalClass) ? self.class : self.class.history
-			oid = is_a?(TemporalTables::TemporalClass) ? orig_class.primary_key : self.class.primary_key
-			clazz.unscoped.where(id: attributes[oid]).order(:eff_from)
-		end
-	end
+    # Returns a scope for the list of all history records for this
+    # particular object.
+    def history
+      clazz = is_a?(TemporalTables::TemporalClass) ? self.class : self.class.history
+      oid = is_a?(TemporalTables::TemporalClass) ? orig_class.primary_key : self.class.primary_key
+      clazz.unscoped.where(id: attributes[oid]).order(:eff_from)
+    end
+  end
 end
 
 ActiveRecord::Base.send :include, TemporalTables::HistoryHook

data/lib/temporal_tables/join_extensions.rb

@@ -1,20 +1,20 @@
 module TemporalTables
-	# This is required for eager_load to work in Rails 5.0.x
-	module JoinDependencyExtensions
-		def build_constraint(klass, table, key, foreign_table, foreign_key)
-			constraint = super
-			if at_value = Thread.current[:at_time]
-				constraint = constraint.and(klass.build_temporal_constraint(at_value))
-			end
-			constraint
-		end
-	end
+  # This is required for eager_load to work in Rails 5.0.x
+  module JoinDependencyExtensions
+    def build_constraint(klass, table, key, foreign_table, foreign_key)
+      constraint = super
+      if at_value = Thread.current[:at_time]
+        constraint = constraint.and(klass.build_temporal_constraint(at_value))
+      end
+      constraint
+    end
+  end
 end
 
 case Rails::VERSION::MAJOR
 when 5
-	case Rails::VERSION::MINOR
-	when 0, 1
-		ActiveRecord::Associations::JoinDependency::JoinAssociation.prepend TemporalTables::JoinDependencyExtensions
-	end
+  case Rails::VERSION::MINOR
+  when 0, 1
+    ActiveRecord::Associations::JoinDependency::JoinAssociation.prepend TemporalTables::JoinDependencyExtensions
+  end
 end

data/lib/temporal_tables/preloader_extensions.rb

@@ -1,19 +1,19 @@
 module TemporalTables
-	# Uses the at time when fetching preloaded records
-	module PreloaderExtensions
-		def build_scope
-			# It seems the at time can be in either of these places, but not both,
-			# depending on when the preloading happens to be done
-			at_time = @owners.first.at_value if @owners.first.respond_to?(:at_value)
-			at_time ||= Thread.current[:at_time]
+  # Uses the at time when fetching preloaded records
+  module PreloaderExtensions
+    def build_scope
+      # It seems the at time can be in either of these places, but not both,
+      # depending on when the preloading happens to be done
+      at_time = @owners.first.at_value if @owners.first.respond_to?(:at_value)
+      at_time ||= Thread.current[:at_time]
 
-			if at_time
-				super.at(at_time)
-			else
-				super
-			end
-		end
-	end
+      if at_time
+        super.at(at_time)
+      else
+        super
+      end
+    end
+  end
 end
 
 ActiveRecord::Associations::Preloader::Association.prepend TemporalTables::PreloaderExtensions

data/lib/temporal_tables/reflection_extensions.rb

@@ -1,21 +1,21 @@
 module TemporalTables
-	# This is required for eager_load to work in Rails 5.2.x
-	module AbstractReflectionExtensions
-		def build_join_constraint(table, foreign_table)
-			constraint = super
-			if at_value = Thread.current[:at_time]
-				constraint = constraint.and(klass.build_temporal_constraint(at_value))
-			end
-			constraint
-		end
-	end
+  # This is required for eager_load to work in Rails 5.2.x
+  module AbstractReflectionExtensions
+    def build_join_constraint(table, foreign_table)
+      constraint = super
+      if at_value = Thread.current[:at_time]
+        constraint = constraint.and(klass.build_temporal_constraint(at_value))
+      end
+      constraint
+    end
+  end
 end
 
 case Rails::VERSION::MAJOR
 when 5
-	case Rails::VERSION::MINOR
-	when 2
-		ActiveRecord::Reflection::AbstractReflection.prepend TemporalTables::AbstractReflectionExtensions
-	end
+  case Rails::VERSION::MINOR
+  when 2
+    ActiveRecord::Reflection::AbstractReflection.prepend TemporalTables::AbstractReflectionExtensions
+  end
 end
 

data/lib/temporal_tables/relation_extensions.rb

@@ -1,94 +1,94 @@
 module TemporalTables
-	# Stores the time from the "at" field into each of the resulting objects
-	# so that it can be carried forward in subsequent queries.
-	module RelationExtensions
-		def self.included(base)
-			base.class_eval do
-				ActiveRecord::Relation::SINGLE_VALUE_METHODS << :at
-			end
-		end
+  # Stores the time from the "at" field into each of the resulting objects
+  # so that it can be carried forward in subsequent queries.
+  module RelationExtensions
+    def self.included(base)
+      base.class_eval do
+        ActiveRecord::Relation::SINGLE_VALUE_METHODS << :at
+      end
+    end
 
-		def at_value
-			case Rails::VERSION::MINOR
-			when 0
-				@values.fetch(:at, nil) || Thread.current[:at_time]
-			else
-				get_value(:at) || Thread.current[:at_time]
-			end
-		end
+    def at_value
+      case Rails::VERSION::MINOR
+      when 0
+        @values.fetch(:at, nil) || Thread.current[:at_time]
+      else
+        get_value(:at) || Thread.current[:at_time]
+      end
+    end
 
-		def at_value=(value)
-			case Rails::VERSION::MINOR
-			when 0
-				@values[:at] = value
-			else
-				set_value(:at, value)
-			end
-		end
+    def at_value=(value)
+      case Rails::VERSION::MINOR
+      when 0
+        @values[:at] = value
+      else
+        set_value(:at, value)
+      end
+    end
 
-		def at(*args)
-			spawn.at!(*args)
-		end
+    def at(*args)
+      spawn.at!(*args)
+    end
 
-		def at!(value)
-			self.at_value = value
-			self.where!(klass.build_temporal_constraint(value))
-		end
+    def at!(value)
+      self.at_value = value
+      self.where!(klass.build_temporal_constraint(value))
+    end
 
-		def to_sql(*args)
-			threadify_at do
-				super *args
-			end
-		end
+    def to_sql(*args)
+      threadify_at do
+        super *args
+      end
+    end
 
-		def threadify_at
-			if at_value && !Thread.current[:at_time]
-				Thread.current[:at_time] = at_value
-				result = yield
-				Thread.current[:at_time] = nil
-			else
-				result = yield
-			end
-			result
-		end
+    def threadify_at
+      if at_value && !Thread.current[:at_time]
+        Thread.current[:at_time] = at_value
+        result = yield
+        Thread.current[:at_time] = nil
+      else
+        result = yield
+      end
+      result
+    end
 
-		def limited_ids_for(*args)
-			threadify_at do
-				super *args
-			end
-		end
+    def limited_ids_for(*args)
+      threadify_at do
+        super *args
+      end
+    end
 
-		def exec_queries
-			# Note that record preloading, like when you specify
-			#  MyClass.includes(:associations)
-			# happens within this exec_queries call.  That's why we needed to
-			# store the at_time in the thread above.
-			threadify_at do
-				super
-			end
+    def exec_queries
+      # Note that record preloading, like when you specify
+      #  MyClass.includes(:associations)
+      # happens within this exec_queries call.  That's why we needed to
+      # store the at_time in the thread above.
+      threadify_at do
+        super
+      end
 
-			if historical?
-				# Store the at value on each record returned
-				@records.each do |r|
-					r.at_value = at_value
-				end
-			end
-			@records
-		end
+      if historical?
+        # Store the at value on each record returned
+        @records.each do |r|
+          r.at_value = at_value
+        end
+      end
+      @records
+    end
 
-		def historical?
-			table_name =~ /_h$/i && at_value
-		end
+    def historical?
+      table_name =~ /_h$/i && at_value
+    end
 
-		# Only needed for Rails 5.1.x
-		def default_value_for(name)
-			if name == :at
-				nil
-			else
-				super(name)
-			end
-		end
-	end
+    # Only needed for Rails 5.1.x
+    def default_value_for(name)
+      if name == :at
+        nil
+      else
+        super(name)
+      end
+    end
+  end
 end
 
 ActiveRecord::Relation.prepend TemporalTables::RelationExtensions