Axe AM state machine

We're going do it eventually, get it done before 3.0 is final.

4 files changed, 0 insertions, 224 deletions

diff --git a/activemodel/lib/active_model/state_machine/event.rb b/activemodel/lib/active_model/state_machine/event.rb
deleted file mode 100644
index 30e9601dc2..0000000000
--- a/activemodel/lib/active_model/state_machine/event.rb
+++ /dev/null
@@ -1,62 +0,0 @@
-module ActiveModel
-  module StateMachine
-    class Event
-      attr_reader :name, :success
-
-      def initialize(machine, name, options = {}, &block)
-        @machine, @name, @transitions = machine, name, []
-        if machine
-          machine.klass.send(:define_method, "#{name}!") do |*args|
-            machine.fire_event(name, self, true, *args)
-          end
-
-          machine.klass.send(:define_method, name.to_s) do |*args|
-            machine.fire_event(name, self, false, *args)
-          end
-        end
-        update(options, &block)
-      end
-
-      def fire(obj, to_state = nil, *args)
-        transitions = @transitions.select { |t| t.from == obj.current_state(@machine ? @machine.name : nil) }
-        raise InvalidTransition if transitions.size == 0
-
-        next_state = nil
-        transitions.each do |transition|
-          next if to_state && !Array(transition.to).include?(to_state)
-          if transition.perform(obj)
-            next_state = to_state || Array(transition.to).first
-            transition.execute(obj, *args)
-            break
-          end
-        end
-        next_state
-      end
-
-      def transitions_from_state?(state)
-        @transitions.any? { |t| t.from? state }
-      end
-
-      def ==(event)
-        if event.is_a? Symbol
-          name == event
-        else
-          name == event.name
-        end
-      end
-
-      def update(options = {}, &block)
-        if options.key?(:success) then @success = options[:success] end
-        if block                  then instance_eval(&block)        end
-        self
-      end
-
-      private
-        def transitions(trans_opts)
-          Array(trans_opts[:from]).each do |s|
-            @transitions << StateTransition.new(trans_opts.merge({:from => s.to_sym}))
-          end
-        end
-    end
-  end
-end
diff --git a/activemodel/lib/active_model/state_machine/machine.rb b/activemodel/lib/active_model/state_machine/machine.rb
deleted file mode 100644
index 777531213e..0000000000
--- a/activemodel/lib/active_model/state_machine/machine.rb
+++ /dev/null
@@ -1,75 +0,0 @@
-module ActiveModel
-  module StateMachine
-    class Machine
-      attr_writer :initial_state
-      attr_accessor :states, :events, :state_index
-      attr_reader :klass, :name
-
-      def initialize(klass, name, options = {}, &block)
-        @klass, @name, @states, @state_index, @events = klass, name, [], {}, {}
-        update(options, &block)
-      end
-
-      def initial_state
-        @initial_state ||= (states.first ? states.first.name : nil)
-      end
-
-      def update(options = {}, &block)
-        if options.key?(:initial) then @initial_state = options[:initial] end
-        if block                  then instance_eval(&block)              end
-        self
-      end
-
-      def fire_event(event, record, persist, *args)
-        state_index[record.current_state(@name)].call_action(:exit, record)
-        if new_state = @events[event].fire(record, *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)
-          end
-
-          record.current_state(@name, new_state, persist)
-          record.send(@events[event].success) if @events[event].success
-          true
-        else
-          if record.respond_to?(event_failed_callback)
-            record.send(event_failed_callback, event)
-          end
-
-          false
-        end
-      end
-
-      def states_for_select
-        states.map { |st| [st.display_name, st.name.to_s] }
-      end
-
-      def events_for(state)
-        events = @events.values.select { |event| event.transitions_from_state?(state) }
-        events.map! { |event| event.name }
-      end
-
-      def current_state_variable
-        "@#{@name}_current_state"
-      end
-
-      private
-        def state(name, options = {})
-          @states << (state_index[name] ||= State.new(name, :machine => self)).update(options)
-        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
-    end
-  end
-end
diff --git a/activemodel/lib/active_model/state_machine/state.rb b/activemodel/lib/active_model/state_machine/state.rb
deleted file mode 100644
index 76916b1d86..0000000000
--- a/activemodel/lib/active_model/state_machine/state.rb
+++ /dev/null
@@ -1,47 +0,0 @@
-module ActiveModel
-  module StateMachine
-    class State
-      attr_reader :name, :options
-
-      def initialize(name, options = {})
-        @name = name
-        if machine = options.delete(:machine)
-          machine.klass.define_state_query_method(name)
-        end
-        update(options)
-      end
-
-      def ==(state)
-        if state.is_a? Symbol
-          name == state
-        else
-          name == state.name
-        end
-      end
-
-      def call_action(action, record)
-        action = @options[action]
-        case action
-        when Symbol, String
-          record.send(action)
-        when Proc
-          action.call(record)
-        end
-      end
-
-      def display_name
-        @display_name ||= name.to_s.gsub(/_/, ' ').capitalize
-      end
-
-      def for_select
-        [display_name, name.to_s]
-      end
-
-      def update(options = {})
-        if options.key?(:display) then @display_name = options.delete(:display) end
-        @options = options
-        self
-      end
-    end
-  end
-end
diff --git a/activemodel/lib/active_model/state_machine/state_transition.rb b/activemodel/lib/active_model/state_machine/state_transition.rb
deleted file mode 100644
index b0c5504de7..0000000000
--- a/activemodel/lib/active_model/state_machine/state_transition.rb
+++ /dev/null
@@ -1,40 +0,0 @@
-module ActiveModel
-  module StateMachine
-    class StateTransition
-      attr_reader :from, :to, :options
-
-      def initialize(opts)
-        @from, @to, @guard, @on_transition = opts[:from], opts[:to], opts[:guard], opts[:on_transition]
-        @options = opts
-      end
-
-      def perform(obj)
-        case @guard
-        when Symbol, String
-          obj.send(@guard)
-        when Proc
-          @guard.call(obj)
-        else
-          true
-        end
-      end
-
-      def execute(obj, *args)
-        case @on_transition
-        when Symbol, String
-          obj.send(@on_transition, *args)
-        when Proc
-          @on_transition.call(obj, *args)
-        end
-      end
-
-      def ==(obj)
-        @from == obj.from && @to == obj.to
-      end
-
-      def from?(value)
-        @from == value
-      end
-    end
-  end
-end