PyObject * Repository_create_tag(Repository *self, PyObject *args) { PyObject *py_oid; Signature *py_tagger; char *tag_name, *message; git_oid oid; git_object *target = NULL; int err, target_type; size_t len; if (!PyArg_ParseTuple(args, "sOiO!s", &tag_name, &py_oid, &target_type, &SignatureType, &py_tagger, &message)) return NULL; len = py_oid_to_git_oid(py_oid, &oid); if (len == 0) return NULL; err = git_object_lookup_prefix(&target, self->repo, &oid, len, target_type); err = err < 0 ? err : git_tag_create(&oid, self->repo, tag_name, target, py_tagger->signature, message, 0); git_object_free(target); if (err < 0) return Error_set_oid(err, &oid, len); return git_oid_to_python(&oid); }
static void action_create_tag(tag_state *state) { git_repository *repo = state->repo; tag_options *opts = state->opts; git_signature *tagger; git_oid oid; git_object *target; check(!opts->tag_name, "Name required"); check(!opts->message, "Message required"); if (!opts->target) opts->target = "HEAD"; check_lg2(git_revparse_single(&target, repo, opts->target), "Unable to resolve spec", opts->target); check_lg2(git_signature_default(&tagger, repo), "Unable to create signature", NULL); check_lg2(git_tag_create(&oid, repo, opts->tag_name, target, tagger, opts->message, opts->force), "Unable to create tag", NULL); git_object_free(target); git_signature_free(tagger); }
void MainWindow::on_pushButtonTag_clicked() { //make a tag! if (repo == NULL) return; qDebug() << "making a tag..."; git_oid oid; git_object *target = NULL; git_signature *tagger = NULL; int err = git_revparse_single(&target, repo, "HEAD^{commit}"); qDebug() << "reverseparse: "<<err; err = git_signature_now(&tagger, "johnty", "*****@*****.**"); qDebug() << "get signature: "<<err; //probably not the best text widgets to use? const char* tag_name = ui->textTagName->toPlainText().toStdString().c_str(); const char* tag_msg = ui->textTagAnno->toPlainText().toStdString().c_str(); err = git_tag_create( &oid, /* new object id */ repo, /* repo */ tag_name, /* name */ target, /* target */ tagger, /* name/email/timestamp */ tag_msg, /* message */ false); /* force? */ qDebug() << "create tag: "<<err; git_object_free(target); git_signature_free(tagger); }
void test_object_tag_write__overwrite(void) { // Attempt to write a tag bearing the same name than an already existing tag git_oid target_id, tag_id; git_signature *tagger; git_object *target; git_oid_fromstr(&target_id, tagged_commit); cl_git_pass(git_object_lookup(&target, g_repo, &target_id, GIT_OBJ_COMMIT)); /* create signature */ cl_git_pass(git_signature_new(&tagger, tagger_name, tagger_email, 123456789, 60)); cl_assert_equal_i(GIT_EEXISTS, git_tag_create( &tag_id, /* out id */ g_repo, "e90810b", target, tagger, tagger_message, 0)); git_object_free(target); git_signature_free(tagger); }
/* * call-seq: * tags.create(name, target[, force = false][, annotation = nil]) -> oid * * Create a new tag with the specified +name+ on +target+ in +repo+. * * If +annotation+ is not +nil+, it will cause the creation of an annotated tag object. * +annotation+ has to contain the following key value pairs: * * :tagger :: * An optional Hash containing a git signature. Defaults to the signature * from the configuration if only `:message` is given. Will cause the * creation of an annotated tag object if present. * * :message :: * An optional string containing the message for the new tag. * * Returns the OID of the newly created tag. */ static VALUE rb_git_tag_collection_create(int argc, VALUE *argv, VALUE self) { git_oid tag_oid; git_repository *repo = NULL; git_object *target = NULL; int error, force = 0; VALUE rb_repo = rugged_owner(self), rb_name, rb_target, rb_force, rb_annotation; rb_scan_args(argc, argv, "21:", &rb_name, &rb_target, &rb_force, &rb_annotation); rugged_check_repo(rb_repo); Data_Get_Struct(rb_repo, git_repository, repo); Check_Type(rb_name, T_STRING); if (!NIL_P(rb_force)) force = rugged_parse_bool(rb_force); target = rugged_object_get(repo, rb_target, GIT_OBJ_ANY); if (NIL_P(rb_annotation)) { error = git_tag_create_lightweight( &tag_oid, repo, StringValueCStr(rb_name), target, force ); } else { git_signature *tagger = rugged_signature_get( rb_hash_aref(rb_annotation, CSTR2SYM("tagger")), repo ); VALUE rb_message = rb_hash_aref(rb_annotation, CSTR2SYM("message")); Check_Type(rb_message, T_STRING); error = git_tag_create( &tag_oid, repo, StringValueCStr(rb_name), target, tagger, StringValueCStr(rb_message), force ); git_signature_free(tagger); } git_object_free(target); rugged_exception_check(error); return rb_git_tag_collection_aref(self, rb_name); }
void test_object_tag_write__basic(void) { // write a tag to the repository and read it again git_tag *tag; git_oid target_id, tag_id; git_signature *tagger; const git_signature *tagger1; git_reference *ref_tag; git_object *target; git_oid_fromstr(&target_id, tagged_commit); cl_git_pass(git_object_lookup(&target, g_repo, &target_id, GIT_OBJ_COMMIT)); /* create signature */ cl_git_pass(git_signature_new(&tagger, tagger_name, tagger_email, 123456789, 60)); cl_git_pass( git_tag_create(&tag_id, g_repo, "the-tag", target, tagger, tagger_message, 0) ); git_object_free(target); git_signature_free(tagger); cl_git_pass(git_tag_lookup(&tag, g_repo, &tag_id)); cl_assert(git_oid_cmp(git_tag_target_oid(tag), &target_id) == 0); /* Check attributes were set correctly */ tagger1 = git_tag_tagger(tag); cl_assert(tagger1 != NULL); cl_assert_equal_s(tagger1->name, tagger_name); cl_assert_equal_s(tagger1->email, tagger_email); cl_assert(tagger1->when.time == 123456789); cl_assert(tagger1->when.offset == 60); cl_assert_equal_s(git_tag_message(tag), tagger_message); cl_git_pass(git_reference_lookup(&ref_tag, g_repo, "refs/tags/the-tag")); cl_assert(git_oid_cmp(git_reference_oid(ref_tag), &tag_id) == 0); cl_git_pass(git_reference_delete(ref_tag)); git_tag_free(tag); }
void test_describe_t6120__pattern(void) { git_describe_options opts = GIT_DESCRIBE_OPTIONS_INIT; git_describe_format_options fmt_opts = GIT_DESCRIBE_FORMAT_OPTIONS_INIT; git_oid tag_id; git_object *head; git_signature *tagger; git_time_t time; /* set-up matching pattern tests */ cl_git_pass(git_revparse_single(&head, repo, "HEAD")); time = 1380553019; cl_git_pass(git_signature_new(&tagger, "tagger", "*****@*****.**", time, 0)); cl_git_pass(git_tag_create(&tag_id, repo, "test-annotated", head, tagger, "test-annotated", 0)); git_signature_free(tagger); git_object_free(head); commit_and_tag(&time, "one more", "refs/tags/test1-lightweight"); commit_and_tag(&time, "yet another", "refs/tags/test2-lightweight"); commit_and_tag(&time, "even more", NULL); /* Exercize */ opts.pattern = "test-*"; assert_describe("test-annotated-*", "HEAD", repo, &opts, &fmt_opts); opts.describe_strategy = GIT_DESCRIBE_TAGS; opts.pattern = "test1-*"; assert_describe("test1-lightweight-*", "HEAD", repo, &opts, &fmt_opts); opts.pattern = "test2-*"; assert_describe("test2-lightweight-*", "HEAD", repo, &opts, &fmt_opts); fmt_opts.always_use_long_format = 1; assert_describe("test2-lightweight-*", "HEAD^", repo, &opts, &fmt_opts); }
void test_object_tag_write__replace(void) { // Replace an already existing tag git_oid target_id, tag_id, old_tag_id; git_signature *tagger; git_reference *ref_tag; git_object *target; git_oid_fromstr(&target_id, tagged_commit); cl_git_pass(git_object_lookup(&target, g_repo, &target_id, GIT_OBJ_COMMIT)); cl_git_pass(git_reference_lookup(&ref_tag, g_repo, "refs/tags/e90810b")); git_oid_cpy(&old_tag_id, git_reference_oid(ref_tag)); git_reference_free(ref_tag); /* create signature */ cl_git_pass(git_signature_new(&tagger, tagger_name, tagger_email, 123456789, 60)); cl_git_pass(git_tag_create( &tag_id, /* out id */ g_repo, "e90810b", target, tagger, tagger_message, 1)); git_object_free(target); git_signature_free(tagger); cl_git_pass(git_reference_lookup(&ref_tag, g_repo, "refs/tags/e90810b")); cl_assert(git_oid_cmp(git_reference_oid(ref_tag), &tag_id) == 0); cl_assert(git_oid_cmp(git_reference_oid(ref_tag), &old_tag_id) != 0); git_reference_free(ref_tag); }
git_oid target_id, tag_id; const git_signature *tagger; git_reference *ref_tag; must_pass(git_repository_open(&repo, REPOSITORY_FOLDER)); git_oid_mkstr(&target_id, tagged_commit); /* create signature */ tagger = git_signature_new(TAGGER_NAME, TAGGER_EMAIL, 123456789, 60); must_be_true(tagger != NULL); must_pass(git_tag_create( &tag_id, /* out id */ repo, "the-tag", &target_id, GIT_OBJ_COMMIT, tagger, TAGGER_MESSAGE)); git_signature_free((git_signature *)tagger); must_pass(git_tag_lookup(&tag, repo, &tag_id)); must_be_true(git_oid_cmp(git_tag_target_oid(tag), &target_id) == 0); /* Check attributes were set correctly */ tagger = git_tag_tagger(tag); must_be_true(tagger != NULL); must_be_true(strcmp(tagger->name, TAGGER_NAME) == 0); must_be_true(strcmp(tagger->email, TAGGER_EMAIL) == 0); must_be_true(tagger->when.time == 123456789);
/** * Create tag targeting HEAD commit in repository. * * @param repo S4 class git_repository * @param name Name for the tag. * @param message The tag message. * @param tagger The tagger (author) of the tag * @return S4 object of class git_tag */ SEXP git2r_tag_create(SEXP repo, SEXP name, SEXP message, SEXP tagger) { SEXP result = R_NilValue; int err; git_oid oid; git_repository *repository = NULL; git_signature *sig_tagger = NULL; git_tag *tag = NULL; git_object *target = NULL; if (git2r_arg_check_string(name)) git2r_error(__func__, NULL, "'name'", git2r_err_string_arg); if (git2r_arg_check_string(message)) git2r_error(__func__, NULL, "'message'", git2r_err_string_arg); if (git2r_arg_check_signature(tagger)) git2r_error(__func__, NULL, "'tagger'", git2r_err_signature_arg); repository = git2r_repository_open(repo); if (!repository) git2r_error(__func__, NULL, git2r_err_invalid_repository, NULL); err = git2r_signature_from_arg(&sig_tagger, tagger); if (err) goto cleanup; err = git_revparse_single(&target, repository, "HEAD^{commit}"); if (err) goto cleanup; err = git_tag_create( &oid, repository, CHAR(STRING_ELT(name, 0)), target, sig_tagger, CHAR(STRING_ELT(message, 0)), 0); if (err) goto cleanup; err = git_tag_lookup(&tag, repository, &oid); if (err) goto cleanup; PROTECT(result = NEW_OBJECT(MAKE_CLASS("git_tag"))); git2r_tag_init(tag, repo, result); cleanup: if (tag) git_tag_free(tag); if (sig_tagger) git_signature_free(sig_tagger); if (target) git_object_free(target); if (repository) git_repository_free(repository); if (R_NilValue != result) UNPROTECT(1); if (err) git2r_error(__func__, giterr_last(), NULL, NULL); return result; }