pastel 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: df0d822f2378510e2c8f751d179c208585fb2e38
+  data.tar.gz: bf0a8a93193af9c35ff862e0e69373d97bf29d51
+SHA512:
+  metadata.gz: 7dcf28176858eeaccc03eb33d702214274e72d32082887d66938afa1f7d6f38b24fa7523437ed4249d51e6c7425db729e42ad50cd83daf0747ea953abb96157c
+  data.tar.gz: c6a17854cb0c7328474da74d4c8ffee8f0af6c757f729bbef91ec02da7202e91d4da108ef318be8dcf4ab51e1fa20a9985cd8e3ed35c4f5f50db3de7e888488d

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.ruby-gemset

@@ -0,0 +1 @@
+pastel

data/.ruby-version

@@ -0,0 +1 @@
+2.0.0

data/.travis.yml

@@ -0,0 +1,24 @@
+language: ruby
+bundler_args: --without yard benchmarks
+script: "bundle exec rake ci"
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - ruby-head
+matrix:
+  include:
+    - rvm: jruby-19mode
+    - rvm: jruby-20mode
+    - rvm: jruby-21mode
+    - rvm: jruby-head
+    - rvm: rbx-2
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: jruby-head
+    - rvm: jruby-20mode
+    - rvm: jruby-21mode
+    - rvm: rbx-2
+  fast_finish: true
+branches:
+  only: master

data/Gemfile

@@ -0,0 +1,15 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development do
+  gem 'rake',  '~> 10.3.2'
+  gem 'rspec', '~> 3.1.0'
+  gem 'yard',  '~> 0.8.7'
+end
+
+group :metrics do
+  gem 'coveralls', '~> 0.7.0'
+  gem 'simplecov', '~> 0.8.2'
+  gem 'yardstick', '~> 0.9.9'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Piotr Murach
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,191 @@
+# Pastel
+[![Gem Version](https://badge.fury.io/rb/pastel.png)][gem]
+[![Build Status](https://secure.travis-ci.org/peter-murach/pastel.png?branch=master)][travis]
+[![Code Climate](https://codeclimate.com/github/peter-murach/pastel.png)][codeclimate]
+
+[gem]: http://badge.fury.io/rb/pastel
+[travis]: http://travis-ci.org/peter-murach/pastel
+[codeclimate]: https://codeclimate.com/github/peter-murach/pastel
+
+Terminal output styling with intuitive and clean API that doesn't monkey patch String class.
+
+**Pastel** is minimal and focused to work in all terminal emulators.
+
+## Features
+
+* Doesn't monkey patch `String`
+* Intuitive and expressive API
+* Minimal and focused to work on all terminal emulators
+* Auto-detection of color support
+* Performant
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'pastel'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install pastel
+
+## Contents
+
+* [1. Usage](#1-usage)
+* [2. Interface](#2-interface)
+  * [2.1 Color](#21-color)
+  * [2.2 Decorate](#22-decorate)
+  * [2.3 Strip](#23-strip)
+  * [2.4 Styles](#24-styles)
+  * [2.5 Valid?](#25-valid)
+* [3. The available styles](#3-the-available-styles)
+
+## 1 Usage
+
+**Pastel** provides a simple, minimal and intuitive API for styling your strings:
+
+```ruby
+pastel = Pastel.new
+
+pastel.red('Unicorns!')
+```
+
+It allows you to combine styled strings with regular ones:
+
+```ruby
+pastel.red('Unicorns') + ' will rule ' + pastel.green('the World!')
+```
+
+You can compose multiple styles through chainable API:
+
+```ruby
+pastel.red.on_green.bold('Unicorns!')
+```
+
+It supports variable number of arguments with individual styling:
+
+```ruby
+pastel.red('Unicorns', 'are', 'running', 'everywhere!')
+```
+
+You can also nest styles as follows:
+
+```ruby
+pastel.red('Unicorns ', pastel.on_green('everywhere!'))
+```
+
+## 2 Interface
+
+### 2.1 Color
+
+You can pass variable number of styled strings like so:
+
+```ruby
+pastel.red('Unicorns', pastel.on_yellow('are running', pastel.bold.underline('everywhere')), '!')
+```
+
+Please refer to [3. The available styles](#3-the-available-styles) section for full list of supported styles.
+
+### 2.2 Decorate
+
+This method is a lower level string styling call that takes as the first argument the string to style and any number of attributes, and returns string wrapped in styles.
+
+```ruby
+pastel.decorate('Unicorn', :green, :on_blue, :bold)
+```
+
+### 2.3 Strip
+
+Strip all color sequence characters:
+
+```ruby
+pastel.strip("\e[1m\e[34mbold blue text\e[0m"")  # => "bold blue text"
+```
+
+### 2.4 Styles
+
+To get a full list of supported styles with the corresponding color codes do:
+
+```ruby
+pastel.styles
+```
+
+### 2.5 Valid?
+
+Determine whether a color is valid:
+
+```ruby
+pastel.valid?(:red)     # => true
+pastel.valid?(:unicorn) # => false
+```
+
+## 3 The available styles
+
+**Pastel** works with terminal emulators that support minimum sixteen colors. It provides `16` basic colors and `8` styles with further `16` bright color pairs. The corresponding bright color is obtained by prepending the `bright` to the normal color name. For example, color `red` will have `bright_red` as its pair.
+
+The variant with `on_` prefix will style the text background color.
+
+The foreground colors:
+
+* `black`
+* `red`
+* `green`
+* `yellow`
+* `blue`
+* `magenta`
+* `cyan`
+* `white`
+* `bright_black`
+* `bright_red`
+* `bright_green`
+* `bright_yellow`
+* `bright_blue`
+* `bright_magenta`
+* `bright_cyan`
+* `bright_white`
+
+The background colors:
+
+* `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`
+
+Generic styles:
+
+* `clear`
+* `bold`
+* `dim`
+* `italic`
+* `underline`
+* `inverse`
+* `hidden`
+* `strikethrough`
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/pastel/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+## Copyright
+
+Copyright (c) 2014 Piotr Murach. See LICENSE for further details.

data/Rakefile

@@ -0,0 +1,8 @@
+# encoding: utf-8
+
+require "bundler/gem_tasks"
+
+FileList['tasks/**/*.rake'].each(&method(:import))
+
+desc 'Run all specs'
+task ci: %w[ spec ]

data/lib/pastel.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+require 'equatable'
+require 'pastel/ansi'
+require 'pastel/color'
+require 'pastel/color_resolver'
+require 'pastel/delegator'
+require 'pastel/decorator_chain'
+require 'pastel/version'
+
+module Pastel
+  # Raised when the style attribute is not supported
+  InvalidAttributeNameError = Class.new(::ArgumentError)
+
+  def new
+    Delegator.for(DecoratorChain.empty)
+  end
+
+  module_function :new
+end # Pastel

data/lib/pastel/ansi.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+module Pastel
+  # Mixin that provides ANSI codes
+  module ANSI
+    CLEAR         = "\e[0m"
+
+    BOLD          = "\e[1m"
+    DIM           = "\e[2m"
+    ITALIC        = "\e[3m"
+    UNDERLINE     = "\e[4m"
+    INVERSE       = "\e[7m"
+    HIDDEN        = "\e[8m"
+    STRIKETHROUGH = "\e[9m"
+
+    # Escape codes for text color.
+    BLACK         = "\e[30m"
+    RED           = "\e[31m"
+    GREEN         = "\e[32m"
+    YELLOW        = "\e[33m"
+    BLUE          = "\e[34m"
+    MAGENTA       = "\e[35m"
+    CYAN          = "\e[36m"
+    WHITE         = "\e[37m"
+
+    BRIGHT_BLACK   = "\e[90m"
+    BRIGHT_RED     = "\e[91m"
+    BRIGHT_GREEN   = "\e[92m"
+    BRIGHT_YELLOW  = "\e[93m"
+    BRIGHT_BLUE    = "\e[94m"
+    BRIGHT_MAGENTA = "\e[95m"
+    BRIGHT_CYAN    = "\e[96m"
+
+    # Escape codes for background color.
+    ON_BLACK         = "\e[40m"
+    ON_RED           = "\e[41m"
+    ON_GREEN         = "\e[42m"
+    ON_YELLOW        = "\e[43m"
+    ON_BLUE          = "\e[44m"
+    ON_MAGENTA       = "\e[45m"
+    ON_CYAN          = "\e[46m"
+    ON_WHITE         = "\e[47m"
+
+    ON_BRIGHT_BLACK   = "\e[100m"
+    ON_BRIGHT_RED     = "\e[101m"
+    ON_BRIGHT_GREEN   = "\e[102m"
+    ON_BRIGHT_YELLOW  = "\e[103m"
+    ON_BRIGHT_BLUE    = "\e[104m"
+    ON_BRIGHT_MAGENTA = "\e[105m"
+    ON_BRIGHT_CYAN    = "\e[106m"
+
+    BACKGROUND_COLORS = constants.grep(/^ON_*/).freeze
+  end # ANSI
+end # Pastel

data/lib/pastel/color.rb

@@ -0,0 +1,139 @@
+# encoding: utf-8
+
+module Pastel
+  # A class responsible for coloring strings.
+  class Color
+    include Equatable
+    include ANSI
+
+    attr_reader :enabled
+
+    # Initialize a Terminal Color
+    #
+    # @api public
+    def initialize(enabled = false)
+      @enabled = enabled
+    end
+
+    # Disable coloring of this terminal session
+    #
+    # @api public
+    def disable!
+      @enabled = false
+    end
+
+    # Apply ANSI color to the given string.
+    #
+    # @param [String] string
+    #   text to add ANSI strings
+    #
+    # @param [Array[Symbol]] colors
+    #
+    # @example
+    #   color.decorate "text", :yellow, :on_green, :underline
+    #
+    # @return [String]
+    #
+    # @api public
+    def decorate(string, *colors)
+      return string if string.empty?
+      validate(*colors)
+      ansi_colors = colors.map { |color| lookup(color) }
+      ansi_string = "#{ansi_colors.join}#{string}#{ANSI::CLEAR}"
+      if ansi_string =~ /(#{Regexp.quote(ANSI::CLEAR)}){2,}/
+        ansi_string.gsub!(/(#{Regexp.quote(ANSI::CLEAR)}){2,}/, '')
+      end
+      matches = ansi_string.scan(/#{Regexp.quote(ANSI::CLEAR)}/)
+      if matches.length >= 2
+        ansi_string.sub!(/#{Regexp.quote(ANSI::CLEAR)}/, ansi_colors.join)
+      end
+      ansi_string
+    end
+
+    # Same as instance method.
+    #
+    # @return [String]
+    #
+    # @api public
+    def self.decorate(string, *colors)
+      new.decorate(string, *colors)
+    end
+
+    # Strip ANSI color codes from a string.
+    #
+    # @param [String] string
+    #
+    # @return [String]
+    #
+    # @api public
+    def strip(string)
+      string.to_s.gsub(/(\[)?\033(\[)?[;?\d]*[\dA-Za-z](\])?/, '')
+    end
+
+    # Return raw color code without embeding it into a string.
+    #
+    # @return [Array[String]]
+    #   ANSI escape codes
+    #
+    # @api public
+    def code(*colors)
+      validate(*colors)
+      colors.map { |color| lookup(color) }
+    end
+
+    # Find color representation.
+    #
+    # @param [Symbol,String] color
+    #   the color name to lookup by
+    #
+    # @return [String]
+    #   the ANSI code
+    #
+    # @api private
+    def lookup(color)
+      self.class.const_get(color.to_s.upcase)
+    end
+
+    # Expose all ANSI color names and their codes
+    #
+    # @return [Hash[Symbol]]
+    #
+    # @api public
+    def styles
+      ANSI.constants(false).each_with_object({}) do |col, acc|
+        acc[col.to_sym.downcase] = lookup(col)
+        acc
+      end
+    end
+
+    # List all available style names
+    #
+    # @return [Array[Symbol]]
+    #
+    # @api public
+    def style_names
+      styles.keys
+    end
+
+    # Check if provided colors are known colors
+    #
+    # @param [Array[Symbol,String]]
+    #   the colors to check
+    #
+    # @reutrn [Boolean]
+    #
+    # @api public
+    def valid?(*colors)
+      colors.all? { |color| style_names.include?(color.to_sym) }
+    end
+
+    protected
+
+    # @api private
+    def validate(*colors)
+      return if valid?(*colors)
+      fail InvalidAttributeNameError, 'Bad style or unintialized constant, ' \
+        " valid styles are: #{style_names.join(', ')}."
+    end
+  end # Color
+end # TTY

data/lib/pastel/color_resolver.rb

@@ -0,0 +1,23 @@
+# coding: utf-8
+
+module Pastel
+  # Contains logic for resolving styles applied to component
+  #
+  # Used internally by {Delegator}.
+  #
+  # @api private
+  class ColorResolver
+    attr_reader :color
+
+    def initialize(color = Color.new)
+      @color = color
+    end
+
+    def resolve(base, *args)
+      unprocessed_string = args.join
+      base.reduce(unprocessed_string) do |component, decorator|
+        color.decorate(component, decorator)
+      end
+    end
+  end # ColorResolver
+end # Pastel

data/lib/pastel/decorator_chain.rb

@@ -0,0 +1,40 @@
+# coding: utf-8
+
+module Pastel
+  # Collects a list of decorators for styling a string
+  #
+  # @api private
+  class DecoratorChain
+    include Enumerable
+    include Equatable
+
+    attr_reader :decorators
+
+    def initialize(decorators = [])
+      @decorators = decorators
+    end
+
+    # Add decorator
+    #
+    # @api public
+    def add(decorator)
+      self.class.new(decorators + [decorator])
+    end
+
+    # Iterate over list of decorators
+    #
+    # @api public
+    def each(&block)
+      decorators.each(&block)
+    end
+
+    # Create an empty decorator chain
+    #
+    # @return [DecoratorChain]
+    #
+    # @api public
+    def self.empty
+      new([])
+    end
+  end # DecoratorChain
+end # Patel

data/lib/pastel/delegator.rb

@@ -0,0 +1,44 @@
+# coding: utf-8
+
+module Pastel
+  # Wrapes the {DecoratorChain} to allow for easy resolution
+  # of string coloring.
+  #
+  # @api private
+  class Delegator
+    extend Forwardable
+
+    attr_reader :base
+
+    attr_reader :resolver
+
+    def_delegators :@color, :valid?, :styles, :strip, :decorate
+
+    def initialize(base)
+      @base = base
+      @color = Color.new
+      @resolver = ColorResolver.new(@color)
+    end
+
+    # @api public
+    def self.for(value)
+      new(value)
+    end
+
+    protected
+
+    def method_missing(method_name, *args, &block)
+      new_base  = base.add(method_name)
+      delegator = self.class.new(new_base)
+      if args.empty?
+        delegator
+      else
+        resolver.resolve(new_base, *args)
+      end
+    end
+
+    def respond_to_missing?(name, include_all = false)
+      super || @color.respond_to?(name, include_all)
+    end
+  end # Delegator
+end # Pastel

data/lib/pastel/version.rb

@@ -0,0 +1,5 @@
+# coding: utf-8
+
+module Pastel
+  VERSION = "0.1.0"
+end

data/pastel.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pastel/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "pastel"
+  spec.version       = Pastel::VERSION
+  spec.authors       = ["Piotr Murach"]
+  spec.email         = [""]
+  spec.summary       = %q{Terminal strings styling with intuitive and clean API.}
+  spec.description   = %q{Terminal strings styling with intuitive and clean API.}
+  spec.homepage      = "https://github.com/peter-murach/pastel"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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.6"
+  spec.add_development_dependency "equatable", "~> 0.5"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'pastel'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  if config.files_to_run.one?
+    config.default_formatter = 'doc'
+  end
+
+  config.profile_examples = 2
+
+  config.order = :random
+
+  Kernel.srand config.seed
+end

data/spec/unit/color/code_spec.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe Pastel::Color, '.code' do
+  let(:string) { "This is a \e[1m\e[34mbold blue text\e[0m" }
+
+  subject(:color) { described_class.new }
+
+  it 'finds single code' do
+    expect(color.code(:black)).to eq(["\e[30m"])
+  end
+
+  it 'finds more than one code' do
+    expect(color.code(:black, :green)).to eq(["\e[30m", "\e[32m"])
+  end
+
+  it "doesn't find code" do
+    expect { color.code(:unkown) }.to raise_error(ArgumentError)
+  end
+end

data/spec/unit/color/decorate_spec.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe Pastel::Color, '.decorate' do
+  let(:string) { 'string' }
+
+  subject(:color) { described_class.new }
+
+  it "doesn't apply styling to empty string" do
+    expect(color.decorate('')).to eq('')
+  end
+
+  it 'applies green text to string' do
+    expect(color.decorate(string, :green)).to eq("\e[32m#{string}\e[0m")
+  end
+
+  it 'applies red text background to string' do
+    expect(color.decorate(string, :on_red)).to eq("\e[41m#{string}\e[0m")
+  end
+
+  it 'applies style and color to string' do
+    expect(color.decorate(string, :bold, :green)).to eq("\e[1m\e[32m#{string}\e[0m")
+  end
+
+  it 'applies style, color and background to string' do
+    text = color.decorate(string, :bold, :green, :on_blue)
+    expect(text).to eq("\e[1m\e[32m\e[44m#{string}\e[0m")
+  end
+
+  it "applies styles to nested text" do
+    decorated = color.decorate(string + color.decorate(string, :red) + string, :green)
+    expect(decorated).to eq("\e[32m#{string}\e[31m#{string}\e[32m#{string}\e[0m")
+  end
+
+  it 'errors for unknown color' do
+    expect {
+      color.decorate(string, :crimson)
+    }.to raise_error(Pastel::InvalidAttributeNameError)
+  end
+end

data/spec/unit/color/strip_spec.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe Pastel::Color, '.strip' do
+  let(:instance) { described_class.new }
+
+  subject(:color) { instance.strip(string) }
+
+  context 'with ansi colors' do
+    let(:string)   { "This is a \e[1m\e[34mbold blue text\e[0m" }
+
+    it 'removes color from string' do
+      is_expected.to eq('This is a bold blue text')
+    end
+  end
+
+  context 'with octal in encapsulating brackets' do
+    let(:string) { "\[\033[01;32m\]u@h \[\033[01;34m\]W $ \[\033[00m\]" }
+
+    it { is_expected.to eq('u@h W $ ') }
+  end
+
+  context 'with octal without brackets' do
+    let(:string) { "\033[01;32mu@h \033[01;34mW $ \033[00m" }
+
+    it { is_expected.to eq('u@h W $ ') }
+  end
+
+  context 'with octal with multiple colors' do
+    let(:string) { "\e[3;0;0;t\e[8;50;0t" }
+
+    it { is_expected.to eq('') }
+  end
+
+  context 'with control codes' do
+    let(:string ) { "WARN. \x1b[1m&\x1b[0m ERR. \x1b[7m&\x1b[0m" }
+
+    it { is_expected.to eq('WARN. & ERR. &') }
+  end
+
+  context 'with escape byte' do
+    let(:string) { "This is a \e[1m\e[34mbold blue text\e[0m" }
+
+    it { is_expected.to eq("This is a bold blue text") }
+  end
+end

data/spec/unit/color/styles_spec.rb

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

data/spec/unit/decorator_chain_spec.rb

@@ -0,0 +1,49 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+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

@@ -0,0 +1,23 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe Pastel::Delegator do
+  describe ".respond_to_missing?" do
+    context 'for a method defined on' do
+      it "returns true" do
+        chain = double(:chain)
+        decorator = described_class.new(chain)
+        expect(decorator.method(:styles)).not_to be_nil
+      end
+    end
+
+    context "for an undefined method " do
+      it "returns false" do
+        chain = double(:chain)
+        decorator = described_class.new(chain)
+        expect { decorator.method(:unknown) }.to raise_error(NameError)
+      end
+    end
+  end
+end

data/spec/unit/new_spec.rb

@@ -0,0 +1,61 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe Pastel do
+
+  subject(:pastel) { described_class.new }
+
+  describe 'coloring string' do
+    it "doesn't apply styles to empty string" do
+      expect(pastel.red('')).to eq('')
+    end
+
+    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 color strings" do
+      expect(pastel.red.on_green.underline("unicorn")).
+        to eq("\e[4m\e[42m\e[31municorn\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[4m\e[43m\e[32mrunning\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[32mg\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[31mr\e[0m")
+    end
+  end
+
+  describe '.valid?' do
+    it "when valid returns true" do
+      expect(pastel.valid?(:red)).to eq(true)
+    end
+
+    it "returns false when invalid" do
+      expect(pastel.valid?(:unknown)).to eq(false)
+    end
+  end
+
+  it "respond to styles method" do
+    expect(pastel).to respond_to(:styles)
+  end
+end

data/tasks/console.rake

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+desc 'Load gem inside irb console'
+task :console do
+  require 'irb'
+  require 'irb/completion'
+  require File.join(__FILE__, '../../lib/pastel')
+  ARGV.clear
+  IRB.start
+end

data/tasks/coverage.rake

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+desc 'Measure code coverage'
+task :coverage do
+  begin
+    original, ENV['COVERAGE'] = ENV['COVERAGE'], 'true'
+    Rake::Task['spec'].invoke
+  ensure
+    ENV['COVERAGE'] = original
+  end
+end

data/tasks/spec.rake

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+begin
+  require 'rspec/core/rake_task'
+
+  desc 'Run all specs'
+  RSpec::Core::RakeTask.new(:spec) do |task|
+    task.pattern = 'spec/{unit,integration}{,/*/**}/*_spec.rb'
+  end
+
+  namespace :spec do
+    desc 'Run unit specs'
+    RSpec::Core::RakeTask.new(:unit) do |task|
+      task.pattern = 'spec/unit{,/*/**}/*_spec.rb'
+    end
+
+    desc 'Run integration specs'
+    RSpec::Core::RakeTask.new(:integration) do |task|
+      task.pattern = 'spec/integration{,/*/**}/*_spec.rb'
+    end
+  end
+
+rescue LoadError
+  %w[spec spec:unit spec:integration].each do |name|
+    task name do
+      $stderr.puts "In order to run #{name}, do `gem install rspec`"
+    end
+  end
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: pastel
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Piotr Murach
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: equatable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.5'
+description: Terminal strings styling with intuitive and clean API.
+email:
+- ''
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .ruby-gemset
+- .ruby-version
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/pastel.rb
+- lib/pastel/ansi.rb
+- lib/pastel/color.rb
+- lib/pastel/color_resolver.rb
+- lib/pastel/decorator_chain.rb
+- lib/pastel/delegator.rb
+- lib/pastel/version.rb
+- pastel.gemspec
+- spec/spec_helper.rb
+- spec/unit/color/code_spec.rb
+- spec/unit/color/decorate_spec.rb
+- spec/unit/color/strip_spec.rb
+- spec/unit/color/styles_spec.rb
+- spec/unit/decorator_chain_spec.rb
+- spec/unit/delegator_spec.rb
+- spec/unit/new_spec.rb
+- tasks/console.rake
+- tasks/coverage.rake
+- tasks/spec.rake
+homepage: https://github.com/peter-murach/pastel
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Terminal strings styling with intuitive and clean API.
+test_files:
+- spec/spec_helper.rb
+- spec/unit/color/code_spec.rb
+- spec/unit/color/decorate_spec.rb
+- spec/unit/color/strip_spec.rb
+- spec/unit/color/styles_spec.rb
+- spec/unit/decorator_chain_spec.rb
+- spec/unit/delegator_spec.rb
+- spec/unit/new_spec.rb
+has_rdoc: