finite_machine 0.11.3 → 0.12.0

data/lib/finite_machine/subscribers.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 require 'monitor'
 

data/lib/finite_machine/threadable.rb

@@ -1,4 +1,6 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
+require_relative 'two_phase_lock'
 
 module FiniteMachine
   # A mixin to allow instance methods to be synchronized

data/lib/finite_machine/transition.rb

@@ -1,7 +1,21 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
+require_relative 'callable'
+require_relative 'threadable'
 
 module FiniteMachine
   # Class describing a transition associated with a given event
+  #
+  # The {Transition} is created with the `event` helper.
+  #
+  # @example Converting event into {Transition}
+  #   event :go, :red => :green
+  #
+  #   will be translated to
+  #
+  #   Transition.new(context, :go, {states: {:red => :green}})
+  #
+  # @api private
   class Transition
     include Threadable
 
@@ -11,11 +25,8 @@ module FiniteMachine
     # Predicates before transitioning
     attr_threadsafe :conditions
 
-    # The current state machine
-    attr_threadsafe :machine
-
-    # Check if transition should be cancelled
-    attr_threadsafe :cancelled
+    # The current state machine context
+    attr_threadsafe :context
 
     # All states for this transition event
     attr_threadsafe :states
@@ -23,33 +34,25 @@ module FiniteMachine
     # Initialize a Transition
     #
     # @example
-    #   attributes = {parsed_states: {green: :yellow}}
-    #   Transition.new(machine, attributes)
+    #   attributes = {states: {green: :yellow}}
+    #   Transition.new(context, :go, attributes)
     #
-    # @param [StateMachine] machine
+    # @param [Object] context
+    #   the context this transition evaluets conditions in
     #
     # @param [Hash] attrs
     #
     # @return [Transition]
     #
     # @api public
-    def initialize(machine, attrs = {})
-      @machine     = machine
-      @name        = attrs[:name]
+    def initialize(context, name, attrs = {})
+      @context     = context
+      @name        = name
       @states      = attrs.fetch(:states, {})
       @if          = Array(attrs.fetch(:if, []))
       @unless      = Array(attrs.fetch(:unless, []))
       @conditions  = make_conditions
-      @cancelled   = attrs.fetch(:cancelled, false)
-    end
-
-    # Check if this transition is cancelled or not
-    #
-    # @return [Boolean]
-    #
-    # @api public
-    def cancelled?
-      @cancelled
+      freeze
     end
 
     # Reduce conditions
@@ -72,7 +75,7 @@ module FiniteMachine
     # @api private
     def check_conditions(*args)
       conditions.all? do |condition|
-        condition.call(machine.target, *args)
+        condition.call(context, *args)
       end
     end
 
@@ -82,7 +85,7 @@ module FiniteMachine
     #   the from state to match against
     #
     # @example
-    #   transition = Transition.new(machine, states: {:green => :red})
+    #   transition = Transition.new(context, states: {:green => :red})
     #   transition.matches?(:green) # => true
     #
     # @return [Boolean]
@@ -99,7 +102,7 @@ module FiniteMachine
     #   the from state to check
     #
     # @example
-    #   transition = Transition.new(machine, states: {:green => :red})
+    #   transition = Transition.new(context, states: {:green => :red})
     #   transition.to_state(:green) # => :red
     #
     # @return [Symbol]
@@ -107,17 +110,13 @@ module FiniteMachine
     #
     # @api public
     def to_state(from)
-      if cancelled?
-        from
-      else
-        states[from] || states[ANY_STATE]
-      end
+      states[from] || states[ANY_STATE]
     end
 
     # Return transition name
     #
     # @example
-    #   transition = Transition.new(machine, name: :go)
+    #   transition = Transition.new(context, name: :go)
     #   transition.to_s # => 'go'
     #
     # @return [String]

data/lib/finite_machine/transition_builder.rb

@@ -1,8 +1,9 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'finite_machine/state_parser'
-require 'finite_machine/event_definition'
-require 'finite_machine/state_definition'
+require_relative 'event_definition'
+require_relative 'state_definition'
+require_relative 'state_parser'
+require_relative 'transition'
 
 module FiniteMachine
   # A class reponsible for building transition out of parsed states
@@ -11,54 +12,44 @@ module FiniteMachine
   #
   # @api private
   class TransitionBuilder
