ukiryu 0.1.0 → 0.1.1

data/lib/ukiryu/validation/constraints.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+module Ukiryu
+  module Validation
+    # Abstract base class for all constraints
+    #
+    # Constraints define validation rules that can be applied to values.
+    # Each constraint type encapsulates a specific validation logic.
+    #
+    # @abstract
+    class Constraint
+      # Validate a value against this constraint
+      #
+      # @param value [Object] the value to validate
+      # @param context [Hash] additional context for validation
+      # @return [void]
+      # @raise [ValidationError] if validation fails
+      def validate(value, context = {})
+        raise NotImplementedError, 'Subclasses must implement validate'
+      end
+
+      # Check if this constraint applies to the given context
+      #
+      # @param context [Hash] validation context
+      # @return [Boolean] true if constraint should be applied
+      def applies_to?(_context)
+        true
+      end
+    end
+
+    # Validates that a value is present (not nil or empty)
+    class RequiredConstraint < Constraint
+      # The name of the attribute being validated
+      attr_reader :attribute_name
+      # The minimum required cardinality
+      attr_reader :min
+
+      # @param attribute_name [String, Symbol] the attribute name
+      # @param min [Integer] minimum cardinality (default: 1)
+      def initialize(attribute_name, min: 1)
+        @attribute_name = attribute_name
+        @min = min
+      end
+
+      # @raise [ValidationError] if value is nil or empty when required
+      def validate(value, _context = {})
+        return if @min.zero?
+
+        is_empty = value.nil? || (value.respond_to?(:empty?) && value.empty?)
+        return unless is_empty
+
+        raise ValidationIssue.new(@attribute_name, :required,
+                                  "Attribute #{@attribute_name} is required but missing")
+      end
+    end
+
+    # Validates numeric or array length ranges
+    class RangeConstraint < Constraint
+      attr_reader :attribute_name, :min, :max
+
+      # @param attribute_name [String, Symbol] the attribute name
+      # @param min [Numeric] minimum value
+      # @param max [Numeric] maximum value
+      def initialize(attribute_name, min:, max:)
+        @attribute_name = attribute_name
+        @min = min
+        @max = max
+      end
+
+      # @raise [ValidationError] if value is outside range
+      def validate(value, _context = {})
+        return if value.nil?
+
+        check_value = value.is_a?(Array) ? value.size : value
+
+        return unless check_value < @min || check_value > @max
+
+        raise ValidationIssue.new(@attribute_name, :range,
+                                  "#{@attribute_name} must be between #{@min} and #{@max}, got #{check_value}")
+      end
+    end
+
+    # Validates that values match one of the allowed values
+    class EnumConstraint < Constraint
+      attr_reader :attribute_name, :allowed_values
+
+      # @param attribute_name [String, Symbol] the attribute name
+      # @param allowed_values [Array] the list of allowed values
+      def initialize(attribute_name, allowed_values:)
+        @attribute_name = attribute_name
+        @allowed_values = allowed_values
+      end
+
+      # @raise [ValidationError] if value is not in allowed values
+      def validate(value, _context = {})
+        return if value.nil?
+
+        if value.is_a?(Array)
+          invalid = value - @allowed_values
+          unless invalid.empty?
+            raise ValidationIssue.new(@attribute_name, :enum,
+                                      "#{@attribute_name} contains invalid values: #{invalid.join(', ')}. " \
+                                      "Valid values: #{@allowed_values.join(', ')}")
+          end
+        elsif !@allowed_values.include?(value)
+          raise ValidationIssue.new(@attribute_name, :enum,
+                                    "#{@attribute_name} must be one of #{@allowed_values.join(', ')}, got #{value}")
+        end
+      end
+    end
+
+    # Validates type constraints using the Type module
+    class TypeConstraint < Constraint
+      attr_reader :attribute_name, :type, :validation_options
+
+      # @param attribute_name [String, Symbol] the attribute name
+      # @param type [Symbol, Hash] the type definition
+      # @param validation_options [Hash] additional validation options
+      def initialize(attribute_name, type, validation_options: {})
+        @attribute_name = attribute_name
+        @type = type
+        @validation_options = validation_options
+      end
+
+      # @raise [ValidationError] if value doesn't match type
+      def validate(value, _context = {})
+        return if value.nil?
+
+        begin
+          Type.validate(value, @type, @validation_options)
+        rescue Ukiryu::ValidationError => e
+          raise ValidationIssue.new(@attribute_name, :type,
+                                    "#{@attribute_name}: #{e.message}")
+        end
+      end
+    end
+
+    # Validates cardinality constraints for variadic arguments
+    class CardinalityConstraint < Constraint
+      attr_reader :attribute_name, :min, :max
+
+      # @param attribute_name [String, Symbol] the attribute name
+      # @param min [Integer] minimum cardinality
+      # @param max [Integer, Float] maximum cardinality (Float::INFINITY for no limit)
+      def initialize(attribute_name, min:, max:)
+        @attribute_name = attribute_name
+        @min = min
+        @max = max
+      end
+
+      # @raise [ValidationError] if array size violates cardinality
+      def validate(value, _context = {})
+        return if value.nil? || !value.is_a?(Array)
+
+        return unless @max != Float::INFINITY && value.size > @max
+
+        raise ValidationIssue.new(@attribute_name, :cardinality,
+                                  "Too many values for #{@attribute_name}: got #{value.size}, max #{@max}")
+      end
+    end
+
+    # Validates that boolean flags are actually boolean
+    class BooleanFlagConstraint < Constraint
+      attr_reader :attribute_name
+
+      # @param attribute_name [String, Symbol] the attribute name
+      def initialize(attribute_name)
+        @attribute_name = attribute_name
+      end
+
+      # @raise [ValidationError] if flag is not boolean
+      def validate(value, _context = {})
+        return if value.nil?
+
+        return if [true, false].include?(value)
+
+        raise ValidationIssue.new(@attribute_name, :boolean,
+                                  "Flag #{@attribute_name} must be boolean, got #{value.class}: #{value}")
+      end
+    end
+
+    # Validates dependency constraints between options
+    class DependencyConstraint < Constraint
+      attr_reader :option_name, :requires, :conflicts, :implies
+
+      # @param option_name [String, Symbol] the option name
+      # @param requires [Array] options that must be present
+      # @param conflicts [Array] options that cannot be present
+      # @param implies [Hash] options that imply certain values
+      def initialize(option_name, requires: nil, conflicts: nil, implies: nil)
+        @option_name = option_name
+        @requires = requires
+        @conflicts = conflicts
+        @implies = implies
+      end
+
+      # @param value [Object] the value of the dependent option
+      # @param context [Hash] must contain :options_accessor to get other values
+      # @raise [ValidationError] if dependency constraints are violated
+      def validate(_value, context = {})
+        accessor = context[:options_accessor]
+        raise ArgumentError, 'Dependency validation requires :options_accessor' unless accessor
+
+        validate_requires(accessor)
+        validate_conflicts(accessor)
+        validate_implies(accessor)
+      end
+
+      private
+
+      def validate_requires(accessor)
+        return unless @requires
+
+        @requires.each do |required_opt|
+          required_value = accessor.call(required_opt)
+          if required_value.nil? || (required_value.is_a?(Array) && required_value.empty?)
+            raise ValidationIssue.new(@option_name, :dependency,
+                                      "Option #{@option_name} requires #{required_opt} to be set")
+          end
+        end
+      end
+
+      def validate_conflicts(accessor)
+        return unless @conflicts
+
+        @conflicts.each do |conflict_opt|
+          conflict_value = accessor.call(conflict_opt)
+          if conflict_value && !conflict_value.nil? && !(conflict_value.is_a?(Array) && conflict_value.empty?)
+            raise ValidationIssue.new(@option_name, :dependency,
+                                      "Option #{@option_name} conflicts with #{conflict_opt}")
+          end
+        end
+      end
+
+      def validate_implies(accessor)
+        return unless @implies
+
+        @implies.each do |implies_opt, implies_def|
+          current_value = accessor.call(implies_opt)
+          expected_value = implies_def[:value]
+          should_be_present = implies_def[:present]
+
+          if should_be_present && (current_value.nil? || (current_value.is_a?(Array) && current_value.empty?))
+            raise ValidationIssue.new(@option_name, :dependency,
+                                      "Option #{@option_name} implies #{implies_opt} should be set")
+          elsif !should_be_present && !current_value.nil?
+            raise ValidationIssue.new(@option_name, :dependency,
+                                      "Option #{@option_name} implies #{implies_opt} should not be set")
+          elsif expected_value && current_value != expected_value
+            raise ValidationIssue.new(@option_name, :dependency,
+                                      "Option #{@option_name} implies #{implies_opt} should be #{expected_value}, got #{current_value}")
+          end
+        end
+      end
+    end
+
+    # Validation issue represents a single validation problem
+    #
+    # This is a proper error object, not just a string.
+    class ValidationIssue < StandardError
+      # The attribute name that failed validation
+      attr_reader :attribute_name
+
+      # The type of validation that failed
+      attr_reader :validation_type
+
+      # Human-readable error message
+      attr_reader :message
+
+      # @param attribute_name [String, Symbol] the attribute that failed
+      # @param validation_type [Symbol] the type of validation
+      # @param message [String] human-readable error message
+      def initialize(attribute_name, validation_type, message)
+        @attribute_name = attribute_name
+        @validation_type = validation_type
+        @message = message
+        super(message)
+      end
+    end
+  end
+end

