summaryrefslogtreecommitdiff
path: root/lib/merge.tcl
blob: 0e50919d4c272e1e071e08c58b30d2c688c8d111 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
# git-gui branch merge support
# Copyright (C) 2006, 2007 Shawn Pearce
 
class merge {
 
field w         ; # top level window
field w_rev     ; # mega-widget to pick the revision to merge
 
method _can_merge {} {
	global HEAD commit_type file_states
 
	if {[string match amend* $commit_type]} {
		info_popup {Cannot merge while amending.
 
You must finish amending this commit before starting any type of merge.
}
		return 0
	}
 
	if {[committer_ident] eq {}} {return 0}
	if {![lock_index merge]} {return 0}

	# -- Our in memory state should match the repository.
	#
	repository_state curType curHEAD curMERGE_HEAD
	if {$commit_type ne $curType || $HEAD ne $curHEAD} {
		info_popup {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 a merge can be performed.
 
The rescan will be automatically started now.
}
		unlock_index
		rescan ui_ready
		return 0
	}
 
	foreach path [array names file_states] {
		switch -glob -- [lindex $file_states($path) 0] {
		_O {
			continue; # and pray it works!
		}
		U? {
			error_popup "You are in the middle of a conflicted merge.
 
File [short_path $path] has merge conflicts.
 
You must resolve them, stage the file, and commit to complete the current merge.  Only then can you begin another merge.
"
			unlock_index
			return 0
		}
		?? {
			error_popup "You are in the middle of a change.
 
File [short_path $path] is modified.
 
You should complete the current commit before starting a merge.  Doing so will help you abort a failed merge, should the need arise.
"
			unlock_index
			return 0
		}
		}
	}
 
	return 1
}
 
method _rev {} {
	if {[catch {$w_rev commit_or_die}]} {
		return {}
	}
	return [$w_rev get]
}
 
method _visualize {} {
	set rev [_rev $this]
	if {$rev ne {}} {
		do_gitk [list $rev --not HEAD]
	}
}
 
method _start {} {
	global HEAD current_branch remote_url
 
	set name [_rev $this]
	if {$name eq {}} {
		return
	}
 
	set spec [$w_rev get_tracking_branch]
	set cmit [$w_rev get_commit]
 
	set fh [open [gitdir FETCH_HEAD] w]
	fconfigure $fh -translation lf
	if {$spec eq {}} {
		set remote .
		set branch $name
		set stitle $branch
	} else {
		set remote $remote_url([lindex $spec 1])
		if {[regexp {^[^:@]*@[^:]*:/} $remote]} {
			regsub {^[^:@]*@} $remote {} remote
		}
		set branch [lindex $spec 2]
		set stitle "$branch of $remote"
	}
	regsub ^refs/heads/ $branch {} branch
	puts $fh "$cmit\t\tbranch '$branch' of $remote"
	close $fh
 
	set cmd [list git]
	lappend cmd merge
	lappend cmd --strategy=recursive
	lappend cmd [git fmt-merge-msg <[gitdir FETCH_HEAD]]
	lappend cmd HEAD
	lappend cmd $name
 
	set msg "Merging $current_branch and $stitle"
	ui_status "$msg..."
	set cons [console::new "Merge" "merge $stitle"]
	console::exec $cons $cmd [cb _finish $cons]
 
	wm protocol $w WM_DELETE_WINDOW {}
	destroy $w
}
 
method _finish {cons ok} {
	console::done $cons $ok
	if {$ok} {
		set msg {Merge completed successfully.}
	} else {
		set msg {Merge failed.  Conflict resolution is required.}
	}
	unlock_index
	rescan [list ui_status $msg]
	delete_this
}
 
constructor dialog {} {
	global current_branch
	global M1B
 
	if {![_can_merge $this]} {
		delete_this
		return
	}
 
	make_toplevel top w
	wm title $top "[appname] ([reponame]): Merge"
	if {$top ne {.}} {
		wm geometry $top "+[winfo rootx .]+[winfo rooty .]"
	}
 
	set _start [cb _start]
 
	label $w.header \
		-text "Merge Into $current_branch" \
		-font font_uibold
	pack $w.header -side top -fill x
 
	frame $w.buttons
	button $w.buttons.visualize \
		-text Visualize \
		-command [cb _visualize]
	pack $w.buttons.visualize -side left
	button $w.buttons.merge \
		-text Merge \
		-command $_start
	pack $w.buttons.merge -side right
	button $w.buttons.cancel \
		-text {Cancel} \
		-command [cb _cancel]
	pack $w.buttons.cancel -side right -padx 5
	pack $w.buttons -side bottom -fill x -pady 10 -padx 10
 
	set w_rev [::choose_rev::new_unmerged $w.rev {Revision To Merge}]
	pack $w.rev -anchor nw -fill both -expand 1 -pady 5 -padx 5
 
	bind $w <$M1B-Key-Return> $_start
	bind $w <Key-Return> $_start
	bind $w <Key-Escape> [cb _cancel]
	wm protocol $w WM_DELETE_WINDOW [cb _cancel]
 
	bind $w.buttons.merge <Visibility> [cb _visible]
	tkwait window $w
}
 
method _visible {} {
	grab $w
	if {[is_config_true gui.matchtrackingbranch]} {
		$w_rev pick_tracking_branch
	}
	$w_rev focus_filter
}
 
method _cancel {} {
	wm protocol $w WM_DELETE_WINDOW {}
	unlock_index
	destroy $w
	delete_this
}
 
}
 
namespace eval merge {
 
proc reset_hard {} {
	global HEAD commit_type file_states
 
	if {[string match amend* $commit_type]} {
		info_popup {Cannot abort while amending.
 
You must finish amending this commit.
}
		return
	}
 
	if {![lock_index abort]} return
 
	if {[string match *merge* $commit_type]} {
		set op_question "Abort merge?
 
Aborting the current merge will cause *ALL* uncommitted changes to be lost.
 
Continue with aborting the current merge?"
	} else {
		set op_question "Reset changes?
 
Resetting the changes will cause *ALL* uncommitted changes to be lost.
 
Continue with resetting the current changes?"
	}
 
	if {[ask_popup $op_question] eq {yes}} {
		set fd [git_read --stderr read-tree --reset -u -v HEAD]
		fconfigure $fd -blocking 0 -translation binary
		fileevent $fd readable [namespace code [list _reset_wait $fd]]
		$::main_status start {Aborting} {files reset}
	} else {
		unlock_index
	}
}
 
proc _reset_wait {fd} {
	global ui_comm
 
	$::main_status update_meter [read $fd]
 
	fconfigure $fd -blocking 1
	if {[eof $fd]} {
		set fail [catch {close $fd} err]
		$::main_status stop
		unlock_index
 
		$ui_comm delete 0.0 end
		$ui_comm edit modified false
 
		catch {file delete [gitdir MERGE_HEAD]}
		catch {file delete [gitdir rr-cache MERGE_RR]}
		catch {file delete [gitdir SQUASH_MSG]}
		catch {file delete [gitdir MERGE_MSG]}
		catch {file delete [gitdir GITGUI_MSG]}
 
		if {$fail} {
			warn_popup "Abort failed.\n\n$err"
		}
		rescan {ui_status {Abort completed.  Ready.}}
	} else {
		fconfigure $fd -blocking 0
	}
}
 
}