chrono_model 0.8.2 → 0.9.0

data/lib/chrono_model/schema_format.rake

@@ -6,20 +6,36 @@ namespace :db do
     task :dump => :environment do
       config = PG.config!
       target = ENV['DB_STRUCTURE'] || Rails.root.join('db', 'structure.sql')
-      schema = config[:schema_search_path] || 'public'
+      schema_search_path = config[:schema_search_path]
 
-      PG.make_dump target, *config.values_at(:username, :database),
-        '-s', '-O', '-n', schema,
-        '-n', ChronoModel::Adapter::TEMPORAL_SCHEMA,
-        '-n', ChronoModel::Adapter::HISTORY_SCHEMA
+      unless schema_search_path.blank?
+        # add in chronomodel schemas
+        schema_search_path << ",#{ChronoModel::Adapter::TEMPORAL_SCHEMA}"
+        schema_search_path << ",#{ChronoModel::Adapter::HISTORY_SCHEMA}"
+
+        # convert to command line arguments
+        schema_search_path = schema_search_path.split(",").map{|part| "--schema=#{part.strip}" }.join(" ")
+      end
+
+      PG.make_dump target,
+                   *config.values_at(:username, :database),
+                   '-i', '-x', '-s', '-O', schema_search_path
 
       # Add migration information, after resetting the schema to the default one
       File.open(target, 'a') do |f|
-        f.puts "SET search_path = #{schema}, pg_catalog;"
+        f.puts "SET search_path TO #{ActiveRecord::Base.connection.schema_search_path};\n\n"
         f.puts ActiveRecord::Base.connection.dump_schema_information
       end
-    end
 
+      # the structure.sql file will contain CREATE SCHEMA statements
+      # but chronomodel creates the temporal and history schemas
+      # when the connection is established, so a db:structure:load fails
+      # fix up create schema statements to include the IF NOT EXISTS directive
+
+      sql = File.read(target)
+      sql.gsub!(/CREATE SCHEMA /, 'CREATE SCHEMA IF NOT EXISTS ')
+      File.open(target, "w") { |file| file << sql  }
+    end
 
     desc "Load structure.sql file into the current environment's database"
     task :load => :environment do

data/lib/chrono_model/schema_format.rb

@@ -24,11 +24,12 @@ module PG
       ENV['PGHOST']     = config[:host].to_s     if config.key?(:host)
       ENV['PGPORT']     = config[:port].to_s     if config.key?(:port)
       ENV['PGPASSWORD'] = config[:password].to_s if config.key?(:password)
+      ENV['PGUSER']     = config[:username].to_s if config.key?(:username)
     end
   end
 
   def make_dump(target, username, database, *options)
-    exec 'pg_dump', '-f', target, '-U', username, database, *options
+    exec 'pg_dump', '-f', target, '-U', username, '-d', database, *options
   end
 
   def load_dump(source, username, database, *options)

data/lib/chrono_model/time_gate.rb

@@ -8,22 +8,14 @@ module ChronoModel
 
     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)}::timestamp AS "as_of_time"]
-        ).to_sql
-
-        as_of = all.from("(#{virtual_table}) #{quoted_table_name}")
-
-        as_of.instance_variable_set(:@temporal, time)
-
-        return as_of
+        all.as_of_time!(time)
       end
 
       include TimeMachine::HistoryMethods::Timeline
     end
 
+    include Patches::AsOfTimeHolder
+
     def as_of(time)
       self.class.as_of(time).where(:id => self.id).first!
     end

data/lib/chrono_model/time_machine.rb

@@ -5,6 +5,8 @@ module ChronoModel
   module TimeMachine
     extend ActiveSupport::Concern
 
+    include Patches::AsOfTimeHolder
+
     included do
       if table_exists? && !chrono?
         puts "WARNING: #{table_name} is not a temporal table. " \
@@ -14,16 +16,28 @@ module ChronoModel
       history = TimeMachine.define_history_model_for(self)
       TimeMachine.chrono_models[table_name] = history
 
