temporal_tables 0.6.1

data/lib/temporal_tables/scope_extensions.rb

@@ -0,0 +1,13 @@
+module TemporalTables
+	module NamedExtensionsWithHistory
+		def scope(name, body, &block)
+			if history
+				history_body = -> { history.instance_exec &body }
+				history.scope_without_history name, history_body, &block
+			end
+			super name, body, &block
+		end
+	end
+end
+
+ActiveRecord::Scoping::Named::ClassMethods.send :prepend, TemporalTables::NamedExtensionsWithHistory

data/lib/temporal_tables/temporal_adapter.rb

@@ -0,0 +1,159 @@
+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
+			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 index_name_exists?(temporal_name(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
+	end
+end

data/lib/temporal_tables/temporal_class.rb

@@ -0,0 +1,91 @@
+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
+				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)
+				sti_class = super(type_name)
+				sti_class = sti_class.history unless sti_class.respond_to?(:orig_class)
+				sti_class
+			end
+		end
+
+		module ClassMethods
+			def orig_class
+				name.sub(/History$/, "").constantize
+			end
+
+			def descends_from_active_record?
+				superclass.descends_from_active_record?
+			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

@@ -0,0 +1,3 @@
+module TemporalTables
+	VERSION = "0.6.1"
+end

data/lib/temporal_tables/whodunnit.rb

@@ -0,0 +1,19 @@
+module TemporalTables
+	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
+end

data/spec/basic_history_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe Person do
+	let(:emily) { Person.create name: "Emily" }
+	let(:historical_emily) { emily.history.last }
+
+	before do
+		emily
+		@init_time = Time.now
+		sleep 0.1
+	end
+
+	describe "upon making significant life changes" do
+		let!(:coven) { Coven.create name: "Double Double Toil & Trouble" }
+		let!(:wart) { Wart.create person: emily, hairiness: 3 }
+
+		before do
+			emily.update_attributes name: "Grunthilda", coven: coven
+			sleep 0.1
+		end
+
+		describe "when affirming changes" do
+			it "should have new name" do
+				expect(emily.name).to eq("Grunthilda")
+				expect(historical_emily.name).to eq("Grunthilda")
+			end
+
+			it "should belong to coven" do
+				expect(emily.coven.name).to eq(coven.name)
+				expect(historical_emily.coven.name).to eq(coven.name)
+			end
+
+			it "should have a wart" do
+				expect(emily.warts).to eq([wart])
+				expect(emily.history.at(Time.now).last.warts).to eq([wart.history.last])
+			end
+
+			it "should allow scopes on associations" do
+				expect(emily.warts.very_hairy).to eq([wart])
+				expect(historical_emily.warts.very_hairy).to eq([wart.history.last])
+			end
+		end
+
+		describe "when reflecting on the past" do
+			let(:orig_emily) { emily.history.at(@init_time).last }
+
+			it "should have historical name" do
+				expect(orig_emily.name).to eq("Emily")
+				expect(orig_emily.at_value).to eq(@init_time)
+			end
+
+			it "should not belong to a coven or have warts" do
+				expect(orig_emily.coven).to eq(nil)
+				expect(orig_emily.warts.count).to eq(0)
+			end
+		end
+
+		describe "when preloading associations" do
+			let(:orig_emily) { emily.history.at(@init_time).preload(:warts).first }
+
+			it 'should preload the correct time' do
+				expect(orig_emily.warts).to be_empty
+			end
+		end
+
+		describe "when eager_loading associations" do
+			let(:orig_emily) { emily.history.at(@init_time).eager_load(:warts).first }
+
+			it 'should include the correct time' do
+				expect(orig_emily.warts).to be_empty
+			end
+		end
+
+		describe "when checking simple code values" do
+			it "should have correct class names" do
+				expect(emily.class.name).to eq("Person")
+				expect(historical_emily.class.name).to eq("PersonHistory")
+
+				expect(Person.history).to eq(PersonHistory)
+			end
+
+			it "should have correct class hierarchies" do
+				expect(emily.is_a?(Person)).to eq(true)
+				expect(emily.is_a?(PersonHistory)).to eq(false)
+
+				expect(historical_emily.is_a?(Person)).to eq(true)
+				expect(historical_emily.is_a?(PersonHistory)).to eq(true)
+			end
+		end
+	end
+end

data/spec/extensions/combustion.rb

@@ -0,0 +1,9 @@
+class Combustion::Database::Reset
+  def call
+    configuration = resettable_db_configs[Rails.env]
+    adapter = configuration["adapter"] ||
+              configuration["url"].split("://").first
+
+    operator_class(adapter).new(configuration).reset
+  end
+end

data/spec/internal/app/models/coven.rb

@@ -0,0 +1,3 @@
+class Coven < ActiveRecord::Base
+  has_many :people
+end

data/spec/internal/app/models/person.rb

@@ -0,0 +1,4 @@
+class Person < ActiveRecord::Base
+  belongs_to :coven
+  has_many :warts
+end

data/spec/internal/app/models/wart.rb

@@ -0,0 +1,7 @@
+class Wart < ActiveRecord::Base
+  belongs_to :person
+
+  scope :very_hairy, -> {
+    where(arel_table[:hairiness].gteq(3))
+  }
+end

data/spec/internal/config/database.sample.yml

@@ -0,0 +1,12 @@
+mysql:
+  adapter: mysql2
+  database: temporal_tables_test
+  host: localhost
+  username: root
+  password:
+
+postgresql:
+  adapter: postgresql
+  database: temporal_tables_test
+  user:
+  password:

data/spec/internal/config/routes.rb

@@ -0,0 +1,3 @@
+Rails.application.routes.draw do
+  #
+end

data/spec/internal/db/schema.rb

@@ -0,0 +1,16 @@
+ActiveRecord::Schema.define do
+	create_table :people, temporal: true, force: true do |t|
+		t.references :coven
+		t.string :name
+	end
+
+	create_table :covens, force: true do |t|
+		t.string :name
+	end
+	add_temporal_table :covens
+
+	create_table :warts, temporal: true, force: true do |t|
+		t.references :person
+		t.integer :hairiness
+	end
+end