ukiryu 0.1.0 → 0.1.1

data/lib/ukiryu/models/version_compatibility.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Ukiryu
+  # Version compatibility model
+  #
+  # Checks if an installed tool version is compatible with
+  # the version requirements specified in a tool profile.
+  class VersionCompatibility
+    attr_reader :installed_version, :required_version, :compatible, :reason
+
+    # Initialize version compatibility check
+    #
+    # @param installed_version [String] the installed tool version
+    # @param required_version [String] the version requirement (e.g., ">= 2.30")
+    # @param compatible [Boolean] whether the versions are compatible
+    # @param reason [String, nil] the reason for incompatibility
+    def initialize(installed_version:, required_version:, compatible:, reason: nil)
+      @installed_version = installed_version
+      @required_version = required_version
+      @compatible = compatible
+      @reason = reason
+    end
+
+    # Check if versions are compatible
+    #
+    # @return [Boolean] true if compatible
+    def compatible?
+      @compatible
+    end
+
+    # Check if versions are incompatible
+    #
+    # @return [Boolean] true if incompatible
+    def incompatible?
+      !@compatible
+    end
+
+    # Get a human-readable status message
+    #
+    # @return [String] the status message
+    def status_message
+      if @compatible
+        "Version #{@installed_version} is compatible with requirement #{@required_version}"
+      else
+        @reason || "Version #{@installed_version} is not compatible with requirement #{@required_version}"
+      end
+    end
+
+    # Check compatibility against a version requirement
+    #
+    # @param installed_version [String] the installed version
+    # @param requirement [String] the version requirement (e.g., ">= 2.30")
+    # @return [VersionCompatibility] the compatibility result
+    def self.check(installed_version, requirement)
+      return new(installed_version: installed_version, required_version: requirement, compatible: true, reason: nil) if !requirement || requirement.empty?
+
+      parser = RequirementParser.new(requirement)
+      compatible = parser.satisfied_by?(installed_version)
+
+      if compatible
+        new(installed_version: installed_version, required_version: requirement, compatible: true, reason: nil)
+      else
+        new(installed_version: installed_version, required_version: requirement, compatible: false,
+            reason: "Version #{installed_version} does not satisfy requirement: #{requirement}")
+      end
+    end
+
+    # Requirement parser for semantic versioning
+    class RequirementParser
+      # Parse a version requirement
+      #
+      # @param requirement [String] the requirement string (e.g., ">= 2.30, < 3.0")
+      def initialize(requirement)
+        @requirement = requirement
+        @constraints = parse_requirements
+      end
+
+      # Check if a version satisfies the requirements
+      #
+      # @param version [String] the version to check
+      # @return [Boolean] true if satisfied
+      def satisfied_by?(version)
+        return true if @constraints.empty?
+
+        @constraints.all? { |constraint| satisfied?(version, constraint) }
+      end
+
+      private
+
+      # Parse requirement string into constraint array
+      #
+      # @return [Array<Hash>] array of constraint hashes
+      def parse_requirements
+        @requirement.split(',').map(&:strip).map do |req|
+          if req =~ /^([><=!~]+)\s*(.+)/
+            { operator: Regexp.last_match(1), version: Regexp.last_match(2) }
+          else
+            # Default to equality
+            { operator: '==', version: req }
+          end
+        end
+      end
+
+      # Check if a version satisfies a single constraint
+      #
+      # @param version [String] the version to check
+      # @param constraint [Hash] the constraint hash
+      # @return [Boolean] true if satisfied
+      def satisfied?(version, constraint)
+        v = parse_version(version)
+        req_v = parse_version(constraint[:version])
+
+        case constraint[:operator]
+        when '>', '>='
+          compare_versions(v, req_v) > 0 || (constraint[:operator] == '>=' && v == req_v)
+        when '<', '<='
+          compare_versions(v, req_v) < 0 || (constraint[:operator] == '<=' && v == req_v)
+        when '==', '='
+          v == req_v
+        when '!='
+          v != req_v
+        when '~>'
+          # Optimistic operator (~> 2.5 means >= 2.5 and < 3.0)
+          compare_versions(v, req_v) >= 0 && (v[0] == req_v[0])
+        else
+          false
+        end
+      end
+
+      # Parse version string into array of integers
+      #
+      # @param version [String] the version string
+      # @return [Array<Integer>] the version components
+      def parse_version(version)
+        version.split('.').map(&:to_i)
+      end
+
+      # Compare two version arrays
+      #
+      # @param v1 [Array<Integer>] first version
+      # @param v2 [Array<Integer>] second version
+      # @return [Integer] -1, 0, or 1
+      def compare_versions(v1, v2)
+        max_length = [v1.length, v2.length].max
+        v1_padded = v1 + [0] * (max_length - v1.length)
+        v2_padded = v2 + [0] * (max_length - v2.length)
+
+        v1_padded <=> v2_padded
+      end
+    end
+  end
+end

