Merge branch 'ea/blame-use-oideq'

[thirdparty/git.git] / git-gui / lib / index.tcl

# git-gui index (add/remove) support
# Copyright (C) 2006, 2007 Shawn Pearce

proc _delete_indexlock {} {
        if {[catch {file delete -- [gitdir index.lock]} err]} {
                error_popup [strcat [mc "Unable to unlock the index."] "\n\n$err"]
        }
}

proc close_and_unlock_index {fd after} {
        if {![catch {_close_updateindex $fd} err]} {
                unlock_index
                uplevel #0 $after
        } else {
                rescan_on_error $err $after
        }
}

proc _close_updateindex {fd} {
        fconfigure $fd -blocking 1
        close $fd
}

proc rescan_on_error {err {after {}}} {
        global use_ttk NS

        set w .indexfried
        Dialog $w
        wm withdraw $w
        wm title $w [strcat "[appname] ([reponame]): " [mc "Index Error"]]
        wm geometry $w "+[winfo rootx .]+[winfo rooty .]"
        set s [mc "Updating the Git index failed.  A rescan will be automatically started to resynchronize git-gui."]
        text $w.msg -yscrollcommand [list $w.vs set] \
                -width [string length $s] -relief flat \
                -borderwidth 0 -highlightthickness 0 \
                -background [get_bg_color $w]
        $w.msg tag configure bold -font font_uibold -justify center
        ${NS}::scrollbar $w.vs -command [list $w.msg yview]
        $w.msg insert end $s bold \n\n$err {}
        $w.msg configure -state disabled

        ${NS}::button $w.continue \
                -text [mc "Continue"] \
                -command [list destroy $w]
        ${NS}::button $w.unlock \
                -text [mc "Unlock Index"] \
                -command "destroy $w; _delete_indexlock"
        grid $w.msg - $w.vs -sticky news
        grid $w.unlock $w.continue - -sticky se -padx 2 -pady 2
        grid columnconfigure $w 0 -weight 1
        grid rowconfigure $w 0 -weight 1

        wm protocol $w WM_DELETE_WINDOW update
        bind $w.continue <Visibility> "
                grab $w
                focus %W
        "
        wm deiconify $w
        tkwait window $w

        $::main_status stop_all
        unlock_index
        rescan [concat $after {ui_ready;}] 0
}

proc update_indexinfo {msg path_list after} {
        global update_index_cp

        if {![lock_index update]} return

        set update_index_cp 0
        set path_list [lsort $path_list]
        set total_cnt [llength $path_list]
        set batch [expr {int($total_cnt * .01) + 1}]
        if {$batch > 25} {set batch 25}

        set status_bar_operation [$::main_status start $msg [mc "files"]]
        set fd [git_write update-index -z --index-info]
        fconfigure $fd \
                -blocking 0 \
                -buffering full \
                -buffersize 512 \
                -encoding binary \
                -translation binary
        fileevent $fd writable [list \
                write_update_indexinfo \
                $fd \
                $path_list \
                $total_cnt \
                $batch \
                $status_bar_operation \
                $after \
                ]
}

proc write_update_indexinfo {fd path_list total_cnt batch status_bar_operation \
        after} {
        global update_index_cp
        global file_states current_diff_path

        if {$update_index_cp >= $total_cnt} {
                $status_bar_operation stop
                close_and_unlock_index $fd $after
                return
        }

        for {set i $batch} \
                {$update_index_cp < $total_cnt && $i > 0} \
                {incr i -1} {
                set path [lindex $path_list $update_index_cp]
                incr update_index_cp

                set s $file_states($path)
                switch -glob -- [lindex $s 0] {
                A? {set new _O}
                MT -
                TM -
                T_ {set new _T}
                M? {set new _M}
                TD -
                D_ {set new _D}
                D? {set new _?}
                ?? {continue}
                }
                set info [lindex $s 2]
                if {$info eq {}} continue

                puts -nonewline $fd "$info\t[encoding convertto utf-8 $path]\0"
                display_file $path $new
        }

        $status_bar_operation update $update_index_cp $total_cnt
}

