about summary refs log tree commit diff
path: root/third_party/git/git-gui/lib/checkout_op.tcl
diff options
context:
space:
mode:
Diffstat (limited to 'third_party/git/git-gui/lib/checkout_op.tcl')
-rw-r--r--third_party/git/git-gui/lib/checkout_op.tcl646
1 files changed, 646 insertions, 0 deletions
diff --git a/third_party/git/git-gui/lib/checkout_op.tcl b/third_party/git/git-gui/lib/checkout_op.tcl
new file mode 100644
index 000000000000..21ea768d8036
--- /dev/null
+++ b/third_party/git/git-gui/lib/checkout_op.tcl
@@ -0,0 +1,646 @@
+# 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
+}
+
+}