strict_machine 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 40ddaf714e2bcffb68253ea0ff08ad7d2cc8c934
-  data.tar.gz: 0e52b5f8b5ae003d24d16ff52c17e737aa7660e2
+  metadata.gz: cd8176055fcd833b0c5e292f89d251ef32067687
+  data.tar.gz: 8c5526e2c67353ce0bb71d52713584219a901d1c
 SHA512:
-  metadata.gz: 23b6365e23c11af49c22639e9a695267301c4097e8876c9a3f040e0c7a5d8d012082d16a4c940431b06e78f33e0cd6df6d85995b534504588d955518df21a25d
-  data.tar.gz: d1577855922f10beeededcd1127a17176e1472be72afa1caf1cdc07ab3a76f2557834a8b92f55323a5504e921f6d94d7f43490978145103a9fa9e85129943a3c
+  metadata.gz: e364a995db6ffbde2984893fdc5f2e0b7d2dccf67b85514904aba17a5e66b86db90d958eb1e8e475e85b63589f70ecdcd7cb7cba6f800fb930073c0e7b043257
+  data.tar.gz: 0c2f0375d4df894541648ca6ddd7e2ebc7a14ca90edf6ed867c91a63b8effe15d914aece8e9496d6f9c964b10541bd9fb3853e145d717655272516eabfcb29ff

data/NOTES.md

@@ -0,0 +1,10 @@
+Object fingerprint
+------------------
+
+- `#state`
+- `#trigger(*transitions)`
+- `#state_attr`
+
+TODO:
+
+- `#can_trigger?(transition)`

data/lib/strict_machine.rb

@@ -1,7 +1,7 @@
 require_relative "ext/object"
 
 module StrictMachine
-  VERSION = "0.1.4".freeze
+  VERSION = "0.2.0".freeze
 
   class << self; attr_accessor :list; end
 end
@@ -11,4 +11,5 @@ class InvalidTransitionError < StandardError; end
 class TransitionNotFoundError < StandardError; end
 class GuardedTransitionError < StandardError; end
 
+require_relative "strict_machine/mount_state_machine"
 require_relative "strict_machine/base"

data/lib/strict_machine/base.rb

@@ -1,93 +1,20 @@
-require_relative "mount_state_machine"
 require_relative "definition_context"
 
 module StrictMachine
   class Base
-    attr_accessor :mounted_on, :state_attr
+    include MountStateMachine::InstanceMethods
 
-    def self.strict_machine(&block)
+    def self.strict_machine(state_attr = "state", &block)
       dc = DefinitionContext.new
       dc.instance_eval(&block)
 
+      stored = self
+
       metaclass.instance_eval do
         define_method(:definition) { dc }
+        define_method(:strict_machine_class) { stored }
+        define_method(:strict_machine_attr) { "@#{state_attr}".to_sym }
       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

@@ -16,11 +16,13 @@ module StrictMachine
       )
     end
 
-    def get_transition(name, is_bang)
-      name = name [0..-2] if is_bang
+    def get_transition(name)
+      name = name.to_s
+      is_bang = name.end_with?("!")
+      name = name[0..-2] if is_bang
 
       @transition_definitions.each do |this_transition|
-        return this_transition if this_transition.name == name.to_sym
+        return is_bang, this_transition if this_transition.name == name.to_sym
       end
 
       raise TransitionNotFoundError, name

data/lib/strict_machine/definition_context.rb

@@ -3,28 +3,12 @@ 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
@@ -33,7 +17,11 @@ module StrictMachine
       raise StateNotFoundError, name
     end
 
-    ###
+    def initial_state_name
+      @states.first.name
+    end
+
+    ### DSL
 
     def state(name, &block)
       @states << State.new(name)

data/lib/strict_machine/mount_state_machine.rb

@@ -1,33 +1,11 @@
-require_relative "mount_state_machine/initializer"
+require_relative "mount_state_machine/instance_methods"
 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 && @state_machine.transition?(meth, current_state)
+      base.include InstanceMethods
     end
   end
 end

data/lib/strict_machine/mount_state_machine/class_methods.rb

