finite_machine 0.12.1 → 0.13.0

data/benchmarks/memory_usage.rb

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

data/examples/atm.rb

@@ -1,45 +0,0 @@
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-
-require 'finite_machine'
-
-class Account
-  attr_accessor :number
-
-  def verify(account_number, pin)
-    return account_number == 123456 && pin == 666
-  end
-end
-
-account = Account.new
-
-atm = FiniteMachine.define do
-  initial :unauthorized
-
-  target account
-
-  events {
-    event :authorize, :unauthorized => :authorized, if: -> (account, account_number, pin) {
-      account.verify(account_number, pin)
-    }
-    event :deauthorize, :authorized => :unauthorized
-  }
-
-  callbacks {
-    on_exit :unauthorized do |event, account_number, pin|
-      # if verify(account_number, pin)
-        self.number = account_number
-#       else
-#         puts "Invalid Account and/or PIN"
-#         FiniteMachine::CANCELLED
-#       end
-    end
-  }
-end
-
-atm.authorize(111222, 666)
-puts "authorized: #{atm.authorized?}"
-puts "Number: #{account.number}"
-
-atm.authorize(123456, 666)
-puts "authorized: #{atm.authorized?}"
-puts "Number: #{account.number}"

data/examples/bug_system.rb

@@ -1,145 +0,0 @@
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-
-require 'finite_machine'
-
-class User
-  attr_accessor :name
-
-  def initialize(name)
-    @name = name
-  end
-end
-
-class Manager < User
-  attr_accessor :developers
-
-  def initialize(name)
-    super
-    @developers = []
-  end
-
-  def manages(developer)
-    @developers << developer
-  end
-
-  def assign(bug)
-    developer = @developers.first
-    bug.assign
-    developer.bug = bug
-  end
-end
-
-class Tester < User
-  def report(bug)
-    bug.report
-  end
-
-  def reopen(bug)
-    bug.reopen
-  end
-end
-
-class Developer < User
-  attr_accessor :bug
-
-  def work_on
-    bug.start
-  end
-
-  def resolve
-    bug.close
-  end
-end
-
-class BugSystem
-  attr_accessor :managers
-
-  def initialize(managers = [])
-    @managers = managers
-  end
-
-  def notify_manager(bug)
-    manager = @managers.first
-    manager.assign(bug)
-  end
-end
-
-class Bug
-  attr_accessor :name
-  attr_accessor :priority
-  # fake belongs_to relationship
-  attr_accessor :bug_system
-
-  def initialize(name, priority)
-    @name = name
-    @priority = priority
-  end
-
-  def report
-    status.report
-  end
-
-  def assign
-    status.assign
-  end
-
-  def start
-    status.start
-  end
-
-  def close
-    status.close
-  end
-
-  def reopen
-    status.reopen
-  end
-
-  def status
-    context = self
-    @status ||= FiniteMachine.define do
-      target context
-
-      events {
-        event :report, :none => :new
-        event :assign, :new => :assigned
-        event :start,  :assigned => :in_progress
-        event :close,  [:in_progress, :reopened] => :resolved
-        event :reopen, :resolved => :reopened
-      }
-
-      callbacks {
-        on_enter :new do |event|
-          bug_system.notify_manager(self)
-        end
-      }
-    end
-  end
-end
-
-tester    = Tester.new("John")
-manager   = Manager.new("David")
-developer = Developer.new("Piotr")
-manager.manages(developer)
-
-bug_system = BugSystem.new([manager])
-bug        = Bug.new(:trojan, :high)
-bug.bug_system = bug_system
-
-puts "A BUG's LIFE"
-puts "#1 #{bug.status.current}"
-
-tester.report(bug)
-puts "#2 #{bug.status.current}"
-
-developer.work_on
-puts "#3 #{bug.status.current}"
-
-developer.resolve
-puts "#4 #{bug.status.current}"
-
-tester.reopen(bug)
-puts "#5 #{bug.status.current}"
-
-developer.resolve
-puts "#6 #{bug.status.current}"

data/finite_machine.gemspec

@@ -1,30 +0,0 @@
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'finite_machine/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = "finite_machine"
-  spec.version       = FiniteMachine::VERSION
-  spec.authors       = ["Piotr Murach"]
-  spec.email         = ["me@piotrmurach.com"]
-  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://piotrmurach.github.io/finite_machine/"
-  spec.license       = "MIT"
-
-  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'
-  spec.add_development_dependency 'rspec', '~> 3.1'
-  spec.add_development_dependency 'rspec-benchmark', '~> 0.4.0'
-  spec.add_development_dependency 'rake'
-end

data/spec/integration/system_spec.rb

