toys 0.2.2 → 0.3.0

data/lib/toys/templates/clean.rb

@@ -27,38 +27,40 @@
 # POSSIBILITY OF SUCH DAMAGE.
 ;
 
-module Toys::Templates
-  ##
-  # A template for tools that clean build artifacts
-  #
-  class Clean
-    include ::Toys::Template
+module Toys
+  module Templates
+    ##
+    # A template for tools that clean build artifacts
+    #
+    class Clean
+      include Template
 
-    def initialize(opts = {})
-      @name = opts[:name] || "clean"
-      @paths = opts[:paths] || []
-    end
+      def initialize(opts = {})
+        @name = opts[:name] || "clean"
+        @paths = opts[:paths] || []
+      end
 
-    attr_accessor :name
-    attr_accessor :paths
+      attr_accessor :name
+      attr_accessor :paths
 
-    to_expand do |template|
-      name(template.name) do
-        short_desc "Clean built files and directories"
+      to_expand do |template|
+        name(template.name) do
+          desc "Clean built files and directories."
 
-        use :file_utils
+          use :file_utils
 
-        execute do
-          files = []
-          patterns = Array(template.paths)
-          patterns = ["lib/**/*.rb"] if patterns.empty?
-          patterns.each do |pattern|
-            files.concat(::Dir.glob(pattern))
-          end
-          files.uniq!
+          execute do
+            files = []
+            patterns = Array(template.paths)
+            patterns = ["lib/**/*.rb"] if patterns.empty?
+            patterns.each do |pattern|
+              files.concat(::Dir.glob(pattern))
+            end
+            files.uniq!
 
-          files.each do |file|
-            rm_rf file
+            files.each do |file|
+              rm_rf file
+            end
           end
         end
       end

data/lib/toys/templates/gem_build.rb

@@ -29,62 +29,64 @@
 
 require "rubygems/package"
 
-module Toys::Templates
-  ##
-  # A template for tools that build and release gems
-  #
-  class GemBuild
-    include ::Toys::Template
+module Toys
+  module Templates
+    ##
+    # A template for tools that build and release gems
+    #
+    class GemBuild
+      include Template
 
-    def initialize(opts = {})
-      @name = opts[:name] || "build"
-      @gem_name = opts[:gem_name]
-      @push_gem = opts[:push_gem]
-      @tag = opts[:tag]
-      @push_tag = opts[:push_tag]
-    end
+      def initialize(opts = {})
+        @name = opts[:name] || "build"
+        @gem_name = opts[:gem_name]
+        @push_gem = opts[:push_gem]
+        @tag = opts[:tag]
+        @push_tag = opts[:push_tag]
+      end
 
-    attr_accessor :name
-    attr_accessor :gem_name
-    attr_accessor :push_gem
-    attr_accessor :tag
-    attr_accessor :push_tag
+      attr_accessor :name
+      attr_accessor :gem_name
+      attr_accessor :push_gem
+      attr_accessor :tag
+      attr_accessor :push_tag
 
-    to_expand do |template|
-      unless template.gem_name
-        candidates = ::Dir.glob("*.gemspec")
-        if candidates.empty?
-          raise ::Toys::ToolDefinitionError, "Could not find a gemspec"
+      to_expand do |template|
+        unless template.gem_name
+          candidates = ::Dir.glob("*.gemspec")
+          if candidates.empty?
+            raise ToolDefinitionError, "Could not find a gemspec"
+          end
+          template.gem_name = candidates.first.sub(/\.gemspec$/, "")
         end
-        template.gem_name = candidates.first.sub(/\.gemspec$/, "")
-      end
-      task_type = template.push_gem ? "Release" : "Build"
+        task_type = template.push_gem ? "Release" : "Build"
 
-      name(template.name) do
-        short_desc "#{task_type} the gem: #{template.gem_name}"
+        name(template.name) do
+          desc "#{task_type} the gem: #{template.gem_name}"
 
-        use :file_utils
-        use :exec
+          use :file_utils
+          use :exec
 
