toys-core 0.3.8 → 0.3.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bbe7cd88d7c1eba9d74c0006bfe81372963949d969671ad3d13597b941525a3f
-  data.tar.gz: 5c567a9a61f747fd292339681d24d7bc56fa89859d9f60f6f0f6796665b93148
+  metadata.gz: 5dae1937beb353c94635ea47760fec27761e258b31c1e09770384ea22d768938
+  data.tar.gz: de39a399a009af7d284d21115cec946349227b99fefaca6cd511696ad6b83550
 SHA512:
-  metadata.gz: fe5308be03b7d7348390caf05d6c6ba76503746133b45931b1b7c75c7b5095f03ca4ee88cefde3e0a46583901a66fa56bd5fb628c242c64d3abb854d3fb548c8
-  data.tar.gz: 9766792fef7ba0e77aa8e0254f222ea6f64238eaa3bdc1ed758faf8429105662be235014de8c375803a2da38fe2b0c3da1ae110e77a96d127e318f452f29453b
+  metadata.gz: 29ab72f03cd03a7efca54b0b9c9f5a9ac479f6cb0df74668b966d8162686f43d311c63758ba919084cac420cb9b35546b144e7afe779435a256014f9009745e4
+  data.tar.gz: 05f7d64072c690d2b9686455e85d7a499cc1bb67f3b3cf98c5a27e83eb2a101c57c3b93f3889f091a5c30eb1ce024876b45f5fca1359ba555eb166e005533505

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Release History
 
+### 0.3.9 / 2018-06-24
+
+* CHANGED: Cli#add_search_path_hierarchy changed the behavior of the base/terminate param
+* CHANGED: Removed alias_as directive since it's incompatible with selective loading.
+* ADDED: Ability to define named templates in Toys files
+* ADDED: Ability to disable argument parsing
+* ADDED: Exec#exec_proc and Exec#exec_tool that supports all the stream redirects
+* IMPROVED: Acceptors can be looked up recursively in the same way as mixins and templates
+
 ### 0.3.8 / 2018-06-10
 
 * CHANGED: Renamed helpers to mixins.

data/lib/toys/cli.rb

@@ -183,16 +183,17 @@ module Toys
     #
     # @param [String] start The first directory to add. Defaults to the current
     #     working directory.
-    # @param [String] base The last directory to add. Defaults to `"/"`.
+    # @param [Array<String>] terminate Optional list of directories that should
+    #     terminate the search.
     # @param [Boolean] high_priority Add the configs at the head of the
     #     priority list rather than the tail.
     #
-    def add_search_path_hierarchy(start: nil, base: "/", high_priority: false)
+    def add_search_path_hierarchy(start: nil, terminate: [], high_priority: false)
       path = start || ::Dir.pwd
       paths = []
       loop do
+        break if terminate.include?(path)
         paths << path
-        break if path == base
         next_path = ::File.dirname(path)
         break if next_path == path
         path = next_path
@@ -232,11 +233,12 @@ module Toys
     # Make a clone with the same settings but no paths in the loader.
     # This is sometimes useful for running sub-tools.
     #
+    # @param [Hash] _opts Unused options that can be used by subclasses.
     # @return [Toys::CLI]
     # @yieldparam cli [Toys::CLI] If you pass a block, the new CLI is yielded
     #     to it so you can add paths and make other modifications.
     #
