rugged 0.17.0.b7 → 0.18.0.b1

data/vendor/libgit2/src/netops.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2012 the libgit2 contributors
+ * Copyright (C) the libgit2 contributors. All rights reserved.
  *
  * This file is part of libgit2, distributed under the GNU GPL v2 with
  * a Linking Exception. For full terms see the included COPYING file.
@@ -10,33 +10,68 @@
 #include "posix.h"
 #include "common.h"
 
+#ifdef GIT_SSL
+# include <openssl/ssl.h>
+#endif
+
+struct gitno_ssl {
+#ifdef GIT_SSL
+	SSL_CTX *ctx;
+	SSL *ssl;
+#else
+	size_t dummy;
+#endif
+};
+
+typedef struct gitno_ssl gitno_ssl;
+
+/* Represents a socket that may or may not be using SSL */
+struct gitno_socket {
+	GIT_SOCKET socket;
+	gitno_ssl ssl;
+};
+
+typedef struct gitno_socket gitno_socket;
+
 struct gitno_buffer {
 	char *data;
 	size_t len;
 	size_t offset;
-	GIT_SOCKET fd;
-#ifdef GIT_SSL
-	struct gitno_ssl *ssl;
-#endif
-	int (*recv)(gitno_buffer *buffer);
+	gitno_socket *socket;
+	int (*recv)(struct gitno_buffer *buffer);
 	void *cb_data;
 };
 
-void gitno_buffer_setup(git_transport *t, gitno_buffer *buf, char *data, size_t len);
-void gitno_buffer_setup_callback(git_transport *t, gitno_buffer *buf, char *data, size_t len, int (*recv)(gitno_buffer *buf), void *cb_data);
+typedef struct gitno_buffer gitno_buffer;
+
+/* Flags to gitno_connect */
+enum {
+	/* Attempt to create an SSL connection. */
+	GITNO_CONNECT_SSL = 1,
+
+	/* Valid only when GITNO_CONNECT_SSL is also specified.
+	 * Indicates that the server certificate should not be validated. */
+	GITNO_CONNECT_SSL_NO_CHECK_CERT = 2,
+};
+
+void gitno_buffer_setup(gitno_socket *t, gitno_buffer *buf, char *data, size_t len);
+void gitno_buffer_setup_callback(gitno_socket *t, gitno_buffer *buf, char *data, size_t len, int (*recv)(gitno_buffer *buf), void *cb_data);
 int gitno_recv(gitno_buffer *buf);
-int gitno__recv(gitno_buffer *buf);
 
 void gitno_consume(gitno_buffer *buf, const char *ptr);
 void gitno_consume_n(gitno_buffer *buf, size_t cons);
 
-int gitno_connect(git_transport *t, const char *host, const char *port);
-int gitno_send(git_transport *t, const char *msg, size_t len, int flags);
-int gitno_close(GIT_SOCKET s);
-int gitno_ssl_teardown(git_transport *t);
-int gitno_send_chunk_size(int s, size_t len);
+int gitno_connect(gitno_socket *socket, const char *host, const char *port, int flags);
+int gitno_send(gitno_socket *socket, const char *msg, size_t len, int flags);
+int gitno_close(gitno_socket *s);
 int gitno_select_in(gitno_buffer *buf, long int sec, long int usec);
 
-int gitno_extract_host_and_port(char **host, char **port, const char *url, const char *default_port);
+int gitno_extract_url_parts(
+		char **host,
+		char **port,
+		char **username,
+		char **password,
+		const char *url,
+		const char *default_port);
 
 #endif

data/vendor/libgit2/src/notes.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2012 the libgit2 contributors
+ * Copyright (C) the libgit2 contributors. All rights reserved.
  *
  * This file is part of libgit2, distributed under the GNU GPL v2 with
  * a Linking Exception. For full terms see the included COPYING file.
@@ -11,6 +11,7 @@
 #include "refs.h"
 #include "config.h"
 #include "iterator.h"
+#include "signature.h"
 
 static int find_subtree_in_current_level(
 	git_tree **out,
@@ -19,11 +20,11 @@ static int find_subtree_in_current_level(
 	const char *annotated_object_sha,
 	int fanout)
 {
-	unsigned int i;
+	size_t i;
 	const git_tree_entry *entry;
 
 	*out = NULL;
-	
+
 	if (parent == NULL)
 		return GIT_ENOTFOUND;
 
@@ -34,12 +35,12 @@ static int find_subtree_in_current_level(
 			continue;
 
 		if (S_ISDIR(git_tree_entry_filemode(entry))
-			&& strlen(git_tree_entry_name(entry)) == 2 
+			&& strlen(git_tree_entry_name(entry)) == 2
 			&& !strncmp(git_tree_entry_name(entry), annotated_object_sha + fanout, 2))
 			return git_tree_lookup(out, repo, git_tree_entry_id(entry));
 
 		/* Not a DIR, so do we have an already existing blob? */
-		if (!strcmp(git_tree_entry_name(entry), annotated_object_sha + fanout))				
+		if (!strcmp(git_tree_entry_name(entry), annotated_object_sha + fanout))
 			return GIT_EEXISTS;
 	}
 
@@ -71,7 +72,7 @@ static int find_subtree_r(git_tree **out, git_tree *root,
 
 static int find_blob(git_oid *blob, git_tree *tree, const char *target)
 {
-	unsigned int i;
+	size_t i;
 	const git_tree_entry *entry;
 
 	for (i=0; i<git_tree_entrycount(tree); i++) {
@@ -128,10 +129,10 @@ static int manipulate_note_in_tree_r(
 	git_tree *parent,
 	git_oid *note_oid,
 	const char *annotated_object_sha,
-	int fanout, 
+	int fanout,
 	int (*note_exists_cb)(
-		git_tree **out, 
-		git_repository *repo, 
+		git_tree **out,
+		git_repository *repo,
 		git_tree *parent,
 		git_oid *note_oid,
 		const char *annotated_object_sha,
@@ -146,7 +147,7 @@ static int manipulate_note_in_tree_r(
 		int fanout,
 		int current_error))
 {
-	int error = -1;	
+	int error;
 	git_tree *subtree = NULL, *new = NULL;
 	char subtree_name[3];
 
@@ -263,18 +264,19 @@ static int insert_note_in_tree_enotfound_cb(git_tree **out,
 
 static int note_write(git_oid *out,
 	git_repository *repo,
-	git_signature *author,
-	git_signature *committer,
+	const git_signature *author,
+	const git_signature *committer,
 	const char *notes_ref,
 	const char *note,
 	git_tree *commit_tree,
 	const char *target,
-	git_commit **parents)
+	git_commit **parents,
+	int allow_note_overwrite)
 {
 	int error;
 	git_oid oid;
 	git_tree *tree = NULL;
-	
+
 	// TODO: should we apply filters?
 	/* create note object */
 	if ((error = git_blob_create_frombuffer(&oid, repo, note, strlen(note))) < 0)
@@ -282,7 +284,8 @@ static int note_write(git_oid *out,
 
 	if ((error = manipulate_note_in_tree_r(
 		&tree, repo, commit_tree, &oid, target, 0,
-		insert_note_in_tree_eexists_cb, insert_note_in_tree_enotfound_cb)) < 0)
+		allow_note_overwrite ? insert_note_in_tree_enotfound_cb : insert_note_in_tree_eexists_cb,
+		insert_note_in_tree_enotfound_cb)) < 0)
 		goto cleanup;
 
 	if (out)
@@ -343,14 +346,14 @@ cleanup:
 }
 
 static int note_remove(git_repository *repo,
-		       git_signature *author, git_signature *committer,
-		       const char *notes_ref, git_tree *tree,
-		       const char *target, git_commit **parents)
+		const git_signature *author, const git_signature *committer,
+		const char *notes_ref, git_tree *tree,
+		const char *target, git_commit **parents)
 {
 	int error;
 	git_tree *tree_after_removal = NULL;
 	git_oid oid;
-		
+
 	if ((error = manipulate_note_in_tree_r(
 		&tree_after_removal, repo, tree, NULL, target, 0,
 		remove_note_in_tree_eexists_cb, remove_note_in_tree_enotfound_cb)) < 0)
@@ -406,7 +409,7 @@ static int retrieve_note_tree_and_commit(
 	if ((error = normalize_namespace(notes_ref, repo)) < 0)
 		return error;
 
-	if ((error = git_reference_name_to_oid(&oid, repo, *notes_ref)) < 0)
+	if ((error = git_reference_name_to_id(&oid, repo, *notes_ref)) < 0)
 		return error;
 
 	if (git_commit_lookup(commit_out, repo, &oid) < 0)
@@ -442,10 +445,14 @@ cleanup:
 }
 
 int git_note_create(
-	git_oid *out, git_repository *repo,
-	git_signature *author, git_signature *committer,
-	const char *notes_ref, const git_oid *oid,
-	const char *note)
+	git_oid *out,
+	git_repository *repo,
+	const git_signature *author,
+	const git_signature *committer,
+	const char *notes_ref,
+	const git_oid *oid,
+	const char *note,
+	int allow_note_overwrite)
 {
 	int error;
 	char *target = NULL;
@@ -461,7 +468,7 @@ int git_note_create(
 		goto cleanup;
 
 	error = note_write(out, repo, author, committer, notes_ref,
-			   note, tree, target, &commit);
+			note, tree, target, &commit, allow_note_overwrite);
 
 cleanup:
 	git__free(target);
@@ -471,8 +478,8 @@ cleanup:
 }
 
 int git_note_remove(git_repository *repo, const char *notes_ref,
-		    git_signature *author, git_signature *committer,
-		    const git_oid *oid)
+		const git_signature *author, const git_signature *committer,
+		const git_oid *oid)
 {
 	int error;
 	char *target = NULL;
@@ -501,13 +508,13 @@ int git_note_default_ref(const char **out, git_repository *repo)
 	return note_get_default_ref(out, repo);
 }
 
-const char * git_note_message(git_note *note)
+const char * git_note_message(const git_note *note)
 {
 	assert(note);
 	return note->message;
 }
 
-const git_oid * git_note_oid(git_note *note)
+const git_oid * git_note_oid(const git_note *note)
 {
 	assert(note);
 	return &note->oid;
@@ -524,14 +531,11 @@ void git_note_free(git_note *note)
 
 static int process_entry_path(
 	const char* entry_path,
-	const git_oid *note_oid,
-	int (*note_cb)(git_note_data *note_data, void *payload),
-	void *payload)
+	git_oid *annotated_object_id)
 {
 	int error = -1;
 	size_t i = 0, j = 0, len;
 	git_buf buf = GIT_BUF_INIT;
-	git_note_data note_data;
 
 	if ((error = git_buf_puts(&buf, entry_path)) < 0)
 		goto cleanup;
@@ -564,14 +568,7 @@ static int process_entry_path(
 		goto cleanup;
 	}
 
-	if ((error = git_oid_fromstr(
-			&note_data.annotated_object_oid, buf.ptr)) < 0)
-		goto cleanup;
-
-	git_oid_cpy(&note_data.blob_oid, note_oid);
-
-	if (note_cb(&note_data, payload))
-		error = GIT_EUSER;
+	error = git_oid_fromstr(annotated_object_id, buf.ptr);
 
 cleanup:
 	git_buf_free(&buf);
@@ -579,32 +576,86 @@ cleanup:
 }
 
 int git_note_foreach(
+    git_repository *repo,
+    const char *notes_ref,
+    git_note_foreach_cb note_cb,
+    void *payload)
+{
+    int error;
+    git_note_iterator *iter = NULL;
+    git_oid note_id, annotated_id;
+
+    if ((error = git_note_iterator_new(&iter, repo, notes_ref)) < 0)
+        return error;
+
+    while (!(error = git_note_next(&note_id, &annotated_id, iter))) {
+        if (note_cb(&note_id, &annotated_id, payload)) {
+            error = GIT_EUSER;
+            break;
+        }
+    }
+
+    if (error == GIT_ITEROVER)
+        error = 0;
+
+    git_note_iterator_free(iter);
+    return error;
+}
+
+
+void git_note_iterator_free(git_note_iterator *it)
+{
+	if (it == NULL)
+		return;
+
+	git_iterator_free(it);
+}
+
+
+int git_note_iterator_new(
+	git_note_iterator **it,
 	git_repository *repo,
-	const char *notes_ref,
-	int (*note_cb)(git_note_data *note_data, void *payload),
-	void *payload)
+	const char *notes_ref)
 {
 	int error;
-	git_iterator *iter = NULL;
-	git_tree *tree = NULL;
 	git_commit *commit = NULL;
-	const git_index_entry *item;
-
-	if (!(error = retrieve_note_tree_and_commit(
-			&tree, &commit, repo, &notes_ref)) &&
-		!(error = git_iterator_for_tree(&iter, repo, tree)))
-		error = git_iterator_current(iter, &item);
+	git_tree *tree = NULL;
 
-	while (!error && item) {
-		error = process_entry_path(item->path, &item->oid, note_cb, payload);
+	error = retrieve_note_tree_and_commit(&tree, &commit, repo, &notes_ref);
+	if (error < 0)
+		goto cleanup;
 
-		if (!error)
-			error = git_iterator_advance(iter, &item);
-	}
+	if ((error = git_iterator_for_tree(it, tree, 0, NULL, NULL)) < 0)
+		git_iterator_free(*it);
 
-	git_iterator_free(iter);
+cleanup:
 	git_tree_free(tree);
 	git_commit_free(commit);
 
 	return error;
 }
+
+int git_note_next(
+	git_oid* note_id,
+	git_oid* annotated_id,
+	git_note_iterator *it)
+{
+	int error;
+	const git_index_entry *item;
+
+	if ((error = git_iterator_current(&item, it)) < 0)
+		goto exit;
+
+	if (item != NULL) {
+		git_oid_cpy(note_id, &item->oid);
+		error = process_entry_path(item->path, annotated_id);
+
+		if (error >= 0)
+			error = git_iterator_advance(NULL, it);
+	} else {
+		error = GIT_ITEROVER;
+	}
+
+exit:
+	return error;
+}

data/vendor/libgit2/src/notes.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2012 the libgit2 contributors
+ * Copyright (C) the libgit2 contributors. All rights reserved.
  *
  * This file is part of libgit2, distributed under the GNU GPL v2 with
  * a Linking Exception. For full terms see the included COPYING file.
@@ -10,6 +10,7 @@
 #include "common.h"
 
 #include "git2/oid.h"
+#include "git2/types.h"
 
 #define GIT_NOTES_DEFAULT_REF "refs/notes/commits"
 

data/vendor/libgit2/src/object.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2012 the libgit2 contributors
+ * Copyright (C) the libgit2 contributors. All rights reserved.
  *
  * This file is part of libgit2, distributed under the GNU GPL v2 with
  * a Linking Exception. For full terms see the included COPYING file.
@@ -87,7 +87,7 @@ int git_object__from_odb_object(
 	git_object *object = NULL;
 
 	if (type != GIT_OBJ_ANY && type != odb_obj->raw.type) {
-		giterr_set(GITERR_ODB, "The requested type does not match the type in the ODB");
+		giterr_set(GITERR_INVALID, "The requested type does not match the type in the ODB");
 		return GIT_ENOTFOUND;
 	}
 
@@ -161,7 +161,7 @@ int git_object_lookup_prefix(
 		if (object != NULL) {
 			if (type != GIT_OBJ_ANY && type != object->type) {
 				git_object_free(object);
-				giterr_set(GITERR_ODB, "The given type does not match the type in ODB");
+				giterr_set(GITERR_INVALID, "The requested type does not match the type in ODB");
 				return GIT_ENOTFOUND;
 			}
 
@@ -304,52 +304,6 @@ size_t git_object__size(git_otype type)
 	return git_objects_table[type].size;
 }
 
-int git_object__resolve_to_type(git_object **obj, git_otype type)
-{
-	int error = 0;
-	git_object *scan, *next;
-
-	if (type == GIT_OBJ_ANY)
-		return 0;
-
-	scan = *obj;
-
-	while (!error && scan && git_object_type(scan) != type) {
-
-		switch (git_object_type(scan)) {
-		case GIT_OBJ_COMMIT:
-		{
-			git_tree *tree = NULL;
-			error = git_commit_tree(&tree, (git_commit *)scan);
-			next = (git_object *)tree;
-			break;
-		}
-
-		case GIT_OBJ_TAG:
-			error = git_tag_target(&next, (git_tag *)scan);
-			break;
-
-		default:
-			giterr_set(GITERR_REFERENCE, "Object does not resolve to type");
-			error = -1;
-			next = NULL;
-			break;
-		}
-
-		git_object_free(scan);
-		scan = next;
-	}
-
-	*obj = scan;
-	return error;
-}
-
-static int peel_error(int error, const char* msg)
-{
-	giterr_set(GITERR_INVALID, "The given object cannot be peeled - %s", msg);
-	return error;
-}
-
 static int dereference_object(git_object **dereferenced, git_object *obj)
 {
 	git_otype type = git_object_type(obj);
@@ -362,31 +316,55 @@ static int dereference_object(git_object **dereferenced, git_object *obj)
 		return git_tag_target(dereferenced, (git_tag*)obj);
 
 	case GIT_OBJ_BLOB:
-		return peel_error(GIT_ERROR, "cannot dereference blob");
+		return GIT_ENOTFOUND;
 
 	case GIT_OBJ_TREE:
-		return peel_error(GIT_ERROR, "cannot dereference tree");
+		return GIT_EAMBIGUOUS;
 
 	default:
-		return peel_error(GIT_ENOTFOUND, "unexpected object type encountered");
+		return GIT_EINVALIDSPEC;
 	}
 }
 
+static int peel_error(int error, const git_oid *oid, git_otype type)
+{
+	const char *type_name;
+	char hex_oid[GIT_OID_HEXSZ + 1];
+
+	type_name = git_object_type2string(type);
+
+	git_oid_fmt(hex_oid, oid);
+	hex_oid[GIT_OID_HEXSZ] = '\0';
+
+	giterr_set(GITERR_OBJECT, "The git_object of id '%s' can not be "
+		"successfully peeled into a %s (git_otype=%i).", hex_oid, type_name, type);
+
+	return error;
+}
+
 int git_object_peel(
 	git_object **peeled,
-	git_object *object,
+	const git_object *object,
 	git_otype target_type)
 {
 	git_object *source, *deref = NULL;
+	int error;
+
+	if (target_type != GIT_OBJ_TAG && 
+		target_type != GIT_OBJ_COMMIT && 
+		target_type != GIT_OBJ_TREE && 
+		target_type != GIT_OBJ_BLOB && 
+		target_type != GIT_OBJ_ANY)
+			return GIT_EINVALIDSPEC;
 
 	assert(object && peeled);
 
 	if (git_object_type(object) == target_type)
-		return git_object__dup(peeled, object);
+		return git_object_dup(peeled, (git_object *)object);
 
-	source = object;
+	source = (git_object *)object;
 
-	while (!dereference_object(&deref, source)) {
+	while (!(error = dereference_object(&deref, source))) {
 
 		if (source != object)
 			git_object_free(source);
@@ -411,5 +389,16 @@ int git_object_peel(
 		git_object_free(source);
 
 	git_object_free(deref);
-	return -1;
+
+	if (error)
+		error = peel_error(error, git_object_id(object), target_type);
+
+	return error;
+}
+
+int git_object_dup(git_object **dest, git_object *source)
+{
+	git_cached_obj_incref(source);
+	*dest = source;
+	return 0;
 }