Utils.cpp

Go to the documentation of this file.

#include "Utils.h"
#include "UI/ConflictsWindow.h"
#include "UI/CredentialsWindow.h"

#include <StorageKit.h>

#include <git2.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>


BString
extract_current_directory(const BMessage* msg)
{   
    // Get current directory path.
    entry_ref dirRef;
    if (msg->FindRef("dir_ref", &dirRef) != B_OK) {
        printf("No dir_ref found!\n");
        return NULL;
    }
    BEntry entry;
    entry.SetTo(&dirRef);
    BPath path;
    entry.GetPath(&path);
    return BString(path.Path());
}


void
extract_selected_paths(const BMessage* msg, vector<char*>& selected)
{
    // Get current directory
    BString dir = extract_current_directory(msg);
    // Get all the selected refs
    entry_ref fileRef;
    for (int refs=0;
             msg->FindRef("refs", refs, &fileRef) == B_NO_ERROR;
             refs++) {
        BEntry entry;
        entry.SetTo(&fileRef);
        BPath path;
        entry.GetPath(&path);
        BString relativePath(path.Path());
        // Generate relative path from absolute path
        relativePath.ReplaceFirst(dir, "");
        relativePath.ReplaceFirst("/", "");
        // To convert const char* to char*
        char* p = (char*) malloc(relativePath.Length());
        strcpy(p, relativePath.String());
        selected.push_back(p);
    }
}


BString
get_root_of_repo(BString dirPath)
{
    git_libgit2_init();
    git_buf buf = GIT_BUF_INIT_CONST(NULL, 0);

    // Check if current directory is in git repo.
    int ret = git_repository_discover(&buf, dirPath.String(), 0, NULL);
    git_libgit2_shutdown();

    // Return root of repo if current directory is in git repo
    // else return current directory.
    return (ret == 0) ? BString(buf.ptr) : dirPath;
}


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;
}


int
create_commit(git_repository* repo, git_index* index, const char* message)
{
    git_tree* tree;
    git_commit* parent;
    git_oid tree_id, commit_id, parent_id;
    git_signature* sign;
    git_config* cfg;
    git_config* cfg_snapshot;
    int ret;

    git_config_open_ondisk(&cfg, "/boot/home/config/settings/git/config");
    git_config_snapshot(&cfg_snapshot, cfg);
    
    const char *user_name, *user_email;
    ret = git_config_get_string(&user_name, cfg_snapshot, "user.name");
    if (ret < 0)
        return ret;

    ret = git_config_get_string(&user_email, cfg_snapshot, "user.email");
    if (ret < 0)
        return ret;

    // Get default commiter
    ret = git_signature_now(&sign, user_name, user_email);
    if (ret < 0)
        return ret;
    
    // Init tree_id
    ret = git_index_write_tree(&tree_id, index);
    if (ret < 0)
        return ret;

    git_index_free(index);

    // Init tree
    ret = git_tree_lookup(&tree, repo, &tree_id);
    if (ret < 0)
        return ret;

    ret = git_reference_name_to_id(&parent_id, repo, "HEAD");
    if (ret < 0) {
        // No parent commit found. This might be initial commit.
        ret = git_commit_create_v(&commit_id, repo, "HEAD", sign, sign, NULL,
                message, tree, 0);
        return ret;
    }

    ret = git_commit_lookup(&parent, repo, &parent_id);
    if (ret < 0)
        return ret;

    // Create commit
    ret = git_commit_create_v(&commit_id, repo, "HEAD", sign, sign, NULL,
            message, tree, 1, parent);
    return ret;
}


void output_conflicts(git_index *index)
{
    ConflictsWindow* conflictsWindow = new ConflictsWindow();
    git_index_conflict_iterator *conflicts;
    const git_index_entry *ancestor;
    const git_index_entry *our;
    const git_index_entry *their;
    int err = 0;
    BString conflictsString;

    err = git_index_conflict_iterator_new(&conflicts, index);
    if (err < 0) {
        conflictsString << "Failed to create conflict iterator!\n";
        goto ret;
    }

    while ((err = git_index_conflict_next(&ancestor, &our, &their, conflicts))
            == 0) {
        conflictsString << "Conflict in file: "
            << " a: " << (ancestor ? ancestor->path : "NULL")
            << " o: " << (our->path ? our->path : "NULL")
            << " t: " << (their->path ? their->path : "NULL")
            << "\n";
    }

    if (err != GIT_ITEROVER)
        conflictsString << "Error iterating conflicts\n";

    git_index_conflict_iterator_free(conflicts);

    conflictsString << "\n"
                    << "  a : Ancestor path\n"
                    << "  o : Our path\n"
                    << "  t : Their path\n";
    conflictsString << "Resolve the conflicts and add files to mark them as "
        << "resolved.\nCommit changes after resolving all files.\n";
ret:
    printf("%s\n", conflictsString.String());
    conflictsWindow->SetText(conflictsString);

    thread_id thread = conflictsWindow->Thread();
    // wait for widow thread to return
    status_t win_status = B_OK;
    wait_for_thread(thread, &win_status);
}


int cred_acquire_cb(git_cred** out, const char* url,
        const char* username_from_url, unsigned int allowed_types,
        void* payload)
{
    char username[100] = "",
         password[100] = "";
    CredentialsWindow* window = new CredentialsWindow(username, password);

    thread_id thread = window->Thread();
    // wait for widow thread to return
    status_t win_status = B_OK;
    wait_for_thread(thread, &win_status);

    return git_cred_userpass_plaintext_new(out, username, password);
}