gonzui 1.2

data/lib/gonzui/license.rb

@@ -0,0 +1,100 @@
+#
+# license.rb - detect types of licenses with heuristics
+#
+# Copyright (C) 2004-2005 Satoru Takabayashi <satoru@namazu.org> 
+#     All rights reserved.
+#     This is free software with ABSOLUTELY NO WARRANTY.
+#
+# You can redistribute it and/or modify it under the terms of 
+# the GNU General Public License version 2.
+#
+
+module Gonzui
+  LicenseRegistry = []
+
+  class License
+    def initialize(abbrev, name, regexp)
+      @abbrev = abbrev
+      @name = name
+      @regexp = regexp
+      @allow_later_p = false
+    end
+    attr_reader :abbrev
+    attr_reader :name
+    attr_reader :regexp
+
+    def allow_later
+      @allow_later_p = true
+    end
+
+    def allow_later?
+      @allow_later_p
+    end
+  end
+
+  LicenseRegistry << License.new("GPL1",  
+                                 "GNU General Public License version 1",
+                                 /GNU General Public License .*?version 1/i
+                                 )
+  LicenseRegistry << License.new("GPL2",  
+                                 "GNU General Public License version 2",
+                                 /GNU General Public License .*?version 2/i
+                                 )
+  LicenseRegistry << License.new("LGPL1", 
+                                 "GNU Library Public License version 1",
+                                 /GNU Library Public License .*?version 1/i
+                                 )
+  LicenseRegistry << License.new("LGPL2", 
+                                 "GNU Library Public License version 2",
+                                 /GNU Library Public License .*?version 2/i
+                                 )
+  LicenseRegistry << License.new("LGPL2.1",
+                                 "GNU Lesser Public License version 2.1",
+                                 /GNU Lesser Public License .*?version 2\.1/i
+                                 )
+  LicenseRegistry << License.new("Perl",
+                                 "Perl's License",
+                                 /under the same terms as Perl/i
+                                 )
+  LicenseRegistry << License.new("Ruby",
+                                 "Ruby's License",
+                                 /under the same terms as Ruby|Ruby's license/i
+                                 )
+
+
+  OtherLicense = License.new("Other", "Other License", "")
+
+  class LicenseDetector
+    def initialize(text)
+      len = 512
+      @chunk = (text[0, len] or "")  # first 512 bytes
+      @chunk << (text[text.length - len, len] or "") # last 512 bytes
+      @chunk.gsub!(/[^\w.']+/, " ")
+    end
+
+    def allow_later?
+      regexp = /or (at your option )?any later version/i
+      return regexp.match(@chunk)
+    end
+
+    def detect
+      candidates = []
+      LicenseRegistry.each {|license|
+        if m = license.regexp.match(@chunk)
+          if allow_later?
+            license = license.clone
+            license.allow_later
+          end
+          candidates.push([m[0].length, license])
+        end
+      }
+      if candidates.empty?
+        return OtherLicense
+      else
+        license_of_shortest_match = 
+          candidates.min {|a, b| a.first <=> b.first }.last
+        return license_of_shortest_match
+      end
+    end
+  end
+end

data/lib/gonzui/logger.rb

@@ -0,0 +1,48 @@
+# -*- mode: ruby -*-
+#
+# logger.rb - logger implementation
+#
+# Copyright (C) 2004-2005 Satoru Takabayashi <satoru@namazu.org> 
+#     All rights reserved.
+#     This is free software with ABSOLUTELY NO WARRANTY.
+#
+# You can redistribute it and/or modify it under the terms of 
+# the GNU General Public License version 2.
+#
+
+module Gonzui
+  class Logger
+    def initialize(out = nil, verbose_p = false)
+      @verbose_p = verbose_p
+      @out = case out
+             when String
+               File.open(out, "a")
+             when NilClass
+               STDERR
+             else
+               out
+             end
+      @out.sync = true
+      @monitor = nil
+    end
+    attr_writer :monitor
+
+    private
+    def puts_log(format, *arguments)
+      time = Time.now.strftime("%Y-%m-%dT%H:%M:%S")
+      message = ""
+      message << time << " " << sprintf(format, *arguments) << "\n"
+      @out << message
+      @monitor << message if @monitor
+    end
+
+    public
+    def log(format, *arguments)
+      puts_log(format, *arguments)
+    end
+
+    def vlog(format, *arguments)
+      puts_log(format, *arguments) if @verbose_p
+    end
+  end
+end

data/lib/gonzui/monitor.rb

@@ -0,0 +1,177 @@
+#
+# monitor.rb - performance monitor
+#
+# Copyright (C) 2004-2005 Satoru Takabayashi <satoru@namazu.org> 
+#     All rights reserved.
+#     This is free software with ABSOLUTELY NO WARRANTY.
+#
+# You can redistribute it and/or modify it under the terms of 
+# the GNU General Public License version 2.
+#
+
+module Gonzui
+  class PerformanceMonitor
+    @@performance_counters = {}
+
+    def initialize
+      @start_time = Time.now
+      @elapsed_time = nil
+      @finished_p = false
+    end
+
+    private
+    def finish
+      @elapsed_time = Time.now - @start_time
+      @finished_p = true
+    end
+
+    def build_label(m, name)
+      case m
+      when Class
+        m.to_s + "#" + name.to_s
+      when Module
+        m.to_s + "." + name.to_s
+      end
+    end
+
+    public
+    def self.[] (label)
+      @@performance_counters[label]
+    end
+
+    def empty?
+      @@performance_counters.empty?
+    end
+
+    def profile(m, name)
+      label = build_label(m, name)
+      if !@@performance_counters[label]
+        @@performance_counters[label] = PerformanceCounter.new
+        case m
+        when Class
+          eval <<"End"
+          class #{m}
+            alias orig_#{name} #{name}
+            @@pc_#{name} = Gonzui::PerformanceMonitor["#{label}"]
+            # redefine with profiler
+            def #{name}(*args, &block)
+              @@pc_#{name}.enter
+              begin
+                orig_#{name}(*args, &block)
+              ensure
+                @@pc_#{name}.leave
+              end
+            end
+          end
+End
+        when Module
+          eval <<"End"
+          module #{m}
+            alias orig_#{name} #{name}
+            module_function :orig_#{name}
+            # redefine with profiler
+            def #{name}(*args, &block)
+              pc = Gonzui::PerformanceMonitor["#{label}"]
+              pc.enter
+              begin
+                orig_#{name}(*args, &block)
+              ensure
+                pc.leave
+              end
+            end
+            module_function :#{name}
+          end
+End
+        end
+      end
+    end
+
+    def heading
+      return Gonzui::PerformanceCounter.heading
+    end
+
+    def format(primary_label, *labels)
+      finish unless @finished_p
+
+      label = build_label(*primary_label)
+      primary_pc = Gonzui::PerformanceMonitor[label]
+      return "" if primary_pc.nil?
+
+      summary = primary_pc.summary(label, 1, @elapsed_time)
+      labels.each {|label|
+        label = build_label(*label)
+        pc = Gonzui::PerformanceMonitor[label]
+        next if pc.nil?
+        summary  << pc.summary(label, 2, @elapsed_time)
+        primary_pc.exclude(pc)
+      }
+      summary << primary_pc.rest_summary(:other, 2, @elapsed_time)
+      summary << "\n"
+      return summary
+    end
+  end
+
+  class PerformanceCounter
+    def initialize
+      @count = 0
+      @time_enter = 0
+      @time_total = 0
+      @time_subtotal = 0
+      @times_enter = 0
+      @times_total = Struct::Tms.new(0, 0, 0, 0)
+      @times_subtotal = Struct::Tms.new(0, 0, 0, 0)
+    end
+
+    def enter
+      @time_enter = Time.now
+      @times_enter = Process.times
+      @count += 1
+    end
+
+    def leave
+      @time_total += Time.now - @time_enter
+      times = Process.times
+      @times_total.utime += times.utime - @times_enter.utime
+      @times_total.stime += times.stime - @times_enter.stime
+    end
+
+    def time
+      @time_total
+    end
+
+    def utime
+      @times_total.utime
+    end
+
+    def stime
+      @times_total.stime
+    end
+
+    def exclude(pc)
+      @time_subtotal += pc.time
+      @times_subtotal.utime += pc.utime
+      @times_subtotal.stime += pc.stime
+    end
+
+    def self.heading
+      sprintf("%-32s %8s   %6s  %6s  %6s\n",
+              "", "count", "utime", "stime", "real")
+    end
+
+    def summary(label, indent, elapsed)
+      sprintf("%-32s %8d  %6.2fs %6.2fs %6.2fs (%6.2f%%)\n",
+              " " * indent + label, @count,
+              @times_total.utime, @times_total.stime,
+              @time_total, @time_total * 100 / elapsed)
+    end
+
+    def rest_summary(label, indent, elapsed)
+      time = @time_total - @time_subtotal
+      utime = @times_total.utime - @times_subtotal.utime
+      stime = @times_total.stime - @times_subtotal.stime
+      sprintf("%-32s %8s  %6.2fs %6.2fs %6.2fs (%6.2f%%)\n",
+              " " * indent + label.to_s, '',
+              utime, stime, time, time * 100 / elapsed)
+    end
+  end
+end

data/lib/gonzui/progressbar.rb

@@ -0,0 +1,235 @@
+#
+# Ruby/ProgressBar - a text progress bar library
+#
+# Copyright (C) 2001-2005 Satoru Takabayashi <satoru@namazu.org>
+#     All rights reserved.
+#     This is free software with ABSOLUTELY NO WARRANTY.
+#
+# You can redistribute it and/or modify it under the terms
+# of Ruby's license.
+#
+
+class ProgressBar
+  VERSION = "0.9"
+
+  def initialize(title, total, out = STDERR)
+    @title = title
+    @total = total
+    @out = out
+    @terminal_width = 80
+    @bar_mark = "o"
+    @current = 0
+    @previous = 0
+    @finished_p = false
+    @start_time = Time.now
+    @previous_time = @start_time
+    @title_width = 14
+    @format = "%-#{@title_width}s %3d%% %s %s"
+    @format_arguments = [:title, :percentage, :bar, :stat]
+    clear
+    show
+  end
+  attr_reader   :title
+  attr_reader   :current
+  attr_reader   :total
+  attr_accessor :start_time
+
+  private
+  def fmt_bar
+    bar_width = do_percentage * @terminal_width / 100
+    sprintf("|%s%s|", 
+            @bar_mark * bar_width, 
+            " " *  (@terminal_width - bar_width))
+  end
+
+  def fmt_percentage
+    do_percentage
+  end
+
+  def fmt_stat
+    if @finished_p then elapsed else eta end
+  end
+
+  def fmt_stat_for_file_transfer
+    if @finished_p then 
+      sprintf("%s %s %s", bytes, transfer_rate, elapsed)
+    else 
+      sprintf("%s %s %s", bytes, transfer_rate, eta)
+    end
+  end
+
+  def fmt_title
+    @title[0,(@title_width - 1)] + ":"
+  end
+
+  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 eol
+    if @finished_p then "\n" else "\r" end
+  end
+
+  def do_percentage
+    if @total.zero?
+      100
+    else
+      @current  * 100 / @total
+    end
+  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 {|method| 
+      method = sprintf("fmt_%s", method)
+      send(method)
+    }
+    line = sprintf(@format, *arguments)
+
+    width = get_width
+    if line.length == width - 1 
+      @out.print(line + eol)
+    elsif line.length >= width
+      @terminal_width = [@terminal_width - (line.length - width + 1), 0].max
+      if @terminal_width == 0 then @out.print(line + eol) else show end
+    else # line.length < width - 1
+      @terminal_width += width - line.length + 1
+      show
+    end
+    @previous_time = Time.now
+  end
+
+  def show_if_needed
+    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
+
+    # Use "!=" instead of ">" to support negative changes
+    if cur_percentage != prev_percentage || 
+        Time.now - @previous_time >= 1 || @finished_p
+      show
+    end
+  end
+
+  public
+  def clear
+    @out.print "\r"
+    @out.print(" " * (get_width - 1))
+    @out.print "\r"
+  end
+
+  def finish
+    @current = @total
+    @finished_p = true
+    show
+  end
+
+  def finished?
+    @finished_p
+  end
+
+  def file_transfer_mode
+    @format_arguments = [:title, :percentage, :bar, :stat_for_file_transfer]
+  end
+
+  def format= (format)
+    @format = format
+  end
+
+  def format_arguments= (arguments)
+    @format_arguments = arguments
+  end
+
+  def halt
+    @finished_p = true
+    show
+  end
+
+  def inc(step = 1)
+    @current += step
+    @current = @total if @current > @total
+    show_if_needed
+    @previous = @current
+  end
+
+  def set(count)
+    if count < 0 || count > @total
+      raise "invalid count: #{count} (total: #{@total})"
+    end
+    @current = count
+    show_if_needed
+    @previous = @current
+  end
+
+  def inspect
+    "#<ProgressBar:#{@current}/#{@total}>"
+  end
+end
+
+class ReversedProgressBar < ProgressBar
+  def do_percentage
+    100 - super
+  end
+end
+