makit 0.0.99 → 0.0.111

data/lib/makit/rake.rb

@@ -4,12 +4,12 @@
 module Makit
   # This class provide methods for working with the system Environment.
   #
-  class Rake
+  class RakeHelper
     def self.rake_repository(url, task_name)
       local_path = File.join(Makit::Directories::HOME, "code", "work", Makit::Directories.get_relative_directory(url))
-      if (Dir.exist?(local_path))
+      if Dir.exist?(local_path)
         Dir.chdir(local_path) do
-          puts "  " + "#{local_path}".colorize(:grey)
+          puts "  #{local_path.to_s.colorize(:grey)}"
           "git pull".run
         end
       else
@@ -17,9 +17,9 @@ module Makit
         `git clone #{url} #{local_path}`
       end
       Dir.chdir(local_path) do
-        puts "  " + "#{local_path}".colorize(:grey)
+        puts "  #{local_path.to_s.colorize(:grey)}"
         "rake #{task_name}".run
       end
     end
-  end # class Rake
-end # module Makit
+  end
+end

data/lib/makit/ruby/cli.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module Makit
+  class Ruby
+    class CLI
+      # Get the current Ruby version using the 'ruby' CLI
+      def self.current_version
+        version_output = `ruby --version 2>/dev/null`.strip
+        raise "Ruby is not installed or not available in PATH" if version_output.empty?
+
+        # Extract version number from output like "ruby 3.2.0p123 (2023-01-01 revision abc123) [x86_64-darwin22]"
+        version_match = version_output.match(/ruby (\d+\.\d+\.\d+)/)
+        if version_match
+          version_match[1]
+        else
+          # Fallback: return the full version string if parsing fails
+          version_output
+        end
+      end
+
+      # Get detailed Ruby version information
+      def self.version_info
+        version_output = `ruby --version 2>/dev/null`.strip
+        raise "Ruby is not installed or not available in PATH" if version_output.empty?
+
+        {
+          full_version: version_output,
+          version: current_version,
+          patch_level: extract_patch_level(version_output),
+          release_date: extract_release_date(version_output),
+          platform: extract_platform(version_output),
+        }
+      end
+
+      # Check if Ruby is installed and available
+      def self.installed?
+        system("ruby --version > /dev/null 2>&1")
+      end
+
+      # Get the Ruby executable path
+      def self.executable_path
+        `which ruby 2>/dev/null`.strip
+      end
+
+      # Get Ruby configuration information
+      def self.config
+        return {} unless installed?
+
+        config_output = `ruby -e "puts RbConfig::CONFIG" 2>/dev/null`
+        return {} if config_output.empty?
+
+        config = {}
+        config_output.lines.each do |line|
+          key, value = line.strip.split("=", 2)
+          config[key] = value if key && value
+        end
+        config
+      end
+
+      # Get Ruby platform information
+      def self.platform
+        return nil unless installed?
+
+        `ruby -e "puts RUBY_PLATFORM" 2>/dev/null`.strip
+      end
+
+      # Get Ruby engine information
+      def self.engine
+        return nil unless installed?
+
+        engine_info = `ruby -e "puts RUBY_ENGINE" 2>/dev/null`.strip
+        engine_version = `ruby -e "puts RUBY_ENGINE_VERSION" 2>/dev/null`.strip
+
+        {
+          name: engine_info,
+          version: engine_version,
+        }
+      end
+
+      # Get Ruby installation directory
+      def self.installation_dir
+        return nil unless installed?
+
+        `ruby -e "puts RbConfig::CONFIG['prefix']" 2>/dev/null`.strip
+      end
+
+      # Get Ruby library directories
+      def self.library_dirs
+        return [] unless installed?
+
+        lib_dirs = `ruby -e "puts RbConfig::CONFIG['libdir']" 2>/dev/null`.strip
+        arch_lib_dirs = `ruby -e "puts RbConfig::CONFIG['archdir']" 2>/dev/null`.strip
+
+        [lib_dirs, arch_lib_dirs].compact.uniq
+      end
+
+      # Get Ruby gem directories
+      def self.gem_dirs
+        return [] unless installed?
+
+        gem_dirs_output = `ruby -e "puts Gem.path" 2>/dev/null`
+        return [] if gem_dirs_output.empty?
+
+        gem_dirs_output.strip.split("\n")
+      end
+
+      # Get Ruby load path
+      def self.load_path
+        return [] unless installed?
+
+        load_path_output = `ruby -e "puts $LOAD_PATH" 2>/dev/null`
+        return [] if load_path_output.empty?
+
+        load_path_output.strip.split("\n")
+      end
+
+      # Check if a specific Ruby version is available
+      def self.version_available?(version)
+        return false unless installed?
+
+        current = current_version
+        case version
+        when /^(\d+)\.(\d+)\.(\d+)$/
+          major = ::Regexp.last_match(1).to_i
+          minor = ::Regexp.last_match(2).to_i
+          patch = ::Regexp.last_match(3).to_i
+          current_major, current_minor, current_patch = current.split(".").map(&:to_i)
+
+          if major != current_major
+            major == current_major
+          elsif minor != current_minor
+            minor == current_minor
+          else
+            patch == current_patch
+          end
+        when /^(\d+)\.(\d+)$/
+          major = ::Regexp.last_match(1).to_i
+          minor = ::Regexp.last_match(2).to_i
+          current_major, current_minor = current.split(".").map(&:to_i)
+          major == current_major && minor == current_minor
+        when /^(\d+)$/
+          major = ::Regexp.last_match(1).to_i
+          current_major = current.split(".").first.to_i
+          major == current_major
+        else
+          false
+        end
+      end
+
+      # Get Ruby environment summary
+      def self.environment_summary
+        return { error: "Ruby is not installed" } unless installed?
+
+        {
+          version: current_version,
+          full_version: version_info[:full_version],
+          platform: platform,
+          engine: engine,
+          executable_path: executable_path,
+          installation_dir: installation_dir,
+          gem_dirs: gem_dirs,
+          library_dirs: library_dirs,
+        }
+      end
+
+      # Extract patch level from version string
+      def self.extract_patch_level(version_string)
+        match = version_string.match(/p(\d+)/)
+        match ? match[1] : nil
+      end
+
+      # Extract release date from version string
+      def self.extract_release_date(version_string)
+        match = version_string.match(/\((\d{4}-\d{2}-\d{2})/)
+        match ? match[1] : nil
+      end
+
+      # Extract platform from version string
+      def self.extract_platform(version_string)
+        match = version_string.match(/\[([^\]]+)\]/)
+        match ? match[1] : nil
+      end
+    end
+  end
+end

data/lib/makit/ruby.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "ruby/cli"
+
+module Makit
+  class Ruby
+    # Main Ruby module for Makit
+    # Provides Ruby-related functionality and utilities
+
+    # Get current Ruby version (convenience method)
+    def self.version
+      CLI.current_version
+    end
+
+    # Check if Ruby is installed (convenience method)
+    def self.installed?
+      CLI.installed?
+    end
+
+    # Get Ruby environment information (convenience method)
+    def self.info
+      CLI.environment_summary
+    end
+  end
+end

data/lib/makit/secrets.rb

@@ -1,49 +1,49 @@
+# frozen_string_literal: true
+
 module Makit
   class Secrets
     def add(key, value)
-      secrets_hash = get_secrets_hash()
+      secrets_hash = get_secrets_hash
       secrets_hash[key] = value
       save_secrets_hash(secrets_hash)
     end
 
     def remove(key)
-      secrets_hash = get_secrets_hash()
+      secrets_hash = get_secrets_hash
       secrets_hash.delete(key)
       save_secrets_hash(secrets_hash)
     end
 
     def has_key?(key)
-      secrets_hash = get_secrets_hash()
-      return secrets_hash.key?(key)
+      secrets_hash = get_secrets_hash
+      secrets_hash.key?(key)
     end
 
     def get(key)
-      secrets_hash = get_secrets_hash()
-      return secrets_hash[key]
+      secrets_hash = get_secrets_hash
+      secrets_hash[key]
     end
 
     def set(key, value)
