toys-core 0.10.4 → 0.11.3

data/lib/toys/utils/exec.rb

@@ -250,13 +250,14 @@ module Toys
         exec_opts = Opts.new(@default_opts).add(opts)
         spawn_cmd =
           if cmd.is_a?(::Array)
-            if cmd.size == 1 && cmd.first.is_a?(::String)
-              [[cmd.first, exec_opts.config_opts[:argv0] || cmd.first]]
+            if cmd.size > 1
+              binary = canonical_binary_spec(cmd.first, exec_opts)
+              [binary] + cmd[1..-1].map(&:to_s)
             else
-              cmd
+              [canonical_binary_spec(Array(cmd.first), exec_opts)]
             end
           else
-            [cmd]
+            [cmd.to_s]
           end
         executor = Executor.new(exec_opts, spawn_cmd, block)
         executor.execute
@@ -492,7 +493,8 @@ module Toys
       #
       class Controller
         ## @private
-        def initialize(name, controller_streams, captures, pid, join_threads, result_callback)
+        def initialize(name, controller_streams, captures, pid, join_threads,
+                       result_callback, mutex)
           @name = name
           @in = controller_streams[:in]
           @out = controller_streams[:out]
@@ -508,6 +510,7 @@ module Toys
           end
           @join_threads = join_threads
           @result_callback = result_callback
+          @mutex = mutex
           @result = nil
         end
 
@@ -547,7 +550,7 @@ module Toys
         ##
         # The process ID.
         #
-        # Exactly one of `exception` and `pid` will be non-nil.
+        # Exactly one of {#exception} and {#pid} will be non-nil.
         #
         # @return [Integer] if the process start was successful
         # @return [nil] if the process could not be started.
@@ -557,7 +560,7 @@ module Toys
         ##
         # The exception raised when the process failed to start.
         #
-        # Exactly one of `exception` and `pid` will be non-nil.
+        # Exactly one of {#exception} and {#pid} will be non-nil.
         #
         # @return [Exception] if the process failed to start.
         # @return [nil] if the process start was successful.
@@ -575,7 +578,10 @@ module Toys
           stream = stream_for(which)
           @join_threads << ::Thread.new do
             begin
-              @captures[which] = stream.read
+              data = stream.read
+              @mutex.synchronize do
+                @captures[which] = data
+              end
             ensure
               stream.close
             end
@@ -722,15 +728,20 @@ module Toys
         ##
         # Wait for the subcommand to complete, and return a result object.
         #
+        # Closes the control streams if present. The stdin stream is always
+        # closed, even if the call times out. The stdout and stderr streams are
+        # closed only after the command terminates.
+        #
         # @param timeout [Numeric,nil] The timeout in seconds, or `nil` to
         #     wait indefinitely.
         # @return [Toys::Utils::Exec::Result] The result object
         # @return [nil] if a timeout occurred.
         #
         def result(timeout: nil)
+          close_streams(:in)
           return nil if @wait_thread && !@wait_thread.join(timeout)
           @result ||= begin
-            close_streams
+            close_streams(:out)
             @join_threads.each(&:join)
             Result.new(name, @captures[:out], @captures[:err], @wait_thread&.value, @exception)
                   .tap { |result| @result_callback&.call(result) }
@@ -738,13 +749,13 @@ module Toys
         end
 
         ##
-        # Close all the controller's streams.
+        # Close the controller's streams.
         # @private
         #
-        def close_streams
-          @in.close if @in && !@in.closed?
-          @out.close if @out && !@out.closed?
-          @err.close if @err && !@err.closed?
+        def close_streams(which)
+          @in.close if which != :out && @in && !@in.closed?
+          @out.close if which != :in && @out && !@out.closed?
+          @err.close if which != :in && @err && !@err.closed?
           self
         end
 
@@ -773,7 +784,21 @@ module Toys
       end
 
       ##
-      # The result returned from a subcommand execution.
+      # The result returned from a subcommand execution. This includes the
+      # identifying name of the execution (if any), the result status of the
+      # execution, and any captured stream output.
+      #
+      # Possible result statuses are:
+      #
+      #  *  The process failed to start. {Result#failed?} will return true, and
+      #     {Result#exception} will return an exception describing the failure
+      #     (often an errno).
+      #  *  The process executed and exited with a normal exit code. Either
+      #     {Result#success?} or {Result#error?} will return true, and
+      #     {Result.exit_code} will return the numeric exit code.
+      #  *  The process executed but was terminated by an uncaught signal.
+      #     {Result#signaled?} will return true, and {Result#term_signal} will
+      #     return the numeric signal code.
       #
       class Result
         ## @private
