rainbow 2.1.0 → 3.1.0

data/spec/integration/rainbow_spec.rb

@@ -1,149 +0,0 @@
-require 'spec_helper'
-require 'rainbow'
-
-describe 'Rainbow() wrapper' do
-
-  before do
-    Rainbow.enabled = true
-  end
-
-  it 'allows foreground coloring by color number' do
-    result = Rainbow('hello').foreground(5)
-    expect(result).to eq("\e[35mhello\e[0m")
-  end
-
-  it 'allows foreground coloring by color name' do
-    result = Rainbow('hello').foreground(:red)
-    expect(result).to eq("\e[31mhello\e[0m")
-  end
-
-  it 'allows foreground coloring directly by ANSI method name' do
-    result = Rainbow('hello').red
-    expect(result).to eq("\e[31mhello\e[0m")
-  end
-
-  it 'allows foreground coloring directly by X11 method name' do
-    result = Rainbow('hello').midnightblue
-    expect(result).to eq("\e[38;5;18mhello\e[0m")
-  end
-
-  it 'allows foreground coloring by ANSI color name (color alias)' do
-    result = Rainbow('hello').color(:red)
-    expect(result).to eq("\e[31mhello\e[0m")
-  end
-
-  it 'allows foreground coloring by color name (colour alias)' do
-    result = Rainbow('hello').colour(:red)
-    expect(result).to eq("\e[31mhello\e[0m")
-  end
-
-  it 'allows foreground coloring by X11 color name' do
-    result = Rainbow('hello').foreground(:midnightblue)
-    expect(result).to eq("\e[38;5;18mhello\e[0m")
-  end
-
-  it 'allows foreground coloring by color rgb' do
-    result = Rainbow('hello').foreground(255, 128, 64)
-    expect(result).to eq("\e[38;5;215mhello\e[0m")
-  end
-
-  it 'allows foreground coloring by color rgb (hex string)' do
-    result = Rainbow('hello').foreground('ff8040')
-    expect(result).to eq("\e[38;5;215mhello\e[0m")
-  end
-
-  it 'allows background coloring by color number' do
-    result = Rainbow('hello').background(3)
-    expect(result).to eq("\e[43mhello\e[0m")
-  end
-
-  it 'allows background coloring by ANSI color name' do
-    result = Rainbow('hello').background(:green)
-    expect(result).to eq("\e[42mhello\e[0m")
-  end
-
-  it 'allows background coloring by X11 color name' do
-    result = Rainbow('hello').background(:midnightblue)
-    expect(result).to eq("\e[48;5;18mhello\e[0m")
-  end
-
-  it 'allows background coloring by color rgb' do
-    result = Rainbow('hello').background(255, 128, 64)
-    expect(result).to eq("\e[48;5;215mhello\e[0m")
-  end
-
-  it 'allows making text bright' do
-    result = Rainbow('hello').bright
-    expect(result).to eq("\e[1mhello\e[0m")
-  end
-
-  it 'allows making text italic' do
-    result = Rainbow('hello').italic
-    expect(result).to eq("\e[3mhello\e[0m")
-  end
-
-  it 'allows making text underlined' do
-    result = Rainbow('hello').underline
-    expect(result).to eq("\e[4mhello\e[0m")
-  end
-
-  it 'allows making text blinking' do
-    result = Rainbow('hello').blink
-    expect(result).to eq("\e[5mhello\e[0m")
-  end
-
-  it 'allows making text inversed' do
-    result = Rainbow('hello').inverse
-    expect(result).to eq("\e[7mhello\e[0m")
-  end
-
-  it 'allows making text hidden' do
-    result = Rainbow('hello').hide
-    expect(result).to eq("\e[8mhello\e[0m")
-  end
-
-  it 'allows resetting all the attributes' do
-    result = Rainbow('hello').reset
-    expect(result).to eq("\e[0mhello\e[0m")
-  end
-
-  it 'allows chaining' do
-    result = Rainbow('hello').
-      foreground(:red).
-      bright.
-      italic.
-      background('#ff8040').
-      underline.
-      color(:blue).
-      blink.
-      inverse.
-      hide
-
-    expect(result).to eq(
-      "\e[31m\e[1m\e[3m\e[48;5;215m\e[4m\e[34m\e[5m\e[7m\e[8mhello\e[0m"
-    )
-  end
-
-  context "when Rainbow is disabled" do
-
-    before do
-      Rainbow.enabled = false
-    end
-
-    it "allows chaining but doesn't wrap with escape codes" do
-      result = Rainbow('hello').
-        foreground(:red).
-        bright.
-        italic.
-        background('#ff8040').
-        underline.
-        color(:blue).
-        blink.
-        inverse.
-        hide
-
-      expect(result).to eq('hello')
-    end
-  end
-
-end

