makit 0.0.164 → 0.0.166

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

@@ -1,371 +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
+# 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