quizzes/git: Fix JSON indentation for GIT_AUTHOR_EMAIL

ui.cli: Avoid divide-by-zero errors if no questions were answered

quiz: Add Quiz.introduction for an optional intro message

ui.cli: `skip` shifts the current question to the back of the stack

Rather than dropping skipped questions, just save them for later.
This gives you another stab at them without having to restart the
quiz.  If you still can't answer the questions once you reach them
again, you can always `quit` ;).

ui.cli: Add a `skip` command to the quizzer shell

This lets you bypass a difficult question on the stack and continue
with the rest of the quiz.

ui.cli: Unwrap multiline answers in display_result

No need to surprise the user with the internal list representation.

ui.cli: Use pygments to colorize command line output

quizzes/git: Don't timeout during the 'gitignore' question

In case the user decides to spawn an editor to tweak .gitignore.

quizzes/git: Add remote-related questions

New questions:
* git remote add
* git remote -v
* git fetch REPOSITORY
* git push REPOSITORY BRANCH

quizzer/git: Add 'git merge' question

quizzes/git: Add 'git checkout *' questions

New questions:
* git checkout
* git checkout -b
* git checkout -b NEW_BRANCH START_POINT

quizzes/git: Add 'git branch *' questions

New questions:
* git branch
* git branch -a
* git branch -r
* git branch -d

quizzes/git: Fix 'in repository' -> 'in your repository'

For the 'git rm / commit' question.

quizzes/git: Add 'git rm / commit' question

quizzes/git: Add 'git log *' questions

New questions:
* git log
* git log -p
* git log --stat
* git log --all
* git log --oneline
* git log --oneline --graph
* git log --oneline --decorate

quizzes/git: Add 'git diff *' questions

New questions:
* git diff
* git diff HEAD --
* git diff HEAD -- README
* git diff --cached

quizzes/git: Avoid escaped double-quotes when single-quotes will do

quizzes/git: Add 'git commit -a' question

ui.cli: Don't start the QuestionCommandLine with an empty stack

There's not much point in a question-answering shell if there are no
questions to be answered.

quizzes/git: Add 'git status' question

quizzes/git: Add 'gitignore' question

ui.cli: Quit after the last question

Oops, should have tested that when I transitioned to Cmd ;).

ui.cli: Fix ._set_ps1 when .question is None

Otherwise QuestionCommandLine will crash if its launched with an empty
stack (not that this should happen, but we should still avoid the
crash).

quizzes/git: Add 'git help config' question

ui.cli: Fix single-line answer extraction

`var.get(key, default)` only works for dicts.  I don't think there is
an equivalent that works for lists.

cli: Add --select to filter the stack by index

For example, you can show the questions in a quiz with either the
`config` tag or the `checkout` tag:

  $ ./pq.py --all --tag config --tag checkout --questions quizzes/git.json
  Question 0:
  Configure your user-wide name to be `A U Thor`.

  Question 1:
  Configure your user-wide email to be `author@example.com`.

  Question 2:
  You've messed up your README file.
  Restore it to the last committed version.

Say questions 0 and 2 look interesting, and you'd like to try question
2 first.  Run:

  $ ./pq.py --all --tag config --tag checkout -s 2 -s 0 quizzes/git.json

ui.cli: Add an `answer` command to QuestionCommandLine

This allows you to bypass quizzer-shell command handling when your
answer line starts with a quizzer-shell command.

ui.cli: Repeat the basic help when the user calls `help`

ui.cli: Transition to a CLI based on cmd.Cmd

This makes command handling more robust, and makes adding additional
non-answer commands more organized.

quizzes: Convert multi-line help to lists

question: Add support for list-of-lines help

We use lists of lines for other question attributes (e.g. setup,
teardown, answer, prompt).  Be consistent with multi-line help.

quizzes/git: Convert multi-line prompts to lists

question: Add support for list-of-lines prompts

We use lists of lines for other question attributes (e.g. setup,
teardown, answer).  Be consistent with multi-line prompts.

The handling is in Question.format_prompt() for easy access by any
consumer.  The `newline` option will make it easy to support
non-terminal output formats (e.g. `newline='<br/>'` for HTML).

quizzes: Use complete sentences with punctation for prompts

This makes multi-sentence prompts less awkward.

cli: Add the --questions option to list questions on the stack

