Class: Belt::CLI::GenerateCommand

Inherits:
Object
  • Object
show all
Includes:
AppDetection
Defined in:
lib/belt/cli/generate_command.rb

Constant Summary collapse

TEMPLATE_DIR = 
File.expand_path('../../templates/generate', __dir__)
GENERATORS = 
%w[resource model controller environment frontend views].freeze
FIELD_TYPES = 
%w[string text integer float boolean date datetime].freeze
GENERATOR_HELP = 
{
  'resource' => {
    description: 'Generate a model, controller, routes, and schema for a REST resource.',
    usage: 'belt generate resource <name> [field:type ...] [options]',
    options: [
      ['--skip-views', 'Skip generating frontend view pages']
    ],
    examples: [
      ['belt g resource post title:string body:text', 'Post with title and body fields'],
      ['belt g resource comment author:string body:text status:string', 'Comment with multiple fields'],
      ['belt g resource task --skip-views', 'Task resource without frontend pages']
    ],
    notes: <<~NOTES
      Creates:
        lambda/models/<name>.rb                            Model with validations and fields
        lambda/controllers/<app>/<names>_controller.rb    RESTful controller (index, show, create, update, destroy)
        infrastructure/routes.tf.rb                        Route entry added
        infrastructure/schema.tf.rb                        DynamoDB table schema added
        lambda/lib/routes/<app>_routes.rb                  Route manifest updated
    NOTES
  },
  'model' => {
    description: 'Generate an ActiveItem model with validations and DynamoDB field definitions.',
    usage: 'belt generate model <name> [field:type ...]',
    options: [],
    examples: [
      ['belt g model user email:string name:string', 'User model with email and name'],
      ['belt g model event title:string starts_at:datetime', 'Event model with datetime field']
    ],
    notes: <<~NOTES
      Creates:
        lambda/models/<name>.rb    Model class inheriting from ActiveItem::Base
    NOTES
  },
  'controller' => {
    description: 'Generate a controller with standard REST actions.',
    usage: 'belt generate controller <name>',
    options: [],
    examples: [
      ['belt g controller posts', 'Posts controller with CRUD actions'],
      ['belt g controller admin/users', 'Namespaced controller']
    ],
    notes: <<~NOTES
      Creates:
        lambda/controllers/<app>/<name>_controller.rb    Controller class
    NOTES
  }
}.freeze
RESERVED_NAMES = 
%w[
  help new edit create update destroy index show delete remove
  application base controller model resource generate
  belt setup environment frontend views routes
].freeze

Class Method Summary collapse

Instance Method Summary collapse

Methods included from AppDetection

#detect_app_name, #detect_namespace, #s3_safe_name

Constructor Details

#initialize(generator, name, fields, skip_views: false) ⇒ GenerateCommand

Returns a new instance of GenerateCommand.



208
209
210
211
212
213
214
215
216
217
218
 
# File 'lib/belt/cli/generate_command.rb', line 208

def initialize(generator, name, fields, skip_views: false)
  @generator = generator
  @name = name.downcase.gsub(/[^a-z0-9_]/, '_')
  @fields = fields
  @skip_views = skip_views
  @app_name = detect_namespace
  @module_name = @app_name.split(/[-_]/).map(&:capitalize).join
  @resource_name = @name.end_with?('s') ? @name : "#{@name}s"
  @singular_name = @name.end_with?('s') ? @name.chomp('s') : @name
  @class_name = @singular_name.split('_').map(&:capitalize).join
end

Class Method Details

.parse_field(arg) ⇒ Object 



110
111
112
113
 
# File 'lib/belt/cli/generate_command.rb', line 110

def self.parse_field(arg)
  name, type = arg.split(':', 2)
  { name: name, type: type || 'string' }
end

.print_generate_help ⇒ Object 



140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
 
# File 'lib/belt/cli/generate_command.rb', line 140

def self.print_generate_help
  puts <<~HELP
    Usage: belt generate <generator> <name> [field:type ...] [options]
           belt g <generator> <name> [field:type ...] [options]

    Generators:
      resource      Generate model, controller, routes, and schema (full REST resource)
      model         Generate an ActiveItem model
      controller    Generate a controller
      environment   Create a new deployment environment
      frontend      Scaffold a frontend app (react, vue, svelte)
      views         Generate React pages for a resource

    Field Types:
      #{FIELD_TYPES.join(', ')}

    Examples:
      belt g resource post title:string body:text status:string
      belt g model user email:string name:string
      belt g controller comments
      belt g environment staging
      belt g frontend react
      belt g views post title:string body:text

    Run 'belt generate <generator> --help' for detailed help on a specific generator.
  HELP
