chrono_model 0.4.0 → 0.5.0.beta

data/lib/chrono_model/patches.rb

@@ -13,92 +13,45 @@ module ChronoModel
     #
     class Association < ActiveRecord::Associations::Association
 
-      # Add temporal Common Table Expressions (WITH queries) to the resulting
-      # scope, checking whether either the association class or the through
-      # association one are ChronoModels.
+      # If the association class or the through association are ChronoModels,
+      # then fetches the records from a virtual table using a subquery scoped
+      # to a specific timestamp.
       def scoped
-        return super unless _chrono_record?
-
-        ctes = {}
-
-        if reflection.klass.chrono?
-          ctes.update _chrono_ctes_for(reflection.klass)
-        end
+        scoped = super
+        return scoped unless _chrono_record?
+
+        klass = reflection.options[:polymorphic] ?
+          owner.public_send(reflection.foreign_type).constantize :
+          reflection.klass
+
+        if klass.chrono?
+          # For standard associations, replace the table name with the virtual
+          # as-of table name at the owner's as-of-time
+          #
+          scoped = scoped.readonly.from(klass.history.virtual_table_at(owner.as_of_time))
+        elsif respond_to?(:through_reflection) && through_reflection.klass.chrono?
+
+          # For through associations, replace the joined table name instead.
+          #
+          scoped.join_sources.each do |join|
+            if join.left.name == through_reflection.klass.table_name
+              v_table = through_reflection.klass.history.virtual_table_at(
+                owner.as_of_time, join.left.table_alias || join.left.table_name)
+
+              join.left = Arel::Nodes::SqlLiteral.new(v_table)
+            end
+          end
 
-        if respond_to?(:through_reflection) && through_reflection.klass.chrono?
-          ctes.update _chrono_ctes_for(through_reflection.klass)
         end
 
-        scoped = super
-        ctes.each {|table, cte| scoped = scoped.with(table, cte) }
-        return scoped.readonly
+        return scoped
       end
 
       private
-        def _chrono_ctes_for(klass)
-          klass.as_of(owner.as_of_time).with_values
-        end
-
         def _chrono_record?
           owner.respond_to?(:as_of_time) && owner.as_of_time.present?
         end
     end
 
-    # Adds the WITH queries (Common Table Expressions) support to
-    # ActiveRecord::Relation.
-    #
-    # \name  is the CTE you want
-    # \value can be a plain SQL query or another AR::Relation
-    #
-    # Example:
-    #
-    #   Post.with('posts',
-    #     Post.from('history.posts').
-    #       where('? BETWEEN valid_from AND valid_to', 1.month.ago)
-    #   ).where(:author_id => 1)
-    #
-    # yields:
-    #
-    #   WITH posts AS (
-    #     SELECT * FROM history.posts WHERE ... BETWEEN valid_from AND valid_to
-    #   ) SELECT * FROM posts
-    #
-    # PG Documentation:
-    # http://www.postgresql.org/docs/9.0/static/queries-with.html
-    #
-    module QueryMethods
-      attr_accessor :with_values
-
-      def with(name, value)
-        clone.tap do |relation|
-          relation.with_values ||= {}
-          value = value.to_sql if value.respond_to? :to_sql
-          relation.with_values[name] = value
-        end
-      end
-
-      def build_arel
-        super.tap {|arel| arel.with with_values if with_values.present? }
-      end
-    end
-
-    module Querying
-      delegate :with, :to => :scoped
-    end
-
-    # Fixes ARel's WITH visitor method with the correct SQL syntax
-    #
-    # FIXME: the .children.first is messy. This should be properly
-    # fixed in ARel.
-    #
-    class Visitor < Arel::Visitors::PostgreSQL
-      def visit_Arel_Nodes_With o
-        values = o.children.first.map do |name, value|
-          [name, ' AS (', value.is_a?(String) ? value : visit(value), ')'].join
-        end
-        "WITH #{values.join ', '}"
-      end
-    end
-
   end
 end

data/lib/chrono_model/railtie.rb

@@ -17,30 +17,5 @@ module ChronoModel
 
       task 'db:schema:load' => 'db:chrono:create_schemas'
     end
-
-    class SchemaDumper < ::ActiveRecord::SchemaDumper
-      def tables(*)
-        super
-        @connection.send(:_on_temporal_schema) { super }
-      end
-
-      def indexes(table, stream)
-        super
-        if @connection.is_chrono?(table)
-          stream.rewind
-          t = stream.read.sub(':force => true', '\&, :temporal => true') # HACK
-          stream.seek(0)
-          stream.truncate(0)
-          stream.write(t)
-        end
-      end
-
-    end
-
-    # I'm getting (too) used to this (dirty) override scheme.
-    #
-    silence_warnings do
-      ::ActiveRecord::SchemaDumper = SchemaDumper
-    end
   end
 end

data/lib/chrono_model/time_gate.rb

@@ -0,0 +1,36 @@
+module ChronoModel
+
+  # Provides the TimeMachine API to non-temporal models that associate
+  # temporal ones.
+  #
+  module TimeGate
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def as_of(time)
+        time = Conversions.time_to_utc_string(time.utc) if time.kind_of? Time
+
+        virtual_table = select(%[
+          #{quoted_table_name}.*, #{connection.quote(time)} AS "as_of_time"]
+        ).to_sql
+
+        as_of = scoped.from("(#{virtual_table}) #{quoted_table_name}")
+
+        as_of.instance_variable_set(:@temporal, time)
+
+        return as_of
+      end
+
+      include TimeMachine::HistoryMethods::Timeline
+    end
+
+    def as_of(time)
+      self.class.as_of(time).where(:id => self.id).first!
+    end
+
+    def timeline
+      self.class.timeline(self)
+    end
+  end
+
+end