makit 0.0.144 → 0.0.145

data/lib/makit/v1/configuration/project_service_impl.rb

@@ -0,0 +1,371 @@
+# frozen_string_literal: true
+
+require_relative "../../../generated/makit/v1/configuration/project_service_services_pb"
+require_relative "../../configuration/gitlab_helper"
+require_relative "../../configuration/rakefile_helper"
+require_relative "../../configuration/step"
+
+module Makit
+  module V1
+    module Configuration
+      # gRPC service implementation for ProjectService
+      # Implements all the RPC methods defined in the protobuf service definition
+      class ProjectServiceImpl < ProjectService::Service
+        # Load a project from a JSON file
+        def load_from_file(request, _unused_call)
+          raise ArgumentError, "File does not exist: #{request.path}" unless File.exist?(request.path)
+
+          content = File.read(request.path)
+          data = JSON.parse(content, symbolize_names: true)
+
+          project = convert_from_json_data(data)
+          project
+        rescue ArgumentError => e
+          raise GRPC::BadStatus.new(GRPC::Core::StatusCodes::INVALID_ARGUMENT, e.message)
+        rescue StandardError => e
+          raise GRPC::BadStatus.new(GRPC::Core::StatusCodes::INTERNAL, e.message)
+        end
+
+        # Load a project from JSON string
+        def load_from_json(request, _unused_call)
+          raise ArgumentError, "JSON string cannot be empty" if request.json_string.nil? || request.json_string.strip.empty?
+
+          data = JSON.parse(request.json_string, symbolize_names: true)
+          project = convert_from_json_data(data)
+          project
+        rescue ArgumentError => e
+          raise GRPC::BadStatus.new(GRPC::Core::StatusCodes::INVALID_ARGUMENT, e.message)
+        rescue StandardError => e
+          raise GRPC::BadStatus.new(GRPC::Core::StatusCodes::INTERNAL, e.message)
+        end
+
+        # Save a project to a specific path as pretty JSON
+        def save_to_file(request, _unused_call)
+          validate_project_model(request.project)
+          raise ArgumentError, "Path cannot be empty" if request.path.nil? || request.path.strip.empty?
+
+          File.write(request.path, convert_to_json_pretty(request.project))
+          Google::Protobuf::Empty.new
+        rescue ArgumentError => e
+          raise GRPC::BadStatus.new(GRPC::Core::StatusCodes::INVALID_ARGUMENT, e.message)
+        rescue StandardError => e
+          raise GRPC::BadStatus.new(GRPC::Core::StatusCodes::INTERNAL, e.message)
+        end
+
+        # Save a project to the default .makit.json file
+        def save_to_default(request, _unused_call)
+          validate_project_model(request.project)
+          File.write(".makit.json", convert_to_json_pretty(request.project))
+          Google::Protobuf::Empty.new
+        rescue ArgumentError => e
+          raise GRPC::BadStatus.new(GRPC::Core::StatusCodes::INVALID_ARGUMENT, e.message)
+        rescue StandardError => e
+          raise GRPC::BadStatus.new(GRPC::Core::StatusCodes::INTERNAL, e.message)
+        end
+
+        # Load the default project from .makit.json or create a new one
+        def load_default(request, _unused_call)
+          if File.exist?(".makit.json")
+            load_from_file(LoadFromFileRequest.new(path: ".makit.json"), nil)
+          else
+            project = Project.new(
+              name: "",
+              version: "0.0.0",
+              project_type: "",
+              authors: "authors",
+              description: "description",
+              license_expression: "MIT",
+              steps: []
+            )
+            Makit::Logging.default_logger.warn("Project not configured")
+            project
+          end
+        rescue StandardError => e
+          raise GRPC::BadStatus.new(GRPC::Core::StatusCodes::INTERNAL, e.message)
+        end
+
+        # Generate GitLab CI YAML from project
+        def generate_gitlab_ci(request, _unused_call)
+          validate_project_model(request.project)
+          raise ArgumentError, "Path cannot be empty" if request.path.nil? || request.path.strip.empty?
+
+          # Convert protobuf model to Ruby model for GitLab helper
+          ruby_model = convert_to_ruby_model(request.project)
+          Makit::Configuration::GitLabHelper.to_yaml(ruby_model, request.path)
+          Google::Protobuf::Empty.new
+        rescue ArgumentError => e
+          raise GRPC::BadStatus.new(GRPC::Core::StatusCodes::INVALID_ARGUMENT, e.message)
+        rescue StandardError => e
+          raise GRPC::BadStatus.new(GRPC::Core::StatusCodes::INTERNAL, e.message)
+        end
+
+        # Generate Rakefile from project
+        def generate_rakefile(request, _unused_call)
+          validate_project_model(request.project)
+          
+          # Convert protobuf model to Ruby model for Rakefile helper
+          ruby_model = convert_to_ruby_model(request.project)
+          content = Makit::Configuration::RakefileHelper.generate(ruby_model)
+          GenerateRakefileResponse.new(content: content)
+        rescue ArgumentError => e
+          raise GRPC::BadStatus.new(GRPC::Core::StatusCodes::INVALID_ARGUMENT, e.message)
+        rescue StandardError => e
+          raise GRPC::BadStatus.new(GRPC::Core::StatusCodes::INTERNAL, e.message)
+        end
+
+        # Write Rakefile to file
+        def write_rakefile(request, _unused_call)
+          validate_project_model(request.project)
+          raise ArgumentError, "Path cannot be empty" if request.path.nil? || request.path.strip.empty?
+
+          # Convert protobuf model to Ruby model for Rakefile helper
+          ruby_model = convert_to_ruby_model(request.project)
+          Makit::Configuration::RakefileHelper.write(ruby_model, request.path)
+          Google::Protobuf::Empty.new
+        rescue ArgumentError => e
+          raise GRPC::BadStatus.new(GRPC::Core::StatusCodes::INVALID_ARGUMENT, e.message)
+        rescue StandardError => e
+          raise GRPC::BadStatus.new(GRPC::Core::StatusCodes::INTERNAL, e.message)
+        end
+
+        # Validate project configuration
+        def validate_project(request, _unused_call)
+          errors = validate_project_model_errors(request.project)
+          ValidateProjectResponse.new(errors: errors)
+        rescue StandardError => e
+          raise GRPC::BadStatus.new(GRPC::Core::StatusCodes::INTERNAL, e.message)
+        end
+
+        # Merge two project configurations
+        def merge_projects(request, _unused_call)
+          merged = Project.new(
+            git_remote_url: request.override_project.git_remote_url || request.base_project.git_remote_url,
+            name: request.override_project.name || request.base_project.name,
+            version: request.override_project.version || request.base_project.version,
+            project_type: request.override_project.project_type || request.base_project.project_type,
+            authors: request.override_project.authors || request.base_project.authors,
+            description: request.override_project.description || request.base_project.description,
+            license_expression: request.override_project.license_expression || request.base_project.license_expression,
+            dotnet_projects: request.override_project.dotnet_projects.any? ? request.override_project.dotnet_projects.to_a : request.base_project.dotnet_projects.to_a,
+            steps: request.override_project.steps.any? ? request.override_project.steps.to_a : request.base_project.steps.to_a
+          )
+          merged
+        rescue StandardError => e
+          raise GRPC::BadStatus.new(GRPC::Core::StatusCodes::INTERNAL, e.message)
+        end
+
+        # Create a new project with default values
+        def create_project(request, _unused_call)
+          raise ArgumentError, "Project name cannot be empty" if request.name.nil? || request.name.strip.empty?
+
+          project = Project.new(
+            name: request.name,
+            version: request.version || "0.0.0",
+            project_type: request.project_type || "gem",
+            authors: "authors",
+            description: "description",
+            license_expression: "MIT",
+            steps: []
+          )
+          project
+        rescue ArgumentError => e
+          raise GRPC::BadStatus.new(GRPC::Core::StatusCodes::INVALID_ARGUMENT, e.message)
+        rescue StandardError => e
+          raise GRPC::BadStatus.new(GRPC::Core::StatusCodes::INTERNAL, e.message)
+        end
+
+        # Update project with new values
+        def update_project(request, _unused_call)
+          updated_project = Project.new(
+            git_remote_url: request.project.git_remote_url,
+            name: request.project.name,
+            version: request.project.version,
+            project_type: request.project.project_type,
+            authors: request.project.authors,
+            description: request.project.description,
+            license_expression: request.project.license_expression,
+            dotnet_projects: request.project.dotnet_projects.to_a,
+            steps: request.project.steps.to_a
+          )
+
+          # Apply updates
+          request.updates.each do |key, value|
+            case key.to_sym
+            when :name
+              updated_project.name = value
+            when :version
+              updated_project.version = value
+            when :project_type
+              updated_project.project_type = value
+            when :authors
+              updated_project.authors = value
+            when :description
+              updated_project.description = value
+            when :license_expression
+              updated_project.license_expression = value
+            when :git_remote_url
+              updated_project.git_remote_url = value
+            end
+          end
+
+          updated_project
+        rescue StandardError => e
+          raise GRPC::BadStatus.new(GRPC::Core::StatusCodes::INTERNAL, e.message)
+        end
+
+        private
+
+        # Validate project model
+        def validate_project_model(project)
+          errors = validate_project_model_errors(project)
+          raise ArgumentError, errors.join(", ") if errors.any?
+          errors
+        end
+
+        # Validate project model and return errors without raising
+        def validate_project_model_errors(project)
+          errors = []
+
+          errors << "Project name cannot be empty" if project.name.nil? || project.name.strip.empty?
+          errors << "Project version cannot be empty" if project.version.nil? || project.version.strip.empty?
+          errors << "Project type cannot be empty" if project.project_type.nil? || project.project_type.strip.empty?
+
+          # Validate steps
+          project.steps.each_with_index do |step, index|
+            errors << "Step #{index} name cannot be empty" if step.name.nil? || step.name.strip.empty?
+            errors << "Step #{index} description cannot be empty" if step.description.nil? || step.description.strip.empty?
+            errors << "Step #{index} commands cannot be empty" if step.commands.nil? || step.commands.empty?
+          end
+
+          errors
+        end
+
+        # Convert JSON data to Project
+        def convert_from_json_data(data)
+          project = Project.new(
+            git_remote_url: data[:git_remote_url] || "",
+            name: data[:name] || "",
+            version: data[:version] || "",
+            project_type: data[:project_type] || "",
+            authors: data[:authors] || "authors",
+            description: data[:description] || "description",
+            license_expression: data[:license_expression] || "MIT",
+            dotnet_projects: data[:dotnet_projects] || []
+          )
+
+          # Convert steps
+          (data[:steps] || []).each do |step_data|
+            step = Step.new(
+              name: step_data[:name] || "",
+              description: step_data[:description] || "",
+              commands: step_data[:commands] || []
+            )
+            project.steps << step
+          end
+
+          project
+        end
+
+        # Convert Project to pretty JSON
+        def convert_to_json_pretty(project)
+          project_data = {
+            name: project.name,
+            version: project.version,
+            project_type: project.project_type,
+            authors: project.authors,
+            description: project.description,
+            license_expression: project.license_expression,
+            steps: project.steps.map do |step|
+              {
+                name: step.name,
+                description: step.description,
+                commands: step.commands.to_a
+              }
+            end
+          }
+
+          JSON.pretty_generate(project_data)
+        end
+
+        # Convert Protobuf Project to Ruby model for helper classes
+        def convert_to_ruby_model(proto_model)
+          # Create a simple Ruby object that mimics the Project interface
+          ruby_model = Object.new
+          
+          def ruby_model.name
+            @name
+          end
+          
+          def ruby_model.name=(value)
+            @name = value
+          end
+          
+          def ruby_model.version
+            @version
+          end
+          
+          def ruby_model.version=(value)
+            @version = value
+          end
+          
+          def ruby_model.project_type
+            @project_type
+          end
+          
+          def ruby_model.project_type=(value)
+            @project_type = value
+          end
+          
+          def ruby_model.steps
+            @steps ||= []
+          end
+          
+          def ruby_model.steps=(value)
+            @steps = value
+          end
+
+          ruby_model.name = proto_model.name
+          ruby_model.version = proto_model.version
+          ruby_model.project_type = proto_model.project_type
+          
+          # Convert steps
+          ruby_steps = proto_model.steps.map do |proto_step|
+            ruby_step = Object.new
+            
+            def ruby_step.name
+              @name
+            end
+            
+            def ruby_step.name=(value)
+              @name = value
+            end
+            
+            def ruby_step.description
+              @description
+            end
+            
+            def ruby_step.description=(value)
+              @description = value
+            end
+            
+            def ruby_step.commands
+              @commands ||= []
+            end
+            
+            def ruby_step.commands=(value)
+              @commands = value
+            end
+
+            ruby_step.name = proto_step.name
+            ruby_step.description = proto_step.description
+            ruby_step.commands = proto_step.commands.to_a
+            ruby_step
+          end
+          
+          ruby_model.steps = ruby_steps
+          ruby_model
+        end
+      end
+    end
+  end
+end

