makit 0.0.147 → 0.0.153

data/lib/makit/configuration/project.rb

@@ -2,25 +2,18 @@
 
 require "json"
 
-# Only load gRPC service implementation if generated files exist
-if File.exist?(File.join(__dir__, "..", "..", "generated", "makit", "v1", "configuration", "project_service_services_pb.rb"))
-  require_relative "../v1/configuration/project_service_impl"
-end
+# Load gRPC service implementation
+require_relative "../v1/configuration/project_service_impl"
 
 module Makit
   module Configuration
-    # Project configuration management - Phase 3: Routes calls to gRPC service
+    # Project configuration management - Refactored to use protobuf messages exclusively
     class Project
       attr_accessor :git_remote_url, :name, :version, :project_type, :steps, :authors, :description, :license_expression
       attr_accessor :dotnet_projects
 
       def initialize(name, version = nil, project_type = nil)
-        # Check if gRPC service is available
-        @grpc_available = defined?(Makit::V1::Configuration::ProjectServiceImpl)
-        
-        if @grpc_available
-          @grpc_service = Makit::V1::Configuration::ProjectServiceImpl.new
-        end
+        @grpc_service = Makit::V1::Configuration::ProjectServiceImpl.new
         
         # Support both keyword arguments and positional arguments for compatibility
         if name.is_a?(Hash)
@@ -35,236 +28,119 @@ module Makit
           @project_type = project_type
         end
         
-        if @grpc_available
-          # Create project via gRPC service (handle empty names)
-          if @name && !@name.strip.empty?
-            create_request = Makit::V1::Configuration::CreateProjectRequest.new(
-              name: @name,
-              version: @version || "0.0.0",
-              project_type: @project_type || "gem"
-            )
-            @proto_model = @grpc_service.create_project(create_request, nil)
-          else
-            # Create empty project directly (bypass gRPC validation for empty names)
-            @proto_model = Makit::V1::Configuration::Project.new(
-              name: @name || "",
-              version: @version || "0.0.0",
-              project_type: @project_type || "",
-              authors: "authors",
-              description: "description",
-              license_expression: "MIT",
-              steps: []
-            )
-          end
-          
-          # Initialize Ruby attributes for backward compatibility
-          @authors = @proto_model.authors
-          @description = @proto_model.description
-          @license_expression = @proto_model.license_expression
-          @steps = convert_steps_from_proto(@proto_model.steps)
-          @git_remote_url = @proto_model.git_remote_url
-          @dotnet_projects = @proto_model.dotnet_projects.to_a
+        # Create project via gRPC service (handle empty names)
+        if @name && !@name.strip.empty?
+          create_request = Makit::V1::Configuration::CreateProjectRequest.new(
+            name: @name,
+            version: @version || "0.0.0",
+            project_type: @project_type || "gem"
+          )
+          @proto_model = @grpc_service.create_project(create_request, nil)
         else
-          # Fallback implementation when gRPC is not available
-          @name = @name || ""
-          @version = @version || "0.0.0"
-          @project_type = @project_type || ""
-          @authors = "authors"
-          @description = "description"
-          @license_expression = "MIT"
-          @steps = []
-          @git_remote_url = ""
-          @dotnet_projects = []
+          # Create empty project directly (bypass gRPC validation for empty names)
+          @proto_model = Makit::V1::Configuration::Project.new(
+            name: @name || "",
+            version: @version || "0.0.0",
+            project_type: @project_type || "",
+            authors: "authors",
+            description: "description",
+            license_expression: "MIT",
+            steps: []
+          )
         end
+        
+        # Initialize Ruby attributes for backward compatibility
+        sync_attributes_from_proto
       end
 
       def add_step(step)
         raise ArgumentError, "Step must be a Makit::Configuration::Step instance" unless step.is_a?(Step)
 
-        if @grpc_available
-          # Add step to Protobuf model
-          proto_step = Makit::V1::Configuration::Step.new(
-            name: step.name,
-            description: step.description,
-            commands: step.commands
-          )
-          @proto_model.steps << proto_step
-        end
+        # Add step to Protobuf model
+        proto_step = Makit::V1::Configuration::Step.new(
+          name: step.name,
+          description: step.description,
+          commands: step.commands
+        )
+        @proto_model.steps << proto_step
         
         # Update Ruby attribute for backward compatibility
         @steps << step
       end
 
       def to_json(*args)
