rainbow 1.1.4 → 1.99.0

data/lib/rainbow/core.rb

@@ -0,0 +1,16 @@
+module Rainbow
+
+  class << self; attr_accessor :enabled; end
+  @enabled = true
+
+  TERM_EFFECTS = {
+    :reset     => 0,
+    :bright    => 1,
+    :italic    => 3,
+    :underline => 4,
+    :blink     => 5,
+    :inverse   => 7,
+    :hide      => 8,
+  }
+
+end

data/lib/rainbow/legacy.rb

@@ -0,0 +1,14 @@
+module Sickill
+  module Rainbow
+
+    def self.enabled=(value)
+      STDERR.puts "Rainbow gem notice: Sickill::Rainbow.enabled= is deprecated, use Rainbow.enabled= instead."
+      ::Rainbow.enabled = value
+    end
+
+    def self.enabled
+      ::Rainbow.enabled
+    end
+
+  end
+end

data/lib/rainbow/string.rb

@@ -0,0 +1,50 @@
+require 'rainbow'
+
+module Rainbow
+  module String
+    module InstanceMethods
+
+      def foreground(*color)
+        Rainbow(self).foreground(*color)
+      end
+
+      alias_method :color, :foreground
+      alias_method :colour, :foreground
+
+      def background(*color)
+        Rainbow(self).background(*color)
+      end
+
+      def reset
+        Rainbow(self).reset
+      end
+
+      def bright
+        Rainbow(self).bright
+      end
+
+      def italic
+        Rainbow(self).italic
+      end
+
+      def underline
+        Rainbow(self).underline
+      end
+
+      def blink
+        Rainbow(self).blink
+      end
+
+      def inverse
+        Rainbow(self).inverse
+      end
+
+      def hide
+        Rainbow(self).hide
+      end
+
+    end
+  end
+end
+
+::String.send(:include, Rainbow::String::InstanceMethods)

data/lib/rainbow/string_utils.rb

@@ -0,0 +1,23 @@
+module Rainbow
+  class StringUtils
+
+    def self.wrap_with_sgr(string, codes)
+      return string if codes.empty?
+
+      seq = "\e[" + codes.join(";") + "m"
+      match = string.match(/^(\e\[([\d;]+)m)*/)
+
+      if match
+        seq_pos = match.end(0)
+        string = string[0...seq_pos] + seq + string[seq_pos..-1]
+      else
+        string = seq + string
+      end
+
+      string = string + "\e[0m" unless string =~ /\e\[0m$/
+
+      string
+    end
+
+  end
+end

data/lib/rainbow/version.rb

@@ -0,0 +1,3 @@
+module Rainbow
+  VERSION = "1.99.0".freeze
+end

data/lib/rainbow/wrapper.rb

@@ -0,0 +1,76 @@
+require 'rainbow/core'
+require 'rainbow/string_utils'
+require 'rainbow/color'
+
+module Rainbow
+
+  class Wrapper < ::String
+
+    # Sets foreground color of this text.
+    def foreground(*values)
+      wrap_with_sgr(Color.build(:foreground, values).codes)
+    end
+
+    alias_method :color, :foreground
+    alias_method :colour, :foreground
+
+    # Sets background color of this text.
+    def background(*values)
+      wrap_with_sgr(Color.build(:background, values).codes)
+    end
+
+    # Resets terminal to default colors/backgrounds.
+    #
+    # It shouldn't be needed to use this method because all methods
+    # append terminal reset code to end of string.
+    def reset
+      wrap_with_sgr(TERM_EFFECTS[:reset])
+    end
+
+    # Turns on bright/bold for this text.
+    def bright
+      wrap_with_sgr(TERM_EFFECTS[:bright])
+    end
+
+    # Turns on italic style for this text (not well supported by terminal
+    # emulators).
+    def italic
+      wrap_with_sgr(TERM_EFFECTS[:italic])
+    end
+
+    # Turns on underline decoration for this text.
+    def underline
+      wrap_with_sgr(TERM_EFFECTS[:underline])
+    end
+
+    # Turns on blinking attribute for this text (not well supported by terminal
+    # emulators).
+    def blink
+      wrap_with_sgr(TERM_EFFECTS[:blink])
+    end
+
+    # Inverses current foreground/background colors.
+    def inverse
+      wrap_with_sgr(TERM_EFFECTS[:inverse])
+    end
+
+    # Hides this text (set its color to the same as background).
+    def hide
+      wrap_with_sgr(TERM_EFFECTS[:hide])
+    end
+
+    private
+
+    def wrap_with_sgr(codes) #:nodoc:
+      return self unless Rainbow.enabled
+
+      self.class.new(StringUtils.wrap_with_sgr(self, [*codes]))
+    end
+
+  end
+
+end
+
+def Rainbow(string)
+  Rainbow::Wrapper.new(string.to_s)
+end

data/rainbow.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rainbow/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rainbow"
+  spec.version       = Rainbow::VERSION
+  spec.authors       = ["Marcin Kulik"]
+  spec.email         = ["m@ku1ik.com"]
+  spec.description   = %q{Colorize printed text on ANSI terminals}
+  spec.summary       = %q{Colorize printed text on ANSI terminals}
+  spec.homepage      = "https://github.com/sickill/rainbow"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency 'mime-types', '< 2.0.0' if RUBY_VERSION < "1.9.0"
+end

data/spec/integration/rainbow_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+require 'rainbow'
+
+describe 'Rainbow() wrapper' do
+
+  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 by 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 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 color name' do
+    result = Rainbow('hello').background(:green)
+    expect(result).to eq("\e[42mhello\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 background coloring by color rgb (hex string)' do
+    result = Rainbow('hello').background('ff8040')
+    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
+      @enabled = Rainbow.enabled
+      Rainbow.enabled = false
+    end
+
+    after do
+      Rainbow.enabled = @enabled
+    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

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require 'rainbow/string'
+
+describe 'String mixin' do
+
+  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 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
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+if ENV["CI"] && (!defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby")
+  require 'coveralls'
+  Coveralls.wear!
+end
+
+RSpec.configure do |config|
+  config.before(:each) do
+    Rainbow.enabled = true
+  end
+end

data/spec/unit/color_spec.rb

@@ -0,0 +1,244 @@
+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_a(Color) }
+      end
+
+      context "when single symbol given" do
+        let(:values) { [:red] }
+
+        it { should be_a(Color) }
+      end
+
+      context "when single string given" do
+        let(:values) { ['#dead00'] }
+
+        it { should be_a(Color) }
+      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_a(Color) }
+      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
+end