yoker 0.1.0

data/lib/yoker/configuration.rb

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "toml-rb" if defined?(TomlRB)
+
+module Yoker
+  class Configuration
+    SUPPORTED_DATABASES = %w[postgresql mysql sqlite3].freeze
+    SUPPORTED_VERSION_MANAGERS = %w[mise rbenv rvm none].freeze
+    SUPPORTED_CONTAINERS = %w[docker-compose docker none].freeze
+    SUPPORTED_ADDITIONAL_SERVICES = %w[redis sidekiq mailcatcher].freeze
+
+    DEFAULT_RUBY_VERSION = RUBY_VERSION
+    DEFAULT_DATABASE = "postgresql"
+    DEFAULT_VERSION_MANAGER = "mise"
+    DEFAULT_CONTAINER = "docker-compose"
+
+    attr_accessor :app_name, :ruby_version, :database, :version_manager,
+                  :container, :additional_services, :force_overwrite,
+                  :backup_existing, :verbose, :database_port, :database_username,
+                  :database_password, :database_host
+
+    def initialize(options = {})
+      @app_name = options[:app_name] || detect_app_name
+      @ruby_version = options[:ruby_version] || DEFAULT_RUBY_VERSION
+      @database = options[:database] || DEFAULT_DATABASE
+      @version_manager = options[:version_manager] || DEFAULT_VERSION_MANAGER
+      @container = options[:container] || DEFAULT_CONTAINER
+      @additional_services = Array(options[:additional_services])
+      @force_overwrite = options[:force_overwrite] || false
+      @backup_existing = options[:backup_existing] || true
+      @verbose = options[:verbose] || false
+
+      # Database-specific settings
+      @database_port = options[:database_port] || default_database_port
+      @database_username = options[:database_username] || default_database_username
+      @database_password = options[:database_password] || default_database_password
+      @database_host = options[:database_host] || default_database_host
+
+      validate!
+    end
+
+    def to_h
+      {
+        app_name: app_name,
+        ruby_version: ruby_version,
+        database: database,
+        version_manager: version_manager,
+        container: container,
+        additional_services: additional_services,
+        force_overwrite: force_overwrite,
+        backup_existing: backup_existing,
+        verbose: verbose,
+        database_port: database_port,
+        database_username: database_username,
+        database_password: database_password,
+        database_host: database_host
+      }
+    end
+
+    def self.from_file(path)
+      return new unless File.exist?(path)
+
+      case File.extname(path)
+      when ".yml", ".yaml"
+        from_yaml(path)
+      when ".toml"
+        from_toml(path)
+      else
+        raise InvalidConfigurationError, "Unsupported configuration file format: #{path}"
+      end
+    end
+
+    def self.from_yaml(path)
+      config = YAML.safe_load(File.read(path), symbolize_names: true)
+      new(config)
+    rescue StandardError => e
+      raise InvalidConfigurationError, "Failed to load YAML configuration: #{e.message}"
+    end
+
+    def self.from_toml(path)
+      raise InvalidConfigurationError, "toml-rb gem required to load TOML configuration" unless defined?(TomlRB)
+
+      config = TomlRB.load_file(path)
+      symbolized_config = deep_symbolize_keys(config)
+      new(symbolized_config)
+    rescue StandardError => e
+      raise InvalidConfigurationError, "Failed to load TOML configuration: #{e.message}"
+    end
+
+    def save_to_file(path)
+      case File.extname(path)
+      when ".yml", ".yaml"
+        File.write(path, to_h.to_yaml)
+      when ".toml"
+        raise InvalidConfigurationError, "toml-rb gem required to save TOML configuration" unless defined?(TomlRB)
+
+        File.write(path, TomlRB.dump(to_h.stringify_keys))
+      else
+        raise InvalidConfigurationError, "Unsupported configuration file format: #{path}"
+      end
+    end
+
+    # Validation methods
+    def valid?
+      validate!
+      true
+    rescue InvalidConfigurationError
+      false
+    end
+
+    def postgresql?
+      database == "postgresql"
+    end
+
+    def mysql?
+      database == "mysql"
+    end
+
+    def sqlite?
+      database == "sqlite3"
+    end
+
+    def uses_containers?
+      container != "none"
+    end
+
+    def uses_docker_compose?
+      container == "docker-compose"
+    end
+
+    def uses_version_manager?
+      version_manager != "none"
+    end
+
+    def uses_mise?
+      version_manager == "mise"
+    end
+
+    def includes_service?(service)
+      additional_services.include?(service.to_s)
+    end
+
+    def database_service_needed?
+      uses_containers? && !sqlite?
+    end
+
+    def redis_needed?
+      includes_service?("redis") || includes_service?("sidekiq")
+    end
+
+    # Merge configurations (for updating existing configs)
+    def merge!(other_config)
+      return self unless other_config.is_a?(Configuration)
+
+      other_config.to_h.each do |key, value|
+        public_send("#{key}=", value) if respond_to?("#{key}=") && !value.nil?
+      end
+
+      validate!
+      self
+    end
+
+    private
+
+    def validate!
+      validate_database!
+      validate_version_manager!
+      validate_container!
+      validate_additional_services!
+      validate_ruby_version!
+      validate_app_name!
+      validate_compatibility!
+    end
+
+    def validate_database!
+      return if SUPPORTED_DATABASES.include?(database)
+
+      raise UnsupportedDatabaseError, database
+    end
+
+    def validate_version_manager!
+      return if SUPPORTED_VERSION_MANAGERS.include?(version_manager)
+
+      raise UnsupportedVersionManagerError, version_manager
+    end
+
+    def validate_container!
+      return if SUPPORTED_CONTAINERS.include?(container)
+
+      raise UnsupportedContainerError, container
+    end
+
+    def validate_additional_services!
+      invalid_services = additional_services - SUPPORTED_ADDITIONAL_SERVICES
+      unless invalid_services.empty?
+        raise InvalidConfigurationError,
+              "Unsupported additional services: #{invalid_services.join(", ")}"
+      end
+
+      # Validate service dependencies
+      return unless includes_service?("sidekiq") && !includes_service?("redis")
+
+      raise ConfigurationConflictError,
+            "Sidekiq requires Redis. Please include 'redis' in additional_services"
+    end
+
+    def validate_ruby_version!
+      return if ruby_version.match?(/\A\d+\.\d+(\.\d+)?\z/)
+
+      raise InvalidConfigurationError,
+            "Invalid Ruby version format: #{ruby_version}. Expected format: X.Y.Z"
+    end
+
+    def validate_app_name!
+      raise InvalidConfigurationError, "App name cannot be empty" if app_name.nil? || app_name.empty?
+
+      return if app_name.match?(/\A[a-zA-Z0-9_-]+\z/)
+
+      raise InvalidConfigurationError,
+            "App name contains invalid characters. Only alphanumeric, underscore, and hyphen allowed"
+    end
+
+    def validate_compatibility!
+      # SQLite doesn't need containers for database
+      if sqlite? && uses_containers?
+        # This is allowed but warn that database container won't be created
+      end
+
+      # Some services only make sense with containers
+      if !uses_containers? && includes_service?("mailcatcher")
+        raise ConfigurationConflictError,
+              "Mailcatcher service requires containerization (Docker or Docker Compose)"
+      end
+
+      # Version manager compatibility
+      nil unless version_manager == "mise" && !uses_containers?
+      # Mise can manage database tools natively
+    end
+
+    def detect_app_name
+      if File.exist?("config/application.rb")
+        # Try to extract from Rails application.rb
+        content = File.read("config/application.rb")
+        return ::Regexp.last_match(1).downcase if content =~ /module\s+(\w+)/
+      end
+
+      # Fallback to directory name
+      File.basename(Dir.pwd).gsub(/[^a-zA-Z0-9]/, "_").downcase
+    end
+
+    def default_database_port
+      case database
+      when "postgresql" then 5432
+      when "mysql" then 3306
+      when "sqlite3" then nil
+      end
+    end
+
+    def default_database_username
+      case database
+      when "postgresql"
+        uses_containers? ? "postgres" : ENV["USER"] || "postgres"
+      when "mysql"
+        uses_containers? ? "rails" : "root"
+      when "sqlite3" then nil
+      end
+    end
+
+    def default_database_password
+      case database
+      when "postgresql", "mysql"
+        uses_containers? ? "password" : ""
+      when "sqlite3" then nil
+      end
+    end
+
+    def default_database_host
+      uses_containers? ? "db" : "localhost"
+    end
+
+    def self.deep_symbolize_keys(hash)
+      hash.each_with_object({}) do |(key, value), result|
+        new_key = key.to_sym
+        new_value = value.is_a?(Hash) ? deep_symbolize_keys(value) : value
+        result[new_key] = new_value
+      end
+    end
+  end
+end