-    def child
+    def child(_opts = {})
       cli = CLI.new(binary_name: @binary_name,
                     config_dir_name: @config_dir_name,
                     config_file_name: @config_file_name,

data/lib/toys/core_version.rb

@@ -32,5 +32,5 @@ module Toys
   # Current version of Toys core
   # @return [String]
   #
-  CORE_VERSION = "0.3.8".freeze
+  CORE_VERSION = "0.3.9".freeze
 end

data/lib/toys/definition/acceptor.rb

@@ -66,7 +66,7 @@ module Toys
       #     block.
       #
       def initialize(name, converter = nil, &block)
-        @name = name
+        @name = name.to_s
         @converter = converter || block
       end
 
@@ -75,14 +75,7 @@ module Toys
       # @return [String]
       #
       attr_reader :name
-
-      ##
-      # Name of the acceptor as a string
-      # @return [String]
-      #
-      def to_s
-        name.to_s
-      end
+      alias to_s name
 
       ##
       # Validate the given input.

data/lib/toys/definition/alias.rb

@@ -43,13 +43,13 @@ module Toys
       #
       def initialize(loader, full_name, target, priority)
         @target_name =
-          if target.is_a?(::String)
-            full_name[0..-2] + [target]
+          if target.is_a?(::Array)
+            target.map(&:to_s)
           else
-            target.dup
+            full_name[0..-2] + [target.to_s]
           end
         @target_name.freeze
-        @full_name = full_name.dup.freeze
+        @full_name = full_name.map(&:to_s).freeze
         @priority = priority
         @tool_class = DSL::Tool.new_class(@full_name, priority, loader)
       end

data/lib/toys/definition/tool.rb

@@ -28,6 +28,7 @@
 ;
 
 require "optparse"
+require "set"
 
 module Toys
   module Definition
@@ -44,21 +45,23 @@ module Toys
       # You can reference these acceptors directly. Otherwise, you have to add
       # one explicitly to the tool using {Tool#add_acceptor}.
       #
-      OPTPARSER_ACCEPTORS = [
-        ::Object,
-        ::NilClass,
-        ::String,
-        ::Integer,
-        ::Float,
-        ::Numeric,
-        ::TrueClass,
-        ::FalseClass,
-        ::Array,
-        ::Regexp,
-        ::OptionParser::DecimalInteger,
-        ::OptionParser::OctalInteger,
-        ::OptionParser::DecimalNumeric
-      ].freeze
+      OPTPARSER_ACCEPTORS = ::Set.new(
+        [
+          ::Object,
+          ::NilClass,
+          ::String,
+          ::Integer,
+          ::Float,
+          ::Numeric,
+          ::TrueClass,
+          ::FalseClass,
+          ::Array,
+          ::Regexp,
+          ::OptionParser::DecimalInteger,
+          ::OptionParser::OctalInteger,
+          ::OptionParser::DecimalNumeric
+        ]
+      ).freeze
 
       ##
       # Create a new tool.
@@ -78,16 +81,18 @@ module Toys
         @long_desc = []
 
         @default_data = {}
-        @acceptors = {}
-        OPTPARSER_ACCEPTORS.each { |a| @acceptors[a] = a }
         @used_flags = []
 
+        @acceptors = {}
         @mixins = {}
+        @templates = {}
 
         @flag_definitions = []
         @required_arg_definitions = []
         @optional_arg_definitions = []
         @remaining_args_definition = nil
+
+        @disable_argument_parsing = false
         @runnable = false
       end
 
@@ -239,6 +244,14 @@ module Toys
         @definition_finished
       end
 
+      ##
+      # Returns true if this tool has disabled argument parsing.
+      # @return [Boolean]
+      #
+      def argument_parsing_disabled?
+        @disable_argument_parsing
+      end
+
       ##
       # Returns all arg definitions in order: required, optional, remaining.
       # @return [Array<Toys::Definition::Arg>]
@@ -264,6 +277,46 @@ module Toys
         result.uniq
       end
 
+      ##
+      # Resolve the given acceptor. You may pass in a
+      # {Toys::Definition::Acceptor}, an acceptor name, a well-known acceptor
+      # understood by OptionParser, or `nil`.
+      #
+      # Returns either `nil` or an acceptor that is usable by OptionParser.
+      #
+      # If an acceptor name is given, it may be resolved by this tool or any of
+      # its ancestors. Raises {Toys::ToolDefinitionError} if the name is not
+      # recognized.
+      #
+      # @param [Object] accept An acceptor input.
+      # @return [Object] The resolved acceptor.
+      #
+      def resolve_acceptor(accept)
+        return accept if accept.nil? || accept.is_a?(Acceptor)
+        name = accept
+        accept = @acceptors.fetch(name) do |k|
+          if @parent
+            @parent.resolve_acceptor(k)
+          elsif OPTPARSER_ACCEPTORS.include?(k)
+            k
+          end
+        end
+        if accept.nil?
+          raise ToolDefinitionError, "Unknown acceptor: #{name.inspect}"
+        end
+        accept
+      end
+
+      ##
+      # Get the named template from this tool or its ancestors.
+      #
+      # @param [String] name The template name
+      # @return [Class,nil] The template class, or `nil` if not found.
+      #
+      def resolve_template(name)
+        @templates.fetch(name.to_s) { |k| @parent ? @parent.resolve_template(k) : nil }
+      end
+
       ##
       # Get the named mixin from this tool or its ancestors.
       #
@@ -335,6 +388,11 @@ module Toys
       # @param [Toys::Definition::Acceptor] acceptor The acceptor to add.
       #
       def add_acceptor(acceptor)
+        if @acceptors.key?(acceptor.name)
+          raise ToolDefinitionError,
+                "An acceptor named #{acceptor.name.inspect} has already been" \
+                " defined in tool #{display_name.inspect}."
+        end
         @acceptors[acceptor.name] = acceptor
         self
       end
@@ -346,7 +404,44 @@ module Toys
       # @param [Module] mixin_module The mixin module.
       #
       def add_mixin(name, mixin_module)
-        @mixins[name.to_s] = mixin_module
+        name = name.to_s
+        if @mixins.key?(name)
+          raise ToolDefinitionError,
+                "A mixin named #{name.inspect} has already been defined in tool" \
+                " #{display_name.inspect}."
+        end
+        @mixins[name] = mixin_module
+        self
+      end
+
+      ##
+      # Add a named template class to this tool.
+      #
+      # @param [String] name The name of the template.
+      # @param [Class] template_class The template class.
+      #
+      def add_template(name, template_class)
+        name = name.to_s
+        if @templates.key?(name)
+          raise ToolDefinitionError,
+                "A template named #{name.inspect} has already been defined in tool" \
+                " #{display_name.inspect}."
+        end
+        @templates[name] = template_class
+        self
+      end
+
+      ##
+      # Disable argument parsing for this tool
+      #
+      def disable_argument_parsing
+        check_definition_state
+        if includes_arguments?
+          raise ToolDefinitionError,
+                "Cannot disable argument parsing for tool #{display_name.inspect}" \
+                " because arguments have already been defined."
+        end
+        @disable_argument_parsing = true
         self
       end
 
@@ -385,7 +480,7 @@ module Toys
                    accept: nil, default: nil, handler: nil,
                    report_collisions: true,
                    desc: nil, long_desc: nil)
-        check_definition_state
+        check_definition_state(is_arg: true)
         accept = resolve_acceptor(accept)
         flag_def = Definition::Flag.new(key, flags, @used_flags, report_collisions,
                                         accept, handler, default)
@@ -404,6 +499,7 @@ module Toys
       # @param [String...] flags The flags to disable
       #
       def disable_flag(*flags)
+        check_definition_state(is_arg: true)
         flags = flags.uniq
         intersection = @used_flags & flags
         unless intersection.empty?
@@ -435,7 +531,7 @@ module Toys
       #     formats. Defaults to the empty array.
       #
       def add_required_arg(key, accept: nil, display_name: nil, desc: nil, long_desc: nil)
-        check_definition_state
+        check_definition_state(is_arg: true)
         accept = resolve_acceptor(accept)
         arg_def = Definition::Arg.new(key, :required, accept, nil, desc, long_desc, display_name)
         @required_arg_definitions << arg_def
@@ -469,7 +565,7 @@ module Toys
       #
       def add_optional_arg(key, default: nil, accept: nil, display_name: nil,
                            desc: nil, long_desc: nil)
-        check_definition_state
+        check_definition_state(is_arg: true)
         accept = resolve_acceptor(accept)
         arg_def = Definition::Arg.new(key, :optional, accept, default,
                                       desc, long_desc, display_name)
@@ -504,7 +600,7 @@ module Toys
       #
       def set_remaining_args(key, default: [], accept: nil, display_name: nil,
                              desc: nil, long_desc: nil)
-        check_definition_state
+        check_definition_state(is_arg: true)
         accept = resolve_acceptor(accept)
         arg_def = Definition::Arg.new(key, :remaining, accept, default,
                                       desc, long_desc, display_name)
@@ -557,19 +653,16 @@ module Toys
         proc { middleware.config(self, loader, &next_config) }
       end
 
-      def check_definition_state
+      def check_definition_state(is_arg: false)
         if @definition_finished
           raise ToolDefinitionError,
                 "Defintion of tool #{display_name.inspect} is already finished"
         end
-      end
-
-      def resolve_acceptor(accept)
-        return accept if accept.nil? || accept.is_a?(Acceptor)
-        unless @acceptors.key?(accept)
-          raise ToolDefinitionError, "Unknown acceptor: #{accept.inspect}"
+        if is_arg && argument_parsing_disabled?
+          raise ToolDefinitionError,
+                "Tool #{display_name.inspect} has disabled argument parsing"
         end
-        @acceptors[accept]
+        self
       end
     end
   end

data/lib/toys/dsl/tool.rb

@@ -139,6 +139,30 @@ module Toys
         self
       end
 
+      ##
+      # Create a named template class.
+      # This template may be expanded by name in this tool or any subtool.
+      #
+      # You should pass a block and define the template in that block. You do
+      # not need to include `Toys::Template` in the block. Otherwise, see
+      # {Toys::Template} for information on defining a template. In general,
+      # the block should define an initialize method, and call `to_expand` to
+      # define how to expand the template.
+      #
+      # @param [String] name Name of the template
+      #
+      def template(name, &block)
+        cur_tool = DSL::Tool.activate_tool(self)
+        if cur_tool
+          template_class = ::Class.new do
+            include ::Toys::Template
+          end
+          template_class.class_eval(&block)
+          cur_tool.add_template(name, template_class)
+        end
+        self
+      end
+
       ##
       # Create a subtool. You must provide a block defining the subtool.
       #
@@ -170,19 +194,6 @@ module Toys
         self
       end
 
-      ##
-      # Create an alias of the current tool.
-      #
-      # @param [String] word The name of the alias
-      #
-      def alias_as(word)
-        if @__words.empty?
-          raise ToolDefinitionError, "Cannot make an alias of the root."
-        end
-        @__loader.make_alias(@__words[0..-2] + [word.to_s], @__words, @__priority)
-        self
-      end
-
       ##
       # Include another config file or directory at the current location.
       #
@@ -204,12 +215,14 @@ module Toys
       # @param [Object...] args Template arguments
       #
       def expand(template_class, *args)
-        unless template_class.is_a?(::Class)
-          name = template_class.to_s
+        name = template_class.to_s
+        if template_class.is_a?(::String)
+          template_class = cur_tool.resolve_template(template_class)
+        elsif template_class.is_a?(::Symbol)
           template_class = @__loader.resolve_standard_template(name)
-          if template_class.nil?
-            raise ToolDefinitionError, "Template name not found: #{name.inspect}"
-          end
+        end
+        if template_class.nil?
+          raise ToolDefinitionError, "Template not found: #{name.inspect}"
         end
         template = template_class.new(*args)
         yield template if block_given?
@@ -446,6 +459,47 @@ module Toys
       end
       alias remaining remaining_args
 
+      ##
+      # Set an option value statically.
+      #
+      # @param [Symbol] key The key to use to retrieve the value from the
+      #     execution context.
+      # @param [Object] value The value to set.
+      #
+      def set(key, value)
+        cur_tool = DSL::Tool.activate_tool(self)
+        return self if cur_tool.nil?
+        cur_tool.default_data[key] = value
+        self
+      end
+
+      ##
+      # Disable argument parsing for this tool. Arguments will not be parsed
+      # and the options will not be populated. Instead, tools can retrieve the
+      # full unparsed argument list by calling {Toys::Tool#args}.
+      #
+      # This directive is mutually exclusive with any of the directives that
+      # declare arguments or flags.
+      #
+      def disable_argument_parsing
+        cur_tool = DSL::Tool.activate_tool(self)
+        cur_tool.disable_argument_parsing unless cur_tool.nil?
+        self
+      end
+
+      ##
+      # Mark one or more flags as disabled, preventing their use by any
+      # subsequent flag definition. This may be used to prevent middleware from
+      # defining a particular flag.
+      #
+      # @param [String...] flags The flags to disable
+      #
+      def disable_flag(*flags)
+        cur_tool = DSL::Tool.activate_tool(self)
+        cur_tool.disable_flag(*flags) unless cur_tool.nil?
+        self
+      end
+
       ##
       # Specify how to run this tool. You may do this by providing a block to
       # this directive, or by defining the `run` method in the tool.
