makit 0.0.99 → 0.0.111

data/lib/makit/mp/project_mp.rb

@@ -1,14 +1,15 @@
 # frozen_string_literal: true
+
 require "json"
 require "yaml"
 
 module Makit
   module V1
     class Project
-      #def to_yaml
+      # def to_yaml
       #  data = JSON.parse(self.to_pretty_json)
       #  data.to_yaml.sub(/^---\n/, "")
-      #end
+      # end
 
       def self.create
         project = Makit::V1::Project.new
@@ -18,14 +19,14 @@ module Makit
 
       def open(filename)
         other = Makit::Serializer.open(filename, Makit::V1::Project)
-        #other = Makit::V1::Project::create_from_file(filename)
+        # other = Makit::V1::Project::create_from_file(filename)
         self.name = other.name
         self.git_remote_url = other.git_remote_url
         self.dotnet_projects = other.dotnet_projects
         self.artifacts = other.artifacts
       end
 
-      #def self.create_from_file(filename)
+      # def self.create_from_file(filename)
       #  extension = File.extname(filename)
       #  case extension
       #  when ".yml"
@@ -37,28 +38,26 @@ module Makit
       #  else
       #    raise "unsupported file extension: #{extension}"
       #  end
-      #end
+      # end
 
-      #def self.create_from_yaml(yaml)
+      # def self.create_from_yaml(yaml)
       #  json = JSON.pretty_generate(YAML.load(yaml))
       #  project = Makit::V1::Project.decode_json(json)
       #  project
-      #end
+      # end
 
-      #def self.create_from_json(json)
+      # def self.create_from_json(json)
       #  project = Makit::V1::Project.decode_json(json)
       #  project
-      #end
+      # end
 
       def set_default_values
-        #self.language = "csharp"
-        #self.primary_artifact_type = "nuget"
-        if self.git_remote_url.nil? || self.git_remote_url.empty?
-          self.git_remote_url = `git remote get-url origin`.strip
-        end
-        if self.name.nil? || self.name.empty?
-          if (!self.git_remote_url.nil? && !self.git_remote_url.empty?)
-            self.name = get_name(File.basename(self.git_remote_url, ".git")) # get_capitalized_name(File.basename(self.git_remote_url, ".git"))
+        # self.language = "csharp"
+        # self.primary_artifact_type = "nuget"
+        self.git_remote_url = `git remote get-url origin`.strip if git_remote_url.nil? || git_remote_url.empty?
+        if name.nil? || name.empty?
+          if !git_remote_url.nil? && !git_remote_url.empty?
+            self.name = get_name(File.basename(git_remote_url, ".git")) # get_capitalized_name(File.basename(self.git_remote_url, ".git"))
           else
             self.name = get_name(File.basename(Dir.getwd)) # get_capitalized_name(File.basename(Dir.getwd))
           end
@@ -67,11 +66,9 @@ module Makit
       end
 
       def get_name(name)
-        if !self.git_remote_url.nil? && !self.git_remote_url.empty?
-          is_dotnet = self.git_remote_url.include?("nuget")
-          if is_dotnet
-            get_capitalized_name(name)
-          end
+        if !git_remote_url.nil? && !git_remote_url.empty?
+          is_dotnet = git_remote_url.include?("nuget")
+          get_capitalized_name(name) if is_dotnet
         end
         name.downcase
       end
@@ -82,25 +79,25 @@ module Makit
 
       def save_as(filename)
         Makit::Serializer.save_as(filename, self)
-        #extension = File.extname(filename)
-        #case extension
-        #when ".json"
+        # extension = File.extname(filename)
+        # case extension
+        # when ".json"
         #  File.write(filename, self.to_pretty_json)
-        #when ".yml"
+        # when ".yml"
         #  File.write(filename, self.to_yaml)
-        #else
+        # else
         #  raise "unsupported file extension: #{extension}"