-        execute do
-          configure_exec(exit_on_nonzero_status: true)
-          gemspec = ::Gem::Specification.load "#{template.gem_name}.gemspec"
-          version = gemspec.version
-          gemfile = "#{template.gem_name}-#{version}.gem"
-          ::Gem::Package.build gemspec
-          mkdir_p "pkg"
-          mv gemfile, "pkg"
-          if template.push_gem
-            if ::File.directory?(".git") && capture("git status -s").strip != ""
-              logger.error "Cannot push the gem when there are uncommited changes"
-              exit(1)
-            end
-            sh "gem push pkg/#{gemfile}"
-            if template.tag
-              sh "git tag v#{version}"
-              if template.push_tag
-                template.push_tag = "origin" if template.push_tag == true
-                sh "git push #{template.push_tag} v#{version}"
+          execute do
+            configure_exec(exit_on_nonzero_status: true)
+            gemspec = ::Gem::Specification.load "#{template.gem_name}.gemspec"
+            version = gemspec.version
+            gemfile = "#{template.gem_name}-#{version}.gem"
+            ::Gem::Package.build gemspec
+            mkdir_p "pkg"
+            mv gemfile, "pkg"
+            if template.push_gem
+              if ::File.directory?(".git") && capture("git status -s").strip != ""
+                logger.error "Cannot push the gem when there are uncommited changes"
+                exit(1)
+              end
+              sh "gem push pkg/#{gemfile}"
+              if template.tag
+                sh "git tag v#{version}"
+                if template.push_tag
+                  template.push_tag = "origin" if template.push_tag == true
+                  sh "git push #{template.push_tag} v#{version}"
+                end
               end
             end
           end

data/lib/toys/templates/minitest.rb

@@ -27,57 +27,63 @@
 # POSSIBILITY OF SUCH DAMAGE.
 ;
 
-module Toys::Templates
-  ##
-  # A template for tools that run minitest
-  #
-  class Minitest
-    include ::Toys::Template
+module Toys
+  module Templates
+    ##
+    # A template for tools that run minitest
+    #
+    class Minitest
+      include Template
 
-    def initialize(opts = {})
-      @name = opts[:name] || "test"
-      @libs = opts[:libs] || ["lib"]
-      @files = opts[:files] || ["test/test*.rb"]
-      @warnings = opts.include?(:warnings) ? opts[:warnings] : true
-    end
+      def initialize(opts = {})
+        @name = opts[:name] || "test"
+        @libs = opts[:libs] || ["lib"]
+        @files = opts[:files] || ["test/test*.rb"]
+        @warnings = opts.include?(:warnings) ? opts[:warnings] : true
+      end
 
-    attr_accessor :name
-    attr_accessor :libs
-    attr_accessor :files
-    attr_accessor :warnings
+      attr_accessor :name
+      attr_accessor :libs
+      attr_accessor :files
+      attr_accessor :warnings
 
-    to_expand do |template|
-      name(template.name) do
-        short_desc "Run minitest"
+      to_expand do |template|
+        name(template.name) do
+          desc "Run minitest on the current project."
 
-        use :exec
+          use :exec
 
-        switch(
-          :warnings, "-w", "--[no-]warnings",
-          default: template.warnings,
-          doc: "Turn on Ruby warnings (defaults to #{template.warnings})"
-        )
-        remaining_args(:tests, doc: "Paths to the tests to run (defaults to all tests)")
+          switch(
+            :warnings, "-w", "--[no-]warnings",
+            default: template.warnings,
+            doc: "Turn on Ruby warnings (defaults to #{template.warnings})"
+          )
+          remaining_args(:tests, doc: "Paths to the tests to run (defaults to all tests)")
 
-        execute do
-          ruby_args = []
-          unless template.libs.empty?
-            lib_path = template.libs.join(::File::PATH_SEPARATOR)
-            ruby_args << "-I#{lib_path}"
-          end
-          ruby_args << "-w" if self[:warnings]
+          execute do
+            ruby_args = []
+            unless template.libs.empty?
+              lib_path = template.libs.join(::File::PATH_SEPARATOR)
+              ruby_args << "-I#{lib_path}"
+            end
+            ruby_args << "-w" if self[:warnings]
 
-          tests = self[:tests]
-          if tests.empty?
-            Array(template.files).each do |pattern|
-              tests.concat(::Dir.glob(pattern))
+            tests = self[:tests]
+            if tests.empty?
+              Array(template.files).each do |pattern|
+                tests.concat(::Dir.glob(pattern))
+              end
+              tests.uniq!
             end
-            tests.uniq!
-          end
 
