stator 0.9.0.beta → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11dfad97bef44bb60c060b086dce2f327f2fca47d309510337533f31f62e105f
-  data.tar.gz: 578888569b569b4e35c7c180ed3ddfe96ea4547f296394c2c81fbc44bee72105
+  metadata.gz: 69cde7f0870cc5691869d9e3dbc94c886a74472ec0c858ded58d7f4fde0b5ac1
+  data.tar.gz: 9d72a8142353d239883d4c0d244ca1ef9d46e9dde2bf602e19a7c28e53951e3a
 SHA512:
-  metadata.gz: 959635a8a2eebce12473a7f79844e25de1038fe3a1e692fa97e5d1edc430778a3148a4a7b6ca2e488f248c318a19d74fb69c489c28928ff44731c0e3e8319823
-  data.tar.gz: a13fa8a216bc2fd590d1abea7be2eab258a5e29b58c0017314a083938b5c6f6f0acebf3179b5c4cf7b122dbc2a62ba1342bdc0937fed82365ad2b23d49ce3201
+  metadata.gz: 29bcc2f18487e5d081e8270646b6a5b612f04aae32c7d0341dda09bf1d90440e6f0788215553ea0d3f86528d8a5593df61d9cb62790fe586af49202bc34db7f1
+  data.tar.gz: 354327de6f695f02c8dffd2b9ed1a6a717c49cb88628a1b1edd7120e152348c6c2aa39f010018d05cb9f0638b3917afd811c3dce49a840996d1881a003ec985f

data/lib/stator/alias.rb

@@ -1,13 +1,11 @@
-# frozen_string_literal: true
-
 module Stator
   class Alias
-    attr_reader :machine, :name, :namespace, :attr_name, :states, :not, :opposite_args, :constant, :scope
 
     def initialize(machine, name, options = {})
       @machine    = machine
       @name       = name
-      @namespace  = machine.namespace
+      @namespace  = @machine.namespace
+      @full_name  = [@namespace, @name].compact.join('_')
       @states     = []
       @not        = false
       @opposite   = nil
@@ -15,12 +13,8 @@ module Stator
       @scope      = options[:scope]
     end
 
-    def attr_name
-      @attr_name ||= generate_attr_name
-    end
-
     def is(*args)
-      @states |= args.map(&:to_sym)
+      @states |= args.map(&:to_s)
     end
 
     def is_not(*args)
@@ -28,75 +22,60 @@ module Stator
       is(*args)
     end
 
-    alias not? not
-
     def opposite(*args)
-      # set the incoming args for opposite as opposite
-      @opposite_args = args
+      @opposite = args
     end
 
     def evaluate
       generate_methods
 
-      return if opposite_args.blank?
+      if @opposite
+        op = @machine.state_alias(*@opposite)
 
-      # this will generate the alias for the opposite
-      op = machine.state_alias(*opposite_args)
-
-      op.is(*states)     if not?
-      op.is_not(*states) unless not?
+        op.is(*@states)     if @not
+        op.is_not(*@states) if !@not
+      end
     end
 
-    private
-
-    def inverse_states
-      (machine.states - states).map(&:to_sym)
-    end
+    protected
 
     def inferred_constant_name
-      [attr_name.upcase, machine.field.to_s.pluralize.upcase].join('_')
-    end
-
-    def generate_attr_name
-      if namespace == Stator.default_namespace
-        name
-      else
-        [namespace, name].compact.join('_').to_sym
-      end
+      [@full_name.upcase, @machine.field.to_s.pluralize.upcase].join('_')
     end
 
     def generate_methods
-      expected_states = (not? ? inverse_states : states)
 
-      if scope
-        name = (scope == true ? attr_name : scope)
+      not_states = (@machine.states - @states)
 
-        machine.klass.class_eval <<-EV, __FILE__, __LINE__ + 1
-          scope :#{name}, -> { where(_stator(#{namespace.inspect}).field => #{expected_states}) }
+      if @scope
+        name = @scope == true ? @full_name : @scope
+        @machine.klass.class_eval <<-EV, __FILE__, __LINE__ + 1
+          scope #{name.inspect}, lambda {
+            where(_stator(#{@namespace.inspect}).field => #{(@not ? not_states : @states).inspect})
+          }
         EV
       end
 
-      if constant
-        name = (constant == true ? inferred_constant_name : constant.to_s.upcase)
-
-        if not?
-          machine.klass.class_eval <<-EV, __FILE__, __LINE__ + 1
-            #{name} = #{inverse_states}.freeze
+      if @constant
+        name = @constant == true ? inferred_constant_name : @constant.to_s.upcase
+        if @not
+          @machine.klass.class_eval <<-EV, __FILE__, __LINE__ + 1
+            #{name} = #{not_states.inspect}.freeze
           EV
         else
-          machine.klass.class_eval <<-EV, __FILE__, __LINE__ + 1
-            #{name} = #{states}.freeze
+          @machine.klass.class_eval <<-EV, __FILE__, __LINE__ + 1
+            #{name} = #{@states.inspect}.freeze
           EV
         end
       end
 
-      machine.klass.class_eval <<-EV, __FILE__, __LINE__ + 1
-        def #{attr_name}?
-          integration = _stator_integration(:#{namespace})
-
-          #{expected_states}.include?(integration.state.to_sym)
+      @machine.klass.class_eval <<-EV, __FILE__, __LINE__ + 1
+        def #{@full_name}?
+          integration = _stator(#{@namespace.inspect}).integration(self)
+          #{(@not ? not_states : @states).inspect}.include?(integration.state)
         end
       EV
     end
+
   end
 end

data/lib/stator/integration.rb

@@ -2,48 +2,48 @@
 
 module Stator
   class Integration
-    delegate :states,       to: :machine
-    delegate :transitions,  to: :machine
-    delegate :namespace,    to: :machine
 
-    attr_reader :skip_validations, :skip_transition_tracking, :record, :machine
+    delegate :states,       to: :@machine
+    delegate :transitions,  to: :@machine
+    delegate :namespace,    to: :@machine
+
+    attr_reader :skip_validations
+    attr_reader :skip_transition_tracking
 
     def initialize(machine, record)
       @machine = machine
       @record  = record
-      @skip_transition_tracking = false
     end
 
     def state=(new_value)
-      record.send("#{machine.field}=", new_value)
+      @record.send("#{@machine.field}=", new_value)
     end
 
     def state
-      record.send(machine.field)&.to_sym
+      @record.send(@machine.field)
     end
 
     def state_was(use_previous = false)
       if use_previous
-        record.previous_changes[machine.field].try(:[], 0).to_sym
+        @record.attribute_before_last_save(@machine.field)
       else
-        record.send("#{@machine.field}_was")
+        @record.attribute_in_database(@machine.field)
       end
     end
 
     def state_by?(state, time)
-      field_name = "#{state}_#{machine.field}_at"
-      return false unless record.respond_to?(field_name)
-      return false if record.send(field_name).nil?
+      field_name = "#{state}_#{@machine.field}_at"
+      return false unless @record.respond_to?(field_name)
+      return false if @record.send(field_name).nil?
       return true if time.nil?
-
-      record.send(field_name) <= time
+      @record.send(field_name) <= time
     end
 
     def state_changed?(use_previous = false)
       if use_previous
-        !!record.previous_changes[machine.field.to_s]
+        @record.saved_change_to_attribute?(@machine.field)
       else
-        record.send("#{machine.field}_changed?")
+        @record.will_save_change_to_attribute?(@machine.field)
       end
     end
 
@@ -51,20 +51,23 @@ module Stator
       return unless state_changed?
       return if skip_validations
 
-      if record.new_record?
-        invalid_state! unless machine.matching_transition(Stator::ANY, state)
+      was = state_was
+      is  = state
+
+      if @record.new_record?
+        invalid_state! unless @machine.matching_transition(::Stator::Transition::ANY, is)
       else
-        invalid_transition!(state_was, state) unless machine.matching_transition(state_was, state)
+        invalid_transition!(was, is) unless @machine.matching_transition(was, is)
       end
     end
 
     # TODO: i18n
     def invalid_state!
-      record.errors.add(machine.field, 'is not a valid state')
+      @record.errors.add(@machine.field, "is not a valid state")
     end
 
     def invalid_transition!(was, is)
-      record.errors.add(machine.field, "cannot transition to #{is} from #{was}")
+      @record.errors.add(@machine.field, "cannot transition to #{is.inspect} from #{was.inspect}")
     end
 
     def track_transition
@@ -80,7 +83,7 @@ module Stator
       state = state.to_s
       t = t.to_time
 
-      state_at = record.send("#{state}_#{machine.field}_at")
+      state_at = @record.send("#{state}_#{@machine.field}_at")
 
       # if we've never been in the state, the answer is no
       return false if state_at.nil?
@@ -88,18 +91,20 @@ module Stator
       # if we came into this state later in life, the answer is no
       return false if state_at > t
 
-      all_states = machine.states.reverse
+      all_states = @machine.states.reverse
 
       # grab all the states and their timestamps that occur on or after state_at and on or before the time in question
-      later_states = all_states.filter_map do |s|
+      later_states = all_states.map do |s|
         next if state == s
 
-        at = record.send("#{s}_#{machine.field}_at")
+        at = @record.send("#{s}_#{@machine.field}_at")
 
-        next if at.nil? || at < state_at || at > t
+        next if at.nil?
+        next if at < state_at
+        next if at > t
 
         { state: s, at: at }
-      end
+      end.compact
 
       # if there were no states on or after the state_at, the answer is yes
       return true if later_states.empty?
@@ -110,51 +115,53 @@ module Stator
       later_states = later_groups[later_group_key]
 
       # if the lowest timestamp is the same as the state's timestamp, evaluate based on state index
-      return all_states.index(state) < all_states.index(later_states[0][:state]) if later_states[0][:at] == state_at
+      if later_states[0][:at] == state_at
+        return all_states.index(state) < all_states.index(later_states[0][:state])
+      end
 
       false
     end
 
     def likely_state_at(t)
-      machine.states.reverse.detect { |s| in_state_at?(s, t) }
+      @machine.states.reverse.detect { |s| in_state_at?(s, t) }
     end
 
     def without_validation
-      was = skip_validations
+      was = @skip_validations
       @skip_validations = true
-      yield record
+      yield @record
     ensure
       @skip_validations = was
     end
 
     def without_transition_tracking
-      was = skip_transition_tracking
+      was = @skip_transition_tracking
       @skip_transition_tracking = true
-      yield record
+      yield @record
     ensure
       @skip_transition_tracking = was
     end
 
-    private
+    protected
 
     def attempt_to_track_state(state_to_track)
       return unless state_to_track
 
-      _attempt_to_track_change("#{state_to_track}_#{machine.field}_at")
+      _attempt_to_track_change("#{state_to_track}_#{@machine.field}_at")
     end
 
     def attempt_to_track_state_changed_timestamp
-      _attempt_to_track_change("#{machine.field}_changed_at")
+      _attempt_to_track_change("#{@machine.field}_changed_at")
     end
 
     def _attempt_to_track_change(field_name)
-      return unless record.respond_to?(field_name)
-      return unless record.respond_to?("#{field_name}=")
-      return unless record.send(field_name.to_s).nil? || state_changed?
-
-      return if record.send("#{field_name}_changed?")
+      return unless @record.respond_to?(field_name)
+      return unless @record.respond_to?("#{field_name}=")
+      return unless @record.send(field_name.to_s).nil? || state_changed?
+      return if @record.will_save_change_to_attribute?(field_name) && !@record.send(field_name.to_s).nil?
 
-      record.send("#{field_name}=", (Time.zone || Time).now)
+      @record.send("#{field_name}=", (Time.zone || Time).now)
     end
+
   end
 end

data/lib/stator/machine.rb

@@ -1,65 +1,57 @@
-# 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
 
-    def initialize(klass, *options)
-      options = options.first
+    attr_reader :initial_state
+    attr_reader :field
+    attr_reader :transition_names
+    attr_reader :transitions
+    attr_reader :states
+    attr_reader :namespace
 
+    def initialize(klass, options = {})
       @class_name       = klass.name
       @field            = options[:field] || :state
-      @namespace        = (options[:namespace] || Stator.default_namespace).to_sym
+      @namespace        = options[:namespace]
 
-      @initial_state    = options[:initial]&.to_sym
-      @states           = [initial_state].compact
+      @initial_state    = options[:initial] && options[:initial].to_s
       @tracking_enabled = options[:track] || false
 
       @transitions      = []
       @aliases          = []
 
-      @options = options
-    end
-
-    alias tracking_enabled? tracking_enabled
+      # 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
 
-    def evaluate_dsl(&block)
-      instance_eval(&block)
-      evaluate
+      @options       = options
     end
 
     def integration(record)
-      Stator::Integration.new(self, record)
+      ::Stator::Integration.new(self, record)
+    end
+
+    def get_transition(name)
+      @transitions.detect{|t| t.name.to_s == name.to_s}
     end
 
     def transition(name, &block)
-      Stator::Transition.new(class_name, name, namespace).tap do |t|
-        t.instance_eval(&block) if block_given?
+      t = ::Stator::Transition.new(@class_name, name, @namespace)
+      t.instance_eval(&block) if block_given?
 
-        verify_transition_validity(t)
+      verify_transition_validity(t)
 
-        @transitions      << t
-        @states           |= [t.to_state] unless t.to_state.nil?
-      end
+      @transitions      << t
+      @transition_names |= [t.full_name]  unless t.full_name.blank?
+      @states           |= [t.to_state]   unless t.to_state.nil?
+
+      t
     end
 
     def state_alias(name, options = {}, &block)
-      Stator::Alias.new(self, name, options).tap do |a|
-        # puts "ALIAS: #{a.inspect}"
-        a.instance_eval(&block) if block_given?
-        @aliases << a
-      end
+      a = ::Stator::Alias.new(self, name, options)
+      a.instance_eval(&block) if block_given?
+      @aliases << a
+      a
     end
 
     def state(name, &block)
@@ -70,32 +62,34 @@ module Stator
       end
     end
 
+    def tracking_enabled?
+      @tracking_enabled
+    end
+
     def conditional(*states, &block)
-      state_check = proc { states.include?(current_state) }
+      _namespace = @namespace
 
-      klass.instance_exec(state_check, &block)
+      klass.instance_exec(proc { states.map(&:to_s).include?(self._stator(_namespace).integration(self).state) }, &block)
     end
 
     def matching_transition(from, to)
-      transitions.detect { |transition| transition.valid?(from, to) }
+      @transitions.detect do |transition|
+        transition.valid?(from, to)
+      end
     end
 
     def evaluate
-      transitions.each(&:evaluate)
-      aliases.each(&:evaluate)
+      @transitions.each(&:evaluate)
+      @aliases.each(&:evaluate)
       generate_methods
     end
 
-    private
-
-    def attr_name(name)
-      if namespace == Stator.default_namespace
-        name.to_sym
-      else
-        [namespace, name].compact.join('_').to_sym
-      end
+    def klass
+      @class_name.constantize
     end
 
+    protected
+
     def verify_transition_validity(transition)
       verify_state_singularity_of_transition(transition)
       verify_name_singularity_of_transition(transition)
@@ -104,29 +98,34 @@ 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} to #{transition}"
+          raise "[Stator] another transition already exists which moves #{@class_name} from #{from.inspect} to #{transition.to_state.inspect}"
         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} 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.inspect} in the #{@class_name} class"
       end
     end
 
     def generate_methods
-      states.each do |state|
+      self.states.each do |state|
+        method_name = [@namespace, state].compact.join('_')
         klass.class_eval <<-EV, __FILE__, __LINE__ + 1
-          def #{attr_name(state)}?
-            _stator_integration(:#{namespace}).state.to_sym == :#{state}
+          def #{method_name}?
+            integration = self._stator(#{@namespace.inspect}).integration(self)
+            integration.state == #{state.to_s.inspect}
           end
 
-          def #{attr_name(state)}_state_by?(time)
-            _stator_integration(:#{namespace}).state_by?(:#{state}.to_sym, time)
+          def #{method_name}_state_by?(time)
+            integration = self._stator(#{@namespace.inspect}).integration(self)
+            integration.state_by?(#{state.to_s.inspect}, time)
           end
         EV
       end
     end
+
+
   end
 end