-        if @grpc_available
-          # Use gRPC service to convert to JSON
-          project_data = {
-            name: @proto_model.name,
-            version: @proto_model.version,
-            project_type: @proto_model.project_type,
-            authors: @proto_model.authors,
-            description: @proto_model.description,
-            license_expression: @proto_model.license_expression,
-            steps: @proto_model.steps.map do |step|
-              {
-                name: step.name,
-                description: step.description,
-                commands: step.commands.to_a
-              }
-            end
-          }
-        else
-          # Fallback implementation
-          project_data = {
-            name: @name,
-            version: @version,
-            project_type: @project_type,
-            authors: @authors,
-            description: @description,
-            license_expression: @license_expression,
-            steps: @steps.map do |step|
-              {
-                name: step.name,
-                description: step.description,
-                commands: step.commands
-              }
-            end
-          }
-        end
+        project_data = {
+          name: @proto_model.name,
+          version: @proto_model.version,
+          project_type: @proto_model.project_type,
+          authors: @proto_model.authors,
+          description: @proto_model.description,
+          license_expression: @proto_model.license_expression,
+          steps: @proto_model.steps.map do |step|
+            {
+              name: step.name,
+              description: step.description,
+              commands: step.commands.to_a
+            }
+          end
+        }
         project_data.to_json(*args)
       end
 
       def to_json_pretty
-        if @grpc_available
-          # Use gRPC service to convert to pretty JSON
-          project_data = {
-            name: @proto_model.name,
-            version: @proto_model.version,
-            project_type: @proto_model.project_type,
-            authors: @proto_model.authors,
-            description: @proto_model.description,
-            license_expression: @proto_model.license_expression,
-            steps: @proto_model.steps.map do |step|
-              {
-                name: step.name,
-                description: step.description,
-                commands: step.commands.to_a
-              }
-            end
-          }
-        else
-          # Fallback implementation
-          project_data = {
-            name: @name,
-            version: @version,
-            project_type: @project_type,
-            authors: @authors,
-            description: @description,
-            license_expression: @license_expression,
-            steps: @steps.map do |step|
-              {
-                name: step.name,
-                description: step.description,
-                commands: step.commands
-              }
-            end
-          }
-        end
+        project_data = {
+          name: @proto_model.name,
+          version: @proto_model.version,
+          project_type: @proto_model.project_type,
+          authors: @proto_model.authors,
+          description: @proto_model.description,
+          license_expression: @proto_model.license_expression,
+          steps: @proto_model.steps.map do |step|
+            {
+              name: step.name,
+              description: step.description,
+              commands: step.commands.to_a
+            }
+          end
+        }
         JSON.pretty_generate(project_data)
       end
 
       def self.from_json(path)
-        if defined?(Makit::V1::Configuration::ProjectServiceImpl)
-          # Use gRPC service to load from file
-          grpc_service = Makit::V1::Configuration::ProjectServiceImpl.new
-          request = Makit::V1::Configuration::LoadFromFileRequest.new(path: path)
-          proto_model = grpc_service.load_from_file(request, nil)
-          
-          # Convert Protobuf model to Ruby object
-          convert_from_proto_model(proto_model)
-        else
-          # Fallback implementation
-          content = File.read(path)
-          data = JSON.parse(content, symbolize_names: true)
-          new(data[:name], data[:version], data[:project_type]).tap do |project|
-            project.authors = data[:authors] || "authors"
-            project.description = data[:description] || "description"
-            project.license_expression = data[:license_expression] || "MIT"
-            project.git_remote_url = data[:git_remote_url] || ""
-            project.dotnet_projects = data[:dotnet_projects] || []
-            
-            # Load 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
-          end
-        end
+        # Use gRPC service to load from file
+        grpc_service = Makit::V1::Configuration::ProjectServiceImpl.new
+        request = Makit::V1::Configuration::LoadFromFileRequest.new(path: path)
+        proto_model = grpc_service.load_from_file(request, nil)
+        
+        # Convert Protobuf model to Ruby object
+        convert_from_proto_model(proto_model)
       end
 
       # Class method for deserializing from JSON string (used by serializer)
       def self.decode_json(json_string)
