toys 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 516ab9d472491bb7250ac10e033024dd2e621908836d8e7ccce46d563418d3d3
-  data.tar.gz: 706e194857b09e1f24f2a360d03ba42259b1782284c80f56299bef3d5dc991b4
+  metadata.gz: 1af0f4b8108ed4bf39da40bffa62fd4cc601df712b0b2e0a5a8d7ff9eb7cb160
+  data.tar.gz: 6c8f02f7f0e5a84c13e3ef7048febbab744f89fc14ca950221d6c56130eb8fc6
 SHA512:
-  metadata.gz: 21ea81146849ffa1549803556ec237af812223b7d3e88ae4f36115ac1ee45ce8795bedbc3b6cbf5168322d557cb85397e89c51195bb8385172ab1bc61b47b24f
-  data.tar.gz: 0c5ec538c871002c01261cfe662ba732f164fb977ed7906460608517f86c0bc16319ba7da3f7e5294ac8aab7e786a5ab0126dbfe7c5ff50d4815ce3514514c8e
+  metadata.gz: 7976bb5dd0d9619f44b6c4e88ef63f417ccf88a72fb2f89aa6d5528eb70270c0dead339419b4339a184f7ef8d7fe7d6a2161f9119a3aa03af425831d54ceed22
+  data.tar.gz: 59e8a779fddedfa0b38245d36002b8e5626be6f9740d2e2090c5fe65ef225dd3278461a20d7e3928a6ce9b6a798f943d818cb3916aeda5562f89e1e7fdc7d8f9

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Release History
 
+### 0.6.0 / 2018-10-22
+
+* FIXED: Build tools cd into the context directory when running.
+* FIXED: Rakefiles are evaluated and tasks are run in the Rakefile's directory.
+* ADDED: Context directory is available in the DSL and the tool runtime.
+* IMPROVED: Rake template searches parent directories for Rakefile.
+* IMPROVED: Rake tasks show the Rakefile path in the long description.
+* IMPROVED: Subtools whose names begin with underscore are no longer listed in help
+  screens unless the `--all` flag is given.
+* IMPROVED: Non-runnable namespaces are no longer displayed in recursive subtool
+  lists if their children are already displayed.
+
 ### 0.5.0 / 2018-10-07
 
 * ADDED: Period and colon are recognized as tool path delimiters.

data/docs/guide.md

@@ -1079,13 +1079,13 @@ which can be used to call another tool:
     end
 
 Pass the tool name and arguments as arguments to the run method. It will
