Start of a "baby" git implementation

This version can traverse a tree and read a pack (including deltas).
At this point, it's an exploration, but it might grow into a basis for
content management.
Beginnings of git server support

A skeleton server that can export a git repository through the "dumb" http
protocol, over App Engine. This was tested both with a real repo (you have
symlink .git to _git, though, to avoid permissions problems) and with a
purely synthetic one.

This patch also improves header handling support, so sha headers match, and
also tweaks the content type header setting to avoid duplicate headers in the
result (this should probably be applied to the main branch irrespective).
Start of App Engine backend for babygit

This patch adds a very simple App Engine backend that stores loose objects
as blobs. As a test, you can check out a test repo (through the dumb
http protocol only).
Serve raw file and directory listings, plus babygit refactoring

Starting to factor the git functionality into layers (so that, for example,
packfile reading can happen from both file system and App Engine stores).
Also added simple functionality to web handler to browse through raw
objects (including traversing trees and simple directory listing).
Add memcache to App Engine babygit store

The App Engine store now uses memcache for object lookups, which should
help performance quite a bit in production.
Basic support for writing into repo

This patch adds functions for writing files into a tree (creating a new
tree), and committing a tree. This is tested in the App Engine test repo,
and the C git client can successfully check out the resulting repo.
Add a stage (like the git index)

This change adds a "stage" in the datastore, so that saves get written
into the stage, then commited as a separate step.

A few flaws remain: timezone handling is quite wonky. Also, the new
interfaces in the store object are only implemented in the appengine
store - they should be implemented in the in-memory store too. And
there's no memcache of the stage. There should probably be a ref in the
stage object (corresponding to HEAD in git). Lastly, there's no
transactions or any protection against concurrent writes clobbering each
other.
Primitive web-based edit and save interface

This patch adds the ability to edit and save text into the repo. It's
primitive but a reasonable start. In particular, there's no good support
for concurrent editing.
Basic support for a wiki

This patch starts adding a wiki to the web app. Wiki pages are stored in
the git repo, and a variant of ghmarkup is used to render the content.

Formatting and styling is still very raw, and there's little integration
with the theorems (you can link to them though), but it's a start.
Make git/wiki work with empty repo

If the database is completely empty, then initialize with an empty repo.
Add basic smart http support

This patch adds simple support for the smart http protocol. It doesn't
do negotiation with the "have" yet, and it doesn't do any delta coding,
but it does pack up a repo and can be cloned with C git client (Dulwich
fails because it can't handle non-sideband data).
Fix bug getting objs out of App Engine store

We weren't actually returning objects retrieved from App Engine. This
was masked in testing because the memcache gets were succeeding.
Add git receive-pack functionality

This patch adds the ability to push to the git repository through the
smart http protocol. Currently that is unauthenticated, but it should
support creation and deletion of branches, ref deltas in packs, and so
on.
Strip CR characters from wiki save

The standard for the repo is Unix-style line endings, so strip the CR
from DOS-style ones.
A start on user accounts

This commit adds very basic account creation and checking, but doesn't
do cookies yet or authenticate git pushes (which is the main point).

There are other possible solutions to this, maybe doing everything at
such a low level isn't the absolute best idea. But something is needed.
Update .gitignore for vi and python

This is a good .gitignore for working with python and common editors.
Upgrade to webapp2

This patch upgrades from webapp to webapp2, and also uses the json
implementation from there (rather than the django simplejson one).

We're not jumping to Python 2.7 yet (which would enable multithreading),
but this helps us get there.
Add authentication to git push

Git push now checks the password (using basic authentication). It also
tries to make sure https is being used.

Note that it's still pretty open - anyone can create an account, and the
web app doesn't do any authentication. So don't push to production.
Add permissions to git push

Just having an account isn't enough, you need permissions. Sorry,
spammers.
Protect access to git repo by login

Any save action into the git repo requires a login with valid write
permissions. In addition, it uses the identity from the user profile for
the commit message.

The flow is still rough (for example, the login action should redirect
you to the page you were attempting), but at least this version should
be strong enough to push to production.