glob-bin

glob-bin

The command line bin script that used to be in node-glob

This has been split out so that it's easier to maintain, since the library and the CLI have somewhat different use cases, API, and security surface areas.

USAGE

This is a command line tool. You can install it locally, and run it from node_modules/.bin (or wherever your package manager puts local CLI executables), or globally with npm i glob-bin -g and then run it from anywhere.

Usage:
  glob [options] [<pattern> [<pattern> ...]]

Glob v13.0.0, CLI v1.0.0

Expand the positional glob expression arguments into any matching file system
paths found.

  -c<command> --cmd=<command>
                         Run the command provided, passing the glob expression
                         matches as arguments.

  -p<pattern> --default=<pattern>
                         If no positional arguments are provided, glob will use
                         this pattern

  --shell                Interpret the command as a shell command by passing it
                         to the shell, with all matched filesystem paths
                         appended,
                         **even if this cannot be done safely**.

                         This is **not** unsafe (and usually unnecessary) when
                         using the known Unix shells sh, bash, zsh, and fish, as
                         these can all be executed in such a way as to pass
                         positional arguments safely.

                         **Note**: THIS IS UNSAFE IF THE FILE PATHS ARE
                         UNTRUSTED, because a path like `'some/path/\$\(cmd)'`
                         will be executed by the shell.

                         If you do have positional arguments that you wish to
                         pass to the command ahead of the glob pattern matches,
                         use the `--cmd-arg`/`-g` option instead.

                         The next major release of glob will fully remove the
                         ability to use this option unsafely.

  -g<arg> --cmd-arg=<arg>
                         Pass the provided values to the supplied command, ahead
                         of the glob matches.

                         For example, the command:

                         glob -c echo -g"hello" -g"world" *.txt

                         might output:

                         hello world a.txt b.txt

                         This is a safer (and future-proof) alternative than
                         putting positional arguments in the `-c`/`--cmd`
                         option.

                         Can be set multiple times

  -A --all               By default, the glob cli command will not expand any
                         arguments that are an exact match to a file on disk.

                         This prevents double-expanding, in case the shell
                         expands an argument whose filename is a glob
                         expression.

                         For example, if 'app/*.ts' would match 'app/[id].ts',
                         then on Windows powershell or cmd.exe, 'glob app/*.ts'
                         will expand to 'app/[id].ts', as expected. However, in
                         posix shells such as bash or zsh, the shell will first
                         expand 'app/*.ts' to a list of filenames. Then glob
                         will look for a file matching 'app/[id].ts' (ie,
                         'app/i.ts' or 'app/d.ts'), which is unexpected.

                         Setting '--all' prevents this behavior, causing glob to
                         treat ALL patterns as glob expressions to be expanded,
                         even if they are an exact match to a file on disk.

                         When setting this option, be sure to enquote arguments
                         so that the shell will not expand them prior to passing
                         them to the glob command process.

  -a --absolute          Expand to absolute paths
  -d --dot-relative      Prepend './' on relative matches
  -m --mark              Append a / on any directories matched
  -x --posix             Always resolve to posix style paths, using '/' as the
                         directory separator, even on Windows. Drive letter
                         absolute matches on Windows will be expanded to their
                         full resolved UNC paths, eg instead of 'C:\foo\bar', it
                         will expand to '//?/C:/foo/bar'.

  -f --follow            Follow symlinked directories when expanding '**'
  -R --realpath          Call 'fs.realpath' on all of the results. In the case
                         of an entry that cannot be resolved, the entry is
                         omitted. This incurs a slight performance penalty, of
                         course, because of the added system calls.

  -s --stat              Call 'fs.lstat' on all entries, whether required or not
                         to determine if it's a valid match.

  -b --match-base        Perform a basename-only match if the pattern does not
                         contain any slash characters. That is, '*.js' would be
                         treated as equivalent to '**/*.js', matching js files
                         in all directories.

  --dot                  Allow patterns to match files/directories that start
                         with '.', even if the pattern does not start with '.'

  --nobrace              Do not expand {...} patterns
  --nocase               Perform a case-insensitive match. This defaults to
                         'true' on macOS and Windows platforms, and false on all
                         others.

                         Note: 'nocase' should only be explicitly set when it is
                         known that the filesystem's case sensitivity differs
                         from the platform default. If set 'true' on
                         case-insensitive file systems, then the walk may return
                         more or less results than expected.

  --nodir                Do not match directories, only files.

                         Note: to *only* match directories, append a '/' at the
                         end of the pattern.

  --noext                Do not expand extglob patterns, such as '+(a|b)'
  --noglobstar           Do not expand '**' against multiple path portions. Ie,
                         treat it as a normal '*' instead.

  --windows-path-no-escape
                         Use '\' as a path separator *only*, and *never* as an
                         escape character. If set, all '\' characters are
                         replaced with '/' in the pattern.

  -D<n> --max-depth=<n>  Maximum depth to traverse from the current working
                         directory

  -C<cwd> --cwd=<cwd>    Current working directory to execute/match in
  -r<root> --root=<root> A string path resolved against the 'cwd', which is used
                         as the starting point for absolute patterns that start
                         with '/' (but not drive letters or UNC paths on
                         Windows).

                         Note that this *doesn't* necessarily limit the walk to
                         the 'root' directory, and doesn't affect the cwd
                         starting point for non-absolute patterns. A pattern
                         containing '..' will still be able to traverse out of
                         the root directory, if it is not an actual root
                         directory on the filesystem, and any non-absolute
                         patterns will still be matched in the 'cwd'.

                         To start absolute and non-absolute patterns in the same
                         path, you can use '--root=' to set it to the empty
                         string. However, be aware that on Windows systems, a
                         pattern like 'x:/*' or '//host/share/*' will *always*
                         start in the 'x:/' or '//host/share/' directory,
                         regardless of the --root setting.

  --platform=<platform>  Defaults to the value of 'process.platform' if
                         available, or 'linux' if not. Setting --platform=win32
                         on non-Windows systems may cause strange behavior!

                         Valid options: "aix", "android", "darwin", "freebsd",
                         "haiku", "linux", "openbsd", "sunos", "win32",
                         "cygwin", "netbsd"

  -i<ignore> --ignore=<ignore>
                         Glob patterns to ignore
                         Can be set multiple times
  -v --debug             Output a huge amount of noisy debug information about
                         patterns as they are parsed and used to match files.

  -V --version           Output the glob library version (12.0.0)
  -h --help              Show this usage information