transitions 0.2.0 → 0.2.1

data/test/active_record/test_active_record.rb

@@ -1,8 +1,8 @@
-require "helper"
+require 'helper'
 
 class CreateTrafficLights < ActiveRecord::Migration
   def self.up
-    create_table(:traffic_lights, :force => true) do |t|
+    create_table(:traffic_lights, force: true) do |t|
       t.string :state
       t.string :name
       t.string :power
@@ -22,7 +22,7 @@ end
 class TrafficLight < ActiveRecord::Base
   include ActiveModel::Transitions
 
-  state_machine :auto_scopes => true do
+  state_machine auto_scopes: true do
     state :off, enter: :turn_power_on
 
     state :red
@@ -30,34 +30,34 @@ class TrafficLight < ActiveRecord::Base
     state :yellow
 
     event :red_on do
-      transitions :to => :red, :from => [:yellow]
+      transitions to: :red, from: [:yellow]
     end
 
     event :green_on do
-      transitions :to => :green, :from => [:red]
+      transitions to: :green, from: [:red]
     end
 
     event :yellow_on do
-      transitions :to => :yellow, :from => [:green]
+      transitions to: :yellow, from: [:green]
     end
 
     event :reset do
-      transitions :to => :red, :from => [:off]
+      transitions to: :red, from: [:off]
     end
   end
 
   def turn_power_on
-    raise "the power should not have been on already" if power == "on"
-    self.power = "on"
+    fail 'the power should not have been on already' if power == 'on'
+    self.power = 'on'
   end
 end
 
 class ValidatingTrafficLight < TrafficLight
-  validate {|t| errors.add(:base, 'This TrafficLight will never validate after creation') unless t.new_record? }
+  validate { |t| errors.add(:base, 'This TrafficLight will never validate after creation') unless t.new_record? }
 end
 
 class ConditionalValidatingTrafficLight < TrafficLight
-  validates(:name, :presence => true, :if => :red?)
+  validates(:name, presence: true, if: :red?)
 end
 
 class TestActiveRecord < Test::Unit::TestCase
@@ -66,31 +66,31 @@ class TestActiveRecord < Test::Unit::TestCase
     @light = TrafficLight.create!
   end
 
-  test "new record has the initial state set" do
+  test 'new record has the initial state set' do
     @light = TrafficLight.new
-    assert_equal "off", @light.state
+    assert_equal 'off', @light.state
   end
 
-  test "new active records defaults current state to the initial state" do
+  test 'new active records defaults current state to the initial state' do
     assert_equal :off, @light.current_state
   end
 
-  test "states initial state" do
+  test 'states initial state' do
     assert @light.off?
     assert_equal :off, @light.current_state
   end
 
-  test "calls enter when setting the initial state" do
+  test 'calls enter when setting the initial state' do
     @new_light = TrafficLight.new
-    assert_equal "on", @new_light.power
+    assert_equal 'on', @new_light.power
   end
 
-  test "does not call enter when loading a persisted record" do
-    assert_equal "on", @light.power
+  test 'does not call enter when loading a persisted record' do
+    assert_equal 'on', @light.power
     assert_nothing_raised { TrafficLight.find(@light.id) }
   end
 
-  test "transition to a valid state" do
+  test 'transition to a valid state' do
     @light.reset
     assert @light.red?
     assert_equal :red, @light.current_state
@@ -100,42 +100,42 @@ class TestActiveRecord < Test::Unit::TestCase
     assert_equal :green, @light.current_state
   end
 
-  test "transition does not persist state" do
+  test 'transition does not persist state' do
     @light.reset
     assert_equal :red, @light.current_state
     @light.reload
-    assert_equal "off", @light.state
+    assert_equal 'off', @light.state
   end
 
-  test "transition does persists state" do
+  test 'transition does persists state' do
     @light.reset!
     assert_equal :red, @light.current_state
     @light.reload
-    assert_equal "red", @light.state
+    assert_equal 'red', @light.state
   end
 
-  test "transition to an invalid state" do
+  test 'transition to an invalid state' do
     assert_raise(Transitions::InvalidTransition) { @light.yellow_on }
     assert_equal :off, @light.current_state
   end
 
-  test "transition with wrong state will not validate" do
+  test 'transition with wrong state will not validate' do
     for s in @light.class.get_state_machine.states
       @light.state = s.name
       assert @light.valid?
     end
-    @light.state = "invalid_one"
+    @light.state = 'invalid_one'
     assert_false @light.valid?
   end
 
