makit 0.0.111 → 0.0.112

data/lib/makit/serializer.rb

@@ -1,117 +1,130 @@
-# 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].freeze
-  end
-
-  # This class provide methods for serializing and deserializing objects.
-  #
-  class Serializer
-    attr_accessor :format_map
-
-    def self.save_as(filename, object)
-      extension = File.extname(filename)
-      case extension
-      when ".json"
-        File.write(filename, Makit::Serializer.new(Makit::Proto3Formats::PRETTY_JSON).serialize(object))
-      when ".yml"
-        File.write(filename, Makit::Serializer.new(Makit::Proto3Formats::YAML).serialize(object))
-      when ".pb"
-        File.binwrite(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
-    end
-
-    def self.open(filename, type)
-      extension = File.extname(filename)
-      case extension
-      when ".json"
-        Makit::Serializer.new(Makit::Proto3Formats::PRETTY_JSON).deserialize(type, File.read(filename))
-      when ".yml"
-        Makit::Serializer.new(Makit::Proto3Formats::YAML).deserialize(type, File.read(filename))
-      when ".pb"
-        data = File.binread(filename)
-        Makit::Serializer.new(Makit::Proto3Formats::BINARY).deserialize(type, data)
-      else
-        raise "unsupported file extension: #{extension}"
-      end
-    end
-
-    def initialize(proto3_format = Proto3Formats::PRETTY_JSON)
-      @format_maps = {
-        ::Google::Protobuf::MessageExts => proto3_format,
-      }
-    end
-
-    # 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" unless object.is_a? ::Google::Protobuf::MessageExts
-
-      case @format_maps[::Google::Protobuf::MessageExts]
-      when Proto3Formats::JSON
-        # puts "Serializing to protobuf json format"
-        object.to_json
-      when Proto3Formats::PRETTY_JSON
-        # puts "Serializing to protobuf pretty json format"
-        json = object.to_json
-        JSON.pretty_generate(JSON.parse(json))
-      when Proto3Formats::YAML
-        # 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"
-        object.to_proto
-      else
-        raise "Unknown serialization format"
-      end
-    end
-
-    # 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" unless data.is_a? String
-
-        json = data
-        # 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" unless data.is_a? String
-
-        json = data
-        # 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" 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}"
-        type.decode_json(json)
-      when Proto3Formats::BINARY
-        # raise "data is not of type byte[]" if !data.is_a? Array
-        bytes = data
-        # puts "Deserializing from protobuf binary format into type #{type}"
-        type.decode(bytes)
-      else
-        raise "Unknown serialization format"
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+begin
+  require "google/protobuf"
+rescue LoadError
+  # google-protobuf gem not available, define a minimal protobuf interface
+  module Google
+    module Protobuf
+      class Message
+        def to_json(*args)
+          {}
+        end
+      end
+    end
+  end
+end
+# This module provides classes for the Makit gem.
+module Makit
+  module Proto3Formats
+    JSON = [0,
+            PRETTY_JSON = 1,
+            YAML = 2,
+            BINARY = 3].freeze
+  end
+
+  # This class provide methods for serializing and deserializing objects.
+  #
+  class Serializer
+    attr_accessor :format_map
+
+    def self.save_as(filename, object)
+      extension = File.extname(filename)
+      case extension
+      when ".json"
+        File.write(filename, Makit::Serializer.new(Makit::Proto3Formats::PRETTY_JSON).serialize(object))
+      when ".yml"
+        File.write(filename, Makit::Serializer.new(Makit::Proto3Formats::YAML).serialize(object))
+      when ".pb"
+        File.binwrite(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
+    end
+
+    def self.open(filename, type)
+      extension = File.extname(filename)
+      case extension
+      when ".json"
+        Makit::Serializer.new(Makit::Proto3Formats::PRETTY_JSON).deserialize(type, File.read(filename))
+      when ".yml"
+        Makit::Serializer.new(Makit::Proto3Formats::YAML).deserialize(type, File.read(filename))
+      when ".pb"
+        data = File.binread(filename)
+        Makit::Serializer.new(Makit::Proto3Formats::BINARY).deserialize(type, data)
+      else
+        raise "unsupported file extension: #{extension}"
+      end
+    end
+
+    def initialize(proto3_format = Proto3Formats::PRETTY_JSON)
+      @format_maps = {
+        ::Google::Protobuf::MessageExts => proto3_format,
+      }
+    end
+
+    # 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" unless object.is_a? ::Google::Protobuf::MessageExts
+
+      case @format_maps[::Google::Protobuf::MessageExts]
+      when Proto3Formats::JSON
+        # puts "Serializing to protobuf json format"
+        object.to_json
+      when Proto3Formats::PRETTY_JSON
+        # puts "Serializing to protobuf pretty json format"
+        json = object.to_json
+        JSON.pretty_generate(JSON.parse(json))
+      when Proto3Formats::YAML
+        # 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"
+        object.to_proto
+      else
+        raise "Unknown serialization format"
+      end
+    end
+
+    # 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" unless data.is_a? String
+
+        json = data
+        # 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" unless data.is_a? String
+
+        json = data
+        # 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" 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}"
+        type.decode_json(json)
+      when Proto3Formats::BINARY
+        # raise "data is not of type byte[]" if !data.is_a? Array
+        bytes = data
+        # puts "Deserializing from protobuf binary format into type #{type}"
+        type.decode(bytes)
+      else
+        raise "Unknown serialization format"
+      end
+    end
+  end
+end

data/lib/makit/services/builder.rb

@@ -1,186 +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
+# 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::Commands::Runner.default.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::Commands::Runner.default.execute("git reset --hard #{commit}")
+          commands << Makit::Commands::Runner.default.execute("git log -n 1")
+        end
+
+        # Execute build commands (bundle, rake, etc.)
+        def execute_build_commands(commands)
+          commands << Makit::Commands::Runner.default.execute("bundle install") if File.exist?("Gemfile")
+
+          return unless File.exist?("Rakefile") || File.exist?("rakefile.rb")
+
+          commands << Makit::Commands::Runner.default.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