finite_machine 0.11.3 → 0.12.0

data/Rakefile

@@ -4,5 +4,9 @@ require "bundler/gem_tasks"
 
 FileList['tasks/**/*.rake'].each(&method(:import))
 
+jruby = RUBY_ENGINE == 'ruby'
+specs = ['spec']
+specs << 'spec:perf' if jruby
+
 desc 'Run all specs'
-task ci: %w[ spec spec:perf ]
+task ci: specs

data/benchmarks/memory_profile.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative '../lib/finite_machine'
+require 'ruby-prof'
+
+result = RubyProf.profile do
+  FiniteMachine.new
+end
+
+printer = RubyProf::FlatPrinter.new(result)
+printer.print($stdout)

data/benchmarks/memory_usage.rb

@@ -1,21 +1,28 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-require 'finite_machine'
+require_relative '../lib/finite_machine'
 
-3.times do
+5.times do
   puts
 
   GC.start
 
-  before = GC.stat
-  p ObjectSpace.count_objects
+  gc_before = GC.stat
+  objects_before = ObjectSpace.count_objects
+  p objects_before[:T_OBJECT]
 
   1_000.times do
-    FiniteMachine.define
+    FiniteMachine.new do
+      initial :green
+
+      events { event :slow, :green => :yellow }
+    end
   end
 
-  p ObjectSpace.count_objects
-  after = GC.stat
+  objects_after = ObjectSpace.count_objects
+  gc_after = GC.stat
+  p objects_after[:T_OBJECT]
 
-  p "GC count: #{after[:count] - before[:count]}"
+  p "GC count: #{gc_after[:count] - gc_before[:count]}"
+  p "Objects count: #{objects_after[:T_OBJECT] - objects_before[:T_OBJECT]}"
 end

data/finite_machine.gemspec

@@ -1,4 +1,3 @@
-# coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'finite_machine/version'
@@ -10,14 +9,22 @@ Gem::Specification.new do |spec|
   spec.email         = [""]
   spec.description   = %q{A minimal finite state machine with a straightforward syntax. You can quickly model states, add callbacks and use object-oriented techniques to integrate with ORMs.}
   spec.summary       = %q{A minimal finite state machine with a straightforward syntax.}
-  spec.homepage      = "http://peter-murach.github.io/finite_machine/"
+  spec.homepage      = "http://piotrmurach.github.io/finite_machine/"
   spec.license       = "MIT"
 
-  spec.files         = `git ls-files`.split($/)
+  spec.files         = Dir['{lib,spec,examples,benchmarks}/**/*.rb']
+  spec.files        += Dir['tasks/*', 'finite_machine.gemspec']
+  spec.files        += Dir['README.md', 'CHANGELOG.md', 'LICENSE.txt', 'Rakefile']
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.required_ruby_version = '>= 2.0.0'
+
+  spec.add_runtime_dependency 'concurrent-ruby', '~> 1.0'
+
   spec.add_development_dependency 'bundler', '>= 1.5.0', '< 2.0'
+  spec.add_development_dependency 'rspec', '~> 3.1'
+  spec.add_development_dependency 'rspec-benchmark', '~> 0.4.0'
   spec.add_development_dependency 'rake'
 end

data/lib/finite_machine.rb