@@ -1,93 +0,0 @@
-# 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
-      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
-      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
-      def initialize
-        @fsmB = FSM_B.new
-        @fsmB.init
-        @signal = Mutex.new
-      end
-
-      def operate
-        @signal.unlock if @signal.locked?
-        @worker = Thread.new do
-          while !@signal.locked? do
-            sleep 0.01
-          end
-          Thread.current.abort_on_exception = true
-          @fsmB.start
-        end
-      end
-
-      def stopit
-        @signal.lock
-        @worker.join
-      end
-    end
-
-    class Fire
-      def initialize
-        @fsmA = FSM_A.new(self)
-
-        @backend = Backend.new
-        @backend.operate
-      end
-
-      def fire
-        @backend.stopit
-      end
-
-      def operate
-        #@fsmA.start # should trigger as well
-        @fsmA.init
-      end
-    end
-
-    fire = Fire.new
-    fire.operate
-
-    expect(callbacks).to match_array([
-      '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,54 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe FiniteMachine, perf: true do
-  include RSpec::Benchmark::Matchers
-
-  class Measurement
-    attr_reader :steps, :loops
-
-    def initialize
-      @steps = 0
-      @loops = 0
-    end
-
-    def inc_step
-      @steps += 1
-    end
-
-    def inc_loop
-      @loops += 1
-    end
-  end
-
-  it "correctly loops through events" do
-    measurement = Measurement.new
-
-    fsm = FiniteMachine.new(measurement) do
-      initial :green
-
-      event :next, :green => :yellow,
-                    :yellow => :red,
-                    :red => :green
-
-      on_enter do |event| target.inc_step; true end
-      on_enter :red do |event| target.inc_loop; true end
-    end
-
-    100.times { fsm.next }
-
-    expect(measurement.steps).to eq(100)
-    expect(measurement.loops).to eq(100 / 3)
-  end
-
-  it "performs at least 400 ips" do
-    fsm = FiniteMachine.new do
-      initial :green
-
-      event :next, :green => :yellow,
-                    :yellow => :red,
-                    :red => :green
-    end
-
-    expect { fsm.next }.to perform_at_least(400).ips
-  end
-end

data/spec/spec_helper.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-if ENV['COVERAGE'] || ENV['TRAVIS']
-  require 'simplecov'
-  require 'coveralls'
-
-  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new([
-    SimpleCov::Formatter::HTMLFormatter,
-    Coveralls::SimpleCov::Formatter
-  ])
-
-  SimpleCov.start do
-    command_name 'spec'
-    add_filter 'spec'
-  end
-end
-
-require 'finite_machine'
-require 'thwait'
-require 'rspec-benchmark'
-
-RSpec.configure do |config|
-  config.run_all_when_everything_filtered = true
-  config.filter_run :focus
-  config.raise_errors_for_deprecations!
-  config.mock_with :rspec do |mocks|
-    mocks.verify_partial_doubles = true
-  end
-  config.disable_monkey_patching!
-  if config.files_to_run.one?
-    config.default_formatter = 'doc'
-  end
-  config.order = :random
-end

data/spec/unit/alias_target_spec.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe FiniteMachine::Definition, '#alias_target' do
-
-  before do
-    stub_const("Car", Class.new do
-      def turn_reverse_lights_off
-        @reverse_lights = false
-      end
-
-      def turn_reverse_lights_on
-        @reverse_lights = true
-      end
-
-      def reverse_lights?
-        @reverse_lights ||= false
-      end
-    end)
-  end
-
-  it "aliases target" do
-    car = Car.new
-    fsm = FiniteMachine.new(car, alias_target: :delorean)
-
-    expect(fsm.target).to eq(car)
-    expect { fsm.car }.to raise_error(NoMethodError)
-    expect(fsm.delorean).to eq(car)
-  end
-
-  it "scopes the target alias to a state machine instance" do
-    delorean = Car.new
-    batmobile = Car.new
-    fsm_a = FiniteMachine.new(delorean, alias_target: :delorean)
-    fsm_b = FiniteMachine.new(batmobile, alias_target: :batmobile)
-
-    expect(fsm_a.delorean).to eq(delorean)
-    expect { fsm_a.batmobile }.to raise_error(NameError)
-
-    expect(fsm_b.batmobile).to eq(batmobile)
-    expect { fsm_b.delorean }.to raise_error(NameError)
-  end
-
-  context 'when inside definition' do
-    before do
-      stub_const("Engine", Class.new(FiniteMachine::Definition) do
-        initial :neutral
-
-        event :forward, [:reverse, :neutral] => :one
-        event :shift, :one => :two
-        event :shift, :two => :one
-        event :back,  [:neutral, :one] => :reverse
-
-        on_enter :reverse do |event|
-          car.turn_reverse_lights_on
-        end
-
-        on_exit :reverse do |event|
-          car.turn_reverse_lights_off
-        end
-
-        handle FiniteMachine::InvalidStateError do |exception| end
-      end)
-    end
-
-    it "creates unique instances" do
-      engine_a = Engine.new(alias_target: :car)
-      engine_b = Engine.new(alias_target: :car)
-      expect(engine_a).not_to be(engine_b)
-
-      engine_a.forward
-      expect(engine_a.current).to eq(:one)
-      expect(engine_b.current).to eq(:neutral)
-    end
-
-    it "allows to create standalone machine" do
-      car = Car.new
-      engine = Engine.new(car, alias_target: :car)
-      expect(engine.current).to eq(:neutral)
-
-      engine.forward
-      expect(engine.current).to eq(:one)
-      expect(car.reverse_lights?).to be false
-
-      engine.back
-      expect(engine.current).to eq(:reverse)
-      expect(car.reverse_lights?).to be true
-    end
-  end
-end