-      # STI support. TODO: more thorough testing
-      #
-      def self.inherited(subclass)
-        super
+      class << self
+        alias_method :direct_descendants_with_history, :direct_descendants
+        def direct_descendants
+          direct_descendants_with_history.reject(&:history?)
+        end
+
+        alias_method :descendants_with_history, :descendants
+        def descendants
+          descendants_with_history.reject(&:history?)
+        end
 
-        # Do not smash stack: as the below method is defining a
-        # new anonymous class, without this check this leads to
-        # infinite recursion.
-        unless subclass.name.nil?
-          TimeMachine.define_inherited_history_model_for(subclass)
+        # STI support. TODO: more thorough testing
+        #
+        def inherited(subclass)
+          super
+
+          # Do not smash stack: as the below method is defining a
+          # new anonymous class, without this check this leads to
+          # infinite recursion.
+          unless subclass.name.nil?
+            TimeMachine.define_inherited_history_model_for(subclass)
+          end
         end
       end
     end
@@ -40,6 +54,8 @@ module ChronoModel
 
         extend TimeMachine::HistoryMethods
 
+        scope :chronological, -> { order(:recorded_at, :hid) }
+
         # The history id is `hid`, but this cannot set as primary key
         # or temporal assocations will break. Solutions are welcome.
         def id
@@ -148,6 +164,7 @@ module ChronoModel
         def valid_to
           validity.last
         end
+        alias as_of_time valid_to
 
         def recorded_at
           Conversions.string_to_utc_time attributes_before_type_cast['recorded_at']
@@ -212,7 +229,7 @@ module ChronoModel
     # Return the complete read-only history of this instance.
     #
     def history
-      self.class.history.of(self)
+      self.class.history.chronological.of(self)
     end
 
     # Returns an Array of timestamps for which this instance has an history
@@ -225,13 +242,7 @@ module ChronoModel
     # Returns a boolean indicating whether this record is an history entry.
     #
     def historical?
-      self.attributes.key?('as_of_time') || self.kind_of?(self.class.history)
-    end
-
-    # Read the virtual 'as_of_time' attribute and return it as an UTC timestamp.
-    #
-    def as_of_time
-      Conversions.string_to_utc_time attributes_before_type_cast['as_of_time']
+      self.as_of_time.present? || self.kind_of?(self.class.history)
     end
 
     # Inhibit destroy of historical records
@@ -317,15 +328,21 @@ module ChronoModel
     end
 
     module ClassMethods
+      # Identify this class as the parent, non-history, class.
+      #
+      def history?
+        false
+      end
+
       # Returns an ActiveRecord::Relation on the history of this model as
       # it was +time+ ago.
       def as_of(time)
-        history.as_of(time, current_scope)
+        history.as_of(time)
       end
 
       def attribute_names_for_history_changes
         @attribute_names_for_history_changes ||= attribute_names -
-          %w( id hid validity recorded_at as_of_time )
+          %w( id hid validity recorded_at )
       end
 
       def has_timeline(options)
@@ -401,6 +418,10 @@ module ChronoModel
         def build_time_query_at(time, range)
           time = if time.kind_of?(Array)
             time.map! {|t| time_for_time_query(t, range)}
+
+            # If both edges of the range are the same the query fails using the '&&' operator.
+            # The correct solution is to use the <@ operator.
+            time.first == time.last ? time.first : time
           else
             time_for_time_query(time, range)
           end
@@ -446,34 +467,21 @@ module ChronoModel
       # superclass of Fruit::History, which is Fruit. So, we use
       # non_history_superclass instead. -npj
       def non_history_superclass(klass = self)
-        if klass.superclass.respond_to?(:history?) && klass.superclass.history?
+        if klass.superclass.history?
           non_history_superclass(klass.superclass)
         else
           klass.superclass
         end
       end
 
+      def relation
+        super.as_of_time!(Time.now)
+      end
+
       # Fetches as of +time+ records.
       #
