makit 0.0.98 → 0.0.111

data/lib/makit/nuget.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "tmpdir"
 # This module provides classes for the Makit gem.
 module Makit
@@ -17,56 +19,56 @@ module Makit
 
     def self.cache(package, version)
       # if the package is already cached, there is nothing to do
-      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
+      return if Dir.exist?(get_cache_dir(package, version))
 
-              # 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
+      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
-          # The directory and its contents will be removed automatically after the block
         end
+        # The directory and its contents will be removed automatically after the block
       end
     end
 
     def self.clear_cache(package, version)
-      if (Dir.exist?(get_cache_dir(package, version)))
-        FileUtils.rm_rf(get_cache_dir(package, version))
-      end
+      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 { |entry| File.directory?(File.join(dir, entry)) && !(entry == "." || entry == "..") }
-        highest_version = Makit::Version::get_highest_version(versions)
+      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)
+    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)
+    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))
+      if File.exist?(target_package_path)
         puts "  #{target_package_path} already exists".colorize(:grey)
-      else  
+      else
         "dotnet nuget push #{nuget_package_path} --source #{directory}".run
       end
     end
-    
   end
 end

data/lib/makit/port.rb

@@ -2,33 +2,31 @@
 
 # This module provides classes for the Makit gem.
 module Makit
-    # This class provide methods for working with ports
-    #
-    class Port
-        def self.is_port_available?(port)
-            begin
-                socket = Socket.new(:INET, :STREAM)
-                socket.bind(Socket.sockaddr_in(port, ''))
-                socket.close
-                return true # Port is available for use
-            rescue Errno::EADDRINUSE, Errno::EACCES
-                return false # Port is not available for use
-            end
-        end
+  # This class provide methods for working with ports
+  #
+  class Port
+    def self.is_port_available?(port)
+      socket = Socket.new(:INET, :STREAM)
+      socket.bind(Socket.sockaddr_in(port, ""))
+      socket.close
+      true # Port is available for use
+    rescue Errno::EADDRINUSE, Errno::EACCES
+      false # Port is not available for use
+    end
 
-        def self.get_available_port(start_port = 1024, end_port = 65535)
-            (start_port..end_port).each do |port|
-                return port if is_port_available?(port)
-            end
-            nil # No available port found in the range
-        end
+    def self.get_available_port(start_port = 1024, end_port = 65_535)
+      (start_port..end_port).each do |port|
+        return port if is_port_available?(port)
+      end
+      nil # No available port found in the range
+    end
 
-        def self.get_random_port
-            rand(1024..65535)
-        end
+    def self.get_random_port
+      rand(1024..65_535)
+    end
 
-        def self.get_random_available_port
-            get_available_port(get_random_port)
-        end
-    end # class Port
-end # module Makit
+    def self.get_random_available_port
+      get_available_port(get_random_port)
+    end
+  end
+end

data/lib/makit/process.rb

@@ -1,64 +1,162 @@
+# frozen_string_literal: true
+
 # This module provides classes for the Makit gem.
 module Makit
+  # Cross-platform process management utilities
+  #
+  # This class provides methods for checking, listing, and terminating processes
+  # across different operating systems (Windows, Linux, macOS). It abstracts
+  # platform-specific commands into a unified interface.
   class Process
+    # Check if a process with the given name is currently running
+    #
+    # Uses platform-specific commands:
+    # - Windows: tasklist command
+    # - Unix: ps command with grep filtering
+    #
+    # @param name [String] Name of the process to check (without .exe extension)
+    # @return [Boolean] True if the process is running, false otherwise
     def self.is_running?(name)
+      return false if name.nil? || name.strip.empty?
+
       # provide a cross-platform way to check if a process is running
-      if Makit::Environment.is_windows?
-        # on windows, use the tasklist command
-        results = `tasklist /FI "imagename eq #{name}.exe"`
-        results.include?(name)
-      else
-        # on linux, use the ps command
-        results = `ps aux | grep #{name} | grep -v grep`
-        results.include?(name)
-      end
+      results = if Makit::Environment.is_windows?
+          # on windows, use the tasklist command
+          `tasklist /FI "imagename eq #{name}.exe" 2>nul`
+        else
+          # on linux/mac, use the ps command
+          `ps aux | grep "#{name}" | grep -v grep 2>/dev/null`
+        end
+      results.include?(name)
     end
 
-    # kill all processes that match a name
+    # Terminate all processes that match a given name
+    #
+    # Uses platform-specific termination commands:
+    # - Windows: taskkill command
+    # - Unix: kill command with SIGKILL (-9)
     #