@@ -480,6 +534,17 @@ module Toys
         super(mod)
       end
 
+      ##
+      # Activate the given gem. If it is not present, attempt to install it (or
+      # inform the user to update the bundle).
+      #
+      # @param [String] name Name of the gem
+      # @param [String...] requirements Version requirements
+      #
+      def gem(name, *requirements)
+        (@__gems ||= Utils::Gems.new).activate(name, *requirements)
+      end
+
       ## @private
       def self.new_class(words, priority, loader)
         tool_class = ::Class.new(::Toys::Tool)

data/lib/toys/input_file.rb

@@ -44,12 +44,15 @@ module Toys::InputFile # rubocop:disable Style/ClassAndModuleChildren
       include ::Toys::Tool::Keys
       @tool_class = tool_class
     end
-    name = "M#{namespace.object_id}"
+    basename = ::File.basename(path).tr(".-", "_").gsub(/\W/, "")
+    name = "M#{namespace.object_id}_#{basename}"
     const_set(name, namespace)
     str = <<-STR
-      module #{name}; @tool_class.class_eval do
-      #{::IO.read(path)}
-      end end
+      module #{name}
+        @tool_class.class_eval do
+          #{::IO.read(path)}
+        end
+      end
     STR
     ::Toys::DSL::Tool.prepare(tool_class, remaining_words, path) do
       ::Toys::ContextualError.capture_path("Error while loading Toys config!", path) do

data/lib/toys/runner.rb

@@ -59,7 +59,7 @@ module Toys
     #
     def run(args, verbosity: 0)
       data = create_data(args, verbosity)
-      parse_args(args, data)
+      parse_args(args, data) unless @tool_definition.argument_parsing_disabled?
       tool = @tool_definition.tool_class.new(@cli, data)
 
       original_level = @cli.logger.level

data/lib/toys/standard_mixins/exec.rb

@@ -89,21 +89,49 @@ module Toys
       # @return [Toys::Utils::Exec::Result] The subprocess result, including
       #     the exit code and any captured output.
       #
-      def ruby(args, opts = {}, &block)
-        Exec._exec(self).ruby(args, Exec._setup_exec_opts(opts, self), &block)
+      def exec_ruby(args, opts = {}, &block)
+        Exec._exec(self).exec_ruby(args, Exec._setup_exec_opts(opts, self), &block)
       end
+      alias ruby exec_ruby
 
       ##
-      # Execute the given string in a shell. Returns the exit code.
+      # Execute a proc in a subprocess.
       #
-      # @param [String] cmd The shell command to execute.
+      # If you provide a block, a {Toys::Utils::Exec::Controller} will be
+      # yielded to it, allowing you to interact with the subprocess streams.
+      #
+      # @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 [Integer] The exit code
+      # @return [Toys::Utils::Exec::Result] The subprocess result, including
+      #     exit code and any captured output.
       #
-      def sh(cmd, opts = {})
-        Exec._exec(self).sh(cmd, Exec._setup_exec_opts(opts, self))
+      def exec_proc(func, opts = {}, &block)
+        Exec._exec(self).exec_proc(func, Exec._setup_exec_opts(opts, self), &block)
+      end
+
+      ##
+      # 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.
+      #
+      # @param [String,Array<String>] cmd The tool 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 [Toys::Utils::Exec::Result] The subprocess result, including
+      #     exit code and any captured output.
+      #
+      def exec_tool(cmd, opts = {}, &block)
+        func = Exec._make_tool_caller(cmd)
+        Exec._exec(self).exec_proc(func, Exec._setup_exec_opts(opts, self), &block)
       end
 
       ##
@@ -122,6 +150,66 @@ module Toys
         Exec._exec(self).capture(cmd, Exec._setup_exec_opts(opts, self))
       end
 