This lets you see what a quiz will ask without actually taking the
quiz.  In the future, it may be useful for jumping to a specific
question.

cli: Add the --tags option to list tags on the stack

quizzes/git: Tag existing questions

Add --tag option and Question.tags sets for filtering large quizzes

cli: Add --all for easy review of previously-answered questions

answerdb: Timestamp answers

This may provide insight into the learning process (e.g. after I
reviewed the Git index, everyone started doing better).

quizzes/git: Add 'git commit --amend' question

README.rst: Add a symlink for GitHub's README renderer

quizzes/git: Add 'git config --global user.{name,email}' questions

quizzes/git: Add 'git checkout HEAD -- FILE' question

question: Add a trailing newline to ScriptQuestion scripts

question: Pass stdin through to the ScriptQuestion-invoked script

Use a temporary script to hold the answer script, to leave stdin open.
This allows users to use commands that need stdin (e.g. `git commit`,
which spawns an `$EDITOR`).

quizzes/git: Add 'git add / commit' question

Remove the default timeout, to give users who spawn `$EDITOR` via `git
commit` time to write and save their message.

Run update-copyright.py

.update-copyright.conf: Configure update-copyright.py

http://blog.tremily.us/posts/update-copyright/
http://pypi.python.org/pypi/update-copyright/

Add `# Copyright` tags to Python files

.gitignore: Ignore MANIFEST and dist/ packaging side effects

MANIFEST.in: Distribute COPYING and quizzes/*.json

setup.py: Package with distutils

README: Flesh out description and add example typescript

README: Mention Python 3.3 dependency

COPYING: Distribute quizzer under the GPLv3+

quizzes/git: Add preliminary Git quiz (repository creation)

Add Question.multiline and associated handling

Some questions can't be answered in a single line without reqiring
more shell knowledge than we need (e.g. `&&`).

ui.cli: Import `readline` for more comfortable input() editing

quizzes/posix-shell: Add a preliminary POSIX shell language quiz

quizzes/posix-utilities: Rename from posix-shell.json and flesh out

Added few more questions:
* print the current directory to stdout
* change to your home directory
* change to the parent of your current working directory
* print the contents of README file to the terminal

The renaming is because the tests are testing knowledge of POSIX
utilities, not knowledge of the shell syntax itself.

question: Normalize tempdir paths in stdout/stderr

Otherwise it's hard to test `pwd`, since tempdir will change between
the expected and user-supplied answer runs.

question: Add ChoiceQuestion for one-of-several correct answers

quizzes: Move quizzes into a subdirectory

Add script invocation to ScriptQuestion

We need Python >= 3.3 for the `timeout` argument to
Popen.communicate().

Remove debugging print(self.stack) from UserInterface.get_question()

Initial ScriptQuestion framework

Fix 'hint' -> 'help' typos

question: Use Question._state_attributes in __init__ and __setstate__

question: Add Question._state_attributes for easier subclassing

This way subclasses can extend the list instead of overriding
__getstate__.

Add question class storage (lookups in QUESTION_CLASS)

This allows us to specify questions with alternate processing classes.
As a simple example, I've added NormalizedStringQuestion, which
softens the string comparison used in the basic Question.  The next
step is to add a command-line question ;).

ui.cli: Rework display_result() for multiple answers per question

ui: Add dependency handling to UserInterface.get_question

We start the stack with all the leaf questions (i.e. questions that
are not dependencies of other question).  If the user gets one wrong,
we push the question back on the stack (so they can try again later),
and also push all of that questions direct dependencies onto the stack
(so they can get the background they need to answer the question they
got wrong).

question: Add Question.__str__() and __repr__()

For easily viewing questions in lists.

Catch EOFError (control-d) in CommandLineInterface input() call

Add dependency storage (list of question IDs)

Use question.id instead of question.prompt for answer indexing

This decouples the keying from the prompt, which is useful if you want
to use another value for the `id` (e.g. a question number).

If `id` is not specified, it defaults to `prompt`.

Add trailing newlines to saved JSON files

Add a persistent answers database

Visually separate the results from the questions

Add .display_results() for showing users their results and scores

Display results (but not the correct answers)

Don't crash with IndexError when we run out of questions

Make get_question() a bit more interesting

Add a simple command line interface

Added saving, loading, and a test quiz

Stubbing out the initial framework