-    include Threadable
-
-    # The current state machine
-    attr_threadsafe :machine
-
-    attr_threadsafe :attributes
-
-    attr_threadsafe :event_definition
-
-    attr_threadsafe :state_definition
-
     # Initialize a TransitionBuilder
     #
     # @example
     #   TransitionBuilder.new(machine, {})
     #
     # @api public
-    def initialize(machine, attributes = {})
-      @machine = machine
+    def initialize(machine, name, attributes = {})
+      @machine    = machine
+      @name       = name
       @attributes = attributes
+
       @event_definition = EventDefinition.new(machine)
       @state_definition = StateDefinition.new(machine)
     end
 
-    # Creates transitions for the states
+    # Converts user transitions into internal {Transition} representation
     #
     # @example
     #   transition_builder.call([:green, :yellow] => :red)
     #
-    # @param [Hash[Symbol]] states
-    #   The states to extract
+    # @param [Hash[Symbol]] transitions
+    #   The transitions to extract states from
     #
     # @return [self]
     #
     # @api public
-    def call(states)
-      StateParser.new(states).parse do |from, to|
-        attributes.merge!(states: { from => to })
-        transition = Transition.new(machine, attributes)
-        name = attributes[:name]
-        silent = attributes.fetch(:silent, false)
-
-        machine.events_chain.add(name, transition)
-
-        unless machine.respond_to?(name)
-          event_definition.apply(name, silent)
+    def call(transitions)
+      StateParser.parse(transitions) do |from, to|
+        transition = Transition.new(@machine.env.target, @name,
+                                    @attributes.merge(states: { from => to }))
+        silent = @attributes.fetch(:silent, false)
+        @machine.events_map.add(@name, transition)
+        next unless @machine.auto_methods?
+
+        unless @machine.respond_to?(@name)
+          @event_definition.apply(@name, silent)
         end
-        state_definition.apply({ from => to })
+        @state_definition.apply(from => to)
       end
       self
     end

data/lib/finite_machine/transition_event.rb

@@ -1,4 +1,6 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
+require_relative 'threadable'
 
 module FiniteMachine
   # A class representing a callback transition event
@@ -7,38 +9,37 @@ module FiniteMachine
   #
   # @api private
   class TransitionEvent
-    include Threadable
-
     # This event from state name
     #
     # @return [Object]
     #
     # @api public
-    attr_threadsafe :from
+    attr_reader :from
 
     # This event to state name
     #
     # @return [Object]
     #
     # @api public
-    attr_threadsafe :to
+    attr_reader :to
 
     # This event name
     #
     # @api public
-    attr_threadsafe :name
+    attr_reader :name
 
     # Build a transition event
     #
-    # @param [FiniteMachine::Transition] transition
+    # @param [String] event_name
+    # @param [String] from
+    # @param [String] to
     #
     # @return [self]
     #
     # @api private
-    # def initialize(transition, *data)
-    def initialize(hook_event, to)
-      @name = hook_event.event_name
-      @from = hook_event.from
+    def initialize(event_name, from, to)
+      @name = event_name
+      @from = from
       @to   = to
       freeze
     end

data/lib/finite_machine/two_phase_lock.rb

@@ -1,4 +1,6 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
+require 'sync'
 
 module FiniteMachine
   # Mixin to provide lock to a {Threadable}

data/lib/finite_machine/undefined_transition.rb

@@ -1,19 +1,18 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module FiniteMachine
   # Stand in for lack of matching transition.
   #
-  # Used internally by {EventsChain}
+  # Used internally by {EventsMap}
   #
   # @api private
   class UndefinedTransition
-    include Threadable
-
     # Initialize an undefined transition
     #
     # @api private
     def initialize(name)
-      self.name = name
+      @name = name
+      freeze
     end
 
     def to_state(from)
@@ -26,7 +25,7 @@ module FiniteMachine
 
     protected
 
-    attr_threadsafe :name
+    attr_reader :name
 
   end # UndefinedTransition
 end # FiniteMachine

data/lib/finite_machine/version.rb

@@ -1,5 +1,5 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module FiniteMachine
-  VERSION = "0.11.3"
+  VERSION = "0.12.0"
 end

data/spec/integration/system_spec.rb

