col 1.0.0

data/LICENCE

@@ -0,0 +1,19 @@
+Copyright (c) 2005 Gavin Sinclair (gsinclair@gmail.com)
+
+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

@@ -0,0 +1,35 @@
+col: high-level console color formatting for Ruby
+
+If you want a dash of color in your Ruby console program, use Term::ANSIColor.
+If your color formatting requirements are more complicated, use Col.
+Col provides as much convenience as possible without modifying builtin classes.
+
+Synopsis
+
+    require 'col'
+
+    puts Col("Hello world!").red.bold
+    puts Col("Hello world!").rb
+    puts Col("Hello world!").fmt [:red, :bold]
+    puts Col("Hello world!").fmt :rb
+
+    puts Col("Hello ", "world!").fmt :red, :green
+    puts Col("Hello ", "world!").fmt "r,g"
+
+    puts Col("Hello ", "world!").fmt [:red, :bold], [:green, :bold]
+    puts Col("Hello ", "world!").fmt "rb,gb"
+
+    puts Col("Hello ", "world!").fmt [:bold], [:cyan, :italic, :on_white]
+    puts Col("Hello ", "world!").fmt "_b,ciow"
+
+    puts Col("Hello ", "world!").fmt [:blue, :on_yellow], [:on_green]
+    puts Col("Hello ", "world!").fmt "b_oy,__og"
+
+    puts Col.inline( "Hello ", :red, "world!", :blue )
+
+    puts Col.inline(
+      "Hello ",   [:red, :bold, :on_white],
+      "world!",   :b_oy
+    )
+
+See http://gsinclair.github.com/col.html for full details.

data/lib/col.rb

@@ -0,0 +1,342 @@
+require 'rubygems'
+require 'term/ansicolor'
+
+# --------------------------------------------------------------------------- #
+
+class Col
+  # args: array of strings (to_s is called on each)
+  def initialize(*args)
+    @strings = args.map { |a| a.to_s }
+  end
+
+  def Col.[](*args)
+    Col.new(*args)
+  end
+
+  COLORED_REGEXP = /\e\[                             # opening character sequence
+                         (?: [34][0-7] | [0-9] ) ?   # optional code
+                     ( ; (?: [34][0-7] | [0-9] ))*   # more optional codes
+                    m                                # closing character
+                   /x
+
+  # Convenience method to remove color codes from a string.
+  # Also available as Col.plain.
+  def Col.uncolored(string)
+    string.gsub(COLORED_REGEXP, '')
+  end
+
+  # Convenience method to remove color codes from a string.
+  # Also available as Col.uncolored.
+  def Col.plain(string)
+    string.gsub(COLORED_REGEXP, '')
+  end
+
+  def Col.inline(*args)
+    unless args.size.even?
+      raise Col::Error, "Col.inline requires an even number of arguments"
+    end
+    String.new.tap { |result|
+      args.each_slice(2) do |string, format|
+        result << Col(string.to_s).fmt(format)
+      end
+    }
+  end
+
+  # e.g.
+  #   Col("one", "two", "three", "four").fmt "rb,y,cb,_b"
+  #     # same as:
+  #       "one".red.bold + "two".yellow + "three".cyan.bold + "four".bold
+  #
+  #   Col
+  def fmt(*spec)
+    ::Col::Formatter.new(@strings, *spec).result
+  end
+
+  def to_s
+    @strings.join
+  end
+
+  def method_missing(message, *args, &block)
+    unless args.empty?
+      super   # We're not interested in a message with arguments; NoMethodError
+    end
+    if Col::DB.method?(message)
+      Col.new( self.fmt(message) )   # Col["..."].yellow -> Col
+                                     #  to allow Col["..."].yellow.bold
+    else
+      self.fmt(message)              # Col["..."].gbow   -> String
+    end
+  end
+end
+
+def Col(*args)
+  Col.new(*args)
+end
+
+# --------------------------------------------------------------------------- #
+
+class Col::Error < StandardError
+end
+
+# --------------------------------------------------------------------------- #
+
+class Col::Formatter
+  def initialize(strings, *spec)
+    check_correct_number_of_arguments(strings, *spec)
+    @strings = strings
+    @format_spec = normalise_format_spec(*spec)
+  end
+
+  def result
+    unless @strings.size == @format_spec.size
+      raise Col::Error, "mismatching strings and specs"
+    end
+    String.new.tap { |str|
+      @strings.zip(@format_spec).each do |string, spec|
+        d = decorated_string(string, spec)
+        str << d
+      end
+    }
+  end
+
+  # e.g.
+  #   string = "hello"
+  #   spec = [:yellow, :bold, :on_red]
+  #   result = "hello".send(:yellow).send(:bold).send(:on_red)
+  def decorated_string(string, spec)
+    raise Col::Error unless string.is_a? String and spec.is_a? Array \
+                        and spec.all? { |e| e.is_a? Symbol }
+    spec.inject(string) { |str, symbol| Term::ANSIColor.send(symbol, str) }
+  end
+
+  #
+  # In general, there should be the same number of arguments as there are
+  # strings:
+  #
+  #   Col["one"].fmt( :b )
+  #   Col["one", "two"].fmt( [:red, :on_white], [:bold, :negative] )
+  #   Col["one", "two", "three"].fmt( :yellow, [:green, :bold], :italic )
+  #   Col["one", "two", "three", "four"].fmt(:rb, :y, :cb, :m)
+  #   Col["one", "two", "three", "four"].fmt "rb,y,cb,m"
+  #
+  # As a special case, if there is only one string, it can have any number of
+  # arguments:
+  #
+  #   Col["string"].fmt( :yellow, :bold, :italic, :blink, :negative, :on_magenta )
+  #
+  # If the number of arguments is incorrect, a Col::Error is thrown.
+  #
+  def check_correct_number_of_arguments(strings, *spec)
+    nargs = spec.size
+    if nargs == 1 and spec.first.is_a? String
+      nargs = spec.first.split(/,/).size
+    end
+    if strings.size > 1 and nargs != strings.size
+      raise Col::Error, "incorrect number of arguments: #{render(spec)}"
+    end
+  end
+
+  #
+  # Each spec in the following groups is equivalent.  The last one is
+  # normalised.
+  #
+  #   [ :rb ]
+  #   [ "rb" ]
+  #   [ [:red, :bold] ]
+  #
+  #   [ :rb, :_n, :y ]
+  #   [ "rb", "_n", "y" ]
+  #   [ [:red, :bold], [:negative], [:yellow] ]
+  #
+  #   [ [:green, :concealed], :blue, :bold ]
+  #   [ [:green, :concealed], [:blue], [:bold] ]
+  #
+  #   [ "rb,y,_i,g_ow" ]
+  #   [ "rb", "y", "_i", "g_ow" ]
+  #   [ [:red, :bold], [:yellow], [:italic], [:green, :on_white] ]
+  #
+  # {spec} is definitely an array because it was gathered like this:
+  #   def fmt(*spec)
+  #
+  # "Normalised" means an array with one element for each string.
+  # Each element is itself an array of all the properties that apply to that
+  # string.
+  #
+  def normalise_format_spec(*spec)
+    if spec.size == 1 and spec.first.is_a? String and spec.first.index(',')
+                                                    # ^^^ "rb,y,_n"
+      spec = spec.first.split(',')                  # ['rb', 'y', '_n']
+      normalise_format_spec(*spec)
+    else
+      # We have an array of items.  We need to treat each item individually and
+      # put the items together.  We remove nil elements.
+      spec.map { |item| normalise_item(item) }.compact
+    end
+  end
+
+  # Examples
+  #     Item               Normalised item
+  #     :r                 [:red]
+  #     "r"                [:red]
+  #     :red               [:red]
+  #     [:red]             [:red]
+  #     "rb"               [:red, :bold]
+  #     :rb                [:red, :bold]
+  #     [:red, :bold]      [:red, :bold]
+  #     :b                 [:blue]
+  #     :_b                [:bold]
+  #     :__b               error
+  #     :__ob              [:on_blue]
+  #     "gsow"             [:green, :strikethrough, :on_white]
+  #     "_noB"             [:negative, :on_black]
+  #     :_                 []
+  #     [:_]               []
+  #     [:_, :_]           []
+  #       (etc.)
+  def normalise_item(item)
+    case item
+    when Symbol then normalise_string(item.to_s)
+    when Array  then normalise_array(item)
+    when String then normalise_string(item)
+    else             raise Col::Error, "Invalid item type: #{item.class}"
+    end
+  end
+
+  # Input:  array of symbols
+  # Result: array of symbols, each of which is a legitimate ANSIColor method
+  # Note:   underscores and nil items are removed from the array
+  def normalise_array(array)
+    array.reject! { |x| x.nil? or x == :_ or x == '_' }
+    invalid_items = array.select { |item| not Col::DB.method? item }
+    case invalid_items.size
+    when 0 then return array
+    when 1 then raise Col::Error, "Invalid item: #{invalid_items.first.inspect}"
+    else        raise Col::Error, "Invalid items: #{invalid_items.inspect}"
+    end
+  end
+
+  # Examples
+  #     Input           Output
+  #      r               [:red]
+  #      b               [:blue]
+  #      rb              [:red, :bold]
+  #      red             [:red]
+  #      bold            [:bold]
+  #      gsow            [:green, :strikethrough, :on_white]
+  #      _b              [:bold]
+  #      __ob            [:on_blue]
+  #      _               []
+  def normalise_string(string)
+    # Is it already one of the methods?  If so, easy.  If not, split and parse.
+    if string == "_"
+      []
+    elsif Col::DB.method? string
+      [ string.intern ]
+    elsif (1..4).include? string.size         # say: "g", "gb", "gbow"
+      color, style, backg = extract(string)
+      color = Col::DB.color(color)            # 'g'  -> :green
+      style = Col::DB.style(style)            # 'b'  -> :bold
+      backg = Col::DB.background(backg)       # 'ow' -> :on_white
+      [ color, style, backg ].compact         # remove nil elements
+    else
+      raise Col::Error, "Invalid item: #{string.inspect}"
+    end
+  rescue Col::Error => e
+    raise Col::Error, "Invalid item: #{string.inspect} (#{e.message})"
+  end
+
+  # Extracts color, style and background color.
+  #   "gbow" -> ["g", "b", "ow"]
+  #   "g"    -> ["g", nil, nil]
+  #   "_b"   -> [nil, "b", nil]
+  def extract(string)
+    string += "    "
+    color, style, backg = /^(.)(.)(..)/.match(string).captures
+    color = nil if [' ', '_'].include? color
+    style = nil if [' ', '_'].include? style
+    backg = nil if ['  ', '__'].include? backg
+    [color, style, backg]
+  end
+
+  def render(spec)
+    ( (spec.size == 1) ? spec.first : spec ).inspect
+  end
+end
+
+# --------------------------------------------------------------------------- #
+
+class Col::DB
+  COLORS = {
+    'B' => :black,
+    'r' => :red,
+    'g' => :green,
+    'y' => :yellow,
+    'b' => :blue,
+    'm' => :magenta,
+    'c' => :cyan,
+    'w' => :white
+  }
+
+  STYLES = {
+    'b' => :bold,
+    'd' => :dark,
+    'i' => :italic,
+    'u' => :underline,
+    'U' => :underscore,
+    'k' => :blink,
+    'r' => :rapid_blink,
+    'n' => :negative,
+    'c' => :concealed,
+    's' => :strikethrough,
+  }
+
+  BACKGROUND = {
+    'oB' => :on_black,
+    'or' => :on_red,
+    'og' => :on_green,
+    'oy' => :on_yellow,
+    'ob' => :on_blue,
+    'om' => :on_magenta,
+    'oc' => :on_cyan,
+    'ow' => :on_white
+  }
+
+  ALL_METHODS_SYMBOL = COLORS.values + STYLES.values + BACKGROUND.values
+  ALL_METHODS_STRING = ALL_METHODS_SYMBOL.map { |x| x.to_s }
+  require 'set'
+  ALL_METHODS = Set[*ALL_METHODS_SYMBOL] + Set[*ALL_METHODS_STRING]
+
+  def self.method?(x)
+    ALL_METHODS.include? x
+  end
+
+  def self.color(key)
+    get_value COLORS, key, "color"
+  end
+
+  def self.style(key)
+    get_value STYLES, key, "style"
+  end
+
+  def self.background(key)
+    get_value BACKGROUND, key, "background color"
+  end
+
+  # If the 'key' is nil, we return nil.  Otherwise, we insist that the key be a
+  # valid color, style or background color.  If it's not, we raise an error
+  # (that's what 'name' is for).
+  #
+  # Return the method name sought:  :green, :bold, :on_white, etc.
+  def self.get_value(hash, key, name)
+    if key.nil?
+      nil
+    else
+      method = hash[key.to_s]
+      if method.nil?
+        raise Col::Error, "Invalid #{name} code: #{key}"
+      end
+      method
+    end
+  end
+
+end  # Col::DB

data/test/_setup.rb

@@ -0,0 +1,2 @@
+require 'col'
+

data/test/col.rb

@@ -0,0 +1,229 @@
+
+# This enhancement to String is needed for testing this file.
+class String
+  require 'term/ansicolor'
+  include Term::ANSIColor
+end
+
+D "Simple formatting (single string)" do
+  D "yellow" do
+    Eq Col["string"].y.to_s,   "string".yellow
+    Eq Col["string"].fmt("y"), "string".yellow
+    Eq Col["string"].fmt(:y),  "string".yellow
+  end
+  D "red" do
+    Eq Col["string"].r.to_s,   "string".red
+    Eq Col["string"].fmt(:r),  "string".red
+    Eq Col["string"].fmt("r"), "string".red
+  end
+  D "red bold" do
+    Eq Col["string"].rb.to_s,  "string".red.bold
+    Eq Col["string"].fmt(:rb), "string".red.bold
+    Eq (Col["string"].fmt [:red, :bold]), "string".red.bold
+  end
+  D "bold" do
+    Eq Col["string"]._b.to_s,  "string".bold
+    Eq Col["string"].fmt(:_b), "string".bold
+  end
+  D "black" do
+    Eq Col["string"].B.to_s,   "string".black
+    Eq Col["string"].fmt(:B),  "string".black
+  end
+end
+
+D "General formatting (multiple strings)" do
+  D "example 1" do
+    str1 = Col("one", "two", "three", "four").fmt(:rb, :y, :cb, :m)
+    str2 = Col("one", "two", "three", "four").fmt "rb,y,cb,m"
+    expected = "one".red.bold + "two".yellow + "three".cyan.bold + "four".magenta
+    Eq str1, expected
+    Eq str2, expected
+  end
+  D "example 2" do
+    str1 = Col("one", "two", "three").fmt(:Bb, :_b, :w_)  # the _ in w_ is optional
+    str2 = Col("one", "two", "three").fmt "Bb,_b,w_"
+    expected = "one".black.bold + "two".bold + "three".white
+    Eq str1, expected
+    Eq str2, expected
+  end
+  D "example 3" do
+    str1 = Col["one","two"].fmt "y,r"
+    expected = "one".yellow + "two".red
+    Eq str1, expected
+  end
+  D "including strings where no formatting is done" do
+    name, age = "Peter", 14
+    str1 = Col["Name: ", name, "   Age: ", age].fmt(:_, :rb, :_, :gb)
+    str2 = Col["Name: ", name, "   Age: ", age].fmt "_,rb,_,gb"
+    expected = "Name: " + name.red.bold + "   Age: " + age.to_s.green.bold
+    Eq str1, expected
+    Eq str2, expected
+  end
+end
+
+D "More complex formatting (on_red, strikethrough, italic, dark, negative, ...)" do
+  D "all styles (part 1)" do
+    str1 = Col["one","two","three","four","five"].fmt(:_b, :_d, :_i, :_u, :_U)
+    str2 = Col["one","two","three","four","five"].fmt "_b,_d,_i,_u,_U"
+    expected = "one".bold + "two".dark + "three".italic + "four".underline \
+             + "five".underscore
+    Eq str1, expected
+    Eq str2, expected
+  end
+  D "all styles (part 2)" do
+    str1 = Col["one","two","three","four","five"].fmt(:_k, :_r, :_n, :_c, :_s)
+    str2 = Col["one","two","three","four","five"].fmt "_k,_r,_n,_c,_s"
+    expected = "one".blink + "two".rapid_blink + "three".negative \
+             + "four".concealed + "five".strikethrough
+    Eq str1, expected
+    Eq str2, expected
+  end
+  D "all backgrounds (part 1)" do
+    str1 = Col["one","two","three","four"].fmt(:__oB, :__or, :__og, :__oy)
+    str2 = Col["one","two","three","four"].fmt "__oB,__or,__og,__oy"
+    expected = "one".on_black + "two".on_red + "three".on_green + "four".on_yellow
+    Eq str1, expected
+    Eq str2, expected
+  end
+  D "all backgrounds (part 2)" do
+    str1 = Col["one","two","three","four"].fmt(:__ob, :__om, :__oc, :__ow)
+    str2 = Col["one","two","three","four"].fmt "__ob,__om,__oc,__ow"
+    expected = "one".on_blue + "two".on_magenta + "three".on_cyan + "four".on_white
+    Eq str1, expected
+    Eq str2, expected
+  end
+  D "mixed 1" do
+    str1 = Col["one","two","three","four"].fmt(:r_ow, :bnoy, :_d, :gs)
+    str2 = Col["one","two","three","four"].fmt "r_ow,bnoy,_d,gs"
+    expected = "one".red.on_white + "two".blue.negative.on_yellow \
+             + "three".dark + "four".green.strikethrough
+    Eq str1, expected
+    Eq str2, expected
+  end
+  D "mixed 2" do
+    str1 = Col["one","two","three","four"].fmt(:cUob, :wkoB, :m_or, :yc)
+    str2 = Col["one","two","three","four"].fmt "cUob,wkoB,m_or,yc"
+    expected = "one".cyan.underscore.on_blue + "two".white.blink.on_black \
+             + "three".magenta.on_red + "four".yellow.concealed
+    Eq str1, expected
+    Eq str2, expected
+  end
+end  # "More complex formatting..."
+
+D ":_ (do-nothing) format specifiers" do
+  Eq Col["..."].fmt(:_), "..."
+  Eq Col["..."].fmt('_'), "..."
+  Eq Col["abc","123"].fmt(:_, :_), "abc123"
+  Eq Col["abc","123"].fmt('_,_'), "abc123"
+  D "totally empty arguments" do
+    Eq Col[].fmt(), ""
+  end
+end
+
+D "Esoteric options" do
+  D "italic,strikethrough,blink" do
+    D "separate" do
+      str1 = Col["one","two","three"].fmt(:italic, :strikethrough, :blink)
+      expected = "one".italic + "two".strikethrough + "three".blink
+      Eq str1, expected
+    end
+    D "combined" do
+      # one string, several symbols
+      str1 = Col["string"].fmt([:italic, :strikethrough, :blink])
+      expected = "string".italic.strikethrough.blink
+      Eq str1, expected
+    end
+  end
+end
+
+D "Verbose specification" do
+  D "example 1" do
+    str1 = Col["one","two"].fmt( [:bold, :yellow, :on_red], [:cyan, :dark] )
+    expected = "one".bold.yellow.on_red + "two".cyan.dark
+    Eq str1, expected
+  end
+  D "example 2" do
+    str1 = Col["one","two"].fmt([:negative, :dark], [:underscore, :rapid_blink])
+    expected = "one".negative.dark + "two".underscore.rapid_blink
+  end
+end
+
+D "Col.inline" do
+  D "with correct # arguments" do
+    str1 = Col.inline(
+      "foo", :blue,
+      "bar", :rb,
+      12345, [:white, :negative],
+      "qux", :_
+    )
+    expected = "foo".blue + "bar".red.bold + "12345".white.negative + "qux"
+    Eq str1, expected
+  end
+  D "with incorrect # arguments" do
+    E(Col::Error) do
+      Col.inline( "foo", :blue, "bar", :red, "quux" )
+    end
+    Mt Attest.exception.message, /even/i
+  end
+end
+
+D "Col.uncolored(string)" do
+  str = Col["foo"].yellow.bold.on_red.to_s
+  Eq Col.uncolored(str), "foo"
+  Eq Col.plain(str), "foo"
+  str = Col["foo","bar"].fmt('rboc,_i')
+  Eq Col.uncolored(str), "foobar"
+  Eq Col.plain(str), "foobar"
+  str = "\e[1;4;37;41mfoo\e[0m"
+  Eq Col.uncolored(str), "foo"
+  Eq Col.plain(str), "foo"
+  str = "foo"
+  Eq Col.uncolored(str), "foo"
+  Eq Col.plain(str), "foo"
+end
+
+D "Object properties" do
+  D "Col[...].green.on_white is still a Col object" do
+    c = Col["..."].green
+    Ko c, Col
+    c = Col["..."].green.on_white
+    Ko c, Col
+  end
+  D "other methods, like Col[...].rb, produce a String object" do
+    str = Col["foo"].yb
+    Ko str, String
+    str = Col["foo"].fmt [:yellow, :italic, :strikethrough, :on_green]
+    Ko str, String
+    str = Col["one","two"].fmt :g_ow, :yb
+    Ko str, String
+  end
+  D "a Col object is printable (implements to_s)" do
+    c = Col["one","two","three"]
+    Eq c.to_s, "onetwothree"
+    c = Col["..."].green.on_white
+    Eq c.to_s, "...".green.on_white
+  end
+  D "the string returned after formatting has nothing mixed in" do
+    # Whilesoever Term::ANSIColor is mixed in to String, as it is at the top of
+    # this file, I can't think of a way to test this property :(
+    # I could change all the "foo".red.bold to bold(foo("red")) but that's a
+    # _lot_ of work and will make this file quite ugly.
+  end
+end
+
+D "Erroneous specifications" do
+  D "incorrect number of arguments" do
+    E(Col::Error) { Col["one","two"].fmt :b }
+    Mt Attest.exception.message, /incorrect number of arguments/i
+    E(Col::Error) { Col["one","two"].fmt(:b, :r, :g) }
+    Mt Attest.exception.message, /incorrect number of arguments/i
+    E(Col::Error) { Col["one","two"].fmt(:b, :r, :g, :cbow) }
+    Mt Attest.exception.message, /incorrect number of arguments/i
+  end
+
+  D "invalid code" do
+    E(Col::Error) { Col["one","two"].fmt(:T, :r) }
+    E(Col::Error) { Col["one","two"].fmt "T,r" }
+    Mt Attest.exception.message, /invalid color code/i
+  end
+end

data/test/col_db.rb

@@ -0,0 +1,14 @@
+D "Col::DB" do
+  D "method?" do
+    D "given symbol" do
+      T Col::DB.method? :yellow
+      T Col::DB.method? :blink
+      T Col::DB.method? :on_cyan
+    end
+    D "given string" do
+      T Col::DB.method? "yellow"
+      T Col::DB.method? "blink"
+      T Col::DB.method? "on_cyan"
+    end
+  end
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification 
+name: col
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Gavin Sinclair
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-25 00:00:00 +10:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: term-ansicolor
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 1
+        - 0
+        version: "1.0"
+  type: :runtime
+  version_requirements: *id001
+description: "    Console color formatting library with abbreviations (e.g. 'rb' for\n    red and bold), and the ability to format several strings easily.\n"
+email: gsinclair@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/col.rb
+- LICENCE
+- README
+- test/col.rb
+- test/col_db.rb
+- test/_setup.rb
+has_rdoc: true
+homepage: http://gsinclair.github.com/col.html
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 59
+      segments: 
+      - 1
+      - 8
+      - 6
+      version: 1.8.6
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: high-level console color formatting
+test_files: 
+- test/col.rb
+- test/col_db.rb
+- test/_setup.rb