-          ruby(ruby_args, in_from: :controller, exit_on_nonzero_status: true) do |controller|
-            tests.each do |file|
-              controller.in.puts("load '#{file}'")
+            result = ruby(ruby_args, in_from: :controller) do |controller|
+              tests.each do |file|
+                controller.in.puts("load '#{file}'")
+              end
+            end
+            if result.error?
+              logger.error("Minitest failed!")
+              exit(result.exit_code)
             end
           end
         end

data/lib/toys/templates/rubocop.rb

@@ -27,37 +27,39 @@
 # POSSIBILITY OF SUCH DAMAGE.
 ;
 
-module Toys::Templates
-  ##
-  # A template for tools that run rubocop
-  #
-  class Rubocop
-    include ::Toys::Template
+module Toys
+  module Templates
+    ##
+    # A template for tools that run rubocop
+    #
+    class Rubocop
+      include Template
 
-    def initialize(opts = {})
-      @name = opts[:name] || "rubocop"
-      @fail_on_error = opts.include?(:fail_on_error) ? opts[:fail_on_error] : true
-      @options = opts[:options] || []
-    end
+      def initialize(opts = {})
+        @name = opts[:name] || "rubocop"
+        @fail_on_error = opts.include?(:fail_on_error) ? opts[:fail_on_error] : true
+        @options = opts[:options] || []
+      end
 
-    attr_accessor :name
-    attr_accessor :fail_on_error
-    attr_accessor :options
+      attr_accessor :name
+      attr_accessor :fail_on_error
+      attr_accessor :options
 
-    to_expand do |template|
-      name(template.name) do
-        short_desc "Run RuboCop"
+      to_expand do |template|
+        name(template.name) do
+          desc "Run rubocop on the current project."
 
-        use :exec
+          use :exec
 
-        execute do
-          require "rubocop"
-          cli = ::RuboCop::CLI.new
-          logger.info "Running RuboCop..."
-          result = cli.run(template.options)
-          if result.nonzero?
-            logger.error "RuboCop failed!"
-            exit(1) if template.fail_on_error
+          execute do
+            require "rubocop"
+            cli = ::RuboCop::CLI.new
+            logger.info "Running RuboCop..."
+            result = cli.run(template.options)
+            if result.nonzero?
+              logger.error "RuboCop failed!"
+              exit(1) if template.fail_on_error
+            end
           end
         end
       end

data/lib/toys/templates/yardoc.rb

@@ -27,50 +27,52 @@
 # POSSIBILITY OF SUCH DAMAGE.
 ;
 
-module Toys::Templates
-  ##
-  # A template for tools that run yardoc
-  #
-  class Yardoc
-    include ::Toys::Template
+module Toys
+  module Templates
+    ##
+    # A template for tools that run yardoc
+    #
+    class Yardoc
+      include Template
 
-    def initialize(opts = {})
-      @name = opts[:name] || "yardoc"
-      @files = opts[:files] || []
-      @options = opts[:options] || []
-      @stats_options = opts[:stats_options] || []
-    end
+      def initialize(opts = {})
+        @name = opts[:name] || "yardoc"
+        @files = opts[:files] || []
+        @options = opts[:options] || []
+        @stats_options = opts[:stats_options] || []
+      end
 
-    attr_accessor :name
-    attr_accessor :files
-    attr_accessor :options
-    attr_accessor :stats_options
+      attr_accessor :name
+      attr_accessor :files
+      attr_accessor :options
+      attr_accessor :stats_options
 
-    to_expand do |template|
-      name(template.name) do
-        short_desc "Run yardoc"
+      to_expand do |template|
+        name(template.name) do
+          desc "Run yardoc on the current project."
 
-        use :exec
+          use :exec
 
-        execute do
-          require "yard"
-          files = []
-          patterns = Array(template.files)
-          patterns = ["lib/**/*.rb"] if patterns.empty?
-          patterns.each do |pattern|
-            files.concat(::Dir.glob(pattern))
-          end
-          files.uniq!
+          execute do
+            require "yard"
+            files = []
+            patterns = Array(template.files)
+            patterns = ["lib/**/*.rb"] if patterns.empty?
+            patterns.each do |pattern|
+              files.concat(::Dir.glob(pattern))
+            end
+            files.uniq!
 
-          unless template.stats_options.empty?
-            template.options << "--no-stats"
-            template.stats_options << "--use-cache"
-          end
+            unless template.stats_options.empty?
+              template.options << "--no-stats"
+              template.stats_options << "--use-cache"
+            end
 
