Class: Tapioca::Compilers::Dsl::StateMachines

Inherits:
Base
  • Object
show all
Extended by:
T::Sig
Defined in:
lib/tapioca/compilers/dsl/state_machines.rb

Overview

RbiGenerator::StateMachines generates RBI files for classes that setup a state_machine (see https://github.com/state-machines/state_machines). The generator also processes the extra methods generated by StateMachines Active Record and StateMachines ActiveModel integrations.

For example, with the following Vehicle class:

class Vehicle
  state_machine :alarm_state, initial: :active, namespace: :'alarm' do
    event :enable do
      transition all => :active
    end

    event :disable do
      transition all => :off
    end

    state :active, :value => 1
    state :off, :value => 0
  end
end

this generator will produce the RBI file vehicle.rbi with the following content:

# vehicle.rbi
# typed: true
class Vehicle
  include Vehicle::StateMachineInstanceHelperModule
  extend Vehicle::StateMachineClassHelperModule
end

module Vehicle::StateMachineClassHelperModule
  sig { params(event: T.any(String, Symbol)).returns(String) }
  def human_alarm_state_event_name(event); end

  sig { params(state: T.any(String, Symbol)).returns(String) }
  def human_alarm_state_name(state); end
end

module Vehicle::StateMachineInstanceHelperModule
  sig { returns(T::Boolean) }
  def alarm_active?; end

  sig { returns(T::Boolean) }
  def alarm_off?; end

  sig { returns(Integer) }
  def alarm_state; end

  sig { params(value: Integer).returns(Integer) }
  def alarm_state=(value); end

  sig { params(state: T.any(String, Symbol)).returns(T::Boolean) }
  def alarm_state?(state); end

  sig { params(args: T.untyped).returns(T::Array[T.any(String, Symbol)]) }
  def alarm_state_events(*args); end

  sig { returns(T.any(String, Symbol)) }
  def alarm_state_name; end

  sig { params(args: T.untyped).returns(T::Array[::StateMachines::Transition]) }
  def alarm_state_paths(*args); end

  sig { params(args: T.untyped).returns(T::Array[::StateMachines::Transition]) }
  def alarm_state_transitions(*args); end

  sig { returns(T::Boolean) }
  def can_disable_alarm?; end

  sig { returns(T::Boolean) }
  def can_enable_alarm?; end

  sig { params(args: T.untyped).returns(T::Boolean) }
  def disable_alarm(*args); end

  sig { params(args: T.untyped).returns(T::Boolean) }
  def disable_alarm!(*args); end

  sig { params(args: T.untyped).returns(T.nilable(::StateMachines::Transition)) }
  def disable_alarm_transition(*args); end

  sig { params(args: T.untyped).returns(T::Boolean) }
  def enable_alarm(*args); end

  sig { params(args: T.untyped).returns(T::Boolean) }
  def enable_alarm!(*args); end

  sig { params(args: T.untyped).returns(T.nilable(::StateMachines::Transition)) }
  def enable_alarm_transition(*args); end

  sig { params(event: T.any(String, Symbol), args: T.untyped).returns(T::Boolean) }
  def fire_alarm_state_event(event, *args); end

  sig { returns(String) }
  def human_alarm_state_name; end
end

Instance Attribute Summary

Attributes inherited from Base

#processable_constants

Instance Method Summary collapse

Methods inherited from Base

#handles?, #initialize

Constructor Details

This class inherits a constructor from Tapioca::Compilers::Dsl::Base

Instance Method Details

#decorate(root, constant) ⇒ Object 



123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
 
# File 'lib/tapioca/compilers/dsl/state_machines.rb', line 123

def decorate(root, constant)
  return if constant.state_machines.empty?

  instance_module_name = "#{constant}::StateMachineInstanceHelperModule"
  class_module_name = "#{constant}::StateMachineClassHelperModule"

  instance_module = root.create_module(instance_module_name)
  class_module = root.create_module(class_module_name)

  constant.state_machines.each_value do |machine|
    state_type = state_type_for(machine)

    define_state_accessor(instance_module, machine, state_type)
    define_state_predicate(instance_module, machine)
    define_event_helpers(instance_module, machine)
    define_path_helpers(instance_module, machine)
    define_name_helpers(instance_module, class_module, machine)
    define_scopes(class_module, machine)

    define_state_methods(instance_module, machine)
    define_event_methods(instance_module, machine)
  end

  matching_integration_name = ::StateMachines::Integrations.match(constant)&.integration_name

  case matching_integration_name
  when :active_record
    define_activerecord_methods(instance_module)
  end

  root.path(constant) do |klass|
    klass.create_include(instance_module_name)
    klass.create_extend(class_module_name)
  end
end

#gather_constants ⇒ Object 



160
161
162
 
# File 'lib/tapioca/compilers/dsl/state_machines.rb', line 160

def gather_constants
  Object.descendants.select { |mod| mod < ::StateMachines::InstanceMethods }
end