makit 0.0.164 → 0.0.166

data/lib/makit/gitlab_runner.rb

@@ -1,59 +1,59 @@
-# frozen_string_literal: true
-
-require "yaml"
-require "fileutils"
-
-# This module provides classes for the Makit gem.
-module Makit
-  # This class provide methods for working with Directories/
-  #
-  # Example:
-  #
-  #   Makit::Directory.find_directory_with_pattern("/home/user", "*.rb")
-  #
-  class GitLabRunner
-    # Parse the .gitlab-ci.yml file
-    def parse_gitlab_ci_file(file_path)
-      YAML.load_file(file_path)
-    end
-
-    # Extract the script for a specified job
-    def extract_script(ci_config, job_name)
-      job = ci_config[job_name]
-      job ? job["script"] : nil
-    end
-
-    # Write the script to a temporary file
-    def write_script_to_file(script, file_path)
-      File.open(file_path, "w") do |file|
-        script.each { |line| file.puts(line) }
-      end
-    end
-
-    # Run the script in a Docker container
-    def run_script_in_docker(image, script_file)
-      system("docker run --rm -v #{Dir.pwd}:/workspace -w /workspace #{image} /bin/sh #{script_file}")
-    end
-
-    # Main function to execute the process
-    def run_job(ci_file_path, job_name, docker_image)
-      ci_config = parse_gitlab_ci_file(ci_file_path)
-      script = extract_script(ci_config, job_name)
-
-      unless script
-        puts "Job '#{job_name}' not found in #{ci_file_path}"
-        return
-      end
-
-      script_file = "temp_script.sh"
-      write_script_to_file(script, script_file)
-      FileUtils.chmod("+x", script_file)
-
-      puts "Running script in Docker container..."
-      run_script_in_docker(docker_image, script_file)
-
-      # Clean up the temporary script file
-      FileUtils.rm(script_file)
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+# This module provides classes for the Makit gem.
+module Makit
+  # This class provide methods for working with Directories/
+  #
+  # Example:
+  #
+  #   Makit::Directory.find_directory_with_pattern("/home/user", "*.rb")
+  #
+  class GitLabRunner
+    # Parse the .gitlab-ci.yml file
+    def parse_gitlab_ci_file(file_path)
+      YAML.load_file(file_path)
+    end
+
+    # Extract the script for a specified job
+    def extract_script(ci_config, job_name)
+      job = ci_config[job_name]
+      job ? job["script"] : nil
+    end
+
+    # Write the script to a temporary file
+    def write_script_to_file(script, file_path)
+      File.open(file_path, "w") do |file|
+        script.each { |line| file.puts(line) }
+      end
+    end
+
+    # Run the script in a Docker container
+    def run_script_in_docker(image, script_file)
+      system("docker run --rm -v #{Dir.pwd}:/workspace -w /workspace #{image} /bin/sh #{script_file}")
+    end
+
+    # Main function to execute the process
+    def run_job(ci_file_path, job_name, docker_image)
+      ci_config = parse_gitlab_ci_file(ci_file_path)
+      script = extract_script(ci_config, job_name)
+
+      unless script
+        puts "Job '#{job_name}' not found in #{ci_file_path}"
+        return
+      end
+
+      script_file = "temp_script.sh"
+      write_script_to_file(script, script_file)
+      FileUtils.chmod("+x", script_file)
+
+      puts "Running script in Docker container..."
+      run_script_in_docker(docker_image, script_file)
+
+      # Clean up the temporary script file
+      FileUtils.rm(script_file)
+    end
+  end
+end

data/lib/makit/humanize.rb

