toys 0.3.0 → 0.3.1

data/lib/toys/templates.rb

@@ -34,6 +34,20 @@ module Toys
   # Namespace for common templates
   #
   module Templates
+    ##
+    # Return a template class by name.
+    #
+    # Currently recognized template names are:
+    #
+    # *  `:clean` : Creates a tool that cleans build artifacts.
+    # *  `:gem_build` : Creates a tool that builds and/or releases gems.
+    # *  `:minitest` : Creates a tool that runs unit tests.
+    # *  `:rubocop` : Creates a tool that runs rubocop.
+    # *  `:yardoc` : Creates a tool that generates YARD documentation.
+    #
+    # @param [String,Symbol] name Name of the template class to return
+    # @return [Class,nil] The class, or `nil` if not found
+    #
     def self.lookup(name)
       Utils::ModuleLookup.lookup(:templates, name)
     end

data/lib/toys/templates/clean.rb

@@ -35,6 +35,18 @@ module Toys
     class Clean
       include Template
 
+      ##
+      # Create the template settings for the Clean template.
+      #
+      # You may provide a hash of options when expanding this template.
+      # Supported options include:
+      #
+      # *  `:name` (String) Name of the tool to create. Defaults to "clean".
+      # *  `:paths` (Array<String>) An array of glob patterns indicating what
+      #    to clean.
+      #
+      # @param [Hash] opts Options.
+      #
       def initialize(opts = {})
         @name = opts[:name] || "clean"
         @paths = opts[:paths] || []
@@ -44,7 +56,7 @@ module Toys
       attr_accessor :paths
 
       to_expand do |template|
-        name(template.name) do
+        tool(template.name) do
           desc "Clean built files and directories."
 
           use :file_utils
@@ -52,7 +64,6 @@ module Toys
           execute do
             files = []
             patterns = Array(template.paths)
-            patterns = ["lib/**/*.rb"] if patterns.empty?
             patterns.each do |pattern|
               files.concat(::Dir.glob(pattern))
             end

data/lib/toys/templates/gem_build.rb

@@ -37,6 +37,24 @@ module Toys
     class GemBuild
       include Template
 
+      ##
+      # Create the template settings for the GemBuild template.
+      #
+      # You may provide a hash of options when expanding this template.
+      # Supported options include:
+      #
+      # *  `:name` (String) Name of the tool to create. Defaults to "build".
+      # *  `:gem_name` (String) Name of the gem to build. If not provided,
+      #    defaults to the first gemspec file it finds.
+      # *  `:push_gem` (Boolean) If true, pushes the built gem to rubygems.
+      # *  `:tag` (Boolean) If true, tags the git repo with the gem version.
+      # *  `:push_tag` (Boolean,String) If truthy, pushes the new tag to
+      #    a git remote. You may specify which remote by setting the value to
+      #    a string. Otherwise, if the value is simply `true`, the "origin"
+      #    remote is used by default.
+      #
+      # @param [Hash] opts Options.
+      #
       def initialize(opts = {})
         @name = opts[:name] || "build"
         @gem_name = opts[:gem_name]
@@ -61,7 +79,7 @@ module Toys
         end
         task_type = template.push_gem ? "Release" : "Build"
 
-        name(template.name) do
+        tool(template.name) do
           desc "#{task_type} the gem: #{template.gem_name}"
 
           use :file_utils

data/lib/toys/templates/minitest.rb

@@ -35,10 +35,25 @@ module Toys
     class Minitest
       include Template
 
+      ##
+      # Create the template settings for the Minitest template.
+      #
+      # You may provide a hash of options when expanding this template.
+      # Supported options include:
+      #
+      # *  `:name` (String) Name of the tool to create. Defaults to "test".
+      # *  `:lib` (Array<String>) An array of library paths to add to the
+      #    ruby require path.
+      # *  `:files` (Array<String>) An array of globs indicating the test
+      #    files to load.
+      # *  `:warnings` (Boolean) If true, runs tests with Ruby warnings.
+      #
+      # @param [Hash] opts Options.
+      #
       def initialize(opts = {})
         @name = opts[:name] || "test"
         @libs = opts[:libs] || ["lib"]
-        @files = opts[:files] || ["test/test*.rb"]
+        @files = opts[:files] || ["test/**/test*.rb"]
         @warnings = opts.include?(:warnings) ? opts[:warnings] : true
       end
 
