nrninsane · June 2, 2021 09:14 · Jun 2, 2021 · Apr 13, 2021 · Apr 13, 2021 · Oct 8, 2020
diff --git a/splitting up a commit.md b/splitting up a commit.md
@@ -15,7 +15,7 @@ git stash save "split this up into multiple commits"
 - ```git stash apply```
 - modify lines,
 - git add, 
-- git commit (first one has to be ```--amend```!)
+- git commit
 
 3. get back the original state of the rebase step
 ```

diff --git a/git-log.md b/git-log.md
@@ -0,0 +1,10 @@
+from https://coderwall.com/p/euwpig/a-better-git-log
+
+configure
+```bash
+git config --global alias.lg "log --color --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit"
+```
+
+usages:
+- `git lg`
+- `git lg -p` to see line changes
diff --git a/dangling commits and cherry-picking.md b/dangling commits and cherry-picking.md
@@ -7,3 +7,8 @@ git reflog
 ```
 git cherry-pick <hash>
 ```
+
+- to cherry-pick without automatically committing
+```
+git chery-pick -n <hash>
+```
diff --git a/dangling commits and cherry-picking.md b/dangling commits and cherry-picking.md
@@ -0,0 +1,9 @@
+- to find recent dangling commit
+```
+git reflog
+```
+
+- this dangling commit can be inserted back
+```
+git cherry-pick <hash>
+```
diff --git a/splitting up a commit.md b/splitting up a commit.md
@@ -1,13 +1,18 @@
 Tip: practice this on a throwaway project to get a better grasp.
 
+0. create a backup
+```
+git branch backup-in-case-of-screwup
+```
+
 1. to split up the commit of current rebase step
 ```
 git reset HEAD^
-git stash save "<myStash>"
+git stash save "split this up into multiple commits"
 ```
 
 2.  make the changes
-- ```git stash apply <myStash>```
+- ```git stash apply```
 - modify lines,
 - git add, 
 - git commit (first one has to be ```--amend```!)

diff --git a/splitting up a commit.md b/splitting up a commit.md
@@ -2,13 +2,15 @@ Tip: practice this on a throwaway project to get a better grasp.
 
 1. to split up the commit of current rebase step
 ```
-git stash save "<myStash>"
 git reset HEAD^
+git stash save "<myStash>"
 ```
 
-1.  make the changes
-```git stash apply <myStash>```
-modify lines, git add, git commit
+2.  make the changes
+- ```git stash apply <myStash>```
+- modify lines,
+- git add, 
+- git commit (first one has to be ```--amend```!)
 
 3. get back the original state of the rebase step
 ```

diff --git a/basic rebase.md b/basic rebase.md
@@ -0,0 +1,18 @@
+Note: only rebase local branches, **NEVER REBASE A REMOTE BRANCH**.
+
+1. create backup to preserve original commit tree
+```
+git branch myBackup
+```
+
+2. get list of commits and their SHA
+```
+git --no-pager log --oneline
+```
+
+3. start interactive rebase on targetSHA
+```
+git rebase -i <targetSHA>^
+```
+
+4. determine what to do with each commit & continue: keep, edit, etc. (git will show you the options)
diff --git a/git.md b/git.md
@@ -1,70 +0,0 @@
-# Stashing
-
-Most of it is straightforward
-
-- to include untracked files
-```
-git stash save --include-untracked "<myDescription>"
-```
-
-- to include everything, even files/folders in .gitignore
-```
-git stash --all "<myDescription>"
-```
-
-# Basic rebasing
-
-Note: only rebase local branches, **NEVER REBASE A REMOTE BRANCH**.
-
-1. create backup to preserve original commit tree
-```
-git branch myBackup
-```
-
-2. get list of commits and their SHA
-```
-git --no-pager log --oneline
-```
-
-3. start interactive rebase on targetSHA
-```
-git rebase -i <targetSHA>^
-```
-
-4. determine what to do with each commit & continue: keep, edit, etc. (git will show you the options)
-
-## Splitting up a commit
-
-Tip: practice this on a throwaway project to get a better grasp.
-
-1. to split up the commit of current rebase step
-```
-git stash save "<myStash>"
-git reset HEAD^
-```
-
-1.  make the changes
-```git stash apply <myStash>```
-modify lines, git add, git commit
-
-3. get back the original state of the rebase step
-```
-git stash apply <myStash>
-```
-
-4. repeat until nothing to commit
-
-5. if you are done with the current rebase step
-```
-git rebase --continue
-```
-
-**if you want to abort rebase**
-```
-git rebase --abort
-```
-
-**if rebase finished and it was not what you wanted**
-```
-git reset myBackup --hard
-```

