Class: AlterEgo::State

Inherits:
Object
  • Object
show all
Extended by:
Assertions
Includes:
Assertions
Defined in:
lib/alter_ego.rb

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Assertions

assert, assert_exists, assert_keys, assert_one_or_more, deny

Class Method Details

.handle(request, method = nil, &block) ⇒ Object 



119
120
121
 
# File 'lib/alter_ego.rb', line 119

def self.handle(request, method = nil, &block)
  define_contextual_method_from_symbol_or_block(request, method, &block)
end

.handled_requests ⇒ Object 



111
112
113
 
# File 'lib/alter_ego.rb', line 111

def self.handled_requests
  public_instance_methods(false)
end

.identifier ⇒ Object 



103
104
105
 
# File 'lib/alter_ego.rb', line 103

def self.identifier
  self
end

.on_enter(method = nil, &block) ⇒ Object 



123
124
125
126
 
# File 'lib/alter_ego.rb', line 123

def self.on_enter(method = nil, &block)
  assert(method.nil? ^ block.nil?)
  define_contextual_method_from_symbol_or_block(:on_enter, method, &block)
end

.on_exit(method = nil, &block) ⇒ Object 



128
129
130
131
 
# File 'lib/alter_ego.rb', line 128

def self.on_exit(method = nil, &block)
  assert(method.nil? ^ block.nil?)
  define_contextual_method_from_symbol_or_block(:on_exit, method, &block)
end

.request_filters ⇒ Object 



115
116
117
 
# File 'lib/alter_ego.rb', line 115

def self.request_filters
  (@request_filters ||= [])
end

.transition(options, &trans_action) ⇒ Object 



76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
# File 'lib/alter_ego.rb', line 76

def self.transition(options, &trans_action)
  options.assert_valid_keys(:to, :on, :if)
  assert_keys(options, :to)
  guard    = options[:if]
  to_state = options[:to]
  request   = options[:on]
  if request
    handle(request) do
      transition_to(to_state, request)
    end
  end
  valid_transitions << to_state unless valid_transitions.include?(to_state)
  if guard
    method = guard.kind_of?(Symbol) ? guard : nil
    block  = guard.kind_of?(Proc) ? guard : nil
    predicate = AlterEgo.proc_from_symbol_or_block(method, &block)
    guard_proc = proc do
      result = instance_eval(&predicate)
      throw :cancel unless result
    end
    add_request_filter(request, to_state, guard_proc)
  end
  if trans_action
    add_request_filter(request, to_state, trans_action)
  end
end

.valid_transitions ⇒ Object 



107
108
109
 
# File 'lib/alter_ego.rb', line 107

def self.valid_transitions
  (@valid_transitions ||= [])
end

Instance Method Details

#==(other) ⇒ Object 



145
146
147
 
# File 'lib/alter_ego.rb', line 145

def ==(other)
  (self.identifier == other) or super(other)
end

#can_handle_request?(request) ⇒ Boolean

Returns:

  • (Boolean) 


149
150
151
152
 
# File 'lib/alter_ego.rb', line 149

def can_handle_request?(request)
  return true if respond_to?(request)
  return false
end

#identifier ⇒ Object 



141
142
143
 
# File 'lib/alter_ego.rb', line 141

def identifier
  self.class.identifier
end

#to_s ⇒ Object 



137
138
139
 
# File 'lib/alter_ego.rb', line 137

def to_s
  "<State:#{identifier}>"
end

#transition_to(context, request, new_state, *args) ⇒ Object 



154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
 
# File 'lib/alter_ego.rb', line 154

def transition_to(context, request, new_state, *args)
  return true if context.state == new_state
  new_state_obj = context.state_for_identifier(new_state)
  unless new_state_obj
    raise(InvalidTransitionError,
          "Context #{context.inspect} has no state '#{new_state}' defined")
  end

  continue = context.execute_request_filters(self.class.identifier,
                                             request,
                                             new_state)
  return false unless continue

  if (not valid_transitions.empty?) and (not valid_transitions.include?(new_state))
    raise(InvalidTransitionError,
          "Not allowed to transition from #{self.identifier} to #{new_state}")
  end

  on_exit(context)
  new_state_obj.on_enter(context)
  context.state=(new_state)
  assert(new_state == context.state)
  true
end

#valid_transitions ⇒ Object 



133
134
135
 
# File 'lib/alter_ego.rb', line 133

def valid_transitions
  self.class.valid_transitions
end