@@ -48,7 +63,7 @@ module Toys
       attr_accessor :warnings
 
       to_expand do |template|
-        name(template.name) do
+        tool(template.name) do
           desc "Run minitest on the current project."
 
           use :exec

data/lib/toys/templates/rubocop.rb

@@ -35,6 +35,19 @@ module Toys
     class Rubocop
       include Template
 
+      ##
+      # Create the template settings for the Rubocop template.
+      #
+      # You may provide a hash of options when expanding this template.
+      # Supported options include:
+      #
+      # *  `:name` (String) Name of the tool to create. Defaults to "rubocop".
+      # *  `:fail_on_error` (Boolean) If true, exits with a nonzero code if
+      #    Rubocop fails. Defaults to true.
+      # *  `:options` (Hash) Additional options passed to the Rubocop CLI.
+      #
+      # @param [Hash] opts Options.
+      #
       def initialize(opts = {})
         @name = opts[:name] || "rubocop"
         @fail_on_error = opts.include?(:fail_on_error) ? opts[:fail_on_error] : true
@@ -46,7 +59,7 @@ module Toys
       attr_accessor :options
 
       to_expand do |template|
-        name(template.name) do
+        tool(template.name) do
           desc "Run rubocop on the current project."
 
           use :exec

data/lib/toys/templates/yardoc.rb

@@ -35,6 +35,20 @@ module Toys
     class Yardoc
       include Template
 
+      ##
+      # Create the template settings for the Yardoc template.
+      #
+      # You may provide a hash of options when expanding this template.
+      # Supported options include:
+      #
+      # *  `:name` (String) Name of the tool to create. Defaults to "yardoc".
+      # *  `:files` (Array<String>) An array of globs indicating the files
+      #    to document.
+      # *  `:options` (Hash) Additional options passed to YARD
+      # *  `:stats_options` (Hash) Additional options passed to YARD stats
+      #
+      # @param [Hash] opts Options.
+      #
       def initialize(opts = {})
         @name = opts[:name] || "yardoc"
         @files = opts[:files] || []
@@ -48,7 +62,7 @@ module Toys
       attr_accessor :stats_options
 
       to_expand do |template|
-        name(template.name) do
+        tool(template.name) do
           desc "Run yardoc on the current project."
 
           use :exec

data/lib/toys/tool.rb

@@ -31,12 +31,21 @@ require "optparse"
 
 module Toys
   ##
-  # A tool definition
+  # A Tool is 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 switches and
+  # command line arguments supported, and a block that gets run when the
+  # tool is executed.
   #
   class Tool
-    def initialize(full_name, middleware_stack)
-      @full_name = full_name
-      @middleware_stack = middleware_stack.dup
+    ##
+    # Create a new tool.
+    #
+    # @param [Array<String>] full_name The name of the tool
+    #
+    def initialize(full_name)
+      @full_name = full_name.dup.freeze
+      @middleware_stack = []
 
       @definition_path = nil
       @cur_path = nil
@@ -47,99 +56,200 @@ module Toys
       @long_desc = nil
 
       @default_data = {}
-      @switches = []
-      @required_args = []
-      @optional_args = []
-      @remaining_args = nil
+      @switch_definitions = []
+      @required_arg_definitions = []
+      @optional_arg_definitions = []
+      @remaining_args_definition = nil
 
       @helpers = {}
       @modules = []
       @executor = nil
     end
 
+    ##
+    # Return the name of the tool as an array of strings.
+    # This array may not be modified.
+    # @return [Array<String>]
+    #
     attr_reader :full_name
-    attr_reader :switches
-    attr_reader :required_args
-    attr_reader :optional_args
-    attr_reader :remaining_args
+
+    ##
+    # Return a list of all defined switches.
+    # @return [Array<Toys::Tool::SwitchDefinition>]
+    #
+    attr_reader :switch_definitions
+
+    ##
+    # Return a list of all defined required positional arguments.
+    # @return [Array<Toys::Tool::ArgDefinition>]
+    #
+    attr_reader :required_arg_definitions
+
+    ##
+    # Return a list of all defined optional positional arguments.
+    # @return [Array<Toys::Tool::ArgDefinition>]
+    #
+    attr_reader :optional_arg_definitions
+
+    ##
+    # Return the remaining arguments specification, or `nil` if remaining
+    # arguments are currently not supported by this tool.
+    # @return [Toys::Tool::ArgDefinition,nil]
+    #
+    attr_reader :remaining_args_definition
+
+    ##
+    # Return the default argument data.
+    # @return [Hash]
+    #
     attr_reader :default_data
