acts_as_scd 0.0.1

data/lib/acts_as_scd/initialize.rb

@@ -0,0 +1,114 @@
+module ActsAsScd
+
+  # Internal value to represent the start of time
+  START_OF_TIME   = 0
+  # Internal value to represent the end of time
+  END_OF_TIME     = 99999999
+
+  # TODO: paremeterize the column names
+
+  # Column that represents the identity of an entity
+  IDENTITY_COLUMN = :identity
+  # Column that represents start of an iteration's life
+  START_COLUMN    = :effective_from
+  # Column that represents end of an iteration's life
+  END_COLUMN      = :effective_to
+
+  def self.initialize_scd(model)
+    model.extend ClassMethods
+
+    # Current iterations
+    model.scope :current, ->{model.where("#{model.effective_to_column_sql} = :date", :date=>END_OF_TIME)}
+    model.scope :initial, ->{model.where("#{model.effective_from_column_sql} = :date", :date=>START_OF_TIME)}
+    # Iterations effective at given date
+    # Note that since Array has an 'at' method, this cannot be applied directly to
+    # associations (the Array method would be used after generating an Array from the query).
+    # It is necessary to use .scoped.at(...) for associations.
+    model.scope :at, ->(date=nil){
+      # TODO: consider renaming this to current_at or active_at to avoid having to use
+      # scoped with associations
+      if date.present?
+        model.where(%{#{model.effective_from_column_sql}<=:date AND #{model.effective_to_column_sql}>:date}, :date=>model.effective_date(date))
+      else
+        model.current
+      end
+    }
+    # Iterations superseded/terminated
+    model.scope :ended, ->{model.where("#{model.effective_to_column_sql} < :date", :date=>END_OF_TIME)}
+    model.scope :earliest, ->(identity=nil){
+      if identity
+        identity_column = model.identity_column_sql('earliest_tmp')
+        if Array==identity
+          identity_list = identity.map{|i| model.connection.quote(i)}*','
+          where_condition = "WHERE #{identity_column} IN (#{identity_list})"
+        else
+          where_condition = "WHERE #{identity_column}=#{model.connection.quote(identity)}"
+        end
+      end
+      model.where(
+        %{(#{model.identity_column_sql}, #{model.effective_from_column_sql}) IN
+            (SELECT #{model.identity_column_sql('earliest_tmp')},
+                    MIN(#{model.effective_from_column_sql('earliest_tmp')}) AS earliest_from
+             FROM #{model.table_name} AS "earliest_tmp"
+             #{where_condition}
+             GROUP BY #{model.identity_column_sql('earliest_tmp')})
+         }
+      )
+    }
+    # Latest iteration (terminated or current) of each identity
+    model.scope :latest, ->(identity=nil){
+      if identity
+        identity_column = model.identity_column_sql('latest_tmp')
+        if Array===identity
+          identity_list = identity.map{|i| model.connection.quote(i)}*','
+          where_condition = "WHERE #{identity_column} IN (#{identity_list})"
+        else
+          where_condition = "WHERE #{identity_column}=#{model.connection.quote(identity)}"
+        end
+      end
+      model.where(
+        %{(#{model.identity_column_sql}, #{model.effective_to_column_sql}) IN
+          (SELECT #{model.identity_column_sql('latest_tmp')},
+                  MAX(#{model.effective_to_column_sql('latest_tmp')}) AS latest_to
+           FROM #{model.table_name} AS "latest_tmp"
+           #{where_condition}
+           GROUP BY #{model.identity_column_sql('latest_tmp')})
+         }
+      )
+    }
+    # Last superseded/terminated iterations
+    # model.scope :last_ended, ->{model.where(%{#{model.effective_to_column_sql} = (SELECT max(#{model.effective_to_column_sql('max_to_tmp')}) FROM "#{model.table_name}" AS "max_to_tmp" WHERE #{model.effective_to_column_sql('max_to_tmp')}<#{END_OF_TIME})})}
+    # last iterations of terminated identities
+    # model.scope :terminated, ->{model.where(%{#{model.effective_to_column_sql}<#{END_OF_TIME} AND #{model.effective_to_column_sql}=(SELECT max(#{model.effective_to_column_sql('max_to_tmp')}) FROM "#{model.table_name}" AS "max_to_tmp")})}
+    model.scope :terminated, ->(identity=nil){
+      where_condition = identity && " WHERE #{model.identity_column_sql('max_to_tmp')}=#{model.connection.quote(identity)} "
+      model.where(
+        %{#{model.effective_to_column_sql}<#{END_OF_TIME}
+          AND (#{model.identity_column_sql}, #{model.effective_to_column_sql}) IN
+            (SELECT #{model.identity_column_sql('max_to_tmp')},
+                    max(#{model.effective_to_column_sql('max_to_tmp')})
+             FROM "#{model.table_name}" AS "max_to_tmp" #{where_condition})
+         }
+      )
+    }
+    # iterations superseded
+    model.scope :superseded, ->(identity=nil){
+      where_condition = identity && " AND #{model.identity_column_sql('max_to_tmp')}=#{model.connection.quote(identity)} "
+      model.where(
+        %{(#{model.identity_column_sql}, #{model.effective_to_column_sql}) IN
+          (SELECT #{model.identity_column_sql('max_to_tmp')},
+                  max(#{model.effective_to_column_sql('max_to_tmp')})
+           FROM "#{model.table_name}" AS "max_to_tmp"
+           WHERE #{model.effective_to_column_sql('max_to_tmp')}<#{END_OF_TIME})
+                 #{where_condition}
+                 AND EXISTS (SELECT * FROM "#{model.table_name}" AS "ex_from_tmp"
+                             WHERE #{model.effective_from_column_sql('ex_from_tmp')}==#{model.effective_to_column_sql})
+        }
+      )
+    }
+    model.before_validation :compute_identity
+    model.validates_uniqueness_of IDENTITY_COLUMN, :scope=>[START_COLUMN, END_COLUMN], :message=>"El periodo de vigencia no es válido"
+    model.before_destroy :remove_this_iteration
+  end
+
+end

data/lib/acts_as_scd/instance_methods.rb

@@ -0,0 +1,105 @@
+module ActsAsScd
+
+  # TODO: replace identity by send(IDENTITY_COLUMN)...
+
+  def current
+    self.class.find_by_identity(identity)
+  end
+
+  def initial
+    self.class.initial.where(IDENTITY_COLUMN=>identity).first
+  end
+
+  def at(date=nil)
+    if date.present?
+      self.class.find_by_identity(identity, date)
+    else
+      current
+    end
+  end
+
+  def successor
+    return nil if effective_to==END_OF_TIME
+    self.class.where(identity:identity, effective_from:effective_to).first
+  end
+
+  def antecessor
+    return nil if effective_from==START_OF_TIME
+    self.class.where(identity:identity, effective_to:effective_from).first
+  end
+
+  def successors
+    return self.class.where('1=0') if effective_to==END_OF_TIME
+    self.class.where(identity:identity).where('effective_from>=:date', date: effective_to).reorder('effective_from')
+  end
+
+  def antecessors
+    return self.class.where('1=0') if effective_from==START_OF_TIME
+    self.class.where(identity:identity).where('effective_to<=:date', date: effective_from).reorder('effective_to')
+  end
+
+  def history
+    self.class.all_of(identity)
+  end
+
+  def latest
+    self.class.where(identity:identity).reorder('effective_to desc').limit(1).first
+  end
+
+  def earliest
+    self.class.where(identity:identity).reorder('effective_from asc').limit(1).first
+  end
+
+  def terminate_identity(finish=Date.today)
+     finish = self.class.effective_date(finish)
+     update_attributes END_COLUMN=>finish
+  end
+
+  def ended?
+    effective_to < END_OF_TIME
+  end
+
+  def ended_at?(date)
+    effective_to <= self.class.effective_date(date)
+  end
+
+  def effective_period
+    Period[effective_from, effective_to]
+  end
+
+  def effective_from_date
+    Period::DateValue[effective_from].to_date
+  end
+
+  def effective_to_date
+    Period::DateValue[effective_to].to_date
+  end
+
+  def initial?
+    effective_period.initial?
+  end
+
+  def current?
+    effective_period.current?
+  end
+
+  def past_limited?
+    effective_period.past_limited?
+  end
+
+  def future_limited?
+    effective_period.future_limited?
+  end
+
+  def limited?
+    effective_period.limited?
+  end
+
+  def remove_this_iteration
+    s = successor
+    s.update_attributes effective_from: self.effective_from if s
+    a = antecessor
+    a.update_attributes effective_to: self.effective_to if a
+  end
+
+end

data/lib/acts_as_scd/period.rb

@@ -0,0 +1,135 @@
+module ActsAsScd
+
+  class Period
+
+    class DateValue
+      def initialize(d)
+
+        d = d.strftime('%Y%m%d') if d.respond_to?(:strftime)
+        if String===d && d =~ /\A(\d\d\d\d)-(\d\d)-(\d\d)\Z/
+          d = $1.to_i*10000 + $2.to_i*100 + $3.to_i
+        end
+        @value = d && d.to_i
+      end
+
+      attr_reader :value
+
+      def to_date
+        begin
+          Date.new *parse
+        rescue
+          raise parse.inspect
+        end
+      end
+
+      def parse
+        y = @value/10000
+        v = @value%10000
+        m = v/100
+        d = v%100
+        [y,m,d]
+      end
+
+      def to_s
+        if @value==START_OF_TIME
+          ''
+        elsif @value==END_OF_TIME
+          ''
+        else
+          y,m,d = parse
+          I18n.l Date.new(y, m, d)
+        end
+      end
+
+      include ModalSupport::BracketConstructor
+    end
+
+    def self.date(date)
+      DateValue[date].value
+    end
+
+    def self.date_to_s(date)
+      DateValue[date].to_s
+    end
+
+    attr_reader :start, :end
+    def from
+      @start
+    end
+    def to
+      @end
+    end
+
+    def initialize(from, to)
+      @start = Period.date(from || START_OF_TIME)
+      @end = Period.date(to || END_OF_TIME)
+    end
+
+    include ModalSupport::StateEquivalent
+
+    def includes?(date)
+      date = Period.date(date)
+      @start <= date && date < @end
+    end
+
+    include ModalSupport::BracketConstructor
+
+    def to_s(options={})
+      if @start<=START_OF_TIME
+        if @end>=END_OF_TIME
+          options[:always] || I18n.t(:"scd.period.always") || '-'
+        else
+          "#{options[:until] || I18n.t(:"scd.period.until") || 'to'} #{Period.date_to_s(@end)}"
+        end
+      else
+        if @end>=END_OF_TIME
+          "#{options[:since] || I18n.t(:"scd.period.from") || 'since'} #{Period.date_to_s(@start)}"
+        else
+          [Period.date_to_s(@start), options[:between] ||  I18n.t(:"scd.period.between") || '-', Period.date_to_s(@end)].compact*' '
+        end
+      end
+    end
+
+    def valid?
+      @start < @end
+    end
+
+    def empty?
+      @start >= @end
+    end
+
+    def past_limited?
+      @start > START_OF_TIME
+    end
+
+    def future_limited?
+      @end < END_OF_TIME
+    end
+
+    def limited?
+      past_limited? || future_limited?
+    end
+
+    def initial?
+      @start == START_OF_TIME
+    end
+
+    def current?
+      @end == END_OF_TIME
+    end
+
+    def reference_date
+      if @start <= START_OF_TIME
+        if @end >= END_OF_TIME
+          DateValue[Date.today].value
+        else
+          DateValue[DateValue[@end].to_date - 1].value
+        end
+      else
+        @start
+      end
+    end
+
+  end
+
+end

data/lib/acts_as_scd/version.rb

@@ -0,0 +1,3 @@
+module ActsAsScd
+  VERSION = "0.0.1"
+end

data/lib/acts_as_scd.rb

@@ -0,0 +1,31 @@
+require 'modalsupport'
+require 'acts_as_scd/initialize'
+require 'acts_as_scd/period'
+require 'acts_as_scd/instance_methods'
+require 'acts_as_scd/class_methods'
+require 'acts_as_scd/base_class_methods'
+require 'acts_as_scd/block_updater'
+
+module ActsAsScd
+
+  begin
+    require 'rails'
+
+    class Railtie < Rails::Railtie
+      initializer 'acts_as_scd.insert_into_active_record' do
+        ActiveSupport.on_load :active_record do
+          # ActiveRecord::Base.send(:include, ActsAsScd)
+          ActiveRecord::Base.extend ActsAsScd::BaseClassMethods
+        end
+      end
+    end
+  rescue LoadError
+    # ActiveRecord::Base.send(:include, ActAsScd) if defined?(ActiveRecord)
+    ActiveRecord::Base.extend ActsAsScd::BaseClassMethods if defined?(ActiveRecord)
+  end
+
+  def self.included(model)
+    initialize_scd model
+  end
+
+end

data/lib/tasks/acts_as_scd_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :acts_as_scd do
+#   # Task goes here
+# end