stator 0.9.0.beta → 0.9.0

data/lib/stator/model.rb

@@ -1,118 +1,113 @@
-# frozen_string_literal: true
-
 module Stator
   module Model
-    extend ActiveSupport::Concern
 
-    included do
-      class_attribute :_stators
-      attr_accessor :_stator_integrations
+    def stator(options = {}, &block)
+
+      class_attribute :_stators unless respond_to?(:_stators)
 
-      validate :_stator_validate_transition
+      include InstanceMethods   unless self.included_modules.include?(InstanceMethods)
+      include TrackerMethods    if options[:track] == true
 
       self._stators ||= {}
 
-      before_save :_stator_maybe_track_transition, prepend: true
+      unless self.abstract_class?
+        f = options[:field] || :state
+        # rescue nil since the table may not exist yet.
+        initial = self.columns_hash[f.to_s].default rescue nil
+        options = options.merge(initial: initial) if initial
+      end
+
+      machine = (self._stators[options[:namespace].to_s] ||= ::Stator::Machine.new(self, options))
+
+      if block_given?
+        machine.instance_eval(&block)
+        machine.evaluate
+      end
+
+      machine
     end
 
-    class_methods do
-      def stator(namespace: nil, field: :state, initial: nil, track: true, &block)
-        unless abstract_class?
-          # Discover the default value (usually initial) from the table...
-          # but rescue nil since the table may not exist yet.
-          initial = _determine_initial_stator_state(field)
-        end
+    def _stator(namespace)
+      self._stators[namespace.to_s]
+    end
 
-        opts = { namespace: _stator_namespace(namespace), field: field.to_sym, initial: initial, track: track }
+    module TrackerMethods
 
-        Stator::Machine.find_or_create(self, **opts).tap do |machine|
-          machine.evaluate_dsl(&block) if block_given?
+      def self.included(base)
+        base.class_eval do
+          before_save :_stator_maybe_track_transition, prepend: true
         end
       end
 
-      def _stator(namespace)
-        self._stators[_stator_namespace(namespace)]
+      def in_state_at?(state, t, namespace = '')
+        _integration(namespace).in_state_at?(state, t)
       end
 
-      def _stator_namespace(namespace = nil)
-        namespace = nil if namespace.blank?
-
-        (namespace || Stator.default_namespace).to_sym
+      def likely_state_at(t, namespace = '')
+        _integration(namespace).likely_state_at(t)
       end
 
-      def _determine_initial_stator_state(field)
-        columns_hash[field.to_s].default.to_sym
-      rescue StandardError
-        nil
+      def state_by?(state, t, namespace = '')
+        _integration(namespace).state_by?(state, t)
       end
-    end
 
-    def initialize_dup(other)
-      @_stator_integrations = {}
-      super
-    end
+      protected
 
-    def without_state_transition_validations(namespace = '')
-      _stator_integration(namespace).without_validation do
-        yield self
-      end
-    end
+      def _stator_maybe_track_transition
+        self._stators.each do |namespace, machine|
+          next unless machine.tracking_enabled?
 
-    def without_state_transition_tracking(namespace = '')
-      _stator_integration(namespace).without_transition_tracking do
-        yield self
-      end
-    end
-
-    def current_state
-      _stator_integration.state&.to_sym
-    end
+          _integration(namespace).track_transition
+        end
 
-    def in_state_at?(state, t, namespace = '')
-      _stator_integration(namespace).in_state_at?(state, t)
-    end
+        true
+      end
 
-    def likely_state_at(t, namespace = '')
-      _stator_integration(namespace).likely_state_at(t)
     end
 
-    def state_by?(state, t, namespace = '')
-      _stator_integration(namespace).state_by?(state, t)
-    end
+    module InstanceMethods
 
-    private
+      def self.included(base)
+        base.class_eval do
+          validate :_stator_validate_transition
+        end
+      end
 
-    # core methods
-    def _stator(namespace = nil)
-      self.class._stator(namespace)
-    end
+      def initialize_dup(other)
+        @_integrations = {}
+        super
+      end
 
-    def _stator_namespace(namespace = nil)
-      self.class._stator_namespace(namespace)
-    end
+      def without_state_transition_validations(namespace = '')
+        _integration(namespace).without_validation do
+          yield self
+        end
+      end
 
