makit 0.0.157 → 0.0.158

data/lib/makit/mp/string_mp.rb

@@ -1,205 +1,205 @@
-# frozen_string_literal: true
-
-require "json"
-require "fileutils"
-# monkey patch String class with command execution methods
-
-class String
-  def run(args = nil)
-    command = self
-    if args.nil?
-      request = Makit::Commands::Request.from_string(command)
-    else
-      # Parse initial request
-      base_request = Makit::Commands::Request.from_string(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|
-          case key.to_s
-          when "arguments"
-            # Append additional arguments
-            request_options[:arguments] = (request_options[:arguments] + Array(value)).flatten
-          when "directory"
-            request_options[:directory] = value
-          when "timeout"
-            request_options[:timeout] = value
-          when "environment"
-            request_options[:environment] = (request_options[:environment] || {}).merge(value)
-          when "metadata"
-            request_options[:metadata] = (request_options[:metadata] || {}).merge(value)
-          else
-            # Add unknown keys to metadata
-            request_options[:metadata] = (request_options[:metadata] || {}).merge(key.to_s => value)
-          end
-        end
-
-        # Create new request with combined options
-        request = Makit::Commands::Request.new(**request_options)
-      else
-        # args is an array of additional arguments
-        request = Makit::Commands::Request.new(
-          command: base_request.command,
-          arguments: (base_request.arguments || []) + Array(args),
-          directory: base_request.directory,
-          timeout: base_request.timeout,
-          environment: base_request.environment || {},
-          metadata: base_request.metadata || {},
-        )
-      end
-    end
-    Makit::Commands::Runner.default.execute(request)
-  end
-
-  def cache_run(timestamp = nil, timeout: nil)
-    #puts "cache_run: #{self}"
-    command = self
-    request = Makit::Commands::Request.from_string(command)
-    
-    # Build request options
-    request_options = {
-      command: request.command,
-      arguments: request.arguments,
-      directory: request.directory,
-      timeout: timeout || request.timeout,
-      environment: request.environment || {},
-      metadata: request.metadata || {},
-    }
-    
-    if timestamp
-      # Add timestamp to metadata for cache key generation
-      request_options[:metadata] = request_options[:metadata].merge(timestamp: timestamp)
-      #puts "timestamp: #{timestamp}"
-    else
-      #puts "no timestamp"
-    end
-    
-    request = Makit::Commands::Request.new(**request_options)
-    Makit::Commands::Runner.default.execute(request)
-  end
-
-  def try
-    command = self
-    request = Makit::Commands::Request.from_string(command).exit_on_failure(false)
-    Makit::Commands::Runner.default.execute(request)
-  end
-
-  def show
-    command = self
-    request = Makit::Commands::Request.from_string(command)
-    Makit::Commands::Runner.default.execute(request)
-  end
-
-  def log(log_file = nil)
-    command = self
-    request = Makit::Commands::Request.from_string(command)
-    result = Makit::Commands::Runner.default.execute(request)
-
-    # If a log file is provided, write outputs to the file (maintains backward compatibility)
-    if log_file
-      FileUtils.mkdir_p(File.dirname(log_file))
-      File.write(log_file, "") unless File.exist?(log_file)
-      File.write(log_file, result.stdout, mode: "w") if result.stdout && !result.stdout.empty?
-      File.write(log_file, result.stderr, mode: "a") if result.stderr && !result.stderr.empty?
-    else
-      # Otherwise, log to the Makit logger
-      if result.success?
-        Makit::Logging.info("Command completed successfully: #{command}")
-      else
-        Makit::Logging.error("Command failed: #{command} (exit code: #{result.exit_code})")
-      end
-    end
-
-    result
-  end
-
-  def cache_try(timestamp = nil)
-    command = self
-    request = Makit::Commands::Request.from_string(command)
-    if timestamp
-      # Add timestamp to metadata for cache key generation
-      request = Makit::Commands::Request.new(
-        command: request.command,
-        arguments: request.arguments,
-        directory: request.directory,
-        timeout: request.timeout,
-        environment: request.environment || {},
-        metadata: (request.metadata || {}).merge(timestamp: timestamp),
-      )
-    end
-    Makit::Commands::Runner.default.execute(request)
-  end
-
-  def show_command(cmd)
-    if cmd.success?
-      puts "✅ #{cmd.command} #{cmd.arguments&.join(" ")}".colorize(:green)
-    else
-      puts "❌ #{cmd.command} #{cmd.arguments&.join(" ")}".colorize(:red)
-      puts "   Exit code: #{cmd.exit_code}".colorize(:red)
-      puts "   Error: #{cmd.stderr}".colorize(:red) if cmd.stderr && !cmd.stderr.empty?
-    end
-  end
-
-  def to_markdown
-    command = self
-    request = Makit::Commands::Request.from_string(command)
-    result = Makit::Commands::Runner.default.execute(request)
-
-    if result.success?
-      "```\n#{result.stdout}\n```"
-    else
-      "```\nError: #{result.stderr}\n```"
-    end
-  end
-
-  def cache_run_with_timestamp(timestamp)
-    command = self
-    request = Makit::Commands::Request.from_string(command)
-    request = Makit::Commands::Request.new(
-      command: request.command,
-      arguments: request.arguments,
-      directory: request.directory,
-      timeout: request.timeout,
-      environment: request.environment || {},
-      metadata: (request.metadata || {}).merge(timestamp: timestamp),
-    )
-    Makit::Commands::Runner.default.execute(request)
-  end
-
-  def cache_try_with_timestamp(timestamp)
-    command = self
-    request = Makit::Commands::Request.from_string(command)
-    request = Makit::Commands::Request.new(
-      command: request.command,
-      arguments: request.arguments,
-      directory: request.directory,
-      timeout: request.timeout,
-      environment: request.environment || {},
-      metadata: (request.metadata || {}).merge(timestamp: timestamp),
-    )
-    Makit::Commands::Runner.default.execute(request)
-  end
-
-  def cache_log(log_file)
-    command = self
-    request = Makit::Commands::Request.from_string(command)
-    result = Makit::Commands::Runner.default.execute(request)
-
-    # Write output to log file
-    FileUtils.mkdir_p(File.dirname(log_file))
-    File.write(log_file, result.stdout) if result.stdout && !result.stdout.empty?
-    File.write(log_file, result.stderr, mode: "a") if result.stderr && !result.stderr.empty?
-
-    result
-  end
-end
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+# monkey patch String class with command execution methods
+
+class String
+  def run(args = nil)
+    command = self
+    if args.nil?
+      request = Makit::Commands::Request.from_string(command)
+    else
+      # Parse initial request
+      base_request = Makit::Commands::Request.from_string(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|
+          case key.to_s
+          when "arguments"
+            # Append additional arguments
+            request_options[:arguments] = (request_options[:arguments] + Array(value)).flatten
+          when "directory"
+            request_options[:directory] = value
+          when "timeout"
+            request_options[:timeout] = value
+          when "environment"
+            request_options[:environment] = (request_options[:environment] || {}).merge(value)
+          when "metadata"
+            request_options[:metadata] = (request_options[:metadata] || {}).merge(value)
+          else
+            # Add unknown keys to metadata
+            request_options[:metadata] = (request_options[:metadata] || {}).merge(key.to_s => value)
+          end
+        end
+
+        # Create new request with combined options
+        request = Makit::Commands::Request.new(**request_options)
+      else
+        # args is an array of additional arguments
+        request = Makit::Commands::Request.new(
+          command: base_request.command,
+          arguments: (base_request.arguments || []) + Array(args),
+          directory: base_request.directory,
+          timeout: base_request.timeout,
+          environment: base_request.environment || {},
+          metadata: base_request.metadata || {},
+        )
+      end
+    end
+    Makit::Commands::Runner.default.execute(request)
+  end
+
+  def cache_run(timestamp = nil, timeout: nil)
+    #puts "cache_run: #{self}"
+    command = self
+    request = Makit::Commands::Request.from_string(command)
+    
+    # Build request options
+    request_options = {
+      command: request.command,
+      arguments: request.arguments,
+      directory: request.directory,
+      timeout: timeout || request.timeout,
+      environment: request.environment || {},
+      metadata: request.metadata || {},
+    }
+    
+    if timestamp
+      # Add timestamp to metadata for cache key generation
+      request_options[:metadata] = request_options[:metadata].merge(timestamp: timestamp)
+      #puts "timestamp: #{timestamp}"
+    else
+      #puts "no timestamp"
+    end
+    
+    request = Makit::Commands::Request.new(**request_options)
+    Makit::Commands::Runner.default.execute(request)
+  end
+
+  def try
+    command = self
+    request = Makit::Commands::Request.from_string(command).exit_on_failure(false)
+    Makit::Commands::Runner.default.execute(request)
+  end
+
+  def show
+    command = self
+    request = Makit::Commands::Request.from_string(command)
+    Makit::Commands::Runner.default.execute(request)
+  end
+
+  def log(log_file = nil)
+    command = self
+    request = Makit::Commands::Request.from_string(command)
+    result = Makit::Commands::Runner.default.execute(request)
+
+    # If a log file is provided, write outputs to the file (maintains backward compatibility)
+    if log_file
+      FileUtils.mkdir_p(File.dirname(log_file))
+      File.write(log_file, "") unless File.exist?(log_file)
+      File.write(log_file, result.stdout, mode: "w") if result.stdout && !result.stdout.empty?
+      File.write(log_file, result.stderr, mode: "a") if result.stderr && !result.stderr.empty?
+    else
+      # Otherwise, log to the Makit logger
+      if result.success?
+        Makit::Logging.info("Command completed successfully: #{command}")
+      else
+        Makit::Logging.error("Command failed: #{command} (exit code: #{result.exit_code})")
+      end
+    end
+
+    result
+  end
+
+  def cache_try(timestamp = nil)
+    command = self
+    request = Makit::Commands::Request.from_string(command)
+    if timestamp
+      # Add timestamp to metadata for cache key generation
+      request = Makit::Commands::Request.new(
+        command: request.command,
+        arguments: request.arguments,
+        directory: request.directory,
+        timeout: request.timeout,
+        environment: request.environment || {},
+        metadata: (request.metadata || {}).merge(timestamp: timestamp),
+      )
+    end
+    Makit::Commands::Runner.default.execute(request)
+  end
+
+  def show_command(cmd)
+    if cmd.success?
+      puts "✅ #{cmd.command} #{cmd.arguments&.join(" ")}".colorize(:green)
+    else
+      puts "❌ #{cmd.command} #{cmd.arguments&.join(" ")}".colorize(:red)
+      puts "   Exit code: #{cmd.exit_code}".colorize(:red)
+      puts "   Error: #{cmd.stderr}".colorize(:red) if cmd.stderr && !cmd.stderr.empty?
+    end
+  end
+
+  def to_markdown
+    command = self
+    request = Makit::Commands::Request.from_string(command)
+    result = Makit::Commands::Runner.default.execute(request)
+
+    if result.success?
+      "```\n#{result.stdout}\n```"
+    else
+      "```\nError: #{result.stderr}\n```"
+    end
+  end
+
+  def cache_run_with_timestamp(timestamp)
+    command = self
+    request = Makit::Commands::Request.from_string(command)
+    request = Makit::Commands::Request.new(
+      command: request.command,
+      arguments: request.arguments,
+      directory: request.directory,
+      timeout: request.timeout,
+      environment: request.environment || {},
+      metadata: (request.metadata || {}).merge(timestamp: timestamp),
+    )
+    Makit::Commands::Runner.default.execute(request)
+  end
+
+  def cache_try_with_timestamp(timestamp)
+    command = self
+    request = Makit::Commands::Request.from_string(command)
+    request = Makit::Commands::Request.new(
+      command: request.command,
+      arguments: request.arguments,
+      directory: request.directory,
+      timeout: request.timeout,
+      environment: request.environment || {},
+      metadata: (request.metadata || {}).merge(timestamp: timestamp),
+    )
+    Makit::Commands::Runner.default.execute(request)
+  end
+
+  def cache_log(log_file)
+    command = self
+    request = Makit::Commands::Request.from_string(command)
+    result = Makit::Commands::Runner.default.execute(request)
+
+    # Write output to log file
+    FileUtils.mkdir_p(File.dirname(log_file))
+    File.write(log_file, result.stdout) if result.stdout && !result.stdout.empty?
+    File.write(log_file, result.stderr, mode: "a") if result.stderr && !result.stderr.empty?
+
+    result
+  end
+end

data/lib/makit/nuget.rb

@@ -1,74 +1,74 @@
-# frozen_string_literal: true
-
-require "tmpdir"
-# This module provides classes for the Makit gem.
-module Makit
-  # This class provide methods for working with the  Nuget package cache
-  #
-  # Example:
-  #
-  #   Makit::Directory.cache("Google.Protobuf", "3.27.2")
-  #
-  # dotnet nuget locals all --list
-  # dotnet nuget locals all --clear
-  #
-  class NuGet
-    def self.get_cache_dir(package, version)
-      File.join(Makit::Directories::NUGET_PACKAGE_CACHE, package, version)
-    end
-
-    def self.cache(package, version)
-      # if the package is already cached, there is nothing to do
-      return if Dir.exist?(get_cache_dir(package, version))
-
-      Dir.mktmpdir do |dir|
-        # Use the temp directory here
-        Dir.chdir(dir) do
-          system("dotnet new classlib -n ClassLib")
-          Dir.chdir("ClassLib") do
-            # display a list of directories in the current directory
-            puts Dir.entries(Dir.pwd)
-            # display a list of files in the current directory
-            puts Dir.entries(Dir.pwd)
-            puts "dotnet add ClassLib.csproj package #{package} --version #{version}"
-            system("dotnet add ClassLib.csproj package #{package} --version #{version}")
-          end
-        end
-        # The directory and its contents will be removed automatically after the block
-      end
-    end
-
-    def self.clear_cache(package, version)
-      return unless Dir.exist?(get_cache_dir(package, version))
-
-      FileUtils.rm_rf(get_cache_dir(package, version))
-    end
-
-    # get the latest version of the package
-    def self.get_latest_version(package)
-      dir = File.join(Makit::Directories::NUGET_PACKAGE_CACHE, package)
-      if Dir.exist?(dir)
-        versions = Dir.entries(dir).select do |entry|
-          File.directory?(File.join(dir, entry)) && ![".", ".."].include?(entry)
-        end
-        highest_version = Makit::Version.get_highest_version(versions)
-        return highest_version
-      end
-      nil
-    end
-
-    # publish a package to a nuget directory feed
-    def self.add_package(_package, path)
-      system("dotnet nuget push #{path} --source #{path}")
-    end
-
-    def self.publish_to_directory(nuget_package_path, directory, package_name, version)
-      target_package_path = "#{directory}/#{package_name}/#{version}/#{package_name}.#{version}.nupkg".downcase
-      if File.exist?(target_package_path)
-        puts "  #{target_package_path} already exists".colorize(:grey)
-      else
-        "dotnet nuget push #{nuget_package_path} --source #{directory}".run
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "tmpdir"
+# This module provides classes for the Makit gem.
+module Makit
+  # This class provide methods for working with the  Nuget package cache
+  #
+  # Example:
+  #
+  #   Makit::Directory.cache("Google.Protobuf", "3.27.2")
+  #
+  # dotnet nuget locals all --list
+  # dotnet nuget locals all --clear
+  #
+  class NuGet
+    def self.get_cache_dir(package, version)
+      File.join(Makit::Directories::NUGET_PACKAGE_CACHE, package, version)
+    end
+
+    def self.cache(package, version)
+      # if the package is already cached, there is nothing to do
+      return if Dir.exist?(get_cache_dir(package, version))
+
+      Dir.mktmpdir do |dir|
+        # Use the temp directory here
+        Dir.chdir(dir) do
+          system("dotnet new classlib -n ClassLib")
+          Dir.chdir("ClassLib") do
+            # display a list of directories in the current directory
+            puts Dir.entries(Dir.pwd)
+            # display a list of files in the current directory
+            puts Dir.entries(Dir.pwd)
+            puts "dotnet add ClassLib.csproj package #{package} --version #{version}"
+            system("dotnet add ClassLib.csproj package #{package} --version #{version}")
+          end
+        end
+        # The directory and its contents will be removed automatically after the block
+      end
+    end
+
+    def self.clear_cache(package, version)
+      return unless Dir.exist?(get_cache_dir(package, version))
+
+      FileUtils.rm_rf(get_cache_dir(package, version))
+    end
+
+    # get the latest version of the package
+    def self.get_latest_version(package)
+      dir = File.join(Makit::Directories::NUGET_PACKAGE_CACHE, package)
+      if Dir.exist?(dir)
+        versions = Dir.entries(dir).select do |entry|
+          File.directory?(File.join(dir, entry)) && ![".", ".."].include?(entry)
+        end
+        highest_version = Makit::Version.get_highest_version(versions)
+        return highest_version
+      end
+      nil
+    end
+
+    # publish a package to a nuget directory feed
+    def self.add_package(_package, path)
+      system("dotnet nuget push #{path} --source #{path}")
+    end
+
+    def self.publish_to_directory(nuget_package_path, directory, package_name, version)
+      target_package_path = "#{directory}/#{package_name}/#{version}/#{package_name}.#{version}.nupkg".downcase
+      if File.exist?(target_package_path)
+        puts "  #{target_package_path} already exists".colorize(:grey)
+      else
+        "dotnet nuget push #{nuget_package_path} --source #{directory}".run
+      end
+    end
+  end
+end