makit 0.0.0

data/docs_/Commands.md

@@ -0,0 +1,166 @@
+# Markdown Examples
+
+<details>
+<summary>✓ git --version C:/Users/lparslow/code/work/gitlab/gems-rb/makit</summary>
+
+<table><tr><th>output</th></tr><tr><td>
+
+```shell
+git version 2.36.1.windows.1
+
+```
+
+</td></tr></table>
+
+| exit code | started at | duration | user | device | os | directory |
+| --- | --- | --- | --- | --- | --- | --- |
+| 0 | 2024-06-04 08:27:02 | 0h 0m 0.06s | lparslow | Lou-Parslow | Windows | C:/Users/lparslow/code/work/gitlab/gems-rb/makit |
+</details>
+<details>
+<summary>✓ git --help C:/Users/lparslow/code/work/gitlab/gems-rb/makit</summary>
+
+<table><tr><th>output</th></tr><tr><td>
+
+```shell
+usage: git [--version] [--help] [-C <path>] [-c <name>=<value>]
+           [--exec-path[=<path>]] [--html-path] [--man-path] [--info-path]
+           [-p | --paginate | -P | --no-pager] [--no-replace-objects] [--bare]
+           [--git-dir=<path>] [--work-tree=<path>] [--namespace=<name>]
+           [--super-prefix=<path>] [--config-env=<name>=<envvar>]
+           <command> [<args>]
+
+These are common Git commands used in various situations:
+
+start a working area (see also: git help tutorial)
+   clone     Clone a repository into a new directory
+   init      Create an empty Git repository or reinitialize an existing one
+
+work on the current change (see also: git help everyday)
+   add       Add file contents to the index
+   mv        Move or rename a file, a directory, or a symlink
+   restore   Restore working tree files
+   rm        Remove files from the working tree and from the index
+
+examine the history and state (see also: git help revisions)
+   bisect    Use binary search to find the commit that introduced a bug
+   diff      Show changes between commits, commit and working tree, etc
+   grep      Print lines matching a pattern
+   log       Show commit logs
+   show      Show various types of objects
+   status    Show the working tree status
+
+grow, mark and tweak your common history
+   branch    List, create, or delete branches
+   commit    Record changes to the repository
+   merge     Join two or more development histories together
+   rebase    Reapply commits on top of another base tip
+   reset     Reset current HEAD to the specified state
+   switch    Switch branches
+   tag       Create, list, delete or verify a tag object signed with GPG
+
+collaborate (see also: git help workflows)
+   fetch     Download objects and refs from another repository
+   pull      Fetch from and integrate with another repository or a local branch
+   push      Update remote refs along with associated objects
+
+'git help -a' and 'git help -g' list available subcommands and some
+concept guides. See 'git help <command>' or 'git help <concept>'
+to read about a specific subcommand or concept.
+See 'git help git' for an overview of the system.
+
+```
+
+</td></tr></table>
+
+| exit code | started at | duration | user | device | os | directory |
+| --- | --- | --- | --- | --- | --- | --- |
+| 0 | 2024-06-04 08:27:02 | 0h 0m 0.08s | lparslow | Lou-Parslow | Windows | C:/Users/lparslow/code/work/gitlab/gems-rb/makit |
+</details>
+<details>
+<summary>✓ ruby --version C:/Users/lparslow/code/work/gitlab/gems-rb/makit</summary>
+
+<table><tr><th>output</th></tr><tr><td>
+
+```shell
+ruby 3.2.3 (2024-01-18 revision 52bb2ac0a6) [x64-mingw-ucrt]
+
+```
+
+</td></tr></table>
+
+| exit code | started at | duration | user | device | os | directory |
+| --- | --- | --- | --- | --- | --- | --- |
+| 0 | 2024-06-04 08:27:02 | 0h 0m 0.05s | lparslow | Lou-Parslow | Windows | C:/Users/lparslow/code/work/gitlab/gems-rb/makit |
+</details>
+<details>
+<summary>✓ ruby --help C:/Users/lparslow/code/work/gitlab/gems-rb/makit</summary>
+
+<table><tr><th>output</th></tr><tr><td>
+
+```shell
+Usage: ruby [switches] [--] [programfile] [arguments]
+  -0[octal]       specify record separator (\0, if no argument)
+  -a              autosplit mode with -n or -p (splits $_ into $F)
+  -c              check syntax only
+  -Cdirectory     cd to directory before executing your script
+  -d, --debug     set debugging flags (set $DEBUG to true)
+  -e 'command'    one line of script. Several -e's allowed. Omit [programfile]
+  -Eex[:in], --encoding=ex[:in]
+                  specify the default external and internal character encodings
+  -Fpattern       split() pattern for autosplit (-a)
+  -i[extension]   edit ARGV files in place (make backup if extension supplied)
+  -Idirectory     specify $LOAD_PATH directory (may be used more than once)
+  -l              enable line ending processing
+  -n              assume 'while gets(); ... end' loop around your script
+  -p              assume loop like -n but print line also like sed
+  -rlibrary       require the library before executing your script
+  -s              enable some switch parsing for switches after script name
+  -S              look for the script using PATH environment variable
+  -v              print the version number, then turn on verbose mode
+  -w              turn warnings on for your script
+  -W[level=2|:category]
+                  set warning level; 0=silence, 1=medium, 2=verbose
+  -x[directory]   strip off text before #!ruby line and perhaps cd to directory
+  --jit           enable JIT for the platform, same as --mjit (experimental)
+  --copyright     print the copyright
+  --dump={insns|parsetree|...}[,...]
+                  dump debug information. see below for available dump list
+  --enable={jit|rubyopt|...}[,...], --disable={jit|rubyopt|...}[,...]
+                  enable or disable features. see below for available features
+  --external-encoding=encoding, --internal-encoding=encoding
+                  specify the default external or internal character encoding
+  --backtrace-limit=num
+                  limit the maximum length of backtrace
+  --verbose       turn on verbose mode and disable script from stdin
+  --version       print the version number, then exit
+  --help          show this message, -h for short message
+Dump List:
+  insns           instruction sequences
+  insns_without_opt
+                  instruction sequences compiled with no optimization
+  yydebug(+error-tolerant)
+                  yydebug of yacc parser generator
+  parsetree(+error-tolerant)
+                  AST
+  parsetree_with_comment(+error-tolerant)
+                  AST with comments
+Features:
+  gems            rubygems (only for debugging, default: enabled)
+  error_highlight error_highlight (default: enabled)
+  did_you_mean    did_you_mean (default: enabled)
+  syntax_suggest  syntax_suggest (default: enabled)
+  rubyopt         RUBYOPT environment variable (default: enabled)
+  frozen-string-literal
+                  freeze all string literals (default: disabled)
+Warning categories:
+  deprecated      deprecated features
+  experimental    experimental features
+
+```
+
+</td></tr></table>
+
+| exit code | started at | duration | user | device | os | directory |
+| --- | --- | --- | --- | --- | --- | --- |
+| 0 | 2024-06-04 08:27:02 | 0h 0m 0.05s | lparslow | Lou-Parslow | Windows | C:/Users/lparslow/code/work/gitlab/gems-rb/makit |
+</details>

