* [PATCH] Make git tag a builtin.
@ 2007-07-19 23:42 Carlos Rica
2007-07-20 8:53 ` Johannes Schindelin
2007-07-20 9:10 ` Junio C Hamano
0 siblings, 2 replies; 4+ messages in thread
From: Carlos Rica @ 2007-07-19 23:42 UTC (permalink / raw)
To: git, Junio C Hamano, Johannes Schindelin
This replaces the script "git-tag.sh" with "builtin-tag.c".
The existing test suite for "git tag" guarantees the compatibility
with the features provided by the script version.
There are some minor changes in the behaviour of "git tag" here:
"git tag -v" now can get more than one tag to verify, like "git tag -d" does,
"git tag" with no arguments prints all tags, more like "git branch" does,
and "git tag -n" also prints all tags with annotations (without needing -l).
Tests and documentation were also updated to reflect these changes.
The program is currently calling the script "git verify-tag" for verify.
This can be changed porting it to C and calling its functions directly
from builtin-tag.c.
Signed-off-by: Carlos Rica <jasampler@gmail.com>
---
This patch is a resend including the suggestions and corrections
commented by Junio in the previous proposal for builtin-tag.c:
http://article.gmane.org/gmane.comp.version-control.git/52246
In this version, a bit of refactoring was also done grouping the common
code between the previous functions delete_tags() and verify_tags().
The function launch_editor will be moved to another file
(editor.c is the suggested name), along with other tools
for editing and reading text files, in order to share its code
wiht other builtins like the upcoming builtin-commit.c from Kristian.
Documentation/git-tag.txt | 8 +-
Makefile | 3 +-
builtin-tag.c | 450 +++++++++++++++++++++++++++++
builtin.h | 1 +
git-tag.sh => contrib/examples/git-tag.sh | 0
git.c | 1 +
t/t7004-tag.sh | 88 +++++-
7 files changed, 538 insertions(+), 13 deletions(-)
create mode 100644 builtin-tag.c
rename git-tag.sh => contrib/examples/git-tag.sh (100%)
diff --git a/Documentation/git-tag.txt b/Documentation/git-tag.txt
index aee2c1b..119117f 100644
--- a/Documentation/git-tag.txt
+++ b/Documentation/git-tag.txt
@@ -12,7 +12,7 @@ SYNOPSIS
'git-tag' [-a | -s | -u <key-id>] [-f] [-m <msg> | -F <file>] <name> [<head>]
'git-tag' -d <name>...
'git-tag' [-n [<num>]] -l [<pattern>]
-'git-tag' -v <name>
+'git-tag' -v <name>...
DESCRIPTION
-----------
@@ -23,7 +23,7 @@ Unless `-f` is given, the tag must not yet exist in
If one of `-a`, `-s`, or `-u <key-id>` is passed, the command
creates a 'tag' object, and requires the tag message. Unless
-`-m <msg>` is given, an editor is started for the user to type
+`-m <msg>` or `-F <file>` is given, an editor is started for the user to type
in the tag message.
Otherwise just the SHA1 object name of the commit object is
@@ -59,15 +59,17 @@ OPTIONS
Delete existing tags with the given names.
-v::
- Verify the gpg signature of given the tag
+ Verify the gpg signature of the given tag names.
-n <num>::
<num> specifies how many lines from the annotation, if any,
are printed when using -l.
The default is not to print any annotation lines.
+ If no number is given to `-n`, only the first line is printed.
-l <pattern>::
List tags with names that match the given pattern (or all if no pattern is given).
+ Typing "git tag" without arguments, also lists all tags.
-m <msg>::
Use the given tag message (instead of prompting)
diff --git a/Makefile b/Makefile
index 73b487f..8db6646 100644
--- a/Makefile
+++ b/Makefile
@@ -206,7 +206,7 @@ SCRIPT_SH = \
git-pull.sh git-rebase.sh git-rebase--interactive.sh \
git-repack.sh git-request-pull.sh git-reset.sh \
git-sh-setup.sh \
- git-tag.sh git-verify-tag.sh \
+ git-verify-tag.sh \
git-am.sh \
git-merge.sh git-merge-stupid.sh git-merge-octopus.sh \
git-merge-resolve.sh git-merge-ours.sh \
@@ -361,6 +361,7 @@ BUILTIN_OBJS = \
builtin-show-branch.o \
builtin-stripspace.o \
builtin-symbolic-ref.o \
+ builtin-tag.o \
builtin-tar-tree.o \
builtin-unpack-objects.o \
builtin-update-index.o \
diff --git a/builtin-tag.c b/builtin-tag.c
new file mode 100644
index 0000000..507f510
--- /dev/null
+++ b/builtin-tag.c
@@ -0,0 +1,450 @@
+/*
+ * Builtin "git tag"
+ *
+ * Copyright (c) 2007 Kristian HÞgsberg <krh@redhat.com>,
+ * Carlos Rica <jasampler@gmail.com>
+ * Based on git-tag.sh and mktag.c by Linus Torvalds.
+ */
+
+#include "cache.h"
+#include "builtin.h"
+#include "refs.h"
+#include "tag.h"
+#include "run-command.h"
+
+static const char builtin_tag_usage[] =
+ "git-tag [-n [<num>]] -l [<pattern>] | [-a | -s | -u <key-id>] [-f | -d | -v] [-m <msg> | -F <file>] <tagname> [<head>]";
+
+static char signingkey[1000];
+
+static void launch_editor(const char *path, char **buffer, unsigned long *len)
+{
+ const char *editor, *terminal;
+ struct child_process child;
+ const char *args[3];
+ int fd;
+
+ editor = getenv("VISUAL");
+ if (!editor)
+ editor = getenv("EDITOR");
+
+ terminal = getenv("TERM");
+ if (!editor && (!terminal || !strcmp(terminal, "dumb"))) {
+ fprintf(stderr,
+ "Terminal is dumb but no VISUAL nor EDITOR defined.\n"
+ "Please supply the message using either -m or -F option.\n");
+ exit(1);
+ }
+
+ if (!editor)
+ editor = "vi";
+
+ memset(&child, 0, sizeof(child));
+ child.argv = args;
+ args[0] = editor;
+ args[1] = path;
+ args[2] = NULL;
+
+ if (run_command(&child))
+ die("There was a problem with the editor %s.", editor);
+
+ fd = open(path, O_RDONLY);
+ if (fd < 0)
+ die("could not open '%s': %s", path, strerror(errno));
+ if (read_fd(fd, buffer, len)) {
+ free(*buffer);
+ die("could not read message file '%s': %s",
+ path, strerror(errno));
+ }
+ close(fd);
+}
+
+struct tag_filter {
+ const char *pattern;
+ int lines;
+};
+
+#define PGP_SIGNATURE "-----BEGIN PGP SIGNATURE-----"
+
+static int show_reference(const char *refname, const unsigned char *sha1,
+ int flag, void *cb_data)
+{
+ struct tag_filter *filter = cb_data;
+
+ if (!fnmatch(filter->pattern, refname, 0)) {
+ int i;
+ unsigned long size;
+ enum object_type type;
+ char *buf, *sp, *eol;
+ size_t len;
+
+ if (!filter->lines) {
+ printf("%s\n", refname);
+ return 0;
+ }
+ printf("%-15s ", refname);
+
+ sp = buf = read_sha1_file(sha1, &type, &size);
+ if (!buf || !size)
+ return 0;
+ /* skip header */
+ while (sp + 1 < buf + size &&
+ !(sp[0] == '\n' && sp[1] == '\n'))
+ sp++;
+ /* only take up to "lines" lines, and strip the signature */
+ for (i = 0, sp += 2; i < filter->lines && sp < buf + size &&
+ prefixcmp(sp, PGP_SIGNATURE "\n");
+ i++) {
+ if (i)
+ printf("\n ");
+ eol = memchr(sp, '\n', size - (sp - buf));
+ len = eol ? eol - sp : size - (sp - buf);
+ fwrite(sp, len, 1, stdout);
+ if (!eol)
+ break;
+ sp = eol + 1;
+ }
+ putchar('\n');
+ free(buf);
+ }
+
+ return 0;
+}
+
+static int list_tags(const char *pattern, int lines)
+{
+ struct tag_filter filter;
+ char *newpattern;
+
+ if (pattern == NULL)
+ pattern = "";
+
+ /* prepend/append * to the shell pattern: */
+ newpattern = xmalloc(strlen(pattern) + 3);
+ sprintf(newpattern, "*%s*", pattern);
+
+ filter.pattern = newpattern;
+ filter.lines = lines;
+
+ for_each_tag_ref(show_reference, (void *) &filter);
+
+ free(newpattern);
+
+ return 0;
+}
+
+typedef int (*func_tag)(const char *name, const char *ref,
+ const unsigned char *sha1);
+
+static int do_tag_names(const char **argv, func_tag fn)
+{
+ const char **p;
+ char ref[PATH_MAX];
+ int had_error = 0;
+ unsigned char sha1[20];
+
+ for (p = argv; *p; p++) {
+ if (snprintf(ref, sizeof(ref), "refs/tags/%s", *p)
+ >= sizeof(ref)) {
+ error("tag name too long: %.*s...", 50, *p);
+ had_error = 1;
+ continue;
+ }
+ if (!resolve_ref(ref, sha1, 1, NULL)) {
+ error("tag '%s' not found.", *p);
+ had_error = 1;
+ continue;
+ }
+ if (fn(*p, ref, sha1))
+ had_error = 1;
+ }
+ return had_error;
+}
+
+static int delete_tag(const char *name, const char *ref,
+ const unsigned char *sha1)
+{
+ if (delete_ref(ref, sha1))
+ return 1;
+ printf("Deleted tag '%s'\n", name);
+ return 0;
+}
+
+static int verify_tag(const char *name, const char *ref,
+ const unsigned char *sha1)
+{
+ const char *argv_verify_tag[] = {"git-verify-tag",
+ "-v", "SHA1_HEX", NULL};
+ argv_verify_tag[2] = sha1_to_hex(sha1);
+
+ if (run_command_v_opt(argv_verify_tag, 0))
+ return error("could not verify the tag '%s'", name);
+ return 0;
+}
+
+static ssize_t do_sign(char *buffer, size_t size, size_t max)
+{
+ struct child_process gpg;
+ const char *args[4];
+ char *bracket;
+ int len;
+
+ if (!*signingkey) {
+ if (strlcpy(signingkey, git_committer_info(1),
+ sizeof(signingkey)) >= sizeof(signingkey))
+ return error("committer info too long.");
+ bracket = strchr(signingkey, '>');
+ if (bracket)
+ bracket[1] = '\0';
+ }
+
+ memset(&gpg, 0, sizeof(gpg));
+ gpg.argv = args;
+ gpg.in = -1;
+ gpg.out = -1;
+ args[0] = "gpg";
+ args[1] = "-bsau";
+ args[2] = signingkey;
+ args[3] = NULL;
+
+ if (start_command(&gpg))
+ return error("could not run gpg.");
+
+ write_or_die(gpg.in, buffer, size);
+ close(gpg.in);
+ gpg.close_in = 0;
+ len = read_in_full(gpg.out, buffer + size, max - size);
+
+ finish_command(&gpg);
+
+ if (len == max - size)
+ return error("could not read the entire signature from gpg.");
+
+ return size + len;
+}
+
+static const char tag_template[] =
+ "\n"
+ "#\n"
+ "# Write a tag message\n"
+ "#\n";
+
+static int git_tag_config(const char *var, const char *value)
+{
+ if (!strcmp(var, "user.signingkey")) {
+ if (!value)
+ die("user.signingkey without value");
+ if (strlcpy(signingkey, value, sizeof(signingkey))
+ >= sizeof(signingkey))
+ die("user.signingkey value too long");
+ return 0;
+ }
+
+ return git_default_config(var, value);
+}
+
+#define MAX_SIGNATURE_LENGTH 1024
+/* message must be NULL or allocated, it will be reallocated and freed */
+static void create_tag(const unsigned char *object, const char *tag,
+ char *message, int sign, unsigned char *result)
+{
+ enum object_type type;
+ char header_buf[1024], *buffer;
+ int header_len, max_size;
+ unsigned long size;
+
+ type = sha1_object_info(object, NULL);
+ if (type <= 0)
+ die("bad object type.");
+
+ header_len = snprintf(header_buf, sizeof(header_buf),
+ "object %s\n"
+ "type %s\n"
+ "tag %s\n"
+ "tagger %s\n\n",
+ sha1_to_hex(object),
+ typename(type),
+ tag,
+ git_committer_info(1));
+
+ if (header_len >= sizeof(header_buf))
+ die("tag header too big.");
+
+ if (!message) {
+ char *path;
+ int fd;
+
+ /* write the template message before editing: */
+ path = xstrdup(git_path("TAG_EDITMSG"));
+ fd = open(path, O_CREAT | O_TRUNC | O_WRONLY, 0600);
+ if (fd < 0)
+ die("could not create file '%s': %s",
+ path, strerror(errno));
+ write_or_die(fd, tag_template, strlen(tag_template));
+ close(fd);
+
+ launch_editor(path, &buffer, &size);
+
+ unlink(path);
+ free(path);
+ }
+ else {
+ buffer = message;
+ size = strlen(message);
+ }
+
+ size = stripspace(buffer, size, 1);
+
+ if (!message && !size)
+ die("no tag message?");
+
+ /* insert the header and add the '\n' if needed: */
+ max_size = header_len + size + (sign ? MAX_SIGNATURE_LENGTH : 0) + 1;
+ buffer = xrealloc(buffer, max_size);
+ if (size)
+ buffer[size++] = '\n';
+ memmove(buffer + header_len, buffer, size);
+ memcpy(buffer, header_buf, header_len);
+ size += header_len;
+
+ if (sign) {
+ size = do_sign(buffer, size, max_size);
+ if (size < 0)
+ die("unable to sign the tag");
+ }
+
+ if (write_sha1_file(buffer, size, tag_type, result) < 0)
+ die("unable to write tag file");
+ free(buffer);
+}
+
+int cmd_tag(int argc, const char **argv, const char *prefix)
+{
+ unsigned char object[20], prev[20];
+ int annotate = 0, sign = 0, force = 0, lines = 0;
+ char *message = NULL;
+ char ref[PATH_MAX];
+ const char *object_ref, *tag;
+ int i;
+ struct ref_lock *lock;
+
+ git_config(git_tag_config);
+
+ for (i = 1; i < argc; i++) {
+ const char *arg = argv[i];
+
+ if (arg[0] != '-')
+ break;
+ if (!strcmp(arg, "-a")) {
+ annotate = 1;
+ continue;
+ }
+ if (!strcmp(arg, "-s")) {
+ annotate = 1;
+ sign = 1;
+ continue;
+ }
+ if (!strcmp(arg, "-f")) {
+ force = 1;
+ continue;
+ }
+ if (!strcmp(arg, "-n")) {
+ if (i + 1 == argc || *argv[i + 1] == '-')
+ /* no argument */
+ lines = 1;
+ else
+ lines = isdigit(*argv[++i]) ?
+ atoi(argv[i]) : 1;
+ continue;
+ }
+ if (!strcmp(arg, "-m")) {
+ annotate = 1;
+ i++;
+ if (i == argc)
+ die("option -m needs an argument.");
+ message = xstrdup(argv[i]);
+ continue;
+ }
+ if (!strcmp(arg, "-F")) {
+ unsigned long len;
+ int fd;
+
+ annotate = 1;
+ i++;
+ if (i == argc)
+ die("option -F needs an argument.");
+
+ if (!strcmp(argv[i], "-"))
+ fd = 0;
+ else {
+ fd = open(argv[i], O_RDONLY);
+ if (fd < 0)
+ die("could not open '%s': %s",
+ argv[i], strerror(errno));
+ }
+ len = 1024;
+ message = xmalloc(len);
+ if (read_fd(fd, &message, &len)) {
+ free(message);
+ die("cannot read %s", argv[i]);
+ }
+ continue;
+ }
+ if (!strcmp(arg, "-u")) {
+ annotate = 1;
+ sign = 1;
+ i++;
+ if (i == argc)
+ die("option -u needs an argument.");
+ if (strlcpy(signingkey, argv[i], sizeof(signingkey))
+ >= sizeof(signingkey))
+ die("argument to option -u too long");
+ continue;
+ }
+ if (!strcmp(arg, "-l")) {
+ return list_tags(argv[i + 1], lines);
+ }
+ if (!strcmp(arg, "-d")) {
+ return do_tag_names(argv + i + 1, delete_tag);
+ }
+ if (!strcmp(arg, "-v")) {
+ return do_tag_names(argv + i + 1, verify_tag);
+ }
+ usage(builtin_tag_usage);
+ }
+
+ if (i == argc) {
+ if (annotate)
+ usage(builtin_tag_usage);
+ return list_tags(NULL, lines);
+ }
+ tag = argv[i++];
+
+ object_ref = i < argc ? argv[i] : "HEAD";
+ if (i + 1 < argc)
+ die("too many params");
+
+ if (get_sha1(object_ref, object))
+ die("Failed to resolve '%s' as a valid ref.", object_ref);
+
+ if (snprintf(ref, sizeof(ref), "refs/tags/%s", tag) >= sizeof(ref))
+ die("tag name too long: %.*s...", 50, tag);
+ if (check_ref_format(ref))
+ die("'%s' is not a valid tag name.", tag);
+
+ if (!resolve_ref(ref, prev, 1, NULL))
+ hashclr(prev);
+ else if (!force)
+ die("tag '%s' already exists", tag);
+
+ if (annotate)
+ create_tag(object, tag, message, sign, object);
+
+ lock = lock_any_ref_for_update(ref, prev, 0);
+ if (!lock)
+ die("%s: cannot lock the ref", ref);
+ if (write_ref_sha1(lock, object, NULL) < 0)
+ die("%s: cannot update the ref", ref);
+
+ return 0;
+}
diff --git a/builtin.h b/builtin.h
index 4cc228d..ac7417f 100644
--- a/builtin.h
+++ b/builtin.h
@@ -70,6 +70,7 @@ extern int cmd_show(int argc, const char **argv, const char *prefix);
extern int cmd_show_branch(int argc, const char **argv, const char *prefix);
extern int cmd_stripspace(int argc, const char **argv, const char *prefix);
extern int cmd_symbolic_ref(int argc, const char **argv, const char *prefix);
+extern int cmd_tag(int argc, const char **argv, const char *prefix);
extern int cmd_tar_tree(int argc, const char **argv, const char *prefix);
extern int cmd_unpack_objects(int argc, const char **argv, const char *prefix);
extern int cmd_update_index(int argc, const char **argv, const char *prefix);
diff --git a/git-tag.sh b/contrib/examples/git-tag.sh
similarity index 100%
rename from git-tag.sh
rename to contrib/examples/git-tag.sh
diff --git a/git.c b/git.c
index a647f9c..eb9e5ca 100644
--- a/git.c
+++ b/git.c
@@ -363,6 +363,7 @@ static void handle_internal_command(int argc, const char **argv)
{ "show", cmd_show, RUN_SETUP | USE_PAGER },
{ "stripspace", cmd_stripspace },
{ "symbolic-ref", cmd_symbolic_ref, RUN_SETUP },
+ { "tag", cmd_tag, RUN_SETUP },
{ "tar-tree", cmd_tar_tree },
{ "unpack-objects", cmd_unpack_objects, RUN_SETUP },
{ "update-index", cmd_update_index, RUN_SETUP },
diff --git a/t/t7004-tag.sh b/t/t7004-tag.sh
index 17de2a9..a0be164 100755
--- a/t/t7004-tag.sh
+++ b/t/t7004-tag.sh
@@ -5,7 +5,7 @@
test_description='git-tag
-Basic tests for operations with tags.'
+Tests for operations with tags.'
. ./test-lib.sh
@@ -16,11 +16,15 @@ tag_exists () {
}
# todo: git tag -l now returns always zero, when fixed, change this test
-test_expect_success 'listing all tags in an empty tree should succeed' \
- 'git tag -l'
+test_expect_success 'listing all tags in an empty tree should succeed' '
+ git tag -l &&
+ git tag
+'
-test_expect_success 'listing all tags in an empty tree should output nothing' \
- 'test `git-tag -l | wc -l` -eq 0'
+test_expect_success 'listing all tags in an empty tree should output nothing' '
+ test `git-tag -l | wc -l` -eq 0 &&
+ test `git-tag | wc -l` -eq 0
+'
test_expect_failure 'looking for a tag in an empty tree should fail' \
'tag_exists mytag'
@@ -49,11 +53,15 @@ test_expect_success 'creating a tag using default HEAD should succeed' '
git tag mytag
'
-test_expect_success 'listing all tags if one exists should succeed' \
- 'git-tag -l'
+test_expect_success 'listing all tags if one exists should succeed' '
+ git-tag -l &&
+ git-tag
+'
-test_expect_success 'listing all tags if one exists should output that tag' \
- 'test `git-tag -l` = mytag'
+test_expect_success 'listing all tags if one exists should output that tag' '
+ test `git-tag -l` = mytag &&
+ test `git-tag` = mytag
+'
# pattern matching:
@@ -165,6 +173,8 @@ test_expect_success 'listing all tags should print them ordered' '
git tag v1.0 &&
git tag t210 &&
git tag -l > actual &&
+ git diff expect actual &&
+ git tag > actual &&
git diff expect actual
'
@@ -264,6 +274,10 @@ test_expect_failure \
'trying to verify a non-annotated and non-signed tag should fail' \
'git-tag -v non-annotated-tag'
+test_expect_failure \
+ 'trying to verify many non-annotated or unknown tags, should fail' \
+ 'git-tag -v unknown-tag1 non-annotated-tag unknown-tag2'
+
# creating annotated tags:
get_tag_msg () {
@@ -306,6 +320,18 @@ test_expect_success \
git diff expect actual
'
+cat >inputmsg <<EOF
+A message from the
+standard input
+EOF
+get_tag_header stdin-annotated-tag $commit commit $time >expect
+cat inputmsg >>expect
+test_expect_success 'creating an annotated tag with -F - should succeed' '
+ git-tag -F - stdin-annotated-tag <inputmsg &&
+ get_tag_msg stdin-annotated-tag >actual &&
+ git diff expect actual
+'
+
# blank and empty messages:
get_tag_header empty-annotated-tag $commit commit $time >expect
@@ -551,6 +577,12 @@ test_expect_success \
! git-tag -v file-annotated-tag
'
+test_expect_success \
+ 'trying to verify two annotated non-signed tags should fail' '
+ tag_exists annotated-tag file-annotated-tag &&
+ ! git-tag -v annotated-tag file-annotated-tag
+'
+
# creating and verifying signed tags:
gpg --version >/dev/null
@@ -589,9 +621,47 @@ test_expect_success 'creating a signed tag with -m message should succeed' '
git diff expect actual
'
+cat >sigmsgfile <<EOF
+Another signed tag
+message in a file.
+EOF
+get_tag_header file-signed-tag $commit commit $time >expect
+cat sigmsgfile >>expect
+echo '-----BEGIN PGP SIGNATURE-----' >>expect
+test_expect_success \
+ 'creating a signed tag with -F messagefile should succeed' '
+ git-tag -s -F sigmsgfile file-signed-tag &&
+ get_tag_msg file-signed-tag >actual &&
+ git diff expect actual
+'
+
+cat >siginputmsg <<EOF
+A signed tag message from
+the standard input
+EOF
+get_tag_header stdin-signed-tag $commit commit $time >expect
+cat siginputmsg >>expect
+echo '-----BEGIN PGP SIGNATURE-----' >>expect
+test_expect_success 'creating a signed tag with -F - should succeed' '
+ git-tag -s -F - stdin-signed-tag <siginputmsg &&
+ get_tag_msg stdin-signed-tag >actual &&
+ git diff expect actual
+'
+
test_expect_success 'verifying a signed tag should succeed' \
'git-tag -v signed-tag'
+test_expect_success 'verifying two signed tags in one command should succeed' \
+ 'git-tag -v signed-tag file-signed-tag'
+
+test_expect_success \
+ 'verifying many signed and non-signed tags should fail' '
+ ! git-tag -v signed-tag annotated-tag &&
+ ! git-tag -v file-annotated-tag file-signed-tag &&
+ ! git-tag -v annotated-tag file-signed-tag file-annotated-tag &&
+ ! git-tag -v signed-tag annotated-tag file-signed-tag
+'
+
test_expect_success 'verifying a forged tag should fail' '
forged=$(git cat-file tag signed-tag |
sed -e "s/signed-tag/forged-tag/" |
--
1.5.0
^ permalink raw reply related [flat|nested] 4+ messages in thread
* Re: [PATCH] Make git tag a builtin.
2007-07-19 23:42 [PATCH] Make git tag a builtin Carlos Rica
@ 2007-07-20 8:53 ` Johannes Schindelin
2007-07-20 9:10 ` Junio C Hamano
1 sibling, 0 replies; 4+ messages in thread
From: Johannes Schindelin @ 2007-07-20 8:53 UTC (permalink / raw)
To: Carlos Rica; +Cc: git, Junio C Hamano
Hi,
On Fri, 20 Jul 2007, Carlos Rica wrote:
> diff --git a/builtin-tag.c b/builtin-tag.c
> new file mode 100644
> index 0000000..507f510
> --- /dev/null
> +++ b/builtin-tag.c
> @@ -0,0 +1,450 @@
> +/*
> + * Builtin "git tag"
> + *
> + * Copyright (c) 2007 Kristian Hv/gsberg <krh@redhat.com>,
In case of encoding problems, I suggest uploading it to repo.or.cz, so it
can be pulled. Uploading has more advantages, such as visibility and
a free backup, too...
> +typedef int (*func_tag)(const char *name, const char *ref,
> + const unsigned char *sha1);
> +
> +static int do_tag_names(const char **argv, func_tag fn)
Neat! Just a minor style nit here, though: in refs.h, we have something
similar, and I would have expected to read "each_tag_name_fn" and
"for_each_tag_name" instead of "func_tag" and "do_tag_names",
respectively. Hmm?
> +static ssize_t do_sign(char *buffer, size_t size, size_t max)
> +{
> + struct child_process gpg;
> + const char *args[4];
> + char *bracket;
> + int len;
> +
> + if (!*signingkey) {
> + if (strlcpy(signingkey, git_committer_info(1),
> + sizeof(signingkey)) >= sizeof(signingkey))
sizeof(signingkey) - 1?
> + len = read_in_full(gpg.out, buffer + size, max - size);
> +
> + finish_command(&gpg);
> +
> + if (len == max - size)
> + return error("could not read the entire signature from gpg.");
Maybe at a later stage, and if this turns out to be not sufficient to
begin with, we might consider not using a buffer, but writing
incrementally into an object right away. Think "git hash-object -w
--stdin".
But at the moment, this is not a problem, so let's keep it as-is.
> +static int git_tag_config(const char *var, const char *value)
> +{
> + if (!strcmp(var, "user.signingkey")) {
> + if (!value)
> + die("user.signingkey without value");
> + if (strlcpy(signingkey, value, sizeof(signingkey))
> + >= sizeof(signingkey))
sizeof(signingkey) - 1?
> +static void create_tag(const unsigned char *object, const char *tag,
> + char *message, int sign, unsigned char *result)
> +{
> + enum object_type type;
> + char header_buf[1024], *buffer;
> + int header_len, max_size;
> + unsigned long size;
> +
> + type = sha1_object_info(object, NULL);
> + if (type <= 0)
Maybe use OBJ_NONE instead of 0? Dunno.
> + die("bad object type.");
> +
> + header_len = snprintf(header_buf, sizeof(header_buf),
> + "object %s\n"
> + "type %s\n"
> + "tag %s\n"
> + "tagger %s\n\n",
> + sha1_to_hex(object),
> + typename(type),
> + tag,
> + git_committer_info(1));
> +
> + if (header_len >= sizeof(header_buf))
sizeof(header_buf) - 1?
> + memmove(buffer + header_len, buffer, size);
Just two ideas for the future (it is not really important now, so we
should not do it now):
- Instead of memmove()ing, we could teach read_fd() to take an offset,
too.
- launch_editor() could learn to write the buffer itself (IMHO it is more
common to write a buffer to the file before editing it, than editing an
existing file).
But as I said, this is just something to keep in mind, not to change now.
> + if (!strcmp(arg, "-F")) {
> + unsigned long len;
> + int fd;
> +
> + annotate = 1;
> + i++;
> + if (i == argc)
> + die("option -F needs an argument.");
> +
> + if (!strcmp(argv[i], "-"))
> + fd = 0;
> + else {
> + fd = open(argv[i], O_RDONLY);
> + if (fd < 0)
> + die("could not open '%s': %s",
> + argv[i], strerror(errno));
> + }
> + len = 1024;
> + message = xmalloc(len);
> + if (read_fd(fd, &message, &len)) {
With your recent sanification of read_fd(), you can initialise len and
message to 0 and NULL, respectively.
> + if (!strcmp(arg, "-u")) {
> + annotate = 1;
> + sign = 1;
> + i++;
> + if (i == argc)
> + die("option -u needs an argument.");
> + if (strlcpy(signingkey, argv[i], sizeof(signingkey))
> + >= sizeof(signingkey))
sizeof(signingkey) - 1?
> + die("argument to option -u too long");
> + continue;
> + }
> + if (!strcmp(arg, "-l")) {
> + return list_tags(argv[i + 1], lines);
> + }
> + if (!strcmp(arg, "-d")) {
> + return do_tag_names(argv + i + 1, delete_tag);
> + }
> + if (!strcmp(arg, "-v")) {
> + return do_tag_names(argv + i + 1, verify_tag);
> + }
Please lose the "{..}" around single lines.
> + if (get_sha1(object_ref, object))
> + die("Failed to resolve '%s' as a valid ref.", object_ref);
> +
> + if (snprintf(ref, sizeof(ref), "refs/tags/%s", tag) >= sizeof(ref))
sizeof(ref) - 1?
> diff --git a/git-tag.sh b/contrib/examples/git-tag.sh
> similarity index 100%
> rename from git-tag.sh
> rename to contrib/examples/git-tag.sh
That should make Nico and Junio happy.
These are my last minor nits. If nobody else has objections, let's put
this ship to sea.
Ciao,
Dscho
^ permalink raw reply [flat|nested] 4+ messages in thread
* Re: [PATCH] Make git tag a builtin.
2007-07-19 23:42 [PATCH] Make git tag a builtin Carlos Rica
2007-07-20 8:53 ` Johannes Schindelin
@ 2007-07-20 9:10 ` Junio C Hamano
2007-07-20 10:15 ` Johannes Schindelin
1 sibling, 1 reply; 4+ messages in thread
From: Junio C Hamano @ 2007-07-20 9:10 UTC (permalink / raw)
To: Carlos Rica; +Cc: git, Johannes Schindelin
Carlos Rica <jasampler@gmail.com> writes:
> This replaces the script "git-tag.sh" with "builtin-tag.c".
Thanks. Will queue in 'next', and perhaps with a few nit fixups
to merge as the first thing after 1.5.3.
> diff --git a/builtin-tag.c b/builtin-tag.c
> new file mode 100644
> index 0000000..507f510
> --- /dev/null
> +++ b/builtin-tag.c
> @@ -0,0 +1,450 @@
> +/*
> + * Builtin "git tag"
> + *
> + * Copyright (c) 2007 Kristian H??gsberg <krh@redhat.com>,
I've fixed up the name here in my copy.
> +static void launch_editor(const char *path, char **buffer, unsigned long *len)
> +{
> + const char *editor, *terminal;
> + struct child_process child;
> + const char *args[3];
> + int fd;
> +
> + editor = getenv("VISUAL");
> + if (!editor)
> + editor = getenv("EDITOR");
> +
> + terminal = getenv("TERM");
> + if (!editor && (!terminal || !strcmp(terminal, "dumb"))) {
> + fprintf(stderr,
> + "Terminal is dumb but no VISUAL nor EDITOR defined.\n"
> + "Please supply the message using either -m or -F option.\n");
> + exit(1);
> + }
> +
> + if (!editor)
> + editor = "vi";
launch-editor() would need adjustment for GIT_EDITOR and
core.editor which should be straightforward.
> +struct tag_filter {
> + const char *pattern;
> + int lines;
> +};
> +
> +#define PGP_SIGNATURE "-----BEGIN PGP SIGNATURE-----"
> +
> +static int show_reference(const char *refname, const unsigned char *sha1,
> + int flag, void *cb_data)
> +{
> + struct tag_filter *filter = cb_data;
> +
> + if (!fnmatch(filter->pattern, refname, 0)) {
> + int i;
> + unsigned long size;
> + enum object_type type;
> + char *buf, *sp, *eol;
> + size_t len;
> +
> + if (!filter->lines) {
> + printf("%s\n", refname);
> + return 0;
> + }
> + printf("%-15s ", refname);
> +
> + sp = buf = read_sha1_file(sha1, &type, &size);
> + if (!buf || !size)
> + return 0;
Theoretically, I can create millions of lightweight tags, all of
them pointing at a zero-length blob object (or an empty tree
object) and kill you with memory leak here ;-).
> + /* skip header */
> + while (sp + 1 < buf + size &&
> + !(sp[0] == '\n' && sp[1] == '\n'))
> + sp++;
> + /* only take up to "lines" lines, and strip the signature */
> + for (i = 0, sp += 2; i < filter->lines && sp < buf + size &&
> + prefixcmp(sp, PGP_SIGNATURE "\n");
> + i++) {
Minor nit; I would have split this to four physical lines, like:
for (i = 0, sp += 2;
i < filter->lines && sp < buf + size &&
prefixcmp(sp, PGP_SIGNATURE "\n");
i++) {
The places that semicolons appear are more significant gaps when
reading the code.
> +int cmd_tag(int argc, const char **argv, const char *prefix)
> +{
> ...
> + if (!strcmp(arg, "-F")) {
> + unsigned long len;
> + int fd;
> +
> + annotate = 1;
> + i++;
> + if (i == argc)
> + die("option -F needs an argument.");
> +
> + if (!strcmp(argv[i], "-"))
> + fd = 0;
> + else {
> + fd = open(argv[i], O_RDONLY);
> + if (fd < 0)
> + die("could not open '%s': %s",
> + argv[i], strerror(errno));
> + }
> + len = 1024;
> + message = xmalloc(len);
You cannot anticipate how many bytes the user will type (or
pipe-in), but when you opened the file you could fstat() to see
how many bytes you would need to hold the contents of that
file. Even in stdin case fstat(fd) could tell you the size, but
I am not sure how to tell if the st_size is reliable. But for
the purposes of "git tag", 1k buffer that grows on demand is
probably cheaper than a fstat() syscall.
> + if (read_fd(fd, &message, &len)) {
> + free(message);
> + die("cannot read %s", argv[i]);
> + }
> + continue;
We seem to leak fd here, but the user is doing something insane
if he gives more than one -F anyway, so it probably is Ok, as
long as we have some sanity checks. Should we barf on "git tag
-m foo -F bar"? What should we do with "git tag -m one -m two"?
Does the test suite check any of these conditions?
> + if (snprintf(ref, sizeof(ref), "refs/tags/%s", tag) >= sizeof(ref))
> + die("tag name too long: %.*s...", 50, tag);
Cute and considerate ;-).
> diff --git a/git-tag.sh b/contrib/examples/git-tag.sh
> similarity index 100%
> rename from git-tag.sh
> rename to contrib/examples/git-tag.sh
This actually caught my attention for completely different
reason. If this were removal of git-tag.sh, this would have
conflicted when applied on top of Adam's GIT_EDITOR/core.editor
patch. With a rename, however, there is no preimage/context
shown, so it just cleanly applied.
Also Johannes's final minor nits.
^ permalink raw reply [flat|nested] 4+ messages in thread
* Re: [PATCH] Make git tag a builtin.
2007-07-20 9:10 ` Junio C Hamano
@ 2007-07-20 10:15 ` Johannes Schindelin
0 siblings, 0 replies; 4+ messages in thread
From: Johannes Schindelin @ 2007-07-20 10:15 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Carlos Rica, git
Hi,
On Fri, 20 Jul 2007, Junio C Hamano wrote:
> Carlos Rica <jasampler@gmail.com> writes:
>
> > This replaces the script "git-tag.sh" with "builtin-tag.c".
>
> Thanks. Will queue in 'next', and perhaps with a few nit fixups
> to merge as the first thing after 1.5.3.
Nice!
> launch-editor() would need adjustment for GIT_EDITOR and core.editor
> which should be straightforward.
Yes. As a separate commit? After a couple of revisions, I lost track of
what I looked at, and what not... So it would make it easier for me to
have these changes after the big builtin-tag commit.
> > + sp = buf = read_sha1_file(sha1, &type, &size);
> > + if (!buf || !size)
> > + return 0;
>
> Theoretically, I can create millions of lightweight tags, all of
> them pointing at a zero-length blob object (or an empty tree
> object) and kill you with memory leak here ;-).
Yes ;-) Would we really want to say
if (!buf)
return 0;
if (!size) {
free(buf);
return 0;
}
here? IMHO that is overkill.
> > + /* skip header */
> > + while (sp + 1 < buf + size &&
> > + !(sp[0] == '\n' && sp[1] == '\n'))
> > + sp++;
> > + /* only take up to "lines" lines, and strip the signature */
> > + for (i = 0, sp += 2; i < filter->lines && sp < buf + size &&
> > + prefixcmp(sp, PGP_SIGNATURE "\n");
> > + i++) {
>
> Minor nit; I would have split this to four physical lines, like:
>
> for (i = 0, sp += 2;
> i < filter->lines && sp < buf + size &&
> prefixcmp(sp, PGP_SIGNATURE "\n");
> i++) {
>
> The places that semicolons appear are more significant gaps when
> reading the code.
I am to blame for that. That code was outlined by me.
> > +int cmd_tag(int argc, const char **argv, const char *prefix)
> > +{
> > ...
> > + if (!strcmp(arg, "-F")) {
> > + unsigned long len;
> > + int fd;
> > +
> > + annotate = 1;
> > + i++;
> > + if (i == argc)
> > + die("option -F needs an argument.");
> > +
> > + if (!strcmp(argv[i], "-"))
> > + fd = 0;
> > + else {
> > + fd = open(argv[i], O_RDONLY);
> > + if (fd < 0)
> > + die("could not open '%s': %s",
> > + argv[i], strerror(errno));
> > + }
> > + len = 1024;
> > + message = xmalloc(len);
>
> You cannot anticipate how many bytes the user will type (or
> pipe-in), but when you opened the file you could fstat() to see
> how many bytes you would need to hold the contents of that
> file. Even in stdin case fstat(fd) could tell you the size, but
> I am not sure how to tell if the st_size is reliable. But for
> the purposes of "git tag", 1k buffer that grows on demand is
> probably cheaper than a fstat() syscall.
For a one-shot program as git-tag, I agree, the current patch is
sufficient.
Ciao,
Dscho
^ permalink raw reply [flat|nested] 4+ messages in thread
end of thread, other threads:[~2007-07-20 10:15 UTC | newest]
Thread overview: 4+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2007-07-19 23:42 [PATCH] Make git tag a builtin Carlos Rica
2007-07-20 8:53 ` Johannes Schindelin
2007-07-20 9:10 ` Junio C Hamano
2007-07-20 10:15 ` Johannes Schindelin
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).