toys-core 0.4.2 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 55fb96e74b22786912b754dbd969e5ead0825afe8ac8182f3a0b06520a46b867
-  data.tar.gz: e85f258b34362a5ab66f47115805898807432560680bd6bde074b25979caa9cd
+  metadata.gz: a85fbb6170bb1609f304cc0b1a62d4743437802b64c796372d569856bdd1e256
+  data.tar.gz: 8291edf5cd82f0bbbcafb83878351415a28f8d0a21e058332184534c08e29751
 SHA512:
-  metadata.gz: 408586c952bc613bed26f549883e39fecc49cca4c298bdd22b40fe44a365c2fe23bae0016622a54ddfeb69cf7b72357310183fc8bd56e4614e476480de9527a6
-  data.tar.gz: 0afaf0c2a723277074e0b772b8166db55b5bc2d8f86150bd2a9367f5254ee770f9c82d09ef98d38c444b269ade5a59857b145f086609efb5bdc4176457ccc5c7
+  metadata.gz: 701ff10d98b0ae6f2b8c9d758c8dcb1769622a59dc3e86b85fedfae327811403c3ae514b05060eb91b701948cd275d94c86fa20973724864fc9c2b4aae355f90
+  data.tar.gz: b042cb80c9fb0f9d0d0132b546384179efc69873e4d060c20b7e2bc1b7c6e36721d27655e4efa4b77960cc899e726bbc47e92cbdbfd5cf2c18289dcde0b8e3cb

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Release History
 
+### 0.4.3 / 2018-07-13
+
+* IMPROVED: Utils::Exec methods can now spawn subprocesses in the background
+* IMPROVED: Utils::Exec capture methods can now yield a controller
+
 ### 0.4.2 / 2018-07-08
 
 * FIXED: Raise an error rather than cause unexpected behavior if a mixin is included twice.

data/lib/toys/core_version.rb

@@ -34,5 +34,5 @@ module Toys
   # Current version of Toys core
   # @return [String]
   #
-  CORE_VERSION = "0.4.2"
+  CORE_VERSION = "0.4.3"
 end

data/lib/toys/standard_mixins/exec.rb

@@ -100,8 +100,8 @@ module Toys
       # Execute a command. The command may be given as a single string to pass
       # to a shell, or an array of strings indicating a posix command.
       #
-      # If you provide a block, a {Toys::Utils::Exec::Controller} will be
-      # yielded to it, allowing you to interact with the subprocess streams.
+      # If the process is not set to run in the background, and a block is
+      # provided, a {Toys::Utils::Exec::Controller} will be yielded to it.
       #
       # @param [String,Array<String>] cmd The command to execute.
       # @param [Hash] opts The command options. All options listed in the
@@ -110,8 +110,9 @@ module Toys
       # @yieldparam controller [Toys::Utils::Exec::Controller] A controller for
       #     the subprocess streams.
       #
-      # @return [Toys::Utils::Exec::Result] The subprocess result, including
-      #     the exit code and any captured output.
+      # @return [Toys::Utils::Exec::Controller,Toys::Utils::Exec::Result] The
+      #     subprocess controller or result, depending on whether the process
+      #     is running in the background or foreground.
       #
       def exec(cmd, opts = {}, &block)
         self[KEY].exec(cmd, Exec._setup_exec_opts(opts, self), &block)
@@ -120,8 +121,8 @@ module Toys
       ##
       # Spawn a ruby process and pass the given arguments to it.
       #
-      # If you provide a block, a {Toys::Utils::Exec::Controller} will be
-      # yielded to it, allowing you to interact with the subprocess streams.
+      # If the process is not set to run in the background, and a block is
+      # provided, a {Toys::Utils::Exec::Controller} will be yielded to it.
       #
       # @param [String,Array<String>] args The arguments to ruby.
       # @param [Hash] opts The command options. All options listed in the
@@ -130,8 +131,9 @@ module Toys
       # @yieldparam controller [Toys::Utils::Exec::Controller] A controller for
       #     for the subprocess streams.
       #
-      # @return [Toys::Utils::Exec::Result] The subprocess result, including
-      #     the exit code and any captured output.
+      # @return [Toys::Utils::Exec::Controller,Toys::Utils::Exec::Result] The
+      #     subprocess controller or result, depending on whether the process
+      #     is running in the background or foreground.
       #
       def exec_ruby(args, opts = {}, &block)
         self[KEY].exec_ruby(args, Exec._setup_exec_opts(opts, self), &block)
