ukiryu 0.1.0 → 0.1.1

data/lib/ukiryu/tools/class_generator.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Ukiryu
+  module Tools
+    # Class generation utilities for tool-specific classes
+    #
+    # This module handles the dynamic generation of Options, Action, and Response
+    # classes for each tool command, keeping the Base class focused on execution.
+    module ClassGenerator
+      # Generate an options class for a command
+      #
+      # @param tool_class [Class] the tool class
+      # @param command_name [Symbol] the command name
+      # @param command_def [Models::CommandDefinition] the command definition
+      # @return [Class] the generated options class
+      def self.generate_options_class(tool_class, command_name, command_def)
+        require_relative '../options/base'
+        require_relative '../options_builder'
+
+        # Capture tool class in closure
+        tool_class_ref = tool_class
+
+        # Create class name
+        class_name = "#{command_name.to_s.capitalize}Options"
+
+        # Define the class in the tool's namespace
+        options_class = Class.new(::Ukiryu::Options::Base) do
+          # Store command definition
+          @command_def = command_def
+          @command_name = command_name
+          @tool_class = tool_class_ref
+
+          # Class methods
+          singleton_class.send(:define_method, :command_def) do
+            @command_def
+          end
+
+          singleton_class.send(:define_method, :command_name) do
+            @command_name
+          end
+
+          singleton_class.send(:define_method, :tool_class) do
+            @tool_class
+          end
+        end
+
+        # Define accessors using the OptionsBuilder
+        Ukiryu::OptionsBuilder.define_accessors(options_class, command_def)
+        Ukiryu::OptionsBuilder.define_to_shell_method(options_class, command_def)
+        Ukiryu::OptionsBuilder.define_validation_method(options_class, command_def)
+
+        # Define extra_args accessor for manual option injection
+        options_class.send(:attr_accessor, :extra_args)
+
+        # Define set() method for batch assignment
+        options_class.send(:define_method, :set) do |params|
+          params.each do |key, value|
+            setter = "#{key}="
+            send(setter, value) if respond_to?(setter)
+          end
+          self
+        end
+
+        # Define run() method that executes on the associated tool
+        options_class.send(:define_method, :run) do
+          # Validate options before execution
+          validate!
+          tool_instance = tool_class_ref.new
+          tool_instance.execute(command_name, self)
+        end
+
+        # Const the class in the tool's namespace
+        tool_class_ref.const_set(class_name, options_class) unless tool_class_ref.const_defined?(class_name)
+
+        options_class
+      end
+
+      # Generate an action class for a command
+      #
+      # @param tool_class [Class] the tool class
+      # @param command_name [Symbol] the command name
+      # @param command_def [Models::CommandDefinition] the command definition
+      # @return [Class] the generated action class
+      def self.generate_action_class(tool_class, command_name, command_def)
+        require_relative '../action/base'
+
+        class_name = "#{command_name.to_s.capitalize}Action"
+
+        action_class = Class.new(::Ukiryu::Action::Base) do
+          @command_name = command_name
+          @command_def = command_def
+          @tool_class = tool_class
+
+          singleton_class.send(:define_method, :command_name) do
+            @command_name
+          end
+
+          singleton_class.send(:define_method, :command_def) do
+            @command_def
+          end
+
+          singleton_class.send(:define_method, :tool_class) do
+            @tool_class
+          end
+        end
+
+        tool_class.const_set(class_name, action_class) unless tool_class.const_defined?(class_name)
+        action_class
+      end
+
+      # Generate a response class for a command
+      #
+      # @param tool_class [Class] the tool class
+      # @param command_name [Symbol] the command name
+      # @param command_def [Models::CommandDefinition] the command definition
+      # @return [Class] the generated response class
+      def self.generate_response_class(tool_class, command_name, command_def)
+        require_relative '../response/base'
+
+        class_name = "#{command_name.to_s.capitalize}Response"
+
+        response_class = Class.new(::Ukiryu::Response::Base) do
+          @command_name = command_name
+          @command_def = command_def
+        end
+
+        tool_class.const_set(class_name, response_class) unless tool_class.const_defined?(class_name)
+        response_class
+      end
+    end
+  end
+end