+
+    ##
+    # Return a list of modules that will be available during execution.
+    # @return [Array<Module>]
+    #
     attr_reader :modules
+
+    ##
+    # Return a list of helper methods that will be available during execution.
+    # @return [Hash{Symbol => Proc}]
+    #
     attr_reader :helpers
+
+    ##
+    # Return the executor block, or `nil` if not present.
+    # @return [Proc,nil]
+    #
     attr_reader :executor
+
+    ##
+    # If this tool is an alias, return the alias target as a local name (i.e.
+    # a single word identifying a sibling of this tool). Returns `nil` if this
+    # tool is not an alias.
+    # @return [String,nil]
+    #
     attr_reader :alias_target
+
+    ##
+    # Returns the middleware stack
+    # @return [Array<Object>]
+    #
     attr_reader :middleware_stack
+
+    ##
+    # Returns the path to the file that contains the definition of this tool.
+    # @return [String]
+    #
     attr_reader :definition_path
 
+    ##
+    # Returns the local name of this tool.
+    # @return [String]
+    #
     def simple_name
       full_name.last
     end
 
+    ##
+    # Returns a displayable name of this tool, generally the full name
+    # delimited by spaces.
+    # @return [String]
+    #
     def display_name
       full_name.join(" ")
     end
 
+    ##
+    # Returns true if this tool is a root tool.
+    # @return [Boolean]
+    #
     def root?
       full_name.empty?
     end
 
+    ##
+    # Returns true if this tool has an executor defined.
+    # @return [Boolean]
+    #
     def includes_executor?
       executor.is_a?(::Proc)
     end
 
+    ##
+    # Returns true if this tool is an alias.
+    # @return [Boolean]
+    #
     def alias?
       !alias_target.nil?
     end
 
+    ##
+    # Returns the effective short description for this tool. This will be
+    # displayed when this tool is listed in a command list.
+    # @return [String]
+    #
     def effective_desc
       @desc || default_desc
     end
 
+    ##
+    # Returns the effective long description for this tool. This will be
+    # displayed as part of the usage for this particular tool.
+    # @return [String]
+    #
     def effective_long_desc
       @long_desc || @desc || default_desc
     end
 
+    ##
+    # Returns true if there is a specific description set for this tool.
+    # @return [Boolean]
+    #
     def includes_description?
       !@long_desc.nil? || !@desc.nil?
     end
 
+    ##
+    # Returns true if at least one switch or positional argument is defined
+    # for this tool.
+    # @return [Boolean]
+    #
     def includes_arguments?
-      !default_data.empty? || !switches.empty? ||
-        !required_args.empty? || !optional_args.empty? || !remaining_args.nil?
+      !default_data.empty? || !switch_definitions.empty? ||
+        !required_arg_definitions.empty? || !optional_arg_definitions.empty? ||
+        !remaining_args_definition.nil?
     end
 
+    ##
+    # Returns true if at least one helper method or module is added to this
+    # tool.
+    # @return [Boolean]
+    #
     def includes_helpers?
       !helpers.empty? || !modules.empty?
     end
 
+    ##
+    # Returns true if this tool has any definition information.
+    # @return [Boolean]
+    #
     def includes_definition?
       alias? || includes_arguments? || includes_executor? || includes_helpers?
     end
 
+    ##
+    # Returns a list of switch flags used by this tool.
+    # @return [Array<String>]
+    #
     def used_switches
-      @switches.reduce([]) { |used, switch| used + switch.switches }.uniq
-    end
-
-    def defining_from(path)
-      raise ToolDefinitionError, "Already being defined" if @cur_path
-      @cur_path = path
-      begin
-        yield
-      ensure
-        @definition_path = @cur_path if includes_description? || includes_definition?
-        @cur_path = nil
-      end
-    end
-
-    def yield_definition
-      saved_path = @cur_path
-      @cur_path = nil
-      begin
-        yield
-      ensure
-        @cur_path = saved_path
-      end
+      @switch_definitions.reduce([]) { |used, sdef| used + sdef.switches }.uniq
     end
 