data/spec/integration/string_spec.rb

@@ -1,80 +0,0 @@
-require 'spec_helper'
-require 'rainbow/ext/string'
-
-describe 'String mixin' do
-
-  before do
-    Rainbow.enabled = true
-  end
-
-  it 'proxies foreground to Rainbow().foreground' do
-    expect('hello'.foreground(:red)).to eq(Rainbow('hello').foreground(:red))
-  end
-
-  it 'proxies color to Rainbow().color' do
-    expect('hello'.color(:red)).to eq(Rainbow('hello').color(:red))
-  end
-
-  it 'proxies x11 color to Rainbow().color' do
-    expect('hello'.color(:midnightblue)).to eq(Rainbow('hello').color(:midnightblue))
-  end
-
-  it 'proxies colour to Rainbow().colour' do
-    expect('hello'.colour(:red)).to eq(Rainbow('hello').colour(:red))
-  end
-
-  it 'proxies background to Rainbow().background' do
-    expect('hello'.background(:red)).to eq(Rainbow('hello').background(:red))
-  end
-
-  it 'proxies bright to Rainbow().bright' do
-    expect('hello'.bright).to eq(Rainbow('hello').bright)
-  end
-
-  it 'proxies italic to Rainbow().italic' do
-    expect('hello'.italic).to eq(Rainbow('hello').italic)
-  end
-
-  it 'proxies underline to Rainbow().underline' do
-    expect('hello'.underline).to eq(Rainbow('hello').underline)
-  end
-
-  it 'proxies blink to Rainbow().blink' do
-    expect('hello'.blink).to eq(Rainbow('hello').blink)
-  end
-
-  it 'proxies inverse to Rainbow().inverse' do
-    expect('hello'.inverse).to eq(Rainbow('hello').inverse)
-  end
-
-  it 'proxies hide to Rainbow().hide' do
-    expect('hello'.hide).to eq(Rainbow('hello').hide)
-  end
-
-  it 'proxies reset to Rainbow().reset' do
-    expect('hello'.reset).to eq(Rainbow('hello').reset)
-  end
-
-  context "when Rainbow is disabled" do
-
-    before do
-      Rainbow.enabled = false
-    end
-
-    it "allows chaining but doesn't wrap with escape codes" do
-      result = 'hello'.
-        foreground(:red).
-        bright.
-        italic.
-        background('#ff8040').
-        underline.
-        color(:blue).
-        blink.
-        inverse.
-        hide
-
-      expect(result).to eq('hello')
-    end
-  end
-
-end

data/spec/spec_helper.rb