data/lib/ukiryu/models/version_detection.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Ukiryu
+  module Models
+    # Version detection configuration
+    #
+    # @example
+    #   vd = VersionDetection.new(
+    #     command: '--version',
+    #     pattern: '(\d+\.\d+)',
+    #     modern_threshold: '7.0'
+    #   )
+    class VersionDetection < Lutaml::Model::Serializable
+      attribute :command, :string, collection: true, default: []
+      attribute :pattern, :string
+      attribute :modern_threshold, :string
+
+      yaml do
+        map_element 'command', to: :command
+        map_element 'pattern', to: :pattern
+        map_element 'modern_threshold', to: :modern_threshold
+      end
+
+      # Hash-like access for Base.detect_version compatibility
+      #
+      # @param key [Symbol, String] the attribute key
+      # @return [Object] the attribute value
+      def [](key)
+        key_sym = key.to_sym
+        # Return nil for unknown keys
+        return nil unless respond_to?(key_sym, true)
+
+        send(key_sym)
+      end
+    end
+  end
+end

data/lib/ukiryu/models.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'models/tool_metadata'
+require_relative 'models/tool_definition'
+require_relative 'models/platform_profile'
+require_relative 'models/command_definition'
+require_relative 'models/option_definition'
+require_relative 'models/flag_definition'
+require_relative 'models/argument_definition'
+require_relative 'models/version_detection'
+require_relative 'models/search_paths'
+require_relative 'models/execution_report'
+require_relative 'models/version_compatibility'
+require_relative 'models/exit_codes'
+require_relative 'models/components'
+
+module Ukiryu
+  module Models
+    # Models namespace for tool profile model classes
+    #
+    # These models use lutaml-model for proper YAML serialization/deserialization
+  end
+end

data/lib/ukiryu/options/base.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Ukiryu
+  module Options
+    # Abstract base class for all option classes
+    #
+    # This class provides common functionality for all dynamically generated
+    # option classes, including batch setting via .set() and execution via .run().
+    #
+    # @abstract
+    class Base
+      # Set multiple options at once
+      #
+      # This method allows batch assignment of options. Each key in the params
+      # hash should correspond to an attribute name.
+      #
+      # @param params [Hash] hash of option names to values
+      # @return [self] returns self for method chaining
+      #
+      # @example Batch setting options
+      #   options.set(inputs: ["image.png"], resize: "50%")
+      #   options.output = "output.jpg"
+      def set(params)
+        params.each do |key, value|
+          setter = "#{key}="
+          send(setter, value) if respond_to?(setter)
+        end
+        self
+      end
+
+      # Validate the options
+      #
+      # Performs comprehensive validation using constraint-based validation.
+      # This includes:
+      # - Type checking using TypeConstraint
+      # - Required argument checking using RequiredConstraint
+      # - Value constraints (min, max, range) using RangeConstraint
+      # - Enum value validation using EnumConstraint
+      # - Option dependencies using DependencyConstraint
+      #
+      # @return [Boolean] true if valid
+      # @raise [Ukiryu::ValidationError] if validation fails
+      def validate!
+        command_def = self.class.command_def
+        return true unless command_def
+
+        validator = Validation::Validator.new(self, command_def)
+        validator.validate!
+      end
+
+      # Check if options are valid without raising errors
+      #
+      # @return [Boolean] true if valid, false otherwise
+      def valid?
+        validate!
+        true
+      rescue Ukiryu::ValidationError
+        false
+      end
+
+      # Get validation errors without raising exceptions
+      #
+      # @return [Array<String>] list of error messages
+      def validation_errors
+        command_def = self.class.command_def
+        return [] unless command_def
+
+        validator = Validation::Validator.new(self, command_def)
+        validator.errors
+      end
+
+      # Convert options to shell command string
+      #
+      # @param shell_type [Symbol] the shell type (:bash, :zsh, :fish, :powershell, etc.)
+      # @return [String] the formatted shell command (without executable)
+      def to_shell(shell_type: :bash)
+        raise NotImplementedError, 'Subclasses must implement to_shell'
+      end
+
+      # Get the command definition
+      #
+      # @return [Hash, nil] the command definition from the profile
+      def command_def
+        self.class.command_def
+      end
+
+      # Get the command name
+      #
+      # @return [Symbol] the command name
+      def command_name
+        self.class.command_name
+      end
+    end
+  end
+end