+    ##
+    # Make this tool an alias of the sibling tool with the given local name.
+    #
+    # @param [String] target_word The name of the alias target
+    #
     def make_alias_of(target_word)
       if root?
         raise ToolDefinitionError, "Cannot make the root tool an alias"
@@ -152,16 +262,33 @@ module Toys
       self
     end
 
+    ##
+    # Set the short description.
+    #
+    # @param [String] str The short description
+    #
     def desc=(str)
       check_definition_state
       @desc = str
     end
 
+    ##
+    # Set the long description.
+    #
+    # @param [String] str The long description
+    #
     def long_desc=(str)
       check_definition_state
       @long_desc = str
     end
 
+    ##
+    # Define a helper method that will be available during execution.
+    # Pass the name of the method in the argument, and provide a block with
+    # the method body. Note the method name may not start with an underscore.
+    #
+    # @param [String] name The method name
+    #
     def add_helper(name, &block)
       check_definition_state
       name_str = name.to_s
@@ -172,6 +299,12 @@ module Toys
       self
     end
 
+    ##
+    # Mix in the given module during execution. You may provide the module
+    # itself, or the name of a well-known module under {Toys::Helpers}.
+    #
+    # @param [Module,String] name The module or module name.
+    #
     def use_module(name)
       check_definition_state
       case name
@@ -189,49 +322,174 @@ module Toys
       self
     end
 
+    ##
+    # Add a switch to the current tool. Each switch must specify a key which
+    # the executor may use to obtain the switch value from the context.
+    # You may then provide the switches themselves in `OptionParser` form.
+    #
+    # @param [Symbol] key The key to use to retrieve the value from the
+    #     execution context.
+    # @param [String...] switches The switches in OptionParser format.
+    # @param [Object,nil] accept An OptionParser acceptor. Optional.
+    # @param [Object] default The default value. This is the value that will
+    #     be set in the context if this switch is not provided on the command
+    #     line. Defaults to `nil`.
+    # @param [String,nil] doc The documentation for the switch, which appears
+    #     in the usage documentation. Defaults to `nil` for no documentation.
+    # @param [Boolean] only_unique If true, any switches that are already
+    #     defined in this tool are removed from this switch. For example, if
+    #     an earlier switch uses `-a`, and this switch wants to use both
+    #     `-a` and `-b`, then only `-b` will be assigned to this switch.
+    #     Defaults to false.
+    # @param [Proc,nil] handler An optional handler for setting/updating the
+    #     value. If given, it should take two arguments, the new given value
+    #     and the previous value, and it should return the new value that
+    #     should be set. The default handler simply replaces the previous
+    #     value. i.e. the default is effectively `-> (val, _prev) { val }`.
+    #
     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)
-      switch_info = SwitchInfo.new(key, switches, handler)
+      bad_switch = switches.find { |s| Tool.extract_switch(s).empty? }
+      if bad_switch
+        raise ToolDefinitionError, "Illegal switch: #{bad_switch.inspect}"
+      end
+      switch_info = SwitchDefinition.new(key, switches + Array(accept) + Array(doc), handler)
       if only_unique
         switch_info.remove_switches(used_switches)
       end
       if switch_info.active?
         @default_data[key] = default
-        @switches << switch_info
+        @switch_definitions << switch_info
       end
       self
     end
 
+    ##
+    # Add a required positional argument to the current tool. You must specify
+    # a key which the executor may use to obtain the argument value from the
+    # context.
+    #
+    # @param [Symbol] key The key to use to retrieve the value from the
+    #     execution context.
+    # @param [Object,nil] accept An OptionParser acceptor. Optional.
+    # @param [String,nil] doc The documentation for the switch, which appears
+    #     in the usage documentation. Defaults to `nil` for no documentation.
+    #
     def add_required_arg(key, accept: nil, doc: nil)
       check_definition_state
       @default_data[key] = nil
-      @required_args << ArgInfo.new(key, accept, Array(doc))
+      @required_arg_definitions << ArgDefinition.new(key, accept, Array(doc))
       self
     end
 
