command_kit 0.4.1 → 0.5.0

data/spec/colors_spec.rb

@@ -1,771 +0,0 @@
-require 'spec_helper'
-require 'command_kit/colors'
-
-describe CommandKit::Colors do
-  module TestColors
-    class TestCommand
-      include CommandKit::Colors
-    end
-  end
-
-  let(:command_class) { TestColors::TestCommand }
-  subject { command_class.new }
-
-  it { expect(described_class).to include(CommandKit::Stdio) }
-  it { expect(described_class).to include(CommandKit::Env) }
-
-  describe CommandKit::Colors::ANSI do
-    subject { described_class }
-
-    describe "RESET" do
-      it { expect(subject::RESET).to eq("\e[0m") }
-    end
-
-    describe "CLEAR" do
-      it { expect(subject::CLEAR).to eq("\e[0m") }
-    end
-
-    describe "BOLD" do
-      it { expect(subject::BOLD).to eq("\e[1m") }
-    end
-
-    describe "RESET_INTENSITY" do
-      it { expect(subject::RESET_INTENSITY).to eq("\e[22m") }
-    end
-
-    describe "BLACK" do
-      it { expect(subject::BLACK).to eq("\e[30m") }
-    end
-
-    describe "RED" do
-      it { expect(subject::RED).to eq("\e[31m") }
-    end
-
-    describe "GREEN" do
-      it { expect(subject::GREEN).to eq("\e[32m") }
-    end
-
-    describe "YELLOW" do
-      it { expect(subject::YELLOW).to eq("\e[33m") }
-    end
-
-    describe "BLUE" do
-      it { expect(subject::BLUE).to eq("\e[34m") }
-    end
-
-    describe "MAGENTA" do
-      it { expect(subject::MAGENTA).to eq("\e[35m") }
-    end
-
-    describe "CYAN" do
-      it { expect(subject::CYAN).to eq("\e[36m") }
-    end
-
-    describe "WHITE" 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
-
-    describe "ON_RED" do
-      it { expect(subject::ON_RED).to eq("\e[41m") }
-    end
-
-    describe "ON_GREEN" do
-      it { expect(subject::ON_GREEN).to eq("\e[42m") }
-    end
-
-    describe "ON_YELLOW" do
-      it { expect(subject::ON_YELLOW).to eq("\e[43m") }
-    end
-
-    describe "ON_BLUE" do
-      it { expect(subject::ON_BLUE).to eq("\e[44m") }
-    end
-
-    describe "ON_MAGENTA" do
-      it { expect(subject::ON_MAGENTA).to eq("\e[45m") }
-    end
-
-    describe "ON_CYAN" do
-      it { expect(subject::ON_CYAN).to eq("\e[46m") }
-    end
-
-    describe "ON_WHITE" 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
-
-    let(:str) { 'foo' }
-
-    describe ".reset" do
-      it { expect(subject.reset).to eq(described_class::RESET) }
-    end
-
-    describe ".clear" do
-      it { expect(subject.clear).to eq(described_class::CLEAR) }
-    end
-
-    describe ".bold" do
-      context "when given a string" do
-        it "must wrap the string with \\e[1m and \\e[22m" do
-          expect(subject.bold(str)).to eq("\e[1m#{str}\e[22m")
-        end
-      end
-
-      context "when given no arguments" do
-        it { expect(subject.bold).to eq("\e[1m") }
-      end
-    end
-
-    describe ".black" do
-      context "when given a string" do
-        it "must wrap the string with \\e[30m and \\e[39m" do
-          expect(subject.black(str)).to eq("\e[30m#{str}\e[39m")
-        end
-      end
-
-      context "when given no arguments" do
-        it { expect(subject.black).to eq("\e[30m") }
-      end
-    end
-
-    describe ".red" do
-      context "when given a string" do
-        it "must wrap the string with \\e[31m and \\e[39m" do
-          expect(subject.red(str)).to eq("\e[31m#{str}\e[39m")
-        end
-      end
-
-      context "when given no arguments" do
-        it { expect(subject.red).to eq("\e[31m") }
-      end
-    end
-
-    describe ".green" do
-      context "when given a string" do
-        it "must wrap the string with \\e[32m and \\e[39m" do
-          expect(subject.green(str)).to eq("\e[32m#{str}\e[39m")
-        end
-      end
-
-      context "when given no arguments" do
-        it { expect(subject.green).to eq("\e[32m") }
-      end
-    end
-
-    describe ".yellow" do
-      context "when given a string" do
-        it "must wrap the string with \\e[33m and \\e[39m" do
-          expect(subject.yellow(str)).to eq("\e[33m#{str}\e[39m")
-        end
-      end
-
-      context "when given no arguments" do
-        it { expect(subject.yellow).to eq("\e[33m") }
-      end
-    end
-
-    describe ".blue" do
-      context "when given a string" do
-        it "must wrap the string with \\e[34m and \\e[39m" do
-          expect(subject.blue(str)).to eq("\e[34m#{str}\e[39m")
-        end
-      end
-
-      context "when given no arguments" do
-        it { expect(subject.blue).to eq("\e[34m") }
-      end
-    end
-
-    describe ".magenta" do
-      context "when given a string" do
-        it "must wrap the string with \\e[35m and \\e[39m" do
-          expect(subject.magenta(str)).to eq("\e[35m#{str}\e[39m")
-        end
-      end
-
-      context "when given no arguments" do
-        it { expect(subject.magenta).to eq("\e[35m") }
-      end
-    end
-
-    describe ".cyan" do
-      context "when given a string" do
-        it "must wrap the string with \\e[36m and \\e[39m" do
-          expect(subject.cyan(str)).to eq("\e[36m#{str}\e[39m")
-        end
-      end
-
-      context "when given no arguments" do
-        it { expect(subject.cyan).to eq("\e[36m") }
-      end
-    end
-
-    describe ".white" do
-      context "when given a string" do
-        it "must wrap the string with \\e[37m and \\e[39m" do
-          expect(subject.white(str)).to eq("\e[37m#{str}\e[39m")
-        end
-      end
-
-      context "when given no arguments" do
-        it { expect(subject.white).to eq("\e[37m") }
-      end
-    end
-
-    describe ".bright_black" do
-      context "when given a string" do
-        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.bright_black).to eq("\e[90m") }
-      end
-    end
-
-    describe ".gray" do
-      context "when given a string" do
-        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.gray).to eq("\e[90m") }
-      end
-    end
-
-    describe ".bright_red" do
-      context "when given a string" do
-        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.bright_red).to eq("\e[91m") }
-      end
-    end
-
-    describe ".bright_green" do
-      context "when given a string" do
-        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.bright_green).to eq("\e[92m") }
-      end
-    end
-
-    describe ".bright_yellow" do
-      context "when given a string" do
-        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.bright_yellow).to eq("\e[93m") }
-      end
-    end
-
-    describe ".bright_blue" do
-      context "when given a string" do
-        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.bright_blue).to eq("\e[94m") }
-      end
-    end
-
-    describe ".bright_magenta" do
-      context "when given a string" do
-        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.bright_magenta).to eq("\e[95m") }
-      end
-    end
-
-    describe ".bright_cyan" do
-      context "when given a string" do
-        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.bright_cyan).to eq("\e[96m") }
-      end
-    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
-
-      context "when given no arguments" do
-        it { expect(subject.bright_white).to eq("\e[97m") }
-      end
-    end
-
-    describe ".on_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")
-        end
-      end
-
-      context "when given no arguments" do
-        it { expect(subject.on_black).to eq("\e[40m") }
-      end
-    end
-
-    describe ".on_red" 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")
-        end
-      end
-
-      context "when given no arguments" do
-        it { expect(subject.on_red).to eq("\e[41m") }
-      end
-    end
-
-    describe ".on_green" 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")
-        end
-      end
-
-      context "when given no arguments" do
-        it { expect(subject.on_green).to eq("\e[42m") }
-      end
-    end
-
-    describe ".on_yellow" 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")
-        end
-      end
-
-      context "when given no arguments" do
-        it { expect(subject.on_yellow).to eq("\e[43m") }
-      end
-    end
-
-    describe ".on_blue" 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")
-        end
-      end
-
-      context "when given no arguments" do
-        it { expect(subject.on_blue).to eq("\e[44m") }
-      end
-    end
-
-    describe ".on_magenta" 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")
-        end
-      end
-
-      context "when given no arguments" do
-        it { expect(subject.on_magenta).to eq("\e[45m") }
-      end
-    end
-
-    describe ".on_cyan" 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")
-        end
-      end
-
-      context "when given no arguments" do
-        it { expect(subject.on_cyan).to eq("\e[46m") }
-      end
-    end
-
-    describe ".on_white" 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")
-        end
-      end
-
-      context "when given no arguments" do
-        it { expect(subject.on_white).to eq("\e[47m") }
-      end
-    end
-
-    describe ".on_bright_black" do
-      context "when given a string" do
-        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.on_bright_black).to eq("\e[100m") }
-      end
-    end
-
-    describe ".on_gray" do
-      context "when given a string" do
-        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_gray).to eq("\e[100m") }
-      end
-    end
-
-    describe ".on_bright_red" do
-      context "when given a string" do
-        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_bright_red).to eq("\e[101m") }
-      end
-    end
-
-    describe ".on_bright_green" do
-      context "when given a string" do
-        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_bright_green).to eq("\e[102m") }
-      end
-    end
-
-    describe ".on_bright_yellow" do
-      context "when given a string" do
-        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_bright_yellow).to eq("\e[103m") }
-      end
-    end
-
-    describe ".on_bright_blue" do
-      context "when given a string" do
-        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_bright_blue).to eq("\e[104m") }
-      end
-    end
-
-    describe ".on_bright_magenta" do
-      context "when given a string" do
-        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_bright_magenta).to eq("\e[105m") }
-      end
-    end
-
-    describe ".on_bright_cyan" do
-      context "when given a string" do
-        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_bright_cyan).to eq("\e[106m") }
-      end
-    end
-
-    describe ".on_bright_white" do
-      context "when given a string" do
-        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_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
-
-  describe "#ansi?" do
-    context "when TERM='dumb'" do
-      subject { command_class.new(env: {'TERM' => 'dumb'}) }
-
-      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) }
-
-      before { allow(stdout).to receive(:tty?).and_return(true) }
-
-      it { expect(subject.ansi?).to be(true) }
-    end
-
-    context "when stdout is not a TTY" do
-      let(:stdout) { StringIO.new }
-      subject { command_class.new(stdout: stdout) }
-
-      it { expect(subject.ansi?).to be(false) }
-    end
-
-    context "when given an alternate stream" do
-      context "and the alternate stream is a TTY" do
-        let(:stream) { StringIO.new }
-
-        before { allow(stream).to receive(:tty?).and_return(true) }
-
-        it { expect(subject.ansi?(stream)).to be(true) }
-      end
-
-      context "but the alternate stream is not a TTY" do
-        let(:stream) { StringIO.new }
-
-        it { expect(subject.ansi?(stream)).to be(false) }
-      end
-    end
-  end
-
-  describe "#colors" do
-    context "when stdout supports ANSI" do
-      let(:stdout) { StringIO.new }
-      subject { command_class.new(stdout: stdout) }
-
-      before { allow(stdout).to receive(:tty?).and_return(true) }
-
-      it do
-        expect(subject.colors).to be(described_class::ANSI)
-      end
-
-      context "when a block is given" do
-        it do
-          expect { |b|
-            subject.colors(&b)
-          }.to yield_with_args(described_class::ANSI)
-        end
-      end
-    end
-
-    context "when stdout does not support ANSI" do
-      let(:stdout) { StringIO.new }
-      subject { command_class.new(stdout: stdout) }
-
-      it do
-        expect(subject.colors).to be(described_class::PlainText)
-      end
-
-      context "when a block is given" do
-        it do
-          expect { |b|
-            subject.colors(&b)
-          }.to yield_with_args(described_class::PlainText)
-        end
-      end
-    end
-
-    context "when given an alternate stream" do
-      context "and the alternate stream supports ANSI" do
-        let(:stream) { StringIO.new }
-
-        before { allow(stream).to receive(:tty?).and_return(true) }
-
-        it do
-          expect(subject.colors(stream)).to be(described_class::ANSI)
-        end
-
-        context "when a block is given" do
-          it do
-            expect { |b|
-              subject.colors(stream,&b)
-            }.to yield_with_args(described_class::ANSI)
-          end
-        end
-      end
-
-      context "but the alternate stream does not support ANSI" do
-        let(:stream) { StringIO.new }
-
-        it do
-          expect(subject.colors(stream)).to be(described_class::PlainText)
-        end
-
-        context "when a block is given" do
-          it do
-            expect { |b|
-              subject.colors(stream,&b)
-            }.to yield_with_args(described_class::PlainText)
-          end
-        end
-      end
-    end
-  end
-end