@@ -141,8 +143,8 @@ module Toys
       ##
       # Execute a proc in a subprocess.
       #
-      # If you provide a block, a {Toys::Utils::Exec::Controller} will be
-      # yielded to it, allowing you to interact with the subprocess streams.
+      # If the process is not set to run in the background, and a block is
+      # provided, a {Toys::Utils::Exec::Controller} will be yielded to it.
       #
       # @param [Proc] func The proc to call.
       # @param [Hash] opts The command options. Most options listed in the
@@ -151,8 +153,9 @@ module Toys
       # @yieldparam controller [Toys::Utils::Exec::Controller] A controller
       #     for the subprocess streams.
       #
-      # @return [Toys::Utils::Exec::Result] The subprocess result, including
-      #     exit code and any captured output.
+      # @return [Toys::Utils::Exec::Controller,Toys::Utils::Exec::Result] The
+      #     subprocess controller or result, depending on whether the process
+      #     is running in the background or foreground.
       #
       def exec_proc(func, opts = {}, &block)
         self[KEY].exec_proc(func, Exec._setup_exec_opts(opts, self), &block)
@@ -162,8 +165,8 @@ module Toys
       # Execute a tool. The command may be given as a single string or an array
       # of strings, representing the tool to run and the arguments to pass.
       #
-      # If you provide a block, a {Toys::Utils::Exec::Controller} will be
-      # yielded to it, allowing you to interact with the subprocess streams.
+      # If the process is not set to run in the background, and a block is
+      # provided, a {Toys::Utils::Exec::Controller} will be yielded to it.
       #
       # @param [String,Array<String>] cmd The tool to execute.
       # @param [Hash] opts The command options. Most options listed in the
@@ -172,8 +175,9 @@ module Toys
       # @yieldparam controller [Toys::Utils::Exec::Controller] A controller
       #     for the subprocess streams.
       #
-      # @return [Toys::Utils::Exec::Result] The subprocess result, including
-      #     exit code and any captured output.
+      # @return [Toys::Utils::Exec::Controller,Toys::Utils::Exec::Result] The
+      #     subprocess controller or result, depending on whether the process
+      #     is running in the background or foreground.
       #
       def exec_tool(cmd, opts = {}, &block)
         func = Exec._make_tool_caller(cmd)
@@ -185,48 +189,66 @@ module Toys
       # to a shell, or an array of strings indicating a posix command.
       #
       # Captures standard out and returns it as a string.
+      # Cannot be run in the background.
+      #
+      # If a block is provided, a {Toys::Utils::Exec::Controller} will be
+      # yielded to it.
       #
       # @param [String,Array<String>] cmd The command to execute.
       # @param [Hash] opts The command options. All options listed in the
       #     {Toys::Utils::Exec} documentation are supported, plus the
       #     `exit_on_nonzero_status` option.
+      # @yieldparam controller [Toys::Utils::Exec::Controller] A controller
+      #     for the subprocess streams.
       #
       # @return [String] What was written to standard out.
       #
-      def capture(cmd, opts = {})
-        self[KEY].capture(cmd, Exec._setup_exec_opts(opts, self))
+      def capture(cmd, opts = {}, &block)
+        self[KEY].capture(cmd, Exec._setup_exec_opts(opts, self), &block)
       end
 
       ##
       # Spawn a ruby process and pass the given arguments to it.
       #
       # Captures standard out and returns it as a string.
+      # Cannot be run in the background.
+      #
+      # If a block is provided, a {Toys::Utils::Exec::Controller} will be
+      # yielded to it.
       #
       # @param [String,Array<String>] args The arguments to ruby.
       # @param [Hash] opts The command options. All options listed in the
       #     {Toys::Utils::Exec} documentation are supported, plus the
       #     `exit_on_nonzero_status` option.
+      # @yieldparam controller [Toys::Utils::Exec::Controller] A controller
+      #     for the subprocess streams.
       #
       # @return [String] What was written to standard out.
       #
-      def capture_ruby(args, opts = {})
-        self[KEY].capture_ruby(args, Exec._setup_exec_opts(opts, self))
+      def capture_ruby(args, opts = {}, &block)
+        self[KEY].capture_ruby(args, Exec._setup_exec_opts(opts, self), &block)
       end
 
       ##
       # Execute a proc in a subprocess.
       #
       # Captures standard out and returns it as a string.
