thor_dleavitt 0.18.1

data/spec/register_spec.rb

@@ -0,0 +1,197 @@
+require 'helper'
+
+class BoringVendorProvidedCLI < Thor
+  desc "boring", "do boring stuff"
+  def boring
+    puts "bored. <yawn>"
+  end
+end
+
+class ExcitingPluginCLI < Thor
+  desc "hooray", "say hooray!"
+  def hooray
+    puts "hooray!"
+  end
+
+  desc "fireworks", "exciting fireworks!"
+  def fireworks
+    puts "kaboom!"
+  end
+end
+
+class SuperSecretPlugin < Thor
+  default_command :squirrel
+
+  desc "squirrel", "All of secret squirrel's secrets"
+  def squirrel
+    puts "I love nuts"
+  end
+end
+
+class GroupPlugin < Thor::Group
+  desc "part one"
+  def part_one
+    puts "part one"
+  end
+
+  desc "part two"
+  def part_two
+    puts "part two"
+  end
+end
+
+class ClassOptionGroupPlugin < Thor::Group
+  class_option :who,
+    :type => :string,
+    :aliases => "-w",
+    :default => "zebra"
+end
+
+class CompatibleWith19Plugin < ClassOptionGroupPlugin
+  desc "animal"
+  def animal
+    p options[:who]
+  end
+end
+
+class PluginWithDefault < Thor
+  desc "say MSG", "print MSG"
+  def say(msg)
+    puts msg
+  end
+
+  default_command :say
+end
+
+class PluginWithDefaultMultipleArguments < Thor
+  desc "say MSG [MSG]", "print multiple messages"
+  def say(*args)
+    puts args
+  end
+
+  default_command :say
+end
+
+class PluginWithDefaultcommandAndDeclaredArgument < Thor
+  desc "say MSG [MSG]", "print multiple messages"
+  argument :msg
+  def say
+    puts msg
+  end
+
+  default_command :say
+end
+
+BoringVendorProvidedCLI.register(
+  ExcitingPluginCLI,
+  "exciting",
+  "do exciting things",
+  "Various non-boring actions")
+
+BoringVendorProvidedCLI.register(
+  SuperSecretPlugin,
+  "secret",
+  "secret stuff",
+  "Nothing to see here. Move along.",
+  :hide => true)
+
+BoringVendorProvidedCLI.register(
+  GroupPlugin,
+  'groupwork',
+  "Do a bunch of things in a row",
+  "purple monkey dishwasher")
+
+BoringVendorProvidedCLI.register(
+  CompatibleWith19Plugin,
+  'zoo',
+  "zoo [-w animal]",
+  "Shows a provided animal or just zebra")
+
+BoringVendorProvidedCLI.register(
+  PluginWithDefault,
+  'say',
+  'say message',
+  'subcommands ftw')
+
+BoringVendorProvidedCLI.register(
+  PluginWithDefaultMultipleArguments,
+  'say_multiple',
+  'say message',
+  'subcommands ftw')
+
+BoringVendorProvidedCLI.register(
+  PluginWithDefaultcommandAndDeclaredArgument,
+  'say_argument',
+  'say message',
+  'subcommands ftw')
+
+describe ".register-ing a Thor subclass" do
+  it "registers the plugin as a subcommand" do
+    fireworks_output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[exciting fireworks]) }
+    expect(fireworks_output).to eq("kaboom!\n")
+  end
+
+  it "includes the plugin's usage in the help" do
+    help_output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[help]) }
+    expect(help_output).to include('do exciting things')
+  end
+
+  it "invokes the default command correctly" do
+    output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[say hello]) }
+    expect(output).to include("hello")
+  end
+
+  it "invokes the default command correctly with multiple args" do
+    output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[say_multiple hello adam]) }
+    expect(output).to include("hello")
+    expect(output).to include("adam")
+  end
+
+  it "invokes the default command correctly with a declared argument" do
+    output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[say_argument hello]) }
+    expect(output).to include("hello")
+  end
+
+  context "when $thor_runner is false" do
+    it "includes the plugin's subcommand name in subcommand's help" do
+      begin
+        $thor_runner = false
+        help_output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[exciting]) }
+        expect(help_output).to include('thor exciting_plugin_c_l_i fireworks')
+      ensure
+        $thor_runner = true
+      end
+    end
+  end
+
+  context "when hidden" do
+    it "omits the hidden plugin's usage from the help" do
+      help_output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[help]) }
+      expect(help_output).not_to include('secret stuff')
+    end
+
+    it "registers the plugin as a subcommand" do
+      secret_output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[secret squirrel]) }
+      expect(secret_output).to eq("I love nuts\n")
+    end
+  end
+end
+
+describe ".register-ing a Thor::Group subclass" do
+  it "registers the group as a single command" do
+    group_output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[groupwork]) }
+    expect(group_output).to eq("part one\npart two\n")
+  end
+end
+
+describe "1.8 and 1.9 syntax compatibility" do
+  it "is compatible with both 1.8 and 1.9 syntax w/o command options" do
+    group_output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[zoo]) }
+    expect(group_output).to match(/zebra/)
+  end
+
+  it "is compatible with both 1.8 and 1.9 syntax w/command options" do
+    group_output = capture(:stdout) { BoringVendorProvidedCLI.start(%w[zoo -w lion]) }
+    expect(group_output).to match(/lion/)
+  end
+end

data/spec/runner_spec.rb

@@ -0,0 +1,241 @@
+require 'helper'
+require 'thor/runner'
+
+describe Thor::Runner do
+  def when_no_thorfiles_exist
+    old_dir = Dir.pwd
+    Dir.chdir '..'
+    delete = Thor::Base.subclasses.select {|e| e.namespace == 'default' }
+    delete.each {|e| Thor::Base.subclasses.delete e }
+    yield
+    Thor::Base.subclasses.concat delete
+    Dir.chdir old_dir
+  end
+
+  describe "#help" do
+    it "shows information about Thor::Runner itself" do
+      expect(capture(:stdout) { Thor::Runner.start(["help"]) }).to match(/List the available thor commands/)
+    end
+
+    it "shows information about a specific Thor::Runner command" do
+      content = capture(:stdout) { Thor::Runner.start(["help", "list"]) }
+      expect(content).to match(/List the available thor commands/)
+      expect(content).not_to match(/help \[COMMAND\]/)
+    end
+
+    it "shows information about a specific Thor class" do
+      content = capture(:stdout) { Thor::Runner.start(["help", "my_script"]) }
+      expect(content).to match(/zoo\s+# zoo around/m)
+    end
+
+    it "shows information about a specific command from a specific Thor class" do
+      content = capture(:stdout) { Thor::Runner.start(["help", "my_script:zoo"]) }
+      expect(content).to match(/zoo around/)
+      expect(content).not_to match(/help \[COMMAND\]/)
+    end
+
+    it "shows information about a specific Thor group class" do
+      content = capture(:stdout) { Thor::Runner.start(["help", "my_counter"]) }
+      expect(content).to match(/my_counter N/)
+    end
+
+    it "raises error if a class/command cannot be found" do
+      content = capture(:stderr){ Thor::Runner.start(["help", "unknown"]) }
+      expect(content.strip).to eq('Could not find command "unknown" in "default" namespace.')
+    end
+
+    it "raises error if a class/command cannot be found for a setup without thorfiles" do
+      when_no_thorfiles_exist do
+        expect(Thor::Runner).to receive :exit
+        content = capture(:stderr){ Thor::Runner.start(["help", "unknown"]) }
+        expect(content.strip).to eq('Could not find command "unknown".')
+      end
+    end
+  end
+
+  describe "#start" do
+    it "invokes a command from Thor::Runner" do
+      ARGV.replace ["list"]
+      expect(capture(:stdout) { Thor::Runner.start }).to match(/my_counter N/)
+    end
+
+    it "invokes a command from a specific Thor class" do
+      ARGV.replace ["my_script:zoo"]
+      expect(Thor::Runner.start).to be_true
+    end
+
+    it "invokes the default command from a specific Thor class if none is specified" do
+      ARGV.replace ["my_script"]
+      expect(Thor::Runner.start).to eq("default command")
+    end
+
+    it "forwards arguments to the invoked command" do
+      ARGV.replace ["my_script:animal", "horse"]
+      expect(Thor::Runner.start).to eq(["horse"])
+    end
+
+    it "invokes commands through shortcuts" do
+      ARGV.replace ["my_script", "-T", "horse"]
+      expect(Thor::Runner.start).to eq(["horse"])
+    end
+
+    it "invokes a Thor::Group" do
+      ARGV.replace ["my_counter", "1", "2", "--third", "3"]
+      expect(Thor::Runner.start).to eq([1, 2, 3, nil, nil, nil])
+    end
+
+    it "raises an error if class/command can't be found" do
+      ARGV.replace ["unknown"]
+      content = capture(:stderr){ Thor::Runner.start }
+      expect(content.strip).to eq('Could not find command "unknown" in "default" namespace.')
+    end
+
+    it "raises an error if class/command can't be found in a setup without thorfiles" do
+      when_no_thorfiles_exist do
+        ARGV.replace ["unknown"]
+        expect(Thor::Runner).to receive :exit
+        content = capture(:stderr){ Thor::Runner.start }
+        expect(content.strip).to eq('Could not find command "unknown".')
+      end
+    end
+
+    it "does not swallow NoMethodErrors that occur inside the called method" do
+      ARGV.replace ["my_script:call_unexistent_method"]
+      expect{ Thor::Runner.start }.to raise_error(NoMethodError)
+    end
+
+    it "does not swallow Thor::Group InvocationError" do
+      ARGV.replace ["whiny_generator"]
+      expect{ Thor::Runner.start }.to raise_error(ArgumentError, /thor wrong_arity takes 1 argument, but it should not/)
+    end
+
+    it "does not swallow Thor InvocationError" do
+      ARGV.replace ["my_script:animal"]
+      content = capture(:stderr) { Thor::Runner.start }
+      expect(content.strip).to eq(%Q'ERROR: "thor animal" was called with no arguments\nUsage: "thor my_script:animal TYPE"')
+    end
+  end
+
+  describe "commands" do
+    before do
+      @location = "#{File.dirname(__FILE__)}/fixtures/command.thor"
+      @original_yaml = {
+        "random" => {
+          :location  => @location,
+          :filename  => "4a33b894ffce85d7b412fc1b36f88fe0",
+          :namespaces => ["amazing"]
+        }
+      }
+
+      root_file = File.join(Thor::Util.thor_root, "thor.yml")
+
+      # Stub load and save to avoid thor.yaml from being overwritten
+      allow(YAML).to receive(:load_file).and_return(@original_yaml)
+      allow(File).to receive(:exists?).with(root_file).and_return(true)
+      allow(File).to receive(:open).with(root_file, "w")
+    end
+
+    describe "list" do
+      it "gives a list of the available commands" do
+        ARGV.replace ["list"]
+        content = capture(:stdout) { Thor::Runner.start }
+        expect(content).to match(/amazing:describe NAME\s+# say that someone is amazing/m)
+      end
+
+      it "gives a list of the available Thor::Group classes" do
+        ARGV.replace ["list"]
+        expect(capture(:stdout) { Thor::Runner.start }).to match(/my_counter N/)
+      end
+
+      it "can filter a list of the available commands by --group" do
+        ARGV.replace ["list", "--group", "standard"]
+        expect(capture(:stdout) { Thor::Runner.start }).to match(/amazing:describe NAME/)
+        ARGV.replace []
+        expect(capture(:stdout) { Thor::Runner.start }).not_to match(/my_script:animal TYPE/)
+        ARGV.replace ["list", "--group", "script"]
+        expect(capture(:stdout) { Thor::Runner.start }).to match(/my_script:animal TYPE/)
+      end
+
+      it "can skip all filters to show all commands using --all" do
+        ARGV.replace ["list", "--all"]
+        content = capture(:stdout) { Thor::Runner.start }
+        expect(content).to match(/amazing:describe NAME/)
+        expect(content).to match(/my_script:animal TYPE/)
+      end
+
+      it "doesn't list superclass commands in the subclass" do
+        ARGV.replace ["list"]
+        expect(capture(:stdout) { Thor::Runner.start }).not_to match(/amazing:help/)
+      end
+
+      it "presents commands in the default namespace with an empty namespace" do
+        ARGV.replace ["list"]
+        expect(capture(:stdout) { Thor::Runner.start }).to match(/^thor :cow\s+# prints 'moo'/m)
+      end
+
+      it "runs commands with an empty namespace from the default namespace" do
+        ARGV.replace [":command_conflict"]
+        expect(capture(:stdout) { Thor::Runner.start }).to eq("command\n")
+      end
+
+      it "runs groups even when there is a command with the same name" do
+        ARGV.replace ["command_conflict"]
+        expect(capture(:stdout) { Thor::Runner.start }).to eq("group\n")
+      end
+
+      it "runs commands with no colon in the default namespace" do
+        ARGV.replace ["cow"]
+        expect(capture(:stdout) { Thor::Runner.start }).to eq("moo\n")
+      end
+    end
+
+    describe "uninstall" do
+      before do
+        path = File.join(Thor::Util.thor_root, @original_yaml["random"][:filename])
+        expect(FileUtils).to receive(:rm_rf).with(path)
+      end
+
+      it "uninstalls existing thor modules" do
+        silence(:stdout) { Thor::Runner.start(["uninstall", "random"]) }
+      end
+    end
+
+    describe "installed" do
+      before do
+        expect(Dir).to receive(:[]).and_return([])
+      end
+
+      it "displays the modules installed in a pretty way" do
+        stdout = capture(:stdout) { Thor::Runner.start(["installed"]) }
+        expect(stdout).to match(/random\s*amazing/)
+        expect(stdout).to match(/amazing:describe NAME\s+# say that someone is amazing/m)
+      end
+    end
+
+    describe "install/update" do
+      before do
+        allow(FileUtils).to receive(:mkdir_p)
+        allow(FileUtils).to receive(:touch)
+        allow($stdin).to receive(:gets).and_return("Y")
+
+        path = File.join(Thor::Util.thor_root, Digest::MD5.hexdigest(@location + "random"))
+        expect(File).to receive(:open).with(path, "w")
+      end
+
+      it "updates existing thor files" do
+        path = File.join(Thor::Util.thor_root, @original_yaml["random"][:filename])
+        if File.directory? path
+          expect(FileUtils).to receive(:rm_rf).with(path)
+        else
+          expect(File).to receive(:delete).with(path)
+        end
+        silence(:stdout) { Thor::Runner.start(["update", "random"]) }
+      end
+
+      it "installs thor files" do
+        ARGV.replace ["install", @location]
+        silence(:stdout) { Thor::Runner.start }
+      end
+    end
+  end
+end

data/spec/shell/basic_spec.rb

@@ -0,0 +1,330 @@
+# coding: UTF-8
+require 'helper'
+
+describe Thor::Shell::Basic do
+  def shell
+    @shell ||= Thor::Shell::Basic.new
+  end
+
+  describe "#padding" do
+    it "cannot be set to below zero" do
+      shell.padding = 10
+      expect(shell.padding).to eq(10)
+
+      shell.padding = -1
+      expect(shell.padding).to eq(0)
+    end
+  end
+
+  describe "#ask" do
+    it "prints a message to the user and gets the response" do
+      expect($stdout).to receive(:print).with("Should I overwrite it? ")
+      expect($stdin).to receive(:gets).and_return('Sure')
+      expect($stdin).to_not receive(:noecho)
+      expect(shell.ask("Should I overwrite it?")).to eq("Sure")
+    end
+
+    it "prints a message and returns nil if EOF is sent to stdin" do
+      expect($stdout).to receive(:print).with(" ")
+      expect($stdin).to receive(:gets).and_return(nil)
+      expect(shell.ask("")).to eq(nil)
+    end
+
+    it "prints a message to the user and does not echo stdin if the echo option is set to false" do
+      expect($stdout).to receive(:print).with('What\'s your password? ')
+      expect($stdin).to receive(:noecho).and_return('mysecretpass')
+      expect(shell.ask("What's your password?", :echo => false)).to eq("mysecretpass")
+    end
+
+    it "prints a message to the user with the available options and determines the correctness of the answer" do
+      expect($stdout).to receive(:print).with('What\'s your favorite Neopolitan flavor? [strawberry, chocolate, vanilla] ')
+      expect($stdin).to receive(:gets).and_return('chocolate')
+      expect(shell.ask("What's your favorite Neopolitan flavor?", :limited_to => ["strawberry", "chocolate", "vanilla"])).to eq("chocolate")
+    end
+
+    it "prints a message to the user with the available options and reasks the question after an incorrect repsonse" do
+      expect($stdout).to receive(:print).with('What\'s your favorite Neopolitan flavor? [strawberry, chocolate, vanilla] ').twice
+      expect($stdout).to receive(:print).with("Your response must be one of: [strawberry, chocolate, vanilla]. Please try again.\n")
+      expect($stdin).to receive(:gets).and_return('moose tracks', 'chocolate')
+      expect(shell.ask("What's your favorite Neopolitan flavor?", :limited_to => ["strawberry", "chocolate", "vanilla"])).to eq("chocolate")
+    end
+
+    it "prints a message to the user containing a default and sets the default if only enter is pressed" do
+      expect($stdout).to receive(:print).with('What\'s your favorite Neopolitan flavor? (vanilla) ')
+      expect($stdin).to receive(:gets).and_return('')
+      expect(shell.ask("What's your favorite Neopolitan flavor?", :default => "vanilla")).to eq("vanilla")
+    end
+
+    it "prints a message to the user with the available options and reasks the question after an incorrect repsonse and then returns the default" do
+      expect($stdout).to receive(:print).with('What\'s your favorite Neopolitan flavor? [strawberry, chocolate, vanilla] (vanilla) ').twice
+      expect($stdout).to receive(:print).with("Your response must be one of: [strawberry, chocolate, vanilla]. Please try again.\n")
+      expect($stdin).to receive(:gets).and_return('moose tracks', '')
+      expect(shell.ask("What's your favorite Neopolitan flavor?", :default => "vanilla", :limited_to => ["strawberry", "chocolate", "vanilla"])).to eq("vanilla")
+    end
+  end
+
+  describe "#yes?" do
+    it "asks the user and returns true if the user replies yes" do
+      expect($stdout).to receive(:print).with("Should I overwrite it? ")
+        expect($stdin).to receive(:gets).and_return('y')
+      expect(shell.yes?("Should I overwrite it?")).to be_true
+
+      expect($stdout).to receive(:print).with("Should I overwrite it? ")
+        expect($stdin).to receive(:gets).and_return('n')
+      expect(shell.yes?("Should I overwrite it?")).not_to be_true
+    end
+  end
+
+  describe "#no?" do
+    it "asks the user and returns true if the user replies no" do
+      expect($stdout).to receive(:print).with("Should I overwrite it? ")
+        expect($stdin).to receive(:gets).and_return('n')
+      expect(shell.no?("Should I overwrite it?")).to be_true
+
+      expect($stdout).to receive(:print).with("Should I overwrite it? ")
+        expect($stdin).to receive(:gets).and_return('Yes')
+      expect(shell.no?("Should I overwrite it?")).to be_false
+    end
+  end
+
+  describe "#say" do
+    it "prints a message to the user" do
+      expect($stdout).to receive(:print).with("Running...\n")
+      shell.say("Running...")
+    end
+
+    it "prints a message to the user without new line if it ends with a whitespace" do
+      expect($stdout).to receive(:print).with("Running... ")
+      shell.say("Running... ")
+    end
+
+    it "does not use a new line with whitespace+newline embedded" do
+      expect($stdout).to receive(:print).with("It's \nRunning...\n")
+      shell.say("It's \nRunning...")
+    end
+
+    it "prints a message to the user without new line" do
+      expect($stdout).to receive(:print).with("Running...")
+      shell.say("Running...", nil, false)
+    end
+  end
+
+  describe "#say_status" do
+    it "prints a message to the user with status" do
+      expect($stdout).to receive(:print).with("      create  ~/.thor/command.thor\n")
+      shell.say_status(:create, "~/.thor/command.thor")
+    end
+
+    it "always uses new line" do
+      expect($stdout).to receive(:print).with("      create  \n")
+      shell.say_status(:create, "")
+    end
+
+    it "does not print a message if base is muted" do
+      expect(shell).to receive(:mute?).and_return(true)
+      expect($stdout).not_to receive(:print)
+
+      shell.mute do
+        shell.say_status(:created, "~/.thor/command.thor")
+      end
+    end
+
+    it "does not print a message if base is set to quiet" do
+      base = MyCounter.new [1,2]
+      expect(base).to receive(:options).and_return(:quiet => true)
+
+      expect($stdout).not_to receive(:print)
+      shell.base = base
+      shell.say_status(:created, "~/.thor/command.thor")
+    end
+
+    it "does not print a message if log status is set to false" do
+      expect($stdout).not_to receive(:print)
+      shell.say_status(:created, "~/.thor/command.thor", false)
+    end
+
+    it "uses padding to set message's left margin" do
+      shell.padding = 2
+      expect($stdout).to receive(:print).with("      create      ~/.thor/command.thor\n")
+      shell.say_status(:create, "~/.thor/command.thor")
+    end
+  end
+
+  describe "#print_in_columns" do
+    before do
+      @array = [1234567890]
+      @array += ('a'..'e').to_a
+    end
+
+    it "prints in columns" do
+      content = capture(:stdout) { shell.print_in_columns(@array) }
+      expect(content.rstrip).to eq("1234567890  a           b           c           d           e")
+    end
+  end
+
+  describe "#print_table" do
+    before do
+      @table = []
+      @table << ["abc", "#123", "first three"]
+      @table << ["", "#0", "empty"]
+      @table << ["xyz", "#786", "last three"]
+    end
+
+    it "prints a table" do
+      content = capture(:stdout) { shell.print_table(@table) }
+      expect(content).to eq(<<-TABLE)
+abc  #123  first three
+     #0    empty
+xyz  #786  last three
+TABLE
+    end
+
+    it "prints a table with indentation" do
+      content = capture(:stdout) { shell.print_table(@table, :indent => 2) }
+      expect(content).to eq(<<-TABLE)
+  abc  #123  first three
+       #0    empty
+  xyz  #786  last three
+TABLE
+    end
+
+    it "uses maximum terminal width" do
+      @table << ["def", "#456", "Lançam foo bar"]
+      @table << ["ghi", "#789", "بالله  عليكم"]
+      expect(shell).to receive(:terminal_width).and_return(20)
+      content = capture(:stdout) { shell.print_table(@table, :indent => 2, :truncate => true) }
+      expect(content).to eq(<<-TABLE)
+  abc  #123  firs...
+       #0    empty
+  xyz  #786  last...
+  def  #456  Lanç...
+  ghi  #789  بالل...
+TABLE
+    end
+
+    it "honors the colwidth option" do
+      content = capture(:stdout) { shell.print_table(@table, :colwidth => 10)}
+      expect(content).to eq(<<-TABLE)
+abc         #123  first three
+            #0    empty
+xyz         #786  last three
+TABLE
+    end
+
+    it "prints tables with implicit columns" do
+      2.times { @table.first.pop }
+      content = capture(:stdout) { shell.print_table(@table) }
+      expect(content).to eq(<<-TABLE)
+abc  
+     #0    empty
+xyz  #786  last three
+TABLE
+    end
+
+    it "prints a table with small numbers and right-aligns them" do
+      table = [
+        ["Name", "Number", "Color"],
+        ["Erik", 1, "green"]
+      ]
+      content = capture(:stdout) { shell.print_table(table) }
+      expect(content).to eq(<<-TABLE)
+Name  Number  Color
+Erik       1  green
+TABLE
+    end
+
+    it "doesn't output extra spaces for right-aligned columns in the last column" do
+      table = [
+        ["Name", "Number"],
+        ["Erik", 1]
+      ]
+      content = capture(:stdout) { shell.print_table(table) }
+      expect(content).to eq(<<-TABLE)
+Name  Number
+Erik       1
+TABLE
+    end
+
+    it "prints a table with big numbers" do
+      table = [
+        ["Name", "Number", "Color"],
+        ["Erik", 1234567890123, "green"]
+      ]
+      content = capture(:stdout) { shell.print_table(table) }
+      expect(content).to eq(<<-TABLE)
+Name  Number         Color
+Erik  1234567890123  green
+TABLE
+    end
+  end
+
+  describe "#file_collision" do
+    it "shows a menu with options" do
+      expect($stdout).to receive(:print).with('Overwrite foo? (enter "h" for help) [Ynaqh] ')
+      expect($stdin).to receive(:gets).and_return('n')
+      shell.file_collision('foo')
+    end
+
+    it "returns true if the user chooses default option" do
+      allow($stdout).to receive(:print)
+      expect($stdin).to receive(:gets).and_return('')
+      expect(shell.file_collision('foo')).to be_true
+    end
+
+    it "returns false if the user chooses no" do
+      allow($stdout).to receive(:print)
+      expect($stdin).to receive(:gets).and_return('n')
+      expect(shell.file_collision('foo')).to be_false
+    end
+
+    it "returns true if the user chooses yes" do
+      allow($stdout).to receive(:print)
+      expect($stdin).to receive(:gets).and_return('y')
+      expect(shell.file_collision('foo')).to be_true
+    end
+
+    it "shows help usage if the user chooses help" do
+      allow($stdout).to receive(:print)
+      expect($stdin).to receive(:gets).and_return('h')
+      expect($stdin).to receive(:gets).and_return('n')
+      help = capture(:stdout) { shell.file_collision('foo') }
+      expect(help).to match(/h \- help, show this help/)
+    end
+
+    it "quits if the user chooses quit" do
+      allow($stdout).to receive(:print)
+      expect($stdout).to receive(:print).with("Aborting...\n")
+      expect($stdin).to receive(:gets).and_return('q')
+
+      expect {
+        shell.file_collision('foo')
+      }.to raise_error(SystemExit)
+    end
+
+    it "always returns true if the user chooses always" do
+      expect($stdout).to receive(:print).with('Overwrite foo? (enter "h" for help) [Ynaqh] ')
+      expect($stdin).to receive(:gets).and_return('a')
+
+      expect(shell.file_collision('foo')).to be_true
+
+      expect($stdout).not_to receive(:print)
+      expect(shell.file_collision('foo')).to be_true
+    end
+
+    describe "when a block is given" do
+      it "displays diff options to the user" do
+        expect($stdout).to receive(:print).with('Overwrite foo? (enter "h" for help) [Ynaqdh] ')
+        expect($stdin).to receive(:gets).and_return('s')
+        shell.file_collision('foo'){ }
+      end
+
+      it "invokes the diff command" do
+        allow($stdout).to receive(:print)
+        expect($stdin).to receive(:gets).and_return('d')
+        expect($stdin).to receive(:gets).and_return('n')
+        expect(shell).to receive(:system).with(/diff -u/)
+        capture(:stdout) { shell.file_collision('foo'){ } }
+      end
+    end
+  end
+end