riel 1.1.2 → 1.1.6

data/lib/riel/ansicolor.rb

@@ -9,7 +9,6 @@
 #         40=black 41=red 42=green 43=yellow 44=blue 45=magenta 46=cyan 47=white
 
 module ANSIColor
-
   ATTRIBUTES = Hash[
     'none'       => '0', 
     'reset'      => '0',
@@ -58,24 +57,24 @@ module ANSIColor
   #     underscore bold magenta on cyan
   #     underscore red on bold cyan
 
-  def ANSIColor.code(str)
+  def ANSIColor.code str
     fg, bg = str.split(/\s*\bon_?\s*/)
     (fg ? foreground(fg) : "") + (bg ? background(bg) : "")
   end
 
   # returns the code for the given background color(s)
-  def ANSIColor.background(bgcolor)
+  def ANSIColor.background bgcolor
     make_code("on_" + bgcolor)
   end
 
   # returns the code for the given foreground color(s)
-  def ANSIColor.foreground(fgcolor)
+  def ANSIColor.foreground fgcolor
     make_code(fgcolor)
   end
 
   protected
 
-  def ANSIColor.make_code(str)
+  def ANSIColor.make_code str
     if str
       str.split.collect do |s|
         if attr = ATTRIBUTES[s]
@@ -89,5 +88,4 @@ module ANSIColor
       ""
     end
   end
-
 end

data/lib/riel/array.rb

@@ -13,6 +13,7 @@ class Array
   end
   $-w = true
 
+  # $$$ this is the same as Array.sample
   def rand
     return self[Kernel.rand(length)]
   end

data/lib/riel/asciitable/cell.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'riel/log'
+
+module RIEL
+  class Cell
+    include Loggable
+    
+    attr_reader :column
+    attr_reader :row
+
+    attr_accessor :value
+    attr_accessor :colors
+    attr_accessor :span
+
+    def initialize column, row, value = nil, colors = Array.new
+      @column = column
+      @row = row
+      @value = value
+      @colors = colors
+      @span = span
+    end
+
+    def _value width
+      value.nil? ? "" : value.to_s
+    end
+
+    def inspect
+      "(#{@column}, #{@row}) => #{@value}"
+    end
+
+    def to_s
+      "(#{@column}, #{@row}) => #{@value}"
+    end
+
+    def formatted_value width, align
+      strval = _value width
+
+      if @span
+        ncolumns = @span - @column
+        width = width * (1 + ncolumns) + (3 * ncolumns)
+      end
+
+      diff = width - strval.length
+        
+      lhs, rhs = case align
+                 when :left
+                   [ 0, diff ]
+                 when :right
+                   [ diff, 0 ]
+                 when :center
+                   l = diff / 2
+                   r = diff - l
+                   [ l, r ]
+                 else
+                   $stderr.puts "oh my!: #{align}"
+                 end
+
+      str = (" " * lhs) + strval + (" " * rhs)
+      
+      if colors
+        colors.each do |cl|
+          str = str.send cl
+        end
+      end
+
+      str
+    end
+  end
+
+  class BannerCell < Cell
+    def initialize char, col, row
+      @char = char
+      super(col, row)
+    end
+
+    def _value width
+      @char * width
+    end
+  end  
+end

data/lib/riel/asciitable/column.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'riel/log'
+
+module RIEL
+  module ASCIITable
+    class Column
+      attr_accessor :width
+      attr_accessor :num
+      attr_accessor :align
+      attr_accessor :table
+
+      def initialize table, num, width = nil, align = nil
+        @table = table
+        @num = num
+        @width = width
+        @align = align
+      end
+
+      def total fromrow, torow
+        @table.cells_in_column(@num).inject(0) { |sum, cell| sum + (cell.row >= fromrow && cell.row <= torow ? cell.value.to_i : 0) }
+      end
+    end
+  end
+end

data/lib/riel/asciitable/row.rb

@@ -0,0 +1,106 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'riel/log'
+
+module RIEL
+  module ASCIITable
+    class Row
+      include Loggable
+      
+      attr_accessor :table
+      attr_accessor :num
+
+      def initialize table, num
+        @table = table
+        @num = num
+      end
+
+      def print columns, align = nil
+        tocol = @table.last_column
+        col = 0
+        fmtdvalues = Array.new
+        while col <= tocol
+          aln = align || @table.column_align(col)
+          cell = @table.cell(col, @num)
+          width = @table.column_width col
+          fmtdvalues << cell.formatted_value(width, aln)
+          if cell.span
+            col += (cell.span - col)
+          end
+          col += 1
+        end
+        print_cells fmtdvalues
+      end
+
+      def print_cells values
+        $stdout.puts "| " + values.join(" | ") + " |"
+      end
+    end
+
+    class BannerRow < Row
+      def initialize table, char
+        @char = char
+        super(table, nil)
+      end
+
+      def print
+        banner = (0 .. @table.last_column).collect { |col| bc = BannerCell.new(@char, col, 1) }
+        bannervalues = banner.collect_with_index do |bc, col| 
+          width = @table.column_width col
+          bc.formatted_value width, :center
+        end
+        print_cells bannervalues
+      end
+    end
+
+    class StatRow < Row
+      def initialize table
+        firstdatarow = table.data_rows.first
+        lastdatarow = table.data_rows.last
+        statrownum = table.last_row + 1
+
+        nrows = lastdatarow + 1 - firstdatarow
+        
+        super table, statrownum
+        
+        ncolumns = @table.last_column
+        
+        @table.set 0, statrownum, name
+        
+        1.upto(ncolumns - 1) do |col|
+          val = calculate col, firstdatarow, lastdatarow
+          @table.set col, statrownum, val
+        end
+      end
+
+      def name
+      end
+
+      def calculate col, firstdatarow, lastdatarow
+      end
+    end
+
+    class TotalRow < StatRow
+      def name
+        "total"
+      end
+
+      def calculate col, fromrow, torow
+        @table.column(col).total fromrow, torow
+      end
+    end
+
+    class AverageRow < StatRow
+      def name
+        "average"
+      end
+      
+      def calculate col, fromrow, torow
+        nrows = torow + 1 - fromrow
+        total = @table.column(col).total fromrow, torow
+        avg = total / nrows
+      end
+    end
+  end
+end

data/lib/riel/asciitable/table.rb

@@ -0,0 +1,295 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+require 'riel/log'
+require 'riel/asciitable/cell'
+require 'riel/asciitable/column'
+require 'riel/asciitable/row'
+
+module RIEL
+  module ASCIITable
+    class TableData
+      def keys
+      end
+
+      def fields
+      end
+      
+      def value key, field
+      end
+    end
+
+    class Table
+      include Loggable      
+
+      def initialize args
+        @cells = Array.new
+        @cellwidth = args[:cellwidth] || 12
+        @align = args[:align] || :left
+        @columns = Array.new
+        @separator_rows = Hash.new
+        @default_value = args[:default_value] || ""
+
+        set_headings
+        set_cells
+
+        if sepival = args[:separators]
+          add_separators sepival
+        end
+
+        totrow = args[:has_total_row]
+        avgrow = args[:has_average_row]
+
+        if totrow || avgrow
+          add_separator_row '='
+          if totrow
+            TotalRow.new(self)
+          end
+          
+          if avgrow
+            AverageRow.new(self)
+          end
+        end
+        
+        if args[:has_total_columns]
+          add_total_columns
+        end
+        
+        if args[:highlight_max_cells]
+          highlight_max_cells
+        end
+      end
+
+      # sets a separator for the row preceding +rownum+. Does not change the
+      # coordinates for any other cells.
+      def set_separator_row rownum, char = '-'
+        @separator_rows[rownum] = char
+      end
+
+      def add_separator_row char = '-'
+        @separator_rows[last_row + 1] = char
+      end
+
+      def add_separators nbetween
+        # banner every N rows
+        drows = data_rows
+
+        drows.first.upto((drows.last - 1) / nbetween) do |num|
+          set_separator_row 1 + num * nbetween, '-'
+        end
+      end
+
+      def last_column
+        @cells.collect { |cell| cell.column }.max
+      end
+
+      def last_row
+        @cells.collect { |cell| cell.row }.max
+      end
+
+      def cells_in_column col
+        @cells.select { |cell| cell.column == col }
+      end
+
+      def cells_in_row row
+        @cells.select { |cell| cell.row == row }
+      end
+
+      def cell col, row
+        cl = @cells.detect { |c| c.row == row && c.column == col }
+        unless cl
+          cl = Cell.new(col, row, @default_value)
+          @cells << cl
+        end
+        cl
+      end
+
+      def set_column_align col, align
+        column(col).align = align
+      end
+
+      def set_column_width col, width
+        column(col).width = width
+      end
+
+      def column_width col
+        ((c = @columns[col]) && c.width) || @cellwidth
+      end
+
+      def column_align col
+        ((c = @columns[col]) && c.align) || @align
+      end
+
+      def column col
+        @columns[col] ||= Column.new(self, col, @cellwidth, @align)
+      end
+
+      def set_cellspan fromcol, tocol, row
+        cell(fromcol, row).span = tocol
+      end
+
+      def set col, row, val
+        cell(col, row).value = val
+      end
+
+      def set_color col, row, *colors
+        cell(col, row).colors = colors
+      end
+
+      def print_row row, align = nil
+        Row.new(self, row).print @columns, align
+      end
+
+      def print_banner char = '-'
+        BannerRow.new(self, char).print
+      end
+      
+      def print_header
+        # cells in the header are always centered
+        print_row 0, :center
+        print_banner
+      end
+
+      def print
+        print_header
+        
+        (1 .. last_row).each do |row|
+          if char = @separator_rows[row]
+            print_banner char
+          end
+          print_row row
+        end
+      end
+
+      # returns the values in cells, sorted and unique
+      def sort_values cells
+        cells.collect { |cell| cell.value }.uniq.sort.reverse
+      end
+
+      def data_cells_for_row row, offset
+        cells_for_row row, offset, fields.length * data_cell_span
+      end
+
+      def get_highlight_colors 
+        Array.new
+      end
+
+      def highlight_cells_in_row row, offset
+        cells = data_cells_for_row row, offset
+        highlight_cells cells
+      end
+
+      def highlight_cells cells
+        vals = sort_values cells
+
+        colors = get_highlight_colors
+        
+        cells.each do |cell|
+          idx = vals.index cell.value
+          if cols = colors[idx]
+            cell.colors = cols
+          end
+        end
+      end
+
+      def highlight_cells_in_column col
+        cells = cells_in_column(col)[data_rows.first .. data_rows.last]
+        highlight_cells cells
+      end
+
+      def highlight_max_cells
+        (1 .. last_row).each do |row|
+          (0 .. (data_cell_span - 1)).each do |offset|
+            highlight_cells_in_row row, offset
+          end
+        end
+
+        0.upto(1) do |n|
+          highlight_cells_in_column data_columns.last + n
+        end
+      end
+
+      def data_cell_span
+        1
+      end
+
+      def set_headings
+        cellspan = data_cell_span
+
+        colidx = 0
+        set colidx, 0, headings[0]
+
+        colidx += 1
+
+        (1 ... headings.length).each do |hi|
+          set colidx, 0, headings[hi]
+          if cellspan > 1
+            set_cellspan colidx, colidx - 1 + cellspan, 0
+          end
+          colidx += cellspan
+        end
+      end
+
+      def add_total_columns
+        last_data_col = data_columns.last
+        totcol = last_data_col + 1
+
+        (1 .. last_row).each do |row|
+          (0 .. (data_cell_span - 1)).each do |offset|
+            rowcells = cells_for_row row, offset, last_data_col
+            total = rowcells.collect { |cell| cell.value }.inject(0) { |sum, num| sum + num }
+            set totcol + offset, row, total
+          end
+        end
+      end
+
+      # returns the cells up to the given column
+      def cells_for_row row, offset, maxcol
+        cells = cells_in_row row
+        cells = cells[1 .. maxcol]
+        cells.select_with_index { |cell, cidx| (cidx % data_cell_span) == offset }
+      end    
+
+      def set_cells
+        rownum = 1
+        keys.each_with_index do |name, nidx|
+          set 0, rownum, name
+          
+          colidx = 1
+          fields.each do |field|
+            (0 .. (data_cell_span - 1)).each do |didx|
+              val = value name, field, didx
+              set colidx, rownum, val
+              colidx += 1
+            end
+          end
+          rownum += 1
+        end
+      end
+
+      def data
+        nil
+      end
+
+      def keys
+        data.keys
+      end
+
+      def fields
+        data.fields
+      end
+
+      def value key, field, index
+        data.value key, field, index
+      end
+
+      def data_rows
+        (1 .. keys.length)
+      end
+
+      def data_columns
+        (1 .. fields.length * data_cell_span)
+      end
+    end
+  end
+end

data/lib/riel/fdprocessor.rb

@@ -0,0 +1,68 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+module RIEL
+  # File and directory processor, with filtering.
+
+  class FileDirFilter
+    def initialize args
+      @dirsonly = args[:dirsonly]
+      @filesonly = args[:filesonly]
+      @basename = args[:basename]
+      @dirname = args[:dirname]
+      @extname = args[:extname]
+    end
+
+    def match? fd
+      if @dirsonly && !fd.directory?
+        false
+      elsif @filesonly && !fd.file?
+        false
+      elsif @basename && @basename != fd.basename.to_s
+        false
+      elsif @dirname && @dirname != fd.parent.to_s
+        false
+      elsif @extname && @extname != fd.extname
+        false
+      else
+        true
+      end
+    end
+  end
+
+  class FileDirProcessor
+    def initialize args, filters = Array.new
+      @filters = filters
+      args.each do |arg|
+        process Pathname.new arg
+      end
+    end
+
+    def process_file file
+    end
+
+    def process_directory dir
+      dir.children.sort.each do |fd|
+        next if @filter && @filter.include?(fd.basename.to_s)
+        process fd
+      end
+    end
+
+    def process fd
+      @filters.each do |filter| 
+        return nil unless filter.match? fd
+      end
+      
+      if fd.directory?
+        process_directory fd
+      elsif fd.file?
+        process_file fd
+      else
+        process_unknown_type fd
+      end
+    end
+
+    def process_unknown_type fd
+    end
+  end
+end

data/lib/riel/integer.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/ruby -w
+# -*- ruby -*-
+
+class Integer
+  POS_NEG_NUMERIC_RE = Regexp.new('^([\-\+])?(\d+)$')
+  
+  class << self
+    # returns the value as an integer, if it is not negative
+    def negative? val
+      negnumre = Regexp.new '^(\-\d+)$'
+      
+      if val.nil?
+        nil
+      elsif val.kind_of? Integer
+        val < 0 && val
+      elsif md = negnumre.match(val.to_s)
+        md[1].to_i
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/riel/io.rb

@@ -3,31 +3,36 @@
 
 require 'riel/file'
 
-
 class IO
-
-  $-w = false
-
   # Reads the stream into an array. It works even when $/ == nil, which
   # works around a problem in Ruby 1.8.1.
-  def readlines
-    contents = []
-    while ((line = gets) && line.length > 0)
-      contents << line
+  if VERSION == "1.8.1"
+    $-w = false
+
+    def readlines
+      contents = []
+      while ((line = gets) && line.length > 0)
+        contents << line
+      end
+      contents
     end
-    contents
+
+    $-w = true
   end
 
-  $-w = true
+  class << self
+    def writelines name, lines
+      fpn = File._to_pathname name
+      
+      fpn.open(File::WRONLY | File::TRUNC | File::CREAT) do |f|
+        f.puts lines
+      end
 
-  def self.writelines(name, lines)
-    fpn = File._to_pathname(name)
+      fpn
+    end
     
-    fpn.open(File::WRONLY | File::TRUNC | File::CREAT) do |f|
-      f.puts lines
+    def numlines io
+      io.readlines.size
     end
-
-    fpn
   end
-
 end