command_kit 0.2.2 → 0.4.0

data/spec/colors_spec.rb

@@ -65,6 +65,38 @@ describe CommandKit::Colors do
       it { expect(subject::WHITE).to eq("\e[37m") }
     end
 
+    describe "BRIGHT_BLACK" do
+      it { expect(subject::BRIGHT_BLACK).to eq("\e[90m") }
+    end
+
+    describe "BRIGHT_RED" do
+      it { expect(subject::BRIGHT_RED).to eq("\e[91m") }
+    end
+
+    describe "BRIGHT_GREEN" do
+      it { expect(subject::BRIGHT_GREEN).to eq("\e[92m") }
+    end
+
+    describe "BRIGHT_YELLOW" do
+      it { expect(subject::BRIGHT_YELLOW).to eq("\e[93m") }
+    end
+
+    describe "BRIGHT_BLUE" do
+      it { expect(subject::BRIGHT_BLUE).to eq("\e[94m") }
+    end
+
+    describe "BRIGHT_MAGENTA" do
+      it { expect(subject::BRIGHT_MAGENTA).to eq("\e[95m") }
+    end
+
+    describe "BRIGHT_CYAN" do
+      it { expect(subject::BRIGHT_CYAN).to eq("\e[96m") }
+    end
+
+    describe "BRIGHT_WHITE" do
+      it { expect(subject::BRIGHT_WHITE).to eq("\e[97m") }
+    end
+
     describe "ON_BLACK" do
       it { expect(subject::ON_BLACK).to eq("\e[40m") }
     end
@@ -97,6 +129,42 @@ describe CommandKit::Colors do
       it { expect(subject::ON_WHITE).to eq("\e[47m") }
     end
 
+    describe "ON_BRIGHT_BLACK" do
+      it { expect(subject::ON_BRIGHT_BLACK).to eq("\e[100m") }
+    end
+
+    describe "ON_BRIGHT_RED" do
+      it { expect(subject::ON_BRIGHT_RED).to eq("\e[101m") }
+    end
+
+    describe "ON_BRIGHT_GREEN" do
+      it { expect(subject::ON_BRIGHT_GREEN).to eq("\e[102m") }
+    end
+
+    describe "ON_BRIGHT_YELLOW" do
+      it { expect(subject::ON_BRIGHT_YELLOW).to eq("\e[103m") }
+    end
+
+    describe "ON_BRIGHT_BLUE" do
+      it { expect(subject::ON_BRIGHT_BLUE).to eq("\e[104m") }
+    end
+
+    describe "ON_BRIGHT_MAGENTA" do
+      it { expect(subject::ON_BRIGHT_MAGENTA).to eq("\e[105m") }
+    end
+
+    describe "ON_BRIGHT_CYAN" do
+      it { expect(subject::ON_BRIGHT_CYAN).to eq("\e[106m") }
+    end
+
+    describe "ON_BRIGHT_WHITE" do
+      it { expect(subject::ON_BRIGHT_WHITE).to eq("\e[107m") }
+    end
+
+    describe "RESET_FG" do
+      it { expect(subject::RESET_FG).to eq("\e[39m") }
+    end
+
     describe "RESET_COLOR" do
       it { expect(subject::RESET_COLOR).to eq("\e[39m") }
     end
@@ -219,401 +287,364 @@ describe CommandKit::Colors do
       end
     end
 
-    describe ".on_black" do
+    describe ".bright_black" do
       context "when given a string" do
-        it "must wrap the string with \\e[40m and \\e[39m" do
-          expect(subject.on_black(str)).to eq("\e[40m#{str}\e[49m")
+        it "must wrap the string with \\e[90m and \\e[39m" do
+          expect(subject.bright_black(str)).to eq("\e[90m#{str}\e[39m")
         end
       end
 
       context "when given no arguments" do
-        it { expect(subject.on_black).to eq("\e[40m") }
+        it { expect(subject.bright_black).to eq("\e[90m") }
       end
     end
 