data/lib/yoker/detectors/database_detector.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Yoker
+  module Detectors
+    class DatabaseDetector
+      def self.detect
+        return "postgresql" if gemfile_includes?("pg")
+        return "mysql" if gemfile_includes?("mysql2")
+        return "sqlite3" if gemfile_includes?("sqlite3")
+
+        # Check database.yml
+        detect_from_database_yml
+      end
+
+      private
+
+      def self.gemfile_includes?(gem_name)
+        return false unless File.exist?("Gemfile")
+
+        File.read("Gemfile").include?(gem_name)
+      end
+
+      def self.detect_from_database_yml
+        return nil unless File.exist?("config/database.yml")
+
+        db_config = File.read("config/database.yml")
+        return "postgresql" if db_config.include?("postgresql") || db_config.include?("adapter: postgresql")
+        return "mysql" if db_config.include?("mysql") || db_config.include?("adapter: mysql2")
+        return "sqlite3" if db_config.include?("sqlite") || db_config.include?("adapter: sqlite3")
+
+        nil
+      end
+    end
+  end
+end

data/lib/yoker/detectors/rails_detector.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Yoker
+  module Detectors
+    class RailsDetector
+      def self.rails_app?
+        File.exist?("config/application.rb") &&
+          File.exist?("Gemfile") &&
+          File.read("Gemfile").include?("rails")
+      end
+
+      def self.rails_version
+        return nil unless rails_app?
+        
+        # Try to get version from Gemfile.lock first
+        if File.exist?("Gemfile.lock")
+          gemfile_lock = File.read("Gemfile.lock")
+          # Look for the rails gem specifically in the GEM section
+          # Format: "    rails (8.1.0.beta1)"
+          if gemfile_lock =~ /^\s{4}rails\s+\(([^)]+)\)/
+            return $1
+          end
+        end
+        
+        # Fallback to checking Rails constant if available
+        begin
+          require_relative File.expand_path("config/application", Dir.pwd)
+          return Rails::VERSION::STRING if defined?(Rails::VERSION::STRING)
+        rescue
+          nil
+        end
+        
+        nil
+      rescue
+        nil
+      end
+
+      def self.rails_api_only?
+        return false unless rails_app?
+        
+        app_rb = File.read("config/application.rb")
+        app_rb.include?("config.api_only = true")
+      rescue
+        false
+      end
+    end
+  end
+end

