makit 0.0.112 → 0.0.128

data/lib/makit/services/validator.rb

@@ -1,112 +1,112 @@
-# frozen_string_literal: true
-
-module Makit
-  module Services
-    # Service class responsible for validating all input parameters
-    # Used by various Makit operations to ensure data integrity
-    class Validator
-      # Git-related validation constants
-      COMMIT_HASH_LENGTH = 40
-      COMMIT_LATEST = "latest"
-      MAX_PAGINATION_LIMIT = 1000
-      MAX_DIRECTORY_PATH_LENGTH = 255
-
-      class << self
-        # Validate directory parameter for initialization operations
-        #
-        # @param directory [String] the directory path to validate
-        # @raise [ArgumentError] if directory parameter is invalid
-        def validate_directory_parameter(directory)
-          raise ArgumentError, "directory parameter cannot be nil" if directory.nil?
-          raise ArgumentError, "directory parameter cannot be empty" if directory.to_s.strip.empty?
-          raise ArgumentError, "directory path contains invalid characters" if directory.to_s.include?("\0")
-          raise ArgumentError, "directory path is too long" if directory.to_s.length > MAX_DIRECTORY_PATH_LENGTH
-        end
-
-        # Validate URL parameter for git repository operations
-        #
-        # @param url [String] the repository URL to validate
-        # @raise [ArgumentError] if URL parameter is invalid
-        def validate_url_parameter(url)
-          raise ArgumentError, "URL parameter cannot be nil" if url.nil?
-          raise ArgumentError, "URL parameter cannot be empty" if url.to_s.strip.empty?
-
-          url_str = url.to_s.strip
-          # Basic URL format validation - accept git@, https://, http://, and simple names like "user/repo"
-          valid_patterns = [
-            %r{\Agit@[\w.-]+:[\w._/-]+\.git\z}, # SSH format: git@github.com:user/repo.git
-            %r{\Ahttps?://[\w.-]+/[\w._/-]+(\.git)?\z}, # HTTPS format: https://github.com/user/repo
-            %r{\A[\w.-]+/[\w._-]+\z}, # Simple format: user/repo
-          ]
-
-          return if valid_patterns.any? { |pattern| url_str.match?(pattern) }
-
-          raise ArgumentError, "Invalid URL format: #{url_str}"
-        end
-
-        # Validate commit parameter for git operations
-        #
-        # @param commit [String] the commit hash or "latest" to validate
-        # @raise [ArgumentError] if commit parameter is invalid
-        def validate_commit_parameter(commit)
-          raise ArgumentError, "commit parameter cannot be nil" if commit.nil?
-
-          commit_str = commit.to_s.strip
-          raise ArgumentError, "commit parameter cannot be empty" if commit_str.empty?
-
-          # Allow "latest" or valid commit hash formats
-          return if commit_str == COMMIT_LATEST
-          return if commit_str.match?(/\A[0-9a-f]{7,#{COMMIT_HASH_LENGTH}}\z/i)
-
-          raise ArgumentError, "Invalid commit format: #{commit_str}. Must be 'latest' or a valid git commit hash."
-        end
-
-        # Validate pagination parameters for log operations
-        #
-        # @param limit [Integer] maximum number of items to retrieve
-        # @param skip [Integer] number of items to skip
-        # @raise [ArgumentError] if pagination parameters are invalid
-        def validate_pagination_parameters(limit, skip)
-          unless limit.is_a?(Integer) && limit.positive?
-            raise ArgumentError,
-                  "limit parameter must be a positive integer"
-          end
-          raise ArgumentError, "skip parameter must be a non-negative integer" unless skip.is_a?(Integer) && skip >= 0
-          raise ArgumentError, "limit parameter is too large" if limit > MAX_PAGINATION_LIMIT
-        end
-
-        # Validate that a directory exists and is accessible
-        #
-        # @param directory [String] the directory path to check
-        # @param description [String] human-readable description for error messages
-        # @raise [Makit::DirectoryError] if directory doesn't exist or isn't accessible
-        def validate_directory_exists(directory, description = "directory")
-          return if Dir.exist?(directory)
-
-          raise Makit::DirectoryError, "#{description} does not exist: #{directory}"
-        end
-
-        # Validate boolean parameters
-        #
-        # @param value [Object] the value to check
-        # @param parameter_name [String] the parameter name for error messages
-        # @raise [ArgumentError] if value is not boolean
-        def validate_boolean_parameter(value, parameter_name)
-          return if [true, false].include?(value)
-
-          raise ArgumentError, "#{parameter_name} must be true or false, got #{value.class}"
-        end
-
-        # Validate string parameters that cannot be empty
-        #
-        # @param value [String] the string value to validate
-        # @param parameter_name [String] the parameter name for error messages
-        # @raise [ArgumentError] if string is nil or empty
-        def validate_required_string(value, parameter_name)
-          raise ArgumentError, "#{parameter_name} cannot be nil" if value.nil?
-          raise ArgumentError, "#{parameter_name} cannot be empty" if value.to_s.strip.empty?
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Makit
+  module Services
+    # Service class responsible for validating all input parameters
+    # Used by various Makit operations to ensure data integrity
+    class Validator
+      # Git-related validation constants
+      COMMIT_HASH_LENGTH = 40
+      COMMIT_LATEST = "latest"
+      MAX_PAGINATION_LIMIT = 1000
+      MAX_DIRECTORY_PATH_LENGTH = 255
+
+      class << self
+        # Validate directory parameter for initialization operations
+        #
+        # @param directory [String] the directory path to validate
+        # @raise [ArgumentError] if directory parameter is invalid
+        def validate_directory_parameter(directory)
+          raise ArgumentError, "directory parameter cannot be nil" if directory.nil?
+          raise ArgumentError, "directory parameter cannot be empty" if directory.to_s.strip.empty?
+          raise ArgumentError, "directory path contains invalid characters" if directory.to_s.include?("\0")
+          raise ArgumentError, "directory path is too long" if directory.to_s.length > MAX_DIRECTORY_PATH_LENGTH
+        end
+
+        # Validate URL parameter for git repository operations
+        #
+        # @param url [String] the repository URL to validate
+        # @raise [ArgumentError] if URL parameter is invalid
+        def validate_url_parameter(url)
+          raise ArgumentError, "URL parameter cannot be nil" if url.nil?
+          raise ArgumentError, "URL parameter cannot be empty" if url.to_s.strip.empty?
+
+          url_str = url.to_s.strip
+          # Basic URL format validation - accept git@, https://, http://, and simple names like "user/repo"
+          valid_patterns = [
+            %r{\Agit@[\w.-]+:[\w._/-]+\.git\z}, # SSH format: git@github.com:user/repo.git
+            %r{\Ahttps?://[\w.-]+/[\w._/-]+(\.git)?\z}, # HTTPS format: https://github.com/user/repo
+            %r{\A[\w.-]+/[\w._-]+\z}, # Simple format: user/repo
+          ]
+
+          return if valid_patterns.any? { |pattern| url_str.match?(pattern) }
+
+          raise ArgumentError, "Invalid URL format: #{url_str}"
+        end
+
+        # Validate commit parameter for git operations
+        #
+        # @param commit [String] the commit hash or "latest" to validate
+        # @raise [ArgumentError] if commit parameter is invalid
+        def validate_commit_parameter(commit)
+          raise ArgumentError, "commit parameter cannot be nil" if commit.nil?
+
+          commit_str = commit.to_s.strip
+          raise ArgumentError, "commit parameter cannot be empty" if commit_str.empty?
+
+          # Allow "latest" or valid commit hash formats
+          return if commit_str == COMMIT_LATEST
+          return if commit_str.match?(/\A[0-9a-f]{7,#{COMMIT_HASH_LENGTH}}\z/i)
+
+          raise ArgumentError, "Invalid commit format: #{commit_str}. Must be 'latest' or a valid git commit hash."
+        end
+
+        # Validate pagination parameters for log operations
+        #
+        # @param limit [Integer] maximum number of items to retrieve
+        # @param skip [Integer] number of items to skip
+        # @raise [ArgumentError] if pagination parameters are invalid
+        def validate_pagination_parameters(limit, skip)
+          unless limit.is_a?(Integer) && limit.positive?
+            raise ArgumentError,
+                  "limit parameter must be a positive integer"
+          end
+          raise ArgumentError, "skip parameter must be a non-negative integer" unless skip.is_a?(Integer) && skip >= 0
+          raise ArgumentError, "limit parameter is too large" if limit > MAX_PAGINATION_LIMIT
+        end
+
+        # Validate that a directory exists and is accessible
+        #
+        # @param directory [String] the directory path to check
+        # @param description [String] human-readable description for error messages
+        # @raise [Makit::DirectoryError] if directory doesn't exist or isn't accessible
+        def validate_directory_exists(directory, description = "directory")
+          return if Dir.exist?(directory)
+
+          raise Makit::DirectoryError, "#{description} does not exist: #{directory}"
+        end
+
+        # Validate boolean parameters
+        #
+        # @param value [Object] the value to check
+        # @param parameter_name [String] the parameter name for error messages
+        # @raise [ArgumentError] if value is not boolean
+        def validate_boolean_parameter(value, parameter_name)
+          return if [true, false].include?(value)
+
+          raise ArgumentError, "#{parameter_name} must be true or false, got #{value.class}"
+        end
+
+        # Validate string parameters that cannot be empty
+        #
+        # @param value [String] the string value to validate
+        # @param parameter_name [String] the parameter name for error messages
+        # @raise [ArgumentError] if string is nil or empty
+        def validate_required_string(value, parameter_name)
+          raise ArgumentError, "#{parameter_name} cannot be nil" if value.nil?
+          raise ArgumentError, "#{parameter_name} cannot be empty" if value.to_s.strip.empty?
+        end
+      end
+    end
+  end
+end

data/lib/makit/setup/classlib.rb

@@ -1,53 +1,94 @@
-# frozen_string_literal: true
-require_relative "../configuration/project"
-
-module Makit
-  module Setup
-    class ClassLib
-      def self.run
-        #puts "Setting up Nuget project..."
-        project = Makit::Configuration::Project.default
-        Makit::DotNet::Project.new_project("classlib", project.name, "source/#{project.name}", "--framework net8.0")
-        Makit::DotNet::Project.new_project("TUnit", "#{project.name}.Tests", "tests/#{project.name}")
-        Makit::DotNet::Project.add_reference("tests/#{project.name}/#{project.name}.Tests.csproj", "source/#{project.name}/#{project.name}.csproj")
-        update_build_step(project)
-        update_test_step(project)
-
-        project.save
-        Makit::Logging.default_logger.info("Project setup completed")
-      end
-
-      def self.update_build_step(project)
-        build_commands = Array.new
-        build_commands << "dotnet build source/#{project.name}/#{project.name}.csproj --configuration Release"
-        steps = project.steps
-        if steps.any? { |step| step.name == "build" }
-          build_step = steps.find { |step| step.name == "build" }
-          build_step.commands = build_commands
-        else
-          build_step = Makit::Configuration::Step.new(name: "build", description: "Build the project artifacts", commands: build_commands)
-          build_step.commands = build_commands
-          project.add_step(build_step)
-        end
-        build_step.commands = build_commands
-
-        project.save
-      end
-
-      def self.update_test_step(project)
-        test_commands = Array.new
-        test_commands << "dotnet test tests/#{project.name}/#{project.name}.Tests.csproj"
-        steps = project.steps
-        if steps.any? { |step| step.name == "test" }
-          test_step = steps.find { |step| step.name == "test" }
-          test_step.commands = test_commands
-        else
-          test_step = Makit::Configuration::Step.new(name: "test", description: "Run the project tests", commands: test_commands)
-          test_step.commands = test_commands
-          project.add_step(test_step)
-        end
-        project.save
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require_relative "../configuration/project"
+
+module Makit
+  module Setup
+    class ClassLib
+      def self.run
+        # puts "Setting up Nuget project..."
+        project = Makit::Configuration::Project.default
+
+        project_filename = "source/#{project.name}/#{project.name}.csproj"
+        if (!File.exist?(project_filename))
+          Makit::DotNet::Project.new_project("classlib", project.name, "source/#{project.name}", "--framework net8.0")
+          dotnet_project = Makit::DotNet::Project.new("source/#{project.name}/#{project.name}.csproj")
+          # set the version to project.version
+          dotnet_project.set_version(project.version)
+          # set the frameworks = ["net8.0","net8.0-browser"]
+          dotnet_project.set_target_frameworks(["net8.0", "net8.0-browser"])
+          # set the nuget metadata
+          dotnet_project.set_nuget_metadata(project.name, project.authors, project.description,
+                                            project.license_expression)
+        end
+
+        test_project_filename = "tests/#{project.name}/#{project.name}.Tests.csproj"
+        if (File.exist?(test_project_filename))
+          Makit::DotNet::Project.new_project("TUnit", "#{project.name}.Tests", "tests/#{project.name}")
+          dotnet_project = Makit::DotNet::Project.new("tests/#{project.name}/#{project.name}.Tests.csproj")
+          # set the version to project.version
+          dotnet_project.set_version(project.version)
+          # set the frameworks = ["net8.0","net8.0-browser"]
+          dotnet_project.set_target_frameworks(["net8.0"])
+          # set the nuget metadata
+          dotnet_project.set_nuget_metadata("#{project.name}.Tests", project.authors, project.description,
+                                            project.license_expression)
+          Makit::DotNet::Project.add_reference("tests/#{project.name}/#{project.name}.Tests.csproj",
+                                               "source/#{project.name}/#{project.name}.csproj")
+        end
+        update_build_step(project)
+        update_test_step(project)
+
+        project.save
+
+        # Setup the sln, then slnx
+        if (!File.exist?("#{project.name}.slnx"))
+          Makit::DotNet.new_solution(project.name)
+          Makit::DotNet.sln_add_projects(project.name)
+          # migrate the sln to slnx
+          "dotnet sln migrate #{project.name}.sln".run
+          FileUtils.rm_f("#{project.name}.sln") if File.exist?("#{project.name}.slnx")
+        end
+        Makit::Logging.default_logger.debug("Project setup completed")
+      end
+
+      def self.update_build_step(project)
+        build_commands = []
+        build_commands << "dotnet restore #{project.name}.slnx" if File.exist?("#{project.name}.slnx")
+        build_commands << "dotnet build source/#{project.name}/#{project.name}.csproj --configuration Release"
+        build_commands << "dotnet build tests/#{project.name}/#{project.name}.Tests.csproj --configuration Release"
+        build_commands << "dotnet pack source/#{project.name}/#{project.name}.csproj --configuration Release --output artifacts/Packages"
+        build_commands << "dotnet pack tests/#{project.name}/#{project.name}.Tests.csproj --configuration Release --output artifacts/Packages"
+        steps = project.steps
+        if steps.any? { |step| step.name == "build" }
+          build_step = steps.find { |step| step.name == "build" }
+          build_step.commands = build_commands
+        else
+          build_step = Makit::Configuration::Step.new(name: "build", description: "Build the project artifacts",
+                                                      commands: build_commands)
+          build_step.commands = build_commands
+          project.add_step(build_step)
+        end
+        build_step.commands = build_commands
+
+        project.save
+      end
+
+      def self.update_test_step(project)
+        test_commands = []
+        test_commands << "dotnet test tests/#{project.name}/#{project.name}.Tests.csproj"
+        steps = project.steps
+        if steps.any? { |step| step.name == "test" }
+          test_step = steps.find { |step| step.name == "test" }
+          test_step.commands = test_commands
+        else
+          test_step = Makit::Configuration::Step.new(name: "test", description: "Run the project tests",
+                                                     commands: test_commands)
+          test_step.commands = test_commands
+          project.add_step(test_step)
+        end
+        project.save
+      end
+    end
+  end
+end