toys-core 0.11.5 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ae396604e3a0005b460ad94f95187b603f36e8d10d1147da2a78b069232f7963
-  data.tar.gz: 267209d6e7ab4575053219eee5fb1c6be47b9bd6ac6468b6da5c9abb9ed227c2
+  metadata.gz: 68a552244c25e03216c7bf958a7ccd2a35bb7fb3795a02e77c4a839b7720e258
+  data.tar.gz: 58513ce7d5d60646a1b9e51235d04df470ee5d9317a9a72048a8e95872227da0
 SHA512:
-  metadata.gz: 527f51e0e679f93786ecd671ff14386615e2014e0dbd4995fd4bb6e58040cb00b27d83d3721c412eb8cc83fdc82fe7dff63c97e0e3d8bca8f8b8d7b04a5d9f41
-  data.tar.gz: 07c617895710b6f5dd69c6fdb16613c2ed7474361a1cbd8617ae1d271eca647ffa457e77bec7e1b30915b1e01ad25173c74251f1728f261a5d5565ca29b80d68
+  metadata.gz: 299c193de07d0802046029c7b305a1e4cecac715eee32d259a917b6ecc2505975ba10a2aca90b510036076d9f32b58849a02381ae61837336eee5361cd2126ea
+  data.tar.gz: b42a4d81db4a71a136deafd4a62f0e7087325097a1c3e7473a5b7edda699b08ee1c8d81377765a70d8a18fd0a2693874781418f9953ca52f92cced670bec1421

data/CHANGELOG.md

@@ -1,5 +1,67 @@
 # Release History
 
+### v0.13.0 / 2022-02-08
+
+Toys-Core 0.13.0 is a major release with significant improvements to the git cache, along with compatibility improvements and bug fixes.
+
+New functionality:
+
+* The `load_git` directive and the underlying `Toys::Utils::GitCache` class now support updating from git based on cache age.
+* The `Toys::Utils::GitCache` class supports copying git content into a provided directory, querying repo information, and deleting cache data.
+* The `Toys::Utils::GitCache` class makes files read-only, to help prevent clients from interfering with one another.
+* The `:terminal` mixin and the underlying `Toys::Utils::Terminal` class now honor the `NO_COLOR` environment variable.
+* Added `Toys::CLI#load_tool`, which is useful for testing tools.
+
+Fixes and compatibility updates:
+
+* Bundler install/updates are now spawned in subprocesses for compatibility with bundler 2.3. The bundler integration also now requires bundler 2.2 or later.
+* The `exec_tool` and `exec_proc` methods in the `:exec` mixin now log their execution in the same way as other exec functions.
+* Minor compatibility fixes to provide partial support for TruffleRuby.
+
+Other notes:
+
+* The internal GitCache representation has changed significantly to support additional features and improve robustness and performance. This will force existing caches to update, but should not break existing usage.
+
+### v0.12.2 / 2021-08-30
+
+* FIXED: Tool context inspect string is no longer overwhelmingly long
+* FIXED: Fixed an exception in GitCache when updating a changed ref
+
+### v0.12.1 / 2021-08-17
+
+* FIXED: Fixed a regression in 0.12.0 where bundler could use the wrong Gemfile if you set a custom context directory
+
+### v0.12.0 / 2021-08-05
+
+Toys-Core 0.12.0 is a major release with significant new features and bug fixes, and a few breaking interface changes. Additionally, this release now requires Ruby 2.4 or later.
+
+Breaking interface changes:
+
+* The Toys::Tool class has been renamed Toys::ToolDefinition so that the old name can be used for class-based tool definition.
+* Tool definition now raises ToolDefinitionError if whitespace, control characters, or certain punctuation are used in a tool name.
+* Toys::Loader#add_path no longer supports multiple paths. Use add_path_set instead.
+* The "name" argument was renamed to "source_name" in Toys::Loader#add_block and Toys::CLI#add_config_block
+
+New functionality:
+
+* The DSL now supports a class-based tool definition syntax (in addition to the existing block-based syntax). Some users may prefer this new class-based style as more Ruby-like.
+* You can now load tools from a remote git repository using the load_git directive.
+* Whitespace is now automatically considered a name delimiter when defining tools.
+* There is now an extensible settings mechanism to activate less-common tool behavior. Currently there is one setting, which causes subtools to inherit their parent's methods by default.
+* The load directive can load into a new tool.
+* Added a new utility class and mixin that provides XDG Base Directory information.
+* Added a new utility class and mixin that provides cached access to remote git repos.
+* The help text generator now supports splitting the subtool list by source.
+* Loader and CLI methods that add tool configs now uniformly provide optional source_name and context_directory arguments.
+* Toys::SourceInfo now supports getting the root ancestor and priority of a source.
+* Toys::ToolDefinition now has a direct accessor for the source root. This is always set for a tool, even if it isn't marked as finished.
+
+Fixes:
+
+* Fixed some bundler integration issues that occurred when the bundle is being installed in a separate path such as a vendor directory.
+* Toys::ContextualError now includes the full backtrace of the cause.
+* Cleaned up some unused memory objects during tool loading and lookup.
+
 ### v0.11.5 / 2021-03-28
 
 * BREAKING CHANGE: The exit_on_nonzero_status option to exec now exits on signals and failures to spawn, in addition to error codes.

