Merge branch 'jc/safe-c-l-d'
[git] / git-gui / lib / mergetool.tcl
1 # git-gui merge conflict resolution
2 # parts based on git-mergetool (c) 2006 Theodore Y. Ts'o
3
4 proc merge_resolve_one {stage} {
5         global current_diff_path
6
7         switch -- $stage {
8                 1 { set targetquestion [mc "Force resolution to the base version?"] }
9                 2 { set targetquestion [mc "Force resolution to this branch?"] }
10                 3 { set targetquestion [mc "Force resolution to the other branch?"] }
11         }
12
13         set op_question [strcat $targetquestion "\n" \
14 [mc "Note that the diff shows only conflicting changes.
15
16 %s will be overwritten.
17
18 This operation can be undone only by restarting the merge." \
19                 [short_path $current_diff_path]]]
20
21         if {[ask_popup $op_question] eq {yes}} {
22                 merge_load_stages $current_diff_path [list merge_force_stage $stage]
23         }
24 }
25
26 proc merge_stage_workdir {path w lno} {
27         global current_diff_path diff_active
28
29         if {$diff_active} return
30
31         if {$path ne $current_diff_path} {
32                 show_diff $path $w $lno {} [list do_merge_stage_workdir $path]
33         } else {
34                 do_merge_stage_workdir $path
35         }
36 }
37
38 proc do_merge_stage_workdir {path} {
39         global current_diff_path is_conflict_diff
40
41         if {$path ne $current_diff_path} return;
42
43         if {$is_conflict_diff} {
44                 if {[ask_popup [mc "File %s seems to have unresolved conflicts, still stage?" \
45                                 [short_path $path]]] ne {yes}} {
46                         return
47                 }
48         }
49
50         merge_add_resolution $path
51 }
52
53 proc merge_add_resolution {path} {
54         global current_diff_path ui_workdir
55
56         set after [next_diff_after_action $ui_workdir $path {} {^_?U}]
57
58         update_index \
59                 [mc "Adding resolution for %s" [short_path $path]] \
60                 [list $path] \
61                 [concat $after [list ui_ready]]
62 }
63
64 proc merge_force_stage {stage} {
65         global current_diff_path merge_stages
66
67         if {$merge_stages($stage) ne {}} {
68                 git checkout-index -f --stage=$stage -- $current_diff_path
69         } else {
70                 file delete -- $current_diff_path
71         }
72
73         merge_add_resolution $current_diff_path
74 }
75
76 proc merge_load_stages {path cont} {
77         global merge_stages_fd merge_stages merge_stages_buf
78
79         if {[info exists merge_stages_fd]} {
80                 catch { kill_file_process $merge_stages_fd }
81                 catch { close $merge_stages_fd }
82         }
83
84         set merge_stages(0) {}
85         set merge_stages(1) {}
86         set merge_stages(2) {}
87         set merge_stages(3) {}
88         set merge_stages_buf {}
89
90         set merge_stages_fd [eval git_read ls-files -u -z -- $path]
91
92         fconfigure $merge_stages_fd -blocking 0 -translation binary -encoding binary
93         fileevent $merge_stages_fd readable [list read_merge_stages $merge_stages_fd $cont]
94 }
95
96 proc read_merge_stages {fd cont} {
97         global merge_stages_buf merge_stages_fd merge_stages
98
99         append merge_stages_buf [read $fd]
100         set pck [split $merge_stages_buf "\0"]
101         set merge_stages_buf [lindex $pck end]
102
103         if {[eof $fd] && $merge_stages_buf ne {}} {
104                 lappend pck {}
105                 set merge_stages_buf {}
106         }
107
108         foreach p [lrange $pck 0 end-1] {
109                 set fcols [split $p "\t"]
110                 set cols  [split [lindex $fcols 0] " "]
111                 set stage [lindex $cols 2]
112                 
113                 set merge_stages($stage) [lrange $cols 0 1]
114         }
115
116         if {[eof $fd]} {
117                 close $fd
118                 unset merge_stages_fd
119                 eval $cont
120         }
121 }
122
123 proc merge_resolve_tool {} {
124         global current_diff_path
125
126         merge_load_stages $current_diff_path [list merge_resolve_tool2]
127 }
128
129 proc merge_resolve_tool2 {} {
130         global current_diff_path merge_stages
131
132         # Validate the stages
133         if {$merge_stages(2) eq {} ||
134             [lindex $merge_stages(2) 0] eq {120000} ||
135             [lindex $merge_stages(2) 0] eq {160000} ||
136             $merge_stages(3) eq {} ||
137             [lindex $merge_stages(3) 0] eq {120000} ||
138             [lindex $merge_stages(3) 0] eq {160000}
139         } {
140                 error_popup [mc "Cannot resolve deletion or link conflicts using a tool"]
141                 return
142         }
143
144         if {![file exists $current_diff_path]} {
145                 error_popup [mc "Conflict file does not exist"]
146                 return
147         }
148
149         # Determine the tool to use
150         set tool [get_config merge.tool]
151         if {$tool eq {}} { set tool meld }
152
153         set merge_tool_path [get_config "mergetool.$tool.path"]
154         if {$merge_tool_path eq {}} {
155                 switch -- $tool {
156                 emerge { set merge_tool_path "emacs" }
157                 araxis { set merge_tool_path "compare" }
158                 default { set merge_tool_path $tool }
159                 }
160         }
161
162         # Make file names
163         set filebase [file rootname $current_diff_path]
164         set fileext  [file extension $current_diff_path]
165         set basename [lindex [file split $current_diff_path] end]
166
167         set MERGED   $current_diff_path
168         set BASE     "./$MERGED.BASE$fileext"
169         set LOCAL    "./$MERGED.LOCAL$fileext"
170         set REMOTE   "./$MERGED.REMOTE$fileext"
171         set BACKUP   "./$MERGED.BACKUP$fileext"
172
173         set base_stage $merge_stages(1)
174
175         # Build the command line
176         switch -- $tool {
177         kdiff3 {
178                 if {$base_stage ne {}} {
179                         set cmdline [list "$merge_tool_path" --auto --L1 "$MERGED (Base)" \
180                                 --L2 "$MERGED (Local)" --L3 "$MERGED (Remote)" -o "$MERGED" "$BASE" "$LOCAL" "$REMOTE"]
181                 } else {
182                         set cmdline [list "$merge_tool_path" --auto --L1 "$MERGED (Local)" \
183                                 --L2 "$MERGED (Remote)" -o "$MERGED" "$LOCAL" "$REMOTE"]
184                 }
185         }
186         tkdiff {
187                 if {$base_stage ne {}} {
188                         set cmdline [list "$merge_tool_path" -a "$BASE" -o "$MERGED" "$LOCAL" "$REMOTE"]
189                 } else {
190                         set cmdline [list "$merge_tool_path" -o "$MERGED" "$LOCAL" "$REMOTE"]
191                 }
192         }
193         meld {
194                 set cmdline [list "$merge_tool_path" "$LOCAL" "$MERGED" "$REMOTE"]
195         }
196         gvimdiff {
197                 set cmdline [list "$merge_tool_path" -f "$LOCAL" "$MERGED" "$REMOTE"]
198         }
199         xxdiff {
200                 if {$base_stage ne {}} {
201                         set cmdline [list "$merge_tool_path" -X --show-merged-pane \
202                                             -R {Accel.SaveAsMerged: "Ctrl-S"} \
203                                             -R {Accel.Search: "Ctrl+F"} \
204                                             -R {Accel.SearchForward: "Ctrl-G"} \
205                                             --merged-file "$MERGED" "$LOCAL" "$BASE" "$REMOTE"]
206                 } else {
207                         set cmdline [list "$merge_tool_path" -X --show-merged-pane \
208                                             -R {Accel.SaveAsMerged: "Ctrl-S"} \
209                                             -R {Accel.Search: "Ctrl+F"} \
210                                             -R {Accel.SearchForward: "Ctrl-G"} \
211                                             --merged-file "$MERGED" "$LOCAL" "$REMOTE"]
212                 }
213         }
214         opendiff {
215                 if {$base_stage ne {}} {
216                         set cmdline [list "$merge_tool_path" "$LOCAL" "$REMOTE" -ancestor "$BASE" -merge "$MERGED"]
217                 } else {
218                         set cmdline [list "$merge_tool_path" "$LOCAL" "$REMOTE" -merge "$MERGED"]
219                 }
220         }
221         ecmerge {
222                 if {$base_stage ne {}} {
223                         set cmdline [list "$merge_tool_path" "$BASE" "$LOCAL" "$REMOTE" --default --mode=merge3 --to="$MERGED"]
224                 } else {
225                         set cmdline [list "$merge_tool_path" "$LOCAL" "$REMOTE" --default --mode=merge2 --to="$MERGED"]
226                 }
227         }
228         emerge {
229                 if {$base_stage ne {}} {
230                         set cmdline [list "$merge_tool_path" -f emerge-files-with-ancestor-command \
231                                         "$LOCAL" "$REMOTE" "$BASE" "$basename"]
232                 } else {
233                         set cmdline [list "$merge_tool_path" -f emerge-files-command \
234                                         "$LOCAL" "$REMOTE" "$basename"]
235                 }
236         }
237         winmerge {
238                 if {$base_stage ne {}} {
239                         # This tool does not support 3-way merges.
240                         # Use the 'conflict file' resolution feature instead.
241                         set cmdline [list "$merge_tool_path" -e -ub "$MERGED"]
242                 } else {
243                         set cmdline [list "$merge_tool_path" -e -ub -wl \
244                                 -dl "Theirs File" -dr "Mine File" "$REMOTE" "$LOCAL" "$MERGED"]
245                 }
246         }
247         araxis {
248                 if {$base_stage ne {}} {
249                         set cmdline [list "$merge_tool_path" -wait -merge -3 -a1 \
250                                 -title1:"'$MERGED (Base)'" -title2:"'$MERGED (Local)'" \
251                                 -title3:"'$MERGED (Remote)'" \
252                                 "$BASE" "$LOCAL" "$REMOTE" "$MERGED"]
253                 } else {
254                         set cmdline [list "$merge_tool_path" -wait -2 \
255                                  -title1:"'$MERGED (Local)'" -title2:"'$MERGED (Remote)'" \
256                                  "$LOCAL" "$REMOTE" "$MERGED"]
257                 }
258         }
259         p4merge {
260                 set cmdline [list "$merge_tool_path" "$BASE" "$REMOTE" "$LOCAL" "$MERGED"]
261         }
262         vimdiff {
263                 error_popup [mc "Not a GUI merge tool: '%s'" $tool]
264                 return
265         }
266         default {
267                 error_popup [mc "Unsupported merge tool '%s'" $tool]
268                 return
269         }
270         }
271
272         merge_tool_start $cmdline $MERGED $BACKUP [list $BASE $LOCAL $REMOTE]
273 }
274
275 proc delete_temp_files {files} {
276         foreach fname $files {
277                 file delete $fname
278         }
279 }
280
281 proc merge_tool_get_stages {target stages} {
282         global merge_stages
283
284         set i 1
285         foreach fname $stages {
286                 if {$merge_stages($i) eq {}} {
287                         file delete $fname
288                         catch { close [open $fname w] }
289                 } else {
290                         # A hack to support autocrlf properly
291                         git checkout-index -f --stage=$i -- $target
292                         file rename -force -- $target $fname
293                 }
294                 incr i
295         }
296 }
297
298 proc merge_tool_start {cmdline target backup stages} {
299         global merge_stages mtool_target mtool_tmpfiles mtool_fd mtool_mtime
300
301         if {[info exists mtool_fd]} {
302                 if {[ask_popup [mc "Merge tool is already running, terminate it?"]] eq {yes}} {
303                         catch { kill_file_process $mtool_fd }
304                         catch { close $mtool_fd }
305                         unset mtool_fd
306
307                         set old_backup [lindex $mtool_tmpfiles end]
308                         file rename -force -- $old_backup $mtool_target
309                         delete_temp_files $mtool_tmpfiles
310                 } else {
311                         return
312                 }
313         }
314
315         # Save the original file
316         file rename -force -- $target $backup
317
318         # Get the blobs; it destroys $target
319         if {[catch {merge_tool_get_stages $target $stages} err]} {
320                 file rename -force -- $backup $target
321                 delete_temp_files $stages
322                 error_popup [mc "Error retrieving versions:\n%s" $err]
323                 return
324         }
325
326         # Restore the conflict file
327         file copy -force -- $backup $target
328
329         # Initialize global state
330         set mtool_target $target
331         set mtool_mtime [file mtime $target]
332         set mtool_tmpfiles $stages
333
334         lappend mtool_tmpfiles $backup
335
336         # Force redirection to avoid interpreting output on stderr
337         # as an error, and launch the tool
338         lappend cmdline {2>@1}
339
340         if {[catch { set mtool_fd [_open_stdout_stderr $cmdline] } err]} {
341                 delete_temp_files $mtool_tmpfiles
342                 error_popup [mc "Could not start the merge tool:\n\n%s" $err]
343                 return
344         }
345
346         ui_status [mc "Running merge tool..."]
347
348         fconfigure $mtool_fd -blocking 0 -translation binary -encoding binary
349         fileevent $mtool_fd readable [list read_mtool_output $mtool_fd]
350 }
351
352 proc read_mtool_output {fd} {
353         global mtool_fd mtool_tmpfiles
354
355         read $fd
356         if {[eof $fd]} {
357                 unset mtool_fd
358
359                 fconfigure $fd -blocking 1
360                 merge_tool_finish $fd
361         }
362 }
363
364 proc merge_tool_finish {fd} {
365         global mtool_tmpfiles mtool_target mtool_mtime
366
367         set backup [lindex $mtool_tmpfiles end]
368         set failed 0
369
370         # Check the return code
371         if {[catch {close $fd} err]} {
372                 set failed 1
373                 if {$err ne {child process exited abnormally}} {
374                         error_popup [strcat [mc "Merge tool failed."] "\n\n$err"]
375                 }
376         }
377
378         # Check the modification time of the target file
379         if {!$failed && [file mtime $mtool_target] eq $mtool_mtime} {
380                 if {[ask_popup [mc "File %s unchanged, still accept as resolved?" \
381                                 [short_path $mtool_target]]] ne {yes}} {
382                         set failed 1
383                 }
384         }
385
386         # Finish
387         if {$failed} {
388                 file rename -force -- $backup $mtool_target
389                 delete_temp_files $mtool_tmpfiles
390                 ui_status [mc "Merge tool failed."]
391         } else {
392                 if {[is_config_true merge.keepbackup]} {
393                         file rename -force -- $backup "$mtool_target.orig"
394                 }
395
396                 delete_temp_files $mtool_tmpfiles
397
398                 merge_add_resolution $mtool_target
399         }
400 }