ukiryu 0.1.0 → 0.1.1

data/lib/ukiryu/execution/output.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Ukiryu
+  module Execution
+    # Captured output from command execution
+    #
+    # Provides typed access to stdout and stderr with parsing utilities
+    class Output
+      attr_reader :raw_stdout, :raw_stderr, :exit_status
+
+      def initialize(stdout:, stderr:, exit_status:)
+        @raw_stdout = stdout
+        @raw_stderr = stderr
+        @exit_status = exit_status
+      end
+
+      # Get stdout as a string (stripped)
+      #
+      # @return [String] stripped stdout
+      def stdout
+        @raw_stdout.strip
+      end
+
+      # Get stderr as a string (stripped)
+      #
+      # @return [String] stripped stderr
+      def stderr
+        @raw_stderr.strip
+      end
+
+      # Get stdout lines as an array
+      #
+      # @return [Array<String>] stdout split by lines
+      def stdout_lines
+        @raw_stdout.split("\n")
+      end
+
+      # Get stderr lines as an array
+      #
+      # @return [Array<String>] stderr split by lines
+      def stderr_lines
+        @raw_stderr.split("\n")
+      end
+
+      # Check if stdout contains a pattern
+      #
+      # @param pattern [String, Regexp] pattern to search for
+      # @return [Boolean] true if pattern is found
+      def stdout_contains?(pattern)
+        if pattern.is_a?(Regexp)
+          @raw_stdout.match?(pattern)
+        else
+          @raw_stdout.include?(pattern.to_s)
+        end
+      end
+
+      # Check if stderr contains a pattern
+      #
+      # @param pattern [String, Regexp] pattern to search for
+      # @return [Boolean] true if pattern is found
+      def stderr_contains?(pattern)
+        if pattern.is_a?(Regexp)
+          @raw_stderr.match?(pattern)
+        else
+          @raw_stderr.include?(pattern.to_s)
+        end
+      end
+
+      # Check if stdout is empty
+      #
+      # @return [Boolean] true if stdout is empty
+      def stdout_empty?
+        @raw_stdout.strip.empty?
+      end
+
+      # Check if stderr is empty
+      #
+      # @return [Boolean] true if stderr is empty
+      def stderr_empty?
+        @raw_stderr.strip.empty?
+      end
+
+      # Get stdout length
+      #
+      # @return [Integer] byte length of stdout
+      def stdout_length
+        @raw_stdout.length
+      end
+
+      # Get stderr length
+      #
+      # @return [Integer] byte length of stderr
+      def stderr_length
+        @raw_stderr.length
+      end
+
+      # Check if command succeeded
+      #
+      # @return [Boolean] true if exit status is 0
+      def success?
+        @exit_status.zero?
+      end
+
+      # Check if command failed
+      #
+      # @return [Boolean] true if exit status is non-zero
+      def failure?
+        @exit_status != 0
+      end
+
+      # Convert to hash
+      #
+      # @return [Hash] output as hash
+      def to_h
+        {
+          stdout: @raw_stdout,
+          stderr: @raw_stderr,
+          exit_status: @exit_status,
+          success: success?,
+          stdout_lines: stdout_lines,
+          stderr_lines: stderr_lines
+        }
+      end
+
+      # String representation
+      #
+      # @return [String] summary string
+      def to_s
+        if success?
+          "Success (exit: #{@exit_status}, stdout: #{stdout_length} bytes, stderr: #{stderr_length} bytes)"
+        else
+          "Failed (exit: #{@exit_status}, stdout: #{stdout_length} bytes, stderr: #{stderr_length} bytes)"
+        end
+      end
+
+      # Inspect
+      #
+      # @return [String] inspection string
+      def inspect
+        "#<Ukiryu::Execution::Output exit=#{@exit_status} success=#{success?}>"
+      end
+    end
+  end
+end