data/docs_/Minitest.Timeouts.md

@@ -0,0 +1,332 @@
+### **Setting Timeouts on Minitest Tests**
+
+To ensure that your tests do not run indefinitely or take too long, you can set timeouts on your Minitest tests. This is particularly useful for catching hanging tests or identifying performance issues.
+
+There are several ways to set timeouts in Minitest:
+
+1. **Using Ruby's `Timeout` Module**
+2. **Using the `minitest-timeout` Gem**
+3. **Using Custom Assertions**
+
+---
+
+#### **1. Using Ruby's `Timeout` Module**
+
+The standard Ruby library provides a `Timeout` module that can be used to limit the execution time of code blocks.
+
+**Example:**
+
+```ruby
+require 'minitest/autorun'
+require 'timeout'
+
+class MyTest < Minitest::Test
+  def test_with_timeout
+    Timeout.timeout(5) do
+      # Test code that should complete within 5 seconds
+      long_running_operation
+    end
+  rescue Timeout::Error
+    flunk "Test exceeded time limit and was aborted."
+  end
+
+  private
+
+  def long_running_operation
+    sleep 10 # Simulates a long-running operation
+  end
+end
+```
+
+**Explanation:**
+
+- **`Timeout.timeout(5) do ... end`**: Executes the block and raises a `Timeout::Error` if it takes more than 5 seconds.
+- **Rescuing `Timeout::Error`**: Captures the timeout exception and marks the test as failed using `flunk`.
+
+**Caveats:**
+
+- The `Timeout` module uses threads to interrupt the execution, which can be unsafe for certain operations, especially IO operations or code that is not thread-safe.
+- Using `Timeout` can sometimes lead to unexpected behavior or hard-to-debug issues due to the abrupt interruption.
+
+---
+
+#### **2. Using the `minitest-timeout` Gem**
+
+The `minitest-timeout` gem provides a cleaner and safer way to set timeouts on tests.
+
+**Installation:**
+
+Add the gem to your `Gemfile`:
+
+```ruby
+gem 'minitest-timeout'
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+**Usage:**
+
+```ruby
+# test/test_helper.rb
+
+require 'minitest/autorun'
+require 'minitest/timeout'
+
+# Set a default timeout for all tests (optional)
+Minitest::Timeout.timeout = 5 # seconds
+```
+
+```ruby
+# test/my_test.rb
+
+require_relative 'test_helper'
+
+class MyTest < Minitest::Test
+  timeout 5 # seconds
+
+  def test_long_running_operation
+    # This test will fail if it runs longer than 5 seconds
+    long_running_operation
+  end
+
+  def test_another_operation
+    # Override timeout for a specific test
+    timeout(2)
+    another_long_running_operation
+  end
+
+  private
+
+  def long_running_operation
+    sleep 10
+  end
+
+  def another_long_running_operation
+    sleep 3
+  end
+end
+```
+
+**Explanation:**
+
+- **`timeout 5` at the class level**: Sets a default timeout of 5 seconds for all tests in the class.
+- **`timeout(2)` in a test method**: Overrides the timeout for that specific test.
+- **Global Timeout**: You can set a global timeout in the `test_helper.rb` that applies to all tests.
+
+**Benefits:**
+
+- **Safe Execution**: The gem ensures that the timeout is handled safely without the drawbacks of the `Timeout` module.
+- **Easy Configuration**: Allows setting timeouts at the test, class, or global level.
+- **Consistent Behavior**: Provides consistent behavior across different types of tests.
+
+---
+
+#### **3. Using Custom Assertions**
+
+You can create a custom assertion to check the execution time of your tests.
+
+**Example:**
+
+```ruby
+require 'minitest/autorun'
+
+class MyTest < Minitest::Test
+  def test_with_custom_timeout
+    assert_execution_time 5 do
+      long_running_operation
+    end
+  end
+
+  private
+
+  def assert_execution_time(max_seconds, &block)
+    start_time = Time.now
+    yield
+    end_time = Time.now
+    execution_time = end_time - start_time
+    assert execution_time <= max_seconds, "Expected execution time to be less than #{max_seconds}s, but was #{execution_time.round(2)}s"
+  end
+
+  def long_running_operation
+    sleep 10
+  end
+end
+```
+
+**Explanation:**
+
+- **`assert_execution_time`**: A custom assertion method that measures the time taken to execute a block.
+- **Usage**: Wrap the code you want to time within the `assert_execution_time` block.
+- **Assertion**: Fails the test if the execution time exceeds the specified maximum.
+
+**Caveats:**
+
+- This method doesn't interrupt the test if it exceeds the time limit; it only checks after the fact.
+- Not suitable if you need to abort the test execution upon exceeding the time limit.
+
+---
+
+### **Recommendations**
+
+For most use cases, using the `minitest-timeout` gem is the most effective and safest way to set timeouts on your Minitest tests.
+
+---
+
+### **Implementing Timeouts in Your Task**
+
+Given your existing test setup, here's how you might integrate timeouts.
+
+**Step 1: Install `minitest-timeout` Gem**
+
+Add to your `Gemfile`:
+
+```ruby
+gem 'minitest-timeout'
+```
+
+Run:
+
+```bash
+bundle install
+```
+
+**Step 2: Configure Timeout in `test_helper.rb`**
+
+Create or update your `test_helper.rb`:
+
+```ruby
+# test/test_helper.rb
+
+require 'minitest/autorun'
+require 'minitest/timeout'
+
+# Set a global timeout for all tests (e.g., 10 seconds)
+Minitest::Timeout.timeout = 10
+```
+
+**Step 3: Update Your Tests**
+
+In your test files, you can set timeouts as needed.
+
+```ruby
+require_relative 'test_helper'
+
+class WixTest < Minitest::Test
+  # Set a class-level timeout (overrides global timeout)
+  timeout 15
+
+  def test_setup_package
+    # Individual test code
+  end
+
+  def test_another_method
+    # Override timeout for this test
+    timeout(5)
+    # Test code
+  end
+end
+```
+
+**Step 4: Run Your Tests**
+
+Run your tests as usual, and they will fail if any test exceeds the specified timeout.
+
+---
+
+### **Handling Timeout Failures**
+
+When a test exceeds the timeout, it will fail with a message indicating that the execution time was exceeded.
+
+**Example Failure Message:**
+
+```
+Minitest::Timeout::Error: execution of test took longer than 5 seconds.
+```
+
+You can handle or customize this behavior if needed.
+
+---
+
+### **Caveats and Considerations**
+
+- **Long-Running Setup or Teardown:** If you have setup or teardown methods that might exceed the timeout, consider adjusting the timeout or refactoring the setup code.
+- **Thread Safety:** Ensure that your code is thread-safe, especially when using gems that manage timeouts internally.
+- **Debugging Timeouts:** If tests fail due to timeouts, investigate whether the code under test is inefficient, has infinite loops, or is waiting on external resources.
+
+---
+
+### **Alternative Approaches**
+
+If you prefer not to use external gems, or if you need more control over the timeout behavior, consider the following:
+
+#### **Using `Timeout` Module with Care**
+
+While the `Timeout` module can be problematic, it may be acceptable for simple tests.
+
+**Example:**
+
+```ruby
+def test_with_timeout
+  status = :passed
+  begin
+    Timeout.timeout(5) do
+      long_running_operation
+    end
+  rescue Timeout::Error
+    status = :failed
+  end
+  assert_equal :passed, status, "Test exceeded time limit and was aborted."
+end
+```
+
+#### **Process Forking**
+
+For tests that may hang due to external resources or blocking IO, running tests in separate processes can prevent them from affecting the main test suite.
+
+**Example:**
+
+```ruby
+def test_with_fork_and_timeout
+  pid = fork do
+    long_running_operation
+  end
+  begin
+    Timeout.timeout(5) do
+      Process.wait(pid)
+    end
+  rescue Timeout::Error
+    Process.kill('TERM', pid)
+    flunk "Test exceeded time limit and was aborted."
+  end
+end
+```
+
+**Note:** Process forking is not available on Windows platforms.
+
+---
+
+### **Conclusion**
+
+Setting timeouts on your Minitest tests helps ensure that they complete within expected time frames and aids in identifying performance issues or hanging tests. By using the `minitest-timeout` gem, you can easily integrate timeouts into your existing test suite with minimal changes.
+
+---
+
+### **References**
+
+- [minitest-timeout GitHub Repository](https://github.com/kamui/minitest-timeout)
+- [Ruby Timeout Module Documentation](https://ruby-doc.org/stdlib-2.7.0/libdoc/timeout/rdoc/Timeout.html)
+- [Minitest Documentation](https://github.com/seattlerb/minitest)
+
+---
+
+### **Additional Tips**
+
+- **Monitoring Test Performance:** Regularly monitor your test suite's performance to catch any tests that are consistently close to the timeout limit.
+- **CI/CD Integration:** Ensure that timeouts are appropriately set in continuous integration environments, where resources may differ from local development machines.
+- **Adjusting Timeouts:** Be cautious not to set timeouts too low, which could cause false negatives due to variations in execution time.
+
+By implementing timeouts effectively, you enhance the reliability and efficiency of your test suite.

data/examples/protoc/Rakefile

@@ -0,0 +1,31 @@
+require_relative "../../lib/makit"
+#require "makit"
+
+task :setup do
+  # setup the protoc environment
+  Makit::Protoc::setup
+
+  # copy the makit.v1.proto file to the current directory
+  FileUtils.cp(File.join("../../lib/makit/v1", "makit.v1.proto"), ".")
+
+  # create the artifacts directory
+  FileUtils.mkdir_p("artifacts") unless Dir.exist?("artifacts")
+end
+
+task :generate => [:setup] do
+  puts ":generate".colorize(:blue)
+
+  puts "  generating code from makit.v1.proto".colorize(:green)
+  "protoc -I . --ruby_out=artifacts makit.v1.proto".run
+  #"grpc_tools_ruby_protoc -I . --ruby_out=artifacts --grpc_out=artifacts makit.v1.proto".run
+end
+
+task :test do
+  runner = Makit::CommandRunner.new
+  command = runner.run(runner.parse_command_request("git --version"))
+
+  puts "command type: #{command.class}"
+  puts "command proto name: #{command.name}"
+end
+
+task :default => [:setup, :generate]

data/examples/rake_default/Rakefile

@@ -0,0 +1,5 @@
+require "makit"
+
+task :default do
+  puts "default task"
+end

data/examples/rubygem-foo/Rakefile

@@ -0,0 +1,3 @@
+require_relative "../../lib/makit"
+
+task :default

data/examples/run_mp/Rakefile

@@ -0,0 +1,8 @@
+require "makit"
+
+task :default do
+  "git --version".run
+  "bogus --version".run({ exit_on_error: false })
+  "docker --version".run({ exit_on_error: false })
+  "makit --version".run({ exit_on_error: false })
+end

data/exe/makit

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "makit"
+Makit::Cli::MainCommand.run(ARGV)

data/lib/makit/apache.rb

@@ -0,0 +1,32 @@
+# 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 Apache
+    def self.server_root
+      os = Makit::Environment::get_os
+      if os == "windows"
+        "C:\\Apache24"
+      elsif os == "linux"
+        "/etc/apache2"
+      elsif os == "mac"
+        "/private/etc/apache2"
+      else
+        nil
+      end
+      # default on windows: C:\Apache24
+      # default on linux: /etc/apache2
+      # default on mac: /private/etc/apache2
+      #nil
+    end
+
+    def self.document_root
+      # default on windows: C:\Apache24\htdocs
+      # default on linux: /var/www/html
+      # default on mac: /Library/WebServer/Documents
+      nil
+    end
+  end
+end

data/lib/makit/cli/clean.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "clamp"
+
+module Makit
+  module Cli
+    # Define the 'new' subcommand
+    class CleanCommand < Clamp::Command
+      def execute
+        puts "TODO: implement clean command"
+      end
+    end
+  end
+end

data/lib/makit/cli/clone.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "clamp"
+#require "git"
+
+module Makit
+  module Cli
+    # Define the 'clone' subcommand
+    class CloneCommand < Clamp::Command
+      parameter "GIT_REPOSITORY", "The git repository url", attribute_name: :git_repository, required: true
+
+      def execute
+        clone_dir = Directories::get_clone_directory(git_repository)
+        puts "cloning repository: #{git_repository} to #{clone_dir}"
+        begin
+          Makit::clone(git_repository)
+          if !Dir.exist?(clone_dir)
+            summary = "failed to clone repository: #{git_repository} to #{clone_dir}\n"
+            summary += "Please check the URL and your network connection.\n"
+            summary += "stdout: #{clone.stdout}\n"
+            summary += "stderr: #{clone.stderr}\n"
+            $stderr.puts summary
+            exit 1
+          end
+        rescue => e
+          #  $stderr.puts "failed to clone repository: #{git_repository} to #{clone_dir}"
+          puts e.message
+          exit 1
+        end
+        #puts "size of clone directory: #{clone_dir} is #{Humanize::get_humanized_size(Directory::get_size(clone_dir))}"
+      end
+
+      #def self.clone(git_repository)
+      # make sure a local clone of the repository exists
+      #  clone_dir = Directories::get_clone_directory(git_repository)
+      #  raise "clone directory already exists: #{clone_dir}" if Dir.exist?(clone_dir)
+      #  begin
+      #    clone_command = Makit::RUNNER.execute("git clone #{git_repository} #{clone_dir}")
+      #    if !Dir.exist?(clone_dir)
+      #      summary = "failed to clone repository: #{git_repository} to #{clone_dir}\n"
+      #      summary += "Please check the URL and your network connection.\n"
+      #      summary += "stdout: #{clone_command.stdout}\n"
+      #      summary += "stderr: #{clone_command.stderr}\n"
+      #      raise Makit::Error, summary
+      #    end
+      #raise "failed to clone repository: #{git_repository} to #{clone_dir}" unless clone_command.success?
+      #Git.clone(git_repository, clone_dir)
+      #  rescue => e
+      #    summary = "=" * 80 + "\n"
+      #    summary += "failed to clone repository: #{git_repository} to #{clone_dir}\n\n"
+      #    summary += "Please check the URL and your network connection.\n"
+      #    summary += "#{e.message}\n\n"
+      #    summary += "=" * 80 + "\n"
+      #    raise Makit::Error, summary
+      #  end
+      #end
+    end
+  end
+end