chrono_model 0.4.0 → 0.5.0.beta

data/lib/chrono_model.rb

@@ -3,6 +3,8 @@ require 'chrono_model/adapter'
 require 'chrono_model/compatibility'
 require 'chrono_model/patches'
 require 'chrono_model/time_machine'
+require 'chrono_model/time_gate'
+require 'chrono_model/utils'
 
 module ChronoModel
   class Error < ActiveRecord::ActiveRecordError #:nodoc:
@@ -24,11 +26,4 @@ silence_warnings do
   # We need to override the "scoped" method on AR::Association for temporal
   # associations to work as well
   ActiveRecord::Associations::Association = ChronoModel::Patches::Association
-
-  # This implements correct WITH syntax on PostgreSQL
-  Arel::Visitors::PostgreSQL = ChronoModel::Patches::Visitor
-
-  # This adds .with support to ActiveRecord::Relation
-  ActiveRecord::Relation.instance_eval { include ChronoModel::Patches::QueryMethods }
-  ActiveRecord::Base.extend ChronoModel::Patches::Querying
 end

data/spec/adapter_spec.rb

@@ -59,7 +59,7 @@ describe ChronoModel::Adapter do
 
     def native.to_proc
       proc {|t|
-        t.string  :test
+        t.string  :test, :null => false
         t.integer :foo
         t.float   :bar
         t.text    :baz
@@ -325,8 +325,8 @@ describe ChronoModel::Adapter do
       it { should include(['id', 'integer']) }
     end
 
-    with_temporal_table &assert
-    with_plain_table    &assert
+    with_temporal_table(&assert)
+    with_plain_table(   &assert)
   end
 
   describe '.primary_key' do
@@ -336,8 +336,8 @@ describe ChronoModel::Adapter do
       it { should == 'id' }
     end
 
-    with_temporal_table &assert
-    with_plain_table    &assert
+    with_temporal_table(&assert)
+    with_plain_table(   &assert)
   end
 
   describe '.indexes' do
@@ -353,8 +353,8 @@ describe ChronoModel::Adapter do
       it { subject.map(&:columns).should =~ [['foo'], ['bar', 'baz']] }
     end
 
-    with_temporal_table &assert
-    with_plain_table    &assert
+    with_temporal_table(&assert)
+    with_plain_table(   &assert)
   end
 
   describe '.on_schema' do
@@ -395,4 +395,71 @@ describe ChronoModel::Adapter do
     end
   end
 
+
+  context 'INSERT multiple values' do
+    before :all do
+      adapter.create_table table, :temporal => true, &columns
+    end
+
+    after :all do
+      adapter.drop_table table
+    end
+
+    let(:current) { [ChronoModel::Adapter::TEMPORAL_SCHEMA, table].join('.') }
+    let(:history) { [ChronoModel::Adapter::HISTORY_SCHEMA,  table].join('.') }
+
+    def count(table)
+      adapter.select_value("SELECT COUNT(*) FROM ONLY #{table}").to_i
+    end
+
+    def ids(table)
+      adapter.select_values("SELECT id FROM ONLY #{table} ORDER BY id")
+    end
+
+    context 'when succeeding' do
+      def insert
+        adapter.execute <<-SQL
+          INSERT INTO #{table} (test, foo) VALUES
+            ('test1', 1),
+            ('test2', 2);
+        SQL
+      end
+
+      it { expect { insert }.to_not raise_error }
+      it { count(current).should == 2 }
+      it { count(history).should == 2 }
+    end
+
+    context 'when failing' do
+      def insert
+        adapter.execute <<-SQL
+          INSERT INTO #{table} (test, foo) VALUES
+            ('test3', 3),
+            (NULL,    0);
+        SQL
+      end
+
+      it { expect { insert }.to raise_error }
+      it { count(current).should == 2 } # Because the previous
+      it { count(history).should == 2 } # records are preserved
+    end
+
+    context 'after a failure' do
+      def insert
+        adapter.execute <<-SQL
+          INSERT INTO #{table} (test, foo) VALUES
+            ('test4', 3),
+            ('test5', 4);
+        SQL
+      end
+
+      it { expect { insert }.to_not raise_error }
+
+      it { count(current).should == 4 }
+      it { count(history).should == 4 }
+
+      it { ids(current).should == ids(history) }
+    end
+  end
+
 end

data/spec/support/connection.rb

@@ -6,7 +6,7 @@ module ChronoTest
   extend self
 
   AR = ActiveRecord::Base
-  log = ENV['VERBOSE'].present? ? $stderr : 'spec/debug.log'.tap{|f| File.truncate(f, 0)}
+  log = ENV['VERBOSE'].present? ? $stderr : 'spec/debug.log'.tap{|f| File.open(f, "ab") { |ft| ft.truncate(0) }}
   AR.logger = ::Logger.new(log).tap do |l|
     l.level = 0
   end

data/spec/support/helpers.rb

@@ -69,6 +69,11 @@ module ChronoTest::Helpers
             t.string  :name
             t.boolean :active
           end
+
+          adapter.create_table 'elements', :temporal => true do |t|
+            t.string :title
+            t.string :type
+          end
         end
 
         after(:all) do
@@ -90,10 +95,16 @@ module ChronoTest::Helpers
 
           belongs_to :foo
           has_one :baz
+
+          has_timeline :with => :foo
         end
 
         class ::Baz < ActiveRecord::Base
-          belongs_to :baz
+          include ChronoModel::TimeGate
+
+          belongs_to :bar
+
+          has_timeline :with => :bar
         end
 
         class ::Defoo < ActiveRecord::Base
@@ -101,6 +112,14 @@ module ChronoTest::Helpers
 
           default_scope where(:active => true)
         end
+
+        # STI case (https://github.com/ifad/chronomodel/issues/5)
+        class ::Element < ActiveRecord::Base
+          include ChronoModel::TimeMachine
+        end
+
+        class ::Publication < Element
+        end
       }
 
       def define_models!