@@ -2,9 +2,11 @@ module StrictMachine
   module MountStateMachine
     module ClassMethods
       def mount_state_machine(klass, options = {})
+        state_attr = options.fetch(:state, :state)
+
         metaclass.instance_eval do
           define_method(:strict_machine_class) { klass }
-          define_method(:strict_machine_options) { options }
+          define_method(:strict_machine_attr) { "@#{state_attr}".to_sym }
         end
       end
     end

data/lib/strict_machine/mount_state_machine/instance_methods.rb

@@ -0,0 +1,74 @@
+module StrictMachine
+  module MountStateMachine
+    module InstanceMethods
+      def trigger(*transitions)
+        transitions.map {|t| change_state(t, state) }
+
+        true
+      end
+
+      def state
+        write_initial_state if current_state_attr_value.nil?
+
+        current_state_attr_value
+      end
+
+      def state_attr
+        self.class.strict_machine_attr.to_s.gsub("@",'')
+      end
+
+      def states
+        definition.states
+      end
+
+      private
+
+      def current_state_attr_value
+        instance_variable_get state_machine_attr_name
+      end
+
+      def write_initial_state
+        write_state(definition.initial_state_name)
+      end
+
+      def write_state(value)
+        instance_variable_set state_machine_attr_name, value
+      end
+
+      def state_machine_attr_name
+        self.class.strict_machine_attr
+      end
+
+      def definition
+        self.class.strict_machine_class.definition
+      end
+
+      def change_state(trigger, current_state_name)
+        dt = Time.now
+        current_state = definition.get_state_by_name(current_state_name)
+        is_bang, transition = current_state.get_transition(trigger)
+
+        if transition.guarded? && !is_bang
+          raise GuardedTransitionError unless self.public_send(
+            transition.guard
+          )
+        end
+
+        new_state = definition.get_state_by_name(transition.to)
+        new_state.on_entry.each do |proc|
+          self.instance_exec(current_state_name, trigger.to_sym, &proc)
+        end
+
+        duration = Time.now - dt
+
+        definition.transitions.each do |proc|
+          self.instance_exec(
+            current_state_name, new_state.name, trigger.to_sym, duration, &proc
+          )
+        end
+
+        write_state(new_state.name)
+      end
+    end
+  end
+end

data/spec/dsl_spec.rb

@@ -10,8 +10,9 @@ describe DefinitionContext do
         end
       end
 
-      expect(klass.states.size).to eq(1)
-      expect(klass.states.first.name).to eq(:initial)
+      machine = klass.new
+      expect(machine.states.size).to eq(1)
+      expect(machine.states.first.name).to eq(:initial)
     end
   end
 
@@ -27,10 +28,9 @@ describe DefinitionContext do
       end
 
       machine = klass.new
-      machine.boot!
-      expect(machine.current_state).to eq(:initial)
-      machine.hop
-      expect(machine.current_state).to eq(:done)
+      expect(machine.state).to eq(:initial)
+      machine.trigger(:hop)
+      expect(machine.state).to eq(:done)
     end
 
     it "honors guard statements" do
@@ -48,9 +48,8 @@ describe DefinitionContext do
       end
 
       machine = klass.new
-      machine.boot!
-      expect(machine.current_state).to eq(:initial)
-      expect { machine.hop }.to raise_error(GuardedTransitionError)
+      expect(machine.state).to eq(:initial)
+      expect { machine.trigger(:hop) }.to raise_error(GuardedTransitionError)
     end
 
     it "bypasses guard statements with a bang" do
@@ -68,9 +67,8 @@ describe DefinitionContext do
       end
 
       machine = klass.new
-      machine.boot!
-      machine.hop!
-      expect(machine.current_state).to eql(:done)
+      machine.trigger(:hop!)
+      expect(machine.state).to eql(:done)
     end
 
     it "raises error on invalid state transitions" do
@@ -83,9 +81,8 @@ describe DefinitionContext do
       end
 
       machine = klass.new
-      machine.boot!
-      expect { machine.hop }.to raise_error(StateNotFoundError)
-      expect { machine.zing }.to raise_error(TransitionNotFoundError)
+      expect { machine.trigger(:hop) }.to raise_error(StateNotFoundError)
+      expect { machine.trigger(:zing) }.to raise_error(TransitionNotFoundError)
     end
   end
 
