Fossil Wrapper

# Add a new filter on `commands' named `name' (creates proc):
proc filter {name commands body} {
    set caller_ns [uplevel 1 {namespace current}]
    set namespaced "${caller_ns}::$name"
    uplevel 1 [list proc $name line $body]
    foreach command_spec $commands {
        foreach command [triggers_for $command_spec] {
            dict append config::filters $command "$namespaced "
        }
    }
}

proc alias {spec target} {
    foreach name [triggers_for $spec] {
        dict set config::aliases $name $target

    alias  alog   {timeline -t ci -n 100000}
    alias  d      diff
    alias  di     diff
    alias  elog   {timeline -t ci -n 100000 -showfiles}
    alias  flog   {finfo}
    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:

proc spawned_errno {{spawn_id -1}} {
    catch {wait -i $spawn_id} result_list
    lindex $result_list 3
}

proc unindent_script {script} {
    regexp "^ *" [set trimmed [string trim $script \n]] indent
    regsub -line -all "^$indent" $trimmed {}
}

proc ansi {mode table text} {
    if {[dict exists $table $mode]} {
        set code [dict get $table $mode]
        return "\[${code}m$text\[0m"
    } else {

# not that in the output list the linefeeds are "shifted"
# to the front of the timeline entries and that status information
# is kept in separate list entries. this allows to use the
# colorizers without modification while still getting the
# printed output to the form "one line per checkin".
# --------------------------------------------------------

   set numrev  {}
   set out     {}
   set usertag {}
   set rgxdate {^=== [0-9-]+ ===$}
   set rgxtime {^\d\d:\d\d:\d\d}
   set rgxrev  {\[([a-f\d]{10})([^\]]*)\]}
   set rgxuser {\(user: .*\)}
   set cnt     0
   set prepend {}

   foreach record $records {
      # first get rid of the all leading/trailing whitespace and line feeds:
      set record [string trim $record]

      if {[regexp $rgxdate $record]} {
         # the `date' information is extracted and then prepended to the suitable checkins
         set date [regsub {(=== )(.*)( ===)} $record {\2}]
      } elseif {[regexp $rgxrev $record]} { # this line contains a checkin message
         # extract relevant fields:
         regexp $rgxtime $record time
         regexp $rgxrev  $record rev
         regexp $rgxuser $record usertag

         # now reduce `record' to the checkin message:
         regsub " $rgxuser" $record {} record
         regsub "$time "    $record {} record
         regsub "$rgxrev "  $record {} record

         # determine relative revision number:
         set numrev [dict get $revnums $rev]:

         incr cnt
         if {$cnt > 1} {set prepend "\n"}

#-----------------------------------------------------------------------
   set huge    1000000     ;# should not be reached by most projects ...
   set revcnt  0
   set maxrev  0
   set rgxtime {^\d\d:\d\d:\d\d}
   set rgxrev  {\[([a-f\d]{10})([^\]]*)\]}
   set rgxrepo {\-R[[:blank:]]+.+} 
   set repo    {}

   regexp $rgxrepo $params repo
   catch {exec fossil timeline -n $huge {*}$repo} timeline
   set lines [split $timeline \n]

   foreach line $lines { 
      if {[regexp $rgxtime $line]} { incr maxrev }

   # output is generated. after extraction of the debug level the
   # option and its value are eliminated from the argument string
   # since it otherwise would be interpreted as an (unknown) command
   # during further processing.
  
   set dbgpat {\--debug[[:blank:]]+([[:digit:]]+[ ]*)}
   regexp $dbgpat $argv dum config::dbglvl
   regsub $dbgpat $argv {} argv

   return $argv
}

# --( Interceptors )----------------------------------------------------

# - Interceptors can refer to the current parameter list via an

        return 0;                # params cleared, no need to run fossil
    }
    set command [first $params]; # expanded candidate

    # Prepare filters:
    set chain [chain_for $candidate]
    set chain [expr {[empty? $chain] ? [chain_for $command] : $chain}]
    set chain [string trimright $chain]

    # Expect settings:
    set prior_log [log_user];   # to be reverted before returning
    if {![empty? $chain]} {
        log_user 0;             # disable logging to stdout
    }
    if {![interactive? $command]} {

          # if yes, don't unwrap (but it's still filtered 
          # through `fancy_timeline'. think ...)
          if {!$catmode} {
             set lines [unwrapTimeline $lines]
          }
       }

       if {$config::dbglvl > 1} {puts "*** filter chain: [join $chain ", "]"}

       foreach line $lines {
          if {$config::dbglvl > 2} {
             puts "IN: >$line<"
             puts -nonewline "OU: >"
             filter_with $chain "$line"
             puts "<"