Fossil Wrapper

namespace eval config {
    set aliases {}
    set filters {};             # registered filters
    set commands {};            # registered interceptors

    proc init {filename} {
        set myname $::argv0
        #if {[file exists $filename] && [file mtime $filename] > [file mtime $myname]} {}
        if {[file exists $filename] } {
	    # an existing config file is used only if it is _newer_ than the
	    # running `fsl' file. otherwise the config file is (re)created
	    # since it's definition in `config::defaults' might have changed.
	    # this makes it probable that changes to this script become
	    # automatically active for other users (as long as they don't happen
	    # to manually modify there config files frequently ...)

interceptor ali:aliases {
    puts "Currently defined expansions:"
    dict for {alias expansion} $config::aliases {
        puts [format "%10s -> %s" $alias $expansion]
    }
}

interceptor df {
   # a first stab at getting relative revision numbers working with `diff'.
   # should be called as `fsl df -r n' or `fsl df -r n:m' where `n, m' are
   # counting from 0 (initial checkin). This call which is 
   # be mapped to 
   #
   # `fsl di -r sha1_n --to sha1_m'
   #
   # where `sha1_n, sha1_m' are the sha1 hashes of the respective checkins.
   #

   set hash2num [computeRevnums {}]
   set dim [dict size $hash2num]

   #revert the above dictonary in order to get the mapping from numbers to sha1.
   #at the same time, strip the square brackets around the hash value.
   dict for {key val} $hash2num {
      regexp {[[:alnum:]]+} $key sha1
      dict set num2hash [expr {$dim - $val}] $sha1
   }

   set parstring [concat $params]

   # first introduce a blank between `-r' and revnum in case it was forgotten...
   set rgxrevnum {[[:digit:]]+(:[[:digit:]]+)?}
   regsub "\\-r($rgxrevnum)" $parstring {-r \1} parstring

   #extract the full match of the `df' command as well as the revnums
   set rgx {df[ ]+\-r[ ]+([[:digit:]]+(:[[:digit:]]+)?)}
   regexp $rgx $parstring fullmatch numbers
   set revs [split $numbers :]
   set fromto [list from to]
   set to {}
   set cnt 0
   
   #translate to sha1 hashes and prepend with correct `diff' options
   foreach rev $revs {
      set which [lindex $fromto $cnt] 
      set $which " --$which [dict get $num2hash $rev]"
      incr cnt
   } 
   #we use `di' instead of `diff' since only the former triggers the `diff' filter
   set replace "di $from$to"
   regsub $fullmatch $parstring $replace parstring

   #create the modified `params' list
   regsub -all {[[:blank:]]+} $parstring " " parstring
   set params [split $parstring]

   puts "executing 'fossil $params'"
   return $params
}

proc unwrapTimeline records {
#-----------------------------------------------------------------------
# unwrap `fossil timeline' output, putting each checkin on a single
# line. expected input: currently, a list of \n terminated lines.
# (maybe the \n should go away?). continuation lines belonging
# to the checkin message (including the trailing user/tags info)

            set line [string trimright $line]
         }
      }
      # we have to newline-terminate the records in order to enable
      # calls to `unwrapTimeline' even if `reformTimeline' is _not_
      # called subsequently.

      set record "[string trimright $record]\n"

      # temporary patch (better strategy needed, probably). eliminate
      # a blank in the used `regsub' pattern, which is assumed(!) to be caused by
      # `fossil' treating `-' as word boundary (there might be other instances,
      # actually, in the commit message itself):
      regsub -all {([[:alnum:]])- ([[:alnum:]])} $record \\1-\\2 record

      lappend out $record
   }
   return $out
}

proc reformTimeline {records revnums} {
# --------------------------------------------------------
# expected input: list of linefeed terminated lines as provided by