makit 0.0.99 → 0.0.111

data/lib/makit/environment.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "sorted_set"
 require_relative "directory"
 # This module provides classes for the Makit gem.
 module Makit
@@ -9,10 +8,8 @@ module Makit
   class Environment
     def self.current_user
       if Makit::Environment.is_windows?
-        `whoami`
-      else
-        `whoami`
       end
+      `whoami`
     end
 
     def self.which(name)
@@ -33,8 +30,11 @@ module Makit
     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)}" }
+      Object.constants.each do |c|
+        #	puts "#{c} = #{Object.const_get(c)}" }
+        constants[c] = Object.const_get(c) if c == c.upcase
+      end
+      # Object.constants.each { |c| constants[c] = Object.const_get(c)}#	puts "#{c} = #{Object.const_get(c)}" }
       constants
     end
 
@@ -46,36 +46,39 @@ module Makit
     end
 
     def self.gem_data_directory
-      gem_data_directory = File.join(Dir.home, ".makit")
+      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
+      if Makit::Environment.rake_file_name.nil?
         Makit::Directory.find_directory_with_pattern(File.dirname(__FILE__), "Rakefile")
         # lass Directory
         #  def self.find_directory_with_pattern(starting_directory, pattern)
         # nil
+      else
+        File.dirname(Makit::Environment.rake_file_name)
       end
     end
 
     def self.get_relative_directory(url)
       url = url.gsub("https://", "").gsub("http://", "")
-      url = url.gsub("gitlab.com", "gitlab")
-      url
+      url.gsub("gitlab.com", "gitlab")
     end
 
     def self.get_code_root
       # user home directory  + "code"
-      code_root = File.join(Dir.home, "code")
+      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
+      raise "invalid url" unless url.include? "https://"
+
+      url.gsub("https://", "").gsub("http://", "")
+      # url = url.gsub("gitlab.com","gitlab")
+    end
+
+    def self.get_work_base_directory
+      File.join(Dir.home, ".makit", "work")
     end
 
     def self.is_windows?
@@ -103,7 +106,7 @@ module Makit
       end
     end
 
-    def self.get_runtime_identifier()
+    def self.get_runtime_identifier
       os = RbConfig::CONFIG["host_os"]
       cpu = RbConfig::CONFIG["host_cpu"]
 
@@ -125,7 +128,7 @@ module Makit
         arch_rid = "x64"
       when /i686|i386/
         arch_rid = "x86"
-        #when /arm/
+        # when /arm/
         #  arch_rid = "arm"
       when /aarch64|arm64/
         arch_rid = "arm64"

data/lib/makit/examples/runner.rb

