rugged 1.3.2 → 1.6.2

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/cli/cli.h

@@ -0,0 +1,20 @@
+/*
+ * 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_cli_h__
+#define CLI_cli_h__
+
+#define PROGRAM_NAME "git2"
+
+#include "git2_util.h"
+
+#include "error.h"
+#include "opt.h"
+#include "opt_usage.h"
+#include "sighandler.h"
+
+#endif /* CLI_cli_h__ */

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

@@ -0,0 +1,21 @@
+/*
+ * 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 "cli.h"
+#include "cmd.h"
+
+const cli_cmd_spec *cli_cmd_spec_byname(const char *name)
+{
+	const cli_cmd_spec *cmd;
+
+	for (cmd = cli_cmds; cmd->name; cmd++) {
+		if (!strcmp(cmd->name, name))
+			return cmd;
+	}
+
+	return NULL;
+}

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

@@ -0,0 +1,33 @@
+/*
+ * 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_cat_file(int argc, char **argv);
+extern int cmd_clone(int argc, char **argv);
+extern int cmd_hash_object(int argc, char **argv);
+extern int cmd_help(int argc, char **argv);
+
+#endif /* CLI_cmd_h__ */

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

@@ -0,0 +1,204 @@
+/*
+ * 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 "cli.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 show_help;
+static int display = DISPLAY_CONTENT;
+static char *type_name, *object_spec;
+
+static const cli_opt_spec opts[] = {
+	{ CLI_OPT_TYPE_SWITCH,    "help",    0, &show_help,   1,
+	  CLI_OPT_USAGE_HIDDEN | CLI_OPT_USAGE_STOP_PARSING, NULL,
+	  "display help about the " COMMAND_NAME " command" },
+
+	{ 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);
+	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)
+{
+	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 (show_help) {
+		print_help();
+		return 0;
+	}
+
+	if (git_repository_open_ext(&repo, ".", GIT_REPOSITORY_OPEN_FROM_ENV, NULL) < 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;
+}

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

@@ -0,0 +1,176 @@
+/*
+ * 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 "cli.h"
+#include "cmd.h"
+#include "error.h"
+#include "sighandler.h"
+#include "progress.h"
+
+#include "fs_path.h"
+#include "futils.h"
+
+#define COMMAND_NAME "clone"
+
+static char *branch, *remote_path, *local_path;
+static int show_help, quiet, checkout = 1, bare;
+static bool local_path_exists;
+static cli_progress progress = CLI_PROGRESS_INIT;
+
+static const cli_opt_spec opts[] = {
+	{ CLI_OPT_TYPE_SWITCH,    "help",         0,  &show_help,   1,
+	  CLI_OPT_USAGE_HIDDEN | CLI_OPT_USAGE_STOP_PARSING, NULL,
+	  "display help about the " COMMAND_NAME " command" },
+
+	{ CLI_OPT_TYPE_SWITCH,    "quiet",       'q', &quiet,       1,
+	  CLI_OPT_USAGE_DEFAULT,   NULL,         "display the type of the object" },
+	{ CLI_OPT_TYPE_SWITCH,    "no-checkout", 'n', &checkout,    0,
+	  CLI_OPT_USAGE_DEFAULT,   NULL,         "don't checkout HEAD" },
+	{ CLI_OPT_TYPE_SWITCH,    "bare",         0,  &bare,        1,
+	  CLI_OPT_USAGE_DEFAULT,   NULL,         "don't create a working directory" },
+	{ CLI_OPT_TYPE_VALUE,     "branch",      'b', &branch,      0,
+	  CLI_OPT_USAGE_DEFAULT,  "name",        "branch to check out" },
+	{ CLI_OPT_TYPE_LITERAL },
+	{ CLI_OPT_TYPE_ARG,       "repository",   0,  &remote_path, 0,
+	  CLI_OPT_USAGE_REQUIRED, "repository",  "repository path" },
+	{ CLI_OPT_TYPE_ARG,       "directory",    0,  &local_path,  0,
+	  CLI_OPT_USAGE_DEFAULT,  "directory",    "directory to clone into" },
+	{ 0 }
+};
+
+static void print_help(void)
+{
+	cli_opt_usage_fprint(stdout, PROGRAM_NAME, COMMAND_NAME, opts);
+	printf("\n");
+
+	printf("Clone a repository into a new directory.\n");
+	printf("\n");
+
+	printf("Options:\n");
+
+	cli_opt_help_fprint(stdout, opts);
+}
+
+static char *compute_local_path(const char *orig_path)
+{
+	const char *slash;
+	char *local_path;
+
+	if ((slash = strrchr(orig_path, '/')) == NULL &&
+	    (slash = strrchr(orig_path, '\\')) == NULL)
+		local_path = git__strdup(orig_path);
+	else
+		local_path = git__strdup(slash + 1);
+
+	return local_path;
+}
+
+static bool validate_local_path(const char *path)
+{
+	if (!git_fs_path_exists(path))
+		return false;
+
+	if (!git_fs_path_isdir(path) || !git_fs_path_is_empty_dir(path)) {
+		fprintf(stderr, "fatal: destination path '%s' already exists and is not an empty directory.\n",
+			path);
+		exit(128);
+	}
+
+	return true;
+}
+
+static void cleanup(void)
+{
+	int rmdir_flags = GIT_RMDIR_REMOVE_FILES;
+
+	cli_progress_abort(&progress);
+
+	if (local_path_exists)
+		rmdir_flags |= GIT_RMDIR_SKIP_ROOT;
+
+	if (!git_fs_path_isdir(local_path))
+		return;
+
+	git_futils_rmdir_r(local_path, NULL, rmdir_flags);
+}
+
+static void interrupt_cleanup(void)
+{
+	cleanup();
+	exit(130);
+}
+
+int cmd_clone(int argc, char **argv)
+{
+	git_clone_options clone_opts = GIT_CLONE_OPTIONS_INIT;
+	git_repository *repo = NULL;
+	cli_opt invalid_opt;
+	char *computed_path = NULL;
+	int 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 (show_help) {
+		print_help();
+		return 0;
+	}
+
+	if (!remote_path) {
+		ret = cli_error_usage("you must specify a repository to clone");
+		goto done;
+	}
+
+	if (bare)
+		clone_opts.bare = 1;
+
+	if (branch)
+		clone_opts.checkout_branch = branch;
+
+	if (!checkout)
+		clone_opts.checkout_opts.checkout_strategy = GIT_CHECKOUT_NONE;
+
+	if (!local_path)
+		local_path = computed_path = compute_local_path(remote_path);
+
+	local_path_exists = validate_local_path(local_path);
+
+	cli_sighandler_set_interrupt(interrupt_cleanup);
+
+	if (!local_path_exists &&
+	    git_futils_mkdir(local_path, 0777, 0) < 0) {
+		ret = cli_error_git();
+		goto done;
+	}
+
+	if (!quiet) {
+		clone_opts.fetch_opts.callbacks.sideband_progress = cli_progress_fetch_sideband;
+		clone_opts.fetch_opts.callbacks.transfer_progress = cli_progress_fetch_transfer;
+		clone_opts.fetch_opts.callbacks.payload = &progress;
+
+		clone_opts.checkout_opts.progress_cb = cli_progress_checkout;
+		clone_opts.checkout_opts.progress_payload = &progress;
+
+		printf("Cloning into '%s'...\n", local_path);
+	}
+
+	if (git_clone(&repo, remote_path, local_path, &clone_opts) < 0) {
+		cleanup();
+		ret = cli_error_git();
+		goto done;
+	}
+
+	cli_progress_finish(&progress);
+
+done:
+	cli_progress_dispose(&progress);
+	git__free(computed_path);
+	git_repository_free(repo);
+	return ret;
+}

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

@@ -0,0 +1,154 @@
+/*
+ * 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 "cli.h"
+#include "cmd.h"
+
+#include "futils.h"
+
+#define COMMAND_NAME "hash-object"
+
+static int show_help;
+static char *type_name;
+static int write_object, read_stdin, literally;
+static char **filenames;
+
+static const cli_opt_spec opts[] = {
+	{ CLI_OPT_TYPE_SWITCH,   "help",      0, &show_help,    1,
+	  CLI_OPT_USAGE_HIDDEN | CLI_OPT_USAGE_STOP_PARSING, NULL,
+	  "display help about the " COMMAND_NAME " command" },
+
+	{ CLI_OPT_TYPE_VALUE,     NULL,      't', &type_name,    0,
+	  CLI_OPT_USAGE_DEFAULT, "type",     "the type of object to hash (default: \"blob\")" },
+	{ CLI_OPT_TYPE_SWITCH,    NULL,      'w', &write_object, 1,
+	  CLI_OPT_USAGE_DEFAULT,  NULL,      "write the object to the object database" },
+	{ CLI_OPT_TYPE_SWITCH,   "literally", 0, &literally,    1,
+	  CLI_OPT_USAGE_DEFAULT,  NULL,      "do not validate the object contents" },
+	{ CLI_OPT_TYPE_SWITCH,   "stdin",     0, &read_stdin,   1,
+	  CLI_OPT_USAGE_REQUIRED, NULL,      "read content from stdin" },
+	{ CLI_OPT_TYPE_ARGS,     "file",      0, &filenames,    0,
+	  CLI_OPT_USAGE_CHOICE,  "file",     "the file (or files) to read and hash" },
+	{ 0 },
+};
+
+static void print_help(void)
+{
+	cli_opt_usage_fprint(stdout, PROGRAM_NAME, COMMAND_NAME, opts);
+	printf("\n");
+
+	printf("Compute the object ID for a given file and optionally write that file\nto the object database.\n");
+	printf("\n");
+
+	printf("Options:\n");
+
+	cli_opt_help_fprint(stdout, opts);
+}
+
+static int hash_buf(
+	git_odb *odb,
+	git_str *buf,
+	git_object_t object_type,
+	git_oid_t oid_type)
+{
+	git_oid oid;
+
+	if (!literally) {
+		int valid = 0;
+
+#ifdef GIT_EXPERIMENTAL_SHA256
+		if (git_object_rawcontent_is_valid(&valid, buf->ptr, buf->size, object_type, oid_type) < 0 || !valid)
+			return cli_error_git();
+#else
+		GIT_UNUSED(oid_type);
+
+		if (git_object_rawcontent_is_valid(&valid, buf->ptr, buf->size, object_type) < 0 || !valid)
+			return cli_error_git();
+#endif
+	}
+
+	if (write_object) {
+		if (git_odb_write(&oid, odb, buf->ptr, buf->size, object_type) < 0)
+			return cli_error_git();
+	} else {
+#ifdef GIT_EXPERIMENTAL_SHA256
+		if (git_odb_hash(&oid, buf->ptr, buf->size, object_type, GIT_OID_SHA1) < 0)
+			return cli_error_git();
+#else
+		if (git_odb_hash(&oid, buf->ptr, buf->size, object_type) < 0)
+			return cli_error_git();
+#endif
+	}
+
+	if (printf("%s\n", git_oid_tostr_s(&oid)) < 0)
+		return cli_error_os();
+
+	return 0;
+}
+
+int cmd_hash_object(int argc, char **argv)
+{
+	git_repository *repo = NULL;
+	git_odb *odb = NULL;
+	git_oid_t oid_type;
+	git_str buf = GIT_STR_INIT;
+	cli_opt invalid_opt;
+	git_object_t object_type = GIT_OBJECT_BLOB;
+	char **filename;
+	int 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 (show_help) {
+		print_help();
+		return 0;
+	}
+
+	if (type_name && (object_type = git_object_string2type(type_name)) == GIT_OBJECT_INVALID)
+		return cli_error_usage("invalid object type '%s'", type_name);
+
+	if (write_object &&
+	    (git_repository_open_ext(&repo, ".", GIT_REPOSITORY_OPEN_FROM_ENV, NULL) < 0 ||
+	     git_repository_odb(&odb, repo) < 0)) {
+		ret = cli_error_git();
+		goto done;
+	}
+
+	oid_type = git_repository_oid_type(repo);
+
+	/*
+	 * TODO: we're reading blobs, we shouldn't pull them all into main
+	 * memory, we should just stream them into the odb instead.
+	 * (Or create a `git_odb_writefile` API.)
+	 */
+	if (read_stdin) {
+		if (git_futils_readbuffer_fd_full(&buf, fileno(stdin)) < 0) {
+			ret = cli_error_git();
+			goto done;
+		}
+
+		if ((ret = hash_buf(odb, &buf, object_type, oid_type)) != 0)
+			goto done;
+	} else {
+		for (filename = filenames; *filename; filename++) {
+			if (git_futils_readbuffer(&buf, *filename) < 0) {
+				ret = cli_error_git();
+				goto done;
+			}
+
+			if ((ret = hash_buf(odb, &buf, object_type, oid_type)) != 0)
+				goto done;
+		}
+	}
+
+done:
+	git_str_dispose(&buf);
+	git_odb_free(odb);
+	git_repository_free(repo);
+	return ret;
+}