toys-core 0.11.5 → 0.13.0

data/lib/toys/{tool.rb → tool_definition.rb}

@@ -4,22 +4,225 @@ require "set"
 
 module Toys
   ##
-  # A Tool describes a single command that can be invoked using Toys.
+  # A ToolDefinition describes a single command that can be invoked using Toys.
   # It has a name, a series of one or more words that you use to identify
   # the tool on the command line. It also has a set of formal flags and
   # command line arguments supported, and a block that gets run when the
   # tool is executed.
   #
-  class Tool
+  class ToolDefinition
+    ##
+    # A Completion that implements the default algorithm for a tool.
+    #
+    class DefaultCompletion < Completion::Base
+      ##
+      # Create a completion given configuration options.
+      #
+      # @param complete_subtools [Boolean] Whether to complete subtool names
+      # @param include_hidden_subtools [Boolean] Whether to include hidden
+      #     subtools (i.e. those beginning with an underscore)
+      # @param complete_args [Boolean] Whether to complete positional args
+      # @param complete_flags [Boolean] Whether to complete flag names
+      # @param complete_flag_values [Boolean] Whether to complete flag values
+      # @param delegation_target [Array<String>,nil] Delegation target, or
+      #     `nil` if none.
+      #
+      def initialize(complete_subtools: true, include_hidden_subtools: false,
+                     complete_args: true, complete_flags: true, complete_flag_values: true,
+                     delegation_target: nil)
+        super()
+        @complete_subtools = complete_subtools
+        @include_hidden_subtools = include_hidden_subtools
+        @complete_flags = complete_flags
+        @complete_args = complete_args
+        @complete_flag_values = complete_flag_values
+        @delegation_target = delegation_target
+      end
+
+      ##
+      # Whether to complete subtool names
+      # @return [Boolean]
+      #
+      def complete_subtools?
+        @complete_subtools
+      end
+
+      ##
+      # Whether to include hidden subtools
+      # @return [Boolean]
+      #
+      def include_hidden_subtools?
+        @include_hidden_subtools
+      end
+
+      ##
+      # Whether to complete flags
+      # @return [Boolean]
+      #
+      def complete_flags?
+        @complete_flags
+      end
+
+      ##
+      # Whether to complete positional args
+      # @return [Boolean]
+      #
+      def complete_args?
+        @complete_args
+      end
+
+      ##
+      # Whether to complete flag values
+      # @return [Boolean]
+      #
+      def complete_flag_values?
+        @complete_flag_values
+      end
+
+      ##
+      # Delegation target, or nil for none.
+      # @return [Array<String>] if there is a delegation target
+      # @return [nil] if there is no delegation target
+      #
+      attr_accessor :delegation_target
+
+      ##
+      # Returns candidates for the current completion.
+      #
+      # @param context [Toys::Completion::Context] the current completion
+      #     context including the string fragment.
+      # @return [Array<Toys::Completion::Candidate>] an array of candidates
+      #
+      def call(context)
+        candidates = valued_flag_candidates(context)
+        return candidates if candidates
+        candidates = subtool_or_arg_candidates(context)
+        candidates += plain_flag_candidates(context)
+        candidates += flag_value_candidates(context)
+        if delegation_target
+          delegate_tool = context.cli.loader.lookup_specific(delegation_target)
+          if delegate_tool
+            context = context.with(previous_words: delegation_target)
+            candidates += delegate_tool.completion.call(context)
+          end
+        end
+        candidates
+      end
+
+      private
+
+      def valued_flag_candidates(context)
+        return unless @complete_flag_values
+        arg_parser = context.arg_parser
+        return unless arg_parser.flags_allowed?
+        active_flag_def = arg_parser.active_flag_def
+        return if active_flag_def && active_flag_def.value_type == :required
+        match = /\A(--\w[?\w-]*)=(.*)\z/.match(context.fragment_prefix)
+        return unless match
+        flag_value_context = context.with(fragment_prefix: match[2])
+        flag_def = flag_value_context.tool.resolve_flag(match[1]).unique_flag
+        return [] unless flag_def
+        flag_def.value_completion.call(flag_value_context)
+      end
+
+      def subtool_or_arg_candidates(context)
+        return [] if context.arg_parser.active_flag_def
+        return [] if context.arg_parser.flags_allowed? && context.fragment.start_with?("-")
+        subtool_candidates(context) || arg_candidates(context)
+      end
+
+      def subtool_candidates(context)
+        return if !@complete_subtools || !context.args.empty?
+        tool_name, prefix, fragment = analyze_subtool_fragment(context)
+        return unless tool_name
+        subtools = context.cli.loader.list_subtools(tool_name,
+                                                    include_hidden: @include_hidden_subtools)
+        return if subtools.empty?
+        candidates = []
+        subtools.each do |subtool|
+          name = subtool.simple_name
+          candidates << Completion::Candidate.new("#{prefix}#{name}") if name.start_with?(fragment)
+        end
+        candidates
+      end
+
+      def analyze_subtool_fragment(context)
+        tool_name = context.tool.full_name
+        prefix = ""
+        fragment = context.fragment
+        delims = context.cli.extra_delimiters
+        unless context.fragment_prefix.empty?
+          if !context.fragment_prefix.end_with?(":") || !delims.include?(":")
+            return [nil, nil, nil]
+          end
+          tool_name += context.fragment_prefix.split(":")
+        end
+        unless delims.empty?
+          delims_regex = ::Regexp.escape(delims)
+          if (match = /\A((.+)[#{delims_regex}])(.*)\z/.match(fragment))
+            fragment = match[3]
+            tool_name += match[2].split(/[#{delims_regex}]/)
+            prefix = match[1]
+          end
+        end
+        [tool_name, prefix, fragment]
+      end
+
+      def arg_candidates(context)
+        return unless @complete_args
+        arg_def = context.arg_parser.next_arg_def
+        return [] unless arg_def
+        arg_def.completion.call(context)
+      end
+
+      def plain_flag_candidates(context)
+        return [] if !@complete_flags || context[:disable_flags]
+        arg_parser = context.arg_parser
+        return [] unless arg_parser.flags_allowed?
+        flag_def = arg_parser.active_flag_def
+        return [] if flag_def && flag_def.value_type == :required
+        return [] if context.fragment =~ /\A[^-]/ || !context.fragment_prefix.empty?
+        context.tool.flags.flat_map do |flag|
+          flag.flag_completion.call(context)
+        end
+      end
+
+      def flag_value_candidates(context)
+        return unless @complete_flag_values
+        arg_parser = context.arg_parser
+        flag_def = arg_parser.active_flag_def
+        return [] unless flag_def
+        return [] if @complete_flags && arg_parser.flags_allowed? &&
+                     flag_def.value_type == :optional && context.fragment.start_with?("-")
+        flag_def.value_completion.call(context)
+      end
+    end
+
+    ##
+    # Tool-based settings class.
+    #
+    # The following settings are supported:
+    #
+    #  *  `propagate_helper_methods` (_Boolean_) - Whether subtools should
+    #     inherit methods defined by parent tools. Defaults to `false`.
+    #
+    class Settings < ::Toys::Settings
+      settings_attr :propagate_helper_methods, default: false
+    end
+
     ##
     # Create a new tool.
     # Should be created only from the DSL via the Loader.
+    #
     # @private
     #
-    def initialize(loader, parent, full_name, priority, middleware_stack, middleware_lookup)
+    def initialize(parent, full_name, priority, source_root, middleware_stack, middleware_lookup,
+                   tool_class = nil)
       @parent = parent
+      @settings = Settings.new(parent: parent&.settings)
       @full_name = full_name.dup.freeze
       @priority = priority
+      @source_root = source_root
       @built_middleware = middleware_stack.build(middleware_lookup)
       @subtool_middleware_stack = middleware_stack.dup
 
@@ -28,22 +231,25 @@ module Toys
       @templates = {}
       @completions = {}
 
-      reset_definition(loader)
+      @precreated_class = tool_class
+
+      reset_definition
     end
 
     ##
     # Reset the definition of this tool, deleting all definition data but
     # leaving named acceptors, mixins, and templates intact.
     # Should be called only from the DSL.
+    #
     # @private
     #
-    def reset_definition(loader)
-      @tool_class = DSL::Tool.new_class(@full_name, @priority, loader)
+    def reset_definition
+      @tool_class = @precreated_class || create_class
 
       @source_info = nil
       @definition_finished = false
 
-      @desc = WrappableString.new("")
+      @desc = WrappableString.new
       @long_desc = []
 
       @default_data = {}
@@ -72,6 +278,13 @@ module Toys
       @completion = DefaultCompletion.new
     end
 
+    ##
+    # Settings for this tool
+    #
+    # @return [Toys::Tool::Settings]
+    #
+    attr_reader :settings
+
     ##
     # The name of the tool as an array of strings.
     # This array may not be modified.
@@ -87,6 +300,13 @@ module Toys
     #
     attr_reader :priority
 
+    ##
+    # The root source info defining this tool, or nil if there is no source.
+    #
+    # @return [Toys::SourceInfo,nil]
+    #
+    attr_reader :source_root
+
     ##
     # The tool class.
     #
@@ -217,14 +437,14 @@ module Toys
     #
     # When reading, this may return an instance of one of the subclasses of
     # {Toys::Completion::Base}, or a Proc that duck-types it. Generally, this
-    # defaults to a {Toys::Tool::DefaultCompletion}, providing a standard
-    # algorithm that finds appropriate completions from flags, positional
-    # arguments, and subtools.
+    # defaults to a {Toys::ToolDefinition::DefaultCompletion}, providing a
+    # standard algorithm that finds appropriate completions from flags,
+    # positional arguments, and subtools.
     #
     # When setting, you may pass any of the following:
     #  *  `nil` or `:default` which sets the value to a default instance.
-    #  *  A Hash of options to pass to the {Toys::Tool::DefaultCompletion}
-    #     constructor.
+    #  *  A Hash of options to pass to the
+    #     {Toys::ToolDefinition::DefaultCompletion} constructor.
     #  *  Any other form recognized by {Toys::Completion.create}.
     #
     # @return [Toys::Completion::Base,Proc]
@@ -408,7 +628,7 @@ module Toys
     # Get the named acceptor from this tool or its ancestors.
     #
     # @param name [String] The acceptor name.
-    # @return [Tool::Acceptor::Base] The acceptor.
+    # @return [Toys::Acceptor::Base] The acceptor.
     # @return [nil] if no acceptor of the given name is found.
     #
     def lookup_acceptor(name)
@@ -441,7 +661,7 @@ module Toys
     # Get the named completion from this tool or its ancestors.
     #
     # @param name [String] The completion name
-    # @return [Tool::Completion::Base,Proc] The completion proc.
+    # @return [Toys::Completion::Base,Proc] The completion proc.
     # @return [nil] if no completion of the given name is found.
     #
     def lookup_completion(name)
@@ -451,11 +671,31 @@ module Toys
     ##
     # Include the given mixin in the tool class.
     #
-    # @param name [String,Symbol,Module] The mixin name or module
+    # The mixin must be given as a module. You can use {#lookup_mixin} to
+    # resolve named mixins.
+    #
+    # @param mod [Module] The mixin module
     # @return [self]
     #
-    def include_mixin(name)
-      tool_class.include(name)
+    def include_mixin(mod, *args, **kwargs)
+      check_definition_state
+      if tool_class.included_modules.include?(mod)
+        raise ToolDefinitionError, "Mixin already included: #{mod.name}"
+      end
+      @includes_modules = true
+      if tool_class.respond_to?(:super_include)
+        tool_class.super_include(mod)
+      else
+        tool_class.include(mod)
+      end
+      if mod.respond_to?(:initializer)
+        callback = mod.initializer
+        add_initializer(callback, *args, **kwargs) if callback
+      end
+      if mod.respond_to?(:inclusion)
+        callback = mod.inclusion
+        tool_class.class_exec(*args, **kwargs, &callback) if callback
+      end
       self
     end
 
@@ -565,7 +805,7 @@ module Toys
     # completion.
     #
     # @param name [String] The name of the completion.
-    # @param completion [Proc,Tool::Completion::Base,Object] The completion to
+    # @param completion [Proc,Toys::Completion::Base,Object] The completion to
     #     add. You can provide either a completion object, or a spec understood
     #     by {Toys::Completion.create}.
     # @param options [Hash] Additional options to pass to the completion.
@@ -669,11 +909,12 @@ module Toys
     #
     # @param type [Symbol] The type of group. Default is `:optional`.
     # @param desc [String,Array<String>,Toys::WrappableString] Short
-    #     description for the group. See {Toys::Tool#desc=} for a description
-    #     of allowed formats. Defaults to `"Flags"`.
+    #     description for the group. See {Toys::ToolDefinition#desc} for a
+    #     description of allowed formats. Defaults to `"Flags"`.
     # @param long_desc [Array<String,Array<String>,Toys::WrappableString>]
-    #     Long description for the flag group. See {Toys::Tool#long_desc=} for
-    #     a description of allowed formats. Defaults to the empty array.
+    #     Long description for the flag group. See
+    #     {Toys::ToolDefinition#long_desc} for a description of allowed
+    #     formats. Defaults to the empty array.
     # @param name [String,Symbol,nil] The name of the group, or nil for no
     #     name.
     # @param report_collisions [Boolean] If `true`, raise an exception if a
@@ -741,11 +982,11 @@ module Toys
     #     this flag. You may provide a group name, a FlagGroup object, or
     #     `nil` which denotes the default group.
     # @param desc [String,Array<String>,Toys::WrappableString] Short
-    #     description for the flag. See {Toys::Tool#desc=} for a description of
-    #     allowed formats. Defaults to the empty string.
+    #     description for the flag. See {Toys::ToolDefinition#desc} for a
+    #     description of allowed formats. Defaults to the empty string.
     # @param long_desc [Array<String,Array<String>,Toys::WrappableString>]
-    #     Long description for the flag. See {Toys::Tool#long_desc=} for a
-    #     description of allowed formats. Defaults to the empty array.
+    #     Long description for the flag. See {Toys::ToolDefinition#long_desc}
+    #     for a description of allowed formats. Defaults to the empty array.
     # @param display_name [String] A display name for this flag, used in help
     #     text and error messages.
     # @return [self]
@@ -808,11 +1049,11 @@ module Toys
     # @param display_name [String] A name to use for display (in help text and
     #     error reports). Defaults to the key in upper case.
     # @param desc [String,Array<String>,Toys::WrappableString] Short
-    #     description for the arg. See {Toys::Tool#desc=} for a description of
-    #     allowed formats. Defaults to the empty string.
+    #     description for the arg. See {Toys::ToolDefinition#desc} for a
+    #     description of allowed formats. Defaults to the empty string.
     # @param long_desc [Array<String,Array<String>,Toys::WrappableString>]
-    #     Long description for the arg. See {Toys::Tool#long_desc=} for a
-    #     description of allowed formats. Defaults to the empty array.
+    #     Long description for the arg. See {Toys::ToolDefinition#long_desc}
+    #     for a description of allowed formats. Defaults to the empty array.
     # @return [self]
     #
     def add_required_arg(key, accept: nil, complete: nil, display_name: nil,
@@ -846,11 +1087,11 @@ module Toys
     # @param display_name [String] A name to use for display (in help text and
     #     error reports). Defaults to the key in upper case.
     # @param desc [String,Array<String>,Toys::WrappableString] Short
-    #     description for the arg. See {Toys::Tool#desc=} for a description of
-    #     allowed formats. Defaults to the empty string.
+    #     description for the arg. See {Toys::ToolDefinition#desc} for a
+    #     description of allowed formats. Defaults to the empty string.
     # @param long_desc [Array<String,Array<String>,Toys::WrappableString>]
-    #     Long description for the arg. See {Toys::Tool#long_desc=} for a
-    #     description of allowed formats. Defaults to the empty array.
+    #     Long description for the arg. See {Toys::ToolDefinition#long_desc}
+    #     for a description of allowed formats. Defaults to the empty array.
     # @return [self]
     #
     def add_optional_arg(key, default: nil, accept: nil, complete: nil,
@@ -884,11 +1125,11 @@ module Toys
     # @param display_name [String] A name to use for display (in help text and
     #     error reports). Defaults to the key in upper case.
     # @param desc [String,Array<String>,Toys::WrappableString] Short
-    #     description for the arg. See {Toys::Tool#desc=} for a description of
-    #     allowed formats. Defaults to the empty string.
+    #     description for the arg. See {Toys::ToolDefinition#desc} for a
+    #     description of allowed formats. Defaults to the empty string.
     # @param long_desc [Array<String,Array<String>,Toys::WrappableString>]
-    #     Long description for the arg. See {Toys::Tool#long_desc=} for a
-    #     description of allowed formats. Defaults to the empty array.
+    #     Long description for the arg. See {Toys::ToolDefinition#long_desc}
+    #     for a description of allowed formats. Defaults to the empty array.
     # @return [self]
     #
     def set_remaining_args(key, default: [], accept: nil, complete: nil,
@@ -910,7 +1151,9 @@ module Toys
     #
     def run_handler=(proc)
       check_definition_state(is_method: true)
-      @tool_class.to_run(&proc)
+      tool_class.class_eval do
+        define_method(:run, &proc)
+      end
     end
 
     ##
@@ -966,7 +1209,7 @@ module Toys
     end
 
     ##
-    # Set the completion strategy for this Tool.
+    # Set the completion strategy for this ToolDefinition.
     #
     # See {#completion} for details.
     #
@@ -1032,6 +1275,7 @@ module Toys
 
     ##
     # Lookup the custom context directory in this tool and its ancestors.
+    #
     # @private
     #
     def lookup_custom_context_directory
@@ -1040,6 +1284,7 @@ module Toys
 
     ##
     # Mark this tool as having at least one module included.
+    #
     # @private
     #
     def mark_includes_modules
@@ -1051,12 +1296,13 @@ module Toys
     ##
     # Complete definition and run middleware configs. Should be called from
     # the Loader only.
+    #
     # @private
     #
     def finish_definition(loader)
       unless @definition_finished
         ContextualError.capture("Error installing tool middleware!", tool_name: full_name) do
-          config_proc = proc {}
+          config_proc = proc { nil }
           @built_middleware.reverse_each do |middleware|
             config_proc = make_config_proc(middleware, loader, config_proc)
           end
@@ -1072,6 +1318,7 @@ module Toys
 
     ##
     # Run all initializers against a context. Called from the Runner.
+    #
     # @private
     #
     def run_initializers(context)
@@ -1083,6 +1330,7 @@ module Toys
     ##
     # Check that the tool can still be defined. Should be called internally
     # or from the DSL only.
+    #
     # @private
     #
     def check_definition_state(is_arg: false, is_method: false)
@@ -1101,194 +1349,12 @@ module Toys
       self
     end
 
-    ##
-    # A Completion that implements the default algorithm for a tool.
-    #
-    class DefaultCompletion < Completion::Base
-      ##
-      # Create a completion given configuration options.
-      #
-      # @param complete_subtools [Boolean] Whether to complete subtool names
-      # @param include_hidden_subtools [Boolean] Whether to include hidden
-      #     subtools (i.e. those beginning with an underscore)
-      # @param complete_args [Boolean] Whether to complete positional args
-      # @param complete_flags [Boolean] Whether to complete flag names
-      # @param complete_flag_values [Boolean] Whether to complete flag values
-      # @param delegation_target [Array<String>,nil] Delegation target, or
-      #     `nil` if none.
-      #
-      def initialize(complete_subtools: true, include_hidden_subtools: false,
-                     complete_args: true, complete_flags: true, complete_flag_values: true,
-                     delegation_target: nil)
-        @complete_subtools = complete_subtools
-        @include_hidden_subtools = include_hidden_subtools
-        @complete_flags = complete_flags
-        @complete_args = complete_args
-        @complete_flag_values = complete_flag_values
-        @delegation_target = delegation_target
-      end
-
-      ##
-      # Whether to complete subtool names
-      # @return [Boolean]
-      #
-      def complete_subtools?
-        @complete_subtools
-      end
-
-      ##
-      # Whether to include hidden subtools
-      # @return [Boolean]
-      #
-      def include_hidden_subtools?
-        @include_hidden_subtools
-      end
-
-      ##
-      # Whether to complete flags
-      # @return [Boolean]
-      #
-      def complete_flags?
-        @complete_flags
-      end
-
-      ##
-      # Whether to complete positional args
-      # @return [Boolean]
-      #
-      def complete_args?
-        @complete_args
-      end
-
-      ##
-      # Whether to complete flag values
-      # @return [Boolean]
-      #
-      def complete_flag_values?
-        @complete_flag_values
-      end
-
-      ##
-      # Delegation target, or nil for none.
-      # @return [Array<String>] if there is a delegation target
-      # @return [nil] if there is no delegation target
-      #
-      attr_accessor :delegation_target
-
-      ##
-      # Returns candidates for the current completion.
-      #
-      # @param context [Toys::Completion::Context] the current completion
-      #     context including the string fragment.
-      # @return [Array<Toys::Completion::Candidate>] an array of candidates
-      #
-      def call(context)
-        candidates = valued_flag_candidates(context)
-        return candidates if candidates
-        candidates = subtool_or_arg_candidates(context)
-        candidates += plain_flag_candidates(context)
-        candidates += flag_value_candidates(context)
-        if delegation_target
-          delegate_tool = context.cli.loader.lookup_specific(delegation_target)
-          if delegate_tool
-            context = context.with(previous_words: delegation_target)
-            candidates += delegate_tool.completion.call(context)
-          end
-        end
-        candidates
-      end
-
-      private
-
-      def valued_flag_candidates(context)
-        return unless @complete_flag_values
-        arg_parser = context.arg_parser
-        return unless arg_parser.flags_allowed?
-        active_flag_def = arg_parser.active_flag_def
-        return if active_flag_def && active_flag_def.value_type == :required
-        match = /\A(--\w[\?\w-]*)=(.*)\z/.match(context.fragment_prefix)
-        return unless match
-        flag_value_context = context.with(fragment_prefix: match[2])
-        flag_def = flag_value_context.tool.resolve_flag(match[1]).unique_flag
-        return [] unless flag_def
-        flag_def.value_completion.call(flag_value_context)
-      end
-
-      def subtool_or_arg_candidates(context)
-        return [] if context.arg_parser.active_flag_def
-        return [] if context.arg_parser.flags_allowed? && context.fragment.start_with?("-")
-        subtool_candidates(context) || arg_candidates(context)
-      end
-
-      def subtool_candidates(context)
-        return if !@complete_subtools || !context.args.empty?
-        tool_name, prefix, fragment = analyze_subtool_fragment(context)
-        return unless tool_name
-        subtools = context.cli.loader.list_subtools(tool_name,
-                                                    include_hidden: @include_hidden_subtools)
-        return if subtools.empty?
-        candidates = []
-        subtools.each do |subtool|
-          name = subtool.simple_name
-          candidates << Completion::Candidate.new("#{prefix}#{name}") if name.start_with?(fragment)
-        end
-        candidates
-      end
-
-      def analyze_subtool_fragment(context)
-        tool_name = context.tool.full_name
-        prefix = ""
-        fragment = context.fragment
-        delims = context.cli.extra_delimiters
-        unless context.fragment_prefix.empty?
-          if !context.fragment_prefix.end_with?(":") || !delims.include?(":")
-            return [nil, nil, nil]
-          end
-          tool_name += context.fragment_prefix.split(":")
-        end
-        unless delims.empty?
-          delims_regex = ::Regexp.escape(delims)
-          if (match = /\A((.+)[#{delims_regex}])(.*)\z/.match(fragment))
-            fragment = match[3]
-            tool_name += match[2].split(/[#{delims_regex}]/)
-            prefix = match[1]
-          end
-        end
-        [tool_name, prefix, fragment]
-      end
-
-      def arg_candidates(context)
-        return unless @complete_args
-        arg_def = context.arg_parser.next_arg_def
-        return [] unless arg_def
-        arg_def.completion.call(context)
-      end
-
-      def plain_flag_candidates(context)
-        return [] if !@complete_flags || context[:disable_flags]
-        arg_parser = context.arg_parser
-        return [] unless arg_parser.flags_allowed?
-        flag_def = arg_parser.active_flag_def
-        return [] if flag_def && flag_def.value_type == :required
-        return [] if context.fragment =~ /\A[^-]/ || !context.fragment_prefix.empty?
-        context.tool.flags.flat_map do |flag|
-          flag.flag_completion.call(context)
-        end
-      end
+    private
 
-      def flag_value_candidates(context)
-        return unless @complete_flag_values
-        arg_parser = context.arg_parser
-        flag_def = arg_parser.active_flag_def
-        return [] unless flag_def
-        return [] if @complete_flags && arg_parser.flags_allowed? &&
-                     flag_def.value_type == :optional && context.fragment.start_with?("-")
-        flag_def.value_completion.call(context)
-      end
+    def create_class
+      ::Class.new(@parent&.settings&.propagate_helper_methods ? @parent.tool_class : ::Toys::Context)
     end
 
-    private
-
     def make_config_proc(middleware, loader, next_config)
       if middleware.respond_to?(:config)
         proc { middleware.config(self, loader, &next_config) }