-    # for a use case, running on a macbook:
-    # Makit::Process.kill("dotnet")
-    # an error 'kill: illegal process id: dotnet' is reported
+    # @param name [String] Name of the process(es) to terminate
+    # @return [Array<String>] Array of killed process IDs (empty if none found/killed)
     def self.kill(name)
-      # provide a cross-platform way to kill a process
+      return [] if name.nil? || name.strip.empty?
+
+      killed_pids = []
+
       if Makit::Environment.is_windows?
-        `taskkill /IM #{name}.exe /F`
+        # Windows: Use tasklist to find PIDs first, then kill them
+        begin
+          # Find processes by name
+          tasklist_output = `tasklist /FI "imagename eq #{name}.exe" /FO CSV 2>nul`
+
+          # Parse CSV output to extract PIDs
+          lines = tasklist_output.split("\n")
+          if lines.length > 1 # Skip header line
+            lines[1..].each do |line|
+              parts = line.split(",")
+              next unless parts.length >= 2
+
+              pid = parts[1]&.gsub('"', "")&.strip
+              next unless pid && !pid.empty? && pid.match?(/^\d+$/)
+
+              begin
+                `taskkill /PID #{pid} /F 2>nul`
+                killed_pids << pid
+              rescue StandardError => e
+                # Log error but continue with other processes
+                puts "Failed to kill process #{pid}: #{e.message}"
+              end
+            end
+          end
+        rescue StandardError => e
+          # If tasklist fails, try direct taskkill by name
+          begin
+            `taskkill /IM "#{name}.exe" /F 2>nul`
+            # Since we can't get PIDs from direct kill, return empty array
+            # but don't raise error
+          rescue StandardError => e2
+            # Both methods failed, return empty array
+            puts "Failed to kill processes by name #{name}: #{e2.message}"
+          end
+        end
       else
-        # First find all PIDs matching the name
-        pids = `pgrep -f #{name}`.split("\n")
-        # Kill each process by its PID
-        pids.each do |pid|
-          `kill -9 #{pid}` unless pid.empty?
+        # Unix (Linux/Mac): Use pgrep to find PIDs, then kill them
+        begin
+          # Use pgrep to find PIDs, handle both Linux and Mac
+          pids = if Makit::Environment.is_mac?
+              # Mac: pgrep -f might not work the same way
+              `pgrep -x "#{name}" 2>/dev/null`.split("\n").reject(&:empty?)
+            else
+              # Linux: pgrep -f works well
+              `pgrep -f "#{name}" 2>/dev/null`.split("\n").reject(&:empty?)
+            end
+
+          pids.each do |pid|
+            next unless pid.match?(/^\d+$/)
+
+            begin
+              `kill -9 #{pid} 2>/dev/null`
+              killed_pids << pid
+            rescue StandardError => e
+              puts "Failed to kill process #{pid}: #{e.message}"
+            end
+          end
+        rescue StandardError => e
+          # If pgrep fails, return empty array but don't raise error
+          puts "Failed to find processes by name #{name}: #{e.message}"
         end
       end
+
+      killed_pids
     end
 
+    # List all running processes on the system
+    #
+    # Uses platform-specific commands to get a complete process listing:
+    # - Windows: tasklist command
+    # - Unix: ps aux command
+    #
+    # @return [String] Raw output from the system process listing command
     def self.list
       if Makit::Environment.is_windows?
-        `tasklist`
+        `tasklist 2>nul`
       else
-        `ps aux`
+        `ps aux 2>/dev/null`
       end
     end
 
+    # List all running processes for the current user
+    #
+    # Filters the process list to show only processes owned by the current user.
+    # Uses platform-specific filtering:
+    # - Windows: tasklist with USERNAME filter
+    # - Unix: ps aux with grep filtering
+    #
+    # @return [String] Raw output from the filtered process listing command
     def self.list_current_user
       if Makit::Environment.is_windows?
-        `tasklist /FI "STATUS eq running and USERNAME eq #{Makit::Environment.current_user}"`
+        `tasklist /FI "STATUS eq running and USERNAME eq #{Makit::Environment.current_user}" 2>nul`
       else
-        `ps aux | grep #{Makit::Environment.current_user} | grep -v grep`
+        `ps aux | grep "#{Makit::Environment.current_user}" | grep -v grep 2>/dev/null`
       end
     end
 