@@ -1,33 +1,12 @@
-# encoding: utf-8
-
-require "logger"
-require "thread"
-require "sync"
-require "forwardable"
-
-require "finite_machine/version"
-require "finite_machine/threadable"
-require "finite_machine/safety"
-require "finite_machine/callable"
-require "finite_machine/catchable"
-require "finite_machine/choice_merger"
-require "finite_machine/async_proxy"
-require "finite_machine/async_call"
-require "finite_machine/hook_event"
-require "finite_machine/env"
-require "finite_machine/message_queue"
-require "finite_machine/events_chain"
-require "finite_machine/logger"
-require "finite_machine/transition"
-require "finite_machine/transition_builder"
-require "finite_machine/transition_event"
-require "finite_machine/dsl"
-require "finite_machine/definition"
-require "finite_machine/state_machine"
-require "finite_machine/subscribers"
-require "finite_machine/observer"
-require "finite_machine/listener"
-require "finite_machine/two_phase_lock"
+# frozen_string_literal: true
+
+require 'logger'
+
+require_relative 'finite_machine/const'
+require_relative 'finite_machine/logger'
+require_relative 'finite_machine/definition'
+require_relative 'finite_machine/state_machine'
+require_relative 'finite_machine/version'
 
 module FiniteMachine
   # Default state name
@@ -36,22 +15,19 @@ module FiniteMachine
   # Initial default event name
   DEFAULT_EVENT_NAME = :init
 
-  # Describe any state transition
-  ANY_STATE = :any
+  # Describe any transition state
+  ANY_STATE = Const.new(:any)
 
   # Describe any event name
-  ANY_EVENT = :any_event
-
-  # Returned when transition has successfully performed
-  SUCCEEDED = 1
-
-  # Returned when transition is cancelled in callback
-  CANCELLED = 2
+  ANY_EVENT = Const.new(:any_event)
 
   # When transition between states is invalid
   TransitionError = Class.new(::StandardError)
 
-  # Raised when transitining to invalid state
+  # When failed to process callback
+  CallbackError = Class.new(::StandardError)
+
+  # Raised when transitioning to invalid state
   InvalidStateError = Class.new(::ArgumentError)
 
   InvalidEventError = Class.new(::NoMethodError)
@@ -74,21 +50,33 @@ module FiniteMachine
   class << self
     attr_accessor :logger
 
-    # TODO: this should instantiate system not the state machine
-    # and then delegate calls to StateMachine instance etc...
+    # Initialize an instance of finite machine
     #
     # @example
-    #   FiniteMachine.define do
+    #   FiniteMachine.new do
     #     ...
     #   end
     #
     # @return [FiniteMachine::StateMachine]
     #
     # @api public
-    def define(*args, &block)
-      StateMachine.new(*args, &block)
+    def new(*args, **options, &block)
+      StateMachine.new(*args, **options, &block)
+    end
+
+    # A factory method for creating reusable FiniteMachine definitions
+    #
+    # @example
+    #   TrafficLights = FiniteMachine.define
+    #   lights_fm_a = TrafficLights.new
+    #   lights_fm_b = TrafficLights.new
+    #
+    # @return [Class]
+    #
+    # @api public
+    def define(&block)
+      Class.new(Definition, &block)
     end
-    alias_method :new, :define
   end
 end # FiniteMachine
 

data/lib/finite_machine/async_call.rb

@@ -1,14 +1,13 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module FiniteMachine
-  # An asynchronouse call representation
+  # An immutable asynchronouse call representation that wraps
+  # the {Callable} object
   #
-  # Used internally by {EventQueue} to schedule events
+  # Used internally by {MessageQueue} to dispatch events
   #
   # @api private
   class AsyncCall
-    include Threadable
-
     # Create asynchronous call instance
     #
     # @param [Object] context
@@ -19,15 +18,12 @@ module FiniteMachine
     # @example
     #   AsyncCall.new(context, Callable.new(:method), :a, :b)
     #
-    # @return [self]
-    #
     # @api public
     def initialize(context, callable, *args, &block)
       @context   = context
       @callable  = callable
       @arguments = args.dup
       @block     = block
-      @mutex     = Mutex.new
       freeze
     end
 
@@ -37,19 +33,7 @@ module FiniteMachine
     #
     # @api private
     def dispatch
-      @mutex.synchronize do
-        callable.call(context, *arguments, &block)
-      end
+      @callable.call(@context, *@arguments, &@block)
     end