-      def as_of(time, scope = nil)
-        as_of = non_history_superclass.unscoped.from(virtual_table_at(time))
-
-        # Add default scopes back if we're passed nil or a
-        # specific scope, because we're .unscopeing above.
-        #
-        scopes = !scope.nil? ? [scope] : (
-          superclass.default_scopes.map do |s|
-            s.respond_to?(:call) ? s.call : s
-          end)
-
-        scopes.each do |s|
-          s.order_values.each {|clause| as_of = as_of.order(clause)}
-          s.where_values.each {|clause| as_of = as_of.where(clause)}
-        end
-
-        as_of.instance_variable_set(:@temporal, time)
-
-        return as_of
+      def as_of(time)
+        non_history_superclass.from(virtual_table_at(time)).as_of_time!(time)
       end
 
       def virtual_table_at(time, name = nil)
@@ -486,11 +494,7 @@ module ChronoModel
       # Fetches history record at the given time
       #
       def at(time)
-        time = Conversions.time_to_utc_string(time.utc) if time.kind_of?(Time) && !time.utc?
-
-        unscoped.
-          select("#{quoted_table_name}.*, #{connection.quote(time)}::timestamp AS as_of_time").
-          time_query(:at, time)
+        time_query(:at, time).from(quoted_table_name).as_of_time!(time)
       end
 
       # Returns the history sorted by recorded_at
@@ -505,49 +509,15 @@ module ChronoModel
       # is maximum.
       #
       def of(object)
-        where(:id => object).extend(HistorySelect)
+        where(:id => object)
       end
 
-      # HACK FIXME. When querying history, ChronoModel does not add his
-      # timestamps and sorting if there is an aggregate function in the
-      # select list - as it is likely what you'll want. However, if you
-      # have a query that performs an aggregate in a subquery, the code
-      # below will do the wrong thing - and you'll have to forcibly add
-      # back the history fields yourself.
+      # FIXME Remove, this was a workaround to a former design flaw.
       #
-      # The obvious solution is to use a VIEW on the history containing
-      # the added history fields, and remove all this crap from here...
-      # but it is not easily feasible. So we're going with a workaround
-      # for now.
-      #
-      #   - vjt  Wed Apr  2 19:56:35 CEST 2014
+      #   - vjt  Wed Oct 28 17:13:57 CET 2015
       #
       def force_history_fields
