methadone 1.0.0.rc5 → 1.0.0.rc6

data/methadone.gemspec

@@ -11,6 +11,16 @@ Gem::Specification.new do |s|
   s.homepage    = "http://github.com/davetron5000/methadone"
   s.summary     = %q{Kick the bash habit and start your command-line apps off right}
   s.description = %q{Methadone provides a lot of small but useful features for developing a command-line app, including an opinionated bootstrapping process, some helpful cucumber steps, and some classes to bridge logging and output into a simple, unified, interface}
+  s.post_install_message = "
+
+!!!!!!!!!!!!!!!!!!!!!!
+
+If you are on Ruby 1.8 or REE, you MUST
+
+gem install open4
+
+!!!!!!!!!!!!!!!!!!!!!!
+  "
 
   s.rubyforge_project = "methadone"
 

data/test/test_main.rb

@@ -209,6 +209,26 @@ class TestMain < BaseTest
     }
   end
 
+  test_that "when we help_now! we exit and show help" do
+    Given {
+      @message = any_sentence
+      main do
+        help_now!(@message)
+      end
+
+      opts.on("--switch") { options[:switch] = true }
+      opts.on("--flag FLAG") { |value| options[:flag] = value }
+
+      set_argv []
+    }
+
+    Then {
+      assert_exits(64) { When run_go! }
+      assert $stdout.string.include?(opts.to_s),"Expected #{$stdout.string} to contain #{opts.to_s}"
+      assert_logged_at_error @message
+    }
+  end
+
   test_that "opts allows us to more expediently set up OptionParser" do
     Given {
       @switch = nil

data/test/test_sh.rb

@@ -108,6 +108,30 @@ class TestSH < Clean::Test::TestCase
         assert_successful_command_execution(@exit_code,@logger,@command,test_command_stdout)
       }
     end
+
+    test_that "#{method}, when the command succeeds and given a block of three arguments, calls the block with the stdout, stderr, and exit code" do
+      Given {
+        use_capturing_logger
+        @command = test_command
+        @block_called = false
+        @stdout_received = nil
+        @stderr_received = nil
+        @exitstatus_received = nil
+      }
+      When {
+        @exit_code = self.send(method,@command) do |stdout,stderr,exitstatus|
+          @stdout_received = stdout
+          @stderr_received = stderr
+          @exitstatus_received = exitstatus
+        end
+      }
+      Then {
+        @stdout_received.should == test_command_stdout
+        @stderr_received.length.should == 0
+        @exitstatus_received.should == 0
+        assert_successful_command_execution(@exit_code,@logger,@command,test_command_stdout)
+      }
+    end
   end
 
   test_that "sh, when the command fails and given a block, doesn't call the block" do
@@ -115,7 +139,7 @@ class TestSH < Clean::Test::TestCase
       use_capturing_logger
       @command = test_command("foo")
       @block_called = false
-    }
+    } 
     When {
       @exit_code = sh @command do
         @block_called = true
@@ -127,6 +151,50 @@ class TestSH < Clean::Test::TestCase
     }
   end
 
