state_machine_rspec 0.1.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.rvmrc

@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+
+# This is an RVM Project .rvmrc file, used to automatically load the ruby
+# development environment upon cd'ing into the directory
+
+# First we specify our desired <ruby>[@<gemset>], the @gemset name is optional,
+# Only full ruby name is supported here, for short names use:
+#     echo "rvm use 1.9.3" > .rvmrc
+environment_id="ruby-1.9.3-p392@state_machine_rspec"
+
+# Uncomment the following lines if you want to verify rvm version per project
+# rvmrc_rvm_version="1.15.5 ()" # 1.10.1 seams as a safe start
+# eval "$(echo ${rvm_version}.${rvmrc_rvm_version} | awk -F. '{print "[[ "$1*65536+$2*256+$3" -ge "$4*65536+$5*256+$6" ]]"}' )" || {
+#   echo "This .rvmrc file requires at least RVM ${rvmrc_rvm_version}, aborting loading."
+#   return 1
+# }
+
+# First we attempt to load the desired environment directly from the environment
+# file. This is very fast and efficient compared to running through the entire
+# CLI and selector. If you want feedback on which environment was used then
+# insert the word 'use' after --create as this triggers verbose mode.
+if [[ -d "${rvm_path:-$HOME/.rvm}/environments"
+  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
+then
+  \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
+  [[ -s "${rvm_path:-$HOME/.rvm}/hooks/after_use" ]] &&
+    \. "${rvm_path:-$HOME/.rvm}/hooks/after_use" || true
+  if [[ $- == *i* ]] # check for interactive shells
+  then echo "Using: $(tput setaf 2)$GEM_HOME$(tput sgr0)" # show the user the ruby and gemset they are using in green
+  else echo "Using: $GEM_HOME" # don't use colors in non-interactive shells
+  fi
+else
+  # If the environment file has not yet been created, use the RVM CLI to select.
+  rvm --create use  "$environment_id" || {
+    echo "Failed to create RVM environment '${environment_id}'."
+    return 1
+  }
+fi
+
+# If you use bundler, this might be useful to you:
+# if [[ -s Gemfile ]] && {
+#   ! builtin command -v bundle >/dev/null ||
+#   builtin command -v bundle | GREP_OPTIONS= \grep $rvm_path/bin/bundle >/dev/null
+# }
+# then
+#   printf "%b" "The rubygem 'bundler' is not installed. Installing it now.\n"
+#   gem install bundler
+# fi
+# if [[ -s Gemfile ]] && builtin command -v bundle >/dev/null
+# then
+#   bundle install | GREP_OPTIONS= \grep -vE '^Using|Your bundle is complete'
+# fi

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in state_machine_rspec.gemspec
+gemspec
+
+group :development do
+  gem 'pry'
+end

data/Guardfile

@@ -0,0 +1,6 @@
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 modocache
+
+MIT License
+
+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,56 @@
+# state_machine_rspec
+
+Custom matchers for [pluginaweek/state_machine](https://github.com/pluginaweek/state_machine).
+
+
+## Matchers
+
+### `have_state` & `reject_state`
+
+```ruby
+describe Vehicle do
+  it { should have_states :parked, :idling, :stalled, :first_gear,
+                          :second_gear, :third_gear }
+  it { should reject_state :flying }
+
+  it { should have_states :active, :off, on: :alarm_state }
+  it { should have_state :active, on: :alarm_state, value: 1 }
+  it { should reject_states :broken, :ringing, on: :alarm_state }
+end
+```
+
+### `handle_event` & `reject_event`
+
+```ruby
+describe Vehicle do
+  it { should handle_events :shift_down, :crash, when: :third_gear }
+  it { should reject_events :park, :ignite, :idle, :shift_up, :repair,
+                            when: :third_gear }
+end
+```
+
+
+## Installation
+
+Add these lines to your application's Gemfile:
+
+    group :test do
+      gem 'state_machine_rspec'
+    end
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install state_machine_rspec
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default  => :spec

data/lib/matchers/events/handle_event.rb

@@ -0,0 +1,29 @@
+require 'matchers/events/matcher'
+
+module StateMachineRspec
+  module Matchers
+    def handle_events(value, *values)
+      HandleEventMatcher.new(values.unshift(value))
+    end
+    alias_method :handle_event, :handle_events
+
+    class HandleEventMatcher < StateMachineRspec::Matchers::Events::Matcher
+      def matches_events?(events)
+        !invalid_events?
+      end
+
+      private
+
+      def invalid_events?
+        invalid_events = @introspector.invalid_events(@events)
+        unless invalid_events.empty?
+          @failure_message = "Expected to be able to handle events: " +
+                              "#{invalid_events.join(', ')} in state: " +
+                              "#{@introspector.current_state_value}"
+        end
+
+        !invalid_events.empty?
+      end
+    end
+  end
+end

data/lib/matchers/events/matcher.rb

@@ -0,0 +1,55 @@
+require 'active_support/core_ext/array/extract_options'
+
+module StateMachineRspec
+  module Matchers
+    module Events
+      class Matcher
+        attr_reader :failure_message
+
+        def initialize(events)
+          @options = events.extract_options!
+          @events = events
+        end
+
+        def matches?(subject)
+          @subject = subject
+          @introspector = StateMachineIntrospector.new(@subject,
+                                                       @options.fetch(:state, nil))
+          enter_when_state
+          return false if undefined_events?
+          return false unless matches_events?(@events)
+          @failure_message.nil?
+        end
+
+        def matches_events?(events)
+          raise NotImplementedError,
+            "subclasses of #{self.class} must override matches_events?"
+        end
+
+        private
+
+        def enter_when_state
+          if state_name = @options.fetch(:when, nil)
+            unless when_state = @introspector.state(state_name)
+              raise StateMachineIntrospectorError,
+                "#{@subject.class} does not define state: #{state_name}"
+            end
+
+            @subject.send("#{@introspector.state_machine_attribute}=",
+                          when_state.value)
+          end
+        end
+
+        def undefined_events?
+          undefined_events = @introspector.undefined_events(@events)
+          unless undefined_events.empty?
+            @failure_message = "state_machine: #{@introspector.state_machine_attribute} " +
+                               "does not define events: #{undefined_events.join(', ')}"
+          end
+
+          !undefined_events.empty?
+        end
+      end
+    end
+  end
+end

data/lib/matchers/events/reject_event.rb

@@ -0,0 +1,29 @@
+require 'matchers/events/matcher'
+
+module StateMachineRspec
+  module Matchers
+    def reject_events(value, *values)
+      RejectEventMatcher.new(values.unshift(value))
+    end
+    alias_method :reject_event, :reject_events
+
+    class RejectEventMatcher < StateMachineRspec::Matchers::Events::Matcher
+      def matches_events?(events)
+        !valid_events?
+      end
+
+      private
+
+      def valid_events?
+        valid_events = @introspector.valid_events(@events)
+        unless valid_events.empty?
+          @failure_message = "Did not expect to be able to handle events: " +
+                              "#{valid_events.join(', ')} in state: " +
+                              "#{@introspector.current_state_value}"
+        end
+
+        !valid_events.empty?
+      end
+    end
+  end
+end

data/lib/matchers/states/have_state.rb

@@ -0,0 +1,40 @@
+require 'matchers/states/matcher'
+
+module StateMachineRspec
+  module Matchers
+    def have_states(state, *states)
+      HaveStateMatcher.new(states.unshift(state))
+    end
+    alias_method :have_state, :have_states
+
+    class HaveStateMatcher < StateMachineRspec::Matchers::States::Matcher
+      def matches_states?(states)
+        return false if undefined_states?
+        return false if incorrect_value?
+        @failure_message.nil?
+      end
+
+      private
+
+      def undefined_states?
+        undefined_states = @introspector.undefined_states(@states)
+        unless undefined_states.empty?
+          @failure_message = "Expected #{@introspector.state_machine_attribute} " +
+                             "to allow states: #{undefined_states.join(', ')}"
+        end
+
+        !undefined_states.empty?
+      end
+
+      def incorrect_value?
+        state_value = @options.fetch(:value, nil)
+        if state_value && @introspector.state(@states.first).value != state_value
+          @failure_message = "Expected #{@states.first} to have value #{state_value}"
+          true
+        end
+
+        false
+      end
+    end
+  end
+end

data/lib/matchers/states/matcher.rb

@@ -0,0 +1,42 @@
+require 'active_support/core_ext/array/extract_options'
+
+module StateMachineRspec
+  module Matchers
+    module States
+      class Matcher
+        attr_reader :failure_message
+
+        def initialize(states)
+          @options = states.extract_options!
+          @states = states
+        end
+
+        def matches?(subject)
+          raise_if_multiple_values
+
+          @subject = subject
+          @introspector = StateMachineIntrospector.new(@subject,
+                                                       @options.fetch(:on, nil))
+
+          return false unless matches_states?(@states)
+          @failure_message.nil?
+        end
+
+        def matches_states?(states)
+          raise NotImplementedError,
+            "subclasses of #{self.class} must override matches_states?"
+        end
+
+        private
+
+        def raise_if_multiple_values
+          if @states.count > 1 && @options.fetch(:value, nil)
+            raise ArgumentError, 'cannot make value assertions on ' +
+                                 'multiple states at once'
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/matchers/states/reject_state.rb

@@ -0,0 +1,28 @@
+require 'matchers/states/matcher'
+
+module StateMachineRspec
+  module Matchers
+    def reject_states(state, *states)
+      RejectStateMatcher.new(states.unshift(state))
+    end
+    alias_method :reject_state, :reject_states
+
+    class RejectStateMatcher < StateMachineRspec::Matchers::States::Matcher
+      def matches_states?(states)
+        no_defined_states?
+      end
+
+      private
+
+      def no_defined_states?
+        defined_states = @introspector.defined_states(@states)
+        unless defined_states.empty?
+          @failure_message = "Did not expect #{@introspector.state_machine_attribute} " +
+                             "to allow states: #{defined_states.join(', ')}"
+        end
+
+        defined_states.empty?
+      end
+    end
+  end
+end

data/lib/state_machine_rspec/state_machine_introspector.rb

@@ -0,0 +1,70 @@
+class StateMachineIntrospector
+  def initialize(subject, state_machine_name=nil)
+    @subject = subject
+    @state_machine_name = state_machine_name
+  end
+
+  def state_machine_attribute
+    state_machine.attribute
+  end
+
+  def current_state_value
+    @subject.send(state_machine_attribute)
+  end
+
+  def state(name)
+    state = state_machine.states.find { |s| s.name == name }
+  end
+
+  def undefined_states(states)
+    states.reject { |s| state_defined? s }
+  end
+
+  def defined_states(states)
+    states.keep_if { |s| state_defined? s }
+  end
+
+  def undefined_events(events)
+    events.reject { |e| event_defined? e }
+  end
+
+  def valid_events(events)
+    events.keep_if { |e| valid_event? e }
+  end
+
+  def invalid_events(events)
+    events.reject { |e| valid_event? e }
+  end
+
+  private
+
+  def state_machine
+    if @state_machine_name
+      unless machine = @subject.class.state_machines[@state_machine_name]
+        raise StateMachineIntrospectorError,
+          "#{@subject.class} does not have a state machine defined " +
+          "on #{@state_machine_name}"
+      end
+    else
+      machine = @subject.class.state_machine
+    end
+
+    machine
+  end
+
+  def state_defined?(state_name)
+    state(state_name)
+  end
+
+  def event_defined?(event)
+    @subject.respond_to? "can_#{event}?"
+  end
+
+  def valid_event?(event)
+    @subject.send("can_#{event}?")
+  end
+
+end
+
+class StateMachineIntrospectorError < StandardError
+end

data/lib/state_machine_rspec/version.rb

@@ -0,0 +1,3 @@
+module StateMachineRspec
+  VERSION = '0.1.0'
+end

data/lib/state_machine_rspec.rb

@@ -0,0 +1,11 @@
+require 'state_machine_rspec/version'
+require 'state_machine_rspec/state_machine_introspector'
+require 'matchers/events/handle_event'
+require 'matchers/events/reject_event'
+require 'matchers/states/have_state'
+require 'matchers/states/reject_state'
+
+module StateMachineRspec
+  module Matchers
+  end
+end