rugged 1.4.5 → 1.5.0

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,135 @@
+/*
+ * 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 type)
+{
+	git_oid oid;
+
+	if (!literally) {
+		int valid = 0;
+
+		if (git_object_rawcontent_is_valid(&valid, buf->ptr, buf->size, type) < 0 || !valid)
+			return cli_error_git();
+	}
+
+	if (write_object) {
+		if (git_odb_write(&oid, odb, buf->ptr, buf->size, type) < 0)
+			return cli_error_git();
+	} else {
+		if (git_odb_hash(&oid, buf->ptr, buf->size, type) < 0)
+			return cli_error_git();
+	}
+
+	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_str buf = GIT_STR_INIT;
+	cli_opt invalid_opt;
+	git_object_t 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 && (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;
+	}
+
+	/*
+	 * 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, 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, type)) != 0)
+				goto done;
+		}
+	}
+
+done:
+	git_str_dispose(&buf);
+	git_odb_free(odb);
+	git_repository_free(repo);
+	return ret;
+}

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

@@ -0,0 +1,86 @@
+/*
+ * 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"
+
+#define COMMAND_NAME "help"
+
+static char *command;
+static int show_help;
+
+static const cli_opt_spec opts[] = {
+	{ CLI_OPT_TYPE_SWITCH,   "help",     0, &show_help, 1,
+	  CLI_OPT_USAGE_HIDDEN,   NULL,     "display help about the help command" },
+	{ CLI_OPT_TYPE_ARG,      "command",  0, &command,   0,
+	  CLI_OPT_USAGE_DEFAULT, "command", "the command to show help for" },
+	{ 0 },
+};
+
+static int print_help(void)
+{
+	cli_opt_usage_fprint(stdout, PROGRAM_NAME, COMMAND_NAME, opts);
+	printf("\n");
+
+	printf("Display help information about %s.  If a command is specified, help\n", PROGRAM_NAME);
+	printf("about that command will be shown.  Otherwise, general information about\n");
+	printf("%s will be shown, including the commands available.\n", PROGRAM_NAME);
+
+	return 0;
+}
+
+static int print_commands(void)
+{
+	const cli_cmd_spec *cmd;
+
+	cli_opt_usage_fprint(stdout, PROGRAM_NAME, NULL, cli_common_opts);
+	printf("\n");
+
+	printf("These are the %s commands available:\n\n", PROGRAM_NAME);
+
+	for (cmd = cli_cmds; cmd->name; cmd++)
+		printf("   %-11s  %s\n", cmd->name, cmd->desc);
+
+	printf("\nSee '%s help <command>' for more information on a specific command.\n", PROGRAM_NAME);
+
+	return 0;
+}
+
+int cmd_help(int argc, char **argv)
+{
+	char *fake_args[2];
+	const cli_cmd_spec *cmd;
+	cli_opt invalid_opt;
+
+	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);
+
+	/* Show the meta-help */
+	if (show_help)
+		return print_help();
+
+	/* We were not asked to show help for a specific command. */
+	if (!command)
+		return print_commands();
+
+	/*
+	 * If we were asked for help for a command (eg, `help <command>`),
+	 * delegate back to that command's `--help` option.  This lets
+	 * commands own their help.  Emulate the command-line arguments
+	 * that would invoke `<command> --help` and invoke that command.
+	 */
+	fake_args[0] = command;
+	fake_args[1] = "--help";
+
+	if ((cmd = cli_cmd_spec_byname(command)) == NULL)
+		return cli_error("'%s' is not a %s command. See '%s help'.",
+		                command, PROGRAM_NAME, PROGRAM_NAME);
+
+	return cmd->fn(2, fake_args);
+}

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

@@ -0,0 +1,51 @@
+/*
+ * 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_error_h__
+#define CLI_error_h__
+
+#include "cli.h"
+#include <stdio.h>
+
+#define CLI_EXIT_OK      0
+#define CLI_EXIT_ERROR   1
+#define CLI_EXIT_OS    128
+#define CLI_EXIT_GIT   128
+#define CLI_EXIT_USAGE 129
+
+#define cli_error__print(fmt) do { \
+		va_list ap; \
+		va_start(ap, fmt); \
+		fprintf(stderr, "%s: ", PROGRAM_NAME); \
+		vfprintf(stderr, fmt, ap); \
+		fprintf(stderr, "\n"); \
+		va_end(ap); \
+	} while(0)
+
+GIT_INLINE(int) cli_error(const char *fmt, ...)
+{
+	cli_error__print(fmt);
+	return CLI_EXIT_ERROR;
+}
+
+GIT_INLINE(int) cli_error_usage(const char *fmt, ...)
+{
+	cli_error__print(fmt);
+	return CLI_EXIT_USAGE;
+}
+
+GIT_INLINE(int) cli_error_git(void)
+{
+	const git_error *err = git_error_last();
+	fprintf(stderr, "%s: %s\n", PROGRAM_NAME,
+	        err ? err->message : "unknown error");
+	return CLI_EXIT_GIT;
+}
+
+#define cli_error_os() (perror(PROGRAM_NAME), CLI_EXIT_OS)
+
+#endif /* CLI_error_h__ */