state_machines 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3935f97b4e0314e076a6a35afc73f4f187058293
-  data.tar.gz: f2e5c9374a4f1b05729035f14f4909dc7f218518
+  metadata.gz: e0c2ed05cead9f7eb53b9e80ac521171b50e8870
+  data.tar.gz: f0fbdb3f32090b62685cc82f3584dbda1c145032
 SHA512:
-  metadata.gz: 48312c212788cc3b03356ea37dbfa1cd5b73ea881b2f61f6367d3d8ad3eece0c145b79bc47b7c895b222651f887af31ca3695028c2c8f87d43f4e7a166944d42
-  data.tar.gz: 4e05b6813f79d0374d9f21be4f91567fa09ed5c18fb9dd99ae108be5e1d813f149fbd757b3ee11ff1f9988d0819a3fa81907967cbcdbb0858d8a12c3de27514a
+  metadata.gz: 489807212fea0ff23f9c65d735b8d8da649e4f671c0af22b6c5c23027d09be8db843f4c488497889756457b0d7b05427e5b8aa1e7dd7f7788fe6b66fda38bb9d
+  data.tar.gz: 2f0622c9e0f6dea50e7495fc036a911b233dd19630449c0f477cd01a03b54c67e5e2896c4c4459ce9732930925e6bb401bb14bb7599895624952d83088d00bdd

data/Changelog.md

