better_app_gen 0.1.0

data/lib/better_app_gen/cli.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require "thor"
+require "pastel"
+require "tty-spinner"
+
+module BetterAppGen
+  # CLI class for handling command-line interactions
+  class CLI < Thor
+    def self.exit_on_failure?
+      true
+    end
+
+    desc "new APP_NAME", "Generate a new Rails 8 application with an opinionated stack"
+    long_desc <<~LONGDESC
+      Creates a new Rails 8 application with a production-ready stack including:
+
+      - Solid Cache/Queue/Cable (PostgreSQL-backed instead of Redis)
+      - Vite 7 + Tailwind CSS 4 for assets
+      - Multi-database setup (primary, cache, queue, cable)
+      - Docker development environment (optional)
+      - UUID primary keys by default
+      - Configurable locale and timezone
+
+      Examples:
+        better_app_gen new my-blog
+        better_app_gen new my-app --with-simple-form
+        better_app_gen new my-app --rails-port 3001 --vite-port 5174
+        better_app_gen new my-app --skip-docker
+        better_app_gen new my-app --locale it
+    LONGDESC
+    method_option :with_simple_form, type: :boolean, default: false,
+                                     desc: "Include SimpleForm with Tailwind CSS styling"
+    method_option :rails_port, type: :numeric, default: 3000,
+                               desc: "Rails server port (default: 3000)"
+    method_option :vite_port, type: :numeric, default: 5173,
+                              desc: "Vite dev server port (default: 5173)"
+    method_option :skip_docker, type: :boolean, default: false,
+                                desc: "Skip Docker configuration"
+    method_option :locale, type: :string, default: "en",
+                           desc: "Default locale (en, it, de, fr, es, pt, nl, pl, ru, ja, zh)"
+    def new(app_name)
+      pastel = Pastel.new
+
+      # Create configuration
+      begin
+        config = Configuration.new(
+          app_name: app_name,
+          rails_port: options[:rails_port],
+          vite_port: options[:vite_port],
+          locale: options[:locale],
+          with_simple_form: options[:with_simple_form],
+          skip_docker: options[:skip_docker]
+        )
+      rescue Error => e
+        say pastel.red("Error: #{e.message}")
+        exit 1
+      end
+
+      # Check if directory already exists
+      if Dir.exist?(config.app_path)
+        say pastel.red("Error: Directory '#{app_name}' already exists.")
+        exit 1
+      end
+
+      # Verify dependencies
+      checker = DependencyChecker.new
+      unless checker.check_all
+        say pastel.red("\nMissing required dependencies:")
+        checker.missing_dependencies.each { |dep| say pastel.red("  - #{dep}") }
+        say pastel.yellow("\nPlease install the missing dependencies and try again.")
+        exit 1
+      end
+
+      # Generate the application
+      say pastel.green("\nGenerating Rails 8 application: #{app_name}\n")
+
+      generator = AppGenerator.new(config)
+      generator.generate!
+
+      # Success message
+      say pastel.green("\nApplication '#{app_name}' created successfully!")
+      say pastel.cyan("\nNext steps:")
+      say "  cd #{app_name}"
+
+      if options[:skip_docker]
+        say "  bundle install"
+        say "  yarn install"
+        say "  rails db:create db:schema:load"
+        say "  bin/dev              # Start Rails + Vite"
+      else
+        say "  script/dc-up         # Start Docker containers"
+        say "  script/dc-shell      # Open shell in Rails container"
+        say "  rails db:create      # Create databases"
+        say "  rails db:schema:load # Load schema"
+        say "  exit                 # Exit shell"
+        say "  script/dc-down && script/dc-up  # Restart containers"
+      end
+
+      # Warn if locale doesn't have translation files
+      warn_about_missing_locale_files(config.locale, pastel)
+
+      say pastel.cyan("\nHappy coding!")
+    end
+
+    desc "check", "Verify that all required dependencies are installed"
+    def check
+      pastel = Pastel.new
+      say pastel.cyan("\nChecking dependencies...\n")
+
+      checker = DependencyChecker.new
+      checker.check_all(verbose: true)
+    end
+
+    desc "version", "Show better_app_gen version"
+    def version
+      puts "better_app_gen v#{VERSION}"
+    end
+
+    # Version aliases
+    map %w[-v --version] => :version
+
+    # Locales that have translation templates included
+    LOCALES_WITH_TEMPLATES = %w[en it].freeze
+
+    private
+
+    def warn_about_missing_locale_files(locale, pastel)
+      return if LOCALES_WITH_TEMPLATES.include?(locale)
+
+      say pastel.yellow("\nNote: Locale '#{locale}' does not include translation files.")
+      say pastel.yellow("You may want to add translations from the rails-i18n gem:")
+      say pastel.yellow("  https://github.com/svenfuchs/rails-i18n")
+    end
+  end
+end