@@ -0,0 +1,370 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "parallel"
+
+module Makit
+  module Examples
+    # Centralized management of example discovery, execution, and verification
+    #
+    # This class provides a clean interface for running all examples in the
+    # examples directory, with support for different execution strategies,
+    # artifact verification, and comprehensive reporting.
+    #
+    # @example Basic usage
+    #   runner = Makit::Examples::Runner.new
+    #   runner.run_all
+    #
+    # @example Custom configuration
+    #   runner = Makit::Examples::Runner.new(
+    #     strategy: :parallel,
+    #     verify_artifacts: true,
+    #     cleanup_after: false
+    #   )
+    #   runner.run_all
+    class Runner
+      # Configuration options
+      attr_reader :examples_dir, :execution_strategy, :verify_artifacts, :cleanup_after, :filter, :timeout, :verbose
+
+      # Execution results
+      attr_reader :results, :failed_examples, :passed_examples, :examples
+
+      # Initialize the examples runner
+      #
+      # @param options [Hash] configuration options
+      # @option options [String] :examples_dir directory containing examples (default: "examples")
+      # @option options [Symbol] :strategy execution strategy (:sequential, :parallel, :filtered)
+      # @option options [Boolean] :verify_artifacts whether to verify expected artifacts (default: true)
+      # @option options [Boolean] :cleanup_after whether to clean up artifacts after testing (default: true)
+      # @option options [Regexp] :filter pattern to filter examples (default: nil)
+      # @option options [Integer] :timeout timeout per example in seconds (default: 30)
+      # @option options [Boolean] :verbose whether to show detailed output (default: false)
+      def initialize(options = {})
+        @examples_dir = options[:examples_dir] || "examples"
+        @execution_strategy = options[:strategy] || :sequential
+        @verify_artifacts = options[:verify_artifacts] || true
+        @cleanup_after = options[:cleanup_after] || true
+        @filter = options[:filter]
+        @timeout = options[:timeout] || 30
+        @verbose = options[:verbose] || false
+
+        @results = []
+        @failed_examples = []
+        @passed_examples = []
+        @examples = []
+      end
+
+      # Run all discovered examples
+      #
+      # @return [Boolean] true if all examples passed, false otherwise
+      def run_all
+        discover_examples
+        execute_examples
+        verify_results
+        report_results
+        cleanup_if_needed
+
+        @failed_examples.empty?
+      end
+
+      # Run a specific example
+      #
+      # @param example_path [String] path to the example directory
+      # @return [Hash] result hash with success status and details
+      def run_example(example_path)
+        discover_examples if @examples.empty?
+        example = @examples.find { |ex| ex[:name] == example_path }
+        return { success: false, error: "Example not found: #{example_path}" } unless example
+
+        execute_single_example(example)
+      end
+
+      # Discover all examples in the examples directory
+      def discover_examples
+        @examples = Dir.glob("#{@examples_dir}/**/Rakefile").map do |rakefile|
+          example_dir = File.dirname(rakefile)
+          example_name = example_dir.gsub("#{@examples_dir}/", "")
+
+          {
+            path: example_dir,
+            name: example_name,
+            rakefile: rakefile,
+            expected_artifacts: determine_expected_artifacts(example_name),
+          }
+        end
+
+        # Apply filter if specified
+        @examples = @examples.select { |ex| ex[:name].match?(@filter) } if @filter
+
+        log "Discovered #{@examples.count} examples" if @verbose
+      end
+
+      private
+
+      # Execute all examples based on the configured strategy
+      def execute_examples
+        case @execution_strategy
+        when :sequential
+          execute_sequential
+        when :parallel
+          execute_parallel
+        when :filtered
+          execute_filtered
+        else
+          execute_sequential
+        end
+      end
+
+      # Execute examples sequentially
+      def execute_sequential
+        @examples.each do |example|
+          result = execute_single_example(example)
+
+          # Verify artifacts immediately after execution if enabled
+          verify_example_artifacts(example, result) if @verify_artifacts && result[:success]
+
+          @results << result
+
+          if result[:success]
+            @passed_examples << example
+            log "  ✅ #{example[:name]} passed".colorize(:green) if @verbose
+          else
+            @failed_examples << example
+            log "  ❌ #{example[:name]} failed: #{result[:error]}".colorize(:red) if @verbose
+          end
+        end
+      end
+
+      # Execute examples in parallel
+      def execute_parallel
+        results = Parallel.map(@examples, in_threads: 4) do |example|
+          result = execute_single_example(example)
+
+          # Verify artifacts immediately after execution if enabled
+          verify_example_artifacts(example, result) if @verify_artifacts && result[:success]
+
+          result
+        end
+
+        results.each_with_index do |result, index|
+          @results << result
+          example = @examples[index]
+
+          if result[:success]
+            @passed_examples << example
+            log "  ✅ #{example[:name]} passed".colorize(:green) if @verbose
+          else
+            @failed_examples << example
+            log "  ❌ #{example[:name]} failed: #{result[:error]}".colorize(:red) if @verbose
+          end
+        end
+      end
+
+      # Execute examples with filtering (same as sequential for now)
+      def execute_filtered
+        execute_sequential
+      end
+
+      # Execute a single example
+      #
+      # @param example [Hash] example configuration
+      # @return [Hash] result hash
+      def execute_single_example(example)
+        # Display separator and example path
+        puts "=" * 80
+        #puts example[:name]
+        puts example[:rakefile]
+
+        log "  Testing example: #{example[:name]}" if @verbose
+
+        # Store current directory
+        original_dir = Dir.pwd
+
+        begin
+          Dir.chdir(example[:path]) do
+            # Use the default runner with middleware for consistent behavior
+            runner = Makit::DEFAULT_COMMANDS_RUNNER
+            custom_logger = Makit::Logging::Logger.new(
+              Makit::Logging::Sinks::Console.new,
+              Makit::Logging::Sinks::FileSink.new(log_file: "artifacts/command_examples.log")
+            )
+
+            begin
+              request = Makit::Commands::Request.from_string("rake default")
+              result = runner.execute(request)
+
+              # Log success or error for each example
+              if result.success?
+                Makit::Logging.success(example[:name])
+              else
+                Makit::Logging.error(example[:name])
+              end
+
+              {
+                example: example,
+                success: result.success?,
+                exit_code: result.exit_code,
+                output: result.stdout,
+                error: result.stderr,
+                duration: result.duration,
+              }
+            rescue StandardError => e
+              # Log error for exceptions
+              Makit::Logging.error(example[:name])
+
+              {
+                example: example,
+                success: false,
+                exit_code: -1,
+                output: "",
+                error: e.message,
+                duration: 0,
+              }
+            end
+          end
+        rescue StandardError => e
+          # Log error for directory change failures
+          Makit::Logging.error(example[:name])
+
+          {
+            example: example,
+            success: false,
+            exit_code: -1,
+            output: "",
+            error: "Failed to change directory: #{e.message}",
+            duration: 0,
+          }
+        ensure
+          # Always return to original directory
+          begin
+            Dir.chdir(original_dir)
+          rescue StandardError
+            nil
+          end
+        end
+      end
+
+      # Determine expected artifacts for an example
+      #
+      # @param example_name [String] name of the example
+      # @return [Array<String>] list of expected artifact paths
+      def determine_expected_artifacts(example_name)
+        case example_name
+        when %r{commands/(default_runner|runner)}
+          ["artifacts/commands/git_version.log", "artifacts/commands/git_version.txt"]
+        when "protoc"
+          ["artifacts/makit.v1_pb.rb"]
+        when "rake_default"
+          [".makit.project.json"]
+        when "run_mp"
+          [] # No expected artifacts
+        when "tasks/simple"
+          [] # No expected artifacts
+        when "rubygem-foo"
+          [] # No expected artifacts
+        else
+          [] # Default to no expected artifacts
+        end
+      end
+
+      # Verify artifacts for a single example immediately after execution
+      #
+      # @param example [Hash] example configuration
+      # @param result [Hash] execution result
+      def verify_example_artifacts(example, result)
+        return unless @verify_artifacts
+
+        # Check artifacts in the example directory context
+        missing_artifacts = example[:expected_artifacts].reject do |artifact|
+          artifact_path = File.join(example[:path], artifact)
+          File.exist?(artifact_path)
+        end
+
+        return unless missing_artifacts.any?
+
+        result[:success] = false
+        result[:error] = "Missing expected artifacts: #{missing_artifacts.join(", ")}"
+      end
+
+      # Verify that all results meet expectations
+      def verify_results
+        return unless @verify_artifacts
+
+        @results.each do |result|
+          next unless result[:success]
+
+          example = result[:example]
+
+          # Check artifacts in the example directory context
+          missing_artifacts = example[:expected_artifacts].reject do |artifact|
+            artifact_path = File.join(example[:path], artifact)
+            File.exist?(artifact_path)
+          end
+
+          next unless missing_artifacts.any?
+
+          result[:success] = false
+          result[:error] = "Missing expected artifacts: #{missing_artifacts.join(", ")}"
+
+          # Move from passed to failed
+          @passed_examples.delete(example)
+          @failed_examples << example
+        end
+      end
+
+      # Clean up artifacts if configured
+      def cleanup_if_needed
+        return unless @cleanup_after
+
+        @examples.each do |example|
+          cleanup_example(example)
+        end
+      end
+
+      # Clean up artifacts for a specific example
+      #
+      # @param example [Hash] example configuration
+      def cleanup_example(example)
+        Dir.chdir(example[:path]) do
+          # Remove artifacts directory if it exists
+          FileUtils.rm_rf("artifacts")
+
+          # Remove project file if it exists
+          FileUtils.rm_f(".makit.project.json")
+        end
+      rescue StandardError => e
+        log "  Warning: Failed to cleanup #{example[:name]}: #{e.message}" if @verbose
+      end
+
+      # Report the results of example execution
+      def report_results
+        puts "📊 Example Test Results:".colorize(:blue)
+        puts "  ✅ Passed: #{@passed_examples.count}".colorize(:green)
+        puts "  ❌ Failed: #{@failed_examples.count}".colorize(:red)
+
+        if @failed_examples.any?
+          puts "  Failed examples:".colorize(:red)
+          @failed_examples.each do |example|
+            result = @results.find { |r| r[:example] == example }
+            error_msg = result ? result[:error] : "Unknown error"
+            puts "    - #{example[:name]}: #{error_msg}".colorize(:red)
+          end
+        end
+
+        return unless @passed_examples.any? && @verbose
+
+        puts "  Passed examples:".colorize(:green)
+        @passed_examples.each do |example|
+          puts "    - #{example[:name]}".colorize(:green)
+        end
+      end
+
+      # Log a message if verbose mode is enabled
+      #
+      # @param message [String] message to log
+      def log(message)
+        puts message if @verbose
+      end
+    end
+  end
+end

