makit 0.0.0

data/lib/makit/cli/init.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "clamp"
+require_relative "../../makit"
+
+module Makit
+  module Cli
+    # Define the 'init' subcommand
+    class InitCommand < Clamp::Command
+      parameter "DIRECTORY", "The directory to init as a git repository", attribute_name: :directory, required: true
+
+      def execute
+        begin
+          Makit::init(directory)
+          puts "initialized local repository: #{directory}"
+        rescue => e
+          $stderr.puts "failed to initialize repository: #{directory}"
+          puts e.message
+          puts e.backtrace
+          exit 1
+        end
+      end
+
+      #def self.init(directory)
+      #  if !Dir.exist?(directory)
+      #    FileUtils.mkdir_p(directory)
+      #  end
+      #  Dir.chdir(directory) do
+      #    init = Makit::RUNNER.execute "git init"
+      #    if init.exit_code != 0
+      #      raise Makit::Error.new("failed to initialize local repository: #{directory}\n#{Makit::Humanize.get_command_summary(init)}")
+      #    end#
+
+      #  end
+      #end
+    end
+  end
+end

data/lib/makit/cli/main.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "clamp"
+require_relative "new"
+require_relative "setup"
+require_relative "make"
+require_relative "work"
+require_relative "clean"
+require_relative "clone"
+require_relative "pull"
+require_relative "init"
+require_relative "nuget_cache"
+
+module Makit
+  module Cli
+    # Define the main command which includes the subcommands
+    class MainCommand < Clamp::Command
+      option ["-v", "--version"], :flag, "Show version" do
+        puts "makit version #{Makit::VERSION}"
+        exit(0)
+      end
+      subcommand "new", "Create a new entity", NewCommand
+      subcommand "setup", "Setup a project directory", SetupCommand
+      subcommand "work", "Work on a project", WorkCommand
+      subcommand "make", "Make a project", MakeCommand
+      subcommand "clean", "Clean a project", CleanCommand
+      subcommand "clone", "Clone a git repository", CloneCommand
+      subcommand "pull", "Pull latest changes from a git repository", PullCommand
+      subcommand "init", "Initialize a directory as a git repository", InitCommand
+      subcommand "nuget_cache", "Manage the NuGet cache", NugetCacheCommand
+    end
+  end
+end

data/lib/makit/cli/make.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "clamp"
+#require "git"
+require "socket"
+require_relative "../humanize"
+
+module Makit
+  module Cli
+    # Define the 'make' subcommand
+    class MakeCommand < Clamp::Command
+      parameter "GIT_REPOSITORY", "The git repository URL or NAME", attribute_name: :git_repository, required: true
+      #option ["-f", "--force"], "FORCE", "Force the command to be run, even if a result already exists", attribute_name: :force
+
+      def execute
+        begin
+          # make sure a local clone of the repository exists
+          clone_dir = Directories::get_clone_directory(git_repository)
+          if Dir.exist?(clone_dir)
+            # attempt to the pull the latest changes
+            begin
+              PullCommand::pull(git_repository)
+            rescue => e
+              puts "warning: failed to pull repository: #{git_repository}"
+            end
+          else
+            CloneCommand::clone(git_repository)
+          end
+        rescue => e
+          $stderr.puts "failed to make repository: #{git_repository}"
+          puts "Please check the URL and your network connection."
+          puts e.message
+          exit 1
+        end
+
+        # determine the latest commit id for the repository
+        g = Git.open(clone_dir)
+        latest_commit = g.log.first
+        commit = latest_commit.sha
+
+        begin
+          #make_result = MakeCommand::make(git_repository, commit)
+          make_result = Makit::make(git_repository, commit)
+          puts make_result.summary
+        rescue => e
+          $stderr.puts "failed to make repository: #{git_repository} commit: #{commit}"
+          puts e.message
+          puts Makit::Humanize::get_make_result_summary make_result
+          exit 1
+        end
+      end
+    end
+  end
+end

