statesman 1.1.0 → 1.2.0

data/lib/statesman/railtie.rb

@@ -0,0 +1,9 @@
+module Statesman
+  class Railtie < ::Rails::Railtie
+    railtie_name :statesman
+
+    rake_tasks do
+      load "tasks/statesman.rake"
+    end
+  end
+end

data/lib/statesman/version.rb

@@ -1,3 +1,3 @@
 module Statesman
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 end

data/lib/tasks/statesman.rake

@@ -0,0 +1,49 @@
+namespace :statesman do
+  desc "Set most_recent to false for old transitions and to true for the "\
+       "latest one. Safe to re-run"
+  task :backfill_most_recent, [:parent_model_name] => :environment do |_, args|
+    parent_model_name = args.parent_model_name
+    abort("Parent model name must be specified") unless parent_model_name
+
+    parent_class = parent_model_name.constantize
+    transition_class = parent_class.transition_class
+    parent_fk = "#{parent_model_name.demodulize.underscore}_id"
+
+    total_models = parent_class.count
+    done_models = 0
+    batch_size = 500
+
+    parent_class.find_in_batches(batch_size: batch_size) do |models|
+      ActiveRecord::Base.transaction do
+        # Set all transitions' most_recent to FALSE
+        transition_class.where(parent_fk => models.map(&:id)).
+          update_all(most_recent: false)
+
+        # Set current transition's most_recent to TRUE
+        ActiveRecord::Base.connection.execute %{
+          UPDATE #{transition_class.table_name}
+          SET most_recent = true
+          FROM
+          (
+            SELECT initial_t.id, subsequent_t.created_at
+            FROM #{transition_class.table_name} initial_t
+            LEFT JOIN #{transition_class.table_name} subsequent_t ON
+            (
+                initial_t.#{parent_fk} = subsequent_t.#{parent_fk}
+                AND initial_t.sort_key < subsequent_t.sort_key
+            )
+            WHERE initial_t.#{parent_fk}
+              IN (#{models.map { |p| "'#{p.id}'" }.join(',')})
+            AND subsequent_t.id IS NULL
+          ) x
+          WHERE #{transition_class.table_name}.id = x.id
+        }
+      end
+
+      done_models += batch_size
+      puts "Updated #{transition_class.name.pluralize} for "\
+           "#{[done_models, total_models].min}/#{total_models} "\
+           "#{parent_model_name.pluralize}"
+    end
+  end
+end

data/spec/fixtures/add_constraints_to_most_recent_for_bacon_transitions.rb

@@ -0,0 +1,13 @@
+class AddConstraintsToMostRecentForBaconTransitions < ActiveRecord::Migration
+  disable_ddl_transaction!
+
+  def up
+    add_index :bacon_transitions, [:bacon_id, :most_recent], unique: true, where: "most_recent", name: "index_bacon_transitions_parent_most_recent", algorithm: :concurrently
+    change_column_null :bacon_transitions, :most_recent, false
+  end
+
+  def down
+    remove_index :bacon_transitions, name: "index_bacon_transitions_parent_most_recent"
+    change_column_null :bacon_transitions, :most_recent, true
+  end
+end

data/spec/fixtures/add_most_recent_to_bacon_transitions.rb

@@ -0,0 +1,9 @@
+class AddMostRecentToBaconTransitions < ActiveRecord::Migration
+  def up
+    add_column :bacon_transitions, :most_recent, :boolean, null: true
+  end
+
+  def down
+    remove_column :bacon_transitions, :most_recent
+  end
+end

data/spec/generators/statesman/active_record_transition_generator_spec.rb

@@ -3,7 +3,6 @@ require "support/generators_shared_examples"
 require "generators/statesman/active_record_transition_generator"
 
 describe Statesman::ActiveRecordTransitionGenerator, type: :generator do
-
   it_behaves_like "a generator" do
     let(:migration_name) { 'db/migrate/create_bacon_transitions.rb' }
   end
@@ -24,5 +23,4 @@ describe Statesman::ActiveRecordTransitionGenerator, type: :generator do
     it { is_expected.not_to contain(/class_name:/) }
     it { is_expected.to contain(/class BaconTransition/) }
   end
-
 end

data/spec/generators/statesman/add_constraints_to_most_recent_generator_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+require "support/generators_shared_examples"
+require "generators/statesman/add_constraints_to_most_recent_generator"
+
+describe Statesman::AddConstraintsToMostRecentGenerator, type: :generator do
+  it_behaves_like "a generator" do
+    let(:migration_name) do
+      'db/migrate/add_constraints_to_most_recent_for_bacon_transitions.rb'
+    end
+  end
+
+  describe "the migration contains the correct words" do
+    let(:migration_number) { '5678309' }
+
+    let(:mock_time) do
+      double('Time', utc: double('UTCTime', strftime: migration_number))
+    end
+
+    subject(:migration_file) do
+      file("db/migrate/#{migration_number}_"\
+           "add_constraints_to_most_recent_for_bacon_transitions.rb")
+    end
+
+    let(:fixture_file) do
+      File.read("spec/fixtures/add_constraints_to_most_recent_for_"\
+                "bacon_transitions.rb")
+    end
+
+    before do
+      allow(Time).to receive(:now).and_return(mock_time)
+      run_generator %w(Bacon BaconTransition)
+    end
+
+    it "matches the fixture" do
+      expect(migration_file).to contain(fixture_file)
+    end
+  end
+end

data/spec/generators/statesman/add_most_recent_generator_spec.rb

@@ -0,0 +1,35 @@
+require "spec_helper"
+require "support/generators_shared_examples"
+require "generators/statesman/add_most_recent_generator"
+
+describe Statesman::AddMostRecentGenerator, type: :generator do
+  it_behaves_like "a generator" do
+    let(:migration_name) do
+      'db/migrate/add_most_recent_to_bacon_transitions.rb'
+    end
+  end
+
+  describe "the migration" do
+    let(:migration_number) { '5678309' }
+
+    let(:mock_time) do
+      double('Time', utc: double('UTCTime', strftime: migration_number))
+    end
+
+    subject(:migration_file) do
+      file("db/migrate/#{migration_number}_"\
+           "add_most_recent_to_bacon_transitions.rb")
+    end
+
+    let(:fixture_file) do
+      File.read("spec/fixtures/add_most_recent_to_bacon_transitions.rb")
+    end
+
+    before { allow(Time).to receive(:now).and_return(mock_time) }
+    before { run_generator %w(Bacon BaconTransition) }
+
+    it "matches the fixture" do
+      expect(migration_file).to contain(fixture_file)
+    end
+  end
+end

data/spec/generators/statesman/migration_generator_spec.rb

@@ -3,7 +3,6 @@ require "support/generators_shared_examples"
 require "generators/statesman/migration_generator"
 
 describe Statesman::MigrationGenerator, type: :generator do
-
   it_behaves_like "a generator" do
     let(:migration_name) { 'db/migrate/add_statesman_to_bacon_transitions.rb' }
   end
@@ -29,5 +28,15 @@ describe Statesman::MigrationGenerator, type: :generator do
     it { is_expected.to contain(/:bacon_transition/) }
     it { is_expected.not_to contain(/:yummy\/bacon/) }
     it { is_expected.to contain(/null: false/) }
+
+    it "names the sorting index appropriately" do
+      expect(subject).
+        to contain("name: \"index_bacon_transitions_parent_sort\"")
+    end
+
+    it "names the most_recent index appropriately" do
+      expect(subject).
+        to contain("name: \"index_bacon_transitions_parent_most_recent\"")
+    end
   end
 end

data/spec/generators/statesman/mongoid_transition_generator_spec.rb

@@ -3,7 +3,6 @@ require "support/generators_shared_examples"
 require "generators/statesman/mongoid_transition_generator"
 
 describe Statesman::MongoidTransitionGenerator, type: :generator do
-
   describe 'the model contains the correct words' do
     before { run_generator %w(Yummy::Bacon Yummy::BaconTransition) }
     subject { file('app/models/yummy/bacon_transition.rb') }
@@ -19,5 +18,4 @@ describe Statesman::MongoidTransitionGenerator, type: :generator do
     it { is_expected.not_to contain(/class_name:/) }
     it { is_expected.not_to contain(/CreateYummy::Bacon/) }
   end
-
 end

data/spec/spec_helper.rb

@@ -26,12 +26,21 @@ RSpec.configure do |config|
     raise(error)
   end
 
-  config.before(:each) do
-    # Connect to & cleanup test database
-    ActiveRecord::Base.establish_connection(adapter: "sqlite3",
-                                            database: DB.to_s)
+  if config.exclusion_filter[:active_record]
+    puts "Skipping ActiveRecord tests"
+  else
+    # Connect to the database for activerecord tests
+    db_conn_spec = ENV["DATABASE_URL"]
+    db_conn_spec ||=  { adapter: "sqlite3", database: ":memory:" }
+    ActiveRecord::Base.establish_connection(db_conn_spec)
 
-    %w(my_models my_model_transitions).each do |table_name|
+    db_adapter = ActiveRecord::Base.connection.adapter_name
+    puts "Running with database adapter '#{db_adapter}'"
+  end
+
+  config.before(:each, active_record: true) do
+    tables = %w(my_active_record_models my_active_record_model_transitions)
+    tables.each do |table_name|
       sql = "DROP TABLE IF EXISTS #{table_name};"
       ActiveRecord::Base.connection.execute(sql)
     end
@@ -45,9 +54,15 @@ RSpec.configure do |config|
     def prepare_transitions_table
       silence_stream(STDOUT) do
         CreateMyActiveRecordModelTransitionMigration.migrate(:up)
+        MyActiveRecordModelTransition.reset_column_information
       end
     end
-  end
 
-  config.after(:each) { DB.delete if DB.exist? }
+    def drop_most_recent_column
+      silence_stream(STDOUT) do
+        DropMostRecentColumn.migrate(:up)
+        MyActiveRecordModelTransition.reset_column_information
+      end
+    end
+  end
 end

data/spec/statesman/adapters/active_record_queries_spec.rb

@@ -1,11 +1,16 @@
 require "spec_helper"
 
-describe Statesman::Adapters::ActiveRecordQueries do
+describe Statesman::Adapters::ActiveRecordQueries, active_record: true do
   before do
     prepare_model_table
     prepare_transitions_table
   end
 
+  before do
+    Statesman.configure { storage_adapter(Statesman::Adapters::ActiveRecord) }
+  end
+  after { Statesman.configure { storage_adapter(Statesman::Adapters::Memory) } }
+
   before do
     MyActiveRecordModel.send(:include, Statesman::Adapters::ActiveRecordQueries)
     MyActiveRecordModel.class_eval do
@@ -21,13 +26,13 @@ describe Statesman::Adapters::ActiveRecordQueries do
 
   let!(:model) do
     model = MyActiveRecordModel.create
-    model.my_active_record_model_transitions.create(to_state: :succeeded)
+    model.state_machine.transition_to(:succeeded)
     model
   end
 
   let!(:other_model) do
     model = MyActiveRecordModel.create
-    model.my_active_record_model_transitions.create(to_state: :failed)
+    model.state_machine.transition_to(:failed)
     model
   end
 
@@ -35,45 +40,122 @@ describe Statesman::Adapters::ActiveRecordQueries do
 
   let!(:returned_to_initial_model) do
     model = MyActiveRecordModel.create
-    model.my_active_record_model_transitions.create(to_state: :failed)
-    model.my_active_record_model_transitions.create(to_state: :initial)
+    model.state_machine.transition_to(:failed)
+    model.state_machine.transition_to(:initial)
     model
   end
 
-  describe ".in_state" do
-    context "given a single state" do
-      subject { MyActiveRecordModel.in_state(:succeeded) }
+  context "with a most_recent column" do
+    describe ".in_state" do
+      context "given a single state" do
+        subject { MyActiveRecordModel.in_state(:succeeded) }
 
-      it { is_expected.to include model }
-    end
+        it { is_expected.to include model }
+        it { is_expected.not_to include other_model }
+        its(:to_sql) { is_expected.to include('most_recent') }
+      end
+
+      context "given multiple states" do
+        subject { MyActiveRecordModel.in_state(:succeeded, :failed) }
+
+        it { is_expected.to include model }
+        it { is_expected.to include other_model }
+      end
 
-    context "given multiple states" do
-      subject { MyActiveRecordModel.in_state(:succeeded, :failed) }
+      context "given the initial state" do
+        subject { MyActiveRecordModel.in_state(:initial) }
 
-      it { is_expected.to include model }
-      it { is_expected.to include other_model }
+        it { is_expected.to include initial_state_model }
+        it { is_expected.to include returned_to_initial_model }
+      end
+
+      context "given an array of states" do
+        subject { MyActiveRecordModel.in_state([:succeeded, :failed]) }
+
+        it { is_expected.to include model }
+        it { is_expected.to include other_model }
+      end
     end
 
-    context "given the initial state" do
-      subject { MyActiveRecordModel.in_state(:initial) }
+    describe ".not_in_state" do
+      context "given a single state" do
+        subject { MyActiveRecordModel.not_in_state(:failed) }
+        it { is_expected.to include model }
+        it { is_expected.not_to include other_model }
+        its(:to_sql) { is_expected.to include('most_recent') }
+      end
+
+      context "given multiple states" do
+        subject { MyActiveRecordModel.not_in_state(:succeeded, :failed) }
+        it do
+          is_expected.to match_array([initial_state_model,
+                                      returned_to_initial_model])
+        end
+      end
 
-      it { is_expected.to include initial_state_model }
-      it { is_expected.to include returned_to_initial_model }
+      context "given an array of states" do
+        subject { MyActiveRecordModel.not_in_state([:succeeded, :failed]) }
+        it do
+          is_expected.to match_array([initial_state_model,
+                                      returned_to_initial_model])
+        end
+      end
     end
   end
 
-  describe ".not_in_state" do
-    context "given a single state" do
-      subject { MyActiveRecordModel.not_in_state(:failed) }
-      it { is_expected.to include model }
-      it { is_expected.not_to include other_model }
+  context "without a most_recent column" do
+    before { drop_most_recent_column }
+
+    describe ".in_state" do
+      context "given a single state" do
+        subject { MyActiveRecordModel.in_state(:succeeded) }
+
+        it { is_expected.to include model }
+      end
+
+      context "given multiple states" do
+        subject { MyActiveRecordModel.in_state(:succeeded, :failed) }
+
+        it { is_expected.to include model }
+        it { is_expected.to include other_model }
+      end
+
+      context "given the initial state" do
+        subject { MyActiveRecordModel.in_state(:initial) }
+
+        it { is_expected.to include initial_state_model }
+        it { is_expected.to include returned_to_initial_model }
+      end
+
+      context "given an array of states" do
+        subject { MyActiveRecordModel.in_state([:succeeded, :failed]) }
+
+        it { is_expected.to include model }
+        it { is_expected.to include other_model }
+      end
     end
 
-    context "given multiple states" do
-      subject { MyActiveRecordModel.not_in_state(:succeeded, :failed) }
-      it do
-        is_expected.to match_array([initial_state_model,
-                                    returned_to_initial_model])
+    describe ".not_in_state" do
+      context "given a single state" do
+        subject { MyActiveRecordModel.not_in_state(:failed) }
+        it { is_expected.to include model }
+        it { is_expected.not_to include other_model }
+      end
+
+      context "given multiple states" do
+        subject { MyActiveRecordModel.not_in_state(:succeeded, :failed) }
+        it do
+          is_expected.to match_array([initial_state_model,
+                                      returned_to_initial_model])
+        end
+      end
+
+      context "given an array of states" do
+        subject { MyActiveRecordModel.not_in_state([:succeeded, :failed]) }
+        it do
+          is_expected.to match_array([initial_state_model,
+                                      returned_to_initial_model])
+        end
       end
     end
   end