Class: CequelStatefulEnum::Machine::Event

Inherits:
Object
  • Object
show all
Defined in:
lib/cequel_stateful_enum/machine.rb

Instance Method Summary collapse

Constructor Details

#initialize(model, column, states, name, &block) ⇒ Event

Returns a new instance of Event.

Raises:



23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
# File 'lib/cequel_stateful_enum/machine.rb', line 23

def initialize(model, column, states, name, &block)
  can = "can_#{name}?"
  raise DefinitionError, "one of the #{name}, #{name}! or #{can} methods already defined" if ([name, "#{name}!", can] & model.instance_methods).any?

  @states, @name, @transitions, @before, @after = states, name, {}, [], []
  instance_eval(&block) if block

  transitions, before, after = @transitions, @before, @after

  # defining event methods
  model.class_eval do
    define_method name do |danger = false|
      next false unless send(can, danger)
      to = transitions[send(column).to_sym].first
      before.each { |callback| instance_eval(&callback) }
      send("#{column}=", to)
      after.each { |callback| instance_eval(&callback) }
      true
    end

    define_method "#{name}!" do
      send(name, true)
    end

    define_method can do |danger = false|
      from = send(column).to_sym
      to, condition = transitions[from]
      if !to
        raise StateError, "can't fire #{name} event from state #{from}" if danger
        false
      elsif condition && !instance_exec(&condition)
        raise ConditionError, "conditions for #{name} event does not met" if danger
        false
      else
        true
      end
    end
  end
end

Instance Method Details

#after(symbol = nil, &block) ⇒ Object

Raises:

  • (ArgumentError) 


108
109
110
111
112
 
# File 'lib/cequel_stateful_enum/machine.rb', line 108

def after(symbol = nil, &block)
  raise ArgumentError, 'use Symbol or block for `after` callback' unless block_given? ? symbol.nil? : symbol.is_a?(Symbol)
  block ||= -> { send(symbol) }
  @after.push(block)
end

#all ⇒ Object 



98
99
100
 
# File 'lib/cequel_stateful_enum/machine.rb', line 98

def all
  @states
end

#before(symbol = nil, &block) ⇒ Object

Raises:

  • (ArgumentError) 


102
103
104
105
106
 
# File 'lib/cequel_stateful_enum/machine.rb', line 102

def before(symbol = nil, &block)
  raise ArgumentError, 'use Symbol or block for `before` callback' unless block_given? ? symbol.nil? : symbol.is_a?(Symbol)
  block ||= -> { send(symbol) }
  @before.push(block)
end

#transition(transitions) ⇒ Object 



63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
 
# File 'lib/cequel_stateful_enum/machine.rb', line 63

def transition(transitions)
  condition = transitions.delete(:if)
  unless condition.nil? || condition.is_a?(Symbol) || condition.respond_to?(:call)
    raise ArgumentError, "`if` condition can be nil, Symbol or callable object, but #{condition.class} given"
  end
  if condition.is_a?(Symbol)
    symbol = condition
    condition = -> { send(symbol) }
  end
  if unless_condition = transitions.delete(:unless)
    unless unless_condition.nil? || unless_condition.is_a?(Symbol) || unless_condition.respond_to?(:call)
      raise ArgumentError, "`unless` condition can be nil, Symbol or callable object, but #{unless_condition.class} given"
    end
    if unless_condition.is_a?(Symbol)
      symbol = unless_condition
      unless_condition = -> { send(symbol) }
    end
    condition = if condition
      if_condition = condition
      -> { instance_exec(&if_condition) && !instance_exec(&unless_condition) }
    else
      -> { !instance_exec(&unless_condition) }
    end
  end

  transitions.each_pair do |froms, to|
    raise DefinitionError, "undefined state #{to}" unless @states.include? to
    Array(froms).each do |from|
      raise DefinitionError, "undefined state #{from}" unless @states.include? from
      raise DefinitionError, "duplicate entry: transition from #{from} to #{@transitions[from].first} has already been defined" if @transitions[from]
      @transitions[from] = [to, condition]
    end
  end
end