+      # Cannot be run in the background.
+      #
+      # If a block is provided, a {Toys::Utils::Exec::Controller} will be
+      # yielded to it.
       #
       # @param [Proc] func The proc to call.
       # @param [Hash] opts The command options. Most options listed in the
       #     {Toys::Utils::Exec} documentation are supported, plus the
       #     `exit_on_nonzero_status` option.
+      # @yieldparam controller [Toys::Utils::Exec::Controller] A controller
+      #     for the subprocess streams.
       #
       # @return [String] What was written to standard out.
       #
-      def capture_proc(func, opts = {})
-        self[KEY].capture_proc(func, Exec._setup_exec_opts(opts, self))
+      def capture_proc(func, opts = {}, &block)
+        self[KEY].capture_proc(func, Exec._setup_exec_opts(opts, self), &block)
       end
 
       ##
@@ -234,31 +256,43 @@ module Toys
       # of strings, representing the tool to run and the arguments to pass.
       #
       # Captures standard out and returns it as a string.
+      # Cannot be run in the background.
+      #
+      # If a block is provided, a {Toys::Utils::Exec::Controller} will be
+      # yielded to it.
       #
       # @param [String,Array<String>] cmd The tool to execute.
       # @param [Hash] opts The command options. Most options listed in the
       #     {Toys::Utils::Exec} documentation are supported, plus the
       #     `exit_on_nonzero_status` option.
+      # @yieldparam controller [Toys::Utils::Exec::Controller] A controller
+      #     for the subprocess streams.
       #
       # @return [String] What was written to standard out.
       #
-      def capture_tool(cmd, opts = {})
+      def capture_tool(cmd, opts = {}, &block)
         func = Exec._make_tool_caller(cmd)
-        self[KEY].capture_proc(func, Exec._setup_exec_opts(opts, self))
+        self[KEY].capture_proc(func, Exec._setup_exec_opts(opts, self), &block)
       end
 
       ##
       # Execute the given string in a shell. Returns the exit code.
+      # Cannot be run in the background.
+      #
+      # If a block is provided, a {Toys::Utils::Exec::Controller} will be
+      # yielded to it.
       #
       # @param [String] cmd The shell command to execute.
       # @param [Hash] opts The command options. All options listed in the
       #     {Toys::Utils::Exec} documentation are supported, plus the
       #     `exit_on_nonzero_status` option.
+      # @yieldparam controller [Toys::Utils::Exec::Controller] A controller
+      #     for the subprocess streams.
       #
       # @return [Integer] The exit code
       #
-      def sh(cmd, opts = {})
-        self[KEY].sh(cmd, Exec._setup_exec_opts(opts, self))
+      def sh(cmd, opts = {}, &block)
+        self[KEY].sh(cmd, Exec._setup_exec_opts(opts, self), &block)
       end
 
       ##

data/lib/toys/standard_mixins/terminal.rb

@@ -82,6 +82,7 @@ module Toys
       def puts(str = "", *styles)
         terminal.puts(str, *styles)
       end
+      alias say puts
 
       ##
       # @see Toys::Utils::Terminal#write

data/lib/toys/utils/exec.rb

@@ -50,6 +50,8 @@ module Toys
     #    If not present, the command is not logged.
     # *  **:log_level** (Integer) Log level for logging the actual command.
     #    Defaults to Logger::INFO if not present.
+    # *  **:background** (Boolean) Runs the process in the background,
+    #    returning a controller object instead of a result object.
     # *  **:in** Connects the input stream of the subprocess. See the section
     #    on stream handling.
     # *  **:out** Connects the standard output stream of the subprocess. See
@@ -95,7 +97,11 @@ module Toys
     #    `Process#spawn`.
     # *  **Redirect to null:** You may redirect to a null stream by passing
     #    `:null` as the option value. This connects to a stream that is not
-    #    closed but contains no data, i.e. `/dev/null` on unix systems.
+    #    closed but contains no data, i.e. `/dev/null` on unix systems. This is
+    #    the default if the subprocess is run in the background.
+    # *  **Inherit parent stream:** You may inherit the corresponding stream in
+    #    the parent process by passing `:inherit` as the option value. This is
+    #    the default if the subprocess is *not* run in the background.
     # *  **Redirect to a file:** You may redirect to a file. This reads from an
     #    existing file when connected to `:in`, and creates or appends to a
     #    file when connected to `:out` or `:err`. To specify a file, use the
@@ -147,8 +153,8 @@ module Toys
       # Execute a command. The command may be given as a single string to pass
       # to a shell, or an array of strings indicating a posix command.
       #
-      # If you provide a block, a {Toys::Utils::Exec::Controller} will be
-      # yielded to it, allowing you to interact with the subprocess streams.
+      # If the process is not set to run in the background, and a block is
+      # provided, a {Toys::Utils::Exec::Controller} will be yielded to it.
       #
       # @param [String,Array<String>] cmd The command to execute.
       # @param [Hash] opts The command options. See the section on
@@ -156,8 +162,9 @@ module Toys
       # @yieldparam controller [Toys::Utils::Exec::Controller] A controller
       #     for the subprocess streams.
       #
-      # @return [Toys::Utils::Exec::Result] The subprocess result, including
-      #     exit code and any captured output.
+      # @return [Toys::Utils::Exec::Controller,Toys::Utils::Exec::Result] The
+      #     subprocess controller or result, depending on whether the process
+      #     is running in the background or foreground.
       #
       def exec(cmd, opts = {}, &block)
         exec_opts = Opts.new(@default_opts).add(opts)
@@ -171,15 +178,15 @@ module Toys
           else
             [cmd]
           end
-        executor = Executor.new(exec_opts, spawn_cmd)
-        executor.execute(&block)
+        executor = Executor.new(exec_opts, spawn_cmd, block)
+        executor.execute
       end
 
       ##
       # Spawn a ruby process and pass the given arguments to it.
       #
-      # If you provide a block, a {Toys::Utils::Exec::Controller} will be
-      # yielded to it, allowing you to interact with the subprocess streams.
+      # If the process is not set to run in the background, and a block is
+      # provided, a {Toys::Utils::Exec::Controller} will be yielded to it.
       #
       # @param [String,Array<String>] args The arguments to ruby.
       # @param [Hash] opts The command options. See the section on
@@ -187,8 +194,9 @@ module Toys
       # @yieldparam controller [Toys::Utils::Exec::Controller] A controller
       #     for the subprocess streams.
       #
-      # @return [Toys::Utils::Exec::Result] The subprocess result, including
-      #     exit code and any captured output.
+      # @return [Toys::Utils::Exec::Controller,Toys::Utils::Exec::Result] The
+      #     subprocess controller or result, depending on whether the process
+      #     is running in the background or foreground.
       #
       def exec_ruby(args, opts = {}, &block)
         cmd = args.is_a?(::Array) ? [::RbConfig.ruby] + args : "#{::RbConfig.ruby} #{args}"
@@ -200,8 +208,8 @@ module Toys
       ##
       # Execute a proc in a fork.
       #
-      # If you provide a block, a {Toys::Utils::Exec::Controller} will be
-      # yielded to it, allowing you to interact with the subprocess streams.
+      # If the process is not set to run in the background, and a block is
+      # provided, a {Toys::Utils::Exec::Controller} will be yielded to it.
       #
       # @param [Proc] func The proc to call.
       # @param [Hash] opts The command options. See the section on
@@ -209,13 +217,14 @@ module Toys
       # @yieldparam controller [Toys::Utils::Exec::Controller] A controller
       #     for the subprocess streams.
       #
-      # @return [Toys::Utils::Exec::Result] The subprocess result, including
-      #     exit code and any captured output.
+      # @return [Toys::Utils::Exec::Controller,Toys::Utils::Exec::Result] The
+      #     subprocess controller or result, depending on whether the process
+      #     is running in the background or foreground.
       #
       def exec_proc(func, opts = {}, &block)
         exec_opts = Opts.new(@default_opts).add(opts)
-        executor = Executor.new(exec_opts, func)
-        executor.execute(&block)
+        executor = Executor.new(exec_opts, func, block)
+        executor.execute
       end
 
       ##
@@ -223,58 +232,79 @@ module Toys
       # to a shell, or an array of strings indicating a posix command.
       #
       # Captures standard out and returns it as a string.
+      # Cannot be run in the background.
+      #
+      # If a block is provided, a {Toys::Utils::Exec::Controller} will be
+      # yielded to it.
       #
       # @param [String,Array<String>] cmd The command to execute.
       # @param [Hash] opts The command options. See the section on
       #     configuration options in the {Toys::Utils::Exec} module docs.
+      # @yieldparam controller [Toys::Utils::Exec::Controller] A controller
+      #     for the subprocess streams.
       #
       # @return [String] What was written to standard out.
       #
-      def capture(cmd, opts = {})
-        exec(cmd, opts.merge(out: :capture)).captured_out
+      def capture(cmd, opts = {}, &block)
+        exec(cmd, opts.merge(out: :capture, background: false), &block).captured_out
       end
 
       ##
       # Spawn a ruby process and pass the given arguments to it.
       #
       # Captures standard out and returns it as a string.
+      # Cannot be run in the background.
+      #
+      # If a block is provided, a {Toys::Utils::Exec::Controller} will be
+      # yielded to it.
       #
       # @param [String,Array<String>] args The arguments to ruby.
       # @param [Hash] opts The command options. See the section on
       #     configuration options in the {Toys::Utils::Exec} module docs.
+      # @yieldparam controller [Toys::Utils::Exec::Controller] A controller
+      #     for the subprocess streams.
       #
       # @return [String] What was written to standard out.
       #
-      def capture_ruby(args, opts = {})
-        ruby(args, opts.merge(out: :capture)).captured_out
+      def capture_ruby(args, opts = {}, &block)
+        ruby(args, opts.merge(out: :capture, background: false), &block).captured_out
       end
 
       ##
       # Execute a proc in a fork.
       #
       # Captures standard out and returns it as a string.
+      # Cannot be run in the background.
+      #
+      # If a block is provided, a {Toys::Utils::Exec::Controller} will be
+      # yielded to it.
       #
       # @param [Proc] func The proc to call.
       # @param [Hash] opts The command options. See the section on
       #     configuration options in the {Toys::Utils::Exec} module docs.
+      # @yieldparam controller [Toys::Utils::Exec::Controller] A controller
+      #     for the subprocess streams.
       #
       # @return [String] What was written to standard out.
       #
-      def capture_proc(func, opts = {})
-        exec_proc(func, opts.merge(out: :capture)).captured_out
+      def capture_proc(func, opts = {}, &block)
+        exec_proc(func, opts.merge(out: :capture, background: false), &block).captured_out
       end
 
       ##
       # Execute the given string in a shell. Returns the exit code.
+      # Cannot be run in the background.
       #
       # @param [String] cmd The shell command to execute.
       # @param [Hash] opts The command options. See the section on
       #     configuration options in the {Toys::Utils::Exec} module docs.
+      # @yieldparam controller [Toys::Utils::Exec::Controller] A controller
+      #     for the subprocess streams.
       #
       # @return [Integer] The exit code
       #
-      def sh(cmd, opts = {})
-        exec(cmd, opts).exit_code
+      def sh(cmd, opts = {}, &block)
+        exec(cmd, opts.merge(background: false), &block).exit_code
       end
 
       ##
