makit 0.0.0

data/lib/makit/environment.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "sorted_set"
+require_relative "directory"
+# This module provides classes for the Makit gem.
+module Makit
+  # This class provide methods for working with the system Environment.
+  #
+  class Environment
+    def self.which(name)
+      return name if File.exist?(name)
+
+      ["", ".exe", ".bat", ".cmd"].each do |ext|
+        aname = name + ext
+        return aname if File.exist?(aname)
+
+        ENV["PATH"].split(File::PATH_SEPARATOR).each do |path|
+          apath = "#{path.gsub("\\", "/")}/#{aname}".gsub("//", "/")
+          return apath if File.exist?(apath)
+        end
+      end
+      ""
+    end
+
+    def self.constants_hash
+      constants = {}
+      # collect all constants that are all uppercase
+      Object.constants.each { |c| constants[c] = Object.const_get(c) if c == c.upcase } #	puts "#{c} = #{Object.const_get(c)}" }
+      #Object.constants.each { |c| constants[c] = Object.const_get(c)}#	puts "#{c} = #{Object.const_get(c)}" }
+      constants
+    end
+
+    def self.rake_file_name
+      caller_locations.each do |location|
+        return location.absolute_path if location.absolute_path&.end_with?("Rakefile")
+      end
+      nil
+    end
+
+    def self.gem_data_directory
+      gem_data_directory = File.join(Dir.home, ".makit")
+    end
+
+    def self.project_root_directory
+      if !Makit::Environment.rake_file_name.nil?
+        File.dirname(Makit::Environment.rake_file_name)
+      else
+        Makit::Directory.find_directory_with_pattern(File.dirname(__FILE__), "Rakefile")
+        # lass Directory
+        #  def self.find_directory_with_pattern(starting_directory, pattern)
+        # nil
+      end
+    end
+
+    def self.get_relative_directory(url)
+      url = url.gsub("https://", "").gsub("http://", "")
+      url = url.gsub("gitlab.com", "gitlab")
+      url
+    end
+
+    def self.get_code_root
+      # user home directory  + "code"
+      code_root = File.join(Dir.home, "code")
+    end
+
+    def self.get_work_directory(url)
+      raise "invalid url" if !url.include? "https://"
+      url = url.gsub("https://", "").gsub("http://", "")
+      #url = url.gsub("gitlab.com","gitlab")
+      url
+    end
+
+    def self.is_windows?
+      RbConfig::CONFIG["host_os"] =~ /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+    end
+
+    def self.get_os
+      case RbConfig::CONFIG["host_os"]
+      when /linux/
+        "Linux"
+      when /darwin/
+        "macOS"
+      when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+        "Windows"
+      else
+        "Unknown"
+      end
+    end
+
+    def self.get_runtime_identifier()
+      os = RbConfig::CONFIG["host_os"]
+      cpu = RbConfig::CONFIG["host_cpu"]
+
+      case os
+      when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+        os_rid = "win"
+      when /darwin|mac os/
+        os_rid = "osx"
+      when /linux/
+        os_rid = "linux"
+      when /solaris|bsd/
+        os_rid = "unix"
+      else
+        raise "Unknown operating system: host_os=#{os}"
+      end
+
+      case cpu
+      when /x86_64|amd64|x64/
+        arch_rid = "x64"
+      when /i686|i386/
+        arch_rid = "x86"
+        #when /arm/
+        #  arch_rid = "arm"
+      when /aarch64|arm64/
+        arch_rid = "arm64"
+      else
+        raise "Unknown architecture: host_cpu=#{cpu}"
+      end
+
+      "#{os_rid}-#{arch_rid}"
+    end
+  end
+end

data/lib/makit/files.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "directory"
+require_relative "environment"
+require_relative "protoc"
+require_relative "nuget"
+require_relative "version"
+require "rake"
+
+# This module provides classes for the Makit gem.
+module Makit
+  # This class provide methods for working with the system Environment.
+  #
+  module Files
+    if (Makit::Directories::PROJECT_ROOT != nil)
+      Dir.chdir(Makit::Directories::PROJECT_ROOT) do
+        CSPROJ = Dir.glob("**/*.csproj")
+      end
+    else
+      CSPROJ = Array.new
+    end
+
+    # show all the files constants in a nicely formatted table format with the name of the constant and the value
+    def self.show
+      # Array of constant names (symbols)
+      constant_names = [:CSPROJ]
+
+      # Find the length of the longest constant name and add 1
+      max_length = constant_names.map(&:to_s).max_by(&:length).length + 1
+
+      # Iterate through each constant name
+      constant_names.each do |constant_name|
+        begin
+          constant_value = const_get(constant_name)  # Fetch the value of the constant
+          if (constant_value != nil && File.exist?(constant_value))
+            constant_value = constant_value.colorize(:green)
+          end
+          # Print the constant name right justified to the max_length
+          puts "#{constant_name.to_s.rjust(max_length)} = #{constant_value}"
+        rescue NameError
+          # Handle the case where the constant is not defined
+          puts "#{constant_name.to_s.rjust(max_length)} = [Constant not defined]"
+        end
+      end
+    end
+  end # module Files
+end # module Makit

