rfs 0.1

data/lib/gui.rb

@@ -0,0 +1,216 @@
+require 'rubygems'
+require_gem 'fxruby'
+require 'stringio'
+require 'results'
+
+include Fox
+
+#TO DO:
+# change pattern to combobox with some useful patterns
+# \d.+(\d+).+
+# (\d+[AB])
+
+#user interface layout
+class RenameWindow < FXMainWindow
+  attr_accessor :renamer
+  
+  def initialize(app)
+    super(app, 'Rename File Set', nil, nil, DECOR_ALL, 20, 100, 1000, 600)
+    
+    FXHorizontalFrame.new(self, LAYOUT_FILL | PACK_UNIFORM_WIDTH) { |mainFrame|
+      # navigation on left
+      @dirList = FXDirList.new mainFrame, nil, 0, LAYOUT_FILL | FRAME_NORMAL
+      # controls in centre
+      FXVerticalFrame.new(mainFrame, LAYOUT_FILL | PACK_UNIFORM_WIDTH) { |controls|
+        FXLabel.new controls, 'Search (replace first capture):', nil, LAYOUT_FILL_X | JUSTIFY_LEFT
+        @search = FXTextField.new controls, 0, nil, LAYOUT_FILL
+        
+        FXGroupBox.new(controls, 'Replacement Method', LAYOUT_FILL | FRAME_GROOVE | JUSTIFY_LEFT ) { |group|
+          @selReplace = FXRadioButton.new(group, 'Replace with:') { |r|
+            connectRadio r
+          }
+          @replace = FXTextField.new group, 30, nil, PACK_UNIFORM_WIDTH
+          @selAdd = FXRadioButton.new(group, 'Add to captured digits: ', nil, LAYOUT_FILL_Y) { |r|
+            connectRadio r
+          }
+          @add = FXSpinner.new(group, 10, nil, FRAME_NORMAL) { |s| s.range = (-500..500)}
+          @selRoman = FXRadioButton.new(group, 'Convert to Roman Numerals', nil, LAYOUT_FILL_X ) { |r|
+            connectRadio r
+          }
+          @selTapeNumbers = FXRadioButton.new(group, 'Convert Tape Numbers', nil, LAYOUT_FILL_X) { |r|
+            connectRadio r
+          }
+          @selFill = FXRadioButton.new(group, 'Replace capture with last match capture:', nil, LAYOUT_FILL_X) { |r|
+            connectRadio r
+          }
+          @fill = FXTextField.new group, 30, nil, PACK_UNIFORM_WIDTH
+          @selFile = FXRadioButton.new(group, 'Replace from files.txt', nil, LAYOUT_FILL_X) { |r|
+            connectRadio r
+          }
+          @selCount = FXRadioButton.new(group, 'Count', nil, LAYOUT_FILL_X) { |r|
+            connectRadio r
+          }
+          @selMarkChange = FXRadioButton.new(group, 'Mark Changes', nil, LAYOUT_FILL_X) { |r|
+            connectRadio r
+          }
+          @selFromFullName = FXRadioButton.new(group, 'Replace with capture in full name:', nil, LAYOUT_FILL_X) { |r|
+            connectRadio r
+          }
+          @fullNamePattern = FXTextField.new group, 30, nil, PACK_UNIFORM_WIDTH
+          @selMoveUp = FXRadioButton.new(group, 'Move to Parent Directory', nil, LAYOUT_FILL_X) { |r|
+            connectRadio r
+          }
+          @selCapitalize = FXRadioButton.new(group, 'Capitalize', nil, LAYOUT_FILL_X) { |r|
+            connectRadio r
+          }
+        }
+        
+        FXButton.new(controls, '&List Files', nil, nil, 0, LAYOUT_FILL_X | BUTTON_NORMAL) { |b|
+          b.connect SEL_COMMAND, method(:onListClick)
+        }
+        FXButton.new(controls, '&Preview', nil, nil, 0, LAYOUT_FILL_X | FRAME_RAISED | FRAME_THICK) { |b|
+          b.connect SEL_COMMAND, method(:onPreviewClick)
+        }
+        FXButton.new(controls, '&Apply', nil, nil, 0, LAYOUT_FILL_X | FRAME_RAISED | FRAME_THICK) { |b|
+          b.connect SEL_COMMAND, method(:onReplaceClick)
+        }
+      }
+      # results on right
+      @results = FXText.new mainFrame, nil, 0, LAYOUT_FILL | FRAME_NORMAL | TEXT_READONLY
+    }
+    
+    @selReplace.checkState = TRUE
+    onRadioUpdate @selReplace, nil, nil
+  end
+  
+  def connectRadio(r)
+    r.connect SEL_COMMAND, method(:onRadioUpdate)
+  end
+
+  def onRadioUpdate(sender, sel, ptr)
+    sender.parent.each_child do |c|
+      if FXRadioButton === c and c != sender
+        c.checkState = FALSE
+      end
+    end
+    @selReplace.checked? ? @replace.enable : @replace.disable
+    @selAdd.checked? ? @add.enable : @add.disable      
+    @selFill.checked? ? @fill.enable : @fill.disable
+    @selFromFullName.checked? ? @fullNamePattern.enable : @fullNamePattern.disable
+  end
+end
+
+#connections to main renaming worker
+class RenameWindow
+  attr_accessor :renamer
+
+  def onPreviewClick(sender, sel, ptr)
+    start :preview
+  end
+  
+  def onReplaceClick(sender, sel, ptr)
+    start :commit
+  end
+  
+  def onListClick(sender, sel, ptr)
+    start :list
+    @dirList.setFocus
+  end
+
+  def selected_function
+    if @selReplace.checked?
+      :rename_replace
+    elsif @selFile.checked?
+      :rename_files_txt
+    elsif @selAdd.checked?
+      :rename_add
+    elsif @selCount.checked?
+      :rename_count
+    elsif @selFromFullName.checked?
+      :rename_from_full_name
+    elsif @selMoveUp.checked?
+      :rename_move_up
+    elsif @selRoman.checked?
+      :rename_roman
+    elsif @selMarkChange.checked?
+      :rename_mark_change
+    elsif @selTapeNumbers.checked?
+      :rename_tape_numbers
+    elsif @selCapitalize.checked?
+      :rename_capitalize
+    elsif @selFill.checked?
+      :rename_fill
+    else
+      throw "No operation selected, or selection unknown."
+    end
+  end
+
+  def start(action)
+    s = StringIO.new
+    @r = CollectResults.new s
+    @r.lineways = true
+    @r.list = action == :list
+    
+    begin
+      fn = selected_function
+      if methods.include? fn.to_s
+        method(fn).call action
+      else
+        rename fn, :action => action
+      end 
+    rescue => e
+      @r.output(:error, e)
+    end
+    @r.display
+    s.rewind
+    @results.text = s.read.lstrip
+  end
+
+  def rename(name, args = {})
+    args[:search] ||= PrepareRegexp.new @search.text
+    args[:filter] = Filter.add(args[:filter], Filter.new(/^\.+$/))
+    args[:file_provider] = Provider::File::NonRecursive.new(Provider::Folder::Tree.new(@dirList))
+
+    PrepareRegexp.each(args) do |k, v|
+      args[k] = t = v.create(false, false, true) do |mode, output|
+        @r.output(mode, output)
+      end
+    end
+
+    @renamer.run name, args do |*a|
+      @r.output(*a)
+    end
+  end
+
+#special functions
+  
+  def rename_replace action
+    rename :rename_replace, :replace => @replace.text, :action => action
+  end
+
+  def rename_add action
+    rename :rename_add, :add => @add.value, :action => action
+  end
+
+  def rename_fill action
+    rename :rename_fill, :fill => PrepareRegexp.new(@fill.text), :action => action
+  end
+
+  def rename_from_full_name action
+    rename :rename_from_full_name, :pattern => PrepareRegexp.new(@fullNamePattern.text), :action => action
+  end
+
+  def rename_mark_change action
+    rename(:rename_mark_change, 
+           :replace_pattern => PrepareRegexp.new('()$/'),    # I could add boxes for these options
+           :replace_text => '--changed--', 
+           :action => action)
+  end
+
+  def rename_files_txt action
+    rename(:rename_name_source,
+           :source => NameFileSource.new('files.txt'),
+           :filter => Filter.new(/^files.txt$/),
+           :action => action)
+  end
+end

