pull = fetch/merge

CalculatorCInterface/calculator_c_interface_lib.cpp

@@ -67,10 +67,8 @@ int PushRepositoryInternal(char const *localRepoName, char const *branchName,
     return GitLibrary::PushRepository(localRepoName, branchName, userName, userPassword);
 }
 
-int PullRepositoryInternal(char const *localRepoName,
-                           char const *branchName, char const *user,
-                           char const *password) {
-    return GitLibrary::PullRepository(localRepoName, branchName, user, password);
+int PullRepositoryInternal(char const *localRepoName, char const *remoteRepoName) {
+    return GitLibrary::PullRepository(localRepoName, remoteRepoName);
 }
 
 #include <local_git_repository.h>

CalculatorCInterface/calculator_c_interface_lib.h

@@ -33,7 +33,7 @@ int CloneRepositoryInternal(char const *url, char const *local_path) CALCULATOR_
 int CheckoutRepositoryInternal(char const *url, char const *localRepoName, char const *branchName) CALCULATOR_C_INTERFACE_LIB_EXPORT;
 int CommitFileInternal(char const *local_path, char const *branch_name, char const *file_name, char const *commit_message) CALCULATOR_C_INTERFACE_LIB_EXPORT;
 int PushRepositoryInternal(char const *local_path, char const *branch_name, char const *user, char const *password) CALCULATOR_C_INTERFACE_LIB_EXPORT;
-int PullRepositoryInternal(char const *localRepoName, char const *branchName, char const *user, char const *password) CALCULATOR_C_INTERFACE_LIB_EXPORT;
+int PullRepositoryInternal(char const *localRepoName, char const *remoteRepoName) CALCULATOR_C_INTERFACE_LIB_EXPORT;
 
 #ifdef __cplusplus
 }

CalculatorCInterface/git_library.cpp

@@ -340,7 +340,8 @@ on_error:
 //
 // git merge
 //
-struct merge_options { const char **heads;
+struct merge_options { 
+    const char **heads;
     size_t heads_count;
 
     git_annotated_commit **annotated;
@@ -376,6 +377,229 @@ static void parse_options(const char **repo_path, struct merge_options *opts) {
 #endif
 }
 
+static void opts_add_refish(struct merge_options *opts, const char *refish) {
+    size_t sz;
+
+    assert(opts != NULL);
+
+    sz = ++opts->heads_count * sizeof(opts->heads[0]);
+    if ((opts->heads = (const char **)realloc((void *) opts->heads, sz)) != 0) {
+        opts->heads[opts->heads_count - 1] = refish;
+    }
+}
+
+static int resolve_heads(git_repository *repo, struct merge_options *opts) {
+    git_annotated_commit **annotated = (git_annotated_commit **)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], git_error_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_checkout_options ff_checkout_options;
+
+    // #define GIT_CHECKOUT_OPTIONS_INIT {GIT_CHECKOUT_OPTIONS_VERSION, GIT_CHECKOUT_SAFE}
+
+    git_checkout_options_init(&ff_checkout_options, GIT_CHECKOUT_OPTIONS_VERSION);
+    ff_checkout_options.checkout_strategy = GIT_CHECKOUT_SAFE;
+
+    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) {
+            qCritical() << HEADER << "failed to lookup HEAD ref";
+            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) {
+            qCritical() << HEADER << "failed to create master reference";
+            return -1;
+        }
+
+        git_reference_free(head_ref);
+    } else {
+        /* HEAD exists, just lookup and resolve */
+        err = git_repository_head(&target_ref, repo);
+        if (err != 0) {
+            qCritical() << HEADER << "failed to get HEAD reference";
+            return -1;
+        }
+    }
+
+    /* Lookup the target object */
+    err = git_object_lookup(&target, repo, target_oid, GIT_OBJECT_COMMIT);
+    if (err != 0) {
+        qCritical() << HEADER << QString("failed to lookup OID %s").arg(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) {
+        qCritical() << HEADER << "failed to checkout HEAD reference";
+        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) {
+        qCritical() << HEADER << "failed to move HEAD reference";
+        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(git_index_conflict_iterator_new(&conflicts, index), "failed to create conflict iterator", NULL);
+
+    while ((err = git_index_conflict_next(&ancestor, &our, &their, conflicts)) == 0) {
+        qCritical() << HEADER
+                    << QString("conflict: a:%s o:%s t:%s")
+                            .arg(ancestor ? ancestor->path : "NULL")
+                            .arg(our->path ? our->path : "NULL")
+                            .arg(their->path ? their->path : "NULL");
+    }
+
+    if (err != GIT_ITEROVER) {
+        qCritical() << HEADER << "error iterating conflicts";
+    }
+
+    git_index_conflict_iterator_free(conflicts);
+}
+
+static int create_merge_commit(git_repository *repo, git_index *index, struct 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 = (git_commit **)calloc(opts->annotated_count + 1, sizeof(git_commit *));
+
+    if (!parents) {
+        qCritical() << HEADER << "calloc failed";
+        return -1;
+    }
+  
+    const char *msg_target = NULL;
+    size_t msglen = 0;
+    char *msg;
+    size_t i;
+    int err;
+
+    /* Grab our needed references */
+    check(git_repository_head(&head_ref, repo), "failed to get repo HEAD", NULL);
+    if (resolve_refish(&merge_commit, repo, opts->heads[0])) {
+        qCritical() << HEADER << QString("failed to resolve refish %s").arg(opts->heads[0]);
+        free(parents);
+        return -1;
+    }
+
+    /* Maybe that's a ref, so DWIM it */
+    err = git_reference_dwim(&merge_ref, repo, opts->heads[0]);
+    check(err, "failed to DWIM reference", git_error_last()->message);
+
+    /* Grab a signature */
+    check(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(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++;
+    }
+  
+    if ((msg = (char *)malloc(msglen)) == nullptr) {
+        qCritical() << HEADER << 'malloc failed';
+        goto cleanup;
+    }
+    
+    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_OBJECT_COMMIT);
+    check(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(git_index_write_tree(&tree_oid, index), "failed to write merged tree", NULL);
+    check(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(err, "failed to create commit", NULL);
+
+    /* We're done merging, cleanup the repository state */
+    git_repository_state_cleanup(repo);
+
+cleanup:
+    free(parents);
+    return err;
+}
+
 static int merge(git_repository *repo) {
     struct merge_options opts;
     git_index *index;
@@ -388,6 +612,85 @@ static int merge(git_repository *repo) {
     merge_options_init(&opts);
     parse_options(&path, &opts);
 
+    state = (git_repository_state_t)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(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);
+        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_merge_options merge_opts;
+
+        git_merge_options_init(&merge_opts, GIT_MERGE_OPTIONS_VERSION);
+
+        // TODO: check this...
+        // merge_opts.file_flags = GIT_MERGE_FIND_RENAMES;
+
+        // GIT_MERGE_OPTIONS_VERSION, GIT_MERGE_FIND_RENAMES }
+
+        //git_checkout_options checkout_opts = GIT_CHECKOUT_OPTIONS_INIT;
+        git_checkout_options checkout_opts;
+
+        git_checkout_options_init(&checkout_opts, GIT_CHECKOUT_OPTIONS_VERSION);
+        checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE;
+
+        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(err, "merge failed", NULL);
+    }
+
+    /* If we get here, we actually performed the merge above */
+
+    check(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((char **)opts.heads);
     free(opts.annotated);
@@ -698,9 +1001,25 @@ int GitLibrary::PushRepository(char const *localRepoName, char const *branchName
     return error;
 }
 
-int GitLibrary::PullRepository(char const *localRepoName, char const *branchName,
-                               char const *userName, char const *userPassword) {
-    // "git pull" is a basiclly a "git fetch" followed by a "git merge"
+int GitLibrary::PullRepository(char const *localRepoName, char const *remoteRepoName) {
+    // "git pull" is a basically a "git fetch" followed by a "git merge"
+    git_repository *repo = nullptr;
+    int error = 0;
 
-    return 0;
+    if ((error = git_repository_open(&repo, localRepoName)) != 0) {
+    	// error
+    }
+    // remoteRepoName typically "origin"
+    if ((error = fetch(repo, remoteRepoName)) != 0) {
+	// error
+    }
+    if ((error = merge(repo)) != 0) {
+        // error
+    }
+
+    if (repo) {
+        git_repository_free(repo);
+    }
+
+    return error;
 }

CalculatorCInterface/git_library.h

@@ -38,7 +38,7 @@ public:
     static int CommitRepository(char const *localRepoName, char const *branchName, char const *commitMessage);
     static int CommitFile(char const *localRepoName, char const *branchName, char const *fName, char const *commitMessage);
     static int PushRepository(char const *localRepoName, char const *branchName, char const *userName, char const *userPassword);
-    static int PullRepository(char const *localRepoName, char const *branchName, char const *userName, char const *userPassword);
+    static int PullRepository(char const *localRepoName, char const *remoteRepoName);
 
     // explicit GitLibrary();
     // ~GitLibrary();