# # ## ### ##### ######## #############

    typemethod dotsto {path} {
	::variable mydotdestination $path
	return
    }

    typemethod watch {id} {
	::variable mywatchids
	lappend mywatchids $id
    }

    typemethod dot {label changesets} {
	::variable mydotprefix $label
	::variable mydotid     0

	set dg [Setup $changesets 0]
	Mark $dg

	#    and work on breaking it.

	log write 3 cyclebreaker {Traverse changesets}

	InitializeCandidates $dg
	while {1} {
	    while {[WithoutPredecessor $dg n]} {
		MarkWatch $dg
		ProcessedHook $dg $n $myat
		$dg node delete $n
		incr myat
		ShowPendingNodes
	    }

	    if {![llength [dg nodes]]} break

	    BreakCycleHook       $dg
	    InitializeCandidates $dg
	    MarkWatch            $dg
	}

	$dg destroy

	log write 3 cyclebreaker Done.
	ClearHooks

    }

    # # ## ### ##### ######## #############
    ## Internal methods

    proc Setup {changesets {log 1}} {
	if {$log} {
	    log write 3 cyclebreaker "Creating graph of changesets"
	}

	set dg [struct::graph dg]

	foreach cset $changesets {
	    set tr [$cset timerange]
	    $dg node insert $cset
	    $dg node set    $cset timerange $tr
	    $dg node set    $cset label     "[$cset str]\\n[join [struct::list map $tr {::clock format}] "\\n"]"
	    $dg node set    $cset __id__    [$cset id]
	    $dg node set    $cset shape     [expr {[$cset bysymbol]
						   ? "ellipse"
						   : "box"}]
	}

	if {$log} {
	    log write 3 cyclebreaker "Has [nsp [llength $changesets] changeset]"
	}

	# 2. Find for all relevant changeset their revisions and their
	#    dependencies. Map the latter back to changesets and
	#    construct the corresponding arcs.





	foreach cset $changesets {
	    foreach succ [$cset successors] {
		# Changesets may have dependencies outside of the
		# chosen set. These are ignored
		if {![$dg node exists $succ]} continue
		$dg arc insert $cset $succ

			    log write 2 cyclebreaker \
				"LOOP * rev <$r> --> rev <$succrev> --> cs [project::rev strlist [project::rev ofrev $succrev]]"
			}
		    }
		}
	    }
	}

	if {$log} {
	    log write 3 cyclebreaker "Has [nsp [llength [$dg arcs]] dependency dependencies]"
	}

	# Run the user hook to manipulate the graph before
	# consummation.

	if {$log} { Mark $dg -start }
	MarkWatch $dg
	PreHook   $dg
	MarkWatch $dg

	# This kills the application if loops (see above) were found.
	trouble abort?
	return  $dg
    }

    # Instead of searching the whole graph for the degree-0 nodes in

	# circles, leaving them in, unbroken.

	set pre [$dg nodes -in $n]

        $dg node delete $n

	foreach cset $replacements {
	    set tr [$cset timerange]
	    $dg node insert $cset
	    $dg node set    $cset timerange $tr
	    $dg node set    $cset label     "[$cset str]\\n[join [struct::list map $tr {::clock format}] "\\n"]"
	    $dg node set    $cset __id__    [$cset id]
	    $dg node set    $cset shape     [expr {[$cset bysymbol]
						   ? "ellipse"
						   : "box"}]
	}

	foreach cset $replacements {
	    foreach succ [$cset successors] {
		# The new changesets may have dependencies outside of
		# the chosen set. These are ignored
		if {![$dg node exists $succ]} continue

	::variable myprecmd   {}
	::variable mysavecmd  {}
	::variable mybreakcmd {}
	return
    }

    # # ## ### ##### ######## #############

    proc MarkWatch {graph} {
	::variable mywatchids
	set watched [Watched $graph $mywatchids]
	if {![llength $watched]} return
	set neighbours [eval [linsert $watched 0 $graph nodes -adj]]
	#foreach n $neighbours { log write 6 cyclebreaker "Neighbor [$n id] => $n" }
	Mark $graph watched [concat $watched $neighbours]
	return
    }

    proc Watched {graph watchids} {
	set res {}
	foreach id $watchids {
	    set nl [$graph nodes -key __id__ -value $id]
	    if {![llength $nl]} continue
	    lappend res $nl
	    #log write 6 breakrcycle "Watching $id => $nl"
	    $graph node set $nl fontcolor red
	}
	return $res
    }

    # # ## ### ##### ######## #############


    typevariable myat      0 ; # Counter for commit ids for the
			       # changesets.
    typevariable mybottom {} ; # List of the candidate nodes for
			       # committing.

    typevariable myprecmd   {} ; # Callback, change graph before walk.
    typevariable mysavecmd  {} ; # Callback, for each processed node.
    typevariable mybreakcmd {} ; # Callback, for each found cycle.

    typevariable mydotdestination {} ; # Destination directory for the
				       # generated .dot files.
    typevariable mydotprefix      {} ; # Prefix for dot files when
				       # exporting the graphs.
    typevariable mydotid           0 ; # Counter for dot file name
				       # generation.
    typevariable mywatchids       {} ; # Changesets to watch the
				       # neighbourhood of.

    # # ## ### ##### ######## #############
    ## Configuration

    pragma -hasinstances   no ; # singleton
    pragma -hastypeinfo    no ; # no introspection
    pragma -hastypedestroy no ; # immortal

		--state                     { state use [Value arguments] }
		--trunk-only                { repository trunkonly! }
		--exclude                   { project::sym exclude     [Value arguments] }
		--force-tag                 { project::sym forcetag    [Value arguments] }
		--force-branch              { project::sym forcebranch [Value arguments] }
		--batch                     { log noprogress }
		--dots                      { cyclebreaker dotsto [Value arguments] }
		--watch                     { cyclebreaker watch  [Value arguments] }
		default {
		    Usage $badoption$option\n$gethelp
		}
	    }
	}

	if {[llength $arguments] > 1} Usage