cli-forge 0.0.0 → 0.1.0

data/.gitignore

@@ -1,4 +1,5 @@
 coverage/
+pkg/
 tmp/
 .DS_Store
 Gemfile.lock

data/.travis.yml

@@ -1,5 +1,5 @@
 language: ruby
-bundler_args: --without debugging development
+bundler_args: --without debugging guard
 script: bundle exec rake spec:ci
 rvm:
   - 1.8.7
@@ -11,3 +11,7 @@ rvm:
   - jruby-18mode
   - jruby-19mode
   - ree
+  - topaz
+matrix:
+  allow_failures:
+    - rvm: topaz

data/Gemfile

@@ -13,7 +13,10 @@ group :test do
 
   # The preferred code mutation library.
   # MIT License - https://github.com/mbj/mutant/blob/master/LICENSE
-  gem "mutant", ">= 0.2.20", "< 1.0.0", :platforms => :ruby_19
+  gem "mutant", "~> 0.2", ">= 0.2.20", :platforms => :ruby_19
+
+  # Dependency of mutant; this version fixes some breaking source gen bugs.
+  gem "to_source", ">= 0.2.20"
 
   # Cover all the things - https://github.com/colszowka/simplecov
   # MIT License - https://github.com/colszowka/simplecov/blob/master/LICENSE
@@ -34,7 +37,7 @@ group :debugging do
   gem "debugger", "~> 1.3", :platforms => :mri
 end
 
-group :development do
+group :guard do
   # A generic file system event handler; spin it up and see the tests fly
   # MIT License - https://github.com/guard/guard/blob/master/LICENSE
   gem "guard", "~> 1.6"
@@ -51,11 +54,27 @@ group :development do
   # MIT License - https://github.com/guard/guard-rspec/blob/master/LICENSE
   gem "guard-rspec", "~> 2.4"
 
-  # Growl notification protocol gem - give us fancy warnings when things go awry
-  # MIT License - https://github.com/snaka/ruby_gntp/blob/master/lib/ruby_gntp.rb
-  gem "ruby_gntp", "~> 0.3"
-
-  # FS event hooks for OS X
+  # File system event hooks for OS X
   # MIT License - https://github.com/thibaudgg/rb-fsevent/blob/master/LICENSE
-  gem "rb-fsevent", "~> 0.9", :require => RUBY_PLATFORM.include?("darwin") && "rb-fsevent"
+  gem "rb-fsevent", "~> 0.9"
+
+  # File system event hooks for Linux
+  # MIT License - https://github.com/nex3/rb-inotify/blob/master/MIT-LICENSE
+  gem "rb-inotify", "~> 0.9"
+
+  # File system event hooks for Windows
+  # MIT License - https://github.com/stereobooster/rb-fchange/blob/master/LICENSE.md
+  gem "rb-fchange", "~> 0.0"
+
+  # OS X 10.8+ notification center support
+  # MIT License - https://github.com/Springest/terminal-notifier-guard#license
+  gem "terminal-notifier-guard", "~> 1.5"
+
+  # libnotify bindings (Linux)
+  # MIT License - https://github.com/splattael/libnotify/blob/master/LICENSE
+  gem "libnotify", "~> 0.8"
+
+  # notifu adapter (Windows)
+  # Unknown License
+  gem "rb-notifu", "~> 0.0"
 end

data/Guardfile

@@ -3,8 +3,6 @@ GLOBAL_SPEC_FILES = [
   ".rspec",
   %r{^spec/.*_helper\.rb$},
   %r{^spec/common/.*\.rb$},
-  "lib/cli_forge.rb",
-  "lib/cli_forge/autoload_convention.rb",
 ]
 
 def specs_for_path(path)
@@ -26,9 +24,9 @@ guard "spork", rspec_port: 2733 do
 end
 
 guard "rspec", cli: "--drb --drb-port 2733" do
-  GLOBAL_SPEC_FILES.each do |pattern|
-    watch(pattern) { "spec" }
-  end
+  watch("lib/cli_forge.rb") { "spec" }
+  watch("lib/cli_forge/autoload_convention.rb") { "spec" }
+  watch(%r{^spec/fixtures/.*\.rb$}) { "spec" }
 
   watch(%r{^spec/.+_spec\.rb$})
   watch(%r{^lib/(.+)\.rb$}) { |m| specs_for_path(m[1]) }

data/README.md