-    # list all processes for the current user
-    # name is a string to filter the processes by name
+    # List processes for the current user filtered by name
+    #
+    # Returns an array of process lines for consistency across platforms.
+    # Filters by both current user and process name.
+    #
+    # @param name [String] Process name to filter by
+    # @return [Array<String>] Array of process lines matching the criteria
     def self.list_current_user_processes(name)
       if Makit::Environment.is_windows?
-        `tasklist /FI "STATUS eq running and USERNAME eq #{Makit::Environment.current_user}"`
         # filter the results to only include the current user
-        results = `tasklist /FI "STATUS eq running and USERNAME eq #{Makit::Environment.current_user}"`
+        results = `tasklist /FI "STATUS eq running and USERNAME eq #{Makit::Environment.current_user}" 2>nul`
         results.split("\n").select { |line| line.include?(Makit::Environment.current_user) }
       else
-        `ps aux | grep #{name} | grep -v grep`
+        # Unix (Linux/Mac): return as array for consistency
+        results = `ps aux | grep "#{name}" | grep -v grep 2>/dev/null`
+        results.split("\n").reject(&:empty?)
       end
     end
   end

data/lib/makit/protoc.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "pathname"
 
 # This module provides classes for the Makit gem.
@@ -7,23 +8,23 @@ module Makit
   #
   class Protoc
     def self.grpc_tools_path
-      File.join(Makit::Directories::NUGET_PACKAGE_CACHE, "grpc.tools", Makit::Protoc::get_latest_grpc_tools_version)
+      File.join(Makit::Directories::NUGET_PACKAGE_CACHE, "grpc.tools", Makit::Protoc.get_latest_grpc_tools_version)
     end
 
     def self.grpc_csharp_plugin_path
-      Makit::Protoc::find_plugin_path("grpc_csharp_plugin")
+      Makit::Protoc.find_plugin_path("grpc_csharp_plugin")
     end
+
     def self.setup
-      if (!Dir.exist?(Makit::Directories::NUGET_PACKAGE_CACHE))
-        puts "  warning: Nuget package cache directory #{Makit::Directories::NUGET_PACKAGE_CACHE} not found".colorize(:red)
-        puts "  warning: Unable to proceed with protoc setup".colorize(:red)
-      else
-        Makit::NuGet::cache("Grpc.Tools", "2.66.0")
-        raise "Nuget package path #{Makit::Directories::NUGET_PACKAGE_CACHE} not found" if !Dir.exist?(Makit::Directories::NUGET_PACKAGE_CACHE)
+      if Dir.exist?(Makit::Directories::NUGET_PACKAGE_CACHE)
+        Makit::NuGet.cache("Grpc.Tools", "2.66.0")
+        unless Dir.exist?(Makit::Directories::NUGET_PACKAGE_CACHE)
+          raise "Nuget package path #{Makit::Directories::NUGET_PACKAGE_CACHE} not found"
+        end
 
         # test if protoc is installed by running >protoc --version
         which_protoc = Makit::Environment.which("protoc")
-        if (Makit::Environment.which("protoc").nil?)
+        if Makit::Environment.which("protoc").nil?
           puts "  protoc not found, installing...".colorize(:red)
           "go version".run
           "go install google.golang.org/protobuf/cmd/protoc-gen-go@latest".run
@@ -32,35 +33,37 @@ module Makit
         else
           puts "  protoc found at #{which_protoc}".colorize(:green)
         end
-        raise "protoc not found" if !Makit::Environment.which("protoc")
+        raise "protoc not found" unless Makit::Environment.which("protoc")
 
-        #"git clone https://github.com/googleapis/googleapis.git third_party".run unless File.directory?("third_party/google")
-        puts "  grpc_tools_path " + "#{Makit::Protoc::grpc_tools_path}".colorize(:green)
-        puts "  grpc_csharp_plugin_path " + "#{Makit::Protoc::grpc_csharp_plugin_path}".colorize(:green)
+        # "git clone https://github.com/googleapis/googleapis.git third_party".run unless File.directory?("third_party/google")
+        puts "  grpc_tools_path #{Makit::Protoc.grpc_tools_path.to_s.colorize(:green)}"
+        puts "  grpc_csharp_plugin_path #{Makit::Protoc.grpc_csharp_plugin_path.to_s.colorize(:green)}"
+      else
+        puts "  warning: Nuget package cache directory #{Makit::Directories::NUGET_PACKAGE_CACHE} not found".colorize(:red)
+        puts "  warning: Unable to proceed with protoc setup".colorize(:red)
       end
     end
 
     # get the latest version of the grpc.tools package
     def self.get_latest_grpc_tools_version
-      Makit::NuGet::get_latest_version("Grpc.Tools")
+      Makit::NuGet.get_latest_version("Grpc.Tools")
     end
 
-    #GRPC_CSHARP_PLUGIN_PATH = Makit::Protoc::find_plugin_path("grpc_csharp_plugin")
+    # GRPC_CSHARP_PLUGIN_PATH = Makit::Protoc::find_plugin_path("grpc_csharp_plugin")
     def self.find_plugin_path(plugin_name)
       # search for a file matching the pattern *grpc_csharp_plugin* in the grpc.tools directory
       # should match on Windows and Linux
-      if (Makit::Environment.is_windows?)
-        plugin_name = plugin_name + ".exe"
-      end
+      plugin_name += ".exe" if Makit::Environment.is_windows?
 
       plugin_path = Dir.glob("#{Makit::Directories::GRPC_TOOLS_PATH}/**/#{plugin_name}").first
 
-      raise "Plugin path #{plugin_path} not found" if !File.exist?(plugin_path)
+      raise "Plugin path #{plugin_path} not found" unless File.exist?(plugin_path)
+
       plugin_path
     end
 
     def self.get_proto_files_from_path(proto_source_dir)
-      proto_files = Array.new()
+      proto_files = []
       Dir.chdir(proto_source_dir) do
         Dir.glob("**/*.proto").each do |proto|
           proto_files << proto
@@ -70,7 +73,7 @@ module Makit
     end
 
     def self.generate_source_file(proto_filename, language, csharp_output_dir)
-      FileUtils.mkdir_p(csharp_output_dir) unless Dir.exist?(csharp_output_dir)
+      FileUtils.mkdir_p(csharp_output_dir)
       "protoc --#{language}_out=#{csharp_output_dir} #{proto_filename}".run
     end
 
@@ -78,7 +81,7 @@ module Makit
     def self.generate_source_files(proto_source_dir, language, output_dir)
       debug = false
       puts "Generating source files for #{language} in #{proto_source_dir} to #{output_dir}" if debug
-      FileUtils.mkdir_p(output_dir) unless Dir.exist?(output_dir)
+      FileUtils.mkdir_p(output_dir)
 
       path_a = Pathname.new(proto_source_dir)
       path_b = Pathname.new(output_dir)
@@ -88,11 +91,11 @@ module Makit
       Dir.chdir(proto_source_dir) do
         Dir.glob("**/*.proto").each do |proto|
           puts "Generating #{proto}" if debug
-          if (language == "csharp")
+          if language == "csharp"
             namespace_dir = File.dirname(proto)
             output_dir = "#{output_relative_path}/#{namespace_dir}"
             puts "Generating #{proto} in #{output_dir}" if debug
-            FileUtils.mkdir_p("#{output_dir}") unless Dir.exist?("#{output_dir}")
+            FileUtils.mkdir_p(output_dir.to_s)
             "protoc --csharp_out=#{output_dir} #{proto}".run
           else
             "protoc --#{language}_out=#{output_relative_path} #{proto}".run