+  test_that "sh, when the command fails with an unexpected status, and given a block, doesn't call the block" do
+    Given {
+      use_capturing_logger
+      @command = test_command("foo")
+      @block_called = false
+    } 
+    When {
+      @exit_code = sh @command, :expected => [2] do
+        @block_called = true
+      end
+    }
+    Then {
+      @exit_code.should == 1
+      assert_logger_output_for_failure(@logger,@command,test_command_stdout,test_command_stderr)
+    }
+  end
+
+  [1,[1],[1,2]].each do |expected|
+    [:sh,:sh!].each do |method|
+      test_that "#{method}, when the command fails with an expected error code (using syntax #{expected}/#{expected.class}), treats it as success" do
+        Given {
+          use_capturing_logger
+          @command = test_command("foo")
+          @block_called = false
+          @exitstatus_received = nil
+        } 
+        When {
+          @exit_code = self.send(method,@command,:expected => expected) do |_,_,exitstatus|
+            @block_called = true
+            @exitstatus_received = exitstatus
+          end
+        }
+        Then {
+          @exit_code.should == 1
+          @block_called.should == true
+          @exitstatus_received.should == 1
+          @logger.debugs[0].should == "Executing '#{test_command}foo'"
+          @logger.debugs[1].should == "Output of '#{test_command}foo': #{test_command_stdout}"
+          @logger.warns[0].should == "Error output of '#{test_command}foo': #{test_command_stderr}"
+        }
+      end
+    end
+  end
+
   test_that "sh runs a command that will fail and logs about it" do
     Given {
       use_capturing_logger
@@ -219,7 +287,11 @@ class TestSH < Clean::Test::TestCase
 
     def run_command(command)
       @command = command
-      [any_string,any_string,OpenStruct.new(:exitstatus => @exit_code)]
+      if @exitcode.kind_of? Fixnum
+        [any_string,any_string,OpenStruct.new(:exitstatus => @exitcode)]
+      else
+        [any_string,any_string,@exitcode]
+      end
     end
 
     def exception_meaning_command_not_found
@@ -251,7 +323,35 @@ class TestSH < Clean::Test::TestCase
     }
     Then {
       @app.strategy.command.should == @command
-      @results.should == @exitstatus
+      @results.should == @exit_code
+    }
+  end
+
+  test_that "when the execution strategy returns a non-int, but truthy value, it gets coerced into a 0" do
+    Given {
+      @app = MyExecutionStrategyApp.new(true)
+      @command = "ls"
+    }
+    When {
+      @results = @app.sh(@command)
+    }
+    Then {
+      @app.strategy.command.should == @command
+      @results.should == 0
+    }
+  end
+
+  test_that "when the execution strategy returns a non-int, but falsey value, it gets coerced into a 1" do
+    Given {
+      @app = MyExecutionStrategyApp.new(false)
+      @command = "ls"
+    }
+    When {
+      @results = @app.sh(@command)
+    }
+    Then {
+      @app.strategy.command.should == @command
+      @results.should == 1
     }
   end
 
@@ -276,6 +376,7 @@ private
     change_logger(@logger)
   end
 
+  # Runs the test command which exits with the length of ARGV/args
   def test_command(args='')
     File.join(File.dirname(__FILE__),'command_for_tests.rb') + ' ' + args
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: methadone
 version: !ruby/object:Gem::Version
-  version: 1.0.0.rc5
+  version: 1.0.0.rc6
   prerelease: 6
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-28 00:00:00.000000000Z
+date: 2012-03-29 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &70123273030540 !ruby/object:Gem::Requirement
+  requirement: &70347550918840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70123273030540
+  version_requirements: *70347550918840
 - !ruby/object:Gem::Dependency
   name: rspec-expectations
-  requirement: &70123273030040 !ruby/object:Gem::Requirement
+  requirement: &70347550918300 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: '2.6'
   type: :development
   prerelease: false
-  version_requirements: *70123273030040
+  version_requirements: *70347550918300
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70123273029560 !ruby/object:Gem::Requirement
+  requirement: &70347550917880 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70123273029560
+  version_requirements: *70347550917880
 - !ruby/object:Gem::Dependency
   name: rdoc
-  requirement: &70123273028900 !ruby/object:Gem::Requirement
+  requirement: &70347550917340 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +54,10 @@ dependencies:
         version: '3.9'
   type: :development
   prerelease: false
-  version_requirements: *70123273028900
+  version_requirements: *70347550917340
 - !ruby/object:Gem::Dependency
   name: cucumber
-  requirement: &70123273028320 !ruby/object:Gem::Requirement
+  requirement: &70347550916840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -65,10 +65,10 @@ dependencies:
         version: 1.1.1
   type: :development
   prerelease: false
-  version_requirements: *70123273028320
+  version_requirements: *70347550916840
 - !ruby/object:Gem::Dependency
   name: aruba
-  requirement: &70123273027800 !ruby/object:Gem::Requirement
+  requirement: &70347550916460 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,10 +76,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70123273027800
+  version_requirements: *70347550916460
 - !ruby/object:Gem::Dependency
   name: simplecov
-  requirement: &70123273027220 !ruby/object:Gem::Requirement
+  requirement: &70347550915860 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -87,10 +87,10 @@ dependencies:
         version: '0.5'
   type: :development
   prerelease: false
-  version_requirements: *70123273027220
+  version_requirements: *70347550915860
 - !ruby/object:Gem::Dependency
   name: clean_test
-  requirement: &70123273026680 !ruby/object:Gem::Requirement
+  requirement: &70347550915300 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -98,10 +98,10 @@ dependencies:
         version: '0.10'
   type: :development
   prerelease: false
-  version_requirements: *70123273026680
+  version_requirements: *70347550915300
 - !ruby/object:Gem::Dependency
   name: mocha