data/lib/makit/cli/new.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "clamp"
+
+module Makit
+  module Cli
+    # Define the 'new' subcommand
+    class NewCommand < Clamp::Command
+      AVAILABLE_TYPES = %w[gem crate nuget].freeze
+      option "--list", :flag, "List available types"
+      option ["-o", "--output"], "OUTPUT_DIR", "Specify output directory", default: "."
+      option ["-t", "--type"], "TYPE", "Type of the new entity", default: "gem"
+      parameter "TYPE", "Type of the new entity", attribute_name: :type, required: false
+      parameter "NAME", "Name of the new entity", attribute_name: :name, required: false
+      parameter "DIRECTORY", "The output directory", attribute_name: :name, required: false
+
+      def execute
+        if list?
+          puts "Available types:"
+          AVAILABLE_TYPES.each { |t| puts "  - #{t}" }
+        else
+          if type.nil? || name.nil?
+            puts "Error: TYPE and NAME are required unless using --list"
+            exit(1)
+          end
+
+          unless AVAILABLE_TYPES.include?(type)
+            puts "Error: '#{type}' is not a valid type. Use --list to see available types."
+            exit(1)
+          end
+
+          puts "Creating a new #{type} named #{name}."
+        end
+      end
+    end
+  end
+end

data/lib/makit/cli/nuget_cache.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "clamp"
+
+module Makit
+  module Cli
+    # Define the 'nuget_cache' subcommand
+    #
+    # nuget_cache Google.Protobuf
+    # nuget_cache Google.Protobuf 3.27.2
+    class NugetCacheCommand < Clamp::Command
+      parameter "PACKAGE", "The package id", attribute_name: :package, required: true
+      parameter "VERSION", "The package version", attribute_name: :version, default: nil
+
+      def execute
+        if version.nil?
+          # look up the latest version of the package
+          raise "TODO: implement latest version lookup"
+        end
+
+        # download the package
+        url = "https://www.nuget.org/api/v2/package/#{package}/#{version}"
+        if !url.nil?
+          # download the package
+
+          raise "TODO: implement package download"
+          puts "url: #{url}"
+          puts "relative directoyr: #{Makit::Environment.get_relative_directory(url)}"
+          puts "work directory: #{Makit::Environment.get_work_directory(url)}"
+        end
+        puts "TODO: implement work command"
+      end
+    end
+
+    def install_cache_package(package, version)
+    end
+  end
+end

data/lib/makit/cli/pull.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "clamp"
+#require "git"
+
+module Makit
+  module Cli
+    # Define the 'pull' subcommand
+    class PullCommand < Clamp::Command
+      parameter "GIT_REPOSITORY", "The git repository url", attribute_name: :git_repository, required: true
+      option "--ignore-errors", :flag, "Ignore errors and present warnings instead of exiting"
+
+      def execute
+        puts "pulling latest changes for repository: #{git_repository}"
+        begin
+          Makit::pull(git_repository)
+        rescue Git::GitExecuteError => e
+          $stderr.puts "failed to pull repository: #{git_repository}"
+          puts "Please check the URL and your network connection."
+          exit 1
+        rescue => e
+          $stderr.puts "failed to pull repository: #{git_repository}"
+          puts e.message
+          exit 1
+        end
+        clone_dir = Directories::get_clone_directory(git_repository)
+        puts "size of clone directory: #{clone_dir} is #{Humanize::get_humanized_size(Directory::get_size(clone_dir))}"
+      end
+    end
+  end
+end