-    describe ".on_red" do
+    describe ".gray" do
       context "when given a string" do
-        it "must wrap the string with \\e[41m and \\e[39m" do
-          expect(subject.on_red(str)).to eq("\e[41m#{str}\e[49m")
+        it "must wrap the string with \\e[90m and \\e[39m" do
+          expect(subject.gray(str)).to eq("\e[90m#{str}\e[39m")
         end
       end
 
       context "when given no arguments" do
-        it { expect(subject.on_red).to eq("\e[41m") }
+        it { expect(subject.gray).to eq("\e[90m") }
       end
     end
 
-    describe ".on_green" do
+    describe ".bright_red" do
       context "when given a string" do
-        it "must wrap the string with \\e[42m and \\e[39m" do
-          expect(subject.on_green(str)).to eq("\e[42m#{str}\e[49m")
+        it "must wrap the string with \\e[91m and \\e[39m" do
+          expect(subject.bright_red(str)).to eq("\e[91m#{str}\e[39m")
         end
       end
 
       context "when given no arguments" do
-        it { expect(subject.on_green).to eq("\e[42m") }
+        it { expect(subject.bright_red).to eq("\e[91m") }
       end
     end
 
-    describe ".on_yellow" do
+    describe ".bright_green" do
       context "when given a string" do
-        it "must wrap the string with \\e[43m and \\e[39m" do
-          expect(subject.on_yellow(str)).to eq("\e[43m#{str}\e[49m")
+        it "must wrap the string with \\e[92m and \\e[39m" do
+          expect(subject.bright_green(str)).to eq("\e[92m#{str}\e[39m")
         end
       end
 
       context "when given no arguments" do
-        it { expect(subject.on_yellow).to eq("\e[43m") }
+        it { expect(subject.bright_green).to eq("\e[92m") }
       end
     end
 
-    describe ".on_blue" do
+    describe ".bright_yellow" do
       context "when given a string" do
-        it "must wrap the string with \\e[44m and \\e[39m" do
-          expect(subject.on_blue(str)).to eq("\e[44m#{str}\e[49m")
+        it "must wrap the string with \\e[93m and \\e[39m" do
+          expect(subject.bright_yellow(str)).to eq("\e[93m#{str}\e[39m")
         end
       end
 
       context "when given no arguments" do
-        it { expect(subject.on_blue).to eq("\e[44m") }
+        it { expect(subject.bright_yellow).to eq("\e[93m") }
       end
     end
 
-    describe ".on_magenta" do
+    describe ".bright_blue" do
       context "when given a string" do
-        it "must wrap the string with \\e[45m and \\e[39m" do
-          expect(subject.on_magenta(str)).to eq("\e[45m#{str}\e[49m")
+        it "must wrap the string with \\e[94m and \\e[39m" do
+          expect(subject.bright_blue(str)).to eq("\e[94m#{str}\e[39m")
         end
       end
 
       context "when given no arguments" do
-        it { expect(subject.on_magenta).to eq("\e[45m") }
+        it { expect(subject.bright_blue).to eq("\e[94m") }
       end
     end
 
-    describe ".on_cyan" do
+    describe ".bright_magenta" do
       context "when given a string" do
-        it "must wrap the string with \\e[46m and \\e[39m" do
-          expect(subject.on_cyan(str)).to eq("\e[46m#{str}\e[49m")
+        it "must wrap the string with \\e[95m and \\e[39m" do
+          expect(subject.bright_magenta(str)).to eq("\e[95m#{str}\e[39m")
         end
       end
 
       context "when given no arguments" do
-        it { expect(subject.on_cyan).to eq("\e[46m") }
+        it { expect(subject.bright_magenta).to eq("\e[95m") }
       end
     end
 
-    describe ".on_white" do
+    describe ".bright_cyan" do
       context "when given a string" do
-        it "must wrap the string with \\e[47m and \\e[39m" do
-          expect(subject.on_white(str)).to eq("\e[47m#{str}\e[49m")
+        it "must wrap the string with \\e[96m and \\e[39m" do
+          expect(subject.bright_cyan(str)).to eq("\e[96m#{str}\e[39m")
         end
       end
 
       context "when given no arguments" do