data/spec/time_machine_spec.rb

@@ -10,7 +10,12 @@ describe ChronoModel::TimeMachine do
   describe '.chrono_models' do
     subject { ChronoModel::TimeMachine.chrono_models }
 
-    it { should == {'foos' => Foo::History, 'defoos' => Defoo::History, 'bars' => Bar::History} }
+    it { should == {
+      'foos'     => Foo::History,
+      'defoos'   => Defoo::History,
+      'bars'     => Bar::History,
+      'elements' => Element::History
+    } }
   end
 
 
@@ -31,6 +36,10 @@ describe ChronoModel::TimeMachine do
     ts_eval(bar) { update_attributes! :name => 'new bar' }
   }
 
+  let!(:baz) {
+    Baz.create :name => 'baz', :bar => bar
+  }
+
   # Specs start here
   #
   describe '#as_of' do
@@ -110,6 +119,23 @@ describe ChronoModel::TimeMachine do
       it { Defoo.unscoped.as_of(hidden.ts[0]).map(&:name).should == ['active 2', 'hidden 1'] }
       it { Defoo.unscoped.as_of(hidden.ts[1]).map(&:name).should == ['active 2', 'hidden 2'] }
     end
+
+    describe 'proxies from non-temporal models to temporal ones' do
+      it { baz.as_of(bar.ts[0]).name.should == 'baz' }
+      it { baz.as_of(bar.ts[1]).name.should == 'baz' }
+      it { baz.as_of(bar.ts[2]).name.should == 'baz' }
+      it { baz.as_of(bar.ts[3]).name.should == 'baz' }
+
+      it { baz.as_of(bar.ts[0]).bar.name.should == 'bar' }
+      it { baz.as_of(bar.ts[1]).bar.name.should == 'foo bar' }
+      it { baz.as_of(bar.ts[2]).bar.name.should == 'bar bar' }
+      it { baz.as_of(bar.ts[3]).bar.name.should == 'new bar' }
+
+      it { baz.as_of(bar.ts[0]).bar.foo.name.should == 'foo bar' }
+      it { baz.as_of(bar.ts[1]).bar.foo.name.should == 'foo bar' }
+      it { baz.as_of(bar.ts[2]).bar.foo.name.should == 'new foo' }
+      it { baz.as_of(bar.ts[3]).bar.foo.name.should == 'new foo' }
+    end
   end
 
   describe '#history' do
@@ -135,6 +161,82 @@ describe ChronoModel::TimeMachine do
       it { foo.history[2].bars.all?(&:readonly?).should be_true }
       it { bar.history.all? {|b| b.foo.readonly?}.should be_true }
     end
+
+    describe 'allows a custom select list' do
+      it { foo.history.select(:id).first.attributes.keys.should == %w( id as_of_time ) }
+    end
+
+    describe 'does not add as_of_time when there are aggregates' do
+      it { foo.history.select('max (id)').to_sql.should_not =~ /as_of_time/ }
+      it { foo.history.select('max (id) as foo, min(id) as bar').first.attributes.keys.should == %w( foo bar ) }
+    end
+
+    describe 'orders by recorded_at, hid by default' do
+      it { foo.history.to_sql.should =~ /order by.*recorded_at,.*hid/i }
+    end
+
+    describe 'allows a custom order list' do
+      it { expect { foo.history.order('id') }.to_not raise_error }
+      it { foo.history.order('id').to_sql.should =~ /order by id/i }
+    end
+
+    context 'with STI models' do
+      let!(:pub) {
+        pub = ts_eval { Publication.create! :title => 'wrong title' }
+        ts_eval(pub) { update_attributes! :title => 'correct title' }
+      }
+
+      it { pub.history.map(&:title).should == ['wrong title', 'correct title'] }
+    end
+  end
+
+  describe '#pred' do
+    context 'on the first history entry' do
+      subject { foo.history.first.pred }
+      it { should be_nil }
+    end
+
+    context 'on the second history entry' do
+      subject { foo.history.second.pred }
+      it { should == foo.history.first }
+    end
+
+    context 'on the last history entry' do
+      subject { foo.history.last.pred }
+      it { should == foo.history[foo.history.size - 2] }
+    end
+  end
+
+  describe '#succ' do
+    context 'on the first history entry' do
+      subject { foo.history.first.succ }
+      it { should == foo.history.second }
+    end
+
+    context 'on the second history entry' do
+      subject { foo.history.second.succ }
+      it { should == foo.history.third }
+    end
+
+    context 'on the last history entry' do
+      subject { foo.history.last.succ }
+      it { should be_nil }
+    end
+  end
+
+  describe '#first' do
+    subject { foo.history.sample.first }
+    it { should == foo.history.first }
+  end
+
+  describe '#last' do
+    subject { foo.history.sample.last }
+    it { should == foo.history.last }
+  end
+
+  describe '#record' do
+    subject { foo.history.sample.record }
+    it { should == foo }
   end
 
   describe '#historical?' do
@@ -197,32 +299,133 @@ describe ChronoModel::TimeMachine do
     end
   end
 
