process_executer 1.1.2 → 1.3.0

data/lib/process_executer/command/runner.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require_relative 'errors'
+require_relative 'result'
+
+module ProcessExecuter
+  module Command
+    # The `Runner` class executes subprocess commands and captures their status and output.
+    #
+    # It does the following:
+    # - Run commands (`call`) with options for capturing output, handling timeouts, and merging stdout/stderr.
+    # - Process command results, including logging and error handling.
+    # - Raise detailed exceptions for common command failures, such as timeouts or subprocess errors.
+    #
+    # This class is used internally by {ProcessExecuter.run}.
+    #
+    # @api public
+    #
+    class Runner
+      # Create a new RunCommand instance
+      #
+      # @example
+      #   runner = Runner.new()
+      #   status = runner.call('echo', 'hello')
+      #
+      # @param logger [Logger] The logger to use. Defaults to a no-op logger if nil.
+      #
+      def initialize(logger)
+        @logger = logger || Logger.new(nil)
+      end
+
+      # The logger to use
+      # @example
+      #   runner.logger #=> #<Logger:0x00007f9b1b8b3d20>
+      # @return [Logger]
+      attr_reader :logger
+
+      # rubocop:disable Metrics/ParameterLists
+
+      # Run a command and return the status including stdout and stderr output
+      #
+      # @example
+      #   command = %w[git status]
+      #   status = run(command)
+      #   status.success? # => true
+      #   status.exitstatus # => 0
+      #   status.out # => "On branch master\nnothing to commit, working tree clean\n"
+      #   status.err # => ""
+      #
+      # @param command [Array<String>] The command to run
+      # @param out [#write] The object to which stdout is written
+      # @param err [#write] The object to which stderr is written
+      # @param merge [Boolean] Write both stdout and stderr into the buffer for stdout
+      # @param raise_errors [Boolean] Raise an exception if the command fails
+      # @param options_hash [Hash] Additional options to pass to Process.spawn
+      #
+      #   See {ProcessExecuter.run} for a full list of options.
+      #
+      # @return [ProcessExecuter::Command::Result] The status of the subprocess and captured stdout and stderr output
+      #
+      def call(*command, out: nil, err: nil, merge: false, raise_errors: true, **options_hash)
+        out ||= StringIO.new
+        err ||= (merge ? out : StringIO.new)
+
+        status = spawn(command, out:, err:, **options_hash)
+
+        process_result(command, status, out, err, options_hash[:timeout], raise_errors)
+      end
+
+      # rubocop:enable Metrics/ParameterLists
+
+      private
+
+      # Wrap the output buffers in pipes and then execute the command
+      #
+      # @param command [Array<String>] The command to execute
+      # @param out [#write] The object to which stdout is written
+      # @param err [#write] The object to which stderr is written
+      # @param options_hash [Hash] Additional options to pass to Process.spawn
+      #
+      #   See {ProcessExecuter.run} for a full list of options.
+      #
+      # @raise [ProcessExecuter::Command::ProcessIOError] If an exception was raised while collecting subprocess output
+      # @raise [ProcessExecuter::Command::TimeoutError] If the command times out
+      #
+      # @return [ProcessExecuter::Status] The status of the completed subprocess
+      #
+      # @api private
+      #
+      def spawn(command, out:, err:, **options_hash)
+        out = [out] unless out.is_a?(Array)
+        err = [err] unless err.is_a?(Array)
+        out_pipe = ProcessExecuter::MonitoredPipe.new(*out)
+        err_pipe = ProcessExecuter::MonitoredPipe.new(*err)
+        ProcessExecuter.spawn(*command, out: out_pipe, err: err_pipe, **options_hash)
+      ensure
+        out_pipe.close
+        err_pipe.close
+        raise_pipe_error(command, :stdout, out_pipe) if out_pipe.exception
+        raise_pipe_error(command, :stderr, err_pipe) if err_pipe.exception
+      end
+
+      # rubocop:disable Metrics/ParameterLists
+
+      # Process the result of the command and return a ProcessExecuter::Command::Result
+      #
+      # Log the command and result, and raise an error if the command failed.
+      #
+      # @param command [Array<String>] The git command that was executed
+      # @param status [Process::Status] The status of the completed subprocess
+      # @param out [#write] The object that stdout was written to
+      # @param err [#write] The object that stderr was written to
+      # @param timeout [Numeric, nil] The maximum seconds to wait for the command to complete
+      # @param raise_errors [Boolean] Raise an exception if the command fails
+      #
+      # @return [ProcessExecuter::Command::Result] The status of the subprocess and captured stdout and stderr output
+      #
+      # @raise [ProcessExecuter::Command::FailedError] If the command failed
+      # @raise [ProcessExecuter::Command::SignaledError] If the command was signaled
+      # @raise [ProcessExecuter::Command::TimeoutError] If the command times out
+      # @raise [ProcessExecuter::Command::ProcessIOError] If an exception was raised while collecting subprocess output
+      #
+      # @api private
+      #
+      def process_result(command, status, out, err, timeout, raise_errors)
+        Result.new(command, status, out, err).tap do |result|
+          log_result(result)
+
+          if raise_errors
+            raise TimeoutError.new(result, timeout) if status.timeout?
+            raise SignaledError, result if status.signaled?
+            raise FailedError, result unless status.success?
+          end
+        end
+      end
+
+      # rubocop:enable Metrics/ParameterLists
+
+      # Log the command and result of the subprocess
+      # @param result [ProcessExecuter::Command::Result] the result of the command including
+      #   the command, status, stdout, and stderr
+      # @return [void]
+      # @api private
+      def log_result(result)
+        logger.info { "#{result.command} exited with status #{result}" }
+        logger.debug { "stdout:\n#{result.stdout_to_s.inspect}\nstderr:\n#{result.stderr_to_s.inspect}" }
+      end
+
+      # Raise an error when there was exception while collecting the subprocess output
+      #
+      # @param command [Array<String>] The command that was executed
+      # @param pipe_name [Symbol] The name of the pipe that raised the exception
+      # @param pipe [ProcessExecuter::MonitoredPipe] The pipe that raised the exception
+      #
+      # @raise [ProcessExecuter::Command::ProcessIOError]
+      #
+      # @return [void] This method always raises an error
+      #
+      # @api private
+      #
+      def raise_pipe_error(command, pipe_name, pipe)
+        error = ProcessExecuter::Command::ProcessIOError.new("Pipe Exception for #{command}: #{pipe_name}")
+        raise(error, cause: pipe.exception)
+      end
+    end
+  end
+end