-        it { expect(subject.on_white).to eq("\e[47m") }
+        it { expect(subject.bright_cyan).to eq("\e[96m") }
       end
     end
-  end
-
-  describe CommandKit::Colors::PlainText do
-    subject { described_class }
-
-    let(:str) { 'foo' }
-
-    describe "RESET" do
-      it { expect(subject::RESET).to eq('') }
-    end
-
-    describe "CLEAR" do
-      it { expect(subject::CLEAR).to eq('') }
-    end
-
-    describe "BOLD" do
-      it { expect(subject::BOLD).to eq('') }
-    end
-
-    describe "RESET_INTENSITY" do
-      it { expect(subject::RESET_INTENSITY).to eq('') }
-    end
-
-    describe "BLACK" do
-      it { expect(subject::BLACK).to eq('') }
-    end
-
-    describe "RED" do
-      it { expect(subject::RED).to eq('') }
-    end
-
-    describe "GREEN" do
-      it { expect(subject::GREEN).to eq('') }
-    end
-
-    describe "YELLOW" do
-      it { expect(subject::YELLOW).to eq('') }
-    end
-
-    describe "BLUE" do
-      it { expect(subject::BLUE).to eq('') }
-    end
-
-    describe "MAGENTA" do
-      it { expect(subject::MAGENTA).to eq('') }
-    end
-
-    describe "CYAN" do
-      it { expect(subject::CYAN).to eq('') }
-    end
-
-    describe "WHITE" do
-      it { expect(subject::WHITE).to eq('') }
-    end
-
-    describe "ON_BLACK" do
-      it { expect(subject::ON_BLACK).to eq('') }
-    end
 
-    describe "ON_RED" do
-      it { expect(subject::ON_RED).to eq('') }
-    end
-
-    describe "ON_GREEN" do
-      it { expect(subject::ON_GREEN).to eq('') }
-    end
-
-    describe "ON_YELLOW" do
-      it { expect(subject::ON_YELLOW).to eq('') }
-    end
-
-    describe "ON_BLUE" do
-      it { expect(subject::ON_BLUE).to eq('') }
-    end
-
-    describe "ON_MAGENTA" do
-      it { expect(subject::ON_MAGENTA).to eq('') }
-    end
-
-    describe "ON_CYAN" do
-      it { expect(subject::ON_CYAN).to eq('') }
-    end
-
-    describe "ON_WHITE" do
-      it { expect(subject::ON_WHITE).to eq('') }
-    end
-
-    describe "RESET_COLOR" do
-      it { expect(subject::RESET_COLOR).to eq('') }
-    end
-
-    describe ".reset" do
-      it { expect(subject.reset).to eq('') }
-    end
+    describe ".bright_white" do
+      context "when given a string" do
+        it "must wrap the string with \\e[97m and \\e[39m" do
+          expect(subject.bright_white(str)).to eq("\e[97m#{str}\e[39m")
+        end
+      end
 
-    describe ".clear" do
-      it { expect(subject.clear).to eq('') }
+      context "when given no arguments" do
+        it { expect(subject.bright_white).to eq("\e[97m") }
+      end
     end
 
-    describe ".bold" do
+    describe ".on_black" do
       context "when given a string" do
-        it "must return that string" do
-          expect(subject.bold(str)).to eq(str)
+        it "must wrap the string with \\e[40m and \\e[39m" do
+          expect(subject.on_black(str)).to eq("\e[40m#{str}\e[49m")
         end
       end
 
       context "when given no arguments" do
-        it { expect(subject.bold).to eq('') }
+        it { expect(subject.on_black).to eq("\e[40m") }
       end
     end
 
-    describe ".black" do
+    describe ".on_red" do
       context "when given a string" do
