makit 0.0.99 → 0.0.111

data/lib/makit/command_runner.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "English"
 require "open3"
 require "socket"
@@ -9,21 +11,23 @@ require_relative "mp/command_request.mp"
 module Makit
   # This class provide methods running commands.
   #
+  # @deprecated Use Commands::Runner instead. This class will be removed in a future version.
+  # @see Commands::Runner for the modern command execution API
   class CommandRunner
-    attr_accessor :show_output_on_success, :log_to_artifacts, :commands
-    attr_accessor :debug, :default_modified
+    attr_accessor :show_output_on_success, :log_to_artifacts, :commands, :debug, :default_modified
 
     def initialize
+      warn_deprecation("CommandRunner is deprecated. Use Commands::Runner instead.")
       @show_output_on_success = false
       @log_to_artifacts = false
       @commands = []
       @debug = false
-      git_file_infos = Makit::Git::get_file_infos
-      if (git_file_infos.length > 0)
-        @default_modified = git_file_infos.first.mtime # Makit::GIT_FILE_INFOS.first.mtime
-      else
-        @default_modified = Time.now
-      end
+      git_file_infos = Makit::Git::Repository.get_file_infos
+      @default_modified = if git_file_infos.length.positive?
+          git_file_infos.first.mtime # Makit::GIT_FILE_INFOS.first.mtime
+        else
+          Time.now
+        end
     end
 
     # search command history for matching commands
@@ -32,41 +36,37 @@ module Makit
       commands.each do |command|
         keywords = []
         keywords << command.name.downcase
-        command.arguments.each { |argument|
+        command.arguments.each do |argument|
           keywords << argument.downcase unless keywords.include?(argument.downcase)
-        }
+        end
         # output is bytes, so convert to UTF 8 string
-        #output_bytes = command.output.clone
-        #output = command.output.clone.force_encoding('UTF-8')
-        #error_bytes = command.error.clone
-        #error = error_bytes.force_encoding('UTF-8')
-        #output.split(" ").each {|word|
+        # output_bytes = command.output.clone
+        # output = command.output.clone.force_encoding('UTF-8')
+        # error_bytes = command.error.clone
+        # error = error_bytes.force_encoding('UTF-8')
+        # output.split(" ").each {|word|
         #  if(word.length > 3)
         #    keywords << word.downcase unless keywords.include?(word.downcase)
         #  end
-        #}
-        #error.split(" ").each { |word|
+        # }
+        # error.split(" ").each { |word|
         #  if(word.length > 3)
         #    keywords << word.downcase unless keywords.include?(word.downcase)
         #  end
-        #}
+        # }
         matchCount = 0
-        terms = query.downcase.split(" ")
-        terms.each { |term|
-          if (keywords.include?(term))
-            matchCount += 1
-          end
-        }
-        if (matchCount == terms.length)
-          results << command
+        terms = query.downcase.split
+        terms.each do |term|
+          matchCount += 1 if keywords.include?(term)
         end
+        results << command if matchCount == terms.length
       end
       results
     end
 
     def get_cache_filename(command)
       int_hash = Digest::SHA256.hexdigest("#{command.name}.#{command.arguments.join(" ")}")
-      hash_string = "#{int_hash}"
+      hash_string = int_hash.to_s
       cache_filename = Makit::Directories::PROJECT_ARTIFACTS +
                        "/commands/cache/#{hash_string}.pb"
       # create the directory if it does not already exist
@@ -74,7 +74,9 @@ module Makit
       cache_filename
     end
 
+    # @deprecated Use Commands::Runner with caching middleware instead
     def cache_run(command_request)
+      warn_deprecation("CommandRunner#cache_run is deprecated. Use Commands::Runner with caching middleware instead.")
       cache_run(command_request, @default_modified)
     end
 
@@ -84,38 +86,44 @@ module Makit
     # then return the result
     def cache_run(command_request, timestamp)
       raise "Invalid command_request" unless command_request.is_a? Makit::V1::CommandRequest
+
       cache_filename = get_cache_filename(command_request)
 
       # Check if timestamp is a valid Time object
-      unless timestamp.is_a?(Time)
-        raise ArgumentError, "timestamp must be a Time object, got #{timestamp.class}"
-      end
+      raise ArgumentError, "timestamp must be a Time object, got #{timestamp.class}" unless timestamp.is_a?(Time)
 
       if debug
