steady_state 1.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b7ad486ead2f7c864e7ba69d8525f7d6e72fbb220c7ebabf866802f1d7ad50b
-  data.tar.gz: f46001c070069cb44e77aa330170c1204626324c175d3c11ad8d11e21aaa3123
+  metadata.gz: 138a31884498cda0cd7785af5ba7a13c59c71459a2970680652edc20bb9a42e8
+  data.tar.gz: 224574b15d9664ea395a4c38656bfa9d3c3ddb8fe100018a60cf30b2f35a4422
 SHA512:
-  metadata.gz: ac41840168b5cf0aeba5ebf7ba80784fe164013ae2926a0939e713e1fb3d686d30c945c07a1b51a68cdcbfc00b13e9a2ccb2b12480f43a166b83d6bf4d7100ed
-  data.tar.gz: f74858d2bf2552e4603272f4cf82bee27bbc2930fe2eb1661e5717c34bfd011faf638caaea83b35d230672b07fca2e017a2965c611992aeac8f60d441735cee7
+  metadata.gz: 1f7f923baf74fadcfd46973f86a5f67523e8138f65a7bdcdd5e07393468677b96a2e7fafa37c9315099e562d7e467a5d71153152c004bb4c004e1b2224de92ff
+  data.tar.gz: d1669039e0f85a5d5926ac35f344f90cf9039e319162b3a1ce47be3a240969e236d2b07ed6d0e12a573fc175d68c812b0b07e92f52e4b02136aea86622257f8a

data/README.md