-        it "must return that string" do
-          expect(subject.black(str)).to eq(str)
+        it "must wrap the string with \\e[41m and \\e[39m" do
+          expect(subject.on_red(str)).to eq("\e[41m#{str}\e[49m")
         end
       end
 
       context "when given no arguments" do
-        it { expect(subject.black).to eq('') }
+        it { expect(subject.on_red).to eq("\e[41m") }
       end
     end
 
-    describe ".red" do
+    describe ".on_green" do
       context "when given a string" do
-        it "must return that string" do
-          expect(subject.red(str)).to eq(str)
+        it "must wrap the string with \\e[42m and \\e[39m" do
+          expect(subject.on_green(str)).to eq("\e[42m#{str}\e[49m")
         end
       end
 
       context "when given no arguments" do
-        it { expect(subject.red).to eq('') }
+        it { expect(subject.on_green).to eq("\e[42m") }
       end
     end
 
-    describe ".green" do
+    describe ".on_yellow" do
       context "when given a string" do
-        it "must return that string" do
-          expect(subject.green(str)).to eq(str)
+        it "must wrap the string with \\e[43m and \\e[39m" do
+          expect(subject.on_yellow(str)).to eq("\e[43m#{str}\e[49m")
         end
       end
 
       context "when given no arguments" do
-        it { expect(subject.green).to eq('') }
+        it { expect(subject.on_yellow).to eq("\e[43m") }
       end
     end
 
-    describe ".yellow" do
+    describe ".on_blue" do
       context "when given a string" do
-        it "must return that string" do
-          expect(subject.yellow(str)).to eq(str)
+        it "must wrap the string with \\e[44m and \\e[39m" do
+          expect(subject.on_blue(str)).to eq("\e[44m#{str}\e[49m")
         end
       end
 
       context "when given no arguments" do
-        it { expect(subject.yellow).to eq('') }
+        it { expect(subject.on_blue).to eq("\e[44m") }
       end
     end
 
-    describe ".blue" do
+    describe ".on_magenta" do
       context "when given a string" do
-        it "must return that string" do
-          expect(subject.blue(str)).to eq(str)
+        it "must wrap the string with \\e[45m and \\e[39m" do
+          expect(subject.on_magenta(str)).to eq("\e[45m#{str}\e[49m")
         end
       end
 
       context "when given no arguments" do
-        it { expect(subject.blue).to eq('') }
+        it { expect(subject.on_magenta).to eq("\e[45m") }
       end
     end
 
-    describe ".magenta" do
+    describe ".on_cyan" do
       context "when given a string" do
-        it "must return that string" do
-          expect(subject.magenta(str)).to eq(str)
+        it "must wrap the string with \\e[46m and \\e[39m" do
+          expect(subject.on_cyan(str)).to eq("\e[46m#{str}\e[49m")
         end
       end
 
       context "when given no arguments" do
-        it { expect(subject.magenta).to eq('') }
+        it { expect(subject.on_cyan).to eq("\e[46m") }
       end
     end
 
-    describe ".cyan" do
+    describe ".on_white" do
       context "when given a string" do
-        it "must return that string" do
-          expect(subject.cyan(str)).to eq(str)
+        it "must wrap the string with \\e[47m and \\e[39m" do
+          expect(subject.on_white(str)).to eq("\e[47m#{str}\e[49m")
         end
       end
 
       context "when given no arguments" do
-        it { expect(subject.cyan).to eq('') }
+        it { expect(subject.on_white).to eq("\e[47m") }
       end
     end
 
-    describe ".white" do
+    describe ".on_bright_black" do
       context "when given a string" do
-        it "must return that string" do
-          expect(subject.white(str)).to eq(str)
+        it "must wrap the string with \\e[100m and \\e[39m" do
+          expect(subject.on_bright_black(str)).to eq("\e[100m#{str}\e[49m")
         end
       end
 
       context "when given no arguments" do
-        it { expect(subject.white).to eq('') }
+        it { expect(subject.on_bright_black).to eq("\e[100m") }
       end
     end
 
-    describe ".on_black" do
+    describe ".on_gray" do
       context "when given a string" do
