Actually, to make this easier Git keeps a reference named `ORIG_HEAD` that points where you were before the rebase.  So, it&#39;s as easy as:

    git reset --hard ORIG_HEAD


using `git reflog` you will see a list of commits HEAD pointed to in the past

using

    git checkout -b after-commit HEAD@{1} # or the commit you want to recover

you create a new branch at that precise position and check it out

You should checkout the command

    git reset --merge

That eliminates the need for a git commit; git stash before a pull (Don&#39;t know about rebase though) 

The command returns a workspace with uncommitted changes to the state before a conflicting pull.


Use `git log -g` and find the commit index you want to go back to, the just do `git checkout`  index

I personally like the [`&lt;fieldset&gt;`][1] tag because of how it draws a box and puts the [`&lt;legend&gt;`][2] at the top of it, over the border. Like this.

![example image of what I&#39;m trying to achieve][3]

However, the `fieldset` element was made to organize [forms][4], and using it for general design is no better than using tables for general design. So, my question is... __how can I achieve the same result using another tag?__ The border has to be erased under the `&lt;legend&gt;` (or whatever other tag will be used), and since there could be a &quot;complex&quot; body background image, I can&#39;t afford to just set the `background-color` of the legend to match the one of the element under.

I&#39;d like it to work without JavaScript, but CSS3 and XML-based formats (such as SVG or XHTML) are fine.


  [1]: http://www.w3.org/wiki/HTML/Elements/fieldset
  [2]: http://www.w3.org/wiki/HTML/Elements/legend
  [3]: http://i.stack.imgur.com/VJ2lh.png
  [4]: http://www.w3.org/wiki/HTML/Elements/form

Is it possible to achieve a &lt;fieldset&gt;-like effect without using the &lt;fieldset&gt; tag?

MSDN Code Sample Description: The following code example uses the IsAuthenticated property to determine whether the current request has been authenticated. If it has not been authenticated, the request is redirected to another page where users can enter their credentials into the Web application. This is a common technique used in the default page for an application.

This is great but no detail or anything...

What exactly is it checking for? How do I set it to true?

Go the extra mile: Where would I find more detailed documentation about this?

How does Request.IsAuthenticated work?

Hey I&#39;m new to git and I need to undo a pull, can anyone help?!? So what I&#39;ve done is...

 1. git commit
 2. git stash
 3. git pull --rebase
 4. git stash pop

this created a bunch of conflicts and went a bit wrong. Now doing &#39;git stash list&#39; reveals that my stash is still there. Is it possible to revert my repo back to the point just after doing git commit. So effectively my repo only contains only changes I have made and nothing new from the server?

Undoing a git pull --rebase

<p>Hey I'm new to git and I need to undo a pull, can anyone help?!? So what I've done is...</p>
<ol>
<li>git commit</li>
<li>git stash</li>
<li>git pull --rebase</li>
<li>git stash pop</li>
</ol>
<p>this created a bunch of conflicts and went a bit wrong. Now doing 'git stash list' reveals that my stash is still there. Is it possible to revert my repo back to the point just after doing git commit. So effectively my repo only contains only changes I have made and nothing new from the server?</p>


I would like to create a patch for the last 2 revisions.

    git format-patch -2

gives me 2 patch files, one for each revision

    git format-patch HEAD~2..HEAD

gives the same thing.

    git format-patch -1 HEAD~2..HEAD

gives a single file, but only contains changes for the last revision.

Is there any way to do this in git?

In git, how do I create a single patch for the last 2+ revisions?

I have several .screen files inside `/xxx/documentation` and its subdirectories that are already tracked by Git.

After modifying many of these screen files, I run `git add documentation/\\*.screen`—as indicated by the first example in `git-add`&#39;s documentation—to stage these files, but the command fails:

&lt;pre&gt;fatal: pathspec &#39;documentation/\*.screen&#39; did not match any files&lt;/pre&gt;

Is my command bad, or does git have a bug?

git: How do I recursively add all files in a directory subtree that match a glob pattern?

When I specify an ancestor commit object in Git, I&#39;m confused between `HEAD^` and `HEAD~`.

Both have a &quot;numbered&quot; version like `HEAD^3` and `HEAD~2`.

They seem very similar or the same to me, but are there any differences between the tilde and the caret?

What&#39;s the difference between HEAD^ and HEAD~ in Git?

**EDIT** This question can be understood in two ways, and the optimal answer is different in the two cases.

*   Question 1: I added a **previously untracked file** to the staging area. How can I remove this file from the staging area without removing it from the file system?

    Answer 1: Use the following command, as described in [John Feminella&#39;s answer](https://stackoverflow.com/a/2223340/17916):

    ```
    git rm --cached &lt;file&gt;
    ```

*   Question 2: I modified a **file already tracked**, and added my modifications to the staging area. How can I remove my modifications from the staging area? I.e., how can I unstage my modifications in the file?

    Answer 2: Use the following command, as described in [David Underhill&#39;s answer](https://stackoverflow.com/a/2223321/17916):

    ```
    git reset &lt;file&gt;
    ```


How to remove a file from the staging area (= index = cache) in Git?

I&#39;ve generated key pairs using PuTTYgen and been logging in using Pageant, so that I have to enter my pass-phrase only once when my system boots. 

How do I achieve this in Linux? I&#39;ve heard of `keychain` but I hear that it uses a different key pair format - I don&#39;t want to change my Windows keys and it would be nice if I could seamlessly connect in the same manner in both Windows and Linux.

How to convert SSH keypairs generated using PuTTYgen (Windows) into key-pairs used by ssh-agent and Keychain (Linux)

I&#39;m new to git and I&#39;m trying to understand the difference between a squash and a rebase.  As I understand it you perform a squash when doing a rebase.

What is the difference between merge --squash and rebase?

Crap! About a week ago, I was rebasing some commits while trying to clean up my repository, and apparently I didn&#39;t actually finish it. Today, a week and several commits later, I went to rebase to reorder a few commits from today, and it told me I was already in the middle of a rebase.

That should have been a cue to copy my repo just in case. But I did not...instead I ran `git rebase --abort` which sounded right at the time. Well, that was not right. It aborted the rebase from a week ago and reset master&#39;s HEAD to the old one. Dummy!

I&#39;ve got several other branches that are fairly recent, and I&#39;ve pushed to remote several times, but the most recent changes appear to be gone forever. I don&#39;t possess the appropriate level of git-fu to know if there&#39;s any way to recover my changes.

Am I screwed?

**EDIT** - WOW! Thanks guys! `git reflog` is awesome! I&#39;m fully recovered...lesson learned. Marking Tchalvak&#39;s answer accepted for being the first to post.


Aborted old git rebase and lost commits since the rebase started

`git-rebase` man page mentions `-X&lt;option&gt;` can be passed to `git-merge`. When/how exactly?

I&#39;d like to rebase by applying patches with *recursive* strategy and *theirs* option (apply whatever sticks, rather than skipping entire conflicting commits). I don&#39;t want merge, I want to make history linear.

I&#39;ve tried:

&lt;!-- language: sh --&gt;

    git rebase -Xtheirs

and

&lt;!-- language: sh --&gt;

    git rebase -s &#39;recursive -Xtheirs&#39;

but git rejects `-X` in both cases.

----

`git rebase -Xtheirs` works in recent versions, except tree conflicts need to be resolved manually. You need to run `git rebase -Xtheirs --continue` (with `-X` repeated) after resolving those conflicts.

How do I select a merge strategy for a git rebase?

Would it make sense to perform `git rebase` while preserving the commit timestamps?

I believe a consequence would be that the new branch will not necessarily have commit dates chronologically. Is that *theoretically* possible at all? (e.g. using plumbing commands; just curious here)

If it is theoretically possible, then is it possible in practice with rebase, not to change the timestamps?

For example, assume I have the following tree:

    master &lt;jun 2010&gt;
      |
      :
      :
      :     oldbranch &lt;feb 1984&gt;
      :     /
    oldcommit &lt;jan 1984&gt;

Now, if I rebase `oldbranch` on `master`, the date of the commit changes from feb 1984 to jun 2010. Is it possible to change that behaviour so that the commit timestamp is not changed? In the end I would thus obtain:

          oldbranch &lt;feb 1984&gt;
          /
     master &lt;jun 2010&gt;
        |
        :

Would that make sense at all? Is it even allowed in git to have a history where an old commit has a more recent commit as a parent?

git rebase without changing commit timestamps

We have a Git repository with over 400 commits, the first couple dozen of which were a lot of trial-and-error. We want to clean up these commits by squashing many down into a single commit. Naturally, git-rebase seems the way to go. My problem is that it ends up with merge conflicts, and these conflicts are not easy to resolve. I don&#39;t understand why there should be any conflicts at all, since I&#39;m just squashing commits (not deleting or rearranging). Very likely, this demonstrates that I&#39;m not completely understanding how git-rebase does its squashes.

Here&#39;s a modified version of the scripts I&#39;m using:

-----
repo_squash.sh (this is the script that is actually run):

-----

    rm -rf repo_squash
    git clone repo repo_squash
    cd repo_squash/
    GIT_EDITOR=../repo_squash_helper.sh git rebase --strategy theirs -i bd6a09a484b8230d0810e6689cf08a24f26f287a

-----
repo_squash_helper.sh (this script is used only by repo_squash.sh):

-----

    if grep -q &quot;pick &quot; $1
    then
    #  cp $1 ../repo_squash_history.txt
    #  emacs -nw $1
      sed -f ../repo_squash_list.txt &lt; $1 &gt; $1.tmp
      mv $1.tmp $1
    else
      if grep -q &quot;initial import&quot; $1
      then
        cp ../repo_squash_new_message1.txt $1
      elif grep -q &quot;fixing bad import&quot; $1
      then
        cp ../repo_squash_new_message2.txt $1
      else
        emacs -nw $1
      fi
    fi

-----
repo_squash_list.txt: (this file is used only by repo_squash_helper.sh)

-----

    # Initial import
    s/pick $251a190$/squash \1/g
    # Leaving &quot;Needed subdir&quot; for now
    # Fixing bad import
    s/pick $46c41d1$/squash \1/g
    s/pick $5d7agf2$/squash \1/g
    s/pick $3da63ed$/squash \1/g

-----

I&#39;ll leave the &quot;new message&quot; contents to your imagination. Initially, I did this without the &quot;--strategy theirs&quot; option (i.e., using the default strategy, which if I understand the documentation correctly is recursive, but I&#39;m not sure which recursive strategy is used), and it also didn&#39;t work. Also, I should point out that, using the commented out code in repo_squash_helper.sh, I saved off the original file that the sed script works on and ran the sed script against it to make sure it was doing what I wanted it to do (it was). Again, I don&#39;t even know why there *would* be a conflict, so it wouldn&#39;t seem to matter so much which strategy is used. Any advice or insight would be helpful, but mostly I just want to get this squashing working.

Updated with extra information from discussion with Jefromi:
---

Before working on our massive &quot;real&quot; repository, I used similar scripts on a test repository. It was a very simple repository and the test worked cleanly.

The message I get when it fails is:

    Finished one cherry-pick.
    # Not currently on any branch.
    nothing to commit (working directory clean)
    Could not apply 66c45e2... Needed subdir

This is the first pick after the first squash commit. Running `git status` yields a clean working directory. If I then do a `git rebase --continue`, I get a very similar message after a few more commits. If I then do it again, I get another very similar message after a couple dozen commits. If I do it yet again, this time it goes through about a hundred commits, and yields this message:

    Automatic cherry-pick failed.  After resolving the conflicts,
    mark the corrected paths with &#39;git add &lt;paths&gt;&#39;, and
    run &#39;git rebase --continue&#39;
    Could not apply f1de3bc... Incremental

If I then run `git status`, I get:

    # Not currently on any branch.
    # Changes to be committed:
    #   (use &quot;git reset HEAD &lt;file&gt;...&quot; to unstage)
    #
    # modified:   repo/file_A.cpp
    # modified:   repo/file_B.cpp
    #
    # Unmerged paths:
    #   (use &quot;git reset HEAD &lt;file&gt;...&quot; to unstage)
    #   (use &quot;git add/rm &lt;file&gt;...&quot; as appropriate to mark resolution)
    #
    # both modified:      repo/file_X.cpp
    #
    # Changed but not updated:
    #   (use &quot;git add/rm &lt;file&gt;...&quot; to update what will be committed)
    #   (use &quot;git checkout -- &lt;file&gt;...&quot; to discard changes in working directory)
    #
    # deleted:    repo/file_Z.imp

The &quot;both modified&quot; bit sounds weird to me, since this was just the result of a pick. It&#39;s also worth noting that if I look at the &quot;conflict&quot;, it boils down to a single line with one version beginning it with a [tab] character, and the other one with four spaces. This sounded like it might be an issue with how I&#39;ve set up my config file, but there&#39;s nothing of the sort in it. (I did note that core.ignorecase is set to true, but evidently git-clone did that automatically. I&#39;m not completely surprised by that considering that the original source was on a Windows machine.)

If I manually fix file_X.cpp, it then fails shortly afterward with another conflict, this time between a file (CMakeLists.txt) that one version thinks should exist and one version thinks shouldn&#39;t. If I fix this conflict by saying I do want this file (which I do), a few commits later I get another conflict (in this same file) where now there&#39;s some rather non-trivial changes. It&#39;s still only about 25% of the way through the conflicts.

I should also point out, since this might be very important, that this project started out in an svn repository. That initial history very likely was imported from that svn repository.

Update #2:
----

On a lark (influenced by Jefromi&#39;s comments), I decided to do the change my repo_squash.sh to be:

    rm -rf repo_squash
    git clone repo repo_squash
    cd repo_squash/
    git rebase --strategy theirs -i bd6a09a484b8230d0810e6689cf08a24f26f287a

And then, I just accepted the original entries, as is. I.e., the &quot;rebase&quot; shouldn&#39;t have changed a thing. It ended up with the same results describe previously.

Update #3:
---

Alternatively, if I omit the strategy and replace the last command with:

    git rebase -i bd6a09a484b8230d0810e6689cf08a24f26f287a

I no longer get the &quot;nothing to commit&quot; rebase problems, but I&#39;m still left with the other conflicts.

Update with toy repository that recreates problem:
---

test_squash.sh (this is the file you actually run):

    #========================================================
    # Initialize directories
    #========================================================
    rm -rf test_squash/ test_squash_clone/
    mkdir -p test_squash
    mkdir -p test_squash_clone
    #========================================================
    
    #========================================================
    # Create repository with history
    #========================================================
    cd test_squash/
    git init
    echo &quot;README&quot;&gt;README
    git add README
    git commit -m&quot;Initial commit: can&#39;t easily access for rebasing&quot;
    echo &quot;Line 1&quot;&gt;test_file.txt
    git add test_file.txt
    git commit -m&quot;Created single line file&quot;
    echo &quot;Line 2&quot;&gt;&gt;test_file.txt 
    git add test_file.txt 
    git commit -m&quot;Meant for it to be two lines&quot;
    git checkout -b dev
    echo Meaningful code&gt;new_file.txt
    git add new_file.txt 
    git commit -m&quot;Meaningful commit&quot;
    git checkout master
    echo Conflicting meaningful code&gt;new_file.txt
    git add new_file.txt 
    git commit -m&quot;Conflicting meaningful commit&quot;
    # This will conflict
    git merge dev
    # Fixes conflict
    echo Merged meaningful code&gt;new_file.txt
    git add new_file.txt
    git commit -m&quot;Merged dev with master&quot;
    cd ..
    
    #========================================================
    # Save off a clone of the repository prior to squashing
    #========================================================
    git clone test_squash test_squash_clone
    #========================================================
    
    #========================================================
    # Do the squash
    #========================================================
    cd test_squash
    GIT_EDITOR=../test_squash_helper.sh git rebase -i HEAD@{7}
    #========================================================
    
    #========================================================
    # Show the results
    #========================================================
    git log
    git gc
    git reflog
    #========================================================

test_squash_helper.sh (used by test_sqash.sh):

    # If the file has the phrase &quot;pick &quot; in it, assume it&#39;s the log file
    if grep -q &quot;pick &quot; $1
    then
      sed -e &quot;s/pick $.*$ $Meant for it to be two lines$/squash \1 \2/g&quot; &lt; $1 &gt; $1.tmp
      mv $1.tmp $1
    # Else, assume it&#39;s the commit message file
    else
    # Use our pre-canned message
      echo &quot;Created two line file&quot; &gt; $1
    fi


P.S.: Yes, I know some of you cringe when you see me using emacs as a fall-back editor.

P.P.S.: We do know we&#39;ll have to blow away all of our clones of the existing repository after the rebase. (Along the lines of &quot;thou shalt not rebase a repository after it&#39;s been published&quot;.)

P.P.P.S: Can anyone tell me how to add a bounty to this? I&#39;m not seeing the option anywhere on this screen whether I&#39;m in edit mode or view mode.




Why does git-rebase give me merge conflicts when all I&#39;m doing is squashing commits?

I have set up some remote tracking branches in git, but I never seem to be able to merge them into the local branch once I have updated them with &#39;git fetch&#39;.

For example, suppose I have remote branch called &#39;an-other-branch&#39;. I set that up locally as a tracking branch using

    git branch --track an-other-branch origin/an-other-branch

So far, so good. But if that branch gets updated (usually by me moving machine and commiting from that machine), and I want to update it on the original machine, I&#39;m running into trouble with fetch/merge:

    git fetch origin an-other-branch
    git merge origin/an-other-branch

Whenever I do this, I get an &#39;Already up-to-date&#39; message and nothing merges.

However, a

    git pull origin an-other-branch

always updates it like you would expect.

Also, running git diff

    git diff origin/an-other-branch

shows that there are differences, so I think I have my syntax wrong.

What am I doing wrong?

**EDIT [2010-04-09]:** I have checked a couple of times, and I&#39;m definitely not on a different branch. Should my &#39;git fetch&#39; followed by a &#39;git merge&#39; (as shown above) do the exact same thing as a git pull? I will get some workflow showing the results of a git status etc.




How Do I &#39;git fetch&#39; and &#39;git merge&#39; from a Remote Tracking Branch (like &#39;git pull&#39;)

I currently have the latest version of my code on another computer that I want to develop from (Home computer and laptop for when I&#39;m out and about) I set up heroku for my app on my laptop. Now I need to associate my code on my desktop so that I can push to heroku from there as well.

This is what I get from my desktop:

    desktop:~/NetBeansProjects/onlinescheduler$ git pull heroku master
    fatal: &#39;heroku&#39; does not appear to be a git repository
    fatal: The remote end hung up unexpectedly

I can&#39;t do `heroku create` because that will create a separate app. How do I associated the existing code with (or pull down a brand new version from) heroku?

Whats the command to do this?

How can I pull an existing heroku app to new location for development?

How do I check the date and time of the latest `git pull` that was executed? I frequently need to know when the code changed on a server when something goes wrong.

How do I check the date and time of the latest `git pull` that was executed?

I work on a project that has 2 branches, A and B. I typically work on branch A, and merge stuff from branch B. For the merging, I would typically do:

    git merge origin/branchB

However, I would also like to keep a local copy of branch B, as I may occasionally check out the branch without first merging with my branch A. For this, I would do:

    git checkout branchB
    git pull
    git checkout branchA

Is there a way to do the above in one command, and without having to switch branch back and forth? Should I be using `git update-ref` for that? How?


Merge, update, and pull Git branches without using checkouts

[Another question][1] says that `git pull` is like a `git fetch` + `git merge`.

But what is the difference between `git pull` and `git fetch` + `git rebase`?

  [1]: https://stackoverflow.com/questions/292357/whats-the-difference-between-git-pull-and-git-fetch

What is the difference between git pull and git fetch + git rebase?

Context: I&#39;m working on master adding a simple feature. After a few minutes I realize it was not so simple and it should have been better to work into a new branch.

This always happens to me and I have no idea how to switch to another branch and take all these uncommited changes with me leaving the master branch clean. I supposed `git stash &amp;&amp; git stash branch new_branch` would simply accomplish that but this is what I get:

    ~/test $ git status
    # On branch master
    nothing to commit (working directory clean)

    ~/test $ echo &quot;hello!&quot; &gt; testing 

    ~/test $ git status
    # On branch master
    # Changed but not updated:
    #   (use &quot;git add &lt;file&gt;...&quot; to update what will be committed)
    #   (use &quot;git checkout -- &lt;file&gt;...&quot; to discard changes in working directory)
    #
    #	modified:   testing
    #
    no changes added to commit (use &quot;git add&quot; and/or &quot;git commit -a&quot;)

    ~/test $ git stash
    Saved working directory and index state WIP on master: 4402b8c testing
    HEAD is now at 4402b8c testing

    ~/test $ git status
    # On branch master
    nothing to commit (working directory clean)

    ~/test $ git stash branch new_branch
    Switched to a new branch &#39;new_branch&#39;
    # On branch new_branch
    # Changed but not updated:
    #   (use &quot;git add &lt;file&gt;...&quot; to update what will be committed)
    #   (use &quot;git checkout -- &lt;file&gt;...&quot; to discard changes in working directory)
    #
    #	modified:   testing
    #
    no changes added to commit (use &quot;git add&quot; and/or &quot;git commit -a&quot;)
    Dropped refs/stash@{0} (db1b9a3391a82d86c9fdd26dab095ba9b820e35b)

    ~/test $ git s
    # On branch new_branch
    # Changed but not updated:
    #   (use &quot;git add &lt;file&gt;...&quot; to update what will be committed)
    #   (use &quot;git checkout -- &lt;file&gt;...&quot; to discard changes in working directory)
    #
    #	modified:   testing
    #
    no changes added to commit (use &quot;git add&quot; and/or &quot;git commit -a&quot;)

    ~/test $ git checkout master
    M	testing
    Switched to branch &#39;master&#39;

    ~/test $ git status
    # On branch master
    # Changed but not updated:
    #   (use &quot;git add &lt;file&gt;...&quot; to update what will be committed)
    #   (use &quot;git checkout -- &lt;file&gt;...&quot; to discard changes in working directory)
    #
    #	modified:   testing
    #
    no changes added to commit (use &quot;git add&quot; and/or &quot;git commit -a&quot;)


Do you know if there is any way of accomplishing this?

Git: Create a branch from unstaged/uncommitted changes on master

I did a `git stash pop` and ended up with merge conflicts. I removed the files from the file system and did a `git checkout` as shown below, but it thinks the files are still unmerged. I then tried replacing the files and doing a `git checkout` again and same result. I event tried forcing it with `-f` flag. Any help would be appreciated!

    chirag-patels-macbook-pro:haloror patelc75$ git status
    app/views/layouts/_choose_patient.html.erb: needs merge
    app/views/layouts/_links.html.erb: needs merge
    # On branch prod-temp
    # Changes to be committed:
    #   (use &quot;git reset HEAD &lt;file&gt;...&quot; to unstage)
    #
    #       modified:   db/schema.rb
    #
    # Changed but not updated:
    #   (use &quot;git add &lt;file&gt;...&quot; to update what will be committed)
    #   (use &quot;git checkout -- &lt;file&gt;...&quot; to discard changes in working directory)
    #
    #       unmerged:   app/views/layouts/_choose_patient.html.erb
    #       unmerged:   app/views/layouts/_links.html.erb
    
    chirag-patels-macbook-pro:haloror patelc75$ git checkout app/views/layouts/_choose_patient.html.erb
    error: path &#39;app/views/layouts/_choose_patient.html.erb&#39; is unmerged
    chirag-patels-macbook-pro:haloror patelc75$ git checkout -f app/views/layouts/_choose_patient.html.erb
    warning: path &#39;app/views/layouts/_choose_patient.html.erb&#39; is unmerged

git stash blunder: git stash pop and ended up with merge conflicts

How can I stash only one of the multiple changed files on my branch?

Stash only one file out of multiple files that have changed with Git?

I often put work away for later, then other stuff comes along, and a few weeks later, I want to inspect the stash, and find out what changes it would make if I applied it to working tree in its current state.

I know I can do a git diff on the stash, but this shows me all the differences between the working tree and the stash, whereas I&#39;m just interested to know what the stash apply is going to change.

How can I do this?

Is it possible to preview stash contents in git?

I ♥ `git stash -p`. But sometimes, after a satisfying session of `y`, `n`, and `s`, I get this:

    Saved working directory and index state WIP on foo: 9794c1a lorum ipsum
    error: patch failed: spec/models/thing_spec.rb:65
    error: spec/models/thing_spec.rb: patch does not apply
    Cannot remove worktree changes

Why?

Why does `git stash -p` sometimes fail?

What is the simplest way to undo a particular commit that is:

* not in the head or HEAD
* Has been pushed to the remote.

Because if it is not the latest commit, 

    git reset HEAD

doesn&#39;t work. And because it has been pushed to a remote,

    git rebase -i

and
    
    git rebase --onto

will cause some problem in the remotes. 

More so, I don&#39;t want to modify the history really. If there was bad code, it was there in the history and can be seen. I just want it out in the working copy, and I don&#39;t mind a reverse merge commit.

In other words, what is the [Git][2] equivalent of the following svn commands:

    svn merge -r 303:295 http://svn.example.com/repos/calc/trunk

which removes all changes from 295 to 302 by reverse merging all changes in those revisions, as a new commit.

    svn merge -c -302 ^/trunk

which undoes the 302 commit, of course by adding another commit that reverse merges the changes from that respective commit.

I thought it should be a fairly simple operation in Git and a fairly common use case. What else is the point of atomic commits? 

We have staging [stashing][3] and all to ensure the commits are perfectly atomic, shouldn&#39;t you be able to undo one or more of those atomic commits easily?

  [2]: http://en.wikipedia.org/wiki/Git_%28software%29
  [3]: http://en.wikipedia.org/wiki/Git_%28software%29#Stash


Undo a particular commit in Git that&#39;s been pushed to remote repos

How do I revert from my current state to a snapshot made on a certain commit?

If I do `git log`, then I get the following output:

    $ git log
    commit a867b4af366350be2e7c21b8de9cc6504678a61b`
    Author: Me &lt;me@me.com&gt;
    Date:   Thu Nov 4 18:59:41 2010 -0400

    blah blah blah...

    commit 25eee4caef46ae64aa08e8ab3f988bc917ee1ce4
    Author: Me &lt;me@me.com&gt;
    Date:   Thu Nov 4 05:13:39 2010 -0400

    more blah blah blah...

    commit 0766c053c0ea2035e90f504928f8df3c9363b8bd
    Author: Me &lt;me@me.com&gt;
    Date:   Thu Nov 4 00:55:06 2010 -0400

    And yet more blah blah...

    commit 0d1d7fc32e5a947fbd92ee598033d85bfc445a50
    Author: Me &lt;me@me.com&gt;
    Date:   Wed Nov 3 23:56:08 2010 -0400

    Yep, more blah blah.

How do I revert to the commit from November 3, i.e. commit `0d1d7fc`?


How do I revert a Git repository to a previous commit?

How can I undo _every_ change made to my directory after the last commit, including deleting added files, resetting modified files, and adding back deleted files?

Reset all changes after last commit in git

For example, in the following master branch, I need to trash just the commit af5c7bf16e6f04321f966b4231371b21475bc4da, which is the second due to previous rebase:

    commit 60b413512e616997c8b929012cf9ca56bf5c9113
    Author: Luca G. Soave &lt;luca.soave@gmail.com&gt;
    Date:   Tue Apr 12 23:50:15 2011 +0200
    
        add generic config/initializers/omniauth.example.rb
    
    commit af5c7bf16e6f04321f966b4231371b21475bc4da
    Author: Luca G. Soave &lt;luca.soave@gmail.com&gt;
    Date:   Fri Apr 22 00:15:50 2011 +0200
    
        show github user info if logged
    
    commit e6523efada4d75084e81971c4dc2aec621d45530
    Author: Luca G. Soave &lt;luca.soave@gmail.com&gt;
    Date:   Fri Apr 22 17:20:48 2011 +0200
    
        add multiple .container at blueprint layout
    
    commit 414ceffc40ea4ac36ca68e6dd0a9ee97e73dee22
    Author: Luca G. Soave &lt;luca.soave@gmail.com&gt;
    Date:   Thu Apr 21 19:55:57 2011 +0200
    
        add %h1 Fantastic Logo + .right for &#39;Sign in with Github&#39;


I need to mantain 
  
 - the First commit 60b413512e616997c8b929012cf9ca56bf5c9113,
 - the Third commit e6523efada4d75084e81971c4dc2aec621d45530 and 
 - the Last commit 414ceffc40ea4ac36ca68e6dd0a9ee97e73dee22 

&quot;throwing away&quot; just the Second commit **af5c7bf16e6f04321f966b4231371b21475bc4da**

How can I do that?
Thanks in advance 
Luca


I need to pop up and trash away a &quot;middle&quot; commit in my master branch. How can I do it?

Is there a git command to revert all uncommitted changes in a working tree and index and to also remove newly created files and folders?

Content Type	Original Author	Original Content on Stackoverflow
Question	Thomas	View Question on Stackoverflow
Solution 1 - Git	Pat Notz	View Answer on Stackoverflow
Solution 2 - Git	knittl	View Answer on Stackoverflow
Solution 3 - Git	Erik Martino Hansen	View Answer on Stackoverflow
Solution 4 - Git	Johan Dahlin	View Answer on Stackoverflow

Undoing a git pull --rebase

Git Problem Overview

Git Solutions

Solution 1 - Git

Solution 2 - Git

Solution 3 - Git

Solution 4 - Git

How does Request.IsAuthenticated work?

Is it possible to achieve a <fieldset>-like effect without using the <fieldset> tag?

Attributions