@@ -210,6 +210,22 @@ steady_state :step, scopes: false do
 end
 ```
 
+`steady_state` also follows the same `prefix` api as `delegate` in Rails.  You may optionally define your scopes to be prefixed to the name of the state machine with `prefix: true`, or you may provide a custom prefix with `prefix: :some_custom_name`.  This may be useful when dealing with multiple state machines on one object.
+
+```ruby
+steady_state :temperature, scopes: { prefix: true } do
+  state 'cold', default: true
+end
+
+steady_state :color_temperature, scopes: { prefix: 'color' } do
+  state 'cold', default: true
+end
+
+Material.solid # => query for 'solid' records
+Material.temperature_cold # => query for records with a cold temperature
+Material.color_cold # => query for for records with a cold color temperature
+```
+
 ### Next and Previous States
 
 The `may_become?` method can be used to see if setting the state to a particular value would be allowed (ignoring all other validations):
@@ -277,7 +293,7 @@ class Material
     self.state = 'liquid'
     valid? # will return `false` if state transition is invalid
   end
-  
+
   def melt!
     self.state = 'liquid'
     validate! # will raise an exception if state transition is invalid

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 begin
   require 'bundler/setup'
 rescue LoadError

data/lib/steady_state/attribute/state.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SteadyState
   module Attribute
     class State < SimpleDelegator

data/lib/steady_state/attribute/state_machine.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SteadyState
   module Attribute
     class StateMachine

data/lib/steady_state/attribute/transition_validator.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module SteadyState
   module Attribute
     class TransitionValidator < ActiveModel::EachValidator
       def validate_each(obj, attr_name, _value)
-        obj.errors.add(attr_name, :invalid) if obj.instance_variable_defined?("@last_valid_#{attr_name}")
+        obj.errors.add(attr_name, :invalid) if obj.instance_variable_defined?(:"@last_valid_#{attr_name}")
       end
     end
   end

data/lib/steady_state/attribute.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'steady_state/attribute/state'
 require 'steady_state/attribute/state_machine'
 require 'steady_state/attribute/transition_validator'
@@ -17,26 +19,26 @@ module SteadyState
         overrides = Module.new do
           define_method :"validate_#{attr_name}_transition_to" do |next_value|
             if public_send(attr_name).may_become?(next_value)
-              remove_instance_variable("@last_valid_#{attr_name}") if instance_variable_defined?("@last_valid_#{attr_name}")
-            elsif !instance_variable_defined?("@last_valid_#{attr_name}")
-              instance_variable_set("@last_valid_#{attr_name}", public_send(attr_name))
+              remove_instance_variable(:"@last_valid_#{attr_name}") if instance_variable_defined?(:"@last_valid_#{attr_name}")
+            elsif !instance_variable_defined?(:"@last_valid_#{attr_name}")
+              instance_variable_set(:"@last_valid_#{attr_name}", public_send(attr_name))
             end
           end
 
           define_method :"#{attr_name}=" do |value|
-            unless instance_variable_defined?("@#{attr_name}_state_initialized")
-              instance_variable_set("@#{attr_name}_state_initialized", true)
+            unless instance_variable_defined?(:"@#{attr_name}_state_initialized")
+              instance_variable_set(:"@#{attr_name}_state_initialized", true)
             end
             public_send(:"validate_#{attr_name}_transition_to", value) if public_send(attr_name).present?
             super(value)
           end
 
           define_method :"#{attr_name}" do |*args, &blk|
-            unless instance_variable_defined?("@#{attr_name}_state_initialized")
+            unless instance_variable_defined?(:"@#{attr_name}_state_initialized")
               public_send(:"#{attr_name}=", state_machines[attr_name].start) if super(*args, &blk).blank?
-              instance_variable_set("@#{attr_name}_state_initialized", true)
+              instance_variable_set(:"@#{attr_name}_state_initialized", true)
             end
-            last_valid_value = instance_variable_get("@last_valid_#{attr_name}") if instance_variable_defined?("@last_valid_#{attr_name}")
+            last_valid_value = instance_variable_get(:"@last_valid_#{attr_name}") if instance_variable_defined?(:"@last_valid_#{attr_name}")
             state_machines[attr_name].new_state super(*args, &blk), last_valid_value
           end
         end
@@ -54,8 +56,11 @@ module SteadyState
 
         delegate(*state_machines[attr_name].predicates, to: attr_name, allow_nil: true) if predicates
         if scopes
+          scopes = {} unless scopes.is_a?(Hash)
+          prefix = SteadyState::Attribute.build_prefix(attr_name, **scopes)
+
           state_machines[attr_name].states.each do |state|
-            scope state.to_sym, -> { where(attr_name.to_sym => state) }
+            scope :"#{prefix}#{state}", -> { where(attr_name.to_sym => state) }
           end
         end
 
@@ -63,5 +68,13 @@ module SteadyState
                                    inclusion: { in: state_machines[attr_name].states }
       end
     end
+
+    def self.build_prefix(attr_name, prefix: false)
+      if prefix
+        "#{prefix == true ? attr_name : prefix}_"
+      else
+        ""
+      end
+    end
   end
 end

data/lib/steady_state/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SteadyState
-  VERSION = '1.0.0'.freeze
+  VERSION = '1.2.0'
 end

data/lib/steady_state.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_support'
 require 'active_support/core_ext'
 require 'active_model'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: steady_state
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Nathan Griffith
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-11 00:00:00.000000000 Z
+date: 2024-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -113,13 +113,11 @@ files:
 - lib/steady_state/attribute/state_machine.rb
 - lib/steady_state/attribute/transition_validator.rb
 - lib/steady_state/version.rb
-- spec/spec_helper.rb
-- spec/steady_state/attribute_spec.rb
-homepage: 
+homepage:
 licenses: []
 metadata:
   rubygems_mfa_required: 'true'
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -127,17 +125,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.5
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.5
-signing_key: 
+rubygems_version: 3.5.14
+signing_key:
 specification_version: 4
 summary: Minimalist state management via "an enum with guard rails"
-test_files:
-- spec/spec_helper.rb
-- spec/steady_state/attribute_spec.rb
+test_files: []

data/spec/spec_helper.rb

@@ -1 +0,0 @@
-require 'steady_state'

data/spec/steady_state/attribute_spec.rb

@@ -1,403 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe SteadyState::Attribute do
-  let(:steady_state_class) do
-    Class.new do
-      include ActiveModel::Model
-      include SteadyState
-
-      def self.model_name
-        ActiveModel::Name.new(self, nil, 'steady_state_class')
-      end
-    end
-  end
-  subject { steady_state_class.new }
-
-  shared_examples 'a basic state machine' do
-    it 'starts on initial state' do
-      expect(subject.state).to eq 'solid'
-    end
-
-    it 'allows initialization to the initial state' do
-      expect(steady_state_class.new(state: 'solid')).to be_valid
-    end
-
-    it 'allows initialization to other states' do
-      expect(steady_state_class.new(state: 'plasma')).to be_valid
-    end
-
-    it 'adds validation errors when initializing to an invalid state' do
-      object = steady_state_class.new(state: 'banana')
-      expect(object).not_to be_valid
-      expect(object.errors[:state]).to match_array(['is not included in the list'])
-    end
-
-    it 'allows valid transitions' do
-      expect(subject.state.may_become?('liquid')).to eq true
-      expect(subject.state.next_values).to match_array(['liquid'])
-      expect(subject.state.previous_values).to match_array([])
-      expect { subject.state = 'liquid' }.to change { subject.state }.from('solid').to('liquid')
-      expect(subject).to be_valid
-
-      expect(subject.state.may_become?('gas')).to eq true
-      expect(subject.state.next_values).to match_array(['gas'])
-      expect(subject.state.previous_values).to match_array(['solid'])
-      expect { subject.state = 'gas' }.to change { subject.state }.from('liquid').to('gas')
-      expect(subject).to be_valid
-
-      expect(subject.state.may_become?('plasma')).to eq true
-      expect(subject.state.next_values).to match_array(['plasma'])
-      expect(subject.state.previous_values).to match_array(['liquid'])
-      expect { subject.state = 'plasma' }.to change { subject.state }.from('gas').to('plasma')
-      expect(subject).to be_valid
-      expect(subject.state.next_values).to be_empty
-      expect(subject.state.previous_values).to match_array(['gas'])
-    end
-
-    it 'adds validation errors for invalid transitions' do
-      expect(subject.state.may_become?('gas')).to eq false
-      expect { subject.state = 'gas' }.to change { subject.state }.from('solid').to('gas')
-      expect(subject).not_to be_valid
-      expect(subject.errors[:state]).to match_array(['is invalid'])
-      expect(subject.state.next_values).to match_array(['liquid'])
-      expect(subject.state.previous_values).to match_array([])
-
-      expect(subject.state.may_become?('plasma')).to eq false
-      expect { subject.state = 'plasma' }.to change { subject.state }.from('gas').to('plasma')
-      expect(subject).not_to be_valid
-      expect(subject.errors[:state]).to match_array(['is invalid'])
-      expect(subject.state.next_values).to match_array(['liquid'])
-      expect(subject.state.previous_values).to match_array([])
-
-      expect(subject.state.may_become?('solid')).to eq false
-      expect { subject.state = 'solid' }.to change { subject.state }.from('plasma').to('solid')
-      expect(subject).not_to be_valid
-      expect(subject.errors[:state]).to match_array(['is invalid'])
-      expect(subject.state.next_values).to match_array(['liquid'])
-      expect(subject.state.previous_values).to match_array([])
-    end
-  end
-
-  context 'with a single field and nothing fancy' do
-    before do
-      steady_state_class.module_eval do
-        attr_accessor :state
-
-        steady_state :state do
-          state 'solid', default: true
-          state 'liquid', from: 'solid'
-          state 'gas', from: 'liquid'
-          state 'plasma', from: 'gas'
-        end
-      end
-    end
-
-    it_behaves_like 'a basic state machine'
-
-    context 'with inheritance' do
-      let(:subclass) do
-        Class.new(steady_state_class) do
-          def initialize
-            # I do my own thing.
-          end
-        end
-      end
-      subject { subclass.new }
-
-      it_behaves_like 'a basic state machine'
-    end
-
-    context 'with an existing state value' do
-      before do
-        steady_state_class.module_eval do
-          def state
-            @state ||= 'liquid'
-          end
-        end
-      end
-
-      it 'starts on existing state' do
-        expect(subject.state).to eq 'liquid'
-      end
-
-      it 'does not allow initialization to an invalid next state' do
-        object = steady_state_class.new(state: 'solid')
-        expect(object).not_to be_valid
-        expect(object.errors[:state]).to match_array(['is invalid'])
-      end
-
-      it 'allows initialization to a valid next state' do
-        expect(steady_state_class.new(state: 'gas')).to be_valid
-      end
-
-      it 'adds validation errors when initializing to an invalid state' do
-        object = steady_state_class.new(state: 'banana')
-        expect(object).not_to be_valid
-        expect(object.errors[:state]).to match_array(['is invalid', 'is not included in the list'])
-      end
-
-      it 'allows valid transitions' do
-        expect(subject).to be_valid
-        expect(subject.state.may_become?('gas')).to eq true
-        expect(subject.state.next_values).to match_array(['gas'])
-        expect(subject.state.previous_values).to match_array(['solid'])
-        expect { subject.state = 'gas' }.to change { subject.state }.from('liquid').to('gas')
-        expect(subject).to be_valid
-
-        expect(subject.state.may_become?('plasma')).to eq true
-        expect(subject.state.next_values).to match_array(['plasma'])
-        expect(subject.state.previous_values).to match_array(['liquid'])
-        expect { subject.state = 'plasma' }.to change { subject.state }.from('gas').to('plasma')
-        expect(subject).to be_valid
-        expect(subject.state.next_values).to be_empty
-        expect(subject.state.previous_values).to match_array(['gas'])
-      end
-
-      it 'adds validation errors for invalid transitions' do
-        expect(subject.state.may_become?('plasma')).to eq false
-        expect { subject.state = 'plasma' }.to change { subject.state }.from('liquid').to('plasma')
-        expect(subject).not_to be_valid
-        expect(subject.errors[:state]).to match_array(['is invalid'])
-        expect(subject.state.next_values).to match_array(['gas'])
-        expect(subject.state.previous_values).to match_array(['solid'])
-
-        expect(subject.state.may_become?('solid')).to eq false
-        expect { subject.state = 'solid' }.to change { subject.state }.from('plasma').to('solid')
-        expect(subject).not_to be_valid
-        expect(subject.errors[:state]).to match_array(['is invalid'])
-        expect(subject.state.next_values).to match_array(['gas'])
-        expect(subject.state.previous_values).to match_array(['solid'])
-      end
-    end
-  end
-
-  context 'with a field reachable by multiple states' do
-    before do
-      steady_state_class.module_eval do
-        attr_accessor :step
-
-        steady_state :step do
-          state 'step-1', default: true
-          state 'step-2', from: 'step-1'
-          state 'cancelled', from: %w(step-1 step-2)
-        end
-      end
-    end
-
-    it 'allows transition from first state' do
-      expect(subject.step.may_become?('step-1')).to eq false
-      expect(subject.step.may_become?('step-2')).to eq true
-      expect(subject.step.may_become?('cancelled')).to eq true
-      expect(subject.step.next_values).to match_array(%w(cancelled step-2))
-      expect(subject.step.previous_values).to match_array([])
-      expect { subject.step = 'cancelled' }.to change { subject.step }.from('step-1').to('cancelled')
-      expect(subject.step.next_values).to match_array([])
-      expect(subject.step.previous_values).to match_array(%w(step-1 step-2))
-      expect(subject).to be_valid
-    end
-
-    it 'allows transition from second state' do
-      expect(subject.step.may_become?('step-1')).to eq false
-      expect(subject.step.may_become?('step-2')).to eq true
-      expect(subject.step.may_become?('cancelled')).to eq true
-      expect(subject.step.next_values).to match_array(%w(cancelled step-2))
-      expect(subject.step.previous_values).to match_array([])
-      expect { subject.step = 'step-2' }.to change { subject.step }.from('step-1').to('step-2')
-      expect(subject).to be_valid
-
-      expect(subject.step.may_become?('step-1')).to eq false
-      expect(subject.step.may_become?('step-2')).to eq false
-      expect(subject.step.may_become?('cancelled')).to eq true
-      expect(subject.step.next_values).to match_array(['cancelled'])
-      expect(subject.step.previous_values).to match_array(['step-1'])
-      expect { subject.step = 'cancelled' }.to change { subject.step }.from('step-2').to('cancelled')
-      expect(subject.step.next_values).to match_array([])
-      expect(subject.step.previous_values).to match_array(%w(step-1 step-2))
-      expect(subject).to be_valid
-    end
-  end
-
-  context 'with the predicates option' do
-    before do
-      options = opts
-      steady_state_class.module_eval do
-        attr_accessor :door
-
-        steady_state :door, **options do
-          state 'open', default: true
-          state 'closed', from: 'open'
-          state 'locked', from: 'closed'
-        end
-      end
-    end
-
-    context 'default' do
-      let(:opts) { {} }
-
-      it 'defines a predicate method for each state' do
-        expect(subject).to respond_to(:open?)
-        expect(subject).to respond_to(:closed?)
-        expect(subject).to respond_to(:locked?)
-
-        expect(subject.open?).to eq true
-        expect(subject.closed?).to eq false
-        expect(subject.locked?).to eq false
-
-        subject.door = 'closed'
-        expect(subject.open?).to eq false
-        expect(subject.closed?).to eq true
-        expect(subject.locked?).to eq false
-
-        subject.door = 'locked'
-        expect(subject.open?).to eq false
-        expect(subject.closed?).to eq false
-        expect(subject.locked?).to eq true
-      end
-    end
-
-    context 'enabled' do
-      let(:opts) { { predicates: true } }
-
-      it 'defines a predicate method for each state' do
-        expect(subject).to respond_to(:open?)
-        expect(subject).to respond_to(:closed?)
-        expect(subject).to respond_to(:locked?)
-
-        expect(subject.open?).to eq true
-        expect(subject.closed?).to eq false
-        expect(subject.locked?).to eq false
-
-        subject.door = 'closed'
-        expect(subject.open?).to eq false
-        expect(subject.closed?).to eq true
-        expect(subject.locked?).to eq false
-
-        subject.door = 'locked'
-        expect(subject.open?).to eq false
-        expect(subject.closed?).to eq false
-        expect(subject.locked?).to eq true
-      end
-    end
-
-    context 'disabled' do
-      let(:opts) { { predicates: false } }
-
-      it 'does not define predicate methods' do
-        expect(subject).not_to respond_to(:open?)
-        expect(subject).not_to respond_to(:closed?)
-        expect(subject).not_to respond_to(:locked?)
-      end
-    end
-  end
-
-  context 'with the states_getter option' do
-    let(:query_object) { double(where: []) } # rubocop:disable RSpec/VerifiedDoubles
-
-    before do
-      options = opts
-      steady_state_class.module_eval do
-        attr_accessor :car
-
-        steady_state :car, **options do
-          state 'driving', default: true
-          state 'stopped', from: 'driving'
-          state 'parked', from: 'stopped'
-        end
-      end
-    end
-
-    context 'default' do
-      let(:opts) { {} }
-
-      it 'defines states getter method' do
-        expect(steady_state_class.cars).to eq %w(driving stopped parked)
-      end
-    end
-
-    context 'disabled' do
-      let(:opts) { { states_getter: false } }
-
-      it 'does not define states getter method' do
-        expect { steady_state_class.cars }.to raise_error(NoMethodError, /undefined method `cars'/)
-      end
-    end
-  end
-
-  context 'with the scopes option' do
-    let(:query_object) { double(where: []) } # rubocop:disable RSpec/VerifiedDoubles
-
-    before do
-      options = opts
-      steady_state_class.module_eval do
-        attr_accessor :car
-
-        def self.defined_scopes
-          @defined_scopes ||= {}
-        end
-
-        def self.scope(name, callable)
-          defined_scopes[name] ||= callable
-        end
-
-        steady_state :car, **options do
-          state 'driving', default: true
-          state 'stopped', from: 'driving'
-          state 'parked', from: 'stopped'
-        end
-      end
-    end
-
-    context 'default' do
-      let(:opts) { {} }
-
-      it 'does not define scope methods' do
-        expect(steady_state_class.defined_scopes.keys).to eq []
-      end
-
-      context 'on an ActiveRecord' do
-        let(:steady_state_class) do
-          stub_const('ActiveRecord::Base', Class.new)
-
-          Class.new(ActiveRecord::Base) do
-            include ActiveModel::Model
-            include SteadyState
-          end
-        end
-
-        it 'defines a scope for each state' do
-          expect(steady_state_class.defined_scopes.keys).to eq %i(driving stopped parked)
-
-          expect(query_object).to receive(:where).with(car: 'driving')
-          query_object.instance_exec(&steady_state_class.defined_scopes[:driving])
-          expect(query_object).to receive(:where).with(car: 'stopped')
-          query_object.instance_exec(&steady_state_class.defined_scopes[:stopped])
-          expect(query_object).to receive(:where).with(car: 'parked')
-          query_object.instance_exec(&steady_state_class.defined_scopes[:parked])
-        end
-      end
-    end
-
-    context 'enabled' do
-      let(:opts) { { scopes: true } }
-
-      it 'defines a scope for each state' do
-        expect(steady_state_class.defined_scopes.keys).to eq %i(driving stopped parked)
-
-        expect(query_object).to receive(:where).with(car: 'driving')
-        query_object.instance_exec(&steady_state_class.defined_scopes[:driving])
-        expect(query_object).to receive(:where).with(car: 'stopped')
-        query_object.instance_exec(&steady_state_class.defined_scopes[:stopped])
-        expect(query_object).to receive(:where).with(car: 'parked')
-        query_object.instance_exec(&steady_state_class.defined_scopes[:parked])
-      end
-    end
-
-    context 'disabled' do
-      let(:opts) { { scopes: false } }
-
-      it 'does not define scope methods' do
-        expect(steady_state_class.defined_scopes.keys).to eq []
-      end
-    end
-  end
-end