data/lib/yoker/detectors/version_manager_detector.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Yoker
+  module Detectors
+    class VersionManagerDetector
+      # Preference order for version managers
+      PREFERENCE_ORDER = %w[mise rvm rbenv].freeze
+
+      def self.detect
+        # First, check which version managers are actually installed
+        installed_managers = detect_installed_managers
+
+        return "none" if installed_managers.empty?
+
+        # Check for configuration files that match installed managers
+        file_based_detection = detect_from_files
+
+        # If we found a config file for an installed manager, use it
+        return file_based_detection if file_based_detection && installed_managers.include?(file_based_detection)
+
+        # Otherwise, return the highest priority installed manager
+        PREFERENCE_ORDER.each do |manager|
+          return manager if installed_managers.include?(manager)
+        end
+
+        "none"
+      end
+
+      def self.detect_installed_managers
+        managers = []
+
+        # Check for mise
+        managers << "mise" if command_exists?("mise")
+
+        # Check for rvm
+        managers << "rvm" if command_exists?("rvm")
+
+        # Check for rbenv
+        managers << "rbenv" if command_exists?("rbenv")
+
+        managers
+      end
+
+      def self.detect_from_files
+        # Check for version manager configuration files
+        return "mise" if File.exist?("mise.toml") || File.exist?(".mise.toml")
+        return "mise" if File.exist?(".tool-versions") # mise/asdf format
+        return "rvm" if File.exist?(".rvmrc") || File.exist?(".ruby-gemset")
+        # .ruby-version alone suggests rbenv
+        return "rbenv" if File.exist?(".ruby-version") && !File.exist?(".ruby-gemset")
+
+        nil
+      end
+
+      def self.command_exists?(command)
+        system("which #{command} > /dev/null 2>&1")
+      end
+
+      def self.current_ruby_version
+        RUBY_VERSION
+      end
+
+      def self.ruby_version_from_file
+        if File.exist?("mise.toml")
+          extract_ruby_from_mise_toml
+        elsif File.exist?(".ruby-version")
+          File.read(".ruby-version").strip
+        elsif File.exist?(".tool-versions")
+          extract_ruby_from_tool_versions
+        end
+      end
+
+      private
+
+      def self.extract_ruby_from_mise_toml
+        content = File.read("mise.toml")
+        ::Regexp.last_match(1) if content =~ /ruby\s*=\s*["']([^"']+)["']/
+      rescue StandardError
+        nil
+      end
+
+      def self.extract_ruby_from_tool_versions
+        content = File.read(".tool-versions")
+        ruby_line = content.lines.find { |line| line.start_with?("ruby ") }
+        ruby_line&.split&.last&.strip
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/yoker/errors.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Yoker
+  # Base error class for all Yoker errors
+  class Error < StandardError; end
+
+  # Raised when not in a Rails application directory
+  class NotRailsAppError < Error
+    def initialize(path = Dir.pwd)
+      super("Directory '#{path}' is not a Rails application. Please run from Rails app root.")
+    end
+  end
+
+  # Raised when required external tools are missing
+  class MissingDependencyError < Error
+    def initialize(tool, installation_hint = nil)
+      message = "Required tool '#{tool}' is not installed or not in PATH."
+      message += " #{installation_hint}" if installation_hint
+      super(message)
+    end
+  end
+
+  # Raised when Docker is not running or accessible
+  class DockerNotAvailableError < MissingDependencyError
+    def initialize
+      super(
+        "Docker",
+        "Please ensure Docker is installed and running. Visit https://docs.docker.com/get-docker/"
+      )
+    end
+  end
+
+  # Raised when version manager is not available
+  class VersionManagerNotAvailableError < MissingDependencyError
+    def initialize(manager)
+      hints = {
+        "mise" => "Install with: curl https://mise.run | sh",
+        "rbenv" => "Install with: brew install rbenv ruby-build",
+        "rvm" => "Install with: \\curl -sSL https://get.rvm.io | bash"
+      }
+
+      super(manager, hints[manager])
+    end
+  end
+
+  # Raised when configuration is invalid
+  class InvalidConfigurationError < Error
+    def initialize(message)
+      super("Invalid configuration: #{message}")
+    end
+  end
+
+  # Raised when unsupported database is specified
+  class UnsupportedDatabaseError < InvalidConfigurationError
+    def initialize(database)
+      supported = %w[postgresql mysql sqlite3]
+      super("Database '#{database}' is not supported. Supported: #{supported.join(", ")}")
+    end
+  end
+
+  # Raised when unsupported version manager is specified
+  class UnsupportedVersionManagerError < InvalidConfigurationError
+    def initialize(manager)
+      supported = %w[mise rbenv rvm none]
+      super("Version manager '#{manager}' is not supported. Supported: #{supported.join(", ")}")
+    end
+  end
+
+  # Raised when unsupported container option is specified
+  class UnsupportedContainerError < InvalidConfigurationError
+    def initialize(container)
+      supported = %w[docker-compose docker none]
+      super("Container option '#{container}' is not supported. Supported: #{supported.join(", ")}")
+    end
+  end
+
+  # Raised when file operations fail
+  class FileOperationError < Error
+    def initialize(operation, path, reason = nil)
+      message = "Failed to #{operation} '#{path}'"
+      message += ": #{reason}" if reason
+      super(message)
+    end
+  end
+
+  # Raised when template is missing or invalid
+  class TemplateError < Error
+    def initialize(template_path, reason = nil)
+      message = "Template error for '#{template_path}'"
+      message += ": #{reason}" if reason
+      super(message)
+    end
+  end
+
+  # Raised when generator fails
+  class GeneratorError < Error
+    def initialize(generator_name, reason)
+      super("Generator '#{generator_name}' failed: #{reason}")
+    end
+  end
+
+  # Raised when service fails to start (Docker containers, etc.)
+  class ServiceStartupError < Error
+    def initialize(service_name, timeout = nil)
+      message = "Service '#{service_name}' failed to start"
+      message += " within #{timeout} seconds" if timeout
+      super(message)
+    end
+  end
+
+  # Raised when database operations fail
+  class DatabaseError < Error
+    def initialize(operation, database, reason = nil)
+      message = "Database operation '#{operation}' failed for #{database}"
+      message += ": #{reason}" if reason
+      super(message)
+    end
+  end
+
+  # Raised when Ruby version conflicts occur
+  class RubyVersionError < Error
+    def initialize(required, current)
+      super("Ruby version mismatch. Required: #{required}, Current: #{current}")
+    end
+  end
+
+  # Raised when conflicting configurations are detected
+  class ConfigurationConflictError < InvalidConfigurationError
+    def initialize(conflict_description)
+      super("Configuration conflict: #{conflict_description}")
+    end
+  end
+
+  # Raised when backup operations fail
+  class BackupError < FileOperationError
+    def initialize(path, reason = nil)
+      super("backup", path, reason)
+    end
+  end
+
+  # Raised when network operations fail (downloading, etc.)
+  class NetworkError < Error
+    def initialize(operation, reason = nil)
+      message = "Network operation failed: #{operation}"
+      message += " (#{reason})" if reason
+      super(message)
+    end
+  end
+end