data/lib/innate/array.rb

@@ -0,0 +1,104 @@
+class Array
+  def match? string
+    find do |i|
+      if i.is_a? String
+        i == string
+      elsif i.is_a? Regexp
+        i =~ string
+      end
+    end
+  end
+
+  def rows(width = 80, spaces = 2, spacer = ' ')
+    return '' if length == 0
+    best = nil
+    bestcw = nil
+    sorted = self # changed my mind: don't sort
+    
+    1.upto(width) do |columns|
+      space = spacer.length * spaces * (columns - 1)
+      break if columns + space > width
+      t = []
+      rows = []
+      cw = [0] * columns
+      result = sorted.each do |item|
+        if t.length == columns
+          break :fail unless check_cols cw, rows, t, width, space, columns
+          t = []
+        end
+        t << item.to_s
+      end
+      t += [''] * (columns - t.length)
+      unless result == :fail
+        result = :fail unless check_cols cw, rows, t, width, space, columns
+      end
+      if result != :fail
+        best = rows
+        bestcw = cw
+      end
+    end
+    fs = bestcw.collect {|w| "%#{w}-s" }.join(spacer * spaces)
+    best.collect {|row| format(fs, *row) }.join "\n"
+  end
+
+  def columns(width = 80, spaces = 2, spacer = ' ')
+    return '' if length == 0
+    best = nil
+    bestcw = nil
+    sorted = self # changed my mind: don't sort
+
+    1.upto(width) do |columns|
+      space = spacer.length * spaces * (columns - 1)
+      rows = []
+      cols = []
+      cw = [0] * columns
+      col_len = length / columns
+      col_len += 1 if length > (columns * col_len)
+
+      temp = nil
+      if length % col_len > 0
+        temp = sorted + ([''] * (col_len - length % col_len))
+      else
+        temp = sorted
+      end
+        
+      columns.times do |c|
+        t = temp[(col_len * c)...(col_len * (c + 1))]
+        cols << t
+      end
+      next if cols.last == [] or cols.last == nil
+
+      cols = cols.transpose
+      result = cols.each do |row|
+        break :fail unless check_cols cw, rows, row, width, space, columns
+      end
+      if result != :fail
+        best = rows
+        bestcw = cw
+      end
+      break if col_len == 1
+    end 
+    fs = bestcw.collect {|w| "%#{w}-s" }.join(spacer * spaces)
+    best.collect {|row| format(fs, *row) }.join "\n"
+  end
+  
+  def pc(w = 130, s = 2, sr = ' ')
+    puts sort.columns(w, s, sr)
+  end
+
+  def pr(w = 130, s = 2, sr = ' ')
+    puts sort.rows(w, s, sr)
+  end
+end
+
+#refactorings
+class Array
+private
+  def check_cols(cw, rows, t, width, space, columns)
+    idx = 0
+    cw.collect! {|w| r = (t[idx].length > w ? t[idx].length : w); idx += 1; r }
+    row_width = cw.inject(0){|tot, n| tot + n} + space
+    rows << t
+    (row_width < width) || columns == 1
+  end
+end

