time-travel 1.0.0

data/lib/tasks/create_postgres_function.rake

@@ -0,0 +1,6 @@
+namespace :time_travel do
+  desc "creates sql function used by time_travel gem to manage history"
+  task :create_postgres_function, [:schema] => [:environment] do |task, args|
+    TimeTravel::SqlFunctionHelper.create(args[:schema])
+  end
+end

data/lib/time_travel/configuration.rb

@@ -0,0 +1,9 @@
+module TimeTravel
+  class Configuration
+    attr_accessor :update_mode
+
+    def initialize
+      @update_mode="native"
+    end
+  end
+end

data/lib/time_travel/railtie.rb

@@ -0,0 +1,7 @@
+module TimeTravel
+  class Railtie < ::Rails::Railtie
+    rake_tasks do
+      load 'tasks/create_postgres_function.rake'
+    end
+  end
+end

data/lib/time_travel/sql_function_helper.rb

@@ -0,0 +1,19 @@
+module TimeTravel
+  class SqlFunctionHelper
+    def self.create(schema=nil)
+      connection = ActiveRecord::Base.connection
+      gem_root = File.expand_path('../../../', __FILE__)
+      ActiveRecord::Base.transaction do
+        result = connection.execute("SHOW search_path;")
+        if schema && !result.first["search_path"].eql?(schema)
+          connection.execute "SET search_path TO #{schema};"
+        end
+        connection.execute(IO.read(gem_root + "/sql/create_column_value.sql"))
+        connection.execute(IO.read(gem_root + "/sql/get_json_attrs.sql"))
+        connection.execute(IO.read(gem_root + "/sql/update_history.sql"))
+        connection.execute(IO.read(gem_root + "/sql/update_bulk_history.sql"))
+        connection.execute(IO.read(gem_root + "/sql/update_latest.sql"))
+      end
+    end
+  end
+end

data/lib/time_travel/timeline.rb

@@ -0,0 +1,225 @@
+require "time_travel/sql_function_helper"
+require "time_travel/update_helper"
+require "pp"
+
+class Timeline
+  include UpdateHelper
+  UPDATE_MODE=ENV["TIME_TRAVEL_UPDATE_MODE"] || TimeTravel.configuration.update_mode
+
+  def initialize(model_class,**timeline_identifiers)
+    @model_class=model_class
+    @timeline_identifiers=timeline_identifiers
+    @timeline=model_class.where(**timeline_identifiers)
+  end
+
+  def at(date, as_of: Time.current)
+    record=@timeline
+      .where("effective_from <= ?", date)
+      .where("effective_till > ?", date)
+      .where("valid_from <= ?", as_of)
+      .where("valid_till > ?", as_of)
+    record.first if record.exists?
+
+  end
+
+  def full_history
+    @timeline.order("effective_from ASC").order("valid_from ASC")
+  end
+
+  def as_of(valid_date=Time.current)
+    @timeline
+      .where("valid_from <= ?", valid_date)
+      .where("valid_till > ?", valid_date)
+      .order("effective_from ASC")
+  end
+
+  def valid_history(effective_at: Time.current)
+    @timeline
+        .where("effective_from <= ?", effective_date)
+        .where("effective_till > ?", effective_date)
+        .order("valid_from ASC")
+  end
+
+  def effective_history
+    @timeline.where(valid_till: TimeTravel::INFINITE_DATE).order("effective_from ASC")
+  end
+
+  def construct_record(attributes,current_time:,effective_from:,effective_till:)
+    record=@model_class.new
+    record.attributes=attributes
+    @timeline_identifiers.each do |attribute,value|
+      record[attribute]=value
+    end
+    record.current_time=current_time
+    record.effective_from=effective_from
+    record.effective_till=effective_till
+    record
+  end
+
+  def create_or_update(attributes,current_time: Time.current, effective_from: nil, effective_till: nil)
+    if self.has_history?
+      self.update(
+        attributes, current_time: current_time, effective_from: effective_from, effective_till: effective_till)
+    else
+      self.create(
+        attributes,current_time: current_time, effective_from: effective_from, effective_till: effective_till)
+    end
+  end
+
+  def create(attributes,current_time: Time.current, effective_from: nil, effective_till: nil)
+    record=construct_record(attributes, current_time: current_time, 
+                            effective_from: effective_from, effective_till: effective_till)
+    if self.has_history?
+      raise "timeline already exists"
+    end
+    raise ActiveRecord::RecordInvalid.new(record) unless record.validate_update(attributes)
+    record.save!
+    record
+  end
+
+  def self.bulk_update(model_class, attribute_set, current_time: Time.current, latest_transactions: false)
+    if UPDATE_MODE=="native"
+      attribute_set.each do |attributes|
+        attributes.symbolize_keys!
+        if attributes.slice(*model_class.timeline_fields).keys.length != model_class.timeline_fields.length
+          raise "Timeline identifiers can't be empty"
+        end
+        timeline=model_class.timeline(attributes.slice(*model_class.timeline_fields))
+        timeline.create_or_update(
+          attributes, 
+          current_time: current_time, 
+          effective_from: attributes[:effective_from], 
+          effective_till: attributes[:effective_till]
+        )
+      end
+    else
+      update_sql(
+        model_class,
+        attribute_set, 
+        current_time: current_time, 
+        latest_transactions: latest_transactions
+      )
+    end
+  end
+
+  def update(attributes, current_time: Time.current, effective_from: nil, effective_till: nil)
+    attributes.symbolize_keys!
+    attributes=attributes.except(*ignored_update_attributes)
+    return true if attributes.empty?
+    if not self.has_history?
+      raise "timeline not found"
+    end
+    record=construct_record(
+      attributes, current_time: current_time, effective_from: effective_from, effective_till: effective_till)
+    raise ActiveRecord::RecordInvalid.new(record) unless record.validate_update(attributes)
+    record_attributes=record.attributes.except(*ignored_copy_attributes).symbolize_keys!
+    update_attributes=record_attributes.slice(*attributes.keys)
+    if UPDATE_MODE=="native"
+      update_native(
+        record, update_attributes, 
+        current_time: current_time, effective_from: effective_from, effective_till: effective_till
+      )
+    else
+      update_attributes.merge!(@timeline_identifiers)
+      update_attributes.merge!({effective_from: effective_from, effective_till: effective_till})
+      self.class.update_sql(@model_class, [update_attributes], current_time: current_time)
+    end
+  end
+ 
+
+  def update_native(record, update_attributes, current_time: Time.current, effective_from: nil, effective_till: nil)
+    affected_records = fetch_history_for_correction(record)
+    affected_timeframes = get_affected_timeframes(record, affected_records)
+
+    corrected_records = construct_corrected_records(
+      record, affected_timeframes, affected_records, update_attributes)
+    squished_records = squish_record_history(corrected_records)
+
+    @model_class.transaction do
+      squished_records.each do |record|
+        insert_record=record.merge(
+          current_time: current_time
+        )
+        @model_class.create!(insert_record)
+      end
+
+      affected_records.each {|record| record.update_attribute(:valid_till, current_time)}
+    end
+    true
+  end
+
+  def self.update_sql(model_class, attribute_set, current_time: Time.current, latest_transactions: false)
+    other_attrs = (model_class.column_names - ["id", "created_at", "updated_at", "valid_from", "valid_till"])
+    empty_obj_attrs = other_attrs.map{|attr| {attr => nil}}.reduce(:merge!).with_indifferent_access
+    query = ActiveRecord::Base.connection.quote(model_class.unscoped.where(valid_till: TimeTravel::INFINITE_DATE).to_sql)
+    table_name = ActiveRecord::Base.connection.quote(model_class.table_name)
+
+    attribute_set.each_slice(model_class.batch_size).to_a.each do |batched_attribute_set|
+      batched_attribute_set.each do |attrs|
+        attrs.symbolize_keys!
+        set_enum(model_class, attrs)
+        attrs[:timeline_clauses], attrs[:update_attrs] = attrs.partition do  |key, value|
+          key.in?(model_class.timeline_fields)
+        end.map(&:to_h).map(&:symbolize_keys!)
+        if attrs[:timeline_clauses].empty? || attrs[:timeline_clauses].values.any?(&:blank?)
+          raise "Timeline identifiers can't be empty"
+        end
+        obj_current_time = attrs[:update_attrs].delete(:current_time) || current_time
+        attrs[:effective_from] = db_timestamp(attrs[:update_attrs].delete(:effective_from) || obj_current_time)
+        attrs[:effective_till] = db_timestamp(attrs[:update_attrs].delete(:effective_till) || TimeTravel::INFINITE_DATE)
+        attrs[:current_time] = db_timestamp(obj_current_time)
+        attrs[:infinite_date] = db_timestamp(TimeTravel::INFINITE_DATE)
+        attrs[:empty_obj_attrs] = empty_obj_attrs.merge(attrs[:timeline_clauses])
+      end
+      attrs = ActiveRecord::Base.connection.quote(batched_attribute_set.to_json)
+      begin
+        result = ActiveRecord::Base.connection.execute("select update_bulk_history(#{query},#{table_name},#{attrs},#{latest_transactions})")
+      rescue => e
+        ActiveRecord::Base.connection.execute 'ROLLBACK'
+        raise e
+      end
+    end
+  end
+  
+  def self.set_enum(model_class, attrs)
+    enum_fields, enum_items = model_class.enum_info
+    enum_fields.each do |key|
+      string_value = attrs[key]
+      attrs[key] = enum_items[key][string_value] unless string_value.blank?
+    end
+  end
+
+  def self.db_timestamp(datetime)
+    datetime.to_datetime.utc.strftime(TimeTravel::PRECISE_TIME_FORMAT)
+  end
+
+  def terminate(current_time: Time.current, effective_till: nil)
+    effective_record = self.effective_history.where(effective_till: TimeTravel::INFINITE_DATE).first
+    if effective_record.present?
+      attributes = effective_record.attributes.except(*ignored_copy_attributes)
+      @model_class.transaction do
+        @model_class.create!(
+          attributes.merge(
+            effective_till: (effective_till || current_time),
+            current_time: current_time
+          )
+        )
+        effective_record.update_attribute(:valid_till, current_time)
+      end
+    else
+      raise "no effective record found on timeline"
+    end
+  end
+
+  def ignored_update_attributes
+    ["id", "created_at", "updated_at", "effective_from", "effective_till", "valid_from", "valid_till"]
+  end
+
+  def ignored_copy_attributes
+    ["id", "created_at", "updated_at", "valid_from", "valid_till"]
+  end
+
+  def has_history?
+    effective_history.exists?
+  end
+end