data/lib/ukiryu/execution/result.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module Ukiryu
+  module Execution
+    # Result class for command execution
+    #
+    # Provides a rich, object-oriented interface to command execution results.
+    # Composes CommandInfo, Output, and ExecutionMetadata for a fully OOP design.
+    class Result
+      attr_reader :command_info, :output, :metadata
+
+      def initialize(command_info:, output:, metadata:)
+        @command_info = command_info
+        @output = output
+        @metadata = metadata
+      end
+
+      # Get the full command string
+      #
+      # @return [String] executed command
+      def command
+        @command_info.full_command
+      end
+
+      # Get the executable
+      #
+      # @return [String] executable path
+      def executable
+        @command_info.executable
+      end
+
+      # Get the executable name only
+      #
+      # @return [String] executable name
+      def executable_name
+        @command_info.executable_name
+      end
+
+      # Get raw stdout
+      #
+      # @return [String] raw stdout
+      def stdout
+        @output.raw_stdout
+      end
+
+      # Get raw stderr
+      #
+      # @return [String] raw stderr
+      def stderr
+        @output.raw_stderr
+      end
+
+      # Get exit status code
+      #
+      # @return [Integer] exit status
+      def status
+        @output.exit_status
+      end
+      alias exit_code status
+
+      # Get the exit code (alias for status)
+      #
+      # @return [Integer] exit status
+      def exit_status
+        @output.exit_status
+      end
+
+      # Get start time
+      #
+      # @return [Time] when command started
+      def started_at
+        @metadata.started_at
+      end
+
+      # Get finish time
+      #
+      # @return [Time] when command finished
+      def finished_at
+        @metadata.finished_at
+      end
+
+      # Get execution duration
+      #
+      # @return [Float, nil] duration in seconds
+      def duration
+        @metadata.duration
+      end
+
+      # Get execution duration (alias)
+      #
+      # @return [Float, nil] duration in seconds
+      def execution_time
+        @metadata.duration_seconds
+      end
+
+      # Check if the command succeeded
+      #
+      # @return [Boolean]
+      def success?
+        @output.success?
+      end
+
+      # Check if the command failed
+      #
+      # @return [Boolean]
+      def failure?
+        @output.failure?
+      end
+
+      # Get stdout as a stripped string
+      #
+      # @return [String] stripped stdout
+      def output
+        @output.stdout
+      end
+
+      # Get stderr as a stripped string
+      #
+      # @return [String] stripped stderr
+      def error_output
+        @output.stderr
+      end
+
+      # Get stdout lines
+      #
+      # @return [Array<String>] stdout split by lines
+      def stdout_lines
+        @output.stdout_lines
+      end
+
+      # Get stderr lines
+      #
+      # @return [Array<String>] stderr split by lines
+      def stderr_lines
+        @output.stderr_lines
+      end
+
+      # Check if stdout contains a pattern
+      #
+      # @param pattern [String, Regexp] pattern to search for
+      # @return [Boolean] true if pattern is found
+      def stdout_contains?(pattern)
+        @output.stdout_contains?(pattern)
+      end
+
+      # Check if stderr contains a pattern
+      #
+      # @param pattern [String, Regexp] pattern to search for
+      # @return [Boolean] true if pattern is found
+      def stderr_contains?(pattern)
+        @output.stderr_contains?(pattern)
+      end
+
+      # Get a hash representation of the result
+      #
+      # @return [Hash] result data as a hash
+      def to_h
+        {
+          command: @command_info.to_h,
+          output: @output.to_h,
+          metadata: @metadata.to_h,
+          success: success?,
+          status: status
+        }
+      end
+
+      # Get a JSON representation of the result
+      #
+      # @return [String] result data as JSON
+      def to_json(*args)
+        require 'json'
+        to_h.to_json(*args)
+      end
+
+      # String representation of the result
+      #
+      # @return [String] summary string
+      def to_s
+        if success?
+          "Success: #{command} (#{metadata.formatted_duration})"
+        else
+          "Failed: #{command} (exit: #{status}, #{metadata.formatted_duration})"
+        end
+      end
+
+      # Inspect
+      #
+      # @return [String] inspection string
+      def inspect
+        "#<Ukiryu::Execution::Result #{self}>"
+      end
+    end
+  end
+end

data/lib/ukiryu/execution.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'execution/command_info'
+require_relative 'execution/output'
+require_relative 'execution/metadata'
+require_relative 'execution/result'
+
+module Ukiryu
+  # Execution namespace for result models
+  #
+  # This namespace contains OOP models for command execution results,
+  # providing a clean separation between execution logic and result modeling.
+  module Execution
+  end
+end

data/lib/ukiryu/execution_context.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+require_relative 'runtime'
+require_relative 'config'
+
+module Ukiryu
+  # Simple thread-local storage for contexts
+  #
+  # @api private
+  class ExecutionContext
+    class ThreadLocal
+      def initialize
+        @key = "__ukiryu_execution_context_#{object_id}__"
+      end
+
+      def value
+        Thread.current[@key]
+      end
+
+      def value=(val)
+        Thread.current[@key] = val
+      end
+    end
+  end
+
+  # Execution context for dependency injection and execution-scoped configuration
+  #
+  # Provides a non-singleton alternative to Runtime.instance for better testability.
+  # Wraps runtime configuration and execution-specific options in a single object.
+  #
+  # @example Using ExecutionContext in production
+  #   context = Ukiryu::ExecutionContext.current
+  #   context.platform  # => :macos
+  #   context.shell     # => :bash
+  #   context.registry  # => '/path/to/registry'
+  #
+  # @example Using ExecutionContext in tests
+  #   context = Ukiryu::ExecutionContext.new(
+  #     platform: :linux,
+  #     shell: :zsh,
+  #     registry_path: '/test/registry'
+  #   )
+  #   context.platform  # => :linux
+  #   context.shell     # => :zsh
+  class ExecutionContext
+    # Thread-local storage for current context
+    @current_context = ThreadLocal.new
+
+    class << self
+      # Get the current execution context
+      #
+      # Creates a new context from the global Runtime if none is set.
+      #
+      # @return [ExecutionContext] the current context
+      def current
+        @current_context.value ||= from_runtime
+      end
+
+      # Set the current execution context
+      #
+      # @param context [ExecutionContext] the context to set
+      # @return [void]
+      def current=(context)
+        @current_context.value = context
+      end
+
+      # Execute a block with a temporary context
+      #
+      # @param context [ExecutionContext] the context to use
+      # @yield the block to execute
+      # @return [Object] the block's return value
+      def with_context(context)
+        old_context = @current_context.value
+        @current_context.value = context
+        yield
+      ensure
+        @current_context.value = old_context
+      end
+
+      # Create a context from the global Runtime
+      #
+      # @return [ExecutionContext] a new context with runtime values
+      def from_runtime
+        runtime = Runtime.instance
+        new(
+          platform: runtime.platform,
+          shell: runtime.shell,
+          registry_path: Registry.default_registry_path,
+          timeout: Config.timeout,
+          debug: Config.debug,
+          metrics: Config.metrics
+        )
+      end
+
+      # Reset the current context (mainly for testing)
+      #
+      # @api private
+      def reset_current!
+        @current_context.value = nil
+      end
+    end
+
+    # Platform (:macos, :linux, :windows)
+    #
+    # @return [Symbol] the platform
+    attr_reader :platform
+
+    # Shell (:bash, :zsh, :fish, :powershell, :cmd)
+    #
+    # @return [Symbol] the shell
+    attr_reader :shell
+
+    # Registry path for tool profiles
+    #
+    # @return [String, nil] the registry path
+    attr_reader :registry_path
+
+    # Execution timeout in seconds
+    #
+    # @return [Integer, nil] the timeout
+    attr_reader :timeout
+
+    # Debug mode enabled
+    #
+    # @return [Boolean] true if debug mode is enabled
+    attr_reader :debug
+
+    # Metrics collection enabled
+    #
+    # @return [Boolean] true if metrics are enabled
+    attr_reader :metrics
+
+    # User-defined options hash
+    #
+    # @return [Hash] additional options
+    attr_reader :options
+
+    # Create a new execution context
+    #
+    # @param platform [Symbol] the platform (:macos, :linux, :windows)
+    # @param shell [Symbol] the shell (:bash, :zsh, :fish, :powershell, :cmd)
+    # @param registry_path [String, nil] the registry path
+    # @param timeout [Integer, nil] execution timeout in seconds
+    # @param debug [Boolean] debug mode flag
+    # @param metrics [Boolean] metrics collection flag
+    # @param options [Hash] additional options
+    def initialize(platform: nil,
+                   shell: nil,
+                   registry_path: nil,
+                   timeout: nil,
+                   debug: false,
+                   metrics: false,
+                   options: {})
+      @platform = platform
+      @shell = shell
+      @registry_path = registry_path
+      @timeout = timeout
+      @debug = debug
+      @metrics = metrics
+      @options = options
+    end
+
+    # Get the shell class for this context
+    #
+    # @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
+
+    # Create a new context with merged options
+    #
+    # @param changes [Hash] the changes to merge
+    # @return [ExecutionContext] a new context with merged values
+    def merge(changes)
+      self.class.new(
+        platform: changes.fetch(:platform, @platform),
+        shell: changes.fetch(:shell, @shell),
+        registry_path: changes.fetch(:registry_path, @registry_path),
+        timeout: changes.fetch(:timeout, @timeout),
+        debug: changes.fetch(:debug, @debug),
+        metrics: changes.fetch(:metrics, @metrics),
+        options: @options.merge(changes.fetch(:options, {}))
+      )
+    end
+
+    # String representation
+    #
+    # @return [String] the context as a string
+    def to_s
+      "ExecutionContext(platform=#{@platform}, shell=#{@shell}, registry=#{@registry_path})"
+    end
+
+    # Inspect
+    #
+    # @return [String] the inspection string
+    def inspect
+      "#<#{self.class} #{self}>"
+    end
+  end
+end