-        it "must return that string" do
-          expect(subject.on_black(str)).to eq(str)
+        it "must wrap the string with \\e[100m and \\e[39m" do
+          expect(subject.on_gray(str)).to eq("\e[100m#{str}\e[49m")
         end
       end
 
       context "when given no arguments" do
-        it { expect(subject.on_black).to eq('') }
+        it { expect(subject.on_gray).to eq("\e[100m") }
       end
     end
 
-    describe ".on_red" do
+    describe ".on_bright_red" do
       context "when given a string" do
-        it "must return that string" do
-          expect(subject.on_red(str)).to eq(str)
+        it "must wrap the string with \\e[101m and \\e[39m" do
+          expect(subject.on_bright_red(str)).to eq("\e[101m#{str}\e[49m")
         end
       end
 
       context "when given no arguments" do
-        it { expect(subject.on_red).to eq('') }
+        it { expect(subject.on_bright_red).to eq("\e[101m") }
       end
     end
 
-    describe ".on_green" do
+    describe ".on_bright_green" do
       context "when given a string" do
-        it "must return that string" do
-          expect(subject.on_green(str)).to eq(str)
+        it "must wrap the string with \\e[102m and \\e[39m" do
+          expect(subject.on_bright_green(str)).to eq("\e[102m#{str}\e[49m")
         end
       end
 
       context "when given no arguments" do
-        it { expect(subject.on_green).to eq('') }
+        it { expect(subject.on_bright_green).to eq("\e[102m") }
       end
     end
 
-    describe ".on_yellow" do
+    describe ".on_bright_yellow" do
       context "when given a string" do
-        it "must return that string" do
-          expect(subject.on_yellow(str)).to eq(str)
+        it "must wrap the string with \\e[103m and \\e[39m" do
+          expect(subject.on_bright_yellow(str)).to eq("\e[103m#{str}\e[49m")
         end
       end
 
       context "when given no arguments" do
-        it { expect(subject.on_yellow).to eq('') }
+        it { expect(subject.on_bright_yellow).to eq("\e[103m") }
       end
     end
 
-    describe ".on_blue" do
+    describe ".on_bright_blue" do
       context "when given a string" do
-        it "must return that string" do
-          expect(subject.on_blue(str)).to eq(str)
+        it "must wrap the string with \\e[104m and \\e[39m" do
+          expect(subject.on_bright_blue(str)).to eq("\e[104m#{str}\e[49m")
         end
       end
 
       context "when given no arguments" do
-        it { expect(subject.on_blue).to eq('') }
+        it { expect(subject.on_bright_blue).to eq("\e[104m") }
       end
     end
 
-    describe ".on_magenta" do
+    describe ".on_bright_magenta" do
       context "when given a string" do
-        it "must return that string" do
-          expect(subject.on_magenta(str)).to eq(str)
+        it "must wrap the string with \\e[105m and \\e[39m" do
+          expect(subject.on_bright_magenta(str)).to eq("\e[105m#{str}\e[49m")
         end
       end
 
       context "when given no arguments" do
-        it { expect(subject.on_magenta).to eq('') }
+        it { expect(subject.on_bright_magenta).to eq("\e[105m") }
       end
     end
 
-    describe ".on_cyan" do
+    describe ".on_bright_cyan" do
       context "when given a string" do
-        it "must return that string" do
-          expect(subject.on_cyan(str)).to eq(str)
+        it "must wrap the string with \\e[106m and \\e[39m" do
+          expect(subject.on_bright_cyan(str)).to eq("\e[106m#{str}\e[49m")
         end
       end
 
       context "when given no arguments" do
-        it { expect(subject.on_cyan).to eq('') }
+        it { expect(subject.on_bright_cyan).to eq("\e[106m") }
       end
     end
 
-    describe ".on_white" do
+    describe ".on_bright_white" do
       context "when given a string" do
-        it "must return that string" do
-          expect(subject.on_white(str)).to eq(str)
+        it "must wrap the string with \\e[107m and \\e[39m" do
+          expect(subject.on_bright_white(str)).to eq("\e[107m#{str}\e[49m")
         end
       end
 
       context "when given no arguments" do
