acquia_toolbelt 2.3.0 → 2.3.1

data/lib/vendor/thor/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

data/lib/vendor/thor/spec/shell/color_spec.rb

@@ -0,0 +1,95 @@
+require 'helper'
+
+describe Thor::Shell::Color do
+  def shell
+    @shell ||= Thor::Shell::Color.new
+  end
+
+  before do
+    allow_any_instance_of(StringIO).to receive(:tty?).and_return(true)
+  end
+
+  describe "#say" do
+    it "set the color if specified and tty?" do
+      out = capture(:stdout) do
+        shell.say "Wow! Now we have colors!", :green
+      end
+
+      expect(out.chomp).to eq("\e[32mWow! Now we have colors!\e[0m")
+    end
+
+    it "does not set the color if output is not a tty" do
+      out = capture(:stdout) do
+        expect($stdout).to receive(:tty?).and_return(false)
+        shell.say "Wow! Now we have colors!", :green
+      end
+
+      expect(out.chomp).to eq("Wow! Now we have colors!")
+    end
+
+    it "does not use a new line even with colors" do
+      out = capture(:stdout) do
+        shell.say "Wow! Now we have colors! ", :green
+      end
+
+      expect(out.chomp).to eq("\e[32mWow! Now we have colors! \e[0m")
+    end
+
+    it "handles an Array of colors" do
+      out = capture(:stdout) do
+        shell.say "Wow! Now we have colors *and* background colors", [:green, :on_red, :bold]
+      end
+
+      expect(out.chomp).to eq("\e[32m\e[41m\e[1mWow! Now we have colors *and* background colors\e[0m")
+    end
+  end
+
+  describe "#say_status" do
+    it "uses color to say status" do
+      out = capture(:stdout) do
+        shell.say_status :conflict, "README", :red
+      end
+
+      expect(out.chomp).to eq("\e[1m\e[31m    conflict\e[0m  README")
+    end
+  end
+
+  describe "#set_color" do
+    it "colors a string with a foreground color" do
+      red = shell.set_color "hi!", :red
+      expect(red).to eq("\e[31mhi!\e[0m")
+    end
+
+    it "colors a string with a background color" do
+      on_red = shell.set_color "hi!", :white, :on_red
+      expect(on_red).to eq("\e[37m\e[41mhi!\e[0m")
+    end
+
+    it "colors a string with a bold color" do
+      bold = shell.set_color "hi!", :white, true
+      expect(bold).to eq("\e[1m\e[37mhi!\e[0m")
+
+      bold = shell.set_color "hi!", :white, :bold
+      expect(bold).to eq("\e[37m\e[1mhi!\e[0m")
+
+      bold = shell.set_color "hi!", :white, :on_red, :bold
+      expect(bold).to eq("\e[37m\e[41m\e[1mhi!\e[0m")
+    end
+  end
+
+  describe "#file_collision" do
+    describe "when a block is given" do
+      it "invokes the diff command" do
+        allow($stdout).to receive(:print)
+        allow($stdout).to receive(:tty?).and_return(true)
+        expect($stdin).to receive(:gets).and_return('d')
+        expect($stdin).to receive(:gets).and_return('n')
+
+        output = capture(:stdout) { shell.file_collision('spec/fixtures/doc/README'){ "README\nEND\n" } }
+        expect(output).to match(/\e\[31m\- __start__\e\[0m/)
+        expect(output).to match(/^  README/)
+        expect(output).to match(/\e\[32m\+ END\e\[0m/)
+      end
+    end
+  end
+end

data/lib/vendor/thor/spec/shell/html_spec.rb

@@ -0,0 +1,31 @@
+require 'helper'
+
+describe Thor::Shell::HTML do
+  def shell
+    @shell ||= Thor::Shell::HTML.new
+  end
+
+  describe "#say" do
+    it "sets the color if specified" do
+      out = capture(:stdout) { shell.say "Wow! Now we have colors!", :green }
+      expect(out.chomp).to eq('<span style="color: green;">Wow! Now we have colors!</span>')
+    end
+
+    it "sets bold if specified" do
+      out = capture(:stdout) { shell.say "Wow! Now we have colors *and* bold!", [:green, :bold] }
+      expect(out.chomp).to eq('<span style="color: green; font-weight: bold;">Wow! Now we have colors *and* bold!</span>')
+    end
+
+    it "does not use a new line even with colors" do
+      out = capture(:stdout) { shell.say "Wow! Now we have colors! ", :green }
+      expect(out.chomp).to eq('<span style="color: green;">Wow! Now we have colors! </span>')
+    end
+  end
+
+  describe "#say_status" do
+    it "uses color to say status" do
+      expect($stdout).to receive(:print).with("<span style=\"color: red; font-weight: bold;\">    conflict</span>  README\n")
+      shell.say_status :conflict, "README", :red
+    end
+  end
+end

data/lib/vendor/thor/spec/shell_spec.rb

@@ -0,0 +1,47 @@
+require 'helper'
+
+describe Thor::Shell do
+  def shell
+    @shell ||= Thor::Base.shell.new
+  end
+
+  describe "#initialize" do
+    it "sets shell value" do
+      base = MyCounter.new [1, 2], { }, :shell => shell
+      expect(base.shell).to eq(shell)
+    end
+
+    it "sets the base value on the shell if an accessor is available" do
+      base = MyCounter.new [1, 2], { }, :shell => shell
+      expect(shell.base).to eq(base)
+    end
+  end
+
+  describe "#shell" do
+    it "returns the shell in use" do
+      expect(MyCounter.new([1,2]).shell).to be_kind_of(Thor::Base.shell)
+    end
+
+    it "uses $THOR_SHELL" do
+      class Thor::Shell::TestShell < Thor::Shell::Basic; end
+
+      expect(Thor::Base.shell).to eq(shell.class)
+      ENV['THOR_SHELL'] = 'TestShell'
+      Thor::Base.shell = nil
+      expect(Thor::Base.shell).to eq(Thor::Shell::TestShell)
+      ENV['THOR_SHELL'] = ''
+      Thor::Base.shell = shell.class
+      expect(Thor::Base.shell).to eq(shell.class)
+    end
+  end
+
+  describe "with_padding" do
+    it "uses padding for inside block outputs" do
+      base = MyCounter.new([1,2])
+      base.with_padding do
+        expect(capture(:stdout) { base.say_status :padding, "cool" }.strip).to eq("padding    cool")
+      end
+    end
+  end
+
+end

data/lib/vendor/thor/spec/subcommand_spec.rb

@@ -0,0 +1,30 @@
+require 'helper'
+
+describe Thor do
+
+  describe "#subcommand" do
+
+    it "maps a given subcommand to another Thor subclass" do
+      barn_help = capture(:stdout) { Scripts::MyDefaults.start(%w[barn]) }
+      expect(barn_help).to include("barn help [COMMAND]  # Describe subcommands or one specific subcommand")
+    end
+
+    it "passes commands to subcommand classes" do
+      expect(capture(:stdout) { Scripts::MyDefaults.start(%w[barn open]) }.strip).to eq("Open sesame!")
+    end
+
+    it "passes arguments to subcommand classes" do
+      expect(capture(:stdout) { Scripts::MyDefaults.start(%w[barn open shotgun]) }.strip).to eq("That's going to leave a mark.")
+    end
+
+    it "ignores unknown options (the subcommand class will handle them)" do
+      expect(capture(:stdout) { Scripts::MyDefaults.start(%w[barn paint blue --coats 4])}.strip).to eq("4 coats of blue paint")
+    end
+
+    it "passes parsed options to subcommands" do
+      output = capture(:stdout) { TestSubcommands::Parent.start(%w[sub print_opt --opt output]) }
+      expect(output).to eq("output")
+    end
+  end
+
+end