data/lib/makit/git.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+# This module provides classes for the Makit gem.
+module Makit
+  # This class provide methods for working with the system Environment.
+  #
+  class Git
+    def self.is_git_repo
+      Dir.exist? ".git"
+    end
+
+    def self.detached
+      `git status`.include?("detached")
+    end
+
+    def self.is_read_only
+      !is_git_repo || detached
+    end
+
+    def self.is_clean
+      `git status --porcelain`.empty?
+    end
+
+    def self.integrate
+      if is_git_repo && !detached
+        "git add .".run
+        "git commit -m \"integrate\"".run unless is_clean
+      end
+    end
+
+    def self.sync
+      if is_git_repo && !detached
+        "git pull".try
+        "git push origin".try
+      end
+    end
+
+    def self.zip_source_files(zipfilename)
+      "git archive --format zip --output #{zipfilename} HEAD".run
+    end
+
+    def self.branch
+      `git branch --show-current`.strip
+    end
+
+    def self.commitsha
+      `git rev-parse HEAD`.strip
+    end
+
+    def self.commitmsg
+      `git log -1 --pretty=%B`.strip
+    end
+
+    def self.commitdate
+      `git log -1 --pretty=%cd`.strip
+    end
+
+    def self.commitauthor
+      `git log -1 --pretty=%an`.strip
+    end
+
+    def self.commitemail
+      `git log -1 --pretty=%ae`.strip
+    end
+  end
+end

data/lib/makit/gitlab_runner.rb

@@ -0,0 +1,60 @@
+# 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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+# This module provides classes for the Makit gem.
+module Makit
+  class Humanize
+    def self.get_humanized_size(bytes, precision = 2)
+      units = ["B", "KB", "MB", "GB", "TB", "PB"]
+      return "0 B" if bytes == 0
+
+      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_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 > 0
+        summary += "  Output:\n"
+        summary += indent_string(command.output, 4)
+        summary += "\n"
+      end
+      if command.error.length > 0
+        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
+  end
+end

