Add support for the pseudo directories to check-path

We need check-path to support the pseudo directories - so that when
the client asks what kind of thing is /tags it gets the response "a
directory", etc.  Otherwise some client commands may walk themselves
up and out of the directory because they never find a valid path to
stop on.

check-path doesn't always include a revision

Sometimes the revision in check-path is omitted - treat this as
"lastest revision".

Improve error detection in complete_commit

More work on picking out and reporting errors in complete_commit.
There is still more to do - there are mny things that the user can try
to do, and only a few that will actually work.  The compliated part is
putting together appropriate error messages.

Start tightening up checking in complete_commit

Since Subversion is so free about it's namespace and we are only
implementing a sub-set of it, with particular rules about what changes
may be made where (e.g. no changes to tags) start using the new
HookFailure error to report restrictions back to the user.

Don't call rev-parse unless we have a valid ref

If we don't have a valid ref, then set parent to None instead of call
rev-parse with a ref of None (which causes us to end up with a parent
of 'None' as we don't currently check rev-parse for errors).

Use pseudo pre-commit hook to prevent tag commits

Since we now have a pre-commit hook framework that allows the repos
instance to abort a commit with a message that will be presented to
the user, we can use it to stop commits to tags from being accepted
(since git can't actually allow you to make arbitrary changes to
tags).

Add support for pre-commit hook

Add the mechanism for the repos instance to report a pre-commit hook
failure that will then be passed back to the client.

Fix commit commands so that error syntax is correct

The commit command wasn't sending the correct sequence of messages for
errors, as cmd_base was always sending a success response before
commit got a chance to send a failure.  Restructure things so that
failures can be sent correctly.

os.popen3 is deprecated too ...

md5 is deprecated

Switch update command to use DeltaCmd

update is another command that is basically the same as switch, so we
can again use the DeltaCmd base class to do most of the work.

Add a diff command

Since diff is very similar to switch, we can use the new DeltaCmd base
class to do the bulk of the work for the diff command.

Fix _path_changed

Without -r diff-tree will only tell us about changes in the top level
- which means that we send updates for all files in a subdirectory
tree when anything in that tree has changed.  With -r it only lists
the actual paths have changed.

Pull out the switch command processing into a base class

This is the first step in sharing code between switch and update.  The
bulk of the processing for the switch command is now in the DeltaCmd
class.

Combine multiple entries for one path into a single entry

Since we store information about a single Subversion path in multiple
git paths we need to combine those multiple entries back into a single
path when presenting log information back to Subversion.

Add a comment explaining why we always create .gitignore

Since we have a good reason to always create a .gitignore file, even
if it is empty it's worth adding a comment explaining why.

Property changes can only ever be 'M'

When a property file is added or deleted that is still just an 'M'
operation on the underlying file as far as Subversion is concerned.

Tidy up the new log code a bit

This is functionally the same, and about the same size - but it feels
nicer somehow ...

Rework log to start including property changes

The log command was no doing any mapping of git paths back to
Subversion ones, so property changes were shown as changes to files
that the Subversion client can't actually see ...

At the moment the changes aren't quite right, as if a file has both
content and property changes in the same commit they will be reported
separately instead of together.

Remove some old debug from update

The list of chunks for large files is just getting in the way these
days ...

Start adding general support for properties

Now we store all the properties that we can't map to git internals in
a JSON dumpfile for each file that has any such properties.  This
means that they are included in commits and visible to git users
(though there are issues with moving files etc. when peopl are not
aware of the property files).

Add support for changing svn:ignore

Although there was support for setting properties on files (though
they are mostly discarded at present), there was no support support
for setting properties on files - in particular the svn:ignore
property (i.e. the .gitignore file).

Add support for using GitFile locally

Instead of assuming that we have a commit object to give to the
GitFile tweak it so that we can use it directly by giving it a
location instead.  This allows it to be used more generally as a
wrapper for creating files in git and getting the resulting sha1.

The paths in a commit aren't always relative to the top

The paths in the files member of a GitCommit are relative to the
prefix member not to the top of the tree - we need to combine them
with the prefix before trying to use them to create a commit.

Create diffs in get-file-revs

Use the previous revision that we already have to create svndiffs
rather than sending the full contents of the file for every revision.

Genereate independant file contents for use with svndiff

When we pass file contents objects to the svndiff Encoder it is going
to step through both files in chunks in parallel, which means that the
two file contents objects need to be independant - they can't have any
implicit sequential requirement, which GitObjects do as they all read
from the same cat-file instance.  We now have an IndepGitObject that
has its own cat-file instance so that it can be read in parallel with
a GitObject or anther IndepGitObject, and a way to ask for an
independant contents object - which we then use to ask for previous
contents when we a going to create a diff.

Remove some unwanted debug output

Use random index file name to create commit

Since we don't want two simultaneous connections to try and use the
same index file when trying to create commits, randomise the name of
the index file that we use - and also try to delete it after we have
used it to stop a large collection of used index files building up.

Don't tell client to delete deleted paths

If the client tells us that a path has been deleted, then we shouldn't
turn around and tell it to delete that same path ... that'll just
confuse the user.

Add support for deleting things.

Finally got around to adding support for deleting things.

This doesn't seem to work quite right yet, update reports the file as
being deleted - which it shouldn't ...

Once again the protocol document is wrong

It turns out that the rev in the editor command is sent inside a list,
despite what the protcol document says ... ho hum, what a surprise ...

Don't assume that changes are always to file contents

If an svn user changes a file's properties then there will be no sha1
from a content change in the data recorded during the commit command
processing - so we need to look up the previous contents and use those
rather than crashing.

Add an initial switch implementation

Create an implementation of the switch command by tweaking the update
command code to deal with the two URLs needed for switching.

We could probably actually use the switch code for both, just by
setting the new URL to the old URL for the update case ...

Give svndiff Encoder a pre-image

If we have previous contents for the file, then give them to the
svndiff Encoder to use as a pre-image to hopefully reduce the amount
of data that we have to send.

Use difflib to encode diffs when we have the pre-image

If we have a pre-image for the svndiff Encoder then use difflib to
actually create some form of diff.  This isn't as complete as the
Subversion diffing (we don't use copy from target at all) but it
should decrease the amount of data that we have to send for updates
and switches.

Implement get-file-revs command

The get-file-revs command is used by svn blame - implement at least
the basics, so svn blame will work for at least the simple cases.

Subversion is now an apache project

Which means they have moved their web repo access to apache.org URLs.

Add tags/branches to ls method

Add support for the tags and branches virtual directories to the ls
method.

Add support for top-level to ls method

Add support for the top-level virtual directory to the ls method.

Add support for tags/branches to stat method

Add support for the tags and branches virtual directories to the stat
method.

Add a function to look up commits using a pattern

Sometimes we want to look for the most recent (up to the given
revision) commit that matches a given pattern.

Add support for looking up tags to commit functions

When looking through the transaction table looking for commits, add
support for tags too.

Only close an open string

If we don't have an open string then don't close it.

Fix a couple of issues with cat_file

Add a tell method to GitCatFile and change it round so that it reads
the extra linefeed at the beginning rather than expecting one at the
end, as we sometimes seem to hang waiting for it.

Use the correct max size for svndiff

Subversion limits the size of a diff to 102400 bytes, so we need to do
so too otherwise Subversion will reject our diffs.

Suite names must start with the word Test

vcs/git: Fix __commit_info

data should be a list so that when we try to extract the message we
get what we expect (a slice of a list of lines) rather than some
random slicing of a string.

tests: increase reliability of tests

Increase the wait for the server to start to increase the reliability
of the tests.

Add very basic support for creating tags and branches

If you use the correct command, and have made all appropriate
sacrifices you can now create tags and branches using the Subversion
copy command.

vcs/git: Make GitData methods more robust

Before trying to manipulate the underlying data stream, make sure that
we actually have one.

auth: fix auth for Python 2.6

With Python 2.6 we get a unicode string for the password instead of a
standard string - which we can't use with hmac.  So force it to be a
regular string.

Use a single long-running git-cat-file instance

Rather than spawning a new git-cat-file instance each time we want to
retrieve data from git we create a single --batch instance for the
entire duration of the connection instead.

Use the maximum possible zlib compression

In order to minimise the amount of data send over the network use the
maximum possible zlib compression level.

Decouple getting the data from sending the data

By running the two tasks in parallel we can improve the wall time
taken.

Remove some debug print statements

Remove a bunch of debug print statements that aren't that useful.

vcs/git: Add some comments to get_files

get_files is a rather long function, so for now add some comments.

vcs/git: Split the db access classes out

Move the db access classes into their own module.

vcs/git: Change vcs/git from being a single module to a package

vcs/git.py was becoming rather large - nearly a third of the code
base.  Move it into a git package so that the code can later be split
up.

vcs/git: Convert .gitignore to svn:ignored property in get_files

When returning data for update from get_files, translate .gitignore
files into svn:ignore properties on the containing directory.

vcs/git: Make log a generator function

Rather than making the user wait until we have generated all the log
entries before sending them to the client, use a generator function so
that each entry gets sent as it is ready.  This makes the user
experience much nicer.  It also means that we don't have to hold a
potentially large amount of data in memory.

vcs/git: Use a path with the log command to reduce irrelevant data

When we are running update on a sub-path of the repository there is no
point in parsing a complete log, so pass the path that we want to look
at to the log command.

svndiff: Make sure the client will understand zlib compressed data

In order for the client to know that data has been zlib compressed it
checks to see if the data length is less than the original data
length.  Which means that if the encoded data is as long as (or longer
than) then raw data we should just send the raw data.

Fix error handling for update so that it works

Technically the error handling is still not 100% compliant with the
protocol description, but at least it works now.  In addition to
actually getting the client to recognise the end of the update command
we send it's error back to it so that it becomes visible to the user.

Rewrite get_files to be based on git log

Rather than using lots of "git ls-tree" and "git cat-file commit"
calls, we can actually use a single "git log" call.  This is
significantly faster, whereas the original get_files was actually
slower than using ls and get_file.

Fix structure building in get_files

The structure returned by get_files was being build incorrectly.  When
a parent entry was defaulted it was created with the first element as
the path of the parent, when it should be just the name.

Treat merges as commits

When looking for commits, we weren't treating merges as commits, which
we should have been.  In addition we were looking for 'create branch'
for branch points, when build_map is only using 'branch'.

Also remove the special case for 'delete branch', as it is the same as
the default handling.

Don't try and look at the first tag when there are none left

Previously we were always trying to look at the first of the remaining
tags, even if there were none left.  Now we check that there are some
tags left to look at first - which prevents the script from crashing
when it runs out of tags.

In addition if there are any tags left after adding all the commits,
add them at the end instead of ignoring them.

update: use the new vcs get_files method

Switch to using the get_files method instead of the ls and get_file
methods to get the tree of files for the new revision, as hopefully
this should be more efficient for complicated git repositories.

vcs: Add get_files function that returns a whole tree

Given an url and a revision get_files will return a structure
containing the properties and contents of every path to be found under
that point.  For a git repository this will hopefully be more
efficient than using ls and get_file in combination, as we can run
through a single rev-list to get the last changed data, instead of
doing it for each file individually (which git isn't very good at).

Don't run off the end of the source file in svndiff

If the source file that we were generating an svndiff for was an exact
multiple of the chunk_size in length then we would go past the end and
try and create a diff window from no data.

Misc fixes and improvements to update command

Some updates and fixes to the update command.

Add missing object to Encoder definition

Not strictly necessary, but is more consistent

Add commit handling for svn:special and svn:executable

Since these two properties are reflected in the mode in git they can
be stored (and for the commit to be correct should be).  So add code
to make the necessary mappings for commit, the inverse of the mappings
already in place for update and similar commands.

Add support for sending svndiff1

If the client supports it, then send deltas encoded using svndiff1,
as the zlib should reduce network traffic.

Parse the optional extra arguments to update

The arguments aren't used yet, but now we parse them.

Handle a path in update correctly

If the client supplies a path in an update call then it wants us to
update the given path from the "root" of the current URL.  Previously
we would try and combine the path with URL to do the right thing -
which is how many commands work, but not this one.

Fix update so that delete-entry work properly

Previously we forgot to prepand the current directory path onto the
entry name - which meant that the client would fail an assertion if we
tried to delete something from a sub-directory (as we would be telling
it to delete it from the top-level).

Record the URL of some more useful documents

The Subversion SVN repos contains some documentation on various bit of
Subversion that can be useful.

Tidy up the server debug output, and add cl option to enable

Previously the debug output from the server module was controlled by a
global variable, and the caller had to compose the output.  Move the
composition into the function, move the function into the
SvnRequestHandler class, and control the output from a command-line
option.

Sort out the server announce message

Tidy up the server announce message a bit.  In particular, we might as
well announce the absent-entries capability - we support the commands
even if they currently aren't implemented.

Add support for receiving svndiff1

Expand the svndiff module so that we can support receiving svndiff1 -
though we don't support generating it as yet.

Subversion expects to be able to perform a stat on the top level

Since the is no mapping from the top level of a Subversion repository
to a real place in a git repository we have to make the results of the
stat up.  In addition, we need to be able to handle the stat of the
top-level for revision 0 where there is no "Last Changed Author" - so
we need to return an empty list for that bit of the response.

Don't end the URL in a / if there is no path

If the caller hasn't supplied a path, then don't end the URL in a /.
If the caller does want a trailing / then they can always pass an
empty path.

Don't hide what the URL was and should have been

If we pass a message to the fail function, then we don't see the
values.  Which for the first two fails in check_svn_info makes sense -
however, for the last check it makes more sense to show the values if
they are not equal.

An empty repository should have revision 0

Rather than returning an error, when asked about an empty repository
we should say that it is at revision 0.

Add a test that git-svnserver looks like a Subversion server

We ought to be able to call 'svn info <url_of_repo>' against
git-svnserver and get a complete response back including the url we
sent.  Even against an emptry repository.

Currently this fails, as the git backend can't cope with requests that
aren't directed against a branch.  And it doesn't like not have any
data in either and returns an error instead of revision 0.

Add Subversion and user bits to test lib

Add some wrapper code for calling Subversion, and for managing users
in our git repositories to the test lib.

Ignore a local copy of CleverSheep

An easy way to make CleverSheep available without installing it is to
put a copy in the test directory.  If we do this, then ignore it.

Ignore test output files

When run the test framework can create some files - which we don't
want in the repository.

Fix parsing of authentication response

If the username had whitespace in it then we mis-split the response.
Split one item from the right hand end instead.

Automatically create a new empty git repository for each test

And also a matching git-svnserver config file to serve it.  This means
that the tests can now run without requiring any external setup.

Also a few other misc tidy ups and improvements to the test lib.

Add some more tests

Adds some tests that we can actually control the IP and port that the
server uses.  Simple command-line option stuff - since the test lib
needs more work before it is ready for testing behaviour with a
Subversion client.

Start adding some tests

At the moment there is only one test - that the server actually
starts, however this is mostly about getting the beginnings of a test
framework in place.  The framework itself still needs more work, as it
doesn't provide facilities for setting up the repository to serve, or
to drive the client for us.

Make the --pidfile option always available

There is no good reason to limit the --pidfile option to only working
when running in daemon mode, so make it work in foreground mode again.

Minor tidy to the output of the auth code

Rather than printing the authentication response as received from the
client print a message when we have authenticated a user.

Add an option to store the pid of the daemon in a file

Now you can ask git-svnserver to store the pid of the daemon process
in a file, making it easier to kill it off later.

Also tidy up the passing of options to the server - simply pass the
whole options object, rather than passing each bit of informtaion on
its own.

Implement get_auth function from Repos API

Since this backend is only really to support protocol development, we
just use the DummyAuthDb rather than bothering to implement a proper
authentication database.

Add a DummyAuthDb class that shows the auth db interface

It also allows backends that don't want to care about authentication
to use something that already exists rather than having to write their
own Dummy.

get_auth is now part of the Repos API

So it should be in the Repos base class

Rename the example config file

test.cfg is not really an obvious name for an example config file.