data/lib/makit/v1/git/git_repository_service_impl.rb

@@ -0,0 +1,295 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Makit
+  module V1
+    module Git
+      # Implementation of the GitRepositoryService gRPC service
+      class GitRepositoryServiceImpl < GitRepositoryService::Service
+        # Get current repository state
+        def get_repository_state(request, _unused_call)
+          # Get the current repository state using direct git commands
+          model = GitRepositoryModel.new
+          
+          # Basic repository checks
+          model.is_git_repo = Dir.exist?(".git")
+          model.is_ci = ENV["CI"] == "true"
+          model.is_detached = `git status`.include?("detached")
+          model.is_read_only = !model.is_git_repo || model.is_detached
+          model.is_clean = `git status --porcelain`.empty?
+          
+          # File information
+          model.unstaged_files.concat(`git status --porcelain`.split("\n"))
+          model.untracked_files.concat(`git ls-files --others --exclude-standard`.split("\n"))
+          model.tracked_file_infos.concat(get_file_infos_proto)
+          model.untracked_file_infos.concat(get_untracked_file_infos_proto)
+          
+          # Commit information
+          model.branch = `git branch --show-current`.strip
+          model.commit_sha = `git rev-parse HEAD`.strip
+          model.commit_message = `git log -1 --pretty=%B`.strip
+          model.commit_date = `git log -1 --pretty=%cd`.strip
+          model.commit_author = `git log -1 --pretty=%an`.strip
+          model.commit_email = `git log -1 --pretty=%ae`.strip
+          model.remote_url = `git remote get-url origin`.strip
+          
+          model
+        end
+
+        # Save repository state to file
+        def save_repository_state(request, _unused_call)
+          raise ArgumentError, "Model cannot be nil" if request.repository.nil?
+          raise ArgumentError, "Path cannot be empty" if request.path.nil? || request.path.strip.empty?
+          
+          # Convert protobuf model to JSON and save
+          json_data = convert_proto_to_json(request.repository)
+          File.write(request.path, JSON.pretty_generate(json_data))
+          
+          Google::Protobuf::Empty.new
+        end
+
+        # Load repository state from file
+        def load_repository_state(request, _unused_call)
+          raise ArgumentError, "File does not exist: #{request.path}" unless File.exist?(request.path)
+          
+          content = File.read(request.path)
+          json_data = JSON.parse(content, symbolize_names: true)
+          convert_json_to_proto(json_data)
+        end
+
+        # Validate repository state
+        def validate_repository_state(request, _unused_call)
+          errors = []
+          
+          if request.repository.nil?
+            errors << "Model cannot be nil"
+          else
+            # Basic validation
+            if request.repository.is_git_repo
+              errors << "Branch cannot be empty for git repository" if request.repository.branch.nil? || request.repository.branch.strip.empty?
+              errors << "Commit SHA cannot be empty for git repository" if request.repository.commit_sha.nil? || request.repository.commit_sha.strip.empty?
+            end
+          end
+          
+          ValidateRepositoryStateResponse.new(errors: errors)
+        end
+
+        # Merge two repository states
+        def merge_repository_states(request, _unused_call)
+          base = request.base_repository
+          override = request.override_repository
+          
+          merged = GitRepositoryModel.new
+          
+          # Use override values if present and not empty, otherwise use base values
+          merged.is_git_repo = override.is_git_repo || base.is_git_repo
+          merged.is_ci = override.is_ci || base.is_ci
+          merged.is_detached = override.is_detached || base.is_detached
+          merged.is_read_only = override.is_read_only || base.is_read_only
+          merged.is_clean = override.is_clean || base.is_clean
+          merged.unstaged_files.concat(override.unstaged_files.any? ? override.unstaged_files.to_a : base.unstaged_files.to_a)
+          merged.untracked_files.concat(override.untracked_files.any? ? override.untracked_files.to_a : base.untracked_files.to_a)
+          merged.tracked_file_infos.concat(override.tracked_file_infos.any? ? override.tracked_file_infos.to_a : base.tracked_file_infos.to_a)
+          merged.untracked_file_infos.concat(override.untracked_file_infos.any? ? override.untracked_file_infos.to_a : base.untracked_file_infos.to_a)
+          merged.branch = (override.branch && !override.branch.empty?) ? override.branch : base.branch
+          merged.commit_sha = (override.commit_sha && !override.commit_sha.empty?) ? override.commit_sha : base.commit_sha
+          merged.commit_message = (override.commit_message && !override.commit_message.empty?) ? override.commit_message : base.commit_message
+          merged.commit_date = (override.commit_date && !override.commit_date.empty?) ? override.commit_date : base.commit_date
+          merged.commit_author = (override.commit_author && !override.commit_author.empty?) ? override.commit_author : base.commit_author
+          merged.commit_email = (override.commit_email && !override.commit_email.empty?) ? override.commit_email : base.commit_email
+          merged.remote_url = (override.remote_url && !override.remote_url.empty?) ? override.remote_url : base.remote_url
+          
+          merged
+        end
+
+        # Create a new repository state
+        def create_repository_state(request, _unused_call)
+          model = GitRepositoryModel.new
+          
+          model.is_git_repo = request.is_git_repo
+          model.is_ci = request.is_ci
+          model.is_detached = request.is_detached
+          model.is_read_only = request.is_read_only
+          model.is_clean = request.is_clean
+          model.branch = request.branch
+          model.commit_sha = request.commit_sha
+          model.commit_message = request.commit_message
+          model.commit_date = request.commit_date
+          model.commit_author = request.commit_author
+          model.commit_email = request.commit_email
+          model.remote_url = request.remote_url
+          
+          model
+        end
+
+        # Update repository state
+        def update_repository_state(request, _unused_call)
+          raise ArgumentError, "Model cannot be nil" if request.repository.nil?
+          raise ArgumentError, "Updates cannot be nil" if request.updates.nil?
+          
+          model = GitRepositoryModel.new
+          model.is_git_repo = request.repository.is_git_repo
+          model.is_ci = request.repository.is_ci
+          model.is_detached = request.repository.is_detached
+          model.is_read_only = request.repository.is_read_only
+          model.is_clean = request.repository.is_clean
+          model.unstaged_files.concat(request.repository.unstaged_files.to_a)
+          model.untracked_files.concat(request.repository.untracked_files.to_a)
+          model.tracked_file_infos.concat(request.repository.tracked_file_infos.to_a)
+          model.untracked_file_infos.concat(request.repository.untracked_file_infos.to_a)
+          model.branch = request.repository.branch
+          model.commit_sha = request.repository.commit_sha
+          model.commit_message = request.repository.commit_message
+          model.commit_date = request.repository.commit_date
+          model.commit_author = request.repository.commit_author
+          model.commit_email = request.repository.commit_email
+          model.remote_url = request.repository.remote_url
+          
+          # Apply updates
+          request.updates.each do |key, value|
+            case key.to_sym
+            when :is_git_repo
+              model.is_git_repo = value == "true"
+            when :is_ci
+              model.is_ci = value == "true"
+            when :is_detached
+              model.is_detached = value == "true"
+            when :is_read_only
+              model.is_read_only = value == "true"
+            when :is_clean
+              model.is_clean = value == "true"
+            when :branch
+              model.branch = value
+            when :commit_sha
+              model.commit_sha = value
+            when :commit_message
+              model.commit_message = value
+            when :commit_date
+              model.commit_date = value
+            when :commit_author
+              model.commit_author = value
+            when :commit_email
+              model.commit_email = value
+            when :remote_url
+              model.remote_url = value
+            end
+          end
+          
+          model
+        end
+
+        private
+
+        # Get file information for tracked files
+        def get_file_infos_proto
+          file_infos = []
+          file_list = `git ls-files`.split("\n")
+          file_list.each do |file|
+            file_infos << convert_file_info_to_proto(file)
+          rescue StandardError
+            next
+          end
+          file_infos.sort_by { |info| info.mtime.seconds }.reverse!
+          file_infos
+        end
+
+        # Get file information for untracked files
+        def get_untracked_file_infos_proto
+          file_infos = []
+          file_list = `git ls-files --others --exclude-standard`.split("\n")
+          file_list.each do |file|
+            file_infos << convert_file_info_to_proto(file)
+          rescue StandardError
+            next
+          end
+          file_infos.sort_by { |info| info.mtime.seconds }.reverse!
+          file_infos
+        end
+
+        # Convert file path to protobuf FileInfo
+        def convert_file_info_to_proto(file_path)
+          timestamp = Google::Protobuf::Timestamp.new
+          mtime = File.mtime(file_path)
+          timestamp.seconds = mtime.to_i
+          timestamp.nanos = mtime.nsec
+          
+          FileInfo.new(
+            name: file_path,
+            mtime: timestamp,
+            size: File.size(file_path)
+          )
+        end
+
+        # Convert protobuf model to JSON hash
+        def convert_proto_to_json(proto_model)
+          {
+            is_git_repo: proto_model.is_git_repo,
+            is_ci: proto_model.is_ci,
+            is_detached: proto_model.is_detached,
+            is_read_only: proto_model.is_read_only,
+            is_clean: proto_model.is_clean,
+            unstaged_files: proto_model.unstaged_files.to_a,
+            untracked_files: proto_model.untracked_files.to_a,
+            tracked_file_infos: proto_model.tracked_file_infos.map { |info| convert_file_info_to_json(info) },
+            untracked_file_infos: proto_model.untracked_file_infos.map { |info| convert_file_info_to_json(info) },
+            branch: proto_model.branch,
+            commit_sha: proto_model.commit_sha,
+            commit_message: proto_model.commit_message,
+            commit_date: proto_model.commit_date,
+            commit_author: proto_model.commit_author,
+            commit_email: proto_model.commit_email,
+            remote_url: proto_model.remote_url
+          }
+        end
+
+        # Convert JSON hash to protobuf model
+        def convert_json_to_proto(json_data)
+          model = GitRepositoryModel.new
+          
+          model.is_git_repo = json_data[:is_git_repo] || false
+          model.is_ci = json_data[:is_ci] || false
+          model.is_detached = json_data[:is_detached] || false
+          model.is_read_only = json_data[:is_read_only] || false
+          model.is_clean = json_data[:is_clean] || false
+          model.unstaged_files.concat(json_data[:unstaged_files] || [])
+          model.untracked_files.concat(json_data[:untracked_files] || [])
+          model.tracked_file_infos.concat((json_data[:tracked_file_infos] || []).map { |info| convert_file_info_from_json(info) })
+          model.untracked_file_infos.concat((json_data[:untracked_file_infos] || []).map { |info| convert_file_info_from_json(info) })
+          model.branch = json_data[:branch] || ""
+          model.commit_sha = json_data[:commit_sha] || ""
+          model.commit_message = json_data[:commit_message] || ""
+          model.commit_date = json_data[:commit_date] || ""
+          model.commit_author = json_data[:commit_author] || ""
+          model.commit_email = json_data[:commit_email] || ""
+          model.remote_url = json_data[:remote_url] || ""
+          
+          model
+        end
+
+        # Convert protobuf FileInfo to JSON hash
+        def convert_file_info_to_json(proto_file_info)
+          {
+            name: proto_file_info.name,
+            mtime: Time.at(proto_file_info.mtime.seconds, proto_file_info.mtime.nanos, :nsec).to_s,
+            size: proto_file_info.size
+          }
+        end
+
+        # Convert JSON hash to protobuf FileInfo
+        def convert_file_info_from_json(json_file_info)
+          timestamp = Google::Protobuf::Timestamp.new
+          mtime = Time.parse(json_file_info[:mtime])
+          timestamp.seconds = mtime.to_i
+          timestamp.nanos = mtime.nsec
+          
+          FileInfo.new(
+            name: json_file_info[:name],
+            mtime: timestamp,
+            size: json_file_info[:size]
+          )
+        end
+      end
+    end
+  end
+end