@@ -1,218 +1,218 @@
-# frozen_string_literal: true
-
-# This module provides classes for the Makit gem.
-module Makit
-  # Provides utilities for converting data into human-readable formats.
-  #
-  # This class handles formatting of file sizes, timestamps, durations,
-  # and build result summaries for display to users.
-  #
-  # @example Basic usage
-  #   Makit::Humanize.get_humanized_size(1024)  # => "1.00 KB"
-  #   Makit::Humanize.get_humanized_duration(3661)  # => "1 hour, 1 minute, 1 second"
-  #
-  class Humanize
-    def self.get_humanized_size(bytes, precision = 2)
-      units = %w[B KB MB GB TB PB]
-      return "0 B" if bytes.zero?
-
-      exp = (Math.log(bytes) / Math.log(1024)).to_i
-      exp = units.size - 1 if exp >= units.size
-
-      size = bytes.to_f / (1024 ** exp)
-      format("%.#{precision}f %s", size, units[exp])
-    end
-
-    def self.get_humanized_timestamp(timestamp)
-      return timestamp.strftime("%Y-%m-%d %I:%M:%S %p") if timestamp.respond_to?(:strftime)
-
-      timestamp.strftime("%Y-%m-%d %H:%M:%S")
-    end
-
-    def self.get_make_result_summary(make_result)
-      summary = "Make Result\n"
-      summary += "  Repository: #{make_result.repository}\n"
-      summary += "  Commit: #{make_result.commit}\n"
-      summary += "  Branch: #{make_result.branch}\n"
-      summary += "  Tag: #{make_result.tag}\n"
-      summary += "  Device: #{make_result.device}\n"
-      summary += "  Runtime Identifier: #{make_result.runtime_identifier}\n"
-      summary += "  Initial Size: #{get_humanized_size(make_result.initial_size)}\n"
-      summary += "  Final Size: #{get_humanized_size(make_result.final_size)}\n"
-      summary += "  Delta Size: #{get_humanized_size(make_result.final_size - make_result.initial_size)}\n"
-      summary += "  Commands: (#{make_result.commands.length})\n"
-      make_result.commands.each do |command|
-        details = get_command_details(command)
-        summary += "\n"
-        summary += indent_string(details, 4)
-        summary += "\n"
-      end
-
-      summary
-    end
-
-    def self.get_commands(commands)
-      message = ""
-      commands.each do |command|
-        message += Makit::Humanize.get_command_details(command)
-      end
-      message
-    end
-
-    def self.get_command_summary(command)
-      symbol = Makit::Symbols.warning
-      symbol = Makit::Symbols.checkmark if !command.exit_code.nil? && command.exit_code.zero?
-      symbol = Makit::Symbols.error if command.exit_code != 0
-      "#{symbol} #{command.name} #{command.arguments.join(" ")}"
-    end
-
-    def self.get_command_details(command)
-      summary = "#{get_command_summary(command)}\n"
-      summary += "  Name: #{command.name}\n"
-      summary += "  Arguments: #{command.arguments.join(" ")}\n"
-      summary += "  Directory: #{command.directory}\n"
-      summary += "  Exit Code: #{command.exit_code}\n"
-      if command.output.length.positive?
-        summary += "  Output:\n"
-        summary += indent_string(command.output, 4)
-        summary += "\n"
-      end
-      if command.error.length.positive?
-        summary += "  Error:\n"
-        summary += indent_string(command.error, 4)
-        summary += "\n"
-      end
-      summary
-    end
-
-    def self.indent_string(string, spaces)
-      string.split("\n").map { |line| (" " * spaces) + line }.join("\n")
-    end
-
-    def self.get_protobuf_timestamp(timestamp)
-      Time.at(timestamp.seconds, timestamp.nanos / 1000.0).strftime("%Y-%m-%d %H:%M:%S")
-    end
-
-    def self.get_protobuf_duration(duration)
-      total_seconds = duration.seconds + (duration.nanos / 1_000_000_000.0)
-      hours = (total_seconds / 3600).to_i
-      minutes = ((total_seconds % 3600) / 60).to_i
-      seconds = (total_seconds % 60).round(2)
-      "#{hours}h #{minutes}m #{seconds}s"
-    end
-
-    def self.get_humanized_duration(seconds_value)
-      minutes = (seconds_value / 60).to_i
-      seconds = (seconds_value % 60).to_i
-      hours = (minutes / 60).to_i
-      minutes %= 60
-      days = (hours / 24).to_i
-      hours %= 24
-      milliseconds = (seconds_value % 1 * 1000).to_i
-
-      parts = []
-      parts << "#{days} days" if days.positive?
-      parts << "#{hours} hours" if hours.positive?
-      if minutes.positive?
-        parts << if minutes == 1
-          "1 minute"
-        else
-          "#{minutes} minutes"
-        end
-      end
-      if seconds.positive?
-        parts << if seconds == 1
-          "1 second"
-        else
-          "#{seconds} seconds"
-        end
-      end
-      # parts << "#{seconds} seconds" if seconds > 0
-      parts << "#{milliseconds} milliseconds" if milliseconds.positive? && seconds < 1
-
-      parts << "0 seconds" if parts.empty?
-      parts.join(", ")
-    end
-
-    def self.get_pipeline_execution_summary(execution_result)
-      summary = "Pipeline Execution Summary\n"
-      summary += "  Execution ID: #{execution_result.execution_id}\n"
-      summary += "  Status: #{execution_result.status}\n"
-      summary += "  Started: #{execution_result.started_at}\n"
-      summary += "  Finished: #{execution_result.finished_at}\n" if execution_result.finished_at
-      
-      if execution_result.respond_to?(:total_duration_seconds) && execution_result.total_duration_seconds
-        summary += "  Duration: #{get_humanized_duration(execution_result.total_duration_seconds)}\n"
-      end
-      
-      if execution_result.respond_to?(:podman_version) && execution_result.podman_version
-        summary += "  Podman Version: #{execution_result.podman_version}\n"
-      end
-      
-      if execution_result.respond_to?(:execution_host) && execution_result.execution_host
-        summary += "  Host: #{execution_result.execution_host}\n"
-      end
-      
-      summary += "  Jobs: (#{execution_result.job_results.length})\n"
-      execution_result.job_results.each do |job_result|
-        summary += "\n"
-        summary += indent_string(get_job_execution_details(job_result), 4)
-        summary += "\n"
-      end
-      
-      if execution_result.errors && execution_result.errors.any?
-        summary += "\n  Errors:\n"
-        execution_result.errors.each do |error|
-          summary += "    - #{error}\n"
-        end
-      end
-      
-      if execution_result.warnings && execution_result.warnings.any?
-        summary += "\n  Warnings:\n"
-        execution_result.warnings.each do |warning|
-          summary += "    - #{warning}\n"
-        end
-      end
-      
-      summary
-    end
-
-    def self.get_job_execution_details(job_result)
-      details = "Job: #{job_result.job_name}\n"
-      details += "  Status: #{job_result.status}\n"
-      details += "  Started: #{job_result.started_at}\n"
-      details += "  Finished: #{job_result.finished_at}\n" if job_result.finished_at
-      details += "  Exit Code: #{job_result.exit_code}\n" if job_result.exit_code
-      
-      if job_result.errors && job_result.errors.any?
-        details += "  Errors:\n"
-        job_result.errors.each do |error|
-          details += "    - #{error}\n"
-        end
-      end
-      
-      if job_result.logs && job_result.logs.any?
-        details += "  Logs:\n"
-        job_result.logs.each do |log|
-          details += "    #{log}\n"
-        end
-      end
-      
-      if job_result.respond_to?(:stdout) && job_result.stdout && !job_result.stdout.empty?
-        details += "  Stdout:\n"
-        job_result.stdout.split("\n").each do |line|
-          details += "    #{line}\n"
-        end
-      end
-      
-      if job_result.respond_to?(:stderr) && job_result.stderr && !job_result.stderr.empty?
-        details += "  Stderr:\n"
-        job_result.stderr.split("\n").each do |line|
-          details += "    #{line}\n"
-        end
-      end
-      
-      details
-    end
-  end
-end
+# frozen_string_literal: true
+
+# This module provides classes for the Makit gem.
+module Makit
+  # Provides utilities for converting data into human-readable formats.
+  #
+  # This class handles formatting of file sizes, timestamps, durations,
+  # and build result summaries for display to users.
+  #
+  # @example Basic usage
+  #   Makit::Humanize.get_humanized_size(1024)  # => "1.00 KB"
+  #   Makit::Humanize.get_humanized_duration(3661)  # => "1 hour, 1 minute, 1 second"
+  #
+  class Humanize
+    def self.get_humanized_size(bytes, precision = 2)
+      units = %w[B KB MB GB TB PB]
+      return "0 B" if bytes.zero?
+
+      exp = (Math.log(bytes) / Math.log(1024)).to_i
+      exp = units.size - 1 if exp >= units.size
+
+      size = bytes.to_f / (1024 ** exp)
+      format("%.#{precision}f %s", size, units[exp])
+    end
+
+    def self.get_humanized_timestamp(timestamp)
+      return timestamp.strftime("%Y-%m-%d %I:%M:%S %p") if timestamp.respond_to?(:strftime)
+
+      timestamp.strftime("%Y-%m-%d %H:%M:%S")
+    end
+
+    def self.get_make_result_summary(make_result)
+      summary = "Make Result\n"
+      summary += "  Repository: #{make_result.repository}\n"
+      summary += "  Commit: #{make_result.commit}\n"
+      summary += "  Branch: #{make_result.branch}\n"
+      summary += "  Tag: #{make_result.tag}\n"
+      summary += "  Device: #{make_result.device}\n"
+      summary += "  Runtime Identifier: #{make_result.runtime_identifier}\n"
+      summary += "  Initial Size: #{get_humanized_size(make_result.initial_size)}\n"
+      summary += "  Final Size: #{get_humanized_size(make_result.final_size)}\n"
+      summary += "  Delta Size: #{get_humanized_size(make_result.final_size - make_result.initial_size)}\n"
+      summary += "  Commands: (#{make_result.commands.length})\n"
+      make_result.commands.each do |command|
+        details = get_command_details(command)
+        summary += "\n"
+        summary += indent_string(details, 4)
+        summary += "\n"
+      end
+
+      summary
+    end
+
+    def self.get_commands(commands)
+      message = ""
+      commands.each do |command|
+        message += Makit::Humanize.get_command_details(command)
+      end
+      message
+    end
+
+    def self.get_command_summary(command)
+      symbol = Makit::Symbols.warning
+      symbol = Makit::Symbols.checkmark if !command.exit_code.nil? && command.exit_code.zero?
+      symbol = Makit::Symbols.error if command.exit_code != 0
+      "#{symbol} #{command.name} #{command.arguments.join(" ")}"
+    end
+
+    def self.get_command_details(command)
+      summary = "#{get_command_summary(command)}\n"
+      summary += "  Name: #{command.name}\n"
+      summary += "  Arguments: #{command.arguments.join(" ")}\n"
+      summary += "  Directory: #{command.directory}\n"
+      summary += "  Exit Code: #{command.exit_code}\n"
+      if command.output.length.positive?
+        summary += "  Output:\n"
+        summary += indent_string(command.output, 4)
+        summary += "\n"
+      end
+      if command.error.length.positive?
+        summary += "  Error:\n"
+        summary += indent_string(command.error, 4)
+        summary += "\n"
+      end
+      summary
+    end
+
+    def self.indent_string(string, spaces)
+      string.split("\n").map { |line| (" " * spaces) + line }.join("\n")
+    end
+
+    def self.get_protobuf_timestamp(timestamp)
+      Time.at(timestamp.seconds, timestamp.nanos / 1000.0).strftime("%Y-%m-%d %H:%M:%S")
+    end
+
+    def self.get_protobuf_duration(duration)
+      total_seconds = duration.seconds + (duration.nanos / 1_000_000_000.0)
+      hours = (total_seconds / 3600).to_i
+      minutes = ((total_seconds % 3600) / 60).to_i
+      seconds = (total_seconds % 60).round(2)
+      "#{hours}h #{minutes}m #{seconds}s"
+    end
+
+    def self.get_humanized_duration(seconds_value)
+      minutes = (seconds_value / 60).to_i
+      seconds = (seconds_value % 60).to_i
+      hours = (minutes / 60).to_i
+      minutes %= 60
+      days = (hours / 24).to_i
+      hours %= 24
+      milliseconds = (seconds_value % 1 * 1000).to_i
+
+      parts = []
+      parts << "#{days} days" if days.positive?
+      parts << "#{hours} hours" if hours.positive?
+      if minutes.positive?
+        parts << if minutes == 1
+          "1 minute"
+        else
+          "#{minutes} minutes"
+        end
+      end
+      if seconds.positive?
+        parts << if seconds == 1
+          "1 second"
+        else
+          "#{seconds} seconds"
+        end
+      end
+      # parts << "#{seconds} seconds" if seconds > 0
+      parts << "#{milliseconds} milliseconds" if milliseconds.positive? && seconds < 1
+
+      parts << "0 seconds" if parts.empty?
+      parts.join(", ")
+    end
+
+    def self.get_pipeline_execution_summary(execution_result)
+      summary = "Pipeline Execution Summary\n"
+      summary += "  Execution ID: #{execution_result.execution_id}\n"
+      summary += "  Status: #{execution_result.status}\n"
+      summary += "  Started: #{execution_result.started_at}\n"
+      summary += "  Finished: #{execution_result.finished_at}\n" if execution_result.finished_at
+      
+      if execution_result.respond_to?(:total_duration_seconds) && execution_result.total_duration_seconds
+        summary += "  Duration: #{get_humanized_duration(execution_result.total_duration_seconds)}\n"
+      end
+      
+      if execution_result.respond_to?(:podman_version) && execution_result.podman_version
+        summary += "  Podman Version: #{execution_result.podman_version}\n"
+      end
+      
+      if execution_result.respond_to?(:execution_host) && execution_result.execution_host
+        summary += "  Host: #{execution_result.execution_host}\n"
+      end
+      
+      summary += "  Jobs: (#{execution_result.job_results.length})\n"
+      execution_result.job_results.each do |job_result|
+        summary += "\n"
+        summary += indent_string(get_job_execution_details(job_result), 4)
+        summary += "\n"
+      end
+      
+      if execution_result.errors && execution_result.errors.any?
+        summary += "\n  Errors:\n"
+        execution_result.errors.each do |error|
+          summary += "    - #{error}\n"
+        end
+      end
+      
+      if execution_result.warnings && execution_result.warnings.any?
+        summary += "\n  Warnings:\n"
+        execution_result.warnings.each do |warning|
+          summary += "    - #{warning}\n"
+        end
+      end
+      
+      summary
+    end
+
+    def self.get_job_execution_details(job_result)
+      details = "Job: #{job_result.job_name}\n"
+      details += "  Status: #{job_result.status}\n"
+      details += "  Started: #{job_result.started_at}\n"
+      details += "  Finished: #{job_result.finished_at}\n" if job_result.finished_at
+      details += "  Exit Code: #{job_result.exit_code}\n" if job_result.exit_code
+      
+      if job_result.errors && job_result.errors.any?
+        details += "  Errors:\n"
+        job_result.errors.each do |error|
+          details += "    - #{error}\n"
+        end
+      end
+      
+      if job_result.logs && job_result.logs.any?
+        details += "  Logs:\n"
+        job_result.logs.each do |log|
+          details += "    #{log}\n"
+        end
+      end
+      
+      if job_result.respond_to?(:stdout) && job_result.stdout && !job_result.stdout.empty?
+        details += "  Stdout:\n"
+        job_result.stdout.split("\n").each do |line|
+          details += "    #{line}\n"
+        end
+      end
+      
+      if job_result.respond_to?(:stderr) && job_result.stderr && !job_result.stderr.empty?
+        details += "  Stderr:\n"
+        job_result.stderr.split("\n").each do |line|
+          details += "    #{line}\n"
+        end
+      end
+      
+      details
+    end
+  end
+end

