Class: Belt::CLI::GenerateCommand

Inherits:

Object

• Object
• Belt::CLI::GenerateCommand

Includes:

AppDetection

Defined in:

lib/belt/cli/generate_command.rb

Constant Summary

TEMPLATE_DIR =

File.expand_path('../../templates/generate', __dir__)

GENERATORS =

%w[scaffold resource model controller environment frontend views].freeze

FIELD_TYPES =

%w[string text integer float boolean date datetime].freeze

GENERATOR_HELP =

{
  'scaffold' => {
    description: 'Generate a model, controller, routes, schema, and views for a REST resource.',
    usage: 'belt generate scaffold <name> [field:type ...] [options]',
    options: [
      ['--skip-views', 'Skip generating frontend view pages']
    ],
    examples: [
      ['belt g scaffold post title:string body:text', 'Post with title and body fields'],
      ['belt g scaffold comment author:string body:text status:string', 'Scaffold with multiple fields'],
      ['belt g scaffold task --skip-views', 'Scaffold 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
        frontend/src/pages/<names>/                        React pages (if frontend exists)

      Alias: `belt g resource` works the same way.
    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

• .parse_field(arg) ⇒ Object
• .print_generate_help ⇒ Object
• .print_generator_help(generator) ⇒ Object
• .run(args) ⇒ Object
• .validate_resource_name!(name, generator) ⇒ Object

Instance Method Summary

• #generate ⇒ Object
• #initialize(generator, name, fields, skip_views: false) ⇒ GenerateCommand constructor

  A new instance of GenerateCommand.

Methods included from AppDetection

#detect_app_name, #detect_environments, #detect_namespace, #s3_safe_name

Constructor Details

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

Returns a new instance of GenerateCommand.

# File 'lib/belt/cli/generate_command.rb', line 217

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

# File 'lib/belt/cli/generate_command.rb', line 116

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

.print_generate_help ⇒ Object

# File 'lib/belt/cli/generate_command.rb', line 146

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

    Generators:
      scaffold      Generate model, controller, routes, schema, and views (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

    Aliases:
      resource      Same as scaffold

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

    Examples:
      belt g scaffold 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

# File 'lib/belt/cli/generate_command.rb', line 177

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

# File 'lib/belt/cli/generate_command.rb', line 72

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 - ['resource']).join(', ')}"
    puts "\nRun 'belt generate --help' for usage information."
    exit 1
  end

  # Normalize: resource is an alias for scaffold
  generator = 'scaffold' if generator == 'resource'

  # Per-generator help: belt g scaffold --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

# File 'lib/belt/cli/generate_command.rb', line 127

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

# File 'lib/belt/cli/generate_command.rb', line 229

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