methadone 1.0.0.rc5 → 1.0.0.rc6

data/tutorial/3_ui.md

@@ -1,336 +0,0 @@
-# Tutorial: UI
-
-We're taking an [outside-in][outsidein] approach to our app.  This means that we start with the user interface, and work our way
-down to make that interface a reality.  I highly recommend this approach, since it forces you to focus on the user of your app
-first.   Doing this will result in an app that's easier to use, and thus easier for you to maintain and enhance over time.
-
-Before we dive into our Cucumber features, let's take a moment to think about how our app might work.  Essentially, we want it to
-clone a git repository somewhere on disk, and then symlink all of those files and directories in the top level of that repo into
-our home directory.  If we did this in `bash` on the command line, it might be something like this:
-
-```sh
-$ cd ~
-$ git clone git@github.com:davetron5000/dotfiles.git
-$ for file in `ls -a dotfiles`; do
-> ln -s dotfiles/$file .
-> done
-```
-
-It's worth understanding why we don't just make this entire thing a `bash` script.  Our app is going to need more smarts than the
-above code: for example, it will need to be able to check if the repo is cloned already, and update it instead of cloning.  It
-will need good error handling so the user knows if they did something wrong.  It might need more complex logic as we use the app
-over time.  Implementing these in `bash` is painful.  `bash` is not a very powerful language, and we'll quickly hit a wall.
-Although `bash` is "close to the metal", we'll see that Ruby + Methadone can provide a *very* similar programming experience.
-
-Now, let's think about how our app will work.  We can summarize our app's interface as having two main features at this point:
-
-* It should accept a required argument that is the URL of the repo to clone
-* It should otherwise be a well-behaved and polished command-line app:
-  * It should have online help.
-  * Getting help is not an error and the app should exit zero when you get help.
-  * There should be a usage statement for the app's invocation syntax.
-  * The app should document what it does.
-  * The app should indicate what options and arguments it takes.
-
-Aruba and Methadone provide all the steps we need to test for these aspects of our app's user interface.  Here's the feature
-we'll use to test this.  We can replace the contents of `features/fullstop.feature` with this:
-
-```cucumber
-Feature: Checkout dotfiles
-  In order to get my dotfiles onto a new computer
-  I want a one-command way to keep them up to date
-  So I don't have to do it myself
-
-  Scenario: Basic UI
-    When I get help for "fullstop"
-    Then the exit status should be 0
-    And the banner should be present
-    And there should be a one line summary of what the app does
-    And the banner should include the version
-    And the banner should document that this app takes options
-    And the banner should document that this app's arguments are:
-      |repo_url|which is required|
-```
-
-This scenario describes getting help for our app and the basic user interface that we need.  This is how we "test-drive" the
-development of the user interface portion of our app.  Let's run the scenario and see what happens.
-
-```sh
-$ rake features
-Feature: Checkout dotfiles
-  In order to get my dotfiles onto a new computer
-  I want a one-command way to keep them up to date
-  So I don't have to do it myself
-
-  Scenario: Basic UI
-    When I get help for "fullstop"
-    Then the exit status should be 0
-    And the banner should be present
-    And there should be a one line summary of what the app does
-      expected "v0.0.1" to match /^\w\w+\s+\w\w+/ (RSpec::Expectations::ExpectationNotMetError)
-      features/fullstop.feature:10:in `And there should be a one line summary of what the app does'
-    And the banner should include the version
-    And the banner should document that this app takes options
-    And the banner should document that this app's arguments are:
-      | repo_url | which is required |
-
-Failing Scenarios:
-cucumber features/fullstop.feature:6
-
-1 scenario (1 failed)
-7 steps (1 failed, 3 skipped, 3 passed)
-0m0.126s
-rake aborted!
-Cucumber failed
-
-Tasks: TOP => features
-(See full trace by running task with --trace)
-```
-
-We have a failing test!  Note that cucumber knows about all of these steps; between Aruba and Metahdone, they are all already defined.  We'll see some custom steps later, that are specific to our app, but for now, we haven't had to write any testing code, which is great!
-  
-You'll also notice that some steps are already passing, despite the fact that we've done no coding.  Also notice that cucumber didn't complain about unknown steps.  Methadone provides almost all of these cucumber steps for us.  The rest are provided by Aruba.  Since Methadone generated an executable for us when we ran the `methadone` command, it already provides the ability to get help, and exits with the correct exit status.
-
-Let's fix things one step at a time, so we can see exactly what we need to do.  The current scenario is failing because our app doesn't have a one line summary.  This summary is important so that we can remember what the app does later on (despite how clever our name is, it's likely we'll forget a few months from now and the description will jog our memory).
-
-Let's have a look at our executable.  A Methadone app is made up of four parts: the setup where we require necessary libraries, a "main" block containing the primary logic of our code, a block of code that declares the app's UI, and a call to `go!`, which runs our app.
-
-```ruby
-#!/usr/bin/env ruby
-
-# setup
-require 'optparse'
-require 'methadone'
-require 'fullstop'
-
-class App
-  include Methadone::Main
-  include Methadone::CLILogging
-
-# the main block
-  main do
-
-  end
-
-# declare UI
-  version Fullstop::VERSION
-
-  use_log_level_option
-
-# call go!
-  go!
-end
-```
-
-There's not much magic going on here; you could think of this code as being roughly equivalent to:
-
-```ruby
-def main
-end
-
-opts = OptionParser.new
-opts.banner = "usage: $0 [options]\n\nversion: #{Fullstop::VERSION}"
-opts.parse!
-
-main
-```
-
-We'll see later that Methadone does a lot more than this, but this should help you understand the control flow.  We now need to
-add a one-line description for our app.
-
-In a vanilla Ruby application, we'd use the `banner` method of an `OptionParser` to add this description (much as we do with the
-version in the above, non-Methadone code).  Methadone actually manages an
-`OptionParser` instance that we can use, available via the `opts` method.  We could call `banner` on that to set our description, but Methadone provides a convenience method to do it for us: `description`.
-
-`description` takes a single argument: a one-line description of our app.  Methadone will then include this in the online help 
-output of our app when the user uses `-h` or `--help`.  We'll add a call to it in the "declare UI" portion of our code:
-
-```ruby
-#!/usr/bin/env ruby
-
-require 'optparse'
-require 'methadone'
-require 'fullstop'
-
-class App
-  include Methadone::Main
-  include Methadone::CLILogging
-
-  main do 
-  end
-
-  version Fullstop::VERSION
-
-  # vvv
-  description 'Manages dotfiles from a git repo'
-  # ^^^
-
-  use_log_level_option
-
-  go!
-end
-```
-
-Now, let's run our scenario again:
-
-```sh
-$ rake features
-Feature: Checkout dotfiles
-  In order to get my dotfiles onto a new computer
-  I want a one-command way to keep them up to date
-  So I don't have to do it myself
-
-  Scenario: Basic UI
-    When I get help for "fullstop"
-    Then the exit status should be 0
-    And the banner should be present
-    And there should be a one line summary of what the app does
-    And the banner should include the version
-    And the banner should document that this app takes options
-    And the banner should document that this app's arguments are:
-      | repo_url | which is required |
-      expected "Usage: fullstop [options]\n\nManages dotfiles from a git repo\n\nv0.0.1\n\nOptions:\n        --version                    Show help/version info\n        --log-level LEVEL            Set the logging level (debug|info|warn|error|fatal)\n                                     (Default: info)\n" to include "repo_url"
-      Diff:
-      @@ -1,2 +1,11 @@
-      -["repo_url"]
-      +Usage: fullstop [options]
-      +
-      +Manages dotfiles from a git repo
-      +
-      +v0.0.1
-      +
-      +Options:
-      +        --version                    Show help/version info
-      +        --log-level LEVEL            Set the logging level (debug|info|warn|error|fatal)
-      +                                     (Default: info)
-       (RSpec::Expectations::ExpectationNotMetError)
-      features/fullstop.feature:13:in `And the banner should document that this app's arguments are:'
-
-Failing Scenarios:
-cucumber features/fullstop.feature:6
-
-1 scenario (1 failed)
-7 steps (1 failed, 6 passed)
-0m0.132s
-rake aborted!
-Cucumber failed
-
-Tasks: TOP => features
-(See full trace by running task with --trace)
-```
-
-We got farther this time.  Our step for checking that we have a one-line summary is passing.  Further, the next two following steps are also passing, despite the fact that we did nothing to explicitly make them pass.  Like the preceding steps ("Then the exit status should be 0" and "And the banner should be present"), the two steps following the one we just fixed pass because Methadone has bootstrapped our app in a way that they are already passing.  
-
-The call to Methadone's `version` method ensures that the version of our app appears in the online help.  The other step, "And the banner should document that this app takes options" passes because we are allowing Methadone to manage the banner.  Methadone knows that our app takes options (namely `--version`), and inserts the string `"[options]"` into the usage statement.
-
-The last step in our scenario is still failing, so let's fix that to finish up our user interface.  What Methadone is looking for is for the string `repo_url` (the name of our only, required, argument) to be in the usage string, in other words, Methadone is expecting to see this:
-
-```
-Usage: fullstop [option] repo_url
-```
-
-Right now, our app's usage string looks like this:
-
-```
-Usage: fullstop [option]
-```
-
-Again, if we were using `OptionParser`, we would need to modify the argument given to `banner` to include this string.  Methadone provides a method, `arg` that will do this automatically for us.  We'll add it right after the call to `description` in the "declare UI" section of our app:
-
-```ruby
-#!/usr/bin/env ruby
-
-require 'optparse'
-require 'methadone'
-require 'fullstop'
-
-class App
-  include Methadone::Main
-  include Methadone::CLILogging
-
-  main do 
-  end
-
-  version Fullstop::VERSION
-
-  description 'Manages dotfiles from a git repo'
-
-  # vvv
-  arg :repo_url, "URL to the git repository containing your dotfiles"
-  # ^^^
-
-  use_log_level_option
-
-  go!
-end
-```
-
-Now, when we run our features again, we can see that everything passes:
-
-```sh
-$ rake features
-Feature: Checkout dotfiles
-  In order to get my dotfiles onto a new computer
-  I want a one-command way to keep them up to date
-  So I don't have to do it myself
-
-  Scenario: Basic UI
-    When I get help for "fullstop"
-    Then the exit status should be 0
-    And the banner should be present
-    And there should be a one line summary of what the app does
-    And the banner should include the version
-    And the banner should document that this app takes options
-    And the banner should document that this app's arguments are:
-      | repo_url | which is required |
-
-1 scenario (1 passed)
-7 steps (7 passed)
-0m0.129s
-```
-
-Nice!  If our UI should ever change, we'll notice the regression, and we also have an easy way to use TDD to enhance our
-application's UI in the future.  Let's take a look at it ourselves to see what it's like:
-
-```sh
-$ bundle exec bin/fullstop --help
-Usage: fullstop [options] repo_url
-
-Manages dotfiles from a git repo
-
-v0.0.1
-
-Options:
-  --version          Show help/version info
-  --log-level LEVEL  Set the logging level (debug|info|warn|error|fatal)
-                     (Default: info)
-```
-
-Not to bad for having written two lines of code!  We can also see that `fullstop` will error out if we omit our required
-argument, `repo_url`:
-
-```sh
-$ bundle exec bin/fullstop 
-parse error: 'repo_url' is required
-
-Usage: fullstop [options] repo_url
-
-Manages dotfiles from a git repo
-
-v0.0.1
-
-Options:
-  --version          Show help/version info
-  --log-level LEVEL  Set the logging level (debug|info|warn|error|fatal)
-                     (Default: info)
-$ echo $?
-64
-```
-
-We see an error message, and exited nonzero (64 is a somewhat standard exit code for errors in command-line invocation).
-
-It's also worth pointing out that Methadone is taking a very light touch.  We could completely re-implement `bin/fullstop` using `OptionParser` and still have our scenario pass.  As we'll see, few of Methadone's parts really rely on each other, and many can be used piecemeal, if that's what you want.
-
-Now that we have our UI, the next order of business is to actually implement something.
-
-[outsidein]: http://en.wikipedia.org/wiki/Outside%E2%80%93in_software_development