-        #end
+        # end
       end
 
       def with_dotnet_project(template, name, output)
-        if !self.dotnet_projects.any? { |project| project.output == output }
-          project = Makit::V1::DotNetProject.new
-          project.template = template
-          project.name = name
-          project.output = output
-          self.dotnet_projects << project
-        end
+        return if dotnet_projects.any? { |project| project.output == output }
+
+        project = Makit::V1::DotNetProject.new
+        project.template = template
+        project.name = name
+        project.output = output
+        dotnet_projects << project
       end
 
       def setup
@@ -112,8 +109,8 @@ module Makit
         make_dotnet_projects
 
         # verify the artifacts exist
-        self.artifacts.each do |artifact|
-          raise "artifact does not exist: #{artifact}" if !File.exist?(artifact)
+        artifacts.each do |artifact|
+          raise "artifact does not exist: #{artifact}" unless File.exist?(artifact)
         end
       end
 
@@ -126,85 +123,77 @@ module Makit
       end
 
       def setup_dotnet_projects
-        if self.dotnet_projects.any?
-          if (!File.exist?("#{self.name}.sln"))
-            puts "  Creating solution file: " + "#{self.name}.sln".colorize(:green)
-            "dotnet new sln -n #{self.name}".run unless File.exist?("#{self.name}.sln")
+        if dotnet_projects.any?
+          if !File.exist?("#{name}.sln")
+            puts "  Creating solution file: #{"#{name}.sln".colorize(:green)}"
+            "dotnet new sln -n #{name}".run unless File.exist?("#{name}.sln")
           else
-            #puts "  Solution file already exists: " + "#{self.name}.sln".colorize(:yellow)
+            # puts "  Solution file already exists: " + "#{self.name}.sln".colorize(:yellow)
           end
-          self.dotnet_projects.each do |project|
+          dotnet_projects.each do |project|
             add_project = true
-            if (project.os == "windows" && !Makit::Environment.is_windows?)
-              add_project = false
-            end
-            if (add_project)
-              Makit::DotNet.new_project(project.template, project.name, project.output)
-              # add any nuget packages to the project
-              project_filename = "#{project.output}/#{project.name}.csproj"
-              project.packages.each { |package|
-                Makit::DotNet::add_package(project_filename, package)
-              }
+            add_project = false if project.os == "windows" && !Makit::Environment.is_windows?
+            next unless add_project
+
+            Makit::DotNet.new_project(project.template, project.name, project.output)
+            # add any nuget packages to the project
+            project_filename = "#{project.output}/#{project.name}.csproj"
+            project.packages.each do |package|
+              Makit::DotNet.add_package(project_filename, package)
             end
           end
-          #Makit::DotNet.new_solution(self.name)
-          Makit::DotNet.sln_add_projects(self.name)
+          # Makit::DotNet.new_solution(self.name)
+          Makit::DotNet.sln_add_projects(name)
         else
-          #puts "  no dotnet projects found".colorize(:yellow)
+          # puts "  no dotnet projects found".colorize(:yellow)
         end
       end
 
       def make_dotnet_projects
-        self.dotnet_projects.each do |project|
-          if (project.os == "windows" && !Makit::Environment.is_windows?)
-            next
-          else
-            project.commands.each do |command|
-              newest_file_timestamp = Makit::Directory::get_newest_file_timestamp(project.output)
-              #newest_file = Makit::Directory::get_newest_file_or_now(project.output)
-              command_request = Makit::RUNNER::parse_command_request(command)
-              RUNNER.cache_run(command_request, newest_file_timestamp)
-            end
+        dotnet_projects.each do |project|
+          next if project.os == "windows" && !Makit::Environment.is_windows?
+
+          project.commands.each do |command|
+            newest_file_timestamp = Makit::Directory.get_newest_file_timestamp(project.output)
+            # newest_file = Makit::Directory::get_newest_file_or_now(project.output)
+            command_request = Makit::RUNNER.parse_command_request(command)
+            RUNNER.cache_run(command_request, newest_file_timestamp)
           end
         end
       end
 
       def build_dotnet_projects
