Git Notes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Git Notes\n",
    "these notes come mainly from W3's Git Tutorial: www.w3schools.com/git  \n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "to check Git version:  \n",
    "$\\qquad {\\color{green}\\texttt{git}} \\space \\texttt{ --version}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Git allowes you to:\n",
    "* Manage projects with $\\textbf{Repositories}$\n",
    "* $\\textbf{Clone}$ a project to work on a local copy\n",
    "* $\\textbf{Stage}$ and $\\textbf{Commit}$ to control and track changes\n",
    "* $\\textbf{Branch}$ and $\\textbf{Merge}$ to allow for work on different parts and versions of a project\n",
    "* $\\textbf{Pull}$ the latest version of the project to a local copy\n",
    "* $\\textbf{Push}$ local updates to the main project\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "diference between Git Bash and Git CMD?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\textbf{Configuraiton}-$ to configure Git:  \n",
    "$\\qquad {\\color{green}\\texttt{git}} \\space \\texttt{ config --global user.name \"username-string\"} \\\\\n",
    "\\qquad {\\color{green}\\texttt{git}} \\space \\texttt{ config --global user.email \"email@string.com\"}$  \n",
    "\n",
    "Use $\\texttt{global}$ to set the username and e-mail for every repository on your computer.\n",
    "If you want to set the username/e-mail for just the current repo, you can remove global"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "to create new Git folder:  \n",
    "$\\qquad \\texttt{mkdir myproject} \\\\\n",
    "\\qquad \\texttt{cd myproject}$  \n",
    "\n",
    "$\\texttt{mkdir}$ makes a new directory.  \n",
    "$\\texttt{cd}$ changes the current working directory  \n",
    "\n",
    "If you already have a folder/directory you would like to use for Git: Navigate to it in command line, or open it in your file explorer, right-click and select \"Git Bash here\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\textbf{Initialization}-$ to initialize Git: once you have navigated to the correct folder, you need to initialize Git on that folder:  \n",
    "$\\qquad {\\color{green}\\texttt{git}} \\texttt{ init}$ \n",
    "\n",
    "this creates a Git repositorey.  \n",
    "\n",
    "---  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "to list the files in the directory: $\\texttt{ls}$  \n",
    "to see what is part of repo:  \n",
    "$\\qquad {\\color{green}\\texttt{git}} \\texttt{ status}$\n",
    "\n",
    "files in your Git repository folder can be in one of 2 states:  \n",
    "* Tracked - files that Git knows about and are added to the repository  \n",
    "* Untracked - files that are in your working directory, but not added to the repository  \n",
    "\n",
    "when you first add files to an empty repository, they are all untracked. to get Git to track them, you need to stage them, or add them to the staging environment."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\textbf{Staging Environment}-$ staged files are files that are ready to be committed to the repository you are working on.  \n",
    "\n",
    "to add a file to the Staging Environment (to stage a file): $ {\\color{green}\\texttt{git}} \\texttt{ add filename.format}$,  \n",
    "ex: ${\\color{green}\\texttt{git}} \\texttt{ add index.html}$  \n",
    "\n",
    "to add multiple files to the Staging Environment: ${\\color{green}\\texttt{git}} \\texttt{ add -all}$  \n",
    "shorthand: ${\\color{green}\\texttt{git}} \\space \\texttt{add -A}$ "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\textbf{Commit}-$ to commit staged files to the repo is a sort of save point:  \n",
    "when we commit, we should always include a message.  \n",
    "$\\qquad {\\color{green}\\texttt{git}} \\space \\texttt{commit -m \"First release of Hello World!\"}$  \n",
    "\n",
    "the commit command performs a commit, and the -m \"message\" adds a message."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "to look over a compact list of changed files:  \n",
    "$\\qquad {\\color{green}\\texttt{git}} \\texttt{ status --short}$  \n",
    "other short status flags:  \n",
    "* ?? - Untracked files\n",
    "* A - Files added to stage\n",
    "* M - Modified files\n",
    "* D - Deleted files\n",
    "\n",
    "to commit already tracked files without staging first:  \n",
    "the -a option will automatically stage every changed, already tracked file.  \n",
    "$\\qquad{\\color{green}\\texttt{git}} \\texttt{ commit -a -m \"Updated index.html with a new line\"}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\textbf{Commit Log}-$ to view the history of commits for a repository:  \n",
    "$\\qquad {\\color{green}\\texttt{git}} \\texttt{ log}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\textbf{Git Help}-$  \n",
    "there are a couple of different ways you can use the help command in command line:\n",
    "\n",
    "* ${\\color{green}\\texttt{git}} \\space \\it{command} \\space \\texttt{-help}$ : see all the available options for the specific $\\it{command}$\n",
    "* ${\\color{green}\\texttt{git}} \\texttt{ help --all}$ : see all possible commands\n",
    "\n",
    "\n",
    "note: if you find yourself stuck in the list view, such as after a help all command, $\\texttt{SHIFT + G}$ to jump the end of the list, then $\\texttt{q}$ to exit the view. \n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\textbf{Git Branch}-$ in Git, a branch is a new/separate version of the main repository."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\textbf{New Branch}-$ to add some new features to a file called 'index.html' , we are working in our local repository, and we do not want to disturb or possibly wreck the main project. so we create a new branch.  \n",
    "\n",
    "to create a new branch called 'hello-world-images':  \n",
    "$\\qquad {\\color{green}\\texttt{git}} \\texttt{ branch hello-world-images}$  \n",
    "\n",
    "to look over all branches:  \n",
    "$\\qquad {\\color{green}\\texttt{git}} \\texttt{ branch}$  \n",
    "if you look over all branches, you will see a list of branches with '*' before the branch we are currently on.  \n",
    "\n",
    "to move to specified branch:  \n",
    "$\\qquad {\\color{green}\\texttt{git}} \\texttt{ checkout hello-world-images}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\textbf{Emergency Branch}-$ to create a new branch from Master without overwriting on a side branch that is currently being worked on:  \n",
    "$\\qquad {\\color{green}\\texttt{git}} \\texttt{ checkout -b emergency-fix}$  \n",
    "this creates a new branch from Master called 'emergency-fix', next step is to stage the file, then merge emergency-fix with Master."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\textbf{Merge Branches}-$ if your'e on emergency-fix and want to merge it to Master:  \n",
    "\n",
    "first change to the Master branch:  \n",
    "$\\qquad {\\color{green}\\texttt{git}} \\texttt{ checkout master}$  \n",
    "\n",
    "then merge current repo (master) with emergency-fix:  \n",
    "$\\qquad {\\color{green}\\texttt{git}} \\texttt{ merge emergency-fix}$  \n",
    "\n",
    "since the emergency-fix branch came directly from master, and no other changes had been made to master while we were working, Git sees this as a continuation of master. So it can \"Fast-forward\", just pointing both master and emergency-fix to the same commit."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\textbf{Delete Branch}-$ to delete 'emergency-fix' branch:  \n",
    "$\\qquad {\\color{green}\\texttt{git}} \\texttt{ branch -d emergency-fix}$  \n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\textbf{Merge Conflict}-$ remember we moved from working on 'hello-world-images' branch-- which changed Master branch-- to emergency-fix -- which fixed something on Master-- and now we want to go back to work on 'hello-world-images' branch. after we are done with 'hello-world-images' branch, we want to stage and commit, however if we changed the same file/s in both branches 'hello-world-images' and 'emergency-fix' (which was merged with Master), we have a conflict.  \n",
    "\n",
    "that is, if index.html is the file changed in both branches, and we try:  \n",
    "$\\qquad {\\color{green}\\texttt{git}} \\texttt{ checkout master} \\\\\n",
    "\\qquad {\\color{green}\\texttt{git}} \\texttt{ merge hello-world-images}$  \n",
    "\n",
    "we will get error:  \n",
    "$\\texttt{Auto-merging index.html}$  \n",
    "$\\texttt{CONFLICT (content): Merge conflict in index.html}$  \n",
    "$\\texttt{Automatic merge failed; fix conflicts and then commit the result.}$  \n",
    "\n",
    "that is, the merge failed, as there is conflict between the versions for index.html.  \n",
    "\n",
    "we can confirm this by checking ${\\color{green}\\texttt{git}} \\texttt{ status}$.  \n",
    "\n",
    "we can open our code editor and change the code to fix the conflict.  \n",
    "\n",
    "then after conflict looks fixed, we can stage the conflicted file $\\texttt{index.html}$  \n",
    "$\\qquad {\\color{green}\\texttt{git}} \\texttt{ add index.html}$  \n",
    "$\\qquad {\\color{green}\\texttt{git}} \\texttt{ status}$  \n",
    "\n",
    "and confirm that the conflict is fixed.  \n",
    "\n",
    "after that we can commit to conclude the merge:  \n",
    "$\\qquad {\\color{green}\\texttt{git}} \\texttt{ commit -m \"merged with hello-world-images after fixing conflicts\"}$  \n",
    "\n",
    "then delete 'hello-world-images' branch.  \n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## GitHub Notes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\textbf{Push Local Repo to GitHub}-$ make sure you have a local repo set up (done earlier upwards), in order to push to GitHub:  \n",
    "* get the clone HTTPS link  \n",
    "* paste in following command:  \n",
    "${\\color{green}\\texttt{git}} \\texttt{ remote add origin https://github.com/dvirzg/git-practice.git}$  \n",
    "\n",
    "$\\texttt{git remote add origin } \\it{URL}$ : specifies that you are adding a remote repository, with the specified $\\it{URL}$, as an $\\texttt{origin}$ to your local Git repo.  \n",
    "\n",
    "to then push master branch to the origin URL and set it as the default remote branch:  \n",
    "$\\qquad {\\color{green}\\texttt{git}} \\texttt{ push --set-upstream origin master}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\textbf{Git Fetch}- $ use to update locally stored tracked files.  \n",
    "\n",
    "to get all change history of a tracked branch/repo:  \n",
    "$\\qquad {\\color{green}\\texttt{git}} \\texttt{ fetch origin}$  \n",
    "\n",
    "if there has been changes on your tracked branch/repo, you would notice them on  \n",
    "$\\qquad {\\color{green}\\texttt{git}} \\texttt{ status}$  \n",
    "\n",
    "you could see the log:  \n",
    "$\\qquad {\\color{green}\\texttt{git}} \\texttt{ log origin/master}$\n",
    "\n",
    "to show the differences:  \n",
    "$\\qquad {\\color{green}\\texttt{git}} \\texttt{ diff origin/master}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\textbf{Git Merge}-$ combines the current branch with a specified branch.   \n",
    "\n",
    "to merge the changed branch/repo with our locally stored version, that is, to merge out current branch 'master' with 'origin/master':  \n",
    "$\\qquad {\\color{green}\\texttt{git}} \\texttt{ merge origin/master}$  \n",
    "\n",
    "then we can check status to confirm we are up to date:  \n",
    "$\\qquad {\\color{green}\\texttt{git}} \\texttt{ status}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\textbf{Git Pull}-$ a combination of fetch and merge, used to pull all changes from a remote repo into the branch you are working on (diferent from merging).  \n",
    "$\\qquad {\\color{green}\\texttt{git}} \\texttt{ pull origin}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\textbf{GitHub Push}-$ push changes done locally to GitHub repo.  \n",
    "\n",
    "if file is changed locally, we commit the changes, check the status, and then push:  \n",
    "$\\qquad {\\color{green}\\texttt{git}} \\texttt{ push origin}$  \n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\textbf{GitHub Branch}-$  \n",
    "\n",
    "if you create a new a branch on GitHub, to update local ls, just ${\\color{green}\\texttt{git}} \\texttt{ pull}$.  \n",
    "\n",
    "to see all local and remote branches (use '-r' instead of '-a' to check for only remote):  \n",
    "$\\qquad {\\color{green}\\texttt{git}} \\texttt{ branch -a}$  \n",
    "\n",
    "if you find a remote branch 'remotebranch' remotely that isn't stored locally, you can check it out:   \n",
    "$\\qquad {\\color{green}\\texttt{git}} \\texttt{ checkout remotebranch}$  \n",
    "\n",
    "then pull it:  \n",
    "$\\qquad {\\color{green}\\texttt{git}} \\texttt{ pull}$  \n",
    "\n",
    "and now you should have the oreviously-remote branch local, check using:  \n",
    "$\\qquad {\\color{green}\\texttt{git}} \\texttt{ branch}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\textbf{Push to GitHub}-$ to create a new local branch, and push that to GitHub.  \n",
    "\n",
    "first create a new local branch 'newbranch' :  \n",
    "$\\qquad {\\color{green}\\texttt{git}} \\texttt{ checkout -b newbranch}$  \n",
    "\n",
    "then make some changes to the files in the branch.  \n",
    "\n",
    "then check status:  \n",
    "$\\qquad {\\color{green}\\texttt{git}} \\texttt{ status}$  \n",
    "you'd find the files that were modified in there but not added to the staging environment, ex: 'file.py'.\n",
    "\n",
    "then add the modified file:  \n",
    "$\\qquad {\\color{green}\\texttt{git}} \\texttt{ add file.py}$  \n",
    "\n",
    "check status before commiting.  \n",
    "\n",
    "then commit:  \n",
    "$\\qquad {\\color{green}\\texttt{git}} \\texttt{ commit -m \"message about the new branch 'newbranch' and the changes committed\"}$   \n",
    "\n",
    "then push the branch 'newbranch' from our local Git repo to GitHub:  \n",
    "$\\qquad {\\color{green}\\texttt{git}} \\texttt{ push origin newbranch}$  \n",
    "\n",
    "that push would be visible on GitHub, where you can review the changes and merge them to the Master branch. you can use the feature \"Compare & pull request\" to go through the changes made.  \n",
    "to merge in GitHub, \"create a pull request\" (pull request is how you propose changes), and then merge the pull request.  \n",
    "\n",
    "to keep the repo from becoming polluted and overly complicated, delete the now unused branch.  \n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\textbf{The GitHub Flow}-$  \n",
    "The GitHub flow works like this:\n",
    " * Create a new Branch\n",
    " * Make changes and add Commits\n",
    " * Open a Pull Request\n",
    " * Review\n",
    " * Deploy\n",
    " * Merge\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\textbf{GitHub Fork}-$ a fork is a copy of a repository, useful when you want to contribute to a project or want to start your own porject based off theirs.  \n",
    "fork is not a command in Git, but a feature offered in GitHub and other repo hosts.  \n",
    "\n",
    "to fork a project: press the fork button. you cannot fork your own project on GitHub.\n",
    "\n",
    "to get someone else's project from GitHub to your local Git:  \n",
    " * fork on GitHub porject page\n",
    " * go to original page, and get URL to clone \n",
    " * open Git Bash and clone the repo: ${\\color{green}\\texttt{git}} \\texttt{ clone } \\it{URL}$  \n",
    " * look over local file system to confirm a new directory named after the cloned porject: $\\texttt{ ls}$\n",
    " * sideways: to specify a specific folder to clone to, add the name of the folder 'myfolder' after the repository URL: ${\\color{green}\\texttt{git}} \\texttt{ clone } \\it{URL} \\texttt{ myfolder}$\n",
    " * navigate to the new directory and check status:  \n",
    " $\\qquad {\\color{cyan}\\texttt{cd}} \\texttt{ name-from-url.github.io}$  \n",
    " $\\qquad {\\color{green}\\texttt{git}} \\texttt{ status}$  \n",
    " * check the log to confirm that the full repo data is present.  \n",
    "\n",
    "now we have a full copy of a repository, whose origin we are not allowed to make changes to."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.4 64-bit",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.4"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "4b926fbef4f16296dee587ec63e8d7863a1bca5b92838282751c68743259275e"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}