data/lib/process_executer/command.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module ProcessExecuter
+  # This module contains classes for implementing ProcessExecuter.run_command
+  module Command; end
+end
+
+require_relative 'command/errors'
+require_relative 'command/result'
+require_relative 'command/runner'
+
+# Runs a command and returns the result

data/lib/process_executer/monitored_pipe.rb

@@ -281,19 +281,56 @@ module ProcessExecuter
     # @api private
     def monitor_pipe
       new_data = pipe_reader.read_nonblock(chunk_size)
-      # SimpleCov under JRuby reports the begin statement as not covered, but it is
-      # :nocov:
-      begin
-        # :nocov:
-        writers.each { |w| w.write(new_data) }
-      rescue StandardError => e
-        @exception = e
-        @state = :closing
-      end
+      write_data(new_data)
     rescue IO::WaitReadable
       pipe_reader.wait_readable(0.001)
     end
 
+    # Check if the writer is a file descriptor
+    #
+    # @param writer [#write] the writer to check
+    # @return [Boolean] true if the writer is a file descriptor
+    # @api private
+    def file_descriptor?(writer) = writer.is_a?(Integer) || writer.is_a?(Symbol)
+
+    # Write the data read from the pipe to all destinations
+    #
+    # If an exception is raised by a writer, set the state to `:closing`
+    # so that the pipe can be closed.
+    #
+    # @param data [String] the data read from the pipe
+    # @return [void]
+    # @api private
+    def write_data(data)
+      writers.each do |w|
+        file_descriptor?(w) ? write_data_to_fd(w, data) : w.write(data)
+      end
+    rescue StandardError => e
+      @exception = e
+      @state = :closing
+    end
+
+    # Write data to the given file_descriptor correctly handling stdout and stderr
+    # @param file_descriptor [Integer, Symbol] the file descriptor to write to (either an integer or :out or :err)
+    # @param data [String] the data to write
+    # @return [void]
+    # @api private
+    def write_data_to_fd(file_descriptor, data)
+      # The case line is not marked as not covered only when using TruffleRuby
+      # :nocov:
+      case file_descriptor
+      # :nocov:
+      when :out, 1
+        $stdout.write data
+      when :err, 2
+        $stderr.write data
+      else
+        io = IO.open(file_descriptor, mode: 'a', autoclose: false)
+        io.write(data)
+        io.close
+      end
+    end
+
     # Read any remaining data from the pipe and close it
     #
     # @return [void]