-        self.dotnet_projects.each do |project|
-          if (project.os == "windows" && !Makit::Environment.is_windows?)
-            next
-          else
-            project.commands.each do |command|
-              newest_file_timestamp = Makit::Directory::get_newest_file_timestamp(project.output)
-              #newest_file = Makit::Directory::get_newest_file_or_now(project.output)
-              command_request = Makit::RUNNER::parse_command_request(command)
-              RUNNER.cache_run(command_request, newest_file_timestamp)
-            end
-            project.build_args.each do |build_arg|
-              project_path = File.join(project.output, "#{project.name}.csproj")
-              Makit::DotNet.build(project_path, build_arg.configuration, build_arg.output)
-            end
-            project.publish_args.each do |publish_arg|
-              project_path = File.join(project.output, "#{project.name}.csproj")
-              Makit::DotNet.publish(project_path, publish_arg.configuration, publish_arg.output)
-            end
+        dotnet_projects.each do |project|
+          next if project.os == "windows" && !Makit::Environment.is_windows?
+
+          project.commands.each do |command|
+            newest_file_timestamp = Makit::Directory.get_newest_file_timestamp(project.output)
+            # newest_file = Makit::Directory::get_newest_file_or_now(project.output)
+            command_request = Makit::RUNNER.parse_command_request(command)
+            RUNNER.cache_run(command_request, newest_file_timestamp)
+          end
+          project.build_args.each do |build_arg|
+            project_path = File.join(project.output, "#{project.name}.csproj")
+            Makit::DotNet.build(project_path, build_arg.configuration, build_arg.output)
+          end
+          project.publish_args.each do |publish_arg|
+            project_path = File.join(project.output, "#{project.name}.csproj")
+            Makit::DotNet.publish(project_path, publish_arg.configuration, publish_arg.output)
           end
         end
       end
 
       def test_dotnet_projects
-        self.dotnet_projects.each do |project|
-          if (project.os == "windows" && !Makit::Environment.is_windows?)
-            next
-          else
-            project.test_args.each do |test_args|
-              project_path = File.join(project.output, "#{project.name}.csproj")
-              Makit::DotNet.test(project_path, test_args.configuration, test_args.output)
-            end
-            #"dotnet test #{project.output} --configuration Release".run
+        dotnet_projects.each do |project|
+          next if project.os == "windows" && !Makit::Environment.is_windows?
+
+          project.test_args.each do |test_args|
+            project_path = File.join(project.output, "#{project.name}.csproj")
+            Makit::DotNet.test(project_path, test_args.configuration, test_args.output)
           end
+          # "dotnet test #{project.output} --configuration Release".run
         end
       end
-    end # class Project
-  end # module V1
-end # module Makit
+    end
+  end
+end

data/lib/makit/mp/string_mp.rb

@@ -1,107 +1,284 @@
 # frozen_string_literal: true
+
 require "json"
 # monkey patch String class with a run method
 
 class String
   def run(args = nil)
+    command = self
     if args.nil?
-      command = self
-      Makit::RUNNER.run(Makit::RUNNER::parse_command_request(command))
+      Makit::COMMANDS_COMPAT.run(Makit::COMMANDS_COMPAT.parse_command_request(command))
     else
-      command = self
-      request = Makit::RUNNER.parse_args(command)
+      # Parse initial request
+      base_request = Makit::COMMANDS_COMPAT.parse_command_request(command)
+
       if args.is_a?(Hash)
+        # Create new request with combined options
+        request_options = {
+          command: base_request.command,
+          arguments: base_request.arguments || [],
+          directory: base_request.directory,
+          timeout: base_request.timeout,
+          environment: base_request.environment || {},
+          metadata: base_request.metadata || {},
+        }
+
+        # Apply args to the request options
         args.each do |key, value|