data/lib/innate/coverage.rb

@@ -0,0 +1,315 @@
+# module COVERAGE__ originally (c) NAKAMURA Hiroshi, under Ruby's license
+# module PrettyCoverage originally (c) Simon Strandgaard, under Ruby's license
+# minor modifications by Mauricio Julio Fern�ndez Pradier
+
+require 'fileutils'
+require 'rbconfig'
+
+include Config
+
+module PrettyCoverage
+
+class HTML
+  def write_page(body, title, css, filename)
+    html = <<EOHTML
+<?xml version="1.0" encoding="ISO-8859-1"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
+<head><title>#{title}</title>
+<style type="text/css">#{css}</style></head>
+<body>#{body}</body></html>
+EOHTML
+    File.open(filename, "w+") {|f| f.write(html) }
+  end
+  
+  def escape(text)
+    text.gsub(/&/, "&amp;").gsub(/\"/, "&quot;").gsub(/>/, "&gt;").gsub(/</, "&lt;")
+  end
+  
+  def initialize
+    @files = {}
+    @files_codeonly = {}
+    @filenames = {}
+    @sidebar = ""
+  end
+  
+  def output_dir(&block)
+    dir = "coverage"
+    if FileTest.directory?(dir)
+      FileUtils.rm_rf(dir)
+    end
+    FileUtils.mkdir(dir)
+    FileUtils.cd(dir) { block.call(dir) }
+  end
+  
+  def load_sidebar
+    return unless FileTest.file?("coverage.sidebar")
+    data = nil
+    File.open("coverage.sidebar", "r") {|f| data = f.read}
+    @sidebar = "<div class=\"sidebar\">#{data}</div>"
+  end
+  
+  def build_filenames
+    duplicates = Hash.new(0)
+    @files.keys.each do |filename, marked|
+      base = File.basename(filename)
+      absolute = File.expand_path(filename)
+      n = duplicates[base]
+      duplicates[base] += 1
+      if n > 0
+        base += n.to_s
+      end
+      @filenames[filename] = [base, absolute]
+    end
+    #p @filenames
+  end
+  
+  def execute
+    puts "execute"
+    build_filenames
+    load_sidebar
+    output_dir do 
+      create_file_index
+      @files.each do |file, line_marked|
+        create_file(file, line_marked, @files_codeonly[file])
+      end
+    end
+  end
+  
+  
+  def mk_filename(name)
+    base_absolute = @filenames[name]
+    raise "should not happen" unless base_absolute
+    base, absolute = base_absolute
+    return nil if absolute =~ /\A#{Regexp.escape(CONFIG["libdir"])}/
+    return nil if base =~ /test_/
+    [base + ".html", base, absolute]
+  end
+  
+  def create_file_index
+    output_filename = "index.html"
+    rows = []
+    filestats = {}
+    filestats_code = {}
+    @files.sort_by{|k,v| k}.each do|file, line_marked|
+      url_filename = mk_filename(file)
+      next unless url_filename
+      percent = "%02.1f" % calc_coverage(line_marked)
+      percent2 = "%02.1f" % calc_coverage(@files_codeonly[file])
+      numlines = line_marked.transpose[1].size
+      if numlines
+        filestats[file] = [calc_coverage(line_marked), numlines]
+        filestats_code[file] = [calc_coverage(@files_codeonly[file]),
+                              numlines]
+      end
+      url, filename, abspath = url_filename
+      cells = [
+        "<a href=\"#{url}\">#{filename}</a>",
+        "<tt>#{numlines}</tt>",
+        "&nbsp;", "&nbsp;", "&nbsp;",
+        "<tt>#{percent}%</tt>",
+        "&nbsp;", "&nbsp;", "&nbsp;",
+        "<tt>#{percent2}%</tt>"
+      ]
+      rows << cells.map{|cell| "<td>#{cell}</td>"}
+    end
+    rows.map!{|row| "<tr>#{row}</tr>"}
+    table = "<table>#{rows.join}</table>"
+    total_cov = 1.0 *
+      filestats.inject(0){|a,(k,v)| a + v[0] * v[1]} /
+      filestats.inject(0){|a,(k,v)| a + v[1]}
+    total_code_cov = 1.0 *
+      filestats_code.inject(0) {|a,(k,v)| a + v[0] * v[1]} /
+      filestats_code.inject(0){|a,(k,v)| a + v[1]}
+    body = "<h1>Average (with comments): %02.1f%%</h1>" % total_cov
+    body << "<h1>Average (code only): %02.1f%%</h1>" % total_code_cov
+    body << @sidebar
+    body << table
+    title = "coverage"
+    css = <<-EOCSS.gsub(/^\s*/, "")
+    body {
+      background-color: rgb(180, 180, 180);
+    }
+    span.marked {
+      background-color: rgb(185, 200, 200);
+      display: block;
+    }
+    div.overview {
+      border-bottom: 8px solid black;
+    }
+    div.sidebar {
+      float: right;
+      width: 300px;
+      border: 2px solid black;
+      margin-left: 10px;
+      padding-left: 10px;
+      padding-right: 10px;
+      margin-right: -10px;
+      background-color: rgb(185, 200, 200);
+    }
+    EOCSS
+    write_page(body, title, css, output_filename)
+  end
+  
+  def add_file(file, line_marked)
+    percent = calc_coverage(line_marked)
+    path = File.expand_path(file)
+    return nil if path =~ /\A#{Regexp.escape(CONFIG["rubylibdir"])}/
+    return nil if path =~ /\A#{Regexp.escape(CONFIG["sitelibdir"])}/
+    #printf("file #{file} coverage=%02.1f%\n", percent)
+
+    # comments and empty lines.. we must
+    # propagate marked-value backwards
+    line_marked << ["", false]
+    (line_marked.size).downto(1) do |index|
+      line, marked = line_marked[index-1]
+      next_line, next_marked = line_marked[index]
+      if line =~ /^\s*(#|$)/ and marked == false
+        marked = next_marked
+        line_marked[index-1] = [line, marked]
+      end
+    end
+    line_marked.pop
+    @files[file] = line_marked
+    @files_codeonly[file] = line_marked.select do |(line, marked)|
+      line !~ /^\s*(#|$)/
+    end
+  end
+
+  def calc_coverage(line_marked)
+    marked = line_marked.transpose[1]
+    if marked
+      n = marked.inject(0) {|r, i| (i) ? (r+1) : r }
+      percent = n.to_f * 100 / marked.size
+    else
+      -1.0
+    end
+  end
+  
+  def format_overview(file, line_marked, code_marked)
+    percent = "%02.1f" % calc_coverage(line_marked)
+    percent2 = "%02.1f" % calc_coverage(code_marked)
+    html = <<-EOHTML.gsub(/^\s*/, "")
+    <div class="overview">
+    <table>
+    <tr><td>filename</td><td><tt>#{file}</tt></td></tr>
+    <tr><td>total coverage</td><td>#{percent}%</td></tr>
+    <tr><td>code coverage</td><td>#{percent2}%</td></tr>
+    </table>
+    </div>
+    EOHTML
+    html
+  end
+  
+  def format_lines(line_marked)
+    result = ""
+    last = nil
+    end_of_span = ""
+    format_line = "%#{line_marked.size.to_s.size}d"
+    line_no = 1
+    line_marked.each do |(line, marked)|
+      if marked != last
+        result += end_of_span
+        case marked
+        when Fixnum
+          if marked < 10
+            result += "<span class=\"marked\">"
+          else
+            result += "<span class=\"highmarks\">"
+          end
+          end_of_span = "</span>"
+        when false
+          end_of_span = ""
+        end
+      end
+      result += (format_line % line_no) + " " + escape(line) + "\n"
+      last = marked
+      line_no += 1
+    end
+    result += end_of_span
+    "<pre>#{result}</pre>"
+  end
+  
+  def create_file(file, line_marked, code_marked)
+    url_filename = mk_filename(file)
+    return unless url_filename
+    output_filename, filename, abspath = url_filename
+    puts "outputting #{output_filename.inspect}"
+    body = format_overview(abspath, line_marked, code_marked) +
+      format_lines(line_marked)
+    title = filename + " - coverage"
+    css = <<-EOCSS.gsub(/^\s*/, "")
+    body {
+      background-color: rgb(180, 180, 180);
+    }
+    span.marked {
+      background-color: rgb(185, 200, 200);
+      display: block;
+    }
+    span.highmarks {
+      background-color: rgb(220, 200, 200);
+      display: block;
+    }
+    div.overview {
+      border-bottom: 8px solid black;
+    }
+    EOCSS
+    write_page(body, title, css, output_filename)
+  end
+end # class HTML
+
+end # module PrettyCoverage
+
+
+SCRIPT_LINES__ = {} unless defined? SCRIPT_LINES__
+
+
+module COVERAGE__
+  COVER = Hash.new do |h, k| 
+    a = [0]
+    if File.exists? k
+      File.open(k) do |f|
+        f.each_line {
+          a.push 0
+        }
+      end
+    else
+      a = [0] * 5000
+    end
+    h[k] = a 
+  end
+  
+  def self.trace_func(event, file, line, id, binding, klass)
+    case event
+    when 'c-call', 'c-return', 'class'
+      return
+    end
+    COVER[file][line] += 1
+  end
+  
+  END {
+    set_trace_func(nil)
+    printer = PrettyCoverage::HTML.new
+    COVER.each do |file, lines|
+      next if SCRIPT_LINES__.has_key?(file) == false
+      lines = SCRIPT_LINES__[file]
+      covers = COVER[file]
+      line_status = []
+      0.upto(lines.size - 1) do |c|
+        line = lines[c].chomp
+        if covers[c + 1] > 0
+        elsif /^\s*(?:begin\s*(?:#.*)?|ensure\s*(?:#.*)?|else\s*(?:#.*)?)$/ =~ line and covers[c + 2] > 0
+          covers[c + 1] = covers[c + 2]
+        elsif /^\s*(?:end|\})\s*$/ =~ line && covers[c] > 0
+          covers[c + 1] = covers[c]
+        end
+        line_status << [line, covers[c+1].nonzero? || false]
+      end
+      printer.add_file(file, line_status) unless line_status == []
+    end
+    printer.execute
+  } # END
+  
+  set_trace_func(COVERAGE__.method(:trace_func).to_proc)
+end