steady_state 0.1.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c80b6cce9dbf7702cdf8fd0d97c21794bcbc6a67c2ea688fcf5b150ee217df5a
-  data.tar.gz: 67bc8bc9e117e55ac21b4dcba713dbf97627354c1997e906fbb317ef06b42ac6
+  metadata.gz: 02e5f7eb48f3ada429e0d38598535c77489ab57172d920c2dbb6083a19dc5466
+  data.tar.gz: bbc957eeed78c83b1a7e2c49395df741ba34eea99d3d4adaabdbbabe1298bb06
 SHA512:
-  metadata.gz: 374352c07075b3ccb50c1c018e6b8e654ebcc84675d44e4024406dde923ba28699f58daf7b67f8161cff8ee41d9e4f75c77f59680f165b62e527787b7dd00e65
-  data.tar.gz: 6d493623807a7332a1e3b96a9849d46b6a33d59e8405dbb935ef66de4d9b054b2c471ca8421feb7f75810a2aa6694b0173a64be694a69a31a6210de2232018b0
+  metadata.gz: a2f28a60fae258f08f3bb57925419c86015d4dc5d738667fffe8e943223fe3603a0a90960653ff2b1d171dac4f077e50b113b4f5b5024da5cb5c8f58a950a096
+  data.tar.gz: 3fd2023e60bb8ff68c5ea40dcc4a263184fe0698ff3d3507dd7b02ecacf8417bcb9e9b0f44c1d789513994ac5010211b1c50716cdedc7f4eb39f21213a481f5f

data/README.md

@@ -231,6 +231,33 @@ As it stands, state history is not preserved, but it is still possible to get a
 material.state.previous_values # => ['solid']
 ```
 
+### The "States Getter"
+
+A pluralized, class-level helper method can be used to access all possible state values:
+
+```ruby
+Material.states # => ['solid', 'liquid', 'gas']
+```
+
+These values respond to reflection methods like `may_become?`, `next_values`, and `previous_values`.
+
+```
+Material.states.first.solid? # => true
+Material.states[1].may_become?('solid') # => false
+Material.states[1].next_values # => ['gas']
+```
+
+The automatic definition of this class method can be disabled by passing `states_getter: false`:
+
+```ruby
+steady_state :step, states_getter: false do
+  # ...
+end
+
+MyClass.steps # => NoMethodError
+```
+
+
 ### ActiveModel Support
 
 SteadyState is also available to classes that are not database-backed, as long as they include the `ActiveModel::Model` mixin:

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 begin
   require 'bundler/setup'
 rescue LoadError
@@ -13,4 +15,14 @@ require 'rspec/core'
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec)
 
-task default: %i(rubocop spec)
+def default_task
+  if ENV['APPRAISAL_INITIALIZED'] || ENV['CI']
+    %i(rubocop spec)
+  else
+    require 'appraisal'
+    Appraisal::Task.new
+    %i(appraisal)
+  end
+end
+
+task(:default).clear.enhance(default_task)

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'
@@ -13,30 +15,30 @@ module SteadyState
     end
 
     class_methods do
-      def steady_state(attr_name, predicates: true, states_getter: true, scopes: SteadyState.active_record?(self), &block) # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity, Metrics/LineLength
+      def steady_state(attr_name, predicates: true, states_getter: true, scopes: SteadyState.active_record?(self), &block) # rubocop:disable Metrics/
         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

data/lib/steady_state/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SteadyState
-  VERSION = '0.1.0'.freeze
+  VERSION = '1.1.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: 0.1.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Nathan Griffith
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-10 00:00:00.000000000 Z
+date: 2024-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -16,30 +16,30 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '5.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '5.2'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '5.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '5.2'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: appraisal
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -53,7 +53,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: betterlint
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -67,7 +81,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rubocop-betterment
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -99,12 +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: {}
-post_install_message: 
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -112,17 +125,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
-signing_key: 
+rubygems_version: 3.5.1
+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(['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(['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(['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(['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