git archive and glob pathspecs

6 messages, 2 authors, 2016-06-15 · open the first message on its own page

git archive and glob pathspecs

From: Peter Wu <hidden>
Date: 2016-06-15 23:02:25

Hi,

The `git archive` seems to accept a pathspec judging from the error message (git
version 2.1.0):

    git archive HEAD -- :x
    fatal: pathspec 'x' did not match any files

When I try to use deeper glob specs however, it throws an error (this also
happens if I use `:(glob)**/Makefile`, tested in the git source tree):

    $ git archive HEAD -- ':(glob)*/Makefile'
    fatal: pathspec '*/Makefile' did not match any files

Strange enough, command `git log -- ':(glob)*/Makefile'` works. Any idea what is
wrong?

Kind regards,
Peter
https://lekensteyn.nl

Re: git archive and glob pathspecs

From: Duy Nguyen <hidden>
Date: 2016-06-15 23:02:25

On Wed, Sep 3, 2014 at 5:17 AM, Peter Wu [off-list ref] wrote:

Hi,

The `git archive` seems to accept a pathspec judging from the error message (git
version 2.1.0):

    git archive HEAD -- :x
    fatal: pathspec 'x' did not match any files

When I try to use deeper glob specs however, it throws an error (this also
happens if I use `:(glob)**/Makefile`, tested in the git source tree):

    $ git archive HEAD -- ':(glob)*/Makefile'
    fatal: pathspec '*/Makefile' did not match any files

Strange enough, command `git log -- ':(glob)*/Makefile'` works. Any idea what is
wrong?

