methadone 0.1.0 → 0.2.0

data/.gitignore

@@ -6,3 +6,4 @@ html
 .*.sw?
 tmp
 results.html
+coverage

data/README.rdoc

@@ -10,7 +10,7 @@ Currently, this is under development and has the following to offer:
 
 * Bootstrapping a new CLI app
 * Utility Classes
-  * Methadone::CLILogger - a logger subclass that sends error message to standard error and all messages to standard out
+  * Methadone::CLILogger - a logger subclass that sends messages to standard error standard out as appropriate
   * Methadone::CLILogging - a module that, when included in any class, provides easy access to a shared logger
 * Cucumber Steps
 
@@ -61,26 +61,30 @@ Currently, there are classes the assist in directing output logger-style to the
     include Methadone::CLILogging
 
     command = "rm -rf /tmp/*"
-    debug("About to run #{command}") # => goes only to STDOUT
+    debug("About to run #{command}") # => goes only to STDOUT, no logging format
     if system(command)
-      info("Succesfully ran #{command}") # => goes only to STDOUT
+      info("Succesfully ran #{command}") # => goes only to STDOUT, no logging format
     else
-      error("There was a problem running #{command}") # => goes to STDOUT AND STDERR
+      error("There was a problem running #{command}") # => goes only to STDERR, no logging format
     end
 
 ==== Using a log file, but respecting STDERR
 
+Here, since we have a logfile, that logfile gets ALL messages and they have the default logger format.
+
     require 'methadone'
 
     include Methadone::CLILogging
 
     self.logger = CLILogger.new("logfile.txt")
     command = "rm -rf /tmp/*"
-    debug("About to run #{command}") # => goes only to logfile.txt
+    debug("About to run #{command}") # => goes only to logfile.txt, in the logger-style format
     if system(command)
-      info("Succesfully ran #{command}") # => goes only to logfile.txt
+      info("Succesfully ran #{command}") # => goes only to logfile.txt, in the logger-style format
     else
-      error("There was a problem running #{command}") # => goes to logfile.txt AND STDERR
+      error("There was a problem running #{command}") 
+      # => goes to logfile.txt in the logger-style format, and
+      #    to STDERR in a plain format
     end
 
 == Cucumber Steps
@@ -143,6 +147,5 @@ Here's an example from methadone's own tests:
 
 == What might be
 