-
-    protected
-
-    attr_threadsafe :context
-
-    attr_threadsafe :callable
-
-    attr_threadsafe :arguments
-
-    attr_threadsafe :block
   end # AsyncCall
 end # FiniteMachine

data/lib/finite_machine/callable.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module FiniteMachine
   # A generic interface for executing strings, symbol methods or procs.
@@ -20,7 +20,7 @@ module FiniteMachine
     #
     # @api public
     def invert
-      lambda { |*args, &block|  !call(*args, &block) }
+      ->(*args, &block) { !call(*args, &block) }
     end
 
     # Execute action
@@ -34,10 +34,10 @@ module FiniteMachine
         target.public_send(object.to_sym, *args, &block)
       when String
         string = args.empty? ? "-> { #{object} }" : "-> { #{object}(*#{args}) }"
-        value  = eval string
+        value  = eval(string)
         target.instance_exec(&value)
       when ::Proc
-        object.arity.zero? ?  object.call : object.call(target, *args)
+        object.arity.zero? ? object.call : object.call(target, *args)
       else
         raise ArgumentError, "Unknown callable #{object}"
       end

data/lib/finite_machine/catchable.rb

@@ -1,9 +1,11 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module FiniteMachine
   # A mixin to allow for specifying error handlers
   module Catchable
-
+    # Extends object with error handling methods
+    #
+    # @api private
     def self.included(base)
       base.module_eval do
         attr_threadsafe :error_handlers, default: []

data/lib/finite_machine/choice_merger.rb

@@ -1,43 +1,43 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
+require_relative 'transition_builder'
 
 module FiniteMachine
   # A class responsible for merging choice options
   class ChoiceMerger
-    include Threadable
-
-    # The context where choice is executed
-    attr_threadsafe :machine
-
-    # The options passed in to the machine
-    attr_threadsafe :options
-
     # Initialize a ChoiceMerger
     #
+    # @param [StateMachine] machine
+    # @param [String] name
+    # @param [Hash] transitions
+    #   the transitions and attributes
+    #
     # @api private
-    def initialize(machine, options)
-      self.machine = machine
-      self.options = options
+    def initialize(machine, name, **transitions)
+      @machine     = machine
+      @name        = name
+      @transitions = transitions
     end
 
     # Create choice transition
     #
     # @example
-    #   event from: :green do
+    #   event :stop, from: :green do
     #     choice :yellow
     #   end
     #
     # @param [Symbol] to
     #   the to state
-    # @param [Hash] attrs
+    # @param [Hash] conditions
+    #   the conditions associated with this choice
     #
     # @return [FiniteMachine::Transition]
     #
     # @api public
-    def choice(to, attrs = {})
-      opts = options.dup
-      opts.merge!(attrs)
-      transition_builder = TransitionBuilder.new(machine, opts)
-      transition_builder.call(options[:from] => to)
+    def choice(to, **conditions)
+      transition_builder = TransitionBuilder.new(@machine, @name,
+                                                 @transitions.merge(conditions))
+      transition_builder.call(@transitions[:from] => to)
     end
     alias_method :default, :choice
   end # ChoiceMerger

data/lib/finite_machine/const.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module FiniteMachine
+  class Const
+    def initialize(name)
+      @name = name.to_s
+      freeze
+    end
+
+    def to_s
+      @name
+    end
+    alias to_str to_s
+    alias inspect to_s
+  end # Const
+end # FiniteMachine

data/lib/finite_machine/definition.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module FiniteMachine
   # A class responsible for defining standalone state machine
@@ -38,7 +38,7 @@ module FiniteMachine
     # @api public
     def self.new(*args)
       context = self
-      FiniteMachine.define(*args) do
+      FiniteMachine.new(*args) do
         context.deferreds.each { |d| d.call(self) }
       end
     end

data/lib/finite_machine/dsl.rb

