| # git-gui commit checkout support |
| # Copyright (C) 2007 Shawn Pearce |
| |
| class checkout_op { |
| |
| field w {}; # our window (if we have one) |
| field w_cons {}; # embedded console window object |
| |
| field new_expr ; # expression the user saw/thinks this is |
| field new_hash ; # commit SHA-1 we are switching to |
| field new_ref ; # ref we are updating/creating |
| field old_hash ; # commit SHA-1 that was checked out when we started |
| |
| field parent_w .; # window that started us |
| field merge_type none; # type of merge to apply to existing branch |
| field merge_base {}; # merge base if we have another ref involved |
| field fetch_spec {}; # refetch tracking branch if used? |
| field checkout 1; # actually checkout the branch? |
| field create 0; # create the branch if it doesn't exist? |
| field remote_source {}; # same as fetch_spec, to setup tracking |
| |
| field reset_ok 0; # did the user agree to reset? |
| field fetch_ok 0; # did the fetch succeed? |
| |
| field readtree_d {}; # buffered output from read-tree |
| field update_old {}; # was the update-ref call deferred? |
| field reflog_msg {}; # log message for the update-ref call |
| |
| constructor new {expr hash {ref {}}} { |
| set new_expr $expr |
| set new_hash $hash |
| set new_ref $ref |
| |
| return $this |
| } |
| |
| method parent {path} { |
| set parent_w [winfo toplevel $path] |
| } |
| |
| method enable_merge {type} { |
| set merge_type $type |
| } |
| |
| method enable_fetch {spec} { |
| set fetch_spec $spec |
| } |
| |
| method remote_source {spec} { |
| set remote_source $spec |
| } |
| |
| method enable_checkout {co} { |
| set checkout $co |
| } |
| |
| method enable_create {co} { |
| set create $co |
| } |
| |
| method run {} { |
| if {$fetch_spec ne {}} { |
| global M1B |
| |
| # We were asked to refresh a single tracking branch |
| # before we get to work. We should do that before we |
| # consider any ref updating. |
| # |
| set fetch_ok 0 |
| set l_trck [lindex $fetch_spec 0] |
| set remote [lindex $fetch_spec 1] |
| set r_head [lindex $fetch_spec 2] |
| regsub ^refs/heads/ $r_head {} r_name |
| |
| set cmd [list git fetch $remote] |
| if {$l_trck ne {}} { |
| lappend cmd +$r_head:$l_trck |
| } else { |
| lappend cmd $r_head |
| } |
| |
| _toplevel $this {Refreshing Tracking Branch} |
| set w_cons [::console::embed \ |
| $w.console \ |
| [mc "Fetching %s from %s" $r_name $remote]] |
| pack $w.console -fill both -expand 1 |
| $w_cons exec $cmd [cb _finish_fetch] |
| |
| bind $w <$M1B-Key-w> break |
| bind $w <$M1B-Key-W> break |
| bind $w <Visibility> " |
| [list grab $w] |
| [list focus $w] |
| " |
| wm protocol $w WM_DELETE_WINDOW [cb _noop] |
| tkwait window $w |
| |
| if {!$fetch_ok} { |
| delete_this |
| return 0 |
| } |
| } |
| |
| if {$new_ref ne {}} { |
| # If we have a ref we need to update it before we can |
| # proceed with a checkout (if one was enabled). |
| # |
| if {![_update_ref $this]} { |
| delete_this |
| return 0 |
| } |
| } |
| |
| if {$checkout} { |
| _checkout $this |
| return 1 |
| } |
| |
| delete_this |
| return 1 |
| } |
| |
| method _noop {} {} |
| |
| method _finish_fetch {ok} { |
| if {$ok} { |
| set l_trck [lindex $fetch_spec 0] |
| if {$l_trck eq {}} { |
| set l_trck FETCH_HEAD |
| } |
| if {[catch {set new_hash [git rev-parse --verify "$l_trck^0"]} err]} { |
| set ok 0 |
| $w_cons insert [mc "fatal: Cannot resolve %s" $l_trck] |
| $w_cons insert $err |
| } |
| } |
| |
| $w_cons done $ok |
| set w_cons {} |
| wm protocol $w WM_DELETE_WINDOW {} |
| |
| if {$ok} { |
| destroy $w |
| set w {} |
| } else { |
| button $w.close -text [mc Close] -command [list destroy $w] |
| pack $w.close -side bottom -anchor e -padx 10 -pady 10 |
| } |
| |
| set fetch_ok $ok |
| } |
| |
| method _update_ref {} { |
| global null_sha1 current_branch repo_config |
| |
| set ref $new_ref |
| set new $new_hash |
| |
| set is_current 0 |
| set rh refs/heads/ |
| set rn [string length $rh] |
| if {[string equal -length $rn $rh $ref]} { |
| set newbranch [string range $ref $rn end] |
| if {$current_branch eq $newbranch} { |
| set is_current 1 |
| } |
| } else { |
| set newbranch $ref |
| } |
| |
| if {[catch {set cur [git rev-parse --verify "$ref^0"]}]} { |
| # Assume it does not exist, and that is what the error was. |
| # |
| if {!$create} { |
| _error $this [mc "Branch '%s' does not exist." $newbranch] |
| return 0 |
| } |
| |
| set reflog_msg "branch: Created from $new_expr" |
| set cur $null_sha1 |
| |
| if {($repo_config(branch.autosetupmerge) eq {true} |
| || $repo_config(branch.autosetupmerge) eq {always}) |
| && $remote_source ne {} |
| && "refs/heads/$newbranch" eq $ref} { |
| |
| set c_remote [lindex $remote_source 1] |
| set c_merge [lindex $remote_source 2] |
| if {[catch { |
| git config branch.$newbranch.remote $c_remote |
| git config branch.$newbranch.merge $c_merge |
| } err]} { |
| _error $this [strcat \ |
| [mc "Failed to configure simplified git-pull for '%s'." $newbranch] \ |
| "\n\n$err"] |
| } |
| } |
| } elseif {$create && $merge_type eq {none}} { |
| # We were told to create it, but not do a merge. |
| # Bad. Name shouldn't have existed. |
| # |
| _error $this [mc "Branch '%s' already exists." $newbranch] |
| return 0 |
| } elseif {!$create && $merge_type eq {none}} { |
| # We aren't creating, it exists and we don't merge. |
| # We are probably just a simple branch switch. |
| # Use whatever value we just read. |
| # |
| set new $cur |
| set new_hash $cur |
| } elseif {$new eq $cur} { |
| # No merge would be required, don't compute anything. |
| # |
| } else { |
| catch {set merge_base [git merge-base $new $cur]} |
| if {$merge_base eq $cur} { |
| # The current branch is older. |
| # |
| set reflog_msg "merge $new_expr: Fast-forward" |
| } else { |
| switch -- $merge_type { |
| ff { |
| if {$merge_base eq $new} { |
| # The current branch is actually newer. |
| # |
| set new $cur |
| set new_hash $cur |
| } else { |
| _error $this [mc "Branch '%s' already exists.\n\nIt cannot fast-forward to %s.\nA merge is required." $newbranch $new_expr] |
| return 0 |
| } |
| } |
| reset { |
| # The current branch will lose things. |
| # |
| if {[_confirm_reset $this $cur]} { |
| set reflog_msg "reset $new_expr" |
| } else { |
| return 0 |
| } |
| } |
| default { |
| _error $this [mc "Merge strategy '%s' not supported." $merge_type] |
| return 0 |
| } |
| } |
| } |
| } |
| |
| if {$new ne $cur} { |
| if {$is_current} { |
| # No so fast. We should defer this in case |
| # we cannot update the working directory. |
| # |
| set update_old $cur |
| return 1 |
| } |
| |
| if {[catch { |
| git update-ref -m $reflog_msg $ref $new $cur |
| } err]} { |
| _error $this [strcat [mc "Failed to update '%s'." $newbranch] "\n\n$err"] |
| return 0 |
| } |
| } |
| |
| return 1 |
| } |
| |
| method _checkout {} { |
| if {[lock_index checkout_op]} { |
| after idle [cb _start_checkout] |
| } else { |
| _error $this [mc "Staging area (index) is already locked."] |
| delete_this |
| } |
| } |
| |
| method _start_checkout {} { |
| global HEAD commit_type |
| |
| # -- Our in memory state should match the repository. |
| # |
| repository_state curType old_hash curMERGE_HEAD |
| if {[string match amend* $commit_type] |
| && $curType eq {normal} |
| && $old_hash eq $HEAD} { |
| } elseif {$commit_type ne $curType || $HEAD ne $old_hash} { |
| info_popup [mc "Last scanned state does not match repository state. |
| |
| Another Git program has modified this repository since the last scan. A rescan must be performed before the current branch can be changed. |
| |
| The rescan will be automatically started now. |
| "] |
| unlock_index |
| rescan ui_ready |
| delete_this |
| return |
| } |
| |
| if {$old_hash eq $new_hash} { |
| _after_readtree $this |
| } elseif {[is_config_true gui.trustmtime]} { |
| _readtree $this |
| } else { |
| ui_status [mc "Refreshing file status..."] |
| set fd [git_read update-index \ |
| -q \ |
| --unmerged \ |
| --ignore-missing \ |
| --refresh \ |
| ] |
| fconfigure $fd -blocking 0 -translation binary |
| fileevent $fd readable [cb _refresh_wait $fd] |
| } |
| } |
| |
| method _refresh_wait {fd} { |
| read $fd |
| if {[eof $fd]} { |
| close $fd |
| _readtree $this |
| } |
| } |
| |
| method _name {} { |
| if {$new_ref eq {}} { |
| return [string range $new_hash 0 7] |
| } |
| |
| set rh refs/heads/ |
| set rn [string length $rh] |
| if {[string equal -length $rn $rh $new_ref]} { |
| return [string range $new_ref $rn end] |
| } else { |
| return $new_ref |
| } |
| } |
| |
| method _readtree {} { |
| global HEAD |
| |
| set readtree_d {} |
| set status_bar_operation [$::main_status start \ |
| [mc "Updating working directory to '%s'..." [_name $this]] \ |
| [mc "files checked out"]] |
| |
| set fd [git_read --stderr read-tree \ |
| -m \ |
| -u \ |
| -v \ |
| --exclude-per-directory=.gitignore \ |
| $HEAD \ |
| $new_hash \ |
| ] |
| fconfigure $fd -blocking 0 -translation binary |
| fileevent $fd readable [cb _readtree_wait $fd $status_bar_operation] |
| } |
| |
| method _readtree_wait {fd status_bar_operation} { |
| global current_branch |
| |
| set buf [read $fd] |
| $status_bar_operation update_meter $buf |
| append readtree_d $buf |
| |
| fconfigure $fd -blocking 1 |
| if {![eof $fd]} { |
| fconfigure $fd -blocking 0 |
| $status_bar_operation stop |
| return |
| } |
| |
| if {[catch {close $fd}]} { |
| set err $readtree_d |
| regsub {^fatal: } $err {} err |
| $status_bar_operation stop [mc "Aborted checkout of '%s' (file level merging is required)." [_name $this]] |
| warn_popup [strcat [mc "File level merge required."] " |
| |
| $err |
| |
| " [mc "Staying on branch '%s'." $current_branch]] |
| unlock_index |
| delete_this |
| return |
| } |
| |
| $status_bar_operation stop |
| _after_readtree $this |
| } |
| |
| method _after_readtree {} { |
| global commit_type HEAD MERGE_HEAD PARENT |
| global current_branch is_detached |
| global ui_comm |
| |
| set name [_name $this] |
| set log "checkout: moving" |
| if {!$is_detached} { |
| append log " from $current_branch" |
| } |
| |
| # -- Move/create HEAD as a symbolic ref. Core git does not |
| # even check for failure here, it Just Works(tm). If it |
| # doesn't we are in some really ugly state that is difficult |
| # to recover from within git-gui. |
| # |
| set rh refs/heads/ |
| set rn [string length $rh] |
| if {[string equal -length $rn $rh $new_ref]} { |
| set new_branch [string range $new_ref $rn end] |
| if {$is_detached || $current_branch ne $new_branch} { |
| append log " to $new_branch" |
| if {[catch { |
| git symbolic-ref -m $log HEAD $new_ref |
| } err]} { |
| _fatal $this $err |
| } |
| set current_branch $new_branch |
| set is_detached 0 |
| } |
| } else { |
| if {!$is_detached || $new_hash ne $HEAD} { |
| append log " to $new_expr" |
| if {[catch { |
| _detach_HEAD $log $new_hash |
| } err]} { |
| _fatal $this $err |
| } |
| } |
| set current_branch HEAD |
| set is_detached 1 |
| } |
| |
| # -- We had to defer updating the branch itself until we |
| # knew the working directory would update. So now we |
| # need to finish that work. If it fails we're in big |
| # trouble. |
| # |
| if {$update_old ne {}} { |
| if {[catch { |
| git update-ref \ |
| -m $reflog_msg \ |
| $new_ref \ |
| $new_hash \ |
| $update_old |
| } err]} { |
| _fatal $this $err |
| } |
| } |
| |
| if {$is_detached} { |
| info_popup [mc "You are no longer on a local branch. |
| |
| If you wanted to be on a branch, create one now starting from 'This Detached Checkout'."] |
| } |
| |
| # -- Run the post-checkout hook. |
| # |
| set fd_ph [githook_read post-checkout $old_hash $new_hash 1] |
| if {$fd_ph ne {}} { |
| global pch_error |
| set pch_error {} |
| fconfigure $fd_ph -blocking 0 -translation binary -eofchar {} |
| fileevent $fd_ph readable [cb _postcheckout_wait $fd_ph] |
| } else { |
| _update_repo_state $this |
| } |
| } |
| |
| method _postcheckout_wait {fd_ph} { |
| global pch_error |
| |
| append pch_error [read $fd_ph] |
| fconfigure $fd_ph -blocking 1 |
| if {[eof $fd_ph]} { |
| if {[catch {close $fd_ph}]} { |
| hook_failed_popup post-checkout $pch_error 0 |
| } |
| unset pch_error |
| _update_repo_state $this |
| return |
| } |
| fconfigure $fd_ph -blocking 0 |
| } |
| |
| method _update_repo_state {} { |
| # -- Update our repository state. If we were previously in |
| # amend mode we need to toss the current buffer and do a |
| # full rescan to update our file lists. If we weren't in |
| # amend mode our file lists are accurate and we can avoid |
| # the rescan. |
| # |
| global commit_type_is_amend commit_type HEAD MERGE_HEAD PARENT |
| global ui_comm |
| |
| unlock_index |
| set name [_name $this] |
| set commit_type_is_amend 0 |
| if {[string match amend* $commit_type]} { |
| $ui_comm delete 0.0 end |
| $ui_comm edit reset |
| $ui_comm edit modified false |
| rescan [list ui_status [mc "Checked out '%s'." $name]] |
| } else { |
| repository_state commit_type HEAD MERGE_HEAD |
| set PARENT $HEAD |
| ui_status [mc "Checked out '%s'." $name] |
| } |
| delete_this |
| } |
| |
| git-version proc _detach_HEAD {log new} { |
| >= 1.5.3 { |
| git update-ref --no-deref -m $log HEAD $new |
| } |
| default { |
| set p [gitdir HEAD] |
| file delete $p |
| set fd [open $p w] |
| fconfigure $fd -translation lf -encoding utf-8 |
| puts $fd $new |
| close $fd |
| } |
| } |
| |
| method _confirm_reset {cur} { |
| set reset_ok 0 |
| set name [_name $this] |
| set gitk [list do_gitk [list $cur ^$new_hash]] |
| |
| _toplevel $this {Confirm Branch Reset} |
| pack [label $w.msg1 \ |
| -anchor w \ |
| -justify left \ |
| -text [mc "Resetting '%s' to '%s' will lose the following commits:" $name $new_expr]\ |
| ] -anchor w |
| |
| set list $w.list.l |
| frame $w.list |
| text $list \ |
| -font font_diff \ |
| -width 80 \ |
| -height 10 \ |
| -wrap none \ |
| -xscrollcommand [list $w.list.sbx set] \ |
| -yscrollcommand [list $w.list.sby set] |
| scrollbar $w.list.sbx -orient h -command [list $list xview] |
| scrollbar $w.list.sby -orient v -command [list $list yview] |
| pack $w.list.sbx -fill x -side bottom |
| pack $w.list.sby -fill y -side right |
| pack $list -fill both -expand 1 |
| pack $w.list -fill both -expand 1 -padx 5 -pady 5 |
| |
| pack [label $w.msg2 \ |
| -anchor w \ |
| -justify left \ |
| -text [mc "Recovering lost commits may not be easy."] \ |
| ] |
| pack [label $w.msg3 \ |
| -anchor w \ |
| -justify left \ |
| -text [mc "Reset '%s'?" $name] \ |
| ] |
| |
| frame $w.buttons |
| button $w.buttons.visualize \ |
| -text [mc Visualize] \ |
| -command $gitk |
| pack $w.buttons.visualize -side left |
| button $w.buttons.reset \ |
| -text [mc Reset] \ |
| -command " |
| set @reset_ok 1 |
| destroy $w |
| " |
| pack $w.buttons.reset -side right |
| button $w.buttons.cancel \ |
| -default active \ |
| -text [mc Cancel] \ |
| -command [list destroy $w] |
| pack $w.buttons.cancel -side right -padx 5 |
| pack $w.buttons -side bottom -fill x -pady 10 -padx 10 |
| |
| set fd [git_read rev-list --pretty=oneline $cur ^$new_hash] |
| while {[gets $fd line] > 0} { |
| set abbr [string range $line 0 7] |
| set subj [string range $line 41 end] |
| $list insert end "$abbr $subj\n" |
| } |
| close $fd |
| $list configure -state disabled |
| |
| bind $w <Key-v> $gitk |
| bind $w <Visibility> " |
| grab $w |
| focus $w.buttons.cancel |
| " |
| bind $w <Key-Return> [list destroy $w] |
| bind $w <Key-Escape> [list destroy $w] |
| tkwait window $w |
| return $reset_ok |
| } |
| |
| method _error {msg} { |
| if {[winfo ismapped $parent_w]} { |
| set p $parent_w |
| } else { |
| set p . |
| } |
| |
| tk_messageBox \ |
| -icon error \ |
| -type ok \ |
| -title [wm title $p] \ |
| -parent $p \ |
| -message $msg |
| } |
| |
| method _toplevel {title} { |
| regsub -all {::} $this {__} w |
| set w .$w |
| |
| if {[winfo ismapped $parent_w]} { |
| set p $parent_w |
| } else { |
| set p . |
| } |
| |
| toplevel $w |
| wm title $w $title |
| wm geometry $w "+[winfo rootx $p]+[winfo rooty $p]" |
| } |
| |
| method _fatal {err} { |
| error_popup [strcat [mc "Failed to set current branch. |
| |
| This working directory is only partially switched. We successfully updated your files, but failed to update an internal Git file. |
| |
| This should not have occurred. %s will now close and give up." [appname]] " |
| |
| $err"] |
| exit 1 |
| } |
| |
| } |
