ansi 1.0.0

data/MANIFEST

@@ -0,0 +1,36 @@
+HISTORY
+LICENSE
+MANIFEST
+README
+demo
+demo/logger.rd
+demo/progressbar.rd
+lib
+lib/ansi
+lib/ansi.rb
+lib/ansi/code.rb
+lib/ansi/logger.rb
+lib/ansi/progressbar.rb
+lib/ansi/string.rb
+lib/ansi/terminal
+lib/ansi/terminal.rb
+lib/ansi/terminal/curses.rb
+lib/ansi/terminal/stty.rb
+lib/ansi/terminal/termios.rb
+lib/ansi/terminal/win32.rb
+meta
+meta/abstract
+meta/authors
+meta/created
+meta/homepage
+meta/license
+meta/package
+meta/project
+meta/released
+meta/repository
+meta/summary
+meta/title
+meta/version
+test
+test/test_ansicode.rb
+test/test_progressbar.rb

data/README

@@ -0,0 +1,72 @@
+= ANSI
+
+* http://death.rubyforge.org
+* http://death.rubyforge.org/ansi
+
+
+== DESCRIPTION
+
+The ANSI project is a collection of ANSI code related libraries
+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,
+Progressbar and String. In addition the library include
+Terminal which provides information about the current output
+device.
+
+
+== FEATURES/ISSUES
+
+* ANSI::Code can be used as a mixin or as module functions.
+* Good coverage of standard ANSI codes.
+* Windows support needs some TLC :(
+
+
+== RELEASE NOTES
+
+Please see HISTORY file.
+
+
+== SYNOPSIS
+
+The ANSI::Code module defines ANSI codes as methods.
+
+   include ANSICode
+
+   p red, "Hello", blue, "World"
+   => "\e[31mHello\e[34mWorld"
+
+   p red { "Hello" } + blue { "World" }
+   => "\e[31mHello\e[0m\e[34mWorld\e[0m"
+
+Thes mehods can also be called as module methods, eg. 'ANSI::Code.red'.
+
+Please see the online documentation for more information on using
+the other libraries.
+
+
+== HOW TO INSTALL
+
+To install with RubyGems simply open a console and type:
+
+  gem install ansi
+
+Local installation requires Setup.rb (gem install setup),
+then download the tarball package and type:
+
+  tar -xvzf ansi-1.0.0.tgz
+  cd ansi-1.0.0
+  sudo setup.rb all
+
+Windows users use 'ruby setup.rb all'.
+
+
+== LICENSE/COPYRIGHT
+
+Copyright (c) 2004 Coding Dead
+
+This program is ditributed unser the terms of the LGPLv3 license.
+
+See LICENSE file for details.

data/demo/logger.rd

@@ -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/demo/progressbar.rd

@@ -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/lib/ansi.rb

@@ -0,0 +1,11 @@
+# ANSI module contains all the ANSI related classes.
+#
+module ANSI
+  VERSION = "1.1.0"  # :till: VERSION="<%= version %>"
+end
+
+require 'ansi/code'
+require 'ansi/logger'
+require 'ansi/progressbar'
+require 'ansi/string'
+

data/lib/ansi/code.rb

@@ -0,0 +1,229 @@
+# Ansi::Code Copyright (c) 2009 Thomas Sawyer, LGPL
+#
+# This library is a partial adaptation of ANSIColor by Florian Frank.
+#
+# ANSIColor Copyright (c) 2002 Florian Frank, LGPL
+#
+# TODO: Need to add rest of ANSI codes. Include modes?
+# TODO: Re-evaluate how color/yielding methods are defined.
+# TODO: Maybe up, down, right, left should have yielding methods too?
+
+module ANSI
+
+  # Currently Windows is not supported.
+  SUPPORTED = !(PLATFORM =~ /win/)
+
+  # Ansi::Code module makes it very easy to use ANSI codes.
+  # These are esspecially nice for beautifying shell output.
+  #
+  #   include Ansi::Code
+  #
+  #   p red, "Hello", blue, "World"
+  #   => "\e[31mHello\e[34mWorld"
+  #
+  #   p red { "Hello" } + blue { "World" }
+  #   => "\e[31mHello\e[0m\e[34mWorld\e[0m"
+  #
+  # == Supported ANSI Commands
+  #
+  # The following is a list of supported codes.
+  #
+  #     save
+  #     restore
+  #     clear_screen
+  #     cls             # synonym for :clear_screen
+  #     clear_line
+  #     clr             # synonym for :clear_line
+  #     move
+  #     up
+  #     down
+  #     left
+  #     right
+  #     display
+  #
+  #     clear
+  #     reset           # synonym for :clear
+  #     bold
+  #     dark
+  #     italic          # not widely implemented
+  #     underline
+  #     underscore      # synonym for :underline
+  #     blink
+  #     rapid_blink     # not widely implemented
+  #     negative        # no reverse because of String#reverse
+  #     concealed
+  #     strikethrough   # not widely implemented
+  #
+  #     black
+  #     red
+  #     green
+  #     yellow
+  #     blue
+  #     magenta
+  #     cyan
+  #     white
+  #
+  #     on_black
+  #     on_red
+  #     on_green
+  #     on_yellow
+  #     on_blue
+  #     on_magenta
+  #     on_cyan
+  #     on_white
+  #
+  module Code
+
+    extend self
+
+    # Save current cursor positon.
+    def save
+      "\e[s"
+    end
+
+    # Restore saved cursor positon.
+    def restore
+      "\e[u"
+    end
+
+    # Clear the screen and move cursor to home.
+    def clear_screen
+      "\e[2J"
+    end
+    alias_method :cls, :clear_screen
+
+    # Clear to the end of the current line.
+    def clear_line
+      "\e[K"
+    end
+    alias_method :clr, :clear_line
+
+    #--
+    #def position
+    #  "\e[#;#R"
+    #end
+    #++
+
+    # Move curose to line and column.
+    def move( line, column=0 )
+      "\e[#{line.to_i};#{column.to_i}H"
+    end
+
+    # Move cursor up a specificed number of spaces.
+    def up( spaces=1 )
+      "\e[#{spaces.to_i}A"
+    end
+
+    # Move cursor down a specificed number of spaces.
+    def down( spaces=1 )
+      "\e[#{spaces.to_i}B"
+    end
+
+    # Move cursor left a specificed number of spaces.
+    def left( spaces=1 )
+      "\e[#{spaces.to_i}D"
+    end
+
+    # Move cursor right a specificed number of spaces.
+    def right( spaces=1 )
+      "\e[#{spaces.to_i}C"
+    end
+
+    # Like +move+ but returns to original positon
+    # after yielding block or adding string argument.
+    def display( line, column=0, string=nil ) #:yield:
+      result = "\e[s"
+      result << "\e[#{line.to_i};#{column.to_i}H"
+      if block_given?
+        result << yield
+        result << "\e[u"
+      elsif string
+        result << string
+        result << "\e[u"
+      elsif respond_to?(:to_str)
+        result << self
+        result << "\e[u"
+      end
+      return result
+    end
+
+    # Define color codes.
+    def self.define_ansicolor_method(name,code)
+      class_eval <<-HERE
+        def #{name.to_s}(string = nil)
+            result = "\e[#{code}m"
+            if block_given?
+                result << yield
+                result << "\e[0m"
+            elsif string
+                result << string
+                result << "\e[0m"
+            elsif respond_to?(:to_str)
+                result << self
+                result << "\e[0m"
+            end
+            return result
+        end
+      HERE
+    end
+
+    @@colors = [
+      [ :clear        ,   0 ],
+      [ :reset        ,   0 ],     # synonym for :clear
+      [ :bold         ,   1 ],
+      [ :dark         ,   2 ],
+      [ :italic       ,   3 ],     # not widely implemented
+      [ :underline    ,   4 ],
+      [ :underscore   ,   4 ],     # synonym for :underline
+      [ :blink        ,   5 ],
+      [ :rapid_blink  ,   6 ],     # not widely implemented
+      [ :negative     ,   7 ],     # no reverse because of String#reverse
+      [ :concealed    ,   8 ],
+      [ :strikethrough,   9 ],     # not widely implemented
+      [ :black        ,  30 ],
+      [ :red          ,  31 ],
+      [ :green        ,  32 ],
+      [ :yellow       ,  33 ],
+      [ :blue         ,  34 ],
+      [ :magenta      ,  35 ],
+      [ :cyan         ,  36 ],
+      [ :white        ,  37 ],
+      [ :on_black     ,  40 ],
+      [ :on_red       ,  41 ],
+      [ :on_green     ,  42 ],
+      [ :on_yellow    ,  43 ],
+      [ :on_blue      ,  44 ],
+      [ :on_magenta   ,  45 ],
+      [ :on_cyan      ,  46 ],
+      [ :on_white     ,  47 ],
+    ]
+
+    @@colors.each do |c, v|
+      define_ansicolor_method(c, v)
+    end
+
+    ColoredRegexp = /\e\[([34][0-7]|[0-9])m/
+
+    module_function
+
+    #
+    def uncolored(string = nil)
+      if block_given?
+        yield.gsub(ColoredRegexp, '')
+      elsif string
+        string.gsub(ColoredRegexp, '')
+      elsif respond_to?(:to_str)
+        gsub(ColoredRegexp, '')
+      else
+        ''
+      end
+    end
+
+    #
+    def colors
+      @@colors.map { |c| c[0] }
+    end
+
+  end
+
+end