There may be something wrong. This patch seems to make it work for me,
but it includes lots of empty directories. I'll have a closer look
later (btw it's surprising that negative pathspec works too..)

diff --git a/archive.c b/archive.c
index 3fc0fb2..a5be58d 100644
--- a/archive.c
+++ b/archive.c

@@ -221,6 +221,7 @@ static int path_exists(struct tree *tree, const char *path)
  int ret;

  parse_pathspec(&pathspec, 0, 0, "", paths);
+ pathspec.recursive = 1;
  ret = read_tree_recursive(tree, "", 0, 0, &pathspec, reject_entry, NULL);
  free_pathspec(&pathspec);
  return ret != 0;

@@ -237,6 +238,7 @@ static void parse_pathspec_arg(const char **pathspec,
  parse_pathspec(&ar_args->pathspec, 0,
        PATHSPEC_PREFER_FULL,
        "", pathspec);
+ ar_args->pathspec.recursive = 1;
  if (pathspec) {
  while (*pathspec) {
  if (**pathspec && !path_exists(ar_args->tree, *pathspec))

-- 
Duy

[PATCH] archive: support filtering paths with glob

From: Nguyễn Thái Ngọc Duy <hidden>
Date: 2016-06-15 23:02:26

This patch fixes two problems with using :(glob) (or even "*.c"
without ":(glob)").

The first one is we forgot to turn on the 'recursive' flag in struct
pathspec. Without that, tree_entry_interesting() will not mark
potential directories "interesting" so that it can confirm whether
those directories have anything matching the pathspec.

The marking directories interesting has a side effect that we need to
walk inside a directory to realize that there's nothing interested in
there. By that time, 'archive' code has already written the (empty)
directory down. That means lots of empty directories in the result
archive.

This problem is fixed by lazily writing directories down when we know
they are actually needed. There is a theoretical bug in this
implementation: we can't write empty trees/directories that match that
pathspec.

Noticed-by: Peter Wu [off-list ref]
Signed-off-by: Nguyễn Thái Ngọc Duy <redacted>
---
 Similar approach could probably be used for teaching ls-tree about pathspec..

 archive.c           | 82 ++++++++++++++++++++++++++++++++++++++++++++++++++++-
 t/t5000-tar-tree.sh | 10 +++++++
 2 files changed, 91 insertions(+), 1 deletion(-)

diff --git a/archive.c b/archive.c
index 3fc0fb2..9e62bf4 100644
--- a/archive.c
+++ b/archive.c

@@ -98,9 +98,19 @@ static void setup_archive_check(struct git_attr_check *check)
 	check[1].attr = attr_export_subst;
 }
 
+struct directory {
+	struct directory *up;
+	unsigned char sha1[20];
+	int baselen, len;
+	unsigned mode;
+	int stage;
+	char path[FLEX_ARRAY];
+};
+
 struct archiver_context {
 	struct archiver_args *args;
 	write_archive_entry_fn_t write_entry;
+	struct directory *bottom;
 };
 
 static int write_archive_entry(const unsigned char *sha1, const char *base,

@@ -146,6 +156,65 @@ static int write_archive_entry(const unsigned char *sha1, const char *base,
 	return write_entry(args, sha1, path.buf, path.len, mode);
 }
 
+static void queue_directory(const unsigned char *sha1,
+		const char *base, int baselen, const char *filename,
+		unsigned mode, int stage, struct archiver_context *c)
+{
+	struct directory *d;
+	d = xmallocz(sizeof(*d) + baselen + 1 + strlen(filename));
+	d->up	   = c->bottom;
+	d->baselen = baselen;
+	d->mode	   = mode;
+	d->stage   = stage;
+	c->bottom  = d;
+	d->len = sprintf(d->path, "%.*s%s/", baselen, base, filename);
+	hashcpy(d->sha1, sha1);
+}
+
+static int write_directory(struct archiver_context *c)
+{
+	struct directory *d = c->bottom;
+	int ret;
+
+	if (!d)
+		return 0;
+	c->bottom = d->up;
+	d->path[d->len - 1] = '\0'; /* no trailing slash */
+	ret =
+		write_directory(c) ||
+		write_archive_entry(d->sha1, d->path, d->baselen,
+				    d->path + d->baselen, d->mode,
+				    d->stage, c) != READ_TREE_RECURSIVE;
+	free(d);
+	return ret ? -1 : 0;
+}
+
+static int queue_or_write_archive_entry(const unsigned char *sha1,
+		const char *base, int baselen, const char *filename,
+		unsigned mode, int stage, void *context)
+{
+	struct archiver_context *c = context;
+
+	while (c->bottom &&
+	       !(baselen >= c->bottom->len &&
+		 !strncmp(base, c->bottom->path, c->bottom->len))) {
+		struct directory *next = c->bottom->up;
+		free(c->bottom);
+		c->bottom = next;
+	}
+
+	if (S_ISDIR(mode)) {
+		queue_directory(sha1, base, baselen, filename,
+				mode, stage, c);
+		return READ_TREE_RECURSIVE;
+	}
+
+	if (write_directory(c))
+		return -1;
+	return write_archive_entry(sha1, base, baselen, filename, mode,
+				   stage, context);
+}
+
 int write_archive_entries(struct archiver_args *args,
 		write_archive_entry_fn_t write_entry)
 {

@@ -167,6 +236,7 @@ int write_archive_entries(struct archiver_args *args,
 			return err;
 	}
 
+	memset(&context, 0, sizeof(context));
 	context.args = args;
 	context.write_entry = write_entry;

@@ -187,9 +257,17 @@ int write_archive_entries(struct archiver_args *args,
 	}
 
 	err = read_tree_recursive(args->tree, "", 0, 0, &args->pathspec,
-				  write_archive_entry, &context);
+				  args->pathspec.has_wildcard ?
+				  queue_or_write_archive_entry :
+				  write_archive_entry,
+				  &context);
 	if (err == READ_TREE_RECURSIVE)
 		err = 0;
+	while (context.bottom) {
+		struct directory *next = context.bottom->up;
+		free(context.bottom);
+		context.bottom = next;
+	}
 	return err;
 }

@@ -221,6 +299,7 @@ static int path_exists(struct tree *tree, const char *path)
 	int ret;
 
 	parse_pathspec(&pathspec, 0, 0, "", paths);
+	pathspec.recursive = 1;
 	ret = read_tree_recursive(tree, "", 0, 0, &pathspec, reject_entry, NULL);
 	free_pathspec(&pathspec);
 	return ret != 0;

@@ -237,6 +316,7 @@ static void parse_pathspec_arg(const char **pathspec,
 	parse_pathspec(&ar_args->pathspec, 0,
 		       PATHSPEC_PREFER_FULL,
 		       "", pathspec);
+	ar_args->pathspec.recursive = 1;
 	if (pathspec) {
 		while (*pathspec) {
 			if (**pathspec && !path_exists(ar_args->tree, *pathspec))

diff --git a/t/t5000-tar-tree.sh b/t/t5000-tar-tree.sh
index 7b8babd..ade7a7f 100755
--- a/t/t5000-tar-tree.sh
+++ b/t/t5000-tar-tree.sh

@@ -305,4 +305,14 @@ test_expect_success GZIP 'remote tar.gz can be disabled' '
 		>remote.tar.gz
 '
 
+test_expect_success 'archive and :(glob)' '
+	git archive -v HEAD -- ":(glob)**/sh" >/dev/null 2>actual &&
+	cat >expect <<EOF &&
+a/
+a/bin/
+a/bin/sh
+EOF
+	test_cmp expect actual
+'
+
 test_done

-- 
2.1.0.rc0.78.gc0d8480

Re: git archive and glob pathspecs

From: Peter Wu <hidden>
Date: 2016-06-15 23:02:30

On Wednesday 03 September 2014 13:21:06 Duy Nguyen wrote:

On Wed, Sep 3, 2014 at 5:17 AM, Peter Wu [off-list ref] wrote:

quoted

Hi,

The `git archive` seems to accept a pathspec judging from the error message (git
version 2.1.0):

    git archive HEAD -- :x
    fatal: pathspec 'x' did not match any files

When I try to use deeper glob specs however, it throws an error (this also
happens if I use `:(glob)**/Makefile`, tested in the git source tree):

    $ git archive HEAD -- ':(glob)*/Makefile'
    fatal: pathspec '*/Makefile' did not match any files

Strange enough, command `git log -- ':(glob)*/Makefile'` works. Any idea what is
wrong?

There may be something wrong. This patch seems to make it work for me,
but it includes lots of empty directories. I'll have a closer look
later (btw it's surprising that negative pathspec works too..)

I can confirm that this patch shows Makefile's, but also includes a lot of empty
directories.

As for why this happens, my guess is that write_archive_entries() recurses the
full tree and adds every encountered directory (via read_tree_1, via
write_archive_entry()).

To fix this, write_archive (write_tar_archive, etc.) should be taught to handle
glob patterns, or parse_pathspec should expand globs (and then
parse_pathspec_arg might have to validate the remaining patterns).

Kind regards,
Peter

quoted hunk

diff --git a/archive.c b/archive.c
index 3fc0fb2..a5be58d 100644
--- a/archive.c
+++ b/archive.c

@@ -221,6 +221,7 @@ static int path_exists(struct tree *tree, const char *path)
  int ret;

  parse_pathspec(&pathspec, 0, 0, "", paths);
+ pathspec.recursive = 1;
  ret = read_tree_recursive(tree, "", 0, 0, &pathspec, reject_entry, NULL);
  free_pathspec(&pathspec);
  return ret != 0;

@@ -237,6 +238,7 @@ static void parse_pathspec_arg(const char **pathspec,
  parse_pathspec(&ar_args->pathspec, 0,
        PATHSPEC_PREFER_FULL,
        "", pathspec);
+ ar_args->pathspec.recursive = 1;
  if (pathspec) {
  while (*pathspec) {
  if (**pathspec && !path_exists(ar_args->tree, *pathspec))

Re: [PATCH] archive: support filtering paths with glob

From: Peter Wu <hidden>
Date: 2016-06-15 23:02:30

On Thursday 04 September 2014 20:37:52 Nguyễn Thái Ngọc Duy wrote:

This patch fixes two problems with using :(glob) (or even "*.c"
without ":(glob)").

The first one is we forgot to turn on the 'recursive' flag in struct
pathspec. Without that, tree_entry_interesting() will not mark
potential directories "interesting" so that it can confirm whether
those directories have anything matching the pathspec.

The marking directories interesting has a side effect that we need to
walk inside a directory to realize that there's nothing interested in
there. By that time, 'archive' code has already written the (empty)
directory down. That means lots of empty directories in the result
archive.

This problem is fixed by lazily writing directories down when we know
they are actually needed. There is a theoretical bug in this
implementation: we can't write empty trees/directories that match that
pathspec.

Noticed-by: Peter Wu [off-list ref]
Signed-off-by: Nguyễn Thái Ngọc Duy <redacted>

Ah, ignore my last mail, I just noticed this one. This patch works fine. By the
way, the glob pattern is treated as a 'nullglob'. If you specify a glob pattern
that matches nothing, an empty archive is created. Perhaps an error message
should be raised for that as it is unlikely that a user wants that?

Tested-by: Peter Wu <redacted>

quoted hunk

---
 Similar approach could probably be used for teaching ls-tree about pathspec..

 archive.c           | 82 ++++++++++++++++++++++++++++++++++++++++++++++++++++-
 t/t5000-tar-tree.sh | 10 +++++++
 2 files changed, 91 insertions(+), 1 deletion(-)

diff --git a/archive.c b/archive.c
index 3fc0fb2..9e62bf4 100644
--- a/archive.c
+++ b/archive.c

@@ -98,9 +98,19 @@ static void setup_archive_check(struct git_attr_check *check)
 	check[1].attr = attr_export_subst;
 }
 
+struct directory {
+	struct directory *up;
+	unsigned char sha1[20];
+	int baselen, len;
+	unsigned mode;
+	int stage;
+	char path[FLEX_ARRAY];
+};
+
 struct archiver_context {
 	struct archiver_args *args;
 	write_archive_entry_fn_t write_entry;
+	struct directory *bottom;
 };
 
 static int write_archive_entry(const unsigned char *sha1, const char *base,

@@ -146,6 +156,65 @@ static int write_archive_entry(const unsigned char *sha1, const char *base,
 	return write_entry(args, sha1, path.buf, path.len, mode);
 }
 
+static void queue_directory(const unsigned char *sha1,
+		const char *base, int baselen, const char *filename,
+		unsigned mode, int stage, struct archiver_context *c)
+{
+	struct directory *d;
+	d = xmallocz(sizeof(*d) + baselen + 1 + strlen(filename));
+	d->up	   = c->bottom;
+	d->baselen = baselen;
+	d->mode	   = mode;
+	d->stage   = stage;
+	c->bottom  = d;
+	d->len = sprintf(d->path, "%.*s%s/", baselen, base, filename);
+	hashcpy(d->sha1, sha1);
+}
+
+static int write_directory(struct archiver_context *c)
+{
+	struct directory *d = c->bottom;
+	int ret;
+
+	if (!d)
+		return 0;
+	c->bottom = d->up;
+	d->path[d->len - 1] = '\0'; /* no trailing slash */
+	ret =
+		write_directory(c) ||
+		write_archive_entry(d->sha1, d->path, d->baselen,
+				    d->path + d->baselen, d->mode,
+				    d->stage, c) != READ_TREE_RECURSIVE;
+	free(d);
+	return ret ? -1 : 0;
+}
+
+static int queue_or_write_archive_entry(const unsigned char *sha1,
+		const char *base, int baselen, const char *filename,
+		unsigned mode, int stage, void *context)
+{
+	struct archiver_context *c = context;
+
+	while (c->bottom &&
+	       !(baselen >= c->bottom->len &&
+		 !strncmp(base, c->bottom->path, c->bottom->len))) {
+		struct directory *next = c->bottom->up;
+		free(c->bottom);
+		c->bottom = next;
+	}
+
+	if (S_ISDIR(mode)) {
+		queue_directory(sha1, base, baselen, filename,
+				mode, stage, c);
+		return READ_TREE_RECURSIVE;
+	}
+
+	if (write_directory(c))
+		return -1;
+	return write_archive_entry(sha1, base, baselen, filename, mode,
+				   stage, context);
+}
+
 int write_archive_entries(struct archiver_args *args,
 		write_archive_entry_fn_t write_entry)
 {

@@ -167,6 +236,7 @@ int write_archive_entries(struct archiver_args *args,
 			return err;
 	}
 
+	memset(&context, 0, sizeof(context));
 	context.args = args;
 	context.write_entry = write_entry;

@@ -187,9 +257,17 @@ int write_archive_entries(struct archiver_args *args,
 	}
 
 	err = read_tree_recursive(args->tree, "", 0, 0, &args->pathspec,
-				  write_archive_entry, &context);
+				  args->pathspec.has_wildcard ?
+				  queue_or_write_archive_entry :
+				  write_archive_entry,
+				  &context);
 	if (err == READ_TREE_RECURSIVE)
 		err = 0;
+	while (context.bottom) {
+		struct directory *next = context.bottom->up;
+		free(context.bottom);
+		context.bottom = next;
+	}
 	return err;
 }

@@ -221,6 +299,7 @@ static int path_exists(struct tree *tree, const char *path)
 	int ret;
 
 	parse_pathspec(&pathspec, 0, 0, "", paths);
+	pathspec.recursive = 1;
 	ret = read_tree_recursive(tree, "", 0, 0, &pathspec, reject_entry, NULL);
 	free_pathspec(&pathspec);
 	return ret != 0;

@@ -237,6 +316,7 @@ static void parse_pathspec_arg(const char **pathspec,
 	parse_pathspec(&ar_args->pathspec, 0,
 		       PATHSPEC_PREFER_FULL,
 		       "", pathspec);
+	ar_args->pathspec.recursive = 1;
 	if (pathspec) {
 		while (*pathspec) {
 			if (**pathspec && !path_exists(ar_args->tree, *pathspec))

diff --git a/t/t5000-tar-tree.sh b/t/t5000-tar-tree.sh
index 7b8babd..ade7a7f 100755
--- a/t/t5000-tar-tree.sh
+++ b/t/t5000-tar-tree.sh

@@ -305,4 +305,14 @@ test_expect_success GZIP 'remote tar.gz can be disabled' '
 		>remote.tar.gz
 '
 
+test_expect_success 'archive and :(glob)' '
+	git archive -v HEAD -- ":(glob)**/sh" >/dev/null 2>actual &&
+	cat >expect <<EOF &&
+a/
+a/bin/
+a/bin/sh
+EOF
+	test_cmp expect actual
+'
+
 test_done

[PATCH v2] archive: support filtering paths with glob

From: Nguyễn Thái Ngọc Duy <hidden>
Date: 2016-06-15 23:02:33

This patch fixes two problems with using :(glob) (or even "*.c"
without ":(glob)").

The first one is we forgot to turn on the 'recursive' flag in struct
pathspec. Without that, tree_entry_interesting() will not mark
potential directories "interesting" so that it can confirm whether
those directories have anything matching the pathspec.

The marking directories interesting has a side effect that we need to
walk inside a directory to realize that there's nothing interested in
there. By that time, 'archive' code has already written the (empty)
directory down. That means lots of empty directories in the result
archive.

This problem is fixed by lazily writing directories down when we know
they are actually needed. There is a theoretical bug in this
implementation: we can't write empty trees/directories that match that
pathspec.

path_exists() is also made stricter in order to detect non-matching
pathspec because when this 'recursive' flag is on, we most likely
match some directories. The easiest way is not consider any
directories "matched".

Noticed-by: Peter Wu [off-list ref]
Signed-off-by: Nguyễn Thái Ngọc Duy <redacted>
---
 On Sat, Sep 13, 2014 at 5:52 PM, Peter Wu [off-list ref] wrote:
 > By the
 > way, the glob pattern is treated as a 'nullglob'. If you specify a glob pattern
 > that matches nothing, an empty archive is created. Perhaps an error message
 > should be raised for that as it is unlikely that a user wants that?

 If you do "git archive HEAD non-existent-path", you get an error.
 There's no reason why glob is an exception. Fixed in this version.

 archive.c           | 97 +++++++++++++++++++++++++++++++++++++++++++++++++++--
 t/t5000-tar-tree.sh | 14 ++++++++
 2 files changed, 108 insertions(+), 3 deletions(-)

diff --git a/archive.c b/archive.c
index 952a659..94a9981 100644
--- a/archive.c
+++ b/archive.c

@@ -5,6 +5,7 @@
 #include "archive.h"
 #include "parse-options.h"
 #include "unpack-trees.h"
+#include "dir.h"
 
 static char const * const archive_usage[] = {
 	N_("git archive [options] <tree-ish> [<path>...]"),

@@ -98,9 +99,19 @@ static void setup_archive_check(struct git_attr_check *check)
 	check[1].attr = attr_export_subst;
 }
 
+struct directory {
+	struct directory *up;
+	unsigned char sha1[20];
+	int baselen, len;
+	unsigned mode;
+	int stage;
+	char path[FLEX_ARRAY];
+};
+
 struct archiver_context {
 	struct archiver_args *args;
 	write_archive_entry_fn_t write_entry;
+	struct directory *bottom;
 };
 
 static int write_archive_entry(const unsigned char *sha1, const char *base,

@@ -146,6 +157,65 @@ static int write_archive_entry(const unsigned char *sha1, const char *base,
 	return write_entry(args, sha1, path.buf, path.len, mode);
 }
 
+static void queue_directory(const unsigned char *sha1,
+		const char *base, int baselen, const char *filename,
+		unsigned mode, int stage, struct archiver_context *c)
+{
+	struct directory *d;
+	d = xmallocz(sizeof(*d) + baselen + 1 + strlen(filename));
+	d->up	   = c->bottom;
+	d->baselen = baselen;
+	d->mode	   = mode;
+	d->stage   = stage;
+	c->bottom  = d;
+	d->len = sprintf(d->path, "%.*s%s/", baselen, base, filename);
+	hashcpy(d->sha1, sha1);
+}
+
+static int write_directory(struct archiver_context *c)
+{
+	struct directory *d = c->bottom;
+	int ret;
+
+	if (!d)
+		return 0;
+	c->bottom = d->up;
+	d->path[d->len - 1] = '\0'; /* no trailing slash */
+	ret =
+		write_directory(c) ||
+		write_archive_entry(d->sha1, d->path, d->baselen,
+				    d->path + d->baselen, d->mode,
+				    d->stage, c) != READ_TREE_RECURSIVE;
+	free(d);
+	return ret ? -1 : 0;
+}
+
+static int queue_or_write_archive_entry(const unsigned char *sha1,
+		const char *base, int baselen, const char *filename,
+		unsigned mode, int stage, void *context)
+{
+	struct archiver_context *c = context;
+
+	while (c->bottom &&
+	       !(baselen >= c->bottom->len &&
+		 !strncmp(base, c->bottom->path, c->bottom->len))) {
+		struct directory *next = c->bottom->up;
+		free(c->bottom);
+		c->bottom = next;
+	}
+
+	if (S_ISDIR(mode)) {
+		queue_directory(sha1, base, baselen, filename,
+				mode, stage, c);
+		return READ_TREE_RECURSIVE;
+	}
+
+	if (write_directory(c))
+		return -1;
+	return write_archive_entry(sha1, base, baselen, filename, mode,
+				   stage, context);
+}
+
 int write_archive_entries(struct archiver_args *args,
 		write_archive_entry_fn_t write_entry)
 {

@@ -167,6 +237,7 @@ int write_archive_entries(struct archiver_args *args,
 			return err;
 	}
 
+	memset(&context, 0, sizeof(context));
 	context.args = args;
 	context.write_entry = write_entry;

@@ -187,9 +258,17 @@ int write_archive_entries(struct archiver_args *args,
 	}
 
 	err = read_tree_recursive(args->tree, "", 0, 0, &args->pathspec,
-				  write_archive_entry, &context);
+				  args->pathspec.has_wildcard ?
+				  queue_or_write_archive_entry :
+				  write_archive_entry,
+				  &context);
 	if (err == READ_TREE_RECURSIVE)
 		err = 0;
+	while (context.bottom) {
+		struct directory *next = context.bottom->up;
+		free(context.bottom);
+		context.bottom = next;
+	}
 	return err;
 }

@@ -211,7 +290,16 @@ static int reject_entry(const unsigned char *sha1, const char *base,
 			int baselen, const char *filename, unsigned mode,
 			int stage, void *context)
 {
-	return -1;
+	int ret = -1;
+	if (S_ISDIR(mode)) {
+		struct strbuf sb = STRBUF_INIT;
+		strbuf_addstr(&sb, base);
+		strbuf_addstr(&sb, filename);
+		if (!match_pathspec(context, sb.buf, sb.len, 0, NULL, 1))
+			ret = READ_TREE_RECURSIVE;
+		strbuf_release(&sb);
+	}
+	return ret;
 }
 
 static int path_exists(struct tree *tree, const char *path)

@@ -221,7 +309,9 @@ static int path_exists(struct tree *tree, const char *path)
 	int ret;
 
 	parse_pathspec(&pathspec, 0, 0, "", paths);
-	ret = read_tree_recursive(tree, "", 0, 0, &pathspec, reject_entry, NULL);
+	pathspec.recursive = 1;
+	ret = read_tree_recursive(tree, "", 0, 0, &pathspec,
+				  reject_entry, &pathspec);
 	free_pathspec(&pathspec);
 	return ret != 0;
 }

@@ -237,6 +327,7 @@ static void parse_pathspec_arg(const char **pathspec,
 	parse_pathspec(&ar_args->pathspec, 0,
 		       PATHSPEC_PREFER_FULL,
 		       "", pathspec);
+	ar_args->pathspec.recursive = 1;
 	if (pathspec) {
 		while (*pathspec) {
 			if (**pathspec && !path_exists(ar_args->tree, *pathspec))

diff --git a/t/t5000-tar-tree.sh b/t/t5000-tar-tree.sh
index 7b8babd..d01bbdc 100755
--- a/t/t5000-tar-tree.sh
+++ b/t/t5000-tar-tree.sh

@@ -305,4 +305,18 @@ test_expect_success GZIP 'remote tar.gz can be disabled' '
 		>remote.tar.gz
 '
 
+test_expect_success 'archive and :(glob)' '
+	git archive -v HEAD -- ":(glob)**/sh" >/dev/null 2>actual &&
+	cat >expect <<EOF &&
+a/
+a/bin/
+a/bin/sh
+EOF
+	test_cmp expect actual
+'
+
+test_expect_success 'catch non-matching pathspec' '
+	test_must_fail git archive -v HEAD -- "*.abc" >/dev/null
+'
+
 test_done

-- 
2.1.0.rc0.78.gc0d8480

`h`	back out one level
`j`	next message in thread
`k`	previous message in thread
`l`	drill in
`Esc`	close help / fold thread tree
`?`	toggle this help