data/lib/makit/exceptions.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Makit
+  # Base exception class for all Makit errors
+  class Error < StandardError; end
+
+  # Raised when a directory operation fails
+  class DirectoryError < Error; end
+
+  # Raised when a git operation fails
+  class GitError < Error; end
+
+  # Raised when a clone operation fails
+  class CloneError < GitError; end
+
+  # Raised when a pull operation fails
+  class PullError < GitError; end
+
+  # Raised when a commit is invalid
+  class InvalidCommitError < GitError; end
+
+  # Raised when a build operation fails
+  class BuildError < Error; end
+
+  # Raised when a configuration is invalid
+  class ConfigurationError < Error; end
+
+  # Raised when a file operation fails
+  class FileError < Error; end
+
+  # Raised when a network operation fails
+  class NetworkError < Error; end
+
+  # Raised when a timeout occurs
+  class TimeoutError < Error; end
+
+  # Raised when a dependency is missing
+  class DependencyError < Error; end
+
+  # Raised when a command execution fails
+  class CommandError < Error; end
+
+  # Raised when a validation fails
+  class ValidationError < Error; end
+end

data/lib/makit/fileinfo.rb

@@ -15,11 +15,9 @@ module Makit
 
     def self.get_file_infos(filenames)
       filenames.map do |filename|