-* Support for running external commands easily, with full error checking
-* Support for main method-style implementation
-* Easy support for filtering the output of a command, e.g. <tt>File.open("ls|")</tt> Perl-style
+See {the roadmap}[https://github.com/davetron5000/methadone/wiki/Roadmap]
+

data/Rakefile

@@ -1,7 +1,7 @@
 require 'bundler'
 require 'rake/clean'
 require 'rake/testtask'
-gem 'rdoc'
+gem 'rdoc' # I need to use the installed RDoc gem, not what comes with the system
 require 'rdoc/task'
 require 'cucumber'
 require 'cucumber/rake/task'
@@ -18,7 +18,7 @@ Rake::TestTask.new do |t|
 end
 
 desc 'build rdoc'
-Rake::RDocTask.new do |rd|
+RDoc::Task.new do |rd|
   rd.main = "README.rdoc"
   rd.generator = 'hanna'
   rd.rdoc_files.include("README.rdoc","lib/**/*.rb","bin/**/*")
@@ -34,4 +34,6 @@ Cucumber::Rake::Task.new(:features) do |t|
   t.fork = false
 end
 
+CLEAN << "coverage"
+
 task :default => [:test, :features]

data/bin/methadone

@@ -1,24 +1,22 @@
 #!/usr/bin/env ruby -w
 
+$: << File.join(File.dirname(__FILE__),'..','lib')
+
 require 'fileutils'
-require 'erb'
 require 'optparse'
+require 'methadone'
+require 'methadone/cli'
 
 include FileUtils
+include Methadone::Main
+include Methadone::CLI
 
-def main(basedir,force)
-  if Dir.exists? basedir
-    if force
-      rm_rf basedir, :verbose => true, :secure => true
-    else
-      STDERR.puts "error: #{basedir} exists, use --force to override"
-      return 1
-    end
-  end
-
-  mkdir_p basedir
+main do |basedir,force|
+  check_and_prepare_basedir!(basedir,force)
 
   gemname = File.basename(basedir)
+  debug "Creating project for gem #{gemname}"
+
   chdir File.dirname(basedir)
 
   %x[bundle gem #{gemname}]
@@ -27,91 +25,20 @@ def main(basedir,force)
 
   template_dirs_in(:full).each  { |dir| mkdir_p dir }
 
-  copy_file "Rakefile"
-  copy_file "test/tc_something.rb"
+  ["Rakefile", "test/tc_something.rb", "features/support/env.rb"].each do |file|
+    copy_file file
+  end
+
   copy_file "features/executable.feature", :as => "#{gemname}.feature", :binding => binding
-  copy_file "features/support/env.rb"
   copy_file "features/step_definitions/executable_steps.rb", :as => "#{gemname}_steps.rb"
   copy_file "bin/executable", :as => gemname, :executable => true
+
   add_to_file "#{gemname}.gemspec", [
     "  s.add_development_dependency('rdoc')",
     "  s.add_development_dependency('aruba')",
     "  s.add_development_dependency('rake','~> 0.9.2')",
     "  s.add_dependency('methadone')",
   ], :before => /^end\s*$/
-
-  return 0
-end
-
-# Add content to a file
-#
-# +file+:: path to the file
-# +lines+:: Array of String representing the lines to add
-# +options+:: Hash of options:
-#             <tt>:before</tt>:: A regexp that will appear right after the new content. i.e.
-#                                this is where to insert said content.
-def add_to_file(file,lines,options = {})
-  new_lines = []
-  found_line = false
-  File.open(file).readlines.each do |line|
-    line.chomp!
-    if options[:before] && options[:before] === line
-      found_line = true
-      new_lines += lines
-    end
-    new_lines << line
-  end
-
-  raise "No line matched #{options[:before]}" if options[:before] && !found_line
-
-  new_lines += lines unless options[:before]
-  File.open(file,'w') do |fp|
-    new_lines.each { |line| fp.puts line }
-  end
-end
-
-# Copies a file, running it through ERB
-#
-# +relative_path+:: path to the file, relative to the project root, minus the .erb extension
-#                   You should use forward slashes to separate paths; this method
-#                   will handle making the ultimate path OS independent.
-# +options+:: Options to affect how the copy is done:
-#             <tt>:from</tt>:: The name of the profile from which to find the file, "full" by default
-#             <tt>:as</tt>:: The name the file should get if not the one in relative_path
-#             <tt>:executable</tt>:: true if this file should be set executable
-#             <tt>:binding</tt>:: the binding to use for the template
-def copy_file(relative_path,options = {})
-  options[:from] ||= :full
-
-  relative_path = File.join(relative_path.split(/\//))
-
-  template_path = File.join(template_dir(options[:from]),relative_path + ".erb")
-  template = ERB.new(File.open(template_path).readlines.join(''))
-
-  relative_path_parts = File.split(relative_path)
-  relative_path_parts[-1] = options[:as] if options[:as]
-
-  erb_binding = options[:binding] or binding
-
-  File.open(File.join(relative_path_parts),'w') do |file|
-    file.puts template.result(erb_binding)
-    file.chmod(0755) if options[:executable]
-  end
-end
-
-# Get the location of the templates for profile "from"
-def template_dir(from)
-  File.join(File.dirname(EXE),'..','templates',from.to_s)
-end
-
-def template_dirs_in(profile)
-  template_dir = template_dir(:full)
-
-  Dir["#{template_dir}/**/*"].select { |x| 
-    File.directory? x 
-  }.map { |dir| 
-    dir.gsub(/^#{template_dir}\//,'')
-  }
 end
 
 options = {}
@@ -132,7 +59,8 @@ EXE = File.expand_path(__FILE__)
 if ARGV.empty?
   STDERR.puts("error: app_dir required")
   exit 2
-else
-  exit main(ARGV[0],options[:force])
 end
 
+ARGV << options[:force]
+go!
+

data/features/support/env.rb

@@ -1,12 +1,21 @@
 require 'aruba/cucumber'
 require 'methadone/cucumber'
 
-ENV['PATH'] = "#{File.expand_path(File.dirname(__FILE__) + '/../../bin')}#{File::PATH_SEPARATOR}#{ENV['PATH']}"
+PROJECT_ROOT = File.join(File.dirname(__FILE__),'..','..')
+ENV['PATH'] = "#{File.join(PROJECT_ROOT,'bin')}#{File::PATH_SEPARATOR}#{ENV['PATH']}"
 ARUBA_DIR = File.join(%w(tmp aruba))
 Before do
   @dirs = [ARUBA_DIR]
   @puts = true
   @aruba_timeout_seconds = 60
-end
+  @original_rubylib = ENV['RUBYLIB']
 
+  # We want to use, hopefully, the methadone from this codebase and not
+  # the gem, so we put it in the RUBYLIB
+  ENV['RUBYLIB'] = File.join(PROJECT_ROOT,'lib') + File::PATH_SEPARATOR + ENV['RUBYLIB'].to_s
+end
 
+After do
+  # Put back how it was
+  ENV['RUBYLIB'] = @original_rubylib
+end

data/lib/methadone.rb

@@ -1,3 +1,5 @@
 require 'methadone/version'
 require 'methadone/cli_logger'
 require 'methadone/cli_logging'
+require 'methadone/main'
+require 'methadone/error'

data/lib/methadone/cli.rb

@@ -0,0 +1,100 @@
+require 'erb'
+
+module Methadone
+  # Stuff to implement methadone's CLI app.  These
+  # stuff isn't generally for your use and it's not
+  # included when you require 'methadone'
+  module CLI
+
+    # Checks that the basedir can be used, either by
+    # not existing, or by existing and force is true.
+    # In that case, we clean it out entirely
+    #
+    # +basedir+:: base directory where the user wants to create a new project
+    # +force+:: if true, and +basedir+ exists, delete it before proceeding
+    #
+    # This will exit the app if the dir exists and force is false
+    def check_and_prepare_basedir!(basedir,force)
+      if Dir.exists? basedir
+        if force
+          rm_rf basedir, :verbose => true, :secure => true
+        else
+          exit_now! 1,"error: #{basedir} exists, use --force to override"
+        end
+      end
+      mkdir_p basedir
+    end
+
+    # Add content to a file
+    #
+    # +file+:: path to the file
+    # +lines+:: Array of String representing the lines to add
+    # +options+:: Hash of options:
+    #             <tt>:before</tt>:: A regexp that will appear right after the new content. i.e.
+    #                                this is where to insert said content.
+    def add_to_file(file,lines,options = {})
+      new_lines = []
+      found_line = false
+      File.open(file).readlines.each do |line|
+        line.chomp!
+        if options[:before] && options[:before] === line
+          found_line = true
+          new_lines += lines
+        end
+        new_lines << line
+      end
+
+      raise "No line matched #{options[:before]}" if options[:before] && !found_line
+
+      new_lines += lines unless options[:before]
+      File.open(file,'w') do |fp|
+        new_lines.each { |line| fp.puts line }
+      end
+    end
+
+    # Copies a file, running it through ERB
+    #
+    # +relative_path+:: path to the file, relative to the project root, minus the .erb extension
+    #                   You should use forward slashes to separate paths; this method
+    #                   will handle making the ultimate path OS independent.
+    # +options+:: Options to affect how the copy is done:
+    #             <tt>:from</tt>:: The name of the profile from which to find the file, "full" by default
+    #             <tt>:as</tt>:: The name the file should get if not the one in relative_path
+    #             <tt>:executable</tt>:: true if this file should be set executable
+    #             <tt>:binding</tt>:: the binding to use for the template
+    def copy_file(relative_path,options = {})
+      options[:from] ||= :full
+
+      relative_path = File.join(relative_path.split(/\//))
+
+      template_path = File.join(template_dir(options[:from]),relative_path + ".erb")
+      template = ERB.new(File.open(template_path).readlines.join(''))
+
+      relative_path_parts = File.split(relative_path)
+      relative_path_parts[-1] = options[:as] if options[:as]
+
+      erb_binding = options[:binding] or binding
+
+      File.open(File.join(relative_path_parts),'w') do |file|
+        file.puts template.result(erb_binding)
+        file.chmod(0755) if options[:executable]
+      end
+    end
+
+    # Get the location of the templates for profile "from"
+    def template_dir(from)
+      File.join(File.dirname(EXE),'..','templates',from.to_s)
+    end
+
+    def template_dirs_in(profile)
+      template_dir = template_dir(:full)
+
+      Dir["#{template_dir}/**/*"].select { |x| 
+        File.directory? x 
+      }.map { |dir| 
+        dir.gsub(/^#{template_dir}\//,'')
+      }
+    end
+
+  end
+end

data/lib/methadone/cli_logger.rb

@@ -1,10 +1,20 @@
 require 'logger'
 
 module Methadone
-  # A Logger appropriate for a command-line program in that it logs
-  # all messages (based on level) to the standard output and logs "error" type
-  # messages additionally to the standard error.  By default, this will pretty
-  # much do what you want, however it can be customized:
+  # A Logger instance that gives better control of messaging the user
+  # and logging app activity.  At it's most basic, you would use
+  # #info as a replacement for +puts+ and #error as a replacement
+  # for <tt>STDERR.puts</tt>.  Since this is a logger, however, you
+  # can also use #debug, #warn, and #fatal, and you can control
+  # the format and "logging level" as such.
+  #
+  # So, by default:
+  # * #debug messages do not appear anywhere
+  # * #info messages appear on the standard output
+  # * #warn, #error, and #fata messagse appear on the standard error
+  # * The default format of messages is simply the message, no logging cruft
+  #
+  # You can customize this in several ways:
   # 
   # * You can override the devices used by passing different devices to the constructor
   # * You can adjust the level of message that goes to the error logger via error_level=
@@ -14,8 +24,22 @@ module Methadone
   #
   #     logger = CLILogger.new
   #     logger.debug("Starting up") # => only the standard output gets this
-  #     logger.error("Something went wrong!") # => both standard error AND standard output get this
+  #     logger.warn("careful!") # => only the standard error gets this
+  #     logger.error("Something went wrong!") # => only the standard error gets this
+  #
+  #     logger = CLILogger.new
+  #     logger.error_level = Logger::ERROR
+  #     logger.debug("Starting up") # => only the standard output gets this
+  #     logger.warn("careful!") # => only the standard OUTPUT gets this
+  #     logger.error("Something went wrong!") # => only the standard error gets this
+  #     
+  #     logger = CLILogger.new('logfile.txt')
+  #     logger.debug("Starting up") # => logfile.txt gets this
+  #     logger.error("Something went wrong!") # => BOTH logfile.txt AND the standard error get this
   class CLILogger < Logger
+    BLANK_FORMAT = proc { |severity,datetime,progname,msg|
+      msg + "\n"
+    }
 
     # Helper to proxy methods to the super class AND to the internal error logger
     # 
@@ -31,17 +55,38 @@ module Methadone
 
     proxy_method :'formatter='
     proxy_method :'datetime_format='
-    proxy_method :add
+
+    def add(severity, message = nil, progname = nil, &block) #:nodoc:
+      if @split_logs 
+        unless severity >= @stderr_logger.level
+          super(severity,message,progname,&block)
+        end
+      else
+        super(severity,message,progname,&block)
+      end
+      @stderr_logger.add(severity,message,progname,&block)
+    end
+    
 
     # A logger that logs error-type messages to a second device; useful
-    # for ensuring that error messages go to standard error
+    # for ensuring that error messages go to standard error.  This should be
+    # pretty smart about doing the right thing.  If both log devices are
+    # ttys, e.g. one is going to standard error and the other to the standard output,
+    # messages only appear once in the overall output stream.  In other words,
+    # an ERROR logged will show up *only* in the standard error.  If either
+    # log device is NOT a tty, then all messages go to +log_device+ and only
+    # errors go to +error_device+
     #
     # +log_device+:: device where all log messages should go, based on level
     # +error_device+:: device where all error messages should go.  By default, this is Logger::Severity::WARN
     def initialize(log_device=$stdout,error_device=$stderr)
       super(log_device)
+      @split_logs = log_device.tty? && error_device.tty?
+      self.level = Logger::Severity::INFO
       @stderr_logger = Logger.new(error_device)
       @stderr_logger.level = Logger::Severity::WARN
+      self.formatter = BLANK_FORMAT if log_device.tty?
+      @stderr_logger.formatter = BLANK_FORMAT if error_device.tty?
     end
 
     # Set the threshold for what messages go to the error device.  Note that calling

data/lib/methadone/error.rb

@@ -0,0 +1,12 @@
+module Methadone
+  # Standard exception you can throw to exit with a given 
+  # status code. Prefer Methadone::Main#exit_now! over this
+  class Error < StandardError
+    attr_reader :exit_code
+    # Create an Error with the given status code and message
+    def initialize(exit_code,message=nil)
+      super(message)
+      @exit_code = exit_code
+    end
+  end
+end

data/lib/methadone/main.rb

@@ -0,0 +1,86 @@
+module Methadone
+  # Include this module to gain access to the "canonical command-line app structure"
+  # DSL.  This is a *very* lightweight layer on top of what you might
+  # normally write that gives you just a bit of help to keep your code structured
+  # in a sensible way.
+  #
+  # This also includes Methadone::CLILogging to give you access to simple logging
+  module Main
+    include Methadone::CLILogging
+    # Declare the main method for your app.
+    # This allows you to specify the general logic of your
+    # app at the top of your bin file, but can rely on any methods
+    # or other code that you define later.  
+    #
+    # For example, suppose you want to process a set of files, but
+    # wish to determine that list from another method to keep your
+    # code clean.
+    #
+    #     #!/usr/bin/env ruby -w
+    #
+    #     require 'methadone'
+    #
+    #     include Methadone::Main
+    #
+    #     main do
+    #       files_to_process.each do |file|
+    #         # process file
+    #       end
+    #     end
+    #
+    #     def files_to_process
+    #       # return list of files
+    #     end
+    #
+    #     go!
+    #
+    # The block can accept any parameters, and unparsed arguments
+    # from the command line will be passed.
+    # 
+    # To run this method, call #go!
+    def main(&block)
+      @main_block = block
+    end
+
+    # Start your command-line app, exiting appropriately when
+    # complete
+    #
+    # This *will* exit your program when it completes.  If your
+    # #main block evaluates to an integer, that value will be sent
+    # to Kernel#exit, otherwise, this will exit with 0
+    def go!
+      result = call_main
+      if result.kind_of? Fixnum
+        exit result
+      else
+        exit 0
+      end
+    end
+
+    # Call this to exit the program immediately
+    # with the given error code and message.
+    #
+    # +exit_code+:: exit status you'd like to exit with
+    # +message+:: message to display to the user explaining the problem
+    def exit_now!(exit_code,message=nil)
+      raise Methadone::Error.new(exit_code,message)
+    end
+
+    private
+
+    # Handle calling main and trapping any exceptions thrown
+    def call_main
+      @main_block.call(*ARGV)
+    rescue Methadone::Error => ex
+      error ex.message unless no_message? ex
+      ex.exit_code
+    rescue => ex
+      error ex.message unless no_message? ex
+      70 # Linux sysexit code for internal software error
+    end
+
+    def no_message?(exception)
+      exception.message.nil? || exception.message.strip.empty?
+    end
+  end
+end

data/lib/methadone/version.rb

@@ -1,3 +1,3 @@
 module Methadone
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/methadone.gemspec

@@ -18,8 +18,9 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
-  s.add_development_dependency("rspec-expectations")
+  s.add_development_dependency("rspec-expectations", "~> 2.6")
   s.add_development_dependency("rake")
-  s.add_development_dependency("rdoc","~> 3.6.1")
+  s.add_development_dependency("rdoc","~> 3.9")
   s.add_development_dependency("aruba")
+  s.add_development_dependency("simplecov", "~> 0.5")
 end

data/templates/full/bin/executable.erb

@@ -1,7 +1,17 @@
 #!/usr/bin/env ruby -w
 
 require 'optparse'
+require 'methadone'
 
+include Methadone::Main
+
+main do |options|
+  # your program code here
+end
+
+# supplemental methods here
+
+options = {}
 option_parser = OptionParser.new do |opts|
   executable_name = File.basename(__FILE__)
   opts.banner = "Usage: #{executable_name}"
@@ -9,7 +19,17 @@ option_parser = OptionParser.new do |opts|
   # opts.banner = "Usage: #{executable_name} [options]\n\n" +
   # "One-line description of your app\n\n" +
   # "Options:"
+
+  # opts.on("--flag VAL","Some flag") do |val|
+  #   options[:flag] = val
+  # end
+  #
+  # opts.on("--[no-]switch","Some switch") do |switch|
+  #   options[:switch] = switch
+  # end
 end
 
 option_parser.parse!
 
+ARGV << options
+go!

data/test/base_test.rb

@@ -1,3 +1,7 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter "/test"
+end
 require 'test/unit'
 require 'rspec/expectations'
 

data/test/test_cli_logger.rb

@@ -20,7 +20,28 @@ class TestCLILogger < BaseTest
     $stdout = @real_stdout
   end
 
-  test "logger sends everything to stdout, and warns, errors, and fatals to stderr" do
+  test "when both stderr and stdin are ttys, split the log messages between them and don't format" do
+    class << $stderr
+      def tty?; true; end
+    end
+    class << $stdout
+      def tty?; true; end
+    end
+
+    logger = CLILogger.new
+    logger.level = Logger::DEBUG
+
+    logger.debug("debug")
+    logger.info("info")
+    logger.warn("warn")
+    logger.error("error")
+    logger.fatal("fatal")
+
+    $stdout.string.should == "debug\ninfo\n"
+    $stderr.string.should == "warn\nerror\nfatal\n"
+  end
+
+  test "logger sends debug and info to stdout, and warns, errors, and fatals to stderr" do
     logger = logger_with_blank_format
 
     logger.debug("debug")
@@ -52,6 +73,7 @@ class TestCLILogger < BaseTest
     err = StringIO.new
 
     logger = CLILogger.new(out,err)
+    logger.level = Logger::DEBUG
     logger.formatter = @blank_format
 
     logger.debug("debug")
@@ -80,6 +102,7 @@ class TestCLILogger < BaseTest
 
   test "both loggers use the same date format" do
     logger = CLILogger.new
+    logger.level = Logger::DEBUG
     logger.datetime_format = "the time"
     logger.debug("debug")
     logger.error("error")

data/test/test_cli_logging.rb

@@ -27,6 +27,7 @@ class TestCLILogging < BaseTest
       logger.formatter = proc do |severity,datetime,progname,msg|
         msg + "\n"
       end
+      logger.level = Logger::DEBUG
     end
 
     def doit

data/test/test_main.rb

@@ -0,0 +1,136 @@
+require 'base_test'
+require 'methadone'
+require 'stringio'
+
+class TestMain < BaseTest
+  include Methadone::Main
+
+  def setup
+    @logged = []
+    @original_argv = ARGV.clone
+    ARGV.clear
+  end
+
+  # Override error so we can capture what's being logged at this level
+  def error(string)
+    @logged << string
+  end
+
+  def teardown
+    set_argv @original_argv
+  end
+
+  test "my main block gets called by run and has access to CLILogging" do
+    called = false
+    main do
+      begin
+      debug "debug"
+      info "info"
+      warn "warn"
+      error "error"
+      fatal "fatal"
+      called = true
+      rescue => ex
+        puts ex.message
+      end
+    end
+    safe_go!
+    assert called,"main block wasn't called"
+  end
+
+  test "my main block gets the command-line parameters" do
+    params = []
+    main do |param1,param2,param3|
+      params << param1
+      params << param2
+      params << param3
+    end
+    set_argv %w(one two three)
+    safe_go!
+    assert_equal %w(one two three),params
+  end
+
+  test "my main block can freely ignore arguments given" do
+    called = false
+    main do
+      called = true
+    end
+    set_argv %w(one two three)
+    safe_go!
+    assert called,"Main block wasn't called?!"
+  end
+
+  test "my main block can ask for arguments that it might not receive" do
+    params = []
+    main do |param1,param2,param3|
+      params << param1
+      params << param2
+      params << param3
+    end
+    set_argv %w(one two)
+    safe_go!
+    assert_equal ['one','two',nil],params
+  end
+
+  test "go exits zero when main evaluates to nil or some other non number" do
+    [nil,'some string',Object.new,[],4.5].each do |non_number|
+      main { non_number }
+      assert_exits(0,"for value #{non_number}") { go! }
+    end
+  end
+
+  test "go exits with the numeric value that main evaluated to" do
+    [0,1,2,3].each do |exit_status|
+      main { exit_status }
+      assert_exits(exit_status) { go! }
+    end
+  end
+
+  test "go exits with 70, which is the Linux sysexits.h code for this sort of thing, if there's an exception" do
+    main do
+      raise "oh noes"
+    end
+    assert_exits(70) { go! }
+    assert_logged_at_error "oh noes"
+  end
+
+  test "go exits with the exit status included in the special-purpose excepiton" do
+    main do
+      raise Methadone::Error.new(4,"oh noes")
+    end
+    assert_exits(4) { go! }
+    assert_logged_at_error "oh noes"
+  end
+
+  test "can exit with a specific status by using the helper method instead of making a new exception" do
+    main do
+      exit_now!(4,"oh noes")
+    end
+    assert_exits(4) { go! }
+    assert_logged_at_error "oh noes"
+  end
+
+  private
+
+  # Calls go!, but traps the exit
+  def safe_go!
+    go!
+  rescue SystemExit
+  end
+
+  def assert_logged_at_error(expected_message)
+    assert @logged.include?(expected_message),"#{@logged} didn't include '#{expected_message}'"
+  end
+
+  def assert_exits(exit_code,message='',&block)
+    block.call
+    fail "Expected an exit of #{exit_code}, but we didn't even exit!"
+  rescue SystemExit => ex
+    assert_equal exit_code,ex.status,message
+  end
+
+  def set_argv(args)
+    ARGV.clear
+    args.each { |arg| ARGV << arg }
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: methadone
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,22 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-25 00:00:00.000000000Z
+date: 2011-10-01 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec-expectations
-  requirement: &70245763026000 !ruby/object:Gem::Requirement
+  requirement: &70156777550060 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.6'
   type: :development
   prerelease: false
-  version_requirements: *70245763026000
+  version_requirements: *70156777550060
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70245763024980 !ruby/object:Gem::Requirement
+  requirement: &70156777549580 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,21 +32,21 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70245763024980
+  version_requirements: *70156777549580
 - !ruby/object:Gem::Dependency
   name: rdoc
-  requirement: &70245763024340 !ruby/object:Gem::Requirement
+  requirement: &70156777548800 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 3.6.1
+        version: '3.9'
   type: :development
   prerelease: false
-  version_requirements: *70245763024340
+  version_requirements: *70156777548800
 - !ruby/object:Gem::Dependency
   name: aruba
-  requirement: &70245763023660 !ruby/object:Gem::Requirement
+  requirement: &70156777548320 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,7 +54,18 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70245763023660
+  version_requirements: *70156777548320
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: &70156777547600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :development
+  prerelease: false
+  version_requirements: *70156777547600
 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,
@@ -76,9 +87,12 @@ files:
 - features/step_definitions/bootstrap_steps.rb
 - features/support/env.rb
 - lib/methadone.rb
+- lib/methadone/cli.rb
 - lib/methadone/cli_logger.rb
 - lib/methadone/cli_logging.rb
 - lib/methadone/cucumber.rb
+- lib/methadone/error.rb
+- lib/methadone/main.rb
 - lib/methadone/version.rb
 - methadone.gemspec
 - templates/full/Rakefile.erb
@@ -90,6 +104,7 @@ files:
 - test/base_test.rb
 - test/test_cli_logger.rb
 - test/test_cli_logging.rb
+- test/test_main.rb
 homepage: http://github.com/davetron5000/methadone
 licenses: []
 post_install_message: 
@@ -121,3 +136,4 @@ test_files:
 - test/base_test.rb
 - test/test_cli_logger.rb
 - test/test_cli_logging.rb
+- test/test_main.rb