data/lib/time_travel/timeline_helper.rb

@@ -0,0 +1,105 @@
+require 'rails'
+require "time_travel/railtie"
+require "time_travel/sql_function_helper"
+require "time_travel/update_helper"
+require "time_travel/configuration"
+
+module TimeTravel::TimelineHelper
+  extend ActiveSupport::Concern
+
+  included do
+    attr_accessor :current_time
+    before_validation :set_current_time
+    before_validation :set_effective_defaults
+    before_create :set_validity_defaults
+
+    validates_presence_of :effective_from
+    validate :effective_range_timeline
+    validate :absence_of_valid_from_till, on: :create
+
+    scope :historically_valid, -> { where(valid_till: TimeTravel::INFINITE_DATE) }
+    scope :effective_now, -> { where(effective_till: TimeTravel::INFINITE_DATE, valid_till: TimeTravel::INFINITE_DATE) }
+  end
+
+
+  module ClassMethods
+    attr_accessor :enum_fields, :enum_items
+
+    def timeline_fields
+      raise "timeline_fields should be defined to return the list of fields which identify a timeline in the record"
+    end
+    
+    def timeline(**timeline_identifiers)
+      Timeline.new(self,timeline_identifiers)
+    end
+
+    def enum_info
+      self.enum_items ||= self.defined_enums.symbolize_keys
+      self.enum_fields ||= self.enum_items.keys
+      [self.enum_fields, self.enum_items]
+    end
+
+  end
+
+  # set defaults
+  def set_current_time
+    self.current_time ||= Time.current
+  end
+
+  def set_effective_defaults
+    self.effective_from ||= current_time
+    self.effective_till ||= TimeTravel::INFINITE_DATE
+  end
+
+  def set_validity_defaults
+    self.valid_from ||= current_time
+    self.valid_till ||= TimeTravel::INFINITE_DATE
+  end
+
+  def has_history
+    if self.class.has_history?
+      self.errors.add("base", "create called on alread existing timeline")
+    end
+  end
+
+  def no_history
+    if not self.class.has_history?
+      self.errors.add("base", "update called on timeline that doesn't exist")
+    end
+  end
+
+  # validations
+  def effective_range_timeline
+    if self.effective_from > self.effective_till
+      self.errors.add(:base, "effective_from can't be greater than effective_till")
+    end
+  end
+
+  def absence_of_valid_from_till
+    if self.valid_from.present? || self.valid_till.present?
+      self.errors.add(:base, "valid_from and valid_till can't be set")
+    end
+  end
+
+  def validate_update(attributes)
+    self.assign_attributes(attributes)
+    self.valid?
+  end
+
+  def invalid_now?
+    !self.valid_now?
+  end
+
+  def valid_now?
+    self.valid_from.present? and self.valid_till==TimeTravel::INFINITE_DATE
+  end
+
+  def ineffective_now?
+    !self.effective_now?
+  end
+
+  def effective_now?
+    self.effective_from.present? and self.effective_till==TimeTravel::INFINITE_DATE
+  end
+end
+

