Class: Legion::CLI::Generate

Inherits:
Thor
  • Object
show all
Defined in:
lib/legion/cli/generate_command.rb

Constant Summary collapse

ACTOR_PARENTS = 
{
  'subscription' => 'Legion::Extensions::Actors::Subscription',
  'every'        => 'Legion::Extensions::Actors::Every',
  'poll'         => 'Legion::Extensions::Actors::Poll',
  'once'         => 'Legion::Extensions::Actors::Once',
  'loop'         => 'Legion::Extensions::Actors::Loop'
}.freeze

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.exit_on_failure? ⇒ Boolean

Returns:

  • (Boolean) 


16
17
18
 
# File 'lib/legion/cli/generate_command.rb', line 16

def self.exit_on_failure?
  true
end

Instance Method Details

#absorber(name) ⇒ Object 



130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
 
# File 'lib/legion/cli/generate_command.rb', line 130

def absorber(name)
  out = formatter
  lex = detect_lex(out)

  snake = name.downcase.gsub(/[^a-z0-9]/, '_')
  class_name = snake.split('_').map(&:capitalize).join
  lex_class = lex.split('_').map(&:capitalize).join
  url_pat = options[:url_pattern]

  absorber_path = "lib/legion/extensions/#{lex}/absorbers/#{snake}.rb"
  spec_path = "spec/absorbers/#{snake}_spec.rb"

  ensure_dir(File.dirname(absorber_path))
  ensure_dir(File.dirname(spec_path))

  File.write(absorber_path, absorber_template(lex_class, class_name, url_pat))
  File.write(spec_path, absorber_spec_template(lex_class, class_name, url_pat))

  out.success("Created #{absorber_path}")
  out.success("Created #{spec_path}")
end

#actor(name) ⇒ Object 



56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
 
# File 'lib/legion/cli/generate_command.rb', line 56

def actor(name)
  out = formatter
  lex = detect_lex(out)

  actor_path = "lib/legion/extensions/#{lex}/actors/#{name}.rb"
  spec_path = "spec/actors/#{name}_spec.rb"

  ensure_dir(File.dirname(actor_path))
  ensure_dir(File.dirname(spec_path))

  class_name = name.split('_').map(&:capitalize).join
  lex_class = lex.split('_').map(&:capitalize).join
  actor_type = options[:type]
  runner_name = options[:runner] || name
  interval = options[:interval]

  actor_opts = { lex_class: lex_class, class_name: class_name, type: actor_type,
                 runner_name: runner_name, interval: interval }
  File.write(actor_path, actor_template(**actor_opts))
  File.write(spec_path, actor_spec_template(**actor_opts))

  out.success("Created #{actor_path}")
  out.success("Created #{spec_path}")
  puts "  Actor type: #{actor_type}"
end

#exchange(name) ⇒ Object 



83
84
85
86
87
88
89
90
91
92
93
94
95
 
# File 'lib/legion/cli/generate_command.rb', line 83

def exchange(name)
  out = formatter
  lex = detect_lex(out)

  exchange_path = "lib/legion/extensions/#{lex}/transport/exchanges/#{name}.rb"
  ensure_dir(File.dirname(exchange_path))

  class_name = name.split('_').map(&:capitalize).join
  lex_class = lex.split('_').map(&:capitalize).join

  File.write(exchange_path, exchange_template(lex, lex_class, name, class_name))
  out.success("Created #{exchange_path}")
end

#message(name) ⇒ Object 



114
115
116
117
118
119
120
121
122
123
124
125
126
 
# File 'lib/legion/cli/generate_command.rb', line 114

def message(name)
  out = formatter
  lex = detect_lex(out)

  message_path = "lib/legion/extensions/#{lex}/transport/messages/#{name}.rb"
  ensure_dir(File.dirname(message_path))

  class_name = name.split('_').map(&:capitalize).join
  lex_class = lex.split('_').map(&:capitalize).join

  File.write(message_path, message_template(lex, lex_class, name, class_name))
  out.success("Created #{message_path}")
end

#queue(name) ⇒ Object 



99
100
101
102
103
104
105
106
107
108
109
110
111
 
# File 'lib/legion/cli/generate_command.rb', line 99

def queue(name)
  out = formatter
  lex = detect_lex(out)

  queue_path = "lib/legion/extensions/#{lex}/transport/queues/#{name}.rb"
  ensure_dir(File.dirname(queue_path))

  class_name = name.split('_').map(&:capitalize).join
  lex_class = lex.split('_').map(&:capitalize).join

  File.write(queue_path, queue_template(lex, lex_class, name, class_name))
  out.success("Created #{queue_path}")
end

#runner(name) ⇒ Object 



22
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
 
# File 'lib/legion/cli/generate_command.rb', line 22

def runner(name)
  out = formatter
  lex = detect_lex(out)

  runner_path = "lib/legion/extensions/#{lex}/runners/#{name}.rb"
  spec_path = "spec/runners/#{name}_spec.rb"

  ensure_dir(File.dirname(runner_path))
  ensure_dir(File.dirname(spec_path))

  class_name = name.split('_').map(&:capitalize).join
  lex_class = lex.split('_').map(&:capitalize).join

  functions = (options[:functions] || 'execute').split(',').map(&:strip)

  File.write(runner_path, runner_template(lex, lex_class, name, class_name, functions))
  File.write(spec_path, runner_spec_template(lex, lex_class, name, class_name, functions))

  out.success("Created #{runner_path}")
  out.success("Created #{spec_path}")

  return unless functions.any?

  out.spacer
  puts "  Functions scaffolded: #{functions.join(', ')}"
  puts "  Add actors with: legion generate actor #{name} --type subscription"
end

#tool(name) ⇒ Object 



153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
 
# File 'lib/legion/cli/generate_command.rb', line 153

def tool(name)
  out = formatter
  lex = detect_lex(out)

  tool_path = "lib/legion/extensions/#{lex}/tools/#{name}.rb"
  spec_path = "spec/tools/#{name}_spec.rb"

  ensure_dir(File.dirname(tool_path))
  ensure_dir(File.dirname(spec_path))

  class_name = name.split('_').map(&:capitalize).join
  lex_class = lex.split('_').map(&:capitalize).join

  File.write(tool_path, tool_template(lex, lex_class, name, class_name))
  File.write(spec_path, tool_spec_template(lex, lex_class, name, class_name))

  out.success("Created #{tool_path}")
  out.success("Created #{spec_path}")
end