data/lib/makit/cli/setup.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "clamp"
+
+module Makit
+  module Cli
+    # Define the 'new' subcommand
+    class SetupCommand < Clamp::Command
+      PACKAGE_TYPES = %w[gem crate nuget].freeze
+      option "--list", :flag, "List available package types"
+      option ["-t", "--type"], "TYPE", "The package type", default: "gem"
+      option ["-o", "--output"], "OUTPUT", "The output directory", default: "."
+      parameter "TYPE", "Type of the package", attribute_name: :type, required: false
+      parameter "NAME", "Name of the package", attribute_name: :name, required: false
+
+      def execute
+        if list?
+          puts "Available package types:"
+          PACKAGE_TYPES.each { |t| puts "  - #{t}" }
+        else
+          if type.nil? || name.nil?
+            puts "Error: TYPE and NAME are required unless using --list"
+            exit(1)
+          end
+
+          unless PACKAGE_TYPES.include?(type)
+            puts "Error: '#{type}' is not a valid type. Use --list to see available types."
+            exit(1)
+          end
+
+          if !Makit::IS_GIT_REPO
+            Makit::LOGGER.error("#{Dir.pwd} does not appear to be a git repository.")
+            exit(1)
+          end
+          if Makit::IS_READ_ONLY
+            Makit::LOGGER.error("The git repository is in a read-only state.")
+            exit(1)
+          end
+
+          # if a Rakefile already exists, then the project has already been setup
+          if File.exist?("Rakefile")
+            Makit::LOGGER.error("Rakefile detected, The project has already been setup.")
+            exit(1)
+          end
+
+          # verify the root directory has a .gitignore file
+          if !File.exist?(".gitignore")
+            Makit::LOGGER.info("added .gitignore file")
+            File.open(".gitignore", "w") do |file|
+              file.puts Makit::Content::GITIGNORE
+            end
+          end
+
+          # verify the root directory has a Rakefile
+
+          if (type == "gem")
+            if !File.exist?("Gemfile")
+              Makit::RUNNER.run("bundle gem . --coc --mit --exe --no-git --ci=gitlab_ci --test=minitest --changelog --linter=rubocop")
+
+              # overwrite the Rakefile with the one from the gem template
+              File.open("Rakefile", "w") do |file|
+                file.puts Makit::Content::GEM_RAKEFILE.gsub("GEM_NAME", name)
+              end
+            end
+          end
+          # Makit::LOGGER.info("bundle gem . --coc --mit --exe --no-git --ci=gitlab_ci --test=minitest --changelog --linter=rubocop --skip=Rakefile,README.md")
+        end
+      end
+    end
+  end
+end

data/lib/makit/cli/work.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "clamp"
+
+module Makit
+  module Cli
+    # Define the 'new' subcommand
+    class WorkCommand < Clamp::Command
+      option ["-u", "--url"], "URL", "The git repository url"
+
+      def execute
+        if !url.nil?
+          puts "url: #{url}"
+          puts "relative directoyr: #{Makit::Environment.get_relative_directory(url)}"
+          puts "work directory: #{Makit::Environment.get_work_directory(url)}"
+        end
+        puts "TODO: implement work command"
+      end
+    end
+  end
+end

data/lib/makit/command_runner.rb

