Merge branch 'index' into improvements

* index:
  index.add: Finished implemenation including through tests
  When parsing trees, we now store the originan type bits as well, previously we dropped it
  cmd.wait: AutoKill wrapped process will automatically raise on errors to unify error handling amongst clients using the process directly. It might be needed to add a flag allowing to easily override that
  added head kwarg to reset and commit method, allowing to automatically change the head to the given commit, which makes the methods more versatile
  refs.SymoblicRef: implemented direcft setting of the symbolic references commit, which possibly dereferences to the respective head
  index.commit: implemented initial version, but in fact some more changes are required to have a nice API. Tests are not yet fully done either
  actor: added __eq__, __ne__ and __hash__ methods including simple test
  index.remove implemented including throrough test
  Implemented index.reset method including test
  IndexEntry is now based on a 'minimal' version that is suitable to be fed into UpdateIndex. The Inode and device information is only needed to quickly compare the index against the working tree for changes, hence it should not be that dominant in the API either. More changes to come
  Added notes about git-update-ref
  Refs can now set the reference they are pointing to in a controlled fashion by writing their ref file directly
  Added TagRefernce creation and deletion including tests
  Implemented head methods: create, delete, rename, including tests
  refs: added create, delete and rename methods where appropriate. Tests are marked, implementation is needed for most of them
  Added frame for IndexFile add/remove/commit methods and respective test markers
  Added repo.index property including simple test, and additional ideas in the TODO list
  Renamed Index to IndexFile, adjusted tests, it will only operate on physical files, not on streams, as Indices are not streamed by any git command ( at least not in raw format )

1 files changed, 43 insertions, 7 deletions

diff --git a/TODO b/TODO
index 5ec71dc3..d841f774 100644
--- a/TODO
+++ b/TODO
@@ -31,6 +31,12 @@ Object
   it should be renamed to 'sha'. There was a time when references where allowed as 
   well, but now objects will be 'baked' to the actual sha to assure comparisons work.
   
+Commit
+------
+* message is stipped during parsing, which is wrong unless we parse from 
+  rev-list output. In fact we don't know that, and can't really tell either.
+  Currently we strip away white space that might actually belong to the message
+  
 Config
 ------
 * Expand .get* methods of GitConfigParser to support default value. If it is not None, 
@@ -50,32 +56,62 @@ Overhaul docs - check examples, check looks, improve existing docs
 
 Index
 -----
-* write_tree should write a tree directly, which would require ability to create
+* [advanced]
+  write_tree should write a tree directly, which would require ability to create
   objects in the first place. Should be rather simple as it is 
   "tree" bytes datablock | sha1sum and zipped.
   Currently we use some file swapping and the git command to do it which probably 
   is much slower. The thing is that properly writing a tree from an index involves
   creating several tree objects, so in the end it might be slower. 
   Hmm, probably its okay to use the command unless we go c(++)
+* Implement diff so that temporary indices can be used as well ( using file swapping )
+* Proper merge handling with index and working copy
+* Checkout individual blobs using the index and git-checkout. Blobs can already 
+  be written using their stream_data method.
+* index.add: could be implemented in python together with hash-object, allowing 
+  to keep the internal entry cache and write once everything is done. Problem 
+  would be that all other git commands are unaware of the changes unless the index
+  gets written. Its worth an evaluation at least.
+  A problem going with it is that there might be shell-related limitations on non-unix
+  where the commandline grows too large.
+* index.remove: On windows, there can be a command line length overflow 
+  as we pass the paths directly as argv. This is as we use git-rm to be able 
+  to remove whole directories easily. This could be implemented using 
+  git-update-index if this becomes an issue, but then we had to do all the globbing
+  and directory removal ourselves
+* commit: advance head = False - tree object should get the base commit wrapping
+  that index uses after writing itself as tree. Perhaps it would even be better
+  to have a Commit.create method from a tree or from an index. Allowing the 
+  latter would be quite flexible and would fit into the system as refs have 
+  create methods as well
 
 Refs
 -----
-* If the HEAD is detached as it points to a specific commit, its not technically
-  a symbolic reference anymore. Currently, we cannot handle this that well 
-  as we do not check for this case. This should be added though as it is 
-  valid to have a detached head in some cases.
-  
+* When adjusting the reference of a symbolic reference, the ref log might need 
+  adjustments as well. This is not critical, but would make things totally 'right'
+  - same with adjusting references directly
+ !! - Could simply rewrite it using git-update-ref which works nicely for symbolic 
+    and for normal refs !!
+* Check whether we are the active reference HEAD.reference == this_ref
+  - NO: The reference dosnt need to know - in fact it does not know about the 
+  main HEAD, so it may not use it. This is to be done in client code only. 
+  Remove me
+
 Remote
 ------
 * 'push' method needs a test, a true test repository is required though, a fork 
   of a fork would do :)!
+* Fetch should return heads that where updated, pull as well.
+* Creation and deletion methods for references should be part of the interface, allowing
+  repo.create_head(...) instaed of Head.create(repo, ...). Its a convenience thing, clearly
   
 Repo
 ----
 * Blame: Read the blame format making assumptions about its structure, 
   currently regex are used a lot although we can deduct what will be next.
   - Read data from a stream directly from git command
-
+* Figure out how to implement a proper merge API
+  
 Submodules
 ----------
 * add submodule support