@@ -1,59 +1,68 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
+require_relative 'choice_merger'
+require_relative 'safety'
+require_relative 'transition_builder'
 
 module FiniteMachine
   # A generic DSL for describing the state machine
   class GenericDSL
-    include Threadable
-
-    class << self
-      # @api private
-      attr_accessor :top_level
+    # Initialize a generic DSL
+    #
+    # @api public
+    def initialize(machine, **attrs)
+      @machine = machine
+      @attrs   = attrs
     end
 
-    attr_threadsafe :machine
-
-    attr_threadsafe :attrs
+    # Expose any state constant
+    # @api public
+    def any_state
+      ANY_STATE
+    end
 
-    # Initialize a generic DSL
-    #
+    # Expose any event constant
     # @api public
-    def initialize(machine, attrs = {})
-      self.attrs = attrs
-      self.machine = machine
+    def any_event
+      ANY_EVENT
     end
 
     # Delegate attributes to machine instance
     #
     # @api private
     def method_missing(method_name, *args, &block)
-      if machine.respond_to?(method_name)
-        machine.send(method_name, *args, &block)
+      if @machine.respond_to?(method_name)
+        @machine.send(method_name, *args, &block)
       else
         super
       end
     end
 
+    # Configure state machine properties
+    #
+    # @api private
     def call(&block)
-      sync_exclusive { instance_eval(&block) }
-      # top_level.instance_eval(&block)
+      instance_eval(&block)
     end
   end # GenericDSL
 
   # A class responsible for adding state machine specific dsl
   class DSL < GenericDSL
-    attr_threadsafe :defer
-
-    attr_threadsafe :initial_event
+    include Safety
 
     # Initialize top level DSL
     #
     # @api public
-    def initialize(machine, attrs = {})
+    def initialize(machine, **attrs)
       super(machine, attrs)
-      machine.state = FiniteMachine::DEFAULT_STATE
-      self.defer    = true
 
-      initialize_attrs
+      @machine.state = FiniteMachine::DEFAULT_STATE
+      @defer_initial = true
+      @silent_initial = true
+
+      initial(@attrs[:initial])   if @attrs[:initial]
+      terminal(@attrs[:terminal]) if @attrs[:terminal]
+      log_transitions(@attrs.fetch(:log_transitions, false))
     end
 
     # Define initial state
@@ -87,11 +96,11 @@ module FiniteMachine
     # @return [StateMachine]
     #
     # @api public
-    def initial(value, options = {})
+    def initial(value, **options)
       state = (value && !value.is_a?(Hash)) ? value : raise_missing_state
-      name, self.defer, silent = *parse_initial(options)
-      self.initial_event = name
-      event(name, FiniteMachine::DEFAULT_STATE => state, silent: silent)
+      name, @defer_initial, @silent_initial = *parse_initial(options)
+      @initial_event = name
+      event(name, FiniteMachine::DEFAULT_STATE => state, silent: @silent_initial)
     end
 
     # Trigger initial event
@@ -100,51 +109,8 @@ module FiniteMachine
     #
     # @api private
     def trigger_init
-      public_send(:"#{initial_event}") unless defer
-    end
-
-    # Attach state machine to an object
-    #
-    # This allows state machine to initiate events in the context
-    # of a particular object
-    #
-    # @example
-    #   FiniteMachine.define do
-    #     target :red
-    #   end
-    #
-    # @param [Object] object
-    #
-    # @return [FiniteMachine::StateMachine]
-    #
-    # @api public
-    def target(object = nil)
-      if object.nil?
-        env.target
-      else
-        env.target = object
-      end
-    end
-
-    # Use alternative name for target
-    #
-    # @example
-    #   target_alias: :car
-    #
-    #   callbacks {
-    #     on_transition do |event|
-    #       car.state = event.to
-    #     end
-    #   }
-    #
-    # @param [Symbol] alias_name
-    #   the name to alias target to
-    #
-    # @return [FiniteMachine::StateMachine]
-    #
-    # @api public
-    def alias_target(alias_name)
-      env.aliases << alias_name.to_sym
+      method = @silent_initial ? :transition : :trigger
+      @machine.public_send(method, :"#{@initial_event}") unless @defer_initial
     end
 
     # Define terminal state