-          request.send("#{key}=", value)
+          case key.to_s
+          when "arguments"
+            # Append additional arguments
+            request_options[:arguments] = request_options[:arguments] + Array(value)
+          when "directory"
+            request_options[:directory] = value
+          when "timeout"
+            request_options[:timeout] = value
+          when "environment"
+            request_options[:environment] = request_options[:environment].merge(value || {})
+          else
+            # Store other options in metadata
+            request_options[:metadata][key] = value
+          end
         end
+
+        # Create new request with updated options
+        request = Makit::Commands::Request.new(**request_options)
+      else
+        request = base_request
       end
-      Makit::RUNNER.run(request)
-    end
-  end
 
-  def cache_run()
-    command = self
-    Makit::RUNNER.cache_run(Makit::RUNNER::parse_command_request(command))
+      Makit::COMMANDS_COMPAT.run(request)
+    end
   end
 
   def cache_run(timestamp = nil)
+    command = self
     if timestamp.nil?
-      timestamp = Makit::GIT_FILE_INFOS.first.mtime #GIT_FILE_INFOS. Makit::Directory.get_newest_git_file_timestamp(Makit::Directories::PROJECT_ROOT)
-      #timestamp = Makit::Timestamp.now
+      # Use default timestamp from compatibility layer
+      Makit::COMMANDS_COMPAT.cache_run(Makit::COMMANDS_COMPAT.parse_command_request(command))
+    else
+      Makit::COMMANDS_COMPAT.cache_run(Makit::COMMANDS_COMPAT.parse_command_request(command), timestamp)
     end
-
-    command = self
-    Makit::RUNNER.cache_run(Makit::RUNNER::parse_command_request(command), timestamp)
   end
 
   def try(args = nil)
+    command = self
     if args.nil?
-      command = self
-      Makit::RUNNER.try(command)
+      Makit::COMMANDS_COMPAT.try(command)
     else
-      command = self
-      request = Makit::RUNNER.parse_args(command)
+      # Parse initial request
+      base_request = Makit::COMMANDS_COMPAT.parse_command_request(command)
+
       if args.is_a?(Hash)
+        # Create new request with combined options
+        request_options = {
+          command: base_request.command,
+          arguments: base_request.arguments || [],
+          directory: base_request.directory,
+          timeout: base_request.timeout,
+          environment: base_request.environment || {},
+          metadata: base_request.metadata || {},
+        }
+
+        # Apply args to the request options
         args.each do |key, value|
-          request.send("#{key}=", value)
+          case key.to_s
+          when "arguments"
+            # Append additional arguments
+            request_options[:arguments] = request_options[:arguments] + Array(value)
+          when "directory"
+            request_options[:directory] = value
+          when "timeout"
+            request_options[:timeout] = value
+          when "environment"
+            request_options[:environment] = request_options[:environment].merge(value || {})
+          else
+            # Store other options in metadata
+            request_options[:metadata][key] = value
+          end
         end
+
+        # Create new request with updated options
+        request = Makit::Commands::Request.new(**request_options)
+      else
+        request = base_request
       end
-      Makit::RUNNER.try(request)
+
+      Makit::COMMANDS_COMPAT.try(request)
     end
   end
 
   def show(args = nil)
+    command = self
     if args.nil?
-      command = self
-      Makit::RUNNER.show(command)
+      Makit::COMMANDS_COMPAT.show(command)
     else
-      command = self
-      request = Makit::RUNNER.parse_args(command)
+      # Parse initial request
+      base_request = Makit::COMMANDS_COMPAT.parse_command_request(command)
+
       if args.is_a?(Hash)
+        # Create new request with combined options
+        request_options = {
+          command: base_request.command,
+          arguments: base_request.arguments || [],
+          directory: base_request.directory,
+          timeout: base_request.timeout,
+          environment: base_request.environment || {},
+          metadata: base_request.metadata || {},
+        }
+
+        # Apply args to the request options
         args.each do |key, value|
