statesman 12.1.0 → 13.1.0

data/lib/generators/statesman/generator_helpers.rb

@@ -10,36 +10,44 @@ module Statesman
       "app/models/#{klass.underscore}.rb"
     end
 
-    def migration_class_name
-      klass.gsub("::", "").pluralize
-    end
-
-    def next_migration_number
-      Time.now.utc.strftime("%Y%m%d%H%M%S")
-    end
-
     def parent_name
-      parent.demodulize.underscore
+      parent.underscore.split("/").join("_")
     end
 
     def parent_table_name
-      parent.demodulize.underscore.pluralize
+      parent.underscore.split("/").join("_").tableize
     end
 
     def parent_id
       parent_name + "_id"
     end
 
-    def table_name
+    def association_name
       klass.demodulize.underscore.pluralize
     end
 
+    def table_name
+      klass.underscore.split("/").join("_").tableize
+    end
+
+    def metadata_column_type
+      if ActiveRecord::Base.connection.supports_json?
+        postgres? ? :jsonb : :json
+      else
+        :text
+      end
+    end
+
     def index_name(index_id)
       "index_#{table_name}_#{index_id}"
     end
 
+    def postgres?
+      configuration.adapter.try(:match, /postgres/)
+    end
+
     def mysql?
-      configuration.try(:[], "adapter").try(:match, /mysql/)
+      configuration.adapter.try(:match, /mysql/)
     end
 
     # [] is deprecated and will be removed in 6.2
@@ -52,11 +60,17 @@ module Statesman
     end
 
     def database_supports_partial_indexes?
-      Statesman::Adapters::ActiveRecord.database_supports_partial_indexes?(klass.constantize)
+      Statesman::Adapters::ActiveRecord.database_supports_partial_indexes?(parent.constantize)
     end
 
     def metadata_default_value
-      Utils.rails_5_or_higher? ? "{}" : "{}".inspect
+      Utils.rails_5_or_higher? ? "{}" : "'{}'"
+    end
+
+    def metadata_column_config
+      return if mysql?
+
+      ", default: #{metadata_default_value}"
     end
   end
 end

data/lib/generators/statesman/migration_generator.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
 require "rails/generators"
+require "rails/generators/active_record"
 require "generators/statesman/generator_helpers"
 
 # Add statesman attributes to a pre-existing transition class
 module Statesman
   class MigrationGenerator < Rails::Generators::Base
     include Statesman::GeneratorHelpers
+    include ActiveRecord::Generators::Migration
 
     desc "Add the required Statesman attributes to your transition model"
 
@@ -15,14 +17,8 @@ module Statesman
 
     source_root File.expand_path("templates", __dir__)
 
-    def create_model_file
-      template("update_migration.rb.erb", file_name)
-    end
-
-    private
-
-    def file_name
-      "db/migrate/#{next_migration_number}_add_statesman_to_#{table_name}.rb"
+    def create_migration_file
+      migration_template("update_migration.rb.erb", File.join(db_migrate_path, "add_statesman_to_#{table_name}.rb"))
     end
   end
 end

data/lib/generators/statesman/templates/active_record_transition_model.rb.erb

@@ -9,17 +9,17 @@ class <%= klass %> < <%= Statesman::Utils.rails_5_or_higher? ? 'ApplicationRecor
   # self.updated_timestamp_column = nil
 
 <%- unless Statesman::Utils.rails_4_or_higher? -%>
-  attr_accessible :to_state, :metadata, :sort_key
+  attr_accessible :from_state, :to_state, :metadata, :sort_key
 
 <%- end -%>
-  belongs_to :<%= parent_name %><%= class_name_option %>, inverse_of: :<%= table_name %>
+  belongs_to :<%= parent_name %><%= class_name_option %>, inverse_of: :<%= association_name %>
 
   after_destroy :update_most_recent, if: :most_recent?
 
   private
 
   def update_most_recent
-    last_transition = <%= parent_name %>.<%= table_name %>.order(:sort_key).last
+    last_transition = <%= parent_name %>.<%= association_name %>.order(:sort_key).last
     return unless last_transition.present?
     last_transition.update_column(:most_recent, true)
   end

data/lib/generators/statesman/templates/create_migration.rb.erb

@@ -1,8 +1,9 @@
-class Create<%= migration_class_name %> < ActiveRecord::Migration<%= "[#{ActiveRecord::Migration.current_version}]" if Statesman::Utils.rails_5_or_higher? %>
+class <%= migration_class_name %> < ActiveRecord::Migration<%= "[#{ActiveRecord::Migration.current_version}]" if Statesman::Utils.rails_5_or_higher? %>
   def change
     create_table :<%= table_name %> do |t|
