03 Tracking Changes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"body\">\n",
    "    <center>\n",
    "    <a href=\"02 Create Repository.ipynb\">  <font size=\"6\"> &lt; </font></a>\n",
    "    <a href=\"index.ipynb\">  <font size=\"6\"> Version Control with Git </font> </a>\n",
    "    <a href=\"04 Exploring History.ipynb\">  <font size=\"6\"> &gt; </font></a>\n",
    "    </center>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **Tracking Changes**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Questions**\n",
    "* How do I record changes in Git?\n",
    "\n",
    "* How do I check the status of my version control repository?\n",
    "\n",
    "* How do I record notes about what changes I made and why?\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Objectives**\n",
    "* Go through the modify-add-commit cycle for one or more files.\n",
    "\n",
    "* Explain where information is stored at each stage of that cycle.\n",
    "\n",
    "* Distinguish between descriptive and non-descriptive commit messages.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* First let’s make sure we’re still in the right directory. You should be in the `SRC` directory created in the previous step.\n",
    "\n",
    "```bash\n",
    "pwd\n",
    "\n",
    "/home/user/git_tutorial/SRC\n",
    "```\n",
    "\n",
    "If you are not in `SRC`, navigate back to it with: `cd /home/user/git_tutorial/SRC`\n",
    "\n",
    "* Let’s create a file called `keyval.py` that contains some `key:value` pair (it is a python dictionary).\n",
    "\n",
    "```bash\n",
    "touch keyval.py\n",
    "```\n",
    "* Modify its content, the file will look like:\n",
    "```python\n",
    "# istantiate a simple python dictionary\n",
    "keyvals = {'key': 'value'}\n",
    "```\n",
    "\n",
    "We’ll use the editor available in the `jupyter lab` environment. On a local machine you can, of course, edit the file with whatever editor you like (e.g. `gedit` or `nano`). In particular, this does not have to be the `core.editor` you set globally earlier. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# istantiate a simple python dictionary\n",
      "keyvals = {'key': 'value'}\n"
     ]
    }
   ],
   "source": [
    "cd SRC\n",
    "touch keyval.py\n",
    "echo \"# istantiate a simple python dictionary\" >> keyval.py\n",
    "echo \"keyvals = {'key': 'value'}\" >> keyval.py\n",
    "cat keyval.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **`git status`**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we check the status of our project again, Git tells us that it’s noticed the new file:\n",
    "\n",
    "```bash\n",
    "git status\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "On branch master\n",
      "\n",
      "No commits yet\n",
      "\n",
      "Untracked files:\n",
      "  (use \"git add <file>...\" to include in what will be committed)\n",
      "\n",
      "\t\u001b[31mkeyval.py\u001b[m\n",
      "\n",
      "nothing added to commit but untracked files present (use \"git add\" to track)\n"
     ]
    }
   ],
   "source": [
    "git status\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **`git add`**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The “untracked files” message means that there’s a file in the directory that Git isn’t keeping track of. We can tell Git to track a file using `git add`:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "On branch master\n",
      "\n",
      "No commits yet\n",
      "\n",
      "Changes to be committed:\n",
      "  (use \"git rm --cached <file>...\" to unstage)\n",
      "\n",
      "\t\u001b[32mnew file:   keyval.py\u001b[m\n",
      "\n"
     ]
    }
   ],
   "source": [
    "git add keyval.py\n",
    "git status"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **`git rm`**\n",
    "You can also remove an added file by calling ´git rm --cached filename´"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rm 'keyval.py'\n"
     ]
    }
   ],
   "source": [
    "git rm --cached keyval.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "On branch master\n",
      "\n",
      "No commits yet\n",
      "\n",
      "Untracked files:\n",
      "  (use \"git add <file>...\" to include in what will be committed)\n",
      "\n",
      "\t\u001b[31mkeyval.py\u001b[m\n",
      "\n",
      "nothing added to commit but untracked files present (use \"git add\" to track)\n"
     ]
    }
   ],
   "source": [
    "git status"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Now let's **re-add** the file, again with `git add`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "On branch master\n",
      "\n",
      "No commits yet\n",
      "\n",
      "Changes to be committed:\n",
      "  (use \"git rm --cached <file>...\" to unstage)\n",
      "\n",
      "\t\u001b[32mnew file:   keyval.py\u001b[m\n",
      "\n"
     ]
    }
   ],
   "source": [
    "git add keyval.py\n",
    "git status"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **`git commit`**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Git now knows that it’s supposed to keep track of `keyvalue.py`, but it hasn’t recorded these changes as a commit yet. To get it to do that, we need to run one more command:\n",
    "\n",
    "```bash\n",
    "git commit -m \"Start notes on Mars as a base\"\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[master (root-commit) 0e03267] Adding a simple python dictionary\n",
      " 1 file changed, 2 insertions(+)\n",
      " create mode 100644 keyval.py\n"
     ]
    }
   ],
   "source": [
    "git commit -m \"Adding a simple python dictionary\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&nbsp;\n",
    "\n",
    "When we run `git commit`, Git takes everything we have told it to save by using `git add` and stores a copy permanently inside the special `.git` directory. This permanent copy is called a [commit](https://swcarpentry.github.io/reference.html#commit) (or [revision](https://swcarpentry.github.io/reference.html#revision)) and its short identifier is `e6580eb`. Your commit may have another identifier.\n",
    "\n",
    "\n",
    "We use the `-m` flag (for “message”) to record a short, descriptive, and specific comment that will help us remember later on what we did and why. If we just run `git commit` without the `-m` option, Git will launch nano (or whatever other editor we configured as core.editor) so that we can write a longer message.\n",
    "\n",
    "[Good commit messages](https://chris.beams.io/posts/git-commit/) start with a brief (<50 characters) statement about the changes made in the commit. Generally, the message should complete the sentence “If applied, this commit will” . If you want to go into more detail, add a blank line between the summary line and your additional notes. Use this additional space to explain why you made changes and/or what their impact will be.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **`git log`**\n",
    "\n",
    "If we run `git status` now:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "On branch master\n",
      "nothing to commit, working tree clean\n"
     ]
    }
   ],
   "source": [
    "git status"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "it tells us everything is up to date. If we want to know what we’ve done recently, we can ask Git to show us the project’s history using `git log`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[33mcommit 0e03267e6c93f71cdd019ec1d2470d6b59ec67a2\u001b[m\u001b[33m (\u001b[m\u001b[1;36mHEAD -> \u001b[m\u001b[1;32mmaster\u001b[m\u001b[33m)\u001b[m\n",
      "Author: Massimo Di Stefano <epiesasha@me.com>\n",
      "Date:   Sun Jun 16 22:06:13 2019 +0200\n",
      "\n",
      "    Adding a simple python dictionary\n"
     ]
    }
   ],
   "source": [
    "git log"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&nbsp;\n",
    "\n",
    "`git log` lists all commits made to a repository in reverse chronological order. The listing for each commit includes the commit’s full identifier (which starts with the same characters as the short identifier printed by the `git commit` command earlier), the commit’s author, when it was created, and the log message Git was given when the commit was created."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **`git diff`**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# istantiate a simple python dictionary\n",
      "keyvals = {'key': 'value'}\n"
     ]
    }
   ],
   "source": [
    "cat keyval.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&nbsp;\n",
    "    \n",
    "* let's now modify the content of the file so that it looks like:\n",
    "\n",
    "```python\n",
    "# istantiate a simple python dictionary\n",
    "keyvals = {'key1': 'value1',\n",
    "           'key2': 'value2'}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "When we run `git status` now, it tells us that a file it already knows about has been modified:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Open the file keyval.py for editing and apply the changes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "On branch master\n",
      "Changes not staged for commit:\n",
      "  (use \"git add <file>...\" to update what will be committed)\n",
      "  (use \"git checkout -- <file>...\" to discard changes in working directory)\n",
      "\n",
      "\t\u001b[31mmodified:   keyval.py\u001b[m\n",
      "\n",
      "Untracked files:\n",
      "  (use \"git add <file>...\" to include in what will be committed)\n",
      "\n",
      "\t\u001b[31m.ipynb_checkpoints/\u001b[m\n",
      "\n",
      "no changes added to commit (use \"git add\" and/or \"git commit -a\")\n"
     ]
    }
   ],
   "source": [
    "git status"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&nbsp;\n",
    "\n",
    "The last line is the key phrase: “no changes added to commit”. We have changed this file, but we haven’t told Git we will want to save those changes (which we do with `git add`) nor have we saved them (which we do with `git commit`). So let’s do that now. It is good practice to always review our changes before saving them. We do this using `git diff`. This shows us the differences between the current state of the file and the most recently saved version:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mdiff --git a/keyval.py b/keyval.py\u001b[m\n",
      "\u001b[1mindex def0459..80b4ff6 100644\u001b[m\n",
      "\u001b[1m--- a/keyval.py\u001b[m\n",
      "\u001b[1m+++ b/keyval.py\u001b[m\n",
      "\u001b[36m@@ -1,2 +1,4 @@\u001b[m\n",
      " # istantiate a simple python dictionary\u001b[m\n",
      "\u001b[31m-keyvals = {'key': 'value'}\u001b[m\n",
      "\u001b[32m+\u001b[m\u001b[32mkeyvals = {'key1': 'value1',\u001b[m\n",
      "\u001b[32m+\u001b[m\u001b[32m           'key2': 'value2'}\u001b[m\n",
      "\u001b[41m+\u001b[m\n"
     ]
    }
   ],
   "source": [
    "git diff"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&nbsp;\n",
    "\n",
    "The output is cryptic because it is actually a series of commands for tools like editors and `patch` telling them how to reconstruct one file given the other. If we break it down into pieces:\n",
    "\n",
    "1. The first line tells us that Git is producing output similar to the Unix `diff` command comparing the old and new versions of the file.\n",
    "2. The second line tells exactly which versions of the file Git is comparing; it uses unique computer-generated labels for those versions.\n",
    "3. The third and fourth lines once again show the name of the file being changed.\n",
    "4. The remaining lines are the most interesting, they show us the actual differences and the lines on which they occur. In particular, the `+/-` markers in the first column shows where we *added / removed* a line."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After reviewing our change, it’s time to commit it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "On branch master\n",
      "Changes not staged for commit:\n",
      "\t\u001b[31mmodified:   keyval.py\u001b[m\n",
      "\n",
      "Untracked files:\n",
      "\t\u001b[31m.ipynb_checkpoints/\u001b[m\n",
      "\n",
      "no changes added to commit\n",
      "On branch master\n",
      "Changes not staged for commit:\n",
      "  (use \"git add <file>...\" to update what will be committed)\n",
      "  (use \"git checkout -- <file>...\" to discard changes in working directory)\n",
      "\n",
      "\t\u001b[31mmodified:   keyval.py\u001b[m\n",
      "\n",
      "Untracked files:\n",
      "  (use \"git add <file>...\" to include in what will be committed)\n",
      "\n",
      "\t\u001b[31m.ipynb_checkpoints/\u001b[m\n",
      "\n",
      "no changes added to commit (use \"git add\" and/or \"git commit -a\")\n"
     ]
    }
   ],
   "source": [
    "git commit -m \"Added new key:value pair in keyval.py\"\n",
    "git status"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Whoops**: Git **won’t commit** because we didn’t use `git add` first. Let’s fix that:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[master 8668044] Added new key:value pair in keyval.py\n",
      " 1 file changed, 3 insertions(+), 1 deletion(-)\n"
     ]
    }
   ],
   "source": [
    "git add keyval.py\n",
    "git commit  -m \"Added new key:value pair in keyval.py\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Git insists that we add files to the set we want to commit before actually committing anything. This allows us to commit our changes in stages and capture changes in logical portions rather than only large batches. For example, suppose we’re adding a few citations to relevant research to our thesis. We might want to commit those additions, and the corresponding bibliography entries, but not commit some of our work drafting the conclusion (which we haven’t finished yet).\n",
    "\n",
    "To allow for this, Git has a special staging area where it keeps track of things that have been added to the current [changeset](https://swcarpentry.github.io/reference.html#changeset) but not yet committed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**More:** you notice that by running in a `jupyter notebook` environment you will probably end up in the situation where `git` wants to keep track of the `.ipynb_checkpoints/` hidden directory (used internaly by jypyter).\n",
    "This is the right use case for using a `.gitignore` file. Just put the following line (including the trailing slash) in a `.gitignore` file in the main directory of the Git repository. If you want only ignore all the files of a spectific directory, add a `.gitignore` file in such directory and add a line with `*` in it.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<blockquote class=\"callout\">\n",
    "  <h2 id=\"staging-area\">Staging Area</h2>\n",
    "\n",
    "  <p>If you think of Git as taking snapshots of changes over the life of a project,\n",
    "<code class=\"highlighter-rouge\">git add</code> specifies <em>what</em> will go in a snapshot\n",
    "(putting things in the staging area),\n",
    "and <code class=\"highlighter-rouge\">git commit</code> then <em>actually takes</em> the snapshot, and\n",
    "makes a permanent record of it (as a commit).\n",
    "If you don’t have anything staged when you type <code class=\"highlighter-rouge\">git commit</code>,\n",
    "Git will prompt you to use <code class=\"highlighter-rouge\">git commit -a</code> or <code class=\"highlighter-rouge\">git commit --all</code>,\n",
    "which is kind of like gathering <em>everyone</em> for the picture!\n",
    "However, it’s almost always better to\n",
    "explicitly add things to the staging area, because you might\n",
    "commit changes you forgot you made. (Going back to snapshots,\n",
    "you might get the extra with incomplete makeup walking on\n",
    "the stage for the snapshot because you used <code class=\"highlighter-rouge\">-a</code>!)\n",
    "Try to stage things manually,\n",
    "or you might find yourself searching for “git undo commit” more\n",
    "than you would like!</p>\n",
    "</blockquote>\n",
    "<center><img src=\"static/images/git-staging-area.svg\"></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let’s watch as our changes to a file move from our editor to the staging area and into long-term storage. First, we’ll add another `key:value` pair to the `keyval.py` file, so that it will ook like:\n",
    "\n",
    "```python\n",
    "# istantiate a simple python dictionary\n",
    "keyvals = {'key1': 'value1',\n",
    "           'key2': 'value2',\n",
    "           'key3': 'value3'}\n",
    "```\n",
    "And then check the `diff` log with:\n",
    "\n",
    "```bash\n",
    "git diff\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Open the file keyval.py for editing and apply the changes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# istantiate a simple python dictionary\n",
      "keyvals = {'key1': 'value1',\n",
      "           'key2': 'value2',\n",
      "           'key3': 'value3'}\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "cat keyval.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mdiff --git a/keyval.py b/keyval.py\u001b[m\n",
      "\u001b[1mindex 80b4ff6..7c4fde4 100644\u001b[m\n",
      "\u001b[1m--- a/keyval.py\u001b[m\n",
      "\u001b[1m+++ b/keyval.py\u001b[m\n",
      "\u001b[36m@@ -1,4 +1,6 @@\u001b[m\n",
      " # istantiate a simple python dictionary\u001b[m\n",
      " keyvals = {'key1': 'value1',\u001b[m\n",
      "\u001b[31m-           'key2': 'value2'}\u001b[m\n",
      "\u001b[32m+\u001b[m\u001b[32m           'key2': 'value2',\u001b[m\n",
      "\u001b[32m+\u001b[m\u001b[32m           'key3': 'value3'}\u001b[m\n",
      "\u001b[41m+\u001b[m\n",
      " \u001b[m\n"
     ]
    }
   ],
   "source": [
    "git diff"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>So far, so good:\n",
    "we’ve added one line to the end of the file\n",
    "(shown with a <code class=\"highlighter-rouge\">+</code> in the first column).\n",
    "Now let’s put that change in the staging area\n",
    "and see what <code class=\"highlighter-rouge\">git diff</code> reports:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "git add keyval.py\n",
    "git diff"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>There is no output:\n",
    "as far as Git can tell,\n",
    "there’s no difference between what it’s been asked to save permanently\n",
    "and what’s currently in the directory.\n",
    "However,\n",
    "if we do this:</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1mdiff --git a/keyval.py b/keyval.py\u001b[m\n",
      "\u001b[1mindex 80b4ff6..7c4fde4 100644\u001b[m\n",
      "\u001b[1m--- a/keyval.py\u001b[m\n",
      "\u001b[1m+++ b/keyval.py\u001b[m\n",
      "\u001b[36m@@ -1,4 +1,6 @@\u001b[m\n",
      " # istantiate a simple python dictionary\u001b[m\n",
      " keyvals = {'key1': 'value1',\u001b[m\n",
      "\u001b[31m-           'key2': 'value2'}\u001b[m\n",
      "\u001b[32m+\u001b[m\u001b[32m           'key2': 'value2',\u001b[m\n",
      "\u001b[32m+\u001b[m\u001b[32m           'key3': 'value3'}\u001b[m\n",
      "\u001b[41m+\u001b[m\n",
      " \u001b[m\n"
     ]
    }
   ],
   "source": [
    "git diff --staged"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "it shows us the difference between the last committed change and what’s in the staging area. Let’s save our changes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[master 55fa2a9] Adding a third key:value pair to the dictionary\n",
      " 1 file changed, 3 insertions(+), 1 deletion(-)\n"
     ]
    }
   ],
   "source": [
    "git commit -m \"Adding a third key:value pair to the dictionary\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "check our status:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "On branch master\n",
      "Untracked files:\n",
      "  (use \"git add <file>...\" to include in what will be committed)\n",
      "\n",
      "\t\u001b[31m.ipynb_checkpoints/\u001b[m\n",
      "\n",
      "nothing added to commit but untracked files present (use \"git add\" to track)\n"
     ]
    }
   ],
   "source": [
    "git status"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and look at the history of what we’ve done so far:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[33mcommit 55fa2a94d2370199fe5a7961a392d68c14f96537\u001b[m\u001b[33m (\u001b[m\u001b[1;36mHEAD -> \u001b[m\u001b[1;32mmaster\u001b[m\u001b[33m)\u001b[m\n",
      "Author: Massimo Di Stefano <epiesasha@me.com>\n",
      "Date:   Sun Jun 16 22:09:08 2019 +0200\n",
      "\n",
      "    Adding a third key:value pair to the dictionary\n",
      "\n",
      "\u001b[33mcommit 8668044d555f68b56471f601e60520f7af1a3976\u001b[m\n",
      "Author: Massimo Di Stefano <epiesasha@me.com>\n",
      "Date:   Sun Jun 16 22:07:43 2019 +0200\n",
      "\n",
      "    Added new key:value pair in keyval.py\n",
      "\n",
      "\u001b[33mcommit 0e03267e6c93f71cdd019ec1d2470d6b59ec67a2\u001b[m\n",
      "Author: Massimo Di Stefano <epiesasha@me.com>\n",
      "Date:   Sun Jun 16 22:06:13 2019 +0200\n",
      "\n",
      "    Adding a simple python dictionary\n"
     ]
    }
   ],
   "source": [
    " git log"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<blockquote class=\"callout\">\n",
    "  <h2 id=\"word-based-diffing\">Word-based diffing</h2>\n",
    "\n",
    "  <p>Sometimes, e.g. in the case of the text documents a line-wise\n",
    "diff is too coarse. That is where the <code class=\"highlighter-rouge\">--color-words</code> option of\n",
    "<code class=\"highlighter-rouge\">git diff</code> comes in very useful as it highlights the changed\n",
    "words using colors.</p>\n",
    "</blockquote>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<blockquote class=\"callout\">\n",
    "  <h2 id=\"paging-the-log\">Paging the Log</h2>\n",
    "\n",
    "  <p>When the output of <code class=\"highlighter-rouge\">git log</code> is too long to fit in your screen,\n",
    "<code class=\"highlighter-rouge\">git</code> uses a program to split it into pages of the size of your screen.\n",
    "When this “pager” is called, you will notice that the last line in your\n",
    "screen is a <code class=\"highlighter-rouge\">:</code>, instead of your usual prompt.</p>\n",
    "\n",
    "  <ul>\n",
    "    <li>To get out of the pager, press <kbd>Q</kbd>.</li>\n",
    "    <li>To move to the next page, press <kbd>Spacebar</kbd>.</li>\n",
    "    <li>To search for <code class=\"highlighter-rouge\">some_word</code> in all pages,\n",
    "press <kbd>/</kbd>\n",
    "and type <code class=\"highlighter-rouge\">some_word</code>.\n",
    "Navigate through matches pressing <kbd>N</kbd>.</li>\n",
    "  </ul>\n",
    "</blockquote>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<blockquote class=\"callout\">\n",
    "  <h2 id=\"limit-log-size\">Limit Log Size</h2>\n",
    "\n",
    "  <p>To avoid having <code class=\"highlighter-rouge\">git log</code> cover your entire terminal screen, you can limit the\n",
    "number of commits that Git lists by using <code class=\"highlighter-rouge\">-N</code>, where <code class=\"highlighter-rouge\">N</code> is the number of\n",
    "commits that you want to view. For example, if you only want information from\n",
    "the last commit you can use:</p>\n",
    "\n",
    "  ```bash\n",
    "  git log -1\n",
    "  ```\n",
    "    \n",
    "  <p>You can also reduce the quantity of information using the\n",
    "\n",
    "  ```bash      \n",
    "  git log --oneline\n",
    "  ```\n",
    "\n",
    "  <p>You can also combine the <code class=\"highlighter-rouge\">--oneline</code> options with others. One useful\n",
    "combination is:</p>\n",
    "\n",
    "  ```bash\n",
    "  git log --oneline --graph --all --decorate\n",
    "  ```\n",
    "</blockquote>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<blockquote class=\"callout\">\n",
    "  <h2 id=\"directories\">Directories</h2>\n",
    "\n",
    "Two important facts you should know about directories in Git.\n",
    "\n",
    "* Git does not track directories on their own, only files within them.\n",
    "* Git does not track directories on their own, only files within them. (e.g. empty directories). See `.gitkeep` and `.gitignore`.\n",
    "* If you create a directory in your Git repository and populate it with files,\n",
    "you can add all files in the directory at once by:\n",
    "    \n",
    "  ```bash\n",
    "   git add <directory-with-files>\n",
    "  ```\n",
    "\n",
    "</blockquote>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Before moving on, we will make sure we commit the last changes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "On branch master\n",
      "Untracked files:\n",
      "\t\u001b[31m.ipynb_checkpoints/\u001b[m\n",
      "\n",
      "nothing added to commit but untracked files present\n"
     ]
    },
    {
     "ename": "",
     "evalue": "1",
     "execution_count": 23,
     "output_type": "error",
     "traceback": []
    }
   ],
   "source": [
    "git commit -m \"Adding a third key:value pair to the dictionary\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "&nbsp;\n",
    "\n",
    "To recap, when we want to add changes to our repository, we first need to add the changed files to the staging area (git add) and then commit the staged changes to the repository (git commit):\n",
    "\n",
    "<center><img src=\"static/images/git-committing.svg\"></center>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<blockquote class=\"keypoints\">\n",
    "  <h2>Key Points</h2>\n",
    "\n",
    "* `git status` shows the status of a repository.\n",
    "\n",
    "* Files can be stored in a project’s working directory (which users see), the staging area (where the next commit is being built up) and the local repository (where commits are permanently recorded).\n",
    "\n",
    "* `git add` puts files in the staging area.\n",
    "\n",
    "* `git commit` saves the staged content as a new commit in the local repository.\n",
    "\n",
    "* Write a commit message that accurately describes your changes.\n",
    "</blockquote>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<blockquote class=\"Note\">\n",
    "  <h2>Note</h2>\n",
    "\n",
    "* When issuing `git status` to show the status of a repository, you will notice the presence of an untracked hidden directory:\n",
    "\n",
    "&nbsp;\n",
    "    \n",
    "```bash\n",
    "    Untracked files:\n",
    "  (use \"git add <file>...\" to include in what will be committed)\n",
    "\n",
    "    .ipynb_checkpoints/\n",
    "```\n",
    "    \n",
    "&nbsp;\n",
    "    \n",
    "The `.ipynb_checkpoints/` is automatically generated by the hypyter notebook and we do not want it in our Git repository. How to ignore specific files and pr directory is shown in <a href=\"05 Ignore Things.ipynb\"> 05 Ignore Things</a>\n",
    "</blockquote>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"body\">\n",
    "    <center>\n",
    "    <a href=\"02 Create Repository.ipynb\">  <font size=\"4\"> &lt; </font></a>\n",
    "    <a href=\"index.ipynb\">  <font size=\"4\"> Version Control with Git </font> </a>\n",
    "    <a href=\"04 Exploring History.ipynb\">  <font size=\"4\"> &gt; </font></a>\n",
    "    </center>\n",
    "</div>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Bash",
   "language": "bash",
   "name": "bash"
  },
  "language_info": {
   "codemirror_mode": "shell",
   "file_extension": ".sh",
   "mimetype": "text/x-sh",
   "name": "bash"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}