strict_machine 0.1.0

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.12.4

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in strict_machine.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Bruno Antunes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,39 @@
+# StrictMachine
+
+Easily add state-machine functionality to your Ruby classes.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'strict_machine'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install strict_machine
+
+## Usage
+
+Still working on this one...
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/strict_machine.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/setup"
+require "bundler/gem_tasks"
+
+Bundler::GemHelper.install_tasks
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:spec)
+task default: :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "strict_machine"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/ext/object.rb

@@ -0,0 +1,5 @@
+class Object
+  def metaclass
+    class << self; self; end
+  end
+end

data/lib/strict_machine/base.rb

@@ -0,0 +1,93 @@
+require_relative "mount_state_machine"
+require_relative "definition_context"
+
+module StrictMachine
+  class Base
+    attr_accessor :mounted_on, :state_attr
+
+    def self.strict_machine(&block)
+      dc = DefinitionContext.new
+      dc.instance_eval(&block)
+
+      metaclass.instance_eval do
+        define_method(:definition) { dc }
+      end
+    end
+
+    attr_writer :state_attr
+
+    def self.states
+      definition.states
+    end
+
+    def boot!
+      @state_attr = :status if @state_attr.nil?
+
+      change_state(self.class.states.first.name)
+    end
+
+    def current_state
+      instance_variable_get "@#{@state_attr}"
+    end
+
+    def definition
+      self.class.definition
+    end
+
+    def transition?(meth, state)
+      definition.transition?(meth, state)
+    end
+
+    def trigger_transition(trigger, stored = self)
+      dt = Time.now
+
+      is_bang = !trigger.to_s.index("!").nil?
+      transition = from_state.get_transition(trigger, is_bang)
+
+      if transition.guarded? && !is_bang
+        raise GuardedTransitionError unless stored.public_send(
+          transition.guard
+        )
+      end
+
+      new_state = definition.get_state_by_name(transition.to)
+      new_state.on_entry.each do |proc|
+        stored.instance_exec(current_state, trigger.to_sym, &proc)
+      end
+
+      duration = Time.now - dt
+
+      definition.transitions.each do |proc|
+        stored.instance_exec(
+          current_state, new_state.name, trigger.to_sym, duration, &proc
+        )
+      end
+
+      change_state(new_state.name)
+    end
+
+    ###
+
+    def respond_to?(meth, _include_private = false)
+      transition?(meth, current_state)
+    end
+
+    def method_missing(meth, *_args)
+      if transition?(meth, current_state)
+        trigger_transition(meth, mounted_on || self)
+      else
+        raise TransitionNotFoundError, meth
+      end
+    end
+
+    private
+
+    def from_state
+      definition.get_state_by_name(current_state)
+    end
+
+    def change_state(new_state, _is_initial = false)
+      instance_variable_set "@#{@state_attr}".to_sym, new_state
+    end
+  end
+end

data/lib/strict_machine/definition/state.rb

@@ -0,0 +1,33 @@
+require_relative "transition_definition"
+
+module StrictMachine
+  class State
+    attr_reader :name, :transition_definitions, :on_entry
+
+    def initialize(name)
+      @name = name.to_sym
+      @transition_definitions = []
+      @on_entry = []
+    end
+
+    def add_transition(transition_definition)
+      @transition_definitions << TransitionDefinition.new(
+        transition_definition
+      )
+    end
+
+    def get_transition(name, is_bang)
+      name = name [0..-2] if is_bang
+
+      @transition_definitions.each do |this_transition|
+        return this_transition if this_transition.name == name.to_sym
+      end
+
+      raise TransitionNotFoundError, name
+    end
+
+    def add_on_entry(proc)
+      @on_entry << proc
+    end
+  end
+end

data/lib/strict_machine/definition/transition_definition.rb

@@ -0,0 +1,20 @@
+module StrictMachine
+  class TransitionDefinition
+    attr_reader :name, :to, :guard
+
+    def initialize(definition)
+      definition.each_pair do |k, v|
+        if k == :if
+          @guard = v.to_sym
+        else
+          @name = k.to_sym
+          @to = v.to_sym
+        end
+      end
+    end
+
+    def guarded?
+      !@guard.nil?
+    end
+  end
+end

data/lib/strict_machine/definition_context.rb

@@ -0,0 +1,57 @@
+require_relative "definition/state"
+
+module StrictMachine
+  class DefinitionContext
+    attr_reader :states, :transitions
+    attr_accessor :mounted_on
+
+    def initialize
+      @states = []
+      @transitions = []
+    end
+
+    def transition?(name, state)
+      is_bang = (name[-1] == "!")
+      name = is_bang ? name[0..-2] : name
+
+      @states.each do |this_state|
+        next unless this_state.name.to_sym == state.to_sym
+
+        this_state.transition_definitions.each do |this_transition|
+          return true if this_transition.name == name.to_sym
+        end
+      end
+
+      false
+    end
+
+    def get_state_by_name(name)
+      @states.each do |this_state|
+        return this_state if this_state.name == name
+      end
+
+      raise StateNotFoundError, name
+    end
+
+    ###
+
+    def state(name, &block)
+      @states << State.new(name)
+      instance_eval(&block) if block_given?
+    end
+
+    def on(hash)
+      @states.last.add_transition hash
+    end
+
+    def on_entry(&block)
+      @states.last.add_on_entry(block)
+    end
+
+    def on_transition(&block)
+      @transitions << block
+    end
+
+    ###
+  end
+end

data/lib/strict_machine/mount_state_machine/class_methods.rb

@@ -0,0 +1,12 @@
+module StrictMachine
+  module MountStateMachine
+    module ClassMethods
+      def mount_state_machine(klass, options = {})
+        metaclass.instance_eval do
+          define_method(:strict_machine_class) { klass }
+          define_method(:strict_machine_options) { options }
+        end
+      end
+    end
+  end
+end

data/lib/strict_machine/mount_state_machine/initializer.rb

@@ -0,0 +1,18 @@
+module StrictMachine
+  module MountStateMachine
+    module Initializer
+      def initialize
+        @state_machine = self.class.strict_machine_class.new
+        @state_machine.mounted_on = self
+
+        options = self.class.strict_machine_options
+        state_attr = options.fetch(:state, :status)
+        @state_machine.state_attr = state_attr
+
+        @state_machine.boot!
+
+        super
+      end
+    end
+  end
+end

data/lib/strict_machine/mount_state_machine.rb

@@ -0,0 +1,33 @@
+require_relative "mount_state_machine/initializer"
+require_relative "mount_state_machine/class_methods"
+
+module StrictMachine
+  module MountStateMachine
+    def self.included(base)
+      base.extend ClassMethods
+      base.public_send :prepend, Initializer
+    end
+
+    def current_state
+      @state_machine.current_state
+    end
+
+    def state_attr
+      @state_machine.state_attr
+    end
+
+    ###
+
+    def method_missing(meth, *args, &block)
+      if @state_machine.transition?(meth, current_state)
+        @state_machine.trigger_transition(meth, self)
+      else
+        super
+      end
+    end
+
+    def respond_to?(meth, _include_private = false)
+      @state_machine.transition?(meth, current_state)
+    end
+  end
+end

data/lib/strict_machine.rb

@@ -0,0 +1,14 @@
+require_relative "ext/object"
+
+module StrictMachine
+  VERSION = "0.1.0".freeze
+
+  class << self; attr_accessor :list; end
+end
+
+class StateNotFoundError < StandardError; end
+class InvalidTransitionError < StandardError; end
+class TransitionNotFoundError < StandardError; end
+class GuardedTransitionError < StandardError; end
+
+require_relative "strict_machine/base"

data/spec/dsl_spec.rb

@@ -0,0 +1,155 @@
+require "spec_helper"
+include StrictMachine
+
+describe DefinitionContext do
+  describe '#state' do
+    it "adds a new state to the definition" do
+      klass = Class.new(StrictMachine::Base) do
+        strict_machine do
+          state :initial
+        end
+      end
+
+      expect(klass.states.size).to eq(1)
+      expect(klass.states.first.name).to eq(:initial)
+    end
+  end
+
+  describe '#on' do
+    it "triggers a state change" do
+      klass = Class.new(StrictMachine::Base) do
+        strict_machine do
+          state :initial do
+            on hop: :done
+          end
+          state :done
+        end
+      end
+
+      machine = klass.new
+      machine.boot!
+      expect(machine.current_state).to eq(:initial)
+      machine.hop
+      expect(machine.current_state).to eq(:done)
+    end
+
+    it "honors guard statements" do
+      klass = Class.new(StrictMachine::Base) do
+        strict_machine do
+          state :initial do
+            on hop: :done, if: :guarded?
+          end
+          state :done
+        end
+
+        def guarded?
+          false
+        end
+      end
+
+      machine = klass.new
+      machine.boot!
+      expect(machine.current_state).to eq(:initial)
+      expect { machine.hop }.to raise_error(GuardedTransitionError)
+    end
+
+    it "bypasses guard statements with a bang" do
+      klass = Class.new(StrictMachine::Base) do
+        strict_machine do
+          state :initial do
+            on hop: :done, if: :guarded?
+          end
+          state :done
+        end
+
+        def guarded?
+          false
+        end
+      end
+
+      machine = klass.new
+      machine.boot!
+      machine.hop!
+      expect(machine.current_state).to eql(:done)
+    end
+
+    it "raises error on invalid state transitions" do
+      klass = Class.new(StrictMachine::Base) do
+        strict_machine do
+          state :initial do
+            on hop: :dinn
+          end
+        end
+      end
+
+      machine = klass.new
+      machine.boot!
+      expect { machine.hop }.to raise_error(StateNotFoundError)
+      expect { machine.zing }.to raise_error(TransitionNotFoundError)
+    end
+  end
+
+  describe '#on_entry' do
+    it "gets called upon entering a state" do
+      klass = Class.new(StrictMachine::Base) do
+        strict_machine do
+          state :initial do
+            on hop: :done
+          end
+          state :done do
+            on_entry do |previous, trigger|
+              log(previous, trigger)
+            end
+            on_entry do |previous, trigger|
+              log2(previous, trigger)
+            end
+          end
+        end
+
+        def log(_, _); end
+
+        def log2(_, _); end
+      end
+
+      machine = klass.new
+      expect_any_instance_of(klass).to receive(:log).with(:initial, :hop)
+      expect_any_instance_of(klass).to receive(:log2).with(:initial, :hop)
+
+      machine.boot!
+      machine.hop
+    end
+  end
+
+  describe '#on_transition' do
+    it "gets called upon entering any state" do
+      klass = Class.new(StrictMachine::Base) do
+        strict_machine do
+          state :initial do
+            on hop: :middle
+          end
+          state :middle do
+            on hop: :final
+          end
+          state :final
+          on_transition do |from, to, trigger_event, duration|
+            log from, to, trigger_event, duration
+          end
+        end
+
+        def log(_, _, _, _); end
+      end
+
+      machine = klass.new
+      expect_any_instance_of(klass).to receive(:log).with(
+        :initial, :middle, :hop, any_args
+      )
+      expect_any_instance_of(klass).to receive(:log).with(
+        :middle, :final, :hop, any_args
+      )
+
+      machine.boot!
+      machine.hop
+      machine.hop
+    end
+  end
+end

data/spec/dummy/dummy.rb

@@ -0,0 +1,19 @@
+class Dummy
+  include StrictMachine::MountStateMachine
+
+  mount_state_machine DummyStateMachine, state: "meh"
+
+  def cool_article?
+    true
+  end
+
+  def bad_article?
+    false
+  end
+
+  def log(_, _, _, _); end
+
+  def log2(_, _); end
+
+  def send_reports; end
+end

data/spec/dummy/dummy_state_machine.rb

@@ -0,0 +1,24 @@
+class DummyStateMachine < StrictMachine::Base
+  strict_machine do
+    state :new do
+      on submit: :awaiting_review
+    end
+
+    state :awaiting_review do
+      on review: :under_review
+    end
+
+    state :under_review do
+      on_entry { |previous, trigger| log2(previous, trigger) }
+      on accept: :accepted, if: :cool_article?
+      on reject: :rejected, if: :bad_article?
+    end
+
+    state :accepted
+    state :rejected
+
+    on_transition do |from, to, trigger_event, duration|
+      log from, to, trigger_event, duration
+    end
+  end
+end

data/spec/mountable_machine_spec.rb

@@ -0,0 +1,47 @@
+require "spec_helper"
+
+describe "mounted StrictMachine" do
+  context "state shifting" do
+    require_relative "dummy/dummy_state_machine"
+    require_relative "dummy/dummy"
+
+    let!(:dummy) { Dummy.new }
+
+    it "has an initial state" do
+      expect(dummy.current_state).to eq(:new)
+    end
+
+    it "shifts state" do
+      dummy.submit
+
+      expect(dummy.current_state).to eq(:awaiting_review)
+    end
+
+    it "honors guard statements" do
+      dummy.submit
+      dummy.review
+
+      expect { dummy.reject }.to raise_error(GuardedTransitionError)
+
+      expect(dummy.current_state).to eq(:under_review)
+    end
+
+    it "bypasses guard statements with bangs" do
+      dummy.submit
+      dummy.review
+      dummy.reject!
+
+      expect(dummy.current_state).to eq(:rejected)
+    end
+
+    it "calls on_transition blocks" do
+      expect(dummy).to receive(:log)
+
+      dummy.submit
+    end
+
+    it "sets state to the given status option name" do
+      expect(dummy.state_attr).to eq("meh")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require "bundler/setup"
+require "byebug"
+
+require "strict_machine"
+
+Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  config.include RSpec::Matchers
+  config.mock_with :rspec
+  config.order = "random"
+end