cape-cod 0.1.2 → 0.1.3

data/README.md

@@ -53,15 +53,21 @@ You can include cape-cod in you String class:
 
     puts 'This is BOLD'.bold
 
-    puts 'and this is ITALIC'.fx(:italic) # You should probably avoid *italics* :\
+    puts 'and this is ITALIC'.fx(:italic) # You're not using this, right?
 
     puts 'Black n white'.fg(:black).on_white
 
     puts 'Magenta background'.bg(:magenta)
 
+    puts 'ZOMG THERE'S RGB AS WELL' background'.bg(220, 112, 234).fg(0xa30fd4)
+
 or use it like this:
 
-```puts CapeCod.yellow('We all live in a yellow submarine!')```
+    puts CapeCod.yellow('We all live in a yellow submarine!')
+
+    puts CapeCod.fx :bold, 'BOOM!'
+
+    puts CapeCod.fg(255, 0, 255, 'Super magenta!')
 
 All the public instance methods are available as module methods.
 

data/lib/cape-cod.rb

@@ -74,51 +74,50 @@ module CapeCod
     end
   end
 
-  def foreground(color) # :nodoc:
-    CapeCod.foreground(color, self)
+  def foreground(*color) # :nodoc:
+    CapeCod.foreground(*color, self)
   end
 
-  def background(color) # :nodoc:
-    CapeCod.background(color, self)
+  def background(*color) # :nodoc:
+    CapeCod.background(*color, self)
   end
 
   def effect(effect)    # :nodoc:
     CapeCod.effect(effect, self)
   end
 
-  alias_method :color, :foreground
-  alias_method :fg,    :foreground
-  alias_method :bg,    :background
-  alias_method :fx,    :effect
+  alias_method :fg, :foreground
+  alias_method :bg, :background
+  alias_method :fx, :effect
 
   class << self
 
     attr_accessor :enabled
+    alias_method  :enabled?, :enabled
 
-    def foreground(color, target) # :nodoc:
-      apply_escape_sequence(color_code_for(color, :foreground), target)
+    def foreground(*color, target) # :nodoc:
+      apply_escape_sequence(color_code_for(*color, :foreground), target)
     end
 
-    def background(color, target) # :nodoc:
-      apply_escape_sequence(color_code_for(color, :background), target)
+    def background(*color, target) # :nodoc:
+      apply_escape_sequence(color_code_for(*color, :background), target)
     end
 
     def effect(effect, target) # :nodoc:
       apply_escape_sequence(effect_code_for(effect), target)
     end
 
-    alias_method :color, :foreground
-    alias_method :fg,    :foreground
-    alias_method :bg,    :background
-    alias_method :fx,    :effect
+    alias_method :fg, :foreground
+    alias_method :bg, :background
+    alias_method :fx, :effect
 
     protected
 
     #
     # Returns the ANSI escape sequence for the given +color+.
     #
-    def color_code_for(color, ground)
-      Color.new(color, ground).ansi_code
+    def color_code_for(*color, ground)
+      Color.new(*color, ground).ansi_code
     end
 
     #
@@ -138,18 +137,30 @@ module CapeCod
     end
 
     #
-    # Prepends the given +string+ with the ANSI escape sequence for the
+    # Prepends the given +target+ with the ANSI escape sequence for the
     # given escape +code+. In case string is not empty, also appends a
     # reset sequence.
     #
-    def apply_escape_sequence(code, string)
-        return string unless self.enabled
+    def apply_escape_sequence(code, target)
+      return target unless self.enabled?
 
-        escape_sequence_for(code).tap do |s|
+      string = target.to_s
+
+      escape_sequence_for(code).tap do |s|
         unless string.nil? || string.empty?
           s << string << escape_sequence_for(effect_code_for(:reset))
         end
       end
     end
+
+    def ensure_windows_dependencies!
+      if RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
+        require 'Win32/Console/ANSI'
+      end
+    rescue LoadError
+      self.enabled = false
+    end
   end
+
+  ensure_windows_dependencies!
 end

data/lib/cape-cod/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module CapeCod
-  VERSION = '0.1.2'
+  VERSION = '0.1.3'
 end

data/spec/cape-cod/color_spec.rb

@@ -4,19 +4,33 @@ require 'spec_helper'
 
 describe CapeCod do
   describe CapeCod::Color do
-    context 'when instantiated with valid args' do
-      it 'produces proper color representation' do
-        color_from_symbol = CapeCod::Color.new(:yellow, :foreground).ansi_code
-        color_from_hex = CapeCod::Color.new(0xffff00, :foreground).ansi_code
-        color_from_rgb = CapeCod::Color.new(255, 255, 0, :foreground).ansi_code
+    context 'instantiated with valid args' do
+      context 'passed a three integer RGB representation' do
+        it 'produces proper color representation' do
+          expect(
+            CapeCod::Color.new(255, 255, 0, :foreground).ansi_code
+          ).to eql '38;5;210'
+        end
+      end
+
+      context 'passed an RGB integer representation' do
+        it 'produces proper color representation' do
+          expect(
+            CapeCod::Color.new(0xffff00, :foreground).ansi_code
+          ).to eql '38;5;210'
+        end
+      end
 
-        expect(color_from_symbol).to eql '33'
-        expect(color_from_hex).to eql '38;5;210'
-        expect(color_from_rgb).to eql '38;5;210'
+      context 'passed a color name' do
+        it 'produces proper color representation' do
+          expect(
+            CapeCod::Color.new(:yellow, :foreground).ansi_code
+          ).to eql '33'
+        end
       end
     end
 
-    context 'when instantiated with invalid args' do
+    context 'instantiated with invalid args' do
       it 'fails initialization' do
         expect {
           CapeCod::Color.new(:not_a_color, :foreground).ansi_code

data/spec/cape-cod_spec.rb

@@ -5,80 +5,197 @@ require 'spec_helper'
 describe CapeCod do
   it('has a version') { expect(CapeCod::VERSION).to be_a String }
 
-  context 'when disabled' do
-    before do
-      class String; include CapeCod end
+  context 'disabled' do
+    before(:all) { CapeCod.enabled = false }
 
-      CapeCod.enabled = false
+    context 'using singleton methods' do
+      it('does nothing') { expect(CapeCod.bold).to be_empty }
     end
 
-    it 'does nothing' do
-      expect(CapeCod.bold).to be_empty
-      expect(CapeCod.red('some text')).to eql('some text')
-      expect('some text'.red.bold.fx(:italic).bg(:cyan)).to eql('some text')
+    context 'using instance methods' do
+      before do
+        class StringWithCapeCodIncluded < String; include CapeCod end
+      end
+
+      let(:target) { StringWithCapeCodIncluded.new('some text') }
+
+      it 'does nothing' do
+        expect(target.red.bold.fx(:italic).bg(:cyan)).to eql target
+      end
     end
   end
 
-  context 'when enabled' do
-    before(:all) do CapeCod.enabled = true end
+  context 'enabled' do
+    before(:all) { CapeCod.enabled = true }
 
-    it 'generates proper escape sequences' do
-      expect(CapeCod.reset).to eq("\e[0m")
-    end
+    let(:target) { 'some text' }
+
+    context 'using singleton methods' do
+      let(:reset)       { %(\e[0m)  }
+      let(:bold)        { %(\e[1m)  }
+      let(:italic)      { %(\e[3m)  }
+      let(:red)         { %(\e[31m) }
+      let(:on_red)      { %(\e[41m) }
+      let(:rgb_red_fg)  { %(\e[38;5;180m) }
+      let(:rgb_red_bg)  { %(\e[48;5;180m) }
+
+      it { should respond_to :fx }
+      it { should respond_to :fg }
+      it { should respond_to :bg }
 
-    context 'when using singleton methods' do
       context 'no params given' do
-        it 'returns the escape sequence' do
-          expect(CapeCod.red).to    eq("\e[31m")
-          expect(CapeCod.on_red).to eq("\e[41m")
-          expect(CapeCod.bold).to   eq("\e[1m")
+        it 'returns the effect escape sequence' do
+          expect(CapeCod.bold).to eq(bold)
+        end
+
+        it 'returns the foreground color escape sequence' do
+          expect(CapeCod.red).to eq(red)
+        end
+
+        it 'returns the background color escape sequence' do
+          expect(CapeCod.on_red).to eq(on_red)
         end
       end
 
-      context 'when object param given' do
-        let(:obj) { ['foo', 10, :bar] }
+      context 'object param given' do
+        let(:target) { ['foo', 10, :bar] }
+
+        it 'returns a new object' do
+          expect(CapeCod.bold(target).object_id).to_not eql(target.object_id)
+        end
+
+        context 'using direct method' do
+          it "escapes the object with the effect's sequence" do
+            expect(CapeCod.bold(target)).to eq("#{bold}#{target}#{reset}")
+          end
+
+          it "escapes the object with the foreground color's sequence" do
+            expect(CapeCod.red(target)).to eq("#{red}#{target}#{reset}")
+          end
+
+          it "escapes the object with the background color's sequence" do
+            expect(CapeCod.on_red(target)).to eq("#{on_red}#{target}#{reset}")
+          end
+        end
 
-        it 'prepends the escape sequence and append a reset' do
+        context 'passing a symbol with color/effect name' do
+          it "escapes the object with the effect's sequence" do
+            expect(CapeCod.fx(:bold, target)).to eq("#{bold}#{target}#{reset}")
+          end
+
+          context 'colorization' do
+            context 'using color names' do
+              it "escapes the object with the foreground color's sequence" do
+                expect(CapeCod.fg(:red, target)).to(
+                  eq("#{red}#{target}#{reset}"))
+              end
+
+              it "escapes the object with the background color's sequence" do
+                expect(CapeCod.bg(:red, target)).to(
+                  eq("#{on_red}#{target}#{reset}"))
+              end
+            end
+
+            context 'using RGB' do
+              context 'passing three integers' do
+                it "escapes the object with the foreground color's sequence" do
+                  expect(CapeCod.fg(255, 0, 0, target)).to(
+                    eq("#{rgb_red_fg}#{target}#{reset}"))
+                end
+
+                it "escapes the object with the background color's sequence" do
+                  expect(CapeCod.bg(255, 0, 0, target)).to(
+                    eq("#{rgb_red_bg}#{target}#{reset}"))
+                end
+              end
+
+              context 'passing a single integer (hex representation)' do
+                it "escapes the object with the foreground color's sequence" do
+                  expect(CapeCod.fg(0xff0000, target)).to(
+                    eq("#{rgb_red_fg}#{target}#{reset}"))
+                end
+
+                it "escapes the object with the background color's sequence" do
+                  expect(CapeCod.bg(0xff0000, target)).to(
+                    eq("#{rgb_red_bg}#{target}#{reset}"))
+                end
+              end
+            end
+          end
+        end
 
-          expect(CapeCod.red(obj)).to    eq("\e[31m#{obj.to_s}\e[0m")
-          expect(CapeCod.on_red(obj)).to eq("\e[41m#{obj.to_s}\e[0m")
-          expect(CapeCod.bold(obj)).to   eq("\e[1m#{obj.to_s}\e[0m")
+        it 'works properly with multiple calls passing the same object' do
+          expect(
+            CapeCod.red(CapeCod.italic(CapeCod.bold(CapeCod.on_red(target))))
+          ).to eql(
+            ''.tap do |s|
+              s << "#{red}#{italic}#{bold}#{on_red}"
+              s << "#{target}"
+              s << "#{reset}#{reset}#{reset}#{reset}"
+            end
+          )
         end
       end
     end
 
-    context 'when using instance methods' do
-      before { class String; include CapeCod end }
+    context 'using instance methods' do
+      before(:all) { class String; include CapeCod end }
 
-      let(:string)    { 'foo bar baz' }
-      let(:bold)      { "\e[1m#{string}\e[0m" }
-      let(:red)       { "\e[31m#{string}\e[0m" }
-      let(:on_yellow) { "\e[43m#{string}\e[0m" }
-      let(:r_on_y)    { "\e[43m\e[31mfoo bar baz\e[0m\e[0m" }
-      let(:r_on_y_b)  { "\e[1m\e[43m\e[31mfoo bar baz\e[0m\e[0m\e[0m" }
+      it('provides the "fx" alias') { String.public_method_defined? :fx }
+      it('provides the "fg" alias') { String.public_method_defined? :fg }
+      it('provides the "bg" alias') { String.public_method_defined? :bg }
 
+      context 'using direct methods' do
+        it 'returns a new string' do
+          expect(target.red.object_id).to_not eql(target.object_id)
+        end
 
-      it 'returns a new string with the proper escape codes applied' do
+        it 'behaves the same way as singleton methods for foreground colors' do
+          expect(target.red).to eql(CapeCod.red(target))
+        end
 
-        expect(string.bold).to_not eql(string)
+        it 'behaves the same way as singleton methods for background colors' do
+          expect(target.on_red).to eql(CapeCod.on_red(target))
+        end
 
-        expect(string.bold).to      eql(bold)
-        expect(string.red).to       eql(red)
-        expect(string.on_yellow).to eql(on_yellow)
+        it 'behaves the same way as singleton methods for effects' do
+          expect(target.bold).to eql(CapeCod.bold(target))
+        end
 
-        expect(string.effect(:bold)).to       eql(bold)
-        expect(string.foreground(:red)).to    eql(red)
-        expect(string.background(:yellow)).to eql(on_yellow)
-        expect(string.fx(:bold)).to           eql(bold)
-        expect(string.fg(:red)).to            eql(red)
-        expect(string.bg(:yellow)).to         eql(on_yellow)
+        it 'behaves the same way as singleton methods for chained calls' do
+          expect(
+            target.on_red.bold.italic.red
+          ).to eql(
+            CapeCod.red(CapeCod.italic(CapeCod.bold(CapeCod.on_red(target))))
+          )
+        end
+      end
 
-        expect(string.red.on_yellow).to eql(r_on_y)
-        expect(string.fg(:red).bg(:yellow)).to eql(r_on_y)
+      context 'passing a symbol with color/effect name' do
+        it 'returns a new string' do
+          expect(target.red.object_id).to_not eql(target.object_id)
+        end
 
-        expect(string.red.on_yellow.bold).to eql(r_on_y_b)
-        expect(string.fg(:red).bg(:yellow).effect(:bold)).to eql(r_on_y_b)
+        it 'behaves the same way as singleton methods for foreground colors' do
+          expect(target.foreground(:red)).to eql(CapeCod.red(target))
+        end
+
+        it 'behaves the same way as singleton methods for background colors' do
+          expect(target.background(:red)).to eql(CapeCod.on_red(target))
+        end
+
+        it 'behaves the same way as singleton methods for effects' do
+          expect(target.effect(:bold)).to eql(CapeCod.bold(target))
+        end
+
+        it 'behaves the same way as singleton methods for chained calls' do
+          expect(
+            target.bg(:red).fx(:bold).fx(:italic).fg(:red)
+          ).to eql(
+            CapeCod.red(CapeCod.italic(CapeCod.bold(CapeCod.on_red(target))))
+          )
+        end
+      end
     end
   end
-  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cape-cod
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-19 00:00:00.000000000 Z
+date: 2013-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -43,6 +43,38 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: ! 'CapeCod offers you simple stupid way of colorizing and applying effects
   to your