Code

git-gui: Show a progress meter for checking out files
[git.git] / lib / commit.tcl
1 # git-gui misc. commit reading/writing support
2 # Copyright (C) 2006, 2007 Shawn Pearce
4 proc load_last_commit {} {
5         global HEAD PARENT MERGE_HEAD commit_type ui_comm
6         global repo_config
8         if {[llength $PARENT] == 0} {
9                 error_popup {There is nothing to amend.
11 You are about to create the initial commit.  There is no commit before this to amend.
12 }
13                 return
14         }
16         repository_state curType curHEAD curMERGE_HEAD
17         if {$curType eq {merge}} {
18                 error_popup {Cannot amend while merging.
20 You are currently in the middle of a merge that has not been fully completed.  You cannot amend the prior commit unless you first abort the current merge activity.
21 }
22                 return
23         }
25         set msg {}
26         set parents [list]
27         if {[catch {
28                         set fd [open "| git cat-file commit $curHEAD" r]
29                         fconfigure $fd -encoding binary -translation lf
30                         if {[catch {set enc $repo_config(i18n.commitencoding)}]} {
31                                 set enc utf-8
32                         }
33                         while {[gets $fd line] > 0} {
34                                 if {[string match {parent *} $line]} {
35                                         lappend parents [string range $line 7 end]
36                                 } elseif {[string match {encoding *} $line]} {
37                                         set enc [string tolower [string range $line 9 end]]
38                                 }
39                         }
40                         set msg [encoding convertfrom $enc [read $fd]]
41                         set msg [string trim $msg]
42                         close $fd
43                 } err]} {
44                 error_popup "Error loading commit data for amend:\n\n$err"
45                 return
46         }
48         set HEAD $curHEAD
49         set PARENT $parents
50         set MERGE_HEAD [list]
51         switch -- [llength $parents] {
52         0       {set commit_type amend-initial}
53         1       {set commit_type amend}
54         default {set commit_type amend-merge}
55         }
57         $ui_comm delete 0.0 end
58         $ui_comm insert end $msg
59         $ui_comm edit reset
60         $ui_comm edit modified false
61         rescan ui_ready
62 }
64 set GIT_COMMITTER_IDENT {}
66 proc committer_ident {} {
67         global GIT_COMMITTER_IDENT
69         if {$GIT_COMMITTER_IDENT eq {}} {
70                 if {[catch {set me [git var GIT_COMMITTER_IDENT]} err]} {
71                         error_popup "Unable to obtain your identity:\n\n$err"
72                         return {}
73                 }
74                 if {![regexp {^(.*) [0-9]+ [-+0-9]+$} \
75                         $me me GIT_COMMITTER_IDENT]} {
76                         error_popup "Invalid GIT_COMMITTER_IDENT:\n\n$me"
77                         return {}
78                 }
79         }
81         return $GIT_COMMITTER_IDENT
82 }
84 proc do_signoff {} {
85         global ui_comm
87         set me [committer_ident]
88         if {$me eq {}} return
90         set sob "Signed-off-by: $me"
91         set last [$ui_comm get {end -1c linestart} {end -1c}]
92         if {$last ne $sob} {
93                 $ui_comm edit separator
94                 if {$last ne {}
95                         && ![regexp {^[A-Z][A-Za-z]*-[A-Za-z-]+: *} $last]} {
96                         $ui_comm insert end "\n"
97                 }
98                 $ui_comm insert end "\n$sob"
99                 $ui_comm edit separator
100                 $ui_comm see end
101         }
104 proc create_new_commit {} {
105         global commit_type ui_comm
107         set commit_type normal
108         $ui_comm delete 0.0 end
109         $ui_comm edit reset
110         $ui_comm edit modified false
111         rescan ui_ready
114 proc commit_tree {} {
115         global HEAD commit_type file_states ui_comm repo_config
116         global pch_error
118         if {[committer_ident] eq {}} return
119         if {![lock_index update]} return
121         # -- Our in memory state should match the repository.
122         #
123         repository_state curType curHEAD curMERGE_HEAD
124         if {[string match amend* $commit_type]
125                 && $curType eq {normal}
126                 && $curHEAD eq $HEAD} {
127         } elseif {$commit_type ne $curType || $HEAD ne $curHEAD} {
128                 info_popup {Last scanned state does not match repository state.
130 Another Git program has modified this repository since the last scan.  A rescan must be performed before another commit can be created.
132 The rescan will be automatically started now.
134                 unlock_index
135                 rescan ui_ready
136                 return
137         }
139         # -- At least one file should differ in the index.
140         #
141         set files_ready 0
142         foreach path [array names file_states] {
143                 switch -glob -- [lindex $file_states($path) 0] {
144                 _? {continue}
145                 A? -
146                 D? -
147                 M? {set files_ready 1}
148                 U? {
149                         error_popup "Unmerged files cannot be committed.
151 File [short_path $path] has merge conflicts.  You must resolve them and add the file before committing.
153                         unlock_index
154                         return
155                 }
156                 default {
157                         error_popup "Unknown file state [lindex $s 0] detected.
159 File [short_path $path] cannot be committed by this program.
161                 }
162                 }
163         }
164         if {!$files_ready && ![string match *merge $curType]} {
165                 info_popup {No changes to commit.
167 You must add at least 1 file before you can commit.
169                 unlock_index
170                 return
171         }
173         # -- A message is required.
174         #
175         set msg [string trim [$ui_comm get 1.0 end]]
176         regsub -all -line {[ \t\r]+$} $msg {} msg
177         if {$msg eq {}} {
178                 error_popup {Please supply a commit message.
180 A good commit message has the following format:
182 - First line: Describe in one sentance what you did.
183 - Second line: Blank
184 - Remaining lines: Describe why this change is good.
186                 unlock_index
187                 return
188         }
190         # -- Run the pre-commit hook.
191         #
192         set pchook [gitdir hooks pre-commit]
194         # On Cygwin [file executable] might lie so we need to ask
195         # the shell if the hook is executable.  Yes that's annoying.
196         #
197         if {[is_Cygwin] && [file isfile $pchook]} {
198                 set pchook [list sh -c [concat \
199                         "if test -x \"$pchook\";" \
200                         "then exec \"$pchook\" 2>&1;" \
201                         "fi"]]
202         } elseif {[file executable $pchook]} {
203                 set pchook [list $pchook |& cat]
204         } else {
205                 commit_writetree $curHEAD $msg
206                 return
207         }
209         ui_status {Calling pre-commit hook...}
210         set pch_error {}
211         set fd_ph [open "| $pchook" r]
212         fconfigure $fd_ph -blocking 0 -translation binary
213         fileevent $fd_ph readable \
214                 [list commit_prehook_wait $fd_ph $curHEAD $msg]
217 proc commit_prehook_wait {fd_ph curHEAD msg} {
218         global pch_error
220         append pch_error [read $fd_ph]
221         fconfigure $fd_ph -blocking 1
222         if {[eof $fd_ph]} {
223                 if {[catch {close $fd_ph}]} {
224                         ui_status {Commit declined by pre-commit hook.}
225                         hook_failed_popup pre-commit $pch_error
226                         unlock_index
227                 } else {
228                         commit_writetree $curHEAD $msg
229                 }
230                 set pch_error {}
231                 return
232         }
233         fconfigure $fd_ph -blocking 0
236 proc commit_writetree {curHEAD msg} {
237         ui_status {Committing changes...}
238         set fd_wt [open "| git write-tree" r]
239         fileevent $fd_wt readable \
240                 [list commit_committree $fd_wt $curHEAD $msg]
243 proc commit_committree {fd_wt curHEAD msg} {
244         global HEAD PARENT MERGE_HEAD commit_type
245         global current_branch
246         global ui_comm selected_commit_type
247         global file_states selected_paths rescan_active
248         global repo_config
250         gets $fd_wt tree_id
251         if {$tree_id eq {} || [catch {close $fd_wt} err]} {
252                 error_popup "write-tree failed:\n\n$err"
253                 ui_status {Commit failed.}
254                 unlock_index
255                 return
256         }
258         # -- Verify this wasn't an empty change.
259         #
260         if {$commit_type eq {normal}} {
261                 set old_tree [git rev-parse "$PARENT^{tree}"]
262                 if {$tree_id eq $old_tree} {
263                         info_popup {No changes to commit.
265 No files were modified by this commit and it was not a merge commit.
267 A rescan will be automatically started now.
269                         unlock_index
270                         rescan {ui_status {No changes to commit.}}
271                         return
272                 }
273         }
275         # -- Build the message.
276         #
277         set msg_p [gitdir COMMIT_EDITMSG]
278         set msg_wt [open $msg_p w]
279         if {[catch {set enc $repo_config(i18n.commitencoding)}]} {
280                 set enc utf-8
281         }
282         fconfigure $msg_wt -encoding binary -translation binary
283         puts -nonewline $msg_wt [encoding convertto $enc $msg]
284         close $msg_wt
286         # -- Create the commit.
287         #
288         set cmd [list commit-tree $tree_id]
289         foreach p [concat $PARENT $MERGE_HEAD] {
290                 lappend cmd -p $p
291         }
292         lappend cmd <$msg_p
293         if {[catch {set cmt_id [eval git $cmd]} err]} {
294                 error_popup "commit-tree failed:\n\n$err"
295                 ui_status {Commit failed.}
296                 unlock_index
297                 return
298         }
300         # -- Update the HEAD ref.
301         #
302         set reflogm commit
303         if {$commit_type ne {normal}} {
304                 append reflogm " ($commit_type)"
305         }
306         set i [string first "\n" $msg]
307         if {$i >= 0} {
308                 set subject [string range $msg 0 [expr {$i - 1}]]
309         } else {
310                 set subject $msg
311         }
312         append reflogm {: } $subject
313         if {[catch {
314                         git update-ref -m $reflogm HEAD $cmt_id $curHEAD
315                 } err]} {
316                 error_popup "update-ref failed:\n\n$err"
317                 ui_status {Commit failed.}
318                 unlock_index
319                 return
320         }
322         # -- Cleanup after ourselves.
323         #
324         catch {file delete $msg_p}
325         catch {file delete [gitdir MERGE_HEAD]}
326         catch {file delete [gitdir MERGE_MSG]}
327         catch {file delete [gitdir SQUASH_MSG]}
328         catch {file delete [gitdir GITGUI_MSG]}
330         # -- Let rerere do its thing.
331         #
332         if {[get_config rerere.enabled] eq {}} {
333                 set rerere [file isdirectory [gitdir rr-cache]]
334         } else {
335                 set rerere [is_config_true rerere.enabled]
336         }
337         if {$rerere} {
338                 catch {git rerere}
339         }
341         # -- Run the post-commit hook.
342         #
343         set pchook [gitdir hooks post-commit]
344         if {[is_Cygwin] && [file isfile $pchook]} {
345                 set pchook [list sh -c [concat \
346                         "if test -x \"$pchook\";" \
347                         "then exec \"$pchook\";" \
348                         "fi"]]
349         } elseif {![file executable $pchook]} {
350                 set pchook {}
351         }
352         if {$pchook ne {}} {
353                 catch {exec $pchook &}
354         }
356         $ui_comm delete 0.0 end
357         $ui_comm edit reset
358         $ui_comm edit modified false
360         if {[is_enabled singlecommit]} do_quit
362         # -- Update in memory status
363         #
364         set selected_commit_type new
365         set commit_type normal
366         set HEAD $cmt_id
367         set PARENT $cmt_id
368         set MERGE_HEAD [list]
370         foreach path [array names file_states] {
371                 set s $file_states($path)
372                 set m [lindex $s 0]
373                 switch -glob -- $m {
374                 _O -
375                 _M -
376                 _D {continue}
377                 __ -
378                 A_ -
379                 M_ -
380                 D_ {
381                         unset file_states($path)
382                         catch {unset selected_paths($path)}
383                 }
384                 DO {
385                         set file_states($path) [list _O [lindex $s 1] {} {}]
386                 }
387                 AM -
388                 AD -
389                 MM -
390                 MD {
391                         set file_states($path) [list \
392                                 _[string index $m 1] \
393                                 [lindex $s 1] \
394                                 [lindex $s 3] \
395                                 {}]
396                 }
397                 }
398         }
400         display_all_files
401         unlock_index
402         reshow_diff
403         ui_status "Created commit [string range $cmt_id 0 7]: $subject"