Fossil Wrapper

           default    {             set  line }
        }
    }

    filter highlight_branch {branch} {
        expr {[regexp {^\* } $line] ? [coloured yellow $line] : $line}
    }

    # vim: ft=tcl
}

# --( Alias expansion )-------------------------------------------------

proc expand {params {explain 0}} {
    set candidate [first $params]
    if {[alias? $candidate]} {

# - If an interceptor returns an empty list, the wrapper is expected
#   to exit without calling Fossil, thereby fully intercepting the
#   query. Otherwise, it acts as a pre-processor: the returned list is
#   treated as a revised parameter list and will be supplied to
#   `fossil'.

proc interceptor {command_spec body} {
    set fn [list {params} $body [uplevel 1 {namespace current}]]
    foreach command [triggers_for $command_spec] {
        dict set config::commands $command $fn
    }
}

proc intercept {params} {
    set command [first $params]

    lindex $xs 0
}

proc interactive? {command} {
    # Check whether the supplied command requires user interaction
    # from the outset:
    switch -re $command {
        ^(stas|stash)$                       { return true  }
        ^(ci|com|comm|commi|commit)$         { return true  }
        ^(sq|sql|sqli|sqlit|sqlite|sqlite3)$ { return true  }
        default                              { return false }
    }
}

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 alias?       {name} { dict exists $config::aliases  $name }
proc filter?      {name} { dict exists $config::filters  $name }
proc interceptor? {name} { dict exists $config::commands $name }

# --( Builtin interceptors )--------------------------------------------

interceptor wr:wrapper {
    set fmt "=> %s:\n   %s"
    puts [format $fmt "Aliases"      [dict keys $config::aliases]]
    puts [format $fmt "Filters"      [dict keys $config::filters]]
    puts [format $fmt "Interceptors" [dict keys $config::commands]]
}

interceptor he:help {
    # Wrap builtin help command by expanding its argument list. This
    # allows us provide help on aliased commands transparently. When
    # the expanded command is an interceptor, simply print its body.
    set expansion [expand [lrange $params 1 end] 1]

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


proc unwrapTimeline records {
#-----------------------------------------------------------------------
# unwrap `fossil timeline' output, putting each comment on a single
# line. expected input: currently, a list of \n terminated lines.
# (maybe the \n should go away?)
#

      regsub -all {([[:alnum:]])- ([[:alnum:]])} $record \\1-\\2 record

      lappend out "$record"
   }
   return $out
}

# --( Fossil )----------------------------------------------------------


proc fossil {args} {
    #if `true' generate some noise:
    set debug false






    set candidate [first $args]; # candidate for expansion

    # Alias expansion and command interception:
    set params [intercept [expand $args]]
    if {[empty? $params]} {
        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}]

    # 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]} {
        set stty_init -onlcr;   # do not map LF to CRLF on output
    }









    #ensure that `lines' always exists:
    set lines {}

    # Call to `fossil' binary:
    spawn -noecho fossil {*}$params
    while 1 {
        if {[interactive? $command]} {
            interact; break
        }
        expect {
            eof { break }
            \n {
            #collect everything and postpone filtering
            lappend lines $expect_out(buffer)

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

    if {[interactive? $command] == false} {
       if {$command == "timeline"} { 
          set lines [unwrapTimeline $lines]
       }
       foreach line $lines {
          if {$debug == true} {
             puts -nonewline "IN: $line"
             puts -nonewline "OU: "
          }
          filter_with $chain "$line"
       }
    }

    log_user $prior_log;              # revert Expect settings
    return [spawned_errno $spawn_id]; # return with fossil error code

}






# --( Entry )-----------------------------------------------------------


config::init ~/.fslrc
exit [fossil {*}$argv]