

Improve your Git commits using patch mode - codenapper
http://neowork.com/2012/11/11/improve-your-git-commits-using-patch-mode

======
masklinn
Still unsolved: ensure your commits are not broken (aka pass all tests)
without stashing everything else (in which case you could just as well stash
the stuff you _don't_ want in patch mode using `git stash -p`).

(even if they are in a feature branch, broken commits will break `git bisect`
unless the branch is folded when merged)

~~~
maaku
Not necessarily. Use patch mode (or a tool like GitX that does the same job),
commit, then stash and run your tests. If it's broken, amend your commit,
rinse and repeat. Then push your changes or pop the stash and continue
development.

~~~
masklinn
I'm pretty sure I specified

> without stashing everything else

and noted that if you're going to stash the rest either way you could just as
well use `stash -p` in the first place.

~~~
emillon
I am not sure why you insist on not stashing the rest of your working
directory ? This is a nice and non-permanent solution.

There's a difference between `stash -p` and `add -p + stash`, though. If you
want to split your changes into more than two commits, you have to use
add/commit/add/commit because stash will just make a commit with "what's left"
(it's subtractive operation).

~~~
masklinn
Because it's an annoying extraneous command _and I already know about this
work-around si I don't need to learn about it_.

------
languagehacker
I'd suggest adding hunks instead of committing them so you can review your
staging area at the end. It's the same flag; just use 'git add -p' instead of
'git commit -p'.

~~~
ujeezy
And if you'd like to diff what's in the staging area, you can use this
command: git diff --cached

------
jakub_g
FYI, in case you added reaaally a lot of stuff, and want to split it into
smaller commits, it might be much more handy to do partial commits using Git
GUI (select lines in the file & right click to have a popup menu with
appropriate option). Also, don't do it the next time.

Side hint: for things like fixing typos, I found that creating a new branch,
say 'typos', is quite handy solution to not do these kind of things in the
commits that are meant to add new things / fix bugs. Just checkout typos, fix,
commit, checkout master / feature branch.

~~~
burntsushi
> Side hint: for things like fixing typos, I found that creating a new branch,
> say 'typos', is quite handy solution to not do these kind of things in the
> commits that are meant to add new things / fix bugs. Just checkout typos,
> fix, commit, checkout master / feature branch.

Could you maybe elaborate on this a little bit more? I don't think I quite
understand this.

My understanding is that you'd have to do a 'git merge master' after you
checkout 'typos', make the fix, commit, and then a 'git merge typos' after you
checkout 'master'. Then wouldn't this add all of the typos commits into the
master branch anyway?

I'm very likely missing something fundamental. (Perhaps my source control
habits aren't up to snuff.)

~~~
jakub_g
Yep I wrote this with too much shortcuts. What I do is: git checkout typos,
git rebase master, [fix typo & commit], git checkout master. This way I
accumulate typo fixes in a separate branch, and merge a couple of them at once
to master when I see fit (perhaps squashing the typo commits into one
beforehand).

------
npsimons
Ah, another "git -p" article. Funny thing is, I didn't even know about the
"-p" option until I looked it up, even though I was using it all the time
indirectly through Egg (Emacs Got Git). The sad part is, though, separating
changes doesn't completely solve the problem (I often get lines overlapping
between bug fixes, cleanups and new features). More than anything, discipline
comes into it, but at least git makes it easier (especially with the fast
branching). Another interesting take on Git's patch mode:
<http://tomayko.com/writings/the-thing-about-git>

------
bluesmoon
Also use -v when committing to see the diff while writing your commit message

------
dpatrick86
\--word-diff is fun too