data/lib/ukiryu/options_builder/formatter.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative '../shell'
+
+module Ukiryu
+  module OptionsBuilder
+    # Formatting utilities for options, flags, and arguments
+    #
+    # This module handles the conversion of option values into shell command
+    # arguments according to various format styles.
+    module Formatter
+      # Format an option according to its definition
+      #
+      # @param opt_def [OptionDefinition] the option definition
+      # @param value [Object] the value to format
+      # @param shell_instance [Shell::Base] the shell instance
+      # @return [String, Array<String>] the formatted option(s)
+      def self.format_option(opt_def, value, _shell_instance)
+        type = opt_def.type
+
+        # Handle boolean types - just return the CLI flag
+        if [:boolean, TrueClass, 'boolean'].include?(type)
+          return nil if value.nil? || value == false
+
+          return opt_def.cli || ''
+        end
+
+        cli = opt_def.cli || ''
+        format = opt_def.format || 'double_dash_equals'
+        format_sym = format.is_a?(String) ? format.to_sym : format
+
+        value_str = value.is_a?(Symbol) ? value.to_s : value.to_s
+
+        # Handle array values
+        if value.is_a?(Array) && opt_def.separator
+          joined = value.join(opt_def.separator)
+          return case format_sym
+                 when :double_dash_equals
+                   "#{cli}#{joined}"
+                 when :double_dash_space, :single_dash_space
+                   [cli, joined]
+                 else
+                   "#{cli}#{joined}"
+                 end
+        end
+
+        case format_sym
+        when :double_dash_equals
+          "#{cli}=#{value_str}"
+        when :double_dash_space, :single_dash_space
+          [cli, value_str]
+        when :single_dash_equals
+          "#{cli}=#{value_str}"
+        when :slash_colon
+          "#{cli}:#{value_str}"
+        when :slash_space
+          "#{cli} #{value_str}"
+        else
+          "#{cli}=#{value_str}"
+        end
+      end
+
+      # Format a flag according to its definition
+      #
+      # @param flag_def [FlagDefinition] the flag definition
+      # @param shell_instance [Shell::Base] the shell instance
+      # @return [String, nil] the formatted flag
+      def self.format_flag(flag_def, _shell_instance)
+        flag_def.cli || ''
+      end
+
+      # Format an argument value
+      #
+      # @param value [Object] the value to format
+      # @param arg_def [ArgumentDefinition] the argument definition
+      # @param shell_instance [Shell::Base] the shell instance
+      # @return [String] the formatted argument
+      def self.format_arg(value, arg_def, shell_instance)
+        if arg_def.type == :file
+          shell_instance.format_path(value.to_s)
+        else
+          value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/ukiryu/options_builder/validator.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../errors'
+
+module Ukiryu
+  module OptionsBuilder
+    # Validation utilities for options classes
+    #
+    # This module provides validation methods for dynamically generated
+    # options classes, ensuring required arguments are present.
+    module Validator
+      # Define validation method on an options class
+      #
+      # @param klass [Class] the class to define the method on
+      # @param command_def [CommandDefinition] the command definition
+      def self.define_validation_method(klass, command_def)
+        klass.define_method(:validate!) do
+          errors = []
+
+          # Check required arguments
+          (command_def.arguments || []).each do |arg_def|
+            attr_name = arg_def.name
+            value = instance_variable_get("@#{attr_name}")
+
+            # Check if required (no min specified or min > 0)
+            min = arg_def.min || (arg_def.variadic ? 1 : 1)
+            errors << "Missing required argument: #{attr_name}" if min.positive? && (value.nil? || (value.is_a?(Array) && value.empty?))
+          end
+
+          raise ValidationError, errors.join(', ') if errors.any?
+        end
+      end
+
+      # Validation error for options
+      #
+      class ValidationError < Error
+        def initialize(messages)
+          super("Validation failed: #{messages.join(', ')}")
+        end
+      end
+    end
+  end
+end