boson 1.1.1 → 1.2.0

data/.gemspec

@@ -16,7 +16,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'bacon', '>= 1.1.0'
   s.add_development_dependency 'mocha-on-bacon'
   s.add_development_dependency 'bacon-bits'
-  s.add_development_dependency 'bahia', '>= 0.4.0'
+  s.add_development_dependency 'bahia', '>= 0.5.0'
   s.files = Dir.glob(%w[{lib,test}/**/*.rb bin/* [A-Z]*.{txt,rdoc,md} ext/**/*.{rb,c} **/deps.rip]) + %w{Rakefile .gemspec .travis.yml}
   s.files += ['.rspec']
   s.extra_rdoc_files = ["README.md", "LICENSE.txt", "Upgrading.md"]

data/CHANGELOG.rdoc

@@ -1,3 +1,12 @@
+== 1.2.0
+* Add help subcommand for executables
+* Allow Runner help methods to be extended
+* Fix arg and no method error handling on rbx
+* Fix OptionParser#delete_invalid_opts bug
+* Prefix Runner executable errors with executable name
+* Fix pending tests
+* Rename Runner help methods to Runner.display_help and Runner.display_command_help
+
 == 1.1.1
 * Fix bug for command with one argument containing quoted arguments
 

data/README.md

@@ -85,9 +85,21 @@ First, what I consider pros boson has over thor. Boson
   manually define your usage with desc: `desc "SOME USAGE", "SOME DESCRIPTION"`
 * is lenient about descriptions. Describe commands at your leisure. With thor
   you must define a desc.
-* has a smaller blacklist for command names i.e. just Kernel + Object method
-  names. Thor has a bigger
-  [blacklist](https://github.com/wycats/thor/blob/a24b6697a37d9bc0c0ea94ef9bf2cdbb33b8abb9/lib/thor/base.rb#L18-19) due to its design.
+* has no blacklist for command names while thor has a
+  [blacklist](https://github.com/wycats/thor/blob/a24b6697a37d9bc0c0ea94ef9bf2cdbb33b8abb9/lib/thor/base.rb#L18-19)
+  due to its design. With boson you can even name commands after Kernel method
+  names but tread with caution in your own Runner class.
+* allows for user-defined default global options (i.e. --help) and commands
+  (i.e. help). This means that with a plugin you could have your own additional
+  default options and commands shared across executables. See the extending
+  section below.
+* allows default help and command help to be overridden/extended by
+  subclassing Runner.display_help and Runner.display_command_help respectively.
+* provides an optional custom rc file for your executable. Simply set
+  ENV['BOSONRC'] to a path i.e. ~/.myprogramrc. This rc file loads before any
+  command processing is done, allowing for users to extend your executable
+  easily i.e. to add more subcommands. For an example, see
+  [vimdb](http://github.com/cldwalker/vimdb).
 
 Now for pros thor has over boson. Thor
 
@@ -96,24 +108,37 @@ Now for pros thor has over boson. Thor
 * is more stable as its feature set is mostly frozen.
 * is used by rails and thus is guaranteed support for some time.
 * supports ruby 1.8.7.
+* can conveniently define an option across commands using class_option.
+  boson may add this later.
 * TODO: I'm sure there's more
 
+## Converting From Thor
+
+* Change your requires and subclass from Boson::Runner instead of Thor.
+* Delete the first argument from `desc`. Usage is automatically created in boson.
+* Rename `method_option` to `option`
+* `class_option` doesn't exist yet but you can emulate it for now by defining
+  your class option in a class method and then calling your class method before
+  every command. See [vimdb](http://github.com/cldwalker/vimdb) for an example.
+
 ## Writing Plugins
 
 The most common way to write a plugin is to extend one of the many method hooks
 available. Any methods that are defined in an API or APIClassMethods module
 are extendable. For example, if you want to extend what any boson-based
-executable does first, extend BareRunner.start:
+executable does first, extend Boson::BareRunner.start:
 
 ```ruby
-module CustomStartUp
-  def start(*)
-    super
-    # additional startup
+module Boson
+  module CustomStartUp
+    def start(*)
+      super
+      # additional startup
+    end
   end
 end
 
-BareRunner.extend CustomStartUp
+Boson::BareRunner.extend Boson::CustomStartUp
 ```
 
 Notice that `extend` was used to extend a class method. To extend an instance
@@ -122,9 +147,53 @@ overridden method to call original functionality. If you don't, you're
 possibly overridden existing functionality, which is fine as long as you know
 what you are overriding.
 
+If you want to gemify your plugin, name it boson-plugin_name and put it under
+lib/boson/plugin_name.  The previous example would go in
+lib/boson/custom_startup.rb. To use your plugin, a user can simply require your
+plugin in their executable.
+
 For many plugin examples, see
 [boson-more](http://github.com/cldwalker/boson-more).
 
+## Using a Plugin
+
+To use a plugin, just require it. For an executable:
+
+```ruby
+require 'boson/runner'
+require 'boson/my_plugin'
+
+MyRunner.start
+```
+
+For the boson executable, just require the plugins in ~/.bosonrc.
+
+## Extending Your Executables
+
+Boson allows for custom default options and commands. This means you can
+add your own defaults in a plugin and use them across your executables.
+
+To add a custom default command, simply reopen Boson::DefaultCommandsRunner:
+
+```ruby
+class Boson::DefaultCommandsRunner
+  desc "whoomp"
+  def whoomp
+    puts "WHOOMP there it is!"
+  end
+end
+```
+
+To add a custom global option, add to Boson::Runner::GLOBAL_OPTIONS:
+
+```ruby
+Boson::Runner::GLOBAL_OPTIONS.update(
+  verbose: {type: :boolean, desc: "Verbose description of loading libraries"}
+)
+```
+
+Custom global options are defined in the same format as options for a command.
+
 ## Bugs/Issues
 
 Please report them [on github](http://github.com/cldwalker/boson/issues).

data/lib/boson/bare_runner.rb

@@ -44,7 +44,8 @@ module Boson
         raise if !allowed_argument_error?($!, cmd, args)
         abort_with "'#{cmd}' was called incorrectly.\nUsage: " + Command.usage(cmd)
       rescue NoMethodError => err
-        raise if !err.backtrace.first.include?('`full_invoke')
+        index = RUBY_ENGINE == 'rbx' ? 1 : 0
+        raise if !err.backtrace[index].include?('`full_invoke')
         no_command_error cmd
       end
 
@@ -55,15 +56,20 @@ module Boson
 
       # Determines if a user command argument error or an internal Boson one
       def allowed_argument_error?(err, cmd, args)
-        (err.message[/wrong number of arguments/] &&
-          (cmd_obj = Command.find(cmd)) && cmd_obj.arg_size != args.size)
+        msg = RUBY_ENGINE == 'rbx' && err.class == ArgumentError ?
+          /given \d+, expected \d+/ : /wrong number of arguments/
+        (err.message[msg] && (cmd_obj = Command.find(cmd)) &&
+          cmd_obj.arg_size != args.size)
+      end
+
+      def option_parser
+        @option_parser ||= OptionParser.new(self::GLOBAL_OPTIONS)
       end
 
       private
       def parse_args(args)
-        @option_parser = OptionParser.new(self::GLOBAL_OPTIONS)
-        options = @option_parser.parse(args.dup, :opts_before_args=>true)
-        new_args = @option_parser.non_opts
+        options = option_parser.parse(args.dup, :opts_before_args=>true)
+        new_args = option_parser.non_opts
         [new_args[0], options, new_args[1..-1]]
       end
 

data/lib/boson/option_parser.rb

@@ -418,12 +418,13 @@ module Boson
     end
 
     def delete_invalid_opts
-      @trailing_non_opts.delete_if {|e|
-        break if STOP_STRINGS.include? e
-        invalid = e.to_s[/^-/]
+      stop = nil
+      @trailing_non_opts.delete_if do |e|
+        stop ||= STOP_STRINGS.include?(e)
+        invalid = e.start_with?('-') && !stop
         warn "Deleted invalid option '#{e}'" if invalid
         invalid
-      }
+      end
     end
 
     def peek

data/lib/boson/runner.rb

@@ -4,16 +4,20 @@ module Boson
   # Defines a RunnerLibrary for use by executables as a simple way to map
   # methods to subcommands
   class Runner < BareRunner
+    # Stores currently started Runner subclass
+    class <<self; attr_accessor :current; end
+
     def self.inherited(mod)
       @help_added ||= add_command_help
       Inspector.enable all_classes: true, module: mod.singleton_class
     end
 
     def self.default_libraries
-      [self]
+      [self, DefaultCommandsRunner]
     end
 
     def self.start(args=ARGV)
+      Runner.current = self
       Boson.in_shell = true
       ENV['BOSONRC'] ||= ''
       super
@@ -23,18 +27,15 @@ module Boson
     end
 
     def self.execute(command, args, options)
-      if options[:help] || command.nil?
-        display_default_usage
-      else
+      options[:help] || command.nil? ? display_help :
         execute_command(command, args, options)
-      end
     end
 
     def self.execute_command(cmd, args, options)
       Command.find(cmd) ? super(cmd, args) : no_command_error(cmd)
     end
 
-    def self.display_help(cmd)
+    def self.display_command_help(cmd)
       puts "Usage: #{app_name} #{cmd.name} #{cmd.basic_usage}".rstrip, ""
       if cmd.options
         puts "Options:"
@@ -44,38 +45,53 @@ module Boson
       puts "Description:\n  #{cmd.desc || 'TODO'}"
     end
 
-    def self.display_default_usage
+    def self.display_help
       commands = Boson.commands.sort_by(&:name).map {|c| [c.name, c.desc.to_s] }
-      puts "Usage: #{app_name} COMMAND [ARGS]", "", "Available commands:",
-        Util.format_table(commands), "",
-        "For help on a command: #{app_name} COMMAND -h"
+      puts "Usage: #{app_name} [OPTIONS] COMMAND [ARGS]", "", "Available commands:",
+        Util.format_table(commands), "", "Options:"
+        option_parser.print_usage_table(no_headers: true)
     end
 
     def self.app_name
       File.basename($0).split(' ').first
     end
 
+    def self.abort_with(msg)
+      super "#{app_name}: #{msg}"
+    end
+
     private
     def self.load_options
       {force: true}
     end
 
     def self.add_command_help
+      Scientist.extend(ScientistExtension)
+      Command.extend(CommandExtension)
+      true # Ensure this method is only called once
+    end
+
+    module ScientistExtension
       # Overrides Scientist' default help
-      Scientist.extend(Module.new do
-        def run_help_option(cmd)
-          Boson::Runner.display_help(cmd)
-        end
-      end)
+      def run_help_option(cmd)
+        Boson::Runner.current.display_command_help(cmd)
+      end
+    end
 
+    module CommandExtension
       # Ensure all commands have -h
-      Command.extend(Module.new do
-        def new_attributes(name, library)
-          super.update(option_command: true)
-        end
-      end)
-      # Ensure this is only called once
-      true
+      def new_attributes(name, library)
+        super.update(option_command: true)
+      end
+    end
+  end
+
+  # Defines default commands that are available to executables i.e. Runner.start
+  class DefaultCommandsRunner < Runner
+    desc "Displays help for a command"
+    def help(cmd)
+      (cmd_obj = Command.find(cmd)) ? Runner.current.display_command_help(cmd_obj) :
+        self.class.no_command_error(cmd)
     end
   end
 end

data/lib/boson/version.rb

@@ -1,3 +1,3 @@
 module Boson
-  VERSION = '1.1.1'
+  VERSION = '1.2.0'
 end

data/test/bin_runner_test.rb

@@ -8,11 +8,7 @@ describe "BinRunner" do
     yield
   end
 
-  unless ENV['FAST'] ||
-    # disable rubinius until Open3.spawn defined in Bahia
-    # disable jruby until Open3.spawn works with ENV in Bahia
-    RUBY_DESCRIPTION.include?('rubinius') || RUBY_PLATFORM[/java/]
-
+  unless ENV['FAST']
     it "prints usage with no arguments" do
       boson
       stdout.should =~ /^boson/
@@ -44,7 +40,6 @@ describe "BinRunner" do
       end
     end
 
-    # TODO: test actual uses of Runner.debug
     it "sets Boson.debug with --debug" do
       boson "--debug -e 'print Boson.debug'"
       stdout.should == 'true'
@@ -60,20 +55,19 @@ describe "BinRunner" do
     it "prints error for unexpected error" do
       boson %[-e 'raise "blarg"']
       stderr.chomp.should == "Error: blarg"
-      process.success?.should == false
     end
 
-    # TODO: enable once bin runner's fate is decided
-    xit "prints error for too many arguments" do
-      boson "commands 1 2 3"
-      stderr.should =~ /^'commands' was called incorrectly/
-      process.success?.should == false
+    it "prints error for too many arguments" do
+      with_command('dude') do
+        boson "dude 1 2 3"
+        stderr.should =~ /^'dude' was called incorrectly/
+        process.success?.should == false
+      end
     end
 
-    # TODO: possible error with persistance extraction
-    xit "prints error for invalid command" do
+    it "prints error for invalid command" do
       boson 'blarg'
-      stderr.chomp.should == "Error: Command 'blarg' not found"
+      stderr.chomp.should == %[Could not find command "blarg"]
       process.success?.should == false
     end
   end

data/test/deps.rip

@@ -2,4 +2,4 @@ mocha ~>0.10.4
 bacon >=1.1.0
 mocha-on-bacon >=0
 bacon-bits >=0
-bahia >=0.4.0
+bahia >=0.5.0

data/test/option_parser_test.rb

@@ -180,14 +180,13 @@ describe "OptionParser" do
         opt.non_opts.should == ['ok']
       end
 
-      # TODO: Fix for 1.9.3
-      xit ":delete_invalid_opts deletes until - or --" do
+      it ":delete_invalid_opts deletes until - or --" do
         create(:foo=>:boolean, :bar=>:boolean)
         %w{- --}.each do |stop_char|
           capture_stderr {
             opt.parse(%w{ok -b -d} << stop_char << '-f', :delete_invalid_opts=>true)
           }.should =~ /'-d'/
-          opt.non_opts.should == %w{ok -d} << stop_char << '-f'
+          opt.non_opts.should == %w{ok} << stop_char << '-f'
         end
       end
 

data/test/runner_library_test.rb

@@ -7,4 +7,9 @@ describe "RunnerLibrary" do
     Manager.load create_runner(:blah)
     library('blarg').commands.should == ['blah']
   end
+
+  it "can coexist with another runner library" do
+    Manager.load create_runner(:blah)
+    should_not_raise { Manager.load create_runner(:blih, library: :Blih) }
+  end
 end

data/test/runner_test.rb

@@ -1,15 +1,16 @@
 require File.dirname(__FILE__) + '/test_helper'
 require 'shellwords'
 
-class MyRunner < Boson::Runner
-  GLOBAL_OPTIONS[:version] = {
-    type: :boolean, :desc => 'Print version'
-  }
+# hack required to re-add default_commands_runner methods
+$".delete_if {|e| e[%r{boson/runner.rb$}] }
+Boson.send(:remove_const, :Runner)
+Boson.send(:remove_const, :DefaultCommandsRunner)
+require 'boson/runner'
 
-  def self.execute(command, args, options)
-    options[:version] ? puts("Version 1000.0") : super
-  end
+# remove side effects from other tests
+Boson::Runner::GLOBAL_OPTIONS.delete_if {|k,v| k != :help }
 
+class MyRunner < Boson::Runner
   desc "This is a small"
   def small(*args)
     p args
@@ -52,22 +53,42 @@ class MyRunner < Boson::Runner
   end
 end
 
+class ExtendedRunner < Boson::Runner
+  def self.execute(command, args, options)
+    options[:version] ? puts("Version 1000.0") : super
+  end
+
+  def self.display_command_help(cmd)
+    super
+    puts "And don't forget to eat BAACCCONN"
+  end
+end
+
 describe "Runner" do
-  before_all { $0 = 'my_command'; reset }
+  before_all { reset }
 
   def my_command(cmd='')
+    $0 = 'my_command'
     capture_stdout do
       MyRunner.start Shellwords.split(cmd)
     end
   end
 
+  def extended_command(cmd='')
+    $0 = 'extended_command'
+    capture_stdout do
+      ExtendedRunner.start Shellwords.split(cmd)
+    end
+  end
+
   def default_usage
     <<-STR
-Usage: my_command COMMAND [ARGS]
+Usage: my_command [OPTIONS] COMMAND [ARGS]
 
 Available commands:
   boom
   broken
+  help    Displays help for a command
   medium  This is a medium
   mini    This is a mini
   quiet
@@ -75,7 +96,8 @@ Available commands:
   splot   This is splot
   test
 
-For help on a command: my_command COMMAND -h
+Options:
+  -h, --help  Displays this help message
 STR
   end
 
@@ -88,6 +110,23 @@ STR
     my_command('--help').should == default_usage
   end
 
+  describe "for help COMMAND" do
+    it 'prints help for valid command' do
+      my_command('help quiet').should ==<<-STR
+Usage: my_command quiet
+
+Description:
+  TODO
+STR
+    end
+
+    it 'prints error for invalid command' do
+      Boson::DefaultCommandsRunner.expects(:abort).
+        with("my_command: Could not find command \"invalid\"")
+      my_command('help invalid')
+    end
+  end
+
   describe "for COMMAND -h" do
     it "prints help for descriptionless command" do
       my_command('quiet -h').should == <<-STR
@@ -147,7 +186,7 @@ STR
 
   it "calls command with too many args" do
     MyRunner.expects(:abort).with <<-STR.chomp
-'medium' was called incorrectly.
+my_command: 'medium' was called incorrectly.
 Usage: medium [ARG]
 STR
     my_command('medium 1 2 3')
@@ -161,7 +200,12 @@ STR
   end
 
   it "executes custom global option" do
-    my_command('-v').chomp.should == 'Version 1000.0'
+    # setup goes here to avoid coupling to other runner
+    ExtendedRunner::GLOBAL_OPTIONS[:version] = {
+      type: :boolean, :desc => 'Print version'
+    }
+
+    extended_command('-v').chomp.should == 'Version 1000.0'
   end
 
   it "allows Kernel-method command names" do
@@ -169,12 +213,12 @@ STR
   end
 
   it "prints error message for internal public method" do
-    MyRunner.expects(:abort).with %[Could not find command "to_s"]
+    MyRunner.expects(:abort).with %[my_command: Could not find command "to_s"]
     my_command('to_s').should == ''
   end
 
   it "prints error message for nonexistant command" do
-    MyRunner.expects(:abort).with %[Could not find command "blarg"]
+    MyRunner.expects(:abort).with %[my_command: Could not find command "blarg"]
     my_command('blarg').should == ''
   end
 
@@ -187,7 +231,7 @@ STR
   end
 
   it "prints error message for private method" do
-    MyRunner.expects(:abort).with %[Could not find command "no_run"]
+    MyRunner.expects(:abort).with %[my_command: Could not find command "no_run"]
     my_command('no_run').should == ''
   end
 
@@ -208,4 +252,26 @@ STR
 
     after_all { ENV['BOSONRC'] = File.dirname(__FILE__) + '/.bosonrc' }
   end
+
+  describe "extend Runner" do
+    it "can extend help" do
+      extended_command('help help').should == <<-STR
+Usage: extended_command help CMD
+
+Description:
+  Displays help for a command
+And don't forget to eat BAACCCONN
+STR
+    end
+
+    it "can extend a command's --help" do
+      extended_command('help -h').should == <<-STR
+Usage: extended_command help CMD
+
+Description:
+  Displays help for a command
+And don't forget to eat BAACCCONN
+STR
+    end
+  end
 end

data/test/scientist_test.rb

@@ -152,8 +152,7 @@ describe "Scientist" do
     end
 
     it "with too many args raises CommandArgumentError" do
-      args3 = RUBY_DESCRIPTION.include?('rubinius') ?
-        [ArgumentError, 'given 3, expected 2'] :
+      args3 = RUBY_ENGINE == 'rbx' ? [ArgumentError, 'given 3, expected 2'] :
         [ArgumentError, '3 for 2']
       args4 = [OptionCommand::CommandArgumentError, '4 for 2']
       assert_error(*args3) { command_with_args 1,2,3 }

data/test/test_helper.rb

@@ -37,6 +37,27 @@ module TestHelpers
     Boson.config = old_config
   end
 
+  # for use with executables
+  def with_command(cmd)
+    old = ENV['BOSONRC']
+    ENV['BOSONRC'] = File.dirname(__FILE__) + '/.bosonrc.temp'
+    File.open(ENV['BOSONRC'], 'w') {|f|
+      f.puts <<-STR
+require 'boson/runner'
+class SomeRunner < Boson::Runner
+def #{cmd}
+end
+end
+Boson::Manager.load SomeRunner
+STR
+    }
+
+    yield
+
+    FileUtils.rm_f ENV['BOSONRC']
+    ENV['BOSONRC'] = old
+  end
+
   def manager_load(lib, options={})
     @stderr = capture_stderr { Manager.load(lib, options) }
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: boson
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-09 00:00:00.000000000 Z
+date: 2012-03-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mocha
-  requirement: &70160942164240 !ruby/object:Gem::Requirement
+  requirement: &70095971880980 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 0.10.4
   type: :development
   prerelease: false
-  version_requirements: *70160942164240
+  version_requirements: *70095971880980
 - !ruby/object:Gem::Dependency
   name: bacon
-  requirement: &70160942163680 !ruby/object:Gem::Requirement
+  requirement: &70095971880140 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: 1.1.0
   type: :development
   prerelease: false
-  version_requirements: *70160942163680
+  version_requirements: *70095971880140
 - !ruby/object:Gem::Dependency
   name: mocha-on-bacon
-  requirement: &70160942163160 !ruby/object:Gem::Requirement
+  requirement: &70095971878980 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70160942163160
+  version_requirements: *70095971878980
 - !ruby/object:Gem::Dependency
   name: bacon-bits
-  requirement: &70160942162700 !ruby/object:Gem::Requirement
+  requirement: &70095971878240 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,18 +54,18 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70160942162700
+  version_requirements: *70095971878240
 - !ruby/object:Gem::Dependency
   name: bahia
-  requirement: &70160942162140 !ruby/object:Gem::Requirement
+  requirement: &70095971877400 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.5.0
   type: :development
   prerelease: false
-  version_requirements: *70160942162140
+  version_requirements: *70095971877400
 description: Boson is a modular command/task framework. Thanks to its rich set of
   plugins, it differentiates itself from rake and thor by being usable from irb and
   the commandline, having optional automated views generated by hirb and allowing
@@ -112,7 +112,6 @@ files:
 - bin/boson
 - LICENSE.txt
 - CHANGELOG.rdoc
-- README.rdoc
 - README.md
 - Upgrading.md
 - test/deps.rip

data/README.rdoc

@@ -1,181 +0,0 @@
-To read a linkable version of this README, {see here}[http://tagaholic.me/boson/doc/].
-
-== Description
-Boson is a command/task framework with the power to turn any ruby method into a full-fledged
-executable with options.  Some unique features that differentiate it from rake and thor include
-being usable from irb and the commandline, optional automated views generated by hirb and allowing
-libraries to be written as plain ruby. For my libraries that use this, see
-{irbfiles}[http://github.com/cldwalker/irbfiles].  Works with all major ruby versions.
-
-== UPDATE
-Boson 0.4.x will be the last 1.8 compatible version.
-Boson 1.0 will be a rewrite compatible with only 1.9. Work is going on in {boson2
-branch}[https://github.com/cldwalker/boson/tree/boson2]. The goal of boson2 is to have a slimmer
-core, move everything else {to plugins}[https://github.com/cldwalker/boson-more]
-and to allow gems to use boson to make executables like thor.
-
-== Features
-* Simple organization: Commands are just methods on an object (default is main) and command libraries are just modules.
-* Commands are accessible from the commandline (Boson::BinRunner) or irb (Boson::ConsoleRunner).
-* Libraries
-  * can be written in plain ruby which allows for easy testing and use independent of boson (Boson::FileLibrary).
-  * can exist locally as a Bosonfile (Boson::LocalFileLibrary) and under lib/boson/commands or .boson/commands.
-  * can be made from gems (Boson::GemLibrary) or any require-able file (Boson::RequireLibrary).
-  * are encouraged to be shared. Libraries can be installed with a given url. Users can customize any aspect of a third-party
-    library without modifying it (Boson::Library).
-* Commands
-  * can have any number of local and global options (Boson::OptionCommand). Options are defined with Boson::OptionParser.
-  * can have any view associated to it (via Hirb) without adding view code to the command's method.
-    These views can be toggled on and manipulated via global render options (Boson::View and Boson::OptionCommand).
-  * can pipe their return value into custom pipe options (Boson::Pipe).
-  * has default pipe options to search and sort an array of any objects (Boson::Pipes).
-* Option parser (Boson::OptionParser)
-  * provides option types that map to objects i.e. :array type creates Array objects.
-  * come with 5 default option types: boolean, array, string, hash and numeric.
-  * can have have custom option types defined by users (Boson::Options).
-* Comes with default commands to load, search, list and install commands and libraries (Boson::Commands::Core).
-* Namespaces are optional and when used are methods which allow for method_missing magic.
-
-== Creating Command Libraries
-See Boson::FileLibrary or here[http://tagaholic.me/boson/doc/classes/Boson/FileLibrary.html].
-
-== Irb Example
-
-To use in irb, drop this in your ~/.irbrc:
-    require 'boson'
-    Boson.start
-
-Having done that, let's start up irb:
-
-  bash> irb
-  Loaded library core
-  Loaded library web_core
-
-  # List default libraries
-  >> libraries
-  +----------+----------+------+--------------+
-  | name     | commands | gems | library_type |
-  +----------+----------+------+--------------+
-  | core     | 6        |      | module       |
-  | web_core | 3        |      | module       |
-  +----------+----------+------+--------------+
-  2 rows in set
-
-  # List default commands
-  >> commands
-  +--------------+----------+-------+--------------------------------------------+-----------------------------------------------------------------------------+
-  | full_name    | lib      | alias | usage                                      | description                                                                 |
-  +--------------+----------+-------+--------------------------------------------+-----------------------------------------------------------------------------+
-  | usage        | core     |       | [name][--verbose]                          | Print a command's usage                                                     |
-  | libraries    | core     |       | [query=''][--index] [--query_fields=A,B,C] | List or search libraries                                                    |
-  | render       | core     |       | [object] [options={}]                      | Render any object using Hirb                                                |
-  | load_library | core     |       | [library][--verbose] [--reload]            | Load/reload a library                                                       |
-  | commands     | core     |       | [query=''][--index] [--query_fields=A,B,C] | List or search commands                                                     |
-  | menu         | core     |       | [output] [options={}] [&block]             | Provide a menu to multi-select elements from a given array                  |
-  | get          | web_core |       | [url]                                      | Gets the body of a url                                                      |
-  | install      | web_core |       | [url][--force] [--name=NAME]               | Installs a library by url. Library should then be loaded with load_library. |
-  | browser      | web_core |       | [*urls]                                    | Opens urls in a browser                                                     |
-  +--------------+----------+-------+--------------------------------------------+-----------------------------------------------------------------------------+
-  9 rows in set
-
-  # Boson commands can behave like shell commands:
-
-  # Basic help
-  >> commands '-h'
-  commands [query=''][--index] [--query_fields=A,B,C]
-
-  # Search the lib column for web
-  >> commands 'web -q=lib' # or 'web --query_fields=lib'
-  +-----------+----------+-------+------------------------------+-----------------------------------------------------------------------------+
-  | full_name | lib      | alias | usage                        | description                                                                 |
-  +-----------+----------+-------+------------------------------+-----------------------------------------------------------------------------+
-  | get       | web_core |       | [url]                        | Gets the body of a url                                                      |
-  | install   | web_core |       | [url][--force] [--name=NAME] | Installs a library by url. Library should then be loaded with load_library. |
-  | browser   | web_core |       | [*urls]                      | Opens urls in a browser                                                     |
-  +-----------+----------+-------+------------------------------+-----------------------------------------------------------------------------+
-  3 rows in set
-
-== Commandline Example
-
-   # Just like in irb
-    bash> boson libraries
-    +----------+----------+------+--------------+
-    | name     | commands | gems | library_type |
-    +----------+----------+------+--------------+
-    | core     | 6        |      | module       |
-    | web_core | 3        |      | module       |
-    +----------+----------+------+--------------+
-    2 rows in set
-
-    # Let's install another library
-    bash> boson install https://github.com/cldwalker/irbfiles/raw/master/boson/commands/public/irb_core.rb
-    Saved to /Users/bozo/.boson/commands/irb_core.rb
-
-    # Let's start irb ...
-    bash> irb
-
-    >> commands
-    +-------------------------------+----------+------------+--------------------------------------------+-----------------------------------------------------------------------------+
-    | full_name                     | lib      | alias      | usage                                      | description                                                                 |
-    +-------------------------------+----------+------------+--------------------------------------------+-----------------------------------------------------------------------------+
-    | usage                         | core     |            | [name][--verbose]                          | Print a command's usage                                                     |
-    | libraries                     | core     |            | [query=''][--index] [--query_fields=name]  | List or search libraries                                                    |
-    | render                        | core     |            | [object] [options={}]                      | Render any object using Hirb                                                |
-    | load_library                  | core     |            | [library][--verbose] [--reload]            | Load/reload a library                                                       |
-    | commands                      | core     |            | [query=''][--index] [--query_fields=A,B,C] | List or search commands                                                     |
-    | menu                          | core     |            | [output] [options={}] [&block]             | Provide a menu to multi-select elements from a given array                  |
-    | get                           | web_core |            | [url]                                      | Gets the body of a url                                                      |
-    | install                       | web_core |            | [url][--force] [--name=NAME]               | Installs a library by url. Library should then be loaded with load_library. |
-    | browser                       | web_core |            | [*urls]                                    | Opens urls in a browser                                                     |
-    | irb_pop_workspace             | irb_core | popws      |                                            | Pops current workspace and changes to next workspace in context             |
-    | irb_require                   | irb_core |            |                                            | Evals file like require line by line                                        |
-    | public                        | irb_core |            |                                            | Works same as module#public                                                 |
-    | private                       | irb_core |            |                                            | Works same as module#private                                                |
-    | irb                           | irb_core |            |                                            | Starts a new workspace/subsession                                           |
-    | irb_push_workspace            | irb_core | pushws     |                                            | Creates a workspace for given object and pushes it into the current context |
-    | irb_load                      | irb_core |            |                                            | Evals file like load line by line                                           |
-    | irb_change_workspace          | irb_core | cws        |                                            | Changes current workspace to given object                                   |
-    | irb_source                    | irb_core | source     |                                            | Evals full path file line by line                                           |
-    | irb_jobs                      | irb_core | jobs       |                                            | List workspaces/subsessions                                                 |
-    | irb_fg                        | irb_core | fg         |                                            | Switch to a workspace/subsession                                            |
-    | irb_help                      | irb_core | help       |                                            | Ri based help                                                               |
-    | irb_kill                      | irb_core | kill       |                                            | Kills a given workspace/subsession                                          |
-    | include                       | irb_core |            |                                            | Works same as module#include                                                |
-    | irb_exit                      | irb_core | exit       |                                            | Kills the current workspace/subsession                                      |
-    | irb_workspaces                | irb_core | workspaces |                                            | Array of workspaces for current context                                     |
-    | irb_context                   | irb_core | conf       |                                            | Displays configuration for current workspace/subsession                     |
-    | install_alias_method          | irb_core |            |                                            | Aliases given method, allows lazy loading of dependent file                 |
-    | irb_current_working_workspace | irb_core | cwws       |                                            | Prints current workspace                                                    |
-    +-------------------------------+----------+------------+--------------------------------------------+-----------------------------------------------------------------------------+
-    28 rows in set
-
-    # Sweet! Now we have a list and description of commands that come with irb.
-
-== Todo
-* More tests
-* Making commands out of existing gems easier and more powerful
-* Features based on commands and their argument types i.e. completing and piping
-* Consider dropping alias gem dependency if not using its full potential
-
-== Bugs/Issues
-Please report them {on github}[http://github.com/cldwalker/boson/issues].
-
-== Contributing
-{See here}[http://tagaholic.me/contributing.html]
-
-== Motivation
-My {tagging obsession}[http://github.com/cldwalker/tag-tree] from the ruby console.
-
-== Links
-* http://tagaholic.me/2009/10/14/boson-command-your-ruby-universe.html
-* http://tagaholic.me/2009/10/15/boson-and-hirb-interactions.html
-* http://tagaholic.me/2009/10/19/how-boson-enhances-your-irb-experience.html
-
-== Credits
-Boson stands on the shoulders of these people and their ideas:
-* Yehuda Katz for inspiring me with Thor and its awesome option parser (Boson::OptionParser).
-* Daniel Berger for his original work on thor's awesome option parser.
-* Dave Thomas for scraping a method's comments (Boson::CommentInspector)
-* Mauricio Fernandez for scraping a method's arguments (Boson::ArgumentInspector)
-* Chris Wanstrath for inspiring Boson's libraries with Rip's packages.
-* And its contributors: @mirell, @martinos