Set prefix in snapshots when using dwimmery

This patch sets the directory prefix in archives to be the filename,
excluding the suffix (.tar.gz, .tar.bz2 etc).

The patch also removes the prefix parameter in cgit_print_snapshot()
as the prefix might differ.

Signed-off-by: Lars Hjemli <hjemli@gmail.com>

3 files changed, 14 insertions, 6 deletions

diff --git a/cmd.c b/cmd.c
index 5b3c14c..8914fa5 100644
--- a/cmd.c
+++ b/cmd.c
@@ -11,155 +11,154 @@
 #include "cache.h"
 #include "ui-shared.h"
 #include "ui-atom.h"
 #include "ui-blob.h"
 #include "ui-clone.h"
 #include "ui-commit.h"
 #include "ui-diff.h"
 #include "ui-log.h"
 #include "ui-patch.h"
 #include "ui-plain.h"
 #include "ui-refs.h"
 #include "ui-repolist.h"
 #include "ui-snapshot.h"
 #include "ui-summary.h"
 #include "ui-tag.h"
 #include "ui-tree.h"
 
 static void HEAD_fn(struct cgit_context *ctx)
 {
 	cgit_clone_head(ctx);
 }
 
 static void atom_fn(struct cgit_context *ctx)
 {
 	cgit_print_atom(ctx->qry.head, ctx->qry.path, 10);
 }
 
 static void about_fn(struct cgit_context *ctx)
 {
 	if (ctx->repo)
 		cgit_print_repo_readme();
 	else
 		cgit_print_site_readme();
 }
 
 static void blob_fn(struct cgit_context *ctx)
 {
 	cgit_print_blob(ctx->qry.sha1, ctx->qry.path, ctx->qry.head);
 }
 
 static void commit_fn(struct cgit_context *ctx)
 {
 	cgit_print_commit(ctx->qry.sha1);
 }
 
 static void diff_fn(struct cgit_context *ctx)
 {
 	cgit_print_diff(ctx->qry.sha1, ctx->qry.sha2, ctx->qry.path);
 }
 
 static void info_fn(struct cgit_context *ctx)
 {
 	cgit_clone_info(ctx);
 }
 
 static void log_fn(struct cgit_context *ctx)
 {
 	cgit_print_log(ctx->qry.sha1, ctx->qry.ofs, ctx->cfg.max_commit_count,
 		       ctx->qry.grep, ctx->qry.search, ctx->qry.path, 1);
 }
 
 static void ls_cache_fn(struct cgit_context *ctx)
 {
 	ctx->page.mimetype = "text/plain";
 	ctx->page.filename = "ls-cache.txt";
 	cgit_print_http_headers(ctx);
 	cache_ls(ctx->cfg.cache_root);
 }
 
 static void objects_fn(struct cgit_context *ctx)
 {
 	cgit_clone_objects(ctx);
 }
 
 static void repolist_fn(struct cgit_context *ctx)
 {
 	cgit_print_repolist();
 }
 
 static void patch_fn(struct cgit_context *ctx)
 {
 	cgit_print_patch(ctx->qry.sha1);
 }
 
 static void plain_fn(struct cgit_context *ctx)
 {
 	cgit_print_plain(ctx);
 }
 
 static void refs_fn(struct cgit_context *ctx)
 {
 	cgit_print_refs();
 }
 
 static void snapshot_fn(struct cgit_context *ctx)
 {
-	cgit_print_snapshot(ctx->qry.head, ctx->qry.sha1,
-			    cgit_repobasename(ctx->repo->url), ctx->qry.path,
+	cgit_print_snapshot(ctx->qry.head, ctx->qry.sha1, ctx->qry.path,
 			    ctx->repo->snapshots, ctx->qry.nohead);
 }
 
 static void summary_fn(struct cgit_context *ctx)
 {
 	cgit_print_summary();
 }
 
 static void tag_fn(struct cgit_context *ctx)
 {
 	cgit_print_tag(ctx->qry.sha1);
 }
 
 static void tree_fn(struct cgit_context *ctx)
 {
 	cgit_print_tree(ctx->qry.sha1, ctx->qry.path);
 }
 
 #define def_cmd(name, want_repo, want_layout) \
 	{#name, name##_fn, want_repo, want_layout}
 
 struct cgit_cmd *cgit_get_cmd(struct cgit_context *ctx)
 {
 	static struct cgit_cmd cmds[] = {
 		def_cmd(HEAD, 1, 0),
 		def_cmd(atom, 1, 0),
 		def_cmd(about, 0, 1),
 		def_cmd(blob, 1, 0),
 		def_cmd(commit, 1, 1),
 		def_cmd(diff, 1, 1),
 		def_cmd(info, 1, 0),
 		def_cmd(log, 1, 1),
 		def_cmd(ls_cache, 0, 0),
 		def_cmd(objects, 1, 0),
 		def_cmd(patch, 1, 0),
 		def_cmd(plain, 1, 0),
 		def_cmd(refs, 1, 1),
 		def_cmd(repolist, 0, 0),
 		def_cmd(snapshot, 1, 0),
 		def_cmd(summary, 1, 1),
 		def_cmd(tag, 1, 1),
 		def_cmd(tree, 1, 1),
 	};
 	int i;
 
 	if (ctx->qry.page == NULL) {
 		if (ctx->repo)
 			ctx->qry.page = "summary";
 		else
 			ctx->qry.page = "repolist";
 	}
 
 	for(i = 0; i < sizeof(cmds)/sizeof(*cmds); i++)
 		if (!strcmp(ctx->qry.page, cmds[i].name))
 			return &cmds[i];
 	return NULL;
 }
diff --git a/ui-snapshot.c b/ui-snapshot.c
index 9c4d086..76457d6 100644
--- a/ui-snapshot.c
+++ b/ui-snapshot.c
@@ -69,120 +69,130 @@ static const struct cgit_snapshot_format *get_format(const char *filename)
 	const struct cgit_snapshot_format *fmt;
 	int fl, sl;
 
 	fl = strlen(filename);
 	for(fmt = cgit_snapshot_formats; fmt->suffix; fmt++) {
 		sl = strlen(fmt->suffix);
 		if (sl >= fl)
 			continue;
 		if (!strcmp(fmt->suffix, filename + fl - sl))
 			return fmt;
 	}
 	return NULL;
 }
 
 static int make_snapshot(const struct cgit_snapshot_format *format,
 			 const char *hex, const char *prefix,
 			 const char *filename)
 {
 	struct archiver_args args;
 	struct commit *commit;
 	unsigned char sha1[20];
 
 	if(get_sha1(hex, sha1)) {
 		cgit_print_error(fmt("Bad object id: %s", hex));
 		return 1;
 	}
 	commit = lookup_commit_reference(sha1);
 	if(!commit) {
 		cgit_print_error(fmt("Not a commit reference: %s", hex));
 		return 1;
 	}
 	memset(&args, 0, sizeof(args));
 	if (prefix) {
 		args.base = fmt("%s/", prefix);
 		args.baselen = strlen(prefix) + 1;
 	} else {
 		args.base = "";
 		args.baselen = 0;
 	}
 	args.tree = commit->tree;
 	args.time = commit->date;
 	ctx.page.mimetype = xstrdup(format->mimetype);
 	ctx.page.filename = xstrdup(filename);
 	cgit_print_http_headers(&ctx);
 	format->write_func(&args);
 	return 0;
 }
 
 char *dwim_filename = NULL;
 const char *dwim_refname = NULL;
 
 static int ref_cb(const char *refname, const unsigned char *sha1, int flags,
 		  void *cb_data)
 {
 	const char *r = refname;
 	while (r && *r) {
 		fprintf(stderr, "  cmp %s with %s:", dwim_filename, r);
 		if (!strcmp(dwim_filename, r)) {
 			fprintf(stderr, "MATCH!\n");
 			dwim_refname = refname;
 			return 1;
 		}
 		fprintf(stderr, "no match\n");
 		if (isdigit(*r))
 			break;
 		r++;
 	}
 	return 0;
 }
 
 /* Try to guess the requested revision by combining repo name and tag name
  * and comparing this to the requested snapshot name. E.g. the requested
  * snapshot is "cgit-0.7.2.tar.gz" while repo name is "cgit" and tag name
  * is "v0.7.2". First, the reponame is stripped off, leaving "-0.7.2.tar.gz".
  * Next, any '-' and '_' characters are stripped, leaving "0.7.2.tar.gz".
  * Finally, the requested format suffix is removed and we end up with "0.7.2".
  * Then we test each tag against this dwimmed filename, and for each tag
  * we even try to remove any leading characters which are non-digits. I.e.
  * we first compare with "v0.7.2", then with "0.7.2" and we've got a match.
  */
 static const char *get_ref_from_filename(const char *url, const char *filename,
 					 const struct cgit_snapshot_format *fmt)
 {
 	const char *reponame = cgit_repobasename(url);
 	fprintf(stderr, "reponame=%s, filename=%s\n", reponame, filename);
 	if (prefixcmp(filename, reponame))
 		return NULL;
 	filename += strlen(reponame);
 	while (filename && (*filename == '-' || *filename == '_'))
 		filename++;
 	dwim_filename = xstrdup(filename);
 	dwim_filename[strlen(filename) - strlen(fmt->suffix)] = '\0';
 	for_each_tag_ref(ref_cb, NULL);
 	return dwim_refname;
 }
 
-void cgit_print_snapshot(const char *head, const char *hex, const char *prefix,
+void cgit_print_snapshot(const char *head, const char *hex,
 			 const char *filename, int snapshots, int dwim)
 {
 	const struct cgit_snapshot_format* f;
+	char *prefix = NULL;
 
 	f = get_format(filename);
 	if (!f) {
 		ctx.page.mimetype = "text/html";
 		cgit_print_http_headers(&ctx);
 		cgit_print_docstart(&ctx);
 		cgit_print_pageheader(&ctx);
 		cgit_print_error(fmt("Unsupported snapshot format: %s", filename));
 		cgit_print_docend();
 		return;
 	}
 
-	if (!hex && dwim)
+	if (!hex && dwim) {
 		hex = get_ref_from_filename(ctx.repo->url, filename, f);
+		if (hex != NULL) {
+			prefix = xstrdup(filename);
+			prefix[strlen(filename) - strlen(f->suffix)] = '\0';
+		}
+	}
 
 	if (!hex)
 		hex = head;
 
+	if (!prefix)
+		prefix = xstrdup(cgit_repobasename(ctx.repo->url));
+
 	make_snapshot(f, hex, prefix, filename);
+	free(prefix);
 }
diff --git a/ui-snapshot.h b/ui-snapshot.h
index 3540303..b6ede52 100644
--- a/ui-snapshot.h
+++ b/ui-snapshot.h
@@ -1,8 +1,7 @@
 #ifndef UI_SNAPSHOT_H
 #define UI_SNAPSHOT_H
 
 extern void cgit_print_snapshot(const char *head, const char *hex,
-				const char *prefix, const char *filename,
-				int snapshot, int dwim);
+				const char *filename, int snapshot, int dwim);
 
 #endif /* UI_SNAPSHOT_H */