comparison.json

[
    {
        "section": "Searching",
        "abilities": [
            {
                "what": "Ignore case",
                "how": {
                    "ack,ag,freebsd,git,gnu,netbsd,osx,rg": "-i --ignore-case",
                    "bsd,posix": "-i"
                }
            },
            {
                "what": "Smart case searching (case-insensitive unless the pattern contains a capital letter)",
                "how": {
                    "ack,ag,rg": "-S --smart-case"
                }
            },
            {
                "what": "Case-sensitive search",
                "how": {
                    "ack": "-I",
                    "ag,rg": "-s --case-sensitive"
                }
            },
            {
                "what": "Match whole words",
                "how": {
                    "ack,ag,freebsd,git,gnu,netbsd,osx,rg": "-w --word-regexp",
                    "bsd": "-w"
                }
            },
            {
                "what": "Invert match",
                "how": {
                    "ack,ag,freebsd,git,gnu,netbsd,osx,rg": "-v --invert-match",
                    "bsd,posix": "-v"
                }
            },
            {
                "what": "Match entire line only",
                "how": {
                    "freebsd,gnu,netbsd,osx,rg": "-x --line-regexp",
                    "bsd,posix": "-x"
                }
            },
            {
                "what": "Specify pattern explicitly",
                "how": {
                    "ack": "--match",
                    "git": "-e",
                    "freebsd,gnu,osx,rg": "-e --regexp",
                    "bsd,posix": "-e"
                }
            },
            {
                "what": "Read patterns from a file",
                "how": {
                    "git": "-f",
                    "freebsd,gnu,osx,rg": "-f --file",
                    "bsd,posix": "-f"
                }
            },
            {
                "what": "Specify multiple patterns with boolean expressions",
                "how": {
                    "git": "--and --or --not --all-match"
                }
            },
            {
                "what": "Match patterns across newlines",
                "how": {
                    "ag": "--[no-]multiline"
                }
            },
            {
                "what": "Print specific lines",
                "how": {
                    "ack": "--lines"
                }
            }
        ]
    },
    {
        "section": "Regular expressions",
        "abilities": [
            {
                "what": "Use fixed strings, not regular expressions, for a literal match",
                "how": {
                    "ack": "-Q --literal",
                    "ag": "-Q --literal -F --fixed-strings",
                    "freebsd,git,osx,rg": "-F --fixed-strings",
                    "gnu": "-F --fixed-strings --fixed-regexp",
                    "posix": "-F"
                }
            },
            {
                "what": "Use basic regular expressions",
                "how": {
                    "freebsd,git,gnu,osx": "-G --basic-regexp"
                }
            },
            {
                "what": "Use extended regular expressions",
                "how": {
                    "freebsd,git,gnu,osx": "-E --extended-regexp",
                    "posix": "-E"
                }
            },
            {
                "what": "Use Perl (or Perl-compatible) regular expressions",
                "how": {
                    "ack": "(always)",
                    "git": "-P --perl-regexp",
                    "gnu": "-P --perl-regexp (experimental)"
                }
            }
        ]
    },
    {
        "section": "Search output",
        "abilities": [
            {
                "what": "Print only filenames that contain matches",
                "how": {
                    "ack,ag,freebsd,git,gnu,rg": "-l --files-with-matches",
                    "bsd,posix": "-l"
                }
            },
            {
                "what": "Print only filenames that do not contain matches",
                "how": {
                    "ack,ag,freebsd,git,gnu": "-L --files-without-match",
                    "rg": "--files-without-match"
                }
            },
            {
                "what": "Show only the part of a line that matched",
                "how": {
                    "ack": "-o",
                    "ag,freebsd,gnu,osx,rg": "-o --only-matching"
                }
            },
            {
                "what": "Print matches on very long lines",
                "how": {
                    "ag": "--print-long-lines"
                }
            },
            {
                "what": "Specify output for each line match",
                "how": {
                    "ack": "--output",
                    "rg": "-r --replace"
                }
            },
            {
                "what": "Print the filename for each match",
                "how": {
                    "ack,freebsd,gnu,rg": "-H --with-filename",
                    "ag": "--[no-]filename",
                    "git,osx": "-H"
                }
            },
            {
                "what": "Suppress the prefixing filename on output",
                "how": {
                    "ack,freebsd,gnu,osx": "-h --no-filename",
                    "ag": "--no-filename",
                    "git": "-h",
                    "rg": "--no-filename"
                }
            },
            {
                "what": "Print paths relative to the project top directory",
                "how": {
                    "git": "--full-name"
                }
            },
            {
                "what": "Prefix the line number to matching lines",
                "how": {
                    "ag": "--[no-]numbers",
                    "freebsd,git,gnu,rg": "-n --line-number",
                    "bsd,posix": "-n"
                }
            },
            {
                "what": "Suppress line numbers",
                "how": {
                    "ag": "--no-numbers",
                    "rg": "-N --no-line-number"
                }
            },
            {
                "what": "Print a heading of each file's name before its matches",
                "how": {
                    "ack,rg": "--[no-]heading",
                    "ag": "-H --[no-]heading",
                    "git": "--heading"
                }
            },
            {
                "what": "Specify filename to show for matches on STDIN",
                "how": {
                    "freebsd,gnu": "--label"
                }
            },
            {
                "what": "Show the column number of the first match",
                "how": {
                    "ack": "--[no-]column",
                    "rg": "--column"
                }
            },
            {
                "what": "Print lines of context after matches",
                "how": {
                    "ack,ag,git,gnu,rg": "-A --after",
                    "freebsd,netbsd,osx": "-A --after-context"
                }
            },
            {
                "what": "Print lines of context before matches",
                "how": {
                    "ack,ag,git,gnu,rg": "-B --before",
                    "netbsd,freebsd": "-B --before-context"
                }
            },
            {
                "what": "Print lines of context before and after matches",
                "how": {
                    "ack,ag,freebsd,git,gnu,rg": "-C --context",
                    "osx": "--context"
                }
            },
            {
                "what": "Show number of lines matching per file",
                "how": {
                    "ack,ag,freebsd,git,gnu,osx,rg": "-c --count",
                    "bsd,posix": "-c"
                }
            },
            {
                "what": "Print null byte as separator between filenames",
                "how": {
                    "ack": "--print0",
                    "ag": "-0 --null --print0",
                    "freebsd": "--null",
                    "git,netbsd": "-z --null",
                    "gnu": "-Z --null",
                    "rg": "-0 --null"
                }
            },
            {
                "what": "Stop searching in each file after NUM matches",
                "how": {
                    "ack,ag,freebsd,gnu,osx,rg": "-m --max-count"
                }
            },
            {
                "what": "Stop searching after one match of any kind",
                "how": {
                    "ack": "-1"
                }
            },
            {
                "what": "Print the byte offset within the file before each line",
                "how": {
                    "freebsd,gnu,netbsd": "-b --byte-offset -u --unix-byte-offsets",
                    "osx": "-b --byte-offset"
                }
            },
            {
                "what": "Print the block number the file before each line",
                "how": {
                    "bsd": "-b"
                }
            },
            {
                "what": "Suppress error messages about nonexistent or unreadable files",
                "how": {
                    "ack,gnu": "-s",
                    "ag": "--silent",
                    "freebsd,gnu,osx": "-s --no-messages",
                    "bsd,posix": "-s",
                    "rg": "--no-messages"
                }
            },
            {
                "what": "Limit length of output lines",
                "how": {
                    "rg": "-M --max-columns"
                }
            },
            {
                "what": "Do not output matched lines",
                "how": {
                    "git,rg": "-q --quiet",
                    "freebsd,gnu,osx": "-q --quiet --silent",
                    "posix": "-q"
                }
            },
            {
                "what": "Print stats (files scanned, time taken, etc.)",
                "how": {
                    "ag": "--stats --stats-only"
                }
            }
        ]
    },
    {
        "section": "File presentation",
        "abilities": [
            {
                "what": "Enable color output",
                "how": {
                    "ack,ag,git,gnu,rg": "--color",
                    "freebsd,osx": "--color --colour"
                }
            },
            {
                "what": "Set colors for various output items",
                "how": {
                    "ack": "--color-match --color-filename --color-lineno --color-colno",
                    "ag": "--color-match --color-path --color-line-number",
                    "git": "Specified in the .gitconfig file",
                    "gnu": "Specified in gnu_COLORS environment variable",
                    "rg": "--colors"
                }
            },
            {
                "what": "Pipe output through a pager or other command",
                "how": {
                    "ack": "--[no-]pager",
                    "git": "-O --open-files-in-pager"
                }
            },
            {
                "what": "Separate match output with blank lines unless they are on adjacent lines",
                "how": {
                    "ack": "--[no-]proximate"
                }
            },
            {
                "what": "Group together all matches in a file",
                "how": {
                    "ack,ag": "--[no-]group"
                }
            },
            {
                "what": "Specify group separator",
                "how": {
                    "gnu": "--[no-]group-separator"
                }
            },
            {
                "what": "Show the function name of the match",
                "how": {
                    "git": "-p --show-function"
                }
            },
            {
                "what": "Show the function in which a match was found",
                "how": {
                    "git": "-W --function-context"
                }
            },
            {
                "what": "Flush output immediately, even when ack is used non-interactively",
                "how": {
                    "ack": "--flush"
                }
            },
            {
                "what": "Print a break between results from different files",
                "how": {
                    "ack,ag": "--[no-]break"
                }
            },
            {
                "what": "Limit width of match lines",
                "how": {
                    "ag": "-W --width"
                }
            },
            {
                "what": "Flush output on every line",
                "how": {
                    "freebsd,osx": "--line-buffered"
                }
            }
        ]
    },
    {
        "section": "File finding",
        "abilities": [
            {
                "what": "Only print the files selected, without searching",
                "how": {
                    "ack": "-f",
                    "rg": "--files"
                }
            },
            {
                "what": "Show which types each file has",
                "how": {
                    "ack": "--show-types"
                }
            },
            {
                "what": "List searchable files that match a pattern",
                "how": {
                    "ack,ag": "-g"
                }
            },
            {
                "what": "Read the list of files to search from FILE",
                "how": {
                    "ack": "--files-from"
                }
            },
            {
                "what": "Sort the found files lexically",
                "how": {
                    "ack,rg": "--sort-files"
                }
            },
            {
                "what": "Read the list of files to search from STDIN",
                "how": {
                    "ack": "-x"
                }
            },
            {
                "what": "Limit search to filenames matching a pattern",
                "how": {
                    "ag": "-G --file-search-regex"
                }
            },
            {
                "what": "Search hidden files",
                "how": {
                    "ag,rg": "--hidden"
                }
            }
        ]
    },
    {
        "section": "File inclusion/exclusion",
        "abilities": [
            {
                "what": "Search only files of a given type",
                "how": {
                    "ack": "--type=X --X (where X is a filetype)",
                    "ag": "--X (where X is a filetype)",
                    "rg": "-t --type"
                }
            },
            {
                "what": "Exclude files of a given type",
                "how": {
                    "ack": "--type=noX --noX (where X is a filetype)",
                    "rg": "-T --type-not"
                }
            },
            {
                "what": "Recurse into subdirectories",
                "how": {
                    "ack": "-r -R --[no-]recurse",
                    "gnu": "-r --recursive",
                    "freebsd,osx": "-r -R --recursive -d recurse --directories=recurse"
                }
            },
            {
                "what": "read directory as a file",
                "how": {
                    "freebsd,osx": "-d read --directories=read"
                }
            },
            {
                "what": "Recurse into subdirectories, following symlinks",
                "how": {
                    "gnu": "-R --dereference-recursive"
                }
            },
            {
                "what": "No descending into subdirectories",
                "how": {
                    "ack": "-n --no-recurse",
                    "freebsd,osx": "-d skip --directories=skip"
                }
            },
            {
                "what": "Add/remove directory from list of ignored dirs",
                "how": {
                    "ack": "--[no-]ignore-dir",
                    "ag": "--ignore-dir"
                }
            },
            {
                "what": "Don't respect ignore files (.gitignore, .ignore, etc)",
                "how": {
                    "rg": "--no-ignore --no-ignore-parent --no-ignore-vcs"
                }
            },
            {
                "what": "Ignore files larger than a given size",
                "how": {
                    "rg": "--max-filesize"
                }
            },
            {
                "what": "Specify files to search",
                "how": {
                    "gnu": "--include",
                    "osx": "--include --include-dir",
                    "freebsd": "--include DIR_PATTERN",
                    "rg": "-g --glob --iglob"
                }
            },
            {
                "what": "Ignore files/directories matching",
                "how": {
                    "ag": "--ignore",
                    "gnu": "--exclude --exclude-from --exclude-dir",
                    "freebsd": "--exclude DIR_PATTERN",
                    "osx": "--exclude --exclude-dir",
                    "rg": "--ignore-file"
                }
            },
            {
                "what": "Add filter for ignoring files",
                "how": {
                    "ack": "--ignore-file"
                }
            },
            {
                "what": "Include only files of types that ack recognizes",
                "how": {
                    "ack": "-k --known-types"
                }
            },
            {
                "what": "Follow symlinks",
                "how": {
                    "ack": "--[no-]follow",
                    "ag": "-f --follow",
                    "rg": "-L --follow",
                    "osx": "-O -S"
                }
            },
            {
                "what": "Don't follow links to other devices",
                "how": {
                    "ag": "--one-device",
                    "gnu": "--devices=skip",
                    "osx": "-p"
                }
            },
            {
                "what": "Specify the demanded action for devices, FIFOs and sockets",
                "how": {
                    "freebsd,osx": "-D --devices"
                }
            },
            {
                "what": "Include only files of a given type",
                "how": {
                    "ack": "--type=X"
                }
            },
            {
                "what": "Search all types of files",
                "how": {
                    "ag": "-a --all-types"
                }
            },
            {
                "what": "Limit directory search depth",
                "how": {
                    "ag": "--depth",
                    "git": "--max-depth",
                    "rg": "--maxdepth"
                }
            },
            {
                "what": "Search binary files",
                "how": {
                    "ag": "--binary",
                    "freebsd,netbsd,osx": "-a --text"
                }
            },
            {
                "what": "Treat files as binary",
                "how": {
                    "gnu": "-U --binary",
                    "freebsd,osx": "-a --text --binary-files=binary -U --binary"
                }
            },
            {
                "what": "Don't search in binary files",
                "how": {
                    "git": "-I",
                    "freebsd,osx": "-I --binary-files=without-match"
                }
            },
            {
                "what": "Treat binary files as if they were text",
                "how": {
                    "git,rg": "-a --text",
                    "freebsd": "-a --text --binary-files=text"
                }
            },
            {
                "what": "Search all text files",
                "how": {
                    "ag": "-t --all-text"
                }
            },
            {
                "what": "Search all files",
                "how": {
                    "ag,rg": "-u --unrestricted"
                }
            },
            {
                "what": "Skip rules found in VCS ignore files (.gitignore, .hgignore, etc)",
                "how": {
                    "ag": "-U --skip-vcs-ignores"
                }
            },
            {
                "what": "Decompress the input data before searching",
                "how": {
                    "freebsd,osx": "-Z --decompress -J --bz2decompress"
                }
            }
        ]
    },
    {
        "section": "File type specification",
        "abilities": [
            {
                "what": "Create a filetype, replacing the previous specs",
                "how": {
                    "ack": "--type-set"
                }
            },
            {
                "what": "Add specifications to an existing filetype",
                "how": {
                    "ack,rg": "--type-add"
                }
            },
            {
                "what": "Remove a file type",
                "how": {
                    "ack": "--type-del",
                    "rg": "--type-clear"
                }
            },
            {
                "what": "Display all known types",
                "how": {
                    "ack": "--help-types",
                    "ag": "--list-file-types",
                    "rg": "--type-list"
                }
            }
        ]
    },
    {
        "section": "Miscellaneous",
        "abilities": [
            {
                "what": "Print all lines, whether matching or not",
                "how": {
                    "ack": "--passthru",
                    "ag": "--passthrough"
                }
            },
            {
                "what": "Outputs a default ackrc for your customization to standard output",
                "how": {
                    "ack": "--create-ackrc"
                }
            },
            {
                "what": "Dump information on which options are loaded",
                "how": {
                    "ack": "--dump"
                }
            },
            {
                "what": "Specify a configuration file to use",
                "how": {
                    "ack": "--ackrc"
                }
            },
            {
                "what": "Ignore environment variables and global configuration files",
                "how": {
                    "ack": "--env"
                }
            },
            {
                "what": "Ignore default definitions included with ack",
                "how": {
                    "ack": "--ignore-ack-defaults"
                }
            },
            {
                "what": "Treat standard input as a pipe",
                "how": {
                    "ack": "--[no-]filter"
                }
            },
            {
                "what": "Search contents of compressed files (e.g. gzip)",
                "how": {
                    "ag": "-z --search-zip"
                }
            },
            {
                "what": "Specify input file encoding",
                "how": {
                    "rg": "-E --encoding"
                }
            },
            {
                "what": "use the mmap(2) system call to read  input",
                "how": {
                    "freebsd,osx": "--mmap"
                }
            }
        ]
    }
]