+      t.string :from_state, null: false
       t.string :to_state, null: false
-      t.text :metadata<%= ", default: #{metadata_default_value}" unless mysql? %>
+      t.<%= metadata_column_type %> :metadata<%= metadata_column_config %>
       t.integer :sort_key, null: false
       t.integer :<%= parent_id %>, null: false
       t.boolean :most_recent<%= ", null: false" if database_supports_partial_indexes? %>

data/lib/generators/statesman/templates/update_migration.rb.erb

@@ -1,7 +1,8 @@
-class AddStatesmanTo<%= migration_class_name %> < ActiveRecord::Migration<%= "[#{ActiveRecord::Migration.current_version}]" if Statesman::Utils.rails_5_or_higher? %>
+class <%= migration_class_name %> < ActiveRecord::Migration<%= "[#{ActiveRecord::Migration.current_version}]" if Statesman::Utils.rails_5_or_higher? %>
   def change
+    add_column :<%= table_name %>, :from_state, :string, null: false
     add_column :<%= table_name %>, :to_state, :string, null: false
-    add_column :<%= table_name %>, :metadata, :text<%= ", default: #{metadata_default_value}" unless mysql? %>
+    add_column :<%= table_name %>, :metadata, :<%= metadata_column_type %><%= metadata_column_config%>
     add_column :<%= table_name %>, :sort_key, :integer, null: false
     add_column :<%= table_name %>, :<%= parent_id %>, :integer, null: false
     add_column :<%= table_name %>, :most_recent, null: false

data/lib/statesman/adapters/active_record.rb

@@ -81,7 +81,7 @@ module Statesman
 
       def create_transition(from, to, metadata)
         transition = transitions_for_parent.build(
-          default_transition_attributes(to, metadata),
+          default_transition_attributes(from, to, metadata),
         )
 
         transition_class.transaction(requires_new: true) do
@@ -116,13 +116,19 @@ module Statesman
         transition
       end
 
-      def default_transition_attributes(to, metadata)
-        {
+      def default_transition_attributes(from, to, metadata)
+        attributes = {
           to_state: to,
           sort_key: next_sort_key,
           metadata: metadata,
           most_recent: not_most_recent_value(db_cast: false),
         }
+
+        if @transition_class.has_attribute?(:from_state)
+          attributes[:from_state] = from
+        end
+
+        attributes
       end
 
       def add_after_commit_callback(from, to, transition)
@@ -379,11 +385,9 @@ module Statesman
         true
       end
 
-      # rubocop: disable Naming/PredicateName
       def has_transactional_callbacks?
         true
       end
-      # rubocop: enable Naming/PredicateName
 
       def committed!(*)
         @callback.call

data/lib/statesman/adapters/active_record_transition.rb

@@ -19,6 +19,12 @@ module Statesman
         class_attribute :updated_timestamp_column
         self.updated_timestamp_column = DEFAULT_UPDATED_TIMESTAMP_COLUMN
       end
+
+      def from_state
+        if has_attribute?(:from_state)
+          self[:from_state]
+        end
+      end
     end
   end
 end

data/lib/statesman/adapters/memory.rb

@@ -20,7 +20,7 @@ module Statesman
       def create(from, to, metadata = {})
         from = from.to_s
         to = to.to_s
-        transition = transition_class.new(to, next_sort_key, metadata)
+        transition = transition_class.new(from, to, next_sort_key, metadata)
 
         @observer.execute(:before, from, to, transition)
         @history << transition

data/lib/statesman/adapters/memory_transition.rb

@@ -5,13 +5,15 @@ module Statesman
     class MemoryTransition
       attr_accessor :created_at
       attr_accessor :updated_at
+      attr_accessor :from_state
       attr_accessor :to_state
       attr_accessor :sort_key
       attr_accessor :metadata
 
-      def initialize(to, sort_key, metadata = {})
+      def initialize(from, to, sort_key, metadata = {})
         @created_at = Time.now
         @updated_at = Time.now
+        @from_state = from
         @to_state = to
         @sort_key = sort_key
         @metadata = metadata

data/lib/statesman/exceptions.rb

@@ -11,6 +11,8 @@ module Statesman
 
   class MissingTransitionAssociation < StandardError; end
 
+  class StateConstantConflictError < StandardError; end
+
   class TransitionFailedError < StandardError
     def initialize(from, to)
       @from = from

data/lib/statesman/guard.rb

@@ -6,7 +6,7 @@ require_relative "exceptions"
 module Statesman
   class Guard < Callback
     def call(*args)
-      raise GuardFailedError.new(from, to, callback) unless super(*args)
+      raise GuardFailedError.new(from, to, callback) unless super
     end
   end
 end

data/lib/statesman/machine.rb

@@ -39,6 +39,8 @@ module Statesman
           validate_initial_state(name)
           @initial_state = name
         end
+        define_state_constant(name)
+
         states << name
       end
 
@@ -163,6 +165,20 @@ module Statesman
 
       private
 
+      def define_state_constant(state_name)
+        constant_name = state_name.upcase.gsub(/[^A-Z0-9]/, "_")
+
+        if const_defined?(constant_name)
+          return if const_get(constant_name) == state_name
+
+          raise StateConstantConflictError, "Name conflict: '#{name}::#{constant_name}' is already " \
+                                            "defined as '#{const_get(constant_name)}' attempting to redefine " \
+                                            "as '#{state_name}'"
+        else
+          const_set(constant_name, state_name)
+        end
+      end
+
       def add_callback(callback_type: nil, callback_class: nil,
                        from: nil, to: nil, &block)
         validate_callback_type_and_class(callback_type, callback_class)

data/lib/statesman/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Statesman
-  VERSION = "12.1.0"
+  VERSION = "13.1.0"
 end

data/spec/generators/statesman/active_record_transition_generator_spec.rb

@@ -11,23 +11,33 @@ describe Statesman::ActiveRecordTransitionGenerator, type: :generator do
     stub_const("Yummy::BaconTransition", Class.new(ActiveRecord::Base))
   end
 
+  around { |e| Timecop.freeze(Time.parse("2025-01-01 00:00:00"), &e) }
+
   it_behaves_like "a generator" do
-    let(:migration_name) { "db/migrate/create_bacon_transitions.rb" }
+    let(:migration_name) { "db/migrate/create_yummy_bacon_transitions.rb" }
   end
 
   describe "creates a migration" do
-    subject(:migration) { file("db/migrate/#{time}_create_bacon_transitions.rb") }
+    subject(:migration) { file("db/migrate/20250101000000_create_yummy_bacon_transitions.rb") }
 
     before do
-      allow(Time).to receive(:now).and_return(mock_time)
       run_generator %w[Yummy::Bacon Yummy::BaconTransition]
     end
 
-    let(:mock_time) { double("Time", utc: double("UTCTime", strftime: time)) }
-    let(:time) { "5678309" }
-
     it "includes a foreign key" do
-      expect(migration).to contain("add_foreign_key :bacon_transitions, :bacons")
+      expect(migration).to contain("add_foreign_key :yummy_bacon_transitions, :yummy_bacons")
+    end
+
+    it "uses the right column type for Postgres", if: postgres? do
+      expect(migration).to contain("t.jsonb :metadata, default: {}")
+    end
+
+    it "uses the right column type for MySQL", if: mysql? do
+      expect(migration).to contain("t.json :metadata")
+    end
+
+    it "uses the right column type for SQLite", if: sqlite? do
+      expect(migration).to contain("t.json :metadata, default: {}")
     end
   end
 
@@ -36,8 +46,7 @@ describe Statesman::ActiveRecordTransitionGenerator, type: :generator do
 
     before { run_generator %w[Yummy::Bacon Yummy::BaconTransition] }
 
-    it { is_expected.to contain(/:bacon_transition/) }
-    it { is_expected.to_not contain(%r{:yummy/bacon}) }
+    it { is_expected.to contain(/:bacon_transitions/) }
     it { is_expected.to contain(/class_name: 'Yummy::Bacon'/) }
   end
 

data/spec/generators/statesman/migration_generator_spec.rb

@@ -2,6 +2,7 @@
 
 require "support/generators_shared_examples"
 require "generators/statesman/migration_generator"
+require "rails/generators/testing/behavior"
 
 describe Statesman::MigrationGenerator, type: :generator do
   before do
@@ -9,40 +10,46 @@ describe Statesman::MigrationGenerator, type: :generator do
     stub_const("Yummy::BaconTransition", Class.new(ActiveRecord::Base))
   end
 
+  around { |e| Timecop.freeze(Time.parse("2025-01-01 00:00:00"), &e) }
+
   it_behaves_like "a generator" do
-    let(:migration_name) { "db/migrate/add_statesman_to_bacon_transitions.rb" }
+    let(:migration_name) { "db/migrate/20250101000000_add_statesman_to_yummy_bacon_transitions.rb" }
   end
 
   describe "the model contains the correct words" do
     subject(:migration) do
       file(
-        "db/migrate/#{migration_number}_add_statesman_to_bacon_transitions.rb",
+        "db/migrate/20250101000000_add_statesman_to_yummy_bacon_transitions.rb",
       )
     end
 
-    let(:migration_number) { "5678309" }
-
-    let(:mock_time) do
-      double("Time", utc: double("UTCTime", strftime: migration_number))
-    end
-
     before do
-      allow(Time).to receive(:now).and_return(mock_time)
       run_generator %w[Yummy::Bacon Yummy::BaconTransition]
     end
 
-    it { is_expected.to contain(/:bacon_transition/) }
-    it { is_expected.to_not contain(%r{:yummy/bacon}) }
+    it { is_expected.to contain(/:yummy_bacon_transition/) }
     it { is_expected.to contain(/null: false/) }
 
     it "names the sorting index appropriately" do
       expect(migration).
-        to contain("name: \"index_bacon_transitions_parent_sort\"")
+        to contain("name: \"index_yummy_bacon_transitions_parent_sort\"")
     end
 
     it "names the most_recent index appropriately" do
       expect(migration).
-        to contain("name: \"index_bacon_transitions_parent_most_recent\"")
+        to contain("name: \"index_yummy_bacon_transitions_parent_most_recent\"")
+    end
+
+    it "uses the right column type for Postgres", if: postgres? do
+      expect(migration).to contain(":metadata, :jsonb")
+    end
+
+    it "uses the right column type for MySQL", if: mysql? do
+      expect(migration).to contain(":metadata, :json")
+    end
+
+    it "uses the right column type for SQLite", if: sqlite? do
+      expect(migration).to contain(":metadata, :json")
     end
   end
 end

data/spec/spec_helper.rb

@@ -15,6 +15,7 @@ require "rspec/rails"
 require "support/exactly_query_databases"
 require "rspec/its"
 require "pry"
+require "timecop"
 
 RSpec.configure do |config|
   config.raise_errors_for_deprecations!

data/spec/statesman/adapters/active_record_queries_spec.rb

@@ -214,13 +214,13 @@ describe Statesman::Adapters::ActiveRecordQueries, :active_record do
   context "using old configuration method" do
     let(:config_type) { :old }
 
-    include_examples "testing methods"
+    it_behaves_like "testing methods"
   end
 
   context "using new configuration method" do
     let(:config_type) { :new }
 
-    include_examples "testing methods"
+    it_behaves_like "testing methods"
   end
 
   context "with no association with the transition class" do

data/spec/statesman/adapters/active_record_spec.rb

@@ -375,9 +375,10 @@ describe Statesman::Adapters::ActiveRecord, :active_record do
     let(:adapter) { described_class.new(transition_class, model, observer) }
 
     context "with a previously looked up transition" do
-      before { adapter.create(:x, :y) }
-
-      before { adapter.last }
+      before do
+        adapter.create(:x, :y)
+        adapter.last
+      end
 
       it "caches the transition" do
         expect_any_instance_of(MyActiveRecordModel).
@@ -444,9 +445,10 @@ describe Statesman::Adapters::ActiveRecord, :active_record do
     end
 
     context "with a pre-fetched transition history" do
-      before { adapter.create(:x, :y) }
-
-      before { model.my_active_record_model_transitions.load_target }
+      before do
+        adapter.create(:x, :y)
+        model.my_active_record_model_transitions.load_target
+      end
 
       it "doesn't query the database" do
         expect(MyActiveRecordModelTransition).to_not receive(:connection)

data/spec/statesman/adapters/memory_transition_spec.rb

@@ -4,10 +4,12 @@ require "statesman/adapters/memory_transition"
 
 describe Statesman::Adapters::MemoryTransition do
   describe "#initialize" do
+    let(:from) { :n }
     let(:to) { :y }
     let(:sort_key) { 0 }
-    let(:create) { described_class.new(to, sort_key) }
+    let(:create) { described_class.new(from, to, sort_key) }
 
+    specify { expect(create.from_state).to equal(from) }
     specify { expect(create.to_state).to equal(to) }
     specify { expect(create.created_at).to be_a(Time) }
     specify { expect(create.updated_at).to be_a(Time) }
@@ -15,7 +17,7 @@ describe Statesman::Adapters::MemoryTransition do
 
     context "with metadata passed" do
       let(:metadata) { { some: :hash } }
-      let(:create) { described_class.new(to, sort_key, metadata) }
+      let(:create) { described_class.new(from, to, sort_key, metadata) }
 
       specify { expect(create.metadata).to eq(metadata) }
     end

data/spec/statesman/adapters/shared_examples.rb

@@ -120,9 +120,10 @@ shared_examples_for "an adapter" do |adapter_class, transition_class, options =
   describe "#last" do
     subject { adapter.last }
 
-    before { adapter.create(:x, :y) }
-
-    before { adapter.create(:y, :z) }
+    before do
+      adapter.create(:x, :y)
+      adapter.create(:y, :z)
+    end
 
     it { is_expected.to be_a(transition_class) }
     specify { expect(adapter.last.to_state.to_sym).to eq(:z) }

data/spec/statesman/adapters/type_safe_active_record_queries_spec.rb

@@ -201,6 +201,6 @@ describe Statesman::Adapters::TypeSafeActiveRecordQueries, :active_record do
   end
 
   context "using configuration method" do
-    include_examples "testing methods"
+    it_behaves_like "testing methods"
   end
 end

data/spec/statesman/exceptions_spec.rb

@@ -51,6 +51,16 @@ describe "Exceptions" do
     end
   end
 
+  describe "StateConstantConflictError" do
+    subject(:error) { Statesman::StateConstantConflictError.new }
+
+    its(:message) { is_expected.to eq("Statesman::StateConstantConflictError") }
+
+    its "string matches its message" do
+      expect(error.to_s).to eq(error.message)
+    end
+  end
+
   describe "TransitionFailedError" do
     subject(:error) { Statesman::TransitionFailedError.new("from", "to") }
 

data/spec/statesman/machine_spec.rb

@@ -1,20 +1,33 @@
 # frozen_string_literal: true
 
 describe Statesman::Machine do
-  let(:machine) { Class.new { include Statesman::Machine } }
+  let(:machine) do
+    Class.new do
+      include Statesman::Machine
+
+      def self.name
+        "MyStateMachine"
+      end
+    end
+  end
   let(:my_model) { Class.new { attr_accessor :current_state }.new }
 
   describe ".state" do
-    before { machine.state(:x) }
-
-    before { machine.state(:y) }
+    before do
+      machine.state(:x)
+      machine.state(:y)
+    end
 
     specify { expect(machine.states).to eq(%w[x y]) }
 
+    specify { expect(machine::X).to eq "x" }
+
+    specify { expect(machine::Y).to eq "y" }
+
     context "initial" do
-      before { machine.state(:x, initial: true) }
+      before { machine.state(:z, initial: true) }
 
-      specify { expect(machine.initial_state).to eq("x") }
+      specify { expect(machine.initial_state).to eq("z") }
 
       context "when an initial state is already defined" do
         it "raises an error" do
@@ -23,6 +36,27 @@ describe Statesman::Machine do
         end
       end
     end
+
+    context "when state name constant is already defined" do
+      context "with the same value" do
+        it "does not raise an error" do
+          machine.const_set(:SOME_CONST, "some_const")
+          expect { machine.state(:some_const) }.to_not raise_error
+        end
+      end
+
+      context "with a different value" do
+        it "raises an error about state constant conflict" do
+          machine.const_set(:SOME_CONST, "some_const_different")
+
+          expect { machine.state(:some_const) }.to raise_error(
+            Statesman::StateConstantConflictError, "Name conflict: 'MyStateMachine::SOME_CONST' is " \
+                                                   "already defined as 'some_const_different' " \
+                                                   "attempting to redefine as 'some_const'"
+          )
+        end
+      end
+    end
   end
 
   describe ".remove_state" do
@@ -610,9 +644,10 @@ describe Statesman::Machine do
     end
 
     context "with multiple transitions" do
-      before { instance.transition_to!(:y) }
-
-      before { instance.transition_to!(:z) }
+      before do
+        instance.transition_to!(:y)
+        instance.transition_to!(:z)
+      end
 
       it { is_expected.to eq("z") }
     end
@@ -627,12 +662,11 @@ describe Statesman::Machine do
         state :y
         transition from: :x, to: :y
       end
+      instance.transition_to!(:y)
     end
 
     let(:instance) { machine.new(my_model) }
 
-    before { instance.transition_to!(:y) }
-
     context "when machine is in given state" do
       let(:state) { "y" }
 
@@ -995,7 +1029,7 @@ describe Statesman::Machine do
     let(:instance) { machine.new(my_model) }
     let(:metadata) { { some: :metadata } }
 
-    context "when it is succesful" do
+    context "when it is successful" do
       before do
         expect(instance).to receive(:transition_to!).once.
           with(:some_state, metadata).and_return(:some_state)