-          request.send("#{key}=", value)
+          case key.to_s
+          when "arguments"
+            # Append additional arguments
+            request_options[:arguments] = request_options[:arguments] + Array(value)
+          when "directory"
+            request_options[:directory] = value
+          when "timeout"
+            request_options[:timeout] = value
+          when "environment"
+            request_options[:environment] = request_options[:environment].merge(value || {})
+          else
+            # Store other options in metadata
+            request_options[:metadata][key] = value
+          end
         end
+
+        # Create new request with updated options
+        request = Makit::Commands::Request.new(**request_options)
+      else
+        request = base_request
       end
-      Makit::RUNNER.show(request)
+
+      Makit::COMMANDS_COMPAT.show(request)
     end
   end
+
   def log(filename)
-    #puts "Logging to file: #{filename}"
-    # does the filename have a directory?
+    # Ensure directory exists if filename contains path
     if filename.include?("/")
-      # get the directory
       directory = File.dirname(filename)
-      # create the directory
-      #puts "Creating directory: #{directory}"
       FileUtils.mkdir_p(directory)
     end
     command = self
 
-    cmd =  Makit::RUNNER.run(Makit::RUNNER::parse_command_request(command))
-    # write the cmd output and error to the file
-    #puts "Writing to file: #{filename}"
+    Makit::Logging.info("Logging command output to file", {
+      command: command,
+      log_file: filename,
+    })
+
+    cmd = Makit::COMMANDS_COMPAT.run(Makit::COMMANDS_COMPAT.parse_command_request(command))
+
+    # Write the cmd output and error to the file
     File.write(filename, cmd.output + cmd.error)
 
-    # display the summary of the command
-    #puts "Command: #{command}"
-    #puts "Output: #{cmd.output}"
-    #puts "Error: #{cmd.error}"
-    Makit::RUNNER.show_command(cmd)
+    # Log the result
+    if cmd.success?
+      Makit::Logging.success("Command logged successfully", {
+        command: command,
+        log_file: filename,
+        output_length: cmd.output.length,
+        error_length: cmd.error.length,
+      })
+    else
+      Makit::Logging.error("Command failed and logged", {
+        command: command,
+        log_file: filename,
+        exit_code: cmd.exit_code,
+        output_length: cmd.output.length,
+        error_length: cmd.error.length,
+      })
+    end
+
+    Makit::COMMANDS_COMPAT.show_command(cmd)
   end
 
-  def cache_try()
+  def cache_log(filename, timestamp = nil)
+    # Ensure directory exists if filename contains path
+    if filename.include?("/")
+      directory = File.dirname(filename)
+      FileUtils.mkdir_p(directory)
+    end
     command = self
-    Makit::RUNNER.cache_try(Makit::RUNNER::parse_command_request(command))
+
+    #Makit::Logging.info("Cache logging command output", {
+    #  command: command,
+    #  log_file: filename,
+    #  timestamp: timestamp ? Makit::Humanize.get_humanized_timestamp(timestamp) : nil
+    #})
+
+    # Use cache_run with optional timestamp
+    cmd = if timestamp.nil?
+        Makit::COMMANDS_COMPAT.cache_run(Makit::COMMANDS_COMPAT.parse_command_request(command))
+      else
+        Makit::COMMANDS_COMPAT.cache_run(Makit::COMMANDS_COMPAT.parse_command_request(command), timestamp)
+      end
+
+    # Write the cached command output and error to the file
+    File.write(filename, cmd.output + cmd.error)
+
+    # Log the execution result
+    if cmd.success?
+      Makit::Logging.success(command)
+      #Makit::Logging.success("Command executed and cached", {
+      #  command: command,
+      #  log_file: filename,
+      #  cached: true,
+      #  output_length: cmd.output.length,
+      #   error_length: cmd.error.length
+      # })
+    else
+      Makit::Logging.error("Command failed and cached", {
+        command: command,
+        log_file: filename,
+        exit_code: cmd.exit_code,
+        cached: true,
+        output_length: cmd.output.length,
+        error_length: cmd.error.length,
+      })
+    end
+
+    # Display detailed output and log location only if it failed
+    return if cmd.success?
+
+    Makit::COMMANDS_COMPAT.show_command(cmd)
+    Makit::Logging.info("Log written to file", {
+      log_file: File.expand_path(filename),
+    })
   end
 
   def cache_try(timestamp = nil)
-    if timestamp.nil?
-      timestamp = Makit::GIT_FILE_INFOS.first.mtime #GIT_FILE_INFOS. Makit::Directory.get_newest_git_file_timestamp(Makit::Directories::PROJECT_ROOT)
-      #timestamp = Makit::Timestamp.now
+    command = self
+
+    Makit::Logging.info("Trying cached command execution", {
+      command: command,
+      timestamp: timestamp ? Makit::Humanize.get_humanized_timestamp(timestamp) : nil,
+    })
+
+    result = if timestamp.nil?
+        # Use default timestamp from compatibility layer
+        Makit::COMMANDS_COMPAT.cache_try(Makit::COMMANDS_COMPAT.parse_command_request(command))
+      else
+        Makit::COMMANDS_COMPAT.cache_try(Makit::COMMANDS_COMPAT.parse_command_request(command), timestamp)
+      end
+
+    # Log the result
+    if result.success?
+      Makit::Logging.success("Cached command executed successfully", {
+        command: command,
+        cached: true,
+        duration: result.duration,
+      })
+    else
+      Makit::Logging.warn("Cached command failed", {
+        command: command,
+        exit_code: result.exit_code,
+        cached: true,
+      })
     end
 
-    command = self
-    Makit::RUNNER.cache_try(Makit::RUNNER::parse_command_request(command), timestamp)
+    result
   end
 
   # Read a value from a JSON file
@@ -117,7 +294,7 @@ class String
     data
   end
 
-  alias_method :retrieve, :get_json_value
+  alias retrieve get_json_value
 
   # Set a value in a JSON file
   # key is a string with the key to set, e.g. "AzureAd.Authority"
@@ -129,7 +306,7 @@ class String
 
     # Traverse and create any missing keys
     keys[0..-2].each do |k|
-      current[k] ||= {}  # Create a new hash if the key doesn't exist
+      current[k] ||= {} # Create a new hash if the key doesn't exist
       current = current[k]
     end
 
@@ -141,36 +318,31 @@ class String
   end
 
   # Alias for set_json_value
-  alias_method :assign, :set_json_value
+  alias assign set_json_value
 
   def strip_color_codes
     # Regular expression to remove ANSI color codes
-    cleaned_content = self.gsub(/\e\[[\d;]+m/, "")
-    cleaned_content
+    gsub(/\e\[[\d;]+m/, "")
   end
 
   def to_lines(max_length = 80, indent_length = 5)
-    if (self.length <= max_length)
-      return self
-    else
-      indent = " " * indent_length
-      words = self.split(" ")
-      lines = []
-      line = ""
-      words.each do |word|
-        if ((line + word).length > max_length)
-          lines << line
-          line = indent + word
-        else
-          if (line.length == 0)
-            line = word
-          else
-            line += " " + word
-          end
-        end
+    return self if length <= max_length
+
+    indent = " " * indent_length
+    words = split(" ")
+    lines = []
+    line = ""
+    words.each do |word|
+      if (line + word).length > max_length
+        lines << line
+        line = indent + word
+      elsif line.empty?
+        line = word
+      else
+        line += " #{word}"
       end
-      lines << line
-      return lines.join("\n")
     end
+    lines << line
+    lines.join("\n")
   end
 end