data/lib/better_app_gen/configuration.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module BetterAppGen
+  # Immutable configuration object holding all options for app generation
+  class Configuration
+    attr_reader :app_name, :rails_port, :vite_port, :locale, :with_simple_form, :skip_docker, :app_path,
+                :app_name_snake, :app_name_pascal, :app_name_dash
+
+    # Valid locale codes supported by the generator
+    SUPPORTED_LOCALES = %w[en it de fr es pt nl pl ru ja zh].freeze
+
+    def initialize(app_name:, rails_port: 3000, vite_port: 5173, locale: "en",
+                   with_simple_form: false, skip_docker: false, app_path: nil)
+      @app_name = app_name
+      @rails_port = rails_port
+      @vite_port = vite_port
+      @locale = locale
+      @with_simple_form = with_simple_form
+      @skip_docker = skip_docker
+      @app_path = app_path || File.expand_path(app_name, Dir.pwd)
+
+      # Compute derived values before freezing
+      @app_name_snake = app_name.tr("-", "_")
+      @app_name_pascal = @app_name_snake.split("_").map(&:capitalize).join
+      @app_name_dash = app_name.tr("_", "-")
+
+      validate!
+      freeze
+    end
+
+    # Returns the timezone based on locale
+    def timezone
+      case locale
+      when "it" then "Europe/Rome"
+      when "de" then "Europe/Berlin"
+      when "fr" then "Europe/Paris"
+      when "es" then "Europe/Madrid"
+      when "pt" then "Europe/Lisbon"
+      when "nl" then "Europe/Amsterdam"
+      when "pl" then "Europe/Warsaw"
+      when "ru" then "Europe/Moscow"
+      when "ja" then "Asia/Tokyo"
+      when "zh" then "Asia/Shanghai"
+      else "UTC"
+      end
+    end
+
+    # Returns a hash representation for template binding
+    def to_binding_hash
+      {
+        app_name: app_name,
+        app_name_snake: app_name_snake,
+        app_name_pascal: app_name_pascal,
+        app_name_dash: app_name_dash,
+        rails_port: rails_port,
+        vite_port: vite_port,
+        locale: locale,
+        timezone: timezone,
+        with_simple_form: with_simple_form,
+        skip_docker: skip_docker
+      }
+    end
+
+    private
+
+    def validate!
+      validate_app_name!
+      validate_locale!
+      validate_ports!
+    end
+
+    def validate_app_name!
+      return if app_name.match?(/\A[a-zA-Z][a-zA-Z0-9_-]*\z/)
+
+      raise InvalidAppNameError, app_name
+    end
+
+    def validate_locale!
+      return if SUPPORTED_LOCALES.include?(locale)
+
+      raise Error, "Unsupported locale '#{locale}'. Supported locales: #{SUPPORTED_LOCALES.join(", ")}"
+    end
+
+    def validate_ports!
+      raise Error, "Rails port must be between 1024 and 65535" unless (1024..65_535).include?(rails_port)
+      raise Error, "Vite port must be between 1024 and 65535" unless (1024..65_535).include?(vite_port)
+      raise Error, "Rails port and Vite port must be different" if rails_port == vite_port
+    end
+  end
+end

