neulab/tldr huggingface dataset:
The JSON Lines format is only supported for showing search results. It cannot be used with other flags that emit other types of output, such as --files, --files-with-matches, --files-without-match, --count or --count-matches. ripgrep will report an error if any of the aforementioned flags are used in concert with --json.
Other flags that control aspects of the standard output such as --only-matching, --heading, --replace, --max-columns, etc., have no effect when --json is set.
A more complete description of the JSON format used can be found here: https://docs.rs/grep-printer/*/grep_printer/struct.JSON.html
The JSON Lines format can be disabled with --no-json.
--line-buffered When enabled, ripgrep will use line buffering. That is, whenever a matching line is found, it will be flushed to stdout immediately. This is the default when ripgrep’s stdout is connected to a terminal, but otherwise, ripgrep will use block buffering, which is typically faster. This flag forces ripgrep to use line buffering even if it would otherwise use block buffering. This is typically useful in shell pipelines, e.g., tail -f something.log | rg foo --line-buffered | rg bar.
Forceful line buffering can be disabled with --no-line-buffered. Note that using --no-line-buffered causes ripgrep to revert to its default behavior of automatically detecting the buffering strategy. To force block buffering, use the --block-buffered flag.
-n, --line-number Show line numbers (1-based). This is enabled by default when searching in a terminal.
-x, --line-regexp Only show matches surrounded by line boundaries. This is equivalent to putting ^...$ around all of the search patterns. In other words, this only prints lines where the entire line participates in a match.
This overrides the --word-regexp flag.
-M, --max-columns NUM Don’t print lines longer than this limit in bytes. Longer lines are omitted, and only the number of matches in that line is printed.
When this flag is omitted or is set to 0, then it has no effect.
--max-columns-preview When the --max-columns flag is used, ripgrep will by default completely replace any line that is too long with a message indicating that a matching line was removed. When this flag is combined with --max-columns, a preview of the line (corresponding to the limit size) is shown instead, where the part of the line exceeding the limit is not shown.
If the --max-columns flag is not set, then this has no effect.
This flag can be disabled with --no-max-columns-preview.
-m, --max-count NUM Limit the number of matching lines per file searched to NUM.
--max-depth NUM Limit the depth of directory traversal to NUM levels beyond the paths given. A value of zero only searches the explicitly given paths themselves.
For example, rg --max-depth 0 dir/ is a no-op because dir/ will not be descended into. rg --max-depth 1 dir/ will search only the direct children of dir.
--max-filesize NUM+SUFFIX? Ignore files larger than NUM in size. This does not apply to directories.
The input format accepts suffixes of K, M or G which correspond to kilobytes, megabytes and gigabytes, respectively. If no suffix is provided the input is treated as bytes.
Examples: --max-filesize 50K or --max-filesize 80M
--mmap Search using memory maps when possible. This is enabled by default when ripgrep thinks it will be faster.
Memory map searching doesn’t currently support all options, so if an incompatible option (e.g., --context) is given with --mmap, then memory maps will not be used.
Note that ripgrep may abort unexpectedly when --mmap if it searches a file that is simultaneously truncated.
This flag overrides --no-mmap.
-U, --multiline Enable matching across multiple lines.
When multiline mode is enabled, ripgrep will lift the restriction that a match cannot include a line terminator. For example, when multiline mode is not enabled (the default), then the regex \p{any} will match any Unicode codepoint other than \n. Similarly, the regex \n is explicitly forbidden, and if you try to use it, ripgrep will return an error. However, when multiline mode is enabled, \p{any} will match any Unicode codepoint, including \n, and regexes like \n are permitted.
An important caveat is that multiline mode does not change the match semantics of .. Namely, in most regex matchers, a . will by default match any character other than \n, and this is true in ripgrep as well. In order to make . match \n, you must enable the "dot all" flag inside the regex. For example, both (?s). and (?s:.) have the same semantics, where . will match any character, including \n. Alternatively, the --multiline-dotall flag may be passed to make the "dot all" behavior the default. This flag only applies when multiline search is enabled.
There is no limit on the number of the lines that a single match can span.
WARNING: Because of how the underlying regex engine works, multiline searches may be slower than normal line-oriented searches, and they may also use more memory. In particular, when multiline mode is enabled, ripgrep requires that each file it searches is laid out contiguously in memory (either by reading it onto the heap or by memory-mapping it). Things that cannot be memory-mapped (such as stdin) will be consumed until EOF before searching can begin. In general, ripgrep will only do these things when necessary. Specifically, if the --multiline flag is provided but the regex does not contain patterns that would match \n characters, then ripgrep will automatically avoid reading each file into memory before searching it. Nevertheless, if you only care about matches spanning at most one line, then it is always better to disable multiline mode.
This flag can be disabled with --no-multiline.
--multiline-dotall This flag enables "dot all" in your regex pattern, which causes . to match newlines when multiline searching is enabled. This flag has no effect if multiline searching isn’t enabled with the --multiline flag.
Normally, a . will match any character except newlines. While this behavior typically isn’t relevant for line-oriented matching (since matches can span at most one line), this can be useful when searching with the -U/--multiline flag. By default, the multiline mode runs without this flag.
This flag is generally intended to be used in an alias or your ripgrep config file if you prefer "dot all" semantics by default. Note that regardless of whether this flag is used, "dot all" semantics can still be controlled via inline flags in the regex pattern itself, e.g., (?s:.) always enables "dot all" whereas (?-s:.) always disables "dot all".
This flag can be disabled with --no-multiline-dotall.
--no-config Never read configuration files. When this flag is present, ripgrep will not respect the RIPGREP_CONFIG_PATH environment variable.
If ripgrep ever grows a feature to automatically read configuration files in pre-defined locations, then this flag will also disable that behavior as well.
-I, --no-filename Never print the file path with the matched lines. This is the default when ripgrep is explicitly instructed to search one file or stdin.
This flag overrides --with-filename.
--no-heading Don’t group matches by each file. If --no-heading is provided in addition to the -H/--with-filename flag, then file paths will be printed as a prefix for every matched line. This is the default mode when not printing to a terminal.
This overrides the --heading flag.
--no-ignore Don’t respect ignore files (.gitignore, .ignore, etc.). This implies --no-ignore-dot, --no-ignore-exclude, --no-ignore-global, no-ignore-parent and --no-ignore-vcs.
This does not imply --no-ignore-files, since --ignore-file is specified explicitly as a command line argument.
When given only once, the -u flag is identical in behavior to --no-ignore and can be considered an alias. However, subsequent -u flags have additional effects; see --unrestricted.
This flag can be disabled with the --ignore flag.
--no-ignore-dot Don’t respect .ignore files.
This does not affect whether ripgrep will ignore files and directories whose names begin with a dot. For that, see the -./--hidden flag.
This flag can be disabled with the --ignore-dot flag.
--no-ignore-exclude Don’t respect ignore files that are manually configured for the repository such as git’s .git/info/exclude.
This flag can be disabled with the --ignore-exclude flag.
--no-ignore-files When set, any --ignore-file flags, even ones that come after this flag, are ignored.
This flag can be disabled with the --ignore-files flag.
--no-ignore-global Don’t respect ignore files that come from "global" sources such as git’s core.excludesFile configuration option (which defaults to $HOME/.config/git/ignore).
This flag can be disabled with the --ignore-global flag.
--no-ignore-messages Suppresses all error messages related to parsing ignore files such as .ignore or .gitignore.
This flag can be disabled with the --ignore-messages flag.
--no-ignore-parent Don’t respect ignore files (.gitignore, .ignore, etc.) in parent directories.
This flag can be disabled with the --ignore-parent flag.
--no-ignore-vcs Don’t respect version control ignore files (.gitignore, etc.). This implies --no-ignore-parent for VCS files. Note that .ignore files will continue to be respected.
This flag can be disabled with the --ignore-vcs flag.
-N, --no-line-number Suppress line numbers. This is enabled by default when not searching in a terminal.
--no-messages Suppress all error messages related to opening and reading files. Error messages related to the syntax of the pattern given are still shown.
This flag can be disabled with the --messages flag.
--no-mmap Never use memory maps, even when they might be faster.
This flag overrides --mmap.
--no-pcre2-unicode DEPRECATED. Use --no-unicode instead.
This flag is now an alias for --no-unicode. And --pcre2-unicode is an alias for --unicode.
--no-require-git By default, ripgrep will only respect global gitignore rules, .gitignore rules and local exclude rules if ripgrep detects that you are searching inside a git repository. This flag allows you to relax this restriction such that ripgrep will respect all git related ignore rules regardless of whether you’re searching in a git repository or not.
This flag can be disabled with --require-git.
--no-unicode By default, ripgrep will enable "Unicode mode" in all of its regexes. This has a number of consequences:
•   . will only match valid UTF-8 encoded scalar values.
•   Classes like \w, \s, \d are all Unicode aware and much bigger than their ASCII only versions.
•   Case insensitive matching will use Unicode case folding.
•   A large array of classes like \p{Emoji} are available.
•   Word boundaries (\b and \B) use the Unicode definition of a word character.
In some cases it can be desirable to turn these things off. The --no-unicode flag will do exactly that.
For PCRE2 specifically, Unicode mode represents a critical trade off in the user experience of ripgrep. In particular, unlike the default regex engine, PCRE2 does not support the ability to search possibly invalid UTF-8 with Unicode features enabled. Instead, PCRE2 requires that everything it searches when Unicode mode is enabled is valid UTF-8. (Or valid UTF-16/UTF-32, but for the purposes of ripgrep, we only discuss UTF-8.) This means that if you have PCRE2’s Unicode mode enabled and you attempt to search invalid UTF-8, then the search for that file will halt and print an error. For this reason, when PCRE2’s Unicode mode is enabled, ripgrep will automatically "fix" invalid UTF-8 sequences by replacing them with the Unicode replacement codepoint. This penalty does not occur when using the default regex engine.
If you would rather see the encoding errors surfaced by PCRE2 when Unicode mode is enabled, then pass the --no-encoding flag to disable all transcoding.
The --no-unicode flag can be disabled with --unicode. Note that --no-pcre2-unicode and --pcre2-unicode are aliases for --no-unicode and --unicode, respectively.
-0, --null Whenever a file path is printed, follow it with a NUL byte. This includes printing file paths before matches, and when printing a list of matching files such as with --count, --files-with-matches and --files. This option is useful for use with xargs.
--null-data Enabling this option causes ripgrep to use NUL as a line terminator instead of the default of \n.
This is useful when searching large binary files that would otherwise have very long lines if \n were used as the line terminator. In particular, ripgrep requires that, at a minimum, each line must fit into memory. Using NUL instead can be a useful stopgap to keep memory requirements low and avoid OOM (out of memory) conditions.
This is also useful for processing NUL delimited data, such as that emitted when using ripgrep’s -0/--null flag or find’s --print0 flag.
Using this flag implies -a/--text.
--one-file-system When enabled, ripgrep will not cross file system boundaries relative to where the search started from.
Note that this applies to each path argument given to ripgrep. For example, in the command rg --one-file-system /foo/bar /quux/baz, ripgrep will search both /foo/bar and /quux/baz even if they are on different file systems, but will not cross a file system boundary when traversing each path’s directory tree.
This is similar to find’s -xdev or -mount flag.
This flag can be disabled with --no-one-file-system.
--passthru Print both matching and non-matching lines.
Another way to achieve a similar effect is by modifying your pattern to match the empty string. For example, if you are searching using rg foo then using rg "^|foo" instead will emit every line in every file searched, but only occurrences of foo will be highlighted. This flag enables the same behavior without needing to modify the pattern.
This overrides the --context, --after-context and --before-context flags.
--path-separator SEPARATOR Set the path separator to use when printing file paths. This defaults to your platform’s path separator, which is / on Unix and \ on Windows. This flag is intended for overriding the default when the environment demands it (e.g., cygwin). A path separator is limited to a single byte.
-P, --pcre2 When this flag is present, ripgrep will use the PCRE2 regex engine instead of its default regex engine.
This is generally useful when you want to use features such as look-around or backreferences.
Note that PCRE2 is an optional ripgrep feature. If PCRE2 wasn’t included in your build of ripgrep, then using this flag will result in ripgrep printing an error message and exiting. PCRE2 may also have worse user experience in some cases, since it has fewer introspection APIs than ripgrep’s default regex engine. For example, if you use a \n in a PCRE2 regex without the -U/--multiline flag, then ripgrep will silently fail to match anything instead of reporting an error immediately (like it does with the default regex engine).
Related flags: --no-pcre2-unicode
This flag can be disabled with --no-pcre2.
--pcre2-version When this flag is present, ripgrep will print the version of PCRE2 in use, along with other information, and then exit. If PCRE2 is not available, then ripgrep will print an error message and exit with an error code.
--pre COMMAND For each input FILE, search the standard output of COMMAND FILE rather than the contents of FILE. This option expects the COMMAND program to either be an absolute path or to be available in your PATH. Either an empty string COMMAND or the --no-pre flag will disable this behavior.
WARNING: When this flag is set, ripgrep will unconditionally spawn a process for every file that is searched. Therefore, this can incur an unnecessarily large performance penalty if you don't otherwise need the flexibility offered by this flag. One possible mitigation to this is to use the '--pre-glob' flag to limit which files a preprocessor is run with.
A preprocessor is not run when ripgrep is searching stdin.
When searching over sets of files that may require one of several decoders as preprocessors, COMMAND should be a wrapper program or script which first classifies FILE based on magic numbers/content or based on the FILE name and then dispatches to an appropriate preprocessor. Each COMMAND also has its standard input connected to FILE for convenience.
For example, a shell script for COMMAND might look like:
case "$1" in *.pdf) exec pdftotext "$1" - ;; *) case $(file "$1") in *Zstandard*) exec pzstd -cdq ;; *) exec cat ;; esac ;; esac
The above script uses pdftotext to convert a PDF file to plain text. For all other files, the script uses the file utility to sniff the type of the file based on its contents. If it is a compressed file in the Zstandard format, then pzstd is used to decompress the contents to stdout.
This overrides the -z/--search-zip flag.
--pre-glob GLOB ... This flag works in conjunction with the --pre flag. Namely, when one or more --pre-glob flags are given, then only files that match the given set of globs will be handed to the command specified by the --pre flag. Any non-matching files will be searched without using the preprocessor command.
This flag is useful when searching many files with the --pre flag. Namely, it permits the ability to avoid process overhead for files that don’t need preprocessing. For example, given the following shell script, pre-pdftotext:
pdftotext "$1" -
then it is possible to use --pre pre-pdftotext --pre-glob '*.pdf' to make it so ripgrep only executes the pre-pdftotext command on files with a .pdf extension.
Multiple --pre-glob flags may be used. Globbing rules match .gitignore globs. Precede a glob with a ! to exclude it.
This flag has no effect if the --pre flag is not used.
-p, --pretty This is a convenience alias for --color always --heading --line-number. This flag is useful when you still want pretty output even if you’re piping ripgrep to another program or file. For example: rg -p foo | less -R.
-q, --quiet Do not print anything to stdout. If a match is found in a file, then ripgrep will stop searching. This is useful when ripgrep is used only for its exit code (which will be an error if no matches are found).
When --files is used, then ripgrep will stop finding files after finding the first file that matches all ignore rules.
--regex-size-limit NUM+SUFFIX? The upper size limit of the compiled regex. The default limit is 10M.
The argument accepts the same size suffixes as allowed in the --max-filesize flag.
-e, --regexp PATTERN ... A pattern to search for. This option can be provided multiple times, where all patterns given are searched. Lines matching at least one of the provided patterns are printed. This flag can also be used when searching for patterns that start with a dash.
For example, to search for the literal -foo, you can use this flag:
rg -e -foo
You can also use the special -- delimiter to indicate that no more flags will be provided. Namely, the following is equivalent to the above:
rg -- -foo
-r, --replace REPLACEMENT_TEXT Replace every match with the text given when printing results. Neither this flag nor any other ripgrep flag will modify your files.
Capture group indices (e.g., $5) and names (e.g., $foo) are supported in the replacement string. Capture group indices are numbered based on the position of the opening parenthesis of the group, where the leftmost such group is $1. The special $0 group corresponds to the entire match.
In shells such as Bash and zsh, you should wrap the pattern in single quotes instead of double quotes. Otherwise, capture group indices will be replaced by expanded shell variables which will most likely be empty.
To write a literal $, use $$.
Note that the replacement by default replaces each match, and NOT the entire line. To replace the entire line, you should match the entire line.
This flag can be used with the -o/--only-matching flag.
-z, --search-zip Search in compressed files. Currently gzip, bzip2, xz, LZ4, LZMA, Brotli and Zstd files are supported. This option expects the decompression binaries to be available in your PATH.
This flag can be disabled with --no-search-zip.
-S, --smart-case Searches case insensitively if the pattern is all lowercase. Search case sensitively otherwise.
A pattern is considered all lowercase if both of the following rules hold:
First, the pattern contains at least one literal character. For example, a\w contains a literal (a) but just \w does not.
Second, of the literals in the pattern, none of them are considered to be uppercase according to Unicode. For example, foo\pL has no uppercase literals but Foo\pL does.
This overrides the -s/--case-sensitive and -i/--ignore-case flags.
--sort SORTBY This flag enables sorting of results in ascending order. The possible values for this flag are:
none      (Default) Do not sort results. Fastest. Can be multi-threaded. path      Sort by file path. Always single-threaded. modified  Sort by the last modified time on a file. Always single-threaded. accessed  Sort by the last accessed time on a file. Always single-threaded. created   Sort by the creation time on a file. Always single-threaded.
If the chosen (manually or by-default) sorting criteria isn’t available on your system (for example, creation time is not available on ext4 file systems), then ripgrep will attempt to detect this, print an error and exit without searching.
To sort results in reverse or descending order, use the --sortr flag. Also, this flag overrides --sortr.
Note that sorting results currently always forces ripgrep to abandon parallelism and run in a single thread.
--sortr SORTBY This flag enables sorting of results in descending order. The possible values for this flag are:
To sort results in ascending order, use the --sort flag. Also, this flag overrides --sort.
--stats Print aggregate statistics about this ripgrep search. When this flag is present, ripgrep will print the following stats to stdout at the end of the search: number of matched lines, number of files with matches, number of files searched, and the time taken for the entire search to complete.
This set of aggregate statistics may expand over time.
Note that this flag has no effect if --files, --files-with-matches or --files-without-match is passed.
This flag can be disabled with --no-stats.
-a, --text Search binary files as if they were text. When this flag is present, ripgrep’s binary file detection is disabled. This means that when a binary file is searched, its contents may be printed if there is a match. This may cause escape codes to be printed that alter the behavior of your terminal.
When binary file detection is enabled it is imperfect. In general, it uses a simple heuristic. If a NUL byte is seen during search, then the file is considered binary and search stops (unless this flag is present). Alternatively, if the --binary flag is used, then ripgrep will only quit when it sees a NUL byte after it sees a match (or searches the entire file).
This flag can be disabled with --no-text. It overrides the --binary flag.
-j, --threads NUM The approximate number of threads to use. A value of 0 (which is the default) causes ripgrep to choose the thread count using heuristics.
--trim When set, all ASCII whitespace at the beginning of each line printed will be trimmed.
This flag can be disabled with --no-trim.
-t, --type TYPE ... Only search files matching TYPE. Multiple type flags may be provided. Use the --type-list flag to list all available types.
This flag supports the special value all, which will behave as if --type was provided for every file type supported by ripgrep (including any custom file types). The end result is that --type all causes ripgrep to search in "whitelist" mode, where it will only search files it recognizes via its type definitions.
--type-add TYPE_SPEC ... Add a new glob for a particular file type. Only one glob can be added at a time. Multiple --type-add flags can be provided. Unless --type-clear is used, globs are added to any existing globs defined inside of ripgrep.
Note that this MUST be passed to every invocation of ripgrep. Type settings are NOT persisted. See CONFIGURATION FILES for a workaround.
rg --type-add 'foo:*.foo' -tfoo PATTERN.
--type-add can also be used to include rules from other types with the special include directive. The include directive permits specifying one or more other type names (separated by a comma) that have been defined and its rules will automatically be imported into the type specified. For example, to create a type called src that matches C++, Python and Markdown files, one can use:
--type-add 'src:include:cpp,py,md'
Additional glob rules can still be added to the src type by using the --type-add flag again:
--type-add 'src:include:cpp,py,md' --type-add 'src:*.foo'
Note that type names must consist only of Unicode letters or numbers. Punctuation characters are not allowed.
--type-clear TYPE ... Clear the file type globs previously defined for TYPE. This only clears the default type definitions that are found inside of ripgrep.
--type-list Show all supported file types and their corresponding globs.
-T, --type-not TYPE ... Do not search files matching TYPE. Multiple type-not flags may be provided. Use the --type-list flag to list all available types.
-u, --unrestricted ... Reduce the level of "smart" searching. A single -u won’t respect .gitignore (etc.) files (--no-ignore). Two -u flags will additionally search hidden files and directories (-./--hidden). Three -u flags will additionally search binary files (--binary).
rg -uuu is roughly equivalent to grep -r.
--vimgrep Show results with every match on its own line, including line numbers and column numbers. With this option, a line with more than one match will be printed more than once.
-H, --with-filename Display the file path for matches. This is the default when more than one file is searched. If --heading is enabled (the default when printing to a terminal), the file path will be shown above clusters of matches from each file; otherwise, the file name will be shown as a prefix for each matched line.
This flag overrides --no-filename.
-w, --word-regexp Only show matches surrounded by word boundaries. This is roughly equivalent to putting \b before and after all of the search patterns.
This overrides the --line-regexp flag.
If ripgrep finds a match, then the exit status of the program is 0. If no match could be found, then the exit status is 1. If an error occurred, then the exit status is always 2 unless ripgrep was run with the --quiet flag and a match was found. In summary:
•   0 exit status occurs only when at least one match was found, and if no error occurred, unless --quiet was given.
•   1 exit status occurs only when no match was found and no error occurred.
•   2 exit status occurs when an error occurred. This is true for both catastrophic errors (e.g., a regex syntax error) and for soft errors (e.g., unable to read a file).
TL;DR - To disable automatic filtering, use rg -uuu.
One of ripgrep’s most important features is its automatic smart filtering. It is the most apparent differentiating feature between ripgrep and other tools like grep. As such, its behavior may be surprising to users that aren’t expecting it.
ripgrep does four types of filtering automatically:
1. Files and directories that match ignore rules are not searched.
2. Hidden files and directories are not searched.
3. Binary files (files with a NUL byte) are not searched.
4. Symbolic links are not followed.
The first type of filtering is the most sophisticated. ripgrep will attempt to respect your gitignore rules as faithfully as possible. In particular, this includes the following:
•   Any global rules, e.g., in $HOME/.config/git/ignore.
•   Any rules in .gitignore.
•   Any local rules, e.g., in .git/info/exclude.
In some cases, ripgrep and git will not always be in sync in terms of which files are ignored. For example, a file that is ignored via .gitignore but is tracked by git would not be searched by ripgrep even though git tracks it. This is unlikely to ever be fixed. Instead, you should either make sure your exclude rules match the files you track precisely, or otherwise use git grep for search.
Additional ignore rules can be provided outside of a git context:
•   Any rules in .ignore.
•   Any rules in .rgignore.
•   Any rules in files specified with the --ignore-file flag.
The precedence of ignore rules is as follows, with later items overriding earlier items:
•   Files given by --ignore-file.
•   Global gitignore rules, e.g., from $HOME/.config/git/ignore.
•   Local rules from .git/info/exclude.
•   Rules from .gitignore.
•   Rules from .ignore.
•   Rules from .rgignore.
So for example, if foo were in a .gitignore and !foo were in an .rgignore, then foo would not be ignored since .rgignore takes precedence over .gitignore.
Each of the types of filtering can be configured via command line flags:
•   There are several flags starting with --no-ignore that toggle which, if any, ignore rules are respected. --no-ignore by itself will disable all of them.
•   -./--hidden will force ripgrep to search hidden files and directories.
•   --binary will force ripgrep to search binary files.
•   -L/--follow will force ripgrep to follow symlinks.
As a special short hand, the -u flag can be specified up to three times. Each additional time incrementally decreases filtering:
•   -u is equivalent to --no-ignore.
•   -uu is equivalent to --no-ignore --hidden.
•   -uuu is equivalent to --no-ignore --hidden --binary.
In particular, rg -uuu should search the same exact content as grep -r.
ripgrep supports reading configuration files that change ripgrep’s default behavior. The format of the configuration file is an "rc" style and is very simple. It is defined by two rules:
1. Every line is a shell argument, after trimming whitespace.
2. Lines starting with # (optionally preceded by any amount of whitespace) are ignored.
ripgrep will look for a single configuration file if and only if the RIPGREP_CONFIG_PATH environment variable is set and is non-empty. ripgrep will parse shell arguments from this file on startup and will behave as if the arguments in this file were prepended to any explicit arguments given to ripgrep on the command line. Note though that the rg command you run must still be valid. That is, it must always contain at least one pattern at the command line, even if the configuration file uses the -e/--regexp flag.
For example, if your ripgreprc file contained a single line:
then the following command
RIPGREP_CONFIG_PATH=wherever/.ripgreprc rg foo
would behave identically to the following command
rg --smart-case foo
another example is adding types
--type-add web:*.{html,css,js}*
rg --type-add 'web:*.{html,css,js}*' foo
same with using globs
--glob=!.git
--glob !.git
rg --glob '!.git' foo
ripgrep also provides a flag, --no-config, that when present will suppress any and all support for configuration. This includes any future support for auto-loading configuration files from pre-determined paths.
Conflicts between configuration files and explicit arguments are handled exactly like conflicts in the same command line invocation. That is, this command:
RIPGREP_CONFIG_PATH=wherever/.ripgreprc rg foo --case-sensitive
is exactly equivalent to
rg --smart-case foo --case-sensitive
in which case, the --case-sensitive flag would override the --smart-case flag.
Shell completion files are included in the release tarball for Bash, Fish, Zsh and PowerShell.
For bash, move rg.bash to $XDG_CONFIG_HOME/bash_completion or /etc/bash_completion.d/.
For fish, move rg.fish to $HOME/.config/fish/completions.
For zsh, move _rg to one of your $fpath directories.
ripgrep may abort unexpectedly when using default settings if it searches a file that is simultaneously truncated. This behavior can be avoided by passing the --no-mmap flag which will forcefully disable the use of memory maps in all cases.
ripgrep may use a large amount of memory depending on a few factors. Firstly, if ripgrep uses parallelism for search (the default), then the entire output for each individual file is buffered into memory in order to prevent interleaving matches in the output. To avoid this, you can disable parallelism with the -j1 flag. Secondly, ripgrep always needs to have at least a single line in memory in order to execute a search. A file with a very long line can thus cause ripgrep to use a lot of memory. Generally, this only occurs when searching binary data with the -a flag enabled. (When the -a flag isn’t enabled, ripgrep will replace all NUL bytes with line terminators, which typically prevents exorbitant memory usage.) Thirdly, when ripgrep searches a large file using a memory map, the process will report its resident memory usage as the size of the file. However, this does not mean ripgrep actually needed to use that much memory; the operating system will generally handle this for you.
Please report bugs and feature requests in the issue tracker. Please do your best to provide a reproducible test case for bugs. This should include the corpus being searched, the rg command, the actual output and the expected output. Please also include the output of running the same rg command but with the --debug flag.
Andrew Gallant jamslam@gmail.com
PKGFILE(1)                       pkgfile Manual                       PKGFILE(1)
pkgfile - an alpm .files metadata explorer
Usage: pkgfile [operation] [options] target
pkgfile searches the .files metadata created by repo-add(8) to retrieve file information about packages. By default, the provided target is considered to be a filename and pkgfile will return the package(s) which contain this file. The repos which pkgfile searches is determined by those enabled in /etc/pacman.conf.
-l, --list The target is considered to be a package name rather than a filename, and the contents of the named package are returned. This allows for repo/package style syntax (such as "core/pacman") to limit the breadth of the search, but only when --list is used without the --glob or --regex options.
-s, --search Search for packages containing the provided target. This is the default mode of operation.
-u, --update Update the stored metadata files. It is recommended to create a daily cron job with this command to ensure accurate results. By default, only repos which are found to be newer on the mirror will be downloaded. Pass this option twice to force all repos to be downloaded.
-b, --binaries Return only files which are contained within a bin or sbin directory.
-d, --directories Match directories in search results.
-g, --glob Enable shell-style glob pattern matching. See glob(7). Note that the shell wildcards * and ? will never match path separators. Thus, this kind of matching is useful for searching for entries within directories, e.g. /usr/bin/*.
-i, --ignorecase Disable case sensitivity in matching.
-r, --regex Enable regular expression matching. See pcre(3).
-R REPO, --repo=REPO Search only the specific repo.
-0, --null Delimit output with null bytes rather than newline characters.
-q, --quiet Output less. This applies to the --list operation.
-v, --verbose Output more. This applies to the --search operation.
-w, --raw Avoid justification of 2 column output.
-z, --compress[=COMPRESSION] Repack downloaded repos with the optionally supplied compression method, which may be one of none, gzip, bzip2, lzop, lz4, lzma, or xz. If this flag is passed without a compression method, this defaults to gzip. If this flag is not passed at all, no compression will be applied. Applying any form of compression will decrease performance, but may be desirable for disk space concerns.
-C FILE, --config=FILE Use a config file other than the default of /etc/pacman.conf.
-D DIRECTORY, --cachedir=DIRECTORY Use a cache path other than the compile-time default.
-V, --version Print the version and exit.
In --search mode and without the --regex or --glob option, pkgfile will attempt to match the provided target as an exact filename. If the target contains a '/' character, a full path match will be attempted. With --regex and --glob enabled searching, pkgfile will always match against the full pathname.
In --list mode and without the --regex or --glob option, pkgfile will attempt to match the provided target as an exact package name. If the target contains a '/' character, the text before the slash will be assumed to be a repository and the search will be restricted.
/usr/share/doc/pkgfile/command-not-found.bash /usr/share/doc/pkgfile/command-not-found.zsh /usr/share/doc/pkgfile/command-not-found.fish zsh, bash and fish compatible functions which can be included in shell initalization to run pkgfile when an executed command is not found.
If the environment variable PKGFILE_PROMPT_INSTALL_MISSING is set, and only one package is found, a prompt to install the package will be shown. NOTE: this feature requires the sudo(8) program, and is currently only supported by the bash implementation.
pkgfile includes systemd timer and service units to automate periodic updates to the .files DBs. Assuming that pkgfile was built with systemd support, this can be enabled with:
systemctl enable --now pkgfile-update.timer
repo-add(8), pcre(3), glob(7), pacman.conf(5)
Dave Reisner <dreisner@archlinux.org>
CHMOD(1P)                   POSIX Programmer's Manual                  CHMOD(1P)
chmod — change the file modes
chmod [-R] mode file...
The chmod utility shall change any or all of the file mode bits of the file named by each file operand in the way specified by the mode operand.
It is implementation-defined whether and how the chmod utility affects any alternate or additional file access control mechanism (see the Base Definitions volume of POSIX.1‐2017, Section 4.5, File Access Permissions) being used for the specified file.
Only a process whose effective user ID matches the user ID of the file, or a process with appropriate privileges, shall be permitted to change the file mode bits of a file.
Upon successfully changing the file mode bits of a file, the chmod utility shall mark for update the last file status change timestamp of the file.
The chmod utility shall conform to the Base Definitions volume of POSIX.1‐2017, Section 12.2, Utility Syntax Guidelines.
-R        Recursively change file mode bits. For each file operand that names a directory, chmod shall change the file mode bits of the directory and all files in the file hierarchy below it.
mode      Represents the change to be made to the file mode bits of each file named by one of the file operands; see the EXTENDED DESCRIPTION section.
file      A pathname of a file whose file mode bits shall be modified.
The following environment variables shall affect the execution of chmod:
The mode operand shall be either a symbolic_mode expression or a non- negative octal integer. The symbolic_mode form is described by the grammar later in this section.
Each clause shall specify an operation to be performed on the current file mode bits of each file.  The operations shall be performed on each file in the order in which the clauses are specified.
The who symbols u, g, and o shall specify the user, group, and other parts of the file mode bits, respectively. A who consisting of the symbol a shall be equivalent to ugo.
The perm symbols r, w, and x represent the read, write, and execute/search portions of file mode bits, respectively. The perm symbol s shall represent the set-user-ID-on-execution (when who contains or implies u) and set-group-ID-on-execution (when who contains or implies g) bits.
The perm symbol X shall represent the execute/search portion of the file mode bits if the file is a directory or if the current (unmodified) file mode bits have at least one of the execute bits (S_IXUSR, S_IXGRP, or S_IXOTH) set. It shall be ignored if the file is not a directory and none of the execute bits are set in the current file mode bits.
The permcopy symbols u, g, and o shall represent the current permissions associated with the user, group, and other parts of the file mode bits, respectively. For the remainder of this section, perm refers to the non- terminals perm and permcopy in the grammar.
If multiple actionlists are grouped with a single wholist in the grammar, each actionlist shall be applied in the order specified with that wholist.  The op symbols shall represent the operation performed, as follows:
+     If perm is not specified, the '+' operation shall not change the file mode bits.
If who is not specified, the file mode bits represented by perm for the owner, group, and other permissions, except for those with corresponding bits in the file mode creation mask of the invoking process, shall be set.
Otherwise, the file mode bits represented by the specified who and perm values shall be set.
-     If perm is not specified, the '-' operation shall not change the file mode bits.
If who is not specified, the file mode bits represented by perm for the owner, group, and other permissions, except for those with corresponding bits in the file mode creation mask of the invoking process, shall be cleared.
Otherwise, the file mode bits represented by the specified who and perm values shall be cleared.
=     Clear the file mode bits specified by the who value, or, if no who value is specified, all of the file mode bits specified in this volume of POSIX.1‐2017.
If perm is not specified, the '=' operation shall make no further modifications to the file mode bits.
When using the symbolic mode form on a regular file, it is implementation-defined whether or not:
*  Requests to set the set-user-ID-on-execution or set-group-ID-on- execution bit when all execute bits are currently clear and none are being set are ignored.
*  Requests to clear all execute bits also clear the set-user-ID-on- execution and set-group-ID-on-execution bits.
*  Requests to clear the set-user-ID-on-execution or set-group-ID-on- execution bits when all execute bits are currently clear are ignored. However, if the command ls -l file writes an s in the position indicating that the set-user-ID-on-execution or set-group-ID-on- execution is set, the commands chmod u-s file or chmod g-s file, respectively, shall not be ignored.
When using the symbolic mode form on other file types, it is implementation-defined whether or not requests to set or clear the set- user-ID-on-execution or set-group-ID-on-execution bits are honored.
If the who symbol o is used in conjunction with the perm symbol s with no other who symbols being specified, the set-user-ID-on-execution and set- group-ID-on-execution bits shall not be modified. It shall not be an error to specify the who symbol o in conjunction with the perm symbol s.
The perm symbol t shall specify the S_ISVTX bit. When used with a file of type directory, it can be used with the who symbol a, or with no who symbol. It shall not be an error to specify a who symbol of u, g, or o in conjunction with the perm symbol t, but the meaning of these combinations is unspecified. The effect when using the perm symbol t with any file type other than directory is unspecified.
For an octal integer mode operand, the file mode bits shall be set absolutely.
For each bit set in the octal number, the corresponding file permission bit shown in the following table shall be set; all other file permission bits shall be cleared. For regular files, for each bit set in the octal number corresponding to the set-user-ID-on-execution or the set-group-ID- on-execution, bits shown in the following table shall be set; if these bits are not set in the octal number, they are cleared. For other file types, it is implementation-defined whether or not requests to set or clear the set-user-ID-on-execution or set-group-ID-on-execution bits are honored.
┌─────────────────┬──────────────────┬──────────────────┬──────────────────┐ │Octal   Mode Bit │ Octal   Mode Bit │ Octal   Mode Bit │ Octal   Mode Bit │ ├─────────────────┼──────────────────┼──────────────────┼──────────────────┤ │4000    S_ISUID  │ 0400    S_IRUSR  │ 0040    S_IRGRP  │ 0004    S_IROTH  │ ├─────────────────┼──────────────────┼──────────────────┼──────────────────┤ │2000    S_ISGID  │ 0200    S_IWUSR  │ 0020    S_IWGRP  │ 0002    S_IWOTH  │ ├─────────────────┼──────────────────┼──────────────────┼──────────────────┤ │1000    S_ISVTX  │ 0100    S_IXUSR  │ 0010    S_IXGRP  │ 0001    S_IXOTH  │ └─────────────────┴──────────────────┴──────────────────┴──────────────────┘ When bits are set in the octal number other than those listed in the table above, the behavior is unspecified.
Grammar for chmod The grammar and lexical conventions in this section describe the syntax for the symbolic_mode operand. The general conventions for this style of grammar are described in Section 1.3, Grammar Conventions.  A valid symbolic_mode can be represented as the non-terminal symbol symbolic_mode in the grammar. This formal syntax shall take precedence over the preceding text syntax description.
The lexical processing is based entirely on single characters. Implementations need not allow <blank> characters within the single argument being processed.
%start    symbolic_mode %%
symbolic_mode    : clause | symbolic_mode ',' clause ;
clause           : actionlist | wholist actionlist ;
wholist          : who | wholist who ;
who              : 'u' | 'g' | 'o' | 'a' ;
actionlist       : action | actionlist action ;
action           : op | op permlist | op permcopy ;
permcopy         : 'u' | 'g' | 'o' ;
op               : '+' | '-' | '=' ;
permlist         : perm | perm permlist ;
perm             : 'r' | 'w' | 'x' | 'X' | 's' | 't' ;
Some implementations of the chmod utility change the mode of a directory before the files in the directory when performing a recursive (-R option) change; others change the directory mode after the files in the directory. If an application tries to remove read or search permission for a file hierarchy, the removal attempt fails if the directory is changed first; on the other hand, trying to re-enable permissions to a restricted hierarchy fails if directories are changed last. Users should not try to make a hierarchy inaccessible to themselves.
Some implementations of chmod never used the umask of the process when changing modes; systems conformant with this volume of POSIX.1‐2017 do so when who is not specified. Note the difference between:
chmod a-w file
which removes all write permissions, and:
chmod -- -w file
which removes write permissions that would be allowed if file was created with the same umask.
Conforming applications should never assume that they know how the set- user-ID and set-group-ID bits on directories are interpreted.
The functionality of chmod is described substantially through references to concepts defined in the System Interfaces volume of POSIX.1‐2017. In this way, there is less duplication of effort required for describing the interactions of permissions. However, the behavior of this utility is not described in terms of the chmod() function from the System Interfaces volume of POSIX.1‐2017 because that specification requires certain side- effects upon alternate file access control mechanisms that might not be appropriate, depending on the implementation.
Implementations that support mandatory file and record locking as specified by the 1984 /usr/group standard historically used the combination of set-group-ID bit set and group execute bit clear to indicate mandatory locking. This condition is usually set or cleared with the symbolic mode perm symbol l instead of the perm symbols s and x so that the mandatory locking mode is not changed without explicit indication that that was what the user intended. Therefore, the details on how the implementation treats these conditions must be defined in the documentation. This volume of POSIX.1‐2017 does not require mandatory locking (nor does the System Interfaces volume of POSIX.1‐2017), but does allow it as an extension. However, this volume of POSIX.1‐2017 does require that the ls and chmod utilities work consistently in this area. If ls -l file indicates that the set-group-ID bit is set, chmod g-s file must clear it (assuming appropriate privileges exist to change modes).
The System V and BSD versions use different exit status codes. Some implementations used the exit status as a count of the number of errors that occurred; this practice is unworkable since it can overflow the range of valid exit status values. This problem is avoided here by specifying only 0 and >0 as exit values.
The System Interfaces volume of POSIX.1‐2017 indicates that implementation-defined restrictions may cause the S_ISUID and S_ISGID bits to be ignored. This volume of POSIX.1‐2017 allows the chmod utility to choose to modify these bits before calling chmod() (or some function providing equivalent capabilities) for non-regular files. Among other things, this allows implementations that use the set-user-ID and set- group-ID bits on directories to enable extended features to handle these extensions in an intelligent manner.