@@ -1,3 +1,5 @@
+*   Namespaced integrations are not registered by default anymore
+
 *   Pass `static: false` in case you don't want initial states to be forced. e.g.
 
     ```ruby

data/lib/state_machines/integrations.rb

@@ -20,7 +20,7 @@ module StateMachines
   # built-in integrations for more information about how to define additional
   # integrations.
   module Integrations
-    @integrations = Set.new
+    @integrations = []
 
     class << self
       #  Register integration
@@ -34,15 +34,8 @@ module StateMachines
         true
       end
 
-
-      def unregister(name) #:nodoc:#
-        @integrations.delete(name)
-      end
-
       def reset #:nodoc:#
-        @integrations = Set.new
-        name_spaced_integrations
-        true
+        @integrations = []
       end
 
       # Gets a list of all of the available integrations for use.
@@ -56,7 +49,6 @@ module StateMachines
       #   # => [StateMachines::Integrations::ActiveModel]
       def integrations
         # Register all namespaced integrations
-        name_spaced_integrations
         @integrations
       end
 
@@ -114,16 +106,10 @@ module StateMachines
 
       private
 
-      def name_spaced_integrations
-        # FIXME, Integrations should be add before their dependencies.
-        self.constants.reject{ |i| i==:Base }.each do |const|
-          integration = self.const_get(const)
-          add(integration)
-        end
-      end
-
       def add(integration)
-        @integrations << integration  if integration.respond_to?(:integration_name)
+        if integration.respond_to?(:integration_name)
+          @integrations.insert(0, integration) unless @integrations.include?(integration)
+        end
       end
     end
   end

data/lib/state_machines/version.rb

@@ -1,3 +1,3 @@
 module StateMachines
-  VERSION = '0.1.4'
+  VERSION = '0.2.0'
 end

data/test/unit/event/event_with_matching_disabled_transitions_test.rb

@@ -1,19 +1,20 @@
 require_relative '../../test_helper'
 
 class EventWithMatchingDisabledTransitionsTest < StateMachinesTest
-  def setup
-    StateMachines::Integrations.const_set('Custom', Module.new do
-                                                    include StateMachines::Integrations::Base
+  module Custom
+    include StateMachines::Integrations::Base
+
+    def invalidate(object, _attribute, message, values = [])
+      (object.errors ||= []) << generate_message(message, values)
+    end
 
-                                                    def invalidate(object, _attribute, message, values = [])
-                                                      (object.errors ||= []) << generate_message(message, values)
-                                                    end
+    def reset(object)
+      object.errors = []
+    end
+  end
 
-                                                    def reset(object)
-                                                      object.errors = []
-                                                    end
-                                                  end)
-    StateMachines::Integrations.register(StateMachines::Integrations::Custom)
+  def setup
+    StateMachines::Integrations.register(EventWithMatchingDisabledTransitionsTest::Custom)
 
     @klass = Class.new do
       attr_accessor :errors
@@ -109,7 +110,6 @@ class EventWithMatchingDisabledTransitionsTest < StateMachinesTest
 
   def teardown
     StateMachines::Integrations.reset
-    StateMachines::Integrations.send(:remove_const, 'Custom')
   end
 end
 

data/test/unit/event/event_with_matching_enabled_transitions_test.rb

@@ -1,19 +1,20 @@
 require_relative '../../test_helper'
 
 class EventWithMatchingEnabledTransitionsTest < StateMachinesTest
-  def setup
-    StateMachines::Integrations.const_set('Custom', Module.new do
-                                                    include StateMachines::Integrations::Base
+  module Custom
+    include StateMachines::Integrations::Base
+
+    def invalidate(object, _attribute, message, values = [])
+      (object.errors ||= []) << generate_message(message, values)
+    end
 
-                                                    def invalidate(object, _attribute, message, values = [])
-                                                      (object.errors ||= []) << generate_message(message, values)
-                                                    end
+    def reset(object)
+      object.errors = []
+    end
+  end
 
-                                                    def reset(object)
-                                                      object.errors = []
-                                                    end
-                                                  end)
-    StateMachines::Integrations.register(StateMachines::Integrations::Custom)
+  def setup
+    StateMachines::Integrations.register(EventWithMatchingEnabledTransitionsTest::Custom)
 
     @klass = Class.new do
       attr_accessor :errors
@@ -69,7 +70,6 @@ class EventWithMatchingEnabledTransitionsTest < StateMachinesTest
 
   def teardown
     StateMachines::Integrations.reset
-    StateMachines::Integrations.send(:remove_const, 'Custom')
   end
 end
 

data/test/unit/event_collection/event_collection_with_validations_test.rb

@@ -1,20 +1,20 @@
 require_relative '../../test_helper'
 
 class EventCollectionWithValidationsTest < StateMachinesTest
-  def setup
-    StateMachines::Integrations.const_set('Custom', Module.new do
-                                                    include StateMachines::Integrations::Base
+  module Custom
+    include StateMachines::Integrations::Base
 
-                                                    def invalidate(object, _attribute, message, values = [])
-                                                      (object.errors ||= []) << generate_message(message, values)
-                                                    end
+    def invalidate(object, _attribute, message, values = [])
+      (object.errors ||= []) << generate_message(message, values)
+    end
 
-                                                    def reset(object)
-                                                      object.errors = []
-                                                    end
-                                                  end)
-    StateMachines::Integrations.register(StateMachines::Integrations::Custom)
+    def reset(object)
+      object.errors = []
+    end
+  end
 
+  def setup
+    StateMachines::Integrations.register(EventCollectionWithValidationsTest::Custom)
 
     @klass = Class.new do
       attr_accessor :errors
@@ -69,7 +69,6 @@ class EventCollectionWithValidationsTest < StateMachinesTest
 
   def teardown
     StateMachines::Integrations.reset
-    StateMachines::Integrations.send(:remove_const, 'Custom')
   end
 end
 

data/test/unit/integrations/integration_finder_test.rb

@@ -11,6 +11,6 @@ class IntegrationFinderTest < StateMachinesTest
   end
 
   def test_should_have_no_integrations
-    assert_equal(Set.new, StateMachines::Integrations.list)
+    assert_equal([], StateMachines::Integrations.list)
   end
 end

data/test/unit/invalid_transition/invalid_transition_with_integration_test.rb

@@ -1,17 +1,16 @@
 require_relative '../../test_helper'
 
 class InvalidTransitionWithIntegrationTest < StateMachinesTest
-  def setup
-    StateMachines::Integrations.const_set('Custom', Module.new do
-                                                    include StateMachines::Integrations::Base
-
-                                                    def errors_for(object)
-                                                      object.errors
-                                                    end
-                                                  end)
+  module Custom
+    include StateMachines::Integrations::Base
 
-    StateMachines::Integrations.register(StateMachines::Integrations::Custom)
+    def errors_for(object)
+      object.errors
+    end
+  end
 
+  def setup
+    StateMachines::Integrations.register(InvalidTransitionWithIntegrationTest::Custom)
 
     @klass = Class.new do
       attr_accessor :errors
@@ -42,6 +41,5 @@ class InvalidTransitionWithIntegrationTest < StateMachinesTest
 
   def teardown
     StateMachines::Integrations.reset
-    StateMachines::Integrations.send(:remove_const, 'Custom')
   end
 end

data/test/unit/machine/machine_finder_with_existing_machine_on_superclass_test.rb

@@ -1,16 +1,16 @@
 require_relative '../../test_helper'
 
 class MachineFinderWithExistingMachineOnSuperclassTest < StateMachinesTest
-  def setup
-    integration = Module.new do
-      include StateMachines::Integrations::Base
+  module Custom
+    include StateMachines::Integrations::Base
 
-      def self.matches?(_klass)
-        false
-      end
+    def self.matches?(_klass)
+      false
     end
-    StateMachines::Integrations.const_set('Custom', integration)
-    StateMachines::Integrations.register(StateMachines::Integrations::Custom)
+  end
+
+  def setup
+    StateMachines::Integrations.register(MachineFinderWithExistingMachineOnSuperclassTest::Custom)
 
     @base_class = Class.new
     @base_machine = StateMachines::Machine.new(@base_class, :status, action: :save, integration: :custom)
@@ -76,11 +76,10 @@ class MachineFinderWithExistingMachineOnSuperclassTest < StateMachinesTest
       ancestors
     end
 
-    assert(class_ancestors.include?(StateMachines::Integrations::Custom))
+    assert(class_ancestors.include?(MachineFinderWithExistingMachineOnSuperclassTest::Custom))
   end
 
   def teardown
     StateMachines::Integrations.reset
-    StateMachines::Integrations.send(:remove_const, 'Custom')
   end
 end

data/test/unit/machine/machine_with_conflicting_helpers_after_definition_test.rb

@@ -1,9 +1,20 @@
 require_relative '../../test_helper'
 
 class MachineWithConflictingHelpersAfterDefinitionTest < StateMachinesTest
+  module Custom
+    include StateMachines::Integrations::Base
+
+    def create_with_scope(_name)
+      ->(_klass, _values) { [] }
+    end
+
+    def create_without_scope(_name)
+      ->(_klass, _values) { [] }
+    end
+  end
   def setup
     @original_stderr, $stderr = $stderr, StringIO.new
-
+    StateMachines::Integrations.register(MachineWithConflictingHelpersAfterDefinitionTest::Custom)
     @klass = Class.new do
       def self.with_state
         :with_state
@@ -68,17 +79,7 @@ class MachineWithConflictingHelpersAfterDefinitionTest < StateMachinesTest
       end
     end
 
-    StateMachines::Integrations.const_set('Custom', Module.new do
-                                                    include StateMachines::Integrations::Base
-
-                                                    def create_with_scope(_name)
-                                                      lambda { |_klass, _values| [] }
-                                                    end
 
-                                                    def create_without_scope(_name)
-                                                      lambda { |_klass, _values| [] }
-                                                    end
-                                                  end)
 
     @machine = StateMachines::Machine.new(@klass, integration: :custom)
     @machine.state :parked, :idling
@@ -238,6 +239,6 @@ class MachineWithConflictingHelpersAfterDefinitionTest < StateMachinesTest
 
   def teardown
     $stderr = @original_stderr
-    StateMachines::Integrations.send(:remove_const, 'Custom')
+    StateMachines::Integrations.reset
   end
 end

data/test/unit/machine/machine_with_conflicting_helpers_before_definition_test.rb

@@ -1,9 +1,23 @@
 require_relative '../../test_helper'
 
 class MachineWithConflictingHelpersBeforeDefinitionTest < StateMachinesTest
+  module Custom
+    include StateMachines::Integrations::Base
+
+    def create_with_scope(_name)
+      lambda { |_klass, _values| [] }
+    end
+
+    def create_without_scope(_name)
+      lambda { |_klass, _values| [] }
+    end
+  end
+
   def setup
     @original_stderr, $stderr = $stderr, StringIO.new
 
+    StateMachines::Integrations.register(MachineWithConflictingHelpersBeforeDefinitionTest::Custom)
+
     @superclass = Class.new do
       def self.with_state
         :with_state
@@ -68,19 +82,6 @@ class MachineWithConflictingHelpersBeforeDefinitionTest < StateMachinesTest
       end
     end
     @klass = Class.new(@superclass)
-
-    StateMachines::Integrations.const_set('Custom', Module.new do
-                                                    include StateMachines::Integrations::Base
-
-                                                    def create_with_scope(_name)
-                                                      lambda { |_klass, _values| [] }
-                                                    end
-
-                                                    def create_without_scope(_name)
-                                                      lambda { |_klass, _values| [] }
-                                                    end
-                                                  end)
-
     @machine = StateMachines::Machine.new(@klass, integration: :custom)
     @machine.state :parked, :idling
     @machine.event :ignite
@@ -169,7 +170,6 @@ class MachineWithConflictingHelpersBeforeDefinitionTest < StateMachinesTest
 
   def teardown
     $stderr = @original_stderr
-    StateMachines::Integrations.send(:remove_const, 'Custom')
   end
 end
 

data/test/unit/machine/machine_with_custom_integration_test.rb

@@ -2,29 +2,27 @@ require_relative '../../test_helper'
 require_relative '../../../test/files/models/vehicle'
 
 class MachineWithCustomIntegrationTest < StateMachinesTest
-  def setup
-    StateMachines::Integrations.reset
-    integration = Module.new do
-      include StateMachines::Integrations::Base
+  module Custom
+    include StateMachines::Integrations::Base
 
-      def self.matching_ancestors
-        ['Vehicle']
-      end
+    def self.matching_ancestors
+      ['Vehicle']
     end
+  end
 
-    StateMachines::Integrations.const_set('Custom', integration)
-    StateMachines::Integrations.register(StateMachines::Integrations::Custom)
+  def setup
+    StateMachines::Integrations.register(MachineWithCustomIntegrationTest::Custom)
 
     @klass = Vehicle
   end
 
   def test_should_be_extended_by_the_integration_if_explicit
     machine = StateMachines::Machine.new(@klass, integration: :custom)
-    assert((class << machine; ancestors; end).include?(StateMachines::Integrations::Custom))
+    assert((class << machine; ancestors; end).include?(MachineWithCustomIntegrationTest::Custom))
   end
 
   def test_should_not_be_extended_by_the_integration_if_implicit_but_not_available
-    StateMachines::Integrations::Custom.class_eval do
+    MachineWithCustomIntegrationTest::Custom.class_eval do
       class << self; remove_method :matching_ancestors; end
       def self.matching_ancestors
         []
@@ -32,11 +30,11 @@ class MachineWithCustomIntegrationTest < StateMachinesTest
     end
 
     machine = StateMachines::Machine.new(@klass)
-    assert(!(class << machine; ancestors; end).include?(StateMachines::Integrations::Custom))
+    assert(!(class << machine; ancestors; end).include?(MachineWithCustomIntegrationTest::Custom))
   end
 
   def test_should_not_be_extended_by_the_integration_if_implicit_but_not_matched
-    StateMachines::Integrations::Custom.class_eval do
+    MachineWithCustomIntegrationTest::Custom.class_eval do
       class << self; remove_method :matching_ancestors; end
       def self.matching_ancestors
         []
@@ -44,26 +42,31 @@ class MachineWithCustomIntegrationTest < StateMachinesTest
     end
 
     machine = StateMachines::Machine.new(@klass)
-    assert(!(class << machine; ancestors; end).include?(StateMachines::Integrations::Custom))
+    assert(!(class << machine; ancestors; end).include?(MachineWithCustomIntegrationTest::Custom))
   end
 
   def test_should_be_extended_by_the_integration_if_implicit_and_available_and_matches
     machine = StateMachines::Machine.new(@klass)
-    assert((class << machine; ancestors; end).include?(StateMachines::Integrations::Custom))
+    assert((class << machine; ancestors; end).include?(MachineWithCustomIntegrationTest::Custom))
   end
 
   def test_should_not_be_extended_by_the_integration_if_nil
     machine = StateMachines::Machine.new(@klass, integration: nil)
-    assert(!(class << machine; ancestors; end).include?(StateMachines::Integrations::Custom))
+    assert(!(class << machine; ancestors; end).include?(MachineWithCustomIntegrationTest::Custom))
   end
 
   def test_should_not_be_extended_by_the_integration_if_false
     machine = StateMachines::Machine.new(@klass, integration: false)
-    assert(!(class << machine; ancestors; end).include?(StateMachines::Integrations::Custom))
+    assert(!(class << machine; ancestors; end).include?(MachineWithCustomIntegrationTest::Custom))
   end
 
   def teardown
     StateMachines::Integrations.reset
-    StateMachines::Integrations.send(:remove_const, 'Custom')
+    MachineWithCustomIntegrationTest::Custom.class_eval do
+      class << self; remove_method :matching_ancestors; end
+      def self.matching_ancestors
+        ['Vehicle']
+      end
+    end
   end
 end

data/test/unit/machine/machine_with_custom_invalidation_test.rb

@@ -1,22 +1,22 @@
 require_relative '../../test_helper'
 
 class MachineWithCustomInvalidationTest < StateMachinesTest
-  def setup
-    @integration = Module.new do
-      include StateMachines::Integrations::Base
+  module Custom
+    include StateMachines::Integrations::Base
 
-      def invalidate(object, _attribute, message, values = [])
-        object.error = generate_message(message, values)
-      end
+    def invalidate(object, _attribute, message, values = [])
+      object.error = generate_message(message, values)
     end
-    StateMachines::Integrations.const_set('Custom', @integration)
-    StateMachines::Integrations.register(StateMachines::Integrations::Custom)
+  end
+
+  def setup
+    StateMachines::Integrations.register(MachineWithCustomInvalidationTest::Custom)
 
     @klass = Class.new do
       attr_accessor :error
     end
 
-    @machine = StateMachines::Machine.new(@klass, integration: :custom, messages: { invalid_transition: 'cannot %s' })
+    @machine = StateMachines::Machine.new(@klass, integration: :custom, messages: {invalid_transition: 'cannot %s'})
     @machine.state :parked
 
     @object = @klass.new
@@ -34,7 +34,6 @@ class MachineWithCustomInvalidationTest < StateMachinesTest
 
   def teardown
     StateMachines::Integrations.reset
-    StateMachines::Integrations.send(:remove_const, 'Custom')
   end
 end
 

data/test/unit/machine/machine_with_custom_plural_test.rb

@@ -2,7 +2,6 @@ require_relative '../../test_helper'
 
 class MachineWithCustomPluralTest < StateMachinesTest
   def setup
-    StateMachines::Integrations.reset
     @integration = Module.new do
       include StateMachines::Integrations::Base
 
@@ -11,18 +10,18 @@ class MachineWithCustomPluralTest < StateMachinesTest
       @without_scopes = []
 
       def create_with_scope(name)
-        StateMachines::Integrations::Custom.with_scopes << name
+        MachineWithCustomPluralTest::Custom.with_scopes << name
         lambda {}
       end
 
       def create_without_scope(name)
-        StateMachines::Integrations::Custom.without_scopes << name
+        MachineWithCustomPluralTest::Custom.without_scopes << name
         lambda {}
       end
     end
 
-    StateMachines::Integrations.const_set('Custom', @integration)
-    StateMachines::Integrations.register(StateMachines::Integrations::Custom)
+    MachineWithCustomPluralTest.const_set('Custom', @integration)
+    StateMachines::Integrations.register(MachineWithCustomPluralTest::Custom)
   end
 
   def test_should_define_a_singular_and_plural_with_scope
@@ -47,7 +46,7 @@ class MachineWithCustomPluralTest < StateMachinesTest
 
   def teardown
     StateMachines::Integrations.reset
-    StateMachines::Integrations.send(:remove_const, 'Custom')
+    MachineWithCustomPluralTest.send(:remove_const, 'Custom')
   end
 end
 

data/test/unit/machine/machine_with_integration_test.rb

@@ -1,34 +1,36 @@
 require_relative '../../test_helper'
 
 class MachineWithIntegrationTest < StateMachinesTest
-  def setup
-    StateMachines::Integrations.const_set('Custom', Module.new do
-                                                    include StateMachines::Integrations::Base
 
-                                                    @defaults = { action: :save, use_transactions: false }
+  module Custom
+    include StateMachines::Integrations::Base
+
+    @defaults = {action: :save, use_transactions: false}
 
-                                                    attr_reader :initialized, :with_scopes, :without_scopes, :ran_transaction
+    attr_reader :initialized, :with_scopes, :without_scopes, :ran_transaction
 
-                                                    def after_initialize
-                                                      @initialized = true
-                                                    end
+    def after_initialize
+      @initialized = true
+    end
 
-                                                    def create_with_scope(name)
-                                                      (@with_scopes ||= []) << name
-                                                      lambda {}
-                                                    end
+    def create_with_scope(name)
+      (@with_scopes ||= []) << name
+      lambda {}
+    end
 
-                                                    def create_without_scope(name)
-                                                      (@without_scopes ||= []) << name
-                                                      lambda {}
-                                                    end
+    def create_without_scope(name)
+      (@without_scopes ||= []) << name
+      lambda {}
+    end
 
-                                                    def transaction(_)
-                                                      @ran_transaction = true
-                                                      yield
-                                                    end
-                                                  end)
-    StateMachines::Integrations.register(StateMachines::Integrations::Custom)
+    def transaction(_)
+      @ran_transaction = true
+      yield
+    end
+  end
+
+  def setup
+    StateMachines::Integrations.register(MachineWithIntegrationTest::Custom)
 
 
     @machine = StateMachines::Machine.new(Class.new, integration: :custom)
@@ -66,6 +68,5 @@ class MachineWithIntegrationTest < StateMachinesTest
 
   def teardown
     StateMachines::Integrations.reset
-    StateMachines::Integrations.send(:remove_const, 'Custom')
   end
 end

data/test/unit/machine/machine_with_nil_action_test.rb

@@ -1,24 +1,27 @@
 require_relative '../../test_helper'
 
 class MachineWithNilActionTest < StateMachinesTest
-  def setup
-    integration = Module.new do
-      include StateMachines::Integrations::Base
+  module Custom
+    include StateMachines::Integrations::Base
 
-      @defaults = { action: :save }
-    end
-    StateMachines::Integrations.const_set('Custom', integration)
-    StateMachines::Integrations.register(StateMachines::Integrations::Custom)
+    @defaults = {action: :save}
+  end
 
-    @machine = StateMachines::Machine.new(Class.new, action: nil, integration: :custom)
+  def setup
+    StateMachines::Integrations.register(MachineWithNilActionTest::Custom)
   end
 
   def test_should_have_a_nil_action
-    assert_nil @machine.action
+    machine = StateMachines::Machine.new(Class.new, action: nil, integration: :custom)
+    assert_nil machine.action
+  end
+
+  def test_should_have_default_action
+    machine = StateMachines::Machine.new(Class.new, integration: :custom)
+    assert_equal :save,  machine.action
   end
 
   def teardown
     StateMachines::Integrations.reset
-    StateMachines::Integrations.send(:remove_const, 'Custom')
   end
 end

data/test/unit/machine_collection/machine_collection_fire_attributes_with_validations_test.rb

@@ -1,19 +1,20 @@
 require_relative '../../test_helper'
 
 class MachineCollectionFireWithValidationsTest < StateMachinesTest
-  def setup
-    StateMachines::Integrations.const_set('Custom', Module.new do
-                                                    include StateMachines::Integrations::Base
+  module Custom
+    include StateMachines::Integrations::Base
+
+    def invalidate(object, _attribute, message, values = [])
+      (object.errors ||= []) << generate_message(message, values)
+    end
 
-                                                    def invalidate(object, _attribute, message, values = [])
-                                                      (object.errors ||= []) << generate_message(message, values)
-                                                    end
+    def reset(object)
+      object.errors = []
+    end
+  end
 
-                                                    def reset(object)
-                                                      object.errors = []
-                                                    end
-                                                  end)
-    StateMachines::Integrations.register(StateMachines::Integrations::Custom)
+  def setup
+    StateMachines::Integrations.register(MachineCollectionFireWithValidationsTest::Custom)
 
     @klass = Class.new do
       attr_accessor :errors
@@ -66,7 +67,6 @@ class MachineCollectionFireWithValidationsTest < StateMachinesTest
 
   def teardown
     StateMachines::Integrations.reset
-    StateMachines::Integrations.send(:remove_const, 'Custom')
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: state_machines
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-28 00:00:00.000000000 Z
+date: 2015-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -559,7 +559,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: State machines for attributes