-          yardoc = ::YARD::CLI::Yardoc.new
-          yardoc.run(*(template.options + files))
-          unless template.stats_options.empty?
-            ::YARD::CLI::Stats.run(*template.stats_options)
+            yardoc = ::YARD::CLI::Yardoc.new
+            yardoc.run(*(template.options + files))
+            unless template.stats_options.empty?
+              ::YARD::CLI::Stats.run(*template.stats_options)
+            end
           end
         end
       end

data/lib/toys/tool.rb

@@ -34,17 +34,17 @@ module Toys
   # A tool definition
   #
   class Tool
-    def initialize(lookup, full_name)
-      @lookup = lookup
+    def initialize(full_name, middleware_stack)
       @full_name = full_name
+      @middleware_stack = middleware_stack.dup
 
       @definition_path = nil
       @cur_path = nil
-
       @alias_target = nil
+      @definition_finished = false
 
+      @desc = nil
       @long_desc = nil
-      @short_desc = nil
 
       @default_data = {}
       @switches = []
@@ -57,7 +57,6 @@ module Toys
       @executor = nil
     end
 
-    attr_reader :lookup
     attr_reader :full_name
     attr_reader :switches
     attr_reader :required_args
@@ -68,6 +67,8 @@ module Toys
     attr_reader :helpers
     attr_reader :executor
     attr_reader :alias_target
+    attr_reader :middleware_stack
+    attr_reader :definition_path
 
     def simple_name
       full_name.last
@@ -81,40 +82,41 @@ module Toys
       full_name.empty?
     end
 
-    def leaf?
-      @executor.is_a?(::Proc)
+    def includes_executor?
+      executor.is_a?(::Proc)
     end
 
     def alias?
       !alias_target.nil?
     end
 
-    def only_collection?
-      @executor == false
+    def effective_desc
+      @desc || default_desc
     end
 
-    def parent
-      return nil if root?
-      @lookup.exact_tool(full_name.slice(0..-2))
+    def effective_long_desc
+      @long_desc || @desc || default_desc
     end
 
-    def effective_short_desc
-      @short_desc || default_desc
+    def includes_description?
+      !@long_desc.nil? || !@desc.nil?
     end
 
-    def effective_long_desc
-      @long_desc || @short_desc || default_desc
+    def includes_arguments?
+      !default_data.empty? || !switches.empty? ||
+        !required_args.empty? || !optional_args.empty? || !remaining_args.nil?
     end
 
-    def includes_description?
-      !@long_desc.nil? || !@short_desc.nil?
+    def includes_helpers?
+      !helpers.empty? || !modules.empty?
     end
 
     def includes_definition?
-      !@default_data.empty? || !@switches.empty? ||
-        !@required_args.empty? || !@optional_args.empty? ||
-        !@remaining_args.nil? || leaf? ||
-        !@helpers.empty? || !@modules.empty?
+      alias? || includes_arguments? || includes_executor? || includes_helpers?
+    end
+
+    def used_switches
+      @switches.reduce([]) { |used, switch| used + switch.switches }.uniq
     end
 
     def defining_from(path)
@@ -142,22 +144,17 @@ module Toys
       if root?
         raise ToolDefinitionError, "Cannot make the root tool an alias"
       end
-      if only_collection?
-        raise ToolDefinitionError, "Tool #{display_name.inspect} is already" \
-          " a collection and cannot be made an alias"
-      end
       if includes_description? || includes_definition?
         raise ToolDefinitionError, "Tool #{display_name.inspect} already has" \
           " a definition and cannot be made an alias"
       end
-      parent.ensure_collection_only(full_name) unless root?
       @alias_target = target_word
       self
     end
 
-    def short_desc=(str)
+    def desc=(str)
       check_definition_state
-      @short_desc = str
+      @desc = str
     end
 
     def long_desc=(str)
@@ -166,95 +163,109 @@ module Toys
     end
 
     def add_helper(name, &block)
-      check_definition_state(true)
+      check_definition_state
       name_str = name.to_s
       unless name_str =~ /^[a-z]\w+$/
         raise ToolDefinitionError, "Illegal helper name: #{name_str.inspect}"
       end
       @helpers[name.to_sym] = block
+      self
     end
 
-    def use_module(mod)
-      check_definition_state(true)
-      case mod
+    def use_module(name)
+      check_definition_state
+      case name
       when ::Module