data/tutorial/4_happy_path.md

@@ -1,405 +0,0 @@
-# The Happy Path
-
-We just used TDD and Methadone to create the basics of the user interface for our application.  Now, we need to actually
-implement it!  Let's focus on the "happy path", i.e. the way the app will work if nothing goes wrong.  Since we're doing
-everything test-first, let's write a new scenario for how the app should work.
-
-We'll append this to `features/fullstop.feature`:
-
-```cucumber
-  Scenario: Happy Path
-    Given a git repo with some dotfiles at "/tmp/dotfiles.git"
-    When I successfully run "fullstop file:///tmp/dotfiles.git"
-    Then the dotfiles should be checked out in the directory "~/dotfiles"
-    And the files in "~/dotfiles" should be symlinked in my home directory
-```
-
-Basically, what we're doing is assuming a git repository in `/tmp/dotfiles.git`, which we then expect `fullstop` to clone, followed by symlinking the contents to our home directory.  There is, however, a slight problem.
-
-Suppose we make this scenario pass.  This means that *every* time we run this scenario, our dotfiles in our *actual* home directory will be blown away.  Yikes!  We don't want that; we want our test as isolated as it can be.  What we'd like is to work in a home directory that, from the perspective of our cucumber tests, is not our home directory and completely under the conrol of the tests but, from the perspective of the `fullstop` app, is the user's bona-fide home directory.
-
-We can easily fake this by changing the environment variable `$HOME` just for the tests.  As long as `bin/fullstop` uses this environment variable to access the user's home directory (which is perfectly valid), everything will be OK.
-
-To do that, we need to modify some of cucumber's plumbing.  Methadone won't do this for you, since it's not applicable to every situation or app.  Open up `features/support/env.rb`.  It should look like this:
-
-```ruby
-require 'aruba/cucumber'
-require 'methadone/cucumber'
-
-ENV['PATH'] = "#{File.expand_path(File.dirname(__FILE__) + '/../../bin')}#{File::PATH_SEPARATOR}#{ENV['PATH']}"
-LIB_DIR = File.join(File.expand_path(File.dirname(__FILE__)),'..','..','lib')
-
-Before do
-  # Using "announce" causes massive warnings on 1.9.2
-  @puts = true
-  @original_rubylib = ENV['RUBYLIB']
-  ENV['RUBYLIB'] = LIB_DIR + File::PATH_SEPARATOR + ENV['RUBYLIB'].to_s
-end
-
-After do
-  ENV['RUBYLIB'] = @original_rubylib
-end
-```
-
-There's a lot in there already to make our tests work and, fortunately, it makes our job of faking the home directory a bit easier.  We need to save the original location in `Before`, and then change it there, setting it back to normal in `After`, just as we have done with the `$RUBYLIB` environment variable (incidentally, this is how Aruba can run our app without using `bundle exec`).
-
-```ruby
-require 'aruba/cucumber'
-require 'methadone/cucumber'
-
-ENV['PATH'] = "#{File.expand_path(File.dirname(__FILE__) + '/../../bin')}#{File::PATH_SEPARATOR}#{ENV['PATH']}"
-LIB_DIR = File.join(File.expand_path(File.dirname(__FILE__)),'..','..','lib')
-
-Before do
-  # Using "announce" causes massive warnings on 1.9.2
-  @puts = true
-  @original_rubylib = ENV['RUBYLIB']
-  ENV['RUBYLIB'] = LIB_DIR + File::PATH_SEPARATOR + ENV['RUBYLIB'].to_s
-  # vvv
-  @original_home = ENV['HOME']
-  ENV['HOME'] = "/tmp/fakehome"
-  FileUtils.rm_rf "/tmp/fakehome"
-  FileUtils.mkdir "/tmp/fakehome"
-  # ^^^
-end
-
-After do
-  ENV['RUBYLIB'] = @original_rubylib
-  # vvv
-  ENV['HOME'] = @original_home
-  # ^^^
-end
-```
-
-As you can see, we also delete the directory and re-create it so that anything leftover from a previous test won't cause false
-positives or negatives in our tests.
-
-*Now*, let's run our scenario and see where we're at:
-
-
-```sh
-$ rake features
-Feature: Checkout dotfiles
-  In order to get my dotfiles onto a new computer
-  I want a one-command way to keep them up to date
-  So I don't have to do it myself
-
-  Scenario: Basic UI
-    When I get help for "fullstop"
-    Then the exit status should be 0
-    And the banner should be present
-    And there should be a one line summary of what the app does
-    And the banner should include the version
-    And the banner should document that this app takes options
-    And the banner should document that this app's arguments are:
-      | repo_url | which is required |
-
-  Scenario: Happy Path
-    Given a git repo with some dotfiles at "/tmp/dotfiles.git"
-    When I successfully run "fullstop file:///tmp/dotfiles.git"
-    Then the dotfiles should be checked out in the directory "~/dotfiles"
-    And the files in "~/dotfiles" should be symlinked in my home directory
-
-2 scenarios (1 undefined, 1 passed)
-11 steps (1 skipped, 3 undefined, 7 passed)
-0m0.152s
-
-You can implement step definitions for undefined steps with these snippets:
-
-Given /^a git repo with some dotfiles at "([^"]*)"$/ do |arg1|
-  pending # express the regexp above with the code you wish you had
-end
-
-Then /^the dotfiles should be checked out in the directory "([^"]*)"$/ do |arg1|
-  pending # express the regexp above with the code you wish you had
-end
-
-Then /^the files in "([^"]*)" should be symlinked in my home directory$/ do |arg1|
-  pending # express the regexp above with the code you wish you had
-end
-```
-
-As you can see there are three steps that cucumber doesn't know how to execute.  It provides boilerplate for doing so, so let's do that next.  We're going to move a bit faster here, since the specifics of implementing cucumber steps is orthogonal to Methadone, and we don't want to stray too far from our goal of learning Methadone.  If you'd like to explore this in more detail, check out the testing chapter of [my book][clibook].
-
-[clibook]: http://www.awesomecommandlineapps.com
-
-Here's the code to implement these steps, which I've put in `features/step_definitions/fullstop_steps.rb`:
-
-```ruby
-include FileUtils
-
-FILES = %w(.vimrc .bashrc .exrc)
-
-Given /^a git repo with some dotfiles at "([^"]*)"$/ do |repo_dir|
-  @repo_dir = repo_dir
-  base_dir = File.dirname(repo_dir)
-  dir = File.basename(repo_dir)
-  Dir.chdir base_dir do
-    rm_rf dir
-    mkdir dir
-  end
-  Dir.chdir repo_dir do
-    FILES.each { |_| touch _ }
-    sh "git init ."
-    sh "git add #{FILES.join(' ')}"
-    sh "git commit -a -m 'initial commit'"
-  end
-end
-
-Then /^the dotfiles should be checked out in the directory "([^"]*)"$/ do |dotfiles_dir|
-  # Expand ~ to ENV["HOME"]
-  base_dir = File.dirname(dir)
-  base_dir = ENV['HOME'] if base_dir == "~"
-  dotfiles_dir = File.join(base_dir,File.basename(dotfiles_dir))
-
-  File.exist?(dotfiles_dir).should == true
-  Dir.chdir dotfiles_dir do
-    FILES.each do |file|
-      File.exist?(file).should == true
-    end
-  end
-end
-
-Then /^the files in "([^"]*)" should be symlinked in my home directory$/ do |dotfiles_dir|
-  Dir.chdir(ENV['HOME']) do
-    FILES.each do |file|
-      File.lstat(file).should be_symlink
-    end
-  end
-end
-```
-
-In short, we set up a fake git repo in our first step definition, using the `FILES` constant so all steps know which files to expect. In our second step definition, we make sure to expand the "~" into `ENV['HOME']` before checking for the cloned repo.  In the last step we check that the files in `ENV['HOME']` are symlinks (being sure to use `lstat` instead of `stat`, as `stat` follows symlinks and will report the files as normal files). 
-
-You won't be familiar with the method `sh` that we're using to call `git`.  This is provided by Methadone and we'll explore it in more detail later.  For now, it functions similarly to `system`.
-
-We should now have a failing test:
-
-```sh
-$ rake features
-Feature: Checkout dotfiles
-  In order to get my dotfiles onto a new computer
-  I want a one-command way to keep them up to date
-  So I don't have to do it myself
-
-  Scenario: Basic UI
-    When I get help for "fullstop"
-    Then the exit status should be 0
-    And the banner should be present
-    And there should be a one line summary of what the app does
-    And the banner should include the version
-    And the banner should document that this app takes options
-    And the banner should document that this app's arguments are:
-      | repo_url | which is required |
-
-  Scenario: Happy Path
-    Given a git repo with some dotfiles at "/tmp/dotfiles.git"
-    When I successfully run `fullstop file:///tmp/dotfiles.git`
-    Then the dotfiles should be checked out in the directory "~/dotfiles"
-      expected: true
-           got: false (using ==) (RSpec::Expectations::ExpectationNotMetError)
-      ./features/step_definitions/fullstop_steps.rb:29:in `/^the dotfiles should be checked out in the directory "([^"]*)"$/'
-      features/fullstop.feature:19:in `Then the dotfiles should be checked out in the directory "~/dotfiles"'
-    And the files in "~/dotfiles" should be symlinked in my home directory
-
-Failing Scenarios:
-cucumber features/fullstop.feature:16
-
-2 scenarios (1 failed, 1 passed)
-11 steps (1 failed, 1 skipped, 9 passed)
-0m0.291s
-rake aborted!
-Cucumber failed
-
-Tasks: TOP => features
-(See full trace by running task with --trace)
-```
-
-This is the step that's failing:
-
-```cucumber
-Then the dotfiles should be checked out in the directory "~/dotfiles"
-```
-
-It's a bit hard to understand *why* it's failing, but the error message and line number helps.  This is the line that's failing:
-
-```ruby
-File.exist?(dotfiles_dir).should == true
-```
-
-Since `dotfiles_dir` is `~/dotfiles` (or, more specifically, `File.join(ENV['HOME'],'dotfiles')`), and it doesn't exist, since we haven't written any code that might cause it to exist, the test fails.  Although it's outside the scope of this tutorial, you should consider writing some custom RSpec matchers for your assertions, since they can allow you to produce better failure messages.
-Now that we have a failing test, we can start writing some code.  This is the first bit of actual logic we'll write, and we need to revisit the canonical structure of a Methadone app to know where to put it.
-Recall that the second part of our app is the "main" block, and it's intended to hold the primary logic of your application.  Methadone provides the method `main`, which lives in `Methadone::Main`, and takes a block.  This block is where you put your logic.  Think of it like the `main` method of a C program.
-Now that we know where to put our code, we need to know *what* code we need to add.  To make this step pass, we need to clone the repo given to us on the command-line.  To do that we need:
-* The ability to execute `git`
-* The ability to change to the user's home directory
-* Access to the repo's URL from the command line
-Although we can use `system` or the backtick operator to call `git`, we're going to use `sh`, which is available by mixing in `Methadone::SH`.  We'll go into the advantages of why we might want to do that later in the tutorial, but for now, think of it as saving us a few characters over `system`.
-
-We can change to the user's home directory using the `chdir` method of `Dir`, which is built-in to Ruby.  To get the value of the URL the user provided on the command-line, we could certainly take it from `ARGV`, but Methadone allows you `main` block to take arguments, which it will populate with the contents of `ARGV`.  All we need to do is change our `main` block to accept `repo_url` as an argument.
-
-Here's the code:
-
-```ruby
-#!/usr/bin/env ruby
-
-require 'optparse'
-require 'methadone'
-require 'fullstop'
-
-class App
-  include Methadone::Main
-  include Methadone::CLILogging
-  # vvv
-  include Methadone::SH
-  # ^^^
-
-  #        vvv
-  main do |repo_url|
-    #      ^^^
-    
-    # vvv
-    Dir.chdir ENV['HOME'] do
-      sh "git clone #{repo_url}"
-    end
-    # ^^^
-  end
-
-  version Fullstop::VERSION
-
-  description 'Manages dotfiles from a git repo'
-
-  arg :repo_url, "URL to the git repository containing your dotfiles"
-
-  use_log_level_option
-
-  go!
-end
-```
-
-Note that all we're doing here is getting the currently-failing step to pass.  We *aren't* implementing the entire app.  We want to write only the code we need to, and we go one step at a time.  Let's re-run our scenario and see if we get farther:
-
-```sh
-rake features
-Feature: Checkout dotfiles
-  In order to get my dotfiles onto a new computer
-  I want a one-command way to keep them up to date
-  So I don't have to do it myself
-
-  Scenario: Basic UI
-    When I get help for "fullstop"
-    Then the exit status should be 0
-    And the banner should be present
-    And there should be a one line summary of what the app does
-    And the banner should include the version
-    And the banner should document that this app takes options
-    And the banner should document that this app's arguments are:
-      | repo_url | which is required |
-
-  Scenario: Happy Path
-    Given a git repo with some dotfiles at "/tmp/dotfiles.git"
-    When I successfully run `fullstop file:///tmp/dotfiles.git`
-    Then the dotfiles should be checked out in the directory "~/dotfiles"
-    And the files in "~/dotfiles" should be symlinked in my home directory
-      No such file or directory - .vimrc (Errno::ENOENT)
-      ./features/step_definitions/fullstop_steps.rb:40:in `lstat'
-      ./features/step_definitions/fullstop_steps.rb:40:in `block (3 levels) in <top (required)>'
-      ./features/step_definitions/fullstop_steps.rb:39:in `each'
-      ./features/step_definitions/fullstop_steps.rb:39:in `block (2 levels) in <top (required)>'
-      ./features/step_definitions/fullstop_steps.rb:38:in `chdir'
-      ./features/step_definitions/fullstop_steps.rb:38:in `/^the files in "([^"]*)" should be symlinked in my home directory$/'
-      features/fullstop.feature:20:in `And the files in "~/dotfiles" should be symlinked in my home directory'
-
-Failing Scenarios:
-cucumber features/fullstop.feature:16
-
-2 scenarios (1 failed, 1 passed)
-11 steps (1 failed, 10 passed)
-0m0.313s
-rake aborted!
-Cucumber failed
-
-Tasks: TOP => features
-(See full trace by running task with --trace)
-```
-
-We're now failing at the next step:
-
-```cucumber
-And the files in "~/dotfiles" should be symlinked in my home directory
-```
-
-The error, "No such file or directory - .vimrc", is being raised from `File.lstat` (as opposed to an explicit test failure).  This is enough to allow us to write some more code.  What we need to do know is iterate over the files in the cloned repo and symlink them to the user's home directory.  The tools to do this are already available to use via the built-in Ruby library `FileUtils`.  We'll require it and implement the symlinking logic:
-
-```ruby
-#!/usr/bin/env ruby
-
-require 'optparse'
-require 'methadone'
-require 'fullstop'
-# vvv
-require 'fileutils'
-# ^^^
-
-class App
-  include Methadone::Main
-  include Methadone::CLILogging
-  include Methadone::SH
-
-  main do |repo_url|
-    
-    Dir.chdir ENV['HOME'] do
-      sh "git clone #{repo_url}"
-      basedir = repo_url.split(/\//)[-1].gsub(/\.git$/,'')
-      # vvv
-      Dir.entries(basedir).each do |file|
-        next if file == '.' || file == '..' || file == '.git'
-        FileUtils.ln_s file,'.'
-      end
-      # ^^^
-    end
-  end
-
-  version Fullstop::VERSION
-
-  description 'Manages dotfiles from a git repo'
-
-  arg :repo_url, "URL to the git repository containing your dotfiles"
-
-  use_log_level_option
-
-  go!
-end
-```
-
-Now, let's run our scenario again:
-
-```sh
-$ rake features
-Feature: Checkout dotfiles
-  In order to get my dotfiles onto a new computer
-  I want a one-command way to keep them up to date
-  So I don't have to do it myself
-
-  Scenario: Basic UI
-    When I get help for "fullstop"
-    Then the exit status should be 0
-    And the banner should be present
-    And there should be a one line summary of what the app does
-    And the banner should include the version
-    And the banner should document that this app takes options
-    And the banner should document that this app's arguments are:
-      | repo_url | which is required |
-
-  Scenario: Happy Path
-    Given a git repo with some dotfiles at "/tmp/dotfiles.git"
-    When I successfully run `fullstop file:///tmp/dotfiles.git`
-    Then the dotfiles should be checked out in the directory "~/dotfiles"
-    And the files in "~/dotfiles" should be symlinked in my home directory
-
-2 scenarios (2 passed)
-11 steps (11 passed)
-0m0.396s
-```
-
-Everything passed!  Our app now works for the "happy path".  As long as the user starts from a clean home directory, `fullstop` will clone their dotfiles, and setup symlinks to them in their home directory.  Now that we have the basics of our app running, we'll see how Methadone makes it easy to add new features.