+      ##
+      # Spawn a ruby process and pass the given arguments to it.
+      #
+      # Captures standard out and returns it as a string.
+      #
+      # @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.
+      #
+      # @return [String] What was written to standard out.
+      #
+      def capture_ruby(args, opts = {})
+        Exec._exec(self).capture_ruby(args, Exec._setup_exec_opts(opts, self))
+      end
+
+      ##
+      # Execute a proc in a subprocess.
+      #
+      # Captures standard out and returns it as a string.
+      #
+      # @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.
+      #
+      # @return [String] What was written to standard out.
+      #
+      def capture_proc(func, opts = {})
+        Exec._exec(self).capture_proc(func, Exec._setup_exec_opts(opts, self))
+      end
+
+      ##
+      # 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.
+      #
+      # Captures standard out and returns it as a string.
+      #
+      # @param [String,Array<String>] cmd The tool to execute.
+      # @param [Hash] opts The command options. See the section on
+      #     configuration options in the {Toys::Utils::Exec} module docs.
+      #
+      # @return [String] What was written to standard out.
+      #
+      def capture_tool(cmd, opts = {})
+        func = Exec._make_tool_caller(cmd)
+        Exec._exec(self).capture_proc(func, Exec._setup_exec_opts(opts, self))
+      end
+
+      ##
+      # Execute the given string in a shell. Returns the exit code.
+      #
+      # @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.
+      #
+      # @return [Integer] The exit code
+      #
+      def sh(cmd, opts = {})
+        Exec._exec(self).sh(cmd, Exec._setup_exec_opts(opts, self))
+      end
+
       ##
       # Exit if the given status code is nonzero. Otherwise, returns 0.
       #
@@ -137,10 +225,21 @@ module Toys
       ## @private
       def self._exec(tool)
         tool[Exec] ||= Utils::Exec.new do |k|
-          k == :logger ? tool[Tool::Keys::LOGGER] : nil
+          case k
+          when :logger
+            tool[Tool::Keys::LOGGER]
+          when :cli
+            tool[Tool::Keys::CLI]
+          end
         end
       end
 
+      ## @private
+      def self._make_tool_caller(cmd)
+        cmd = ::Shellwords.split(cmd) if cmd.is_a?(::String)
+        proc { |config| ::Kernel.exit(config[:cli].run(*cmd)) }
+      end
+
       ## @private
       def self._setup_exec_opts(opts, tool)
         return opts unless opts.key?(:exit_on_nonzero_status)

data/lib/toys/template.rb

@@ -99,6 +99,7 @@ module Toys
   module Template
     ## @private
     def self.included(mod)
+      return if mod.respond_to?(:to_expand)
       mod.extend(ClassMethods)
       mod.include(Tool::Keys)
     end

data/lib/toys/tool.rb

@@ -269,6 +269,17 @@ module Toys
       key.is_a?(::Symbol) || key.is_a?(::String) ? @__data[key] : nil
     end
 
+    ##
+    # Activate the given gem. If it is not present, attempt to install it (or
+    # inform the user to update the bundle).
+    #
+    # @param [String] name Name of the gem
+    # @param [String...] requirements Version requirements
+    #
+    def gem(name, *requirements)
+      (@__data[Utils::Gems] ||= Utils::Gems.new).activate(name, *requirements)
+    end
+
     ##
     # Exit immediately with the given status code
     #

data/lib/toys/utils/exec.rb

@@ -28,6 +28,7 @@
 ;
 
 require "logger"
+require "shellwords"
 
 module Toys
   module Utils
@@ -187,22 +188,32 @@ module Toys
       # @return [Toys::Utils::Exec::Result] The subprocess result, including
       #     exit code and any captured output.
       #
-      def ruby(args, opts = {}, &block)
+      def exec_ruby(args, opts = {}, &block)
         cmd = args.is_a?(::Array) ? [::RbConfig.ruby] + args : "#{::RbConfig.ruby} #{args}"
-        exec(cmd, {argv0: "ruby"}.merge(opts), &block)
+        log_cmd = args.is_a?(::Array) ? ["ruby"] + args : "ruby #{args}"
+        exec(cmd, {argv0: "ruby", log_cmd: log_cmd}.merge(opts), &block)
       end
+      alias ruby exec_ruby
 
       ##
-      # Execute the given string in a shell. Returns the exit code.
+      # Execute a proc in a fork.
       #
-      # @param [String] cmd The shell command to execute.
+      # If you provide a block, a {Toys::Utils::Exec::Controller} will be
+      # yielded to it, allowing you to interact with the subprocess streams.
+      #
+      # @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 [Integer] The exit code
+      # @return [Toys::Utils::Exec::Result] The subprocess result, including
+      #     exit code and any captured output.
       #
-      def sh(cmd, opts = {})
-        exec(cmd, opts).exit_code
+      def exec_proc(func, opts = {}, &block)
+        exec_opts = Opts.new(@default_opts).add(opts)
+        executor = Executor.new(exec_opts, func)
+        executor.execute(&block)
       end
 
       ##
@@ -221,6 +232,49 @@ module Toys
         exec(cmd, opts.merge(out: :capture)).captured_out
       end
 
+      ##
+      # Spawn a ruby process and pass the given arguments to it.
+      #
+      # Captures standard out and returns it as a string.
+      #
+      # @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.
+      #
+      # @return [String] What was written to standard out.
+      #
+      def capture_ruby(args, opts = {})
+        ruby(args, opts.merge(out: :capture)).captured_out
+      end
+
+      ##
+      # Execute a proc in a fork.
+      #
+      # Captures standard out and returns it as a string.
+      #
+      # @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.
+      #
+      # @return [String] What was written to standard out.
+      #
+      def capture_proc(func, opts = {})
+        exec_proc(func, opts.merge(out: :capture)).captured_out
+      end
+
+      ##
+      # Execute the given string in a shell. Returns the exit code.
+      #
+      # @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.
+      #
+      # @return [Integer] The exit code
+      #
+      def sh(cmd, opts = {})
+        exec(cmd, opts).exit_code
+      end
+
       ##
       # An internal helper class storing the configuration of a subprocess invocation
       # @private
@@ -232,10 +286,12 @@ module Toys
         #
         CONFIG_KEYS = %i[
           argv0
+          cli
           env
           err
           in
           logger
+          log_cmd
           log_level
           nonzero_status_handler
           out
@@ -414,21 +470,25 @@ module Toys
       #
       class Executor
         def initialize(exec_opts, spawn_cmd)
-          @spawn_cmd = spawn_cmd
+          @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
           @spawn_opts = exec_opts.spawn_opts
           @captures = {}
           @controller_streams = {}
           @join_threads = []
           @child_streams = []
+          @parent_streams = []
         end
 
         def execute(&block)
           setup_in_stream
-          setup_out_stream(:out)
-          setup_out_stream(:err)
+          setup_out_stream(:out, $stdout, 1)
+          setup_out_stream(:err, $stderr, 2)
           log_command
-          wait_thread = start_process
+          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)
         end
@@ -438,8 +498,9 @@ module Toys
         def log_command
           logger = @config_opts[:logger]
           if logger && @config_opts[:log_level] != false
-            cmd_str = @spawn_cmd.size == 1 ? @spawn_cmd.first : @spawn_cmd.inspect
-            logger.add(@config_opts[:log_level] || ::Logger::INFO, cmd_str)
+            cmd_str = @config_opts[:log_cmd]
+            cmd_str ||= @spawn_cmd.size == 1 ? @spawn_cmd.first : @spawn_cmd.inspect if @spawn_cmd
+            logger.add(@config_opts[:log_level] || ::Logger::INFO, cmd_str) if cmd_str
           end
         end
 
@@ -447,9 +508,107 @@ module Toys
           args = []
           args << @config_opts[:env] if @config_opts[:env]
           args.concat(@spawn_cmd)
