pastel 0.7.0 → 0.8.0

data/spec/unit/color/equal_spec.rb

@@ -1,22 +0,0 @@
-# encoding: utf-8
-
-RSpec.describe Pastel::Color, '#==' do
-  it "is true with the same enabled and eachline attributes" do
-    expect(Pastel::Color.new(enabled: false, eachline: "\n")).
-      to eq(Pastel::Color.new(enabled: false, eachline: "\n"))
-  end
-
-  it "is false with different enabled attribute" do
-    expect(Pastel::Color.new(enabled: true, eachline: "\n")).
-      not_to eq(Pastel::Color.new(enabled: false, eachline: "\n"))
-  end
-
-  it "is false with different eachline attribute" do
-    expect(Pastel::Color.new(enabled: false, eachline: "\n")).
-      not_to eq(Pastel::Color.new(enabled: false, eachline: "\r\n"))
-  end
-
-  it "is false with non-color" do
-    expect(Pastel::Color.new(enabled: true)).not_to eq(:other)
-  end
-end

data/spec/unit/color/lookup_spec.rb

@@ -1,17 +0,0 @@
-# encoding: utf-8
-
-RSpec.describe Pastel::Color, '#lookup' do
-  it "looksup colors" do
-    color = described_class.new(enabled: true)
-    expect(color.lookup(:red, :on_green, :bold)).to eq("\e[31;42;1m")
-  end
-
-  it "caches color lookups" do
-    color = described_class.new(enabled: true)
-    allow(color).to receive(:code).and_return([31])
-    color.lookup(:red, :on_green)
-    color.lookup(:red, :on_green)
-    color.lookup(:red, :on_green)
-    expect(color).to have_received(:code).once
-  end
-end

data/spec/unit/color/new_spec.rb

@@ -1,10 +0,0 @@
-# encoding: utf-8
-
-RSpec.describe Pastel::Color, '::new' do
-  it "allows to disable coloring" do
-    color = described_class.new(enabled: false)
-
-    expect(color.enabled?).to eq(false)
-    expect(color.decorate("Unicorn", :red)).to eq("Unicorn")
-  end
-end

data/spec/unit/color/strip_spec.rb

@@ -1,56 +0,0 @@
-# encoding: utf-8
-
-RSpec.describe Pastel::Color, '.strip' do
-
-  subject(:color) { described_class.new(enabled: true) }
-
-  it 'strips ansi color from string' do
-    string = "This is a \e[1m\e[34mbold blue text\e[0m"
-    expect(color.strip(string)).to eq('This is a bold blue text')
-  end
-
-  it "strips partial ansi color" do
-    string = "foo\e[1mbar"
-    expect(color.strip(string)).to eq('foobar')
-  end
-
-  it 'preserves movement characters' do
-    # [176A - move cursor up n lines
-    expect(color.strip("foo\e[176Abar")).to eq("foo\e[176Abar")
-  end
-
-  it 'strips reset/setfg/setbg/italics/strike/underline sequence' do
-    string = "\x1b[0;33;49;3;9;4mfoo\x1b[0m"
-    expect(color.strip(string)).to eq("foo")
-  end
-
-  it 'strips octal in encapsulating brackets' do
-    string = "\[\033[01;32m\]u@h \[\033[01;34m\]W $ \[\033[00m\]"
-    expect(color.strip(string)).to eq('[]u@h []W $ []')
-  end
-
-  it 'strips octal codes without brackets' do
-    string = "\033[01;32mu@h \033[01;34mW $ \033[00m"
-    expect(color.strip(string)).to eq('u@h W $ ')
-  end
-
-  it 'strips octal with multiple colors' do
-    string = "\e[3;0;0;mfoo\e[8;50;0m"
-    expect(color.strip(string)).to eq('foo')
-  end
-
-  it "strips multiple colors delimited by :" do
-    string = "\e[31:44:4mfoo\e[0m"
-    expect(color.strip(string)).to eq('foo')
-  end
-
-  it 'strips control codes' do
-    string = "WARN. \x1b[1m&\x1b[0m ERR. \x1b[7m&\x1b[0m"
-    expect(color.strip(string)).to eq('WARN. & ERR. &')
-  end
-
-  it 'strips escape bytes' do
-    string = "This is a \e[1m\e[34mbold blue text\e[0m"
-    expect(color.strip(string)).to eq("This is a bold blue text")
-  end
-end