@@ -1,6 +0,0 @@
-if ENV["CI"] && (!defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby")
-  require 'coveralls'
-  Coveralls.wear!
-end
-
-Dir[File.expand_path('../support/**/*.rb', __FILE__)].each { |file| require file }

data/spec/support/presenter_shared_examples.rb

@@ -1,9 +0,0 @@
-shared_examples_for "presenter with shortcut color methods" do
-  [:black, :red, :green, :yellow, :blue, :magenta, :cyan, :white].each do |name|
-    describe "##{name}" do
-      subject { presenter.public_send(name) }
-
-      it { should eq(presenter.color(name)) }
-    end
-  end
-end

data/spec/unit/color_spec.rb

@@ -1,301 +0,0 @@
-require 'spec_helper'
-require 'rainbow/color'
-
-module Rainbow
-  describe Color do
-    describe '.build' do
-
-      subject { described_class.build(ground, values) }
-
-      let(:ground) { :foreground }
-
-      context "when single fixnum given" do
-        let(:values) { [1] }
-
-        it { should be_instance_of(Color::Indexed) }
-
-        specify { expect(subject.ground).to eq(ground) }
-        specify { expect(subject.num).to eq(1) }
-      end
-
-      context "when single ansi symbol given" do
-        let(:values) { [:red] }
-
-        it { should be_instance_of(Color::Named) }
-
-        specify { expect(subject.ground).to eq(ground) }
-        specify { expect(subject.num).to eq(1) }
-      end
-
-      context "when single x11 symbol given" do
-        let(:values) { [:midnightblue] }
-
-        it { should be_instance_of(Color::X11Named) }
-
-        specify { expect(subject.ground).to eq(ground) }
-        specify { expect(subject.r).to eq(25) }
-        specify { expect(subject.g).to eq(25) }
-        specify { expect(subject.b).to eq(112) }
-      end
-
-      context "when single string given" do
-        let(:values) { ['#deadcc'] }
-
-        it { should be_instance_of(Color::RGB) }
-
-        specify { expect(subject.ground).to eq(ground) }
-        specify { expect(subject.r).to eq(222) }
-        specify { expect(subject.g).to eq(173) }
-        specify { expect(subject.b).to eq(204) }
-      end
-
-      context "when 2 elements" do
-        let(:values) { [1, 2] }
-
-        it 'raises ArgumentError' do
-          expect { subject }.to raise_error(ArgumentError)
-        end
-      end
-
-      context "when 3 elements given" do
-        let(:values) { [1, 2, 3] }
-
-        it { should be_instance_of(Color::RGB) }
-
-        specify { expect(subject.ground).to eq(ground) }
-        specify { expect(subject.r).to eq(1) }
-        specify { expect(subject.g).to eq(2) }
-        specify { expect(subject.b).to eq(3) }
-      end
-
-      context "when 4 elements" do
-        let(:values) { [1, 2, 3, 4] }
-
-        it 'raises ArgumentError' do
-          expect { subject }.to raise_error(ArgumentError)
-        end
-      end
-
-    end
-  end
-
-  describe Color::Indexed do
-    let(:color) { described_class.new(ground, 5) }
-
-    describe '#codes' do
-      subject { color.codes }
-
-      context "when ground is :foreground" do
-        let(:ground) { :foreground }
-
-        it { should eq([35]) }
-      end
-
-      context "when ground is :background" do
-        let(:ground) { :background }
-
-        it { should eq([45]) }
-      end
-    end
-  end
-
-  describe Color::Named do
-    let(:color) { described_class.new(ground, name) }
-
-    describe '#codes' do
-      subject { color.codes }
-
-      context "when ground is :foreground" do
-        let(:ground) { :foreground }
-
-        context "and name is :black" do
-          let(:name) { :black }
-
-          it { should eq([30]) }
-        end
-
-        context "and name is :red" do
-          let(:name) { :red }
-
-          it { should eq([31]) }
-        end
-
-        context "and name is :green" do
-          let(:name) { :green }
-
-          it { should eq([32]) }
-        end
-
-        context "and name is :yellow" do
-          let(:name) { :yellow }
-
-          it { should eq([33]) }
-        end
-
-        context "and name is :blue" do
-          let(:name) { :blue }
-
-          it { should eq([34]) }
-        end
-
-        context "and name is :magenta" do
-          let(:name) { :magenta }
-
-          it { should eq([35]) }
-        end
-
-        context "and name is :cyan" do
-          let(:name) { :cyan }
-
-          it { should eq([36]) }
-        end
-
-        context "and name is :white" do
-          let(:name) { :white }
-
-          it { should eq([37]) }
-        end
-
-        context "and name is invalid" do
-          let(:name) { :foo }
-
-          it 'raises ArgumentError' do
-            expect { subject }.to raise_error(ArgumentError)
-          end
-        end
-      end
-
-      context "when ground is :background" do
-        let(:ground) { :background }
-
-        context "and name is :black" do
-          let(:name) { :black }
-
-          it { should eq([40]) }
-        end
-
-        context "and name is :red" do
-          let(:name) { :red }
-
-          it { should eq([41]) }
-        end
-
-        context "and name is :green" do
-          let(:name) { :green }
-
-          it { should eq([42]) }
-        end
-
-        context "and name is :yellow" do
-          let(:name) { :yellow }
-
-          it { should eq([43]) }
-        end
-
-        context "and name is :blue" do
-          let(:name) { :blue }
-
-          it { should eq([44]) }
-        end
-
-        context "and name is :magenta" do
-          let(:name) { :magenta }
-
-          it { should eq([45]) }
-        end
-
-        context "and name is :cyan" do
-          let(:name) { :cyan }
-
-          it { should eq([46]) }
-        end
-
-        context "and name is :white" do
-          let(:name) { :white }
-
-          it { should eq([47]) }
-        end
-
-        context "and name is invalid" do
-          let(:name) { :foo }
-
-          it 'raises ArgumentError' do
-            expect { subject }.to raise_error(ArgumentError)
-          end
-        end
-      end
-    end
-  end
-
-  describe Color::RGB do
-    let(:color) { described_class.new(ground, r, g, b) }
-
-    describe '#codes' do
-      subject { color.codes }
-
-      let(:ground) { :foreground }
-      let(:r) { 0 }
-      let(:g) { 128 }
-      let(:b) { 255 }
-
-      context "when ground is :foreground" do
-        let(:ground) { :foreground }
-
-        it { should eq([38, 5, 39]) }
-      end
-
-      context "when ground is :background" do
-        let(:ground) { :background }
-
-        it { should eq([48, 5, 39]) }
-      end
-
-      context "when a component is lower than 0" do
-        let(:r) { -1 }
-
-        it 'raises ArgumentError' do
-          expect { subject }.to raise_error(ArgumentError)
-        end
-      end
-
-      context "when a component is greater than 255" do
-        let(:b) { 256 }
-
-        it 'raises ArgumentError' do
-          expect { subject }.to raise_error(ArgumentError)
-        end
-      end
-
-    end
-  end
-
-  describe Color::X11Named do
-    let(:color) { described_class.new(ground, name) }
-
-    describe '#codes' do
-      subject { color.codes }
-
-      context "when ground is :foreground" do
-        let(:name) { :midnightblue }
-        let(:ground) { :foreground }
-        it { should eq([38, 5, 18]) }
-      end
-
-      context "when ground is :background" do
-        let(:name) { :midnightblue }
-        let(:ground) { :background }
-        it { should eq([48, 5, 18]) }
-      end
-
-      context "when name is invalid" do
-        let(:name) { :foo }
-        let(:ground) { :background }
-        it 'raises ArgumentError' do
-          expect { subject }.to raise_error(ArgumentError)
-        end
-      end
-
-    end
-  end
-
-end

data/spec/unit/namespace_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-require 'rainbow'
-
-describe Sickill::Rainbow do
-
-  describe '.enabled' do
-    before do
-      ::Rainbow.enabled = :nope
-    end
-
-    it 'returns ::Rainbow.enabled' do
-      expect(Sickill::Rainbow.enabled).to eq(:nope)
-    end
-  end
-
-  describe '.enabled=' do
-    before do
-      allow(STDERR).to receive(:puts)
-      Sickill::Rainbow.enabled = :yep
-    end
-
-    it 'sets ::Rainbow.enabled=' do
-      expect(::Rainbow.enabled).to eq(:yep)
-    end
-
-    it 'prints the deprecation notice' do
-      expect(STDERR).to have_received(:puts)
-    end
-  end
-
-end

data/spec/unit/null_presenter_spec.rb

@@ -1,93 +0,0 @@
-require 'spec_helper'
-require 'rainbow/null_presenter'
-
-module Rainbow
-  describe NullPresenter do
-
-    let(:presenter) { described_class.new('hello') }
-
-    shared_examples_for "rainbow null string method" do
-      it "doesn't wrap the text with any sgr sequence" do
-        expect(subject).to eq('hello')
-      end
-
-      it "returns an instance of Rainbow::NullPresenter" do
-        expect(subject).to be_kind_of(Rainbow::NullPresenter)
-      end
-    end
-
-    describe '#color' do
-      subject { presenter.color(:arg1, 'arg2') }
-
-      it_behaves_like "rainbow null string method"
-    end
-
-    describe '#foreground' do
-      subject { presenter.foreground(:arg1, 'arg2') }
-
-      it_behaves_like "rainbow null string method"
-    end
-
-    describe '#fg' do
-      subject { presenter.fg(:arg1, 'arg2') }
-
-      it_behaves_like "rainbow null string method"
-    end
-
-    describe '#background' do
-      subject { presenter.background(:arg1, 'arg2') }
-
-      it_behaves_like "rainbow null string method"
-    end
-
-    describe '#bg' do
-      subject { presenter.bg(:arg1, 'arg2') }
-
-      it_behaves_like "rainbow null string method"
-    end
-
-    describe '#reset' do
-      subject { presenter.reset }
-
-      it_behaves_like "rainbow null string method"
-    end
-
-    describe '#bright' do
-      subject { presenter.bright }
-
-      it_behaves_like "rainbow null string method"
-    end
-
-    describe '#italic' do
-      subject { presenter.italic }
-
-      it_behaves_like "rainbow null string method"
-    end
-
-    describe '#underline' do
-      subject { presenter.underline }
-
-      it_behaves_like "rainbow null string method"
-    end
-
-    describe '#blink' do
-      subject { presenter.blink }
-
-      it_behaves_like "rainbow null string method"
-    end
-
-    describe '#inverse' do
-      subject { presenter.inverse }
-
-      it_behaves_like "rainbow null string method"
-    end
-
-    describe '#hide' do
-      subject { presenter.hide }
-
-      it_behaves_like "rainbow null string method"
-    end
-
-    it_behaves_like "presenter with shortcut color methods"
-  end
-end