data/LICENSE.md

@@ -1,6 +1,6 @@
 # License
 
-Copyright 2019-2020 Daniel Azuma and the Toys contributors
+Copyright 2019-2022 Daniel Azuma and the Toys contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -34,11 +34,14 @@ Install the **toys-core** gem using:
 You may also install the **toys** gem, which brings in **toys-core** as a
 dependency.
 
-Toys-Core requires Ruby 2.3 or later.
+Toys-Core requires Ruby 2.4 or later.
 
 Most parts of Toys-Core work on JRuby. However, JRuby is not recommended
 because of JVM boot latency, lack of support for Kernel#fork, and other issues.
 
+Most parts of Toys-Core work on TruffleRuby. However, TruffleRuby is not
+recommended because it has a few known bugs that affect Toys.
+
 ### Create a new executable
 
 We'll start by creating an executable Ruby script. Using your favorite text
@@ -338,7 +341,7 @@ templates, and middleware, in the
 
 ## License
 
-Copyright 2019-2020 Daniel Azuma and the Toys contributors
+Copyright 2019-2022 Daniel Azuma and the Toys contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/docs/guide.md

@@ -31,7 +31,7 @@ sophisticated command line tools.
 
 Toys-Core is a command line *framework* in the traditional sense. It is
 intended to be used to write custom command line executables in Ruby. The
-framework provides common facilities such as argumentparsing and online help,
+framework provides common facilities such as argument parsing and online help,
 while your executable chooses and configures those facilities, and implements
 the actual behavior.
 

data/lib/toys/acceptor.rb

@@ -178,6 +178,7 @@ module Toys
 
       ##
       # Overrides {Toys::Acceptor::Base#match} to use the given function.
+      #
       # @private
       #
       def match(str)
@@ -188,6 +189,7 @@ module Toys
       ##
       # Overrides {Toys::Acceptor::Base#convert} to use the given function's
       # result.
+      #
       # @private
       #
       def convert(_str, result)
@@ -234,6 +236,7 @@ module Toys
 
       ##
       # Overrides {Toys::Acceptor::Base#match} to use the given regex.
+      #
       # @private
       #
       def match(str)
@@ -242,6 +245,7 @@ module Toys
 
       ##
       # Overrides {Toys::Acceptor::Base#convert} to use the given converter.
+      #
       # @private
       #
       def convert(str, *extra)
@@ -285,6 +289,7 @@ module Toys
 
       ##
       # Overrides {Toys::Acceptor::Base#match} to find the value.
+      #
       # @private
       #
       def match(str)
@@ -294,6 +299,7 @@ module Toys
       ##
       # Overrides {Toys::Acceptor::Base#convert} to return the actual enum
       # element.
+      #
       # @private
       #
       def convert(_str, elem)
@@ -303,6 +309,7 @@ module Toys
       ##
       # Overrides {Toys::Acceptor::Base#suggestions} to return close matches
       # from the enum.
+      #
       # @private
       #
       def suggestions(str)
@@ -513,7 +520,9 @@ module Toys
         internal_create(spec, options, block)
       end
 
-      ## @private
+      ##
+      # @private
+      #
       def scalarize_spec(spec, options, block)
         spec ||= block
         if options.empty?
@@ -602,11 +611,11 @@ module Toys
         Simple.new(type_desc: "boolean", well_known_spec: spec) do |s|
           if s.nil?
             default
+          elsif s.empty?
+            REJECT
           else
             s = s.downcase
-            if s.empty?
-              REJECT
-            elsif TRUE_STRINGS.any? { |t| t.start_with?(s) }
+            if TRUE_STRINGS.any? { |t| t.start_with?(s) }
               true
             elsif FALSE_STRINGS.any? { |f| f.start_with?(s) }
               false

data/lib/toys/arg_parser.rb

@@ -261,7 +261,7 @@ module Toys
       # @param message [String] The message. Required.
       #
       def initialize(message)
-        super(message)
+        super(message, name: nil)
       end
     end
 
@@ -269,7 +269,7 @@ module Toys
     # Create an argument parser for a particular tool.
     #
     # @param cli [Toys::CLI] The CLI in effect.
-    # @param tool [Toys::Tool] The tool defining the argument format.
+    # @param tool [Toys::ToolDefinition] The tool defining the argument format.
     # @param default_data [Hash] Additional initial data (such as verbosity).
     # @param require_exact_flag_match [Boolean] Whether to require flag matches
     #     be exact (not partial). Default is false.
@@ -295,7 +295,7 @@ module Toys
 
     ##
     # The tool definition governing this parser.
-    # @return [Toys::Tool]
+    # @return [Toys::ToolDefinition]
     #
     attr_reader :tool
 
@@ -417,6 +417,7 @@ module Toys
 
     REMAINING_HANDLER = ->(val, prev) { prev.is_a?(::Array) ? prev << val : [val] }
     ARG_HANDLER = ->(val, _prev) { val }
+    private_constant :REMAINING_HANDLER, :ARG_HANDLER
 
     def initial_data(cli, tool, default_data)
       data = {
@@ -429,7 +430,7 @@ module Toys
         Context::Key::TOOL_NAME => tool.full_name,
         Context::Key::USAGE_ERRORS => [],
       }
-      Compat.merge_clones(data, tool.default_data)
+      tool.default_data.each { |k, v| data[k] = v.clone }
       default_data.each { |k, v| data[k] ||= v }
       data
     end
@@ -450,7 +451,7 @@ module Toys
       case arg
       when "--"
         @flags_allowed = false
-      when /\A(--\w[\?\w-]*)=(.*)\z/
+      when /\A(--\w[?\w-]*)=(.*)\z/
         handle_valued_flag(::Regexp.last_match(1), ::Regexp.last_match(2))
       when /\A--.+\z/
         handle_plain_flag(arg)
@@ -474,8 +475,7 @@ module Toys
       return "" unless flag_def
       @seen_flag_keys << flag_def.key
       if flag_def.flag_type == :boolean
-        add_data(flag_def.key, flag_def.handler, nil, !flag_result.unique_flag_negative?,
-                 :flag, name)
+        add_data(flag_def.key, flag_def.handler, nil, !flag_result.unique_flag_negative?, :flag, name)
       elsif following.empty?
         if flag_def.value_type == :required || flag_result.unique_flag_syntax.value_delim == " "
           @active_flag_def = flag_def

data/lib/toys/cli.rb

@@ -78,8 +78,8 @@ module Toys
     #     with different verbosity settings (since the logger cannot have
     #     multiple level settings simultaneously). In that case, do not set a
     #     global logger, but use the `logger_factory` parameter instead.
-    # @param logger_factory [Proc] A proc that takes a {Toys::Tool} as an
-    #     argument, and returns a `Logger` to use when running that tool.
+    # @param logger_factory [Proc] A proc that takes a {Toys::ToolDefinition}
+    #     as an argument, and returns a `Logger` to use when running that tool.
     #     Optional. If not provided (and no global logger is set), CLI will use
     #     a default factory that writes generates loggers writing formatted
     #     output to `STDERR`, as defined by {Toys::CLI.default_logger_factory}.
@@ -175,26 +175,24 @@ module Toys
     #     Optional. If not provided, lib directories are disabled.
     #     Note: the standard toys executable sets this to `".lib"`.
     #
-    def initialize( # rubocop:disable Metrics/MethodLength
-      executable_name: nil,
-      middleware_stack: nil,
-      extra_delimiters: "",
-      config_dir_name: nil,
-      config_file_name: nil,
-      index_file_name: nil,
-      preload_file_name: nil,
-      preload_dir_name: nil,
-      data_dir_name: nil,
-      lib_dir_name: nil,
-      mixin_lookup: nil,
-      middleware_lookup: nil,
-      template_lookup: nil,
-      logger_factory: nil,
-      logger: nil,
-      base_level: nil,
-      error_handler: nil,
-      completion: nil
-    )
+    def initialize(executable_name: nil, # rubocop:disable Metrics/MethodLength
+                   middleware_stack: nil,
+                   extra_delimiters: "",
+                   config_dir_name: nil,
+                   config_file_name: nil,
+                   index_file_name: nil,
+                   preload_file_name: nil,
+                   preload_dir_name: nil,
+                   data_dir_name: nil,
+                   lib_dir_name: nil,
+                   mixin_lookup: nil,
+                   middleware_lookup: nil,
+                   template_lookup: nil,
+                   logger_factory: nil,
+                   logger: nil,
+                   base_level: nil,
+                   error_handler: nil,
+                   completion: nil)
       @executable_name = executable_name || ::File.basename($PROGRAM_NAME)
       @middleware_stack = middleware_stack || CLI.default_middleware_stack
       @mixin_lookup = mixin_lookup || CLI.default_mixin_lookup
@@ -321,10 +319,22 @@ module Toys
     #     a Toys directory.
     # @param high_priority [Boolean] Add the config at the head of the priority
     #     list rather than the tail.
+    # @param source_name [String] A custom name for the root source. Optional.
+    # @param context_directory [String,nil,:path,:parent] The context directory
+    #     for tools loaded from this path. You can pass a directory path as a
+    #     string, `:path` to denote the given path, `:parent` to denote the
+    #     given path's parent directory, or `nil` to denote no context.
+    #     Defaults to `:parent`.
     # @return [self]
     #
-    def add_config_path(path, high_priority: false)
-      @loader.add_path(path, high_priority: high_priority)
+    def add_config_path(path,
+                        high_priority: false,
+                        source_name: nil,
+                        context_directory: :parent)
+      @loader.add_path(path,
+                       high_priority: high_priority,
+                       source_name: source_name,
+                       context_directory: context_directory)
       self
     end
 
@@ -336,15 +346,24 @@ module Toys
     #
     # @param high_priority [Boolean] Add the config at the head of the priority
     #     list rather than the tail.
-    # @param name [String] The source name that will be shown in documentation
-    #     for tools defined in this block. If omitted, a default unique string
-    #     will be generated.
+    # @param source_name [String] The source name that will be shown in
+    #     documentation for tools defined in this block. If omitted, a default
+    #     unique string will be generated.
     # @param block [Proc] The block of configuration, executed in the context
     #     of the tool DSL {Toys::DSL::Tool}.
+    # @param context_directory [String,nil] The context directory for tools
+    #     loaded from this block. You can pass a directory path as a string, or
+    #     `nil` to denote no context. Defaults to `nil`.
     # @return [self]
     #
-    def add_config_block(high_priority: false, name: nil, &block)
-      @loader.add_block(high_priority: high_priority, name: name, &block)
+    def add_config_block(high_priority: false,
+                         source_name: nil,
+                         context_directory: nil,
+                         &block)
+      @loader.add_block(high_priority: high_priority,
+                        source_name: source_name,
+                        context_directory: context_directory,
+                        &block)
       self
     end
 
@@ -358,19 +377,28 @@ module Toys
     # @param search_path [String] A path to search for configs.
     # @param high_priority [Boolean] Add the configs at the head of the
     #     priority list rather than the tail.
+    # @param context_directory [String,nil,:path,:parent] The context directory
+    #     for tools loaded from this path. You can pass a directory path as a
+    #     string, `:path` to denote the given path, `:parent` to denote the
+    #     given path's parent directory, or `nil` to denote no context.
+    #     Defaults to `:path`.
     # @return [self]
     #