data/lib/process_executer/status.rb

@@ -15,6 +15,7 @@ module ProcessExecuter
     #
     # @param status [Process::Status] the status to delegate to
     # @param timeout [Boolean] true if the process timed out
+    # @param timeout_duration [Numeric, nil] The secs the command ran before being killed OR o or nil for no timeout
     #
     # @example
     #   status = Process.wait2(pid).last
@@ -23,23 +24,47 @@ module ProcessExecuter
     #
     # @api public
     #
-    def initialize(status, timeout)
+    def initialize(status, timeout, timeout_duration)
       super(status)
       @timeout = timeout
+      @timeout_duration = timeout_duration
     end
 
+    # The secs the command ran before being killed OR o or nil for no timeout
+    # @example
+    #   status.timeout_duration #=> 10
+    # @return [Numeric, nil]
+    attr_reader :timeout_duration
+
     # @!attribute [r] timeout?
-    #
     # True if the process timed out and was sent the SIGKILL signal
-    #
     # @example
     #   status = ProcessExecuter.spawn('sleep 10', timeout: 0.01)
     #   status.timeout? # => true
-    #
     # @return [Boolean]
     #
-    # @api public
-    #
     def timeout? = @timeout
+
+    # Overrides the default success? method to return nil if the process timed out
+    #
+    # This is because when a timeout occurs, Windows will still return true
+    # @example
+    #   status = ProcessExecuter.spawn('sleep 10', timeout: 0.01)
+    #   status.success? # => nil
+    # @return [Boolean, nil]
+    #
+    def success?
+      return nil if timeout? # rubocop:disable Style/ReturnNilInPredicateMethodDefinition
+
+      super
+    end
+
+    # Return a string representation of the status
+    # @example
+    #   status.to_s #=> "pid 70144 SIGKILL (signal 9) timed out after 10s"
+    # @return [String]
+    def to_s
+      "#{super}#{timeout? ? " timed out after #{timeout_duration}s" : ''}"
+    end
   end
 end

data/lib/process_executer/version.rb

@@ -2,5 +2,5 @@
 
 module ProcessExecuter
   # The current Gem version
-  VERSION = '1.1.2'
+  VERSION = '1.3.0'
 end

data/lib/process_executer.rb

@@ -2,27 +2,43 @@
 
 require 'process_executer/monitored_pipe'
 require 'process_executer/options'
+require 'process_executer/command'
 require 'process_executer/status'
 
+require 'logger'
 require 'timeout'
 
-# Execute a command in a subprocess and optionally capture its output
+# The `ProcessExecuter` module provides methods to execute subprocess commands
+# with enhanced features such as output capture, timeout handling, and custom
+# environment variables.
+#
+# Methods:
+# * {run}: Executes a command and captures its output and status in a result object.
+# * {spawn}: Executes a command and returns its exit status.
+#
+# Features:
+# * Supports executing commands via a shell or directly.
+# * Captures stdout and stderr to buffers, files, or custom objects.
+# * Optionally enforces timeouts and terminates long-running commands.
+# * Provides detailed status information, including success, failure, or timeout states.
 #
 # @api public
 #
 module ProcessExecuter