@@ -115,8 +112,7 @@ describe DefinitionContext do
       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
+      machine.trigger(:hop)
     end
   end
 
@@ -147,9 +143,18 @@ describe DefinitionContext do
         :middle, :final, :hop, any_args
       )
 
-      machine.boot!
-      machine.hop
-      machine.hop
+      machine.trigger(:hop, :hop)
+    end
+  end
+
+  it "sets state to the given status option name" do
+    klass = Class.new(StrictMachine::Base) do
+      strict_machine("meh") do
+        state :initial
+      end
     end
+
+    machine = klass.new
+    expect(machine.state_attr).to eq("meh")
   end
 end

data/spec/dummy/dummy.rb

@@ -1,3 +1,5 @@
+require_relative "dummy_state_machine"
+
 class Dummy
   include StrictMachine::MountStateMachine
 

data/spec/mountable_machine_spec.rb

@@ -2,46 +2,43 @@ 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(2) }
 
-    it "preserves passed arguments to initializer" do
-      expect(dummy.a).to eq(2)
+    it "enumerates states" do
+      expect(dummy.states.size).to eq(5)
+      expect(dummy.states.first.name).to eq(:new)
     end
 
     it "has an initial state" do
-      expect(dummy.current_state).to eq(:new)
+      expect(dummy.state).to eq(:new)
     end
 
     it "shifts state" do
-      dummy.submit
+      dummy.trigger(:submit)
 
-      expect(dummy.current_state).to eq(:awaiting_review)
+      expect(dummy.state).to eq(:awaiting_review)
     end
 
     it "honors guard statements" do
-      dummy.submit
-      dummy.review
+      dummy.trigger(:submit, :review)
 
-      expect { dummy.reject }.to raise_error(GuardedTransitionError)
+      expect { dummy.trigger(:reject) }.to raise_error(GuardedTransitionError)
 
-      expect(dummy.current_state).to eq(:under_review)
+      expect(dummy.state).to eq(:under_review)
     end
 
     it "bypasses guard statements with bangs" do
-      dummy.submit
-      dummy.review
-      dummy.reject!
+      dummy.trigger(:submit, :review, :reject!)
 
-      expect(dummy.current_state).to eq(:rejected)
+      expect(dummy.state).to eq(:rejected)
     end
 
     it "calls on_transition blocks" do
       expect(dummy).to receive(:log)
 
-      dummy.submit
+      dummy.trigger(:submit)
     end
 
     it "sets state to the given status option name" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: strict_machine
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Bruno Antunes
@@ -81,6 +81,7 @@ files:
 - ".travis.yml"
 - Gemfile
 - LICENSE.txt
+- NOTES.md
 - README.md
 - Rakefile
 - bin/console
@@ -93,7 +94,7 @@ files:
 - lib/strict_machine/definition_context.rb
 - lib/strict_machine/mount_state_machine.rb
 - lib/strict_machine/mount_state_machine/class_methods.rb
-- lib/strict_machine/mount_state_machine/initializer.rb
+- lib/strict_machine/mount_state_machine/instance_methods.rb
 - spec/dsl_spec.rb
 - spec/dummy/dummy.rb
 - spec/dummy/dummy_state_machine.rb
@@ -126,7 +127,7 @@ specification_version: 4
 summary: State machine functionality for Ruby classes
 test_files:
 - spec/dsl_spec.rb
-- spec/dummy/dummy.rb
-- spec/dummy/dummy_state_machine.rb
 - spec/mountable_machine_spec.rb
 - spec/spec_helper.rb
+- spec/dummy/dummy.rb
+- spec/dummy/dummy_state_machine.rb

data/lib/strict_machine/mount_state_machine/initializer.rb

@@ -1,20 +0,0 @@
-module StrictMachine
-  module MountStateMachine
-    module Initializer
-      def initialize(*args)
-        if self.class.respond_to?(:strict_machine_class)
-          @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!
-        end
-
-        super
-      end
-    end
-  end
-end