@@ -0,0 +1,237 @@
+require "English"
+require "open3"
+require "socket"
+require "etc"
+require "logger"
+
+# This module provides classes for the Makit gem.
+module Makit
+  # This class provide methods running commands.
+  #
+  class CommandRunner
+    attr_accessor :show_output_on_success, :log_to_artifacts
+
+    def initialize
+      @show_output_on_success = false
+      @log_to_artifacts = false
+    end
+
+    def run(command_request)
+      raise "Invalid command_request" unless command_request.is_a? Makit::V1::CommandRequest
+      command = execute(command_request)
+      show_output = true
+      exit_on_error = true
+
+      log_to_artifacts(command) if @log_to_artifacts
+      if command.exit_code != 0
+        puts Makit::CommandRunner.get_command_summary(command) + " (exit code #{command.exit_code})".colorize(:default)
+        puts "  directory: #{command.directory}\n"
+        puts "  duration: #{command.duration.seconds} seconds\n"
+        puts Makit::Humanize::indent_string(command.output, 2) if command.output.length > 0
+        puts Makit::Humanize::indent_string(command.error, 2) if command.error.length > 0
+        exit 1 if command_request.exit_on_error
+      else
+        puts Makit::CommandRunner.get_command_summary(command) + " (#{command.duration.seconds} seconds)".colorize(:cyan)
+        puts Makit::Humanize::indent_string(command.output, 2).colorize(:default) if show_output_on_success
+      end
+
+      command
+    end
+
+    def log_to_artifacts(command)
+      dir = File.join(Makit::Directories::PROJECT_ARTIFACTS, "commands")
+      FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      filename_friendly_timestamp = Time.now.strftime("%Y.%m.%d_%H%M%S")
+      log_filename = File.join(dir, "#{filename_friendly_timestamp}.json")
+      # serialize to protobuf json
+      json = command.to_json
+      pretty_json = JSON.pretty_generate(JSON.parse(json))
+      File.write(log_filename, pretty_json)
+    end
+
+    # Run a command and return a Makit::V1::Command.
+    def try(args)
+      request = parse_command_request(args)
+      request.exit_on_error = false
+      run(request)
+      #run2(args, false)
+    end
+
+    # Show the output of a command and return a Makit::V1::Command.
+    def show(args)
+      request = parse_args(args)
+      command = execute(request)
+
+      show_output = true
+      exit_on_error = true
+      Makit::LOGGER.info(Makit::CommandRunner.get_command_summary(command))
+      show_output = true if command.exit_code != 0
+      Makit::LOGGER.info(indent_string("\n#{command.output}\n#{command.error}\n".strip, 2)) if show_output
+      exit(command.exit_code) if exit_on_error && command.exit_code != 0 # unless process_status.success?
+      command
+    end
+
+    # Parse and return a Makit::V1::CommandRequest.
+    def parse_command_request(source)
+      return Makit::V1::CommandRequest.new(source) if source.is_a? Hash
+      return source if source.is_a? Makit::V1::CommandRequest
+      if source.is_a? String
+        return parse_args(source)
+      end
+
+      raise "Invalid source" unless source.is_a? Makit::V1::CommandRequest
+    end
+
+    def parse_command_request_from_hash(hash)
+      raise "Invalid hash" unless hash.is_a? Hash
+      Makit::V1::CommandRequest.new(hash)
+    end
+
+    def parse_command_request_from_string(source)
+      raise "Invalid source" unless source.is_a? String
+      words = source.split(" ")
+      hash = {
+        name: words.shift,
+        arguments: words,
+        exit_on_error: true,
+      }
+    end
+
+    # Parse the command line arguments into a Makit::V1::CommandRequest.
+    def parse_args(args)
+      #raise "No command specified" if args.empty?
+      if args.is_a? Makit::V1::CommandRequest
+        args
+      else
+        if args.is_a? String
+          args = args.split(" ")
+          if (args.length == 1)
+            hash = {
+              name: args[0],
+              arguments: [],
+              exit_on_error: true,
+            }
+            Makit::V1::CommandRequest.new(hash)
+          else
+            hash = {
+              name: args.shift,
+              arguments: args,
+              exit_on_error: true,
+            }
+
+            Makit::V1::CommandRequest.new(hash)
+          end
+        else
+          Makit::V1::CommandRequest.new(args)
+        end
+      end
+    end
+
+    def get_path_name(name)
+      # replace all characters that a not valid in a filename with an underscore
+      name.gsub(/[^0-9a-z]/i, "_")
+    end
+
+    # Given a Makit::V1::CommandRequest, execute the command and return a Makit::V1::Command.
+    def execute(args)
+      command_request = parse_args(args)
+      command_request.directory = Dir.pwd if command_request.directory.nil?
+      command_request.directory = Dir.pwd if command_request.directory.length == 0
+      result = Makit::V1::Command.new(name: command_request.name)
+      command_request.arguments.each do |arg|
+        result.arguments.push(arg)
+      end
+      command = "#{command_request.name} #{command_request.arguments.join(" ")}"
+      result.directory = command_request.directory
+      start = Time.now
+      filename_friendly_timestamp = Time.now.strftime("%Y.%m.%d_%H%M%S")
+      log_filename = File.join(Makit::Directories::LOG, "#{filename_friendly_timestamp}.log")
+
+      # assign a directory variable to the current working directory, if not specified,
+      # otherwise assign the specified directory
+      command_request.directory = Dir.pwd if command_request.directory.nil?
+      command_request.directory = Dir.pwd if command_request.directory.length == 0
+      raise "Invalid directory" unless Dir.exist?(command_request.directory)
+
+      result.started_at = Google::Protobuf::Timestamp.new(seconds: start.to_i, nanos: start.nsec.to_i)
+      ############# execute the command
+      (output, error, exit_code) = execute_command(command, command_request.directory, command_request.timeout)
+      result.output = output.force_encoding("ASCII-8BIT")
+      result.error = error.force_encoding("ASCII-8BIT")
+      result.exit_code = exit_code.nil? ? 0 : exit_code
+
+
+      elapsed_time = Time.now - start
+      seconds = elapsed_time.to_i
+      nanos = ((elapsed_time - seconds) * 1_000_000_000).to_i
+
+      result.duration = Google::Protobuf::Duration.new(seconds: seconds, nanos: nanos)
+
+      result
+    end
+
+    # pure function to execute a command
+    # returns (stdout, stderr, exit_code) or raise an exception
+    def execute_command(command, directory, timeout)
+      original_directory = Dir.pwd
+      begin
+        output = nil
+        error = nil
+        process_status = nil
+        Dir.chdir(directory) do
+          output, error, process_status = Open3.capture3(command)
+        end
+        return [output, error, process_status.exitstatus]
+      rescue => e
+        # restore the original working directory
+        Dir.chdir(original_directory)
+        message_parts = []
+        message_parts << "failed to execute #{command}"
+        message_parts << "directory: #{directory}"
+        message_parts << "timeout: #{timeout}" unless timeout.nil?
+        message_parts << "error: #{e.message}"
+        message = message_parts.join("\n") + "\n"
+        return ["", message, 1]
+        #raise Makit::Error, message
+      end
+    end
+
+    def execute_command_request(command_request)
+      # if the command_request is not a Makit::V1::CommandRequest, raise an error
+      raise "Invalid command_request" unless command_request.is_a? Makit::V1::CommandRequest
+
+      args = Array.new
+      command_request.arguments.each do |arg|
+        args.push(arg)
+      end
+      result = Makit::V1::Command.new({
+        name: command_request.name,
+        arguments: args,
+        started_at: Google::Protobuf::Timestamp.new({ seconds: Time.now.to_i, nanos: Time.now.nsec }),
+      })
+
+      begin
+      rescue => e
+      end
+    end
+
+    def indent_string(input_string, indent_spaces)
+      indentation = " " * indent_spaces
+      input_string.lines.map { |line| indentation + line }.join
+    end
+
+    def self.get_command_summary(command)
+      symbol = Makit::Symbols.warning
+      symbol = Makit::Symbols.checkmark if !command.exit_code.nil? && command.exit_code.zero?
+      symbol = Makit::Symbols.error if command.exit_code != 0
+      summary = "#{symbol} #{command.name.colorize(:yellow)} #{command.arguments.join(" ")}"
+
+      if summary.length > 80
+        summary = summary.to_lines(80,command.name.length+3)
+      end
+
+      summary
+    end
+
+  end   # class CommandRunner
+end # module Makit

data/lib/makit/commands.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "English"
+require "open3"
+require "socket"
+require "etc"
+require "logger"
+
+# This module provides classes for the Makit gem.
+module Makit
+  # This class provide methods running commands.
+  #
+  class Commands < Array
+
+    # Generate the commands based on the current directory.
+    def auto_generate
+      self << Makit::V1::CommandRequest.new(name: "bundle", arguments: ["install"]) if File.exist?("Gemfile")
+      self << Makit::V1::CommandRequest.new(name: "bundle", arguments: ["exec", "rake"]) if File.exist?("Rakefile")
+    end
+  end
+end

data/lib/makit/content/default_gitignore.rb

@@ -0,0 +1,5 @@
+module Makit
+  module Content
+    GITIGNORE = File.read(File.join(__dir__, "default_gitignore.txt"))
+  end # module Content
+end # module Makit