Class: MetaState::Machine

Inherits:
Object
  • Object
show all
Defined in:
lib/meta-state.rb

Direct Known Subclasses

SockJS::Session

Constant Summary collapse

NON_MESSAGES = 
[:on_exit, :on_enter]

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Machine

Returns a new instance of Machine.



99
100
101
102
 
# File 'lib/meta-state.rb', line 99

def initialize
  @debug_block = nil
  assign_state(self.class.default_state)
end

Instance Attribute Details

#current_state ⇒ Object (readonly)

Returns the value of attribute current_state.



98
99
100
 
# File 'lib/meta-state.rb', line 98

def current_state
  @current_state
end

Class Method Details

.add_state(state) ⇒ Object 



12
13
14
15
16
17
18
19
20
21
22
 
# File 'lib/meta-state.rb', line 12

def add_state(state)
  @default_state ||= state
  states
  @states[state] = true
  name = state.name.sub(/.*::/,'').downcase
  state_names
  @state_names[name] = state
  @state_names[name.to_sym] = state
  include state
  @void_state_module = nil
end

.build_void_state ⇒ Object 



66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
 
# File 'lib/meta-state.rb', line 66

def build_void_state
  methods = (self.states.keys.map do |state|
    state.instance_methods
  end.flatten + NON_MESSAGES).uniq

  @void_state_module = Module.new do
    methods.each do |method|
      if NON_MESSAGES.include?(method)
        define_method(method){|*args| }
      else
        define_method(method) do |*args|
          raise WrongStateError, "Message #{method} received in state #{current_state}"
        end
      end
    end
  end

  include @void_state_module
end

.default_state ⇒ Object 



30
31
32
 
# File 'lib/meta-state.rb', line 30

def default_state
  @default_state || superclass.default_state
end

.default_state=(state) ⇒ Object

Explicitly set the default (i.e. initial state) for an FSM Normally, this defaults to the first state defined, but some folks like to be explicit



44
45
46
 
# File 'lib/meta-state.rb', line 44

def default_state=(state)
  @default_state = state
end

.state(name, &block) ⇒ Object 



24
25
26
27
28
 
# File 'lib/meta-state.rb', line 24

def state(name, &block)
  mod = Module.new(&block)
  const_set(name, mod)
  add_state(mod)
end

.state_names ⇒ Object 



48
49
50
51
52
53
54
55
 
# File 'lib/meta-state.rb', line 48

def state_names
  @state_names ||= {}
  if Machine > superclass
    superclass.state_names.merge(@state_names)
  else
    @state_names
  end
end

.states ⇒ Object 



57
58
59
60
61
62
63
64
 
# File 'lib/meta-state.rb', line 57

def states
  @states ||= {}
  if Machine > superclass
    superclass.states.merge(@states)
  else
    @states
  end
end

.void_state_module ⇒ Object 



34
35
36
37
38
39
 
# File 'lib/meta-state.rb', line 34

def void_state_module
  if @void_state_module.nil?
    build_void_state
  end
  @void_state_module
end

Instance Method Details

#debug_with(&block) ⇒ Object 



94
95
96
 
# File 'lib/meta-state.rb', line 94

def debug_with(&block)
  @debug_block = block
end

#state=(state) ⇒ Object

Explicitly put an FSM into a particular state. Simultaneously enters a state of sin. Use sparingly if at all.



89
90
91
92
 
# File 'lib/meta-state.rb', line 89

def state=(state)
  mod = state_module(state)
  assign_state(mod)
end