Git/hacks: Difference between revisions

==Search==

<code>git grep</code> only works on the current content of your working copy. To search through all revisions, you can use something like

# -F is --fixed-strings

# Interpret PATTERN as a list of fixed strings (instead of regular expressions), separated by newlines, any of which is to be matched.

git rev-list --all | ( while read revision; do git grep -F 'wgAWSCredentials' $revision; done; )

<code>git log --reverse --grep rocky -i</code>

==Ignore File Mode==

Sometimes you have to temporarily change file modes (or some script might alter your working directory).  Anyway, to ignore file mode changes temporarily, you can just add <code>-c core.fileMode=false</code> to your command. E.g.:

git -c core.fileMode=false status

You can also put this into a repo or global config, but you probably shouldn't.

If you need to change filemodes back to the way they were in the repo, you can do something like

git diff --summary | grep --color 'mode change 100755 => 100644' | cut -d' ' -f7 | xargs chmod +x

git diff --summary | grep --color 'mode change 100644 => 100755' | cut -d' ' -f7 | xargs chmod -x

==Working on a remote terminal==

If you're working on a remote terminal  and your repository get's complicated, but you don't have desktop tools like [[meld]] or [[gitk]] to look at it, you can copy the remote repo to your desktop with <code>rsync</code>, even if you have to jump through a bastion host with something like:

rsync -e "ssh -t bastion ssh -A" -ravz centos@10.0.50.68:/opt/meza/ ./meza-es1/

If that complains about host-key verification, then simply do an SSH first to the host, accept the host key identity, and logout.  Now the rsync will work because the host-key is already accepted as valid.

Add <code>GIT_TRACE=1</code> to your command to see more of what's going on. (Note that there are no spaces and no semicolon.)

GIT_TRACE=1 git status

==Just the facts==

See all the changes in color, but without any context lines, and without the leading +/-/<nowiki>[space]</nowiki>

This makes it easy to grab changes and stuff them in another file for example.

git diff -U0 --color myfile | sed -r "s/^([^-+ ]*)[-+ ]/\\1/"

==What is this miscellaneous file, and how does it compare to what's in my repo?==

Say you've got a config file lying around (untracked) in your local working tree.  It's not in your current project branch, but you know it's an important file.  How does it compare to what's in the '''freephile''' remote, '''es128''' branch version of the file?

git diff freephile/es128:config/core/MezaLocalExtensions.yml config/core/MezaLocalExtensions.yml

==How has this file changed over time?==

Do you think a particular file has changed between two separate feature branches (ea based off master)?

# git diff branch1..branch2 -- path/to/file

git diff es128-rebased..get-to-know-meza -- manual/commands.md

==Add that forgotten file==

You forgot to add a file to the last commit?  Just add it to the index, and commit with <code>--amend</code>.  Added a file that shouldn't be there? <code>git rm</code> it.  If you leave off the -m (message) option in the new commit, it will let you re-use the last commit message.  This lets you "undo the last commit" and redo it right.  You usually do not want to amend a commit if you've already pushed it to other repos, but if it's just local <code>--amend</code> is awesome-sauce.

git add forgotten.php

git rm oops.txt

git commit --amend

git log --stat

==Undo a commit==

Sometimes a commit is just wrong or 'breaks the build' so to speak. If you really just want to '''undo''' a commit, then  

# view what changes were made in the last commit

git difftool HEAD~

# reset --hard will undo the last commit, and discard any changes that were made in the commit. Your work tree will be identical to the way it was after the prior commit.

git reset --hard HEAD~

Using <code>reset</code> you can even go backwards several commits if you want.   

The entire internet tells you not to <code>reset</code> if you've already pushed. But if you're just pushing (from machine A: your desktop) to a remote (machine B: eg. GitHub) so that you can then pull those changes into another space (machine C: development/staging/production/other machine) you can push your changes with <code>--force</code>; and pull them from that other environment.  It may be quicker and easier though to identify the SHA of the n-1 commit and then <code>reset</code> on machine C

git log -n 4

# find the commit SHA, and use it on machine C

git reset --hard d89c004cfe4bd67838fb41c7a6644bb15feee5cc

Credit: there's a clear explanation at https://www.git-tower.com/learn/git/faq/undo-last-commit

==Delete local and remote merged branches==

git branch --merged | egrep -v "(^\*|master|dev)" | xargs -I % echo 'git branch -d % ; git push --delete freephile % ;'

Using '''echo''' helps you look before you leap. '''%''' is the replacement string in <code>xargs</code>. Change '<code>echo</code>' to '<code>sh -c</code>' to execute. Does both local and remote prunes.

<code>--stat</code> gives a nice view of what happened in the log.

git log --stat

# try these other git log variatiations

git log --since 'last week'

git log --since 2017-01-01

How do you ignore a directory, but make an exception?  What if you already added certain directories to git but want to stop tracking them now (ie. "take them out of version control")?

</pre>

Then you simply remove all files from git's index, and add them back (only now adding them back will look to .gitignore for the corrected rules)

git rm -r --cached .

git add .

git commit -m 'ignoring vendor/*'

==Tags==

With git, you can just tag something with <code>git tag foo</code>.  This produces a 'lightweight' tag <ref>[https://stackoverflow.com/questions/21031201/how-can-i-list-all-lightweight-tags how can I list all the lightweight tags]</ref>.  Use "annotated tags" whenever you want to know '''when''' something was tagged and '''who''' did it.  Pass an empty message if you really don't care or need extra annotation.

git tag -am '' 'REL-1.0-alpha'

When using git between a local repository and a single 'origin' remote, it's a simple process to work locally and push things back up to origin.  But, what if you have a separate remote repository... perhaps on GitHub, or a collaborator who has similar sources but not using your origin (so disconnected, and perhaps not even linked ancestrally like a fork).  How do you add that other remote to your project and then pull in the code "they" have on top of yours?  Here's an example of how we started with a repo from github and added a repo that we were developing privately. (The reality is that we were developing a repo privately; created a sibling version of the code at github; and then wanted to re-incorporate the changes of the github repo back into our private repo.)

# start with one 'origin' remote

git clone https://github.com/freephile/qb.git

# and push to other remote 'eqt'

git push eqt

==Unbloat==

https://stackoverflow.com/questions/3797907/how-to-remove-unused-objects-from-a-git-repository

git -c gc.reflogExpire=0 -c gc.reflogExpireUnreachable=0 \

   -c gc.rerereresolved=0 -c gc.rerereunresolved=0 \

   -c gc.pruneExpire=now gc  

==Put your project on GitHub==

<br />

# first make a "bare" clone

# from your server

git push --set-upstream github master

# from now on you can just 'git push' from master

==Create a README from a webpage==

Now create a fine README file using [[pandoc]] to convert your webpage to [[Markdown]]

pandoc --standalone --read html https://freephile.org/barcode/index.html -o README.md

==Remember your password==