-  # Execute the specified command as a subprocess and return the exit status
+  # Execute the given command as a subprocess and return the exit status
   #
-  # This is a convenience method that calls Process.spawn and blocks until the
-  # command has terminated.
+  # This is a convenience method that calls
+  # [Process.spawn](https://docs.ruby-lang.org/en/3.3/Process.html#method-c-spawn)
+  # and blocks until the command terminates.
   #
-  # The command will be send the SIGKILL signal if it does not terminate within
+  # The command will be sent the SIGKILL signal if it does not terminate within
   # the specified timeout.
   #
   # @example
   #   status = ProcessExecuter.spawn('echo hello')
   #   status.exited? # => true
   #   status.success? # => true
+  #   status.timeout? # => false
   #
   # @example with a timeout
   #   status = ProcessExecuter.spawn('sleep 10', timeout: 0.01)
@@ -30,6 +46,7 @@ module ProcessExecuter
   #   status.success? # => nil
   #   status.signaled? # => true
   #   status.termsig # => 9
+  #   status.timeout? # => true
   #
   # @example capturing stdout to a string
   #   stdout = StringIO.new
@@ -42,10 +59,10 @@ module ProcessExecuter
   # @see ProcessExecuter::Options#initialize See ProcessExecuter::Options#initialize
   #   for options that may be specified
   #
-  # @param command [Array<String>] the command to execute
-  # @param options_hash [Hash] the options to use when exectuting the command
+  # @param command [Array<String>] The command to execute
+  # @param options_hash [Hash] The options to use when executing the command
   #
-  # @return [Process::Status] the exit status of the proceess
+  # @return [Process::Status] the exit status of the process
   #
   def self.spawn(*command, **options_hash)
     options = ProcessExecuter::Options.new(**options_hash)
@@ -53,23 +70,210 @@ module ProcessExecuter
     wait_for_process(pid, options)
   end
 
