methadone 0.0.1

data/.gitignore

@@ -0,0 +1,8 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+html
+.*.sw?
+tmp
+results.html

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.2@methadone-dev --create

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in methadone.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1,136 @@
+= Methadone - kick the bash habit and start your command line apps off right
+
+Author::  Dave Copeland (mailto:davetron5000 at g mail dot com)
+Copyright:: Copyright (c) 2011 by Dave Copeland
+License:: Distributes under the Apache License, see LICENSE.txt in the source distro
+
+A smattering of tools to make your command-line apps easily awesome; kick the bash habit without sacrificing any of the power.
+
+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::CLILogging - a module that, when included in any class, provides easy access to a shared logger
+* Cucumber Steps
+
+== Links
+
+* {Source on Github}[http://github.com/davetron5000/methadone]
+* RDoc[http://rdoc.info/github/davetron5000/methadone/master/frames]
+
+== Bootstrapping
+
+The +methadone+ command-line app will bootstrap a new command-line app, setting up a proper gem structure, unit tests, and cucumber-based tests with aruba:
+
+    $ methadone --help
+    Usage: methadone [options] app_name
+            --force                      Overwrite files if they exist
+    $ methadone newgem
+    $ cd newgem
+    $ rake
+    1 tests, 1 assertions, 0 failures, 0 errors, 0 skips
+    1 scenario (1 passed)
+    3 steps (3 passed)
+    $ cat features/newgem.feature
+    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 run `newgem --help`
+        Then the exit status should be 0
+        And the output should contain:
+        """
+        Usage: newgem [options]
+        """
+
+Basically, this sets you up with all the boilerplate that you *should* be using to write a command-line app.
+
+== Utility Classes
+
+Currently, there are classes the assist in directing output logger-style to the right place; basically ensuring that errors go to +STDERR+ and everything else goes to +STDOUT+.  All of this is, of course, configurable
+
+=== Examples
+
+==== Using STDOUT as a log, respecting STDERR
+
+    require 'methadone'
+
+    include Methadone::CLILogging
+
+    command = "rm -rf /tmp/*"
+    debug("About to run #{command}") # => goes only to STDOUT
+    if system(command)
+      info("Succesfully ran #{command}") # => goes only to STDOUT
+    else
+      error("There was a problem running #{command}") # => goes to STDOUT AND STDERR
+    end
+
+==== Using a log file, but respecting STDERR
+
+    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
+    if system(command)
+      info("Succesfully ran #{command}") # => goes only to logfile.txt
+    else
+      error("There was a problem running #{command}") # => goes to logfile.txt AND STDERR
+    end
+
+== Cucumber Steps
+
+Methadone uses aruba[http://www.github.com/cucumber/aruba] for BDD-style testing with cucumber. This library has some awesome steps, and methadone provides additional, more opinionated, steps.  
+
+=== Example
+
+Here's an example from methadone's own tests:
+
+    Scenario: Help is properly documented
+      When I get help for "methadone"
+      Then the exit status should be 0
+      And the following options should be documented:
+        |--force|
+      And the banner should be present
+      And the banner should document that this app takes options
+      And the banner should document that this app's arguments are:
+        |app_name|required|
+
+=== Steps Provided
+* Run <tt>command_to_run --help</tt> using aruba
+
+    When I get help for "command_to_run"
+
+* Make sure that each option shows up in the help and has *some* sort of documentation
+
+    Then the following options should be documented:
+      |--force|
+      |-x     |
+
+* Check an individual option for documentation:
+
+    Then the option "--force" should be documented
+
+* Checks that the help has a proper usage banner
+
+    Then the banner should be present
+
+* Checks that the usage banner indicates it takes options via <tt>[options]</tt>
+
+    Then the banner should document that this app takes options
+
+* Checks that the app's usage banner documents that its arguments are <tt>args</tt>
+
+    Then the banner should document that this app's arguments are "args"
+
+
+== 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

data/Rakefile

@@ -0,0 +1,35 @@
+require 'bundler'
+require 'rake/clean'
+require 'rake/testtask'
+gem 'rdoc'
+require 'rdoc/task'
+require 'cucumber'
+require 'cucumber/rake/task'
+
+include Rake::DSL
+
+Bundler::GemHelper.install_tasks
+
+desc 'run tests'
+Rake::TestTask.new do |t|
+  t.libs << "lib"
+  t.libs << "test"
+  t.test_files = FileList['test/test_*.rb']
+end
+
+desc 'build rdoc'
+Rake::RDocTask.new do |rd|
+  rd.main = "README.rdoc"
+  rd.generator = 'hanna'
+  rd.rdoc_files.include("README.rdoc","lib/**/*.rb","bin/**/*")
+  rd.title = 'Methadone - Power Up your Command Line Apps'
+end
+
+CUKE_RESULTS = 'results.html'
+CLEAN << CUKE_RESULTS
+Cucumber::Rake::Task.new(:features) do |t|
+  t.cucumber_opts = "features --format html -o #{CUKE_RESULTS} --format pretty -x"
+  t.fork = false
+end
+
+task :default => [:test, :features]

data/bin/methadone

@@ -0,0 +1,136 @@
+#!/usr/bin/env ruby -w
+
+require 'fileutils'
+require 'erb'
+require 'optparse'
+
+include FileUtils
+
+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
+
+  gemname = File.basename(basedir)
+  chdir File.dirname(basedir)
+
+  %x[bundle gem #{gemname}]
+
+  chdir gemname
+
+  template_dirs_in(:full).each  { |dir| mkdir_p dir }
+
+  copy_file "Rakefile"
+  copy_file "test/tc_something.rb"
+  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('grancher')",
+    "  s.add_development_dependency('aruba')",
+  ], :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 = {}
+option_parser = OptionParser.new do |opts|
+  executable = File.basename(__FILE__)
+  opts.banner = "Usage: #{executable} [options] app_name"
+
+  opts.on("--force","Overwrite files if they exist") do
+    options[:force] = true
+  end
+end
+
+option_parser.parse!
+
+EXE = File.expand_path(__FILE__)
+
+if ARGV.empty?
+  STDERR.puts("error: app_dir required")
+  exit 2
+else
+  exit main(ARGV[0],options[:force])
+end
+

data/features/bootstrap.feature

@@ -0,0 +1,89 @@
+Feature: Bootstrap a new command-line app
+  As an awesome developer who wants to make a command-line app
+  I should be able to use methadone to bootstrap it
+  And get all kinds of cool things
+
+  Background:
+    Given the directory "tmp/newgem" does not exist
+
+  Scenario: Bootstrap a new app from scratch
+    When I successfully run `methadone tmp/newgem`
+    Then the following directories should exist:
+      |tmp/newgem                           |
+      |tmp/newgem/bin                       |
+      |tmp/newgem/lib                       |
+      |tmp/newgem/lib/newgem                |
+      |tmp/newgem/test                      |
+      |tmp/newgem/features                  |
+      |tmp/newgem/features/support          |
+      |tmp/newgem/features/step_definitions |
+    And the following files should exist:
+      |tmp/newgem/newgem.gemspec                            |
+      |tmp/newgem/Rakefile                                  |
+      |tmp/newgem/Gemfile                                   |
+      |tmp/newgem/bin/newgem                                |
+      |tmp/newgem/features/newgem.feature                   |
+      |tmp/newgem/features/support/env.rb                   |
+      |tmp/newgem/features/step_definitions/newgem_steps.rb |
+      |tmp/newgem/test/tc_something.rb                      |
+    And the file "tmp/newgem/newgem.gemspec" should match /add_development_dependency\('grancher'/
+    And the file "tmp/newgem/newgem.gemspec" should match /add_development_dependency\('aruba'/
+    And the file "tmp/newgem/newgem.gemspec" should match /add_development_dependency\('rdoc'/
+    Given I cd to "tmp/newgem"
+    When I successfully run `rake -T`
+    Then the output should contain:
+    """
+    rake build         # Build newgem-0.0.1.gem into the pkg directory
+    rake clean         # Remove any temporary products.
+    rake clobber       # Remove any generated file.
+    rake clobber_rdoc  # Remove RDoc HTML files
+    rake features      # Run Cucumber features
+    rake install       # Build and install newgem-0.0.1.gem into system gems
+    rake rdoc          # Build RDoc HTML files
+    rake release       # Create tag v0.0.1 and build and push newgem-0.0.1.gem to Rubygems
+    rake rerdoc        # Rebuild RDoc HTML files
+    rake test          # Run tests
+    """    
+    When I run `rake`
+    Then the exit status should be 0
+    And the output should contain:
+    """
+    1 tests, 1 assertions, 0 failures, 0 errors, 0 skips
+    """
+    And the output should contain:
+    """
+    1 scenario (1 passed)
+    3 steps (3 passed)
+    """
+
+  Scenario: Won't squash an existing dir
+    When I successfully run `methadone tmp/newgem`
+    And I run `methadone tmp/newgem`
+    Then the exit status should not be 0
+    And the stderr should contain:
+    """
+    error: tmp/newgem exists, use --force to override
+    """
+
+  Scenario: WILL squash an existing dir if we use --force
+    When I successfully run `methadone tmp/newgem`
+    And I run `methadone --force tmp/newgem`
+    Then the exit status should be 0
+
+  Scenario: We must supply a dirname
+    When I run `methadone`
+    Then the exit status should not be 0
+    And the stderr should contain:
+    """
+    error: app_dir required
+    """
+
+  Scenario: Help is properly documented
+    When I get help for "methadone"
+    Then the exit status should be 0
+    And the following options should be documented:
+      |--force|
+    And the banner should be present
+    And the banner should document that this app takes options
+    And the banner should document that this app's arguments are:
+      |app_name|required|

data/features/step_definitions/bootstrap_steps.rb

@@ -0,0 +1,7 @@
+require 'fileutils'
+include FileUtils
+
+Given /^the directory "([^"]*)" does not exist$/ do |dir|
+  dir = File.join(ARUBA_DIR,dir)
+  rm_rf dir,:verbose => false, :secure => true
+end

data/features/support/env.rb

@@ -0,0 +1,12 @@
+require 'aruba/cucumber'
+require 'methadone/cucumber'
+
+ENV['PATH'] = "#{File.expand_path(File.dirname(__FILE__) + '/../../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
+
+

data/lib/methadone.rb

@@ -0,0 +1,3 @@
+require 'methadone/version'
+require 'methadone/cli_logger'
+require 'methadone/cli_logging'

data/lib/methadone/cli_logger.rb

@@ -0,0 +1,65 @@
+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:
+  # 
+  # * 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=
+  # * You can adjust the format for messages to the error logger separately via error_formatter=
+  #
+  # === Example
+  #
+  #     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
+  class CLILogger < Logger
+
+    # Helper to proxy methods to the super class AND to the internal error logger
+    # 
+    # +symbol+:: Symbol for name of the method to proxy
+    def self.proxy_method(symbol) #:nodoc:
+      old_name = "old_#{symbol}".to_sym
+      alias_method old_name,symbol
+      define_method symbol do |*args,&block|
+        send(old_name,*args,&block)
+        @stderr_logger.send(symbol,*args,&block)
+      end
+    end
+
+    proxy_method :'formatter='
+    proxy_method :'datetime_format='
+    proxy_method :add
+
+    # A logger that logs error-type messages to a second device; useful
+    # for ensuring that error messages go to standard error
+    #
+    # +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)
+      @stderr_logger = Logger.new(error_device)
+      @stderr_logger.level = Logger::Severity::WARN
+    end
+
+    # Set the threshold for what messages go to the error device.  Note that calling
+    # #level= will *not* affect the error logger
+    #
+    # +level+:: a constant from Logger::Severity for the level of messages that should go
+    #           to the error logger
+    def error_level=(level)
+      @stderr_logger.level = level
+    end
+
+    # Overrides the formatter for the error logger.  A future call to #formatter= will
+    # affect both, so the order of the calls matters.
+    #
+    # +formatter+:: Proc that handles the formatting, the same as for #formatter=
+    def error_formatter=(formatter)
+      @stderr_logger.formatter=formatter
+    end
+
+  end
+end

data/lib/methadone/cli_logging.rb

@@ -0,0 +1,52 @@
+module Methadone
+  # Provides easier access to a shared Methadone::CLILogger instance.
+  #
+  # Include this module into your class, and #logger provides access to a shared logger.
+  # This is handy if you want all of your clases to have access to the same logger, but 
+  # don't want to (or aren't able to) pass it around to each class.
+  #
+  # This also provides methods for direct logging without going through the #logger
+  #
+  # === Example
+  #
+  #     class MyClass
+  #       include Methadone::CLILogger
+  #       
+  #       def doit
+  #         debug("About to doit!")
+  #         if results
+  #           info("We did it!"
+  #         else
+  #           error("Something went wrong")
+  #         end
+  #         debug("Done doing it")
+  #       end
+  #     end
+  module CLILogging
+    # Access the shared logger.  All classes that include this module
+    # will get the same logger via this method.
+    def logger
+      @@logger ||= CLILogger.new
+    end
+
+    # Change the global logger that includers will use.  Useful if you
+    # don't want the default configured logger.
+    #
+    # +new_logger+:: the new logger.  May not be nil and should be a a logger of some kind
+    def logger=(new_logger)
+      raise ArgumentError,"Logger may not be nil" if new_logger.nil?
+      @@logger = new_logger
+    end
+
+    # pass-through to <tt>logger.debug(progname,&block)</tt>
+    def debug(progname = nil, &block); logger.debug(progname,&block); end
+    # pass-through to <tt>logger.info(progname,&block)</tt>
+    def info(progname = nil, &block); logger.info(progname,&block); end
+    # pass-through to <tt>logger.warn(progname,&block)</tt>
+    def warn(progname = nil, &block); logger.warn(progname,&block); end
+    # pass-through to <tt>logger.error(progname,&block)</tt>
+    def error(progname = nil, &block); logger.error(progname,&block); end
+    # pass-through to <tt>logger.fatal(progname,&block)</tt>
+    def fatal(progname = nil, &block); logger.fatal(progname,&block); end
+  end
+end

data/lib/methadone/cucumber.rb

@@ -0,0 +1,30 @@
+When /^I get help for "([^"]*)"$/ do |app_name|
+  @app_name = app_name
+  When %(I run `#{app_name} --help`)
+end
+
+Then /^the following options should be documented:$/ do |options|
+  options.raw.each do |option|
+    Then %(the option "#{option[0]}" should be documented)
+  end
+end
+
+Then /^the option "([^"]*)" should be documented$/ do |option|
+  Then %(the output should match /^\\s*#{option}\\s+\\w\\w\\w+/)
+end
+
+Then /^the banner should be present$/ do
+  Then %(the output should match /Usage: #{@app_name}/)
+end
+
+Then /^the banner should document that this app takes options$/ do
+  Then %(the output should match /\[options\]/)
+end
+
+Then /^the banner should document that this app's arguments are:$/ do |table|
+  expected_arguments = table.raw.map { |row|
+    option = row[0]
+    option = "[#{option}]" if row[1] == 'optional'
+  }.join(' ')
+  Then %(the output should contain "#{expected_arguments}")
+end

data/lib/methadone/version.rb

@@ -0,0 +1,3 @@
+module Methadone
+  VERSION = "0.0.1"
+end

data/methadone.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "methadone/version"
+
+Gem::Specification.new do |s|
+  s.name        = "methadone"
+  s.version     = Methadone::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["davetron5000"]
+  s.email       = ["davetron5000 at gmail.com"]
+  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.rubyforge_project = "methadone"
+
+  s.files         = `git ls-files`.split("\n")
+  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("rake")
+  s.add_development_dependency("rdoc","~> 3.6.1")
+  s.add_development_dependency("aruba")
+end

data/templates/full/Rakefile.erb

@@ -0,0 +1,28 @@
+require 'bundler'
+require 'rake/clean'
+require 'rake/testtask'
+require 'cucumber'
+require 'cucumber/rake/task'
+require 'rdoc/task'
+
+include Rake::DSL
+
+Bundler::GemHelper.install_tasks
+
+Rake::TestTask.new do |t|
+  t.pattern = 'test/tc_*.rb'
+end
+
+CUKE_RESULTS = 'results.html'
+CLEAN << CUKE_RESULTS
+Cucumber::Rake::Task.new(:features) do |t|
+  t.cucumber_opts = "features --format html -o #{CUKE_RESULTS} --format progress -x"
+  t.fork = false
+end
+
+Rake::RDocTask.new do |rd|
+  rd.main = "README.rdoc"
+  rd.rdoc_files.include("README.rdoc","lib/**/*.rb","bin/**/*")
+end
+
+task :default => [:test,:features]

data/templates/full/bin/executable.erb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby -w
+
+require 'optparse'
+
+option_parser = OptionParser.new do |opts|
+  executable_name = File.basename(__FILE__)
+  opts.banner = "Usage: #{executable_name} [options]"
+end
+
+option_parser.parse!
+

data/templates/full/features/executable.feature.erb

@@ -0,0 +1,12 @@
+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 run `<%= gemname %> --help`
+    Then the exit status should be 0
+    And the output should contain:
+    """
+    Usage: <%= gemname %> [options]
+    """

data/templates/full/features/step_definitions/executable_steps.rb.erb

@@ -0,0 +1 @@
+# Put your step defintions here

data/templates/full/features/support/env.rb.erb

@@ -0,0 +1,8 @@
+require 'aruba/cucumber'
+
+ENV['PATH'] = "#{File.expand_path(File.dirname(__FILE__) + '/../../bin')}#{File::PATH_SEPARATOR}#{ENV['PATH']}"
+
+Before do
+  # Using "announce" causes massive warnings on 1.9.2
+  @puts = true
+end

data/templates/full/test/tc_something.rb.erb

@@ -0,0 +1,7 @@
+require 'minitest/autorun'
+
+class TestSomething < MiniTest::Unit::TestCase
+  def test_truth
+    assert true
+  end
+end

data/test/base_test.rb

@@ -0,0 +1,18 @@
+require 'test/unit'
+require 'rspec/expectations'
+
+class BaseTest < Test::Unit::TestCase
+  # Copied from Rails; makes a test method using a string
+  def self.test(name, &block)
+    test_name = "test_#{name.gsub(/\s+/,'_')}".to_sym
+    defined = instance_method(test_name) rescue false
+    raise "#{test_name} is already defined in #{self}" if defined
+    if block_given?
+      define_method(test_name, &block)
+    else
+      define_method(test_name) do
+        raise "No implementation provided for #{name}"
+      end
+    end
+  end
+end

data/test/test_cli_logger.rb

@@ -0,0 +1,117 @@
+require 'base_test'
+require 'methadone'
+require 'stringio'
+
+class TestCLILogger < BaseTest
+  include Methadone
+  
+  def setup
+    @blank_format = proc { |severity,datetime,progname,msg|
+      msg + "\n"
+    }
+    @real_stderr = $stderr
+    @real_stdout = $stdout
+    $stderr = StringIO.new
+    $stdout = StringIO.new
+  end
+
+  def teardown
+    $stderr = @real_stderr
+    $stdout = @real_stdout
+  end
+
+  test "logger sends everything to stdout, and warns, errors, and fatals to stderr" do
+    logger = logger_with_blank_format
+
+    logger.debug("debug")
+    logger.info("info")
+    logger.warn("warn")
+    logger.error("error")
+    logger.fatal("fatal")
+
+    $stdout.string.should == "debug\ninfo\nwarn\nerror\nfatal\n"
+    $stderr.string.should == "warn\nerror\nfatal\n"
+  end
+
+  test "we can control what goes to stderr" do
+    logger = logger_with_blank_format
+    logger.error_level = Logger::Severity::FATAL
+
+    logger.debug("debug")
+    logger.info("info")
+    logger.warn("warn")
+    logger.error("error")
+    logger.fatal("fatal")
+
+    $stdout.string.should == "debug\ninfo\nwarn\nerror\nfatal\n"
+    $stderr.string.should == "fatal\n"
+  end
+
+  test "we can log to alternate devices easily" do
+    out = StringIO.new
+    err = StringIO.new
+
+    logger = CLILogger.new(out,err)
+    logger.formatter = @blank_format
+
+    logger.debug("debug")
+    logger.info("info")
+    logger.warn("warn")
+    logger.error("error")
+    logger.fatal("fatal")
+
+    out.string.should == "debug\ninfo\nwarn\nerror\nfatal\n"
+    err.string.should == "warn\nerror\nfatal\n"
+  end
+
+
+  test "error logger ignores the log level" do
+    logger = logger_with_blank_format
+    logger.level = Logger::Severity::FATAL
+    logger.debug("debug")
+    logger.info("info")
+    logger.warn("warn")
+    logger.error("error")
+    logger.fatal("fatal")
+
+    $stdout.string.should == "fatal\n"
+    $stderr.string.should == "warn\nerror\nfatal\n"
+  end
+
+  test "both loggers use the same date format" do
+    logger = CLILogger.new
+    logger.datetime_format = "the time"
+    logger.debug("debug")
+    logger.error("error")
+    $stdout.string.should match /the time.*DEBUG.*debug/
+    $stderr.string.should match /the time.*ERROR.*error/
+  end
+
+  test "error logger does not get <<" do
+    logger = logger_with_blank_format
+    logger << "foo"
+    $stdout.string.should == "foo"
+    $stderr.string.should == ""
+  end
+
+  test "error logger can have a different format" do
+    logger = logger_with_blank_format
+    logger.error_formatter = proc { |severity,datetime,progname,msg|
+      "ERROR_LOGGER: #{msg}\n"
+    }
+    logger.debug("debug")
+    logger.error("error")
+    $stdout.string.should == "debug\nerror\n"
+    $stderr.string.should == "ERROR_LOGGER: error\n"
+  end
+
+  private 
+
+  def logger_with_blank_format
+    logger = CLILogger.new
+    logger.formatter = @blank_format
+    logger.level = Logger::Severity::DEBUG
+    logger
+  end
+
+end

data/test/test_cli_logging.rb

@@ -0,0 +1,97 @@
+require 'base_test'
+require 'methadone'
+require 'stringio'
+
+class TestCLILogging < BaseTest
+  include Methadone
+  
+  def setup
+    @blank_format = proc do |severity,datetime,progname,msg|
+      msg + "\n"
+    end
+    @real_stderr = $stderr
+    @real_stdout = $stdout
+    $stderr = StringIO.new
+    $stdout = StringIO.new
+  end
+
+  def teardown
+    $stderr = @real_stderr
+    $stdout = @real_stdout
+  end
+
+  class MyClassThatLogsToStdout
+    include Methadone::CLILogging
+
+    def initialize
+      logger.formatter = proc do |severity,datetime,progname,msg|
+        msg + "\n"
+      end
+    end
+
+    def doit
+      debug("debug")
+      info("info")
+      warn("warn")
+      error("error")
+      fatal("fatal")
+    end
+
+    def logger_id; logger.object_id; end
+  end
+
+  test "a class can include CLILogging and get terser logging" do
+    MyClassThatLogsToStdout.new.doit
+    $stdout.string.should == "debug\ninfo\nwarn\nerror\nfatal\n"
+    $stderr.string.should == "warn\nerror\nfatal\n"
+  end
+
+  test "another class using CLILogging gets the same logger instance" do
+    first = MyClassThatLogsToStdout.new
+    second = MyOtherClassThatLogsToStdout.new
+    first.logger_id.should == second.logger_id
+  end
+
+  test "we can change the global logger" do
+    first = MyClassThatLogsToStdout.new
+    second = MyOtherClassThatLogsToStdout.new
+    logger_id = second.logger_id
+
+    second.change_logger
+
+    logger_id.should_not == second.logger_id
+    first.logger_id.should == second.logger_id
+  end
+
+  test "we cannot use a nil logger" do
+    lambda { MyOtherClassThatLogsToStdout.new.change_to_nil_logger }.should raise_error(ArgumentError)
+  end
+
+  class MyOtherClassThatLogsToStdout
+    include Methadone::CLILogging
+
+    def initialize
+      logger.formatter = proc do |severity,datetime,progname,msg|
+        msg + "\n"
+      end
+    end
+
+    def doit
+      debug("debug")
+      info("info")
+      warn("warn")
+      error("error")
+      fatal("fatal")
+    end
+
+    def change_logger
+      self.logger=Methadone::CLILogger.new
+    end
+
+    def change_to_nil_logger
+      self.logger = nil
+    end
+
+    def logger_id; logger.object_id; end
+  end
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: methadone
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- davetron5000
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-12 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec-expectations
+  requirement: &70311581180940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70311581180940
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70311581180520 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70311581180520
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: &70311581180020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.6.1
+  type: :development
+  prerelease: false
+  version_requirements: *70311581180020
+- !ruby/object:Gem::Dependency
+  name: aruba
+  requirement: &70311581179600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70311581179600
+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,
+  interface
+email:
+- davetron5000 at gmail.com
+executables:
+- methadone
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- Gemfile
+- README.rdoc
+- Rakefile
+- bin/methadone
+- features/bootstrap.feature
+- features/step_definitions/bootstrap_steps.rb
+- features/support/env.rb
+- lib/methadone.rb
+- lib/methadone/cli_logger.rb
+- lib/methadone/cli_logging.rb
+- lib/methadone/cucumber.rb
+- lib/methadone/version.rb
+- methadone.gemspec
+- templates/full/Rakefile.erb
+- templates/full/bin/executable.erb
+- templates/full/features/executable.feature.erb
+- templates/full/features/step_definitions/executable_steps.rb.erb
+- templates/full/features/support/env.rb.erb
+- templates/full/test/tc_something.rb.erb
+- test/base_test.rb
+- test/test_cli_logger.rb
+- test/test_cli_logging.rb
+homepage: http://github.com/davetron5000/methadone
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: methadone
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Kick the bash habit and start your command-line apps off right
+test_files:
+- features/bootstrap.feature
+- features/step_definitions/bootstrap_steps.rb
+- features/support/env.rb
+- test/base_test.rb
+- test/test_cli_logger.rb
+- test/test_cli_logging.rb