-    def add_search_path(search_path, high_priority: false)
+    def add_search_path(search_path,
+                        high_priority: false,
+                        context_directory: :path)
       paths = []
       if @config_file_name
         file_path = ::File.join(search_path, @config_file_name)
-        paths << file_path if !::File.directory?(file_path) && ::File.readable?(file_path)
+        paths << @config_file_name if !::File.directory?(file_path) && ::File.readable?(file_path)
       end
       if @config_dir_name
         dir_path = ::File.join(search_path, @config_dir_name)
-        paths << dir_path if ::File.directory?(dir_path) && ::File.readable?(dir_path)
+        paths << @config_dir_name if ::File.directory?(dir_path) && ::File.readable?(dir_path)
       end
-      @loader.add_path(paths, high_priority: high_priority)
+      @loader.add_path_set(search_path, paths,
+                           high_priority: high_priority,
+                           context_directory: context_directory)
       self
     end
 
@@ -416,6 +444,9 @@ module Toys
     #     run and what arguments to pass to it. You may pass either a single
     #     array of strings, or a series of string arguments.
     # @param verbosity [Integer] Initial verbosity. Default is 0.
+    # @param delegated_from [Toys::Context] The context from which this
+    #     execution is delegated. Optional. Should be set only if this is a
+    #     delegated execution.
     #
     # @return [Integer] The resulting process status code (i.e. 0 for success).
     #
@@ -427,101 +458,32 @@ module Toys
         "Error during tool execution!", tool.source_info&.source_path,
         tool_name: tool.full_name, tool_args: remaining
       ) do
-        default_data = {
-          Context::Key::VERBOSITY => verbosity,
-          Context::Key::DELEGATED_FROM => delegated_from,
-        }
-        run_tool(tool, remaining, default_data)
+        context = build_context(tool, remaining,
+                                verbosity: verbosity,
+                                delegated_from: delegated_from)
+        execute_tool(tool, context, &:run)
       end
     rescue ContextualError, ::Interrupt => e
       @error_handler.call(e).to_i
     end
 
-    private
-
     ##
-    # Run the given tool with the given arguments.
-    # Does not handle exceptions.
+    # Prepare a tool to be run, but just execute the given block rather than
+    # performing a full run of the tool. This is intended for testing tools.
+    # Unlike {#run}, this does not catch errors and perform error handling.
     #
-    # @param tool [Toys::Tool] The tool to run.
-    # @param args [Array<String>] Command line arguments passed to the tool.
-    # @param default_data [Hash] Initial tool context data.
-    # @return [Integer] The resulting status code
+    # @param args [String...] Command line arguments specifying which tool to
+    #     run and what arguments to pass to it. You may pass either a single
+    #     array of strings, or a series of string arguments.
+    # @yieldparam context [Toys::Context] Yields the tool context.
     #
-    def run_tool(tool, args, default_data)
-      arg_parser = ArgParser.new(self, tool,
-                                 default_data: default_data,
-                                 require_exact_flag_match: tool.exact_flag_match_required?)
-      arg_parser.parse(args).finish
-      context = tool.tool_class.new(arg_parser.data)
-      tool.source_info&.apply_lib_paths
-      tool.run_initializers(context)
-
-      cur_logger = context[Context::Key::LOGGER]
-      if cur_logger
-        original_level = cur_logger.level
-        cur_logger.level = (base_level || original_level) - context[Context::Key::VERBOSITY].to_i
-      end
-      begin
-        execute_tool_in_context(context, tool)
-      ensure
-        cur_logger.level = original_level if cur_logger
-      end
-    end
-
-    def execute_tool_in_context(context, tool)
-      executor = proc do
-        begin
-          if !context[Context::Key::USAGE_ERRORS].empty?
-            handle_usage_errors(context, tool)
-          elsif !tool.runnable?
-            raise NotRunnableError, "No implementation for tool #{tool.display_name.inspect}"
-          else
-            context.run
-          end
-        rescue ::Interrupt => e
-          raise e unless tool.handles_interrupts?
-          handle_interrupt(context, tool.interrupt_handler, e)
-        end
-      end
-      tool.built_middleware.reverse_each do |middleware|
-        executor = make_executor(middleware, context, executor)
-      end
-      catch(:result) do
-        executor.call
-        0
-      end
-    end
-
-    def handle_usage_errors(context, tool)
-      usage_errors = context[Context::Key::USAGE_ERRORS]
-      handler = tool.usage_error_handler
-      raise ArgParsingError, usage_errors if handler.nil?
-      handler = context.method(handler).to_proc if handler.is_a?(::Symbol)
-      if handler.arity.zero?
-        context.instance_exec(&handler)
-      else
-        context.instance_exec(usage_errors, &handler)
-      end
-    end
-
-    def handle_interrupt(context, handler, exception)
-      handler = context.method(handler).to_proc if handler.is_a?(::Symbol)
-      if handler.arity.zero?
-        context.instance_exec(&handler)
-      else
-        context.instance_exec(exception, &handler)
-      end
-    rescue ::Interrupt => e
-      raise e if e.equal?(exception)
-      handle_interrupt(context, handler, e)
-    end
-
-    def make_executor(middleware, context, next_executor)
-      if middleware.respond_to?(:run)
-        proc { middleware.run(context, &next_executor) }
-      else
-        next_executor
+    # @return [Object] The value returned from the block.
+    #
+    def load_tool(*args)
+      tool, remaining = @loader.lookup(args.flatten)
+      context = build_context(tool, remaining)
+      execute_tool(tool, context) do |ctx|
+        ctx.exit(yield ctx)
       end
     end
 