+  # Execute the given command as a subprocess, blocking until it finishes
+  #
+  # Returns a result object which includes the process's status and output.
+  #
+  # Supports the same features as
+  # [Process.spawn](https://docs.ruby-lang.org/en/3.3/Process.html#method-c-spawn).
+  # In addition, it:
+  #
+  # 1. Blocks until the command exits
+  # 2. Captures stdout and stderr to a buffer or file
+  # 3. Optionally kills the command if it exceeds a timeout
+  #
+  # This method takes two forms:
+  #
+  # 1. The command is executed via a shell when the command is given as a single
+  #    string:
+  #
+  #     `ProcessExecuter.run([env, ] command_line, options = {}) ->` {ProcessExecuter::Command::Result}
+  #
+  # 2. The command is executed directly (bypassing the shell) when the command and it
+  #    arguments are given as an array of strings:
+  #
+  #     `ProcessExecuter.run([env, ] exe_path, *args, options = {}) ->` {ProcessExecuter::Command::Result}
+  #
+  # Optional argument `env` is a hash that affects ENV for the new process; see
+  # [Execution
+  # Environment](https://docs.ruby-lang.org/en/3.3/Process.html#module-Process-label-Execution+Environment).
+  #
+  # Argument `options` is a hash of options for the new process. See the options listed below.
+  #
+  # @example Run a command given as a single string (uses shell)
+  #   # The command must be properly shell escaped when passed as a single string.
+  #   command = 'echo "stdout: `pwd`"" && echo "stderr: $HOME" 1>&2'
+  #   result = ProcessExecuter.run(command)
+  #   result.success? #=> true
+  #   result.stdout.string #=> "stdout: /Users/james/projects/main-branch/process_executer\n"
+  #   result.stderr.string #=> "stderr: /Users/james\n"
+  #
+  # @example Run a command given as an array of strings (does not use shell)
+  #   # The command and its args must be provided as separate strings in the array.
+  #   # Shell expansions and redirections are not supported.
+  #   command = ['git', 'clone', 'https://github.com/main-branch/process_executer']
+  #   result = ProcessExecuter.run(*command)
+  #   result.success? #=> true
+  #   result.stdout.string #=> ""
+  #   result.stderr.string #=> "Cloning into 'process_executer'...\n"
+  #
+  # @example Run a command with a timeout
+  #   command = ['sleep', '1']
+  #   result = ProcessExecuter.run(*command, timeout: 0.01)
+  #   #=> raises ProcessExecuter::Command::TimeoutError which contains the command result
+  #
+  # @example Run a command which fails
+  #   command = ['exit 1']
+  #   result = ProcessExecuter.run(*command)
+  #   #=> raises ProcessExecuter::Command::FailedError which contains the command result
+  #
+  # @example Run a command which exits due to an unhandled signal
+  #   command = ['kill -9 $$']
+  #   result = ProcessExecuter.run(*command)
+  #   #=> raises ProcessExecuter::Command::SignaledError which contains the command result
+  #
+  # @example Return a result instead of raising an error when `raise_errors` is `false`
+  #   # By setting `raise_errors` to `false`, exceptions will not be raised even
+  #   # if the command fails.
+  #   command = ['echo "Some error" 1>&2 && exit 1']
+  #   result = ProcessExecuter.run(*command, raise_errors: false)
+  #   # An error is not raised
+  #   result.success? #=> false
+  #   result.exitstatus #=> 1
+  #   result.stdout.string #=> ""
+  #   result.stderr.string #=> "Some error\n"
+  #
+  # @example Set environment variables
+  #   env = { 'FOO' => 'foo', 'BAR' => 'bar' }
+  #   command = 'echo "$FOO$BAR"'
+  #   result = ProcessExecuter.run(env, *command)
+  #   result.stdout.string #=> "foobar\n"
+  #
+  # @example Set environment variables when using a command array
+  #   env = { 'GIT_DIR' => '/path/to/.git' }
+  #   command = ['git', 'status']
+  #   result = ProcessExecuter.run(env, *command)
+  #   result.stdout.string #=> "On branch main\nYour branch is ..."
+  #
+  # @example Unset environment variables
+  #   env = { 'GIT_DIR' => nil } # setting to nil unsets the variable in the environment
+  #   command = ['git', 'status']
+  #   result = ProcessExecuter.run(env, *command)
+  #   result.stdout.string #=> "On branch main\nYour branch is ..."
+  #
+  # @example Reset existing environment variables and add new ones
+  #   env = { 'PATH' => '/bin' }
+  #   result = ProcessExecuter.run(env, 'echo "Home: $HOME" && echo "Path: $PATH"', unsetenv_others: true)
+  #   result.stdout.string #=> "Home: \n/Path: /bin\n"
+  #
+  # @example Run command in a different directory
+  #   command = ['pwd']
+  #   result = ProcessExecuter.run(*command, chdir: '/tmp')
+  #   result.stdout.string #=> "/tmp\n"
+  #
+  # @example Capture stdout and stderr into a single buffer
+  #   command = ['echo "stdout" && echo "stderr" 1>&2']
+  #   result = ProcessExecuter.run(*command, merge: true)
+  #   result.stdout.string #=> "stdout\nstderr\n"
+  #   result.stdout.object_id == result.stderr.object_id #=> true
+  #
+  # @example Capture to an explicit buffer
+  #   out = StringIO.new
+  #   err = StringIO.new
+  #   command = ['echo "stdout" && echo "stderr" 1>&2']
+  #   result = ProcessExecuter.run(*command, out: out, err: err)
+  #   out.string #=> "stdout\n"
+  #   err.string #=> "stderr\n"
+  #   result.stdout.object_id == out.object_id #=> true
+  #   result.stderr.object_id == err.object_id #=> true
+  #
+  # @example Capture to a file
+  #   # Same technique can be used for stderr
+  #   out = File.open('stdout.txt', 'w')
+  #   command = ['echo "stdout" && echo "stderr" 1>&2']
+  #   result = ProcessExecuter.run(*command, out: out, err: err)
+  #   out.close
+  #   File.read('stdout.txt') #=> "stdout\n"
+  #   # stderr is still captured to a StringIO buffer internally
+  #   result.stderr.string #=> "stderr\n"
+  #
+  # @example Capture to multiple writers (e.g. files, buffers, STDOUT, etc.)
+  #   # Same technique can be used for stderr
+  #   out_buffer = StringIO.new
+  #   out_file = File.open('stdout.txt', 'w')
+  #   command = ['echo "stdout" && echo "stderr" 1>&2']
+  #   result = ProcessExecuter.run(*command, out: [out_buffer, out_file])
+  #   # You must manage closing resources you create yourself
+  #   out_file.close
+  #   out_buffer.string #=> "stdout\n"
+  #   File.read('stdout.txt') #=> "stdout\n"
+  #
+  # @param command [Array<String>] The command to run
+  #
+  #   If the first element of command is a Hash, it is added to the ENV of
+  #   the new process. See [Execution Environment](https://ruby-doc.org/3.3.6/Process.html#module-Process-label-Execution+Environment)
+  #   for more details. The env hash is then removed from the command array.
+  #
+  #   If the first and only (remaining) command element is a string, it is passed to
+  #   a subshell if it begins with a shell reserved word, contains special built-ins,
+  #   or includes shell metacharacters.
+  #
+  #   Care must be taken to properly escape shell metacharacters in the command string.
+  #
+  #   Otherwise, the command is run bypassing the shell. When bypassing the shell, shell expansions
+  #   and redirections are not supported.
+  #
+  # @param logger [Logger] The logger to use
+  # @param options_hash [Hash] Additional options
+  # @option options_hash [Numeric] :timeout The maximum seconds to wait for the command to complete
+  #
+  #     If timeout is zero or nil, the command will not time out. If the command
+  #     times out, it is killed via a SIGKILL signal and {ProcessExecuter::Command::TimeoutError} is raised.
+  #
+  #     If the command does not exit when receiving the SIGKILL signal, this method may hang indefinitely.
+  #
+  # @option options_hash [#write] :out (nil) The object to write stdout to
+  # @option options_hash [#write] :err (nil) The object to write stderr to
+  # @option options_hash [Boolean] :merge (false) If true, stdout and stderr are written to the same capture buffer
+  # @option options_hash [Boolean] :raise_errors (true) Raise an exception if the command fails
+  # @option options_hash [Boolean] :unsetenv_others (false) If true, unset all environment variables before
+  #   applying the new ones
+  # @option options_hash [true, Integer, nil] :pgroup (nil) true or 0: new process group; non-zero: join
+  #   the group, nil: existing group
+  # @option options_hash [Boolean] :new_pgroup (nil) Create a new process group (Windows only)
+  # @option options_hash [Integer] :rlimit_resource_name (nil) Set resource limits (see Process.setrlimit)
+  # @option options_hash [Integer] :umask (nil) Set the umask (see File.umask)
+  # @option options_hash [Boolean] :close_others (false) If true, close non-standard file descriptors
+  # @option options_hash [String] :chdir (nil) The directory to run the command in
+  #
+  # @raise [ProcessExecuter::Command::FailedError] if the command returned a non-zero exit status
+  # @raise [ProcessExecuter::Command::SignaledError] if the command exited because of an unhandled signal
+  # @raise [ProcessExecuter::Command::TimeoutError] if the command timed out
+  # @raise [ProcessExecuter::Command::ProcessIOError] if an exception was raised while collecting subprocess output
+  #
+  # @return [ProcessExecuter::Command::Result] A result object containing the process status and captured output
+  #
+  def self.run(*command, logger: Logger.new(nil), **options_hash)
+    ProcessExecuter::Command::Runner.new(logger).call(*command, **options_hash)
+  end
+
   # Wait for process to terminate
   #
-  # If a timeout is speecified in options, kill the process after options.timeout seconds.
+  # If a timeout is specified in options, terminate the process after options.timeout seconds.
   #
-  # @param pid [Integer] the process id
+  # @param pid [Integer] the process ID
   # @param options [ProcessExecuter::Options] the options used
   #
-  # @return [ProcessExecuter::Status] the status of the process
+  # @return [ProcessExecuter::Status] the process status including Process::Status attributes and a timeout flag
   #
   # @api private
   #
   private_class_method def self.wait_for_process(pid, options)
     Timeout.timeout(options.timeout) do
-      ProcessExecuter::Status.new(Process.wait2(pid).last, false)
+      ProcessExecuter::Status.new(Process.wait2(pid).last, false, options.timeout)
     end
   rescue Timeout::Error
     Process.kill('KILL', pid)
-    ProcessExecuter::Status.new(Process.wait2(pid).last, true)
+    ProcessExecuter::Status.new(Process.wait2(pid).last, true, options.timeout)
   end
 end

data/package.json

@@ -0,0 +1,11 @@
+{
+  "devDependencies": {
+    "@commitlint/cli": "^19.5.0",
+    "@commitlint/config-conventional": "^19.5.0",
+    "husky": "^9.1.0"
+  },
+  "scripts": {
+    "postinstall": "husky",
+    "prepare": "husky"
+  }
+}

data/process_executer.gemspec

@@ -10,16 +10,17 @@ Gem::Specification.new do |spec|
 
   spec.summary = 'An API for executing commands in a subprocess'
   spec.description = 'An API for executing commands in a subprocess'
-  spec.homepage = 'https://github.com/main-branch/process_executer'
   spec.license = 'MIT'
-  spec.required_ruby_version = '>= 3.0.0'
+  spec.required_ruby_version = '>= 3.1.0'
 
   spec.metadata['allowed_push_host'] = 'https://rubygems.org'
 
+  # Project links
+  spec.homepage = "https://github.com/main-branch/#{spec.name}"
   spec.metadata['homepage_uri'] = spec.homepage
-  spec.metadata['source_code_uri'] = 'https://github.com/main-branch/process_executer'
-  spec.metadata['changelog_uri'] = "https://rubydoc.info/gems/#{spec.name}/#{spec.version}/file/CHANGELOG.md"
+  spec.metadata['source_code_uri'] = spec.homepage
   spec.metadata['documentation_uri'] = "https://rubydoc.info/gems/#{spec.name}/#{spec.version}"
+  spec.metadata['changelog_uri'] = "https://rubydoc.info/gems/#{spec.name}/#{spec.version}/file/CHANGELOG.md"
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
@@ -31,15 +32,21 @@ Gem::Specification.new do |spec|
   spec.bindir = 'exe'
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
+  spec.requirements = [
+    'Platform: Mac, Linux, or Windows',
+    'Ruby: MRI 3.1 or later, TruffleRuby 24 or later, or JRuby 9.4 or later'
+  ]
 
   spec.add_development_dependency 'bundler-audit', '~> 0.9'
-  spec.add_development_dependency 'create_github_release', '~> 1.1'
-  spec.add_development_dependency 'rake', '~> 13.1'
-  spec.add_development_dependency 'rspec', '~> 3.12'
-  spec.add_development_dependency 'rubocop', '~> 1.59'
+  spec.add_development_dependency 'create_github_release', '~> 2.1'
+  spec.add_development_dependency 'main_branch_shared_rubocop_config', '~> 0.1'
+  spec.add_development_dependency 'rake', '~> 13.2'
+  spec.add_development_dependency 'rspec', '~> 3.13'
+  spec.add_development_dependency 'rubocop', '~> 1.66'
   spec.add_development_dependency 'semverify', '~> 0.3'
   spec.add_development_dependency 'simplecov', '~> 0.22'
   spec.add_development_dependency 'simplecov-lcov', '~> 0.8'
+  spec.add_development_dependency 'simplecov-rspec', '~> 0.3'
 
   unless RUBY_PLATFORM == 'java'
     spec.add_development_dependency 'redcarpet', '~> 3.6'