Eskil

2019-02-04
 Include a file selector when committing multiple files.
 Allow directory with -review.

2018-10-03
 Handle deleted files in GIT vcsvfs

2018-09-23
 Upgraded tablelist to 6.3

2018-06-20
 Added save-reload option in edit mode.
 Upgraded tablelist to 6.2

    return 1
}

# Sort file names
proc Fsort {l} {
    lsort -dictionary $l
}

set ::profList [list CompareFiles eskil::rev::SVN::mount]
proc InitProf {} {
    foreach n $::profList {
        trace add execution $n {enter} [list DoProfEnter $n]
        trace add execution $n {leave} [list DoProfLeave $n]
    }
    set ::prof(start) [clock milliseconds]
}
proc DoProfEnter {point args} {
    set ::prof($point,enter) [clock milliseconds]
}
proc DoProfLeave {point args} {
    set dur [expr { [clock milliseconds] - $::prof($point,enter)}]
    incr ::prof($point,dur) $dur
}
proc EndProf {} {
    set ::prof(end) [clock milliseconds]
    set ::prof(dur) [expr {$::prof(end) - $::prof(start)}]
    foreach n $::profList {
        trace remove execution $n {enter} [list DoProfEnter $n]
        trace remove execution $n {leave} [list DoProfLeave $n]
    }
    parray ::prof
}

# Compare two files or dirs
# Return true if equal
proc CompareFiles {file1 file2} {
    if {[catch {file lstat $file1 stat1}]} {
        return 0
    }

    }

    switch $::Pref(dir,comparelevel) {
        2 -
        1 { # Check contents internally
            set bufsz 65536
            set eq 2 ;# 2 = equal this far, 1 = equal, 0 = not equal
            DoProfEnter OpenFile1
            set ch1 [open $file1 r]
            DoProfLeave OpenFile1
            DoProfEnter OpenFile2
            set ch2 [open $file2 r]
            DoProfLeave OpenFile2
            if {$::Pref(dir,comparelevel) == 2} {
                fconfigure $ch1 -translation binary
                fconfigure $ch2 -translation binary
            }
            # Allow a plugin to do its thing
            if {$anyPlugin} {
                #puts "PLUGIN!"

                } else {
                    if {![string equal $f1 $f2]} {
                        set eq 0
                    }
                }
            }
            while {$eq == 2 && ![eof $ch1] && ![eof $ch2]} {
                DoProfEnter ReadIt
                set f1 [read $ch1 $bufsz]
                set f2 [read $ch2 $bufsz]
                DoProfLeave ReadIt
                if {$nocase} {
                    if {![string equal -nocase $f1 $f2]} {
                        set eq 0
                    }
                } else {
                    if {![string equal $f1 $f2]} {
                        set eq 0
                    }
                }
            }
            if {$eq == 2 && (![eof $ch1] || ![eof $ch2])} {
                set eq 0
            }
            # Errors during close are not interesting
            DoProfEnter Close
            catch {close $ch1}
            catch {close $ch2}
            DoProfLeave Close
        }
    }
    return [expr {$eq != 0}]
}

# Returns the contents of a directory as a sorted list of full file paths.
proc DirContents {dir} {

            set DebugCh ""
            set DebugTime {}
        }
        # Uncomment to activate debug logging
        #set DebugCh [open ~/dirdiff.log a]
        #$self DlogTablelist
        $self Dlog RESTART
        InitProf
        set AfterId ""
        set IdleQueue {}
        set ScheduledRestart 0
        array unset IdleQueueArr
        set protect {left 0 right 0}

        # Directory Diff only supports one plugin.

            } else {
                set statusvar "$rightfull  ($count)"
            }

            $self Dlog Reschedule
            set AfterId [after $AfterTime [mymethod UpdateIdle]]
        } else {
            EndProf
            $self Dlog DONE
            set statusvar ""
            set AfterId ""
        }
    }

    method SetNodeStatus {node status} {

    mapNoChange $top 0
}

# Read a patch file and display it
proc displayPatch {top} {
    set ::eskil($top,leftLabel) "Patch $::eskil($top,patchFile): old"
    set ::eskil($top,rightLabel) "Patch $::eskil($top,patchFile): new"
    set ::eskil($top,patchFilelist) {}
    update idletasks

    if {$::eskil($top,patchFile) eq ""} {
        if {$::eskil($top,patchData) eq ""} {
            set data [getFullPatch $top]
        } else {
            set data $::eskil($top,patchData)

                    insertLine $top $side "" $divider patch
                    insertLine $top $side "" $fname   patch
                    insertLine $top $side "" $divider patch
                }
                addChange $top 4 change 0 0 0 0
            }
            set fname [string range $line 7 end]
            # Collect the files seen. Used by revision control for commit.
            if {[file isfile $fname]} {
                lappend ::eskil($top,patchFilelist) $fname
            }
        }
        # Detect the first line in a -c style diff
        if {[regexp {^\*\*\* } $line]} {
            if {$state eq "right"} {
                displayOnePatch $top $leftLines $rightLines $leftLine $rightLine
                set leftLines {}
                set rightLines {}

            emptyLine $top $side
            insertLine $top $side "" $divider patch
            insertLine $top $side "" $fname   patch
            insertLine $top $side "" $divider patch
        }
        addChange $top 4 change 0 0 0 0
    }

    # Cleanup detected files
    set ::eskil($top,patchFilelist) [lsort -dictionary -unique \
                                             $::eskil($top,patchFilelist)]
}

#####################################
# Main diff
#####################################

# Prepare for a diff by creating needed temporary files

    set ::eskil($top,leftFile) $::eskil($top,RevFile)
}

proc revCommit {top} {
    if {[$::widgets($top,commit) cget -state] eq "disabled"} return
    set type $::eskil($top,modetype)
    if {$::eskil($top,mode) eq "patch"} {
        if {[llength $::eskil($top,patchFilelist)] != 0} {
            # Use the list extracted from patch
            set files $::eskil($top,patchFilelist)
        } else {
            # Use the list given by user
            set files $::eskil($top,reviewFiles)
        }
    } else {
        set files [list $::eskil($top,RevFile)]
    }
    eskil::rev::${type}::commitFile $top {*}$files
}

proc revRevert {top} {

        return $last
    } else {
        return [file join $penultimate $last]
    }
}

# Dialog for commit, getting log message
# target: String shown in dialog
# system: Rev System
# precmd: Command part before message
# postcmd: Command part after message. Assumed to be files.
# useSts: Use status from exec rather than message to recognise error.
proc CommitDialog {top target system precmd postcmd {useSts 0}} {
    set w $top.logmsg
    destroy  $w
    toplevel $w -padx 3 -pady 3
    wm title $w "Commit log message for $target"

    set ::eskil($top,logdialogok) 0

    bind $w <Alt-c> [list destroy $w]\;break
    bind $w <Key-Escape> [list destroy $w]\;break

    grid $w.t  - -sticky news -padx 3 -pady 3
    grid $w.ok $w.ca -padx 3 -pady 3
    grid columnconfigure $w $w.t -weight 1 -uniform a
    grid rowconfigure    $w $w.t -weight 1

    if {[llength $postcmd] > 1} {
        # TODO: Scrolled frame
        ttk::frame $w.f -padding 1
        set t 0
        foreach fileName $postcmd {
            set ::eskil($top,commit,fileselect$t) 1
            ttk::checkbutton $w.f.cb$t -text $fileName \
                    -variable ::eskil($top,commit,fileselect$t)
            grid $w.f.cb$t -sticky "w" -padx 1 -pady 1
            incr t
        }
        grid $w.f -sticky news -padx 3 -pady 3
    }

    tkwait visibility $w
    focus -force $w.t
    tkwait window $w.dummy

    if {!$::eskil($top,logdialogok)} {
        return
    }

    set res [string trim $::eskil(logdialog)]
    set ::eskil(logdialog) $res

    set todo $postcmd
    if {[llength $postcmd] > 1} {
        set todo {}
        set t 0
        foreach fileName $postcmd {
            if {$::eskil($top,commit,fileselect$t)} {
                lappend todo $fileName
            }
            incr t
        }
        # None left means skip.
        if {[llength $todo] == 0} {
            return
        }
    }

    # Splash screen for visual feedback
    set now [clock clicks -milliseconds]
    ttk::label $w.splash -text "Committing" -anchor center -font myfont
    place $w.splash -x 0 -y 0 -relwidth 1.0 -relheight 1.0
    update
    # Commit