data/lib/ukiryu/validation/validator.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require_relative 'constraints'
+
+module Ukiryu
+  module Validation
+    # Validates option objects using constraint-based validation
+    #
+    # The Validator class applies a collection of constraints to an options
+    # object, ensuring all validation rules are satisfied before execution.
+    #
+    # This is a proper OOP validator that:
+    # - Uses constraint objects (not procedural code)
+    # - Returns validation result objects (not string arrays)
+    # - Provides clear separation of concerns
+    class Validator
+      # The options object being validated
+      attr_reader :options
+
+      # The command definition containing validation rules
+      attr_reader :command_def
+
+      # Collection of constraints to apply
+      attr_reader :constraints
+
+      # @param options [Object] the options object to validate
+      # @param command_def [Hash] the command definition
+      def initialize(options, command_def)
+        @options = options
+        @command_def = command_def
+        @constraints = []
+        build_constraints
+      end
+
+      # Perform validation
+      #
+      # @return [Boolean] true if validation passes
+      # @raise [ValidationError] if validation fails
+      def validate!
+        @constraints.each do |constraint|
+          constraint.validate(get_constraint_value(constraint), constraint_context)
+        end
+        true
+      rescue Validation::ValidationIssue => e
+        raise Ukiryu::ValidationError, e.message
+      end
+
+      # Check if validation would pass without raising errors
+      #
+      # @return [Boolean] true if valid, false otherwise
+      def valid?
+        validate!
+        true
+      rescue Ukiryu::ValidationError
+        false
+      end
+
+      # Get all validation errors
+      #
+      # @return [Array<String>] list of error messages
+      def errors
+        errors_list = []
+        @constraints.each do |constraint|
+          constraint.validate(get_constraint_value(constraint), constraint_context)
+        rescue Validation::ValidationIssue => e
+          errors_list << e.message
+        end
+        errors_list
+      end
+
+      private
+
+      # Build constraint objects from command definition
+      def build_constraints
+        build_argument_constraints
+        build_option_constraints(@command_def[:options])
+        build_option_constraints(@command_def[:post_options])
+        build_flag_constraints(@command_def[:flags])
+        build_dependency_constraints
+      end
+
+      # Build constraints for arguments
+      def build_argument_constraints
+        return unless @command_def[:arguments]
+
+        @command_def[:arguments].each do |arg_def|
+          attr_name = arg_def[:name]
+          min = arg_def[:min] || (arg_def[:variadic] ? 1 : 1)
+
+          # Required constraint
+          @constraints << RequiredConstraint.new(attr_name, min: min)
+
+          # Type constraint
+          @constraints << build_type_constraint(attr_name, arg_def) if arg_def[:type]
+
+          # Cardinality constraint for variadic arguments
+          next unless arg_def[:variadic] && arg_def[:max]
+
+          @constraints << CardinalityConstraint.new(attr_name,
+                                                    min: min,
+                                                    max: arg_def[:max])
+        end
+      end
+
+      # Build constraints for options
+      def build_option_constraints(options)
+        return unless options
+
+        options.each do |opt_def|
+          attr_name = opt_def[:name]
+
+          # Type constraint
+          @constraints << build_type_constraint(attr_name, opt_def) if opt_def[:type]
+
+          # Range constraint
+          if opt_def[:range]
+            min, max = opt_def[:range]
+            @constraints << RangeConstraint.new(attr_name, min: min, max: max)
+          end
+
+          # Enum constraint
+          @constraints << EnumConstraint.new(attr_name, allowed_values: opt_def[:values]) if opt_def[:values]
+        end
+      end
+
+      # Build constraints for flags
+      def build_flag_constraints(flags)
+        return unless flags
+
+        flags.each do |flag_def|
+          @constraints << BooleanFlagConstraint.new(flag_def[:name])
+        end
+      end
+
+      # Build dependency constraints
+      def build_dependency_constraints
+        dependencies = @command_def[:dependencies] || []
+        dependencies.each do |dep|
+          @constraints << DependencyConstraint.new(
+            dep[:option],
+            requires: dep[:requires],
+            conflicts: dep[:conflicts],
+            implies: dep[:implies]
+          )
+        end
+      end
+
+      # Build a type constraint from a definition
+      def build_type_constraint(attr_name, defn)
+        validation_opts = {}
+        validation_opts[:require_existing] = defn[:must_exist] if defn.key?(:must_exist)
+        validation_opts[:allow_empty] = defn[:allow_empty] if defn.key?(:allow_empty)
+        validation_opts[:pattern] = defn[:pattern] if defn[:pattern]
+        validation_opts[:range] = defn[:range] if defn[:range]
+        validation_opts[:min] = defn[:min] if defn[:min]
+        validation_opts[:max] = defn[:max] if defn[:max]
+        validation_opts[:values] = defn[:values] if defn[:values]
+
+        type = defn[:type]
+        validation_opts[:of] = type[:of] if type.is_a?(Hash) && type[:name] == :array && type[:of]
+        validation_opts[:keys] = type[:keys] if type.is_a?(Hash) && type[:name] == :hash && type[:keys]
+
+        TypeConstraint.new(attr_name, type, validation_options: validation_opts)
+      end
+
+      # Get the value for a constraint
+      #
+      # For attribute constraints, get the instance variable value.
+      # For dependency constraints, get the option's current value.
+      def get_constraint_value(constraint)
+        case constraint
+        when RequiredConstraint, TypeConstraint, RangeConstraint, EnumConstraint,
+             BooleanFlagConstraint, CardinalityConstraint
+          @options.instance_variable_get("@#{constraint.attribute_name}")
+        when DependencyConstraint
+          @options.instance_variable_get("@#{constraint.option_name}")
+        end
+      end
+
+      # Get context for constraint validation
+      def constraint_context
+        {
+          options_accessor: ->(attr_name) { @options.instance_variable_get("@#{attr_name}") }
+        }
+      end
+    end
+  end
+end

