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 github.com/state-machines/state_machines). The generator also processes the extra methods generated by [StateMachines Active Record](github.com/state-machines/state_machines-activerecord) and [StateMachines ActiveModel](github.com/state-machines/state_machines-activemodel) integrations.

For example, with the following ‘Vehicle` class:

~~~rb 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:

~~~rbi # 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