Fossil Wrapper

set config::defaults {
    # -*-tcl-*-

    # -- Aliases:

    alias  .      changes
    alias  ,      ui
    alias  d      diff
    alias  di     diff
    alias  elog   {timeline -t ci -showfiles}
    alias  heads  leaves;       # for hg refugees
    alias  log    {timeline -t ci}
    alias  not    {extras --dotfiles --ignore ""}
    alias  st     status
    alias  stat   status


    alias  t      {timeline -t ci}
    alias  time   timeline

    # -- Filters:

    filter status {changes status info timeline add rm addremove} {
        lassign [split [string trim $line]] status
        switch $status {
            MERGED_WITH { coloured purple $line }
            ADDED       { coloured  green $line }
            EDITED      { coloured   cyan $line }
            DELETED     { coloured    red $line }
            MISSING     { coloured  blue $line }

            coloured blue $line
        } else {
            regsub -all {\[[A-Fa-f0-9]+\]} $line [coloured yellow &]
        }
    }

   filter fancy_timeline {leaves timeline} {
       if {[regexp "\n=== .* ===" $line]} {
           return [coloured yellow $line]
       }
       # Expressions to match:
       set artifact_rx {\[([a-f\d]{4})([^\]]*)\]}
       set date_rx     {\n\d\d:\d\d:\d\d}
       set current_rx  {\*CURRENT\*}
       set frkmrg_rx   {\*(FORK|MERGE|BRANCH)\*}
       # Colour the output (repeated substitutions on $line):
       set line [regsub -all $artifact_rx $line\
                     [format {[%s%s]} [coloured red {\1}] {\2}]]
       set line [regsub $date_rx    $line [coloured blue &]]
       set line [regsub $current_rx $line [display reversed &]]

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

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)
# are identified by a leading indent of 10 blanks. all other
# lines (notably file status lines as delivered by 
# `timeline -showfiles') are passed through as is.
#
# result: a new (probably shorter) list with the unwrapped lines
# (multiple spaces squeezed) 
#-----------------------------------------------------------------------
   # this pattern is taken to identify checkin message continuation lines:
   set indent {^[ ]{9}}   

   set len [llength $records]
   set i 0
   set out {}
   while {$i < $len} {
      set record [lindex $records $i]
      incr i
      if {[regexp {^[0-9]} $record]} {
         set line [lindex $records $i] 
         set line [string trimright "$line"]
         while {[regexp $indent $line]} {
            set sub { }
            regsub -all {[[:blank:]]+} $line $sub line
            set record "[string trimright ${record}]${line}"

            incr i
            set line [lindex $records $i]
            set line [string trimright $line]

   set rgxtime {^\d\d:\d\d:\d\d}
   set rgxrev {\[([a-f\d]{10})([^\]]*)\]}
   set rgxuser {\(user: .*\)}

   set maxrev [dict size $revnums]

   foreach record $records {
      # temporarily get rid of the record/line terminating newline:
      set record "[string trimright $record]"

      if {[regexp $rgxdate $record]} {
         # a "date" line is passed through (plus additional linefeed):
         lappend out \n$record\n
      } elseif {[regexp $rgxrev $record]} {

         # this line contains the checkin message:
         regexp $rgxtime $record time
         regexp $rgxrev $record rev
         regexp $rgxuser $record usertag
         set numrev [expr { $maxrev - [dict get $revnums $rev] }]
         lappend out "\n$time $numrev:$rev $usertag\n"


         regsub $rgxuser $record "" record
         regsub $time    $record "" record
         regsub $rgxrev  $record "" record

         set message [string trim $record]
         set words [split $message]
         set line $indent[lindex $words 0]
         set len [string length $line]

         set words [lreplace $words 0 0]
         set wrdnum [llength $words]
         set wrdcnt 0
         foreach word $words {
            incr wrdcnt
            set wrdlen [string length $word]
            set len [expr {$len + 1 + $wrdlen}]
            if {$len <= $maxlen} {
               set line "$line $word"
               set isAppended 0
            } else {
               lappend out $line\n
               set line $indent$word
               set len [string length $line]
               if {$wrdcnt < $wrdnum} {
                  set isAppended 1
               } else {set isAppended 0} ;#since the loop stops _now_...
            }
         }

         if {$isAppended == 0} {lappend out $line\n}
      } else {
         # should be a file status line as delivered by `-showfiles' (since
         # it is neither matching `rgxdate' nor `rgxrev') and is passed 
         # through as is.
         lappend out $record\n
      }
   }
   return $out
}

proc computeRevnums {} {
#-----------------------------------------------------------------------
# generate a dictionary of SHA1 keys vs. "reverse" revision numbers 

            interact; break
        }
        expect {
            eof { break }
            \n {
            #collect everything and postpone filtering
            lappend lines $expect_out(buffer)

        }
            -re {[\?:] $} {
                # Transfer control to user following prompt:
                if {![log_user]} {
                    send_user $expect_out(buffer)
                }
                interact -o \n { send_user \r\n }
                break
            }
        }