kdeploy 1.2.0 → 1.2.2

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/initializer.rb

@@ -3,6 +3,7 @@
 require 'fileutils'
 
 module Kdeploy
+  # Project initializer for creating new deployment projects
   class Initializer
     def initialize(target_dir = '.')
       @target_dir = File.expand_path(target_dir)

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,194 @@
+# 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])
+      type == :upload ? @pastel.green : @pastel.yellow
+      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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module Kdeploy
+  # Post-installation configuration handler
   class PostInstall
     class << self
       def run

data/lib/kdeploy/runner.rb

@@ -3,6 +3,7 @@
 require 'concurrent'
 
 module Kdeploy
+  # Concurrent task runner for executing tasks across multiple hosts
   class Runner
     def initialize(hosts, tasks, parallel: Configuration.default_parallel, output: ConsoleOutput.new)
       @hosts = hosts
@@ -14,19 +15,31 @@ 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
@@ -36,23 +49,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,17 +1,26 @@
 # frozen_string_literal: true
 
 require 'erb'
-require 'ostruct'
 require 'tempfile'
 
 module Kdeploy
+  # ERB template rendering and upload handler
   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.0'
+  VERSION = '1.2.2'
 end

data/lib/kdeploy.rb

@@ -9,12 +9,15 @@ 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'
 require_relative 'kdeploy/post_install'
 require_relative 'kdeploy/cli'
 
+# Kdeploy - A lightweight agentless deployment automation tool
 module Kdeploy
   # Your code goes here...
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kdeploy
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.2
 platform: ruby
 authors:
 - Kk
@@ -122,48 +122,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.12'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '13.0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: rubocop
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.21'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.21'
 description: Kdeploy is a Ruby-based deployment automation tool that provides agentless
   remote deployment solutions with an elegant DSL
 email:
@@ -174,7 +132,9 @@ extensions:
 - ext/mkrf_conf.rb
 extra_rdoc_files: []
 files:
+- OPTIMIZATION_COMPLETE.md
 - README.md
+- REFACTORING_SUMMARY.md
 - exe/kdeploy
 - ext/mkrf_conf.rb
 - lib/kdeploy.rb
@@ -188,8 +148,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