proc update_index {msg path_list after} {
        global update_index_cp

        if {![lock_index update]} return

        set update_index_cp 0
        set path_list [lsort $path_list]
        set total_cnt [llength $path_list]
        set batch [expr {int($total_cnt * .01) + 1}]
        if {$batch > 25} {set batch 25}

        set status_bar_operation [$::main_status start $msg [mc "files"]]
        set fd [git_write update-index --add --remove -z --stdin]
        fconfigure $fd \
                -blocking 0 \
                -buffering full \
                -buffersize 512 \
                -encoding binary \
                -translation binary
        fileevent $fd writable [list \
                write_update_index \
                $fd \
                $path_list \
                $total_cnt \
                $batch \
                $status_bar_operation \
                $after \
                ]
}

proc write_update_index {fd path_list total_cnt batch status_bar_operation \
        after} {
        global update_index_cp
        global file_states current_diff_path

        if {$update_index_cp >= $total_cnt} {
                $status_bar_operation stop
                close_and_unlock_index $fd $after
                return
        }

        for {set i $batch} \
                {$update_index_cp < $total_cnt && $i > 0} \
                {incr i -1} {
                set path [lindex $path_list $update_index_cp]
                incr update_index_cp

                switch -glob -- [lindex $file_states($path) 0] {
                AD {set new __}
                ?D {set new D_}
                _O -
                AT -
                AM {set new A_}
                TM -
                MT -
                _T {set new T_}
                _U -
                U? {
                        if {[file exists $path]} {
                                set new M_
                        } else {
                                set new D_
                        }
                }
                ?M {set new M_}
                ?? {continue}
                }
                puts -nonewline $fd "[encoding convertto utf-8 $path]\0"
                display_file $path $new
        }

        $status_bar_operation update $update_index_cp $total_cnt
}

proc checkout_index {msg path_list after capture_error} {
        global update_index_cp

        if {![lock_index update]} return

        set update_index_cp 0
        set path_list [lsort $path_list]
        set total_cnt [llength $path_list]
        set batch [expr {int($total_cnt * .01) + 1}]
        if {$batch > 25} {set batch 25}

        set status_bar_operation [$::main_status start $msg [mc "files"]]
        set fd [git_write checkout-index \
                --index \
                --quiet \
                --force \
                -z \
                --stdin \
                ]
        fconfigure $fd \
                -blocking 0 \
                -buffering full \
                -buffersize 512 \
                -encoding binary \
                -translation binary
        fileevent $fd writable [list \
                write_checkout_index \
                $fd \
                $path_list \
                $total_cnt \
                $batch \
                $status_bar_operation \
                $after \
                $capture_error \
                ]
}

proc write_checkout_index {fd path_list total_cnt batch status_bar_operation \
        after capture_error} {
        global update_index_cp
        global file_states current_diff_path

        if {$update_index_cp >= $total_cnt} {
                $status_bar_operation stop

                # We do not unlock the index directly here because this
                # operation expects to potentially run in parallel with file
                # deletions scheduled by revert_helper. We're done with the
                # update index, so we close it, but actually unlocking the index
                # and dealing with potential errors is deferred to the chord
                # body that runs when all async operations are completed.
                #
                # (See after_chord in revert_helper.)

                if {[catch {_close_updateindex $fd} err]} {
                        uplevel #0 $capture_error [list $err]
                }

                uplevel #0 $after

                return
        }

        for {set i $batch} \
                {$update_index_cp < $total_cnt && $i > 0} \
                {incr i -1} {
                set path [lindex $path_list $update_index_cp]
                incr update_index_cp
                switch -glob -- [lindex $file_states($path) 0] {
                U? {continue}
                ?M -
                ?T -
                ?D {
                        puts -nonewline $fd "[encoding convertto utf-8 $path]\0"
                        display_file $path ?_
                }
                }
        }

        $status_bar_operation update $update_index_cp $total_cnt
}