@@ -809,11 +834,13 @@ module Toys
         attr_reader :captured_err
 
         ##
-        # The status code object.
+        # The Ruby process status object, providing various information about
+        # the ending state of the process.
         #
-        # Exactly one of `exception` and `status` will be non-nil.
+        # Exactly one of {#exception} and {#status} will be non-nil.
         #
-        # @return [Process::Status] The status code.
+        # @return [Process::Status] The status, if the process was successfully
+        #     spanwed and terminated.
         # @return [nil] if the process could not be started.
         #
         attr_reader :status
@@ -821,7 +848,7 @@ module Toys
         ##
         # The exception raised if a process couldn't be started.
         #
-        # Exactly one of `exception` and `status` will be non-nil.
+        # Exactly one of {#exception} and {#status} will be non-nil.
         #
         # @return [Exception] The exception raised from process start.
         # @return [nil] if the process started successfully.
@@ -829,33 +856,76 @@ module Toys
         attr_reader :exception
 
         ##
-        # The numeric status code.
+        # The numeric status code for a process that exited normally,
         #
-        # This will be a nonzero integer if the process failed to start. That
-        # is, `exit_code` will never be `nil`, even if `status` is `nil`.
+        # Exactly one of {#exception}, {#exit_code}, and {#term_signal} will be
+        # non-nil.
         #
-        # @return [Integer]
+        # @return [Integer] the numeric status code, if the process started
+        #     successfully and exited normally.
+        # @return [nil] if the process did not start successfully, or was
+        #     terminated by an uncaught signal.
         #
         def exit_code
-          status ? status.exitstatus : 127
+          status&.exitstatus
+        end
+
+        ##
+        # The numeric signal code that caused process termination.
+        #
+        # Exactly one of {#exception}, {#exit_code}, and {#term_signal} will be
+        # non-nil.
+        #
+        # @return [Integer] The signal that caused the process to terminate.
+        # @return [nil] if the process did not start successfully, or executed
+        #     and exited with a normal exit code.
+        #
+        def term_signal
+          status&.termsig
+        end
+
+        ##
+        # Returns true if the subprocess failed to start, or false if the
+        # process was able to execute.
+        #
+        # @return [Boolean]
+        #
+        def failed?
+          status.nil?
+        end
+
+        ##
+        # Returns true if the subprocess terminated due to an unhandled signal,
+        # or false if the process failed to start or exited normally.
+        #
+        # @return [Boolean]
+        #
+        def signaled?
+          !term_signal.nil?
         end
 
         ##
-        # Returns true if the subprocess terminated with a zero status.
+        # Returns true if the subprocess terminated with a zero status, or
+        # false if the process failed to start, terminated due to a signal, or
+        # returned a nonzero status.
         #
         # @return [Boolean]
         #
         def success?
-          exit_code.zero?
+          code = exit_code
+          !code.nil? && code.zero?
         end
 
         ##
-        # Returns true if the subprocess terminated with a nonzero status.
+        # Returns true if the subprocess terminated with a nonzero status, or
+        # false if the process failed to start, terminated due to a signal, or
+        # returned a zero status.
         #
         # @return [Boolean]
         #
         def error?
-          !exit_code.zero?
+          code = exit_code
+          !code.nil? && !code.zero?
         end
       end
 
@@ -876,6 +946,7 @@ module Toys
           @parent_streams = []
           @block = block
           @default_stream = @config_opts[:background] ? :null : :inherit
+          @mutex = ::Mutex.new
         end
 
         def execute
@@ -887,10 +958,10 @@ module Toys
           return controller if @config_opts[:background]
           begin
             @block&.call(controller)
+            controller.result
           ensure
-            controller.close_streams
+            controller.close_streams(:both)
           end
-          controller.result
         end
 
         private
@@ -898,12 +969,19 @@ module Toys
         def log_command
           logger = @config_opts[:logger]
           if logger && @config_opts[:log_level] != false
-            cmd_str = @config_opts[:log_cmd]
-            cmd_str ||= @spawn_cmd.size == 1 ? @spawn_cmd.first : @spawn_cmd.inspect if @spawn_cmd
+            cmd_str = @config_opts[:log_cmd] || default_log_str(@spawn_cmd)
             logger.add(@config_opts[:log_level] || ::Logger::INFO, cmd_str) if cmd_str
           end
         end
 
