You want to use the `--follow` option on `git log`, which is described in the man page as:

    Continue listing the history of a file beyond renames.

Effectively, not only does this allow you to see the history of a renamed file, but this also allows you to view the history of a file no longer in the working tree. So the command you should use should look something like:

    git log --follow -- foo

**Update:**

Git 2.9+ has now enabled this by default for all `git diff` and `git log` commands:

&gt; The end-user facing Porcelain level commands in the &quot;git diff&quot; and
&quot;git log&quot; family by default enable the rename detection; you can still
use &quot;diff.renames&quot; configuration variable to disable this.

Thanks to x-yuri for the heads up!

First, I acknowledge the possibility that this question could be a duplicate; just let me know.

I&#39;m curious what the general &quot;best practice&quot; is for those situations when mutability is desired. F# seems to offer two facilities for this: the `let mutable` binding, which seems to work like variables in &quot;most&quot; languages, and the reference cell (created with the `ref` function) that requires explicit dereferencing to use.

There are a couple of cases where one is &quot;forced&quot; into one or the other: .NET interop tends to use mutable with `&lt;-`, and in workflow computations one must use `ref` with `:=`. So those cases are pretty clear-cut, but I&#39;m curious what to do when creating my own mutable variables outside of those scenarios. What advantage does one style have over the other? (Perhaps further insight into the implementation would help.)

Thanks!

F#: let mutable vs. ref

How do I convert a byte array into a string?