proc unstage_helper {txt paths} {
        global file_states current_diff_path

        if {![lock_index begin-update]} return

        set path_list [list]
        set after {}
        foreach path $paths {
                switch -glob -- [lindex $file_states($path) 0] {
                A? -
                M? -
                T? -
                D? {
                        lappend path_list $path
                        if {$path eq $current_diff_path} {
                                set after {reshow_diff;}
                        }
                }
                }
        }
        if {$path_list eq {}} {
                unlock_index
        } else {
                update_indexinfo \
                        $txt \
                        $path_list \
                        [concat $after {ui_ready;}]
        }
}

proc do_unstage_selection {} {
        global current_diff_path selected_paths

        if {[array size selected_paths] > 0} {
                unstage_helper \
                        [mc "Unstaging selected files from commit"] \
                        [array names selected_paths]
        } elseif {$current_diff_path ne {}} {
                unstage_helper \
                        [mc "Unstaging %s from commit" [short_path $current_diff_path]] \
                        [list $current_diff_path]
        }
}

proc add_helper {txt paths} {
        global file_states current_diff_path

        if {![lock_index begin-update]} return

        set path_list [list]
        set after {}
        foreach path $paths {
                switch -glob -- [lindex $file_states($path) 0] {
                _U -
                U? {
                        if {$path eq $current_diff_path} {
                                unlock_index
                                merge_stage_workdir $path
                                return
                        }
                }
                _O -
                ?M -
                ?D -
                ?T {
                        lappend path_list $path
                        if {$path eq $current_diff_path} {
                                set after {reshow_diff;}
                        }
                }
                }
        }
        if {$path_list eq {}} {
                unlock_index
        } else {
                update_index \
                        $txt \
                        $path_list \
                        [concat $after {ui_status [mc "Ready to commit."];}]
        }
}

proc do_add_selection {} {
        global current_diff_path selected_paths

        if {[array size selected_paths] > 0} {
                add_helper \
                        [mc "Adding selected files"] \
                        [array names selected_paths]
        } elseif {$current_diff_path ne {}} {
                add_helper \
                        [mc "Adding %s" [short_path $current_diff_path]] \
                        [list $current_diff_path]
        }
}

proc do_add_all {} {
        global file_states

        set paths [list]
        set untracked_paths [list]
        foreach path [array names file_states] {
                switch -glob -- [lindex $file_states($path) 0] {
                U? {continue}
                ?M -
                ?T -
                ?D {lappend paths $path}
                ?O {lappend untracked_paths $path}
                }
        }
        if {[llength $untracked_paths]} {
                set reply 0
                switch -- [get_config gui.stageuntracked] {
                no {
                        set reply 0
                }
                yes {
                        set reply 1
                }
                ask -
                default {
                        set reply [ask_popup [mc "Stage %d untracked files?" \
                                                                          [llength $untracked_paths]]]
                }
                }
                if {$reply} {
                        set paths [concat $paths $untracked_paths]
                }
        }
        add_helper [mc "Adding all changed files"] $paths
}

# Copied from TclLib package "lambda".
proc lambda {arguments body args} {
        return [list ::apply [list $arguments $body] {*}$args]
}

proc revert_helper {txt paths} {
        global file_states current_diff_path

        if {![lock_index begin-update]} return

        # Common "after" functionality that waits until multiple asynchronous
        # operations are complete (by waiting for them to activate their notes
        # on the chord).
        #
        # The asynchronous operations are each indicated below by a comment
        # before the code block that starts the async operation.
        set after_chord [SimpleChord::new {
                if {[string trim $err] != ""} {
                        rescan_on_error $err
                } else {
                        unlock_index
                        if {$should_reshow_diff} { reshow_diff }
                        ui_ready
                }
        }]

        $after_chord eval { set should_reshow_diff 0 }

        # This function captures an error for processing when after_chord is
        # completed. (The chord is curried into the lambda function.)
        set capture_error [lambda \
                {chord error} \
                { $chord eval [list set err $error] } \
                $after_chord]

        # We don't know how many notes we're going to create (it's dynamic based
        # on conditional paths below), so create a common note that will delay
        # the chord's completion until we activate it, and then activate it
        # after all the other notes have been created.
        set after_common_note [$after_chord add_note]

        set path_list [list]
        set untracked_list [list]

        foreach path $paths {
                switch -glob -- [lindex $file_states($path) 0] {
                U? {continue}
                ?O {
                        lappend untracked_list $path
                }
                ?M -
                ?T -
                ?D {
                        lappend path_list $path
                        if {$path eq $current_diff_path} {
                                $after_chord eval { set should_reshow_diff 1 }
                        }
                }
                }
        }

        set path_cnt [llength $path_list]
        set untracked_cnt [llength $untracked_list]

        # Asynchronous operation: revert changes by checking them out afresh
        # from the index.
        if {$path_cnt > 0} {
                # Split question between singular and plural cases, because
                # such distinction is needed in some languages. Previously, the
                # code used "Revert changes in" for both, but that can't work
                # in languages where 'in' must be combined with word from
                # rest of string (in different way for both cases of course).
                #
                # FIXME: Unfortunately, even that isn't enough in some languages
                # as they have quite complex plural-form rules. Unfortunately,
                # msgcat doesn't seem to support that kind of string
                # translation.
                #
                if {$path_cnt == 1} {
                        set query [mc \
                                "Revert changes in file %s?" \
                                [short_path [lindex $path_list]] \
                                ]
                } else {
                        set query [mc \
                                "Revert changes in these %i files?" \
                                $path_cnt]
                }

                set reply [tk_dialog \
                        .confirm_revert \
                        "[appname] ([reponame])" \
                        "$query

[mc "Any unstaged changes will be permanently lost by the revert."]" \
                        question \
                        1 \
                        [mc "Do Nothing"] \
                        [mc "Revert Changes"] \
                        ]

                if {$reply == 1} {
                        set note [$after_chord add_note]
                        checkout_index \
                                $txt \
                                $path_list \
                                [list $note activate] \
                                $capture_error
                }
        }

        # Asynchronous operation: Deletion of untracked files.
        if {$untracked_cnt > 0} {
                # Split question between singular and plural cases, because
                # such distinction is needed in some languages.
                #
                # FIXME: Unfortunately, even that isn't enough in some languages
                # as they have quite complex plural-form rules. Unfortunately,
                # msgcat doesn't seem to support that kind of string
                # translation.
                #
                if {$untracked_cnt == 1} {
                        set query [mc \
                                "Delete untracked file %s?" \
                                [short_path [lindex $untracked_list]] \
                                ]
                } else {
                        set query [mc \
                                "Delete these %i untracked files?" \
                                $untracked_cnt \
                                ]
                }

                set reply [tk_dialog \
                        .confirm_revert \
                        "[appname] ([reponame])" \
                        "$query

[mc "Files will be permanently deleted."]" \
                        question \
                        1 \
                        [mc "Do Nothing"] \
                        [mc "Delete Files"] \
                        ]

                if {$reply == 1} {
                        $after_chord eval { set should_reshow_diff 1 }

                        set note [$after_chord add_note]
                        delete_files $untracked_list [list $note activate]
                }
        }

        # Activate the common note. If no other notes were created, this
        # completes the chord. If other notes were created, then this common
        # note prevents a race condition where the chord might complete early.
        $after_common_note activate
}

# Delete all of the specified files, performing deletion in batches to allow the
# UI to remain responsive and updated.
proc delete_files {path_list after} {
        # Enable progress bar status updates
        set status_bar_operation [$::main_status \
                start \
                [mc "Deleting"] \
                [mc "files"]]

        set path_index 0
        set deletion_errors [list]
        set batch_size 50

        delete_helper \
                $path_list \
                $path_index \
                $deletion_errors \
                $batch_size \
                $status_bar_operation \
                $after
}

# Helper function to delete a list of files in batches. Each call deletes one
# batch of files, and then schedules a call for the next batch after any UI
# messages have been processed.
proc delete_helper {path_list path_index deletion_errors batch_size \
        status_bar_operation after} {
        global file_states

        set path_cnt [llength $path_list]

        set batch_remaining $batch_size

        while {$batch_remaining > 0} {
                if {$path_index >= $path_cnt} { break }

                set path [lindex $path_list $path_index]

                set deletion_failed [catch {file delete -- $path} deletion_error]

                if {$deletion_failed} {
                        lappend deletion_errors [list "$deletion_error"]
                } else {
                        remove_empty_directories [file dirname $path]

                        # Don't assume the deletion worked. Remove the file from
                        # the UI, but only if it no longer exists.
                        if {![path_exists $path]} {
                                unset file_states($path)
                                display_file $path __
                        }
                }

                incr path_index 1
                incr batch_remaining -1
        }

        # Update the progress bar to indicate that this batch has been
        # completed. The update will be visible when this procedure returns
        # and allows the UI thread to process messages.
        $status_bar_operation update $path_index $path_cnt

        if {$path_index < $path_cnt} {
                # The Tcler's Wiki lists this as the best practice for keeping
                # a UI active and processing messages during a long-running
                # operation.

                after idle [list after 0 [list \
                        delete_helper \
                        $path_list \
                        $path_index \
                        $deletion_errors \
                        $batch_size \
                        $status_bar_operation \
                        $after
                        ]]
        } else {
                # Finish the status bar operation.
                $status_bar_operation stop

                # Report error, if any, based on how many deletions failed.
                set deletion_error_cnt [llength $deletion_errors]

                if {($deletion_error_cnt > 0)
                 && ($deletion_error_cnt <= [MAX_VERBOSE_FILES_IN_DELETION_ERROR])} {
                        set error_text [mc "Encountered errors deleting files:\n"]

                        foreach deletion_error $deletion_errors {
                                append error_text "* [lindex $deletion_error 0]\n"
                        }

                        error_popup $error_text
                } elseif {$deletion_error_cnt == $path_cnt} {
                        error_popup [mc \
                                "None of the %d selected files could be deleted." \
                                $path_cnt \
                                ]
                } elseif {$deletion_error_cnt > 1} {
                        error_popup [mc \
                                "%d of the %d selected files could not be deleted." \
                                $deletion_error_cnt \
                                $path_cnt \
                                ]
                }

                uplevel #0 $after
        }
}

proc MAX_VERBOSE_FILES_IN_DELETION_ERROR {} { return 10; }

# This function is from the TCL documentation:
#
#   https://wiki.tcl-lang.org/page/file+exists
#
# [file exists] returns false if the path does exist but is a symlink to a path
# that doesn't exist. This proc returns true if the path exists, regardless of
# whether it is a symlink and whether it is broken.
proc path_exists {name} {
        expr {![catch {file lstat $name finfo}]}
}

# Remove as many empty directories as we can starting at the specified path,
# walking up the directory tree. If we encounter a directory that is not
# empty, or if a directory deletion fails, then we stop the operation and
# return to the caller. Even if this procedure fails to delete any
# directories at all, it does not report failure.
proc remove_empty_directories {directory_path} {
        set parent_path [file dirname $directory_path]

        while {$parent_path != $directory_path} {
                set contents [glob -nocomplain -dir $directory_path *]

                if {[llength $contents] > 0} { break }
                if {[catch {file delete -- $directory_path}]} { break }

                set directory_path $parent_path
                set parent_path [file dirname $directory_path]
        }
}

proc do_revert_selection {} {
        global current_diff_path selected_paths

        if {[array size selected_paths] > 0} {
                revert_helper \
                        [mc "Reverting selected files"] \
                        [array names selected_paths]
        } elseif {$current_diff_path ne {}} {
                revert_helper \
                        [mc "Reverting %s" [short_path $current_diff_path]] \
                        [list $current_diff_path]
        }
}

proc do_select_commit_type {} {
        global commit_type commit_type_is_amend

        if {$commit_type_is_amend == 0
                && [string match amend* $commit_type]} {
                create_new_commit
        } elseif {$commit_type_is_amend == 1
                && ![string match amend* $commit_type]} {
                load_last_commit

                # The amend request was rejected...
                #
                if {![string match amend* $commit_type]} {
                        set commit_type_is_amend 0
                }
        }
}