-    def _stator_integration(namespace = nil)
-      ns = _stator_namespace(namespace)
+      def without_state_transition_tracking(namespace = '')
+        _integration(namespace).without_transition_tracking do
+          yield self
+        end
+      end
 
-      self._stator_integrations ||= {}
-      self._stator_integrations[ns] ||= self.class._stator(ns).integration(self)
-    end
+      protected
 
-    # validation/transitional
-    def _stator_validate_transition
-      self._stators.each_key do |namespace|
-        _stator_integration(namespace).validate_transition
+      def _stator_validate_transition
+        self._stators.each_key do |namespace|
+          _integration(namespace).validate_transition
+        end
       end
-    end
 
-    def _stator_maybe_track_transition
-      self._stators.each do |namespace, machine|
-        next unless machine.tracking_enabled?
+      def _stator(namespace = '')
+        self.class._stator(namespace)
+      end
 
-        _stator_integration(namespace).track_transition
+      def _integration(namespace = '')
+        @_integrations ||= {}
+        @_integrations[namespace] ||= _stator(namespace).integration(self)
+        @_integrations[namespace]
       end
 
-      true
     end
   end
 end

data/lib/stator/transition.rb

@@ -1,39 +1,44 @@
-# frozen_string_literal: true
-
 module Stator
   class Transition
-    attr_reader :namespace, :name, :attr_name, :from_states, :to_state, :class_name, :callbacks
+
+    ANY = '__any__'
+
+    attr_reader :name
+    attr_reader :full_name
 
     def initialize(class_name, name, namespace = nil)
-      @class_name  = class_name
-      @name        = name&.to_sym
-      @namespace   = namespace&.to_sym
-      @from_states = []
-      @to_state    = nil
-      @callbacks   = {}
+      @class_name = class_name
+      @name       = name
+      @namespace  = namespace
+      @full_name  = [@namespace, @name].compact.join('_') if @name
+      @froms      = []
+      @to         = nil
+      @callbacks  = {}
     end
 
-    def attr_name
-      @attr_name ||= generate_attr_name
+    def from(*froms)
+      @froms |= froms.map{|f| f.try(:to_s) } # nils are ok
     end
 
-    def from_states(*new_froms)
-      @from_states |= new_froms
+    def to(to)
+      @to = to.to_s
     end
-    alias from from_states
 
-    def to(new_to)
-      @to_state = new_to
+    def to_state
+      @to
     end
 
-    def can?(current_state)
-      from_states.include?(current_state) || from_states.include?(Stator::ANY) || current_state == Stator::ANY
+    def from_states
+      @froms
     end
 
-    def valid?(from_check, to_check)
-      from_check = from_check&.to_sym # coming from the database, i suspect
+    def can?(current_state)
+      @froms.include?(current_state) || @froms.include?(ANY) || current_state == ANY
+    end
 
-      can?(from_check) && (to_check == to_state || to_check == ANY || to_state == ANY)
+    def valid?(from, to)
+      can?(from) &&
+      (@to == to || @to == ANY || to == ANY)
     end
 
     def conditional(options = {}, &block)
@@ -41,85 +46,79 @@ module Stator
     end
 
     def any
-      Stator::ANY
+      ANY
     end
 
     def evaluate
-      generate_methods if attr_name.present?
+      generate_methods unless @full_name.blank?
     end
 
-    private
+    protected
 
     def klass
-      class_name.constantize
-    end
-
-    def generate_attr_name
-      if namespace == Stator.default_namespace
-        name
-      else
-        [namespace, name].compact.join('_').to_sym
-      end
+      @class_name.constantize
     end
 
     def callbacks(kind)
-      callbacks[kind] || []
+      @callbacks[kind] || []
     end
 
     def conditional_block(options = {})
       options[:use_previous] ||= false
 
-      _namespace = namespace
-      _froms     = from_states
-      _to        = to_state
-
-      proc do
-        integration = self.class._stator(_namespace).integration(self)
-
-        integration.state_changed?(options[:use_previous]) &&
-          _froms.include?(integration.state_was(options[:use_previous])) ||
-          _froms.include?(Stator::ANY) &&
-            integration.state == _to || _to == Stator::ANY
+      _namespace = @namespace
+      _froms     = @froms
+      _to        = @to
+
+      Proc.new do
+        (
+          self._stator(_namespace).integration(self).state_changed?(options[:use_previous])
+        ) && (
+          _froms.include?(self._stator(_namespace).integration(self).state_was(options[:use_previous])) ||
+          _froms.include?(::Stator::Transition::ANY)
+        ) && (
+          self._stator(_namespace).integration(self).state == _to ||
+          _to == ::Stator::Transition::ANY
+        )
       end
     end
 
     def generate_methods
       klass.class_eval <<-EV, __FILE__, __LINE__ + 1
-        def #{attr_name}(should_save = true)
-          integration = _stator_integration(:#{namespace})
+        def #{@full_name}(should_save = true)
+          integration = _integration(#{@namespace.to_s.inspect})
 
-          unless can_#{attr_name}?
-            integration.invalid_transition!(integration.state, :#{to_state}) if should_save
+          unless can_#{@full_name}?
+            integration.invalid_transition!(integration.state, #{@to.inspect}) if should_save
             return false
           end
 
-          integration.state = :#{to_state}
-
+          integration.state = #{@to.inspect}
           self.save if should_save
         end
 
-        def #{attr_name}!
-          integration = _stator_integration(:#{namespace})
+        def #{@full_name}!
+          integration = _integration(#{@namespace.to_s.inspect})
 
-          unless can_#{attr_name}?
-            integration.invalid_transition!(integration.state, :#{to_state})
+          unless can_#{@full_name}?
+            integration.invalid_transition!(integration.state, #{@to.inspect})
             raise ActiveRecord::RecordInvalid.new(self)
           end
 
-          integration.state = :#{to_state}
+          integration.state = #{@to.inspect}
           self.save!
         end
 
-        def can_#{attr_name}?
-          integration = _stator_integration(:#{namespace})
+        def can_#{@full_name}?
+          integration = _integration(#{@namespace.to_s.inspect})
           return true if integration.skip_validations
 
-          machine     = self._stator(:#{namespace})
-          transition  = machine.transitions.detect { |t| t.attr_name == :#{attr_name} }
-
+          machine     = self._stator(#{@namespace.to_s.inspect})
+          transition  = machine.transitions.detect{|t| t.full_name.to_s == #{@full_name.inspect}.to_s }
           transition.can?(integration.state)
         end
       EV
     end
+
   end
 end

data/lib/stator/version.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
 module Stator
+
   MAJOR       = 0
   MINOR       = 9
   PATCH       = 0
-  PRERELEASE  = "beta"
+  PRERELEASE  = nil
+
+  VERSION = [MAJOR, MINOR, PATCH, PRERELEASE].compact.join(".")
 
-  VERSION = [MAJOR, MINOR, PATCH, PRERELEASE].compact.join('.')
 end

data/lib/stator.rb

@@ -1,19 +1,6 @@
-# frozen_string_literal: true
-
 require 'stator/version'
 require 'stator/alias'
 require 'stator/integration'
 require 'stator/machine'
 require 'stator/model'
 require 'stator/transition'
-
-require 'active_support/concern'
-require 'debug'
-
-module Stator
-  ANY = :__ANY__
-
-  def self.default_namespace
-    ENV.fetch('STATOR_NAMESPACE', :default).to_sym
-  end
-end

data/stator.gemspec

@@ -10,13 +10,24 @@ Gem::Specification.new do |gem|
   gem.email         = ["mike@mikeonrails.com"]
   gem.description   = %q{The simplest of ActiveRecord state machines. Intended to be lightweight and minimalistic.}
   gem.summary       = %q{The simplest of ActiveRecord state machines}
-  gem.homepage      = "https://www.github.com/mnelson/stator"
+  gem.homepage      = "https://github.com/guideline-tech/stator"
+  gem.license       = "MIT"
+
+  # Specify which files should be added to the gem when it is released.
+  gem.files = Dir["lib/**/*"] + Dir["*.gemspec"]
 
-  gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_dependency 'activerecord'
-  gem.add_dependency 'activesupport'
+  gem.metadata["allowed_push_host"] = "https://rubygems.org"
+  gem.metadata["rubygems_mfa_required"] = "true"
+
+  gem.add_dependency 'base64'
+  gem.add_dependency 'benchmark'
+  gem.add_dependency 'bigdecimal'
+  gem.add_dependency 'logger'
+  gem.add_dependency 'mutex_m'
+  gem.add_dependency 'activerecord', ">= 6.0"
+
+  gem.required_ruby_version = ">= 3.2.0"
 end

metadata

@@ -1,17 +1,30 @@
 --- !ruby/object:Gem::Specification
 name: stator
 version: !ruby/object:Gem::Version
-  version: 0.9.0.beta
+  version: 0.9.0
 platform: ruby
 authors:
 - Mike Nelson
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-07-26 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: activerecord
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: benchmark
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -25,7 +38,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: bigdecimal
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -38,6 +51,48 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mutex_m
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
 description: The simplest of ActiveRecord state machines. Intended to be lightweight
   and minimalistic.
 email:
@@ -46,28 +101,6 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".github/workflows/build.yml"
-- ".gitignore"
-- ".rspec"
-- ".ruby-gemset"
-- ".ruby-version"
-- Appraisals
-- Gemfile
-- LICENSE.txt
-- README.md
-- Rakefile
-- gemfiles/activerecord_5.1.gemfile
-- gemfiles/activerecord_5.1.gemfile.lock
-- gemfiles/activerecord_5.2.gemfile
-- gemfiles/activerecord_5.2.gemfile.lock
-- gemfiles/activerecord_5.gemfile
-- gemfiles/activerecord_5.gemfile.lock
-- gemfiles/activerecord_6.0.gemfile
-- gemfiles/activerecord_6.0.gemfile.lock
-- gemfiles/activerecord_6.1.gemfile
-- gemfiles/activerecord_6.1.gemfile.lock
-- gemfiles/activerecord_7.0.gemfile
-- gemfiles/activerecord_7.0.gemfile.lock
 - lib/stator.rb
 - lib/stator/alias.rb
 - lib/stator/integration.rb
@@ -75,15 +108,13 @@ files:
 - lib/stator/model.rb
 - lib/stator/transition.rb
 - lib/stator/version.rb
-- spec/model_spec.rb
-- spec/spec_helper.rb
-- spec/support/models.rb
-- spec/support/schema.rb
 - stator.gemspec
-homepage: https://www.github.com/mnelson/stator
-licenses: []
-metadata: {}
-post_install_message: 
+homepage: https://github.com/guideline-tech/stator
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -91,19 +122,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubygems_version: 3.1.6
-signing_key: 
+rubygems_version: 3.6.8
 specification_version: 4
 summary: The simplest of ActiveRecord state machines
-test_files:
-- spec/model_spec.rb
-- spec/spec_helper.rb
-- spec/support/models.rb
-- spec/support/schema.rb
+test_files: []

data/.github/workflows/build.yml

@@ -1,28 +0,0 @@
-name: build
-on:
-  pull_request:
-  push:
-      branches:
-        - master
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    continue-on-error: ${{ matrix.experimental }}
-    strategy:
-      fail-fast: false
-      matrix:
-        ruby-version: [2.7.5, 2.7.6]
-        experimental: [false]
-        include:
-          - ruby-version: 3.0
-            experimental: true
-          - ruby-version: 3.1
-            experimental: true
-    steps:
-      - uses: actions/checkout@v2
-      - uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: ${{ matrix.ruby-version }}
-          bundler-cache: true # runs `bundle install` and caches installed gems automatically
-      - run: bundle exec appraisal install
-      - run: bundle exec appraisal rspec

data/.gitignore

@@ -1,18 +0,0 @@
-*.gem
-*.rbc
-.bundle
-.config
-.yardoc
-Gemfile.lock
-InstalledFiles
-_yardoc
-coverage
-doc/
-lib/bundler/man
-pkg
-rdoc
-spec/reports
-test/tmp
-test/version_tmp
-tmp
-.envrc

data/.rspec

@@ -1,2 +0,0 @@
---color
---format documentation

data/.ruby-gemset

@@ -1 +0,0 @@
-stator

data/.ruby-version

@@ -1 +0,0 @@
-2.7.5