-        @modules << mod
+        @modules << name
       when ::Symbol
-        mod = mod.to_s
-        file_name =
-          mod
-          .gsub(/([a-zA-Z])([A-Z])/) { |_m| "#{$1}_#{$2.downcase}" }
-          .downcase
-        require "toys/helpers/#{file_name}"
-        const_name = mod.gsub(/(^|_)([a-zA-Z0-9])/) { |_m| $2.upcase }
-        @modules << Helpers.const_get(const_name)
+        mod = Helpers.lookup(name.to_s)
+        if mod.nil?
+          raise ToolDefinitionError, "Module not found: #{name.inspect}"
+        end
+        @modules << mod
       else
-        raise ToolDefinitionError, "Illegal helper module name: #{mod.inspect}"
+        raise ToolDefinitionError, "Illegal helper module name: #{name.inspect}"
       end
+      self
     end
 
-    def add_switch(key, *switches, accept: nil, default: nil, doc: nil)
-      check_definition_state(true)
-      @default_data[key] = default
+    def add_switch(key, *switches,
+                   accept: nil, default: nil, doc: nil, only_unique: false, handler: nil)
+      check_definition_state
       switches << "--#{Tool.canonical_switch(key)}=VALUE" if switches.empty?
       switches << accept unless accept.nil?
       switches += Array(doc)
-      @switches << SwitchInfo.new(key, switches)
+      switch_info = SwitchInfo.new(key, switches, handler)
+      if only_unique
+        switch_info.remove_switches(used_switches)
+      end
+      if switch_info.active?
+        @default_data[key] = default
+        @switches << switch_info
+      end
+      self
     end
 
     def add_required_arg(key, accept: nil, doc: nil)
-      check_definition_state(true)
+      check_definition_state
       @default_data[key] = nil
       @required_args << ArgInfo.new(key, accept, Array(doc))
+      self
     end
 
     def add_optional_arg(key, accept: nil, default: nil, doc: nil)
-      check_definition_state(true)
+      check_definition_state
       @default_data[key] = default
       @optional_args << ArgInfo.new(key, accept, Array(doc))
+      self
     end
 
     def set_remaining_args(key, accept: nil, default: [], doc: nil)
-      check_definition_state(true)
+      check_definition_state
       @default_data[key] = default
       @remaining_args = ArgInfo.new(key, accept, Array(doc))
+      self
     end
 
     def executor=(executor)
-      check_definition_state(true)
+      check_definition_state
       @executor = executor
     end
 
-    def execute(context_base, args)
-      Execution.new(self).execute(context_base, args)
+    def finish_definition
+      if !alias? && !@definition_finished
+        config_proc = proc {}
+        middleware_stack.reverse.each do |middleware|
+          config_proc = make_config_proc(middleware, config_proc)
+        end
+        config_proc.call
+      end
+      @definition_finished = true
+      self
     end
 
-    protected
-
-    def ensure_collection_only(source_name)
-      if includes_definition?
-        raise ToolDefinitionError, "Cannot create tool #{source_name.inspect}" \
-          " because #{display_name.inspect} is already a tool."
-      end
-      unless @executor == false
-        @executor = false
-        parent.ensure_collection_only(source_name) unless root?
-      end
+    def execute(context_base, args, verbosity: 0)
+      finish_definition unless @definition_finished
+      Execution.new(self).execute(context_base, args, verbosity: verbosity)
     end
 
     private
 
+    def make_config_proc(middleware, next_config)
+      proc { middleware.config(self, &next_config) }
+    end
+
     def default_desc
       if alias?
         "(Alias of #{@alias_target.inspect})"
-      elsif leaf?
+      elsif includes_executor?
         "(No description available)"
       else
-        "(A collection of commands)"
+        "(A group of commands)"
       end
     end
 
-    def check_definition_state(execution_field = false)
+    def check_definition_state
       if alias?
         raise ToolDefinitionError, "Tool #{display_name.inspect} is an alias"
       end
@@ -264,13 +275,9 @@ module Toys
               "Cannot redefine tool #{display_name.inspect} #{in_clause}" \
               "(already defined in #{@definition_path})"
       end
-      if execution_field
-        if only_collection?
-          raise ToolDefinitionError,
-                "Cannot make tool #{display_name.inspect} executable because" \
-                " a descendant is already executable"
-        end
-        parent.ensure_collection_only(full_name) unless root?
+      if @definition_finished
+        raise ToolDefinitionError,
+              "Defintion of tool #{display_name.inspect} is already finished"
       end
     end
 
@@ -284,13 +291,44 @@ module Toys
     # Representation of a formal switch
     #
     class SwitchInfo
-      def initialize(key, optparse_info)
+      def initialize(key, optparse_info, handler = nil)
         @key = key
         @optparse_info = optparse_info
+        @handler = handler || ->(val, _cur) { val }
+        @switches = nil
       end
 
       attr_reader :key
       attr_reader :optparse_info
+      attr_reader :handler
+
+      def switches
+        @switches ||= optparse_info.map { |s| extract_switch(s) }.flatten
+      end
+
+      def active?
+        !switches.empty?
+      end
+
+      def remove_switches(switches)
+        @optparse_info.select! do |s|
+          extract_switch(s).all? { |ss| !switches.include?(ss) }
+        end
+        @switches = nil
+        self
+      end
+
+      def extract_switch(str)
+        if str =~ /^(-[\?\w])/
+          [$1]
+        elsif str =~ /^--\[no-\](\w[\w-]*)/
+          ["--#{$1}", "--no-#{$1}"]
+        elsif str =~ /^(--\w[\w-]*)/
+          [$1]
+        else
+          []
+        end
+      end
     end
 
     ##
@@ -309,7 +347,7 @@ module Toys
 
       def process_value(val)
         return val unless accept
-        n = canonical_switch(key)
+        n = canonical_name
         result = val
         optparse = ::OptionParser.new
         optparse.on("--#{n}=VALUE", accept) { |v| result = v }
@@ -329,235 +367,59 @@ module Toys
     class Execution
       def initialize(tool)
         @tool = tool
+        @data = @tool.default_data.dup
+        @data[Context::TOOL] = tool
+        @data[Context::TOOL_NAME] = tool.full_name
       end
 
-      def execute(context_base, args)
+      def execute(context_base, args, verbosity: 0)
         return execute_alias(context_base, args) if @tool.alias?
 
-        parsed_args = ParsedArgs.new(@tool, context_base.binary_name, args)
-        context = create_child_context(context_base, parsed_args, args)
+        parse_args(args, verbosity)
+        context = create_child_context(context_base)
 
-        if parsed_args.usage_error
-          puts(parsed_args.usage_error)
-          puts("")
-          show_usage(parsed_args.optparse)
-          -1
-        elsif parsed_args.show_help
-          show_usage(parsed_args.optparse, recursive: parsed_args.recursive)
-          0
-        else
-          catch(:result) do
-            context.instance_eval(&@tool.executor)
-            0
-          end
+        original_level = context.logger.level
+        context.logger.level = context_base.base_level - @data[Context::VERBOSITY]
+        begin
+          perform_execution(context)
+        ensure
+          context.logger.level = original_level
         end
       end
 
       private
 
-      def create_child_context(context_base, parsed_args, args)
-        context = context_base.create_context(@tool.full_name, args, parsed_args.data)
-        context.logger.level += parsed_args.delta_severity
-        @tool.modules.each do |mod|
-          context.extend(mod)
-        end
-        @tool.helpers.each do |name, block|
-          context.define_singleton_method(name, &block)
-        end
-        context
-      end
-
-      def show_usage(optparse, recursive: false)
-        puts(optparse.to_s)
-        if @tool.leaf?
-          required_args = @tool.required_args
-          optional_args = @tool.optional_args
-          remaining_args = @tool.remaining_args
-          if !required_args.empty? || !optional_args.empty? || remaining_args
-            show_positional_arguments(required_args, optional_args, remaining_args)
-          end
-        else
-          show_command_list(recursive)
-        end
-      end
-
-      def show_positional_arguments(required_args, optional_args, remaining_args)
-        puts("")
-        puts("Positional arguments:")
-        args_to_display = required_args + optional_args
-        args_to_display << remaining_args if remaining_args
-        args_to_display.each do |arg_info|
-          puts("    #{arg_info.canonical_name.ljust(31)}  #{arg_info.doc.first}")
-          next if arg_info.doc.empty?
-          arg_info.doc[1..-1].each do |d|
-            puts("                                     #{d}")
-          end
-        end
-      end
-
-      def show_command_list(recursive)
-        puts("")
-        puts("Commands:")
-        name_len = @tool.full_name.length
-        @tool.lookup.list_subtools(@tool.full_name, recursive).each do |subtool|
-          desc = subtool.effective_short_desc
-          tool_name = subtool.full_name.slice(name_len..-1).join(" ").ljust(31)
-          puts("    #{tool_name}  #{desc}")
-        end
-      end
-
-      def execute_alias(context_base, args)
-        target_name = @tool.full_name.slice(0..-2) + [@tool.alias_target]
-        target_tool = @tool.lookup.lookup(target_name)
-        if target_tool.full_name == target_name
-          target_tool.execute(context_base, args)
-        else
-          logger.fatal("Alias target #{@tool.alias_target.inspect} not found")
-          -1
-        end
-      end
-    end
-
-    ##
-    # An internal class that manages parsing of tool arguments
-    # @private
-    #
-    class ParsedArgs
-      def initialize(tool, binary_name, args)
-        binary_name ||= ::File.basename($PROGRAM_NAME)
-        @show_help = !tool.leaf?
-        @usage_error = nil
-        @delta_severity = 0
-        @recursive = false
-        @data = tool.default_data.dup
-        @optparse = create_option_parser(tool, binary_name)
-        parse_args(args, tool)
-      end
-
-      attr_reader :show_help
-      attr_reader :usage_error
-      attr_reader :delta_severity
-      attr_reader :recursive
-      attr_reader :data
-      attr_reader :optparse
-
-      private
-
-      ##
-      # Well-known flags
-      # @private
-      #
-      SPECIAL_FLAGS = %w[
-        -q
-        --quiet
-        -v
-        --verbose
-        -?
-        -h
-        --help
-      ].freeze
-
-      def parse_args(args, tool)
-        remaining = @optparse.parse(args)
-        remaining = parse_required_args(remaining, tool, args)
-        remaining = parse_optional_args(remaining, tool)
-        parse_remaining_args(remaining, tool, args)
+      def parse_args(args, base_verbosity)
+        optparse = create_option_parser
+        @data[Context::VERBOSITY] = base_verbosity
+        @data[Context::ARGS] = args
+        @data[Context::USAGE_ERROR] = nil
+        remaining = optparse.parse(args)
+        remaining = parse_required_args(remaining, args)
+        remaining = parse_optional_args(remaining)
+        parse_remaining_args(remaining, args)
       rescue ::OptionParser::ParseError => e
-        @usage_error = e
+        @data[Context::USAGE_ERROR] = e.message
       end
 
-      def create_option_parser(tool, binary_name)
+      def create_option_parser
         optparse = ::OptionParser.new
-        optparse.banner =
-          if tool.leaf?
-            leaf_banner(tool, binary_name)
-          else
-            collection_banner(tool, binary_name)
-          end
-        unless tool.effective_long_desc.empty?
-          optparse.separator("")
-          optparse.separator(tool.effective_long_desc)
-        end
-        optparse.separator("")
-        optparse.separator("Options:")
-        if tool.leaf?
-          leaf_switches(tool, optparse)
-        else
-          collection_switches(optparse)
-        end
-        optparse
-      end
-
-      def leaf_banner(tool, binary_name)
-        banner = ["Usage:", binary_name] + tool.full_name
-        banner << "[<options...>]" unless tool.switches.empty?
-        tool.required_args.each do |arg_info|
-          banner << "<#{arg_info.canonical_name}>"
-        end
-        tool.optional_args.each do |arg_info|
-          banner << "[<#{arg_info.canonical_name}>]"
-        end
-        if tool.remaining_args
-          banner << "[<#{tool.remaining_args.canonical_name}...>]"
-        end
-        banner.join(" ")
-      end
-
-      def collection_banner(tool, binary_name)
-        (["Usage:", binary_name] + tool.full_name + ["<command>", "[<options...>]"]).join(" ")
-      end
-
-      def leaf_switches(tool, optparse)
-        found_special_flags = []
-        leaf_normal_switches(tool.switches, optparse, found_special_flags)
-        leaf_verbose_switch(optparse, found_special_flags)
-        leaf_quiet_switch(optparse, found_special_flags)
-        leaf_help_switch(optparse, found_special_flags)
-      end
-
-      def collection_switches(optparse)
-        optparse.on("-?", "--help", "Show help message")
-        optparse.on("-r", "--[no-]recursive", "Show all subcommands recursively") do |val|
-          @recursive = val
-        end
-      end
-
-      def leaf_normal_switches(switches, optparse, found_special_flags)
-        switches.each do |switch|
-          found_special_flags |= (switch.optparse_info & SPECIAL_FLAGS)
+        # The following clears out the Officious (hidden default switches).
+        optparse.remove
+        optparse.remove
+        optparse.new
+        optparse.new
+        @tool.switches.each do |switch|
           optparse.on(*switch.optparse_info) do |val|