end

.print_generator_help(generator) ⇒ Object 



168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
 
# File 'lib/belt/cli/generate_command.rb', line 168

def self.print_generator_help(generator)
  info = GENERATOR_HELP[generator]

  unless info
    puts "Usage: belt generate #{generator} <name>"
    puts "\nRun 'belt generate #{generator} --help' is not yet documented."
    puts "Try 'belt generate --help' for the full list of generators."
    return
  end

  puts info[:description]
  puts
  puts "Usage: #{info[:usage]}"

  if info[:options].any?
    puts "\nOptions:"
    info[:options].each do |flag, desc|
      puts "  %-20s %s" % [flag, desc]
    end
  end

  puts "\nField Types:"
  puts "  #{FIELD_TYPES.join(', ')}"

  puts "\nExamples:"
  info[:examples].each do |cmd, desc|
    puts "  #{cmd}"
    puts "    #{desc}" if desc
  end

  puts "\n#{info[:notes]}" if info[:notes]

  puts "Naming Rules:"
  puts "  - Must start with a letter"
  puts "  - At least 2 characters"
  puts "  - Letters, numbers, and single underscores only"
  puts "  - No leading/trailing/consecutive underscores"
  puts "  - Cannot use reserved names (help, new, create, destroy, etc.)"
end

.run(args) ⇒ Object 



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
97
98
99
100
101
102
103
104
105
106
107
108
 
# File 'lib/belt/cli/generate_command.rb', line 69

def self.run(args)
  generator = args.shift

  # Top-level help: belt generate --help or belt generate (no args)
  if generator.nil? || generator =~ /\A-/
    print_generate_help
    exit 0
  end

  unless GENERATORS.include?(generator)
    puts "Unknown generator: '#{generator}'"
    puts "Available generators: #{GENERATORS.join(', ')}"
    puts "\nRun 'belt generate --help' for usage information."
    exit 1
  end

  # Per-generator help: belt g resource --help
  if args.include?('--help') || args.include?('-h')
    print_generator_help(generator)
    exit 0
  end

  return Belt::CLI::EnvironmentCommand.run(args) if generator == 'environment'

  return Belt::CLI::FrontendCommand.run(args) if generator == 'frontend'

  return Belt::CLI::ViewsCommand.run(args) if generator == 'views'

  name = args.shift
  if name.nil? || name.empty?
    print_generator_help(generator)
    exit 0
  end

  validate_resource_name!(name, generator)

  skip_views = args.delete('--skip-views')
  fields = args.map { |arg| parse_field(arg) }
  new(generator, name, fields, skip_views: skip_views).generate
end

.validate_resource_name!(name, generator) ⇒ Object 



121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
 
# File 'lib/belt/cli/generate_command.rb', line 121

def self.validate_resource_name!(name, generator)
  errors = []

  errors << 'must start with a letter' unless name.match?(/\A[a-zA-Z]/)
  errors << 'must be at least 2 characters' if name.length < 2
  errors << 'must only contain letters, numbers, and underscores' unless name.match?(/\A[a-zA-Z][a-zA-Z0-9_]*\z/)
  errors << 'must not start or end with an underscore' if name.match?(/\A_|_\z/)
  errors << 'must not contain consecutive underscores' if name.include?('__')
  errors << "is a reserved name" if RESERVED_NAMES.include?(name.downcase.chomp('s'))
  errors << "is a reserved name" if RESERVED_NAMES.include?(name.downcase)

  return if errors.empty?

  puts "\n✗ Invalid #{generator} name '#{name}':"
  errors.uniq.each { |e| puts "  - #{e}" }
  puts "\nName must start with a letter, be at least 2 characters, and contain only letters, numbers, and single underscores."
  exit 1
end

Instance Method Details

#generate ⇒ Object 



220
221
222
223
224
225
226
 
# File 'lib/belt/cli/generate_command.rb', line 220

def generate
  case @generator
  when 'resource'  then generate_resource
  when 'model'     then generate_model
  when 'controller' then generate_controller
  end
end