void test_notes_notes__1(void)
{
git_oid oid, note_oid;
static git_note *note;
static git_blob *blob;
cl_git_pass(git_oid_fromstr(&oid, "8496071c1b46c854b31185ea97743be6a8774479"));
cl_git_pass(git_note_create(¬e_oid, _repo, _sig, _sig, "refs/notes/some/namespace", &oid, "hello world\n"));
cl_git_pass(git_note_create(¬e_oid, _repo, _sig, _sig, NULL, &oid, "hello world\n"));
cl_git_pass(git_note_read(¬e, _repo, NULL, &oid));
cl_assert_equal_s(git_note_message(note), "hello world\n");
cl_assert(!git_oid_cmp(git_note_oid(note), ¬e_oid));
cl_git_pass(git_blob_lookup(&blob, _repo, ¬e_oid));
cl_assert_equal_s(git_note_message(note), git_blob_rawcontent(blob));
cl_git_fail(git_note_create(¬e_oid, _repo, _sig, _sig, NULL, &oid, "hello world\n"));
cl_git_fail(git_note_create(¬e_oid, _repo, _sig, _sig, "refs/notes/some/namespace", &oid, "hello world\n"));
cl_git_pass(git_note_remove(_repo, NULL, _sig, _sig, &oid));
cl_git_pass(git_note_remove(_repo, "refs/notes/some/namespace", _sig, _sig, &oid));
cl_git_fail(git_note_remove(_repo, NULL, _sig, _sig, ¬e_oid));
cl_git_fail(git_note_remove(_repo, "refs/notes/some/namespace", _sig, _sig, &oid));
git_note_free(note);
git_blob_free(blob);
}
PyObject *
Repository_create_note(Repository *self, PyObject* args)
{
git_oid note_id, annotated_id;
char *annotated = NULL, *message = NULL, *ref = "refs/notes/commits";
int err = GIT_ERROR;
unsigned int force = 0;
Signature *py_author, *py_committer;
if (!PyArg_ParseTuple(args, "sO!O!s|si",
&message,
&SignatureType, &py_author,
&SignatureType, &py_committer,
&annotated, &ref, &force))
return NULL;
err = git_oid_fromstr(&annotated_id, annotated);
if (err < 0)
return Error_set(err);
err = git_note_create(¬e_id, self->repo, ref, py_author->signature,
py_committer->signature,
&annotated_id, message, force);
if (err < 0)
return Error_set(err);
return git_oid_to_python(¬e_id);
}
static void create_note(git_oid *note_oid, const char *canonical_namespace, const char *target_sha, const char *message)
{
git_oid oid;
cl_git_pass(git_oid_fromstr(&oid, target_sha));
cl_git_pass(git_note_create(note_oid, _repo, canonical_namespace, _sig, _sig, &oid, message, 0));
}
void test_notes_notesref__config_corenotesref(void)
{
git_oid oid, note_oid;
const char *default_ref;
cl_git_pass(git_signature_now(&_sig, "alice", "*****@*****.**"));
cl_git_pass(git_oid_fromstr(&oid, "8496071c1b46c854b31185ea97743be6a8774479"));
cl_git_pass(git_repository_config(&_cfg, _repo));
cl_git_pass(git_config_set_string(_cfg, "core.notesRef", "refs/notes/mydefaultnotesref"));
cl_git_pass(git_note_create(¬e_oid, _repo, _sig, _sig, NULL, &oid, "test123test\n"));
cl_git_pass(git_note_read(&_note, _repo, NULL, &oid));
cl_assert(!strcmp(git_note_message(_note), "test123test\n"));
cl_assert(!git_oid_cmp(git_note_oid(_note), ¬e_oid));
git_note_free(_note);
cl_git_pass(git_note_read(&_note, _repo, "refs/notes/mydefaultnotesref", &oid));
cl_assert(!strcmp(git_note_message(_note), "test123test\n"));
cl_assert(!git_oid_cmp(git_note_oid(_note), ¬e_oid));
cl_git_pass(git_note_default_ref(&default_ref, _repo));
cl_assert(!strcmp(default_ref, "refs/notes/mydefaultnotesref"));
cl_git_pass(git_config_delete(_cfg, "core.notesRef"));
cl_git_pass(git_note_default_ref(&default_ref, _repo));
cl_assert(!strcmp(default_ref, GIT_NOTES_DEFAULT_REF));
}
/*
* $ git notes --ref fanout list 8496071c1b46c854b31185ea97743be6a8774479
* 08b041783f40edfe12bb406c9c9a8a040177c125
*/
void test_notes_notes__creating_a_note_on_a_target_which_already_has_one_returns_EEXISTS(void)
{
int error;
git_oid note_oid, target_oid;
cl_git_pass(git_oid_fromstr(&target_oid, "08b041783f40edfe12bb406c9c9a8a040177c125"));
create_note(¬e_oid, NULL, "08b041783f40edfe12bb406c9c9a8a040177c125", "hello world\n");
error = git_note_create(¬e_oid, _repo, NULL, _sig, _sig, &target_oid, "hello world\n", 0);
cl_git_fail(error);
cl_assert_equal_i(GIT_EEXISTS, error);
create_note(¬e_oid, "refs/notes/some/namespace", "08b041783f40edfe12bb406c9c9a8a040177c125", "hello world\n");
error = git_note_create(¬e_oid, _repo, "refs/notes/some/namespace", _sig, _sig, &target_oid, "hello world\n", 0);
cl_git_fail(error);
cl_assert_equal_i(GIT_EEXISTS, error);
}
static void test_copy_note(
const git_rebase_options *opts,
bool should_exist)
{
git_rebase *rebase;
git_reference *branch_ref, *upstream_ref;
git_annotated_commit *branch_head, *upstream_head;
git_commit *branch_commit;
git_rebase_operation *rebase_operation;
git_checkout_options checkout_opts = GIT_CHECKOUT_OPTIONS_INIT;
git_oid note_id, commit_id;
git_note *note = NULL;
int error;
checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE;
cl_git_pass(git_reference_lookup(&branch_ref, repo, "refs/heads/gravy"));
cl_git_pass(git_reference_lookup(&upstream_ref, repo, "refs/heads/veal"));
cl_git_pass(git_annotated_commit_from_ref(&branch_head, repo, branch_ref));
cl_git_pass(git_annotated_commit_from_ref(&upstream_head, repo, upstream_ref));
cl_git_pass(git_reference_peel((git_object **)&branch_commit,
branch_ref, GIT_OBJ_COMMIT));
/* Add a note to a commit */
cl_git_pass(git_note_create(¬e_id, repo, "refs/notes/test",
git_commit_author(branch_commit), git_commit_committer(branch_commit),
git_commit_id(branch_commit),
"This is a commit note.", 0));
cl_git_pass(git_rebase_init(&rebase, repo, branch_head, upstream_head, NULL, opts));
cl_git_pass(git_rebase_next(&rebase_operation, rebase, &checkout_opts));
cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature,
NULL, NULL));
cl_git_pass(git_rebase_finish(rebase, signature, opts));
cl_assert_equal_i(GIT_REPOSITORY_STATE_NONE, git_repository_state(repo));
if (should_exist) {
cl_git_pass(git_note_read(¬e, repo, "refs/notes/test", &commit_id));
cl_assert_equal_s("This is a commit note.", git_note_message(note));
} else {
cl_git_fail(error =
git_note_read(¬e, repo, "refs/notes/test", &commit_id));
cl_assert_equal_i(GIT_ENOTFOUND, error);
}
git_note_free(note);
git_commit_free(branch_commit);
git_annotated_commit_free(branch_head);
git_annotated_commit_free(upstream_head);
git_reference_free(branch_ref);
git_reference_free(upstream_ref);
git_rebase_free(rebase);
}
void test_notes_notes__creating_a_note_on_a_target_can_overwrite_existing_note(void)
{
git_oid note_oid, target_oid;
git_note *note, *namespace_note;
cl_git_pass(git_oid_fromstr(&target_oid, "08b041783f40edfe12bb406c9c9a8a040177c125"));
create_note(¬e_oid, NULL, "08b041783f40edfe12bb406c9c9a8a040177c125", "hello old world\n");
cl_git_pass(git_note_create(¬e_oid, _repo, NULL, _sig, _sig, &target_oid, "hello new world\n", 1));
cl_git_pass(git_note_read(¬e, _repo, NULL, &target_oid));
assert_note_equal(note, "hello new world\n", ¬e_oid);
create_note(¬e_oid, "refs/notes/some/namespace", "08b041783f40edfe12bb406c9c9a8a040177c125", "hello old world\n");
cl_git_pass(git_note_create(¬e_oid, _repo, "refs/notes/some/namespace", _sig, _sig, &target_oid, "hello new ref world\n", 1));
cl_git_pass(git_note_read(&namespace_note, _repo, "refs/notes/some/namespace", &target_oid));
assert_note_equal(namespace_note, "hello new ref world\n", ¬e_oid);
git_note_free(note);
git_note_free(namespace_note);
}
/*
* $ git ls-tree refs/notes/fanout
* 040000 tree 4b22b35d44b5a4f589edf3dc89196399771796ea 84
*
* $ git ls-tree 4b22b35
* 040000 tree d71aab4f9b04b45ce09bcaa636a9be6231474759 96
*
* $ git ls-tree d71aab4
* 100644 blob 08b041783f40edfe12bb406c9c9a8a040177c125 071c1b46c854b31185ea97743be6a8774479
*/
void test_notes_notes__can_insert_a_note_in_an_existing_fanout(void)
{
size_t i;
git_oid note_oid, target_oid;
git_note *_note;
cl_git_pass(git_oid_fromstr(&target_oid, "08b041783f40edfe12bb406c9c9a8a040177c125"));
for (i = 0; i < MESSAGES_COUNT; i++) {
cl_git_pass(git_note_create(¬e_oid, _repo, "refs/notes/fanout", _sig, _sig, &target_oid, messages[i], 0));
cl_git_pass(git_note_read(&_note, _repo, "refs/notes/fanout", &target_oid));
git_note_free(_note);
git_oid_cpy(&target_oid, ¬e_oid);
}
}
static int rebase_copy_note(
git_rebase *rebase,
const char *notes_ref,
git_oid *from,
git_oid *to,
const git_signature *committer)
{
git_note *note = NULL;
git_oid note_id;
git_signature *who = NULL;
int error;
if ((error = git_note_read(¬e, rebase->repo, notes_ref, from)) < 0) {
if (error == GIT_ENOTFOUND) {
giterr_clear();
error = 0;
}
goto done;
}
if (!committer) {
if((error = git_signature_default(&who, rebase->repo)) < 0) {
if (error != GIT_ENOTFOUND ||
(error = git_signature_now(&who, "unknown", "unknown")) < 0)
goto done;
giterr_clear();
}
committer = who;
}
error = git_note_create(¬e_id, rebase->repo, notes_ref,
git_note_author(note), committer, to, git_note_message(note), 0);
done:
git_note_free(note);
git_signature_free(who);
return error;
}
/*
* call-seq:
* obj.create_note(data = {}) -> oid
*
* Write a new +note+ to +object+, with the given +data+
* arguments, passed as a +Hash+:
*
* - +:message+: the content of the note to add to the object
* - +:committer+: a hash with the signature for the committer
* - +:author+: a hash with the signature for the author
* - +:ref+: (optional): cannonical name of the reference to use, defaults to "refs/notes/commits"
* - +:force+: (optional): overwrite existing note (disabled by default)
*
* When the note is successfully written to disk, its +oid+ will be
* returned as a hex +String+.
*
* author = {:email=>"*****@*****.**", :time=>Time.now, :name=>"Vicent Mart\303\255"}
*
* obj.create_note(
* :author => author,
* :committer => author,
* :message => "Hello world\n\n",
* :ref => 'refs/notes/builds'
* )
*/
static VALUE rb_git_note_create(VALUE self, VALUE rb_data)
{
VALUE rb_ref, rb_message, rb_force;
git_repository *repo = NULL;
const char *notes_ref = NULL;
VALUE owner;
git_signature *author, *committer;
git_oid note_oid;
git_object *target = NULL;
int error = 0;
int force = 0;
Check_Type(rb_data, T_HASH);
Data_Get_Struct(self, git_object, target);
owner = rugged_owner(self);
Data_Get_Struct(owner, git_repository, repo);
rb_ref = rb_hash_aref(rb_data, CSTR2SYM("ref"));
rb_force = rb_hash_aref(rb_data, CSTR2SYM("force"));
if (!NIL_P(rb_force))
force = rugged_parse_bool(rb_force);
if (!NIL_P(rb_ref)) {
Check_Type(rb_ref, T_STRING);
notes_ref = StringValueCStr(rb_ref);
}
rb_message = rb_hash_aref(rb_data, CSTR2SYM("message"));
Check_Type(rb_message, T_STRING);
committer = rugged_signature_get(
rb_hash_aref(rb_data, CSTR2SYM("committer"))
);
author = rugged_signature_get(
rb_hash_aref(rb_data, CSTR2SYM("author"))
);
error = git_note_create(
¬e_oid,
repo,
author,
committer,
notes_ref,
git_object_id(target),
StringValueCStr(rb_message),
force);
git_signature_free(author);
git_signature_free(committer);
rugged_exception_check(error);
return rugged_create_oid(¬e_oid);
}
/**
* Add a note for an object
*
* @param repo S4 class git_repository
* @param sha The sha string of object
* @param commit S4 class git_commit
* @param message Content of the note to add
* @param ref Canonical name of the reference to use
* @param author Signature of the notes note author
* @param committer Signature of the notes note committer
* @param force Overwrite existing note
* @return S4 class git_note
*/
SEXP git2r_note_create(
SEXP repo,
SEXP sha,
SEXP message,
SEXP ref,
SEXP author,
SEXP committer,
SEXP force)
{
int err;
SEXP result = R_NilValue;
int overwrite = 0;
git_oid note_oid;
git_oid object_oid;
git_signature *sig_author = NULL;
git_signature *sig_committer = NULL;
git_repository *repository = NULL;
if (git2r_arg_check_sha(sha))
git2r_error(git2r_err_sha_arg, __func__, "sha");
if (git2r_arg_check_string(message))
git2r_error(git2r_err_string_arg, __func__, "message");
if (git2r_arg_check_string(ref))
git2r_error(git2r_err_string_arg, __func__, "ref");
if (git2r_arg_check_signature(author))
git2r_error(git2r_err_signature_arg, __func__, "author");
if (git2r_arg_check_signature(committer))
git2r_error(git2r_err_signature_arg, __func__, "committer");
if (git2r_arg_check_logical(force))
git2r_error(git2r_err_logical_arg, __func__, "force");
repository = git2r_repository_open(repo);
if (!repository)
git2r_error(git2r_err_invalid_repository, __func__, NULL);
err = git2r_signature_from_arg(&sig_author, author);
if (GIT_OK != err)
goto cleanup;
err = git2r_signature_from_arg(&sig_committer, committer);
if (GIT_OK != err)
goto cleanup;
err = git_oid_fromstr(&object_oid, CHAR(STRING_ELT(sha, 0)));
if (GIT_OK != err)
goto cleanup;
if (LOGICAL(force)[0])
overwrite = 1;
err = git_note_create(
¬e_oid,
repository,
CHAR(STRING_ELT(ref, 0)),
sig_author,
sig_committer,
&object_oid,
CHAR(STRING_ELT(message, 0)),
overwrite);
if (GIT_OK != err)
goto cleanup;
PROTECT(result = NEW_OBJECT(MAKE_CLASS("git_note")));
err = git2r_note_init(¬e_oid,
&object_oid,
repository,
CHAR(STRING_ELT(ref, 0)),
repo,
result);
cleanup:
if (sig_author)
git_signature_free(sig_author);
if (sig_committer)
git_signature_free(sig_committer);
if (repository)
git_repository_free(repository);
if (R_NilValue != result)
UNPROTECT(1);
if (GIT_OK != err)
git2r_error(git2r_err_from_libgit2, __func__, giterr_last()->message);
return result;
}