data/lib/makit/logging.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "logger"
+require "colorize"
+require_relative "symbols"
+
+# This module provides classes for the Makit gem.
+module Makit
+  module Logging
+    ANSI_COLOR_REGEX = /\e\[[0-9;]*m/
+
+    class PlainFormatter < Logger::Formatter
+      def call(_severity, _time, _progname, msg)
+        stripped_msg = msg.gsub(ANSI_COLOR_REGEX, "") # Remove ANSI color codes
+        "#{stripped_msg}\n"
+      end
+    end
+
+    class ColorFormatter < Logger::Formatter
+      def call(_severity, _time, _progname, msg)
+        "#{msg}\n"
+      end
+    end
+
+    # This class provide methods for working with Directories/
+    #
+    # Example:
+    #
+    #   Makit::Directory.find_directory_with_pattern("/home/user", "*.rb")
+    #
+    class MultiLogger
+      def initialize(*targets)
+        @targets = targets
+      end
+
+      def add(severity, message = nil, progname = nil, &block)
+        @targets.each do |logger|
+          logger.add(severity, message, progname, &block)
+          logger.flush if logger.respond_to?(:flush)
+        end
+      end
+
+      def <<(message)
+        @targets.each do |logger|
+          logger << message
+          logger.flush if logger.respond_to?(:flush)
+        end
+      end
+
+      def close
+        @targets.each(&:close)
+      end
+
+      def method_missing(method, *args, &block)
+        @targets.each { |logger| logger.send(method, *args, &block) }
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        @targets.all? { |logger| logger.respond_to?(method, include_private) }
+      end
+
+      def self.create_logger
+        stdout_logger = Logger.new($stdout) # ColoredLogger.new(STDOUT)
+        stdout_logger.level = Logger::DEBUG
+        # Assign the custom formatter to the file_logger
+        stdout_logger.formatter = ColorFormatter.new
+
+        # if clean or clobber commands are used, then log ONLY to stdout
+        if ARGV.include?("clean") || ARGV.include?("clobber")
+          return stdout_logger
+        end
+        if Makit::Environment.project_root_directory.nil?
+          logger = stdout_logger
+        else
+          #log_filename = if ARGV.empty?
+          #    "#{Makit::Environment.project_root_directory}/artifacts/rake.log"
+          #  else
+          #    "#{Makit::Environment.project_root_directory}/artifacts/rake_#{ARGV.join("_").gsub(":",
+          #                                                                                       "_")}.log"
+          #  end
+          # FileUtils.remove_file(log_file) if File.exist?(log_file)
+          #FileUtils.mkdir_p(File.dirname(log_filename)) unless Dir.exist?(File.dirname(log_filename))
+          #File.open(log_filename, "w")
+          #file_logger = Logger.new(log_filename)
+          #file_logger.level = Logger::DEBUG
+          # Assign the custom formatter to the file_logger
+          #file_logger.formatter = PlainFormatter.new
+          #logger = MultiLogger.new(file_logger, stdout_logger)
+          logger = stdout_logger
+        end
+
+        logger
+      end
+    end
+  end
+end

data/lib/makit/markdown.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "humanize"
+
+# This module provides classes for the Makit gem.
+module Makit
+  class Markdown
+    def self.get_commands_markdown(commands)
+      summary = ""
+      commands.each do |command|
+        md = Makit::Markdown.get_command_markdown(command)
+        summary += md
+      end
+      summary
+    end
+
+    def self.get_command_markdown(command)
+      md = "<details>\n"
+      md += "<summary>#{Makit::Humanize::get_command_summary(command)}</summary>\n\n"
+
+      if command.output.length > 0
+        md += "<table><tr><th>output</th></tr><tr><td>\n\n" #<pre>\n"
+        md += "```shell\n"
+        md += "#{command.output}\n"
+        md += "```\n\n"
+        md += "</td></tr></table>\n\n"
+        #md += "output:\n"
+        #md += "```shell\n"
+        #md += "#{command.output}\n"
+        #md += "```\n\n"
+      end
+      if command.error.length > 0
+        md += "error:\n"
+        md += "```shell\n"
+        md += "#{command.error}\n"
+        md += "```\n\n"
+      end
+      md += "| exit code | started at | duration | user | device | os | directory |\n"
+      md += "| --- | --- | --- | --- | --- | --- | --- |\n"
+      md += "| #{command.exit_code} | #{Makit::Humanize::get_protobuf_timestamp(command.started_at)} | #{Makit::Humanize::get_protobuf_duration(command.duration)} | #{command.user} | #{command.device} | #{command.os} | #{command.directory} |\n"
+
+      #md += "| Name | Value |\n"
+      #md += "| --- | --- |\n"
+      #md += "| exit code | #{command.exit_code} |\n"
+      #md += "| started at | #{Makit::Humanize::get_protobuf_timestamp(command.started_at)} |\n"
+      #md += "| duration | #{Makit::Humanize::get_protobuf_duration(command.duration)} |\n"
+      #md += "| user | #{command.user} |\n"
+      #md += "| device | #{command.device} |\n"
+      #md += "| os | #{command.os} |\n"
+      #md += "| directory | #{command.directory} |\n"
+      md += "</details>\n"
+      md
+    end
+
+    def self.get_make_result_markdown(make_result)
+      md = "# Make Result\n"
+      # display allow of the fields of the MakeResult message
+      md += "| Name | Value |\n"
+      md += "| --- | --- |\n"
+      md += "| repository | #{make_result.repository} |\n"
+      md += "| commit | #{make_result.commit} |\n"
+      md += "| branch | #{make_result.branch} |\n"
+      md += "| tag | #{make_result.tag} |\n"
+      md += "| device | #{make_result.device} |\n"
+      md += "| runtime identifier | #{make_result.runtime_identifier} |\n"
+      md += "| initial size | #{make_result.initial_size} |\n"
+      md += "| final size | #{make_result.final_size} |\n"
+      md += "\n"
+      md += "## Commands\n"
+      make_result.commands.each do |command|
+        md += Makit::Markdown.get_command_markdown(command)
+      end
+    end
+  end
+end

data/lib/makit/mp/basic_object_mp.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+require "json"
+require "yaml"
+
+# monkey patch String class with a run method
+
+class BasicObject
+  def to_json
+    self.to_json
+  end
+
+  def to_pretty_json
+    json = self.to_json
+    ::JSON.pretty_generate(::JSON.parse(json))
+  end
+end # class BasicObject