@@ -288,6 +318,7 @@ module Toys
         #
         CONFIG_KEYS = %i[
           argv0
+          background
           cli
           env
           err
@@ -356,17 +387,24 @@ module Toys
       end
 
       ##
-      # An object of this type is passed to a subcommand control block.
+      # An object that controls a subprocess. This object is returned from an
+      # execution running in the background, or is yielded to a control block
+      # for an execution running in the foreground.
       # You may use this object to interact with the subcommand's streams,
-      # and/or send signals to the process.
+      # send signals to the process, and get its result.
       #
       class Controller
         ## @private
-        def initialize(ins, out, err, pid)
-          @in = ins
-          @out = out
-          @err = err
+        def initialize(controller_streams, captures, pid, join_threads, nonzero_status_handler)
+          @in = controller_streams[:in]
+          @out = controller_streams[:out]
+          @err = controller_streams[:err]
+          @captures = captures
           @pid = pid
+          @join_threads = join_threads
+          @nonzero_status_handler = nonzero_status_handler
+          @wait_thread = ::Process.detach(pid)
+          @result = nil
         end
 
         ##
@@ -408,6 +446,47 @@ module Toys
         def kill(signal)
           ::Process.kill(signal, pid)
         end
+
+        ##
+        # Determine whether the subcommand is still executing
+        #
+        # @return [Boolean]
+        #
+        def executing?
+          @wait_thread.status ? true : false
+        end
+
+        ##
+        # Wait for the subcommand to complete, and return a result object.
+        #
+        # @param [Numeric,nil] timeout The timeout in seconds, or `nil` to
+        #     wait indefinitely.
+        # @return [Toys::Utils::Exec::Result,nil] The result object, or `nil`
+        #     if a timeout occurred.
+        #
+        def result(timeout: nil)
+          return nil unless @wait_thread.join(timeout)
+          @result ||= begin
+            close_streams
+            @join_threads.each(&:join)
+            status = @wait_thread.value
+            if @nonzero_status_handler && status.exitstatus != 0
+              @nonzero_status_handler.call(status)
+            end
+            Result.new(@captures[:out], @captures[:err], status)
+          end
+        end
+
+        ##
+        # Close all 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?
+          self
+        end
       end
 
       ##
@@ -471,7 +550,7 @@ module Toys
       # @private
       #
       class Executor
-        def initialize(exec_opts, spawn_cmd)
+        def initialize(exec_opts, spawn_cmd, block)
           @fork_func = spawn_cmd.respond_to?(:call) ? spawn_cmd : nil
           @spawn_cmd = spawn_cmd.respond_to?(:call) ? nil : spawn_cmd
           @config_opts = exec_opts.config_opts
@@ -481,18 +560,26 @@ module Toys
           @join_threads = []
           @child_streams = []
           @parent_streams = []
+          @block = block
+          @default_stream = @config_opts[:background] ? :null : :inherit
         end
 
-        def execute(&block)
+        def execute
           setup_in_stream
-          setup_out_stream(:out, $stdout, 1)
-          setup_out_stream(:err, $stderr, 2)
+          setup_out_stream(:out)
+          setup_out_stream(:err)
           log_command
           pid = @fork_func ? start_fork : start_process
           @child_streams.each(&:close)
-          wait_thread = ::Process.detach(pid)
-          status = control_process(wait_thread, &block)
-          create_result(status)
+          controller = Controller.new(@controller_streams, @captures, pid, @join_threads,
+                                      @config_opts[:nonzero_status_handler])
+          return controller if @config_opts[:background]
+          begin
+            @block&.call(controller)
+          ensure
+            controller.close_streams
+          end
+          controller.result
         end
 
         private
@@ -613,34 +700,8 @@ module Toys
           end
         end
 
-        def control_process(wait_thread)
-          begin
-            if block_given?
-              controller = Controller.new(
-                @controller_streams[:in], @controller_streams[:out], @controller_streams[:err],
-                wait_thread.pid
-              )
-              yield controller
-            end
-          ensure
-            @controller_streams.each_value(&:close)
-          end
-          @join_threads.each(&:join)
-          wait_thread.value
-        end
-
-        def create_result(status)
-          nonzero_status_handler = @config_opts[:nonzero_status_handler]
-          nonzero_status_handler.call(status) if nonzero_status_handler && status.exitstatus != 0
-          Result.new(@captures[:out], @captures[:err], status)
-        end
-
         def setup_in_stream
-          setting = @config_opts[:in]
-          if setting.nil?
-            return if $stdin.respond_to?(:fileno) && $stdin.fileno.zero?
-            setting = $stdin
-          end
+          setting = @config_opts[:in] || @default_stream
           return unless setting
           case setting
           when ::Symbol
@@ -683,6 +744,8 @@ module Toys
             @controller_streams[:in] = make_in_pipe
           when :null
             make_null_stream(:in, "r")
+          when :inherit
+            @spawn_opts[:in] = :in
           when :close
             @spawn_opts[:in] = type
           when :parent
@@ -705,12 +768,8 @@ module Toys
           @spawn_opts[:in] = args + [::File::RDONLY]
         end
 
-        def setup_out_stream(key, stdstream, stdfileno)
-          setting = @config_opts[key]
-          if setting.nil?
-            return if setting.respond_to?(:fileno) && setting.fileno == stdfileno
-            setting = stdstream
-          end
+        def setup_out_stream(key)
+          setting = @config_opts[key] || @default_stream
           case setting
           when ::Symbol
             setup_out_stream_of_type(key, setting, [])
@@ -752,6 +811,8 @@ module Toys
             @controller_streams[key] = make_out_pipe(key)
           when :null
             make_null_stream(key, "w")
+          when :inherit
+            @spawn_opts[key] = key
           when :close, :out, :err
             @spawn_opts[key] = type
           when :parent

data/lib/toys/utils/terminal.rb

@@ -192,6 +192,7 @@ module Toys
         str = "#{str}\n" unless str.end_with?("\n")
         write(str, *styles)
       end
+      alias say puts
 
       ##
       # Write a line, appending a newline if one is not already present.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: toys-core
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.3
 platform: ruby
 authors:
 - Daniel Azuma
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-09 00:00:00.000000000 Z
+date: 2018-07-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: highline