@@ -1,41 +1,38 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 RSpec.describe FiniteMachine, 'system' do
 
   it "doesn't share state between machine callbacks" do
     callbacks = []
     stub_const("FSM_A", Class.new(FiniteMachine::Definition) do
-      events {
-        event :init, :none => :green
-        event :green, :any => :green
-      }
-      callbacks {
-        on_before do |event|
-          callbacks << "fsmA on_before(#{event.to})"
-        end
-        on_enter_green do |event|
-          target.fire
-          callbacks << "fsmA on_enter_green"
-        end
-        once_on_enter_green do |event|
-          callbacks << "fsmA once_on_enter_green"
-        end
-      }
+      event :init, :none => :green
+      event :start, any_state => :green
+
+      on_before do |event|
+        callbacks << "fsmA on_before(#{event.name})"
+      end
+      on_enter_green do |event|
+        target.fire
+        callbacks << "fsmA on_enter(:green)"
+      end
+      once_on_enter_green do |event|
+        callbacks << "fsmA once_on_enter(:green)"
+      end
     end)
 
     stub_const("FSM_B", Class.new(FiniteMachine::Definition) do
-      events {
-        event :init,  :none    => :stopped
-        event :start, :stopped => :started
-      }
-      callbacks {
-        on_before do |event|
-          callbacks << "fsmB on_before(#{event.to})"
-        end
-        on_enter_started do |event|
-          callbacks << "fsmB on_enter_started"
-        end
-      }
+      event :init,  :none    => :stopped
+      event :start, :stopped => :started
+
+      on_before do |event|
+        callbacks << "fsmB on_before(#{event.name})"
+      end
+      on_enter_stopped do |event|
+        callbacks << "fsmB on_enter(:stopped)"
+      end
+      on_enter_started do |event|
+        callbacks << "fsmB on_enter(:started)"
+      end
     end)
 
     class Backend
@@ -64,8 +61,7 @@ RSpec.describe FiniteMachine, 'system' do
 
     class Fire
       def initialize
-        @fsmA = FSM_A.new
-        @fsmA.target(self)
+        @fsmA = FSM_A.new(self)
 
         @backend = Backend.new
         @backend.operate
@@ -76,7 +72,8 @@ RSpec.describe FiniteMachine, 'system' do
       end
 
       def operate
-        @fsmA.green
+        #@fsmA.start # should trigger as well
+        @fsmA.init
       end
     end
 
@@ -84,12 +81,13 @@ RSpec.describe FiniteMachine, 'system' do
     fire.operate
 
     expect(callbacks).to match_array([
-      'fsmA on_before(green)',
-      'fsmA on_enter_green',
-      'fsmA once_on_enter_green',
-      'fsmB on_before(stopped)',
-      'fsmB on_before(started)',
-      'fsmB on_enter_started'
+      'fsmB on_before(init)',
+      'fsmB on_enter(:stopped)',
+      'fsmA on_before(init)',
+      'fsmA on_enter(:green)',
+      'fsmA once_on_enter(:green)',
+      'fsmB on_before(start)',
+      'fsmB on_enter(:started)'
     ])
   end
 end

data/spec/performance/benchmark_spec.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-RSpec.describe FiniteMachine do
+RSpec.describe FiniteMachine, perf: true do
   include RSpec::Benchmark::Matchers
 
   class Measurement
@@ -23,21 +23,15 @@ RSpec.describe FiniteMachine do
   it "correctly loops through events" do
     measurement = Measurement.new
 
-    fsm = FiniteMachine.define do
+    fsm = FiniteMachine.new(measurement) do
       initial :green
 
-      target(measurement)
+      event :next, :green => :yellow,
+                    :yellow => :red,
+                    :red => :green
 
-      events {
-        event :next, :green => :yellow,
-                     :yellow => :red,
-                     :red => :green
-      }
-
-      callbacks {
-        on_enter do |event| target.inc_step; true end
-        on_enter :red do |event| target.inc_loop; true end
-      }
+      on_enter do |event| target.inc_step; true end
+      on_enter :red do |event| target.inc_loop; true end
     end
 
     100.times { fsm.next }
@@ -46,15 +40,13 @@ RSpec.describe FiniteMachine do
     expect(measurement.loops).to eq(100 / 3)
   end
 
-  it "performs at least 300 ips" do
-    fsm = FiniteMachine.define do
+  it "performs at least 400 ips" do
+    fsm = FiniteMachine.new do
       initial :green
 
-      events {
-        event :next, :green => :yellow,
-                     :yellow => :red,
-                     :red => :green
-      }
+      event :next, :green => :yellow,
+                    :yellow => :red,
+                    :red => :green
     end
 
     expect { fsm.next }.to perform_at_least(400).ips