1. 10 May, 2011 8 commits
    • libgit2 v0.12.0 "absolutely no reason" · 40774549
      Hey, welcome to yet another minor libgit2 release. Sorry for the delay from
      the last one. As you'll see the changelog is quite extensive -- hopefully from
      now on we'll stick to more frequent minor releases.
      
      Together with the usual bugfixes, here's a list of the new key features:
      
      * Distfiles
      
      	This version comes with proper distfiles as requested in #131. These are
      	available in the Downloads section of the GitHub project.
      
      * Error handling
      
      	A new error handling API has been implemented that allows the library to
      	return detailed error messages together with the generic error codes. We
      	hope this will be a great when wrapping and integrating the library
      
      	New external method to get the last detailed error message:
      
      		+ git_lasterror(void)
      
      	The old `git_strerror` still exists, but will be deprecated in the future
      	as soon as every method in the library returns a valid error message.
      
      	The task of writing error messages for every method is quite daunting.
      	We appreciate pull requests with more error messages. Check the new error
      	handling documentation in the following commit:
      
      	https://github.com/libgit2/libgit2/commit/fa59f18d0ddbbb98d45e33934fb0efc3e2bf1557
      
      * Redis backend
      
      	We now have a Redis backend courtesy of Dmitry Kovega. Just like the
      	SQLite backend, this allows the library to store Git objects in a Redis
      	key-value store.
      
      	The backend requires the `hiredis` library. Use `--with-redis` when
      	building libgit2 to enable building the backend if `hiredis` is available.
      
      * Commits
      
      	New methods to access tree and parent data as a raw OID value
      	instead of forcing a repository lookup
      
      		+ git_commit_tree_oid(git_commit *commit)
      		+ git_commit_parent_oid(git_commit *commit, unsigned int n)
      
      * Index
      
      	The `git_index_add` method has been split into 4 different calls
      	which allow for appending and replacing in-memory entries and on-disk
      	files to the index.
      
      		+ git_index_add(git_index *index, const char *path, int stage)
      		+ git_index_add2(git_index *index, const git_index_entry *source_entry)
      		+ git_index_append(git_index *index, const char *path, int stage)
      		+ git_index_append2(git_index *index, const git_index_entry *source_entry)
      
      	Index entries can now also be efficiently removed from the index:
      
      		+ git_index_remove(git_index *index, int position)
      
      * References
      
      	Methods to force the creation and renaming of references, even if those already
      	exist on the repository.
      
      		+ git_reference_create_symbolic_f(git_reference **ref_out, git_repository *repo,
      				const char *name, const char *target)
      		+ git_reference_create_oid_f(git_reference **ref_out, git_repository *repo,
      				const char *name, const git_oid *id)
      		+ git_reference_rename_f(git_reference *ref, const char *new_name)
      
      * Repository
      
      	New auxiliary methods with repository information
      
      		+ git_repository_is_empty(git_repository *repo)
      		+ git_repository_path(git_repository *repo)
      		+ git_repository_workdir(git_repository *repo)
      
      * Signatures
      
      	New method to create a signature with the current date/time
      
      		+ git_signature_now(const char *name, const char *email)
      
      * Tags
      
      	Several wrappers to automate tag creation.
      
      		+ git_tag_create_frombuffer(git_oid *oid, git_repository *repo,
      				const char *buffer)
      		+ git_tag_create_f(git_oid *oid, git_repository *repo,
      				const char *tag_name, const git_oid *target,
      				git_otype target_type, const git_signature *tagger,
      				const char *message);
      		+ git_tag_create_fo(git_oid *oid, git_repository *repo,
      				const char *tag_name, const git_object *target,
      				const git_signature *tagger, const char *message)
      
      	New functionality to delete and list tags in a repository without
      	having to resort to the `references` API.
      
      		+ git_tag_delete(git_repository *repo, const char *tag_name)
      
      		+ git_tag_list(git_strarray *tag_names, git_repository *repo)
      
      * Trees
      
      	All instances of `git_tree_entry` are now returned and handled
      	as constant, to remind the user that these opaque types are not
      	supposed to be manually free'd.
      
      	The `git_tree_entry_2object` method now takes a `git_repository`
      	argument which defines in which repository the resolved object
      	should be looked up. (It is expected to be the same repository
      	that contains the parent `git_tree` for the entry).
      
      		+ git_tree_entry_2object(git_object **object_out, git_repository *repo,
      				const git_tree_entry *entry)
      
      	New opaque type `git_treebuilder` with functionality to create and
      	write trees on memory
      
      		+ git_treebuilder_create(git_treebuilder **builder_p, const git_tree *source)
      		+ git_treebuilder_clear(git_treebuilder *bld)
      		+ git_treebuilder_free(git_treebuilder *bld)
      		+ git_treebuilder_get(git_treebuilder *bld, const char *filename)
      		+ git_treebuilder_insert(git_tree_entry **entry_out, git_treebuilder *bld,
      				const char *filename, const git_oid *id, unsigned int attributes)
      		+ git_treebuilder_remove(git_treebuilder *bld, const char *filename)
      		+ git_treebuilder_filter(git_treebuilder *bld,
      				int (*filter)(const git_tree_entry *, void *), void *payload)
      		+ git_treebuilder_write(git_oid *oid, git_repository *repo, git_treebuilder *bld)
      
      	New method to write an index file as a tree to the ODB.
      
      		+ git_tree_create_fromindex(git_oid *oid, git_index *index)
      
      Thanks to the usual guility parties that make this this happen, to
      all the new contributors who are starting to submit pull requests, and
      to the bindings developers who have to keep up with our shit.
      
      Feedback and questions welcome on libgit2@librelist.org
      
      Signed-off-by: Vicent Marti <tanoku@gmail.com>
      Vicent Marti committed
    • Bring back `git_strerror` · f4a936b5
      We cannot totally deprecate this until the new error handling mechanisms
      are all in place.
      Vicent Marti committed
    • Merge pull request #180 from kellypleahy/bug/fix_issue_79 · 86b74ea0
      Fix issue #79 - git_lasterror() isn't appearing in git2.dll in windows.
      Vicent Martí committed
    • Merge pull request #181 from carlosmn/errors · 97ce36e7
      Move signature.c and tag.c to the new error handling
      Vicent Martí committed
    • Move tag.c to the new error handling · 44dc0d26
      Signed-off-by: Carlos Martín Nieto <cmn@elego.de>
      Carlos Martín Nieto committed
    • Move signature.c to the new error handling · 5de24ec7
      Signed-off-by: Carlos Martín Nieto <cmn@elego.de>
      Carlos Martín Nieto committed
    • Fix issue #79 - git_lasterror() isn't appearing in git2.dll in windows. · ab86f159
      The GIT_EXPORT macro is used to declare a function to be externally
      accessible to other libraries.  This commit uses GIT_EXPORT to declare
      the git_lasterror() function as externally exported.  I verified with
      depends.exe that the function is available to external callers (i.e.
      in the exports table of the PE file).
      kelly.leahy committed
  2. 09 May, 2011 5 commits
    • Change error handling mechanism once again · fa59f18d
      Ok, this is the real deal. Hopefully. Here's how it's going to work:
      
      - One main method, called `git__throw`, that sets the error
      	code and error message when an error happens.
      
      	This method must be called in every single place where an error
      	code was being returned previously, setting an error message
      	instead.
      
      	Example, instead of:
      
      		return GIT_EOBJCORRUPTED;
      
      	Use:
      
      		return git__throw(GIT_EOBJCORRUPTED,
      			"The object is missing a finalizing line feed");
      
      	And instead of:
      
      		[...] {
      			error = GIT_EOBJCORRUPTED;
      			goto cleanup;
      		}
      
      	Use:
      
      		[...] {
      			error = git__throw(GIT_EOBJCORRUPTED, "What an error!");
      			goto cleanup;
      		}
      
      	The **only** exception to this are the allocation methods, which
      	return NULL on failure but already set the message manually.
      
      		/* only place where an error code can be returned directly,
      		   because the error message has already been set by the wrapper */
      		if (foo == NULL)
      			return GIT_ENOMEM;
      
      - One secondary method, called `git__rethrow`, which can be used to
      fine-grain an error message and build an error stack.
      
      	Example, instead of:
      
      		if ((error = foobar(baz)) < GIT_SUCCESS)
      			return error;
      
      	You can now do:
      
      		if ((error = foobar(baz)) < GIT_SUCCESS)
      			return git__rethrow(error, "Failed to do a major operation");
      
      	The return of the `git_lasterror` method will be a string in the
      	shape of:
      
      		"Failed to do a major operation. (Failed to do an internal
      		operation)"
      
      	E.g.
      
      		"Failed to open the index. (Not enough permissions to access
      		'/path/to/index')."
      
      	NOTE: do not abuse this method. Try to write all `git__throw`
      	messages in a descriptive manner, to avoid having to rethrow them to
      	clarify their meaning.
      
      	This method should only be used in the places where the original
      	error message set by a subroutine is not specific enough.
      
      	It is encouraged to continue using this style as much possible to
      	enforce error propagation:
      
      		if ((error = foobar(baz)) < GIT_SUCCESS)
      			return error; /* `foobar` has set an error message, and
      							 we are just propagating it */
      
      The error handling revamp will take place in two phases:
      
      	- Phase 1: Replace all pieces of code that return direct error codes
      	with calls to `git__throw`. This can be done semi-automatically
      	using `ack` to locate all the error codes that must be replaced.
      
      	- Phase 2: Add some `git__rethrow` calls in those cases where the
      	original error messages are not specific enough.
      
      Phase 1 is the main goal. A minor libgit2 release will be shipped once
      Phase 1 is ready, and the work will start on gradually improving the
      error handling mechanism by refining specific error messages.
      
      OTHER NOTES:
      
      	- When writing error messages, please refrain from using weasel
      	words. They add verbosity to the message without giving any real
      	information. (<3 Emeric)
      
      	E.g.
      
      		"The reference file appears to be missing a carriage return"
      			Nope.
      
      		"The reference file is missing a carriage return"
      			Yes.
      
      	- When calling `git__throw`, please try to use more generic error
      	codes so we can eventually reduce the list of error codes to
      	something more reasonable. Feel free to add new, more generic error
      	codes if these are going to replace several of the old ones.
      
      	E.g.
      
      		return GIT_EREFCORRUPTED;
      
      	Can be turned into:
      
      		return git__throw(GIT_EOBJCORRUPTED,
      			"The reference is corrupted");
      Vicent Marti committed
  3. 08 May, 2011 7 commits
  4. 06 May, 2011 3 commits
  5. 05 May, 2011 1 commit
  6. 04 May, 2011 1 commit
  7. 02 May, 2011 2 commits
  8. 01 May, 2011 6 commits
  9. 29 Apr, 2011 3 commits
    • Add root commit test · 79b61557
      Signed-off-by: Carlos Martín Nieto <cmn@elego.de>
      Carlos Martín Nieto committed
    • commit: support a root commits · 8381238e
      A root commit is a commit whose branch (usually what HEAD points to)
      doesn't exist (yet). This situation can happen when the commit is the
      first after 1) a repository is initialized or 2) a orphan checkout has
      been performed.
      
      Take this opportunity to remove the symbolic link check, as
      git_reference_resolve works on OID refs as well.
      
      Signed-off-by: Carlos Martín Nieto <cmn@elego.de>
      Carlos Martín Nieto committed
    • refs: don't loose info on resolve error · 68a146c1
      Typical use is git_reference_resolve(&ref, ref). Currently, if there is
      an error, ref will point to NULL, causing the user to lose that
      reference.
      
      Always update resolved_ref instead of just on finding an OID ref,
      storing the last valid reference in it.
      
      This change helps simplify the code for allowing root commits.
      
      Signed-off-by: Carlos Martín Nieto <cmn@elego.de>
      Carlos Martín Nieto committed
  10. 27 Apr, 2011 1 commit
  11. 26 Apr, 2011 2 commits
  12. 23 Apr, 2011 1 commit