data/lib/ukiryu/tools/executable_finder.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Ukiryu
+  module Tools
+    # Executable finder utilities for tool classes
+    #
+    # This module provides methods to find executables on the system
+    # using search paths and aliases from tool definitions.
+    module ExecutableFinder
+      # Find the executable for a tool
+      #
+      # @param tool_name [String] the tool name
+      # @param tool_definition [Models::ToolDefinition] the tool definition
+      # @return [String, nil] path to executable or nil
+      def self.find_executable(tool_name, tool_definition)
+        require_relative '../executable_locator'
+
+        platform = Ukiryu::Runtime.instance.platform
+
+        ExecutableLocator.find(
+          tool_name: tool_name,
+          aliases: tool_definition.aliases || [],
+          search_paths: tool_definition.search_paths,
+          platform: platform
+        )
+      end
+    end
+  end
+end

data/lib/ukiryu/tools/generator.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require_relative '../models/tool_definition'
+require_relative '../cache'
+
+module Ukiryu
+  module Tools
+    # Generator module for dynamically creating tool-specific classes
+    #
+    # This module is responsible for:
+    # - Loading tool definitions from YAML as lutaml-model models
+    # - Generating tool classes (e.g., Ukiryu::Tools::Imagemagick)
+    # - Caching generated classes with bounded LRU cache
+    # - Providing constant autoloading via const_missing
+    #
+    module Generator
+      class << self
+        # Get the generated classes cache (bounded LRU cache)
+        #
+        # @return [Cache] the generated classes cache
+        def generated_classes_cache
+          @generated_classes_cache ||= Cache.new(max_size: 50, ttl: 3600)
+        end
+
+        # Get or generate a tool class
+        #
+        # @param tool_name [Symbol, String] the tool name
+        # @return [Class] the tool class
+        def generate(tool_name)
+          tool_name = tool_name.to_sym
+          cached = generated_classes_cache[tool_name]
+          return cached if cached
+
+          # Load the tool definition as a lutaml-model
+          tool_definition = load_tool_definition(tool_name)
+          raise Ukiryu::ToolNotFoundError, "Tool not found: #{tool_name}" unless tool_definition
+
+          # Get the compatible platform profile
+          platform_profile = tool_definition.compatible_profile
+
+          # Generate the tool class
+          tool_class = generate_tool_class(tool_name, tool_definition, platform_profile)
+
+          generated_classes_cache[tool_name] = tool_class
+          tool_class
+        end
+
+        # Load a ToolDefinition model from the registry
+        #
+        # @param tool_name [Symbol] the tool name
+        # @return [Models::ToolDefinition, nil] the tool definition model
+        def load_tool_definition(tool_name)
+          require_relative '../registry'
+
+          # Load the YAML file content
+          yaml_content = Registry.load_tool_yaml(tool_name)
+          return nil unless yaml_content
+
+          # Use lutaml-model's from_yaml to parse
+          tool_definition = Models::ToolDefinition.from_yaml(yaml_content)
+
+          # Resolve profile inheritance (e.g., windows profiles inherit from unix)
+          tool_definition&.resolve_inheritance!
+
+          tool_definition
+        end
+
+        # Generate a tool class from a tool definition
+        #
+        # @param tool_name [Symbol] the tool name
+        # @param tool_definition [Models::ToolDefinition] the tool definition
+        # @param platform_profile [Models::PlatformProfile] the compatible platform profile
+        # @return [Class] the generated tool class
+        def generate_tool_class(tool_name, tool_definition, platform_profile)
+          Class.new(::Ukiryu::Tools::Base) do
+            @tool_name = tool_name
+            @tool_definition = tool_definition
+            @platform_profile = platform_profile
+
+            # Define class methods
+            singleton_class.send(:define_method, :tool_name) do
+              @tool_name
+            end
+
+            singleton_class.send(:define_method, :tool_definition) do
+              @tool_definition
+            end
+
+            singleton_class.send(:define_method, :platform_profile) do
+              @platform_profile
+            end
+          end
+        end
+
+        # Generate a tool class and const it in the Tools namespace
+        #
+        # @param tool_name [Symbol] the tool name
+        # @return [Class] the tool class
+        def generate_and_const_set(tool_name)
+          tool_class = generate(tool_name)
+          class_name = tool_name.to_s.capitalize
+
+          # Const the class in the Tools module
+          Ukiryu::Tools.const_set(class_name, tool_class) unless Ukiryu::Tools.const_defined?(class_name)
+
+          tool_class
+        end
+
+        # Clear the cache of generated classes
+        #
+        # Useful for testing or reloading profiles
+        def clear_cache
+          generated_classes_cache.clear
+        end
+
+        # Check if a tool class has been generated
+        #
+        # @param tool_name [Symbol] the tool name
+        # @return [Boolean] true if the class has been generated
+        def generated?(tool_name)
+          generated_classes_cache.key?(tool_name.to_sym)
+        end
+
+        # Get all generated tool classes
+        #
+        # @return [Hash] map of tool name to class
+        def all_generated
+          result = {}
+          generated_classes_cache.each_key do |key|
+            result[key] = generated_classes_cache[key]
+          end
+          result
+        end
+
+        # Get a list of all available tool names
+        #
+        # @return [Array<Symbol>] list of tool names
+        def available_tools
+          require_relative '../registry'
+
+          registry_path = Registry.default_registry_path
+          return [] unless registry_path
+
+          tools_dir = File.join(registry_path, 'tools')
+          return [] unless Dir.exist?(tools_dir)
+
+          Dir.entries(tools_dir)
+             .reject { |e| e.start_with?('.') }
+             .map(&:to_sym)
+        end
+      end
+    end
+  end
+end