-        if defined?(Makit::V1::Configuration::ProjectServiceImpl)
-          # Use gRPC service to load from JSON string
-          grpc_service = Makit::V1::Configuration::ProjectServiceImpl.new
-          request = Makit::V1::Configuration::LoadFromJsonRequest.new(json_string: json_string)
-          proto_model = grpc_service.load_from_json(request, nil)
-          
-          # Convert Protobuf model to Ruby object
-          convert_from_proto_model(proto_model)
-        else
-          # Fallback implementation
-          data = JSON.parse(json_string, symbolize_names: true)
-          new(data[:name], data[:version], data[:project_type]).tap do |project|
-            project.authors = data[:authors] || "authors"
-            project.description = data[:description] || "description"
-            project.license_expression = data[:license_expression] || "MIT"
-            project.git_remote_url = data[:git_remote_url] || ""
-            project.dotnet_projects = data[:dotnet_projects] || []
-            
-            # Load 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
-          end
-        end
+        # Use gRPC service to load from JSON string
+        grpc_service = Makit::V1::Configuration::ProjectServiceImpl.new
+        request = Makit::V1::Configuration::LoadFromJsonRequest.new(json_string: json_string)
+        proto_model = grpc_service.load_from_json(request, nil)
+        
+        # Convert Protobuf model to Ruby object
+        convert_from_proto_model(proto_model)
       end
 
       def to_gitlab_ci(path)
-        if @grpc_available
-          # Use gRPC service to generate GitLab CI
-          request = Makit::V1::Configuration::GenerateGitlabCiRequest.new(
-            project: @proto_model,
-            path: path
-          )
-          @grpc_service.generate_gitlab_ci(request, nil)
-        else
-          # Fallback implementation - just create a basic GitLab CI file
-          require_relative "gitlab_helper"
-          Makit::Configuration::GitLabHelper.to_yaml(self, path)
-        end
+        # Use gRPC service to generate GitLab CI
+        request = Makit::V1::Configuration::GenerateGitlabCiRequest.new(
+          project: @proto_model,
+          path: path
+        )
+        @grpc_service.generate_gitlab_ci(request, nil)
       end
 
       def to_rakefile
-        if @grpc_available
-          # Use gRPC service to generate Rakefile
-          request = Makit::V1::Configuration::GenerateRakefileRequest.new(project: @proto_model)
-          response = @grpc_service.generate_rakefile(request, nil)
-          response.content
-        else
-          # Fallback implementation
-          require_relative "rakefile_helper"
-          Makit::Configuration::RakefileHelper.generate(self)
-        end
+        # Use gRPC service to generate Rakefile
+        request = Makit::V1::Configuration::GenerateRakefileRequest.new(project: @proto_model)
+        response = @grpc_service.generate_rakefile(request, nil)
+        response.content
       end
 
       # Save the project to a specific path as pretty JSON
@@ -274,17 +150,12 @@ module Makit
           raise ArgumentError, "Project name cannot be empty. Please set a valid project name before saving."
         end
 
-        if @grpc_available
-          # Use gRPC service to save to file
-          request = Makit::V1::Configuration::SaveToFileRequest.new(
-            project: @proto_model,
-            path: path
-          )
-          @grpc_service.save_to_file(request, nil)
-        else
-          # Fallback implementation
-          File.write(path, to_json_pretty)
-        end
+        # Use gRPC service to save to file
+        request = Makit::V1::Configuration::SaveToFileRequest.new(
+          project: @proto_model,
+          path: path
+        )
+        @grpc_service.save_to_file(request, nil)
       end
 
       def save
@@ -293,135 +164,109 @@ module Makit
           raise ArgumentError, "Project name cannot be empty. Please set a valid project name before saving."
         end
 
-        if @grpc_available
-          # Use gRPC service to save to default location
-          request = Makit::V1::Configuration::SaveToDefaultRequest.new(project: @proto_model)
-          @grpc_service.save_to_default(request, nil)
-        else
-          # Fallback implementation
-          File.write(".makit.json", to_json_pretty)
-        end
+        # Use gRPC service to save to default location
+        request = Makit::V1::Configuration::SaveToDefaultRequest.new(project: @proto_model)
+        @grpc_service.save_to_default(request, nil)
       end
 
       # Display the project configuration in YAML format
       def show
         require "yaml"
 
-        if @grpc_available
-          project_data = {
-            name: @proto_model.name,
-            version: @proto_model.version,
-            project_type: @proto_model.project_type,
-            git_remote_url: @proto_model.git_remote_url,
-            steps: @proto_model.steps.map do |step|
-              {
-                name: step.name,
-                description: step.description,
-                commands: step.commands.to_a
-              }
-            end
-          }
-        else
-          project_data = {
-            name: @name,
-            version: @version,
-            project_type: @project_type,
-            git_remote_url: @git_remote_url,
-            steps: @steps.map do |step|
-              {
-                name: step.name,
-                description: step.description,
-                commands: step.commands
-              }
-            end
-          }
-        end
+        project_data = {
+          name: @proto_model.name,
+          version: @proto_model.version,
+          project_type: @proto_model.project_type,
+          git_remote_url: @proto_model.git_remote_url,
+          steps: @proto_model.steps.map do |step|
+            {
+              name: step.name,
+              description: step.description,
+              commands: step.commands.to_a
+            }
+          end
+        }
 
         puts YAML.dump(project_data)
       end
 
       # Load a project from the default .makit.json file
       def self.default