-      secrets_hash = get_secrets_hash()
+      secrets_hash = get_secrets_hash
       secrets_hash[key] = value
       save_secrets_hash(secrets_hash)
     end
 
-    def get_secrets_filename()
-      return "#{Makit::Directories::ROOT}/secrets.json"
+    def get_secrets_filename
+      "#{Makit::Directories::ROOT}/secrets.json"
     end
 
-    def get_secrets_hash()
-      secrets_file = get_secrets_filename()
-      if File.exist?(secrets_file)
-        text = IO.read(secrets_file)
-        return JSON.parse(text)
-      else
-        return {}
-      end
+    def get_secrets_hash
+      secrets_file = get_secrets_filename
+      return {} unless File.exist?(secrets_file)
+
+      text = File.read(secrets_file)
+      JSON.parse(text)
     end
 
     def save_secrets_hash(hash)
-      secrets_file = get_secrets_filename()
+      secrets_file = get_secrets_filename
       # pretty print the hash
       File.open(secrets_file, "w") { |f| f.puts JSON.pretty_generate(hash) }
     end

data/lib/makit/serializer.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
+
 require "google/protobuf"
 # This module provides classes for the Makit gem.
 module Makit
   module Proto3Formats
-    JSON = 0,
-           PRETTY_JSON = 1,
-           YAML = 2,
-    BINARY = 3
+    JSON = [0,
+            PRETTY_JSON = 1,
+            YAML = 2,
+            BINARY = 3].freeze
   end
 
   # This class provide methods for serializing and deserializing objects.
@@ -22,11 +23,9 @@ module Makit
       when ".yml"
         File.write(filename, Makit::Serializer.new(Makit::Proto3Formats::YAML).serialize(object))
       when ".pb"
-        File.open(filename, "wb") do |file|
-          file.write(Makit::Serializer.new(Makit::Proto3Formats::BINARY).serialize(object))
-        end
+        File.binwrite(filename, Makit::Serializer.new(Makit::Proto3Formats::BINARY).serialize(object))
 
-        #File.write(filename, Makit::Serializer.new(Makit::Proto3Formats::BINARY).serialize(object))
+        # File.write(filename, Makit::Serializer.new(Makit::Proto3Formats::BINARY).serialize(object))
       else
         raise "unsupported file extension: #{extension}"
       end
@@ -40,7 +39,7 @@ module Makit
       when ".yml"
         Makit::Serializer.new(Makit::Proto3Formats::YAML).deserialize(type, File.read(filename))
       when ".pb"
-        data = File.open(filename, "rb") { |file| file.read }
+        data = File.binread(filename)
         Makit::Serializer.new(Makit::Proto3Formats::BINARY).deserialize(type, data)
       else
         raise "unsupported file extension: #{extension}"
@@ -56,24 +55,23 @@ module Makit
     # Serialize an object to a byte[] or a string
     def serialize(object)
       raise "Object is nil" if object.nil?
-      raise "object is not of type ::Google::Protobuf::MessageExts" if !object.is_a? ::Google::Protobuf::MessageExts
+      raise "object is not of type ::Google::Protobuf::MessageExts" unless object.is_a? ::Google::Protobuf::MessageExts
 
       case @format_maps[::Google::Protobuf::MessageExts]
       when Proto3Formats::JSON
-        #puts "Serializing to protobuf json format"
+        # puts "Serializing to protobuf json format"
         object.to_json
       when Proto3Formats::PRETTY_JSON
-        #puts "Serializing to protobuf pretty json format"
+        # puts "Serializing to protobuf pretty json format"
         json = object.to_json
-        pretty_json = JSON.pretty_generate(JSON.parse(json))
-        pretty_json
+        JSON.pretty_generate(JSON.parse(json))
       when Proto3Formats::YAML
-        #puts "Serializing to protobuf yaml format"
+        # puts "Serializing to protobuf yaml format"
         data = JSON.parse(object.to_json)
         data.to_yaml.sub(/^---\n/, "")
       when Proto3Formats::BINARY