-        puts "  timestamp: #{Makit::Humanize.get_humanized_timestamp(timestamp)}"
-        puts "  command.name: #{command_request.name}"
-        puts "  command.arguments: #{command_request.arguments.join(" ")}"
-        puts "  cache_filename: #{cache_filename}"
+        Makit::Logging.debug("Cache run debug info", {
+          timestamp: Makit::Humanize.get_humanized_timestamp(timestamp),
+          command: command_request.name,
+          arguments: command_request.arguments.join(" "),
+          cache_filename: cache_filename,
+        })
       end
-      #cache_filename = Makit::Directories::PROJECT_ARTIFACTS + "/commands/#{command_request.name}.#{command_request.arguments.join("_")}.#{timestamp.seconds}.pb"
+      # cache_filename = Makit::Directories::PROJECT_ARTIFACTS + "/commands/#{command_request.name}.#{command_request.arguments.join("_")}.#{timestamp.seconds}.pb"
       if File.exist?(cache_filename)
         cache_timestamp = File.mtime(cache_filename)
-        if debug
-          puts "  cache timestamp: #{Makit::Humanize.get_humanized_timestamp(cache_timestamp)}"
-        end
-        #puts "cache file date: #{File.mtime(cache_filename)}"
-        if (File.mtime(cache_filename) > timestamp)
+        Makit::Logging.debug("Cache timestamp", {
+          cache_timestamp: Makit::Humanize.get_humanized_timestamp(cache_timestamp),
+        }) if debug
+        # puts "cache file date: #{File.mtime(cache_filename)}"
+        if File.mtime(cache_filename) > timestamp
+          Makit::Logging.info("Using cached command result", {
+            command: command_request.name,
+            arguments: command_request.arguments,
+            cache_filename: cache_filename,
+            cache_timestamp: Makit::Humanize.get_humanized_timestamp(cache_timestamp),
+          })
 
-          #puts "  found cached command (newer than #{timestamp})".colorize(:grey)
-          #puts "  cache_filename: #{cache_filename}"
           command = Makit::Serializer.open(cache_filename, Makit::V1::Command)
           show_cached_command(command)
-          if command.exit_code != 0
-            abort "cached command failed: #{command.name} #{command.arguments.join(" ")}"
-          end
+          abort "cached command failed: #{command.name} #{command.arguments.join(" ")}" if command.exit_code != 0
           return command
         else
-          puts "  cache_filename exists, but is older than #{timestamp}" if debug
+          Makit::Logging.debug("Cache file is older than timestamp", {
+            cache_filename: cache_filename,
+            timestamp: Makit::Humanize.get_humanized_timestamp(timestamp),
+          }) if debug
           File.delete(cache_filename)
         end
       end
@@ -123,52 +131,81 @@ module Makit
       command = run(command_request)
       # make sure the cache directory exists
       FileUtils.mkdir_p(File.dirname(cache_filename))
-      #puts "saving command to cache_filename"
+
+      Makit::Logging.info("Saving command to cache", {
+        command: command.name,
+        arguments: command.arguments,
+        cache_filename: cache_filename,
+        success: command.exit_code.zero?,
+      })
+
       Makit::Serializer.save_as(cache_filename, command)
       commands.push(command)
       command
     end
 
     def show_command(command)
-      if command.exit_code != 0
-        puts Makit::CommandRunner.get_command_summary(command) + " (exit code #{command.exit_code})".colorize(:default)
-        puts "  directory: #{command.directory}\n"
-        puts "  duration: #{command.duration.seconds} seconds\n"
-        puts Makit::Humanize::indent_string(command.output, 2) if command.output.length > 0
-        puts Makit::Humanize::indent_string(command.error, 2) if command.error.length > 0
-        #exit 1 if command.exit_on_error
+      if command.exit_code.zero?
+        Makit::Logging.success("Command completed", {
+          command: command.name,
+          arguments: command.arguments,
+          duration: command.duration&.seconds || 0,
+          output: show_output_on_success ? command.output : nil,
+        })
       else
-        puts Makit::CommandRunner.get_command_summary(command) + " (#{command.duration.seconds} seconds)".colorize(:cyan)
-        puts Makit::Humanize::indent_string(command.output, 2).colorize(:default) if show_output_on_success
+        Makit::Logging.error("Command failed", {
+          command: command.name,
+          arguments: command.arguments,
+          exit_code: command.exit_code,
+          directory: command.directory,
+          duration: command.duration&.seconds || 0,
+          output: command.output.length.positive? ? command.output : nil,
+          error: command.error.length.positive? ? command.error : nil,
+        })
       end
     end
 
     def show_cached_command(command)
-      if command.exit_code != 0
-        puts Makit::CommandRunner.get_command_summary(command) + " (exit code #{command.exit_code})".colorize(:default)
-        puts "  directory: #{command.directory}\n"
-        puts "  duration: #{command.duration.seconds} seconds\n"
-        puts Makit::Humanize::indent_string(command.output, 2) if command.output.length > 0
-        puts Makit::Humanize::indent_string(command.error, 2) if command.error.length > 0
-        #exit 1 if command.exit_on_error
+      if command.exit_code.zero?
+        Makit::Logging.info("Cached command completed", {
+          command: command.name,
+          arguments: command.arguments,
+          duration: command.duration&.seconds || 0,
+          cached: true,
+          output: show_output_on_success ? command.output : nil,
+        })
       else
-        puts Makit::CommandRunner.get_command_summary(command).strip_color_codes.colorize(:grey) + " (#{command.duration.seconds} seconds)".colorize(:grey)
-        puts Makit::Humanize::indent_string(command.output, 2).colorize(:default) if show_output_on_success
+        Makit::Logging.warn("Cached command failed", {
+          command: command.name,
+          arguments: command.arguments,
+          exit_code: command.exit_code,
+          directory: command.directory,
+          duration: command.duration&.seconds || 0,
+          cached: true,
+          output: command.output.length.positive? ? command.output : nil,
+          error: command.error.length.positive? ? command.error : nil,
+        })
       end
     end
 
     # Run a command and return a Makit::V1::Command.
+    # @deprecated Use Commands::Runner#execute instead
     def run(command_request)
+      warn_deprecation("CommandRunner#run is deprecated. Use Commands::Runner#execute instead.")
       raise "Invalid command_request" unless command_request.is_a? Makit::V1::CommandRequest
+
+      # Log command start
+      Makit::Logging.info("Starting command execution", {
+        command: command_request.name,
+        arguments: command_request.arguments,
+        directory: command_request.directory,
+      })
+
       command = execute(command_request)
-      show_output = true
-      exit_on_error = true
 
       log_to_artifacts(command) if @log_to_artifacts
       show_command(command)
-      if command.exit_code != 0
-        exit 1 if command_request.exit_on_error
-      end
+      exit 1 if (command.exit_code != 0) && command_request.exit_on_error
       commands.push(command)
       command
     end
@@ -179,7 +216,9 @@ module Makit
     end
 
     # Run a command and return a Makit::V1::Command.
+    # @deprecated Use Commands::Runner#execute with exit_on_error: false instead
     def try(args)
+      warn_deprecation("CommandRunner#try is deprecated. Use Commands::Runner#execute with exit_on_error: false instead.")
       request = parse_command_request(args)
       request.exit_on_error = false
       run(request)
@@ -195,16 +234,31 @@ module Makit
     end
 
     # Show the output of a command and return a Makit::V1::Command.
+    # @deprecated Use Commands::Runner#execute with show_output: true instead
     def show(args)
+      warn_deprecation("CommandRunner#show is deprecated. Use Commands::Runner#execute with show_output: true instead.")
       request = parse_args(args)
       command = execute(request)
 
-      show_output = true
-      exit_on_error = true
-      Makit::LOGGER.info(Makit::CommandRunner.get_command_summary(command))
-      show_output = true if command.exit_code != 0
-      Makit::LOGGER.info(indent_string("\n#{command.output}\n#{command.error}\n".strip, 2)) if show_output
-      exit(command.exit_code) if exit_on_error && command.exit_code != 0 # unless process_status.success?
+      # Log command execution with structured data
+      if command.exit_code.zero?
+        Makit::Logging.success("Command executed successfully", {
+          command: command.name,
+          arguments: command.arguments,
+          duration: command.duration&.seconds || 0,
+          output: command.output,
+        })
+      else
+        Makit::Logging.error("Command execution failed", {
+          command: command.name,
+          arguments: command.arguments,
+          exit_code: command.exit_code,
+          duration: command.duration&.seconds || 0,
+          output: command.output,
+          error: command.error,
+        })
+        exit(command.exit_code) if command.exit_code != 0
+      end
       command
     end
 
