lib/transitions/machine.rb in transitions-0.0.18 vs lib/transitions/machine.rb in transitions-0.1.0

@@ -22,14 +22,14 @@
 
 module Transitions
   class Machine
     attr_writer :initial_state
     attr_accessor :states, :events, :state_index
-    attr_reader :klass, :name, :auto_scopes
+    attr_reader :klass, :auto_scopes
 
-    def initialize(klass, name, options = {}, &block)
-      @klass, @name, @states, @state_index, @events = klass, name, [], {}, {}
+    def initialize(klass, options = {}, &block)
+      @klass, @states, @state_index, @events = klass, [], {}, {}
       update(options, &block)
     end
 
     def initial_state
       @initial_state ||= (states.first ? states.first.name : nil)
@@ -42,29 +42,29 @@
       include_scopes if @auto_scopes && defined?(ActiveRecord::Base) && @klass < ActiveRecord::Base
       self
     end
 
     def fire_event(event, record, persist, *args)
-      state_index[record.current_state(@name)].call_action(:exit, record)
+      state_index[record.current_state].call_action(:exit, record)
       begin
         if new_state = @events[event].fire(record, nil, *args)
           state_index[new_state].call_action(:enter, record)
 
-          if record.respond_to?(event_fired_callback)
-            record.send(event_fired_callback, record.current_state, new_state, event)
+          if record.respond_to?(:event_fired)
+            record.send(:event_fired, record.current_state, new_state, event)
           end
 
-          record.current_state(@name, new_state, persist)
+          record.current_state(new_state, persist)
           @events[event].success.call(record) if @events[event].success
           return true
         else
-          record.send(event_fired_callback, event) if record.respond_to?(event_failed_callback)
+          record.send(:event_failed, event) if record.respond_to?(:event_failed)
           return false
         end
       rescue => e
-        if record.respond_to?(event_failed_callback)
-          record.send(event_failed_callback, event)
+        if record.respond_to?(:event_failed)
+          record.send(:event_failed, event)
           return false
         else
           raise e
         end
       end
@@ -78,28 +78,25 @@
       events = @events.values.select { |event| event.transitions_from_state?(state) }
       events.map! { |event| event.name }
     end
 
     def current_state_variable
-      "@#{@name}_current_state"
+      "@current_state"
     end
 
     private
 
     def state(name, options = {})
-      @states << (state_index[name] ||= State.new(name, :machine => self)).update(options)
+      unless @state_index.key? name # Just ignore duplicates
+        state = State.new(name, :machine => self)
+        state.update options
+        @state_index[name] = state
+        @states << state
+      end
     end
 
     def event(name, options = {}, &block)
       (@events[name] ||= Event.new(self, name)).update(options, &block)
-    end
-
-    def event_fired_callback
-      @event_fired_callback ||= (@name == :default ? '' : "#{@name}_") + 'event_fired'
-    end
-
-    def event_failed_callback
-      @event_failed_callback ||= (@name == :default ? '' : "#{@name}_") + 'event_failed'
     end
 
     def include_scopes
       @states.each do |state|
         state_name = state.name.to_s