@@ -727,5 +689,93 @@ module Toys
         "#{styled_header}  #{msg}\n"
       end
     end
+
+    private
+
+    def build_context(tool, args, verbosity: 0, delegated_from: nil)
+      default_data = {
+        Context::Key::VERBOSITY => verbosity,
+        Context::Key::DELEGATED_FROM => delegated_from,
+      }
+      arg_parser = ArgParser.new(self, tool,
+                                 default_data: default_data,
+                                 require_exact_flag_match: tool.exact_flag_match_required?)
+      arg_parser.parse(args).finish
+      tool.tool_class.new(arg_parser.data)
+    end
+
+    def execute_tool(tool, context)
+      tool.source_info&.apply_lib_paths
+      tool.run_initializers(context)
+      cur_logger = context[Context::Key::LOGGER]
+      if cur_logger
+        original_level = cur_logger.level
+        cur_logger.level = (base_level || original_level) - context[Context::Key::VERBOSITY].to_i
+      end
+      begin
+        executor = build_executor(tool, context) do
+          yield context
+        end
+        catch(:result) do
+          executor.call
+          0
+        end
+      ensure
+        cur_logger.level = original_level if cur_logger
+      end
+    end
+
+    def build_executor(tool, context)
+      executor = proc do
+        begin
+          if !context[Context::Key::USAGE_ERRORS].empty?
+            handle_usage_errors(context, tool)
+          elsif !tool.runnable?
+            raise NotRunnableError, "No implementation for tool #{tool.display_name.inspect}"
+          else
+            yield
+          end
+        rescue ::Interrupt => e
+          raise e unless tool.handles_interrupts?
+          handle_interrupt(context, tool.interrupt_handler, e)
+        end
+      end
+      tool.built_middleware.reverse_each do |middleware|
+        executor = make_executor(middleware, context, executor)
+      end
+      executor
+    end
+
+    def handle_usage_errors(context, tool)
+      usage_errors = context[Context::Key::USAGE_ERRORS]
+      handler = tool.usage_error_handler
+      raise ArgParsingError, usage_errors if handler.nil?
+      handler = context.method(handler).to_proc if handler.is_a?(::Symbol)
+      if handler.arity.zero?
+        context.instance_exec(&handler)
+      else
+        context.instance_exec(usage_errors, &handler)
+      end
+    end
+
+    def handle_interrupt(context, handler, exception)
+      handler = context.method(handler).to_proc if handler.is_a?(::Symbol)
+      if handler.arity.zero?
+        context.instance_exec(&handler)
+      else
+        context.instance_exec(exception, &handler)
+      end
+    rescue ::Interrupt => e
+      raise e if e.equal?(exception)
+      handle_interrupt(context, handler, e)
+    end
+
+    def make_executor(middleware, context, next_executor)
+      if middleware.respond_to?(:run)
+        proc { middleware.run(context, &next_executor) }
+      else
+        next_executor
+      end
+    end
   end
 end