@@ -212,22 +266,22 @@ module Makit
     def parse_command_request(source)
       return Makit::V1::CommandRequest.new(source) if source.is_a? Hash
       return source if source.is_a? Makit::V1::CommandRequest
-      if source.is_a? String
-        return parse_args(source)
-      end
+      return parse_args(source) if source.is_a? String
 
       raise "Invalid source" unless source.is_a? Makit::V1::CommandRequest
     end
 
     def parse_command_request_from_hash(hash)
       raise "Invalid hash" unless hash.is_a? Hash
+
       Makit::V1::CommandRequest.new(hash)
     end
 
     def parse_command_request_from_string(source)
       raise "Invalid source" unless source.is_a? String
-      words = source.split(" ")
-      hash = {
+
+      words = source.split
+      {
         name: words.shift,
         arguments: words,
         exit_on_error: true,
@@ -236,31 +290,27 @@ module Makit
 
     # Parse the command line arguments into a Makit::V1::CommandRequest.
     def parse_args(args)
-      #raise "No command specified" if args.empty?
+      # raise "No command specified" if args.empty?
       if args.is_a? Makit::V1::CommandRequest
         args
-      else
-        if args.is_a? String
-          args = args.split(" ")
-          if (args.length == 1)
-            hash = {
+      elsif args.is_a? String
+        args = args.split
+        hash = if args.length == 1
+            {
               name: args[0],
               arguments: [],
               exit_on_error: true,
             }
-            Makit::V1::CommandRequest.new(hash)
           else
-            hash = {
+            {
               name: args.shift,
               arguments: args,
               exit_on_error: true,
             }
-
-            Makit::V1::CommandRequest.new(hash)
           end
-        else
-          Makit::V1::CommandRequest.new(args)
-        end
+        Makit::V1::CommandRequest.new(hash)
+      else
+        Makit::V1::CommandRequest.new(args)
       end
     end
 
@@ -273,7 +323,7 @@ module Makit
     def execute(args)
       command_request = parse_args(args)
       command_request.directory = Dir.pwd if command_request.directory.nil?
-      command_request.directory = Dir.pwd if command_request.directory.length == 0
+      command_request.directory = Dir.pwd if command_request.directory.empty?
       result = Makit::V1::Command.new(name: command_request.name)
       command_request.arguments.each do |arg|
         result.arguments.push(arg)
@@ -282,19 +332,19 @@ module Makit
       result.directory = command_request.directory
       start = Time.now
       filename_friendly_timestamp = Time.now.strftime("%Y.%m.%d_%H%M%S")
-      log_filename = File.join(Makit::Directories::LOG, "#{filename_friendly_timestamp}.log")
+      File.join(Makit::Directories::LOG, "#{filename_friendly_timestamp}.log")
 
       # assign a directory variable to the current working directory, if not specified,
       # otherwise assign the specified directory
       command_request.directory = Dir.pwd if command_request.directory.nil?
-      command_request.directory = Dir.pwd if command_request.directory.length == 0
+      command_request.directory = Dir.pwd if command_request.directory.empty?
       raise "Invalid directory" unless Dir.exist?(command_request.directory)
 
       result.started_at = Google::Protobuf::Timestamp.new(seconds: start.to_i, nanos: start.nsec.to_i)
       ############# execute the command
       (output, error, exit_code) = execute_command(command, command_request.directory, command_request.timeout)
-      result.output = output.force_encoding("ASCII-8BIT")
-      result.error = error.force_encoding("ASCII-8BIT")
+      result.output = output.dup.force_encoding("ASCII-8BIT")
+      result.error = error.dup.force_encoding("ASCII-8BIT")
       result.exit_code = exit_code.nil? ? 0 : exit_code
 
       elapsed_time = Time.now - start
@@ -317,8 +367,8 @@ module Makit
         Dir.chdir(directory) do
           output, error, process_status = Open3.capture3(command)
         end
-        return [output, error, process_status.exitstatus]
-      rescue => e
+        [output, error, process_status.exitstatus]
+      rescue StandardError => e
         # restore the original working directory
         Dir.chdir(original_directory)
         message_parts = []
@@ -326,9 +376,9 @@ module Makit
         message_parts << "directory: #{directory}"
         message_parts << "timeout: #{timeout}" unless timeout.nil?
         message_parts << "error: #{e.message}"
-        message = message_parts.join("\n") + "\n"
-        return ["", message, 1]
-        #raise Makit::Error, message
+        message = "#{message_parts.join("\n")}\n"
+        ["", message, 1]
+        # raise Makit::Error, message
       end
     end
 
@@ -336,18 +386,18 @@ module Makit
       # if the command_request is not a Makit::V1::CommandRequest, raise an error
       raise "Invalid command_request" unless command_request.is_a? Makit::V1::CommandRequest
 
-      args = Array.new
-      command_request.arguments.each do |arg|
-        args.push(arg)
+      args = command_request.arguments.map do |arg|
+        arg
       end
-      result = Makit::V1::Command.new({
-        name: command_request.name,
-        arguments: args,
-        started_at: Google::Protobuf::Timestamp.new({ seconds: Time.now.to_i, nanos: Time.now.nsec }),
-      })
+      Makit::V1::Command.new({
+                               name: command_request.name,
+                               arguments: args,
+                               started_at: Google::Protobuf::Timestamp.new({ seconds: Time.now.to_i,
+                                                                             nanos: Time.now.nsec }),
+                             })
 
       begin
-      rescue => e
+      rescue StandardError
       end
     end
 
@@ -362,25 +412,23 @@ module Makit
       symbol = Makit::Symbols.error if command.exit_code != 0
       summary = "#{symbol} #{command.name.colorize(:yellow)} #{command.arguments.join(" ")}"
 
-      if summary.length > 80
-        summary = summary.to_lines(80, command.name.length + 3)
-      end
+      summary = summary.to_lines(80, command.name.length + 3) if summary.length > 80
 
       summary
     end
 
     def log_rake_commands
       dir = File.join(Makit::Directories::PROJECT_ARTIFACTS, "commands")
-      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      FileUtils.mkdir_p(dir)
 
       # open a text file to write to
       File.open(File.join(dir, "rake.commands.txt"), "w") do |file|
-        #rake_commands = commands.select { |command| command.name == "rake" }
+        # rake_commands = commands.select { |command| command.name == "rake" }
         commands.each do |command|
-          file.puts " " + Makit::CommandRunner.get_command_summary(command).strip_color_codes
+          file.puts " #{Makit::CommandRunner.get_command_summary(command).strip_color_codes}"
           file.puts "   start time: #{command.started_at}"
-          file.puts command.output.strip_color_codes unless command.output.strip_color_codes.strip.length == 0
-          file.puts command.error.strip_color_codes unless command.error.strip_color_codes.strip.length == 0
+          file.puts command.output.strip_color_codes unless command.output.strip_color_codes.strip.empty?
+          file.puts command.error.strip_color_codes unless command.error.strip_color_codes.strip.empty?
           file.puts " "
         end
       end
@@ -388,17 +436,28 @@ module Makit
 
     def log_slowest_commands
       dir = File.join(Makit::Directories::PROJECT_ARTIFACTS, "commands")
-      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      FileUtils.mkdir_p(dir)
 
       # open a text file to write to
       File.open(File.join(dir, "slow.commands.txt"), "w") do |file|
-        Makit::RUNNER.commands.sort_by { |command| (command.duration.seconds + (command.duration.nanos / 1_000_000_000.0)) }.reverse.first(5).each do |command|
+        Makit::RUNNER.commands.sort_by do |command|
+          (command.duration.seconds + (command.duration.nanos / 1_000_000_000.0))
+        end.reverse.first(5).each do |command|
           # Convert to float representation
-          duration_in_float = command.duration.seconds + (command.duration.nanos / 1_000_000_000.0)
-          #puts "  #{command.name} took #{duration_in_float} seconds"
-          file.puts " " + Makit::CommandRunner.get_command_summary(command).strip_color_codes + " (#{command.duration.seconds} seconds)"
+          command.duration.seconds + (command.duration.nanos / 1_000_000_000.0)
+          # puts "  #{command.name} took #{duration_in_float} seconds"
+          file.puts " #{Makit::CommandRunner.get_command_summary(command).strip_color_codes} (#{command.duration.seconds} seconds)"
         end
       end
     end
-  end   # class CommandRunner
-end # module Makit
+
+    private
+
+    # Helper method to emit deprecation warnings
+    #
+    # @param message [String] deprecation message
+    def warn_deprecation(message)
+      warn "[DEPRECATED] #{message} (called from #{caller(1, 1).first})"
+    end
+  end
+end