+        def default_log_str(spawn_cmd)
+          return nil unless spawn_cmd
+          return spawn_cmd.first if spawn_cmd.size == 1 && spawn_cmd.first.is_a?(::String)
+          cmd_binary = spawn_cmd.first
+          cmd_binary = cmd_binary.first if cmd_binary.is_a?(::Array)
+          ([cmd_binary] + spawn_cmd[1..-1]).inspect
+        end
+
         def start_with_controller
           pid =
             begin
@@ -913,7 +991,7 @@ module Toys
             end
           @child_streams.each(&:close)
           Controller.new(@config_opts[:name], @controller_streams, @captures, pid,
-                         @join_threads, @config_opts[:result_callback])
+                         @join_threads, @config_opts[:result_callback], @mutex)
         end
 
         def start_process
@@ -1220,13 +1298,27 @@ module Toys
           stream = make_out_pipe(key)
           @join_threads << ::Thread.new do
             begin
-              @captures[key] = stream.read
+              data = stream.read
+              @mutex.synchronize do
+                @captures[key] = data
+              end
             ensure
               stream.close
             end
           end
         end
       end
+
+      private
+
+      def canonical_binary_spec(cmd, exec_opts)
+        config_argv0 = exec_opts.config_opts[:argv0]
+        return cmd.to_s if !config_argv0 && !cmd.is_a?(::Array)
+        cmd = Array(cmd)
+        actual_cmd = cmd.first
+        argv0 = cmd[1] || config_argv0 || actual_cmd
+        [actual_cmd.to_s, argv0.to_s]
+      end
     end
   end
 end

data/lib/toys/utils/gems.rb

@@ -64,6 +64,19 @@ module Toys
       class AlreadyBundledError < BundlerFailedError
       end
 
+      ##
+      # The bundle contained a toys or toys-core dependency that is
+      # incompatible with the currently running version.
+      #
+      class IncompatibleToysError < BundlerFailedError
+      end
+
+      ##
+      # The gemfile names that are searched by default.
+      # @return [Array<String>]
+      #
+      DEFAULT_GEMFILE_NAMES = [".gems.rb", "gems.rb", "Gemfile"].freeze
+
       ##
       # Activate the given gem. If it is not present, attempt to install it (or
       # inform the user to update the bundle).
@@ -142,16 +155,33 @@ module Toys
       end
 
       ##
-      # Set up the bundle.
+      # Search for an appropriate Gemfile, and set up the bundle.
+      #
+      # @param groups [Array<String>] The groups to include in setup.
+      #
+      # @param gemfile_path [String] The path to the Gemfile to use. If `nil`
+      #     or not given, the `:search_dirs` will be searched for a Gemfile.
+      #
+      # @param search_dirs [String,Array<String>] Directories in which to
+      #     search for a Gemfile, if gemfile_path is not given. You can provide
+      #     a single directory or an array of directories.
+      #
+      # @param gemfile_names [String,Array<String>] File names that are
+      #     recognized as Gemfiles, when searching because gemfile_path is not
+      #     given. Defaults to {DEFAULT_GEMFILE_NAMES}.
       #
-      # @param groups [Array<String>] The groups to include in setup
-      # @param search_dirs [Array<String>] Directories to search for a Gemfile
       # @return [void]
       #
       def bundle(groups: nil,
-                 search_dirs: nil)
+                 gemfile_path: nil,
+                 search_dirs: nil,
+                 gemfile_names: nil)
+        Array(search_dirs).each do |dir|
+          break if gemfile_path
+          gemfile_path = Gems.find_gemfile(dir, gemfile_names: gemfile_names)
+        end
+        raise GemfileNotFoundError, "Gemfile not found" unless gemfile_path
         Gems.synchronize do
-          gemfile_path = find_gemfile(Array(search_dirs))
           if configure_gemfile(gemfile_path)
             activate("bundler", "~> 2.1")
             require "bundler"
@@ -160,9 +190,19 @@ module Toys
         end
       end
 
+      # @private
+      def self.find_gemfile(search_dir, gemfile_names: nil)
+        gemfile_names ||= DEFAULT_GEMFILE_NAMES
+        Array(gemfile_names).each do |file|
+          gemfile_path = ::File.join(search_dir, file)
+          return gemfile_path if ::File.readable?(gemfile_path)
+        end
+        nil
+      end
+
       @global_mutex = ::Monitor.new
 