data/spec/unit/color/styles_spec.rb

@@ -1,10 +0,0 @@
-# coding: utf-8
-
-RSpec.describe Pastel::Color, '#styles' do
-
-  subject(:color) { described_class.new(enabled: true) }
-
-  it "exposes all available style ANSI codes" do
-    expect(color.styles[:red]).to eq(31)
-  end
-end

data/spec/unit/color/valid_spec.rb

@@ -1,19 +0,0 @@
-# encoding: utf-8
-
-RSpec.describe Pastel::Color, '.valid?' do
-  it "detects valid colors" do
-    color = described_class.new
-    expect(color.valid?(:red, :on_green, :bold)).to eq(true)
-  end
-
-  it "detects valid color aliases" do
-    color = described_class.new
-    color.alias_color(:funky, :red)
-    expect(color.valid?(:funky)).to eq(true)
-  end
-
-  it "detects invalid color" do
-    color = described_class.new
-    expect(color.valid?(:red, :unknown)).to eq(false)
-  end
-end

data/spec/unit/color_parser_spec.rb

@@ -1,67 +0,0 @@
-# encoding: utf-8
-
-RSpec.describe Pastel::ColorParser, '::parse' do
-  subject(:parser) { described_class }
-
-  it "parses string with no color" do
-    expect(parser.parse("foo")).to eq([{text: 'foo'}])
-  end
-
-  it "parses simple color" do
-    expect(parser.parse("\e[32mfoo\e[0m")).to eq([
-     {foreground: :green, text: 'foo'}
-    ])
-  end
-
-  it "parses simple color and style" do
-    expect(parser.parse("\e[32;1mfoo\e[0m")).to eq([
-      {foreground: :green, style: :bold, text: 'foo'}
-    ])
-  end
-
-  it "parses chained colors in shorthand syntax" do
-    expect(parser.parse("\e[32;44mfoo\e[0m")).to eq([
-      {foreground: :green, background: :on_blue, text: 'foo'}
-    ])
-  end
-
-  it "parses chained colors in regular syntax" do
-    expect(parser.parse("\e[32m\e[44mfoo\e[0m")).to eq([
-      {foreground: :green, background: :on_blue, text: 'foo'}
-    ])
-  end
-
-  it "parses many colors" do
-    expect(parser.parse("\e[32mfoo\e[0m \e[31mbar\e[0m")).to eq([
-      {foreground: :green, text: 'foo'},
-      {text: ' '},
-      {foreground: :red, text: 'bar'}
-    ])
-  end
-
-  it "parses nested colors with one reset" do
-    expect(parser.parse("\e[32mfoo\e[31mbar\e[0m")).to eq([
-      {foreground: :green, text: 'foo'},
-      {foreground: :red, text: 'bar'}
-    ])
-  end
-
-  it "parses nested colors with two resets" do
-    expect(parser.parse("\e[32mfoo\e[31mbar\e[0m\e[0m")).to eq([
-      {foreground: :green, text: 'foo'},
-      {foreground: :red, text: 'bar'}
-    ])
-  end
-
-  it "parses unrest color" do
-    expect(parser.parse("\e[32mfoo")).to eq([
-      {foreground: :green, text: 'foo'}
-    ])
-  end
-
-  it "parses malformed control sequence" do
-    expect(parser.parse("\eA foo bar ESC\e")).to eq([
-      {text: "\eA foo bar ESC\e"}
-    ])
-  end
-end

data/spec/unit/decorate_dsl_spec.rb