data/lib/better_app_gen/dependency_checker.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "English"
+module BetterAppGen
+  # Checks for required system dependencies
+  class DependencyChecker
+    REQUIRED_DEPENDENCIES = {
+      "ruby" => { command: "ruby --version", min_version: "3.2.0" },
+      "rails" => { command: "rails --version", min_version: "8.0.0" },
+      "node" => { command: "node --version", min_version: "20.0.0" },
+      "yarn" => { command: "yarn --version", min_version: "4.0.0" },
+      "git" => { command: "git --version", min_version: nil },
+      "psql" => { command: "psql --version", min_version: nil }
+    }.freeze
+
+    attr_reader :pastel
+
+    def initialize
+      @pastel = Pastel.new
+      @results = {}
+    end
+
+    # Check all dependencies, optionally with verbose output
+    # Returns true if all dependencies are met
+    def check_all(verbose: false)
+      missing = []
+
+      REQUIRED_DEPENDENCIES.each do |name, config|
+        result = check_dependency(name, config)
+        @results[name] = result
+
+        print_result(name, result) if verbose
+        missing << name unless result[:satisfied]
+      end
+
+      if verbose
+        puts
+        if missing.empty?
+          puts pastel.green("All dependencies satisfied!")
+        else
+          puts pastel.red("Missing dependencies: #{missing.join(", ")}")
+        end
+      end
+
+      missing.empty?
+    end
+
+    # Check a specific dependency
+    def check(name)
+      config = REQUIRED_DEPENDENCIES[name.to_s]
+      raise Error, "Unknown dependency: #{name}" unless config
+
+      check_dependency(name.to_s, config)[:satisfied]
+    end
+
+    # Returns missing dependencies as an array
+    def missing_dependencies
+      @results.reject { |_, r| r[:satisfied] }.keys
+    end
+
+    private
+
+    def check_dependency(_name, config)
+      # Run command outside of bundler environment to detect system-wide installations
+      output = nil
+      installed = false
+
+      Bundler.with_unbundled_env do
+        output = `#{config[:command]} 2>&1`.strip
+        installed = $CHILD_STATUS.success?
+      end
+
+      if installed && config[:min_version]
+        version = extract_version(output)
+        version_ok = version_satisfied?(version, config[:min_version])
+        {
+          satisfied: version_ok,
+          installed: true,
+          version: version,
+          min_version: config[:min_version]
+        }
+      else
+        {
+          satisfied: installed,
+          installed: installed,
+          version: installed ? extract_version(output) : nil,
+          min_version: config[:min_version]
+        }
+      end
+    end
+
+    def extract_version(output)
+      # Match common version patterns like "1.2.3", "v1.2.3", "Ruby 3.2.0", etc.
+      match = output.match(/v?(\d+\.\d+(?:\.\d+)?)/i)
+      match ? match[1] : nil
+    end
+
+    def version_satisfied?(current, required)
+      return true unless required && current
+
+      current_parts = current.split(".").map(&:to_i)
+      required_parts = required.split(".").map(&:to_i)
+
+      # Compare each version part
+      required_parts.each_with_index do |req_part, i|
+        cur_part = current_parts[i] || 0
+        return true if cur_part > req_part
+        return false if cur_part < req_part
+      end
+
+      true
+    end
+
+    def print_result(name, result)
+      if result[:satisfied]
+        status = pastel.green("OK")
+        version_info = result[:version] ? " (#{result[:version]})" : ""
+        puts "  #{status} #{name}#{version_info}"
+      else
+        status = pastel.red("MISSING")
+        if result[:installed] && result[:min_version]
+          puts "  #{status} #{name} - version #{result[:version]} < #{result[:min_version]} required"
+        else
+          puts "  #{status} #{name}"
+        end
+      end
+    end
+  end
+end

data/lib/better_app_gen/errors.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module BetterAppGen
+  # Base error class for all BetterAppGen errors
+  class Error < StandardError; end
+
+  # Raised when a required dependency is missing
+  class DependencyError < Error
+    attr_reader :missing_dependencies
+
+    def initialize(missing_dependencies)
+      @missing_dependencies = missing_dependencies
+      super("Missing required dependencies: #{missing_dependencies.join(", ")}")
+    end
+  end
+
+  # Raised when the app name is invalid
+  class InvalidAppNameError < Error
+    def initialize(app_name)
+      super("Invalid app name '#{app_name}'. App name must start with a letter and contain only letters, " \
+            "numbers, hyphens, and underscores.")
+    end
+  end
+
+  # Raised when the target directory already exists
+  class DirectoryExistsError < Error
+    def initialize(path)
+      super("Directory '#{path}' already exists. Please choose a different name or remove the existing directory.")
+    end
+  end
+
+  # Raised when a template file is not found
+  class TemplateNotFoundError < Error
+    def initialize(template_path)
+      super("Template file not found: #{template_path}")
+    end
+  end
+
+  # Raised when a shell command fails
+  class CommandFailedError < Error
+    attr_reader :command, :exit_code
+
+    def initialize(command, exit_code)
+      @command = command
+      @exit_code = exit_code
+      super("Command '#{command}' failed with exit code #{exit_code}")
+    end
+  end
+
+  # Raised when Rails app generation fails
+  class RailsGenerationError < Error
+    def initialize(message = "Failed to generate Rails application")
+      super
+    end
+  end
+end

