ansi 1.0.0

data/lib/ansi/logger.rb

@@ -0,0 +1,209 @@
+# Ansi::Logger
+# Copyright (c) 2009 Thomas Sawyer
+# Copyright (c) 2005 George Moschovitis
+
+require "logger"
+require "time"
+require "ansi/code"
+
+# = ANSI::Logger
+#
+# Extended variation of Ruby's standard Logger library.
+# Mainly for compatibility purposes (with what?)
+#
+#   log = ANSI::Logger.new
+#
+#   log.formatter do |severity, timestamp, progname, msg|
+#     ANSI::Logger::SIMPLE_FORMAT % [severity, msg]
+#   end
+#
+#--
+# TODO: What's all this about then?
+#
+# When using debug level logger messages always append 'if $DBG'
+# at the end. This hack is needed because Ruby does not support
+# lazy evaluation (lisp macros).
+#++
+class ANSI::Logger < Logger
+
+  # Some available logging formats.
+  SIMPLE_FORMAT   = "%5s: %s\n"
+  DETAILED_FORMAT = "%s %5s: %s\n"
+
+  #
+  class ::Logger::LogDevice
+    attr_writer :ansicolor
+
+    def ansicolor?
+      @ansicolor.nil? ? true : @ansicolor
+    end
+  end
+
+  #
+  def ansicolor?
+    @logdev.ansicolor?
+  end
+
+  #
+  def ansicolor=(on)
+    @logdev.ansicolor = on
+  end
+
+  # Dictate the way in which this logger should format the
+  # messages it displays. This method requires a block. The
+  # block should return formatted strings given severity,
+  # timestamp, progname and msg.
+  #
+  # === Example
+  #
+  #   logger = ANSI::Logger.new
+  #
+  #   logger.formatter do |severity, timestamp, progname, msg|
+  #     "#{progname}@#{timestamp} - #{severity}::#{msg}"
+  #   end
+  #
+  def formatter(&block)
+    self.formatter = block if block
+    super
+  end
+
+  def styles(options=nil)
+    @styles ||= {
+      :info  => [],
+      :warn  => [:yellow],
+      :debug => [:cyan],
+      :error => [:red],
+      :fatal => [:bold, :red]
+    }
+    @styles.merge!(options) if options
+    @styles
+  end
+
+  #
+  def info(progname=nil, &block)
+    return unless info?
+    @logdev.ansicolor? ? info_with_color{ super } : super
+  end
+
+  #
+  def warn(progname=nil, &block)
+    return unless warn?
+    @logdev.ansicolor? ? warn_with_color{ super } : super
+  end
+
+  #
+  def debug(progname=nil, &block)
+    return unless debug?
+    @logdev.ansicolor? ? debug_with_color{ super } : super
+  end
+
+  #
+  def error(progname=nil, &block)
+    return unless error?
+    @logdev.ansicolor? ? error_with_color{ super } : super
+  end
+
+  #
+  def fatal(progname=nil, &block)
+    return unless error?
+    @logdev.ansicolor? ? fatal_with_color{ super } : super
+  end
+
+private
+
+  def info_with_color #:yield:
+    styles[:info].each{ |s| self << ANSI::Code.send(s) }
+    yield
+    self << ANSI::Code.clear
+  end
+
+  def warn_with_color #:yield:
+    styles[:warn].each{ |s| self << ANSI::Code.send(s) }
+    yield
+    self << ANSI::Code.clear
+  end
+
+  def error_with_color #:yield:
+    styles[:error].each{ |s| self << ANSI::Code.send(s) }
+    yield
+    self << ANSI::Code.clear
+  end
+
+  def debug_with_color #:yield:
+    styles[:debug].each{ |s| self << ANSI::Code.send(s) }
+    yield
+    self << ANSI::Code.clear
+  end
+
+  def fatal_with_color #:yield:
+    styles[:fatal].each{ |s| self << ANSI::Code.send(s) }
+    yield
+    self << ANSI::Code.clear
+  end
+
+end
+
+
+# NOTE: trace is deprecated b/c binding of caller is no longer possible.
+=begin
+  # Prints a trace message to DEBUGLOG (at debug level).
+  # Useful for emitting the value of variables, etc.  Use
+  # like this:
+  #
+  #   x = y = 5
+  #   trace 'x'        # -> 'x = 5'
+  #   trace 'x ** y'   # -> 'x ** y = 3125'
+  #
+  # If you have a more complicated value, like an array of
+  # hashes, then you'll probably want to use an alternative
+  # output format.  For instance:
+  #
+  #   trace 'value', :yaml
+  #
+  # Valid output format values (the _style_ parameter) are:
+  #
+  #   :p :inspect
+  #   :pp                     (pretty-print, using 'pp' library)
+  #   :s :to_s
+  #   :y :yaml :to_yaml       (using the 'yaml' library')
+  #
+  # The default is <tt>:p</tt>.
+  #
+  # CREDITS:
+  #
+  # This code comes straight from the dev-utils Gem.
+  # Author: Gavin Sinclair <gsinclair@soyabean.com.au>
+
+  def trace(expr, style=:p)
+    unless expr.respond_to? :to_str
+      warn "trace: Can't evaluate the given value: #{caller.first}"
+    else
+      raise "FACETS: binding/or_caller is no longer possible"
+      require "facets/core/binding/self/of_caller"
+
+      Binding.of_caller do |b|
+        value = b.eval(expr.to_str)
+        formatter = TRACE_STYLES[style] || :inspect
+        case formatter
+        when :pp then require 'pp'
+        when :y, :yaml, :to_yaml then require 'yaml'
+        end
+        value_s = value.send(formatter)
+        message = "#{expr} = #{value_s}"
+        lines = message.split(/\n/)
+        indent = "   "
+        debug(lines.shift)
+        lines.each do |line|
+          debug(indent + line)
+        end
+      end
+    end
+  end
+
+  TRACE_STYLES = {}  # :nodoc:
+  TRACE_STYLES.update(
+    :pp => :pp_s, :s => :to_s, :p => :inspect,
+    :y => :to_yaml, :yaml => :to_yaml,
+    :inspect => :inspect, :to_yaml => :to_yaml
+  )
+=end

