int
Reference_target__set__(Reference *self, PyObject *py_name)
{
char *c_name;
int err;
git_reference *new_ref;
CHECK_REFERENCE_INT(self);
/* Get the C name */
c_name = py_path_to_c_str(py_name);
if (c_name == NULL)
return -1;
/* Set the new target */
err = git_reference_symbolic_set_target(&new_ref, self->reference, c_name);
free(c_name);
if (err < 0) {
Error_set(err);
return -1;
}
git_reference_free(self->reference);
self->reference = new_ref;
return 0;
}
/**
* ggit_ref_set_symbolic_target:
* @ref: a #GgitRef.
* @target: The new target for the reference.
* @log_message: The one line long message to be appended to the reflog.
* @error: a #GError for error reporting, or %NULL.
*
* Create a new reference with the same name as the given reference but a
* different symbolic target. The reference must be a symbolic reference,
* otherwise this will fail.
*
* The new reference will be written to disk, overwriting the given reference.
*
* The target name will be checked for validity.
* See `ggit_ref_create_symbolic()` for rules about valid names.
*
* Returns: (transfer full): the newly created #GgitRef.
*/
GgitRef *
ggit_ref_set_symbolic_target (GgitRef *ref,
const gchar *target,
const gchar *log_message,
GError **error)
{
git_reference *out;
gint ret;
g_return_val_if_fail (ref != NULL, NULL);
g_return_val_if_fail (target != NULL, NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
ret = git_reference_symbolic_set_target (&out,
_ggit_native_get (ref),
target,
log_message);
if (ret != GIT_OK)
{
_ggit_error_set (error, ret);
return NULL;
}
return _ggit_ref_wrap (out, FALSE);
}
PyObject *
Reference_set_target(Reference *self, PyObject *args, PyObject *kwds)
{
git_oid oid;
char *c_name;
int err;
git_reference *new_ref;
const git_signature *sig = NULL;
PyObject *py_target = NULL;
Signature *py_signature = NULL;
const char *message = NULL;
char *keywords[] = {"target", "signature", "message", NULL};
CHECK_REFERENCE(self);
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O!s", keywords,
&py_target, &SignatureType, &py_signature, &message))
return NULL;
if (py_signature)
sig = py_signature->signature;
/* Case 1: Direct */
if (GIT_REF_OID == git_reference_type(self->reference)) {
err = py_oid_to_git_oid_expand(self->repo->repo, py_target, &oid);
if (err < 0)
goto error;
err = git_reference_set_target(&new_ref, self->reference, &oid, sig, message);
if (err < 0)
goto error;
git_reference_free(self->reference);
self->reference = new_ref;
Py_RETURN_NONE;
}
/* Case 2: Symbolic */
c_name = py_path_to_c_str(py_target);
if (c_name == NULL)
return NULL;
err = git_reference_symbolic_set_target(&new_ref, self->reference, c_name, sig, message);
free(c_name);
if (err < 0)
goto error;
git_reference_free(self->reference);
self->reference = new_ref;
Py_RETURN_NONE;
error:
Error_set(err);
return NULL;
}
// create a root commit
void test_commit_write__root(void)
{
git_oid tree_id, commit_id;
const git_oid *branch_oid;
git_signature *author, *committer;
const char *branch_name = "refs/heads/root-commit-branch";
git_tree *tree;
git_oid_fromstr(&tree_id, tree_oid);
cl_git_pass(git_tree_lookup(&tree, g_repo, &tree_id));
/* create signatures */
cl_git_pass(git_signature_new(&committer, committer_name, committer_email, 123456789, 60));
cl_git_pass(git_signature_new(&author, committer_name, committer_email, 987654321, 90));
/* First we need to update HEAD so it points to our non-existant branch */
cl_git_pass(git_reference_lookup(&head, g_repo, "HEAD"));
cl_assert(git_reference_type(head) == GIT_REF_SYMBOLIC);
head_old = git__strdup(git_reference_symbolic_target(head));
cl_assert(head_old != NULL);
cl_git_pass(git_reference_symbolic_set_target(head, branch_name));
cl_git_pass(git_commit_create_v(
&commit_id, /* out id */
g_repo,
"HEAD",
author,
committer,
NULL,
root_commit_message,
tree,
0));
git_object_free((git_object *)tree);
git_signature_free(committer);
git_signature_free(author);
/*
* The fact that creating a commit works has already been
* tested. Here we just make sure it's our commit and that it was
* written as a root commit.
*/
cl_git_pass(git_commit_lookup(&commit, g_repo, &commit_id));
cl_assert(git_commit_parentcount(commit) == 0);
cl_git_pass(git_reference_lookup(&branch, g_repo, branch_name));
branch_oid = git_reference_target(branch);
cl_git_pass(git_oid_cmp(branch_oid, &commit_id));
cl_assert_equal_s(root_commit_message, git_commit_message(commit));
}
int luagi_reference_gen_symbolic_set_target( lua_State *L, const char *tablename )
{
git_reference **ref = luaL_checkudata( L, 1, tablename );
const char *target = luaL_checkstring( L, 2 );
const char *log_message = luaL_checkstring( L, 4 );
git_reference **out = lua_newuserdata( L, sizeof( git_reference * ) );
if( git_reference_symbolic_set_target( out, *ref, target, log_message ) )
{
return ltk_push_git_error( L );
}
ltk_setmetatable( L, LUAGI_REFERENCE_FUNCS );
return 1;
}
int
Reference_target__set__(Reference *self, PyObject *py_target)
{
git_oid oid;
char *c_name;
int err;
git_reference *new_ref;
CHECK_REFERENCE_INT(self);
/* Case 1: Direct */
if (GIT_REF_OID == git_reference_type(self->reference)) {
err = py_oid_to_git_oid_expand(self->repo->repo, py_target, &oid);
if (err < 0)
return err;
err = git_reference_set_target(&new_ref, self->reference, &oid);
if (err < 0)
goto error;
git_reference_free(self->reference);
self->reference = new_ref;
return 0;
}
/* Case 2: Symbolic */
c_name = py_path_to_c_str(py_target);
if (c_name == NULL)
return -1;
err = git_reference_symbolic_set_target(&new_ref, self->reference, c_name);
free(c_name);
if (err < 0)
goto error;
git_reference_free(self->reference);
self->reference = new_ref;
return 0;
error:
Error_set(err);
return -1;
}
void Reference::setSymbolicTarget(const QString& target, const Signature &signature, const QString &message)
{
git_reference* rp;
qGitThrow(git_reference_symbolic_set_target(&rp, data(), PathCodec::toLibGit2(target), signature.data(), message.toUtf8()));
d = ptr_type(rp, git_reference_free);
}