-  requirement: &70123273026220 !ruby/object:Gem::Requirement
+  requirement: &70347550914780 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -109,7 +109,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70123273026220
+  version_requirements: *70347550914780
 description: Methadone provides a lot of small but useful features for developing
   a command-line app, including an opinionated bootstrapping process, some helpful
   cucumber steps, and some classes to bridge logging and output into a simple, unified,
@@ -152,6 +152,7 @@ files:
 - lib/methadone/execution_strategy/rbx_open_4.rb
 - lib/methadone/exit_now.rb
 - lib/methadone/main.rb
+- lib/methadone/process_status.rb
 - lib/methadone/sh.rb
 - lib/methadone/version.rb
 - methadone.gemspec
@@ -179,35 +180,10 @@ files:
 - test/test_exit_now.rb
 - test/test_main.rb
 - test/test_sh.rb
-- tutorial/.vimrc
-- tutorial/1_intro.md
-- tutorial/2_bootstrap.md
-- tutorial/3_ui.md
-- tutorial/4_happy_path.md
-- tutorial/5_more_features.md
-- tutorial/6_refactor.md
-- tutorial/7_logging_debugging.md
-- tutorial/8_conclusion.md
-- tutorial/code/.rvmrc
-- tutorial/code/fullstop/.gitignore
-- tutorial/code/fullstop/Gemfile
-- tutorial/code/fullstop/LICENSE.txt
-- tutorial/code/fullstop/README.rdoc
-- tutorial/code/fullstop/Rakefile
-- tutorial/code/fullstop/bin/fullstop
-- tutorial/code/fullstop/features/fullstop.feature
-- tutorial/code/fullstop/features/step_definitions/fullstop_steps.rb
-- tutorial/code/fullstop/features/support/env.rb
-- tutorial/code/fullstop/fullstop.gemspec
-- tutorial/code/fullstop/lib/fullstop.rb
-- tutorial/code/fullstop/lib/fullstop/repo.rb
-- tutorial/code/fullstop/lib/fullstop/version.rb
-- tutorial/code/fullstop/test/tc_something.rb
-- tutorial/en.utf-8.add
-- tutorial/toc.md
 homepage: http://github.com/davetron5000/methadone
 licenses: []
-post_install_message: 
+post_install_message: ! "\n\n!!!!!!!!!!!!!!!!!!!!!!\n\nIf you are on Ruby 1.8 or REE,
+  you MUST\n\ngem install open4\n\n!!!!!!!!!!!!!!!!!!!!!!\n  "
 rdoc_options: []
 require_paths:
 - lib

data/tutorial/.vimrc

@@ -1,6 +0,0 @@
-set spell spelllang=en_us
-syn spell toplevel
-set spf=~/Projects/methadone/tutorial/en.utf-8.add
-ab taht that
-ab builting built-in
-ab builtin built-in

data/tutorial/1_intro.md

@@ -1,52 +0,0 @@
-# Awesome Ruby Command Line Apps with Methadone
-
-Kick the bash habit, and make all your command-line apps with Ruby.  
-
-In [Build Awesome Command-Line Applications in Ruby][clibook], I lay out how to make an awesome command-line application using
-Ruby.  The book focuses on tools like `OptionParser` to create the app.  As I wrote and researched, it became clear that there
-was a gap between `OptionParser`, which is very powerful, yet verbose, and other command line tools like [trollop][trollop], 
-[main][main], and [thor][thor], which have simple APIs, but aren't very powerful.  
-
-[clibook]: http://www.awesomecommandlineapps.com
-[main]: http://github.com/ahoward/main
-[trollop]: http://trollop.rubyforge.org
-[thor]: http://www.github.com/wycats/thor
-
-I created Methadone to bridge that gap.  Methadone provides all the power of `OptionParser`, but has a simple, clean API.
-Methadone also includes additional tools and classes to make your command-line apps even better.
-
-This tutorial will show you how to make a simple command-line app using Methadone that will be easy-to-use, easy-to-maintain, and
-fully tested.
-
-## What you'll need
-
-You'll need an installation of Ruby and the ability to install Ruby gems.  I would recommend that you use rvm and a gemset to
-work through these, but they aren't required.  There's a decent [walkthrough][setup] on my book's website of setting this up the
-way I work.  Although Methadone works on most versions of Ruby, I would recommend you use Ruby
-1.9.3, if you can.  If not, try to use an MRI Ruby as those versions (1.8.7, REE, 1.9.2, or 1.9.3) have the highest compatibility
-with other gems.
-
-[setup]: http://www.awesomecommandlineapps.com/setup.html
-
-## How this is organized
-
-This is a tutorial for making a simple command-line app.  Unlike some tutorials and books, we will be working through this using
-a "test-first" approach.  One thing that Methadone tries to enable is using [TDD][tdd] for creating and writing your command-line
-app.  As such, we'll write tests as much as possible to drive our work.
-
-[tdd]: http://en.wikipedia.org/wiki/Test-driven_development
-
-## The tutorial app
-
-The app we'll build is going to manage "dot files".  These are the files that live in your home directory and configure your
-shell, editor, and various other programs.  For example, `~/.bashrc` is the file to configure `bash`.  Many developers keep these
-files on [Github][github] so that they can maintain the same files across multiple computers.
-
-[github]: http://www.github.com
-
-To set this up on a new computer, you have to checkout the repo, and symlink all the files to your home directory.  To update the
-files you have to update the repo and then check if any new files were added.  This is the sort of tedious manual process that is
-ripe for automation via a command-line app.
-
-We'll develop a simplified version to demonstrate how to use Methadone.
-