diff --git a/splitting up a commit.md b/splitting up a commit.md
@@ -0,0 +1,33 @@
+Tip: practice this on a throwaway project to get a better grasp.
+
+1. to split up the commit of current rebase step
+```
+git stash save "<myStash>"
+git reset HEAD^
+```
+
+1.  make the changes
+```git stash apply <myStash>```
+modify lines, git add, git commit
+
+3. get back the original state of the rebase step
+```
+git stash apply <myStash>
+```
+
+4. repeat until nothing to commit
+
+5. if you are done with the current rebase step
+```
+git rebase --continue
+```
+
+**if you want to abort rebase**
+```
+git rebase --abort
+```
+
+**if rebase finished and it was not what you wanted**
+```
+git reset myBackup --hard
+```
diff --git a/stashing.md b/stashing.md
@@ -0,0 +1,9 @@
+- to include untracked files
+```
+git stash save --include-untracked "<myDescription>"
+```
+
+- to include everything, even files/folders in .gitignore
+```
+git stash --all "<myDescription>"
+```
diff --git a/git.md b/git.md
@@ -39,7 +39,7 @@ Tip: practice this on a throwaway project to get a better grasp.
 
 1. to split up the commit of current rebase step
 ```
-git stash save myStash
+git stash save "<myStash>"
 git reset HEAD^
 ```
 

diff --git a/git.md b/git.md
@@ -3,23 +3,33 @@
 Most of it is straightforward
 
 - to include untracked files
-```git stash save --include-untracked "<myDescription>"```
+```
+git stash save --include-untracked "<myDescription>"
+```
 
 - to include everything, even files/folders in .gitignore
-```git stash --all "<myDescription>"```
+```
+git stash --all "<myDescription>"
+```
 
 # Basic rebasing
 
 Note: only rebase local branches, **NEVER REBASE A REMOTE BRANCH**.
 
 1. create backup to preserve original commit tree
-```git branch myBackup```
+```
+git branch myBackup
+```
 
 2. get list of commits and their SHA
-```git --no-pager log --oneline```
+```
+git --no-pager log --oneline
+```
 
 3. start interactive rebase on targetSHA
-```git rebase -i <targetSHA>^```
+```
+git rebase -i <targetSHA>^
+```
 
 4. determine what to do with each commit & continue: keep, edit, etc. (git will show you the options)
 
@@ -38,15 +48,23 @@ git reset HEAD^
 modify lines, git add, git commit
 
 3. get back the original state of the rebase step
-```git stash apply <myStash>```
+```
+git stash apply <myStash>
+```
 
 4. repeat until nothing to commit
 
 5. if you are done with the current rebase step
-```git rebase --continue```
+```
+git rebase --continue
+```
 
 **if you want to abort rebase**
-```git rebase --abort```
+```
+git rebase --abort
+```
 
 **if rebase finished and it was not what you wanted**
-```git reset myBackup --hard```
+```
+git reset myBackup --hard
+```
diff --git a/git.md b/git.md
@@ -3,23 +3,23 @@
 Most of it is straightforward
 
 - to include untracked files
-`git stash save --include-untracked "<myDescription>"`
+```git stash save --include-untracked "<myDescription>"```
 
 - to include everything, even files/folders in .gitignore
-`git stash --all "<myDescription>"`
+```git stash --all "<myDescription>"```
 
 # Basic rebasing
 
 Note: only rebase local branches, **NEVER REBASE A REMOTE BRANCH**.
 
 1. create backup to preserve original commit tree
-`git branch myBackup`
+```git branch myBackup```
 
 2. get list of commits and their SHA
-`git --no-pager log --oneline`
+```git --no-pager log --oneline```
 
 3. start interactive rebase on targetSHA
-`git rebase -i <targetSHA>^`
+```git rebase -i <targetSHA>^```
 
 4. determine what to do with each commit & continue: keep, edit, etc. (git will show you the options)
 