@@ -1,98 +0,0 @@
-# encoding: utf-8
-
-RSpec.describe Pastel, 'coloring dsl' do
-
-  subject(:pastel) { described_class.new(enabled: true) }
-
-  it "colors string" do
-    expect(pastel.red("unicorn")).to eq("\e[31municorn\e[0m")
-  end
-
-  it "allows to specify variable number of arguments" do
-    expect(pastel.red("unicorn", "running")).to eq("\e[31municornrunning\e[0m")
-  end
-
-  it "combines colored strings with regular ones" do
-    expect(pastel.red("Unicorns") + ' will rule ' + pastel.green('the World!')).
-      to eq("\e[31mUnicorns\e[0m will rule \e[32mthe World!\e[0m")
-  end
-
-  it "composes two color strings " do
-    expect(pastel.red.on_green("unicorn")).to eq("\e[31;42municorn\e[0m")
-  end
-
-  it "composes three color strings" do
-    expect(pastel.red.on_green.underline("unicorn")).
-      to eq("\e[31;42;4municorn\e[0m")
-  end
-
-  it "combines colored composed strings with regular ones" do
-    expect(pastel.red.on_green("Unicorns") + ' will rule ' +
-      pastel.green.on_red('the World!')).
-    to eq("\e[31;42mUnicorns\e[0m will rule \e[32;41mthe World!\e[0m")
-  end
-
-  it "allows one level nesting" do
-    expect(pastel.red("Unicorn" + pastel.blue("rule!"))).
-      to eq("\e[31mUnicorn\e[34mrule!\e[0m\e[0m")
-  end
-
-  it "allows to nest mixed styles" do
-    expect(pastel.red("Unicorn" + pastel.green.on_yellow.underline('running') + '!')).
-      to eq("\e[31mUnicorn\e[32;43;4mrunning\e[0m\e[31m!\e[0m")
-  end
-
-  it "allows for deep nesting" do
-    expect(pastel.red('r' + pastel.green('g' + pastel.yellow('y') + 'g') + 'r')).
-      to eq("\e[31mr\e[32mg\e[33my\e[0m\e[32mg\e[0m\e[31mr\e[0m")
-  end
-
-  it "allows for variable nested arguments" do
-    expect(pastel.red('r', pastel.green('g'), 'r')).
-      to eq("\e[31mr\e[32mg\e[0m\e[31mr\e[0m")
-  end
-
-  it "nests color foreground & background" do
-    expect(pastel.on_red('foo', pastel.green('bar'), 'foo')).
-      to eq("\e[41mfoo\e[32mbar\e[0m\e[41mfoo\e[0m")
-  end
-
-  it "allows to nest styles within block" do
-    string = pastel.red.on_green('Unicorns' +
-      pastel.green.on_red('will ', 'dominate' + pastel.yellow('the world!')))
-
-    expect(pastel.red.on_green('Unicorns') do
-      green.on_red('will ', 'dominate') do
-        yellow('the world!')
-      end
-    end).to eq(string)
-  end
-
-  it "doesn't decorate nil" do
-    expect(pastel.red(nil)).to eq('')
-  end
-
-  it "doesn't apply styles to empty string" do
-    expect(pastel.red('')).to eq('')
-  end
-
-  it "applies styles to empty with width more than 1" do
-    expect(pastel.red(' ')).to eq("\e[31m \e[0m")
-  end
-
-  it "applies color only once" do
-    expect(pastel.red.red.red("unicorn")).to eq(pastel.red("unicorn"))
-  end
-
-  it "raises error when chained with unrecognized color" do
-    expect {
-      pastel.unknown.on_red('unicorn')
-    }.to raise_error(Pastel::InvalidAttributeNameError)
-  end
-
-  it "raises error when doesn't recognize color" do
-    expect {
-      pastel.unknown('unicorn')
-    }.to raise_error(Pastel::InvalidAttributeNameError)
-  end
-end

data/spec/unit/decorator_chain_spec.rb