data/lib/ukiryu/tools.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require_relative 'tools/base'
+require_relative 'tools/generator'
+
+module Ukiryu
+  # Tools namespace for tool-specific classes
+  #
+  # This namespace provides lazy-autoloaded tool classes.
+  # When you reference Ukiryu::Tools::Imagemagick, it automatically
+  # generates the class if it doesn't exist.
+  #
+  # Platform aliases are also supported - e.g., Ping resolves to PingBsd
+  # on macOS or PingGnu on Linux.
+  #
+  # @example
+  #   Ukiryu::Tools::Imagemagick.new.tap do |tool|
+  #     options = tool.options_for(:convert)
+  #     options.set(inputs: ["image.png"], resize: "50%")
+  #     options.run
+  #   end
+  #
+  # @example Platform alias
+  #   # Automatically uses PingBsd on macOS, PingGnu on Linux
+  #   Ukiryu::Tools::Ping.new.execute(:ping, host: 'localhost', count: 1)
+  module Tools
+    class << self
+      # Autoload tool classes via const_missing
+      #
+      # When you reference Ukiryu::Tools::Imagemagick, this method automatically
+      # generates the class if it doesn't exist.
+      #
+      # Platform aliases are resolved first - e.g., Ping resolves to PingBsd
+      # on macOS or PingGnu on Linux based on the current platform.
+      #
+      # @param name [String, Symbol] the constant name
+      # @return [Class] the generated tool class
+      def const_missing(name)
+        # Convert CamelCase constant name to snake_case tool name
+        # e.g., PingBsd -> ping_bsd, PingGnu -> ping_gnu, Ping -> ping
+        tool_name_str = name.to_s
+                            .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2') # Add underscore before caps that follow lowercase
+                            .gsub(/([a-z\d])([A-Z])/, '\1_\2') # Add underscore between lowercase and uppercase
+                            .downcase
+
+        tool_name = tool_name_str.to_sym
+
+        # First, check if it's a platform alias
+        # Look for tools that implement this alias for the current platform
+        platform_impl = find_platform_implementation(tool_name)
+        return Generator.generate_and_const_set(platform_impl) if platform_impl
+
+        # If not an alias, try to generate the tool directly
+        generated = Generator.generate_and_const_set(tool_name)
+        return generated if generated
+
+        # If nothing found, let the error propagate
+        nil
+      end
+
+      private
+
+      # Find a platform-specific implementation for a tool alias
+      #
+      # @param alias_name [Symbol] the alias to resolve
+      # @return [Symbol, nil] the platform-specific tool name
+      def find_platform_implementation(alias_name)
+        registry_path = Registry.default_registry_path
+        return nil unless registry_path && Dir.exist?(registry_path)
+
+        tools_dir = File.join(registry_path, 'tools')
+        return nil unless Dir.exist?(tools_dir)
+
+        current_platform = Platform.detect
+
+        # Search through all tool directories
+        Dir.entries(tools_dir).each do |tool_dir|
+          next if tool_dir.start_with?('.')
+
+          tool_path = File.join(tools_dir, tool_dir)
+          next unless File.directory?(tool_path)
+
+          # Look for YAML files in this directory
+          Dir.entries(tool_path).each do |yaml_file|
+            next unless yaml_file.end_with?('.yaml')
+
+            yaml_path = File.join(tool_path, yaml_file)
+            profile = YAML.load_file(yaml_path, symbolize_names: true)
+
+            # Check if this tool implements the alias and matches current platform
+            # Note: implements field is a string in YAML, convert to symbol for comparison
+            next unless profile[:implements]&.to_sym == alias_name
+
+            # Check platform compatibility
+            profiles = profile[:profiles] || []
+            compatible = profiles.any? do |p|
+              platforms = p[:platforms] || p[:platform]
+              platforms.nil? || platforms.map(&:to_sym).include?(current_platform)
+            end
+
+            return tool_dir.to_sym if compatible
+          end
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/ukiryu/type.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "uri"
-require "time"
+require 'uri'
+require 'time'
 
 module Ukiryu
   # Type validation and conversion
@@ -75,12 +75,10 @@ module Ukiryu
       # Validate file type
       def validate_file(value, options)
         value = value.to_s
-        raise ValidationError, "File path cannot be empty" if value.empty?
+        raise ValidationError, 'File path cannot be empty' if value.empty?
 
         # Check if file exists (only if require_existing is true)
-        if options[:require_existing] && !File.exist?(value)
-          raise ValidationError, "File not found: #{value}"
-        end
+        raise ValidationError, "File not found: #{value}" if options[:require_existing] && !File.exist?(value)
 
         value
       end
@@ -88,11 +86,9 @@ module Ukiryu
       # Validate string type
       def validate_string(value, options)
         value = value.to_s
-        raise ValidationError, "String cannot be empty" if value.empty? && !options[:allow_empty]
+        raise ValidationError, 'String cannot be empty' if value.empty? && !options[:allow_empty]
 
-        if options[:pattern] && !(value =~ options[:pattern])
-          raise ValidationError, "String does not match required pattern: #{options[:pattern]}"
-        end
+        raise ValidationError, "String does not match required pattern: #{options[:pattern]}" if options[:pattern] && value !~ options[:pattern]
 
         value
       end
@@ -109,17 +105,17 @@ module Ukiryu
 
         if options[:range]
           min, max = options[:range]
-          if integer < min || integer > max
-            raise ValidationError, "Integer #{integer} out of range [#{min}, #{max}]"
-          end
+          raise ValidationError, "Integer #{integer} out of range [#{min}, #{max}]" if integer < min || integer > max
         end
 
         if options[:min] && integer < options[:min]
-          raise ValidationError, "Integer #{integer} below minimum #{options[:min]}"
+          raise ValidationError,
+                "Integer #{integer} below minimum #{options[:min]}"
         end
 
         if options[:max] && integer > options[:max]
-          raise ValidationError, "Integer #{integer} above maximum #{options[:max]}"
+          raise ValidationError,
+                "Integer #{integer} above maximum #{options[:max]}"
         end
 
         integer
@@ -137,9 +133,7 @@ module Ukiryu
 
         if options[:range]
           min, max = options[:range]
-          if float < min || float > max
-            raise ValidationError, "Float #{float} out of range [#{min}, #{max}]"
-          end
+          raise ValidationError, "Float #{float} out of range [#{min}, #{max}]" if float < min || float > max
         end
 
         float
@@ -152,9 +146,7 @@ module Ukiryu
         if options[:values]
           # Convert values to symbols for comparison (handle both string and symbol values)
           valid_values = options[:values].map { |v| v.is_a?(String) ? v.to_sym : v }
-          unless valid_values.include?(value)
-            raise ValidationError, "Invalid symbol: #{value.inspect}. Valid values: #{options[:values].inspect}"
-          end
+          raise ValidationError, "Invalid symbol: #{value.inspect}. Valid values: #{options[:values].inspect}" unless valid_values.include?(value)
         end
 
         value
@@ -166,9 +158,9 @@ module Ukiryu
         case value
         when TrueClass, FalseClass
           value
-        when "true", "1", "yes", "on"
+        when 'true', '1', 'yes', 'on'
           true
-        when "false", "0", "no", "off", ""
+        when 'false', '0', 'no', 'off', ''
           false
         else
           raise ValidationError, "Invalid boolean: #{value.inspect}"
@@ -176,13 +168,14 @@ module Ukiryu
       end
 
       # Validate URI type
-      def validate_uri(value, options)
+      def validate_uri(value, _options)
         value = value.to_s
-        raise ValidationError, "URI cannot be empty" if value.empty?
+        raise ValidationError, 'URI cannot be empty' if value.empty?
 
         begin
           uri = URI.parse(value)
           raise ValidationError, "Invalid URI: #{value}" unless uri.is_a?(URI::Generic)
+
           uri.to_s
         rescue URI::InvalidURIError => e
           raise ValidationError, "Invalid URI: #{value} - #{e.message}"
@@ -190,7 +183,7 @@ module Ukiryu
       end
 
       # Validate datetime type
-      def validate_datetime(value, options)
+      def validate_datetime(value, _options)
         if value.is_a?(Time) || value.is_a?(DateTime)
           value
         else
@@ -204,14 +197,13 @@ module Ukiryu
 
       # Validate hash type
       def validate_hash(value, options)
-        unless value.is_a?(Hash)
-          raise ValidationError, "Hash expected, got #{value.class}: #{value.inspect}"
-        end
+        raise ValidationError, "Hash expected, got #{value.class}: #{value.inspect}" unless value.is_a?(Hash)
 
         if options[:keys]
           unknown_keys = value.keys - options[:keys]
           if unknown_keys.any?
-            raise ValidationError, "Unknown hash keys: #{unknown_keys.inspect}. Valid keys: #{options[:keys].inspect}"
+            raise ValidationError,
+                  "Unknown hash keys: #{unknown_keys.inspect}. Valid keys: #{options[:keys].inspect}"
           end
         end
 
@@ -222,30 +214,23 @@ module Ukiryu
       def validate_array(value, options)
         array = value.is_a?(Array) ? value : [value]
 
-        if options[:min] && array.size < options[:min]
-          raise ValidationError, "Array has #{array.size} elements, minimum is #{options[:min]}"
-        end
+        raise ValidationError, "Array has #{array.size} elements, minimum is #{options[:min]}" if options[:min] && array.size < options[:min]
 
-        if options[:max] && array.size > options[:max]
-          raise ValidationError, "Array has #{array.size} elements, maximum is #{options[:max]}"
-        end
+        raise ValidationError, "Array has #{array.size} elements, maximum is #{options[:max]}" if options[:max] && array.size > options[:max]
 
         if options[:size]
           if options[:size].is_a?(Integer)
             if array.size != options[:size]
-              raise ValidationError, "Array has #{array.size} elements, expected #{options[:size]}"
+              raise ValidationError,
+                    "Array has #{array.size} elements, expected #{options[:size]}"
             end
           elsif options[:size].is_a?(Array)
-            unless options[:size].include?(array.size)
-              raise ValidationError, "Array has #{array.size} elements, expected one of: #{options[:size].inspect}"
-            end
+            raise ValidationError, "Array has #{array.size} elements, expected one of: #{options[:size].inspect}" unless options[:size].include?(array.size)
           end
         end
 
         # Validate element type if specified
-        if options[:of]
-          array = array.map { |v| validate(v, options[:of], options) }
-        end
+        array = array.map { |v| validate(v, options[:of], options) } if options[:of]
 
         array
       end