data/lib/ansi/progressbar.rb

@@ -0,0 +1,268 @@
+# Copyright (C) 2009 Thomas Sawyer
+#
+# This library is based on the original ProgressBar
+# by Satoru Takabayashi.
+#
+# ProgressBar Copyright (C) 2001 Satoru Takabayashi
+
+require 'ansi/code'
+
+# ProgressBar is a text-based progressbar library.
+#
+#   pbar = Progressbar.new( "Demo", 100 )
+#   100.times { pbar.inc }
+#   pbar.finish
+#
+class ANSI::Progressbar
+  #
+  def initialize(title, total, out=STDERR)
+    @title = title
+    @total = total
+    @out   = out
+
+    @bar_length = 80
+    @bar_mark = "o"
+    @total_overflow = true
+    @current = 0
+    @previous = 0
+    @is_finished = false
+    @start_time = Time.now
+    @format = "%-14s %3d%% %s %s"
+    @format_arguments = [:title, :percentage, :bar, :stat]
+    @styles = {}
+    #
+    yield self if block_given?
+    #
+    show_progress
+  end
+
+  public
+
+  attr_accessor :format
+  attr_accessor :format_arguments
+  attr_accessor :styles
+
+  #
+  def title=(str)
+    @title = str
+  end
+  #
+  def bar_mark=(mark)
+    @bar_mark = String(mark)[0..0]
+  end
+
+  def total_overflow=(boolv)
+    @total_overflow = boolv ? true : false
+  end
+
+  # Set format and format arguments.
+  def format(format, *arguments)
+    @format = format
+    @format_arguments = *arguments unless arguments.empty?
+  end
+
+  # Set ANSI styling options.
+  def style(options)
+    @styles = options
+  end
+
+  #
+  def standard_mode
+    @format = "%-14s %3d%% %s %s"
+    @format_arguments = [:title, :percentage, :bar, :stat]
+  end
+
+  #
+  def transfer_mode
+    @format = "%-14s %3d%% %s %s"
+    @format_arguments = [:title, :percentage, :bar, :stat_for_file_transfer]
+  end
+
+  # For backward compatability
+  alias_method :file_transfer_mode, :transfer_mode
+
+  def finish
+    @current = @total
+    @is_finished = true
+    show_progress
+  end
+
+  def flush
+    @out.flush
+  end
+
+  def halt
+    @is_finished = true
+    show_progress
+  end
+
+  def set(count)
+    if count < 0
+      raise "invalid count less than zero: #{count}"
+    elsif count > @total
+      if @total_overflow
+        @total = count + 1
+      else
+        raise "invalid count greater than total: #{count}"
+      end
+    end
+    @current = count
+    show_progress
+    @previous = @current
+  end
+
+  #
+  def reset
+    @current = 0
+    @is_finished = false
+  end
+
+  def inc(step = 1)
+    @current += step
+    @current = @total if @current > @total
+    show_progress
+    @previous = @current
+  end
+
+  def inspect
+    "(ProgressBar: #{@current}/#{@total})"
+  end
+
+  private
+
+  #
+  def convert_bytes(bytes)
+    if bytes < 1024
+      sprintf("%6dB", bytes)
+    elsif bytes < 1024 * 1000 # 1000kb
+      sprintf("%5.1fKB", bytes.to_f / 1024)
+    elsif bytes < 1024 * 1024 * 1000  # 1000mb
+      sprintf("%5.1fMB", bytes.to_f / 1024 / 1024)
+    else
+      sprintf("%5.1fGB", bytes.to_f / 1024 / 1024 / 1024)
+    end
+  end
+  #
+  def transfer_rate
+    bytes_per_second = @current.to_f / (Time.now - @start_time)
+    sprintf("%s/s", convert_bytes(bytes_per_second))
+  end
+  #
+  def bytes
+    convert_bytes(@current)
+  end
+  #
+  def format_time(t)
+    t = t.to_i
+    sec = t % 60
+    min  = (t / 60) % 60
+    hour = t / 3600
+    sprintf("%02d:%02d:%02d", hour, min, sec);
+  end
+  #
+  # ETA stands for Estimated Time of Arrival.
+  def eta
+    if @current == 0
+      "ETA:  --:--:--"
+    else
+      elapsed = Time.now - @start_time
+      eta = elapsed * @total / @current - elapsed;
+      sprintf("ETA:  %s", format_time(eta))
+    end
+  end
+  #
+  def elapsed
+    elapsed = Time.now - @start_time
+    sprintf("Time: %s", format_time(elapsed))
+  end
+  #
+  def stat
+    if @is_finished then elapsed else eta end
+  end
+  #
+  def stat_for_file_transfer
+    if @is_finished then
+      sprintf("%s %s %s", bytes, transfer_rate, elapsed)
+    else
+      sprintf("%s %s %s", bytes, transfer_rate, eta)
+    end
+  end
+  #
+  def eol
+    if @is_finished then "\n" else "\r" end
+  end
+  #
+  def bar
+    len = percentage * @bar_length / 100
+    sprintf("|%s%s|", @bar_mark * len, " " *  (@bar_length - len))
+  end
+  #
+  def percentage
+    if @total.zero?
+      100
+    else
+      @current  * 100 / @total
+    end
+  end
+  #
+  def title
+    @title[0,13] + ":"
+  end
+  #
+  def get_width
+    # FIXME: I don't know how portable it is.
+    default_width = 80
+    begin
+      tiocgwinsz = 0x5413
+      data = [0, 0, 0, 0].pack("SSSS")
+      if @out.ioctl(tiocgwinsz, data) >= 0 then
+        rows, cols, xpixels, ypixels = data.unpack("SSSS")
+        if cols >= 0 then cols else default_width end
+      else
+        default_width
+      end
+    rescue Exception
+      default_width
+    end
+  end
+
+  #
+  def show
+    arguments = @format_arguments.map do |method|
+      colorize(send(method), styles[method])
+    end
+    line      = sprintf(@format, *arguments)
+    width     = get_width
+    length    = ANSI::Code.uncolored(line).length
+    if length == width - 1
+      @out.print(line + eol)
+    elsif length >= width
+      @bar_length = [@bar_length - (length - width + 1), 0].max
+      @bar_length == 0 ?  @out.print(line + eol) : show
+    else #line.length < width - 1
+      @bar_length += width - length + 1
+      show
+    end
+  end
+
+  #
+  def show_progress
+    if @total.zero?
+      cur_percentage = 100
+      prev_percentage = 0
+    else
+      cur_percentage  = (@current  * 100 / @total).to_i
+      prev_percentage = (@previous * 100 / @total).to_i
+    end
+    if cur_percentage > prev_percentage || @is_finished
+      show
+    end
+  end
+
+  #
+  def colorize(part, style)
+    return part unless style
+    [style].flatten.inject(part){ |pt, st| ANSI::Code.send(st){ pt } }
+  end
+
+end