discharger 0.2.10 → 0.2.12

data/lib/discharger/setup_runner/commands/database_command.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require_relative "base_command"
+require "open3"
+
+module Discharger
+  module SetupRunner
+    module Commands
+      class DatabaseCommand < BaseCommand
+        def execute
+          # Drop and recreate development database
+          terminate_database_connections
+          with_spinner("Dropping and recreating development database") do
+            _stdout, stderr, status = Open3.capture3("bash", "-c", "bin/rails db:drop db:create > /dev/null 2>&1")
+            if status.success?
+              {success: true}
+            else
+              {success: false, error: "Failed to drop/create database: #{stderr}"}
+            end
+          end
+
+          # Load schema and run migrations
+          with_spinner("Loading database schema and running migrations") do
+            _stdout, stderr, status = Open3.capture3("bin/rails db:schema:load db:migrate")
+            if status.success?
+              {success: true}
+            else
+              {success: false, error: "Failed to load schema: #{stderr}"}
+            end
+          end
+
+          # Seed the database
+          env = (config.respond_to?(:seed_env) && config.seed_env) ? {"SEED_DEV_ENV" => "true"} : {}
+          with_spinner("Seeding the database") do
+            _stdout, stderr, status = Open3.capture3(env, "bin/rails db:seed")
+            if status.success?
+              {success: true}
+            else
+              {success: false, error: "Failed to seed database: #{stderr}"}
+            end
+          end
+
+          # Setup test database
+          terminate_database_connections("test")
+          with_spinner("Setting up test database") do
+            _stdout, stderr, status = Open3.capture3({"RAILS_ENV" => "test"}, "bash", "-c", "bin/rails db:drop db:create db:schema:load > /dev/null 2>&1")
+            if status.success?
+              {success: true}
+            else
+              {success: false, error: "Failed to setup test database: #{stderr}"}
+            end
+          end
+
+          # Clear logs and temp files
+          with_spinner("Clearing logs and temp files") do
+            _stdout, _stderr, status = Open3.capture3("bash", "-c", "bin/rails log:clear tmp:clear > /dev/null 2>&1")
+            if status.success?
+            else
+              # Don't fail for log clearing
+            end
+            {success: true}
+          end
+        end
+
+        def can_execute?
+          File.exist?(File.join(app_root, "bin/rails"))
+        end
+
+        def description
+          "Setup database"
+        end
+
+        private
+
+        def terminate_database_connections(rails_env = nil)
+          # Use a Rails runner to terminate connections within the Rails context
+          env_vars = rails_env ? {"RAILS_ENV" => rails_env} : {}
+
+          runner_script = <<~RUBY
+            begin
+              # Only proceed if using PostgreSQL
+              if defined?(ActiveRecord::Base) && ActiveRecord::Base.connection.adapter_name =~ /postgresql/i
+                ActiveRecord::Base.connection.execute <<-SQL
+                  SELECT pg_terminate_backend(pid)
+                  FROM pg_stat_activity
+                  WHERE datname = current_database() AND pid <> pg_backend_pid();
+                SQL
+              end
+            rescue => e
+              # If we can't connect or terminate, that's okay - the database might not exist yet
+              # Log error silently in test environment
+              puts "Note: Could not terminate existing connections: \#{e.message}" unless ENV['QUIET_SETUP']
+            end
+          RUBY
+
+          with_spinner("Terminating existing database connections#{rails_env ? " (#{rails_env})" : ""}") do
+            stdout, stderr, status = Open3.capture3(env_vars, "bin/rails", "runner", runner_script)
+
+            if status.success?
+              logger&.debug("Output: #{stdout}") if stdout && !stdout.empty?
+            elsif stderr && !stderr.empty?
+              logger&.debug("Error: #{stderr}")
+              # Don't fail if we can't terminate connections - the database might not exist
+            end
+            {success: true}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/discharger/setup_runner/commands/docker_command.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative "base_command"
+
+module Discharger
+  module SetupRunner
+    module Commands
+      class DockerCommand < BaseCommand
+        def execute
+          log "Ensure Docker is running"
+
+          unless system_quiet("docker info > /dev/null 2>&1")
+            log "Starting Docker..."
+            system_quiet("open -a Docker")
+            sleep 10
+            unless system_quiet("docker info > /dev/null 2>&1")
+              log "Docker is not running. Please start Docker manually."
+              return
+            end
+          end
+
+          # Setup database container if configured
+          if config.respond_to?(:database) && config.database
+            setup_container(
+              name: config.database.name || "db-app",
+              port: config.database.port || 5432,
+              image: "postgres:#{config.database.version || "14"}",
+              env: {"POSTGRES_PASSWORD" => config.database.password || "postgres"},
+              volume: "#{config.database.name || "db-app"}:/var/lib/postgresql/data",
+              internal_port: 5432
+            )
+          end
+
+          # Setup Redis container if configured
+          if config.respond_to?(:redis) && config.redis
+            setup_container(
+              name: config.redis.name || "redis-app",
+              port: config.redis.port || 6379,
+              image: "redis:#{config.redis.version || "latest"}",
+              internal_port: 6379
+            )
+          end
+        end
+
+        def can_execute?
+          # Only execute if Docker is available and containers are configured
+          system_quiet("which docker") && (
+            (config.respond_to?(:database) && config.database) ||
+            (config.respond_to?(:redis) && config.redis)
+          )
+        end
+
+        def description
+          "Setup Docker containers"
+        end
+
+        private
+
+        def setup_container(name:, port:, image:, internal_port:, env: {}, volume: nil)
+          log "Checking #{name} container"
+
+          if system_quiet("docker ps | grep #{name} > /dev/null 2>&1")
+            log "#{name} container is already running"
+            return
+          end
+
+          # Check if container exists but is stopped
+          if system_quiet("docker inspect #{name} > /dev/null 2>&1")
+            log "Starting existing #{name} container"
+            unless system_quiet("docker start #{name}")
+              log "Removing failed #{name} container"
+              system_quiet("docker rm -f #{name}")
+              create_container(name: name, port: port, image: image, env: env, volume: volume, internal_port: internal_port)
+            end
+          else
+            create_container(name: name, port: port, image: image, env: env, volume: volume, internal_port: internal_port)
+          end
+
+          # Verify container is running
+          sleep 2
+          unless system_quiet("docker ps | grep #{name} > /dev/null 2>&1")
+            log "#{name} container failed to start"
+            raise "#{name} container failed to start"
+          end
+        end
+
+        def create_container(name:, port:, image:, internal_port:, env: {}, volume: nil)
+          log "Creating new #{name} container"
+
+          cmd = ["docker", "run", "-d", "--name", name, "-p", "#{port}:#{internal_port}"]
+          env.each { |k, v| cmd.push("-e", "#{k}=#{v}") }
+          cmd.push("-v", volume) if volume
+          cmd.push(image)
+
+          system!(*cmd)
+        end
+      end
+    end
+  end
+end

data/lib/discharger/setup_runner/commands/env_command.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "base_command"
+
+module Discharger
+  module SetupRunner
+    module Commands
+      class EnvCommand < BaseCommand
+        def execute
+          if File.exist?(".env")
+            unless ENV["QUIET_SETUP"] || ENV["DISABLE_OUTPUT"]
+              require "rainbow"
+              puts Rainbow("  → .env file already exists. Skipping.").yellow
+            end
+            return
+          end
+
+          unless File.exist?(".env.example")
+            unless ENV["QUIET_SETUP"] || ENV["DISABLE_OUTPUT"]
+              require "rainbow"
+              puts Rainbow("  → WARNING: .env.example not found. Skipping .env creation").yellow
+            end
+            return
+          end
+
+          simple_action("Creating .env from .env.example") do
+            FileUtils.cp(".env.example", ".env")
+          end
+        end
+
+        def can_execute?
+          File.exist?(".env.example")
+        end
+
+        def description
+          "Setup environment file"
+        end
+      end
+    end
+  end
+end

data/lib/discharger/setup_runner/commands/git_command.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "base_command"
+
+module Discharger
+  module SetupRunner
+    module Commands
+      class GitCommand < BaseCommand
+        def execute
+          log "Setting up git configuration"
+
+          # Set up commit template if it exists
+          commit_template = File.join(app_root, ".commit-template")
+          if File.exist?(commit_template)
+            system! "git config --local commit.template .commit-template"
+            log "Git commit template configured"
+          end
+
+          # Set up git hooks if .githooks directory exists
+          githooks_dir = File.join(app_root, ".githooks")
+          if File.directory?(githooks_dir)
+            system! "git config --local core.hooksPath .githooks"
+            log "Git hooks path configured"
+          end
+
+          # Any other git config from the setup.yml
+          if config.respond_to?(:git_config) && config.git_config
+            config.git_config.each do |key, value|
+              system! "git config --local #{key} '#{value}'"
+              log "Set git config #{key}"
+            end
+          end
+        end
+
+        def can_execute?
+          File.directory?(File.join(app_root, ".git"))
+        end
+
+        def description
+          "Setup git configuration"
+        end
+      end
+    end
+  end
+end

data/lib/discharger/setup_runner/commands/yarn_command.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "base_command"
+
+module Discharger
+  module SetupRunner
+    module Commands
+      class YarnCommand < BaseCommand
+        def execute
+          log "Installing Node modules"
+
+          # Enable corepack if yarn.lock exists (Yarn 2+)
+          if File.exist?(File.join(app_root, "yarn.lock"))
+            if system_quiet("which corepack")
+              system! "corepack enable"
+              system! "corepack use yarn@stable"
+            end
+
+            # Install dependencies
+            system_quiet("yarn check --check-files > /dev/null 2>&1") || system!("yarn install")
+          elsif File.exist?(File.join(app_root, "package-lock.json"))
+            # NPM project
+            log "Found package-lock.json, using npm"
+            system! "npm ci"
+          elsif File.exist?(File.join(app_root, "package.json"))
+            # Generic package.json - try yarn first, fall back to npm
+            if system_quiet("which yarn")
+              system! "yarn install"
+            else
+              system! "npm install"
+            end
+          end
+        end
+
+        def can_execute?
+          File.exist?(File.join(app_root, "package.json"))
+        end
+
+        def description
+          "Install JavaScript dependencies"
+        end
+      end
+    end
+  end
+end

data/lib/discharger/setup_runner/condition_evaluator.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Discharger
+  module SetupRunner
+    class ConditionEvaluator
+      class << self
+        def evaluate(condition, context = {})
+          return true if condition.nil? || condition.strip.empty?
+          ast = Prism.parse(condition).value
+          raise "Parse error" unless ast
+          evaluate_node(ast)
+        rescue => e
+          log_warning("Condition evaluation failed: #{e.message}")
+          false
+        end
+
+        private
+
+        def evaluate_node(node)
+          case node.type
+          when :program_node
+            # Evaluate the first statement in the program
+            stmts = node.statements
+            if stmts&.body&.any?
+              evaluate_node(stmts.body.first)
+            else
+              true
+            end
+          when :statements_node
+            # Evaluate the first statement
+            if node.body.any?
+              evaluate_node(node.body.first)
+            else
+              true
+            end
+          when :and_node
+            left = evaluate_node(node.left)
+            right = evaluate_node(node.right)
+            left && right
+          when :or_node
+            left = evaluate_node(node.left)
+            right = evaluate_node(node.right)
+            left || right
+          when :call_node
+            # Handle method calls
+            if node.receiver&.type == :constant_read_node
+              case node.receiver.name
+              when :ENV
+                if node.name == :[]
+                  ENV[evaluate_node(node.arguments.arguments.first)]
+                else
+                  raise "Unsafe ENV method: #{node.name}"
+                end
+              when :File
+                case node.name
+                when :exist?
+                  File.exist?(evaluate_node(node.arguments.arguments.first))
+                when :directory?
+                  File.directory?(evaluate_node(node.arguments.arguments.first))
+                when :file?
+                  File.file?(evaluate_node(node.arguments.arguments.first))
+                else
+                  raise "Unsafe File method: #{node.name}"
+                end
+              when :Dir
+                if node.name == :exist?
+                  Dir.exist?(evaluate_node(node.arguments.arguments.first))
+                else
+                  raise "Unsafe Dir method: #{node.name}"
+                end
+              else
+                raise "Unsafe method call: #{node.receiver.name}.#{node.name}"
+              end
+            elsif node.receiver&.type == :call_node
+              # Handle chained calls like ENV['FOO'] == 'bar'
+              if node.name == :==
+                left = evaluate_node(node.receiver)
+                right = evaluate_node(node.arguments.arguments.first)
+                left == right
+              elsif node.name == :!=
+                left = evaluate_node(node.receiver)
+                right = evaluate_node(node.arguments.arguments.first)
+                left != right
+              else
+                raise "Unsafe operator: #{node.name}"
+              end
+            elsif node.receiver.nil?
+              # Method call without receiver (like system)
+              raise "Unsafe method call: #{node.name}"
+            else
+              raise "Unsafe method call: #{node.receiver&.name}.#{node.name}"
+            end
+          when :constant_read_node
+            node.name
+          when :string_node
+            node.unescaped
+          when :true_node # standard:disable Lint/BooleanSymbol
+            true
+          when :false_node # standard:disable Lint/BooleanSymbol
+            false
+          when :array_node
+            node.elements.map { |el| evaluate_node(el) }
+          when :symbol_node
+            node.unescaped
+          when :integer_node
+            node.value
+          when :x_string_node
+            # Backtick commands - block for security
+            raise "Unsafe backtick command"
+          when :parentheses_node
+            # Evaluate the expression inside parentheses
+            evaluate_node(node.body)
+          else
+            raise "Unsafe node: #{node.type}"
+          end
+        end
+
+        def log_warning(message)
+          if defined?(Rails)
+            Rails.logger.warn(message)
+          else
+            warn("[SetupRunner] #{message}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/discharger/setup_runner/configuration.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Discharger
+  module SetupRunner
+    class Configuration
+      attr_accessor :app_name, :db_config, :redis_config, :services, :steps, :custom_steps
+
+      def initialize
+        @app_name = "Application"
+        @db_config = DatabaseConfig.new
+        @redis_config = RedisConfig.new
+        @services = []
+        @steps = []
+        @custom_steps = []
+      end
+
+      def self.from_file(path)
+        config = new
+        yaml = YAML.load_file(path)
+
+        # Handle empty YAML files
+        return config if yaml.nil? || yaml == false
+
+        config.app_name = yaml["app_name"] if yaml["app_name"]
+        config.db_config.from_hash(yaml["database"]) if yaml["database"]
+        config.redis_config.from_hash(yaml["redis"]) if yaml["redis"]
+        config.services = yaml["services"] || []
+        config.steps = yaml["steps"] || []
+        config.custom_steps = yaml["custom_steps"] || []
+
+        config
+      end
+    end
+
+    class DatabaseConfig
+      attr_accessor :port, :name, :version, :password
+
+      def initialize
+        @port = 5432
+        @name = "db-app"
+        @version = "14"
+        @password = "postgres"
+      end
+
+      def from_hash(hash)
+        @port = hash["port"] if hash["port"]
+        @name = hash["name"] if hash["name"]
+        @version = hash["version"] if hash["version"]
+        @password = hash["password"] if hash["password"]
+      end
+    end
+
+    class RedisConfig
+      attr_accessor :port, :name, :version
+
+      def initialize
+        @port = 6379
+        @name = "redis-app"
+        @version = "latest"
+      end
+
+      def from_hash(hash)
+        @port = hash["port"] if hash["port"]
+        @name = hash["name"] if hash["name"]
+        @version = hash["version"] if hash["version"]
+      end
+    end
+  end
+end

data/lib/discharger/setup_runner/runner.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "logger"
+require_relative "command_factory"
+
+module Discharger
+  module SetupRunner
+    class Error < StandardError; end
+
+    class Runner
+      attr_reader :config, :app_root, :logger, :command_factory
+
+      def initialize(config, app_root = nil, logger = nil)
+        @config = config
+        @app_root = app_root || Dir.pwd
+        @logger = logger || Logger.new($stdout)
+        @command_factory = CommandFactory.new(config, app_root, logger)
+      end
+
+      def run
+        require "rainbow"
+        unless ENV["QUIET_SETUP"] || ENV["DISABLE_OUTPUT"]
+          puts Rainbow("\n🚀 Starting setup for #{config.app_name}").bright.blue
+          puts Rainbow("=" * 50).blue
+        end
+
+        FileUtils.chdir app_root do
+          execute_commands
+        end
+
+        unless ENV["QUIET_SETUP"] || ENV["DISABLE_OUTPUT"]
+          puts Rainbow("\n✅ Setup completed successfully!").bright.green
+        end
+      rescue => e
+        unless ENV["QUIET_SETUP"] || ENV["DISABLE_OUTPUT"]
+          puts Rainbow("\n❌ Setup failed: #{e.message}").bright.red
+        end
+        raise Error, e.message
+      end
+
+      def add_command(command)
+        commands << command
+      end
+
+      def remove_command(command_name)
+        commands.reject! { |cmd| cmd.class.name.demodulize.underscore == command_name.to_s }
+      end
+
+      def replace_command(command_name, new_command)
+        remove_command(command_name)
+        add_command(new_command)
+      end
+
+      def insert_command_before(target_command_name, new_command)
+        target_index = commands.find_index { |cmd| cmd.class.name.demodulize.underscore == target_command_name.to_s }
+        if target_index
+          commands.insert(target_index, new_command)
+        else
+          add_command(new_command)
+        end
+      end
+
+      def insert_command_after(target_command_name, new_command)
+        target_index = commands.find_index { |cmd| cmd.class.name.demodulize.underscore == target_command_name.to_s }
+        if target_index
+          commands.insert(target_index + 1, new_command)
+        else
+          add_command(new_command)
+        end
+      end
+
+      private
+
+      def commands
+        @commands ||= command_factory.create_all_commands
+      end
+
+      def execute_commands
+        commands.each do |command|
+          execute_command(command)
+        end
+      end
+
+      def execute_command(command)
+        unless command.can_execute?
+          unless ENV["QUIET_SETUP"] || ENV["DISABLE_OUTPUT"]
+            require "rainbow"
+            puts Rainbow("⏭️  Skipping #{command.description} (prerequisites not met)").yellow
+          end
+          return
+        end
+
+        unless ENV["QUIET_SETUP"] || ENV["DISABLE_OUTPUT"]
+          puts Rainbow("\n▶️  #{command.description}").bright
+        end
+        command.execute
+      rescue => e
+        unless ENV["QUIET_SETUP"] || ENV["DISABLE_OUTPUT"]
+          require "rainbow"
+          puts Rainbow("❌ Command #{command.description} failed: #{e.message}").red
+        end
+        raise e
+      end
+
+      def log(message)
+        logger.info message
+      end
+    end
+  end
+end

data/lib/discharger/setup_runner/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Discharger
+  module SetupRunner
+    VERSION = "0.1.0"
+  end
+end