-        if defined?(Makit::V1::Configuration::ProjectServiceImpl)
-          # Use gRPC service to load default project
-          grpc_service = Makit::V1::Configuration::ProjectServiceImpl.new
-          request = Google::Protobuf::Empty.new
-          proto_model = grpc_service.load_default(request, nil)
-          
-          # Convert Protobuf model to Ruby object
-          convert_from_proto_model(proto_model)
-        else
-          # Fallback implementation
-          if File.exist?(".makit.json")
-            from_json(".makit.json")
-          else
-            new("", "0.0.0", "")
-          end
-        end
+        # Use gRPC service to load default project
+        grpc_service = Makit::V1::Configuration::ProjectServiceImpl.new
+        request = Google::Protobuf::Empty.new
+        proto_model = grpc_service.load_default(request, nil)
+        
+        # Convert Protobuf model to Ruby object
+        convert_from_proto_model(proto_model)
       end
 
       # Update project attributes
       def name=(value)
         @name = value
-        update_proto_attribute(:name, value) if @grpc_available
+        update_proto_attribute(:name, value)
       end
 
       def version=(value)
         @version = value
-        update_proto_attribute(:version, value) if @grpc_available
+        update_proto_attribute(:version, value)
       end
 
       def project_type=(value)
         @project_type = value
-        update_proto_attribute(:project_type, value) if @grpc_available
+        update_proto_attribute(:project_type, value)
       end
 
       def authors=(value)
         @authors = value
-        update_proto_attribute(:authors, value) if @grpc_available
+        update_proto_attribute(:authors, value)
       end
 
       def description=(value)
         @description = value
-        update_proto_attribute(:description, value) if @grpc_available
+        update_proto_attribute(:description, value)
       end
 
       def license_expression=(value)
         @license_expression = value
-        update_proto_attribute(:license_expression, value) if @grpc_available
+        update_proto_attribute(:license_expression, value)
       end
 
       def git_remote_url=(value)
         @git_remote_url = value
-        update_proto_attribute(:git_remote_url, value) if @grpc_available
+        update_proto_attribute(:git_remote_url, value)
       end
 
       def dotnet_projects=(value)
         @dotnet_projects = value
-        @proto_model.dotnet_projects.replace(value || []) if @grpc_available
+        @proto_model.dotnet_projects.replace(value || [])
       end
 
       private
 
+      # Synchronize Ruby attributes from protobuf model
+      def sync_attributes_from_proto
+        @authors = @proto_model.authors
+        @description = @proto_model.description
+        @license_expression = @proto_model.license_expression
+        @steps = convert_steps_from_proto(@proto_model.steps)
+        @git_remote_url = @proto_model.git_remote_url
+        @dotnet_projects = @proto_model.dotnet_projects.to_a
+      end
+
       # Convert Protobuf model to Ruby Project object
       def self.convert_from_proto_model(proto_model)
         project = new(proto_model.name, proto_model.version, proto_model.project_type)
         
         # Update all attributes from Protobuf model
         project.instance_variable_set(:@proto_model, proto_model)
-        project.instance_variable_set(:@authors, proto_model.authors)
-        project.instance_variable_set(:@description, proto_model.description)
-        project.instance_variable_set(:@license_expression, proto_model.license_expression)
-        project.instance_variable_set(:@git_remote_url, proto_model.git_remote_url)
-        project.instance_variable_set(:@dotnet_projects, proto_model.dotnet_projects.to_a)
-        project.instance_variable_set(:@steps, project.send(:convert_steps_from_proto, proto_model.steps))
+        project.send(:sync_attributes_from_proto)
         
         project
       end
 
       # Convert Protobuf steps to Ruby Step objects
       def convert_steps_from_proto(proto_steps)
-        return [] unless @grpc_available
         proto_steps.map do |proto_step|
           Step.new(
             name: proto_step.name,
@@ -433,14 +278,15 @@ module Makit
 
       # Update a single attribute in the Protobuf model
       def update_proto_attribute(attribute, value)
-        return unless @grpc_available
         updates = { attribute.to_s => value }
         request = Makit::V1::Configuration::UpdateProjectRequest.new(
           project: @proto_model,
           updates: updates
         )
         @proto_model = @grpc_service.update_project(request, nil)
+        # Sync Ruby attributes after update
+        sync_attributes_from_proto
       end
     end
   end
-end
+end