+    ##
+    # Add an optional positional argument to the current tool. You must specify
+    # a key which the executor may use to obtain the argument value from the
+    # context. If an optional argument is not given on the command line, the
+    # value is set to the given default.
+    #
+    # @param [Symbol] key The key to use to retrieve the value from the
+    #     execution context.
+    # @param [Object,nil] accept An OptionParser acceptor. Optional.
+    # @param [Object] default The default value. This is the value that will
+    #     be set in the context if this argument is not provided on the command
+    #     line. Defaults to `nil`.
+    # @param [String,nil] doc The documentation for the argument, which appears
+    #     in the usage documentation. Defaults to `nil` for no documentation.
+    #
     def add_optional_arg(key, accept: nil, default: nil, doc: nil)
       check_definition_state
       @default_data[key] = default
-      @optional_args << ArgInfo.new(key, accept, Array(doc))
+      @optional_arg_definitions << ArgDefinition.new(key, accept, Array(doc))
       self
     end
 
+    ##
+    # Specify what should be done with unmatched positional arguments. You must
+    # specify a key which the executor may use to obtain the remaining args
+    # from the context.
+    #
+    # @param [Symbol] key The key to use to retrieve the value from the
+    #     execution context.
+    # @param [Object,nil] accept An OptionParser acceptor. Optional.
+    # @param [Object] default The default value. This is the value that will
+    #     be set in the context if no unmatched arguments are provided on the
+    #     command line. Defaults to the empty array `[]`.
+    # @param [String,nil] doc The documentation for the remaining arguments,
+    #     which appears in the usage documentation. Defaults to `nil` for no
+    #     documentation.
+    #
     def set_remaining_args(key, accept: nil, default: [], doc: nil)
       check_definition_state
       @default_data[key] = default
-      @remaining_args = ArgInfo.new(key, accept, Array(doc))
+      @remaining_args_definition = ArgDefinition.new(key, accept, Array(doc))
       self
     end
 
+    ##
+    # Set the executor for this tool. This is a proc that will be called,
+    # with `self` set to a {Toys::Context}.
+    #
+    # @param [Proc] executor The executor for this tool.
+    #
     def executor=(executor)
       check_definition_state
       @executor = executor
     end
 
+    ##
+    # Execute this tool in the given context.
+    #
+    # @param [Toys::Context::Base] context_base The execution context
+    # @param [Array<String>] args The arguments to pass to the tool. Should
+    #     not include the tool name.
+    # @param [Integer] verbosity The starting verbosity. Defaults to 0.
+    #
+    # @return [Integer] The result code.
+    #
+    def execute(context_base, args, verbosity: 0)
+      finish_definition unless @definition_finished
+      Execution.new(self).execute(context_base, args, verbosity: verbosity)
+    end
+
+    ##
+    # Declare that this tool is now defined in the given path
+    #
+    # @private
+    #
+    def defining_from(path)
+      raise ToolDefinitionError, "Already being defined" if @cur_path
+      @cur_path = path
+      begin
+        yield
+      ensure
+        @definition_path = @cur_path if includes_description? || includes_definition?
+        @cur_path = nil
+      end
+    end
+
+    ##
+    # Relinquish the current path declaration
+    #
+    # @private
+    #
+    def yield_definition
+      saved_path = @cur_path
+      @cur_path = nil
+      begin
+        yield
+      ensure
+        @cur_path = saved_path
+      end
+    end
+
+    ##
+    # Complete definition and run middleware configs
+    #
+    # @private
+    #
     def finish_definition
       if !alias? && !@definition_finished
         config_proc = proc {}
@@ -244,11 +502,6 @@ module Toys
       self
     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)
@@ -282,69 +535,148 @@ module Toys
     end
 
     class << self
+      ## @private
       def canonical_switch(name)
         name.to_s.downcase.tr("_", "-").gsub(/[^a-z0-9-]/, "")
       end
+
+      ## @private
+      def extract_switch(str)
+        if !str.is_a?(String)
+          []
+        elsif str =~ /^(-[\?\w])(\s?\w+)?$/
+          [$1]
+        elsif str =~ /^--\[no-\](\w[\?\w-]*)$/
+          ["--#{$1}", "--no-#{$1}"]
+        elsif str =~ /^(--\w[\?\w-]*)([=\s]\w+)?$/
+          [$1]
+        else
+          []
+        end
+      end
     end
 
     ##
-    # Representation of a formal switch
+    # Representation of a formal switch.
     #