data/lib/makit/indexer.rb

@@ -1,47 +1,47 @@
-# frozen_string_literal: true
-
-# This module provides classes for the Makit gem.
-module Makit
-  # This class provide methods for indexing objects.
-  #
-  class Indexer
-    attr_accessor :keywords_index, :protoc_json_serializer # Hash of string key to string[] of keyword
-
-    def initialize
-      @keywords_index = {}
-      @protoc_json_serializer = Makit::Serializer.new(Makit::Proto3Formats::JSON)
-    end
-
-    def index(key, item)
-      # item must be serializable to json
-      keywords = []
-      hash = JSON.parse(item.to_json)
-      hash.each_value do |value|
-        value = value.to_s.downcase
-        keywords << value if value.length >= 3 && !keywords.include?(value)
-      end
-      keywords.each do |keyword|
-        @keywords_index[keyword] = [] unless @keywords_index.key?(keyword)
-        @keywords_index[keyword] << key unless @keywords_index[keyword].include?(key)
-      end
-    end
-
-    def search(query)
-      keys = []
-      # todo, remove terms less that length of 3
-      terms = query.downcase.split.reject { |term| term.length < 3 }
-      keywords_index.each do |key, value| # {|kvp|
-        keys << key if get_match_count(terms, value) == terms.length
-      end
-      keys
-    end
-
-    def get_match_count(terms, keywords)
-      match_count = 0
-      terms.each do |term|
-        match_count += 1 if keywords.include?(term)
-      end
-      match_count
-    end
-  end
-end
+# frozen_string_literal: true
+
+# This module provides classes for the Makit gem.
+module Makit
+  # This class provide methods for indexing objects.
+  #
+  class Indexer
+    attr_accessor :keywords_index, :protoc_json_serializer # Hash of string key to string[] of keyword
+
+    def initialize
+      @keywords_index = {}
+      @protoc_json_serializer = Makit::Serializer.new(Makit::Proto3Formats::JSON)
+    end
+
+    def index(key, item)
+      # item must be serializable to json
+      keywords = []
+      hash = JSON.parse(item.to_json)
+      hash.each_value do |value|
+        value = value.to_s.downcase
+        keywords << value if value.length >= 3 && !keywords.include?(value)
+      end
+      keywords.each do |keyword|
+        @keywords_index[keyword] = [] unless @keywords_index.key?(keyword)
+        @keywords_index[keyword] << key unless @keywords_index[keyword].include?(key)
+      end
+    end
+
+    def search(query)
+      keys = []
+      # todo, remove terms less that length of 3
+      terms = query.downcase.split.reject { |term| term.length < 3 }
+      keywords_index.each do |key, value| # {|kvp|
+        keys << key if get_match_count(terms, value) == terms.length
+      end
+      keys
+    end
+
+    def get_match_count(terms, keywords)
+      match_count = 0
+      terms.each do |term|
+        match_count += 1 if keywords.include?(term)
+      end
+      match_count
+    end
+  end
+end