-      ## @private
+      # @private
       def self.synchronize(&block)
         @global_mutex.synchronize(&block)
       end
@@ -230,14 +270,6 @@ module Toys
         raise ActivationFailedError, err.message
       end
 
-      def find_gemfile(search_dirs)
-        search_dirs.each do |dir|
-          gemfile_path = ::File.join(dir, "Gemfile")
-          return gemfile_path if ::File.readable?(gemfile_path)
-        end
-        raise GemfileNotFoundError, "Gemfile not found"
-      end
-
       def configure_gemfile(gemfile_path)
         old_path = ::ENV["BUNDLE_GEMFILE"]
         if old_path
@@ -258,13 +290,13 @@ module Toys
       def setup_bundle(gemfile_path, groups)
         begin
           modify_bundle_definition(gemfile_path)
-          ::Bundler.setup(*groups)
-        rescue ::Bundler::GemNotFound
+          ::Bundler.ui.silence { ::Bundler.setup(*groups) }
+        rescue ::Bundler::GemNotFound, ::Bundler::VersionConflict
           restore_toys_libs
           install_bundle(gemfile_path)
           ::Bundler.reset!
           modify_bundle_definition(gemfile_path)
-          ::Bundler.setup(*groups)
+          ::Bundler.ui.silence { ::Bundler.setup(*groups) }
         end
         restore_toys_libs
       end
@@ -272,24 +304,38 @@ module Toys
       def modify_bundle_definition(gemfile_path)
         builder = ::Bundler::Dsl.new
         builder.eval_gemfile(gemfile_path)
-        begin
-          builder.eval_gemfile(::File.join(__dir__, "gems", "gemfile.rb"))
-        rescue ::Bundler::Dsl::DSLError
-          terminal.puts(
-            "WARNING: Unable to integrate your Gemfile into the Toys runtime.\n" \
-            "When using the Toys Bundler integration features, do NOT list\n" \
-            "the toys or toys-core gems directly in your Gemfile. They can be\n" \
-            "dependencies of another gem, but cannot be listed directly.",
-            :red
-          )
-          return
-        end
         toys_gems = ["toys-core"]
-        toys_gems << "toys" if ::Toys.const_defined?(:VERSION)
+        remove_gem_from_definition(builder, "toys-core")
+        removed_toys = remove_gem_from_definition(builder, "toys")
+        add_gem_to_definition(builder, "toys-core")
+        if removed_toys || ::Toys.const_defined?(:VERSION)
+          add_gem_to_definition(builder, "toys")
+          toys_gems << "toys"
+        end
         definition = builder.to_definition(gemfile_path + ".lock", { gems: toys_gems })
         ::Bundler.instance_variable_set(:@definition, definition)
       end
 
+      def remove_gem_from_definition(builder, name)
+        existing_dep = builder.dependencies.find { |dep| dep.name == name }
+        return false unless existing_dep
+        unless existing_dep.requirement.satisfied_by?(::Gem::Version.new(::Toys::Core::VERSION))
+          raise IncompatibleToysError,
+                "The bundle lists #{name} #{existing_dep.requirement} as a dependency, which is" \
+                " incompatible with the current version #{::Toys::Core::VERSION}."
+        end
+        builder.dependencies.delete(existing_dep)
+        true
+      end
+
+      def add_gem_to_definition(builder, name)
+        if ::ENV["TOYS_DEV"] == "true"
+          path = ::File.join(::File.dirname(::File.dirname(::Toys::CORE_LIB_PATH)), name)
+        end
+        command = "gem #{name.inspect}, #{::Toys::Core::VERSION.inspect}, path: #{path.inspect}\n"
+        builder.eval_gemfile("current #{name}", command)
+      end
+
       def restore_toys_libs
         $LOAD_PATH.delete(::Toys::CORE_LIB_PATH)
         $LOAD_PATH.unshift(::Toys::CORE_LIB_PATH)
@@ -319,7 +365,12 @@ module Toys
                   " `cd #{gemfile_dir} && bundle install`"
         end
         require "bundler/cli"
-        ::Bundler::CLI.start(["install"])
+        begin
+          ::Bundler::CLI.start(["install"])
+        rescue ::Bundler::GemNotFound, ::Bundler::InstallError
+          terminal.puts("Failed to install. Trying update...")
+          ::Bundler::CLI.start(["update"])
+        end
       end
     end
   end