-        begin
-          FileInfo.new(name: filename, mtime: File.mtime(filename), size: File.size(filename))
-        rescue
-          next
-        end
+        FileInfo.new(name: filename, mtime: File.mtime(filename), size: File.size(filename))
+      rescue StandardError
+        next
       end
     end
   end

data/lib/makit/files.rb

@@ -12,12 +12,12 @@ module Makit
   # This class provide methods for working with the system Environment.
   #
   module Files
-    if (Makit::Directories::PROJECT_ROOT != nil)
+    if Makit::Directories::PROJECT_ROOT.nil?
+      CSPROJ = [].freeze
+    else
       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
@@ -30,18 +30,14 @@ module Makit
 
       # 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
+        constant_value = const_get(constant_name) # Fetch the value of the constant
+        constant_value = constant_value.colorize(:green) if !constant_value.nil? && File.exist?(constant_value)
+        # 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 # module Files
-end # module Makit
+  end
+end

data/lib/makit/gems.rb

@@ -1,39 +1,40 @@
-# frozen_string_literal: true
-
-# This module provides classes for the Makit gem.
-module Makit
-  # This class provide methods for working with the system Environment.
-  #
-  module Gems
-    def self.install_latest_gem(gem_name)
-        if(!is_gem_installed(gem_name))
-          "gem install #{gem_name}".run
-          puts "  #{gem_name} gem installed".colorize(:green)
-        else
-          latest_version = get_latest_gem_version(gem_name)
-          installed_version = get_installed_gem_version(gem_name)
-          if(installed_version != latest_version)
-            "gem install #{gem_name}".run
-            puts "  #{gem_name} gem updated to #{latest_version}".colorize(:green)
-          else
-            puts "  #{gem_name} gem is up to date".colorize(:green)
-          end
-        end
-      end
-      
-      def self.is_gem_installed(gem_name)
-        `gem list #{gem_name}`
-        $?.success?
-      end
-      
-      
-      def self.get_installed_gem_version(gem_name)
-        versions = `gem list #{gem_name}`.split("(")[1].split(")")[0].split(",")
-        versions.first.strip
-      end
-      
-      def self.get_latest_gem_version(gem_name)
-        `gem search #{gem_name} --remote --exact`.split("(")[1].split(")")[0]
-      end
-  end # class Gem
-end # module Makit
+# frozen_string_literal: true
+
+# This module provides classes for the Makit gem.
+require "English"
+
+module Makit
+  # This class provide methods for working with the system Environment.
+  #
+  module Gems
+    def self.install_latest_gem(gem_name)
+      if is_gem_installed(gem_name)
+        latest_version = get_latest_gem_version(gem_name)
+        installed_version = get_installed_gem_version(gem_name)
+        if installed_version == latest_version
+          puts "  #{gem_name} gem is up to date".colorize(:green)
+        else
+          "gem install #{gem_name}".run
+          puts "  #{gem_name} gem updated to #{latest_version}".colorize(:green)
+        end
+      else
+        "gem install #{gem_name}".run
+        puts "  #{gem_name} gem installed".colorize(:green)
+      end
+    end
+
+    def self.is_gem_installed(gem_name)
+      `gem list #{gem_name}`
+      $CHILD_STATUS.success?
+    end
+
+    def self.get_installed_gem_version(gem_name)
+      versions = `gem list #{gem_name}`.split("(")[1].split(")")[0].split(",")
+      versions.first.strip
+    end
+
+    def self.get_latest_gem_version(gem_name)
+      `gem search #{gem_name} --remote --exact`.split("(")[1].split(")")[0]
+    end
+  end
+end