-          pid = ::Process.spawn(*args, @spawn_opts)
-          @child_streams.each(&:close)
-          ::Process.detach(pid)
+          ::Process.spawn(*args, @spawn_opts)
+        end
+
+        def start_fork
+          pid = ::Process.fork
+          return pid unless pid.nil?
+          exit_code = -1
+          begin
+            setup_env_within_fork
+            setup_streams_within_fork
+            exit_code = run_fork_func
+          rescue ::SystemExit => e
+            exit_code = e.status
+          rescue ::Exception => e # rubocop:disable Lint/RescueException
+            warn(([e.inspect] + e.backtrace).join("\n"))
+          ensure
+            ::Kernel.exit!(exit_code)
+          end
+        end
+
+        def run_fork_func
+          catch(:result) do
+            if @spawn_opts[:chdir]
+              ::Dir.chdir(@spawn_opts[:chdir]) { @fork_func.call(@config_opts) }
+            else
+              @fork_func.call(@config_opts)
+            end
+            0
+          end
+        end
+
+        def setup_env_within_fork
+          if @config_opts[:unsetenv_others]
+            ::ENV.each_key do |k|
+              ::ENV.delete(k) unless @config_opts.key?(k)
+            end
+          end
+          (@config_opts[:env] || {}).each { |k, v| ::ENV[k.to_s] = v.to_s }
+        end
+
+        def setup_streams_within_fork
+          @parent_streams.each(&:close)
+          setup_in_stream_within_fork(@spawn_opts[:in])
+          out_stream = interpret_out_stream_within_fork(@spawn_opts[:out])
+          err_stream = interpret_out_stream_within_fork(@spawn_opts[:err])
+          if out_stream == :close
+            $stdout.close
+          elsif out_stream
+            $stdout.reopen(out_stream)
+            $stdout.sync = true
+          end
+          if err_stream == :close
+            $stderr.close
+          elsif err_stream
+            $stderr.reopen(err_stream)
+            $stderr.sync = true
+          end
+        end
+
+        def setup_in_stream_within_fork(stream)
+          in_stream =
+            case stream
+            when ::Integer
+              ::IO.open(stream)
+            when ::Array
+              ::File.open(*stream)
+            when ::String
+              ::File.open(stream, "r")
+            when :close
+              :close
+            else
+              stream if stream.respond_to?(:write)
+            end
+          if in_stream == :close
+            $stdin.close
+          elsif in_stream
+            $stdin.reopen(in_stream)
+          end
+        end
+
+        def interpret_out_stream_within_fork(stream)
+          case stream
+          when ::Integer
+            ::IO.open(stream)
+          when ::Array
+            if stream.first == :child
+              if stream[1] == :err
+                $stderr
+              elsif stream[1] == :out
+                $stdout
+              end
+            else
+              ::File.open(*stream)
+            end
+          when ::String
+            ::File.open(stream, "w")
+          when :close
+            :close
+          else
+            stream if stream.respond_to?(:write)
+          end
         end
 
         def control_process(wait_thread)
@@ -476,6 +635,10 @@ module Toys
 
         def setup_in_stream
           setting = @config_opts[:in]
+          if setting.nil?
+            return if $stdin.respond_to?(:fileno) && $stdin.fileno.zero?
+            setting = $stdin
+          end
           return unless setting
           case setting
           when ::Symbol
@@ -540,9 +703,12 @@ module Toys
           @spawn_opts[:in] = args + [::File::RDONLY]
         end
 
-        def setup_out_stream(key)
+        def setup_out_stream(key, stdstream, stdfileno)
           setting = @config_opts[key]
-          return unless setting
+          if setting.nil?
+            return if setting.respond_to?(:fileno) && setting.fileno == stdfileno
+            setting = stdstream
+          end
           case setting
           when ::Symbol
             setup_out_stream_of_type(key, setting, [])
@@ -617,6 +783,7 @@ module Toys
           r, w = ::IO.pipe
           @spawn_opts[:in] = r
           @child_streams << r
+          @parent_streams << w
           w.sync = true
           w
         end
@@ -625,6 +792,7 @@ module Toys
           r, w = ::IO.pipe
           @spawn_opts[key] = w
           @child_streams << w
+          @parent_streams << r
           r
         end
 

data/lib/toys/utils/gems.rb

@@ -74,7 +74,8 @@ module Toys
       end
 
       ##
-      # Activate the given gem.
+      # Activate the given gem. If it is not present, attempt to install it (or
+      # inform the user to update the bundle).
       #
       # @param [String] name Name of the gem
       # @param [String...] requirements Version requirements

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: toys-core
 version: !ruby/object:Gem::Version
-  version: 0.3.8
+  version: 0.3.9
 platform: ruby
 authors:
 - Daniel Azuma
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-11 00:00:00.000000000 Z
+date: 2018-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest