ansi 1.2.3 → 1.2.4

data/.ruby

@@ -1,8 +1,26 @@
 --- 
-name: ansi
 spec_version: 1.0.0
+replaces: []
+
+loadpath: 
+- lib
+name: ansi
+repositories: {}
+
+conflicts: []
+
+engine_check: []
+
 title: ANSI
 contact: rubyworks-mailinglist@googlegroups.com
+resources: 
+  repository: git://github.com/rubyworks/ansi.git
+  api: http://rubyworks.github.com/ansi/rdoc
+  mail: http://groups.google.com/group/rubyworks-mailinglist
+  home: http://rubyworks.github.com/ansi
+  work: http://github.com/rubyworks/ansi
+maintainers: []
+
 requires: 
 - group: 
   - build
@@ -12,47 +30,15 @@ requires:
   - test
   name: ko
   version: 0+
-resources: 
-  repository: git://github.com/rubyworks/ansi.git
-  api: http://rubyworks.github.com/ansi/rdoc
-  mail: http://groups.google.com/group/rubyworks-mailinglist
-  home: http://rubyworks.github.com/ansi
-  work: http://github.com/rubyworks/ansi
-manifest: 
-- .ruby
-- lib/ansi/bbcode.rb
-- lib/ansi/code.rb
-- lib/ansi/columns.rb
-- lib/ansi/logger.rb
-- lib/ansi/mixin.rb
-- lib/ansi/progressbar.rb
-- lib/ansi/string.rb
-- lib/ansi/table.rb
-- lib/ansi/terminal/curses.rb
-- lib/ansi/terminal/stty.rb
-- lib/ansi/terminal/termios.rb
-- lib/ansi/terminal/win32.rb
-- lib/ansi/terminal.rb
-- lib/ansi/version.rb
-- lib/ansi.rb
-- test/case_ansicode.rb
-- test/case_bbcode.rb
-- test/case_mixin.rb
-- test/case_progressbar.rb
-- PROFILE
-- LICENSE
-- README.rdoc
-- HISTORY
-- NOTICE
-- VERSION
-version: 1.2.3
+manifest: MANIFEST
+version: 1.2.4
 licenses: 
 - Apache 2.0
 copyright: Copyright (c) 2009 Thomas Sawyer
-description: ANSI codes at your fingertips!
-summary: ANSI codes at your fingertips!
-organization: RubyWorks
 authors: 
 - Thomas Sawyer
 - Florian Frank
+organization: RubyWorks
+description: The ANSI project is a collection of ANSI escape code related libraries enabling ANSI code based colorization and stylization of output. It is very nice for beautifying shell output.
+summary: ANSI codes at your fingertips!
 created: 2004-08-01

data/{HISTORY → HISTORY.rdoc}

@@ -1,6 +1,18 @@
 = RELEASE HISTORY
 
-== 1.2.3 // 2011-04-12
+== 1.2.4 // 2011-04-09
+
+This release improves to the ANSI::Columns class. In particular the
+layout is more consitent with intended functionality.
+
+Changes:
+
+* Improved ANSI::Columns to give more consitant output.
+* ANSI::Columns#to_s can override number of columns.
+* ANSI::Columns can take a String or Array list.
+
+
+== 1.2.3 // 2011-04-08
 
 Minor release to add #clear method to ProgressBar and provide bug
 fix to BBCode.ansi_to_bbcode. Big thanks goes to Junegunn Choi 

data/README.rdoc

@@ -1,9 +1,5 @@
 = ANSI
 
-* http://rubyworks.github.com/ansi
-* http://github.com/rubyworks/ansi
-
-
 == DESCRIPTION
 
 The ANSI project is a collection of ANSI escape code related libraries
@@ -11,13 +7,13 @@ enabling ANSI code based colorization and stylization of output.
 It is very nice for beautifying shell output.
 
 This collection is based on a set of scripts spun-off from
-Ruby Facets. Include are Code (used to be ANSICode), Logger,
+Ruby Facets. Included are Code (used to be ANSICode), Logger,
 ProgressBar and String. In addition the library includes
 Terminal which provides information about the current output
 device.
 
 
-== FEATURES/ISSUES
+== FEATURES
 
 * ANSI::Code provides ANSI codes as module functions.
 * String#ansi makes common usage very easy and elegant.
@@ -25,6 +21,12 @@ device.
 * Very Good coverage of standard ANSI codes.
 
 
+== RESOURCES
+
+* home: http://rubyworks.github.com/ansi
+* code: http://github.com/rubyworks/ansi
+
+
 == RELEASE NOTES
 
 Please see HISTORY file.

data/Rakefile

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+Dir['task/*.rake'].each{ |f| load f }
+

data/lib/ansi.rb

@@ -1,10 +1,20 @@
 # ANSI module contains all the ANSI related classes.
 module ANSI
+  #
+  def self.meta
+    @spec ||= (
+      require 'yaml'
+      YAML.load(File.new(File.dirname(__FILE__) + '/ansi.yml'))
+    )
+  end
+  #
+  def self.const_missing(name)
+    meta[name.to_s.downcase] || super(name)
+  end
 end
 
-require 'ansi/version'
 require 'ansi/code'
 require 'ansi/logger'
 require 'ansi/progressbar'
 require 'ansi/string'
-
+require 'ansi/columns'

data/lib/ansi.yml

@@ -0,0 +1,44 @@
+--- 
+spec_version: 1.0.0
+replaces: []
+
+loadpath: 
+- lib
+name: ansi
+repositories: {}
+
+conflicts: []
+
+engine_check: []
+
+title: ANSI
+contact: rubyworks-mailinglist@googlegroups.com
+resources: 
+  repository: git://github.com/rubyworks/ansi.git
+  api: http://rubyworks.github.com/ansi/rdoc
+  mail: http://groups.google.com/group/rubyworks-mailinglist
+  home: http://rubyworks.github.com/ansi
+  work: http://github.com/rubyworks/ansi
+maintainers: []
+
+requires: 
+- group: 
+  - build
+  name: syckle
+  version: 0+
+- group: 
+  - test
+  name: ko
+  version: 0+
+manifest: MANIFEST
+version: 1.2.4
+licenses: 
+- Apache 2.0
+copyright: Copyright (c) 2009 Thomas Sawyer
+authors: 
+- Thomas Sawyer
+- Florian Frank
+organization: RubyWorks
+description: The ANSI project is a collection of ANSI escape code related libraries enabling ANSI code based colorization and stylization of output. It is very nice for beautifying shell output.
+summary: ANSI codes at your fingertips!
+created: 2004-08-01

data/lib/ansi/columns.rb

@@ -7,77 +7,102 @@ module ANSI
 
     # Create a column-based layout.
     #
-    # string - multiline string to columnize
+    # list - Multiline String or Array of strings to columnize
     #
     # options[:columns] - number of columns
     # options[:align]   - align :left or :right
     # options[:padding] - space to add to each cell
     #
-    # The +format+ must return ansi codes.
-    def initialize(string, options={}, &format)
-      @string  = string
-      @columns = options[:columns] || 3
-      @padding = options[:padding] || 0
+    # The +format+ block MUST return ANSI codes.
+    def initialize(list, options={}, &format)
+      self.list = list
+
+      @columns = options[:columns]
+      @padding = options[:padding] || 1
       @align   = options[:align]
       #@ansi    = [options[:ansi]].flatten
       @format  = format
+
+      @columns = nil if @columns == 0
     end
 
-    #
-    attr_accessor :string
+    # List layout into columns. Each new line is taken to be 
+    # a row-column cell.
+    attr_accessor :list
 
-    #
+    def list=(list)
+      case list
+      when ::String
+        @list = list.lines.to_a.map{ |e| e.chomp("\n") }
+      when ::Array
+        @list = list.map{ |e| e.to_s }
+      end
+    end
+
+    # Default number of columns to display. If nil then the number
+    # of coumns is estimated from the size of the terminal.
     attr_accessor :columns
 
-    #
+    # Padding size to apply to cells.
     attr_accessor :padding
 
-    #
+    # Alignment to apply to cells.
     attr_accessor :align
 
-    #
+    # Formating to apply to cells.
     attr_accessor :format
 
-    #
-    def to_s
-      if columns
-        to_s_columns(columns)
-      else
-        to_s_auto
-      end
+    # Return string in column layout. The number of columns is determined
+    # by the `columns` property or overriden by +cols+ argument.
+    #--
+    # TODO: Allow #to_s to take options and formating block?
+    #++
+    def to_s(cols=nil)
+      to_s_columns(cols || columns)
     end
 
     private
 
+    # Layout string lines into columns.
     #
     # TODO: put in empty strings for blank cells
-    def to_s_columns(columns)
-      lines = string.lines.to_a
+    def to_s_columns(columns=nil)
+      lines = list.to_a
       count = lines.size
-      cols  = []
-      mod   = (count / columns.to_f).to_i + 1
+      max   = lines.map{ |l| l.size }.max
+      if columns.nil?
+        width = Terminal.terminal_width
+        columns = (width / (max + padding)).to_i
+      end
+      cols = []
+      mod = (count / columns.to_f).to_i
+      mod += 1 if count % columns != 0
+
       lines.each_with_index do |line, index|
         (cols[index % mod] ||=[]) << line.strip
       end
-      max = lines.map{ |l| l.size }.max
+
       pad = " " * padding
       tmp = template(max, pad)
       str = ""
       cols.each_with_index do |row, c|
         row.each_with_index do |cell, r|
-          str << (tmp % cell).ansi(*ansi_formating(cell, c, r))
+          ansi_codes = ansi_formating(cell, c, r)
+          if ansi_codes.empty?
+            str << (tmp % cell)
+          else
+            str << (tmp % cell).ansi(*ansi_codes)
+          end
         end
+        str.rstrip!
         str << "\n"
       end
       str
     end
 
-    # TODO: look at the lines and figure out how many columns will fit
-    def to_s_auto    
-      width = Terminal.terminal_width
-    end
-
+    # Aligns the cell left or right.
     #
+    # TODO: Handle centered alignment.
     def template(max, pad)
       case align
       when :right, 'right'
@@ -87,7 +112,7 @@ module ANSI
       end
     end
 
-    #
+    # Used to apply ANSI formating to each cell.
     def ansi_formating(cell, col, row)
       if @format
         case @format.arity

data/qed/01_ansicode.rdoc

@@ -0,0 +1,56 @@
+= ANSI::Code
+
+Require the library.
+
+  require 'ansi/code'
+
+ANSI::Code can be used as a functions module.
+
+  str = ANSI::Code.red + "Hello" + ANSI::Code.blue + "World"
+  str.assert == "\e[31mHello\e[34mWorld"
+
+If a block is supplied to each method then yielded value will
+be wrapped in the ANSI code and clear code. 
+
+  str = ANSI::Code.red{ "Hello" } + ANSI::Code.blue{ "World" }
+  str.assert == "\e[31mHello\e[0m\e[34mWorld\e[0m"
+
+More conveniently the ANSI::Code module extends ANSI itself.
+
+  str = ANSI.red + "Hello" + ANSI.blue + "World"
+  str.assert == "\e[31mHello\e[34mWorld"
+
+  str = ANSI.red{ "Hello" } + ANSI.blue{ "World" }
+  str.assert == "\e[31mHello\e[0m\e[34mWorld\e[0m"
+
+In the appropriate context the ANSI::Code module can also be
+included, making its methods directly accessible.
+
+  include ANSI::Code
+
+  str = red + "Hello" + blue + "World"
+  str.assert == "\e[31mHello\e[34mWorld"
+
+  str = red{ "Hello" } + blue{ "World" }
+  str.assert == "\e[31mHello\e[0m\e[34mWorld\e[0m"
+
+Along with the single font colors, the library include background colors.
+
+  str = on_red + "Hello"
+  str.assert == "\e[41mHello"
+
+As well as combined color methods.
+
+  str = white_on_red + "Hello"
+  str.assert == "\e[37m\e[41mHello"
+
+In addition the library offers an extension to String class
+called #ansi, which allows some of the ANSI::Code methods
+to be called in a more object-oriented fashion.
+
+  str = "Hello".ansi(:red) + "World".ansi(:blue)
+  str.assert == "\e[31mHello\e[0m\e[34mWorld\e[0m"
+
+The ANSI::Code module supports most standard ANSI codes, though
+not all platforms support every code, so YMMV.
+

data/qed/02_bbcode.rdoc

@@ -0,0 +1,24 @@
+= ANSI::BBCode
+
+The BBCode module provides methods for converting between
+BBCodes, basic HTML and ANSI codes.
+
+  require 'ansi/bbcode'
+
+BBCodes are color and style codes in square brackets, quite
+popular with on line forums.
+
+  bbcode = "this is [COLOR=red]red[/COLOR], this is [B]bold[/B]"
+
+We can convert this to ANSI code simply enough:
+
+  ansi = ANSI::BBCode.bbcode_to_ansi(bbcode)
+
+  ansi.assert == "this is \e[0;31mred\e[0m, this is \e[1mbold\e[0m\n"
+
+In addition the BBCode module supports conversion to simple HTML.
+
+  html = ANSI::BBCode.bbcode_to_html(bbcode)
+
+  html.assert == "this is <font color=\"red\">red</font>, this is <strong>bold</strong><br />\n"
+

data/qed/03_logger.rdoc

@@ -0,0 +1,31 @@
+= ANSI::Logger
+
+Require the ANSI::Logger library.
+
+  require 'ansi/logger'
+
+Create a new ANSI::Logger
+
+  log = ANSI::Logger.new(STDOUT)
+
+Info logging appears normal.
+
+  log.info{"Info logs are green.\n"}
+
+Warn logging appears yellow.
+
+  log.warn{"Warn logs are yellow.\n"}
+
+Debug logging appears cyan.
+
+  log.debug{"Debug logs are cyan.\n"}
+
+Error logging appears red.
+
+  log.error{"Error logs are red.\n"}
+
+Fatal logging appears bright red.
+
+  log.fatal{"Fatal logs are bold red!\n"}
+
+QED.

data/qed/04_progressbar.rdoc

@@ -0,0 +1,63 @@
+= ANSI::Progressbar
+
+Pretty progress bars are easy to construct.
+
+  require 'ansi/progressbar'
+
+  pbar = ANSI::Progressbar.new("Test Bar", 100)
+
+Running the bar simply requires calling the #inc method during
+a loop and calling #finish when done.
+
+  100.times do |i|
+    sleep 0.01
+    pbar.inc
+  end
+  pbar.finish
+
+We will use this same rountine in all the examples below, so lets
+make a quick macro for it. Notice we have to use #reset first
+before reusing the same progress bar.
+
+  def run(pbar)
+    pbar.reset
+    100.times do |i|
+      sleep 0.01
+      pbar.inc
+    end
+    pbar.finish
+    puts
+  end
+
+The progress bar can be stylized in almost any way.
+The #format setter provides control over the parts
+that appear on the line. For example, by default the
+format is:
+
+  pbar.format("%-14s %3d%% %s %s", :title, :percentage, :bar, :stat)
+
+So lets vary it up to demonstrate the case.
+
+  pbar.format("%-14s %3d%% %s %s", :title, :percentage, :stat, :bar)
+  run(pbar)
+
+The progress bar has an extra build in format intended for use with
+file downloads called #transer_mode.
+
+  pbar.transfer_mode
+  run(pbar)
+
+Calling this methods is the same as calling:
+
+  pbar.format("%-14s %3d%% %s %s",:title, :percentage, :bar, :stat_for_file_transfer)
+  run(pbar)
+
+The #style setter allows each part of the line be modified with ANSI codes. And the
+#bar_mark writer can be used to change the character used to make the bar.
+
+  pbar.standard_mode
+  pbar.style(:title => [:red], :bar=>[:blue])
+  pbar.bar_mark = "="
+  run(pbar)
+
+QED.

data/qed/05_mixin.rdoc

@@ -0,0 +1,37 @@
+= ANSI::Mixin
+
+The ANSI::Mixin module is design for including into
+String-like classes. It will support any class that defines
+a #to_s method.
+
+  require 'ansi/mixin'
+
+In this demonstration we will simply include it in the
+core String class.
+
+  class ::String
+    include ANSI::Mixin
+  end
+
+Now all strings will have access to ANSI's style and color
+codes via simple method calls.
+
+  "roses".red.assert == "\e[31mroses\e[0m"
+
+  "violets".blue.assert == "\e[34mviolets\e[0m"
+
+  "sugar".italic.assert == "\e[3msugar\e[0m"
+
+The method can be combined, of course.
+
+  "you".italic.bold.assert == "\e[1m\e[3myou\e[0m\e[0m"
+
+The mixin also supports background methods.
+
+  "envy".on_green.assert == "\e[42menvy\e[0m"
+
+And it also supports the combined foreground-on-background 
+methods.
+
+  "b&w".white_on_black.assert == "\e[37m\e[40mb&w\e[0m"
+

data/qed/06_string.rdoc

@@ -0,0 +1,56 @@
+= ANSI::String
+
+The ANSI::String class is a very sophisticated implementation
+of Ruby's standard String class, but one that can handle
+ANSI codes seamlessly.
+
+  require 'ansi/string'
+
+  flower1 = ANSI::String.new("Roses")
+  flower2 = ANSI::String.new("Violets")
+
+Like any other string.
+
+  flower1.to_s.assert == "Roses"
+  flower2.to_s.assert == "Violets"
+
+Bet now we can add color.
+
+  flower1.red!
+  flower2.blue!
+
+  flower1.to_s.assert == "\e[31mRoses\e[0m"
+  flower2.to_s.assert == "\e[34mViolets\e[0m"
+
+Despite that the string representation now contains ANSI codes,
+we can still manipulate the string in much the same way that
+we manipulate an ordinary string.
+
+  flower1.size.assert == 5
+  flower2.size.assert == 7
+
+Like ordinary strings we can concatenate the two strings
+
+  flowers = flower1 + ' ' + flower2
+  flowers.to_s.assert == "\e[31mRoses\e[0m \e[34mViolets\e[0m"
+
+  flowers.size.assert == 13
+
+Standard case conversion such as #upcase and #downcase work.
+
+  flower1.upcase.to_s.assert == "\e[31mROSES\e[0m"
+  flower1.downcase.to_s.assert == "\e[31mroses\e[0m"
+
+Some of the most difficult methods to re-implement were the 
+substitution methods such as #sub and #gsub. They are still
+somewhat more limited than the original string methods, but
+their primary functionality should work.
+
+  flower1.gsub('s', 'z').to_s.assert == "\e[31mRozez\e[0m"
+
+There are still a number of methods that need implementation.
+ANSI::String is currently a very partial implementation. But
+as you can see from the methods it does currently support,
+is it already useful.
+
+

data/qed/07_columns.rdoc

@@ -0,0 +1,90 @@
+= ANSI::Columns
+
+The +Columns+ class makes it easy to create nice looking text columns,
+sorted from top to bottom, right to left (as opposed to the other way
+around).
+
+  require 'ansi/columns'
+
+  list = %w{a b c d e f g h i j k l}
+
+  columns = ANSI::Columns.new(list)
+
+  columns.to_s(4)
+
+The output will be:
+
+  a d g j
+  b e h k
+  c f i l
+
+Besides and array of elements, Columns.new can take a string in which
+the elements are divided by newlines characters. The default column
+size can also be given to the initializer.
+
+  list = "a\nb\nc\nd\ne\nf\ng\nh\ni\nj\nk\nl"
+
+  columns = ANSI::Columns.new(list, :columns=>6)
+
+  columns.to_s
+
+The output will be:
+
+  a c e g i k
+  b d f h j l
+
+If the column count is +nil+, then the number of columns will be calculated
+as a best fit for the current terminal window.
+
+== Padding
+
+Columns can adjsut the padding between cells.
+
+  list = %w{a b c d e f g h i j k l}
+
+  columns = ANSI::Columns.new(list, :padding=>2)
+
+  columns.to_s(4)
+
+The output will be:
+
+  a  d  g  j
+  b  e  h  k
+  c  f  i  l
+
+== Alignment
+
+Columns can also be aligned either left or right.
+
+  list = %w{xx xx xx yy y yy z zz z}
+
+  columns = ANSI::Columns.new(list, :align=>:right)
+
+  columns.to_s(3)
+
+The output will be:
+
+  xx yy  z
+  xx  y zz
+  xx yy  z
+
+== Format
+
+Lastly, columns can be aguamented with ANSI codes. This is done through
+a formating block. The block can take upto three parameters, the cell
+content, the row and column numbers, or the cell and the row and column
+numbers.
+
+  list = %w{a b c d e f g h i j k l}
+
+  columns = ANSI::Columns.new(list){ |r,c| c % 2 == 0 ? :red : :blue }
+
+  out = columns.to_s(4)
+
+  out.assert == (
+    "\e[31ma \e[0m\e[31md \e[0m\e[31mg \e[0m\e[31mj \e[0m\n" +
+    "\e[34mb \e[0m\e[34me \e[0m\e[34mh \e[0m\e[34mk \e[0m\n" +
+    "\e[31mc \e[0m\e[31mf \e[0m\e[31mi \e[0m\e[31ml \e[0m\n"
+  )
+
+QED.

data/qed/08_table.rdoc

@@ -0,0 +1,28 @@
+= ANSI::Table
+
+The ANSI::Table class can be used to output tabular data with nicely
+formated ASCII cell borders.
+
+  require 'ansi/table'
+
+The constructor takes an 2-dimensional array.
+
+  data = [
+    [ 10, 20, 30 ],
+    [ 20, 10, 20 ],
+    [ 50, 40, 20 ]
+  ]
+
+  table = ANSI::Table.new(data)
+
+  table.to_s
+
+The output will be:
+
+  +----+----+----+
+  | 10 | 20 | 30 |
+  | 20 | 10 | 20 |
+  | 50 | 40 | 20 |
+  +----+----+----+
+
+

data/qed/applique/output.rb

@@ -0,0 +1,5 @@
+When "output will be" do |text|
+  # how to get result of last block?
+  @_.strip.assert == text.strip
+end
+

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ansi
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 23
   prerelease: false
   segments: 
   - 1
   - 2
-  - 3
-  version: 1.2.3
+  - 4
+  version: 1.2.4
 platform: ruby
 authors: 
 - Thomas Sawyer
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-08 00:00:00 -04:00
+date: 2011-05-01 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -47,7 +47,7 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id002
-description: ANSI codes at your fingertips!
+description: The ANSI project is a collection of ANSI escape code related libraries enabling ANSI code based colorization and stylization of output. It is very nice for beautifying shell output.
 email: rubyworks-mailinglist@googlegroups.com
 executables: []
 
@@ -70,18 +70,26 @@ files:
 - lib/ansi/terminal/termios.rb
 - lib/ansi/terminal/win32.rb
 - lib/ansi/terminal.rb
-- lib/ansi/version.rb
 - lib/ansi.rb
+- lib/ansi.yml
+- qed/01_ansicode.rdoc
+- qed/02_bbcode.rdoc
+- qed/03_logger.rdoc
+- qed/04_progressbar.rdoc
+- qed/05_mixin.rdoc
+- qed/06_string.rdoc
+- qed/07_columns.rdoc
+- qed/08_table.rdoc
+- qed/applique/output.rb
 - test/case_ansicode.rb
 - test/case_bbcode.rb
 - test/case_mixin.rb
 - test/case_progressbar.rb
-- PROFILE
+- Rakefile
+- HISTORY.rdoc
 - LICENSE
 - README.rdoc
-- HISTORY
-- NOTICE
-- VERSION
+- NOTICE.rdoc
 has_rdoc: true
 homepage: http://rubyworks.github.com/ansi
 licenses: 

data/PROFILE

@@ -1,28 +0,0 @@
---- 
-title  : ANSI
-summary: ANSI codes at your fingertips!
-license: Apache 2.0
-contact: rubyworks-mailinglist@googlegroups.com
-created: 2004-08-01
-
-requires:
-  - syckle (build)
-  - ko (test)
-
-authors:
-  - Thomas Sawyer
-  - Florian Frank
-
-description:
-  ANSI codes at your fingertips!
-
-resources:
-  homepage    : http://rubyworks.github.com/ansi
-  development : http://github.com/rubyworks/ansi
-  reference   : http://rubyworks.github.com/ansi/rdoc
-  mailinglist : http://groups.google.com/group/rubyworks-mailinglist
-  repository  : git://github.com/rubyworks/ansi.git
-
-organization : RubyWorks
-copyright    : Copyright (c) 2009 Thomas Sawyer
-

data/VERSION

@@ -1 +0,0 @@
-1.2.3

data/lib/ansi/version.rb

@@ -1,4 +0,0 @@
-module ANSI
-  VERSION = '1.2.3'
-  DATE    = '2011-04-08'
-end