kdeploy 1.2.1 → 1.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d8190b20e37d5dcf26ea9834e8ccf2f2a9b9c396dd44a48b294e7d0c643bdcd8
-  data.tar.gz: 0af02ac4d1fbb6c76983e30841ec6940d9fb8539a3e642095cc305f108b94eae
+  metadata.gz: a675dda751570dd0f5fce2042bfc5a68411e03e869d78bf8569739644bf8021f
+  data.tar.gz: 3b4861d5ba0c55f57ab2ace6a9e4bf3ae963076767e0db23f5a444b380efb861
 SHA512:
-  metadata.gz: 468ff349e53c460a39e5bd0553dab1ed747c9038fb319ff0e2e4f6ad6d5bdb766e3e6a2072b6ba4ac06b6d78967ba7e3f2955e984bbac21f1fc7431fde3df6c4
-  data.tar.gz: 6f5bb7bf536f1945dec267c6a816de9f29f1bdc1dea8a43e8b103f3e670f274c9f998a435308492f2fc56850cc81cc88b868982eb9447b06f35bed9f32aa08e7
+  metadata.gz: 4e2952dfbc5956c61ad1f58cdc8fb45a9d050a331f1f224ea3233d8f9e6618d06f5c86382e6446fecbdcc86f624a24600c672dda5fcd2ea26c535d3f16068fc9
+  data.tar.gz: 7edd9ae73dfe74015798197cd9cf03309aeb4a6d3ca065a1224710f4dc02b42fdbc4a6a17a541cba40a83f4637e324746627b023e7ce5475a3481a04d163e81e

data/lib/kdeploy/cli.rb

@@ -28,41 +28,7 @@ module Kdeploy
       if command
         super
       else
-        pastel = Pastel.new
-        puts Kdeploy::Banner.show
-        puts <<~HELP
-          #{pastel.bright_white('📖 Available Commands:')}
-
-          #{pastel.bright_yellow('🚀')} #{pastel.bright_white('execute TASK_FILE [TASK]')}     Execute deployment tasks from file
-          #{pastel.dim('    --limit HOSTS')}              Limit to specific hosts (comma-separated)
-          #{pastel.dim('    --parallel NUM')}             Number of parallel executions (default: 5)
-          #{pastel.dim('    --dry-run')}                  Show what would be done without executing
-
-          #{pastel.bright_yellow('🆕')} #{pastel.bright_white('init [DIR]')}                  Initialize new deployment project
-          #{pastel.bright_yellow('ℹ️')} #{pastel.bright_white('version')}                    Show version information
-          #{pastel.bright_yellow('❓')} #{pastel.bright_white('help [COMMAND]')}              Show help information
-
-          #{pastel.bright_white('💡 Examples:')}
-
-          #{pastel.dim('# Initialize a new project')}
-          #{pastel.bright_cyan('kdeploy init my-deployment')}
-
-          #{pastel.dim('# Deploy to web servers')}
-          #{pastel.bright_cyan('kdeploy execute deploy.rb deploy_web')}
-
-          #{pastel.dim('# Backup database')}
-          #{pastel.bright_cyan('kdeploy execute deploy.rb backup_db')}
-
-          #{pastel.dim('# Run maintenance on specific hosts')}
-          #{pastel.bright_cyan('kdeploy execute deploy.rb maintenance --limit web01')}
-
-          #{pastel.dim('# Preview deployment')}
-          #{pastel.bright_cyan('kdeploy execute deploy.rb deploy_web --dry-run')}
-
-          #{pastel.bright_white('📚 Documentation:')}
-          #{pastel.bright_cyan('https://github.com/kevin197011/kdeploy')}
-
-        HELP
+        show_general_help
       end
     end
 
@@ -80,40 +46,11 @@ module Kdeploy
     method_option :parallel, type: :numeric, default: 10, desc: 'Number of parallel executions'
     method_option :dry_run, type: :boolean, desc: 'Show what would be done'
     def execute(task_file, task_name = nil)
-      # 只在最前面输出一次 banner
-      @banner_printed ||= false
-      unless @banner_printed
-        puts Kdeploy::Banner.show
-        @banner_printed = true
-      end
-
+      show_banner_once
       load_task_file(task_file)
 
-      tasks_to_run = if task_name
-                       [task_name.to_sym]
-                     else
-                       self.class.kdeploy_tasks.keys
-                     end
-
-      tasks_to_run.each do |task|
-        task_hosts = self.class.get_task_hosts(task)
-        hosts = filter_hosts(options[:limit], task_hosts)
-
-        if hosts.empty?
-          puts Kdeploy::Banner.show_error("No hosts found for task: #{task}")
-          next
-        end
-
-        if options[:dry_run]
-          print_dry_run(hosts, task)
-          next
-        end
-
-        output = ConsoleOutput.new
-        runner = Runner.new(hosts, self.class.kdeploy_tasks, parallel: options[:parallel], output: output)
-        results = runner.run(task)
-        print_results(results, task)
-      end
+      tasks_to_run = determine_tasks(task_name)
+      execute_tasks(tasks_to_run)
     rescue StandardError => e
       puts Kdeploy::Banner.show_error(e.message)
       exit 1
@@ -122,11 +59,7 @@ module Kdeploy
     private
 
     def load_task_file(file)
-      unless File.exist?(file)
-        puts Kdeploy::Banner.show_error("Task file not found: #{file}")
-        exit 1
-      end
-
+      validate_task_file(file)
       # 用 instance_eval 并传递顶层 binding，兼容 heredoc
       self.class.module_eval(File.read(file), file)
     rescue StandardError => e
@@ -135,6 +68,19 @@ module Kdeploy
       raise
     end
 
+    def validate_task_file(file)
+      return if File.exist?(file)
+
+      puts Kdeploy::Banner.show_error("Task file not found: #{file}")
+      exit 1
+    end
+
+    def show_general_help
+      formatter = HelpFormatter.new
+      puts Kdeploy::Banner.show
+      puts formatter.format_help
+    end
+
     def filter_hosts(limit, task_hosts)
       hosts = self.class.kdeploy_hosts.slice(*task_hosts)
       return hosts unless limit
@@ -144,139 +90,137 @@ module Kdeploy
     end
 
     def print_dry_run(hosts, task_name)
+      formatter = OutputFormatter.new
       puts Kdeploy::Banner.show
-      pastel = Pastel.new
-      puts TTY::Box.frame(
-        'Showing what would be done without executing any commands',
-        title: { top_left: ' Dry Run Mode ', bottom_right: ' Kdeploy ' },
-        style: {
-          border: {
-            fg: :blue
-          }
-        }
-      )
+      puts formatter.format_dry_run_header
       puts
 
       hosts.each do |name, config|
-        commands = self.class.kdeploy_tasks[task_name][:block].call
-        output = commands.map do |command|
-          case command[:type]
-          when :run
-            "#{pastel.green('>')} #{command[:command]}"
-          when :upload
-            "#{pastel.blue('>')} Upload: #{command[:source]} -> #{command[:destination]}"
-          end
-        end.join("\n")
-
-        puts TTY::Box.frame(
-          output,
-          title: { top_left: " #{name} (#{config[:ip]}) " },
-          style: {
-            border: {
-              fg: :yellow
-            }
-          }
-        )
-        puts
+        print_dry_run_for_host(name, config, task_name, formatter)
       end
     end
 
+    def print_dry_run_for_host(name, config, task_name, formatter)
+      commands = self.class.kdeploy_tasks[task_name][:block].call
+      output = commands.map { |cmd| formatter.format_command_for_dry_run(cmd) }.join("\n")
+      title = "#{name} (#{config[:ip]})"
+      puts formatter.format_dry_run_box(title, output)
+      puts
+    end
+
     def print_results(results, task_name)
-      pastel = Pastel.new
-      puts pastel.cyan("\nPLAY [#{task_name}] " + ('*' * 64))
+      formatter = OutputFormatter.new
+      puts formatter.format_task_header(task_name)
 
       results.each do |host, result|
-        status = case result[:status]
-                 when :success then pastel.green('ok')
-                 when :changed then pastel.yellow('changed')
-                 else pastel.red('failed')
-                 end
-        puts pastel.bright_white("\n#{host.ljust(24)} : #{status}")
-
-        if %i[success changed].include?(result[:status])
-          shown = {}
-          grouped = result[:output].group_by { |step| step[:type] || :run }
-          grouped.each do |type, steps|
-            case type
-            when :upload
-              puts pastel.green('  === Upload ===')
-              steps.each do |step|
-                key = [step[:command], type].hash
-                next if shown[key]
-
-                shown[key] = true
-                duration_str = step[:duration] ? pastel.dim(" [#{format('%.2f', step[:duration])}s]") : ''
-                puts pastel.green("    [upload] #{step[:command].sub('upload: ', '')}#{duration_str}")
-              end
-            when :upload_template
-              puts pastel.yellow('  === Template ===')
-              steps.each do |step|
-                key = [step[:command], type].hash
-                next if shown[key]
-
-                shown[key] = true
-                duration_str = step[:duration] ? pastel.dim(" [#{format('%.2f', step[:duration])}s]") : ''
-                puts pastel.yellow("    [template] #{step[:command].sub('upload_template: ', '')}#{duration_str}")
-              end
-            when :run
-              puts pastel.cyan('  === Run ===')
-              steps.each do |step|
-                key = [step[:command], type].hash
-                next if shown[key]
-
-                shown[key] = true
-                duration_str = step[:duration] ? pastel.dim(" [#{format('%.2f', step[:duration])}s]") : ''
-                puts pastel.cyan("    [run]    #{step[:command].to_s.lines.first.strip}#{duration_str}")
-                # 多行命令内容高亮
-                cmd_lines = step[:command].to_s.lines[1..].map(&:strip).reject(&:empty?)
-                cmd_lines.each { |line| puts pastel.cyan("           > #{line}") } if cmd_lines.any?
-                if step[:output].is_a?(Hash) && step[:output][:stdout]
-                  step[:output][:stdout].each_line do |line|
-                    puts pastel.green("        #{line.rstrip}") unless line.strip.empty?
-                  end
-                elsif step[:output].is_a?(String)
-                  step[:output].each_line do |line|
-                    puts pastel.green("        #{line.rstrip}") unless line.strip.empty?
-                  end
-                end
-              end
-            end
-          end
-        else
-          # 失败主机高亮错误
-          err = result[:error] || (if result[:output].is_a?(Array)
-                                     result[:output].map do |o|
-                                       o[:output][:stderr] if o[:output].is_a?(Hash)
-                                     end.compact.join("\n")
-                                   else
-                                     result[:output].to_s
-                                   end)
-          puts pastel.red("  ERROR: #{err}")
-        end
+        puts formatter.format_host_status(host, result[:status])
+        print_host_result(host, result, formatter)
+      end
+
+      print_summary(results, formatter)
+    end
+
+    def print_host_result(_host, result, formatter)
+      if %i[success changed].include?(result[:status])
+        print_success_result(result, formatter)
+      else
+        print_failure_result(result, formatter)
+      end
+    end
+
+    def print_success_result(result, formatter)
+      shown = {}
+      grouped = group_output_by_type(result[:output])
+
+      grouped.each do |type, steps|
+        output_lines = format_steps_by_type(type, steps, shown, formatter)
+        output_lines.each { |line| puts line }
       end
+    end
+
+    def group_output_by_type(output)
+      output.group_by { |step| step[:type] || :run }
+    end
+
+    def format_steps_by_type(type, steps, shown, formatter)
+      case type
+      when :upload
+        formatter.format_upload_steps(steps, shown)
+      when :upload_template
+        formatter.format_template_steps(steps, shown)
+      when :run
+        formatter.format_run_steps(steps, shown)
+      else
+        []
+      end
+    end
+
+    def print_failure_result(result, formatter)
+      error_message = extract_error_message(result)
+      puts formatter.format_error(error_message)
+    end
 
-      # summary
-      puts pastel.cyan("\nPLAY RECAP #{'*' * 64}")
+    def print_summary(results, formatter)
+      puts formatter.format_summary_header
       max_host_len = results.keys.map(&:length).max || 16
-      ok_w = 7
-      changed_w = 11
-      failed_w = 10
+
       results.keys.sort.each do |host|
         result = results[host]
-        ok = %i[success changed].include?(result[:status]) ? result[:output].size : 0
-        failed = result[:status] == :failed ? 1 : 0
-        changed = result[:status] == :changed ? result[:output].size : 0
-        ok_str = pastel.green("ok=#{ok.to_s.ljust(ok_w - 3)}")
-        changed_str = pastel.yellow("changed=#{changed.to_s.ljust(changed_w - 8)}")
-        failed_str = pastel.red("failed=#{failed.to_s.ljust(failed_w - 7)}")
-        line = "#{host.ljust(max_host_len)} : #{ok_str}  #{changed_str}  #{failed_str}"
-        if failed.positive?
-          puts pastel.red(line)
-        elsif ok.positive? && failed.zero?
-          puts pastel.green(line)
-        else
-          puts line
-        end
+        puts formatter.format_summary_line(host, result, max_host_len)
+      end
+    end
+
+    def show_banner_once
+      @banner_printed ||= false
+      return if @banner_printed
+
+      puts Kdeploy::Banner.show
+      @banner_printed = true
+    end
+
+    def determine_tasks(task_name)
+      task_name ? [task_name.to_sym] : self.class.kdeploy_tasks.keys
+    end
+
+    def execute_tasks(tasks_to_run)
+      tasks_to_run.each do |task|
+        execute_single_task(task)
+      end
+    end
+
+    def execute_single_task(task)
+      task_hosts = self.class.get_task_hosts(task)
+      hosts = filter_hosts(options[:limit], task_hosts)
+
+      if hosts.empty?
+        puts Kdeploy::Banner.show_error("No hosts found for task: #{task}")
+        return
+      end
+
+      if options[:dry_run]
+        print_dry_run(hosts, task)
+        return
+      end
+
+      run_task(hosts, task)
+    end
+
+    def run_task(hosts, task)
+      output = ConsoleOutput.new
+      runner = Runner.new(hosts, self.class.kdeploy_tasks, parallel: options[:parallel], output: output)
+      results = runner.run(task)
+      print_results(results, task)
+    end
+
+    def extract_error_message(result)
+      return result[:error] if result[:error]
+
+      if result[:output].is_a?(Array)
+        result[:output].map do |o|
+          o[:output][:stderr] if o[:output].is_a?(Hash)
+        end.compact.join("\n")
+      else
+        result[:output].to_s
       end
     end
   end

data/lib/kdeploy/command_executor.rb

@@ -54,35 +54,52 @@ module Kdeploy
       return unless output.is_a?(Hash)
 
       pastel = @output.respond_to?(:pastel) ? @output.pastel : Pastel.new
+      show_stdout(output[:stdout])
+      show_stderr(output[:stderr], pastel)
+    end
+
+    def show_stdout(stdout)
+      return unless stdout && !stdout.empty?
 
-      if output[:stdout] && !output[:stdout].empty?
-        output[:stdout].each_line do |line|
-          @output.write_line("    #{line.rstrip}") unless line.strip.empty?
-        end
+      stdout.each_line do |line|
+        @output.write_line("    #{line.rstrip}") unless line.strip.empty?
       end
+    end
 
-      return unless output[:stderr] && !output[:stderr].empty?
+    def show_stderr(stderr, pastel)
+      return unless stderr && !stderr.empty?
 
-      output[:stderr].each_line do |line|
+      stderr.each_line do |line|
         @output.write_line(pastel.green("    #{line.rstrip}")) unless line.strip.empty?
       end
     end
 
     def show_command_header(host_name, type, description)
-      pastel = @output.respond_to?(:pastel) ? @output.pastel : Pastel.new
+      pastel = pastel_instance
       @output.write_line(pastel.bright_white("\n#{host_name.ljust(24)} : "))
+      format_command_by_type(type, description, pastel)
+    end
 
+    def pastel_instance
+      @output.respond_to?(:pastel) ? @output.pastel : Pastel.new
+    end
+
+    def format_command_by_type(type, description, pastel)
       case type
       when :run
-        @output.write_line(pastel.cyan("  [run]    #{description.lines.first.strip}"))
-        description.lines[1..].each do |line|
-          @output.write_line("           > #{line.strip}") unless line.strip.empty?
-        end
+        format_run_command(description, pastel)
       when :upload
         @output.write_line(pastel.green("  [upload] #{description}"))
       when :upload_template
         @output.write_line(pastel.yellow("  [template] #{description}"))
       end
     end
+
+    def format_run_command(description, pastel)
+      @output.write_line(pastel.cyan("  [run]    #{description.lines.first.strip}"))
+      description.lines[1..].each do |line|
+        @output.write_line("           > #{line.strip}") unless line.strip.empty?
+      end
+    end
   end
 end

data/lib/kdeploy/dsl.rb

@@ -3,6 +3,7 @@
 require 'set'
 
 module Kdeploy
+  # Domain-specific language for defining hosts, roles, and tasks
   module DSL
     def self.extended(base)
       base.instance_variable_set(:@kdeploy_hosts, {})
@@ -32,21 +33,33 @@ module Kdeploy
 
     def task(name, on: nil, roles: nil, &block)
       kdeploy_tasks[name] = {
-        hosts: if on.is_a?(Array)
-                 on
-               else
-                 (on ? [on] : nil)
-               end,
-        roles: if roles.is_a?(Array)
-                 roles
-               else
-                 (roles ? [roles] : nil)
-               end,
-        block: lambda {
-          @kdeploy_commands = []
-          instance_eval(&block)
-          @kdeploy_commands
-        }
+        hosts: normalize_hosts_option(on),
+        roles: normalize_roles_option(roles),
+        block: create_task_block(block)
+      }
+    end
+
+    def normalize_hosts_option(on)
+      return on if on.is_a?(Array)
+
+      return [on] if on
+
+      nil
+    end
+
+    def normalize_roles_option(roles)
+      return roles if roles.is_a?(Array)
+
+      return [roles] if roles
+
+      nil
+    end
+
+    def create_task_block(block)
+      lambda {
+        @kdeploy_commands = []
+        instance_eval(&block)
+        @kdeploy_commands
       }
     end
 
@@ -76,25 +89,33 @@ module Kdeploy
 
     def get_task_hosts(task_name)
       task = kdeploy_tasks[task_name]
-      return kdeploy_hosts.keys if !task || (!task[:hosts] && !task[:roles])
+      return kdeploy_hosts.keys if task_empty?(task)
 
       hosts = Set.new
+      add_explicit_hosts(task, hosts)
+      add_role_hosts(task, hosts)
+      hosts.to_a
+    end
 
-      # 添加指定的主机
+    def task_empty?(task)
+      !task || (!task[:hosts] && !task[:roles])
+    end
+
+    def add_explicit_hosts(task, hosts)
       task[:hosts]&.each do |host|
         hosts.add(host) if kdeploy_hosts.key?(host)
       end
+    end
 
-      # 添加角色中的主机
+    def add_role_hosts(task, hosts)
       task[:roles]&.each do |role|
-        next unless (role_hosts = kdeploy_roles[role])
+        role_hosts = kdeploy_roles[role]
+        next unless role_hosts
 
         role_hosts.each do |host|
           hosts.add(host) if kdeploy_hosts.key?(host)
         end
       end
-
-      hosts.to_a
     end
   end
 end

data/lib/kdeploy/executor.rb

@@ -17,28 +17,7 @@ module Kdeploy
 
     def execute(command)
       Net::SSH.start(@ip, @user, ssh_options) do |ssh|
-        stdout = String.new
-        stderr = String.new
-
-        ssh.open_channel do |channel|
-          channel.exec(command) do |_ch, success|
-            raise SSHError, "Could not execute command: #{command}" unless success
-
-            channel.on_data do |_ch, data|
-              stdout << data
-            end
-
-            channel.on_extended_data do |_ch, _type, data|
-              stderr << data
-            end
-          end
-        end
-        ssh.loop
-        {
-          stdout: stdout.strip,
-          stderr: stderr.strip,
-          command: command
-        }
+        execute_command_on_ssh(ssh, command)
       end
     rescue Net::SSH::AuthenticationFailed => e
       raise SSHError.new("SSH authentication failed: #{e.message}", e)
@@ -46,6 +25,39 @@ module Kdeploy
       raise SSHError.new("SSH execution failed: #{e.message}", e)
     end
 
+    def execute_command_on_ssh(ssh, command)
+      stdout = String.new
+      stderr = String.new
+
+      ssh.open_channel do |channel|
+        channel.exec(command) do |_ch, success|
+          raise SSHError, "Could not execute command: #{command}" unless success
+
+          setup_channel_handlers(channel, stdout, stderr)
+        end
+      end
+      ssh.loop
+      build_command_result(stdout, stderr, command)
+    end
+
+    def setup_channel_handlers(channel, stdout, stderr)
+      channel.on_data do |_ch, data|
+        stdout << data
+      end
+
+      channel.on_extended_data do |_ch, _type, data|
+        stderr << data
+      end
+    end
+
+    def build_command_result(stdout, stderr, command)
+      {
+        stdout: stdout.strip,
+        stderr: stderr.strip,
+        command: command
+      }
+    end
+
     def upload(source, destination)
       Net::SCP.start(@ip, @user, ssh_options) do |scp|
         scp.upload!(source, destination)
@@ -63,18 +75,29 @@ module Kdeploy
     private
 
     def ssh_options
-      options = {
+      options = base_ssh_options
+      add_authentication(options)
+      add_port_option(options)
+      options
+    end
+
+    def base_ssh_options
+      {
         verify_host_key: :never,
         timeout: 30
       }
+    end
 
+    def add_authentication(options)
       if @password
         options[:password] = @password
       elsif @key
         options[:keys] = [@key]
       end
-      options[:port] = @port if @port # 新增端口传递
-      options
+    end
+
+    def add_port_option(options)
+      options[:port] = @port if @port
     end
   end
 end

data/lib/kdeploy/help_formatter.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'pastel'
+
+module Kdeploy
+  # Formats help text for CLI
+  class HelpFormatter
+    def initialize
+      @pastel = Pastel.new
+    end
+
+    def format_help
+      <<~HELP
+        #{@pastel.bright_white('📖 Available Commands:')}
+
+        #{format_commands}
+
+        #{format_examples}
+
+        #{format_documentation}
+      HELP
+    end
+
+    private
+
+    def format_commands
+      <<~COMMANDS
+        #{@pastel.bright_yellow('🚀')} #{@pastel.bright_white('execute TASK_FILE [TASK]')}     Execute deployment tasks from file
+        #{@pastel.dim('    --limit HOSTS')}              Limit to specific hosts (comma-separated)
+        #{@pastel.dim('    --parallel NUM')}             Number of parallel executions (default: 5)
+        #{@pastel.dim('    --dry-run')}                  Show what would be done without executing
+
+        #{@pastel.bright_yellow('🆕')} #{@pastel.bright_white('init [DIR]')}                  Initialize new deployment project
+        #{@pastel.bright_yellow('ℹ️')} #{@pastel.bright_white('version')}                    Show version information
+        #{@pastel.bright_yellow('❓')} #{@pastel.bright_white('help [COMMAND]')}              Show help information
+      COMMANDS
+    end
+
+    def format_examples
+      <<~EXAMPLES
+        #{@pastel.bright_white('💡 Examples:')}
+
+        #{@pastel.dim('# Initialize a new project')}
+        #{@pastel.bright_cyan('kdeploy init my-deployment')}
+
+        #{@pastel.dim('# Deploy to web servers')}
+        #{@pastel.bright_cyan('kdeploy execute deploy.rb deploy_web')}
+
+        #{@pastel.dim('# Backup database')}
+        #{@pastel.bright_cyan('kdeploy execute deploy.rb backup_db')}
+
+        #{@pastel.dim('# Run maintenance on specific hosts')}
+        #{@pastel.bright_cyan('kdeploy execute deploy.rb maintenance --limit web01')}
+
+        #{@pastel.dim('# Preview deployment')}
+        #{@pastel.bright_cyan('kdeploy execute deploy.rb deploy_web --dry-run')}
+      EXAMPLES
+    end
+
+    def format_documentation
+      <<~DOCS
+        #{@pastel.bright_white('📚 Documentation:')}
+        #{@pastel.bright_cyan('https://github.com/kevin197011/kdeploy')}
+      DOCS
+    end
+  end
+end

data/lib/kdeploy/output.rb

@@ -21,6 +21,7 @@ module Kdeploy
   # Console output implementation
   class ConsoleOutput < Output
     def initialize
+      super
       @pastel = Pastel.new
     end
 
@@ -44,6 +45,7 @@ module Kdeploy
     attr_reader :messages, :errors
 
     def initialize
+      super
       @messages = []
       @errors = []
     end

data/lib/kdeploy/output_formatter.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require 'pastel'
+require 'tty-box'
+
+module Kdeploy
+  # Formats and displays execution results
+  class OutputFormatter
+    def initialize
+      @pastel = Pastel.new
+    end
+
+    def format_task_header(task_name)
+      @pastel.cyan("\nPLAY [#{task_name}] " + ('*' * 64))
+    end
+
+    def format_host_status(host, status)
+      status_str = case status
+                   when :success then @pastel.green('ok')
+                   when :changed then @pastel.yellow('changed')
+                   else @pastel.red('failed')
+                   end
+      @pastel.bright_white("\n#{host.ljust(24)} : #{status_str}")
+    end
+
+    def format_upload_steps(steps, shown)
+      format_file_steps(steps, shown, :upload, @pastel.green('  === Upload ==='), 'upload: ')
+    end
+
+    def format_template_steps(steps, shown)
+      format_file_steps(steps, shown, :upload_template, @pastel.yellow('  === Template ==='), 'upload_template: ')
+    end
+
+    def format_file_steps(steps, shown, type, header, prefix)
+      output = [header]
+      steps.each do |step|
+        next if step_already_shown?(step, type, shown)
+
+        mark_step_as_shown(step, type, shown)
+        output << format_file_step(step, type, prefix)
+      end
+      output
+    end
+
+    def format_file_step(step, type, prefix)
+      duration_str = format_duration(step[:duration])
+      label = type == :upload ? '[upload]' : '[template]'
+      color("    #{label} #{step[:command].sub(prefix, '')}#{duration_str}")
+    end
+
+    def format_run_steps(steps, shown)
+      output = []
+      output << @pastel.cyan('  === Run ===')
+      steps.each do |step|
+        next if step_already_shown?(step, :run, shown)
+
+        mark_step_as_shown(step, :run, shown)
+        output.concat(format_single_run_step(step))
+      end
+      output
+    end
+
+    def format_single_run_step(step)
+      output = []
+      duration_str = format_duration(step[:duration])
+      command_line = step[:command].to_s.lines.first.strip
+      output << @pastel.cyan("    [run]    #{command_line}#{duration_str}")
+      output.concat(format_multiline_command(step[:command]))
+      output.concat(format_command_output(step[:output]))
+      output
+    end
+
+    def format_error(error_message)
+      @pastel.red("  ERROR: #{error_message}")
+    end
+
+    def format_summary_header
+      @pastel.cyan("\nPLAY RECAP #{'*' * 64}")
+    end
+
+    def format_summary_line(host, result, max_host_len)
+      counts = calculate_summary_counts(result)
+      line = build_summary_line(host, counts, max_host_len)
+      colorize_summary_line(line, counts)
+    end
+
+    def calculate_summary_counts(result)
+      ok = %i[success changed].include?(result[:status]) ? result[:output].size : 0
+      failed = result[:status] == :failed ? 1 : 0
+      changed = result[:status] == :changed ? result[:output].size : 0
+      { ok: ok, failed: failed, changed: changed }
+    end
+
+    def build_summary_line(host, counts, max_host_len)
+      ok_w = 7
+      changed_w = 11
+      failed_w = 10
+
+      ok_str = @pastel.green("ok=#{counts[:ok].to_s.ljust(ok_w - 3)}")
+      changed_str = @pastel.yellow("changed=#{counts[:changed].to_s.ljust(changed_w - 8)}")
+      failed_str = @pastel.red("failed=#{counts[:failed].to_s.ljust(failed_w - 7)}")
+      "#{host.ljust(max_host_len)} : #{ok_str}  #{changed_str}  #{failed_str}"
+    end
+
+    def colorize_summary_line(line, counts)
+      if counts[:failed].positive?
+        @pastel.red(line)
+      elsif counts[:ok].positive? && counts[:failed].zero?
+        @pastel.green(line)
+      else
+        line
+      end
+    end
+
+    def format_dry_run_box(title, content)
+      TTY::Box.frame(
+        content,
+        title: { top_left: " #{title} " },
+        style: {
+          border: {
+            fg: :yellow
+          }
+        }
+      )
+    end
+
+    def format_dry_run_header
+      TTY::Box.frame(
+        'Showing what would be done without executing any commands',
+        title: { top_left: ' Dry Run Mode ', bottom_right: ' Kdeploy ' },
+        style: {
+          border: {
+            fg: :blue
+          }
+        }
+      )
+    end
+
+    def format_command_for_dry_run(command)
+      case command[:type]
+      when :run
+        "#{@pastel.green('>')} #{command[:command]}"
+      when :upload
+        "#{@pastel.blue('>')} Upload: #{command[:source]} -> #{command[:destination]}"
+      when :upload_template
+        "#{@pastel.blue('>')} Template: #{command[:source]} -> #{command[:destination]}"
+      else
+        "#{@pastel.blue('>')} #{command[:type]}: #{command}"
+      end
+    end
+
+    private
+
+    def format_duration(duration)
+      duration ? @pastel.dim(" [#{format('%.2f', duration)}s]") : ''
+    end
+
+    def format_multiline_command(command)
+      output = []
+      cmd_lines = command.to_s.lines[1..].map(&:strip).reject(&:empty?)
+      cmd_lines.each { |line| output << @pastel.cyan("           > #{line}") } if cmd_lines.any?
+      output
+    end
+
+    def format_command_output(output)
+      result = []
+      return result unless output
+
+      if output.is_a?(Hash) && output[:stdout]
+        format_stdout_lines(output[:stdout], result)
+      elsif output.is_a?(String)
+        format_stdout_lines(output, result)
+      end
+      result
+    end
+
+    def format_stdout_lines(stdout, result)
+      stdout.each_line do |line|
+        result << @pastel.green("        #{line.rstrip}") unless line.strip.empty?
+      end
+    end
+
+    def step_already_shown?(step, type, shown)
+      key = [step[:command], type].hash
+      shown[key]
+    end
+
+    def mark_step_as_shown(step, type, shown)
+      key = [step[:command], type].hash
+      shown[key] = true
+    end
+  end
+end

data/lib/kdeploy/post_install.rb

@@ -22,20 +22,7 @@ module Kdeploy
         return if completion_path.nil?
 
         source_line = "source \"#{completion_path}\""
-
-        # 检查是否已经配置
-        content = File.read(bashrc_path)
-        if content.match?(/source.*kdeploy\.bash/)
-          # 更新现有的配置
-          new_content = content.gsub(/source.*kdeploy\.bash.*$/, source_line)
-          File.write(bashrc_path, new_content)
-        else
-          # 添加新配置
-          File.open(bashrc_path, 'a') do |f|
-            f.puts "\n# Kdeploy completion"
-            f.puts source_line
-          end
-        end
+        update_shell_config(bashrc_path, source_line, /source.*kdeploy\.bash/)
         puts "✅ Bash completion configured in #{bashrc_path}"
       rescue StandardError => e
         puts "⚠️  Failed to configure Bash completion: #{e.message}"
@@ -47,64 +34,97 @@ module Kdeploy
         completion_path = find_completion_file('kdeploy.zsh')
         return if completion_path.nil?
 
-        source_lines = [
+        source_lines = build_zsh_source_lines(completion_path)
+        update_zsh_config(zshrc_path, source_lines)
+        puts "✅ Zsh completion configured in #{zshrc_path}"
+      rescue StandardError => e
+        puts "⚠️  Failed to configure Zsh completion: #{e.message}"
+      end
+
+      def find_completion_file(filename)
+        paths = build_completion_paths(filename)
+
+        paths.each do |path|
+          found_path = search_path(path)
+          return found_path if found_path
+        end
+
+        report_completion_file_not_found(filename, paths)
+        nil
+      end
+
+      def bashrc_path
+        File.join(Dir.home, '.bashrc')
+      end
+
+      def zshrc_path
+        File.join(Dir.home, '.zshrc')
+      end
+
+      def update_shell_config(config_path, source_line, pattern)
+        content = File.read(config_path)
+        if content.match?(pattern)
+          new_content = content.gsub(/#{pattern.source}.*$/, source_line)
+          File.write(config_path, new_content)
+        else
+          append_shell_config(config_path, source_line)
+        end
+      end
+
+      def append_shell_config(config_path, source_line)
+        File.open(config_path, 'a') do |f|
+          f.puts "\n# Kdeploy completion"
+          f.puts source_line
+        end
+      end
+
+      def build_zsh_source_lines(completion_path)
+        [
           "source \"#{completion_path}\"",
           'autoload -Uz compinit && compinit'
         ]
+      end
 
+      def update_zsh_config(zshrc_path, source_lines)
         content = File.read(zshrc_path)
-
-        # 检查是否已经配置
         if content.match?(/source.*kdeploy\.zsh/)
-          # 更新现有的配置
           new_content = content.gsub(/source.*kdeploy\.zsh.*$/, source_lines[0])
           File.write(zshrc_path, new_content)
         else
-          # 添加新配置
-          File.open(zshrc_path, 'a') do |f|
-            f.puts "\n# Kdeploy completion"
-            source_lines.each { |line| f.puts line unless content.include?(line) }
-          end
+          append_zsh_config(zshrc_path, source_lines, content)
         end
-        puts "✅ Zsh completion configured in #{zshrc_path}"
-      rescue StandardError => e
-        puts "⚠️  Failed to configure Zsh completion: #{e.message}"
       end
 
-      def find_completion_file(filename)
-        # 尝试所有可能的路径
-        paths = [
-          # 开发环境路径
+      def append_zsh_config(zshrc_path, source_lines, content)
+        File.open(zshrc_path, 'a') do |f|
+          f.puts "\n# Kdeploy completion"
+          source_lines.each { |line| f.puts line unless content.include?(line) }
+        end
+      end
+
+      def build_completion_paths(filename)
+        [
           File.expand_path("../completions/#{filename}", __FILE__),
-          # RubyGems 安装路径
           *Gem.path.map { |path| File.join(path, "gems/kdeploy-*/lib/kdeploy/completions/#{filename}") },
-          # 系统路径
           "/usr/local/share/kdeploy/completions/#{filename}",
           "/usr/share/kdeploy/completions/#{filename}"
         ]
+      end
 
-        # 使用 Dir.glob 处理通配符路径
-        paths.each do |path|
-          if path.include?('*')
-            matches = Dir.glob(path)
-            return matches.first if matches.any?
-          elsif File.exist?(path)
-            return path
-          end
+      def search_path(path)
+        if path.include?('*')
+          matches = Dir.glob(path)
+          return matches.first if matches.any?
+        elsif File.exist?(path)
+          return path
         end
+        nil
+      end
 
+      def report_completion_file_not_found(filename, paths)
         puts "⚠️  Could not find completion file: #{filename}"
         puts 'Searched paths:'
         paths.each { |path| puts "  - #{path}" }
-        nil
-      end
-
-      def bashrc_path
-        File.join(Dir.home, '.bashrc')
-      end
-
-      def zshrc_path
-        File.join(Dir.home, '.zshrc')
       end
     end
   end

data/lib/kdeploy/runner.rb

@@ -15,19 +15,32 @@ module Kdeploy
     end
 
     def run(task_name)
+      task = find_task(task_name)
+      execute_concurrent_tasks(task)
+    ensure
+      @pool.shutdown
+    end
+
+    def find_task(task_name)
       task = @tasks[task_name]
+
       raise TaskNotFoundError, task_name unless task
 
-      futures = @hosts.map do |name, config|
+      task
+    end
+
+    def execute_concurrent_tasks(task)
+      futures = create_task_futures(task)
+      futures.each(&:wait)
+      @results
+    end
+
+    def create_task_futures(task)
+      @hosts.map do |name, config|
         Concurrent::Future.execute(executor: @pool) do
           execute_task_for_host(name, config, task)
         end
       end
-
-      futures.each(&:wait)
-      @results
-    ensure
-      @pool.shutdown
     end
 
     private
@@ -37,23 +50,30 @@ module Kdeploy
       command_executor = CommandExecutor.new(executor, @output)
       result = { status: :success, output: [] }
 
+      execute_grouped_commands(task, command_executor, name, result)
+      @results[name] = result
+    rescue StandardError => e
+      @results[name] = { status: :failed, error: e.message }
+    end
+
+    def execute_grouped_commands(task, command_executor, name, result)
       commands = task[:block].call
       grouped_commands = CommandGrouper.group(commands)
 
       grouped_commands.each_value do |command_group|
-        first_cmd = command_group.first
-        task_desc = CommandGrouper.task_description(first_cmd)
-        show_task_header(task_desc)
-
-        command_group.each do |command|
-          step_result = execute_command(command_executor, command, name)
-          result[:output] << step_result
-        end
+        execute_command_group(command_group, command_executor, name, result)
       end
+    end
 
-      @results[name] = result
-    rescue StandardError => e
-      @results[name] = { status: :failed, error: e.message }
+    def execute_command_group(command_group, command_executor, name, result)
+      first_cmd = command_group.first
+      task_desc = CommandGrouper.task_description(first_cmd)
+      show_task_header(task_desc)
+
+      command_group.each do |command|
+        step_result = execute_command(command_executor, command, name)
+        result[:output] << step_result
+      end
     end
 
     def execute_command(command_executor, command, host_name)

data/lib/kdeploy/template.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'erb'
-require 'ostruct'
 require 'tempfile'
 
 module Kdeploy
@@ -9,10 +8,19 @@ module Kdeploy
   class Template
     def self.render(template_path, variables = {})
       template_content = File.read(template_path)
-      context = OpenStruct.new(variables)
+      context = create_template_context(variables)
       ERB.new(template_content).result(context.instance_eval { binding })
     end
 
+    def self.create_template_context(variables)
+      # Use a simple class instead of OpenStruct for better performance
+      context_class = Class.new
+      variables.each do |key, value|
+        context_class.define_method(key) { value }
+      end
+      context_class.new
+    end
+
     def self.render_and_upload(executor, template_path, destination, variables = {})
       rendered_content = render(template_path, variables)
 

data/lib/kdeploy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kdeploy
-  VERSION = '1.2.1'
+  VERSION = '1.2.3'
 end

data/lib/kdeploy.rb

@@ -9,6 +9,8 @@ require_relative 'kdeploy/dsl'
 require_relative 'kdeploy/executor'
 require_relative 'kdeploy/command_grouper'
 require_relative 'kdeploy/command_executor'
+require_relative 'kdeploy/output_formatter'
+require_relative 'kdeploy/help_formatter'
 require_relative 'kdeploy/runner'
 require_relative 'kdeploy/initializer'
 require_relative 'kdeploy/template'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kdeploy
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.2.3
 platform: ruby
 authors:
 - Kk
@@ -146,8 +146,10 @@ files:
 - lib/kdeploy/dsl.rb
 - lib/kdeploy/errors.rb
 - lib/kdeploy/executor.rb
+- lib/kdeploy/help_formatter.rb
 - lib/kdeploy/initializer.rb
 - lib/kdeploy/output.rb
+- lib/kdeploy/output_formatter.rb
 - lib/kdeploy/post_install.rb
 - lib/kdeploy/runner.rb
 - lib/kdeploy/template.rb