data/lib/ukiryu/validation.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'validation/constraints'
+require_relative 'validation/validator'
+
+module Ukiryu
+  # Validation module for constraint-based option validation
+  #
+  # This module provides an OOP approach to validation using:
+  # - Constraint objects (not procedural code)
+  # - Validator classes that apply constraints
+  # - Proper error objects (not just strings)
+  #
+  # @example Validating options
+  #   validator = Validation::Validator.new(options, command_def)
+  #   validator.validate!  # Raises ValidationError if invalid
+  #   validator.valid?     # Returns true/false
+  #   validator.errors     # Returns array of error messages
+  module Validation
+  end
+end

data/lib/ukiryu/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ukiryu
-  VERSION = "0.1.0"
+  VERSION = '0.1.1'
 end

data/lib/ukiryu/version_detector.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative 'executor'
+
+module Ukiryu
+  # Version detector for external CLI tools
+  #
+  # This module provides centralized version detection logic with:
+  # - Configurable version command patterns
+  # - Regex pattern matching for version strings
+  # - Proper shell handling for command execution
+  #
+  # @example Detecting version
+  #   version = VersionDetector.detect(
+  #     executable: '/usr/bin/ffmpeg',
+  #     command: '-version',
+  #     pattern: /version (\d+\.\d+)/,
+  #     shell: :bash
+  #   )
+  module VersionDetector
+    class << self
+      # Detect the version of an external tool
+      #
+      # @param executable [String] the executable path
+      # @param command [String, Array<String>] the version command (default: '--version')
+      # @param pattern [Regexp] the regex pattern to extract version
+      # @param shell [Symbol] the shell to use for execution
+      # @return [String, nil] the detected version or nil if not found
+      def detect(executable:, command: '--version', pattern: /(\d+\.\d+)/, shell: nil)
+        # Return nil if executable is not found
+        return nil if executable.nil? || executable.empty?
+
+        shell ||= Shell.detect
+
+        # Normalize command to array
+        command_args = command.is_a?(Array) ? command : [command]
+
+        result = Executor.execute(executable, command_args, shell: shell)
+
+        return nil unless result.success?
+
+        # Sanitize strings to handle invalid UTF-8 sequences
+        stdout = result.stdout.scrub
+        stderr = result.stderr.scrub
+
+        match = stdout.match(pattern) || stderr.match(pattern)
+        match[1] if match
+      end
+    end
+  end
+end

data/lib/ukiryu.rb

@@ -1,28 +1,43 @@
 # frozen_string_literal: true
 
-require_relative "ukiryu/version"
-require_relative "ukiryu/errors"
+require_relative 'ukiryu/version'
+require_relative 'ukiryu/errors'
 
 # Core modules
-require_relative "ukiryu/platform"
-require_relative "ukiryu/shell"
-require_relative "ukiryu/type"
-require_relative "ukiryu/executor"
-require_relative "ukiryu/registry"
-require_relative "ukiryu/tool"
-require_relative "ukiryu/schema_validator"
+require_relative 'ukiryu/platform'
+require_relative 'ukiryu/shell'
+require_relative 'ukiryu/runtime'
+require_relative 'ukiryu/execution_context'
+require_relative 'ukiryu/type'
+require_relative 'ukiryu/executor'
+require_relative 'ukiryu/registry'
+require_relative 'ukiryu/tool'
+require_relative 'ukiryu/options_builder'
+require_relative 'ukiryu/schema_validator'
+require_relative 'ukiryu/io'
+
+# Models - OOP representation of YAML profiles
+require_relative 'ukiryu/models'
+
+# New OOP modules
+require_relative 'ukiryu/tools'
+require_relative 'ukiryu/options/base'
+require_relative 'ukiryu/response/base'
+require_relative 'ukiryu/action/base'
+require_relative 'ukiryu/validation'
+
+# Extractors
+require_relative 'ukiryu/extractors/extractor'
 
 # CLI (optional, only load if thor is available)
 begin
-  require "thor"
-  require_relative "ukiryu/cli"
+  require 'thor'
+  require_relative 'ukiryu/cli'
 rescue LoadError
   # Thor not available, CLI will not be available
 end
 
 module Ukiryu
-  class Error < StandardError; end
-
   class << self
     # Configure global Ukiryu settings
     def configure
@@ -38,13 +53,14 @@ module Ukiryu
     def reset_configuration
       @configuration = nil
       Shell.reset
+      Runtime.instance.reset!
+      ExecutionContext.reset_current!
     end
   end
 
   # Configuration class for global settings
   class Configuration
-    attr_accessor :default_shell
-    attr_accessor :registry_path
+    attr_accessor :default_shell, :registry_path
 
     def initialize
       @default_shell = nil # Auto-detect by default