Recursive globbing shorthand (a la **.c)

Recursive globbing shorthand (a la **.c)

[Dominik Vogt]

Most of the time, I use recursive globbing to find files of
certain types, e.g.

  $ ll **/*.c

With the zsh here (4.3.17), recursive globbing works only
with a plain ** anyway (i.e. in "**x" and "x**" the ** works just
like a plain "*").  So, is it possible (or a useful future
feature) to make "**" imply a trailing "/*" if not with a trailing
pattern?  Then we could type

  $ ll **.c

as a shorthand, and the "traditional" uses would work without
change (e.g. **/*.c or **/foo).

(Note that on German keyboards, "/" and "*" are very awkward to
type in a sequence because both need the left shift key held and
the keys for the right hand are very far apart, so this is really
a usability issue.)

Ciao

Dominik ^_^  ^_^

Re: Recursive globbing shorthand (a la **.c)

[Mikael Magnusson]

On Wed, Oct 28, 2015 at 7:57 AM, Dominik Vogt <vogt@linux.vnet.ibm.com> wrote:
> Most of the time, I use recursive globbing to find files of
> certain types, e.g.
>
>   $ ll **/*.c
>
> With the zsh here (4.3.17), recursive globbing works only
> with a plain ** anyway (i.e. in "**x" and "x**" the ** works just
> like a plain "*").  So, is it possible (or a useful future
> feature) to make "**" imply a trailing "/*" if not with a trailing
> pattern?  Then we could type
>
>   $ ll **.c
>
> as a shorthand, and the "traditional" uses would work without
> change (e.g. **/*.c or **/foo).
>
> (Note that on German keyboards, "/" and "*" are very awkward to
> type in a sequence because both need the left shift key held and
> the keys for the right hand are very far apart, so this is really
> a usability issue.)

If this is something you do often, you can do
alias -g '**.c=**/*.c'

I don't think it's useful to implement generally though, there's no
particular reason to assume the pattern following the **/ should start
with a *

-- 
Mikael Magnusson

Re: Recursive globbing shorthand (a la **.c)

[ZyX]

28.10.2015, 16:28, "Mikael Magnusson" <mikachu@gmail.com>:
> On Wed, Oct 28, 2015 at 7:57 AM, Dominik Vogt <vogt@linux.vnet.ibm.com> wrote:
>>  Most of the time, I use recursive globbing to find files of
>>  certain types, e.g.
>>
>>    $ ll **/*.c
>>
>>  With the zsh here (4.3.17), recursive globbing works only
>>  with a plain ** anyway (i.e. in "**x" and "x**" the ** works just
>>  like a plain "*"). So, is it possible (or a useful future
>>  feature) to make "**" imply a trailing "/*" if not with a trailing
>>  pattern? Then we could type
>>
>>    $ ll **.c
>>
>>  as a shorthand, and the "traditional" uses would work without
>>  change (e.g. **/*.c or **/foo).
>>
>>  (Note that on German keyboards, "/" and "*" are very awkward to
>>  type in a sequence because both need the left shift key held and
>>  the keys for the right hand are very far apart, so this is really
>>  a usability issue.)
>
> If this is something you do often, you can do
> alias -g '**.c=**/*.c'
>
> I don't think it's useful to implement generally though, there's no
> particular reason to assume the pattern following the **/ should start
> with a *