-            @data[switch.key] = val
+            @data[switch.key] = switch.handler.call(val, @data[switch.key])
           end
         end
+        optparse
       end
 
-      def leaf_verbose_switch(optparse, found_special_flags)
-        flags = ["-v", "--verbose"] - found_special_flags
-        return if flags.empty?
-        optparse.on(*(flags + ["Increase verbosity"])) do
-          @delta_severity -= 1
-        end
-      end
-
-      def leaf_quiet_switch(optparse, found_special_flags)
-        flags = ["-q", "--quiet"] - found_special_flags
-        return if flags.empty?
-        optparse.on(*(flags + ["Decrease verbosity"])) do
-          @delta_severity += 1
-        end
-      end
-
-      def leaf_help_switch(optparse, found_special_flags)
-        flags = ["-?", "-h", "--help"] - found_special_flags
-        return if flags.empty?
-        optparse.on(*(flags + ["Show help message"])) do
-          @show_help = true
-        end
-      end
-
-      def parse_required_args(remaining, tool, args)
-        tool.required_args.each do |arg_info|
-          if !@show_help && remaining.empty?
+      def parse_required_args(remaining, args)
+        @tool.required_args.each do |arg_info|
+          if remaining.empty?
             reason = "No value given for required argument named <#{arg_info.canonical_name}>"
             raise create_parse_error(args, reason)
           end
@@ -566,25 +428,25 @@ module Toys
         remaining
       end
 
-      def parse_optional_args(remaining, tool)
-        tool.optional_args.each do |arg_info|
+      def parse_optional_args(remaining)
+        @tool.optional_args.each do |arg_info|
           break if remaining.empty?
           @data[arg_info.key] = arg_info.process_value(remaining.shift)
         end
         remaining
       end
 
-      def parse_remaining_args(remaining, tool, args)
+      def parse_remaining_args(remaining, args)
         return if remaining.empty?
-        unless tool.remaining_args
-          if tool.leaf?
+        unless @tool.remaining_args
+          if @tool.includes_executor?
             raise create_parse_error(remaining, "Extra arguments provided")
           else
-            raise create_parse_error(tool.full_name + args, "Tool not found")
+            raise create_parse_error(@tool.full_name + args, "Tool not found")
           end
         end
-        @data[tool.remaining_args.key] =
-          remaining.map { |arg| tool.remaining_args.process_value(arg) }
+        @data[@tool.remaining_args.key] =
+          remaining.map { |arg| @tool.remaining_args.process_value(arg) }
       end
 
       def create_parse_error(path, reason)
@@ -592,6 +454,50 @@ module Toys
           e.reason = reason
         end
       end
+
+      def create_child_context(context_base)
+        context = context_base.create_context(@data)
+        @tool.modules.each do |mod|
+          context.extend(mod)
+        end
+        @tool.helpers.each do |name, block|
+          context.define_singleton_method(name, &block)
+        end
+        context
+      end
+
+      def perform_execution(context)
+        executor = proc do
+          if @tool.includes_executor?
+            context.instance_eval(&@tool.executor)
+          else
+            context.logger.fatal("No implementation for #{@tool.display_name.inspect}")
+            context.exit(-1)
+          end
+        end
+        @tool.middleware_stack.reverse.each do |middleware|
+          executor = make_executor(middleware, context, executor)
+        end
+        catch(:result) do
+          executor.call
+          0
+        end
+      end
+
+      def make_executor(middleware, context, next_executor)
+        proc { middleware.execute(context, &next_executor) }
+      end
+
+      def execute_alias(context_base, args)
+        target_name = @tool.full_name.slice(0..-2) + [@tool.alias_target]
+        target_tool = context_base.loader.lookup(target_name)
+        if target_tool.full_name == target_name
+          target_tool.execute(context_base, args)
+        else
+          context_base.logger.fatal("Alias target #{@tool.alias_target.inspect} not found")
+          -1
+        end
+      end
     end
   end
 end