-  test "transition raises exception when model validation fails" do
-    validating_light = ValidatingTrafficLight.create!(:name => 'Foobar')
+  test 'transition raises exception when model validation fails' do
+    validating_light = ValidatingTrafficLight.create!(name: 'Foobar')
     assert_raise(ActiveRecord::RecordInvalid) do
       validating_light.reset!
     end
   end
 
-  test "state query method used in a validation condition" do
+  test 'state query method used in a validation condition' do
     validating_light = ConditionalValidatingTrafficLight.create!
     assert_raise(ActiveRecord::RecordInvalid) do
       validating_light.reset!
@@ -143,19 +143,19 @@ class TestActiveRecord < Test::Unit::TestCase
     assert(validating_light.off?)
   end
 
-  test "reloading model resets current state" do
+  test 'reloading model resets current state' do
     @light.reset
     assert @light.red?
     @light.update_attribute(:state, 'green')
-    assert @light.reload.green?, "reloaded state should come from database, not instance variable"
+    assert @light.reload.green?, 'reloaded state should come from database, not instance variable'
   end
 
-  test "calling non-bang event updates state attribute" do
+  test 'calling non-bang event updates state attribute' do
     @light.reset!
     assert @light.red?
     @light.green_on
-    assert_equal "green", @light.state
-    assert_equal "red", @light.reload.state
+    assert_equal 'green', @light.state
+    assert_equal 'red', @light.reload.state
   end
 end
 
@@ -172,38 +172,36 @@ if ActiveRecord::VERSION::MAJOR == 3
       end
     end
 
-    test "transition does persists state when state is protected" do
+    test 'transition does persists state when state is protected' do
       protected_light = @light_with_protected_state.create!
       protected_light.reset!
       assert_equal :red, protected_light.current_state
       protected_light.reload
-      assert_equal "red", protected_light.state
+      assert_equal 'red', protected_light.state
     end
   end
 end
 
 class TestNewActiveRecord < TestActiveRecord
-
   def setup
     set_up_db CreateTrafficLights
     @light = TrafficLight.new
   end
 
-  test "new active records defaults current state to the initial state" do
+  test 'new active records defaults current state to the initial state' do
     assert_equal :off, @light.current_state
   end
-
 end
 
 class TestScopes < Test::Unit::TestCase
-  test "scope returns correct object" do
+  test 'scope returns correct object' do
     @light = TrafficLight.create!
     assert_respond_to TrafficLight, :off
     assert_equal TrafficLight.off.first, @light
     assert TrafficLight.red.empty?
   end
 
-  test "scopes exist" do
+  test 'scopes exist' do
     assert_respond_to TrafficLight, :off
     assert_respond_to TrafficLight, :red
     assert_respond_to TrafficLight, :green
@@ -216,23 +214,23 @@ class TestScopes < Test::Unit::TestCase
   end
 
   test 'scope generation raises an exception if we try to overwrite an existing method' do
-    assert_raise(Transitions::InvalidMethodOverride) {
+    assert_raise(Transitions::InvalidMethodOverride) do
       class Light < ActiveRecord::Base
         include ActiveModel::Transitions
 
-        state_machine :auto_scopes => true do
+        state_machine auto_scopes: true do
           state :new
           state :broken
         end
       end
-    }
+    end
   end
 end
 
 class DifferentTrafficLight < ActiveRecord::Base
   include ActiveModel::Transitions
 
-  state_machine :attribute_name => :different_state, :auto_scopes => true do
+  state_machine attribute_name: :different_state, auto_scopes: true do
     state :off
 
     state :red
@@ -240,19 +238,19 @@ class DifferentTrafficLight < ActiveRecord::Base
     state :yellow
 
     event :red_on do
-      transitions :to => :red, :from => [:yellow]
+      transitions to: :red, from: [:yellow]
     end
 
     event :green_on do
-      transitions :to => :green, :from => [:red]
+      transitions to: :green, from: [:red]
     end
 
     event :yellow_on do
-      transitions :to => :yellow, :from => [:green]
+      transitions to: :yellow, from: [:green]
     end
 
     event :reset do
-      transitions :to => :red, :from => [:off]
+      transitions to: :red, from: [:off]
     end
   end
 end
@@ -263,17 +261,17 @@ class TestActiveRecordWithDifferentColumnName < Test::Unit::TestCase
     @light = DifferentTrafficLight.create!
   end
 
-  test "new record has the initial state set" do
+  test 'new record has the initial state set' do
     @light = DifferentTrafficLight.new