data/lib/time_travel/update_helper.rb

@@ -0,0 +1,72 @@
+module UpdateHelper
+  def fetch_history_for_correction(record)
+    correction_head = self.effective_history
+                        .where("effective_from <= ?", record.effective_from)
+                        .where("effective_till > ?", record.effective_from).first
+    correction_tail = self.effective_history
+                        .where("effective_from < ?", record.effective_till)
+                        .where("effective_till >= ?", record.effective_till).first
+    correction_range = self.effective_history
+                        .where("effective_from > ?", record.effective_from)
+                        .where("effective_till < ?", record.effective_till)
+
+    [correction_head, correction_range.to_a, correction_tail].flatten.compact.uniq
+  end
+
+  def get_affected_timeframes(record,affected_records)
+    affected_timeframes = affected_records.map { |record| [record.effective_from, record.effective_till] }
+    affected_timeframes << [record.effective_from, record.effective_till]
+    affected_timeframes = affected_timeframes.flatten.uniq.sort
+    affected_timeframes.each_with_index.map{|time, i| {from: time, till: affected_timeframes[i+1]} }[0..-2]
+  end
+
+  def construct_corrected_records(new_record, affected_timeframes, affected_records, attributes)
+    affected_timeframes.map do |timeframe|
+      matched_record = affected_records.find do |record|
+        record.effective_from <= timeframe[:from] && record.effective_till >= timeframe[:till]
+      end
+
+      if matched_record
+        attrs = matched_record.attributes.except(*ignored_copy_attributes)
+        if timeframe[:from] >= new_record.effective_from && timeframe[:till] <= new_record.effective_till
+          attrs.merge!(attributes)
+        end
+      else
+        attrs = new_record.attributes.except(*ignored_copy_attributes)
+      end
+
+      attrs.merge!(
+        **@timeline_identifiers,
+        effective_from: timeframe[:from],
+        effective_till: timeframe[:till]).symbolize_keys
+    end
+  end
+
+  def squish_record_history(corrected_records)
+    squished = []
+
+    corrected_records.each do |current|
+      # fetch and compare last vs current record
+      last_squished = squished.last
+      effective_attr = [:effective_from, :effective_till]
+
+      if last_squished &&
+        if last_squished.except(*effective_attr) == current.except(*effective_attr) &&
+            last_squished[:effective_till] == current[:effective_from]
+          # remove last_squished and push squished attributes
+
+          squished = squished[0..-2]
+          squished << last_squished.merge(effective_from: last_squished[:effective_from],
+                              effective_till: current[:effective_till])
+        end
+      else
+        squished << current
+      end
+    end
+    squished.compact
+  end
+
+  def ignored_copy_attributes
+    ["id", "created_at", "updated_at", "valid_from", "valid_till"]
+  end
+end