data/lib/better_app_gen/generators/base.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+require "English"
+require "erb"
+require "fileutils"
+require "json"
+require "securerandom"
+
+module BetterAppGen
+  module Generators
+    # Base class for all generators with ERB template support
+    class Base
+      attr_reader :config
+
+      def initialize(config)
+        @config = config
+      end
+
+      # Main entry point for the generator - subclasses must implement
+      def generate!
+        raise NotImplementedError, "Subclasses must implement #generate!"
+      end
+
+      protected
+
+      # Delegate config accessors
+      def app_name = config.app_name
+      def app_name_snake = config.app_name_snake
+      def app_name_pascal = config.app_name_pascal
+      def app_name_dash = config.app_name_dash
+      def rails_port = config.rails_port
+      def vite_port = config.vite_port
+      def locale = config.locale
+      def timezone = config.timezone
+      def with_simple_form = config.with_simple_form
+      def skip_docker = config.skip_docker
+      def app_path = config.app_path
+
+      # Returns the templates directory path
+      def templates_path
+        BetterAppGen.templates_path
+      end
+
+      # Reads and renders an ERB template file
+      def render_template(template_name, trim_mode: "-")
+        template_file = templates_path.join(template_name)
+        raise TemplateNotFoundError, template_file unless template_file.exist?
+
+        template_content = template_file.read
+        ERB.new(template_content, trim_mode: trim_mode).result(binding)
+      end
+
+      # Creates a file with the given content
+      def create_file(relative_path, content)
+        full_path = File.join(app_path, relative_path)
+        FileUtils.mkdir_p(File.dirname(full_path))
+        File.write(full_path, content)
+      end
+
+      # Creates a file from an ERB template
+      def create_file_from_template(relative_path, template_name)
+        content = render_template(template_name)
+        create_file(relative_path, content)
+      end
+
+      # Reads a file from the app directory
+      def read_file(relative_path)
+        full_path = File.join(app_path, relative_path)
+        File.read(full_path)
+      end
+
+      # Updates a file with new content
+      def update_file(relative_path, content)
+        full_path = File.join(app_path, relative_path)
+        File.write(full_path, content)
+      end
+
+      # Checks if a file exists in the app directory
+      def file_exists?(relative_path)
+        full_path = File.join(app_path, relative_path)
+        File.exist?(full_path)
+      end
+
+      # Appends content to a file if not already present
+      def append_to_file(relative_path, content)
+        full_path = File.join(app_path, relative_path)
+        current_content = File.read(full_path)
+        return if current_content.include?(content)
+
+        File.write(full_path, current_content + content)
+      end
+
+      # Inserts content before a matching pattern
+      def insert_before(relative_path, pattern, content)
+        full_path = File.join(app_path, relative_path)
+        current_content = File.read(full_path)
+        new_content = current_content.gsub(pattern) { |match| content + match }
+        File.write(full_path, new_content)
+      end
+
+      # Inserts content after a matching pattern
+      def insert_after(relative_path, pattern, content)
+        full_path = File.join(app_path, relative_path)
+        current_content = File.read(full_path)
+        new_content = current_content.gsub(pattern) { |match| match + content }
+        File.write(full_path, new_content)
+      end
+
+      # Replaces content matching a pattern
+      def gsub_file(relative_path, pattern, replacement)
+        full_path = File.join(app_path, relative_path)
+        current_content = File.read(full_path)
+        new_content = current_content.gsub(pattern, replacement)
+        File.write(full_path, new_content)
+      end
+
+      # Intelligent Gemfile merge - adds gems without duplicates
+      def merge_gemfile(gems_to_add)
+        gemfile_path = File.join(app_path, "Gemfile")
+        current_content = File.read(gemfile_path)
+
+        gems_to_add.each do |gem_line|
+          # Extract gem name from line (e.g., gem "solid_cache" -> solid_cache)
+          gem_name = gem_line.match(/gem ["']([^"']+)["']/)[1]
+
+          # Skip if gem already present
+          next if current_content.match?(/gem ["']#{Regexp.escape(gem_name)}["']/)
+
+          # Insert before development group if exists, otherwise append
+          if current_content.match?(/group :development do/)
+            insert_before("Gemfile", /group :development do/, "#{gem_line}\n")
+          else
+            append_to_file("Gemfile", "\n#{gem_line}\n")
+          end
+          current_content = File.read(gemfile_path)
+        end
+      end
+
+      # Intelligent package.json merge
+      def merge_package_json(dependencies: {}, dev_dependencies: {}, scripts: {}, extra: {})
+        package_path = File.join(app_path, "package.json")
+
+        package_data = if File.exist?(package_path)
+                         JSON.parse(File.read(package_path))
+        else
+                         { "name" => app_name_dash, "private" => true }
+        end
+
+        # Merge dependencies
+        package_data["dependencies"] ||= {}
+        package_data["dependencies"].merge!(dependencies)
+
+        # Merge devDependencies
+        package_data["devDependencies"] ||= {}
+        package_data["devDependencies"].merge!(dev_dependencies)
+
+        # Merge scripts
+        package_data["scripts"] ||= {}
+        package_data["scripts"].merge!(scripts)
+
+        # Merge extra fields
+        extra.each { |key, value| package_data[key] = value }
+
+        # Write formatted JSON
+        File.write(package_path, JSON.pretty_generate(package_data))
+      end
+
+      # Creates a directory
+      def create_directory(relative_path)
+        full_path = File.join(app_path, relative_path)
+        FileUtils.mkdir_p(full_path)
+      end
+
+      # Copies a file within the app directory
+      def copy_file(source_path, destination_path)
+        source_full = File.join(app_path, source_path)
+        dest_full = File.join(app_path, destination_path)
+        FileUtils.mkdir_p(File.dirname(dest_full))
+        FileUtils.cp(source_full, dest_full)
+      end
+
+      # Makes a file executable
+      def chmod_executable(relative_path)
+        full_path = File.join(app_path, relative_path)
+        FileUtils.chmod("+x", full_path)
+      end
+
+      # Removes a file or directory
+      def remove_file(relative_path)
+        full_path = File.join(app_path, relative_path)
+        FileUtils.rm_rf(full_path)
+      end
+
+      # Generates a timestamp for migrations
+      def migration_timestamp(offset_seconds = 0)
+        (Time.now + offset_seconds).utc.strftime("%Y%m%d%H%M%S")
+      end
+
+      # Runs a shell command in the app directory
+      def run_command(command, capture: false)
+        Dir.chdir(app_path) do
+          if capture
+            `#{command}`
+          else
+            system(command)
+          end
+        end
+      end
+
+      # Runs a shell command and raises on failure
+      def run_command!(command)
+        Dir.chdir(app_path) do
+          success = system(command)
+          raise CommandFailedError.new(command, $CHILD_STATUS.exitstatus) unless success
+        end
+      end
+    end
+  end
+end

data/lib/better_app_gen/generators/database.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module BetterAppGen
+  module Generators
+    # Sets up database configuration and migrations
+    class Database < Base
+      def generate!
+        create_database_yml
+        create_migrations
+        create_db_rake_task
+        create_schema_settings_initializer
+      end
+
+      private
+
+      def create_database_yml
+        create_file_from_template("config/database.yml", "config/database.yml.erb")
+      end
+
+      def create_migrations
+        # UUID extension migration
+        create_file_from_template(
+          "db/migrate/#{migration_timestamp(0)}_enable_uuid_extension.rb",
+          "db/migrate/enable_uuid_extension.rb.erb"
+        )
+
+        # Shared schema migration
+        create_file_from_template(
+          "db/migrate/#{migration_timestamp(1)}_create_shared_schema.rb",
+          "db/migrate/create_shared_schema.rb.erb"
+        )
+
+        # Solid Cache migration
+        create_file_from_template(
+          "db/cache_migrate/#{migration_timestamp(2)}_create_solid_cache_schema.rb",
+          "db/cache_migrate/create_solid_cache_schema.rb.erb"
+        )
+
+        # Solid Queue migration
+        create_file_from_template(
+          "db/queue_migrate/#{migration_timestamp(3)}_create_solid_queue_schema.rb",
+          "db/queue_migrate/create_solid_queue_schema.rb.erb"
+        )
+
+        # Solid Cable migration
+        create_file_from_template(
+          "db/cable_migrate/#{migration_timestamp(4)}_create_solid_cable_schema.rb",
+          "db/cable_migrate/create_solid_cable_schema.rb.erb"
+        )
+      end
+
+      def create_db_rake_task
+        create_file_from_template("lib/tasks/db.rake", "lib/tasks/db.rake.erb")
+      end
+
+      def create_schema_settings_initializer
+        create_file_from_template(
+          "config/initializers/active_record_schema_settings.rb",
+          "config/initializers/active_record_schema_settings.rb.erb"
+        )
+      end
+    end
+  end
+end