gitgym 0.1.0__tar.gz

gitgym-0.1.0/.gitignore

@@ -0,0 +1,29 @@
+# Python
+__pycache__/
+*.pyc
+*.pyo
+.pytest_cache/
+.venv/
+*.egg-info/
+
+# Node.js
+node_modules/
+dist/
+*.tsbuildinfo
+
+# Test coverage
+coverage/
+
+# Environment
+.env
+.env.local
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Claude Code workflow
+prompt.md
+specs/
+run_loop.sh
+logs/

gitgym-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aaron Marquez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

gitgym-0.1.0/PKG-INFO

@@ -0,0 +1,140 @@
+Metadata-Version: 2.4
+Name: gitgym
+Version: 0.1.0
+Summary: An interactive CLI platform for learning git, inspired by Rustlings.
+Project-URL: Homepage, https://github.com/enerrio/git-gym
+Project-URL: Repository, https://github.com/enerrio/git-gym
+Project-URL: Issues, https://github.com/enerrio/git-gym/issues
+Project-URL: Changelog, https://github.com/enerrio/git-gym/blob/main/CHANGELOG.md
+Author: enerrio
+License-Expression: MIT
+License-File: LICENSE
+Keywords: cli,education,exercises,git,learning,tutorial
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Education
+Classifier: Topic :: Software Development :: Version Control :: Git
+Requires-Python: >=3.12
+Requires-Dist: click
+Provides-Extra: watch
+Requires-Dist: watchdog; extra == 'watch'
+Description-Content-Type: text/markdown
+
+# gitgym
+
+[![PyPI version](https://img.shields.io/pypi/v/gitgym)](https://pypi.org/project/gitgym/)
+[![Python](https://img.shields.io/pypi/pyversions/gitgym)](https://pypi.org/project/gitgym/)
+[![CI](https://github.com/enerrio/gitgym/actions/workflows/ci.yml/badge.svg)](https://github.com/enerrio/gitgym/actions/workflows/ci.yml)
+
+An interactive CLI for learning git through hands-on exercises, inspired by [Rustlings](https://github.com/rust-lang/rustlings). No quizzes — you practice real git commands in real repositories inside a safe, sandboxed workspace.
+
+## Installation
+
+```bash
+pip install gitgym
+```
+
+Or with [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv tool install gitgym
+```
+
+**Requirements:** Python 3.12+ and git. macOS and Linux only (Windows is not currently supported).
+
+## Quick Start
+
+```bash
+gitgym list              # see all 32 exercises
+gitgym next              # set up the next exercise
+cd ~/.gitgym/exercises/01_basics/01_init   # cd into the printed path
+# ... run git commands to solve the exercise ...
+gitgym verify            # check your work
+```
+
+## Recommended Setup
+
+Open **two terminal windows** (or tabs) side by side:
+
+| Terminal 1 (work)                       | Terminal 2 (control)              |
+| --------------------------------------- | --------------------------------- |
+| `cd` into the exercise directory        | `gitgym describe` — read the goal |
+| Run git commands to solve the exercise  | `gitgym hint` — get a hint        |
+| Edit files, stage, commit, branch, etc. | `gitgym verify` — check your work |
+|                                         | `gitgym watch` — live feedback    |
+
+This keeps your git work separate from the gitgym CLI, just like a real workflow.
+
+## Commands
+
+| Command                   | Description                                                |
+| ------------------------- | ---------------------------------------------------------- |
+| `gitgym list`             | List all exercises grouped by topic with completion status |
+| `gitgym start [exercise]` | Set up an exercise (defaults to next incomplete)           |
+| `gitgym next`             | Alias for `gitgym start` with no argument                  |
+| `gitgym describe`         | Print the current exercise's description and goal          |
+| `gitgym verify`           | Check if the current exercise's goal state is met          |
+| `gitgym watch`            | Auto re-verify on changes (Ctrl+C to stop)                 |
+| `gitgym hint`             | Show the next progressive hint                             |
+| `gitgym reset [exercise]` | Reset an exercise to its initial state                     |
+| `gitgym reset --all`      | Reset all exercises and clear progress                     |
+| `gitgym progress`         | Show overall progress summary                              |
+| `gitgym clean`            | Remove all gitgym data from your system                    |
+
+Exercise names are shown in `gitgym list` (e.g. `init`, `staging`, `amend`). Use these names with `gitgym start` and `gitgym reset`.
+
+## Exercises
+
+32 exercises across 9 topics, from beginner to advanced:
+
+| Topic               | Exercises                                              |
+| ------------------- | ------------------------------------------------------ |
+| **Basics**          | init, staging, status, first_commit, gitignore         |
+| **Committing**      | amend, multi_commit, diff                              |
+| **Branching**       | create_branch, switch_branches, delete_branch          |
+| **Merging**         | fast_forward, three_way_merge, merge_conflict          |
+| **History**         | log_basics, log_graph, blame, show                     |
+| **Undoing Changes** | restore_file, unstage, revert, reset_soft, reset_mixed |
+| **Rebase**          | basic_rebase, interactive_rebase, rebase_conflict      |
+| **Stashing**        | stash_basics, stash_pop_apply                          |
+| **Advanced**        | cherry_pick, bisect, tags, aliases                     |
+
+## Features
+
+**Progressive hints** — Each exercise has multiple hints revealed one at a time:
+
+```
+$ gitgym hint
+Hint 1/3: Look at the `git init` command.
+
+$ gitgym hint
+Hint 2/3: Run `git init` inside the exercise directory.
+```
+
+**Watch mode** — `gitgym watch` polls the exercise directory and re-verifies automatically whenever you make changes. No need to switch terminals to run verify.
+
+**Progress tracking** — Your progress is saved locally in `~/.gitgym/progress.json`. Close your terminal and pick up where you left off. Run `gitgym progress` to see a per-topic breakdown.
+
+**Cleanup** — When you're done, run `gitgym clean` to remove all exercise data from your system.
+
+## Platform Support
+
+gitgym works on **macOS** and **Linux**. Windows is not currently supported because exercises use bash shell scripts. Windows users can use [WSL](https://learn.microsoft.com/en-us/windows/wsl/install) as a workaround.
+
+## Contributing
+
+Exercises follow a simple structure — each one is a directory with three files:
+
+- `exercise.toml` — metadata, description, goal, and hints
+- `setup.sh` — creates the initial repo state
+- `verify.sh` — checks if the goal is met (exit 0 = pass)
+
+See the `exercises/` directory for examples.

gitgym-0.1.0/README.md

@@ -0,0 +1,110 @@
+# gitgym
+
+[![PyPI version](https://img.shields.io/pypi/v/gitgym)](https://pypi.org/project/gitgym/)
+[![Python](https://img.shields.io/pypi/pyversions/gitgym)](https://pypi.org/project/gitgym/)
+[![CI](https://github.com/enerrio/gitgym/actions/workflows/ci.yml/badge.svg)](https://github.com/enerrio/gitgym/actions/workflows/ci.yml)
+
+An interactive CLI for learning git through hands-on exercises, inspired by [Rustlings](https://github.com/rust-lang/rustlings). No quizzes — you practice real git commands in real repositories inside a safe, sandboxed workspace.
+
+## Installation
+
+```bash
+pip install gitgym
+```
+
+Or with [uv](https://docs.astral.sh/uv/):
+
+```bash
+uv tool install gitgym
+```
+
+**Requirements:** Python 3.12+ and git. macOS and Linux only (Windows is not currently supported).
+
+## Quick Start
+
+```bash
+gitgym list              # see all 32 exercises
+gitgym next              # set up the next exercise
+cd ~/.gitgym/exercises/01_basics/01_init   # cd into the printed path
+# ... run git commands to solve the exercise ...
+gitgym verify            # check your work
+```
+
+## Recommended Setup
+
+Open **two terminal windows** (or tabs) side by side:
+
+| Terminal 1 (work)                       | Terminal 2 (control)              |
+| --------------------------------------- | --------------------------------- |
+| `cd` into the exercise directory        | `gitgym describe` — read the goal |
+| Run git commands to solve the exercise  | `gitgym hint` — get a hint        |
+| Edit files, stage, commit, branch, etc. | `gitgym verify` — check your work |
+|                                         | `gitgym watch` — live feedback    |
+
+This keeps your git work separate from the gitgym CLI, just like a real workflow.
+
+## Commands
+
+| Command                   | Description                                                |
+| ------------------------- | ---------------------------------------------------------- |
+| `gitgym list`             | List all exercises grouped by topic with completion status |
+| `gitgym start [exercise]` | Set up an exercise (defaults to next incomplete)           |
+| `gitgym next`             | Alias for `gitgym start` with no argument                  |
+| `gitgym describe`         | Print the current exercise's description and goal          |
+| `gitgym verify`           | Check if the current exercise's goal state is met          |
+| `gitgym watch`            | Auto re-verify on changes (Ctrl+C to stop)                 |
+| `gitgym hint`             | Show the next progressive hint                             |
+| `gitgym reset [exercise]` | Reset an exercise to its initial state                     |
+| `gitgym reset --all`      | Reset all exercises and clear progress                     |
+| `gitgym progress`         | Show overall progress summary                              |
+| `gitgym clean`            | Remove all gitgym data from your system                    |
+
+Exercise names are shown in `gitgym list` (e.g. `init`, `staging`, `amend`). Use these names with `gitgym start` and `gitgym reset`.
+
+## Exercises
+
+32 exercises across 9 topics, from beginner to advanced:
+
+| Topic               | Exercises                                              |
+| ------------------- | ------------------------------------------------------ |
+| **Basics**          | init, staging, status, first_commit, gitignore         |
+| **Committing**      | amend, multi_commit, diff                              |
+| **Branching**       | create_branch, switch_branches, delete_branch          |
+| **Merging**         | fast_forward, three_way_merge, merge_conflict          |
+| **History**         | log_basics, log_graph, blame, show                     |
+| **Undoing Changes** | restore_file, unstage, revert, reset_soft, reset_mixed |
+| **Rebase**          | basic_rebase, interactive_rebase, rebase_conflict      |
+| **Stashing**        | stash_basics, stash_pop_apply                          |
+| **Advanced**        | cherry_pick, bisect, tags, aliases                     |
+
+## Features
+
+**Progressive hints** — Each exercise has multiple hints revealed one at a time:
+
+```
+$ gitgym hint
+Hint 1/3: Look at the `git init` command.
+
+$ gitgym hint
+Hint 2/3: Run `git init` inside the exercise directory.
+```
+
+**Watch mode** — `gitgym watch` polls the exercise directory and re-verifies automatically whenever you make changes. No need to switch terminals to run verify.
+
+**Progress tracking** — Your progress is saved locally in `~/.gitgym/progress.json`. Close your terminal and pick up where you left off. Run `gitgym progress` to see a per-topic breakdown.
+
+**Cleanup** — When you're done, run `gitgym clean` to remove all exercise data from your system.
+
+## Platform Support
+
+gitgym works on **macOS** and **Linux**. Windows is not currently supported because exercises use bash shell scripts. Windows users can use [WSL](https://learn.microsoft.com/en-us/windows/wsl/install) as a workaround.
+
+## Contributing
+
+Exercises follow a simple structure — each one is a directory with three files:
+
+- `exercise.toml` — metadata, description, goal, and hints
+- `setup.sh` — creates the initial repo state
+- `verify.sh` — checks if the goal is met (exit 0 = pass)
+
+See the `exercises/` directory for examples.

gitgym-0.1.0/exercises/01_basics/01_init/exercise.toml

@@ -0,0 +1,20 @@
+[exercise]
+name = "init"
+topic = "Basics"
+title = "Initialize a Repository"
+description = """
+Every git journey starts with `git init`. In this exercise, you'll \
+initialize a new git repository in the provided directory.
+"""
+
+[goal]
+summary = "The directory should be a valid git repository."
+
+[[hints]]
+text = "Look at the `git init` command."
+
+[[hints]]
+text = "Run `git init` inside the exercise directory."
+
+[[hints]]
+text = "Just run: git init"

gitgym-0.1.0/exercises/01_basics/01_init/setup.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+EXERCISE_DIR="$1"
+mkdir -p "$EXERCISE_DIR"
+cd "$EXERCISE_DIR"
+
+# Remove any existing git repo so the exercise is in the expected initial state
+# (idempotent: running setup.sh a second time resets back to pre-init state)
+if [ -d ".git" ]; then
+	rm -rf .git
+fi
+
+# Create a file for the user to work with
+echo "Hello, git!" >hello.txt

gitgym-0.1.0/exercises/01_basics/01_init/verify.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+EXERCISE_DIR="$1"
+cd "$EXERCISE_DIR"
+
+# Check that it's a git repo
+if [ ! -d ".git" ]; then
+	echo "This directory is not a git repository yet."
+	echo "Use 'git init' to initialize it."
+	exit 1
+fi
+
+echo "Great job! You initialized a git repository."
+exit 0

gitgym-0.1.0/exercises/01_basics/02_staging/exercise.toml

@@ -0,0 +1,21 @@
+[exercise]
+name = "staging"
+topic = "Basics"
+title = "Stage a File"
+description = """
+Before git can track a file, you need to stage it with `git add`. \
+In this exercise, a file called `hello.txt` exists in the repo but \
+has not been staged yet. Stage it so git will include it in the next commit.
+"""
+
+[goal]
+summary = "hello.txt should be staged (in the index)."
+
+[[hints]]
+text = "Use `git status` to see the current state of the repository."
+
+[[hints]]
+text = "Look at the `git add` command."
+
+[[hints]]
+text = "Run `git add hello.txt` to stage the file."

gitgym-0.1.0/exercises/01_basics/02_staging/setup.sh

@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+EXERCISE_DIR="$1"
+mkdir -p "$EXERCISE_DIR"
+cd "$EXERCISE_DIR"
+
+# Initialize a fresh git repo (idempotent: remove any existing one first)
+if [ -d ".git" ]; then
+	rm -rf .git
+fi
+
+git init --initial-branch=main
+git config user.email "gitgym@example.com"
+git config user.name "Git Gym"
+
+# Create an untracked file for the user to stage
+echo "Hello, git!" >hello.txt

gitgym-0.1.0/exercises/01_basics/02_staging/verify.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+EXERCISE_DIR="$1"
+cd "$EXERCISE_DIR"
+
+# Check that hello.txt is staged (present in the index)
+if ! git diff --cached --name-only | grep -qx "hello.txt"; then
+	echo "hello.txt is not staged yet."
+	echo "Use 'git add hello.txt' to stage it."
+	exit 1
+fi
+
+echo "Great job! hello.txt is staged and ready to commit."
+exit 0

gitgym-0.1.0/exercises/01_basics/03_status/exercise.toml

@@ -0,0 +1,28 @@
+[exercise]
+name = "status"
+topic = "Basics"
+title = "Interpret git status"
+description = """
+`git status` shows you exactly what is staged, what is modified, and what \
+is untracked. In this exercise the repo already has some files committed. \
+Three new files have been added:
+
+  - `feature.txt`  — a new file that should be staged
+  - `notes.txt`    — a new file that should NOT be staged
+  - `readme.txt`   — a previously committed file that has been modified
+
+Your task: stage `feature.txt` and the modified `readme.txt`, but leave \
+`notes.txt` untracked.
+"""
+
+[goal]
+summary = "feature.txt and the modified readme.txt are staged; notes.txt is not."
+
+[[hints]]
+text = "Run `git status` to see the current state of all files."
+
+[[hints]]
+text = "Use `git add <file>` to stage a specific file."
+
+[[hints]]
+text = "Stage both files: `git add feature.txt readme.txt`"

gitgym-0.1.0/exercises/01_basics/03_status/setup.sh

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+EXERCISE_DIR="$1"
+mkdir -p "$EXERCISE_DIR"
+cd "$EXERCISE_DIR"
+
+# Start fresh (idempotent)
+if [ -d ".git" ]; then
+	rm -rf .git
+fi
+
+git init --initial-branch=main
+git config user.email "gitgym@example.com"
+git config user.name "Git Gym"
+
+# Create and commit an initial file so readme.txt has a committed version
+echo "# My Project" >readme.txt
+git add readme.txt
+git commit -m "Initial commit"
+
+# Modify the committed file (now it appears as "modified" in git status)
+echo "# My Project (updated)" >readme.txt
+
+# Add two new untracked files — user must stage only feature.txt
+echo "New feature content" >feature.txt
+echo "Private notes" >notes.txt

gitgym-0.1.0/exercises/01_basics/03_status/verify.sh

@@ -0,0 +1,35 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+EXERCISE_DIR="$1"
+cd "$EXERCISE_DIR"
+
+STAGED=$(git diff --cached --name-only)
+PASS=1
+
+# feature.txt must be staged
+if ! echo "$STAGED" | grep -qx "feature.txt"; then
+	echo "feature.txt is not staged yet."
+	echo "Use 'git add feature.txt' to stage it."
+	PASS=0
+fi
+
+# readme.txt (modified) must be staged
+if ! echo "$STAGED" | grep -qx "readme.txt"; then
+	echo "readme.txt is not staged yet."
+	echo "Use 'git add readme.txt' to stage the modified version."
+	PASS=0
+fi
+
+# notes.txt must NOT be staged
+if echo "$STAGED" | grep -qx "notes.txt"; then
+	echo "notes.txt should not be staged — leave it untracked."
+	PASS=0
+fi
+
+if [ "$PASS" -eq 0 ]; then
+	exit 1
+fi
+
+echo "Great job! You staged the right files and left notes.txt untracked."
+exit 0

gitgym-0.1.0/exercises/01_basics/04_first_commit/exercise.toml

@@ -0,0 +1,22 @@
+[exercise]
+name = "first_commit"
+topic = "Basics"
+title = "Create Your First Commit"
+description = """
+Staging a file is only half the story — you still need to save those \
+changes permanently with `git commit`. In this exercise, `hello.txt` is \
+already staged and ready to go. Create a commit with a meaningful message \
+to record the snapshot.
+"""
+
+[goal]
+summary = "The repo has at least one commit with a non-empty message."
+
+[[hints]]
+text = "Use `git log` to see the commit history (it will be empty until you commit)."
+
+[[hints]]
+text = "Look at the `git commit` command."
+
+[[hints]]
+text = "Run `git commit -m \"Your message here\"` to create the commit."

gitgym-0.1.0/exercises/01_basics/04_first_commit/setup.sh

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+EXERCISE_DIR="$1"
+mkdir -p "$EXERCISE_DIR"
+cd "$EXERCISE_DIR"
+
+# Start fresh (idempotent)
+if [ -d ".git" ]; then
+	rm -rf .git
+fi
+
+git init --initial-branch=main
+git config user.email "gitgym@example.com"
+git config user.name "Git Gym"
+
+# Stage a file so the user only needs to commit
+echo "Hello, git!" >hello.txt
+git add hello.txt

gitgym-0.1.0/exercises/01_basics/04_first_commit/verify.sh

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+EXERCISE_DIR="$1"
+cd "$EXERCISE_DIR"
+
+# Check there is at least one commit
+COMMIT_COUNT=$(git rev-list --count HEAD 2>/dev/null || echo 0)
+if [ "$COMMIT_COUNT" -eq 0 ]; then
+	echo "No commits found yet."
+	echo "Use 'git commit -m \"your message\"' to create your first commit."
+	exit 1
+fi
+
+# Check the commit message is non-empty
+COMMIT_MSG=$(git log -1 --format="%s")
+if [ -z "$COMMIT_MSG" ]; then
+	echo "Your commit has an empty message."
+	echo "A good commit message describes what changed and why."
+	exit 1
+fi
+
+echo "Great job! You made your first commit: \"$COMMIT_MSG\""
+exit 0

gitgym-0.1.0/exercises/01_basics/05_gitignore/exercise.toml

@@ -0,0 +1,30 @@
+[exercise]
+name = "gitignore"
+topic = "Basics"
+title = "Ignore Files with .gitignore"
+description = """
+Not every file belongs in version control. Build artifacts, log files, \
+and editor configs should usually be excluded. Git reads a `.gitignore` \
+file to know which files to skip.
+
+In this exercise, the repo contains two files that should never be \
+committed:
+
+  - `build.log`  — a log file generated during builds
+  - `secret.key` — a sensitive file that must not be tracked
+
+Create a `.gitignore` that excludes both of these files. The rest of \
+the repo should remain unaffected.
+"""
+
+[goal]
+summary = ".gitignore exists and causes build.log and secret.key to be ignored by git."
+
+[[hints]]
+text = "Create a file named `.gitignore` in the exercise directory."
+
+[[hints]]
+text = "Each line in `.gitignore` is a pattern. Add `build.log` and `secret.key` on separate lines."
+
+[[hints]]
+text = "Run `git status` after creating .gitignore — the two files should no longer appear as untracked."

gitgym-0.1.0/exercises/01_basics/05_gitignore/setup.sh

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+EXERCISE_DIR="$1"
+mkdir -p "$EXERCISE_DIR"
+cd "$EXERCISE_DIR"
+
+# Start fresh (idempotent)
+if [ -d ".git" ]; then
+	rm -rf .git
+fi
+rm -f .gitignore
+
+git init --initial-branch=main
+git config user.email "gitgym@example.com"
+git config user.name "Git Gym"
+
+# Commit a normal source file to give the repo some history
+echo "print('hello')" >main.py
+git add main.py
+git commit -m "Initial commit"
+
+# Create files that the user should ignore (do NOT stage or commit them)
+echo "build output log" >build.log
+echo "super-secret-value" >secret.key

gitgym-0.1.0/exercises/01_basics/05_gitignore/verify.sh

@@ -0,0 +1,35 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+EXERCISE_DIR="$1"
+cd "$EXERCISE_DIR"
+
+PASS=1
+
+# .gitignore must exist
+if [ ! -f ".gitignore" ]; then
+	echo ".gitignore does not exist yet."
+	echo "Create a .gitignore file in the exercise directory."
+	exit 1
+fi
+
+# build.log must be ignored
+if ! git check-ignore -q build.log 2>/dev/null; then
+	echo "build.log is not being ignored by git."
+	echo "Add 'build.log' to your .gitignore."
+	PASS=0
+fi
+
+# secret.key must be ignored
+if ! git check-ignore -q secret.key 2>/dev/null; then
+	echo "secret.key is not being ignored by git."
+	echo "Add 'secret.key' to your .gitignore."
+	PASS=0
+fi
+
+if [ "$PASS" -eq 0 ]; then
+	exit 1
+fi
+
+echo "Great job! Your .gitignore correctly excludes build.log and secret.key."
+exit 0