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