-    assert_equal "off", @light.different_state
+    assert_equal 'off', @light.different_state
   end
 
-  test "states initial state" do
+  test 'states initial state' do
     assert @light.off?
     assert_equal :off, @light.current_state
   end
 
-  test "transition to a valid state" do
+  test 'transition to a valid state' do
     @light.reset
     assert @light.red?
     assert_equal :red, @light.current_state
@@ -283,46 +281,46 @@ class TestActiveRecordWithDifferentColumnName < Test::Unit::TestCase
     assert_equal :green, @light.current_state
   end
 
-  test "transition does not persist state" do
+  test 'transition does not persist state' do
     @light.reset
     assert_equal :red, @light.current_state
     @light.reload
-    assert_equal "off", @light.different_state
+    assert_equal 'off', @light.different_state
   end
 
-  test "transition does persists state" do
+  test 'transition does persists state' do
     @light.reset!
     assert_equal :red, @light.current_state
     @light.reload
-    assert_equal "red", @light.different_state
+    assert_equal 'red', @light.different_state
   end
 
-  test "transition to an invalid state" do
+  test 'transition to an invalid state' do
     assert_raise(Transitions::InvalidTransition) { @light.yellow_on }
     assert_equal :off, @light.current_state
   end
 
-  test "transition with wrong state will not validate" do
+  test 'transition with wrong state will not validate' do
     for s in @light.class.state_machine.states
       @light.different_state = s.name
       assert @light.valid?
     end
-    @light.different_state = "invalid_one"
+    @light.different_state = 'invalid_one'
     assert_false @light.valid?
   end
 
-  test "reloading model resets current state" do
+  test 'reloading model resets current state' do
     @light.reset
     assert @light.red?
     @light.update_attribute(:different_state, 'green')
-    assert @light.reload.green?, "reloaded state should come from database, not instance variable"
+    assert @light.reload.green?, 'reloaded state should come from database, not instance variable'
   end
 
-  test "calling non-bang event updates state attribute" do
+  test 'calling non-bang event updates state attribute' do
     @light.reset!
     assert @light.red?
     @light.green_on
-    assert_equal "green", @light.different_state
-    assert_equal "red", @light.reload.different_state
+    assert_equal 'green', @light.different_state
+    assert_equal 'red', @light.reload.different_state
   end
 end

data/test/active_record/test_active_record_scopes.rb

@@ -1,8 +1,8 @@
-require "helper"
+require 'helper'
 
 class CreateBunnies < ActiveRecord::Migration
   def self.up
-    create_table(:bunnies, :force => true) do |t|
+    create_table(:bunnies, force: true) do |t|
       t.string :status # Explicitly use another state column to ensure that this whole enchilada is working with other state column names than the default ones.
     end
   end
@@ -10,7 +10,7 @@ end
 
 class CreatePuppies < ActiveRecord::Migration
   def self.up
-    create_table(:puppies, :force => true) do |t|
+    create_table(:puppies, force: true) do |t|
       t.string :state
     end
   end
@@ -19,7 +19,7 @@ end
 class Bunny < ActiveRecord::Base
   include ActiveModel::Transitions
 
-  state_machine :attribute_name => :status, :auto_scopes => true do
+  state_machine attribute_name: :status, auto_scopes: true do
     state :hobbling
   end
 end
@@ -38,11 +38,11 @@ class TestScopes < Test::Unit::TestCase
     @bunny = Bunny.create!
   end
 
-  test "scopes exist" do
+  test 'scopes exist' do
     assert_respond_to Bunny, :hobbling
   end
 
-  test "scope returns correct object" do
+  test 'scope returns correct object' do
     assert_equal Bunny.hobbling.first, @bunny
   end
 
@@ -55,7 +55,7 @@ class TestScopes < Test::Unit::TestCase
       Class.new(ActiveRecord::Base) do
         include ActiveModel::Transitions
 
-        state_machine :auto_scopes => true do
+        state_machine auto_scopes: true do
           state :new
         end
       end

data/test/active_record/test_active_record_timestamps.rb

@@ -1,15 +1,15 @@
-require "helper"
+require 'helper'
 
 class CreateOrders < ActiveRecord::Migration
   def self.up
-    create_table(:orders, :force => true) do |t|
+    create_table(:orders, force: true) do |t|
       t.string :state
       t.string :order_number
       t.datetime :paid_at
       t.datetime :prepared_on
       t.datetime :dispatched_at
       t.date :cancellation_date
-      t.boolean :allow_transition, :default => true
+      t.boolean :allow_transition, default: true
     end
   end
 end
@@ -27,62 +27,62 @@ class Order < ActiveRecord::Base
 
     # no timestamp col is being specified here - should be ignored
     event :place do
-      transitions :from => :opened, :to => :placed
+      transitions from: :opened, to: :placed
     end
 
     # should set paid_at timestamp
-    event :pay, :timestamp => true do
-      transitions :from => :placed, :to => :paid, :guard => lambda { |obj| obj.allow_transition }
+    event :pay, timestamp: true do
+      transitions from: :placed, to: :paid, guard: lambda { |obj| obj.allow_transition }
     end
 
     # should set prepared_on
-    event :prepare, :timestamp => true do
-      transitions :from => :paid, :to => :prepared
+    event :prepare, timestamp: true do
+      transitions from: :paid, to: :prepared
     end
 
     # should set dispatched_at
-    event :deliver, :timestamp => "dispatched_at" do
-      transitions :from => :prepared, :to => :delivered
+    event :deliver, timestamp: 'dispatched_at' do
+      transitions from: :prepared, to: :delivered
     end
 
     # should set cancellation_date
-    event :cancel, :timestamp => :cancellation_date do
-      transitions :from => [:placed, :paid, :prepared], :to => :cancelled
+    event :cancel, timestamp: :cancellation_date do
+      transitions from: [:placed, :paid, :prepared], to: :cancelled
     end
 
     # should raise an exception as there is no timestamp col
-    event :reopen, :timestamp => true do
-      transitions :from => :cancelled, :to => :opened
+    event :reopen, timestamp: true do
+      transitions from: :cancelled, to: :opened
     end
   end
 end
 
 class TestActiveRecordTimestamps < Test::Unit::TestCase
-  require "securerandom"
+  require 'securerandom'
 
   def setup
     set_up_db CreateOrders
   end
 
   def create_order(state = nil)
-    Order.create! :order_number => SecureRandom.hex(4), :state => state
+    Order.create! order_number: SecureRandom.hex(4), state: state
   end
 
   # control case, no timestamp has been set so we should expect default behaviour
-  test "moving to placed does not raise any exceptions" do
+  test 'moving to placed does not raise any exceptions' do
     @order = create_order
     assert_nothing_raised { @order.place! }
-    assert_equal @order.state, "placed"
+    assert_equal @order.state, 'placed'
   end
 
-  test "moving to paid should set paid_at" do
+  test 'moving to paid should set paid_at' do
     @order = create_order(:placed)
     @order.pay!
     @order.reload
     assert_not_nil @order.paid_at
   end
 
-  test "moving to paid should not set paid_at if our guard evaluates to false" do
+  test 'moving to paid should not set paid_at if our guard evaluates to false' do
     @order = create_order(:placed)
     @order.update_attribute :allow_transition, false
     @order.pay!
@@ -90,43 +90,42 @@ class TestActiveRecordTimestamps < Test::Unit::TestCase
     assert_nil @order.paid_at
   end
 
-  test "moving to prepared should set prepared_on" do
+  test 'moving to prepared should set prepared_on' do
     @order = create_order(:paid)
     @order.prepare!
     @order.reload
     assert_not_nil @order.prepared_on
   end
 
-  test "moving to delivered should set dispatched_at" do
+  test 'moving to delivered should set dispatched_at' do
     @order = create_order(:prepared)
     @order.deliver!
     @order.reload
     assert_not_nil @order.dispatched_at
   end
 
-  test "moving to cancelled should set cancellation_date" do
+  test 'moving to cancelled should set cancellation_date' do
     @order = create_order(:placed)
     @order.cancel!
     @order.reload
     assert_not_nil @order.cancellation_date
   end
 
-  test "moving to reopened should raise an exception as there is no attribute" do
+  test 'moving to reopened should raise an exception as there is no attribute' do
     @order = create_order(:cancelled)
     assert_raise(NoMethodError) { @order.re_open! }
     @order.reload
   end
 
-  test "passing an invalid value to timestamp options should raise an exception" do
+  test 'passing an invalid value to timestamp options should raise an exception' do
     assert_raise(ArgumentError) do
       class Order < ActiveRecord::Base
         include ActiveModel::Transitions
         state_machine do
-          event :replace, :timestamp => 1 do
-            transitions :from => :prepared, :to => :placed
+          event :replace, timestamp: 1 do
+            transitions from: :prepared, to: :placed
           end
         end