@@ -1,4 +1,4 @@
-CLI Forge [![Gem Version](https://badge.fury.io/rb/cli-forge.png)](https://rubygems.org/gems/cli-forge) [![Build Status](https://secure.travis-ci.org/nevir/cli-forge.png?branch=master)](http://travis-ci.org/nevir/cli-forge) [![Coverage Status](https://coveralls.io/repos/nevir/cli-forge/badge.png?branch=master)](https://coveralls.io/r/nevir/cli-forge) [![Code Climate](https://codeclimate.com/github/nevir/cli-forge.png)](https://codeclimate.com/github/nevir/cli-forge) [![Dependency Status](https://gemnasium.com/nevir/cli-forge.png)](https://gemnasium.com/nevir/cli-forge)
+CLI Forge [![Gem Version](https://badge.fury.io/rb/cli-forge.png)](https://rubygems.org/gems/cli-forge) [![Build Status](https://secure.travis-ci.org/nevir/cli-forge.png?branch=master)](http://travis-ci.org/nevir/cli-forge) [![Dependency Status](https://gemnasium.com/nevir/cli-forge.png)](https://gemnasium.com/nevir/cli-forge) [![Coverage Status](https://coveralls.io/repos/nevir/cli-forge/badge.png?branch=master)](https://coveralls.io/r/nevir/cli-forge) [![Code Climate](https://codeclimate.com/github/nevir/cli-forge.png)](https://codeclimate.com/github/nevir/cli-forge)
 =========
 
 Beat your CLI tool suites into submission!

data/Rakefile

@@ -1,12 +1,12 @@
 #!/usr/bin/env rake
 require "bundler/gem_tasks"
 
-PROJECT_PATH = File.expand_path("..", __FILE__)
-Dir["#{PROJECT_PATH}/tasks/**/*.rake"].each do |path|
+PROJECT_ROOT = File.expand_path("..", __FILE__)
+Dir["#{PROJECT_ROOT}/tasks/**/*.rake"].each do |path|
   load path
 end
 
-$LOAD_PATH.unshift File.join(PROJECT_PATH, "lib")
+$LOAD_PATH.unshift File.join(PROJECT_ROOT, "lib")
 
 
 desc "Run the full test suite"

data/cli-forge.gemspec

@@ -5,7 +5,7 @@ require File.expand_path("../lib/cli_forge/version", __FILE__)
 Gem::Specification.new do |gem|
   gem.name        = "cli-forge"
   gem.version     = CLIForge::VERSION
-  gem.homepage    = "http://github.com/nevir/cli-forge"
+  gem.homepage    = "https://github.com/nevir/cli-forge"
   gem.summary     = "Beat your CLI tool suites into submission!"
   gem.description = "A library for building CLI tools that are intended to be easily extensible (git style)"
   gem.author      = "Ian MacLeod"

data/lib/cli_forge.rb

@@ -2,4 +2,31 @@ require "cli_forge/autoload_convention"
 
 module CLIForge
   extend CLIForge::AutoloadConvention
+
+  def self.start(bin_name=nil, &block)
+    config = CLIForge::DefaultConfiguration.new
+
+    config.search_paths  = Array(caller_path(caller.first))
+    config.search_paths += ENV["PATH"].split(":")
+    config.search_paths.uniq!
+
+    block.call(config) if block
+
+    config.bin_name ||= bin_name || guess_bin_name
+
+    CLIForge::Runner.new(config).start(ARGV)
+  end
+
+  def self.guess_bin_name
+    File.basename($0)
+  end
+
+  def self.caller_path(stack_line)
+    return unless stack_line
+    stack_path = stack_line.split(":").first
+    return if stack_path =~ /^\(.*\)$/
+
+    File.expand_path(File.dirname(stack_path))
+  end
+
 end

data/lib/cli_forge/autoload_convention.rb

@@ -15,7 +15,10 @@ module CLIForge
     def const_missing(sym)
       full_sym   = "#{self.name}::#{sym}"
       path_parts = full_sym.split("::").map { |part|
-        part.gsub(/([^A-Z])([A-Z]+)/, "\\1_\\2").downcase
+        part.gsub! /([^A-Z])([A-Z]+)/,       "\\1_\\2" # OneTwo -> One_Two
+        part.gsub! /([A-Z]+)([A-Z][^A-Z]+)/, "\\1_\\2" # ABCOne -> ABC_One
+
+        part.downcase
       }
 
       require File.join(*path_parts)

data/lib/cli_forge/bin_command.rb

@@ -0,0 +1,17 @@
+class CLIForge::BinCommand
+
+  def initialize(path)
+    @path = path
+  end
+
+  attr_reader :path
+
+  def to_s
+    "#<#{self.class} #{path}>"
+  end
+
+  def call(arguments)
+    exec path, *arguments
+  end
+
+end

data/lib/cli_forge/command_set.rb

@@ -0,0 +1,38 @@
+class CLIForge::CommandSet
+
+  def initialize(config)
+    @config = config
+  end
+
+  def [](command_name)
+    if embedded_command = @config.embedded_commands[command_name.to_sym]
+      return embedded_command
+    end
+
+    target_bin = @config.bin_name + @config.bin_separator + command_name.to_s
+    commands   = find_bin_commands(target_bin)
+
+    # if commands.size > 1
+      # TODO: Warn
+    # end
+
+    commands.first
+  end
+
+private
+
+  def clean_search_paths
+    @config.search_paths.map { |path| File.expand_path(path) }.uniq
+  end
+
+  # Given a glob expression for the bin name, find any matching commands on the
+  # search paths.
+  def find_bin_commands(glob_expression)
+    clean_search_paths.reduce([]) { |paths, search_path|
+      paths + Dir["#{search_path}/#{glob_expression}"].map { |found_bin|
+        CLIForge::BinCommand.new(found_bin)
+      }
+    }
+  end
+
+end

data/lib/cli_forge/configuration.rb

@@ -0,0 +1,66 @@
+class CLIForge::Configuration
+
+  def initialize
+    @default_command = "help"
+    @bin_separator   = "-"
+
+    @search_paths      = []
+    @argument_filters  = {}
+    @embedded_commands = {}
+  end
+
+  # The name of the binary for this program; used to determine where to find
+  # sub-commands, help, etc.
+  attr_accessor :bin_name
+
+  # If no command is given, fall back to this.
+  attr_accessor :default_command
+
+  # Paths to search for sub command binaries.
+  attr_accessor :search_paths
+
+  # Separator to use when searching for subcommands.
+  attr_accessor :bin_separator
+
+
+  # Argument Filters
+  # ----------------
+  # Argument filters are named procs that are given the current command's
+  # arguments and have the opportunity to modify them.
+  #
+  # The return value of the proc is used as the new argument set.
+  def register_argument_filter(name, &block)
+    @argument_filters[name.to_sym] = block
+  end
+
+  # Remove a previously registered argument filter.
+  def remove_argument_filter(name)
+    @argument_filters.delete(name.to_sym)
+  end
+
+  # The active argument filters.
+  def argument_filters
+    @argument_filters.values
+  end
+
+
+  # Embedded Sub Commands
+  # ---------------------
+  # In addition to exposing sub commands via external bins, you can register
+  # specific commands directly:
+  def register_command(name, command_object)
+    @embedded_commands[name.to_sym] = command_object
+  end
+
+  # Remove a previosuly registered command.
+  #
+  # This _does not_ block an external bin by the same name from being run!
+  def remove_command(name)
+    @embedded_commands.delete(name.to_sym)
+  end
+
+  # The set of embedded commands.  Prefer using `register_command` and
+  # `remove_command`.
+  attr_reader :embedded_commands
+
+end

data/lib/cli_forge/default_configuration.rb

@@ -0,0 +1,27 @@
+class CLIForge::DefaultConfiguration < CLIForge::Configuration
+
+  def initialize
+    super
+
+    with_help_command
+    with_implicit_help_flags
+  end
+
+private
+
+  # Help is one of those global commands that pretty much everyone wants
+  def with_help_command
+    register_command :help, CLIForge::EmbeddedCommands::Help.new(self)
+  end
+
+  # Passing a help flag to any command results in us calling the help command.
+  def with_implicit_help_flags
+    register_argument_filter(:help_flags) { |arguments|
+      new_arguments = arguments - ["--help", "-h", "/?"]
+      new_arguments.unshift("help") if new_arguments.length != arguments.length
+
+      new_arguments
+    }
+  end
+
+end

data/lib/cli_forge/embedded_commands.rb

@@ -0,0 +1,3 @@
+module CLIForge::EmbeddedCommands
+  extend CLIForge::AutoloadConvention
+end

data/lib/cli_forge/embedded_commands/help.rb

@@ -0,0 +1,11 @@
+class CLIForge::EmbeddedCommands::Help
+
+  def initialize(config)
+    @config = config
+  end
+
+  def call(arguments)
+    puts "help and stuff"
+  end
+
+end

data/lib/cli_forge/runner.rb

@@ -0,0 +1,42 @@
+class CLIForge::Runner
+
+  def initialize(config)
+    @config = config
+  end
+
+  def start(arguments)
+    arguments    = filter_arguments(arguments.dup)
+    command_name = pop_command(arguments) || @config.default_command
+    command_set  = CLIForge::CommandSet.new(@config)
+
+    unless command = command_set[command_name]
+      # TODO: Output!
+      command = command_set[@config.default_command]
+    end
+
+    # TODO: Output!
+    return 1 unless command
+
+    command.call(arguments)
+  end
+
+private
+
+  def filter_arguments(arguments)
+    @config.argument_filters.each do |argument_filter|
+      arguments = argument_filter.call(arguments)
+    end
+
+    # TODO: Validate args
+
+    arguments
+  end
+
+  def pop_command(arguments)
+    index = arguments.find_index { |a| !a.start_with? "-" }
+    return unless index
+
+    arguments.delete_at(index)
+  end
+
+end

data/lib/cli_forge/version.rb

@@ -1,3 +1,3 @@
 module CLIForge
-  VERSION = "0.0.0"
+  VERSION = "0.1.0"
 end

data/spec/common/fixture_config.rb

@@ -0,0 +1,13 @@
+shared_context "fixture config" do
+
+  let(:config) {
+    CLIForge::Configuration.new.tap do |config|
+      config.bin_name = "foo"
+
+      config.search_paths << File.join(FIXTURE_ROOT, "bins")
+      config.search_paths << File.join(FIXTURE_ROOT, "bins2")
+      config.search_paths << File.join(FIXTURE_ROOT, "bins3")
+    end
+  }
+
+end

data/spec/fixtures/autoload_convention/abc_one_two_three.rb

@@ -0,0 +1,5 @@
+module Fixtures; end
+
+module Fixtures::AutoloadConvention
+  ABCOneTwoThree = :you_can_count!
+end

data/spec/spec_helper.rb

@@ -16,7 +16,8 @@ end
 
 Spork.prefork do
   # Allow requires relative to the spec dir
-  SPEC_ROOT = File.expand_path("..", __FILE__)
+  SPEC_ROOT    = File.expand_path("..", __FILE__)
+  FIXTURE_ROOT = File.join(SPEC_ROOT, "fixtures")
   $LOAD_PATH << SPEC_ROOT
 
   require "rspec"

data/spec/unit/cli_forge/autoload_convention/const_missing_spec.rb

@@ -40,6 +40,12 @@ describe CLIForge::AutoloadConvention, "#const_missing" do
     expect(namespace::ALLCAPS).to eq(:yelling)
   end
 
+  it "should split ACRONYMSEndingWithRegularNames" do
+    namespace.should_receive(:require).with("fixtures/autoload_convention/abc_one_two_three").and_call_original
+
+    expect(namespace::ABCOneTwoThree).to eq(:you_can_count!)
+  end
+
   it "shouldn't pick up constants in parent namespaces" do
     namespace.should_receive(:require).with("fixtures/autoload_convention/string").and_call_original
 

data/spec/unit/cli_forge/class_methods/caller_path_spec.rb

@@ -0,0 +1,38 @@
+describe CLIForge, ".caller_path" do
+
+  def spec_caller_line
+    caller.first
+  end
+
+  it "should extract the current platform's stack format" do
+    caller_line = spec_caller_line
+    path        = described_class.caller_path(caller_line)
+
+    expect(path).to eq(File.dirname(__FILE__)), "Extracted #{path.inspect} from #{caller_line.inspect}"
+  end
+
+  it "should extract paths from well formed MRI stack lines" do
+    path = described_class.caller_path("/usr/bin/foo:6:in `<main>'")
+
+    expect(path).to eq("/usr/bin")
+  end
+
+  it "should expand relative paths" do
+    path = described_class.caller_path("bin/bar:6:in `<main>'")
+
+    expect(path).to eq(File.expand_path("bin"))
+  end
+
+  it "should not freak out if given nil" do
+    path = described_class.caller_path(nil)
+
+    expect(path).to eq(nil)
+  end
+
+  it "should not expose fake paths as the current path" do
+    path = described_class.caller_path("(irb):3:in `irb_binding'")
+
+    expect(path).to eq(nil)
+  end
+
+end

data/spec/unit/cli_forge/class_methods/guess_bin_name_spec.rb

@@ -0,0 +1,17 @@
+describe CLIForge, ".guess_bin_name" do
+
+  it "should return the basename of $0" do
+    old_name = $0
+
+    begin
+      $0 = "/foo/bar/baz-biff"
+      expect(described_class.send(:guess_bin_name)).to eq("baz-biff")
+
+    ensure
+      $0 = old_name
+    end
+  end
+
+  it "should freak out if we don't have a reasonable $0"
+
+end

data/spec/unit/cli_forge/class_methods/start_spec.rb

@@ -0,0 +1,93 @@
+describe CLIForge, ".start" do
+
+  let(:mock_runner) {
+    double("CLIForge::Runner").tap do |runner|
+      runner.stub(:start)
+    end
+  }
+
+  before(:each) do
+    CLIForge::Runner.stub(:new) { |config|
+      @config = config
+      mock_runner
+    }
+  end
+
+  # Stub out our environment
+  around(:each) do |spec|
+    old_path, old_argv = ENV["PATH"], ARGV
+
+    begin
+      spec.run
+    ensure
+      ENV["PATH"] = old_path
+      Object.send(:remove_const, :ARGV)
+      ::ARGV = old_argv
+    end
+  end
+
+
+  it "should not require any arguments" do
+    mock_runner.should_receive(:start)
+    described_class.should_receive(:guess_bin_name)
+
+    described_class.start
+  end
+
+  it "should pass the configuration to the given block" do
+    mock_runner.should_receive(:start)
+    described_class.should_not_receive(:guess_bin_name)
+
+    described_class.start do |config|
+      config.bin_name = "foo-bar"
+    end
+
+    expect(@config.bin_name).to eq("foo-bar")
+  end
+
+  describe "special-cased configuration properties" do
+
+    it "should consume the passed name if given" do
+      mock_runner.should_receive(:start)
+      described_class.should_not_receive(:guess_bin_name)
+
+      described_class.start("awesomesauce")
+
+      expect(@config.bin_name).to eq("awesomesauce")
+    end
+
+    it "should extract the caller path" do
+      ENV["PATH"] = ""
+
+      described_class.start
+
+      expect(@config.search_paths).to eq([
+        File.dirname(__FILE__)
+      ])
+    end
+
+    it "should pull search paths in order from PATH" do
+      ENV["PATH"] = "/usr/bin:/usr/local/bin:/foo/bar:/usr/bin"
+      described_class.stub(:caller_path) { nil }
+
+      described_class.start
+
+      expect(@config.search_paths).to eq([
+        "/usr/bin",
+        "/usr/local/bin",
+        "/foo/bar"
+      ])
+    end
+
+    it "should extract ARGV" do
+      Object.send(:remove_const, :ARGV)
+      ::ARGV = ["my-bin", "sub-command", "--stuff"]
+
+      mock_runner.should_receive(:start).with(["my-bin", "sub-command", "--stuff"])
+
+      described_class.start
+    end
+
+  end
+
+end

data/spec/unit/cli_forge/command_set/element_reader_spec.rb

@@ -0,0 +1,55 @@
+describe CLIForge::CommandSet, "#[]" do
+  include_context "fixture config"
+
+  subject {
+    described_class.new(config)
+  }
+
+  it "should return nil if no command was found" do
+    expect(subject[:missing_command]).to eq(nil)
+  end
+
+  describe "bin commands" do
+
+    it "should return the first matching command on the search paths" do
+      command = subject[:bar]
+
+      expect(command).to be_a(CLIForge::BinCommand)
+      expect(command.path).to eq(File.join(FIXTURE_ROOT, "bins", "foo-bar"))
+    end
+
+    it "should search subsequent search paths" do
+      command = subject[:too]
+
+      expect(command).to be_a(CLIForge::BinCommand)
+      expect(command.path).to eq(File.join(FIXTURE_ROOT, "bins2", "foo-too"))
+    end
+
+    it "should accept strings" do
+      command = subject["bar"]
+
+      expect(command).to be_a(CLIForge::BinCommand)
+      expect(command.path).to eq(File.join(FIXTURE_ROOT, "bins", "foo-bar"))
+    end
+
+  end
+
+  describe "embedded commands" do
+
+    it "should return embedded commands" do
+      command = double("TestCommand")
+      config.register_command("my-command", command)
+
+      expect(subject["my-command"]).to be(command)
+    end
+
+    it "should prioritize embedded commands" do
+      command = double("ABetterBar")
+      config.register_command(:bar, command)
+
+      expect(subject[:bar]).to be(command)
+    end
+
+  end
+
+end

data/spec/unit/cli_forge/configuration/register_argument_filter_spec.rb

@@ -0,0 +1,26 @@
+describe CLIForge::Configuration, "#register_argument_filter" do
+
+  it "should register the filter" do
+    subject.register_argument_filter(:hi) { "hi" }
+
+    expect(subject.argument_filters.size).to eq(1)
+    expect(subject.argument_filters[0].call).to eq("hi")
+  end
+
+  it "should allow you to register over existing commands" do
+    subject.register_argument_filter(:hi) { "hi" }
+    subject.register_argument_filter(:hi) { "bye" }
+
+    expect(subject.argument_filters.size).to eq(1)
+    expect(subject.argument_filters[0].call).to eq("bye")
+  end
+
+  it "should coerce string names to symbols" do
+    subject.register_argument_filter("hi") { "hi" }
+    subject.register_argument_filter(:hi) { "bye" }
+
+    expect(subject.argument_filters.size).to eq(1)
+    expect(subject.argument_filters[0].call).to eq("bye")
+  end
+
+end

data/spec/unit/cli_forge/configuration/register_command_spec.rb

@@ -0,0 +1,26 @@
+describe CLIForge::Configuration, "#register_command" do
+
+  it "should register the command" do
+    command = double("TestCommand")
+    subject.register_command(:foo, command)
+
+    expect(subject.embedded_commands[:foo]).to be(command)
+  end
+
+  it "should coerce string names to symbols" do
+    command = double("TestCommand")
+    subject.register_command("foo", command)
+
+    expect(subject.embedded_commands[:foo]).to be(command)
+  end
+
+  it "should allow you to register over existing commands" do
+    command1 = double("TestCommand1")
+    command2 = double("TestCommand2")
+    subject.register_command(:foo, command1)
+    subject.register_command(:foo, command2)
+
+    expect(subject.embedded_commands[:foo]).to be(command2)
+  end
+
+end

data/spec/unit/cli_forge/configuration/remove_argument_filter_spec.rb

@@ -0,0 +1,29 @@
+describe CLIForge::Configuration, "#remove_argument_filter" do
+
+  it "should remove the argument filter" do
+    expect(subject.argument_filters).to eq([])
+
+    subject.register_argument_filter(:hi) { "hi" }
+    subject.remove_argument_filter(:hi)
+
+    expect(subject.argument_filters).to eq([])
+  end
+
+  it "should not freak out if the argument filter doesn't exist" do
+    expect(subject.argument_filters).to eq([])
+
+    subject.remove_argument_filter(:bar)
+
+    expect(subject.argument_filters).to eq([])
+  end
+
+  it "should coerce string names to symbols" do
+    expect(subject.argument_filters).to eq([])
+
+    subject.register_argument_filter(:hi) { "hi" }
+    subject.remove_argument_filter("hi")
+
+    expect(subject.argument_filters).to eq([])
+  end
+
+end

data/spec/unit/cli_forge/configuration/remove_command_spec.rb

@@ -0,0 +1,30 @@
+describe CLIForge::Configuration, "#remove_command" do
+
+  it "should remove the command" do
+    command = double("TestCommand")
+    subject.register_command(:foo, command)
+    subject.remove_command(:foo)
+
+    expect(subject.embedded_commands[:foo]).to eq(nil)
+  end
+
+  it "should not freak out if the command doesn't exist" do
+    expect(subject.embedded_commands[:bar]).to eq(nil)
+
+    subject.remove_command(:bar)
+
+    expect(subject.embedded_commands[:bar]).to eq(nil)
+  end
+
+  it "should coerce string names to symbols" do
+    expect(subject.embedded_commands[:bar]).to eq(nil)
+
+    command = double("TestCommand")
+    subject.register_command(:bar, command)
+    subject.remove_command("bar")
+
+    expect(subject.embedded_commands[:bar]).to eq(nil)
+    expect(subject.embedded_commands["bar"]).to eq(nil)
+  end
+
+end

data/spec/unit/cli_forge/runner/start_spec.rb

@@ -0,0 +1,28 @@
+describe CLIForge::Runner, "#start" do
+  include_context "fixture config"
+
+  subject {
+    described_class.new(config)
+  }
+
+  let(:default_command) {
+    double("DefaultCommand").tap do |command|
+      command.stub(:call) { "Called and stuff" }
+    end
+  }
+
+  describe "edge cases" do
+
+    it "should not modify the input arguments" do
+      config.register_command(:default, default_command)
+
+      arguments = ["default", "and", "stuff"]
+
+      subject.start(arguments)
+
+      expect(arguments).to eq(["default", "and", "stuff"])
+    end
+
+  end
+
+end

data/tasks/spec/coverage.rake

@@ -8,7 +8,7 @@ namespace :spec do
     Rake::Task["spec"].execute
 
     if RUBY_PLATFORM.include? "darwin"
-      `open #{File.join(PROJECT_PATH, "coverage", "index.html")}`
+      `open #{File.join(PROJECT_ROOT, "coverage", "index.html")}`
     end
 
     ENV["COVERAGE"] = prev

data/tasks/spec/mutate.rake

@@ -1,30 +1,21 @@
 namespace :spec do
 
-  def mutant_supported?
-    return false unless RUBY_VERSION.start_with?("1.9")
-
-    begin
-      return false unless RUBY_ENGINE == "ruby" || RUBY_ENGINE == "rbx"
-    rescue NameError
-      return false
-    end
-
-    true
-  end
-
   desc "Runs tests with code mutation"
   task :mutate, [:focus_on] do |t, args|
     next unless mutant_supported?
 
     require "cli_forge"
     require "mutant"
+    require "mutant/constants"
+    require "mutant/mutation/filter/regexp"
 
     # You can focus on a particular symbol/method by passing it to the task:
     # rake spec:mutate[AutoloadConvention#const_missing], for example.
     if args.focus_on
-      matcher = Mutant::Matcher.from_string("::CLIForge::#{args.focus_on}")
+      matcher = matcher_for_filter(args.focus_on)
+    # Otherwise we're doing a full mutation suite
     else
-      matcher = Mutant::Matcher::ObjectSpace.new(/\ACLIForge(::|#|\.).+\Z/)
+      matcher = all_matcher
     end
 
     # Mutant doesn't have a public scripting API yet; so we're cheating.
@@ -37,7 +28,7 @@ namespace :spec do
       :strategy => Mutant::Strategy::Rspec::DM2.new(config),
       :killer   => Mutant::Killer::Rspec,
       :matcher  => matcher,
-      :filter   => Mutant::Mutation::Filter::ALL,
+      :filter   => filter_for_specs,
       :reporter => Mutant::Reporter::CLI.new(config)
     )
 
@@ -47,4 +38,120 @@ namespace :spec do
     end
   end
 
+  def mutant_supported?
+    return false unless RUBY_VERSION.start_with?("1.9")
+    # TODO: Rubinius crashes under mutant:
+    # https://github.com/rubinius/rubinius/issues/2186
+    return false if RUBY_ENGINE == "rbx"
+
+    begin
+      return false unless RUBY_ENGINE == "ruby" || RUBY_ENGINE == "rbx"
+    rescue NameError
+      return false
+    end
+
+    true
+  end
+
+  # Also preloads the related constants
+  def matcher_for_filter(filter)
+    # Method on CLIForge?
+    if filter.start_with?(".") || filter.start_with?("#")
+      matcher = Mutant::Matcher.from_string("::CLIForge#{filter}")
+
+    # Or regular constant?
+    else
+      matcher = Mutant::Matcher.from_string("::CLIForge::#{filter}")
+      # Force that symbol to load
+      const = CLIForge
+      filter[/^[^#\.]+/].split("::").each do |const_name|
+        const = const.const_get(const_name.to_sym)
+      end
+    end
+
+    matcher
+  end
+
+  def all_matcher
+    # Force everything to load
+    Dir["#{PROJECT_ROOT}/lib/cli_forge/**/*.rb"].each do |path|
+      require path[/lib.(cli_forge..+)\.rb$/, 1]
+    end
+
+    unit_folders   = Dir["spec/unit/**/*/"].map { |f| f[/^spec.unit.(.+)./, 1] }
+    unit_constants = unit_folders.map do |folder|
+      folder.gsub(File::SEPARATOR, "::").gsub("_", "").downcase
+    end
+
+    Mutant::Matcher::ObjectSpace.new(/^CLIForge/)
+  end
+
+  def spec_filter_klass
+    # Avoid loading w/ rake
+    filter_klass = Class.new(Mutant::Mutation::Filter)
+    filter_klass.class_eval do
+      def initialize(regexp)
+        @regexp = regexp
+      end
+
+      def match?(mutation)
+        @regexp =~ mutation.subject.matcher.identification
+      end
+    end
+
+    filter_klass
+  end
+
+  def filter_for_specs
+    # Only run mutations for methods that we have specs for.  Basic code
+    # coverage can cover simple cases.
+    spec_symbols = Dir["#{PROJECT_ROOT}/spec/unit/**/*_spec.rb"].map { |path|
+      path_to_symbol(path[/spec.unit.(.+)_spec\.rb$/, 1])
+    }
+    safe_symbols = spec_symbols.map { |s| Regexp.escape(s) }
+
+    spec_filter_klass.new(/^(#{safe_symbols.join("|")})$/i)
+  end
+
+  # convert a spec path back to a (case insensitive) symbol
+  def path_to_symbol(spec_path)
+    parts  = spec_path.split(/[\/\\]/)
+    method = symbolicate_method_name(parts.pop)
+    if parts.last == "class_methods"
+      method = ".#{method}"
+      parts.pop
+    else
+      method = "##{method}"
+    end
+
+    parts.join("::").gsub("_", "") + method
+  end
+
+  # https://github.com/mbj/mutant/blob/master/lib/mutant/constants.rb
+  def postfix_expansions
+    # @postfix_expansions ||= Mutant::METHOD_POSTFIX_EXPANSIONS.invert
+    @postfix_expansions ||= {
+      '_predicate' => '?',
+      '_writer'    => '=',
+      '_bang'      => '!'
+    }
+  end
+
+  def operator_expansions
+    @operator_expansions ||= Mutant::OPERATOR_EXPANSIONS.invert
+  end
+
+  def symbolicate_method_name(method_name)
+    operator = operator_expansions[method_name.to_sym]
+    return operator.to_s if operator
+
+    postfix_expansions.each do |postfix, symbol|
+      if method_name.end_with? postfix
+        method_name = method_name[0...-postfix.size] + symbol.to_s
+      end
+    end
+
+    method_name
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cli-forge
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-02 00:00:00.000000000 Z
+date: 2013-03-07 00:00:00.000000000 Z
 dependencies: []
 description: A library for building CLI tools that are intended to be easily extensible
   (git style)
@@ -31,20 +31,42 @@ files:
 - lib/cli-forge.rb
 - lib/cli_forge.rb
 - lib/cli_forge/autoload_convention.rb
+- lib/cli_forge/bin_command.rb
+- lib/cli_forge/command_set.rb
+- lib/cli_forge/configuration.rb
+- lib/cli_forge/default_configuration.rb
+- lib/cli_forge/embedded_commands.rb
+- lib/cli_forge/embedded_commands/help.rb
+- lib/cli_forge/runner.rb
 - lib/cli_forge/version.rb
+- spec/common/fixture_config.rb
+- spec/fixtures/autoload_convention/abc_one_two_three.rb
 - spec/fixtures/autoload_convention/allcaps.rb
 - spec/fixtures/autoload_convention/mismatched.rb
 - spec/fixtures/autoload_convention/multi_token.rb
 - spec/fixtures/autoload_convention/single.rb
 - spec/fixtures/autoload_convention/string.rb
+- spec/fixtures/bins/foo-bar
+- spec/fixtures/bins2/foo-bar
+- spec/fixtures/bins2/foo-too
+- spec/fixtures/bins3/foo-bar
 - spec/spec_helper.rb
 - spec/unit/cli_forge/autoload_convention/const_missing_spec.rb
+- spec/unit/cli_forge/class_methods/caller_path_spec.rb
+- spec/unit/cli_forge/class_methods/guess_bin_name_spec.rb
+- spec/unit/cli_forge/class_methods/start_spec.rb
+- spec/unit/cli_forge/command_set/element_reader_spec.rb
+- spec/unit/cli_forge/configuration/register_argument_filter_spec.rb
+- spec/unit/cli_forge/configuration/register_command_spec.rb
+- spec/unit/cli_forge/configuration/remove_argument_filter_spec.rb
+- spec/unit/cli_forge/configuration/remove_command_spec.rb
+- spec/unit/cli_forge/runner/start_spec.rb
 - tasks/console.rake
 - tasks/spec.rake
 - tasks/spec/ci.rake
 - tasks/spec/coverage.rake
 - tasks/spec/mutate.rake
-homepage: http://github.com/nevir/cli-forge
+homepage: https://github.com/nevir/cli-forge
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -56,12 +78,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 850686175948221601
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 850686175948221601
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23