-        #puts "Serializing to protobuf binary format"
-        serialized_object = object.to_proto
+        # puts "Serializing to protobuf binary format"
+        object.to_proto
       else
         raise "Unknown serialization format"
       end
@@ -82,34 +80,38 @@ module Makit
     # Deserialize a byte[] or a string to an object
     def deserialize(type, data)
       raise "data is nil" if data.nil?
+
       case @format_maps[::Google::Protobuf::MessageExts]
       when Proto3Formats::JSON
-        raise "data is not of type string" if !data.is_a? String
+        raise "data is not of type string" unless data.is_a? String
+
         json = data
-        #puts "Deserializing from protobuf json format into type #{type}"
+        # puts "Deserializing from protobuf json format into type #{type}"
         # use the from_json method to deserialize the object
         type.decode_json(json)
       when Proto3Formats::PRETTY_JSON
-        raise "data is not of type string" if !data.is_a? String
+        raise "data is not of type string" unless data.is_a? String
+
         json = data
-        #puts "Deserializing from protobuf pretty json format into type #{type}"
+        # puts "Deserializing from protobuf pretty json format into type #{type}"
         # use the from_json method to deserialize the object
         type.decode_json(json)
       when Proto3Formats::YAML
-        raise "data is not of type string" if !data.is_a? String
+        raise "data is not of type string" unless data.is_a? String
+
         yaml = data
         # convert yaml to json
         json = JSON.pretty_generate(YAML.safe_load(yaml))
-        #puts "Deserializing from protobuf yaml format into type #{type}"
+        # puts "Deserializing from protobuf yaml format into type #{type}"
         type.decode_json(json)
       when Proto3Formats::BINARY
-        #raise "data is not of type byte[]" if !data.is_a? Array
+        # raise "data is not of type byte[]" if !data.is_a? Array
         bytes = data
-        #puts "Deserializing from protobuf binary format into type #{type}"
+        # puts "Deserializing from protobuf binary format into type #{type}"
         type.decode(bytes)
       else
         raise "Unknown serialization format"
       end
     end
-  end # class Storage
-end # module Makit
+  end
+end

data/lib/makit/services/builder.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require_relative "validator"
+require_relative "repository_manager"
+
+module Makit
+  module Services
+    # Service class responsible for build operations and make processes
+    # Handles the complex build workflow including repository setup and execution
+    class Builder
+      class << self
+        # Build a repository at a specific commit
+        #
+        # @param url [String] the git repository URL
+        # @param commit [String] the commit hash or "latest" for the most recent commit
+        # @param force [Boolean] whether to force rebuild even if cached result exists
+        # @return [Makit::V1::MakeResult] the build result with all command outputs
+        def make_repository(url, commit, force: false)
+          Validator.validate_url_parameter(url)
+          Validator.validate_commit_parameter(commit)
+
+          log_filename = get_log_filename(url, commit)
+
+          return load_existing_result(log_filename) if should_load_existing_result?(log_filename, force, commit)
+
+          execute_make_process(url, commit, log_filename)
+        end
+
+        # Ensure .gitignore exists in the current directory
+        def ensure_gitignore
+          return if File.exist?(".gitignore")
+
+          Makit::LOGGER.info("added .gitignore file")
+          File.open(".gitignore", "w") do |file|
+            file.puts Makit::Content::GITIGNORE
+          end
+        end
+
+        private
+
+        # Get the log filename for storing build results
+        def get_log_filename(url, commit)
+          File.join(
+            Directories.get_log_directory(url),
+            commit,
+            "#{Makit::RUNTIME_IDENTIFIER}.#{Makit::DEVICE}.json"
+          )
+        end
+
+        # Check if we should load an existing cached result
+        def should_load_existing_result?(log_filename, force, commit)
+          File.exist?(log_filename) && !force && commit != Validator::COMMIT_LATEST
+        end
+
+        # Load existing build result from cache
+        def load_existing_result(log_filename)
+          Makit::V1::MakeResult.decode_json(File.read(log_filename))
+        rescue StandardError
+          FileUtils.rm(log_filename)
+          nil
+        end
+
+        # Execute the complete make process
+        def execute_make_process(url, commit, log_filename)
+          commands = []
+          begin
+            commands = setup_repository_for_build(url, commit, log_filename)
+            make_result = build_make_result(url, commit, commands)
+            save_make_result(make_result, log_filename)
+            make_result
+          rescue StandardError => e
+            handle_make_error(e, url, commit, commands)
+          end
+        end
+
+        # Set up repository for build process
+        def setup_repository_for_build(url, commit, log_filename)
+          commands = initialize_repository_commands(url)
+
+          clone_dir = RepositoryManager.validate_clone_directory(url)
+          resolved_commit = resolve_commit_reference(commit, clone_dir, commands, log_filename, url)
+          prepare_make_directory(url, resolved_commit, clone_dir, commands)
+
+          commands
+        end
+
+        # Initialize repository commands (clone or pull)
+        def initialize_repository_commands(url)
+          RepositoryManager.clone_or_pull_repository(url).flatten
+        end
+
+        # Resolve commit reference (handle "latest" commit)
+        def resolve_commit_reference(commit, clone_dir, commands, log_filename, url)
+          return commit unless commit == Validator::COMMIT_LATEST
+
+          latest_commit = RepositoryManager.get_latest_commit(clone_dir, commands)
+          # Update log filename with resolved commit hash
+          log_filename.replace(
+            File.join(
+              Directories.get_log_directory(url),
+              latest_commit,
+              "#{Makit::RUNTIME_IDENTIFIER}.#{Makit::DEVICE}.json"
+            )
+          )
+          latest_commit
+        end
+
+        # Prepare make directory with repository clone
+        def prepare_make_directory(url, commit, clone_dir, commands)
+          make_dir = Directories.get_make_commit_directory(url, commit)
+          FileUtils.rm_rf(make_dir)
+
+          clone_command = Makit::RUNNER.execute("git clone #{clone_dir} #{make_dir}")
+          commands << clone_command
+
+          return if Dir.exist?(make_dir)
+
+          raise Makit::CloneError, "failed to clone repository: #{url} to #{make_dir}"
+        end
+
+        # Build the make result by executing all build steps
+        def build_make_result(url, commit, commands)
+          Dir.chdir(Directories.get_make_commit_directory(url, commit)) do
+            execute_git_commands(commit, commands)
+            execute_build_commands(commands)
+
+            make_result = create_make_result_object(url, commit)
+            commands.flatten.each { |command| make_result.commands << command }
+            make_result
+          end
+        end
+
+        # Execute git-specific commands for the build
+        def execute_git_commands(commit, commands)
+          commands << Makit::RUNNER.execute("git reset --hard #{commit}")
+          commands << Makit::RUNNER.execute("git log -n 1")
+        end
+
+        # Execute build commands (bundle, rake, etc.)
+        def execute_build_commands(commands)
+          commands << Makit::RUNNER.execute("bundle install") if File.exist?("Gemfile")
+
+          return unless File.exist?("Rakefile") || File.exist?("rakefile.rb")
+
+          commands << Makit::RUNNER.execute("rake default")
+        end
+
+        # Create the make result object
+        def create_make_result_object(url, commit)
+          Makit::V1::MakeResult.new(
+            repository: url,
+            commit: commit,
+            branch: "?",
+            tag: "?",
+            device: Makit::DEVICE,
+            runtime_identifier: Makit::RUNTIME_IDENTIFIER,
+          )
+        end
+
+        # Save make result to file
+        def save_make_result(make_result, log_filename)
+          FileUtils.mkdir_p(File.dirname(log_filename))
+          File.write(log_filename, make_result.to_json)
+        end
+
+        # Handle make process errors
+        def handle_make_error(error, url, commit, commands)
+          message_parts = [
+            "error raised attempting to make repository: #{url} commit: #{commit}",
+            "",
+            error.message,
+            error.backtrace.join("\\n"),
+            "",
+            "commands:",
+          ]
+
+          commands.flatten.each do |command|
+            message_parts << Makit::Humanize.get_command_details(command)
+          end
+
+          raise Makit::BuildError, message_parts.join("\\n")
+        end
+      end
+    end
+  end
+end