-  describe '#history_timestamps' do
+  describe '#timeline' do
+    split = lambda {|ts| ts.map!{|t| [t.to_i, t.usec]} }
+
     timestamps_from = lambda {|*records|
-      records.map(&:history).flatten!.inject([]) {|ret, rec|
-        ret.concat [rec.valid_from, rec.valid_to]
+      ts = records.map(&:history).flatten!.inject([]) {|ret, rec|
+        ret.concat [
+          [rec.valid_from.to_i, rec.valid_from.usec + 2],
+          [rec.valid_to.to_i,   rec.valid_to.usec + 2]
+        ]
       }.sort.uniq[0..-2]
     }
 
     describe 'on records having an :has_many relationship' do
-      subject { foo.history_timestamps }
+      describe 'by default returns timestamps of the record only' do
+        subject { split.call(foo.timeline) }
+        its(:size) { should == foo.ts.size }
+        it { should == timestamps_from.call(foo) }
+      end
 
-      describe 'returns timestamps of the record and its associations' do
+      describe 'when asked, returns timestamps including the related objects' do
+        subject { split.call(foo.timeline(:with => :bars)) }
         its(:size) { should == foo.ts.size + bar.ts.size }
-        it { should == timestamps_from.call(foo, bar) }
+        it { should == timestamps_from.call(foo, *foo.bars) }
       end
     end
 
-    describe 'on records having a :belongs_to relationship' do
-      subject { bar.history_timestamps }
+    describe 'on records using has_timeline :with' do
+      subject { split.call(bar.timeline) }
 
       describe 'returns timestamps of the record and its associations' do
-        its(:size) { should == foo.ts.size + bar.ts.size }
-        it { should == timestamps_from.call(foo, bar) }
+
+        let!(:expected) do
+          creat = bar.history.first.valid_from
+          c_sec, c_usec = creat.to_i, creat.usec
+
+          timestamps_from.call(foo, bar).reject {|sec, usec|
+            sec < c_sec || ( sec == c_sec && usec < c_usec )
+          }
+        end
+
+        its(:size) { should == expected.size }
+        it { should == expected }
+      end
+    end
+
+    describe 'on non-temporal records using has_timeline :with' do
+      subject { split.call(baz.timeline) }
+
+      describe 'returns timestamps of its temporal associations' do
+        its(:size) { should == bar.ts.size }
+        it { should == timestamps_from.call(bar) }
+      end
+    end
+  end
+
+  describe '#last_changes' do
+    context 'on plain records' do
+      context 'having history' do
+        subject { bar.last_changes }
+        it { should == {'name' => ['bar bar', 'new bar']} }
+      end
+
+      context 'without history' do
+        let(:record) { Bar.create!(:name => 'foreveralone') }
+        subject { record.last_changes }
+        it { should be_nil }
+        after { record.destroy.history.delete_all } # UGLY
+      end
+    end
+
+    context 'on history records' do
+      context 'at the beginning of the timeline' do
+        subject { bar.history.first.last_changes }
+        it { should be_nil }
+      end
+
+      context 'in the middle of the timeline' do
+        subject { bar.history.second.last_changes }
+        it { should == {'name' => ['bar', 'foo bar']} }
       end
     end
   end
 
+  describe '#changes_against' do
+    context 'can compare records against history' do
+      it { bar.changes_against(bar.history.first).should ==
+             {'name' => ['bar', 'new bar']} }
+
+      it { bar.changes_against(bar.history.second).should ==
+             {'name' => ['foo bar', 'new bar']} }
+
+      it { bar.changes_against(bar.history.third).should ==
+             {'name' => ['bar bar', 'new bar']} }
+
+      it { bar.changes_against(bar.history.last).should == {} }
+    end
+
+    context 'can compare history against history' do
+      it { bar.history.first.changes_against(bar.history.third).should ==
+             {'name' => ['bar bar', 'bar']} }
+
+      it { bar.history.second.changes_against(bar.history.third).should ==
+             {'name' => ['bar bar', 'foo bar']} }
+
+      it { bar.history.third.changes_against(bar.history.third).should == {} }
+    end
+  end
+
+  describe '#pred' do
+    context 'on records having history' do
+      subject { bar.pred }
+      its(:name) { should == 'bar bar' }
+    end
+
+    context 'when there is enough history' do
+      subject { bar.pred.pred.pred.pred }
+      its(:name) { should == 'bar' }
+    end
+
+    context 'when no history is recorded' do
+      let(:record) { Bar.create!(:name => 'quuuux') }
+      subject { record.pred }
+      it { should be_nil }
+      after { record.destroy.history.delete_all }
+    end
+  end
+
   context do
     let!(:history) { foo.history.first }
     let!(:current) { foo }
@@ -239,7 +442,8 @@ describe ChronoModel::TimeMachine do
 
         describe 'on current records' do
           subject { current.public_send(attr) }
-          it { expect { subject }.to raise_error(NoMethodError) }
+
+          it { should be_nil }
         end
       }
     }

metadata

@@ -1,19 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: chrono_model
 version: !ruby/object:Gem::Version
-  version: 0.4.0
-  prerelease: 
+  version: 0.5.0.beta
+  prerelease: 6
 platform: ruby
 authors:
 - Marcello Barnaba
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-30 00:00:00.000000000 Z
+date: 2013-02-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &79419830 !ruby/object:Gem::Requirement
+  requirement: &77788870 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: '3.2'
   type: :runtime
   prerelease: false
-  version_requirements: *79419830
+  version_requirements: *77788870
 - !ruby/object:Gem::Dependency
   name: pg
-  requirement: &79493370 !ruby/object:Gem::Requirement
+  requirement: &77787530 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,7 +32,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *79493370
+  version_requirements: *77787530
 description: Give your models as-of date temporal extensions. Built entirely for PostgreSQL
   >= 9.0
 email:
@@ -55,7 +55,9 @@ files:
 - lib/chrono_model/compatibility.rb
 - lib/chrono_model/patches.rb
 - lib/chrono_model/railtie.rb
+- lib/chrono_model/time_gate.rb
 - lib/chrono_model/time_machine.rb
+- lib/chrono_model/utils.rb
 - lib/chrono_model/version.rb
 - spec/adapter_spec.rb
 - spec/config.yml.example
@@ -83,9 +85,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.10