diff options
author | Patrick Steinhardt <ps@pks.im> | 2018-02-01 09:42:33 +0000 |
---|---|---|
committer | GitHub <noreply@github.com> | 2018-02-01 09:42:33 +0000 |
commit | f55accce05c3eff9a3ef09a06e80c09135328790 (patch) | |
tree | 340d9dc82695e5893ccb8c0507b2340fa940e8a6 | |
parent | 341608dcd47f1c36ed8cb00e84d3e150bdda70fb (diff) | |
parent | 33f44db9d0a169493335708daa91d57288f13515 (diff) | |
download | libgit2-f55accce05c3eff9a3ef09a06e80c09135328790.tar.gz |
Merge pull request #4040 from tiennou/examples/merge
Merge example
-rw-r--r-- | examples/CMakeLists.txt | 2 | ||||
-rw-r--r-- | examples/common.c | 10 | ||||
-rw-r--r-- | examples/common.h | 5 | ||||
-rw-r--r-- | examples/describe.c | 10 | ||||
-rw-r--r-- | examples/merge.c | 396 | ||||
-rw-r--r-- | examples/network/fetch.c | 7 | ||||
-rw-r--r-- | examples/network/git2.c | 53 |
7 files changed, 447 insertions, 36 deletions
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt index a6f26c7a6..99e2ba9c1 100644 --- a/examples/CMakeLists.txt +++ b/examples/CMakeLists.txt @@ -1,7 +1,7 @@ LINK_DIRECTORIES(${LIBGIT2_LIBDIRS}) INCLUDE_DIRECTORIES(${LIBGIT2_INCLUDES}) -FILE(GLOB_RECURSE SRC_EXAMPLE_GIT2 network/*.c network/*.h) +FILE(GLOB_RECURSE SRC_EXAMPLE_GIT2 network/*.c network/*.h common.?) ADD_EXECUTABLE(cgit2 ${SRC_EXAMPLE_GIT2}) IF(WIN32 OR ANDROID) TARGET_LINK_LIBRARIES(cgit2 git2) diff --git a/examples/common.c b/examples/common.c index 96f5eaa8e..118072044 100644 --- a/examples/common.c +++ b/examples/common.c @@ -235,3 +235,13 @@ void treeish_to_tree( git_object_free(obj); } +void *xrealloc(void *oldp, size_t newsz) +{ + void *p = realloc(oldp, newsz); + if (p == NULL) { + fprintf(stderr, "Cannot allocate memory, exiting.\n"); + exit(1); + } + return p; +} + diff --git a/examples/common.h b/examples/common.h index adea0d318..af42324c2 100644 --- a/examples/common.h +++ b/examples/common.h @@ -103,3 +103,8 @@ extern int diff_output( */ extern void treeish_to_tree( git_tree **out, git_repository *repo, const char *treeish); + +/** + * A realloc that exits on failure + */ +extern void *xrealloc(void *oldp, size_t newsz); diff --git a/examples/describe.c b/examples/describe.c index 4cdf61f75..2005de4ae 100644 --- a/examples/describe.c +++ b/examples/describe.c @@ -47,16 +47,6 @@ typedef struct { typedef struct args_info args_info; -static void *xrealloc(void *oldp, size_t newsz) -{ - void *p = realloc(oldp, newsz); - if (p == NULL) { - fprintf(stderr, "Cannot allocate memory, exiting.\n"); - exit(1); - } - return p; -} - static void opts_add_commit(describe_options *opts, const char *commit) { size_t sz; diff --git a/examples/merge.c b/examples/merge.c new file mode 100644 index 000000000..59982cb9b --- /dev/null +++ b/examples/merge.c @@ -0,0 +1,396 @@ +/* + * libgit2 "merge" example - shows how to perform merges + * + * Written by the libgit2 contributors + * + * To the extent possible under law, the author(s) have dedicated all copyright + * and related and neighboring rights to this software to the public domain + * worldwide. This software is distributed without any warranty. + * + * You should have received a copy of the CC0 Public Domain Dedication along + * with this software. If not, see + * <http://creativecommons.org/publicdomain/zero/1.0/>. + */ + +#include "common.h" +#include <assert.h> + +#ifdef _MSC_VER +#define snprintf sprintf_s +#endif + +/** The following example demonstrates how to do merges with libgit2. + * + * It will merge whatever commit-ish you pass in into the current branch. + * + * Recognized options are : + * --no-commit: don't actually commit the merge. + * + */ + +typedef struct { + const char **heads; + size_t heads_count; + + git_annotated_commit **annotated; + size_t annotated_count; + + int no_commit : 1; +} merge_options; + +static void print_usage(void) +{ + fprintf(stderr, "usage: merge [--no-commit] <commit...>\n"); + exit(1); +} + +static void merge_options_init(merge_options *opts) +{ + memset(opts, 0, sizeof(*opts)); + + opts->heads = NULL; + opts->heads_count = 0; + opts->annotated = NULL; + opts->annotated_count = 0; +} + +static void opts_add_refish(merge_options *opts, const char *refish) +{ + size_t sz; + + assert(opts != NULL); + + sz = ++opts->heads_count * sizeof(opts->heads[0]); + opts->heads = xrealloc(opts->heads, sz); + opts->heads[opts->heads_count - 1] = refish; +} + +static void parse_options(const char **repo_path, merge_options *opts, int argc, char **argv) +{ + struct args_info args = ARGS_INFO_INIT; + + if (argc <= 1) + print_usage(); + + for (args.pos = 1; args.pos < argc; ++args.pos) { + const char *curr = argv[args.pos]; + + if (curr[0] != '-') { + opts_add_refish(opts, curr); + } else if (!strcmp(curr, "--no-commit")) { + opts->no_commit = 1; + } else if (match_str_arg(repo_path, &args, "--git-dir")) { + continue; + } else { + print_usage(); + } + } +} + +static int resolve_refish(git_annotated_commit **commit, git_repository *repo, const char *refish) +{ + git_reference *ref; + int err = 0; + git_oid oid; + + assert(commit != NULL); + + err = git_reference_dwim(&ref, repo, refish); + if (err == GIT_OK) { + git_annotated_commit_from_ref(commit, repo, ref); + git_reference_free(ref); + return 0; + } + + err = git_oid_fromstr(&oid, refish); + if (err == GIT_OK) { + err = git_annotated_commit_lookup(commit, repo, &oid); + } + + return err; +} + +static int resolve_heads(git_repository *repo, merge_options *opts) +{ + git_annotated_commit **annotated = calloc(opts->heads_count, sizeof(git_annotated_commit *)); + size_t annotated_count = 0, i; + int err = 0; + + for (i = 0; i < opts->heads_count; i++) { + err = resolve_refish(&annotated[annotated_count++], repo, opts->heads[i]); + if (err != 0) { + fprintf(stderr, "failed to resolve refish %s: %s\n", opts->heads[i], giterr_last()->message); + annotated_count--; + continue; + } + } + + if (annotated_count != opts->heads_count) { + fprintf(stderr, "unable to parse some refish\n"); + free(annotated); + return -1; + } + + opts->annotated = annotated; + opts->annotated_count = annotated_count; + return 0; +} + +static int perform_fastforward(git_repository *repo, const git_oid *target_oid, int is_unborn) +{ + git_checkout_options ff_checkout_options = GIT_CHECKOUT_OPTIONS_INIT; + git_reference *target_ref; + git_reference *new_target_ref; + git_object *target = NULL; + int err = 0; + + if (is_unborn) { + const char *symbolic_ref; + git_reference *head_ref; + + /* HEAD reference is unborn, lookup manually so we don't try to resolve it */ + err = git_reference_lookup(&head_ref, repo, "HEAD"); + if (err != 0) { + fprintf(stderr, "failed to lookup HEAD ref\n"); + return -1; + } + + /* Grab the reference HEAD should be pointing to */ + symbolic_ref = git_reference_symbolic_target(head_ref); + + /* Create our master reference on the target OID */ + err = git_reference_create(&target_ref, repo, symbolic_ref, target_oid, 0, NULL); + if (err != 0) { + fprintf(stderr, "failed to create master reference\n"); + return -1; + } + + git_reference_free(head_ref); + } else { + /* HEAD exists, just lookup and resolve */ + err = git_repository_head(&target_ref, repo); + if (err != 0) { + fprintf(stderr, "failed to get HEAD reference\n"); + return -1; + } + } + + /* Lookup the target object */ + err = git_object_lookup(&target, repo, target_oid, GIT_OBJ_COMMIT); + if (err != 0) { + fprintf(stderr, "failed to lookup OID %s\n", git_oid_tostr_s(target_oid)); + return -1; + } + + /* Checkout the result so the workdir is in the expected state */ + ff_checkout_options.checkout_strategy = GIT_CHECKOUT_SAFE; + err = git_checkout_tree(repo, target, &ff_checkout_options); + if (err != 0) { + fprintf(stderr, "failed to checkout HEAD reference\n"); + return -1; + } + + /* Move the target reference to the target OID */ + err = git_reference_set_target(&new_target_ref, target_ref, target_oid, NULL); + if (err != 0) { + fprintf(stderr, "failed to move HEAD reference\n"); + return -1; + } + + git_reference_free(target_ref); + git_reference_free(new_target_ref); + git_object_free(target); + + return 0; +} + +static void output_conflicts(git_index *index) +{ + git_index_conflict_iterator *conflicts; + const git_index_entry *ancestor; + const git_index_entry *our; + const git_index_entry *their; + int err = 0; + + check_lg2(git_index_conflict_iterator_new(&conflicts, index), "failed to create conflict iterator", NULL); + + while ((err = git_index_conflict_next(&ancestor, &our, &their, conflicts)) == 0) { + fprintf(stderr, "conflict: a:%s o:%s t:%s\n", + ancestor ? ancestor->path : "NULL", + our->path ? our->path : "NULL", + their->path ? their->path : "NULL"); + } + + if (err != GIT_ITEROVER) { + fprintf(stderr, "error iterating conflicts\n"); + } + + git_index_conflict_iterator_free(conflicts); +} + +static int create_merge_commit(git_repository *repo, git_index *index, merge_options *opts) +{ + git_oid tree_oid, commit_oid; + git_tree *tree; + git_signature *sign; + git_reference *merge_ref = NULL; + git_annotated_commit *merge_commit; + git_reference *head_ref; + git_commit **parents = calloc(opts->annotated_count + 1, sizeof(git_commit *)); + const char *msg_target = NULL; + size_t msglen = 0; + char *msg; + size_t i; + int err; + + /* Grab our needed references */ + check_lg2(git_repository_head(&head_ref, repo), "failed to get repo HEAD", NULL); + if (resolve_refish(&merge_commit, repo, opts->heads[0])) { + fprintf(stderr, "failed to resolve refish %s", opts->heads[0]); + return -1; + } + + /* Maybe that's a ref, so DWIM it */ + err = git_reference_dwim(&merge_ref, repo, opts->heads[0]); + check_lg2(err, "failed to DWIM reference", giterr_last()->message); + + /* Grab a signature */ + check_lg2(git_signature_now(&sign, "Me", "me@example.com"), "failed to create signature", NULL); + +#define MERGE_COMMIT_MSG "Merge %s '%s'" + /* Prepare a standard merge commit message */ + if (merge_ref != NULL) { + check_lg2(git_branch_name(&msg_target, merge_ref), "failed to get branch name of merged ref", NULL); + } else { + msg_target = git_oid_tostr_s(git_annotated_commit_id(merge_commit)); + } + + msglen = snprintf(NULL, 0, MERGE_COMMIT_MSG, (merge_ref ? "branch" : "commit"), msg_target); + if (msglen > 0) msglen++; + msg = malloc(msglen); + err = snprintf(msg, msglen, MERGE_COMMIT_MSG, (merge_ref ? "branch" : "commit"), msg_target); + + /* This is only to silence the compiler */ + if (err < 0) goto cleanup; + + /* Setup our parent commits */ + err = git_reference_peel((git_object **)&parents[0], head_ref, GIT_OBJ_COMMIT); + check_lg2(err, "failed to peel head reference", NULL); + for (i = 0; i < opts->annotated_count; i++) { + git_commit_lookup(&parents[i + 1], repo, git_annotated_commit_id(opts->annotated[i])); + } + + /* Prepare our commit tree */ + check_lg2(git_index_write_tree(&tree_oid, index), "failed to write merged tree", NULL); + check_lg2(git_tree_lookup(&tree, repo, &tree_oid), "failed to lookup tree", NULL); + + /* Commit time ! */ + err = git_commit_create(&commit_oid, + repo, git_reference_name(head_ref), + sign, sign, + NULL, msg, + tree, + opts->annotated_count + 1, (const git_commit **)parents); + check_lg2(err, "failed to create commit", NULL); + + /* We're done merging, cleanup the repository state */ + git_repository_state_cleanup(repo); + +cleanup: + free(parents); + return err; +} + +int main(int argc, char **argv) +{ + git_repository *repo = NULL; + merge_options opts; + git_index *index; + git_repository_state_t state; + git_merge_analysis_t analysis; + git_merge_preference_t preference; + const char *path = "."; + int err = 0; + + merge_options_init(&opts); + parse_options(&path, &opts, argc, argv); + + git_libgit2_init(); + + check_lg2(git_repository_open_ext(&repo, path, 0, NULL), + "Could not open repository", NULL); + + state = git_repository_state(repo); + if (state != GIT_REPOSITORY_STATE_NONE) { + fprintf(stderr, "repository is in unexpected state %d\n", state); + goto cleanup; + } + + err = resolve_heads(repo, &opts); + if (err != 0) + goto cleanup; + + err = git_merge_analysis(&analysis, &preference, + repo, + (const git_annotated_commit **)opts.annotated, + opts.annotated_count); + check_lg2(err, "merge analysis failed", NULL); + + if (analysis & GIT_MERGE_ANALYSIS_UP_TO_DATE) { + printf("Already up-to-date\n"); + return 0; + } else if (analysis & GIT_MERGE_ANALYSIS_UNBORN || + (analysis & GIT_MERGE_ANALYSIS_FASTFORWARD && + !(preference & GIT_MERGE_PREFERENCE_NO_FASTFORWARD))) { + const git_oid *target_oid; + if (analysis & GIT_MERGE_ANALYSIS_UNBORN) { + printf("Unborn\n"); + } else { + printf("Fast-forward\n"); + } + + /* Since this is a fast-forward, there can be only one merge head */ + target_oid = git_annotated_commit_id(opts.annotated[0]); + assert(opts.annotated_count == 1); + + return perform_fastforward(repo, target_oid, (analysis & GIT_MERGE_ANALYSIS_UNBORN)); + } else if (analysis & GIT_MERGE_ANALYSIS_NORMAL) { + git_merge_options merge_opts = GIT_MERGE_OPTIONS_INIT; + git_checkout_options checkout_opts = GIT_CHECKOUT_OPTIONS_INIT; + + merge_opts.flags = 0; + merge_opts.file_flags = GIT_MERGE_FILE_STYLE_DIFF3; + + checkout_opts.checkout_strategy = GIT_CHECKOUT_FORCE|GIT_CHECKOUT_ALLOW_CONFLICTS; + + if (preference & GIT_MERGE_PREFERENCE_FASTFORWARD_ONLY) { + printf("Fast-forward is preferred, but only a merge is possible\n"); + return -1; + } + + err = git_merge(repo, + (const git_annotated_commit **)opts.annotated, opts.annotated_count, + &merge_opts, &checkout_opts); + check_lg2(err, "merge failed", NULL); + } + + /* If we get here, we actually performed the merge above */ + + check_lg2(git_repository_index(&index, repo), "failed to get repository index", NULL); + + if (git_index_has_conflicts(index)) { + /* Handle conflicts */ + output_conflicts(index); + } else if (!opts.no_commit) { + create_merge_commit(repo, index, &opts); + printf("Merge made\n"); + } + +cleanup: + free(opts.heads); + free(opts.annotated); + git_repository_free(repo); + git_libgit2_shutdown(); + + return 0; +} diff --git a/examples/network/fetch.c b/examples/network/fetch.c index 10974a9f1..76b301193 100644 --- a/examples/network/fetch.c +++ b/examples/network/fetch.c @@ -8,13 +8,6 @@ # include <unistd.h> #endif -struct dl_data { - git_remote *remote; - git_fetch_options *fetch_opts; - int ret; - int finished; -}; - static int progress_cb(const char *str, int len, void *data) { (void)data; diff --git a/examples/network/git2.c b/examples/network/git2.c index 448103c46..1d3d27b1b 100644 --- a/examples/network/git2.c +++ b/examples/network/git2.c @@ -2,10 +2,11 @@ #include <stdio.h> #include <string.h> +#include "../common.h" #include "common.h" -// This part is not strictly libgit2-dependent, but you can use this -// as a starting point for a git-like tool +/* This part is not strictly libgit2-dependent, but you can use this + * as a starting point for a git-like tool */ struct { char *name; @@ -18,20 +19,12 @@ struct { { NULL, NULL} }; -static int run_command(git_cb fn, int argc, char **argv) +static int run_command(git_cb fn, git_repository *repo, struct args_info args) { int error; - git_repository *repo; - - // Before running the actual command, create an instance of the local - // repository and pass it to the function. - - error = git_repository_open(&repo, ".git"); - if (error < 0) - repo = NULL; - // Run the command. If something goes wrong, print the error message to stderr - error = fn(repo, argc, argv); + /* Run the command. If something goes wrong, print the error message to stderr */ + error = fn(repo, args.argc - args.pos, &args.argv[args.pos]); if (error < 0) { if (giterr_last() == NULL) fprintf(stderr, "Error without message"); @@ -39,9 +32,6 @@ static int run_command(git_cb fn, int argc, char **argv) fprintf(stderr, "Bad news:\n %s\n", giterr_last()->message); } - if(repo) - git_repository_free(repo); - return !!error; } @@ -49,6 +39,10 @@ int main(int argc, char **argv) { int i; int return_code = 1; + int error; + git_repository *repo; + struct args_info args = ARGS_INFO_INIT; + const char *git_dir = NULL; if (argc < 2) { fprintf(stderr, "usage: %s <cmd> [repo]\n", argv[0]); @@ -57,9 +51,30 @@ int main(int argc, char **argv) git_libgit2_init(); + for (args.pos = 1; args.pos < args.argc; ++args.pos) { + char *a = args.argv[args.pos]; + + if (a[0] != '-') { + /* non-arg */ + break; + } else if (optional_str_arg(&git_dir, &args, "--git-dir", ".git")) { + continue; + } else if (!strcmp(a, "--")) { + /* arg separator */ + break; + } + } + + /* Before running the actual command, create an instance of the local + * repository and pass it to the function. */ + + error = git_repository_open(&repo, git_dir); + if (error < 0) + repo = NULL; + for (i = 0; commands[i].name != NULL; ++i) { - if (!strcmp(argv[1], commands[i].name)) { - return_code = run_command(commands[i].fn, --argc, ++argv); + if (!strcmp(args.argv[args.pos], commands[i].name)) { + return_code = run_command(commands[i].fn, repo, args); goto shutdown; } } @@ -67,6 +82,8 @@ int main(int argc, char **argv) fprintf(stderr, "Command not found: %s\n", argv[1]); shutdown: + git_repository_free(repo); + git_libgit2_shutdown(); return return_code; |