rugged 1.3.1 → 1.9.0

data/vendor/libgit2/src/cli/CMakeLists.txt

@@ -0,0 +1,56 @@
+set(CLI_INCLUDES
+	"${libgit2_BINARY_DIR}/src/util"
+	"${libgit2_BINARY_DIR}/include"
+	"${libgit2_SOURCE_DIR}/src/util"
+	"${libgit2_SOURCE_DIR}/src/cli"
+	"${libgit2_SOURCE_DIR}/include"
+	"${LIBGIT2_DEPENDENCY_INCLUDES}"
+	"${LIBGIT2_SYSTEM_INCLUDES}")
+
+if(WIN32 AND NOT CYGWIN)
+	file(GLOB CLI_SRC_OS win32/*.c)
+	list(SORT CLI_SRC_OS)
+else()
+	file(GLOB CLI_SRC_OS unix/*.c)
+	list(SORT CLI_SRC_OS)
+endif()
+
+file(GLOB CLI_SRC_C *.c *.h)
+list(SORT CLI_SRC_C)
+
+#
+# The CLI currently needs to be statically linked against libgit2 because
+# the utility library uses libgit2's thread-local error buffers.  TODO:
+# remove this dependency and allow us to dynamically link against libgit2.
+#
+
+if(BUILD_CLI STREQUAL "dynamic")
+	set(CLI_LIBGIT2_LIBRARY libgit2package)
+else()
+	set(CLI_LIBGIT2_OBJECTS $<TARGET_OBJECTS:libgit2>)
+endif()
+
+#
+# Compile and link the CLI
+#
+
+add_executable(git2_cli ${CLI_SRC_C} ${CLI_SRC_OS} ${CLI_OBJECTS}
+	$<TARGET_OBJECTS:util>
+	${CLI_LIBGIT2_OBJECTS}
+	${LIBGIT2_DEPENDENCY_OBJECTS})
+target_link_libraries(git2_cli ${CLI_LIBGIT2_LIBRARY} ${LIBGIT2_SYSTEM_LIBS})
+
+set_target_properties(git2_cli PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${libgit2_BINARY_DIR})
+set_target_properties(git2_cli PROPERTIES OUTPUT_NAME ${LIBGIT2_FILENAME})
+
+ide_split_sources(git2_cli)
+
+target_include_directories(git2_cli PRIVATE ${CLI_INCLUDES})
+
+if(MSVC_IDE)
+	# Precompiled headers
+	set_target_properties(git2_cli PROPERTIES COMPILE_FLAGS "/Yuprecompiled.h /FIprecompiled.h")
+	set_source_files_properties(win32/precompiled.c COMPILE_FLAGS "/Ycprecompiled.h")
+endif()
+
+install(TARGETS git2_cli RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})

data/vendor/libgit2/src/cli/README.md

@@ -0,0 +1,26 @@
+# cli
+
+A git-compatible command-line interface that uses libgit2.
+
+## Adding commands
+
+1. Individual commands have a `main`-like top-level entrypoint.  For example:
+
+   ```c
+   int cmd_help(int argc, char **argv)
+   ```
+
+   Although this is the same signature as `main`, commands are not built as
+   individual standalone executables, they'll be linked into the main cli.
+   (Though there may be an option for command executables to be built as
+   standalone executables in the future.)
+
+2. Commands are prototyped in `cmd.h` and added to `main.c`'s list of
+   commands (`cli_cmds[]`).  Commands should be specified with their name,
+   entrypoint and a brief description that can be printed in `git help`.
+   This is done because commands are linked into the main cli.
+
+3. Commands should accept a `--help` option that displays their help
+   information.  This will be shown when a user runs `<command> --help` and
+   when a user runs `help <command>`.
+

data/vendor/libgit2/src/{branch.h → cli/cmd.c}

@@ -4,16 +4,18 @@
  * This file is part of libgit2, distributed under the GNU GPL v2 with
  * a Linking Exception. For full terms see the included COPYING file.
  */
-#ifndef INCLUDE_branch_h__
-#define INCLUDE_branch_h__
 
 #include "common.h"
+#include "cmd.h"
 
-#include "buffer.h"
+const cli_cmd_spec *cli_cmd_spec_byname(const char *name)
+{
+	const cli_cmd_spec *cmd;
 
-int git_branch_upstream__name(
-	git_buf *tracking_name,
-	git_repository *repo,
-	const char *canonical_branch_name);
+	for (cmd = cli_cmds; cmd->name; cmd++) {
+		if (!strcmp(cmd->name, name))
+			return cmd;
+	}
 
-#endif
+	return NULL;
+}

data/vendor/libgit2/src/cli/cmd.h

@@ -0,0 +1,37 @@
+/*
+ * 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.
+ */
+
+#ifndef CLI_cmd_h__
+#define CLI_cmd_h__
+
+/* Command definitions */
+typedef struct {
+	const char *name;
+	int (*fn)(int argc, char **argv);
+	const char *desc;
+} cli_cmd_spec;
+
+/* Options that are common to all commands (eg --help, --git-dir) */
+extern const cli_opt_spec cli_common_opts[];
+
+/* All the commands supported by the CLI */
+extern const cli_cmd_spec cli_cmds[];
+
+/* Find a command by name */
+extern const cli_cmd_spec *cli_cmd_spec_byname(const char *name);
+
+/* Commands */
+extern int cmd_blame(int argc, char **argv);
+extern int cmd_cat_file(int argc, char **argv);
+extern int cmd_clone(int argc, char **argv);
+extern int cmd_config(int argc, char **argv);
+extern int cmd_hash_object(int argc, char **argv);
+extern int cmd_help(int argc, char **argv);
+extern int cmd_index_pack(int argc, char **argv);
+extern int cmd_init(int argc, char **argv);
+
+#endif /* CLI_cmd_h__ */

data/vendor/libgit2/src/cli/cmd_blame.c

@@ -0,0 +1,287 @@
+/*
+ * 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.
+ */
+
+#include <stdio.h>
+#include <git2.h>
+#include "common.h"
+#include "cmd.h"
+#include "error.h"
+#include "sighandler.h"
+#include "progress.h"
+
+#include "fs_path.h"
+#include "futils.h"
+#include "date.h"
+#include "hashmap.h"
+
+#define COMMAND_NAME "blame"
+
+static char *file;
+static int porcelain, line_porcelain;
+
+static const cli_opt_spec opts[] = {
+	CLI_COMMON_OPT,
+
+	{ CLI_OPT_TYPE_SWITCH,    "porcelain",      'p', &porcelain, 1,
+	  CLI_OPT_USAGE_DEFAULT,   NULL,            "show machine readable output" },
+	{ CLI_OPT_TYPE_SWITCH,    "line-porcelain",  0,  &line_porcelain, 1,
+	  CLI_OPT_USAGE_DEFAULT,   NULL,            "show individual lines in machine readable output" },
+	{ CLI_OPT_TYPE_LITERAL },
+	{ CLI_OPT_TYPE_ARG,       "file",            0,  &file, 0,
+	  CLI_OPT_USAGE_REQUIRED, "file",           "file to blame" },
+
+	{ 0 }
+};
+
+static void print_help(void)
+{
+	cli_opt_usage_fprint(stdout, PROGRAM_NAME, COMMAND_NAME, opts, 0);
+	printf("\n");
+
+	printf("Show the origin of each line of a file.\n");
+	printf("\n");
+
+	printf("Options:\n");
+
+	cli_opt_help_fprint(stdout, opts);
+}
+
+static int strintlen(size_t n)
+{
+	int len = 1;
+
+	while (n > 10) {
+		n /= 10;
+		len++;
+
+		if (len == INT_MAX)
+			break;
+	}
+
+	return len;
+}
+
+static int fmt_date(git_str *out, git_time_t time, int offset)
+{
+	time_t t;
+	struct tm gmt;
+
+	GIT_ASSERT_ARG(out);
+
+	t = (time_t)(time + offset * 60);
+
+	if (p_gmtime_r(&t, &gmt) == NULL)
+		return -1;
+
+	return git_str_printf(out, "%.4u-%02u-%02u %02u:%02u:%02u %+03d%02d",
+		gmt.tm_year + 1900, gmt.tm_mon + 1, gmt.tm_mday,
+		gmt.tm_hour, gmt.tm_min, gmt.tm_sec,
+		offset / 60, offset % 60);
+}
+
+static int print_standard(git_blame *blame)
+{
+	size_t max_line_number = 0;
+	int max_lineno_len, max_line_len, max_author_len = 0, max_path_len = 0;
+	const char *last_path = NULL;
+	const git_blame_line *line;
+	bool paths_differ = false;
+	git_str date_str = GIT_STR_INIT;
+	size_t i;
+	int ret = 0;
+
+	/* Compute the maximum size of things */
+	for (i = 0; i < git_blame_hunkcount(blame); i++) {
+		const git_blame_hunk *hunk = git_blame_hunk_byindex(blame, i);
+		size_t hunk_author_len = strlen(hunk->orig_signature->name);
+		size_t hunk_path_len = strlen(hunk->orig_path);
+		size_t hunk_max_line_number =
+			hunk->orig_start_line_number + hunk->lines_in_hunk;
+
+		if (hunk_max_line_number > max_line_number)
+			max_line_number = hunk_max_line_number;
+
+		if (hunk_author_len > INT_MAX)
+			max_author_len = INT_MAX;
+		else if ((int)hunk_author_len > max_author_len)
+			max_author_len = (int)hunk_author_len;
+
+		if (hunk_path_len > INT_MAX)
+			hunk_path_len = INT_MAX;
+		else if ((int)hunk_path_len > max_path_len)
+			max_path_len = (int)hunk_path_len;
+
+		if (!paths_differ && last_path != NULL &&
+		    strcmp(last_path, hunk->orig_path) != 0) {
+			paths_differ = true;
+		}
+
+		last_path = hunk->orig_path;
+	}
+
+	max_lineno_len = strintlen(max_line_number);
+
+	max_author_len--;
+
+	for (i = 1; i < git_blame_linecount(blame); i++) {
+		const git_blame_hunk *hunk = git_blame_hunk_byline(blame, i);
+		int oid_abbrev;
+
+		if (!hunk)
+			break;
+
+		oid_abbrev = hunk->boundary ? 7 : 8;
+		printf("%s%.*s ", hunk->boundary ? "^" : "",
+			oid_abbrev, git_oid_tostr_s(&hunk->orig_commit_id));
+
+		if (paths_differ)
+			printf("%-*.*s ", max_path_len, max_path_len, hunk->orig_path);
+
+		git_str_clear(&date_str);
+		if (fmt_date(&date_str,
+				hunk->orig_signature->when.time,
+				hunk->orig_signature->when.offset) < 0) {
+			ret = cli_error_git();
+			goto done;
+		}
+
+		if ((line = git_blame_line_byindex(blame, i)) == NULL) {
+			ret = cli_error_git();
+			goto done;
+		}
+
+		max_line_len = (int)min(line->len, INT_MAX);
+
+		printf("(%-*.*s %s %*" PRIuZ ") %.*s" ,
+			max_author_len, max_author_len, hunk->orig_signature->name,
+			date_str.ptr,
+			max_lineno_len, i,
+			max_line_len, line->ptr);
+		printf("\n");
+	}
+
+done:
+	git_str_dispose(&date_str);
+	return ret;
+}
+
+GIT_INLINE(uint32_t) oid_hashcode(const git_oid *oid)
+{
+	uint32_t hash;
+	memcpy(&hash, oid->id, sizeof(uint32_t));
+	return hash;
+}
+
+GIT_HASHSET_SETUP(git_blame_commitmap, const git_oid *, oid_hashcode, git_oid_equal);
+
+static int print_porcelain(git_blame *blame)
+{
+	git_blame_commitmap seen_ids = GIT_HASHSET_INIT;
+	size_t i, j;
+
+	for (i = 0; i < git_blame_hunkcount(blame); i++) {
+		const git_blame_line *line;
+		const git_blame_hunk *hunk = git_blame_hunk_byindex(blame, i);
+
+		for (j = 0; j < hunk->lines_in_hunk; j++) {
+			size_t line_number = hunk->final_start_line_number + j;
+			bool seen = git_blame_commitmap_contains(&seen_ids, &hunk->orig_commit_id);
+
+			printf("%s %" PRIuZ " %" PRIuZ,
+				git_oid_tostr_s(&hunk->orig_commit_id),
+				hunk->orig_start_line_number + j,
+				hunk->final_start_line_number + j);
+
+			if (!j)
+				printf(" %" PRIuZ, hunk->lines_in_hunk);
+
+			printf("\n");
+
+			if ((!j && !seen) || line_porcelain) {
+				printf("author %s\n", hunk->orig_signature->name);
+				printf("author-mail <%s>\n", hunk->orig_signature->email);
+				printf("author-time %" PRId64 "\n", hunk->orig_signature->when.time);
+				printf("author-tz %+03d%02d\n",
+					hunk->orig_signature->when.offset / 60,
+					hunk->orig_signature->when.offset % 60);
+
+				printf("committer %s\n", hunk->orig_committer->name);
+				printf("committer-mail <%s>\n", hunk->orig_committer->email);
+				printf("committer-time %" PRId64 "\n", hunk->orig_committer->when.time);
+				printf("committer-tz %+03d%02d\n",
+					hunk->orig_committer->when.offset / 60,
+					hunk->orig_committer->when.offset % 60);
+
+				printf("summary %s\n", hunk->summary);
+
+				/* TODO: previous */
+
+				printf("filename %s\n", hunk->orig_path);
+			}
+
+			if ((line = git_blame_line_byindex(blame, line_number)) == NULL)
+				return cli_error_git();
+
+			printf("\t%.*s\n", (int)min(line->len, INT_MAX),
+				line->ptr);
+
+			if (!seen)
+				git_blame_commitmap_add(&seen_ids, &hunk->orig_commit_id);
+		}
+	}
+
+	git_blame_commitmap_dispose(&seen_ids);
+	return 0;
+}
+
+int cmd_blame(int argc, char **argv)
+{
+	cli_repository_open_options open_opts = { argv + 1, argc - 1 };
+	git_blame_options blame_opts = GIT_BLAME_OPTIONS_INIT;
+	git_repository *repo = NULL;
+	git_str workdir_path = GIT_STR_INIT;
+	git_blame *blame = NULL;
+	cli_opt invalid_opt;
+	int ret = 0;
+
+	blame_opts.flags |= GIT_BLAME_USE_MAILMAP;
+
+	if (cli_opt_parse(&invalid_opt, opts, argv + 1, argc - 1, CLI_OPT_PARSE_GNU))
+		return cli_opt_usage_error(COMMAND_NAME, opts, &invalid_opt);
+
+	if (cli_opt__show_help) {
+		print_help();
+		return 0;
+	}
+
+	if (!file) {
+		ret = cli_error_usage("you must specify a file to blame");
+		goto done;
+	}
+
+	if (cli_repository_open(&repo, &open_opts) < 0)
+		return cli_error_git();
+
+	if ((ret = cli_resolve_path(&workdir_path, repo, file)) != 0)
+		goto done;
+
+	if (git_blame_file(&blame, repo, workdir_path.ptr, &blame_opts) < 0) {
+		ret = cli_error_git();
+		goto done;
+	}
+
+	if (porcelain || line_porcelain)
+		ret = print_porcelain(blame);
+	else
+		ret = print_standard(blame);
+
+done:
+	git_str_dispose(&workdir_path);
+	git_blame_free(blame);
+	git_repository_free(repo);
+	return ret;
+}

data/vendor/libgit2/src/cli/cmd_cat_file.c

@@ -0,0 +1,202 @@
+/*
+ * 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.
+ */
+
+#include <git2.h>
+#include "common.h"
+#include "cmd.h"
+
+#define COMMAND_NAME "cat-file"
+
+typedef enum {
+	DISPLAY_CONTENT = 0,
+	DISPLAY_EXISTS,
+	DISPLAY_PRETTY,
+	DISPLAY_SIZE,
+	DISPLAY_TYPE
+} display_t;
+
+static int display = DISPLAY_CONTENT;
+static char *type_name, *object_spec;
+
+static const cli_opt_spec opts[] = {
+	CLI_COMMON_OPT,
+
+	{ CLI_OPT_TYPE_SWITCH,     NULL,    't', &display,    DISPLAY_TYPE,
+	  CLI_OPT_USAGE_REQUIRED,  NULL,    "display the type of the object" },
+	{ CLI_OPT_TYPE_SWITCH,     NULL,    's', &display,    DISPLAY_SIZE,
+	  CLI_OPT_USAGE_CHOICE,    NULL,    "display the size of the object" },
+	{ CLI_OPT_TYPE_SWITCH,     NULL,    'e', &display,    DISPLAY_EXISTS,
+	  CLI_OPT_USAGE_CHOICE,    NULL,    "displays nothing unless the object is corrupt" },
+	{ CLI_OPT_TYPE_SWITCH,     NULL,    'p', &display,    DISPLAY_PRETTY,
+	  CLI_OPT_USAGE_CHOICE,    NULL,    "pretty-print the object" },
+	{ CLI_OPT_TYPE_ARG,       "type",    0, &type_name,   0,
+	  CLI_OPT_USAGE_CHOICE,   "type",   "the type of object to display" },
+	{ CLI_OPT_TYPE_ARG,       "object",  0, &object_spec, 0,
+	  CLI_OPT_USAGE_REQUIRED, "object", "the object to display" },
+	{ 0 },
+};
+
+static void print_help(void)
+{
+	cli_opt_usage_fprint(stdout, PROGRAM_NAME, COMMAND_NAME, opts, 0);
+	printf("\n");
+
+	printf("Display the content for the given object in the repository.\n");
+	printf("\n");
+
+	printf("Options:\n");
+
+	cli_opt_help_fprint(stdout, opts);
+}
+
+static int print_odb(git_object *object, display_t display)
+{
+	git_odb *odb = NULL;
+	git_odb_object *odb_object = NULL;
+	const unsigned char *content;
+	git_object_size_t size;
+	int ret = 0;
+
+	/*
+	 * Our parsed blobs retain the raw content; all other objects are
+	 * parsed into a working representation.  To get the raw content,
+	 * we need to do an ODB lookup.  (Thankfully, this should be cached
+	 * in-memory from our last call.)
+	 */
+	if (git_object_type(object) == GIT_OBJECT_BLOB) {
+		content = git_blob_rawcontent((git_blob *)object);
+		size = git_blob_rawsize((git_blob *)object);
+	} else {
+		if (git_repository_odb(&odb, git_object_owner(object)) < 0 ||
+		    git_odb_read(&odb_object, odb, git_object_id(object)) < 0) {
+			ret = cli_error_git();
+			goto done;
+		}
+
+		content = git_odb_object_data(odb_object);
+		size = git_odb_object_size(odb_object);
+	}
+
+	switch (display) {
+	case DISPLAY_SIZE:
+		if (printf("%" PRIu64 "\n", size) < 0)
+			ret = cli_error_os();
+		break;
+	case DISPLAY_CONTENT:
+		if (p_write(fileno(stdout), content, (size_t)size) < 0)
+			ret = cli_error_os();
+		break;
+	default:
+		GIT_ASSERT(0);
+	}
+
+done:
+	git_odb_object_free(odb_object);
+	git_odb_free(odb);
+	return ret;
+}
+
+static int print_type(git_object *object)
+{
+	if (printf("%s\n", git_object_type2string(git_object_type(object))) < 0)
+		return cli_error_os();
+
+	return 0;
+}
+
+static int print_pretty(git_object *object)
+{
+	const git_tree_entry *entry;
+	size_t i, count;
+
+	/*
+	 * Only trees are stored in an unreadable format and benefit from
+	 * pretty-printing.
+	 */
+	if (git_object_type(object) != GIT_OBJECT_TREE)
+		return print_odb(object, DISPLAY_CONTENT);
+
+	for (i = 0, count = git_tree_entrycount((git_tree *)object); i < count; i++) {
+		entry = git_tree_entry_byindex((git_tree *)object, i);
+
+		if (printf("%06o %s %s\t%s\n",
+		           git_tree_entry_filemode_raw(entry),
+		           git_object_type2string(git_tree_entry_type(entry)),
+		           git_oid_tostr_s(git_tree_entry_id(entry)),
+		           git_tree_entry_name(entry)) < 0)
+			return cli_error_os();
+	}
+
+	return 0;
+}
+
+int cmd_cat_file(int argc, char **argv)
+{
+	cli_repository_open_options open_opts = { argv + 1, argc - 1};
+	git_repository *repo = NULL;
+	git_object *object = NULL;
+	git_object_t type;
+	cli_opt invalid_opt;
+	int giterr, ret = 0;
+
+	if (cli_opt_parse(&invalid_opt, opts, argv + 1, argc - 1, CLI_OPT_PARSE_GNU))
+		return cli_opt_usage_error(COMMAND_NAME, opts, &invalid_opt);
+
+	if (cli_opt__show_help) {
+		print_help();
+		return 0;
+	}
+
+	if (cli_repository_open(&repo, &open_opts) < 0)
+		return cli_error_git();
+
+	if ((giterr = git_revparse_single(&object, repo, object_spec)) < 0) {
+		if (display == DISPLAY_EXISTS && giterr == GIT_ENOTFOUND)
+			ret = 1;
+		else
+			ret = cli_error_git();
+
+		goto done;
+	}
+
+	if (type_name) {
+		git_object *peeled;
+
+		if ((type = git_object_string2type(type_name)) == GIT_OBJECT_INVALID) {
+			ret = cli_error_usage("invalid object type '%s'", type_name);
+			goto done;
+		}
+
+		if (git_object_peel(&peeled, object, type) < 0) {
+			ret = cli_error_git();
+			goto done;
+		}
+
+		git_object_free(object);
+		object = peeled;
+	}
+
+	switch (display) {
+	case DISPLAY_EXISTS:
+		ret = 0;
+		break;
+	case DISPLAY_TYPE:
+		ret = print_type(object);
+		break;
+	case DISPLAY_PRETTY:
+		ret = print_pretty(object);
+		break;
+	default:
+		ret = print_odb(object, display);
+		break;
+	}
+
+done:
+	git_object_free(object);
+	git_repository_free(repo);
+	return ret;
+}