@@ -1,47 +0,0 @@
-# coding: utf-8
-
-RSpec.describe Pastel::DecoratorChain do
-  it "is enumerable" do
-    expect(described_class.new).to be_a(Enumerable)
-  end
-
-  it "is equatable" do
-    expect(described_class.new).to be_a(Equatable)
-  end
-
-  describe ".each" do
-    it "yields each decorator" do
-      first   = double('first')
-      second  = double('second')
-      chain   = described_class.new.add(first).add(second)
-      yielded = []
-
-      expect {
-        chain.each { |decorator| yielded << decorator }
-      }.to change { yielded }.from([]).to([first, second])
-    end
-  end
-
-  describe ".==" do
-    it "is equivalent with the same decorator" do
-      expect(described_class.new.add(:foo).add(:bar)).
-        to eq(described_class.new.add(:foo).add(:bar))
-    end
-
-    it "is not equivalent with different decorator" do
-      expect(described_class.new.add(:foo).add(:bar)).
-        not_to eq(described_class.new.add(:foo).add(:baz))
-    end
-
-    it "is not equivalent to another type" do
-      expect(described_class.new.add(:foo).add(:bar)).
-        not_to eq(:other)
-    end
-  end
-
-  describe ".inspect" do
-    it "displays object information" do
-      expect(described_class.new.inspect).to match(/decorators=\[\]/)
-    end
-  end
-end

data/spec/unit/delegator_spec.rb

@@ -1,38 +0,0 @@
-# coding: utf-8
-
-RSpec.describe Pastel::Delegator do
-
-  it "returns delegator for color without argument" do
-    pastel = Pastel.new(enabled: true)
-    expect(pastel.red).to be_a(Pastel::Delegator)
-  end
-
-  describe ".inspect" do
-    it "inspects delegator styles chain" do
-      chain = ['red', 'on_green']
-      delegator = described_class.new(:resolver, chain)
-      allow(delegator).to receive(:styles).and_return({red: 31, on_green: 42})
-      expect(delegator.inspect).to eq("#<Pastel @styles=[\"red\", \"on_green\"]>")
-    end
-  end
-
-  describe ".respond_to_missing?" do
-    context 'for a method defined on' do
-      it "returns true" do
-        resolver = double(:resolver)
-        chain = double(:chain)
-        decorator = described_class.new(resolver, chain)
-        expect(decorator.method(:styles)).not_to be_nil
-      end
-    end
-
-    context "for an undefined method " do
-      it "returns false" do
-        resolver = double(:resolver, color: true)
-        chain = double(:chain)
-        decorator = described_class.new(resolver, chain)
-        expect { decorator.method(:unknown) }.to raise_error(NameError)
-      end
-    end
-  end
-end

data/spec/unit/detach_spec.rb

@@ -1,48 +0,0 @@
-# coding: utf-8
-
-RSpec.describe Pastel, '.detach' do
-
-  subject(:pastel) { described_class.new(enabled: true) }
-
-  it "creates detached instance" do
-    error = pastel.red.bold.detach
-    expect(error).to be_a(Pastel::Detached)
-  end
-
-  it "ensures instance is immutable" do
-    error = pastel.red.detach
-    expect(error.frozen?).to be(true)
-  end
-
-  it "detaches colors combination" do
-    error = pastel.red.bold.detach
-    expect(error.call('unicorn')).to eq("\e[31;1municorn\e[0m")
-    expect(error.call('error')).to eq("\e[31;1merror\e[0m")
-  end
-
-  it "allows array like access" do
-    error = pastel.red.bold.detach
-    expect(error['unicorn']).to eq("\e[31;1municorn\e[0m")
-  end
-
-  it "allows alternative call invocation" do
-    error = pastel.red.bold.detach
-    expect(error.('unicorn')).to eq("\e[31;1municorn\e[0m")
-  end
-
-  it "calls detached colors with no arguments" do
-    warning = pastel.yellow.detach
-    expect(warning.call('')).to eq('')
-  end
-
-  it "inspects detached colors" do
-    warning = pastel.yellow.bold.detach
-    expect(warning.inspect).to eq('#<Pastel::Detached styles=[:yellow, :bold]>')
-  end
-
-  it "accepts multiple strings" do
-    error = pastel.red.bold.detach
-    expect(error.call('Unicorns', ' run ', 'wild')).
-      to eq("\e[31;1mUnicorns run wild\e[0m")
-  end
-end