This depends on how you treat patterns. In mercurial `**` is treated as `.*` and `*` is treated as `[^/]*`, so pattern `a**b` matches file `a/c/b` (note. With such interpretation transforming foo** into foo*/**, **bar into **/*bar and foo**bar into foo*/**/*bar makes perfect sense. Though mercurial is using regexps on a list of files, not the real globbing, this behaviour is official and not an accident: there are patterns like `**.c` in examples. As OP said this is convenient in many cases.

// And git documentation officially says that only valid uses of `**` are `…/**`, `**/…` and `…/**/…`.

>
> --
> Mikael Magnusson

Re: Recursive globbing shorthand (a la **.c)

[Stephane Chazelas]

2015-10-28 22:04:04 +0300, ZyX:
[...]
> This depends on how you treat patterns. In mercurial `**` is
> treated as `.*` and `*` is treated as `[^/]*`, so pattern
> `a**b` matches file `a/c/b` (note. With such interpretation
> transforming foo** into foo*/**, **bar into **/*bar and
> foo**bar into foo*/**/*bar makes perfect sense. Though
> mercurial is using regexps on a list of files, not the real
> globbing, this behaviour is official and not an accident:
> there are patterns like `**.c` in examples. As OP said this is
> convenient in many cases.
[...]

That's also the behaviour of globbing in the  fish shell.

That means that for instance you cannot match dot files (or any
pattern matching on the beggining of the file in fish.

For zsh's **/.*, in fish you'd need both .* and **/.*

I prefer zsh behaviour.

ksh93, bash and tcsh support ** alone, but not **.c

See also
http://unix.stackexchange.com/questions/62660/the-result-of-ls-ls-and-ls/62665#62665

BTW, a related question:

In zsh (also in yash and tcsh now), *** is the version of **
that traverses symlinks.

Also,

*.d/foo

traverses symlinks,

(*.d)#/foo

doesn't

** is short for (*/)#

Is there a way to do */foo without traversing symlinks (other
than l=(*(/N)); l=($^l/foo(N)); (($#l)) && cmd $l)?

(*/)(#c1)foo doesn't work

Or (^.svn/)#foo.c that traverses symlinks?

-- 
Stephane

Re: Recursive globbing shorthand (a la **.c)

[Dominik Vogt]

On Wed, Oct 28, 2015 at 02:27:38PM +0100, Mikael Magnusson wrote:
> If this is something you do often, you can do
> alias -g '**.c=**/*.c'

It *is* something I do a lot, but with varying patterns.  A kind
of "regexp" alias woud allow that:

  alias -R REGEXP=REPLACEMENT   # usual regexp syntax plus back references
  alias -g -R [.][.][.]='../..'
  alias -g -R [*][*]\([^*/]\)='**/*\1'

(or give up the pretense that "search and replace" can be
expressed as "x=y" patterns:

  alias -g -R 's:[.][.][.]:../..:g'       # replace all (g flag)
  alias -g -R 's:[*][*]([^*/]):**/*\1:'   # replace one (no flags)
)

I frequently miss such a feature that allows some user defined
preprocessing of command lines.

Dominik ^_^  ^_^

-- 

Dominik Vogt
IBM Germany

Re: Recursive globbing shorthand (a la **.c)

[Peter Stephenson]

On Wed, 28 Oct 2015 07:57:02 +0100
Dominik Vogt <vogt@linux.vnet.ibm.com> wrote:
> Most of the time, I use recursive globbing to find files of
> certain types, e.g.
> 
>   $ ll **/*.c
> 
> With the zsh here (4.3.17), recursive globbing works only
> with a plain ** anyway (i.e. in "**x" and "x**" the ** works just
> like a plain "*").  So, is it possible (or a useful future
> feature) to make "**" imply a trailing "/*" if not with a trailing
> pattern?  Then we could type
> 
>   $ ll **.c

It turns out this is pretty trivial to implement as an option which I've
called GLOBSTARSHORT.  No documentation yet.  It's trivial enough that I
doubt this would be problematic to include.

pws

diff --git a/Src/glob.c b/Src/glob.c
index 24e60d0..51ffeb5 100644
--- a/Src/glob.c
+++ b/Src/glob.c
@@ -682,25 +682,32 @@ parsecomplist(char *instr)
     char *str;
     int compflags = gf_noglobdots ? (PAT_FILE|PAT_NOGLD) : PAT_FILE;
 
-    if (instr[0] == Star && instr[1] == Star &&
-        (instr[2] == '/' || (instr[2] == Star && instr[3] == '/'))) {
-	/* Match any number of directories. */
-	int follow;
-
-	/* with three stars, follow symbolic links */
-	follow = (instr[2] == Star);
-	instr += (3 + follow);
-
-	/* Now get the next path component if there is one. */
-	l1 = (Complist) zhalloc(sizeof *l1);
-	if ((l1->next = parsecomplist(instr)) == NULL) {
-	    errflag |= ERRFLAG_ERROR;
-	    return NULL;
+    if (instr[0] == Star && instr[1] == Star) {
+	int shortglob = 0;
+        if (instr[2] == '/' || (instr[2] == Star && instr[3] == '/')
+	    || (shortglob = isset(GLOBSTARSHORT))) {
+	    /* Match any number of directories. */
+	    int follow;
+
+	    /* with three stars, follow symbolic links */
+	    follow = (instr[2] == Star);
+	    /*
+	     * With GLOBSTARSHORT, leave a star in place for the
+	     * pattern inside the directory.
+	     */
+	    instr += ((shortglob ? 1 : 3) + follow);
+
+	    /* Now get the next path component if there is one. */
+	    l1 = (Complist) zhalloc(sizeof *l1);
+	    if ((l1->next = parsecomplist(instr)) == NULL) {
+		errflag |= ERRFLAG_ERROR;
+		return NULL;
+	    }
+	    l1->pat = patcompile(NULL, compflags | PAT_ANY, NULL);
+	    l1->closure = 1;		/* ...zero or more times. */
+	    l1->follow = follow;
+	    return l1;
 	}
-	l1->pat = patcompile(NULL, compflags | PAT_ANY, NULL);
-	l1->closure = 1;		/* ...zero or more times. */
-	l1->follow = follow;
-	return l1;
     }
 
     /* Parse repeated directories such as (dir/)# and (dir/)## */
diff --git a/Src/options.c b/Src/options.c
index 1fb102f..3bf9f39 100644
--- a/Src/options.c
+++ b/Src/options.c
@@ -140,6 +140,7 @@ static struct optname optns[] = {
 {{NULL, "globassign",	      OPT_EMULATE|OPT_CSH},	 GLOBASSIGN},
 {{NULL, "globcomplete",	      0},			 GLOBCOMPLETE},
 {{NULL, "globdots",	      OPT_EMULATE},		 GLOBDOTS},
+{{NULL, "globstarshort",      OPT_EMULATE},		 GLOBSTARSHORT},
 {{NULL, "globsubst",	      OPT_EMULATE|OPT_NONZSH},	 GLOBSUBST},
 {{NULL, "hashcmds",	      OPT_ALL},			 HASHCMDS},
 {{NULL, "hashdirs",	      OPT_ALL},			 HASHDIRS},
diff --git a/Src/zsh.h b/Src/zsh.h
index f819249..a600105 100644
--- a/Src/zsh.h
+++ b/Src/zsh.h
@@ -2218,6 +2218,7 @@ enum {
     GLOBASSIGN,
     GLOBCOMPLETE,
     GLOBDOTS,
+    GLOBSTARSHORT,
     GLOBSUBST,
     HASHCMDS,
     HASHDIRS,