data/lib/makit/rake/cli.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require "clamp"
+
+module Makit
+  module Rake
+    # CLI command for managing rake-related functionality
+    # Command to run rake tasks
+    class RunCommand < Clamp::Command
+      self.description = "Run a rake task in a directory or repository"
+
+      parameter "TARGET", "Directory path or repository URL"
+      parameter "TASK", "Rake task to run"
+      option ["-v", "--verbose"], :flag, "Verbose output"
+      option ["-f", "--fail-fast"], :flag, "Stop on first failure"
+      option ["-j", "--jobs"], "JOBS", "Number of parallel jobs", default: "1"
+      option ["-t", "--trace"], :flag, "Show full backtrace on errors"
+
+      def execute
+        target_path = resolve_target(target)
+
+        signal_usage_error "Target directory does not exist: #{target_path}" unless Dir.exist?(target_path)
+
+        Dir.chdir(target_path) do
+          puts "Running rake task '#{task}' in #{target_path}".colorize(:blue)
+
+          # Build rake command with options
+          rake_cmd = build_rake_command
+
+          # Execute the command
+          result = system(rake_cmd)
+
+          if result
+            puts "Rake task '#{task}' completed successfully".colorize(:green)
+          else
+            puts "Rake task '#{task}' failed".colorize(:red)
+            exit(1)
+          end
+        end
+      end
+
+      private
+
+      def resolve_target(target)
+        return handle_repository_target(target) if target.start_with?("http")
+
+        # It's a repository URL, clone or update it
+
+        # It's a local path
+        File.expand_path(target)
+      end
+
+      def handle_repository_target(url)
+        local_path = File.join(
+          Makit::Directories::HOME,
+          "code",
+          "work",
+          Makit::Directories.get_relative_directory(url)
+        )
+
+        if Dir.exist?(local_path)
+          puts "Updating existing repository: #{url}".colorize(:yellow)
+          Dir.chdir(local_path) do
+            "git pull".run
+          end
+        else
+          puts "Cloning repository: #{url}".colorize(:green)
+          `git clone #{url} #{local_path}`
+        end
+
+        local_path
+      end
+
+      def build_rake_command
+        cmd_parts = ["rake", task]
+
+        cmd_parts << "--verbose" if verbose?
+        cmd_parts << "--fail-fast" if fail_fast?
+        cmd_parts << "--jobs" << jobs if jobs != "1"
+        cmd_parts << "--trace" if trace?
+
+        cmd_parts.join(" ")
+      end
+    end
+
+    # Command to list available rake tasks
+    class ListCommand < Clamp::Command
+      self.description = "List available rake tasks in a directory or repository"
+
+      parameter "TARGET", "Directory path or repository URL"
+      option ["-a", "--all"], :flag, "Show all tasks including private ones"
+      option ["-p", "--pattern"], "PATTERN", "Filter tasks by pattern"
+
+      def execute
+        target_path = resolve_target(target)
+
+        signal_usage_error "Target directory does not exist: #{target_path}" unless Dir.exist?(target_path)
+
+        Dir.chdir(target_path) do
+          puts "Available rake tasks in #{target_path}:".colorize(:blue)
+
+          # Build rake command to list tasks
+          rake_cmd = "rake --tasks"
+          rake_cmd += " --all" if all?
+
+          # Execute and capture output
+          output = `#{rake_cmd} 2>/dev/null`
+
+          if output.empty?
+            puts "No rake tasks found or Rakefile not present".colorize(:yellow)
+            return
+          end
+
+          # Filter by pattern if specified
+          output = output.lines.select { |line| line.include?(pattern) }.join if pattern
+
+          puts output
+        end
+      end
+
+      private
+
+      def resolve_target(target)
+        return handle_repository_target(target) if target.start_with?("http")
+
+        # It's a repository URL, clone or update it
+
+        # It's a local path
+        File.expand_path(target)
+      end
+
+      def handle_repository_target(url)
+        local_path = File.join(
+          Makit::Directories::HOME,
+          "code",
+          "work",
+          Makit::Directories.get_relative_directory(url)
+        )
+
+        if Dir.exist?(local_path)
+          puts "Updating existing repository: #{url}".colorize(:yellow)
+          Dir.chdir(local_path) do
+            "git pull".run
+          end
+        else
+          puts "Cloning repository: #{url}".colorize(:green)
+          `git clone #{url} #{local_path}`
+        end
+
+        local_path
+      end
+    end
+
+    # Command to run rake tasks in repositories (legacy compatibility)
+    class RepositoryCommand < Clamp::Command
+      self.description = "Run a rake task in a repository (legacy command)"
+
+      parameter "URL", "Repository URL"
+      parameter "TASK", "Rake task to run"
+
+      def execute
+        puts "Running rake task '#{task}' in repository: #{url}".colorize(:blue)
+        Makit::Rake.rake_repository(url, task)
+      end
+    end
+
+    # CLI command for managing rake-related functionality
+    class CliCommand < Clamp::Command
+      self.description = <<~DESC
+        Rake management commands for Makit.
+
+        This command provides utilities for working with Rake tasks, including:
+        - Running rake tasks in repositories
+        - Managing rake task execution
+        - Repository-based rake operations
+
+        Common usage examples:
+          # Run a rake task in a repository
+          makit rake run https://github.com/user/repo test
+        #{"  "}
+          # Run a rake task in a local directory
+          makit rake run ./my-project build
+        #{"  "}
+          # List available rake tasks in a repository
+          makit rake list https://github.com/user/repo
+        #{"  "}
+          # Run rake task with specific options
+          makit rake run ./my-project test --verbose
+      DESC
+
+      subcommand "run", "Run a rake task in a repository or directory", RunCommand
+      subcommand "list", "List available rake tasks", ListCommand
+      subcommand "repository", "Run rake task in a repository", RepositoryCommand
+    end
+  end
+end