data/tutorial/2_bootstrap.md

@@ -1,174 +0,0 @@
-# Bootstrapping our app
-
-One thing that's great about writing a webapp with Ruby on Rails is that, with one command, you have a skeleton app, including
-a fully functional test framework set up.  You can start writing tests immediately.  There's no common equivalent for a
-command-line app, which is what Methadone aims to provide.
-
-Methadone will also bootstrap other aspects of your app, such a `Rakefile`, a gemspec, a shell of an executable, a license, and a
-README.  First, let's install Methadone via RubyGems (note that if your aren't using rvm, you may need to use `sudo` to install
-gems):
-
-```sh
-$ gem install methadone
-Fetching: methadone-1.0.0.gem (100%)
-Successfully installed methadone-1.0.0
-1 gem installed
-Installing ri documentation for methadone-1.0.0...
-Installing RDoc documentation for methadone-1.0.0...
-```
-
-Methadone comes bundled with a command-line app that will do the bootstrapping:
-
-```sh
-$ methadone --help
-Usage: methadone [options] app_name
-
-Kick the bash habit by bootstrapping your Ruby command-line apps
-
-v1.0.0
-
-Options:
-        --force                      Overwrite files if they exist
-        --[no-]readme                [Do not ]produce a README file
-    -l, --license LICENSE            Specify the license for your project (mit|apache|custom|NONE)
-        --log-level LEVEL            Set the logging level (debug|info|warn|error|fatal)
-                                     (Default: info)
-        --version                    Show help/version info
-
-Default values can be placed in the METHODONE_OPTS environment variable
-```
-
-The app that we'll be building in this tutorial is be called `fullstop`, which is derived from the [British name][fullstop] for a period, which is the character used as a prefix to our dotfiles, and, is the reason they are called "dot" files in the first place.  Based on the command-line syntax for `methadone`, we can create our app right now with one simple command.  We'll use the Apache license as well as a README.
-
-[fullstop]: http://en.wikipedia.org/wiki/Full_stop
-
-```sh
-$ methadone --readme --license apache fullstop
-$ ls fullstop
-Gemfile           README.rdoc       bin/              
-fullstop.gemspec  test/             LICENSE.txt       
-Rakefile          features/         lib/
-```
-
-As you can see, we've got a generic gemified project.  Before we can start developing, we'll need to install a few gems using Bundler first:
-
-```sh
-$ cd fullstop
-$ bundle install
-Fetching source index for http://rubygems.org/
-Installing rake (0.9.2.2) 
-Installing ffi (1.0.11) with native extensions 
-Installing childprocess (0.3.1) 
-Installing builder (3.0.0) 
-Installing diff-lcs (1.1.3) 
-Installing json (1.6.5) with native extensions 
-Installing gherkin (2.7.6) with native extensions 
-Installing term-ansicolor (1.0.7) 
-Installing cucumber (1.1.4) 
-Installing rspec-core (2.8.0) 
-Installing rspec-expectations (2.8.0) 
-Installing rspec-mocks (2.8.0) 
-Installing rspec (2.8.0) 
-Installing aruba (0.4.11) 
-Using bundler (1.0.21) 
-Installing methadone (0.5.1) 
-Using fullstop (0.0.1) from source at /Users/davec/Projects/methadone/tutorial/code/fullstop 
-Installing rdoc (3.12) 
-Your bundle is complete! Use `bundle show [gemname]` to see where a bundled gem is installed.
-```
-
-Your versions might not match up, but this should be more or less what you see.  The first thing you'll notice is that this seems
-like a *lot* of gems!  Most of them are brought in by our acceptance testing framework, [aruba][aruba], which is a library on top
-of [cucumber][cucumber] tailor-made for testing command-line apps.  Methadone also assumes  you'll be unit
-testing with `Test::Unit`, which is a fine default.   In fact, both unit and acceptance tests are set up for you and available
-via `rake` tasks.  Let's see them in action.
-
-[aruba]: http://www.github.com/cucumber/aruba
-[cucumber]: http://cukes.info
-
-```sh
-$ rake
-Run options: 
-
-# Running tests:
-
-.
-
-Finished tests in 0.000623s, 1605.1364 tests/s, 1605.1364 assertions/s.
-
-1 tests, 1 assertions, 0 failures, 0 errors, 0 skips
-......
-
-1 scenario (1 passed)
-6 steps (6 passed)
-0m0.136s
-```
-
-As you can see, we ran one unit test and one cucumber scenario.  These were provided by Methadone as placeholders for your tests.
-Just like what Ruby on Rails does when you create an app, Methadone has reduced the friction between your need to write software
-and your ability to do so.
-
-Methadone also generated a very basic scaffold of the command-line app itself.  It's in `bin` and is called `fullstop` (the
-argument we gave to `methadone`).  Let's run it now:
-
-```sh
-$ bin/fullstop
-/Users/davec/.rvm/rubies/ruby-1.9.3-p0/lib/ruby/site_ruby/1.9.1/rubygems/custom_require.rb:36:in `require': cannot load such file -- fullstop (LoadError)
-from /Users/davec/.rvm/rubies/ruby-1.9.3-p0/lib/ruby/site_ruby/1.9.1/rubygems/custom_require.rb:36:in `require'
-from bin/fullstop:5:in `<main>'
-```
-
-Oops!  What happened?  
-
-Methadone is encouraging you to develop your app with best practices, and one such practice is to not have your executables mess with the load path.  In many Ruby command-line applications, you'll see code like this at the top of the file:
-
-```ruby
-$: << File.join(File.dirname(__FILE__),'..','lib')
-```
-
-This puts the `lib` directory, that is relative to the `bin` directory (where our executable lives), into Ruby's load path.  This will allow *us* to run the app easily, but for your users, it's not necessary if you distribute your app with RubyGems (which you should do) and it's generally not a good idea to modify the load path.  In order to run the app directly during development, we'll need to use `bundle exec`, like so (note that we won't be running our app a lot in development, but scripting it using Aruba so we can test its behavior in an automated way):
-
-```sh
-$ bundle exec bin/fullstop --help
-Usage: fullstop [options]
-
-v0.0.1
-
-Options:
-        --version                    Show help/version info
-        --log-level LEVEL            Set the logging level (debug|info|warn|error|fatal)
-                                         (Default: info)
-```
-
-
-Not too bad!  We've got the makings of a reasonable help system, versioning support, a usage statement and a working executable.
-Just remember to run the app with `bundle exec` while you're developing.  Remember, your users won't have to worry about as long
-as they installed it with RubyGems.
-
-Before we move on, let's look at the cucumber scenario that Methadone generated for us.  We're going to work "outside in" on our
-app, so this will be a sneak peek at what we'll be doing next.
-
-```sh
-$ cat features/fullstop.feature 
-```
-```cucumber
-Feature: My bootstrapped app kinda works
-  In order to get going on coding my awesome app
-  I want to have aruba and cucumber setup
-  So I don't have to do it myself
-
-  Scenario: App just runs
-    When I get help for "fullstop"
-    Then the exit status should be 0
-    And the banner should be present
-    And the banner should document that this app takes options
-    And the following options should be documented:
-      |--version|
-    And the banner should document that this app takes no arguments
-```
-
-We probably won't keep this exactly scenario around, but it's a good demonstration of Aruba and Cucumber, and will help to get us
-going.  Since this scenario passes, that means that we already have the cucumber steps defined somewhere.  As we'll see, the
-combination of Aruba and Methadone results in a lot of pre-defined steps that make acceptance testing a snap.
-
-In the next section, we'll expand this scenario to create the user interface we'll need to get our app going.