I have found these functions that do the reverse:

    function string2Bin(s) {
        var b = new Array();
        var last = s.length;
        
        for (var i = 0; i &lt; last; i++) {
            var d = s.charCodeAt(i);
            if (d &lt; 128)
                b[i] = dec2Bin(d);
            else {
                var c = s.charAt(i);
                alert(c + &#39; is NOT an ASCII character&#39;);
                b[i] = -1;
            }
        }
        return b;
    }
    
    function dec2Bin(d) {
        var b = &#39;&#39;;
        
        for (var i = 0; i &lt; 8; i++) {
            b = (d%2) + b;
            d = Math.floor(d/2);
        }
        
        return b;
    }

But how do I get the functions working the other way?

Thanks.

Shao


Converting byte array to string in javascript

My repository underwent changes such as:

1. ...some unrelated commits...
1. Commit new file `foo` with 100 lines of content
1. ...intervening commits, some of which touch `foo`...
1. Insert the contents of `foo` at the top of an existing file `bar` and `git rm foo` in the same commit
1. ...more unrelated commits...

Now I want to see the log of deleted file `foo`.  Everything I&#39;ve read, including on SO, says I should be able to `git log -- foo`, but that command produces no output.

If I find the commit that includes deleting `foo` I can `git log 1234abcd -- foo` and see its log, so I think my path to `foo` isn&#39;t the problem.  Also note that `git merge-base HEAD 1234abcd` outputs `1234abcd[...]`, so I think that should prove the commit is reachable from `HEAD`.  Note that there is no file `foo` in my working tree (obvious, since it was deleted).  Using Git 1.7.1.1 on OS X.

Why doesn&#39;t `git log -- foo` work for me and how can I fix it?  Thanks!

Why doesn&#39;t &quot;git log -‌- foo&quot; work for deleted file foo?

My repository underwent changes such as:
<ol>
<li>...some unrelated commits...</li>
<li>Commit new file <code>foo</code> with 100 lines of content</li>
<li>...intervening commits, some of which touch <code>foo</code>...</li>
<li>Insert the contents of <code>foo</code> at the top of an existing file <code>bar</code> and <code>git rm foo</code> in the same commit</li>
<li>...more unrelated commits...</li>
</ol>
Now I want to see the log of deleted file <code>foo</code>. Everything I've read, including on SO, says I should be able to <code>git log -- foo</code>, but that command produces no output.
If I find the commit that includes deleting <code>foo</code> I can <code>git log 1234abcd -- foo</code> and see its log, so I think my path to <code>foo</code> isn't the problem. Also note that <code>git merge-base HEAD 1234abcd</code> outputs <code>1234abcd[...]</code>, so I think that should prove the commit is reachable from <code>HEAD</code>. Note that there is no file <code>foo</code> in my working tree (obvious, since it was deleted). Using Git 1.7.1.1 on OS X.
Why doesn't <code>git log -- foo</code> work for me and how can I fix it? Thanks!

In git let say I commit A and B

    A---[B]

But then I revert with

    git revert HEAD

So I am there now:

    [A]---B

How do I cancel my revert so that I can go back to B?

Git cancel a revert

I have a gitignore file that makes git ignore `*.dll` files, and that is actually the behavior I want. However, if I want an exception ( i.e. to be able to commit `foo.dll`), how can I achieve this?

git ignore exception

I&#39;ve read a lot of different questions and answers on Stack Overflow as well as **git** documentation on how the **core.autocrlf** setting works.

This is my understanding from what I&#39;ve read:

Unix and Mac OSX (pre-OSX uses CR) clients use LF line endings.  
Windows clients use CRLF line endings.

When core.autocrlf is set to true on the client, the git repository always stores files in LF line ending format and line endings in files on the client are converted back and forth on check out / commit for clients (i.e. Windows) that use non-LF line endings, no matter what format the line endings files are on the client (this disagrees with Tim Clem&#39;s definition - see update below).

Here is a matrix that tries to document the same for the &#39;input&#39; and &#39;false&#39; settings of core.autocrlf with question marks where I&#39;m not sure of line ending conversion behavior.

My questions are:

 1. **What should the question marks be?**
 2. **Is this matrix correct for the &quot;non-question marks&quot;?**

I&#39;ll update the question marks from the answers as consensus appears to be formed.

&lt;pre&gt;
                       core.autocrlf value
            true            input              false
----------------------------------------------------------
commit   |  convert           ?                  ?
new      |  to LF      (convert to LF?)   (no conversion?)

commit   |  convert to        ?                 no 
existing |  LF         (convert to LF?)     conversion

checkout |  convert to        ?                 no
existing |  CRLF       (no conversion?)     conversion

&lt;/pre&gt;

I&#39;m not really looking for opinions on the pros and cons of the various settings.  I&#39;m just looking for data which makes it clear how to expect git to operate with each of the three settings.

--

**Update 04/17/2012**: After reading [the article by Tim Clem][1] linked by JJD in the comments, I have modified some of the values in the &quot;unknown&quot; values in the table above, as well as changing &quot;checkout existing | true to convert to CRLF instead of convert to client&quot;.  Here are the definitions he gives, which are more clear than anything I&#39;ve seen elsewhere:

**core.autocrlf = false**

&gt; This is the default, but most people are encouraged to change this
&gt; immediately. The result of using false is that Git doesn’t ever mess
&gt; with line endings on your file. You can check in files with LF or CRLF
&gt; or CR or some random mix of those three and Git does not care. This
&gt; can make diffs harder to read and merges more difficult. Most people
&gt; working in a Unix/Linux world use this value because they don’t have
&gt; CRLF problems and they don’t need Git to be doing extra work whenever
&gt; files are written to the object database or written out into the
&gt; working directory.

**core.autocrlf = true**

&gt; This means that Git will process all text files and make sure that
&gt; CRLF is replaced with LF when writing that file to the object database
&gt; and turn all LF back into CRLF when writing out into the working
&gt; directory. This is the recommended setting on Windows because it
&gt; ensures that your repository can be used on other platforms while
&gt; retaining CRLF in your working directory.

**core.autocrlf = input**

&gt; This means that Git will process all text files and make sure that
&gt; CRLF is replaced with LF when writing that file to the object
&gt; database. It will not, however, do the reverse. When you read files
&gt; back out of the object database and write them into the working
&gt; directory they will still have LFs to denote the end of line. This
&gt; setting is generally used on Unix/Linux/OS X to prevent CRLFs from
&gt; getting written into the repository. The idea being that if you pasted
&gt; code from a web browser and accidentally got CRLFs into one of your
&gt; files, Git would make sure they were replaced with LFs when you wrote
&gt; to the object database.


Tim&#39;s article is excellent, the only thing I can think of that is missing is that he assumes the repository is in LF format, which is not necessarily true, especially for Windows only projects.

Comparing Tim&#39;s article to the highest voted [answer](https://stackoverflow.com/a/4425433/147511) to date by jmlane shows perfect agreement on the true and input settings and disagreement on the false setting.


  [1]: https://adaptivepatchwork.com/2012/03/01/mind-the-end-of-your-line/

How line ending conversions work with git core.autocrlf between different operating systems

I merged branch `dog` into `animal`.  When I go to commit, I get the following:

    Unmerged paths:
    (use &quot;git reset HEAD &lt;file&gt;...&quot; to unstage)
    (use &quot;git add &lt;file&gt;...&quot; to mark resolution
    both deleted:       ../public/images/originals/dog.ai
    added by them:      ../public/images/original_files/dog.ai

I had different directory names and file names in each branch.  The `animal` branch has the changes that I want.

When I go to reset the head, it doesn&#39;t work.  And when I go to take any other git action (remove, checkout, etc), I get a `path not found` error.

What commands do I need to execute to resolve this?





How to resolve git status &quot;Unmerged paths:&quot;?

I want to version control my web server as described in  https://stackoverflow.com/questions/3154227/version-control-for-my-web-server, by creating a git repo out of my `/var/www directory`.  My hope was that I would then be able to push web content from our dev server to github, pull it to our production server, and spend the rest of the day at the pool.  

Apparently a kink in my plan is that Git won&#39;t respect file permissions (I haven&#39;t tried it, only reading about it now.)  I guess this makes sense in that different boxes are liable to have different user/group setups.  But if I wanted to force permissions to propagate, knowing my servers are configured the same, do I have any options? Or is there an easier way to approach what I&#39;m trying to do?

Retaining file permissions with Git

I have a commit c. I want to get the changeset of that exact commit c + metainformation and no other one. Is there a simpler way than `git log -p c^..c` to do that?


git log of a single revision

When using `git log`, how can I filter by user so that I see only commits from that user?

How can I view a git log of just one user&#39;s commits?

I&#39;ve renamed a couple of files using `git mv`, used `git stash`, had a quick look at HEAD (without changing it) then did `git stash pop` to get the whole lot back again. My moves had disappeared from the commit list, so I redid them with `git rm` and the commit message claimed git had spotted the rename was a rename. So I thought no more of it.

But now, post-commit, I can&#39;t get at the history of the moved files! Here&#39;s what git says about the commit in question:

    ~/projects% git log --summary
    commit de6e9fa2179ae17ec35a5c368d246f19da27f93a
    Author: brone
    Date:   Wed Dec 8 22:37:54 2010 +0000
    
        Moved R_DebugUI into runtime
    
     delete mode 100644 test/R_DebugUI_iOS.h
     delete mode 100644 test/R_DebugUI_iOS.m
     create mode 100644 system/runtime/src/R_DebugUI_iOS.h
     create mode 100644 system/runtime/src/R_DebugUI_iOS.m

     &lt;&lt;snip older commits&gt;&gt;
     ~/projects%

I&#39;m now trying to get the history of one of these moved files, so I can look at an old version, but I don&#39;t get anything very useful:

    ~/projects/system/runtime/src% git log --follow --find-copies-harder -M -C R_DebugUI_iOS.m
    commit de6e9fa2179ae17ec35a5c368d246f19da27f93a
    Author: brone
    Date:   Wed Dec 8 22:37:54 2010 +0000
    
        Moved R_DebugUI into runtime
    ~/projects/system/runtime/src% 

(I&#39;ve also tried it without `-M`, `-C` and `--find-copies-harder`, but to no avail.)

I can get its history under its old name, which stops at the point it was deleted from its old location:

    ~/projects% git log --summary --follow --find-copies-harder -M -C -- test/R_DebugUI_iOS.m
    commit de6e9fa2179ae17ec35a5c368d246f19da27f93a
    Author: brone
    Date:   Wed Dec 8 22:37:54 2010 +0000
    
        Moved R_DebugUI into runtime
    
     delete mode 100644 test/R_DebugUI_iOS.m
    
    commit 32a22d53c27e260714f759ecb3d3864e38b2e87f
    Author: brone
    Date:   Tue Dec 7 23:52:51 2010 +0000
    
        Can set debug UI&#39;s alpha.
    
    &lt;&lt;snip older commits&gt;&gt;
    ~/projects%

So I&#39;m not completely stuck this time, but I wouldn&#39;t fancy having to do this kind of thing all the time. (I anticipate having a fair number of files that will move at least once in their life.)

Am I doing something wrong? The old copy of the file and the new copy are 98.8% the same (2 lines out of 166 changed). My understanding is that git should be able to track the file in this case, because it infers rename operations rather than storing them explicitly, and the files are similar enough that I believe it should consider them the same.

Is there anything I can do to fix this?


Why might git log not show history for a moved file, and what can I do about it?

I have a local branch tracking the remote/master branch. After running `git-pull` and `git-log`, the log will show all commits in the remote tracking branch as well as the current branch. However, because there were so many changes made to the remote branch, I need to see just the commits made to the current local branch.

What would be the Git command to use to only show commits for a specific branch?

Notes:

Configuration information:

    [branch &quot;my-branch&quot;]
      remote = origin
      merge = refs/heads/master


How do I run git log to see changes only for a specific branch?

Let&#39;s say that I have a graph like this:

    A---B---C---D (master)
         \
          \-E---F (HEAD)

If I do `git log --all --oneline`, I will get all six of my commits.

But if the graph is


    A---B---C---D (master, HEAD)
         \
          \-E---F

I will not see E and F. Can I get git to tell me all the commits, including those on branches which are not named?

Thanks

Content Type	Original Author	Original Content on Stackoverflow
Question	user385804	View Question on Stackoverflow
Solution 1 - Git	Nathan Kleyn	View Answer on Stackoverflow

Why doesn't "git log -‌- foo" work for deleted file foo?

Git Problem Overview

Git Solutions

Solution 1 - Git

Converting byte array to string in javascript

F#: let mutable vs. ref

Attributions