-        select(HistorySelect::SELECT_VALUES).order(HistorySelect::ORDER_VALUES[quoted_table_name])
-      end
-
-      module HistorySelect #:nodoc:
-        Aggregates = %r{(?:(?:bit|bool)_(?:and|or)|(?:array_|string_|xml)agg|count|every|m(?:in|ax)|sum|stddev|var(?:_pop|_samp|iance)|corr|covar_|regr_)\w*\s*\(}i
-
-        SELECT_VALUES = "upper(validity) AS as_of_time"
-        ORDER_VALUES  = lambda {|tbl| %[#{tbl}."recorded_at", #{tbl}."hid"]}
-
-        def build_arel
-          has_aggregate = select_values.any? do |v|
-            v.kind_of?(Arel::Nodes::Function) || # FIXME this is a bit ugly.
-            v.to_s =~ Aggregates
-          end
-
-          return super if has_aggregate
-
-          if order_values.blank?
-            self.order_values += [ ORDER_VALUES[quoted_table_name] ]
-          end
-
-          super.tap do |rel|
-            rel.project(SELECT_VALUES)
-          end
-        end
+        self
       end
 
       include(Timeline = Module.new do
@@ -568,7 +538,7 @@ module ChronoModel
 
           fields = models.inject([]) {|a,m| a.concat m.quoted_history_fields}
 
-          relation = self.
+          relation = self.except(:order).
             select("DISTINCT UNNEST(ARRAY[#{fields.join(',')}]) AS ts")
 
           if assocs.present?
@@ -639,25 +609,6 @@ module ChronoModel
         end
       end
     end
-
-    module QueryMethods
-      def build_arel
-        super.tap do |arel|
-
-          arel.join_sources.each do |join|
-            model = TimeMachine.chrono_models[join.left.table_name]
-            next unless model
-
-            join.left = Arel::Nodes::SqlLiteral.new(
-              model.history.virtual_table_at(@temporal, join.left.table_alias || join.left.table_name)
-            )
-          end if @temporal
-
-        end
-      end
-    end
-    ActiveRecord::Relation.instance_eval { include QueryMethods }
-
   end
 
 end

data/lib/chrono_model/version.rb

@@ -1,3 +1,3 @@
 module ChronoModel
-  VERSION = "0.8.2"
+  VERSION = "0.9.0"
 end

data/spec/adapter_spec.rb

@@ -2,30 +2,30 @@ require 'spec_helper'
 require 'support/helpers'
 
 shared_examples_for 'temporal table' do
-  it { adapter.is_chrono?(subject).should be_true }
+  it { expect(adapter.is_chrono?(subject)).to be(true) }
 
-  it { should_not have_public_backing }
+  it { is_expected.to_not have_public_backing }
 
-  it { should have_temporal_backing }
-  it { should have_history_backing }
-  it { should have_history_extra_columns }
-  it { should have_public_interface }
+  it { is_expected.to have_temporal_backing }
+  it { is_expected.to have_history_backing }
+  it { is_expected.to have_history_extra_columns }
+  it { is_expected.to have_public_interface }
 
-  it { should have_columns(columns) }
-  it { should have_temporal_columns(columns) }
-  it { should have_history_columns(columns) }
+  it { is_expected.to have_columns(columns) }
+  it { is_expected.to have_temporal_columns(columns) }
+  it { is_expected.to have_history_columns(columns) }
 end
 
 shared_examples_for 'plain table' do
-  it { adapter.is_chrono?(subject).should be_false }
+  it { expect(adapter.is_chrono?(subject)).to be(false) }
 
-  it { should have_public_backing }
+  it { is_expected.to have_public_backing }
 
-  it { should_not have_temporal_backing }
-  it { should_not have_history_backing }
-  it { should_not have_public_interface }
+  it { is_expected.to_not have_temporal_backing }
+  it { is_expected.to_not have_history_backing }
+  it { is_expected.to_not have_public_interface }
 
-  it { should have_columns(columns) }
+  it { is_expected.to have_columns(columns) }
 end
 
 describe ChronoModel::Adapter do
@@ -33,17 +33,21 @@ describe ChronoModel::Adapter do
 
   context do
     subject { adapter }
-    it { should be_a_kind_of(ChronoModel::Adapter) }
-    its(:adapter_name) { should == 'PostgreSQL' }
+    it { is_expected.to be_a_kind_of(ChronoModel::Adapter) }
 
     context do
-      before { adapter.stub(:postgresql_version => 90300) }
-      it { should be_chrono_supported }
+      subject { adapter.adapter_name }
+      it { is_expected.to eq 'PostgreSQL' }
     end
 
     context do
-      before { adapter.stub(:postgresql_version => 90000) }
-      it { should_not be_chrono_supported }
+      before { expect(adapter).to receive(:postgresql_version).and_return(90300) }
+      it { is_expected.to be_chrono_supported }
+    end
+
+    context do
+      before { expect(adapter).to receive(:postgresql_version).and_return(90000) }
+      it { is_expected.to_not be_chrono_supported }
     end
   end
 
@@ -52,7 +56,7 @@ describe ChronoModel::Adapter do
 
   columns do
     native = [
-      ['test', 'character varying(255)'],
+      ['test', 'character varying'],
       ['foo',  'integer'],
       ['bar',  'double precision'],
       ['baz',  'text']
@@ -135,11 +139,11 @@ describe ChronoModel::Adapter do
       end
 
       it "copies plain index to history" do
-        history_indexes.find {|i| i.columns == ['foo']}.should be_present
+        expect(history_indexes.find {|i| i.columns == ['foo']}).to be_present
       end
 
       it "copies unique index to history without uniqueness constraint" do
-        history_indexes.find {|i| i.columns == ['bar'] && i.unique == false}.should be_present
+        expect(history_indexes.find {|i| i.columns == ['bar'] && i.unique == false}).to be_present
       end
     end
   end
@@ -151,10 +155,10 @@ describe ChronoModel::Adapter do
       adapter.drop_table table
     end
 
-    it { should_not have_public_backing }
-    it { should_not have_temporal_backing }
-    it { should_not have_history_backing }
-    it { should_not have_public_interface }
+    it { is_expected.to_not have_public_backing }
+    it { is_expected.to_not have_temporal_backing }
+    it { is_expected.to_not have_history_backing }
+    it { is_expected.to_not have_public_interface }
   end
 
   describe '.add_index' do
@@ -164,13 +168,13 @@ describe ChronoModel::Adapter do
         adapter.add_index table, [:test],      :name => 'test_index'
       end
 
-      it { should have_temporal_index 'foobar_index', %w( foo bar ) }
-      it { should have_history_index  'foobar_index', %w( foo bar ) }
-      it { should have_temporal_index 'test_index',   %w( test ) }
-      it { should have_history_index  'test_index',   %w( test ) }
+      it { is_expected.to have_temporal_index 'foobar_index', %w( foo bar ) }
+      it { is_expected.to have_history_index  'foobar_index', %w( foo bar ) }
+      it { is_expected.to have_temporal_index 'test_index',   %w( test ) }
+      it { is_expected.to have_history_index  'test_index',   %w( test ) }
 
-      it { should_not have_index 'foobar_index', %w( foo bar ) }
-      it { should_not have_index 'test_index',   %w( test ) }
+      it { is_expected.to_not have_index 'foobar_index', %w( foo bar ) }
+      it { is_expected.to_not have_index 'test_index',   %w( test ) }
     end
 
     with_plain_table do
@@ -179,13 +183,13 @@ describe ChronoModel::Adapter do
         adapter.add_index table, [:test],      :name => 'test_index'
       end
 
-      it { should_not have_temporal_index 'foobar_index', %w( foo bar ) }
-      it { should_not have_history_index  'foobar_index', %w( foo bar ) }
-      it { should_not have_temporal_index 'test_index',   %w( test ) }
-      it { should_not have_history_index  'test_index',   %w( test ) }
+      it { is_expected.to_not have_temporal_index 'foobar_index', %w( foo bar ) }
+      it { is_expected.to_not have_history_index  'foobar_index', %w( foo bar ) }
+      it { is_expected.to_not have_temporal_index 'test_index',   %w( test ) }
+      it { is_expected.to_not have_history_index  'test_index',   %w( test ) }
 
-      it { should have_index 'foobar_index', %w( foo bar ) }
-      it { should have_index 'test_index',   %w( test ) }
+      it { is_expected.to have_index 'foobar_index', %w( foo bar ) }
+      it { is_expected.to have_index 'test_index',   %w( test ) }
     end
   end
 
@@ -198,9 +202,9 @@ describe ChronoModel::Adapter do
         adapter.remove_index table, :name => 'test_index'
       end
 
-      it { should_not have_temporal_index 'test_index', %w( test ) }
-      it { should_not have_history_index  'test_index', %w( test ) }
-      it { should_not have_index          'test_index', %w( test ) }
+      it { is_expected.to_not have_temporal_index 'test_index', %w( test ) }
+      it { is_expected.to_not have_history_index  'test_index', %w( test ) }
+      it { is_expected.to_not have_index          'test_index', %w( test ) }
     end
 
     with_plain_table do
@@ -211,9 +215,9 @@ describe ChronoModel::Adapter do
         adapter.remove_index table, :name => 'test_index'
       end
 
-      it { should_not have_temporal_index 'test_index', %w( test ) }
-      it { should_not have_history_index  'test_index', %w( test ) }
-      it { should_not have_index          'test_index', %w( test ) }
+      it { is_expected.to_not have_temporal_index 'test_index', %w( test ) }
+      it { is_expected.to_not have_history_index  'test_index', %w( test ) }
+      it { is_expected.to_not have_index          'test_index', %w( test ) }
     end
   end
 
@@ -225,9 +229,9 @@ describe ChronoModel::Adapter do
         adapter.add_column table, :foobarbaz, :integer
       end
 
-      it { should have_columns(extra_columns) }
-      it { should have_temporal_columns(extra_columns) }
-      it { should have_history_columns(extra_columns) }
+      it { is_expected.to have_columns(extra_columns) }
+      it { is_expected.to have_temporal_columns(extra_columns) }
+      it { is_expected.to have_history_columns(extra_columns) }
     end
 
     with_plain_table do
@@ -235,7 +239,7 @@ describe ChronoModel::Adapter do
         adapter.add_column table, :foobarbaz, :integer
       end
 
-      it { should have_columns(extra_columns) }
+      it { is_expected.to have_columns(extra_columns) }
     end
   end
 
@@ -247,13 +251,13 @@ describe ChronoModel::Adapter do
         adapter.remove_column table, :foo
       end
 
-      it { should have_columns(resulting_columns) }
-      it { should have_temporal_columns(resulting_columns) }
-      it { should have_history_columns(resulting_columns) }
+      it { is_expected.to have_columns(resulting_columns) }
+      it { is_expected.to have_temporal_columns(resulting_columns) }
+      it { is_expected.to have_history_columns(resulting_columns) }
 
-      it { should_not have_columns([['foo', 'integer']]) }
-      it { should_not have_temporal_columns([['foo', 'integer']]) }
-      it { should_not have_history_columns([['foo', 'integer']]) }
+      it { is_expected.to_not have_columns([['foo', 'integer']]) }
+      it { is_expected.to_not have_temporal_columns([['foo', 'integer']]) }
+      it { is_expected.to_not have_history_columns([['foo', 'integer']]) }
     end
 
     with_plain_table do
@@ -261,8 +265,8 @@ describe ChronoModel::Adapter do
         adapter.remove_column table, :foo
       end
 
-      it { should have_columns(resulting_columns) }
-      it { should_not have_columns([['foo', 'integer']]) }
+      it { is_expected.to have_columns(resulting_columns) }
+      it { is_expected.to_not have_columns([['foo', 'integer']]) }
     end
   end
 
@@ -272,13 +276,13 @@ describe ChronoModel::Adapter do
         adapter.rename_column table, :foo, :taratapiatapioca
       end
 
-      it { should_not have_columns([['foo', 'integer']]) }
-      it { should_not have_temporal_columns([['foo', 'integer']]) }
-      it { should_not have_history_columns([['foo', 'integer']]) }
+      it { is_expected.to_not have_columns([['foo', 'integer']]) }
+      it { is_expected.to_not have_temporal_columns([['foo', 'integer']]) }
+      it { is_expected.to_not have_history_columns([['foo', 'integer']]) }
 
-      it { should have_columns([['taratapiatapioca', 'integer']]) }
-      it { should have_temporal_columns([['taratapiatapioca', 'integer']]) }
-      it { should have_history_columns([['taratapiatapioca', 'integer']]) }
+      it { is_expected.to have_columns([['taratapiatapioca', 'integer']]) }
+      it { is_expected.to have_temporal_columns([['taratapiatapioca', 'integer']]) }
+      it { is_expected.to have_history_columns([['taratapiatapioca', 'integer']]) }
     end
 
     with_plain_table do
@@ -286,8 +290,8 @@ describe ChronoModel::Adapter do
         adapter.rename_column table, :foo, :taratapiatapioca
       end
 
-      it { should_not have_columns([['foo', 'integer']]) }
-      it { should have_columns([['taratapiatapioca', 'integer']]) }
+      it { is_expected.to_not have_columns([['foo', 'integer']]) }
+      it { is_expected.to have_columns([['taratapiatapioca', 'integer']]) }
     end
   end
 
@@ -297,13 +301,13 @@ describe ChronoModel::Adapter do
         adapter.change_column table, :foo, :float
       end
 
-      it { should_not have_columns([['foo', 'integer']]) }
-      it { should_not have_temporal_columns([['foo', 'integer']]) }
-      it { should_not have_history_columns([['foo', 'integer']]) }
+      it { is_expected.to_not have_columns([['foo', 'integer']]) }
+      it { is_expected.to_not have_temporal_columns([['foo', 'integer']]) }
+      it { is_expected.to_not have_history_columns([['foo', 'integer']]) }
 
-      it { should have_columns([['foo', 'double precision']]) }
-      it { should have_temporal_columns([['foo', 'double precision']]) }
-      it { should have_history_columns([['foo', 'double precision']]) }
+      it { is_expected.to have_columns([['foo', 'double precision']]) }
+      it { is_expected.to have_temporal_columns([['foo', 'double precision']]) }
+      it { is_expected.to have_history_columns([['foo', 'double precision']]) }
     end
 
     with_plain_table do
@@ -311,8 +315,8 @@ describe ChronoModel::Adapter do
         adapter.change_column table, :foo, :float
       end
 
-      it { should_not have_columns([['foo', 'integer']]) }
-      it { should have_columns([['foo', 'double precision']]) }
+      it { is_expected.to_not have_columns([['foo', 'integer']]) }
+      it { is_expected.to have_columns([['foo', 'double precision']]) }
     end
   end
 
@@ -322,9 +326,9 @@ describe ChronoModel::Adapter do
         adapter.remove_column table, :foo
       end
 
-      it { should_not have_columns([['foo', 'integer']]) }
-      it { should_not have_temporal_columns([['foo', 'integer']]) }
-      it { should_not have_history_columns([['foo', 'integer']]) }
+      it { is_expected.to_not have_columns([['foo', 'integer']]) }
+      it { is_expected.to_not have_temporal_columns([['foo', 'integer']]) }
+      it { is_expected.to_not have_history_columns([['foo', 'integer']]) }
     end
 
     with_plain_table do
@@ -332,7 +336,7 @@ describe ChronoModel::Adapter do
         adapter.remove_column table, :foo
       end
 
-      it { should_not have_columns([['foo', 'integer']]) }
+      it { is_expected.to_not have_columns([['foo', 'integer']]) }
     end
   end
 
@@ -340,8 +344,8 @@ describe ChronoModel::Adapter do
     subject { adapter.column_definitions(table).map {|d| d.take(2)} }
 
     assert = proc do
-      it { (subject & columns).should == columns }
-      it { should include(['id', 'integer']) }
+      it { expect(subject & columns).to eq columns }
+      it { is_expected.to include(['id', 'integer']) }
     end
 
     with_temporal_table(&assert)
@@ -352,7 +356,7 @@ describe ChronoModel::Adapter do
     subject { adapter.primary_key(table) }
 
     assert = proc do
-      it { should == 'id' }
+      it { is_expected.to eq 'id' }
     end
 
     with_temporal_table(&assert)
@@ -368,8 +372,8 @@ describe ChronoModel::Adapter do
         adapter.add_index table, [:bar, :baz], :name => 'bar_index'
       end
 
-      it { subject.map(&:name).should =~ %w( foo_index bar_index ) }
-      it { subject.map(&:columns).should =~ [['foo'], ['bar', 'baz']] }
+      it { expect(subject.map(&:name)).to match_array %w( foo_index bar_index ) }
+      it { expect(subject.map(&:columns)).to match_array [['foo'], ['bar', 'baz']] }
     end
 
     with_temporal_table(&assert)
@@ -384,32 +388,32 @@ describe ChronoModel::Adapter do
     context 'with nesting' do
 
       it 'saves the schema at each recursion' do
-        should be_in_schema(:default)
+        is_expected.to be_in_schema(:default)
 
-        adapter.on_schema('test_1') { should be_in_schema('test_1')
-          adapter.on_schema('test_2') { should be_in_schema('test_2')
-            adapter.on_schema('test_3') { should be_in_schema('test_3')
+        adapter.on_schema('test_1') { is_expected.to be_in_schema('test_1')
+          adapter.on_schema('test_2') { is_expected.to be_in_schema('test_2')
+            adapter.on_schema('test_3') { is_expected.to be_in_schema('test_3')
             }
-            should be_in_schema('test_2')
+            is_expected.to be_in_schema('test_2')
           }
-          should be_in_schema('test_1')
+          is_expected.to be_in_schema('test_1')
         }
 
-        should be_in_schema(:default)
+        is_expected.to be_in_schema(:default)
       end
 
     end
 
     context 'without nesting' do
       it 'ignores recursive calls' do
-        should be_in_schema(:default)
+        is_expected.to be_in_schema(:default)
 
-        adapter.on_schema('test_1', false) { should be_in_schema('test_1')
-          adapter.on_schema('test_2', false) { should be_in_schema('test_1')
-            adapter.on_schema('test_3', false) { should be_in_schema('test_1')
+        adapter.on_schema('test_1', false) { is_expected.to be_in_schema('test_1')
+          adapter.on_schema('test_2', false) { is_expected.to be_in_schema('test_1')
+            adapter.on_schema('test_3', false) { is_expected.to be_in_schema('test_1')
         } } }
 
-        should be_in_schema(:default)
+        is_expected.to be_in_schema(:default)
       end
     end
   end
@@ -445,8 +449,8 @@ describe ChronoModel::Adapter do
       end
 
       it { expect { insert }.to_not raise_error }
-      it { count(current).should == 2 }
-      it { count(history).should == 2 }
+      it { expect(count(current)).to eq 2 }
+      it { expect(count(history)).to eq 2 }
     end
 
     context 'when failing' do
@@ -458,9 +462,9 @@ describe ChronoModel::Adapter do
         SQL
       end
 
-      it { expect { insert }.to raise_error }
-      it { count(current).should == 2 } # Because the previous
-      it { count(history).should == 2 } # records are preserved
+      it { expect { insert }.to raise_error(ActiveRecord::StatementInvalid) }
+      it { expect(count(current)).to eq 2 } # Because the previous
+      it { expect(count(history)).to eq 2 } # records are preserved
     end
 
     context 'after a failure' do
@@ -474,10 +478,10 @@ describe ChronoModel::Adapter do
 
       it { expect { insert }.to_not raise_error }
 
-      it { count(current).should == 4 }
-      it { count(history).should == 4 }
+      it { expect(count(current)).to eq 4 }
+      it { expect(count(history)).to eq 4 }
 
-      it { ids(current).should == ids(history) }
+      it { expect(ids(current)).to eq ids(history) }
     end
   end
 
@@ -503,7 +507,7 @@ describe ChronoModel::Adapter do
     end
 
     it { expect { insert }.to_not raise_error }
-    it { insert; select.uniq.should == ['default-value'] }
+    it { insert; expect(select.uniq).to eq ['default-value'] }
   end
 
   context 'redundant UPDATEs' do
@@ -528,8 +532,8 @@ describe ChronoModel::Adapter do
       adapter.drop_table table
     end
 
-    it { count(current).should == 1 }
-    it { count(history).should == 2 }
+    it { expect(count(current)).to eq 1 }
+    it { expect(count(history)).to eq 2 }
 
   end
 
@@ -537,7 +541,7 @@ describe ChronoModel::Adapter do
     before :all do
       adapter.create_table table, :temporal => true do |t|
         t.string 'test'
-        t.timestamps
+        t.timestamps null: false
       end
 
       adapter.execute <<-SQL
@@ -563,8 +567,8 @@ describe ChronoModel::Adapter do
       adapter.drop_table table
     end
 
-    it { count(current).should == 1 }
-    it { count(history).should == 2 }
+    it { expect(count(current)).to eq 1 }
+    it { expect(count(history)).to eq 2 }
   end
 
   context 'selective journaled fields' do
@@ -593,8 +597,8 @@ describe ChronoModel::Adapter do
       adapter.drop_table table
     end
 
-    it { count(current).should == 1 }
-    it { count(history).should == 1 }
+    it { expect(count(current)).to eq 1 }
+    it { expect(count(history)).to eq 1 }
 
     it 'preserves options upon column change'
     it 'changes option upon table change'