-
       end
     end
   end

data/test/active_record/test_custom_select.rb

@@ -1,9 +1,9 @@
-require "helper"
+require 'helper'
 
 # Regression test for https://github.com/troessner/transitions/issues/95
 class CreateSwitches < ActiveRecord::Migration
   def self.up
-    create_table(:switches, :force => true) do |t|
+    create_table(:switches, force: true) do |t|
       t.string :state
     end
   end
@@ -24,7 +24,7 @@ class TestCustomSelect < Test::Unit::TestCase
     Switch.create!
   end
 
-  test "should not trigger an exception when we use a custom select query which excludes the name of our state attribute" do
+  test 'should not trigger an exception when we use a custom select query which excludes the name of our state attribute' do
     result = Switch.select(:id)
     assert_nothing_raised NoMethodError do
       result.inspect

data/test/event/test_event.rb

@@ -1,4 +1,4 @@
-require "helper"
+require 'helper'
 
 class TestEvent < Test::Unit::TestCase
   def setup
@@ -9,64 +9,64 @@ class TestEvent < Test::Unit::TestCase
   end
 
   def event_with_symbol_success_callback
-    @event = Transitions::Event.new(nil, @state_name, {:success => @success_as_symbol}) do
-      transitions :to => :closed, :from => [:open, :received]
+    @event = Transitions::Event.new(nil, @state_name, success: @success_as_symbol) do
+      transitions to: :closed, from: [:open, :received]
     end
   end
   alias_method :new_event, :event_with_symbol_success_callback
 
   def event_with_lambda_success_callback
-    @event = Transitions::Event.new(nil, @state_name, {:success => @success_as_lambda}) do
-      transitions :to => :closed, :from => [:open, :received]
+    @event = Transitions::Event.new(nil, @state_name, success: @success_as_lambda) do
+      transitions to: :closed, from: [:open, :received]
     end
   end
 
   def event_with_array_success_callback
-    @event = Transitions::Event.new(nil, @state_name, {:success => @success_as_array}) do
-      transitions :to => :closed, :from => [:open, :received]
+    @event = Transitions::Event.new(nil, @state_name, success: @success_as_array) do
+      transitions to: :closed, from: [:open, :received]
     end
   end
 
-  test "should set the name" do
+  test 'should set the name' do
     assert_equal @state_name, new_event.name
   end
 
-  test "should set the success callback with a symbol and return a block" do
+  test 'should set the success callback with a symbol and return a block' do
     assert_respond_to event_with_symbol_success_callback.success, :call
   end
 
-  test "should build a block which calls the given success_callback symbol on the passed record instance" do
-    record = mock("SomeRecordToGetCalled")
+  test 'should build a block which calls the given success_callback symbol on the passed record instance' do
+    record = mock('SomeRecordToGetCalled')
     record.expects(:success_callback)
 
     event_with_symbol_success_callback.success.call(record)
   end
 
-  test "should set the success callback with a lambda" do
+  test 'should set the success callback with a lambda' do
     assert_respond_to event_with_lambda_success_callback.success, :call
   end
 
-  test "should build a block which calls the given success_callback lambda on the passed record instance" do
-    record = mock("SomeRecordToGetCalled")
+  test 'should build a block which calls the given success_callback lambda on the passed record instance' do
+    record = mock('SomeRecordToGetCalled')
     record.expects(:success_callback)
 
     event_with_lambda_success_callback.success.call(record)
   end
 
-  test "should set the success callback with an array" do
+  test 'should set the success callback with an array' do
     assert_respond_to event_with_array_success_callback.success, :call
   end
 
-  test "should build a block which calls the given success_callback array on the passed record instance for each callback" do
-    record = mock("SomeRecordToGetCalled")
+  test 'should build a block which calls the given success_callback array on the passed record instance for each callback' do
+    record = mock('SomeRecordToGetCalled')
     record.expects(:success_callback).twice
 
     event_with_array_success_callback.success.call(record)
   end
 
-  test "should create StateTransitions" do
-    Transitions::StateTransition.expects(:new).with(:to => :closed, :from => :open)
-    Transitions::StateTransition.expects(:new).with(:to => :closed, :from => :received)
+  test 'should create StateTransitions' do
+    Transitions::StateTransition.expects(:new).with(to: :closed, from: :open)
+    Transitions::StateTransition.expects(:new).with(to: :closed, from: :received)
     new_event
   end
 end