-        it { expect(subject.on_white).to eq('') }
+        it { expect(subject.on_bright_white).to eq("\e[107m") }
+      end
+    end
+  end
+
+  describe CommandKit::Colors::PlainText do
+    subject { described_class }
+
+    let(:str) { 'foo' }
+
+    [
+      :RESET, :CLEAR,
+      :BOLD, :RESET_INTENSITY,
+      :BLACK, :RED, :GREEN, :YELLOW, :BLUE, :MAGENTA, :CYAN, :WHITE,
+      :BRIGHT_BLACK, :BRIGHT_RED, :BRIGHT_GREEN, :BRIGHT_YELLOW, :BRIGHT_BLUE, :BRIGHT_MAGENTA, :BRIGHT_CYAN, :BRIGHT_WHITE,
+      :RESET_FG, :RESET_COLOR,
+      :ON_BLACK, :ON_RED, :ON_GREEN, :ON_YELLOW, :ON_BLUE, :ON_MAGENTA, :ON_CYAN, :ON_WHITE,
+      :ON_BRIGHT_BLACK, :ON_BRIGHT_RED, :ON_BRIGHT_GREEN, :ON_BRIGHT_YELLOW, :ON_BRIGHT_BLUE, :ON_BRIGHT_MAGENTA, :ON_BRIGHT_CYAN, :ON_BRIGHT_WHITE,
+      :RESET_BG
+    ].each do |const_name|
+      describe const_name.to_s do
+        it { expect(subject.const_get(const_name)).to eq('') }
+      end
+    end
+
+    describe ".reset" do
+      it { expect(subject.reset).to eq('') }
+    end
+
+    describe ".clear" do
+      it { expect(subject.clear).to eq('') }
+    end
+
+    [
+      :bold,
+      :black, :red, :green, :yellow, :blue, :magenta, :cyan, :white,
+      :bright_black, :gray, :bright_red, :bright_green, :bright_yellow, :bright_blue, :bright_magenta, :bright_cyan, :bright_white,
+      :on_black, :on_red, :on_green, :on_yellow, :on_blue, :on_magenta, :on_cyan, :on_white,
+      :on_bright_black, :on_gray, :on_bright_red, :on_bright_green, :on_bright_yellow, :on_bright_blue, :on_bright_magenta, :on_bright_cyan, :on_bright_white
+    ].each do |method_name|
+      describe ".#{method_name}" do
+        context "when given a string" do
+          it "must return that string" do
+            expect(subject.send(method_name,str)).to eq(str)
+          end
+        end
+
+        context "when given no arguments" do
+          it { expect(subject.send(method_name)).to eq('') }
+        end
       end
     end
   end
@@ -625,6 +656,12 @@ describe CommandKit::Colors do
       it { expect(subject.ansi?).to be(false) }
     end
 
+    context "when NO_COLOR is set" do
+      subject { command_class.new(env: {'NO_COLOR' => 'true'}) }
+
+      it { expect(subject.ansi?).to be(false) }
+    end
+
     context "when stdout is a TTY" do
       let(:stdout) { StringIO.new }
       subject { command_class.new(stdout: stdout) }

data/spec/command_name_spec.rb

@@ -19,7 +19,7 @@ describe CommandKit::CommandName do
       end
     end
 
-    context "when a command_name is explicitly set" do
+    context "when a command_name has been explicitly set" do
       module TestCommandName
         class ExplicitCmd
           include CommandKit::CommandName

data/spec/command_spec.rb

@@ -46,8 +46,8 @@ describe CommandKit::Command do
     expect(described_class).to include(CommandKit::ExceptionHandler)
   end
 
-  it "must include FileUtils" do
-    expect(described_class).to include(FileUtils)
+  it "must include CommandKit::FileUtils" do
+    expect(described_class).to include(CommandKit::FileUtils)
   end
 
   module TestCommandClass