-execute, and return a process status object (i.e. 0 for success, and nonzero
-for error). Make sure you handle the exit status. For example, in most cases,
-you should probably exit if the tool you are calling returns a nonzero code.
+execute, and return a process status code (i.e. 0 for success, and nonzero for
+error). Make sure you handle the exit status. For example, in most cases, you
+should probably exit if the tool you are calling returns a nonzero code.
 
 You may also use the `exec` mixin [described below](#Executing_Subprocesses) to
 run a tool in a separate process. This is particularly useful if you need to
-capture or manipulate that tool's input or output.
+capture or manipulate that tool's input or output stream.
 
 ### Helper Methods and Mixins
 
@@ -1572,96 +1572,6 @@ Either a single `.preload.rb` file or a `.preload` directory, or both, may be
 used. If both are present, the `.preload.rb` file is loaded first before the
 `.preload` directory contents.
 
-### Data Files
-
-If your tools require images, archives, keys, or other such static data, Toys
-provides a convenient place to put data files that can be looked up by tools
-either during definition or runtime.
-
-To use data files, you must define your tools inside a
-[Toys directory](#Toys_Directories). Within the Toys directory, create a
-directory named `.data` and copy your data files there. You may "find" a data
-file using the `find_data` directive in a Toys file, or by calling the
-`find_data` method in a tool. The `find_data` mechanism takes a relative path
-to a file, locates a matching file (or directory) among the data files, and
-returns the full path to that file system object. You may then read the file
-or perform any other operation on it.
-
-For example, take the following directory structure:
-
-    (current directory)
-    |
-    +- .toys/
-       |
-       +- .data
-       |  |
-       |  +- greeting.txt
-       |  |
-       |  +- desc/
-       |     |
-       |     +- short.txt
-       |
-       +- greet.rb   <-- defines "greet" (and subtools)
-
-The data files in `.toys/.data` are available to any tool in the `.toys`
-directory or any of its subdirectories. For example, suppose we want our
-"greet" tool to use the contents of `greeting.txt`. We can call `find_data` to
-read those contents when the tool is executed:
-
-    # greet.rb
-    desc "Print a friendly greeting."
-    optional_arg :whom, default: "world", desc: "Whom to greet."
-    def run
-      greeting = IO.read(find_data("greeting.txt")).strip
-      puts "#{greeting}, #{whom}!"
-    end
-
-You can include directories in the argument to `find_data`. For example, here
-is how to use the `find_data` directive to read the short description from the
-file "desc/short.txt":
-
-    # greet.rb
-    desc IO.read(find_data("desc/short.txt")).strip
-    optional_arg :whom, default: "world", desc: "Whom to greet."
-    def run
-      greeting = IO.read(find_data("greeting.txt")).strip
-      puts "#{greeting}, #{whom}!"
-    end
-
-The `find_data` mechanism will return the "closest" file or directory found.
-In the example below, there is a `desc/short.txt` file in the `.data` directory
-at the top level, but there is also a `desc/short.txt` file in the `.data`
-directory under `test`. Tools under the `test` directory will find the more
-specific data file, while other tools will find the more general file.
-
-    (current directory)
-    |
-    +- .toys/
-       |
-       +- .data
-       |  |
-       |  +- greeting.txt
-       |  |
-       |  +- desc/
-       |     |
-       |     +- short.txt  <-- default description for all tools
-       |
-       +- greet.rb   <-- defines "greet" (and subtools)
-       |
-       +- test/
-          |
-          +- .data
-          |  |
-          |  +- desc/
-          |     |
-          |     +- short.txt  <-- override description for test tools
-          |
-          +- unit.rb   <-- defines "test unit" (and its subtools)
-
-If, however, you find `greeting.txt` from a tool under `test`, it will still
-find the more general `.toys/.data/greeting.txt` file because there is no
-overriding file under `.toys/test/.data`.
-
 ## Using Third-Party Gems
 
 The Ruby community has developed many resources for building command line
@@ -1814,8 +1724,8 @@ Toys was designed to organize scripts that may be "scoped" to a project or
 directory. Rake is also commonly used for this purpose: you can write a
 "Rakefile" that defines rake tasks scoped to a directory. In many cases, Toys
 can be used as a replacement for Rake. Indeed, the Toys repository itself
-contains a `.toys.rb` file that defines tools for running tests, builds, and so
-forth, instead of a Rakefile.
+contains a `.toys.rb` file instead of a Rakefile for running tests, builds, and
+so forth.
 
 This section will explore the differences between Toys and Rake, and describe
 how to use Toys for some of the things traditionally done with Rake.
@@ -1859,7 +1769,7 @@ it focuses on making it easy to define imperative tasks.
 All told, this boils down to the principle of using the best tool for the job.
 There will be times when you need to express file-based dependencies in some of
 your build tasks. Rake will continue to be your friend in those cases. However,
-for high level tasks such as "run my tests", "build my YARD documentation", or
+for imperative tasks such as "run my tests", "build my YARD documentation", or
 "release my gem", you may find Toys easier to use.
 
 ### Using Toys to Invoke Rake Tasks
@@ -1955,17 +1865,18 @@ can use either or both tools, depending on your needs.
 
 Toys provides a built-in template for minitest, called `:minitest`. It is
 implemented by the template class {Toys::Templates::Minitest}, and it uses the
-minitest gem, which is provided with most recent versions of Ruby. The
-following directive uses the minitest template to create a tool called `test`:
+[minitest gem](https://rubygems.org/gems/minitest). The following directive
+uses the minitest template to create a tool called `test`:
 
     expand :minitest, files: ["test/test*.rb"], libs: ["lib", "ext"]
 
 See the {Toys::Templates::Minitest} documentation for details on the various
 options.
 
-If you want to enforce code style using the "rubocop" gem, you can use the
-built-in `:rubocop` template. The following directive uses this template to
-create a tool called `rubocop`:
+If you want to enforce code style using the
+[rubocop gem](https://rubygems.org/gems/rubocop), you can use the built-in
+`:rubocop` template. The following directive uses this template to create a
+tool called `rubocop`:
 
     expand :rubocop
 
@@ -2020,13 +1931,13 @@ Here's an example for YARD, creating a tool called `yardoc`:
 Let's look at a complete example that combines the techniques above to provide
 all the basic tools for a Ruby gem. It includes:
 
-* A testing tool that can be run with `toys test`
-* Code style checking using Rubocop, run with `toys rubocop`
-* Documentation building using Yardoc, run with `toys yardoc`
-* Gem building, run with `toys build`
-* Gem build and release to Rubygems.org, run with `toys release`
-* A full CI tool, run with `toys ci`, that can be run from your favorite CI
-  system. It runs the tests and style checks, and checks (but does not
+* A testing tool that can be invoked using `toys test`
+* Code style checking using Rubocop, invoked using `toys rubocop`
+* Documentation building using Yardoc, invoked using `toys yardoc`
+* Gem building, invoked using `toys build`
+* Gem build and release to Rubygems.org, invoked using `toys release`
+* A full CI tool, invoked using `toys ci`, that can be run from your favorite
+  CI system. It runs the tests and style checks, and checks (but does not
   actually build) the documentation for warnings and completeness.
 
 Below is the full annotated `.toys.rb` file. For many gems, you could drop this
@@ -2211,10 +2122,10 @@ completely disable decreasing the verbosity, disable both `-q` and `--quiet`.
 
 Normally Toys handles parsing command line arguments for you. This makes
 writing tools easier, and also allows Toys to generate documentation
-automatically for flags and arguments. However, occasionally you'll not want
-Toys to perform any parsing, but just to give you the command line arguments
+automatically for flags and arguments. However, occasionally you'll want Toys
+not to perform any parsing, but just to give you the command line arguments
 raw. One common case is if your tool turns around and passes its arguments
-verbatim to another subprocess.
+verbatim to a subprocess.
 
 To disable argument parsing, use the `disable_argument_parsing` directive. This
 directive disables parsing and validation of flags and positional arguments.
@@ -2233,6 +2144,232 @@ Here is an example that wraps calls to git:
       end
     end
 
+### Data Files
+
+If your tools require images, archives, keys, or other such static data, Toys
+provides a convenient place to put data files that can be looked up by tools
+either during definition or runtime.
+
+To use data files, you must define your tools inside a
+[Toys directory](#Toys_Directories). Within the Toys directory, create a
+directory named `.data` and copy your data files there.
+
+You may then "find" a data file by providing the relative path to the file from
+the `.data` directory. When defining a tool, use the
+[Toys::DSL::Tool#find_data](https://www.rubydoc.info/gems/toys-core/Toys%2FDSL%2FTool:find_data)
+directive in a Toys file. Or, at tool execution time, call
+[Toys::Tool#find_data](https://www.rubydoc.info/gems/toys-core/Toys%2FTool:find_data)
+(which is a convenience method for getting the tool source object using the
+`TOOL_SOURCE` key, and calling
+[Toys::Definition::SourceInfo#find_data](https://www.rubydoc.info/gems/toys-core/Toys%2FDefinition%2FSourceInfo:find_data)
+on it). In either case, `find_data` locates a matching file (or directory)
+among the data files, and returns the full path to that file system object. You
+may then read the file or perform any other operation on it.
+
+For example, take the following directory structure:
+
+    (current directory)
+    |
+    +- .toys/
+       |
+       +- .data/
+       |  |
+       |  +- greeting.txt
+       |  |
+       |  +- desc/
+       |     |
+       |     +- short.txt
+       |
+       +- greet.rb   <-- defines "greet" (and subtools)
+
+The data files in `.toys/.data` are available to any tool in the `.toys`
+directory or any of its subdirectories. For example, suppose we want our
+"greet" tool to use the contents of `greeting.txt`. We can call `find_data` to
+read those contents when the tool is executed:
+
+    # greet.rb
+    desc "Print a friendly greeting."
+    optional_arg :whom, default: "world", desc: "Whom to greet."
+    def run
+      greeting = IO.read(find_data("greeting.txt")).strip
+      puts "#{greeting}, #{whom}!"
+    end
+
+You can include directories in the argument to `find_data`. For example, here
+is how to use the `find_data` directive to read the short description from the
+file "desc/short.txt":
+
+    # greet.rb
+    desc IO.read(find_data("desc/short.txt")).strip
+    optional_arg :whom, default: "world", desc: "Whom to greet."
+    def run
+      greeting = IO.read(find_data("greeting.txt")).strip
+      puts "#{greeting}, #{whom}!"
+    end
+
+The `find_data` mechanism will return the "closest" file or directory found.
+In the example below, there is a `desc/short.txt` file in the `.data` directory
+at the top level, but there is also a `desc/short.txt` file in the `.data`
+directory under `test`. Tools under the `test` directory will find the more
+specific data file, while other tools will find the more general file.
+
+    (current directory)
+    |
+    +- .toys/
+       |
+       +- .data/
+       |  |
+       |  +- greeting.txt
+       |  |
+       |  +- desc/
+       |     |
+       |     +- short.txt  <-- default description for all tools
+       |
+       +- greet.rb   <-- defines "greet" (and subtools)
+       |
+       +- test/
+          |
+          +- .data/
+          |  |
+          |  +- desc/
+          |     |
+          |     +- short.txt  <-- override description for test tools
+          |
+          +- unit.rb   <-- defines "test unit" (and its subtools)
+
+If, however, you find `greeting.txt` from a tool under `test`, it will still
+find the more general `.toys/.data/greeting.txt` file because there is no
+overriding file under `.toys/test/.data`.
+
+### The Context Directory
+
+The **context directory** for a tool is the directory containing the toplevel
+`.toys.rb` file or the `.toys` directory within which the tool is defined. It
+is sometimes useful for tools that expect to be run from a specific working
+directory.
+
+For example, suppose you have a Ruby project directory:
+
+    my-project/
+    |
+    +- .toys.rb  <-- project tools defined here
+    |
+    +- lib/
+    |
+    +- test/
+    |
+    etc...
+
+Now suppose you defined a tool that lists the tests:
+
+    tool "list-tests" do
+      def run
+        puts Dir.glob("test/**/*.rb").join("\n")
+      end
+    end
+
+This tool assumes it will be run from the main project directory (`my-project`
+in the above case). However, Toys lets you invoke tools even if you are in a
+subdirectory:
+
+    cd lib
+    toys list-tests  # Does not work
+
+Rake handles this by actually changing the current working directory to the
+directory containing the active Rakefile. Toys, however, does not change the
+working directory unless you tell it. You can make the `list-tests` tool work
+correctly by changing the directory to the context directory (which is the
+directory containing the `.toys.rb` file, i.e. the `my-project` directory.)
+
+    tool "list-tests" do
+      def run
+        Dir.chdir context_directory do
+          puts Dir.glob("test/**/*.rb").join("\n")
+        end
+      end
+    end
+
+Note the context directory is different from `__dir__`. It is not necessarily
+the directory containing the file being executed, but the directory containing
+the entire toys directory structure. So if your tool definition is inside a
+`.toys` directory, it will still work:
+
+    my-project/   <-- context_directory still points here
+    |
+    +- .toys/
+    |  |
+    |  +- list-tests.rb   <-- tool defined here
+    |
+    +- lib/
+    |
+    +- test/
+    |
+    etc...
+
+This behavior is particularly useful for build tools. Indeed, all the build
+tools described in the section on
+[Toys as a Rake Replacement](#Toys_as_a_Rake_Replacement) automatically move
+into the context directory when they execute.
+
+#### Changing the Context Directory
+
+It is even possible to modify the context directory, causing tools that use the
+context directory (such as the standard build tools) to run in a different
+directory. Here is an example:
+
+Suppose you have a repository with multiple gems, each in its own directory:
+
+    my-repo/
+    |
+    +- .toys.rb  <-- all project tools defined here
+    |
+    +- gem1/
+    |  |
+    |  +- lib/
+    |  |
+    |  +- test/
+    |
+    +- gem2/
+    |  |
+    |  +- lib/
+    |  |
+    |  +- test/
+    |
+    etc...
+
+Assuming all the gems use the same set of build tools, it is possible to define
+those tools once in a single `.toys.rb` file and have it run in a particular
+gem directory depending on your current location. For example, you can cd into
+`gem1` or even `gem1/lib` to have the tools run on `gem1`. Because the standard
+build tools execute within the context directory, you can accomplish this by
+setting the context directory to the gem directory corresponding to the current
+location. That is, if the working directory is `my-repo/gem1/lib`, set the
+context directory to `my-repo/gem1`. Here's what that could look like:
+
+    # .toys.rb content
+
+    require "pathname"
+    base_dir = Pathname.new context_directory
+    cur_dir = Pathname.new Dir.getwd
+
+    # The gem name is the first segment of the relative path from the context
+    # directory to the current directory.
+    relative_path = cur_dir.relative_path_from(base_dir).to_s
+    gem_name = relative_path.split("/").first
+
+    # Only proceed if we're truly in a subdirectory
+    if gem_name && gem_name != "." && gem_name != ".."
+
+      # Now set the context directory to the gem directory.
+      set_context_directory base_dir.join(gem_name).to_s
+
+      # Define the build tools. Each of these uses the custom context directory
+      # set above, and thus runs for the selected gem.
+      expand :minitest
+      expand :gem_build
+      # etc.
+    end
+
 ## Toys Administration Using the System Tools
 
 Toys comes with a few built-in tools, including some that let you administer
@@ -2265,8 +2402,8 @@ A similar effect can of course be obtained simply by `gem install toys`.
 
 ## Writing Your Own CLI Using Toys
 
-Toys is not primarily designed to help you write a custom command-line binary,
-but you can use it in that fashion. Toys is factored into two gems:
+Although Toys is not primarily designed to help you write a custom command-line
+binary, you can use it in that way. Toys is factored into two gems:
 **toys-core**, which includes all the underlying machinery for creating
 command-line binaries, and **toys**, which is really just a wrapper that
 provides the `toys` binary itself and its built-in commands and behavior. To
@@ -2284,7 +2421,8 @@ line binary. For example:
     Toys-Core lets you provide an alternate default run method for your own
     command line binary.
 *   Toys itself provides several built-in tools, such as `do`, and `system`.
-    Toys-Core lets your own command line binary define its own built-in tools.
+    Toys-Core lets you write your own command line binary with its own built-in
+    tools.
 *   Toys itself implements a particular search path for user-provided Toys
     files, and looks for specific file and directory names such as `.toys.rb`.
     Toys-Core lets you change the search path, the file/directory names, or

data/lib/toys/standard_cli.rb

@@ -186,6 +186,7 @@ module Toys
           list_flags: true,
           recursive_flags: true,
           search_flags: true,
+          show_all_subtools_flags: true,
           default_recursive: true,
           allow_root_args: true,
           show_source_path: true,

data/lib/toys/templates/clean.rb

@@ -66,17 +66,17 @@ module Toys
           include :fileutils
 
           to_run do
-            files = []
-            patterns = Array(template.paths)
-            patterns.each do |pattern|
-              files.concat(::Dir.glob(pattern))
-            end
-            files.uniq!
-
-            files.each do |file|
-              if ::File.exist?(file)
-                rm_rf(file)
-                puts "Cleaned: #{file}"
+            ::Dir.chdir(context_directory || ::Dir.getwd) do
+              files = []
+              patterns = Array(template.paths)
+              patterns.each do |pattern|
+                files.concat(::Dir.glob(pattern))
+              end
+              files.uniq.each do |file|
+                if ::File.exist?(file)
+                  rm_rf(file)
+                  puts "Cleaned: #{file}"
+                end
               end
             end
           end

data/lib/toys/templates/gem_build.rb

@@ -77,7 +77,9 @@ module Toys
 
       to_expand do |template|
         unless template.gem_name
-          candidates = ::Dir.glob("*.gemspec")
+          candidates = ::Dir.chdir(context_directory || ::Dir.getwd) do
+            ::Dir.glob("*.gemspec")
+          end
           if candidates.empty?
             raise ToolDefinitionError, "Could not find a gemspec"
           end
@@ -90,31 +92,32 @@ module Toys
 
           flag :yes, "-y", "--yes", desc: "Do not ask for interactive confirmation"
 
-          include :exec
+          include :exec, exit_on_nonzero_status: true
           include :fileutils
           include :terminal
 
           to_run do
             require "rubygems/package"
-            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
-              exit(1) unless yes || confirm("Release #{gemfile}?", default: true)
-              exec(["gem", "push", "pkg/#{gemfile}"])
-              if template.tag
-                exec(["git", "tag", "v#{version}"])
-                if template.push_tag
-                  template.push_tag = "origin" if template.push_tag == true
-                  exec(["git", "push", template.push_tag, "v#{version}"])
+            ::Dir.chdir(context_directory || ::Dir.getwd) do
+              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
+                exit(1) unless yes || confirm("Release #{gemfile}?", default: true)
+                exec(["gem", "push", "pkg/#{gemfile}"])
+                if template.tag
+                  exec(["git", "tag", "v#{version}"])
+                  if template.push_tag
+                    template.push_tag = "origin" if template.push_tag == true
+                    exec(["git", "push", template.push_tag, "v#{version}"])
+                  end
                 end
               end
             end

data/lib/toys/templates/minitest.rb

@@ -109,28 +109,30 @@ module Toys
           to_run do
             gem "minitest", *Array(template.gem_version)
 
-            ruby_args = []
-            unless template.libs.empty?
-              lib_path = template.libs.join(::File::PATH_SEPARATOR)
-              ruby_args << "-I#{lib_path}"
-            end
-            ruby_args << "-w" if warnings
+            ::Dir.chdir(context_directory || ::Dir.getwd) 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 warnings
 
-            if tests.empty?
-              Array(template.files).each do |pattern|
-                tests.concat(::Dir.glob(pattern))
+              if tests.empty?
+                Array(template.files).each do |pattern|
+                  tests.concat(::Dir.glob(pattern))
+                end
+                tests.uniq!
               end
-              tests.uniq!
-            end
 
-            result = ruby(ruby_args, in: :controller) do |controller|
-              tests.each do |file|
-                controller.in.puts("load '#{file}'")
+              result = ruby(ruby_args, in: :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
-            if result.error?
-              logger.error("Minitest failed!")
-              exit(result.exit_code)
             end
           end
         end

data/lib/toys/templates/rake.rb

@@ -50,8 +50,8 @@ module Toys
       #     the rake gem. Defaults to nil, indicating no version requirement.
       # @param [String] rakefile_path Path to the Rakefile. Defaults to
       #     {DEFAULT_RAKEFILE_PATH}.
-      # @param [Boolean] only_described Tools are generated only for rake tasks
-      #     with descriptions. Default is false.
+      # @param [Boolean] only_described If true, tools are generated only for
+      #     rake tasks with descriptions. Default is false.
       # @param [Boolean] use_flags Generated tools use flags instead of
       #     positional arguments to pass arguments to rake tasks. Default is
       #     false.
@@ -74,16 +74,17 @@ module Toys
       to_expand do |template|
         gem "rake", *Array(template.gem_version)
         require "rake"
-        ::Rake::TaskManager.record_task_metadata = true
-        rake = ::Rake::Application.new
-        ::Rake.application = rake
-        ::Rake.load_rakefile(template.rakefile_path)
+        rakefile_path = Templates::Rake.find_rakefile(template.rakefile_path, context_directory)
+        raise "Cannot find #{template.rakefile_path}" unless rakefile_path
+        context_dir = ::File.dirname(rakefile_path)
+        rake = Templates::Rake.prepare_rake(rakefile_path, context_dir)
         rake.tasks.each do |task|
           comments = task.full_comment.to_s.split("\n")
           next if comments.empty? && template.only_described
           tool(task.name.split(":"), if_defined: :ignore) do
             unless comments.empty?
               desc(comments.first)
+              comments << "" << "Defined as a Rake task in #{rakefile_path}"
               long_desc(*comments)
             end
             if template.use_flags
@@ -93,14 +94,18 @@ module Toys
               end
               to_run do
                 args = task.arg_names.map { |arg| self[arg] }
-                task.invoke(*args)
+                ::Dir.chdir(context_dir) do
+                  task.invoke(*args)
+                end
               end
             else
               task.arg_names.each do |arg|
                 optional_arg(arg)
               end
               to_run do
-                task.invoke(*args)
+                ::Dir.chdir(context_dir) do
+                  task.invoke(*args)
+                end
               end
             end
           end
@@ -118,6 +123,34 @@ module Toys
         end
         specs
       end
+
+      ## @private
+      def self.find_rakefile(path, context_dir)
+        if path == ::File.absolute_path(path)
+          return ::File.file?(path) && ::File.readable?(path) ? path : nil
+        end
+        dir = ::Dir.getwd
+        50.times do
+          rakefile_path = ::File.expand_path(path, dir)
+          return rakefile_path if ::File.file?(rakefile_path) && ::File.readable?(rakefile_path)
+          break if dir == context_dir
+          next_dir = ::File.dirname(dir)
+          break if dir == next_dir
+          dir = next_dir
+        end
+        nil
+      end
+
+      ## @private
+      def self.prepare_rake(rakefile_path, context_dir)
+        ::Rake::TaskManager.record_task_metadata = true
+        rake = ::Rake::Application.new
+        ::Rake.application = rake
+        ::Dir.chdir(context_dir) do
+          ::Rake.load_rakefile(rakefile_path)
+        end
+        rake
+      end
     end
   end
 end

data/lib/toys/templates/rdoc.rb

@@ -122,23 +122,25 @@ module Toys
             gem "rdoc", *Array(template.gem_version)
             require "rdoc"
 
-            files = []
-            patterns = Array(template.files)
-            patterns = ["lib/**/*.rb"] if patterns.empty?
-            patterns.each do |pattern|
-              files.concat(::Dir.glob(pattern))
-            end
-            files.uniq!
+            ::Dir.chdir(context_directory || ::Dir.getwd) do
+              files = []
+              patterns = Array(template.files)
+              patterns = ["lib/**/*.rb"] if patterns.empty?
+              patterns.each do |pattern|
+                files.concat(::Dir.glob(pattern))
+              end
+              files.uniq!
 
-            args = template.options.dup
-            args << "-o" << template.output_dir
-            args << "--markup" << template.markup if template.markup
-            args << "--main" << template.main if template.main
-            args << "--title" << template.title if template.title
-            args << "-T" << template.template if template.template
-            args << "-f" << template.generator if template.generator
+              args = template.options.dup
+              args << "-o" << template.output_dir
+              args << "--markup" << template.markup if template.markup
+              args << "--main" << template.main if template.main
+              args << "--title" << template.title if template.title
+              args << "-T" << template.template if template.template
+              args << "-f" << template.generator if template.generator
 
-            exec_proc(proc { RDoc::RDoc.new.document(args + files) })
+              exec_proc(proc { RDoc::RDoc.new.document(args + files) })
+            end
           end
         end
       end

data/lib/toys/templates/rubocop.rb

@@ -86,12 +86,14 @@ module Toys
             gem "rubocop", *Array(template.gem_version)
             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
+            ::Dir.chdir(context_directory || ::Dir.getwd) do
+              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

@@ -169,55 +169,57 @@ module Toys
             gem "yard", *Array(template.gem_version)
             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!
+            ::Dir.chdir(context_directory || ::Dir.getwd) do
+              files = []
+              patterns = Array(template.files)
+              patterns = ["lib/**/*.rb"] if patterns.empty?
+              patterns.each do |pattern|
+                files.concat(::Dir.glob(pattern))
+              end
+              files.uniq!
 
-            run_options = template.options.dup
-            stats_options = template.stats_options.dup
-            stats_options << "--list-undoc" if template.fail_on_undocumented_objects
-            run_options << "--fail-on-warning" if template.fail_on_warning
-            run_options << "--no-output" unless generate_output
-            run_options << "--output-dir" << template.output_dir if template.output_dir
-            run_options << "--no-public" unless template.show_public
-            run_options << "--protected" if template.show_protected
-            run_options << "--private" if template.show_private
-            run_options << "--no-private" if template.hide_private_tag
-            run_options << "-r" << template.readme if template.readme
-            run_options << "-m" << template.markup if template.markup
-            run_options << "-t" << template.template if template.template
-            run_options << "-p" << template.template_path if template.template_path
-            run_options << "-f" << template.format if template.format
-            unless stats_options.empty?
-              run_options << "--no-stats"
-              stats_options << "--use-cache"
-            end
-            run_options.concat(files)
+              run_options = template.options.dup
+              stats_options = template.stats_options.dup
+              stats_options << "--list-undoc" if template.fail_on_undocumented_objects
+              run_options << "--fail-on-warning" if template.fail_on_warning
+              run_options << "--no-output" unless generate_output
+              run_options << "--output-dir" << template.output_dir if template.output_dir
+              run_options << "--no-public" unless template.show_public
+              run_options << "--protected" if template.show_protected
+              run_options << "--private" if template.show_private
+              run_options << "--no-private" if template.hide_private_tag
+              run_options << "-r" << template.readme if template.readme
+              run_options << "-m" << template.markup if template.markup
+              run_options << "-t" << template.template if template.template
+              run_options << "-p" << template.template_path if template.template_path
+              run_options << "-f" << template.format if template.format
+              unless stats_options.empty?
+                run_options << "--no-stats"
+                stats_options << "--use-cache"
+              end
+              run_options.concat(files)
 
-            result = exec_proc(proc { ::YARD::CLI::Yardoc.run(*run_options) })
-            if result.error?
-              puts("Yardoc encountered errors", :red, :bold) unless verbosity.negative?
-              exit(1)
-            end
-            unless stats_options.empty?
-              result = exec_proc(proc { ::YARD::CLI::Stats.run(*stats_options) }, out: :capture)
-              puts result.captured_out
+              result = exec_proc(proc { ::YARD::CLI::Yardoc.run(*run_options) })
               if result.error?
                 puts("Yardoc encountered errors", :red, :bold) unless verbosity.negative?
                 exit(1)
               end
-              exit_on_nonzero_status(result)
-              if template.fail_on_undocumented_objects
-                if result.captured_out =~ /Undocumented\sObjects:/
-                  unless verbosity.negative?
-                    puts("Yardoc encountered undocumented objects", :red, :bold)
-                  end
+              unless stats_options.empty?
+                result = exec_proc(proc { ::YARD::CLI::Stats.run(*stats_options) }, out: :capture)
+                puts result.captured_out
+                if result.error?
+                  puts("Yardoc encountered errors", :red, :bold) unless verbosity.negative?
                   exit(1)
                 end
+                exit_on_nonzero_status(result)
+                if template.fail_on_undocumented_objects
+                  if result.captured_out =~ /Undocumented\sObjects:/
+                    unless verbosity.negative?
+                      puts("Yardoc encountered undocumented objects", :red, :bold)
+                    end
+                    exit(1)
+                  end
+                end
               end
             end
           end

data/lib/toys/version.rb

@@ -34,5 +34,5 @@ module Toys
   # Current version of the Toys command line binary
   # @return [String]
   #
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: toys
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Daniel Azuma
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-08 00:00:00.000000000 Z
+date: 2018-10-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: toys-core
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.6.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.6.0
 - !ruby/object:Gem::Dependency
   name: highline
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
 - !ruby/object:Gem::Dependency
   name: redcarpet
   requirement: !ruby/object:Gem::Requirement
@@ -100,14 +114,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.59.1
+        version: 0.59.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.59.1
+        version: 0.59.2
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement