Class: EventEngine::EventEngineHelpersWriter

Inherits:
Object
  • Object
show all
Defined in:
lib/event_engine/event_engine_helpers_writer.rb

Constant Summary collapse

HEADER = 
<<~RUBY.freeze
  # This file is authoritative in production.
  # It is generated from EventDefinitions via:
  #
  #   bin/rails event_engine:schema:dump
  #
  # Do not edit manually.

RUBY
ENVELOPE_KEYS = 
DslCompiler::RESERVED_INPUT_NAMES

Class Method Summary collapse

Class Method Details

.events_by_domain(event_schema) ⇒ Object 



64
65
66
67
68
 
# File 'lib/event_engine/event_engine_helpers_writer.rb', line 64

def self.events_by_domain(event_schema)
  event_schema.schemas_by_event.keys
    .group_by { |(domain, _event_name)| domain }
    .transform_values { |pairs| pairs.map { |(_domain, event_name)| event_name }.sort }
end

.flat_body(event_schema, emit) ⇒ Object 



52
53
54
55
56
 
# File 'lib/event_engine/event_engine_helpers_writer.rb', line 52

def self.flat_body(event_schema, emit)
  events_by_domain(event_schema).map do |domain, event_names|
    helpers_for(event_schema, domain, event_names, emit, indent: 2)
  end.join
end

.generate(event_schema, root_module: "EventEngine", emit: "EventEngine.emit", header: HEADER, group_by_domain: true, schema_filename: nil) ⇒ Object 



24
25
26
27
28
29
30
 
# File 'lib/event_engine/event_engine_helpers_writer.rb', line 24

def self.generate(event_schema, root_module: "EventEngine", emit: "EventEngine.emit",
                  header: HEADER, group_by_domain: true, schema_filename: nil)
  body = group_by_domain ? grouped_body(event_schema, emit) : flat_body(event_schema, emit)
  body = "#{schema_path_accessor(schema_filename)}#{body}#{pack_registration}" if schema_filename

  "#{header}#{pack_require if schema_filename}module #{root_module}\n#{body}end\n"
end

.grouped_body(event_schema, emit) ⇒ Object 



44
45
46
47
48
49
50
 
# File 'lib/event_engine/event_engine_helpers_writer.rb', line 44

def self.grouped_body(event_schema, emit)
  events_by_domain(event_schema).map do |domain, event_names|
    helpers = helpers_for(event_schema, domain, event_names, emit, indent: 4)

    "  module #{module_name(domain)}\n#{helpers}  end\n"
  end.join
end

.helper(domain, schema, emit, indent) ⇒ Object 



74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
 
# File 'lib/event_engine/event_engine_helpers_writer.rb', line 74

def self.helper(domain, schema, emit, indent)
  pad = " " * indent
  call_pad = " " * (indent + 2)
  arg_pad = " " * (indent + 4)

  arguments = [
    schema.event_name.inspect,
    "domain: #{domain.inspect}",
    "inputs: #{inputs_hash(schema)}",
    *ENVELOPE_KEYS.map { |name| "#{name}: #{name}" }
  ].map { |argument| "#{arg_pad}#{argument}" }.join(",\n")

  "#{pad}def self.#{schema.event_name}(#{signature(schema)})\n" \
    "#{call_pad}#{emit}(\n" \
    "#{arguments}\n" \
    "#{call_pad})\n" \
    "#{pad}end\n"
end

.helpers_for(event_schema, domain, event_names, emit, indent:) ⇒ Object 



58
59
60
61
62
 
# File 'lib/event_engine/event_engine_helpers_writer.rb', line 58

def self.helpers_for(event_schema, domain, event_names, emit, indent:)
  event_names.map do |event_name|
    helper(domain, event_schema.latest_for(event_name, domain: domain), emit, indent)
  end.join
end

.inputs_hash(schema) ⇒ Object 



101
102
103
104
105
106
 
# File 'lib/event_engine/event_engine_helpers_writer.rb', line 101

def self.inputs_hash(schema)
  inputs = schema.required_inputs + schema.optional_inputs
  return "{}" if inputs.empty?

  "{ #{inputs.map { |name| "#{name}: #{name}" }.join(", ")} }"
end

.module_name(domain) ⇒ Object 



70
71
72
 
# File 'lib/event_engine/event_engine_helpers_writer.rb', line 70

def self.module_name(domain)
  domain.to_s.split("_").map(&:capitalize).join
end

.pack_registration ⇒ Object 



36
37
38
 
# File 'lib/event_engine/event_engine_helpers_writer.rb', line 36

def self.pack_registration
  "\n  EventEngine::Definition.register_pack(self)\n"
end

.pack_require ⇒ Object 



32
33
34
 
# File 'lib/event_engine/event_engine_helpers_writer.rb', line 32

def self.pack_require
  %(require "event_engine/definition"\n\n)
end

.schema_path_accessor(filename) ⇒ Object 



40
41
42
 
# File 'lib/event_engine/event_engine_helpers_writer.rb', line 40

def self.schema_path_accessor(filename)
  "  def self.schema_path\n    File.expand_path(#{filename.inspect}, __dir__)\n  end\n"
end

.signature(schema) ⇒ Object 



93
94
95
96
97
98
99
 
# File 'lib/event_engine/event_engine_helpers_writer.rb', line 93

def self.signature(schema)
  required = schema.required_inputs.map { |name| "#{name}:" }
  optional = schema.optional_inputs.map { |name| "#{name}: nil" }
  envelope = ENVELOPE_KEYS.map { |name| "#{name}: nil" }

  (required + optional + envelope).join(", ")
end

.write(path, event_schema, root_module: "EventEngine", emit: "EventEngine.emit", header: HEADER, group_by_domain: true, schema_filename: nil) ⇒ Object 



15
16
17
18
19
20
21
22
 
# File 'lib/event_engine/event_engine_helpers_writer.rb', line 15

def self.write(path, event_schema, root_module: "EventEngine", emit: "EventEngine.emit",
               header: HEADER, group_by_domain: true, schema_filename: nil)
  File.write(
    path,
    generate(event_schema, root_module: root_module, emit: emit, header: header,
                           group_by_domain: group_by_domain, schema_filename: schema_filename)
  )
end