@@ -34,19 +34,19 @@ git reset HEAD^
 ```
 
 1.  make the changes
-`git stash apply <myStash>` 
+```git stash apply <myStash>```
 modify lines, git add, git commit
 
 3. get back the original state of the rebase step
-`git stash apply <myStash>`
+```git stash apply <myStash>```
 
 4. repeat until nothing to commit
 
 5. if you are done with the current rebase step
-`git rebase --continue`
+```git rebase --continue```
 
 **if you want to abort rebase**
-`git rebase --abort`
+```git rebase --abort```
 
 **if rebase finished and it was not what you wanted**
-`git reset myBackup --hard`
+```git reset myBackup --hard```
diff --git a/git.commands b/git.commands
@@ -1,52 +0,0 @@
-NOTE: ONLY REBASE A LOCAL BRANCH, **NEVER REBASE A REMOTE BRANCH**
-
-##########################################
-# NOTE    								 #
-##########################################
-#										 #
-# ONLY REBASE A LOCAL BRANCH             #
-# NEVER EVER EVER REBASE A REMOTE BRANCH #
-#										 #
-##########################################
-
-# create backup to preserve original commit tree
-git branch myBackup
-
-# get list of commits and their SHA
-git --no-pager log --oneline
-
-# start interactive rebase on targetSHA
-git rebase -i targetSHA^
-
-# determine what to do with each commit & continue
-# keep, edit, etc. (git will show you the options)
-
-## if you want to split up the commit of current rebase step
-git stash save myStash
-git reset HEAD^
-
-### make the changes
-git stash apply myStash
-### modify lines, git add, git commit
-
-### get back the original state of the rebase step
-git stash apply myStash
-
-### repeat until nothing to commit
-### (go to line 16)
-
-## if you are done with the current rebase step
-git rebase --continue
-
-## if you want to abort rebase
-git rebase --abort
-
-#if rebase finished and it was not what you wanted
-git reset myBackup --hard
-
-################
-# Tip:
-# Practice this on some nonsensical files 
-# to get a sense for this process
-
-

diff --git a/git.md b/git.md
@@ -0,0 +1,52 @@
+# Stashing
+
+Most of it is straightforward
+
+- to include untracked files
+`git stash save --include-untracked "<myDescription>"`
+
+- to include everything, even files/folders in .gitignore
+`git stash --all "<myDescription>"`
+
+# Basic rebasing
+
+Note: only rebase local branches, **NEVER REBASE A REMOTE BRANCH**.
+
+1. create backup to preserve original commit tree
+`git branch myBackup`
+
+2. get list of commits and their SHA
+`git --no-pager log --oneline`
+
+3. start interactive rebase on targetSHA
+`git rebase -i <targetSHA>^`
+
+4. determine what to do with each commit & continue: keep, edit, etc. (git will show you the options)
+
+## Splitting up a commit
+
+Tip: practice this on a throwaway project to get a better grasp.
+
+1. to split up the commit of current rebase step
+```
+git stash save myStash
+git reset HEAD^
+```
+
+1.  make the changes
+`git stash apply <myStash>` 
+modify lines, git add, git commit
+
+3. get back the original state of the rebase step
+`git stash apply <myStash>`
+
+4. repeat until nothing to commit
+
+5. if you are done with the current rebase step
+`git rebase --continue`
+
+**if you want to abort rebase**
+`git rebase --abort`
+
+**if rebase finished and it was not what you wanted**
+`git reset myBackup --hard`
diff --git a/git.commands b/git.commands
@@ -1,3 +1,5 @@
+NOTE: ONLY REBASE A LOCAL BRANCH, **NEVER REBASE A REMOTE BRANCH**
+
 ##########################################
 # NOTE    								 #
 ##########################################

diff --git a/git.commands b/git.commands
@@ -24,6 +24,7 @@ git stash save myStash
 git reset HEAD^
 
 ### make the changes
+git stash apply myStash
 ### modify lines, git add, git commit
 
 ### get back the original state of the rebase step

diff --git a/git.commands b/git.commands
@@ -1,11 +1,11 @@
-##############################################
-# NOTE    									 #
-##############################################
-#											 #
-# ONLY REBASE ON A LOCAL BRANCH              #
-# NEVER EVER EVER DO THIS ON A REMOTE BRANCH #
-#											 #
-##############################################
+##########################################
+# NOTE    								 #
+##########################################
+#										 #
+# ONLY REBASE A LOCAL BRANCH             #
+# NEVER EVER EVER REBASE A REMOTE BRANCH #
+#										 #
+##########################################
 
 # create backup to preserve original commit tree
 git branch myBackup

diff --git a/git.commands b/git.commands
@@ -10,7 +10,7 @@
 # create backup to preserve original commit tree
 git branch myBackup
 
-# get list of commits
+# get list of commits and their SHA
 git --no-pager log --oneline
 
 # start interactive rebase on targetSHA

diff --git a/commands.git → git.commands b/commands.git → git.commands
diff --git a/git commands → commands.git b/git commands → commands.git
@@ -41,8 +41,9 @@ git rebase --abort
 #if rebase finished and it was not what you wanted
 git reset myBackup --hard
 
-
-
-
+################
+# Tip:
+# Practice this on some nonsensical files 
+# to get a sense for this process
 
 
diff --git a/git commands b/git commands
@@ -0,0 +1,48 @@
+##############################################
+# NOTE    									 #
+##############################################
+#											 #
+# ONLY REBASE ON A LOCAL BRANCH              #
+# NEVER EVER EVER DO THIS ON A REMOTE BRANCH #
+#											 #
+##############################################
+
+# create backup to preserve original commit tree
+git branch myBackup
+
+# get list of commits
+git --no-pager log --oneline
+
+# start interactive rebase on targetSHA
+git rebase -i targetSHA^
+
+# determine what to do with each commit & continue
+# keep, edit, etc. (git will show you the options)
+
+## if you want to split up the commit of current rebase step
+git stash save myStash
+git reset HEAD^
+
+### make the changes
+### modify lines, git add, git commit
+
+### get back the original state of the rebase step
+git stash apply myStash
+
+### repeat until nothing to commit
+### (go to line 16)
+
+## if you are done with the current rebase step
+git rebase --continue
+
+## if you want to abort rebase
+git rebase --abort
+
+#if rebase finished and it was not what you wanted
+git reset myBackup --hard
+
+
+
+
+
+
No results found