@@ -159,39 +125,44 @@ module FiniteMachine
       self.final_state = values
     end
 
-    # Define state machine events
+    # Create event and associate transition
     #
     # @example
-    #   events do
-    #     event :start, :red => :green
-    #   end
+    #   event :go, :green => :yellow
+    #   event :go, :green => :yellow, if: :lights_on?
     #
-    # @return [FiniteMachine::StateMachine]
+    # @param [Symbol] name
+    #   the event name
+    # @param [Hash] transitions
+    #   the event transitions and conditions
+    #
+    # @return [Transition]
     #
     # @api public
-    def events(&block)
-      events_dsl.call(&block)
+    def event(name, transitions = {}, &block)
+      detect_event_conflict!(name) if machine.auto_methods?
+
+      if block_given?
+        merger = ChoiceMerger.new(machine, name, transitions)
+        merger.instance_eval(&block)
+      else
+        transition_builder = TransitionBuilder.new(machine, name, transitions)
+        transition_builder.call(transitions)
+      end
     end
 
-    # Define state machine callbacks
+    # Add error handler
     #
-    # @example
-    #   callbacks do
-    #     on_enter :green do |event| ... end
-    #   end
+    # @param [Array] exceptions
     #
-    # @return [FiniteMachine::Observer]
+    # @example
+    #   handle InvalidStateError, with: :log_errors
     #
-    # @api public
-    def callbacks(&block)
-      observer.call(&block)
-    end
-
-    # Error handler that throws exception when machine is in illegal state
+    # @return [Array[Exception]]
     #
     # @api public
-    def handlers(&block)
-      errors_dsl.call(&block)
+    def handle(*exceptions, &block)
+      @machine.handle(*exceptions, &block)
     end
 
     # Decide whether to log transitions
@@ -203,16 +174,6 @@ module FiniteMachine
 
     private
 
-    # Initialize state machine properties based off attributes
-    #
-    # @api private
-    def initialize_attrs
-      attrs[:initial]  && initial(attrs[:initial])
-      attrs[:target]   && target(attrs[:target])
-      attrs[:terminal] && terminal(attrs[:terminal])
-      log_transitions(attrs.fetch(:log_transitions, false))
-    end
-
     # Parse initial options
     #
     # @param [Hash] options
@@ -240,48 +201,4 @@ module FiniteMachine
            'Provide state to transition :to for the initial event'
     end
   end # DSL
-
-  # A DSL for describing events
-  class EventsDSL < GenericDSL
-    include Safety
-    # Create event and associate transition
-    #
-    # @example
-    #   event :go, :green => :yellow
-    #   event :go, :green => :yellow, if: :lights_on?
-    #
-    # @return [Transition]
-    #
-    # @api public
-    def event(name, attrs = {}, &block)
-      sync_exclusive do
-        detect_event_conflict!(name)
-        attributes = attrs.merge!(name: name)
-        if block_given?
-          merger = ChoiceMerger.new(machine, attributes)
-          merger.instance_eval(&block)
-        else
-          transition_builder = TransitionBuilder.new(machine, attributes)
-          transition_builder.call(attrs)
-        end
-      end
-    end
-  end # EventsDSL
-
-  # A DSL for describing error conditions
-  class ErrorsDSL < GenericDSL
-    # Add error handler
-    #
-    # @param [Array] exceptions
-    #
-    # @example
-    #   handle InvalidStateError, with: :log_errors
-    #
-    # @return [Array[Exception]]
-    #
-    # @api public
-    def handle(*exceptions, &block)
-      machine.handle(*exceptions, &block)
-    end
-  end # ErrorsDSL
 end # FiniteMachine