ukiryu 0.1.0 → 0.1.1

data/lib/ukiryu/runtime.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+require_relative 'platform'
+require_relative 'shell'
+require_relative 'config'
+
+module Ukiryu
+  # Runtime singleton for centralized platform and shell detection.
+  #
+  # This class provides a single source of truth for platform and shell
+  # detection across the entire application, eliminating redundant detection
+  # calls and ensuring consistency.
+  #
+  # @example
+  #   platform = Ukiryu::Runtime.instance.platform
+  #   shell = Ukiryu::Runtime.instance.shell
+  class Runtime
+    include Singleton
+
+    # Initialize the runtime with cached values
+    def initialize
+      @platform = nil
+      @shell = nil
+      @platform_cached = false
+      @shell_cached = false
+      @locked = false
+    end
+
+    # Get the current platform (cached)
+    #
+    # @return [Symbol] the detected platform (:macos, :linux, :windows)
+    def platform
+      return @platform if @platform_cached
+
+      @platform = Platform.detect
+      @platform_cached = true
+      @platform
+    end
+
+    # Get the current shell (cached)
+    #
+    # Priority:
+    # 1. Explicitly set shell (via shell=)
+    # 2. Config.shell (from --shell CLI option, UKIRYU_SHELL env, or programmatic config)
+    # 3. Auto-detected shell
+    #
+    # @return [Symbol] the detected shell
+    def shell
+      return @shell if @shell_cached
+
+      # Check for explicit override
+      override = shell_override
+      if override
+        @shell = override
+        @shell_cached = true
+        return @shell
+      end
+
+      # Auto-detect
+      @shell = Shell.detect
+      @shell_cached = true
+      @shell
+    end
+
+    # Manually set the platform (for testing)
+    #
+    # @param value [Symbol] the platform to set
+    def platform=(value)
+      raise 'Runtime is locked' if @locked
+
+      @platform = value&.to_sym
+      @platform_cached = true
+    end
+
+    # Manually set the shell (for testing)
+    #
+    # @param value [Symbol] the shell to set
+    def shell=(value)
+      raise 'Runtime is locked' if @locked
+
+      @shell = value&.to_sym
+      @shell_cached = true
+    end
+
+    # Lock the runtime to prevent further changes
+    #
+    # This should be called after initial configuration is complete.
+    def lock!
+      @locked = true
+    end
+
+    # Reset the runtime cache (for testing)
+    #
+    # @api private
+    def reset!
+      @platform = nil
+      @shell = nil
+      @platform_cached = false
+      @shell_cached = false
+      @locked = false
+    end
+
+    # Get the platform class for the current platform
+    #
+    # @return [Class] the platform class
+    def platform_class
+      Platform.class_for(platform)
+    end
+
+    # Get the shell class for the current shell
+    #
+    # @return [Class] the shell class
+    def shell_class
+      Shell.class_for(shell)
+    end
+
+    # Check if running on a specific platform
+    #
+    # @param plat [Symbol] the platform to check
+    # @return [Boolean] true if running on the specified platform
+    def on_platform?(plat)
+      platform == plat.to_sym
+    end
+
+    # Check if using a specific shell
+    #
+    # @param sh [Symbol] the shell to check
+    # @return [Boolean] true if using the specified shell
+    def using_shell?(sh)
+      shell == sh.to_sym
+    end
+
+    # Check if running on Windows
+    #
+    # @return [Boolean] true if on Windows
+    def windows?
+      on_platform?(:windows)
+    end
+
+    # Check if running on macOS
+    #
+    # @return [Boolean] true if on macOS
+    def macos?
+      on_platform?(:macos)
+    end
+
+    # Check if running on Linux
+    #
+    # @return [Boolean] true if on Linux
+    def linux?
+      on_platform?(:linux)
+    end
+
+    # Check if using a Unix-like shell
+    #
+    # @return [Boolean] true if using bash, zsh, fish, or sh
+    def unix_shell?
+      %i[bash zsh fish sh].include?(shell)
+    end
+
+    # Check if using a Windows shell
+    #
+    # @return [Boolean] true if using powershell or cmd
+    def windows_shell?
+      %i[powershell cmd].include?(shell)
+    end
+
+    private
+
+    # Get shell override from Config
+    #
+    # @return [Symbol, nil] the shell override or nil
+    def shell_override
+      Config.shell
+    end
+  end
+end

data/lib/ukiryu/schema_validator.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require "json"
+require 'json'
 begin
-  require "json-schema"
+  require 'json-schema'
 rescue LoadError
   # json-schema is optional - only needed for schema validation
 end
-require "yaml"
+require 'yaml'
 
 module Ukiryu
   # Schema validator for YAML tool profiles
@@ -23,15 +23,13 @@ module Ukiryu
       # @return [Array<String>] list of validation errors (empty if valid)
       def validate_profile(profile, options = {})
         # Check if json-schema gem is available
-        unless defined?(JSON::Validator)
-          return ["json-schema gem not installed. Add 'json-schema' to Gemfile for schema validation."]
-        end
+        return ["json-schema gem not installed. Add 'json-schema' to Gemfile for schema validation."] unless defined?(JSON::Validator)
 
         errors = []
 
         # Load the schema
         schema = load_schema(options[:schema_path])
-        return ["Failed to load schema"] unless schema
+        return ['Failed to load schema'] unless schema
 
         # Validate against JSON schema
         begin
@@ -71,9 +69,9 @@ module Ukiryu
       def default_schema_path
         # Schema is in the sibling 'schema' directory at the same level as the gem
         # From lib/ukiryu/, we go up to gem root, then to sibling schema/
-        gem_root = File.expand_path("../..", __dir__) # ukiryu gem root
-        schema_dir = File.expand_path("../schema", gem_root) # src/ukiryu/schema/
-        schema_file = File.join(schema_dir, "tool-profile.schema.yaml")
+        gem_root = File.expand_path('../..', __dir__) # ukiryu gem root
+        schema_dir = File.expand_path('../schema', gem_root) # src/ukiryu/schema/
+        schema_file = File.join(schema_dir, 'tool-profile.schema.yaml')
         return schema_file if File.exist?(schema_file)
 
         nil

data/lib/ukiryu/shell/bash.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "base"
+require_relative 'base'
 
 module Ukiryu
   module Shell
@@ -46,14 +46,14 @@ module Ukiryu
       # @param args [Array<String>] the arguments
       # @return [String] the complete command line
       def join(executable, *args)
-        [executable, *args.map { |a| quote(a) }].join(" ")
+        [executable, *args.map { |a| quote(a) }].join(' ')
       end
 
       # Get headless environment (disable DISPLAY on Unix)
       #
       # @return [Hash] environment variables for headless operation
       def headless_environment
-        { "DISPLAY" => "" }
+        { 'DISPLAY' => '' }
       end
     end
   end

data/lib/ukiryu/shell/cmd.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "base"
+require_relative 'base'
 
 module Ukiryu
   module Shell
@@ -19,7 +19,7 @@ module Ukiryu
       # @param string [String] the string to escape
       # @return [String] the escaped string
       def escape(string)
-        string.to_s.gsub(/[%^<>&|]/) { "^$&" }
+        string.to_s.gsub(/[%^<>&|]/) { '^$&' }
       end
 
       # Quote an argument for cmd.exe
@@ -44,7 +44,7 @@ module Ukiryu
       # @param path [String] the file path
       # @return [String] the formatted path
       def format_path(path)
-        path.to_s.gsub("/", "\\")
+        path.to_s.gsub('/', '\\')
       end
 
       # Format an environment variable reference
@@ -61,7 +61,7 @@ module Ukiryu
       # @param args [Array<String>] the arguments
       # @return [String] the complete command line
       def join(executable, *args)
-        [executable, *args.map { |a| quote(a) }].join(" ")
+        [executable, *args.map { |a| quote(a) }].join(' ')
       end
 
       # cmd.exe doesn't need DISPLAY variable

data/lib/ukiryu/shell/fish.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "bash"
+require_relative 'bash'
 
 module Ukiryu
   module Shell

data/lib/ukiryu/shell/powershell.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "base"
+require_relative 'base'
 
 module Ukiryu
   module Shell
@@ -20,7 +20,7 @@ module Ukiryu
       # @param string [String] the string to escape
       # @return [String] the escaped string
       def escape(string)
-        string.to_s.gsub(/[`"$]/) { "`$&" }
+        string.to_s.gsub(/[`"$]/) { '`$&' }
       end
 
       # Quote an argument for PowerShell
@@ -46,7 +46,7 @@ module Ukiryu
       # @param args [Array<String>] the arguments
       # @return [String] the complete command line
       def join(executable, *args)
-        [executable, *args.map { |a| quote(a) }].join(" ")
+        [executable, *args.map { |a| quote(a) }].join(' ')
       end
 
       # PowerShell doesn't need DISPLAY variable

data/lib/ukiryu/shell/sh.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "bash"
+require_relative 'bash'
 
 module Ukiryu
   module Shell

data/lib/ukiryu/shell/zsh.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "bash"
+require_relative 'bash'
 
 module Ukiryu
   module Shell

data/lib/ukiryu/shell.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "shell/base"
+require_relative 'shell/base'
 
 module Ukiryu
   # Shell detection and management
@@ -8,10 +8,84 @@ module Ukiryu
   # Provides EXPLICIT shell detection with no fallbacks.
   # If shell cannot be determined, raises a clear error.
   module Shell
+    # All supported shell types
+    VALID_SHELLS = %i[bash zsh fish sh powershell cmd].freeze
+
+    # Platform-specific shell mappings
+    UNIX_SHELLS = %i[bash zsh fish sh].freeze
+    WINDOWS_SHELLS = %i[powershell cmd bash].freeze
+
     class << self
       # Get or set the current shell (for explicit configuration)
       attr_writer :current_shell
 
+      # Check if a shell symbol is valid
+      #
+      # @param shell_sym [Symbol] the shell symbol to check
+      # @return [Boolean] true if shell is valid
+      def valid?(shell_sym)
+        VALID_SHELLS.include?(shell_sym&.to_sym)
+      end
+
+      # Get list of all valid shells
+      #
+      # @return [Array<Symbol>] list of valid shell symbols
+      def all_valid
+        VALID_SHELLS.dup
+      end
+
+      # Get shells valid for current platform
+      #
+      # @return [Array<Symbol>] list of valid shells for current platform
+      def valid_for_platform
+        Platform.windows? ? WINDOWS_SHELLS.dup : UNIX_SHELLS.dup
+      end
+
+      # Convert string to shell symbol
+      #
+      # @param str [String] the shell name string
+      # @return [Symbol] the shell symbol
+      # @raise [ArgumentError] if shell name is invalid
+      def from_string(str)
+        shell_sym = str.to_s.downcase.to_sym
+        return shell_sym if valid?(shell_sym)
+
+        raise ArgumentError,
+              "Invalid shell: #{str}. Valid shells: #{VALID_SHELLS.join(', ')}"
+      end
+
+      # Check if a shell is available on the system
+      #
+      # @param shell_sym [Symbol] the shell to check
+      # @return [Boolean] true if shell is available
+      def available?(shell_sym)
+        return false unless valid?(shell_sym)
+
+        case shell_sym
+        when :bash
+          shell_available_on_unix?('bash') || bash_available_on_windows?
+        when :zsh
+          shell_available_on_unix?('zsh')
+        when :fish
+          shell_available_on_unix?('fish')
+        when :sh
+          shell_available_on_unix?('sh')
+        when :powershell
+          powershell_available?
+        when :cmd
+          true # cmd is always available on Windows
+        else
+          false
+        end
+      end
+
+      # Get all shells available on the current system
+      #
+      # @return [Array<Symbol>] list of available shells
+      def available_shells
+        VALID_SHELLS.select { |shell| available?(shell) }
+      end
+
       # Detect the current shell
       #
       # @return [Symbol] :bash, :zsh, :fish, :sh, :powershell, or :cmd
@@ -54,22 +128,22 @@ module Ukiryu
       def class_for(name)
         case name
         when :bash
-          require_relative "shell/bash"
+          require_relative 'shell/bash'
           Bash
         when :zsh
-          require_relative "shell/zsh"
+          require_relative 'shell/zsh'
           Zsh
         when :fish
-          require_relative "shell/fish"
+          require_relative 'shell/fish'
           Fish
         when :sh
-          require_relative "shell/sh"
+          require_relative 'shell/sh'
           Sh
         when :powershell
-          require_relative "shell/powershell"
+          require_relative 'shell/powershell'
           PowerShell
         when :cmd
-          require_relative "shell/cmd"
+          require_relative 'shell/cmd'
           Cmd
         else
           raise UnknownShellError, "Unknown shell: #{name}"
@@ -83,13 +157,13 @@ module Ukiryu
       # @return [Symbol] detected shell
       def detect_windows_shell
         # PowerShell check
-        return :powershell if ENV["PSModulePath"]
+        return :powershell if ENV['PSModulePath']
 
         # Git Bash / MSYS check
-        return :bash if ENV["MSYSTEM"] || ENV["MINGW_PREFIX"]
+        return :bash if ENV['MSYSTEM'] || ENV['MINGW_PREFIX']
 
         # WSL check
-        return :bash if ENV["WSL_DISTRO"]
+        return :bash if ENV['WSL_DISTRO']
 
         # Default to cmd on Windows
         :cmd
@@ -99,37 +173,36 @@ module Ukiryu
       #
       # @return [Symbol] detected shell
       def detect_unix_shell
-        shell_env = ENV["SHELL"]
+        shell_env = ENV['SHELL']
 
         # Try to determine from SHELL environment variable
-        if shell_env
-          return :bash if shell_env.end_with?("bash")
-          return :zsh if shell_env.end_with?("zsh")
-          return :fish if shell_env.end_with?("fish")
-          return :sh if shell_env.end_with?("sh")
-
-          # Try to determine from executable name
-          shell_name = File.basename(shell_env)
-          case shell_name
-          when "bash"
-            :bash
-          when "zsh"
-            :zsh
-          when "fish"
-            :fish
-          when "sh"
-            :sh
-          else
-            # Unknown shell in ENV - check if executable
-            if File.executable?(shell_env)
-              # Return as symbol for custom shell
-              shell_name.to_sym
-            else
-              raise UnknownShellError, unknown_shell_error_msg("Unknown shell in SHELL: #{shell_env}")
-            end
-          end
+        raise UnknownShellError, unknown_shell_error_msg('SHELL environment variable not set') unless shell_env
+        return :bash if shell_env.end_with?('bash')
+        return :zsh if shell_env.end_with?('zsh')
+        return :fish if shell_env.end_with?('fish')
+        return :sh if shell_env.end_with?('sh')
+
+        # Try to determine from executable name
+        shell_name = File.basename(shell_env)
+        case shell_name
+        when 'bash'
+          :bash
+        when 'zsh'
+          :zsh
+        when 'fish'
+          :fish
+        when 'sh'
+          :sh
         else
-          raise UnknownShellError, unknown_shell_error_msg("SHELL environment variable not set")
+          # Unknown shell in ENV - check if executable
+          unless File.executable?(shell_env)
+            raise UnknownShellError,
+                  unknown_shell_error_msg("Unknown shell in SHELL: #{shell_env}")
+          end
+
+          # Return as symbol for custom shell
+          shell_name.to_sym
+
         end
       end
 
@@ -154,11 +227,45 @@ module Ukiryu
             end
 
           Current environment:
-            Platform: #{RbConfig::CONFIG['host_os']}
+            Platform: #{RUBY_PLATFORM}
             SHELL: #{ENV['SHELL']}
             PSModulePath: #{ENV['PSModulePath']}
         ERROR
       end
+
+      # Check if a Unix shell is available on the system
+      #
+      # @param shell_name [String] the shell executable name
+      # @return [Boolean] true if shell is available
+      def shell_available_on_unix?(shell_name)
+        return false if Platform.windows?
+
+        # Check if shell is in PATH
+        system("which #{shell_name} > /dev/null 2>&1")
+      end
+
+      # Check if bash is available on Windows (Git Bash/MSYS)
+      #
+      # @return [Boolean] true if bash is available
+      def bash_available_on_windows?
+        return false unless Platform.windows?
+
+        # Check for Git Bash / MSYS
+        !!(ENV['MSYSTEM'] || ENV['MINGW_PREFIX'] || ENV['WSL_DISTRO'] ||
+           system('where bash >nul 2>&1'))
+      end
+
+      # Check if PowerShell is available
+      #
+      # @return [Boolean] true if PowerShell is available
+      def powershell_available?
+        return true if Platform.windows? && ENV['PSModulePath']
+
+        # On Unix, check for PowerShell Core (pwsh)
+        return true if !Platform.windows? && system('which pwsh > /dev/null 2>&1')
+
+        false
+      end
     end
   end
 end