stator 0.8.0 → 0.9.0.beta

data/lib/stator/machine.rb

@@ -1,57 +1,65 @@
+# frozen_string_literal: true
+
 module Stator
   class Machine
+    attr_reader :initial_state, :field, :transitions, :states, :namespace,
+                :class_name, :name, :aliases, :options, :tracking_enabled, :klass
+
+    def self.find_or_create(klass, *kwargs)
+      kwargs = kwargs.first
+
+      klass._stators[kwargs[:namespace]] ||= new(klass, **kwargs)
+    end
+
+    def klass
+      @klass ||= class_name.constantize
+    end
 
-    attr_reader :initial_state
-    attr_reader :field
-    attr_reader :transition_names
-    attr_reader :transitions
-    attr_reader :states
-    attr_reader :namespace
+    def initialize(klass, *options)
+      options = options.first
 
-    def initialize(klass, options = {})
       @class_name       = klass.name
       @field            = options[:field] || :state
-      @namespace        = options[:namespace]
+      @namespace        = (options[:namespace] || Stator.default_namespace).to_sym
 
-      @initial_state    = options[:initial] && options[:initial].to_s
+      @initial_state    = options[:initial]&.to_sym
+      @states           = [initial_state].compact
       @tracking_enabled = options[:track] || false
 
       @transitions      = []
       @aliases          = []
 
-      # pushed out into their own variables for performance reasons (AR integration can use method missing - see the HelperMethods module)
-      @transition_names = []
-      @states           = [@initial_state].compact
-
-      @options       = options
+      @options = options
     end
 
-    def integration(record)
-      ::Stator::Integration.new(self, record)
+    alias tracking_enabled? tracking_enabled
+
+    def evaluate_dsl(&block)
+      instance_eval(&block)
+      evaluate
     end
 
-    def get_transition(name)
-      @transitions.detect{|t| t.name.to_s == name.to_s}
+    def integration(record)
+      Stator::Integration.new(self, record)
     end
 
     def transition(name, &block)
-      t = ::Stator::Transition.new(@class_name, name, @namespace)
-      t.instance_eval(&block) if block_given?
-
-      verify_transition_validity(t)
+      Stator::Transition.new(class_name, name, namespace).tap do |t|
+        t.instance_eval(&block) if block_given?
 
-      @transitions      << t
-      @transition_names |= [t.full_name]  unless t.full_name.blank?
-      @states           |= [t.to_state]   unless t.to_state.nil?
+        verify_transition_validity(t)
 
-      t
+        @transitions      << t
+        @states           |= [t.to_state] unless t.to_state.nil?
+      end
     end
 
     def state_alias(name, options = {}, &block)
-      a = ::Stator::Alias.new(self, name, options)
-      a.instance_eval(&block) if block_given?
-      @aliases << a
-      a
+      Stator::Alias.new(self, name, options).tap do |a|
+        # puts "ALIAS: #{a.inspect}"
+        a.instance_eval(&block) if block_given?
+        @aliases << a
+      end
     end
 
     def state(name, &block)
@@ -62,33 +70,31 @@ module Stator
       end
     end
 
-    def tracking_enabled?
-      @tracking_enabled
-    end
-
     def conditional(*states, &block)
-      _namespace = @namespace
+      state_check = proc { states.include?(current_state) }
 
-      klass.instance_exec(proc { states.map(&:to_s).include?(self._stator(_namespace).integration(self).state) }, &block)
+      klass.instance_exec(state_check, &block)
     end
 
     def matching_transition(from, to)
-      @transitions.detect do |transition|
-        transition.valid?(from, to)
-      end
+      transitions.detect { |transition| transition.valid?(from, to) }
     end
 
     def evaluate
-      @transitions.each(&:evaluate)
-      @aliases.each(&:evaluate)
+      transitions.each(&:evaluate)
+      aliases.each(&:evaluate)
       generate_methods
     end
 
-    def klass
-      @class_name.constantize
-    end
+    private
 
-    protected
+    def attr_name(name)
+      if namespace == Stator.default_namespace
+        name.to_sym
+      else
+        [namespace, name].compact.join('_').to_sym
+      end
+    end
 
     def verify_transition_validity(transition)
       verify_state_singularity_of_transition(transition)
@@ -98,34 +104,29 @@ module Stator
     def verify_state_singularity_of_transition(transition)
       transition.from_states.each do |from|
         if matching_transition(from, transition.to_state)
-          raise "[Stator] another transition already exists which moves #{@class_name} from #{from.inspect} to #{transition.to_state.inspect}"
+          raise "[Stator] another transition already exists which moves #{class_name} from #{from} to #{transition}"
         end
       end
     end
 
     def verify_name_singularity_of_transition(transition)
-      if @transitions.detect{|other| transition.name && transition.name == other.name }
-        raise "[Stator] another transition already exists with the name of #{transition.name.inspect} in the #{@class_name} class"
+      if transitions.detect { |other| transition.name && transition.name == other.name }
+        raise "[Stator] another transition already exists with the name of #{transition.name} in the #{class_name} class"
       end
     end
 
     def generate_methods
-      self.states.each do |state|
-        method_name = [@namespace, state].compact.join('_')
+      states.each do |state|
         klass.class_eval <<-EV, __FILE__, __LINE__ + 1
-          def #{method_name}?
-            integration = self._stator(#{@namespace.inspect}).integration(self)
-            integration.state == #{state.to_s.inspect}
+          def #{attr_name(state)}?
+            _stator_integration(:#{namespace}).state.to_sym == :#{state}
           end
 
-          def #{method_name}_state_by?(time)
-            integration = self._stator(#{@namespace.inspect}).integration(self)
-            integration.state_by?(#{state.to_s.inspect}, time)
+          def #{attr_name(state)}_state_by?(time)
+            _stator_integration(:#{namespace}).state_by?(:#{state}.to_sym, time)
           end
         EV
       end
     end
-
-
   end
 end

data/lib/stator/model.rb

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

data/lib/stator/transition.rb

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

data/lib/stator/version.rb

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

data/lib/stator.rb

@@ -1,6 +1,19 @@
+# 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