-    class SwitchInfo
+    class SwitchDefinition
+      ##
+      # Create a SwitchDefinition
+      #
+      # @param [Symbol] key This switch will set the given context key.
+      # @param [Array<String>] optparse_info The switch definition in
+      #     OptionParser format
+      # @param [Proc,nil] handler An optional handler for setting/updating the
+      #     value. If given, it should take two arguments, the new given value
+      #     and the previous value, and it should return the new value that
+      #     should be set. If `nil`, uses a default handler that just replaces
+      #     the previous value. i.e. the default is effectively
+      #     `-> (val, _prev) { val }`.
+      #
       def initialize(key, optparse_info, handler = nil)
         @key = key
         @optparse_info = optparse_info
-        @handler = handler || ->(val, _cur) { val }
+        @handler = handler || ->(val, _prev) { val }
         @switches = nil
       end
 
+      ##
+      # Returns the key.
+      # @return [Symbol]
+      #
       attr_reader :key
+
+      ##
+      # Returns the OptionParser definition.
+      # @return [Array<String>]
+      #
       attr_reader :optparse_info
+
+      ##
+      # Returns the handler.
+      # @return [Proc]
+      #
       attr_reader :handler
 
+      ##
+      # Returns the list of switches used.
+      # @return [Array<String>]
+      #
       def switches
-        @switches ||= optparse_info.map { |s| extract_switch(s) }.flatten
+        @switches ||= optparse_info.map { |s| Tool.extract_switch(s) }.flatten
       end
 
+      ##
+      # Returns true if this switch is active. That is, it has a nonempty
+      # switches list.
+      # @return [Boolean]
+      #
       def active?
         !switches.empty?
       end
 
+      ##
+      # Removes the given switches.
+      # @param [Array<String>] switches
+      #
       def remove_switches(switches)
         @optparse_info.select! do |s|
-          extract_switch(s).all? { |ss| !switches.include?(ss) }
+          Tool.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
 
     ##
-    # Representation of a formal argument
+    # Representation of a formal positional argument
     #
-    class ArgInfo
+    class ArgDefinition
+      ##
+      # Create an ArgDefinition
+      #
+      # @param [Symbol] key This argument will set the given context key.
+      # @param [Object] accept An OptionParser acceptor
+      # @param [Array<String>] doc An array of documentation strings
+      #
       def initialize(key, accept, doc)
         @key = key
         @accept = accept
         @doc = doc
       end
 
+      ##
+      # Returns the key.
+      # @return [Symbol]
+      #
       attr_reader :key
+
+      ##
+      # Returns the acceptor.
+      # @return [Object]
+      #
       attr_reader :accept
+
+      ##
+      # Returns the documentation strings.
+      # @return [Array<String>]
+      #
       attr_reader :doc
 
+      ##
+      # Return a canonical name for this arg. Used in usage documentation.
+      #
+      # @return [String]
+      #
+      def canonical_name
+        Tool.canonical_switch(key)
+      end
+
+      ##
+      # Process the given value through the acceptor.
+      #
+      # @private
+      #
       def process_value(val)
         return val unless accept
         n = canonical_name
@@ -354,10 +686,6 @@ module Toys
         optparse.parse(["--#{n}", val])
         result
       end
-
-      def canonical_name
-        Tool.canonical_switch(key)
-      end
     end
 
     ##
@@ -409,7 +737,7 @@ module Toys
         optparse.remove
         optparse.new
         optparse.new
-        @tool.switches.each do |switch|
+        @tool.switch_definitions.each do |switch|
           optparse.on(*switch.optparse_info) do |val|
             @data[switch.key] = switch.handler.call(val, @data[switch.key])
           end
@@ -418,7 +746,7 @@ module Toys
       end
 
       def parse_required_args(remaining, args)
-        @tool.required_args.each do |arg_info|
+        @tool.required_arg_definitions.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)
@@ -429,7 +757,7 @@ module Toys
       end
 
       def parse_optional_args(remaining)
-        @tool.optional_args.each do |arg_info|
+        @tool.optional_arg_definitions.each do |arg_info|
           break if remaining.empty?
           @data[arg_info.key] = arg_info.process_value(remaining.shift)
         end
@@ -438,15 +766,15 @@ module Toys
 
       def parse_remaining_args(remaining, args)
         return if remaining.empty?
-        unless @tool.remaining_args
+        unless @tool.remaining_args_definition
           if @tool.includes_executor?
             raise create_parse_error(remaining, "Extra arguments provided")
           else
             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_definition.key] =
+          remaining.map { |arg| @tool.remaining_args_definition.process_value(arg) }
       end
 
       def create_parse_error(path, reason)