ack-v3.8.1/ 000755 000766 000024 00000000000 14735132536 012557 5 ustar 00andy staff 000000 000000 ack-v3.8.1/LICENSE.md 000644 000766 000024 00000021663 14376470274 014200 0 ustar 00andy staff 000000 000000 ack is released under the [Artistic License 2.0][1].
[1]: https://www.perlfoundation.org/artistic-license-20.html
Artistic License 2.0
====================
Copyright (c) 2000-2006, The Perl Foundation.
Everyone is permitted to copy and distribute verbatim copies of this
license document, but changing it is not allowed.
Preamble
--------
This license establishes the terms under which a given free software
Package may be copied, modified, distributed, and/or redistributed. The
intent is that the Copyright Holder maintains some artistic control
over the development of that Package while still keeping the Package
available as open source and free software.
You are always permitted to make arrangements wholly outside of this
license directly with the Copyright Holder of a given Package. If the
terms of this license do not permit the full use that you propose to
make of the Package, you should contact the Copyright Holder and seek
a different licensing arrangement.
Definitions
-----------
"Copyright Holder" means the individual(s) or organization(s) named in
the copyright notice for the entire Package.
"Contributor" means any party that has contributed code or other material
to the Package, in accordance with the Copyright Holder's procedures.
"You" and "your" means any person who would like to copy, distribute,
or modify the Package.
"Package" means the collection of files distributed by the Copyright
Holder, and derivatives of that collection and/or of those files. A given
Package may consist of either the Standard Version, or a Modified Version.
"Distribute" means providing a copy of the Package or making it accessible
to anyone else, or in the case of a company or organization, to others
outside of your company or organization.
"Distributor Fee" means any fee that you charge for Distributing this
Package or providing support for this Package to another party. It does
not mean licensing fees.
"Standard Version" refers to the Package if it has not been modified,
or has been modified only in ways explicitly requested by the Copyright
Holder.
"Modified Version" means the Package, if it has been changed, and such
changes were not explicitly requested by the Copyright Holder.
"Original License" means this Artistic License as Distributed with the
Standard Version of the Package, in its current version or as it may be
modified by The Perl Foundation in the future.
"Source" form means the source code, documentation source, and
configuration files for the Package.
"Compiled" form means the compiled bytecode, object code, binary, or any
other form resulting from mechanical transformation or translation of
the Source form.
Permission for Use and Modification Without Distribution
--------------------------------------------------------
(1) You are permitted to use the Standard Version and create and use
Modified Versions for any purpose without restriction, provided that you
do not Distribute the Modified Version.
Permissions for Redistribution of the Standard Version
------------------------------------------------------
(2) You may Distribute verbatim copies of the Source form of the Standard
Version of this Package in any medium without restriction, either gratis
or for a Distributor Fee, provided that you duplicate all of the original
copyright notices and associated disclaimers. At your discretion, such
verbatim copies may or may not include a Compiled form of the Package.
(3) You may apply any bug fixes, portability changes, and other
modifications made available from the Copyright Holder. The resulting
Package will still be considered the Standard Version, and as such will
be subject to the Original License. Distribution of Modified Versions
of the Package as Source
(4) You may Distribute your Modified Version as Source (either gratis
or for a Distributor Fee, and with or without a Compiled form of the
Modified Version) provided that you clearly document how it differs
from the Standard Version, including, but not limited to, documenting
any non-standard features, executables, or modules, and provided that
you do at least ONE of the following:
(a) make the Modified Version available to the Copyright Holder of
the Standard Version, under the Original License, so that the Copyright
Holder may include your modifications in the Standard Version.
(b) ensure that installation of your Modified Version does not prevent
the user installing or running the Standard Version. In addition, the
Modified Version must bear a name that is different from the name of
the Standard Version.
(c) allow anyone who receives a copy of the Modified Version to make
the Source form of the Modified Version available to others under (i)
the Original License or (ii) a license that permits the licensee to
freely copy, modify and redistribute the Modified Version using the
same licensing terms that apply to the copy that the licensee received,
and requires that the Source form of the Modified Version, and of any
works derived from it, be made freely available in that license fees
are prohibited but Distributor Fees are allowed.
Distribution of Compiled Forms of the Standard Version or Modified Versions without the Source
----------------------------------------------------------------------------------------------
(5) You may Distribute Compiled forms of the Standard Version without
the Source, provided that you include complete instructions on how to
get the Source of the Standard Version. Such instructions must be valid
at the time of your distribution. If these instructions, at any time
while you are carrying out such distribution, become invalid, you must
provide new instructions on demand or cease further distribution. If
you provide valid instructions or cease distribution within thirty days
after you become aware that the instructions are invalid, then you do
not forfeit any of your rights under this license.
(6) You may Distribute a Modified Version in Compiled form without the
Source, provided that you comply with Section 4 with respect to the
Source of the Modified Version.
Aggregating or Linking the Package
----------------------------------
(7) You may aggregate the Package (either the Standard Version or
Modified Version) with other packages and Distribute the resulting
aggregation provided that you do not charge a licensing fee for the
Package. Distributor Fees are permitted, and licensing fees for other
components in the aggregation are permitted. The terms of this license
apply to the use and Distribution of the Standard or Modified Versions
as included in the aggregation.
(8) You are permitted to link Modified and Standard Versions with other
works, to embed the Package in a larger work of your own, or to build
stand-alone binary or bytecode versions of applications that include the
Package, and Distribute the result without restriction, provided the
result does not expose a direct interface to the Package.
Items That are Not Considered Part of a Modified Version
--------------------------------------------------------
(9) Works (including, but not limited to, modules and scripts) that
merely extend or make use of the Package, do not, by themselves, cause
the Package to be a Modified Version. In addition, such works are not
considered parts of the Package itself, and are not subject to the terms
of this license.
General Provisions
------------------
(10) Any use, modification, and distribution of the Standard or Modified
Versions is governed by this Artistic License. By using, modifying or
distributing the Package, you accept this license. Do not use, modify,
or distribute the Package, if you do not accept this license.
(11) If your Modified Version has been derived from a Modified Version
made by someone other than you, you are nevertheless required to ensure
that your Modified Version complies with the requirements of this license.
(12) This license does not grant you the right to use any trademark,
service mark, tradename, or logo of the Copyright Holder.
(13) This license includes the non-exclusive, worldwide, free-of-charge
patent license to make, have made, use, offer to sell, sell, import
and otherwise transfer the Package with respect to any patent claims
licensable by the Copyright Holder that are necessarily infringed by the
Package. If you institute patent litigation (including a cross-claim or
counterclaim) against any party alleging that the Package constitutes
direct or contributory patent infringement, then this Artistic License
to you shall terminate on the date that such litigation is filed.
(14) Disclaimer of Warranty: THE PACKAGE IS PROVIDED BY THE COPYRIGHT
HOLDER AND CONTRIBUTORS "AS IS' AND WITHOUT ANY EXPRESS OR IMPLIED
WARRANTIES. THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
PARTICULAR PURPOSE, OR NON-INFRINGEMENT ARE DISCLAIMED TO THE EXTENT
PERMITTED BY YOUR LOCAL LAW. UNLESS REQUIRED BY LAW, NO COPYRIGHT HOLDER
OR CONTRIBUTOR WILL BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OR
CONSEQUENTIAL DAMAGES ARISING IN ANY WAY OUT OF THE USE OF THE PACKAGE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
ack-v3.8.1/squash 000755 000766 000024 00000005043 14731437760 014016 0 ustar 00andy staff 000000 000000 #!perl
=pod
Squashes together the parts of ack into the single ack-standalone
file.
The arguments to squash are either filenames from the ack distro
like Ack.pm, or module names like File::Next. For modules, squash
loads them and then pushes them into ack-standalone.
POD gets stripped from all modules.
=cut
use warnings;
use strict;
use File::Next;
# Make clear that ack is not supposed to be edited.
my $NO_EDIT_COMMENT = <<'EOCOMMENT';
#
# This file, ack, is generated code.
# Please DO NOT EDIT or send patches for it.
#
# Please take a look at the source from
# https://github.com/beyondgrep/ack3
# and submit patches against the individual files
# that build ack.
#
EOCOMMENT
my @parts;
push @parts, <<"PERL";
#!/usr/bin/env perl
$NO_EDIT_COMMENT
\$App::Ack::STANDALONE = 1;
PERL
for my $arg ( @ARGV ) {
my $filename = $arg;
if ( $arg =~ /::/ ) {
my $key = "$arg.pm";
$key =~ s{::}{/}g;
$filename = $INC{$key} or die "Can't find the file for $arg";
}
my $is_ack = $filename eq 'ack';
warn "Reading $filename\n";
push @parts,
"{\n",
_get_code_from_file( $filename ),
"}\n",
;
}
my $code = join( '', @parts );
# We only use two of the four constructors in File::Next, so delete the other two.
for my $unused_func ( qw( dirs everything ) ) {
$code =~ s/^sub $unused_func\b.*?^}//sm or die qq{Unable to find the sub "$unused_func" to remove from ack-standalone};
}
print $code;
exit 0;
sub _get_code_from_file {
my $filename = shift;
my @lines;
open( my $fh, '<', $filename ) or die "Can't open $filename: $!";
my $was_in_pod = 0;
my $in_pod = 0;
while ( <$fh> ) {
next if /^use (?:File::Next|App::Ack)/;
s/^use parent (.+)/BEGIN {\n our \@ISA = $1\n}/;
if ( $was_in_pod && !$in_pod ) {
$was_in_pod = 0;
}
# See if we're in module POD blocks.
if ( $filename ne 'ack' ) {
$was_in_pod = $in_pod;
if ( /^=(\w+)/ ) {
$in_pod = ($1 ne 'cut');
next;
}
elsif ( $in_pod ) {
next;
}
}
# Replace the shebang line and append 'no edit' comment
if ( s{^#!.+}{package main;} ) {
# Skip the shebang line and replace it with package statement.
}
# Remove Perl::Critic comments.
# I'd like to remove all comments, but this is a start
s{\s*##.+critic.*}{};
push @lines, $_;
}
close $fh;
return join( '', @lines );
}
ack-v3.8.1/Changes 000644 000766 000024 00000032475 14735132514 014061 0 ustar 00andy staff 000000 000000 History file for ack 3. https://beyondgrep.com/
v3.8.1 Tue Dec 31 21:22:59 CST 2024
========================================
[ENHANCEMENTS]
The rules for Pytest were modified so that zsh's ad hoc scraping of
filetypes for tab completion wouldn't blow up. (GH #386)
v3.8.0 Fri Dec 20 22:07:26 CST 2024
========================================
[FEATURES]
Add --and and --or options to allow combinations of search terms. This is
in addition to the --not that was added in v3.7.0. (GH #385)
Add support for Pytest filetype.
Add support for Terraform. Thanks, Thiago Perrotta. (GH #377)
[FIXES]
The ack-standalone that gets built, and is what's available for download at
https://beyondgrep.com, now puts each of the modules it pulls in into its
own lexical scope. This should fix any future conflicts of pragmata that
might come up in the future. Thanks, mauke. (GH #376)
v3.7.0 Sat Feb 25 14:00:57 CST 2023
========================================
[FEATURES]
Added a repeatable --not option to let you supply patterns that should NOT
match. For example, if you want to search for "dogs" but not if "cats" or
"fish" are on the same line, you can do:
ack dogs --not cats --not fish
Added .Rmd to the list of extensions understood to be R. Thanks, Kieran
Mace. (GH#358)
Added file type for for Powershell (.ps1 and .psm1 files). Thanks, Thomas
Gossler, (GH#362)
v3.6.0 Sat Aug 20 22:57:47 CDT 2022
========================================
[FEATURES]
Added default ignores for Python's pickle serialization format (GH#348)
Added default ignore for Visual Studio's user & workspace settings. Thanks,
Gabor Szabo. (GH#324)
Added support for the Crystal language. Thanks, Gabor Szabo. (GH#340)
Fixed some spelling errors. Thanks, Frieder Bluemle. (GH#310)
Added .sbt as a Scala extension. Thanks, Grzegorz Kaczmarczyk. (GH#322)
[DOCS]
Fixed incorrect example in the docs for --range-start. Thanks, Alex Beamish.
v3.5.0 Fri Mar 12 22:29:44 CST 2021
========================================
[FIXES]
Reworked the option parsing to run correctly with Getopt::Long 2.38.
[FEATURES]
Added support for the Elm language. (GH#316)
Added support for the Purescript language. (GH#317)
Added support for the Bazel build tool. (GH#327)
v3.4.0 Mon Jun 29 23:04:18 CDT 2020
========================================
[FEATURES]
When calling "ack -c" to get a list of filenames and counts, the filename
would not be colored like when getting normal search results. Now it will.
Thanks to Matthew Hughes for adding the feature, and Ophir Lifshitz for the
suggestion. (GH#282)
Added --toml for the TOML filetype. (GH#306)
[FIXES]
The test t/ack-x.t would fail when run as root. Now it is skipped. Thanks,
Michael LaGrasta. (GH#217)
v3.3.1 Mon Jan 13 10:27:16 CST 2020
========================================
[FIXES]
Some regexes would be shown as invalid when used with the -Q option. Since
the -Q tells ack to treat the regex as a literal, this shouldn't be
possible. (GH#294)
v3.3.0 Sat Dec 28 16:00:21 CST 2019
========================================
[FEATURES]
The error message ack displays when the regex passed is invalid has been
improved. The message is more readable and includes a pointer to the
offending part of the regex. For example:
$ ack 'status: (open|closed|in progress'
ack: Invalid regex 'status: (open|closed|in progress'
Regex: status: (open|closed|in progress
^---HERE Unmatched ( in regex
Added many new file and directory exclusions to speed up file selection.
* Python's *.pyc, *.pyd and *.pyo compiled files
* Python's __pycache__ and .pytest_cache directories
* Linux *.so shared object files
* Windows dynamic-link library *.dll files
* gettext compiled *.mo translation files
* macOS's __MACOSX directories and .DS_Store files
Reorganized the --help menu to put "action" options like -f, -g and -l at
the top of the listing.
The --show-types option only has an effect with -f or -g. ack will now
tell you if you use --show-types without -f or -g when it will have no
effect.
Improved the error message when ack gets passed two options that can't be
used together.
[FIXES]
Fixed the behavior of --break and --heading. Using --break would
implicitly set --noheading, and --heading would implicitly set --nobreak.
The following pairs of options don't make sense to use together, and ack will now warn you if you try:
* -x and --files-from
* -v and -o
* -v and --output
* -v and --passthru
Fixed the minimum version of the Getopt::Long module required. (GH #287)
The line number and filename separators in --passthru mode now work the
same as in context (-A/-B/-C) mode. (GH #291)
v3.2.0 Sun Nov 3 22:52:18 CST 2019
========================================
[FEATURES]
Added "-t X" as a short alias for --type=X.
Added "-T X" as a short alias for --type=noX.
The feature of using the name of the type as an option is deprecated. For
example, ack currently lets you use "--perl" instead of "--type=perl" or
"-t perl", This is now deprecated and will be removed in a future release.
Removed support for Parrot (--parrot).
v3.1.3 Sat Oct 19 19:23:48 CDT 2019
========================================
No changes to functionality. Fixed a problem with version numbers.
Thanks to Dan Book for his help.
See https://github.com/beyondgrep/ack3/commit/b3c43d44109dea6ebc0753107a8e85a6b322f4ca
v3.1.2 Mon Oct 14 21:47:51 CDT 2019
========================================
[SPEEDUP]
Using -w with a pattern that ended with a metacharacter would be slower
than it should be because it would skip an optimization. Now it's fixed.
(GH #181, #251)
[FIXES]
Fixed test failures that would sometimes happen on Windows machines because
of taint mode. Thanks, Tomasz Konojacki. (GH #235)
Remove the use of the version.pm module.
v3.1.1 Sat Aug 31 22:56:10 CDT 2019
========================================
[SPEEDUP]
Improved the speed up the -l, -L and -c options by pre-scanning the file
in bulk before doing line-by-line scan. (GH #221)
ack now uses File::Next 1.18 which calls stat() only once per file or
directory, instead of sometimes calling it twice. This should improve the
time spent traversing directories.
[FIXES]
On Windows, patterns with $ to mark the end of the line would not match.
(GH #229)
[DOCUMENTATION]
Fixed docs that referred to --range-stop instead of --range-end. (GH #228)
v3.1.0 Thu Aug 22 22:43:15 CDT 2019
========================================
[FEATURES]
Added the --range-start and --range-end options to allow searching only
ranges of each file. (GH #165)
v3.0.3 Tue Aug 20 23:42:02 CDT 2019
========================================
[FIXES]
Made smartcase's check for lowercase patterns smarter.
[DOCUMENTATION]
Updated many URLs, especially in the config. (GH #223)
v3.0.2 Thu Jul 4 21:42:43 CDT 2019
========================================
[FIXES]
ack's smart-case feature would think that a pattern like "select \S+ from"
is looking for a uppercase letter, and so would not make a case-insensitive
search. Now, ack knows that uppercase letters in metacharacters don't
count as looking for a uppercase letter. (GH #156, 187, 214)
v3.0.1 Tue Jun 25 20:47:58 CDT 2019
========================================
[FIXES]
The -s option tells ack not to complain about missing or unreadable files
it tries to search. The -s option would not always work in conjection with
the -x option. Now it does. Thanks, Anders Eriksson and M. Scott Ford.
(GH #175)
ack would die if you specified a --output option that didn't use one
of Perl's special match variables. Now it won't. Thanks, M. Scott
Ford. (GH #210)
[INTERNALS]
Added a Dockerfile for use when working on ack development. Thanks,
M. Scott Ford. (GH #208)
v3.0.0 Mon May 27 21:46:34 CDT 2019
========================================
First official release of ack version 3.
See "Release notes for ack 3.0.0" at the bottom of this document for
details of what has changed between ack 2.x and ack 3.
[FIXES]
Fixed a failing test if Pod::Perldoc::ToTextOverstrike was being
used. (GH#202)
2.999_08 Sun May 19 20:33:13 CDT 2019
=====================================
[ENHANCEMENTS]
Consolidated the manual and FAQ into one document, accessible with --man.
Cookbook.pm has been moved to dev for future use.
Added SVG filetype.
[FIXES]
Invalid options used to cause an error message triplicate. Fixes GH #192.
2.999_07 Sun Mar 31 21:54:55 CDT 2019
=====================================
[ENHANCEMENTS]
Added --help-colors and --help-rgb-colors options to display colors
available for color options.
Many more mutex options have been added to help users know when they've
made a mistake. For example, it doesn't make sense to have -C to show
context when using -f to get a file list.
Overhauled the handling of mutually exclusive options. We now properly
handle mutex options even if they are abbreviated. The actual argument
used is now shown. Fixes GH #57.
2.999_06 Thu Jan 10 20:37:23 CST 2019
=====================================
[ENHANCEMENTS]
The --tt option for Template Toolkit is now --ttml. The short version
still works.
The standalone version of ack no longer supports the --faq or --cookbook
options, which never worked right for it anyway. Instead, --man includes
the FAQ and Cookbook.
The --man option no longer uses the `perldoc` program for rendering the
documentation. This means you'll have to pipe it into your own pager if
you want scrolling, but it makes it much more portable.
[FIXES]
ack would stop finding files if there was a file named "0" in the current
directory. Thanks, Rob Hoelz. (GH #162)
[REMOVED FUNCTIONALITY]
The --lines option has been removed. (GH #167)
The -u short alias for --underline has been removed. (GH #173)
2.999_05 Sun Oct 21 21:37:39 CDT 2018
=====================================
[ENHANCEMENTS]
Add -p as a shorter version of --proximate.
2.999_04 Thu Sep 6 17:45:07 CDT 2018
=====================================
[ENHANCEMENTS]
Added -P as a negation of --proximate. It is the same as --proximate=0.
If you have --proximate in an .ackrc, -P can be used to cancel it.
Added --ts for TypeScript.
2.999_03 Fri Jan 19 11:02:46 CST 2018
=====================================
[ENHANCEMENTS]
The check for whether we need to scan the entire file line-by-line now
reads 10M of file instead of just 100K.
Removed support for the ACK_OPTIONS environment variable. Use an ackrc
file instead. If you have ACK_OPTIONS set, ack will give a warning.
Lots of internal speedups.
2.999_02 Mon Jan 8 23:03:42 CST 2018
=====================================
[ENHANCEMENTS]
Added an optimization to make ack only do a line-by-line search of a
file if there's a match somewhere in the file. This gives ack a 20-30%
in timings of common cases.
2.999_01 Mon Jan 1 22:11:17 CST 2018
=====================================
[ENHANCEMENTS]
Added --pod as a filetype, recognizing .pod as its extension. This is
Perl's POD (Plain Old Documentation) format.
Added --markdown as a filetype, recognizing .md and .markdown as
extensions.
--pager is no longer allowed in a project .ackrc file. --match and
--output are not allowed in any .ackrc file.
ack 3's new features are listed below for now.
[FIXES]
--lines had some mutex options that were not getting checked. Now,
--lines is mutex with --passthru, --match and all context options.
=============================
# Release notes for ack 3.0.0
=============================
# New features
ack 3 is a greplike tool optimized for searching large code trees.
Improvements over ack 2 include:
* Improved `-w` option.
* `-w` option will warn if your pattern does not lend itself to
word matching.
* `-i`, `-I` and `--smart-case`
* `--proximate=N` option
* Added `--pod` and `--markdown`.
* Added `GNUmakefile` to the list of makefile specs.
* Added `-S` as a synonym for `--smart-case`.
# Bug fixes
* Column numbers were not getting colorized in the output. Added
`--color-colno` option and `ACK_COLOR_COLNO` environment variable.
* A pattern that wanted whitespace at the end could match the
linefeed at the end of a line. This is no longer possible.
# Incompatibilities with ack 2
## ack 3 requires Perl 5.10.1
ack 2 only needed Perl 5.8.8. This shouldn't be a problem since 5.10.1
has been out since 2009.
## ack 3 no longer highlights capture groups.
ack 2 would highlight your capture groups. For example,
ack '(set|get)_foo_(name|id)'
would highlight the `set` or `get`, and the `name` or `id`, but not the
full `set_user_id` that was matched.
This feature was too confusing and has been removed. Now, the entire
matching string is highlighted.
## ack 3's --output allows fewer special variables
In ack 2, you could put any kind of Perl code in the `--output`
option and it would get `eval`uated at run time, which would let
you do tricky stuff like this gem from Mark Fowler
(http://www.perladvent.org/2014/2014-12-21.html):
ack --output='$&: @{[ eval "use LWP::Simple; 1" && length LWP::Simple::get($&) ]} bytes' \
'https?://\S+' list.txt
http://google.com/: 19529 bytes
http://metacpan.org/: 7560 bytes
http://www.perladvent.org/: 5562 bytes
This has been a security problem in the past, and so in ack 3 we
no longer `eval` the contents of `--output`. You're now restricted
to the following variables: `$1` thru `$9`, `$_`, `$.`, `$&`, ``$` ``,
`$'` and `$+`. You can also embed `\t`, `\n` and `\r` ,
and `$f` as stand-in for `$filename` in `ack2 --output` .
ack-v3.8.1/MANIFEST 000644 000766 000024 00000011721 14735132536 013712 0 ustar 00andy staff 000000 000000 Changes
LICENSE.md
MANIFEST
README.md
Makefile.PL
ack
lib/App/Ack.pm
lib/App/Ack/ConfigDefault.pm
lib/App/Ack/ConfigFinder.pm
lib/App/Ack/ConfigLoader.pm
lib/App/Ack/File.pm
lib/App/Ack/Files.pm
lib/App/Ack/Filter.pm
lib/App/Ack/Filter/Collection.pm
lib/App/Ack/Filter/Default.pm
lib/App/Ack/Filter/Extension.pm
lib/App/Ack/Filter/ExtensionGroup.pm
lib/App/Ack/Filter/FirstLineMatch.pm
lib/App/Ack/Filter/Inverse.pm
lib/App/Ack/Filter/Is.pm
lib/App/Ack/Filter/IsGroup.pm
lib/App/Ack/Filter/IsPath.pm
lib/App/Ack/Filter/IsPathGroup.pm
lib/App/Ack/Filter/Match.pm
lib/App/Ack/Filter/MatchGroup.pm
squash
t/Barfly.pm
t/Util.pm
t/test-pager
t/00-load.t
t/FilterTest.pm
t/ack-1.t
t/ack-Q.t
t/ack-c.t
t/ack-color.t
t/ack-column.t
t/ack-create-ackrc.t
t/ack-dump.t
t/ack-f.t
t/ack-files-from.t
t/ack-g.t
t/ack-group.t
t/ack-h.t
t/ack-help-types.t
t/ack-help.t
t/ack-i.barfly
t/ack-i.t
t/ack-ignore-dir.t
t/ack-ignore-file.t
t/ack-k.t
t/ack-l.t
t/ack-m.t
t/ack-man.t
t/ack-match.t
t/ack-n.t
t/ack-o.t
t/ack-output.t
t/ack-pager.t
t/ack-passthru.t
t/ack-print0.t
t/ack-proximate.t
t/ack-s.t
t/ack-show-types.t
t/ack-type-del.t
t/ack-type.t
t/ack-underline.barfly
t/ack-underline.t
t/ack-v.t
t/ack-version.t
t/ack-w.barfly
t/ack-w.t
t/ack-x.t
t/anchored.t
t/bad-ackrc-opt.t
t/basic.t
t/boolean.t
t/build_regex.t
t/command-line-files.t
t/config-backwards-compat.t
t/config-finder.t
t/config-loader.t
t/context-with-newlines.t
t/context.t
t/default-filter.t
t/double-hyphen.t
t/empty-lines.t
t/exit-code.t
t/ext-filter.t
t/file-iterator.t
t/file-permission.t
t/filetype-detection.t
t/filetypes.t
t/filter.t
t/firstlinematch-filter.t
t/forbidden-options.t
t/from-stdin.t
t/highlighting.t
t/illegal-regex.t
t/incomplete-last-line.t
t/interactive.t
t/invalid-ackrc.t
t/invalid-options.t
t/inverted-file-filter.t
t/is-filter.t
t/line-endings.t
t/longopts.t
t/lowercase.t
t/match-filter.t
t/multiple-captures.t
t/mutex-options.t
t/named-pipes.t
t/needs-line-scan.t
t/noackrc.t
t/noenv.t
t/prescan-line-boundaries.t
t/process-substitution.t
t/runtests.pl
t/trailing-whitespace.t
t/zero.t
t/etc/buttonhook.xml.xxx
t/etc/shebang.empty.xxx
t/etc/shebang.foobar.xxx
t/etc/shebang.php.xxx
t/etc/shebang.pl.xxx
t/etc/shebang.py.xxx
t/etc/shebang.rb.xxx
t/etc/shebang.sh.xxx
t/home/.ackrc
t/range/rangefile.pm
t/range/america-the-beautiful.html
t/range/anchors-aweigh.html
t/range/johnny-rebeck.txt
t/range/stars-and-stripes-forever.html
t/swamp/__pycache__/notes.pl
t/swamp/#emacs-workfile.pl#
t/swamp/0
t/swamp/CMakeLists.txt
t/swamp/Makefile
t/swamp/Makefile.PL
t/swamp/MasterPage.master
t/swamp/Rakefile
t/swamp/Sample.ascx
t/swamp/Sample.asmx
t/swamp/blib/ignore.pm
t/swamp/blib/ignore.pod
t/swamp/c-header.h
t/swamp/c-source.c
t/swamp/constitution-100k.pl
t/swamp/crystallography-weenies.f
t/swamp/example.R
t/swamp/favicon.ico
t/swamp/file.bar
t/swamp/file.foo
t/swamp/foo_test.py
t/swamp/fresh.css
t/swamp/fresh.css.min
t/swamp/fresh.min.css
t/swamp/groceries/CVS/fruit
t/swamp/groceries/CVS/junk
t/swamp/groceries/CVS/meat
t/swamp/groceries/RCS/fruit
t/swamp/groceries/RCS/junk
t/swamp/groceries/RCS/meat
t/swamp/groceries/another_subdir/CVS/fruit
t/swamp/groceries/another_subdir/CVS/junk
t/swamp/groceries/another_subdir/CVS/meat
t/swamp/groceries/another_subdir/RCS/fruit
t/swamp/groceries/another_subdir/RCS/junk
t/swamp/groceries/another_subdir/RCS/meat
t/swamp/groceries/another_subdir/fruit
t/swamp/groceries/another_subdir/junk
t/swamp/groceries/another_subdir/meat
t/swamp/groceries/dir.d/CVS/fruit
t/swamp/groceries/dir.d/CVS/junk
t/swamp/groceries/dir.d/CVS/meat
t/swamp/groceries/dir.d/fruit
t/swamp/groceries/dir.d/junk
t/swamp/groceries/dir.d/meat
t/swamp/groceries/dir.d/RCS/fruit
t/swamp/groceries/dir.d/RCS/junk
t/swamp/groceries/dir.d/RCS/meat
t/swamp/groceries/fruit
t/swamp/groceries/junk
t/swamp/groceries/meat
t/swamp/groceries/subdir/fruit
t/swamp/groceries/subdir/junk
t/swamp/groceries/subdir/meat
t/swamp/html.htm
t/swamp/html.html
t/swamp/incomplete-last-line.txt
t/swamp/javascript.js
t/swamp/lua-shebang-test
t/swamp/minified.js.min
t/swamp/minified.min.js
t/swamp/moose-andy.jpg
t/swamp/not-an-#emacs-workfile#
t/swamp/notaMakefile
t/swamp/notaRakefile
t/swamp/notes.md
t/swamp/options-crlf.pl
t/swamp/options.pl
t/swamp/options.pl.bak
t/swamp/perl-test.t
t/swamp/perl-without-extension
t/swamp/perl.cgi
t/swamp/perl.handler.pod
t/swamp/perl.pl
t/swamp/perl.pm
t/swamp/perl.pod
t/swamp/perl.tar.gz
t/swamp/perltoot.jpg
t/swamp/pipe-stress-freaks.F
t/swamp/sample.asp
t/swamp/sample.aspx
t/swamp/sample.rake
t/swamp/service.svc
t/swamp/solution8.tar
t/swamp/stuff.cmake
t/swamp/test.py
t/swamp/test_foo.py
t/swamp/swamp/ignoreme.txt
t/text/amontillado.txt
t/text/bill-of-rights.txt
t/text/constitution.txt
t/text/gettysburg.txt
t/text/movies.txt
t/text/number.txt
t/text/numbered-text.txt
t/text/ozymandias.txt
t/text/raven.txt
xt/coding-standards.t
xt/coresubs.t
xt/man.t
xt/pod.t
META.yml Module YAML meta-data (added by MakeMaker)
META.json Module JSON meta-data (added by MakeMaker)
ack-v3.8.1/t/ 000755 000766 000024 00000000000 14735132536 013022 5 ustar 00andy staff 000000 000000 ack-v3.8.1/xt/ 000755 000766 000024 00000000000 14735132536 013212 5 ustar 00andy staff 000000 000000 ack-v3.8.1/README.md 000644 000766 000024 00000005702 14731437760 014045 0 ustar 00andy staff 000000 000000 # ack 3
ack is a code-searching tool, similar to grep but optimized for
programmers searching large trees of source code. It is highly
portable and runs on any platform that runs Perl.
ack is written and maintained by Andy Lester (andy@petdance.com).
* [Project home page](https://beyondgrep.com/)
* [Code home page](https://github.com/beyondgrep/ack3)
* [Issue tracker](https://github.com/beyondgrep/ack3/issues)
* Mailing lists
* [ack-announce](https://groups.google.com/d/forum/ack-announce), announcements-only
* [ack-users](https://groups.google.com/d/forum/ack-users), for users of ack
* [ack-dev](https://groups.google.com/d/forum/ack-dev), for ack development
* [Build status ](https://github.com/beyondgrep/ack3/actions?query=workflow%3Atestsuite+branch%3Adev)
* [CPAN Testers](https://cpantesters.org/distro/A/ack.html)
# Building
ack requires Perl 5.10.1 or higher, and it requires the
[File::Next](https://metacpan.org/pod/File::Next) module to be installed.
## Checking prerequisites
To check ack's dependencies, run this command in the shell:
perl -MFile::Next -E'say "ack is ready to build!"'
If everything is OK, you'll see:
ack is ready to build!
If your installation of Perl is outdated, you'll see an error like this:
Unrecognized switch: -Esay "ack is ready to build!" (-h will show valid options).
If you don't have File::Next installed, you'll see an error like this:
Can't locate File/Next.pm in @INC (@INC contains: /home/andy/...
BEGIN failed--compilation aborted.
and you'll need to install File::Next yourself:
# Install File::Next dependency
perl -MCPAN -e install File::Next
## Building ack
If you've got a recent enough version of Perl and you have File::Next
installed, you can build ack.
# Required
perl Makefile.PL
make
make test
sudo make install # For a system-wide installation
# - or -
make ack-standalone
cp ack-standalone ~/bin/ack3 # For a personal installation
# Development
* [How to contribute](CONTRIBUTING.md)
* [Developer's Guide](DEVELOPERS.md)
* [Design Guide](DESIGN.md)
# Community
See the [Community](https://beyondgrep.com/community/) page.
Please follow the [Code of Conduct](CODE_OF_CONDUCT.md) in all your interactions with our project.
# License
Copyright 2005-2024 Andy Lester.
This program is free software; you can redistribute it and/or modify
it under the terms of the
[Artistic License v2.0](https://www.perlfoundation.org/artistic_license_2_0).
See also the LICENSE.md file that comes with the ack distribution.
# Support
[ack](https://github.com/beyondgrep/ack3) and [beyondgrep.com](https://beyondgrep.com) are supported by [DigitalOcean](https://m.do.co/c/6a437192f552).
ack-v3.8.1/META.yml 000644 000766 000024 00000002212 14735132536 014025 0 ustar 00andy staff 000000 000000 ---
abstract: 'A grep-like program for searching source code'
author:
- 'Andy Lester '
build_requires:
ExtUtils::MakeMaker: '0'
configure_requires:
ExtUtils::MakeMaker: '0'
dynamic_config: 1
generated_by: 'ExtUtils::MakeMaker version 7.70, CPAN::Meta::Converter version 2.143240'
license: artistic_2
meta-spec:
url: http://module-build.sourceforge.net/META-spec-v1.4.html
version: '1.4'
name: ack
no_index:
directory:
- t
- inc
requires:
Cwd: '3.00'
File::Basename: '1.00015'
File::Next: '1.18'
File::Spec: '3.00'
File::Temp: '0.19'
Getopt::Long: '2.38'
List::Util: '0'
Pod::Perldoc: '3.20'
Pod::Text: '0'
Pod::Usage: '1.26'
Scalar::Util: '0'
Term::ANSIColor: '1.10'
Test::Harness: '2.50'
Test::More: '0.98'
Text::ParseWords: '3.1'
filetest: '0'
if: '0'
parent: '0'
perl: '5.010001'
version: '0'
resources:
MailingList: https://groups.google.com/group/ack-users
bugtracker: https://github.com/beyondgrep/ack3
homepage: https://beyondgrep.com/
license: https://www.perlfoundation.org/artistic-license-20.html
repository: git://github.com/beyondgrep/ack3.git
version: v3.8.1
ack-v3.8.1/lib/ 000755 000766 000024 00000000000 14735132536 013325 5 ustar 00andy staff 000000 000000 ack-v3.8.1/Makefile.PL 000644 000766 000024 00000011510 14572776326 014541 0 ustar 00andy staff 000000 000000 package main;
require 5.010001;
use strict;
use warnings;
use ExtUtils::MakeMaker;
print "Running Perl $^V at $^X\n";
my $debug_mode = (grep { $_ eq '--debug' } @ARGV) ? '--debug' : '';
my %parms = (
NAME => 'ack',
AUTHOR => 'Andy Lester ',
ABSTRACT => 'A grep-like program for searching source code',
VERSION_FROM => 'lib/App/Ack.pm',
LICENSE => 'artistic_2',
MIN_PERL_VERSION => 5.010001,
META_MERGE => {
resources => {
homepage => 'https://beyondgrep.com/',
bugtracker => 'https://github.com/beyondgrep/ack3',
license => 'https://www.perlfoundation.org/artistic-license-20.html',
repository => 'git://github.com/beyondgrep/ack3.git',
MailingList => 'https://groups.google.com/group/ack-users',
},
},
EXE_FILES => [ 'ack' ],
PREREQ_PM => {
'Cwd' => '3.00',
'File::Basename' => '1.00015',
'File::Next' => '1.18',
'File::Spec' => '3.00',
'File::Temp' => '0.19', # For newdir()
'filetest' => 0,
'Getopt::Long' => '2.38',
'if' => 0,
'List::Util' => 0,
'parent' => 0,
'Pod::Perldoc' => '3.20', # Starting with 3.20, default output is Pod::Perldoc::ToTerm instead of ::ToMan
'Pod::Text' => 0, # Used to render pod by Pod::Usage.
'Pod::Usage' => '1.26',
'Scalar::Util' => 0,
'Term::ANSIColor' => '1.10',
'Test::Harness' => '2.50', # Something reasonably newish
'Test::More' => '0.98', # For subtest()
'Text::ParseWords' => '3.1',
'version' => 0,
( $^O eq 'MSWin32' ? ('Win32::ShellQuote' => '0.002001') : () ),
},
MAN3PODS => {}, # no need for man pages for any of the .pm files
dist => { COMPRESS => 'gzip -9f', SUFFIX => 'gz', },
clean => { FILES => 'ack-3* nytprof* stderr.log stdout.log completion.*' },
);
WriteMakefile( %parms );
package MY;
# Suppress EU::MM test rule.
sub MY::test {
return '';
}
sub MY::postamble {
my $postamble = sprintf(<<'MAKE_FRAG', $debug_mode);
ACK = ack
CODE_PM = \
lib/App/Ack.pm \
\
lib/App/Ack/ConfigDefault.pm \
lib/App/Ack/ConfigFinder.pm \
lib/App/Ack/ConfigLoader.pm \
lib/App/Ack/File.pm \
lib/App/Ack/Files.pm \
lib/App/Ack/Filter.pm \
\
lib/App/Ack/Filter/Collection.pm \
lib/App/Ack/Filter/Default.pm \
lib/App/Ack/Filter/Extension.pm \
lib/App/Ack/Filter/ExtensionGroup.pm \
lib/App/Ack/Filter/FirstLineMatch.pm \
lib/App/Ack/Filter/Inverse.pm \
lib/App/Ack/Filter/Is.pm \
lib/App/Ack/Filter/IsGroup.pm \
lib/App/Ack/Filter/IsPath.pm \
lib/App/Ack/Filter/IsPathGroup.pm \
lib/App/Ack/Filter/Match.pm \
lib/App/Ack/Filter/MatchGroup.pm \
TEST_VERBOSE=0
TEST_UTILS=t/*.pm
TEST_FILES=t/*.t
TEST_XT_FILES=xt/*.t
.PHONY: tags critic
tags:
ctags -f tags --recurse --totals \
--exclude=blib \
--exclude=.git \
--exclude='*~' \
--exclude=ack-standalone \
--exclude=garage/* \
--exclude=ack-v3*/* \
--languages=Perl --langmap=Perl:+.t \
# Don't run critic on docs.
critic:
perlcritic -1 -q -profile perlcriticrc $(ACK) $(CODE_PM) $(TEST_UTILS) $(TEST_FILES) $(TEST_XT_FILES)
ack-standalone : $(ACK) $(CODE_PM) squash Makefile
$(PERL) squash $(ACK) $(CODE_PM) File::Next %s > ack-standalone
$(FIXIN) ack-standalone
-$(NOECHO) $(CHMOD) $(PERM_RWX) ack-standalone
$(PERL) -c ack-standalone
bininst : $(ACK)
$(CP) $(ACK) ~/bin/ack3
$(CP) ackrc ~/.ack3rc
test: test_classic test_standalone
fulltest: test_classic test_standalone test_xt
test_classic: all
$(FULLPERLRUN) t/runtests.pl 0 $(TEST_VERBOSE) "$(INST_LIB)" "$(INST_ARCHLIB)" $(TEST_FILES)
test_standalone: all ack-standalone
$(FULLPERLRUN) t/runtests.pl 1 $(TEST_VERBOSE) "$(INST_LIB)" "$(INST_ARCHLIB)" $(TEST_FILES)
test_xt: all
$(FULLPERLRUN) t/runtests.pl 0 $(TEST_VERBOSE) "$(INST_LIB)" "$(INST_ARCHLIB)" $(TEST_XT_FILES)
test_all: test_classic test_standalone test_xt
PROF_ARGS = -Mblib blib/script/ack foo ~/parrot
nytprof: all
$(PERL) -d:NYTProf $(PROF_ARGS) >> /dev/null 2>&1
nytprofhtml
TIMER_ARGS=foo ~/parrot > /dev/null
time-ack196:
time $(PERL) ./garage/ack196 --noenv $(TIMER_ARGS)
time-head: ack-standalone
time $(PERL) ./ack-standalone --noenv $(TIMER_ARGS)
timings: ack-standalone
./dev/timings.pl ~/parrot
timings-beta: ack-standalone
./dev/timings.pl ~/parrot --ack=2.999_0{1,2,3,4,5,6}
completion.bash: pm_to_blib
./dev/generate-completion-scripts.pl completion.bash
completion.zsh: pm_to_blib
./dev/generate-completion-scripts.pl completion.zsh
MAKE_FRAG
return $postamble;
}
1;
ack-v3.8.1/ack 000755 000766 000024 00000223772 14735132514 013254 0 ustar 00andy staff 000000 000000 #!/usr/bin/perl
use strict;
use warnings;
our $VERSION = 'v3.8.1'; # Check https://beyondgrep.com/ for updates
use 5.010001;
use File::Spec ();
use File::Next ();
use Getopt::Long ();
use App::Ack ();
use App::Ack::ConfigLoader ();
use App::Ack::File ();
use App::Ack::Files ();
use App::Ack::Filter ();
use App::Ack::Filter::Default ();
use App::Ack::Filter::Extension ();
use App::Ack::Filter::FirstLineMatch ();
use App::Ack::Filter::Inverse ();
use App::Ack::Filter::Is ();
use App::Ack::Filter::IsPath ();
use App::Ack::Filter::Match ();
use App::Ack::Filter::Collection ();
# Global command-line options
our $opt_1;
our $opt_A;
our $opt_B;
our $opt_break;
our $opt_color;
our $opt_column;
our $opt_debug;
our $opt_c;
our $opt_f;
our $opt_g;
our $opt_heading;
our $opt_L;
our $opt_l;
our $opt_m;
our $opt_output;
our $opt_passthru;
our $opt_p;
our $opt_range_start;
our $opt_range_end;
our $opt_regex;
our $opt_show_filename;
our $opt_show_types;
our $opt_underline;
our $opt_v;
# Flag if we need any context tracking.
our $is_tracking_context;
# The regex that we use to match each line in the file.
our $re_match;
# Regex for matching for highlighting in matched lines.
our $re_hilite;
# The regex that matches for things we want to exclude via the --not option.
our $re_not;
# Version of the match regex for checking to see if the file should be scanned line-by-line.
our $re_scan;
our @special_vars_used_by_opt_output;
our $using_ranges;
# Internal stats for debugging.
our %stats;
MAIN: {
$App::Ack::ORIGINAL_PROGRAM_NAME = $0;
$0 = join(' ', 'ack', $0);
$App::Ack::ors = "\n";
if ( $App::Ack::VERSION ne $main::VERSION ) {
App::Ack::die( "Program/library version mismatch\n\t$0 is $main::VERSION\n\t$INC{'App/Ack.pm'} is $App::Ack::VERSION" );
}
# Do preliminary arg checking;
my $env_is_usable = 1;
for my $arg ( @ARGV ) {
last if ( $arg eq '--' );
# Get the --thpppt, --bar, --cathy and --man checking out of the way.
$arg =~ /^--th[pt]+t+$/ and App::Ack::thpppt($arg);
$arg eq '--bar' and App::Ack::ackbar();
$arg eq '--cathy' and App::Ack::cathy();
# See if we want to ignore the environment. (Don't tell Al Gore.)
$arg eq '--env' and $env_is_usable = 1;
$arg eq '--noenv' and $env_is_usable = 0;
}
if ( $env_is_usable ) {
if ( $ENV{ACK_OPTIONS} ) {
App::Ack::warn( 'WARNING: ack no longer uses the ACK_OPTIONS environment variable. Use an ackrc file instead.' );
}
}
else {
my @keys = ( 'ACKRC', grep { /^ACK_/ } keys %ENV );
delete @ENV{@keys};
}
# Load colors
my $modules_loaded_ok = eval 'use Term::ANSIColor 1.10 (); 1;';
if ( $modules_loaded_ok && $App::Ack::is_windows ) {
$modules_loaded_ok = eval 'use Win32::Console::ANSI; 1;';
}
if ( $modules_loaded_ok ) {
$ENV{ACK_COLOR_MATCH} ||= 'black on_yellow';
$ENV{ACK_COLOR_FILENAME} ||= 'bold green';
$ENV{ACK_COLOR_LINENO} ||= 'bold yellow';
$ENV{ACK_COLOR_COLNO} ||= 'bold yellow';
}
App::Ack::ConfigLoader::configure_parser( 'no_auto_abbrev', 'pass_through' );
Getopt::Long::GetOptions(
help => sub { App::Ack::show_help(); exit; },
version => sub { App::Ack::print( App::Ack::get_version_statement() ); exit; },
man => sub { App::Ack::show_man(); },
);
if ( !@ARGV ) {
App::Ack::show_help();
exit 1;
}
my @arg_sources = App::Ack::ConfigLoader::retrieve_arg_sources();
my $opt = App::Ack::ConfigLoader::process_args( @arg_sources );
$opt_1 = $opt->{1};
$opt_A = $opt->{A};
$opt_B = $opt->{B};
$opt_break = $opt->{break};
$opt_c = $opt->{c};
$opt_color = $opt->{color};
$opt_column = $opt->{column};
$opt_debug = $opt->{debug};
$opt_f = $opt->{f};
$opt_g = $opt->{g};
$opt_heading = $opt->{heading};
$opt_L = $opt->{L};
$opt_l = $opt->{l};
$opt_m = $opt->{m};
$opt_output = $opt->{output};
$opt_p = $opt->{p};
$opt_passthru = $opt->{passthru};
$opt_range_start = $opt->{range_start};
$opt_range_end = $opt->{range_end};
$opt_regex = $opt->{regex};
$opt_show_filename = $opt->{show_filename};
$opt_show_types = $opt->{show_types};
$opt_underline = $opt->{underline};
$opt_v = $opt->{v};
if ( $opt_show_types && not( $opt_f || $opt_g ) ) {
App::Ack::die( '--show-types can only be used with -f or -g.' );
}
if ( $opt_range_start ) {
($opt_range_start, undef) = App::Ack::build_regex( $opt_range_start, {} );
}
if ( $opt_range_end ) {
($opt_range_end, undef) = App::Ack::build_regex( $opt_range_end, {} );
}
$using_ranges = $opt_range_start || $opt_range_end;
$App::Ack::report_bad_filenames = !$opt->{s};
$App::Ack::ors = $opt->{print0} ? "\0" : "\n";
if ( !defined($opt_color) && !$opt_g ) {
my $windows_color = 1;
if ( $App::Ack::is_windows ) {
$windows_color = eval { require Win32::Console::ANSI; };
}
$opt_color = !App::Ack::output_to_pipe() && $windows_color;
}
$opt_heading //= !App::Ack::output_to_pipe();
$opt_break //= !App::Ack::output_to_pipe();
if ( defined($opt->{H}) || defined($opt->{h}) ) {
$opt_show_filename = $opt->{show_filename} = $opt->{H} && !$opt->{h};
}
if ( defined $opt_output ) {
# Expand out \t, \n and \r.
$opt_output =~ s/\\n/\n/g;
$opt_output =~ s/\\r/\r/g;
$opt_output =~ s/\\t/\t/g;
my @supported_special_variables = ( 1..9, qw( _ . ` & ' + f ) );
@special_vars_used_by_opt_output = grep { $opt_output =~ /\$$_/ } @supported_special_variables;
# If the $opt_output contains $&, $` or $', those vars won't be
# captured until they're used at least once in the program.
# Do the eval to make this happen.
for my $i ( @special_vars_used_by_opt_output ) {
if ( $i eq q{&} || $i eq q{'} || $i eq q{`} ) {
no warnings; # They will be undef, so don't warn.
eval qq{"\$$i"}; ## no critic ( ErrorHandling::RequireCheckingReturnValueOfEval )
}
}
}
# Set up file filters.
my $files;
if ( $App::Ack::is_filter_mode && !$opt->{files_from} ) { # probably -x
$files = App::Ack::Files->from_stdin();
$opt_regex //= shift @ARGV;
defined $opt_regex or App::Ack::die( 'No regular expression found.' );
($re_match, $re_not, $re_hilite, $re_scan) = App::Ack::build_all_regexes( $opt_regex, $opt );
$stats{re_match} = $re_match;
$stats{re_not} = $re_not;
$stats{re_hilite} = $re_hilite;
$stats{re_scan} = $re_scan;
}
else {
if ( $opt_f ) {
# No need to check for regex, since mutex options are handled elsewhere.
}
else {
$opt_regex //= shift @ARGV;
defined $opt_regex or App::Ack::die( 'No regular expression found.' );
($re_match, $re_not, $re_hilite, $re_scan) = App::Ack::build_all_regexes( $opt_regex, $opt );
$stats{re_match} = $re_match;
$stats{re_not} = $re_not;
$stats{re_hilite} = $re_hilite;
$stats{re_scan} = $re_scan;
}
my @start;
if ( not defined $opt->{files_from} ) {
@start = @ARGV;
}
if ( !exists($opt->{show_filename}) ) {
unless(@start == 1 && !(-d $start[0])) {
$opt_show_filename = $opt->{show_filename} = 1;
}
}
if ( defined $opt->{files_from} ) {
$files = App::Ack::Files->from_file( $opt, $opt->{files_from} );
exit 1 unless $files;
}
else {
@start = ('.') unless @start;
foreach my $target (@start) {
if ( !-e $target && $App::Ack::report_bad_filenames) {
App::Ack::warn( "$target: No such file or directory" );
}
}
$opt->{file_filter} = _compile_file_filter($opt, \@start);
$opt->{descend_filter} = _compile_descend_filter($opt);
$files = App::Ack::Files->from_argv( $opt, \@start );
}
}
App::Ack::set_up_pager( $opt->{pager} ) if defined $opt->{pager};
my $nmatches;
if ( $opt_f || $opt_g ) {
$nmatches = file_loop_fg( $files );
}
elsif ( $opt_c ) {
$nmatches = file_loop_c( $files );
}
elsif ( $opt_l || $opt_L ) {
$nmatches = file_loop_lL( $files );
}
else {
$nmatches = file_loop_normal( $files );
}
if ( $opt_debug ) {
require List::Util;
my @stats = qw( re_match re_scan re_not prescans linescans filematches linematches );
my $width = List::Util::max( map { length } @stats );
for my $stat ( @stats ) {
App::Ack::warn( sprintf( '%-*.*s = %s', $width, $width, $stat, $stats{$stat} // 'undef' ) );
}
}
close $App::Ack::fh;
App::Ack::exit_from_ack( $nmatches );
} # End of MAIN
exit 0;
sub file_loop_fg {
my $files = shift;
my $nmatches = 0;
while ( defined( my $file = $files->next ) ) {
if ( $opt_show_types ) {
App::Ack::show_types( $file );
}
elsif ( $opt_g ) {
print_line_with_options( undef, $file->name, 0, $App::Ack::ors );
}
else {
App::Ack::say( $file->name );
}
++$nmatches;
last if defined($opt_m) && ($nmatches >= $opt_m);
}
return $nmatches;
}
sub file_loop_c {
my $files = shift;
my $total_count = 0;
while ( defined( my $file = $files->next ) ) {
my $matches_for_this_file = count_matches_in_file( $file );
if ( not $opt_show_filename ) {
$total_count += $matches_for_this_file;
next;
}
if ( !$opt_l || $matches_for_this_file > 0 ) {
if ( $opt_show_filename ) {
my $display_filename = $file->name;
if ( $opt_color ) {
$display_filename = Term::ANSIColor::colored($display_filename, $ENV{ACK_COLOR_FILENAME});
}
App::Ack::say( $display_filename, ':', $matches_for_this_file );
}
else {
App::Ack::say( $matches_for_this_file );
}
}
}
if ( !$opt_show_filename ) {
App::Ack::say( $total_count );
}
return;
}
sub file_loop_lL {
my $files = shift;
my $nmatches = 0;
while ( defined( my $file = $files->next ) ) {
my $is_match = count_matches_in_file( $file, 1 );
if ( $opt_L ? !$is_match : $is_match ) {
App::Ack::say( $file->name );
++$nmatches;
last if $opt_1;
last if defined($opt_m) && ($nmatches >= $opt_m);
}
}
return $nmatches;
}
sub _compile_descend_filter {
my ( $opt ) = @_;
my $idirs = 0;
my $dont_ignore_dirs = 0;
for my $filter (@{$opt->{idirs} || []}) {
if ($filter->is_inverted()) {
$dont_ignore_dirs++;
}
else {
$idirs++;
}
}
# If we have one or more --noignore-dir directives, we can't ignore
# entire subdirectory hierarchies, so we return an "accept all"
# filter and scrutinize the files more in _compile_file_filter.
return if $dont_ignore_dirs;
return unless $idirs;
$idirs = $opt->{idirs};
return sub {
my $file = App::Ack::File->new($File::Next::dir);
return !grep { $_->filter($file) } @{$idirs};
};
}
sub _compile_file_filter {
my ( $opt, $start ) = @_;
my $ifiles_filters = $opt->{ifiles};
my $filters = $opt->{'filters'} || [];
my $direct_filters = App::Ack::Filter::Collection->new();
my $inverse_filters = App::Ack::Filter::Collection->new();
foreach my $filter (@{$filters}) {
if ($filter->is_inverted()) {
# We want to check if files match the uninverted filters
$inverse_filters->add($filter->invert());
}
else {
$direct_filters->add($filter);
}
}
my %is_member_of_starting_set = map { (get_file_id($_) => 1) } @{$start};
my @ignore_dir_filter = @{$opt->{idirs} || []};
my @is_inverted = map { $_->is_inverted() } @ignore_dir_filter;
# This depends on InverseFilter->invert returning the original filter (for optimization).
@ignore_dir_filter = map { $_->is_inverted() ? $_->invert() : $_ } @ignore_dir_filter;
my $dont_ignore_dir_filter = grep { $_ } @is_inverted;
my $previous_dir = '';
my $previous_dir_ignore_result;
return sub {
if ( $opt_g ) {
if ( $File::Next::name =~ /$re_match/o ) {
return 0 if $opt_v;
}
else {
return 0 if !$opt_v;
}
}
# ack always selects files that are specified on the command
# line, regardless of filetype. If you want to ack a JPEG,
# and say "ack foo whatever.jpg" it will do it for you.
return 1 if $is_member_of_starting_set{ get_file_id($File::Next::name) };
if ( $dont_ignore_dir_filter ) {
if ( $previous_dir eq $File::Next::dir ) {
if ( $previous_dir_ignore_result ) {
return 0;
}
}
else {
my @dirs = File::Spec->splitdir($File::Next::dir);
my $is_ignoring;
for ( my $i = 0; $i < @dirs; $i++) {
my $dir_rsrc = App::Ack::File->new(File::Spec->catfile(@dirs[0 .. $i]));
my $j = 0;
for my $filter (@ignore_dir_filter) {
if ( $filter->filter($dir_rsrc) ) {
$is_ignoring = !$is_inverted[$j];
}
$j++;
}
}
$previous_dir = $File::Next::dir;
$previous_dir_ignore_result = $is_ignoring;
if ( $is_ignoring ) {
return 0;
}
}
}
# Ignore named pipes found in directory searching. Named
# pipes created by subprocesses get specified on the command
# line, so the rule of "always select whatever is on the
# command line" wins.
return 0 if -p $File::Next::name;
# We can't handle unreadable filenames; report them.
if ( not -r _ ) {
use filetest 'access';
if ( not -R $File::Next::name ) {
if ( $App::Ack::report_bad_filenames ) {
App::Ack::warn( "${File::Next::name}: cannot open file for reading" );
}
return 0;
}
}
my $file = App::Ack::File->new($File::Next::name);
if ( $ifiles_filters && $ifiles_filters->filter($file) ) {
return 0;
}
my $match_found = $direct_filters->filter($file);
# Don't bother invoking inverse filters unless we consider the current file a match.
if ( $match_found && $inverse_filters->filter( $file ) ) {
$match_found = 0;
}
return $match_found;
}; # End of compiled sub
}
# Returns a (fairly) unique identifier for a file.
# Use this function to compare two files to see if they're
# equal (ie. the same file, but with a different path/links/etc).
sub get_file_id {
my ( $filename ) = @_;
if ( $App::Ack::is_windows ) {
return File::Next::reslash( $filename );
}
else {
# XXX Is this the best method? It always hits the FS.
if ( my ( $dev, $inode ) = (stat($filename))[0, 1] ) {
return join(':', $dev, $inode);
}
else {
# XXX This could be better.
return $filename;
}
}
}
my $match_colno;
{
# Number of context lines
my $n_before_ctx_lines;
my $n_after_ctx_lines;
# Array to keep track of lines that might be required for a "before" context
my @before_context_buf;
# Position to insert next line in @before_context_buf
my $before_context_pos;
# Number of "after" context lines still pending
my $after_context_pending;
# Number of latest line that got printed
my $printed_lineno;
my $is_first_match;
state $has_printed_from_any_file;
sub file_loop_normal {
my $files = shift;
$n_before_ctx_lines = $opt_output ? 0 : ($opt_B || 0);
$n_after_ctx_lines = $opt_output ? 0 : ($opt_A || 0);
@before_context_buf = (undef) x $n_before_ctx_lines;
$before_context_pos = 0;
$is_tracking_context = $n_before_ctx_lines || $n_after_ctx_lines;
$is_first_match = 1;
my $nmatches = 0;
while ( defined( my $file = $files->next ) ) {
if ($is_tracking_context) {
$printed_lineno = 0;
$after_context_pending = 0;
if ( $opt_heading ) {
$is_first_match = 1;
}
}
my $needs_line_scan = 1;
if ( !$opt_passthru && !$opt_v ) {
$stats{prescans}++;
if ( $file->may_be_present( $re_scan ) ) {
$file->reset();
}
else {
$needs_line_scan = 0;
}
}
if ( $needs_line_scan ) {
$stats{linescans}++;
$nmatches += print_matches_in_file( $file );
}
last if $opt_1 && $nmatches;
}
return $nmatches;
}
sub print_matches_in_file {
my $file = shift;
my $filename = $file->name;
my $fh = $file->open;
if ( !$fh ) {
if ( $App::Ack::report_bad_filenames ) {
App::Ack::warn( "$filename: $!" );
}
return 0;
}
my $display_filename = $filename;
if ( $opt_show_filename && $opt_heading && $opt_color ) {
$display_filename = Term::ANSIColor::colored($display_filename, $ENV{ACK_COLOR_FILENAME});
}
# Check for context before the main loop, so we don't pay for it if we don't need it.
my $nmatches;
my $max_count = $opt_m || -1; # Go negative for no limit so it can never reduce to 0.
if ( $is_tracking_context ) {
$nmatches = pmif_context( $fh, $filename, $display_filename, $max_count );
}
elsif ( $opt_passthru ) {
$nmatches = pmif_passthru( $fh, $filename, $display_filename, $max_count );
}
elsif ( $opt_v ) {
$nmatches = pmif_opt_v( $fh, $filename, $display_filename, $max_count );
}
else {
$nmatches = pmif_normal( $fh, $filename, $display_filename, $max_count );
}
return $nmatches;
}
sub pmif_context {
my $fh = shift;
my $filename = shift;
my $display_filename = shift;
my $max_count = shift;
my $in_range = range_setup();
my $has_printed_from_this_file;
my $nmatches = 0;
$after_context_pending = 0;
local $_ = undef;
while ( <$fh> ) {
chomp;
$match_colno = undef;
$in_range = 1 if ( $using_ranges && !$in_range && defined($opt_range_start) && /$opt_range_start/o );
my $does_match;
if ( $in_range ) {
$does_match = /$re_match/o;
if ( $does_match && defined($re_not) ) {
local @-;
$does_match = !/$re_not/o;
}
if ( $opt_v ) {
$does_match = !$does_match;
}
else {
if ( $does_match ) {
# @- = @LAST_MATCH_START
$match_colno = $-[0] + 1;
}
}
}
if ( $does_match && $max_count ) {
if ( !$has_printed_from_this_file ) {
$stats{filematches}++;
if ( $opt_break && $has_printed_from_any_file ) {
App::Ack::print_blank_line();
}
if ( $opt_show_filename && $opt_heading ) {
App::Ack::say( $display_filename );
}
}
print_line_with_context( $filename, $_, $. );
$has_printed_from_this_file = 1;
$stats{linematches}++;
$nmatches++;
$max_count--;
}
else {
if ( $after_context_pending ) {
# Disable $opt_column since there are no matches in the context lines.
local $opt_column = 0;
print_line_with_options( $filename, $_, $., '-' );
--$after_context_pending;
}
elsif ( $n_before_ctx_lines ) {
# Save line for "before" context.
$before_context_buf[$before_context_pos] = $_;
$before_context_pos = ($before_context_pos+1) % $n_before_ctx_lines;
}
}
$in_range = 0 if ( $using_ranges && $in_range && defined($opt_range_end) && /$opt_range_end/o );
last if ($max_count == 0) && ($after_context_pending == 0);
}
return $nmatches;
}
sub pmif_passthru {
my $fh = shift;
my $filename = shift;
my $display_filename = shift;
my $max_count = shift;
my $in_range = range_setup();
my $has_printed_from_this_file;
my $nmatches = 0;
local $_ = undef;
while ( <$fh> ) {
chomp;
$in_range = 1 if ( $using_ranges && !$in_range && defined($opt_range_start) && /$opt_range_start/o );
$match_colno = undef;
my $does_match = /$re_match/o;
if ( $does_match && defined($re_not) ) {
local @-;
$does_match = !/$re_not/o;
}
if ( $in_range && $does_match ) {
$match_colno = $-[0] + 1;
if ( !$has_printed_from_this_file ) {
if ( $opt_break && $has_printed_from_any_file ) {
App::Ack::print_blank_line();
}
if ( $opt_show_filename && $opt_heading ) {
App::Ack::say( $display_filename );
}
}
print_line_with_options( $filename, $_, $., ':' );
$has_printed_from_this_file = 1;
$nmatches++;
$max_count--;
}
else {
if ( $opt_break && !$has_printed_from_this_file && $has_printed_from_any_file ) {
App::Ack::print_blank_line();
}
print_line_with_options( $filename, $_, $., '-', 1 );
$has_printed_from_this_file = 1;
}
$in_range = 0 if ( $using_ranges && $in_range && defined($opt_range_end) && /$opt_range_end/o );
last if $max_count == 0;
}
return $nmatches;
}
sub pmif_opt_v {
my $fh = shift;
my $filename = shift;
my $display_filename = shift;
my $max_count = shift;
my $in_range = range_setup();
my $has_printed_from_this_file;
my $nmatches = 0;
$match_colno = undef;
local $_ = undef;
while ( <$fh> ) {
chomp;
$in_range = 1 if ( $using_ranges && !$in_range && defined($opt_range_start) && /$opt_range_start/o );
if ( $in_range ) {
my $does_match = /$re_match/o;
if ( $does_match && defined($re_not) ) {
# local @-; No need to localize this because we don't use @-.
$does_match = !/$re_not/o;
}
if ( !$does_match ) {
if ( !$has_printed_from_this_file ) {
if ( $opt_break && $has_printed_from_any_file ) {
App::Ack::print_blank_line();
}
if ( $opt_show_filename && $opt_heading ) {
App::Ack::say( $display_filename );
}
}
print_line_with_context( $filename, $_, $. );
$has_printed_from_this_file = 1;
$nmatches++;
$max_count--;
}
}
$in_range = 0 if ( $using_ranges && $in_range && defined($opt_range_end) && /$opt_range_end/o );
last if $max_count == 0;
}
return $nmatches;
}
sub pmif_normal {
my $fh = shift;
my $filename = shift;
my $display_filename = shift;
my $max_count = shift;
my $in_range = range_setup();
my $has_printed_from_this_file;
my $nmatches = 0;
my $last_match_lineno;
local $_ = undef;
while ( <$fh> ) {
chomp;
$in_range = 1 if ( $using_ranges && !$in_range && defined($opt_range_start) && /$opt_range_start/o );
if ( $in_range ) {
$match_colno = undef;
my $is_match = /$re_match/o;
if ( $is_match && defined($re_not) ) {
local @-;
$is_match = !/$re_not/o;
}
if ( $is_match ) {
$match_colno = $-[0] + 1;
if ( !$has_printed_from_this_file ) {
$stats{filematches}++;
if ( $opt_break && $has_printed_from_any_file ) {
App::Ack::print_blank_line();
}
if ( $opt_show_filename && $opt_heading ) {
App::Ack::say( $display_filename );
}
}
if ( $opt_p ) {
if ( $last_match_lineno ) {
if ( $. > $last_match_lineno + $opt_p ) {
App::Ack::print_blank_line();
}
}
elsif ( !$opt_break && $has_printed_from_any_file ) {
App::Ack::print_blank_line();
}
}
s/[\r\n]+$//;
print_line_with_options( $filename, $_, $., ':' );
$has_printed_from_this_file = 1;
$nmatches++;
$stats{linematches}++;
$max_count--;
$last_match_lineno = $.;
}
}
$in_range = 0 if ( $using_ranges && $in_range && defined($opt_range_end) && /$opt_range_end/o );
last if $max_count == 0;
}
return $nmatches;
}
sub print_line_with_options {
my ( $filename, $line, $lineno, $separator, $skip_coloring ) = @_;
$has_printed_from_any_file = 1;
$printed_lineno = $lineno;
my @line_parts;
if ( $opt_show_filename && defined($filename) ) {
my $colno;
$colno = get_match_colno() if $opt_column;
if ( $opt_color ) {
$filename = Term::ANSIColor::colored( $filename, $ENV{ACK_COLOR_FILENAME} );
$lineno = Term::ANSIColor::colored( $lineno, $ENV{ACK_COLOR_LINENO} );
$colno = Term::ANSIColor::colored( $colno, $ENV{ACK_COLOR_COLNO} ) if $opt_column;
}
if ( $opt_heading ) {
push @line_parts, $lineno;
}
else {
push @line_parts, $filename, $lineno;
}
push @line_parts, $colno if $opt_column;
}
if ( $opt_output ) {
while ( $line =~ /$re_match/og ) {
my $output = $opt_output;
if ( @special_vars_used_by_opt_output ) {
no strict;
# Stash copies of the special variables because we can't rely
# on them not changing in the process of doing the s///.
my %keep = map { ($_ => ${$_} // '') } @special_vars_used_by_opt_output;
$keep{_} = $line if exists $keep{_}; # Manually set it because $_ gets reset in a map.
$keep{f} = $filename if exists $keep{f};
my $special_vars_used_by_opt_output = join( '', @special_vars_used_by_opt_output );
$output =~ s/\$([$special_vars_used_by_opt_output])/$keep{$1}/ego;
}
App::Ack::say( join( $separator, @line_parts, $output ) );
}
}
else {
my $underline = '';
# We have to do underlining before any highlighting because highlighting modifies string length.
if ( $opt_underline && !$skip_coloring ) {
while ( $line =~ /$re_hilite/og ) {
my $match_start = $-[0] // next;
my $match_end = $+[0];
my $match_length = $match_end - $match_start;
last if $match_length <= 0;
my $spaces_needed = $match_start - length $underline;
$underline .= (' ' x $spaces_needed);
$underline .= ('^' x $match_length);
}
}
if ( $opt_color && !$skip_coloring ) {
my $highlighted = 0; # If highlighted, need to escape afterwards.
while ( $line =~ /$re_hilite/og ) {
my $match_start = $-[0] // next;
my $match_end = $+[0];
my $match_length = $match_end - $match_start;
last if $match_length <= 0;
my $substring = substr( $line, $match_start, $match_length );
my $substitution = Term::ANSIColor::colored( $substring, $ENV{ACK_COLOR_MATCH} );
# Fourth argument replaces the string specified by the first three.
substr( $line, $match_start, $match_length, $substitution );
# Move the offset of where /g left off forward the number of spaces of highlighting.
pos($line) = $match_end + (length( $substitution ) - length( $substring ));
$highlighted = 1;
}
# Reset formatting and delete everything to the end of the line.
$line .= "\e[0m\e[K" if $highlighted;
}
push @line_parts, $line;
App::Ack::say( join( $separator, @line_parts ) );
# Print the underline, if appropriate.
if ( $underline ne '' ) {
# Figure out how many spaces are used per line for the ANSI coloring.
state $chars_used_by_coloring;
if ( !defined($chars_used_by_coloring) ) {
$chars_used_by_coloring = 0;
if ( $opt_color ) {
my $len_fn = sub { length( Term::ANSIColor::colored( 'x', $ENV{$_[0]} ) ) - 1 };
$chars_used_by_coloring += $len_fn->('ACK_COLOR_FILENAME') unless $opt_heading;
$chars_used_by_coloring += $len_fn->('ACK_COLOR_LINENO');
$chars_used_by_coloring += $len_fn->('ACK_COLOR_COLNO') if $opt_column;
}
}
pop @line_parts; # Leave only the stuff on the left.
if ( @line_parts ) {
my $stuff_on_the_left = join( $separator, @line_parts );
my $spaces_needed = length($stuff_on_the_left) - $chars_used_by_coloring + 1;
App::Ack::print( ' ' x $spaces_needed );
}
App::Ack::say( $underline );
}
}
return;
}
sub print_line_with_context {
my ( $filename, $matching_line, $lineno ) = @_;
$matching_line =~ s/[\r\n]+$//;
# Check if we need to print context lines first.
if ( $opt_A || $opt_B ) {
my $before_unprinted = $lineno - $printed_lineno - 1;
if ( !$is_first_match && ( !$printed_lineno || $before_unprinted > $n_before_ctx_lines ) ) {
App::Ack::say( '--' );
}
# We want at most $n_before_ctx_lines of context.
if ( $before_unprinted > $n_before_ctx_lines ) {
$before_unprinted = $n_before_ctx_lines;
}
while ( $before_unprinted > 0 ) {
my $line = $before_context_buf[($before_context_pos - $before_unprinted + $n_before_ctx_lines) % $n_before_ctx_lines];
chomp $line;
# Disable $opt->{column} since there are no matches in the context lines.
local $opt_column = 0;
print_line_with_options( $filename, $line, $lineno-$before_unprinted, '-' );
$before_unprinted--;
}
}
print_line_with_options( $filename, $matching_line, $lineno, ':' );
# We want to get the next $n_after_ctx_lines printed.
$after_context_pending = $n_after_ctx_lines;
$is_first_match = 0;
return;
}
}
sub get_match_colno {
return $match_colno;
}
sub count_matches_in_file {
my $file = shift;
my $bail = shift; # True if we're just checking for existence.
my $nmatches = 0;
my $do_scan = 1;
if ( !$file->open() ) {
$do_scan = 0;
if ( $App::Ack::report_bad_filenames ) {
App::Ack::warn( $file->name . ": $!" );
}
}
else {
if ( !$opt_v ) {
if ( !$file->may_be_present( $re_scan ) ) {
$do_scan = 0;
}
}
}
if ( $do_scan ) {
$file->reset();
my $in_range = range_setup();
my $fh = $file->{fh};
if ( $using_ranges ) {
while ( <$fh> ) {
chomp;
$in_range = 1 if ( !$in_range && defined($opt_range_start) && /$opt_range_start/o );
if ( $in_range ) {
my $is_match = /$re_match/o;
if ( $is_match && defined($re_not) ) {
$is_match = !/$re_not/o;
}
if ( $is_match xor $opt_v ) {
++$nmatches;
last if $bail;
}
}
$in_range = 0 if ( $in_range && defined($opt_range_end) && /$opt_range_end/o );
}
}
else {
while ( <$fh> ) {
chomp;
my $is_match = /$re_match/o;
if ( $is_match && defined($re_not) ) {
$is_match = !/$re_not/o;
}
if ( $is_match xor $opt_v ) {
++$nmatches;
last if $bail;
}
}
}
}
$file->close;
return $nmatches;
}
sub range_setup {
return !$using_ranges || (!$opt_range_start && $opt_range_end);
}
=pod
=encoding UTF-8
=head1 NAME
ack - grep-like text finder
=head1 SYNOPSIS
ack [options] PATTERN [FILE...]
ack -f [options] [DIRECTORY...]
=head1 DESCRIPTION
ack is designed as an alternative to F for programmers.
ack searches the named input FILEs or DIRECTORYs for lines containing a
match to the given PATTERN. By default, ack prints the matching lines.
If no FILE or DIRECTORY is given, the current directory will be searched.
PATTERN is a Perl regular expression. Perl regular expressions
are commonly found in other programming languages, but for the particulars
of their behavior, please consult
L. If you don't know
how to use regular expression but are interested in learning, you may
consult L. If you do not
need or want ack to use regular expressions, please see the
C<-Q>/C<--literal> option.
Ack can also list files that would be searched, without actually
searching them, to let you take advantage of ack's file-type filtering
capabilities.
=head1 FILE SELECTION
If files are not specified for searching, either on the command
line or piped in with the C<-x> option, I delves into
subdirectories selecting files for searching.
I is intelligent about the files it searches. It knows about
certain file types, based on both the extension on the file and,
in some cases, the contents of the file. These selections can be
made with the B<--type> option.
With no file selection, I searches through regular files that
are not explicitly excluded by B<--ignore-dir> and B<--ignore-file>
options, either present in F files or on the command line.
The default options for I ignore certain files and directories. These
include:
=over 4
=item * Backup files: Files matching F<#*#> or ending with F<~>.
=item * Coredumps: Files matching F
=item * Version control directories like F<.svn> and F<.git>.
=back
Run I with the C<--dump> option to see what settings are set.
However, I always searches the files given on the command line,
no matter what type. If you tell I to search in a coredump,
it will search in a coredump.
=head1 DIRECTORY SELECTION
I descends through the directory tree of the starting directories
specified. If no directories are specified, the current working directory is
used. However, it will ignore the shadow directories used by
many version control systems, and the build directories used by the
Perl MakeMaker system. You may add or remove a directory from this
list with the B<--[no]ignore-dir> option. The option may be repeated
to add/remove multiple directories from the ignore list.
For a complete list of directories that do not get searched, run
C.
=head1 MATCHING IN A RANGE OF LINES
The C<--range-start> and C<--range-end> options let you specify ranges of
lines to search within each file.
Say you had the following file, called F:
# This function calls print on "foo".
sub foo {
print 'foo';
}
my $print = 1;
sub bar {
print 'bar';
}
my $task = 'print';
Calling C will give us five matches:
$ ack print testfile
# This function calls print on "foo".
print 'foo';
my $print = 1;
print 'bar';
my $task = 'print';
What if we only want to search for C within the subroutines? We can
specify ranges of lines that we want ack to search. The range starts with
any line that matches the pattern C<^sub \w+>, and stops with any line that
matches C<^}>.
$ ack --range-start='^sub \w+' --range-end='^}' print testfile
print 'foo';
print 'bar';
Note that ack searched two ranges of lines. The listing below shows which
lines were in a range and which were out of the range.
Out # This function calls print on "foo".
In sub foo {
In print 'foo';
In }
Out my $print = 1;
In sub bar {
In print 'bar';
In }
Out my $task = 'print';
You don't have to specify both C<--range-start> and C<--range-end>. IF
C<--range-start> is omitted, then the range runs from the first line in the
file until the first line that matches C<--range-end>. Similarly, if
C<--range-end> is omitted, the range runs from the first line matching
C<--range-start> to the end of the file.
For example, if you wanted to search all HTML files up until the first
instance of the C<< >>, you could do
ack foo --html --range-end=''
Or to search after Perl's `__DATA__` or `__END__` markers, you would do
ack pattern --perl --range-start='^__(END|DATA)__'
It's possible for a range to start and stop on the same line. For example
--range-start='' --range-end=''
would match this line as both the start and end of the range, making a
one-line range.
Page title
Note that the patterns in C<--range-start> and C<--range-end> are not
affected by options like C<-i>, C<-w> and C<-Q> that modify the behavior of
the main pattern being matched.
Again, ranges only affect where matches are looked for. Everything else in
ack works the same way. Using C<-c> option with a range will give a count
of all the matches that appear within those ranges. The C<-l> shows those
files that have a match within a range, and the C<-L> option shows files
that do not have a match within a range.
The C<-v> option for negating a match works inside the range, too.
To see lines that don't match "google" within the "" section of
your HTML files, you could do:
ack google -v --html --range-start=''
Specifying a range to search does not affect how matches are displayed.
The context for a match will still be the same, and
Using the context options work the same way, and will show context
lines for matches even if the context lines fall outside the range.
Similarly, C<--passthru> will show all lines in the file, but only show
matches for lines within the range.
=head1 OPTIONS
=over 4
=item B<--ackrc>
Specifies an ackrc file to load after all others; see L"ACKRC LOCATION SEMANTICS">.
=item B<--and=PATTERN>
Specifies a I that MUST ALSO be found on a given line for a match to
occur. This option can be repeated.
If you want to find all the lines with both "dogs" or "cats", use:
ack dogs --and cats
Note that the options that affect "dogs" also affect "cats", so if you have
ack -i -w dogs --and cats
then the search for both "dogs" and "cats" will be case-insensitive and be
word-limited.
See also the other two boolean options C<--or> and C<--not>, neither of
which can be used with C<--and>.
=item B<-A I>, B<--after-context=I>
Print I lines of trailing context after matching lines.
=item B<-B I>, B<--before-context=I>
Print I lines of leading context before matching lines.
=item B<--[no]break>
Print a break between results from different files. On by default
when used interactively.
=item B<-C [I]>, B<--context[=I]>
Print I lines (default 2) of context around matching lines.
You can specify zero lines of context to override another context
specified in an ackrc.
=item B<-c>, B<--count>
Suppress normal output; instead print a count of matching lines for
each input file. If B<-l> is in effect, it will only show the
number of lines for each file that has lines matching. Without
B<-l>, some line counts may be zeroes.
If combined with B<-h> (B<--no-filename>) ack outputs only one total
count.
=item B<--[no]color>, B<--[no]colour>
B<--color> highlights the matching text. B<--nocolor> suppresses
the color. This is on by default unless the output is redirected.
On Windows, this option is off by default unless the
L module is installed or the C
environment variable is used.
=item B<--color-filename=I>
Sets the color to be used for filenames.
=item B<--color-match=I>
Sets the color to be used for matches.
=item B<--color-colno=I>
Sets the color to be used for column numbers.
=item B<--color-lineno=I>
Sets the color to be used for line numbers.
=item B<--[no]column>
Show the column number of the first match. This is helpful for
editors that can place your cursor at a given position.
=item B<--create-ackrc>
Dumps the default ack options to standard output. This is useful for
when you want to customize the defaults.
=item B<--dump>
Writes the list of options loaded and where they came from to standard
output. Handy for debugging.
=item B<--[no]env>
B<--noenv> disables all environment processing. No F<.ackrc> is
read and all environment variables are ignored. By default, F
considers F<.ackrc> and settings in the environment.
=item B<--flush>
B<--flush> flushes output immediately. This is off by default
unless ack is running interactively (when output goes to a pipe or
file).
=item B<-f>
Only print the files that would be searched, without actually doing
any searching. PATTERN must not be specified, or it will be taken
as a path to search.
=item B<--files-from=I>
The list of files to be searched is specified in I. The list of
files are separated by newlines. If I is C<->, the list is loaded
from standard input.
Note that the list of files is B filtered in any way. If you
add C<--type=html> in addition to C<--files-from>, the C<--type> will
be ignored.
=item B<--[no]filter>
Forces ack to act as if it were receiving input via a pipe.
=item B<--[no]follow>
Follow or don't follow symlinks, other than whatever starting files
or directories were specified on the command line.
This is off by default.
=item B<-g I>
Print searchable files where the relative path + filename matches
I.
Note that
ack -g foo
is exactly the same as
ack -f | ack foo
This means that just as ack will not search, for example, F<.jpg>
files, C<-g> will not list F<.jpg> files either. ack is not intended
to be a general-purpose file finder.
Note also that if you have C<-i> in your .ackrc that the filenames
to be matched will be case-insensitive as well.
This option can be combined with B<--color> to make it easier to
spot the match.
=item B<--[no]group>
B<--group> groups matches by file name. This is the default
when used interactively.
B<--nogroup> prints one result per line, like grep. This is the
default when output is redirected.
=item B<-H>, B<--with-filename>
Print the filename for each match. This is the default unless searching
a single explicitly specified file.
=item B<-h>, B<--no-filename>
Suppress the prefixing of filenames on output when multiple files are
searched.
=item B<--[no]heading>
Print a filename heading above each file's results. This is the default
when used interactively.
=item B<--help>
Print a short help statement.
=item B<--help-types>
Print all known types.
=item B<--help-colors>
Print a chart of various color combinations.
=item B<--help-rgb-colors>
Like B<--help-colors> but with more precise RGB colors.
=item B<-i>, B<--ignore-case>
Ignore case distinctions in PATTERN. Overrides B<--smart-case> and B<-I>.
=item B<-I>, B<--no-ignore-case>
Turns on case distinctions in PATTERN. Overrides B<--smart-case> and B<-i>.
=item B<--ignore-ack-defaults>
Tells ack to completely ignore the default definitions provided with ack.
This is useful in combination with B<--create-ackrc> if you I want
to customize ack.
=item B<--[no]ignore-dir=I>, B<--[no]ignore-directory=I>
Ignore directory (as CVS, .svn, etc are ignored). May be used
multiple times to ignore multiple directories. For example, mason
users may wish to include B<--ignore-dir=data>. The B<--noignore-dir>
option allows users to search directories which would normally be
ignored (perhaps to research the contents of F<.svn/props> directories).
The I must always be a simple directory name. Nested
directories like F are NOT supported. You would need to
specify B<--ignore-dir=foo> and then no files from any foo directory
are taken into account by ack unless given explicitly on the command
line.
=item B<--ignore-file=I>
Ignore files matching I. The filters are specified
identically to file type filters as seen in L"Defining your own types">.
=item B<-k>, B<--known-types>
Limit selected files to those with types that ack knows about.
=item B<-l>, B<--files-with-matches>
Only print the filenames of matching files, instead of the matching text.
=item B<-L>, B<--files-without-matches>
Only print the filenames of files that do I match.
=item B<--match I>
Specify the I explicitly. This is helpful if you don't want to put the
regex as your first argument, e.g. when executing multiple searches over the
same set of files.
# search for foo and bar in given files
ack file1 t/file* --match foo
ack file1 t/file* --match bar
=item B<-m=I>, B<--max-count=I>
Print only I matches out of each file. If you want to stop ack
after printing the first match of any kind, use the B<-1> options.
=item B<--man>
Print this manual page.
=item B<-n>, B<--no-recurse>
No descending into subdirectories.
=item B<--not=PATTERN>
Specifies a I that must NOT be true on a given line for a match to
occur. This option can be repeated.
If you want to find all the lines with "dogs" but not if "cats" or "fish"
appear on the line, use:
ack dogs --not cats --not fish
Note that the options that affect "dogs" also affect "cats" and "fish", so
if you have
ack -i -w dogs --not cats
then the search for both "dogs" and "cats" will be case-insensitive and be
word-limited.
See also the other two boolean options C<--and> and C<--or>, neither of
which can be used with C<--not>.
=item B<-o>
Show only the part of each line matching PATTERN (turns off text
highlighting). This is exactly the same as C<--output=$&>.
=item B<--or=PATTERN>
Specifies a I that MAY be found on a given line for a match to
occur. This option can be repeated.
If you want to find all the lines with "dogs" or "cats", use:
ack dogs --or cats
Note that the options that affect "dogs" also affect "cats", so if you have
ack -i -w dogs --or cats
then the search for both "dogs" and "cats" will be case-insensitive and be
word-limited.
See also the other two boolean options C<--and> and C<--not>, neither of
which can be used with C<--or>.
=item B<--output=I>
Output the evaluation of I for each line (turns off text
highlighting). If PATTERN matches more than once then a line is
output for each non-overlapping match.
I may contain the strings "\n", "\r" and "\t", which will be
expanded to their corresponding characters line feed, carriage return
and tab, respectively.
I may also contain the following Perl special variables:
=over 4
=item C<$1> through C<$9>
The subpattern from the corresponding set of capturing parentheses.
If your pattern is C<(.+) and (.+)>, and the string is "this and
that', then C<$1> is "this" and C<$2> is "that".
=item C<$_>
The contents of the line in the file.
=item C<$.>
The number of the line in the file.
=item C<$&>, C<$`> and C<$'>
C<$&> is the string matched by the pattern, C<$`> is what
precedes the match, and C<$'> is what follows it. If the pattern
is C and the string is "lexicographic", then C<$&> is
"graph", C<$`> is "lexico" and C<$'> is "ic".
Use of these variables in your output will slow down the pattern
matching.
=item C<$+>
The match made by the last parentheses that matched in the pattern.
For example, if your pattern is C,
then C<$+> will contain whichever set of parentheses matched.
=item C<$f>
C<$f> is available, in C<--output> only, to insert the filename.
This is a stand-in for the discovered C<$filename> usage in old C<< ack2 --output >>,
which is disallowed with C improved security.
The intended usage is to provide the grep or compile-error syntax needed for editor/IDE go-to-line integration,
e.g. C<--output=$f:$.:$_> or C<--output=$f\t$.\t$&>
=back
=item B<--pager=I>, B<--nopager>
B<--pager> directs ack's output through I. This can also be specified
via the C and C environment variables.
Using --pager does not suppress grouping and coloring like piping
output on the command-line does.
B<--nopager> cancels any setting in F<~/.ackrc>, C or C.
No output will be sent through a pager.
=item B<--passthru>
Prints all lines, whether or not they match the expression. Highlighting
will still work, though, so it can be used to highlight matches while
still seeing the entire file, as in:
# Watch a log file, and highlight a certain IP address.
$ tail -f ~/access.log | ack --passthru 123.45.67.89
=item B<--print0>
Only works in conjunction with B<-f>, B<-g>, B<-l> or B<-c>, options
that only list filenames. The filenames are output separated with a
null byte instead of the usual newline. This is helpful when dealing
with filenames that contain whitespace, e.g.
# Remove all files of type HTML.
ack -f --html --print0 | xargs -0 rm -f
=item B<-p[N]>, B<--proximate[=N]>
Groups together match lines that are within N lines of each other.
This is useful for visually picking out matches that appear close
to other matches.
For example, if you got these results without the C<--proximate> option,
15: First match
18: Second match
19: Third match
37: Fourth match
they would look like this with C<--proximate=1>
15: First match
18: Second match
19: Third match
37: Fourth match
and this with C<--proximate=3>.
15: First match
18: Second match
19: Third match
37: Fourth match
If N is omitted, N is set to 1.
=item B<-P>
Negates the effect of the B<--proximate> option. Shortcut for B<--proximate=0>.
=item B<-Q>, B<--literal>
Quote all metacharacters in PATTERN, it is treated as a literal.
=item B<-r>, B<-R>, B<--recurse>
Recurse into sub-directories. This is the default and just here for
compatibility with grep. You can also use it for turning B<--no-recurse> off.
=item B<--range-start=PATTERN>, B<--range-end=PATTERN>
Specifies patterns that mark the start and end of a range. See
L for details.
=item B<-s>
Suppress error messages about nonexistent or unreadable files. This is taken
from fgrep.
=item B<-S>, B<--[no]smart-case>, B<--no-smart-case>
Ignore case in the search strings if PATTERN contains no uppercase
characters. This is similar to C in the vim text editor.
The options overrides B<-i> and B<-I>.
B<-S> is a synonym for B<--smart-case>.
B<-i> always overrides this option.
=item B<--sort-files>
Sorts the found files lexicographically. Use this if you want your file
listings to be deterministic between runs of I.
=item B<--show-types>
Outputs the filetypes that ack associates with each file.
Works with B<-f> and B<-g> options.
=item B<-t TYPE>, B<--type=TYPE>, B<--TYPE>
Specify the types of files to include in the search.
TYPE is a filetype, like I or I. B<--type=perl> can
also be specified as B<--perl>, although this is deprecated.
Type inclusions can be repeated and are ORed together.
See I for a list of valid types.
=item B<-T TYPE>, B<--type=noTYPE>, B<--noTYPE>
Specifies the type of files to exclude from the search. B<--type=noperl>
can be done as B<--noperl>, although this is deprecated.
If a file is of both type "foo" and "bar", specifying both B<--type=foo>
and B<--type=nobar> will exclude the file, because an exclusion takes
precedence over an inclusion.
=item B<--type-add I:I:I>
Files with the given ARGS applied to the given FILTER
are recognized as being of (the existing) type TYPE.
See also L"Defining your own types">.
=item B<--type-set I:I:I>
Files with the given ARGS applied to the given FILTER are recognized as
being of type TYPE. This replaces an existing definition for type TYPE. See
also L"Defining your own types">.
=item B<--type-del I>
The filters associated with TYPE are removed from Ack, and are no longer considered
for searches.
=item B<--[no]underline>
Turns on underlining of matches, where "underlining" is printing a line of
carets under the match.
$ ack -u foo
peanuts.txt
17: Come kick the football you fool
^^^ ^^^
623: Price per square foot
^^^
This is useful if you're dumping the results of an ack run into a text
file or printer that doesn't support ANSI color codes.
The setting of underline does not affect highlighting of matches.
=item B<-v>, B<--invert-match>
Invert match: select non-matching lines.
=item B<--version>
Display version and copyright information.
=item B<-w>, B<--word-regexp>
Force PATTERN to match only whole words.
=item B<-x>
An abbreviation for B<--files-from=->. The list of files to search are read
from standard input, with one line per file.
Note that the list of files is B filtered in any way. If you add
C<--type=html> in addition to C<-x>, the C<--type> will be ignored.
=item B<-1>
Stops after reporting first match of any kind. This is different
from B<--max-count=1> or B<-m1>, where only one match per file is
shown. Also, B<-1> works with B<-f> and B<-g>, where B<-m> does
not.
=item B<--thpppt>
Display the all-important Bill The Cat logo. Note that the exact
spelling of B<--thpppppt> is not important. It's checked against
a regular expression.
=item B<--bar>
Check with the admiral for traps.
=item B<--cathy>
Chocolate, Chocolate, Chocolate!
=back
=head1 THE .ackrc FILE
The F<.ackrc> file contains command-line options that are prepended
to the command line before processing. Multiple options may live
on multiple lines. Lines beginning with a # are ignored. A F<.ackrc>
might look like this:
# Always sort the files
--sort-files
# Always color, even if piping to another program
--color
# Use "less -r" as my pager
--pager=less -r
Note that arguments with spaces in them do not need to be quoted,
as they are not interpreted by the shell. Basically, each I
in the F<.ackrc> file is interpreted as one element of C<@ARGV>.
F looks in several locations for F<.ackrc> files; the searching
process is detailed in L"ACKRC LOCATION SEMANTICS">. These
files are not considered if B<--noenv> is specified on the command line.
=head1 Defining your own types
ack allows you to define your own types in addition to the predefined
types. This is done with command line options that are best put into
an F<.ackrc> file - then you do not have to define your types over and
over again. In the following examples the options will always be shown
on one command line so that they can be easily copy & pasted.
File types can be specified both with the I<--type=xxx> option,
or the file type as an option itself. For example, if you create
a filetype of "cobol", you can specify I<--type=cobol> or simply
I<--cobol>. File types must be at least two characters long. This
is why the C language is I<--cc> and the R language is I<--rr>.
I searches for foo in all perl files. I
tells you, that perl files are files ending
in .pl, .pm, .pod or .t. So what if you would like to include .xs
files as well when searching for --perl files? I
does this for you. B<--type-add> appends
additional extensions to an existing type.
If you want to define a new type, or completely redefine an existing
type, then use B<--type-set>. I defines
the type I to include files with
the extensions .e or .eiffel. So to search for all eiffel files
containing the word Bertrand use I.
As usual, you can also write B<--type=eiffel>
instead of B<--eiffel>. Negation also works, so B<--noeiffel> excludes
all eiffel files from a search. Redefining also works: I
and I<.xs> files no longer belong to the type I.
When defining your own types in the F<.ackrc> file you have to use
the following:
--type-set=eiffel:ext:e,eiffel
or writing on separate lines
--type-set
eiffel:ext:e,eiffel
The following does B work in the F<.ackrc> file:
--type-set eiffel:ext:e,eiffel
In order to see all currently defined types, use I<--help-types>, e.g.
I
In addition to filtering based on extension, ack offers additional
filter types. The generic syntax is
I<--type-set TYPE:FILTER:ARGS>; I depends on the value
of I.
=over 4
=item is:I
I filters match the target filename exactly. It takes exactly one
argument, which is the name of the file to match.
Example:
--type-set make:is:Makefile
=item ext:I[,I[,...]]
I filters match the extension of the target file against a list
of extensions. No leading dot is needed for the extensions.
Example:
--type-set perl:ext:pl,pm,t
=item match:I
I filters match the target filename against a regular expression.
The regular expression is made case-insensitive for the search.
Example:
--type-set make:match:/(gnu)?makefile/
=item firstlinematch:I
I matches the first line of the target file against a
regular expression. Like I, the regular expression is made
case insensitive.
Example:
--type-add perl:firstlinematch:/perl/
=back
=head1 ACK COLORS
ack allows customization of the colors it uses when presenting matches
onscreen. It uses the colors available in Perl's L
module, which provides the following listed values. Note that case does not
matter when using these values.
There are four different colors ack uses:
Aspect Option Env. variable Default
-------- ----------------- ------------------ ---------------
filename --color-filename ACK_COLOR_FILENAME black on_yellow
match --color-match ACK_COLOR_MATCH bold green
line no. --color-lineno ACK_COLOR_LINENO bold yellow
column no. --color-colno ACK_COLOR_COLNO bold yellow
The column number column is only used if the column number is shown because
of the --column option.
Colors may be specified by command-line option, such as
C, or by setting an environment
variable, such as C. Options for colors
can be set in your ACKRC file (See "THE .ackrc FILE").
ack can understand the following colors for the foreground:
black red green yellow blue magenta cyan white
The optional background color is specified by prepending "on_" to one of
the foreground colors:
on_black on_red on_green on_yellow on_blue on_magenta on_cyan on_white
Each of the foreground colors can be modified with the following
attributes, which may or may not be supported by your terminal:
bold faint italic underline blink reverse concealed
Any combinations of modifiers can be added to the foreground color. If your
terminal supports it, and you enjoy visual punishment, you can specify:
ack --color-filename="blink italic underline bold red on_yellow"
For charts of the colors and what they look like, run C
and C.
If the eight standard colors, in their bold, faint and unmodified states,
aren't enough for you to choose from, you can also specify colors by their
RGB values. They are specified as "rgbXYZ" where X, Y, and Z are values
between 0 and 5 giving the intensity of red, green and blue, respectively.
Therefore, "rgb500" is pure red, "rgb505" is purple, and so on.
Background colors can be specified with the "on_" prefix prepended on an
RGB color, so that "on_rgb505" would be a purple background.
The modifier attributes of blink, italic, underscore and so on may or may
not work on the RGB colors.
For a chart of the 216 possible RGB colors, run C.
=head1 ENVIRONMENT VARIABLES
For commonly-used ack options, environment variables can make life
much easier. These variables are ignored if B<--noenv> is specified
on the command line.
=over 4
=item ACKRC
Specifies the location of the user's F<.ackrc> file. If this file doesn't
exist, F looks in the default location.
=item ACK_COLOR_COLNO
Color specification for the column number in ack's output. By default, the
column number is not shown. You have to enable it with the B<--column>
option. See the section "ack Colors" above.
=item ACK_COLOR_FILENAME
Color specification for the filename in ack's output. See the section "ack
Colors" above.
=item ACK_COLOR_LINENO
Color specification for the line number in ack's output. See the section
"ack Colors" above.
=item ACK_COLOR_MATCH
Color specification for the matched text in ack's output. See the section
"ack Colors" above.
=item ACK_PAGER
Specifies a pager program, such as C, C or C, to which
ack will send its output.
Using C does not suppress grouping and coloring like
piping output on the command-line does, except that on Windows
ack will assume that C does not support color.
C overrides C if both are specified.
=item ACK_PAGER_COLOR
Specifies a pager program that understands ANSI color sequences.
Using C does not suppress grouping and coloring
like piping output on the command-line does.
If you are not on Windows, you never need to use C.
=back
=head1 ACK & OTHER TOOLS
=head2 Simple vim integration
F integrates easily with the Vim text editor. Set this in your
F<.vimrc> to use F instead of F:
set grepprg=ack\ -k
That example uses C<-k> to search through only files of the types ack
knows about, but you may use other default flags. Now you can search
with F and easily step through the results in Vim:
:grep Dumper perllib
=head2 Editor integration
Many users have integrated ack into their preferred text editors.
For details and links, see L.
=head2 Shell and Return Code
For greater compatibility with I, I in normal use returns
shell return or exit code of 0 only if something is found and 1 if
no match is found.
(Shell exit code 1 is C<$?=256> in perl with C or backticks.)
The I code 2 for errors is not used.
If C<-f> or C<-g> are specified, then 0 is returned if at least one
file is found. If no files are found, then 1 is returned.
=cut
=head1 DEBUGGING ACK PROBLEMS
If ack gives you output you're not expecting, start with a few simple steps.
=head2 Try it with B<--noenv>
Your environment variables and F<.ackrc> may be doing things you're
not expecting, or forgotten you specified. Use B<--noenv> to ignore
your environment and F<.ackrc>.
=head2 Use B<-f> to see what files have been selected for searching
Ack's B<-f> was originally added as a debugging tool. If ack is
not finding matches you think it should find, run F to see
what files have been selected. You can also add the C<--show-types>
options to show the type of each file selected.
=head2 Use B<--dump>
This lists the ackrc files that are loaded and the options loaded
from them. You may be loading an F<.ackrc> file that you didn't know
you were loading.
=head1 ACKRC LOCATION SEMANTICS
Ack can load its configuration from many sources. The following list
specifies the sources Ack looks for configuration files; each one
that is found is loaded in the order specified here, and
each one overrides options set in any of the sources preceding
it. (For example, if I set --sort-files in my user ackrc, and
--nosort-files on the command line, the command line takes
precedence)
=over 4
=item *
Defaults are loaded from App::Ack::ConfigDefaults. This can be omitted
using C<--ignore-ack-defaults>.
=item * Global ackrc
Options are then loaded from the global ackrc. This is located at
C on Unix-like systems.
Under Windows XP and earlier, the global ackrc is at
C
Under Windows Vista/7, the global ackrc is at
C
The C<--noenv> option prevents all ackrc files from being loaded.
=item * User ackrc
Options are then loaded from the user's ackrc. This is located at
C<$HOME/.ackrc> on Unix-like systems.
Under Windows XP and earlier, the user's ackrc is at
C.
Under Windows Vista/7, the user's ackrc is at
C.
If you want to load a different user-level ackrc, it may be specified
with the C<$ACKRC> environment variable.
The C<--noenv> option prevents all ackrc files from being loaded.
=item * Project ackrc
Options are then loaded from the project ackrc. The project ackrc is
the first ackrc file with the name C<.ackrc> or C<_ackrc>, first searching
in the current directory, then the parent directory, then the grandparent
directory, etc. This can be omitted using C<--noenv>.
=item * --ackrc
The C<--ackrc> option may be included on the command line to specify an
ackrc file that can override all others. It is consulted even if C<--noenv>
is present.
=item * Command line
Options are then loaded from the command line.
=back
=head1 BUGS & ENHANCEMENTS
ack is based at GitHub at L
Please report any bugs or feature requests to the issues list at
GitHub: L.
Please include the operating system that you're using; the output of
the command C; and any customizations in your F<.ackrc>
you may have.
To suggest enhancements, please submit an issue at
L. Also read the
F file in the ack code repository.
Also, feel free to discuss your issues on the ack mailing
list at L.
=head1 SUPPORT
Support for and information about F can be found at:
=over 4
=item * The ack homepage
L
=item * Source repository
L
=item * The ack issues list at GitHub
L
=item * The ack announcements mailing list
L
=item * The ack users' mailing list
L
=item * The ack development mailing list
L
=back
=head1 COMMUNITY
There are ack mailing lists and a Slack channel for ack. See
L for details.
=head1 FAQ
This is the Frequently Asked Questions list for ack.
=head2 Can I stop using grep now?
Many people find I to be better than I as an everyday tool
99% of the time, but don't throw I away, because there are times
you'll still need it. For example, you might be looking through huge
log files and not using regular expressions. In that case, I
will probably perform better.
=head2 Why isn't ack finding a match in (some file)?
First, take a look and see if ack is even looking at the file. ack is
intelligent in what files it will search and which ones it won't, but
sometimes that can be surprising.
Use the C<-f> switch, with no regex, to see a list of files that ack
will search for you. If your file doesn't show up in the list of files
that C shows, then ack never looks in it.
=head2 Wouldn't it be great if F did search & replace?
No, ack will always be read-only. Perl has a perfectly good way
to do search & replace in files, using the C<-i>, C<-p> and C<-n>
switches.
You can certainly use ack to select your files to update. For
example, to change all "foo" to "bar" in all PHP files, you can do
this from the Unix shell:
$ perl -i -p -e's/foo/bar/g' $(ack -f --php)
=head2 Can I make ack recognize F<.xyz> files?
Yes! Please see L"Defining your own types"> in the ack manual.
=head2 Will you make ack recognize F<.xyz> files by default?
We might, depending on how widely-used the file format is.
Submit an issue at in the GitHub issue queue at
L. Explain what the file format
is, where we can find out more about it, and what you have been using
in your F<.ackrc> to support it.
Please do not bother creating a pull request. The code for filetypes
is trivial compared to the rest of the process we go through.
=head2 Why is it called ack if it's called ack-grep?
The name of the program is "ack". Some packagers have called it
"ack-grep" when creating packages because there's already a package
out there called "ack" that has nothing to do with this ack.
I suggest you make a symlink named F that points to F
because one of the crucial benefits of ack is having a name that's
so short and simple to type.
To do that, run this with F or as root:
ln -s /usr/bin/ack-grep /usr/bin/ack
Alternatively, you could use a shell alias:
# bash/zsh
alias ack=ack-grep
# csh
alias ack ack-grep
=head2 What does F mean?
Nothing. I wanted a name that was easy to type and that you could
pronounce as a single syllable.
=head2 Can I do multi-line regexes?
No, ack does not support regexes that match multiple lines. Doing
so would require reading in the entire file at a time.
If you want to see lines near your match, use the C<--A>, C<--B>
and C<--C> switches for displaying context.
=head2 Why is ack telling me I have an invalid option when searching for C<+foo>?
ack treats command line options beginning with C<+> or C<-> as options; if you
would like to search for these, you may prefix your search term with C<--> or
use the C<--match> option. (However, don't forget that C<+> is a regular
expression metacharacter!)
=head2 Why does C<"ack '.{40000,}'"> fail? Isn't that a valid regex?
The Perl language limits the repetition quantifier to 32K. You
can search for C<.{32767}> but not C<.{32768}>.
=head2 Ack does "X" and shouldn't, should it?
We try to remain as close to grep's behavior as possible, so when in
doubt, see what grep does! If there's a mismatch in functionality there,
please submit an issue to GitHub, and/or bring it up on the ack-users
mailing list.
=cut
=head1 ACKNOWLEDGEMENTS
How appropriate to have Inowledgements!
Thanks to everyone who has contributed to ack in any way, including
Geraint Edwards,
Loren Howard,
Yaroslav Halchenko,
Thiago Perrotta,
Thomas Gossler,
Kieran Mace,
Volker Glave,
Axel Beckert,
Eric Pement,
Gabor Szabo,
Frieder Bluemle,
Grzegorz Kaczmarczyk,
Dan Book,
Tomasz Konojacki,
Salomon Smeke,
M. Scott Ford,
Anders Eriksson,
H.Merijn Brand,
Duke Leto,
Gerhard Poul,
Ethan Mallove,
Marek Kubica,
Ray Donnelly,
Nikolaj Schumacher,
Ed Avis,
Nick Morrott,
Austin Chamberlin,
Varadinsky,
SEbastien FeugEre,
Jakub Wilk,
Pete Houston,
Stephen Thirlwall,
Jonah Bishop,
Chris Rebert,
Denis Howe,
RaEl GundEn,
James McCoy,
Daniel Perrett,
Steven Lee,
Jonathan Perret,
Fraser Tweedale,
RaEl GundEn,
Steffen Jaeckel,
Stephan Hohe,
Michael Beijen,
Alexandr Ciornii,
Christian Walde,
Charles Lee,
Joe McMahon,
John Warwick,
David Steinbrunner,
Kara Martens,
Volodymyr Medvid,
Ron Savage,
Konrad Borowski,
Dale Sedivic,
Michael McClimon,
Andrew Black,
Ralph Bodenner,
Shaun Patterson,
Ryan Olson,
Shlomi Fish,
Karen Etheridge,
Olivier Mengue,
Matthew Wild,
Scott Kyle,
Nick Hooey,
Bo Borgerson,
Mark Szymanski,
Marq Schneider,
Packy Anderson,
JR Boyens,
Dan Sully,
Ryan Niebur,
Kent Fredric,
Mike Morearty,
Ingmar Vanhassel,
Eric Van Dewoestine,
Sitaram Chamarty,
Adam James,
Richard Carlsson,
Pedro Melo,
AJ Schuster,
Phil Jackson,
Michael Schwern,
Jan Dubois,
Christopher J. Madsen,
Matthew Wickline,
David Dyck,
Jason Porritt,
Jjgod Jiang,
Thomas Klausner,
Uri Guttman,
Peter Lewis,
Kevin Riggle,
Ori Avtalion,
Torsten Blix,
Nigel Metheringham,
GEbor SzabE,
Tod Hagan,
Michael Hendricks,
Evar ArnfjErE Bjarmason,
Piers Cawley,
Stephen Steneker,
Elias Lutfallah,
Mark Leighton Fisher,
Matt Diephouse,
Christian Jaeger,
Bill Sully,
Bill Ricker,
David Golden,
Nilson Santos F. Jr,
Elliot Shank,
Merijn Broeren,
Uwe Voelker,
Rick Scott,
Ask BjErn Hansen,
Jerry Gay,
Will Coleda,
Mike O'Regan,
Slaven ReziE<0x107>,
Mark Stosberg,
David Alan Pisoni,
Adriano Ferreira,
James Keenan,
Leland Johnson,
Ricardo Signes,
Pete Krawczyk and
Rob Hoelz.
=head1 AUTHOR
Andy Lester, C<< >>
=head1 COPYRIGHT & LICENSE
Copyright 2005-2024 Andy Lester.
This program is free software; you can redistribute it and/or modify
it under the terms of the Artistic License v2.0.
See https://www.perlfoundation.org/artistic-license-20.html or the LICENSE.md
file that comes with the ack distribution.
=cut
1;
ack-v3.8.1/META.json 000644 000766 000024 00000003661 14735132536 014206 0 ustar 00andy staff 000000 000000 {
"abstract" : "A grep-like program for searching source code",
"author" : [
"Andy Lester "
],
"dynamic_config" : 1,
"generated_by" : "ExtUtils::MakeMaker version 7.70, CPAN::Meta::Converter version 2.143240",
"license" : [
"artistic_2"
],
"meta-spec" : {
"url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec",
"version" : "2"
},
"name" : "ack",
"no_index" : {
"directory" : [
"t",
"inc"
]
},
"prereqs" : {
"build" : {
"requires" : {
"ExtUtils::MakeMaker" : "0"
}
},
"configure" : {
"requires" : {
"ExtUtils::MakeMaker" : "0"
}
},
"runtime" : {
"requires" : {
"Cwd" : "3.00",
"File::Basename" : "1.00015",
"File::Next" : "1.18",
"File::Spec" : "3.00",
"File::Temp" : "0.19",
"Getopt::Long" : "2.38",
"List::Util" : "0",
"Pod::Perldoc" : "3.20",
"Pod::Text" : "0",
"Pod::Usage" : "1.26",
"Scalar::Util" : "0",
"Term::ANSIColor" : "1.10",
"Test::Harness" : "2.50",
"Test::More" : "0.98",
"Text::ParseWords" : "3.1",
"filetest" : "0",
"if" : "0",
"parent" : "0",
"perl" : "5.010001",
"version" : "0"
}
}
},
"release_status" : "stable",
"resources" : {
"bugtracker" : {
"web" : "https://github.com/beyondgrep/ack3"
},
"homepage" : "https://beyondgrep.com/",
"license" : [
"https://www.perlfoundation.org/artistic-license-20.html"
],
"repository" : {
"type" : "git",
"url" : "git://github.com/beyondgrep/ack3.git"
},
"x_MailingList" : "https://groups.google.com/group/ack-users"
},
"version" : "v3.8.1"
}
ack-v3.8.1/lib/App/ 000755 000766 000024 00000000000 14735132536 014045 5 ustar 00andy staff 000000 000000 ack-v3.8.1/lib/App/Ack.pm 000644 000766 000024 00000073305 14735132514 015105 0 ustar 00andy staff 000000 000000 package App::Ack;
use warnings;
use strict;
=head1 NAME
App::Ack
=head1 DESCRIPTION
A container for functions for the ack program.
=cut
our $VERSION;
our $COPYRIGHT;
BEGIN {
$VERSION = 'v3.8.1'; # Check https://beyondgrep.com/ for updates
$COPYRIGHT = 'Copyright 2005-2024 Andy Lester.';
}
our $STANDALONE = 0;
our $ORIGINAL_PROGRAM_NAME;
our $fh;
BEGIN {
$fh = *STDOUT;
}
our %types;
our %type_wanted;
our %mappings;
our %ignore_dirs;
our $is_filter_mode;
our $output_to_pipe;
our $is_windows;
our $debug_nopens = 0;
# Line ending, changes to "\0" if --print0.
our $ors = "\n";
BEGIN {
# These have to be checked before any filehandle diddling.
$output_to_pipe = not -t *STDOUT;
$is_filter_mode = -p STDIN;
$is_windows = ($^O eq 'MSWin32');
}
=head1 SYNOPSIS
If you want to know about the F program, see the F file itself.
No user-serviceable parts inside. F is all that should use this.
=head1 FUNCTIONS
=head2 warn( @_ )
Put out an ack-specific warning.
=cut
sub warn {
return CORE::warn( _my_program(), ': ', @_, "\n" );
}
=head2 die( @msgs )
Die in an ack-specific way.
=cut
sub die {
return CORE::die( _my_program(), ': ', @_, "\n" );
}
sub _my_program {
require File::Basename;
return File::Basename::basename( $0 );
}
sub thpppt {
my $y = q{_ /|,\\'!.x',=(www)=, U };
$y =~ tr/,x!w/\nOo_/;
App::Ack::print( "$y ack $_[0]!\n" );
exit 0;
}
sub ackbar {
my $x;
$x = <<'_BAR';
6?!I'7!I"?%+!
3~!I#7#I"7#I!?!+!="+"="+!:!
2?#I!7!I!?#I!7!I"+"=%+"=#
1?"+!?*+!=#~"=!+#?"="+!
0?"+!?"I"?&+!="~!=!~"=!+%="+"
/I!+!?)+!?!+!=$~!=!~!="+!="+"?!="?!
.?%I"?%+%='?!=#~$="
,,!?%I"?(+$=$~!=#:"~$:!~!
,I!?!I!?"I"?!+#?"+!?!+#="~$:!~!:!~!:!,!:!,":#~!
+I!?&+!="+!?#+$=!~":!~!:!~!:!,!:#,!:!,%:"
*+!I!?!+$=!+!=!+!?$+#=!~":!~":#,$:",#:!,!:!
*I!?"+!?!+!=$+!?#+#=#~":$,!:",!:!,&:"
)I!?$=!~!=#+"?!+!=!+!=!~!="~!:!~":!,'.!,%:!~!
(=!?"+!?!=!~$?"+!?!+!=#~"=",!="~$,$.",#.!:!=!
(I"+"="~"=!+&=!~"=!~!,!~!+!=!?!+!?!=!I!?!+"=!.",!.!,":!
%I$?!+!?!=%+!~!+#~!=!~#:#=!~!+!~!=#:!,%.!,!.!:"
$I!?!=!?!I!+!?"+!=!~!=!~!?!I!?!=!+!=!~#:",!~"=!~!:"~!=!:",&:" '-/
$?!+!I!?"+"=!+"~!,!:"+#~#:#,"=!~"=!,!~!,!.",!:".!:! */! !I!t!'!s! !a! !g!r!e!p!!! !/!
$+"=!+!?!+"~!=!:!~!:"I!+!,!~!=!:!~!,!:!,$:!~".&:"~!,# (-/
%~!=!~!=!:!.!+"~!:!,!.!,!~!=!:$.!,":!,!.!:!~!,!:!=!.#="~!,!:" ./!
%=!~!?!+"?"+!=!~",!.!:!?!~!.!:!,!:!,#.!,!:","~!:!=!~!=!:",!~! ./!
%+"~":!~!=#~!:!~!,!.!~!:",!~!=!~!.!:!,!.",!:!,":!=":!.!,!:!7! -/!
%~",!:".#:!=!:!,!:"+!:!~!:!.!,!~!,!.#,!.!,$:"~!,":"~!=! */!
&=!~!=#+!=!~",!.!:",#:#,!.",+:!,!.",!=!+!?!
&~!=!~!=!~!:"~#:",!.!,#~!:!.!+!,!.",$.",$.#,!+!I!?!
&~!="~!:!~":!~",!~!=!~":!,!:!~!,!:!,&.$,#."+!?!I!?!I!
&~!=!~!=!+!,!:!~!:!=!,!:!~&:$,!.!,".!,".!,#."~!+!?$I!
&~!=!~!="~!=!:!~":!,!~%:#,!:",!.!,#.",#I!7"I!?!+!?"I"
&+!I!7!:#~"=!~!:!,!:"~$.!=!.!,!~!,$.#,!~!7!I#?!+!?"I"7!
%7#?!+!~!:!=!~!=!~":!,!:"~":#.!,)7#I"?"I!7&
%7#I!=":!=!~!:"~$:"~!:#,!:!,!:!~!:#,!7#I!?#7)
$7$+!,!~!=#~!:!~!:!~$:#,!.!~!:!=!,":!7#I"?#7+=!?!
$7#I!~!,!~#=!~!:"~!:!,!:!,#:!=!~",":!7$I!?#I!7*+!=!+"
"I!7$I!,":!,!.!=":$,!:!,$:$7$I!+!?"I!7+?"I!7!I!7!,!
!,!7%I!:",!."~":!,&.!,!:!~!I!7$I!+!?"I!7,?!I!7',!
!7(,!.#~":!,%.!,!7%I!7!?#I"7,+!?!7*
7+:!,!~#,"=!7'I!?#I"7/+!7+
77I!+!7!?!7!I"71+!7,
_BAR
return _pic_decode($x);
}
sub cathy {
my $x = <<'CATHY';
0+!--+!
0|! "C!H!O!C!O!L!A!T!E!!! !|!
0|! "C!H!O!C!O!L!A!T!E!!! !|!
0|! "C!H!O!C!O!L!A!T!E!!! !|!
0|! $A"C!K!!! $|!
0+!--+!
6\! 1:!,!.! !
7\! /.!M!~!Z!M!~!
8\! /~!D! "M! !
4.! $\! /M!~!.!8! +.!M# 4
0,!.! (\! .~!M!N! ,+!I!.!M!.! 3
/?!O!.!M!:! '\! .O!.! +~!Z!=!N!.! 4
..! !D!Z!.!Z!.! '\! 9=!M".! 6
/.! !.!~!M".! '\! 8~! 9
4M!.! /.!7!N!M!.! F
4.! &:!M! !N"M# !M"N!M! #D!M&=! =
:M!7!M#:! !~!M!7!,!$!M!:! #.! !O!N!.!M!:!M# ;
8Z!M"~!N!$!D!.!N!?! !I!N!.! (?!M! !M!,!D!M".! 9
(?!Z!M!N!:! )=!M!O!8!.!M!+!M! !M!,! !O!M! +,!M!.!M!~!Z!N!M!:! &:!~! 0
&8!7!.!~!M"D!M!,! &M!?!=!8! !M!,!O! !M!+! !+!O!.!M! $M#~! !.!8!M!Z!.!M! !O!M"Z! %:!~!M!Z!M!Z!.! +
&:!M!7!,! *M!.!Z!M! !8"M!.!M!~! !.!M!.!=! #~!8!.!M! !7!M! "N!Z#I! !D!M!,!M!.! $."M!,! !M!.! *
2$!O! "N! !.!M!I! !7" "M! "+!O! !~!M! !d!O!.!7!I!M!.! !.!O!=!M!.! !M",!M!.! %.!$!O!D! +
1~!O! "M!+! !8!$! "M! "?!O! %Z!8!D!M!?!8!I!O!7!M! #M!.!M! "M",!M! 4
07!~! ".!8! !.!M! "I!+! !.!M! &Z!D!.!7!=!M! !:!.!M! #:!8"+! !.!+!8! !8! 3
/~!M! #N! !~!M!$! !.!M! !.!M" &~!M! "~!M!O! "D! $M! !8! "M!,!M!+!D!.! 1
#.! #?!M!N!.! #~!O! $M!.!7!$! "?" !?!~!M! '7!8!?!M!.!+!M"O! $?"$!D! !.!O! !$!7!I!.! 0
$,!M!:!O!?! ".! !?!=! $=!:!O! !M! "M! !M! !+!$! (.! +.!M! !M!.! !8! !+"Z!~! $:!M!$! !.! '
#.!8!.!I!$! $7!I! %M" !=!M! !~!M!D! "7!I! .I!O! %?!=!,!D! !,!M! !D!~!8!~! %D!M! (
#.!M"?! $=!O! %=!N! "8!.! !Z!M! #M!~! (M!:! #.!M" &O! !M!.! !?!,! !8!.!N!~! $8!N!M!,!.! %
*$!O! &M!,! "O! !.!M!.! #M! (~!M( &O!.! !7! "M! !.!M!.!M!,! #.!M! !M! &
)=!8!.! $.!M!O!.! "$!.!I!N! !I!M# (7!M(I! %D"Z!M! "=!I! "M! !M!:! #~!D! '
)D! &8!N!:! ".!O! !M!="M! "M! (7!M) %." !M!D!."M!.! !$!=! !M!,! +
(M! &+!.!M! #Z!7!O!M!.!~!8! +,!M#D!?!M#D! #.!Z!M#,!Z!?! !~!N! "N!.! !M! +
'D!:! %$!D! !?! #M!Z! !8!.! !M"?!7!?!7! '+!I!D! !?!O!:!M!:! ":!M!:! !M!7".!M! "8!+! !:!D! !.!M! *
%.!O!:! $.!O!+! !D!.! #M! "M!.!+!N!I!Z! "7!M!N!M!N!?!I!7!Z!=!M'D"~! #M!.!8!$! !:! !.!M! "N!?! !,!O! )
!.!?!M!:!M!I! %8!,! "M!.! #M! "N! !M!.! !M!.! !+!~! !.!M!.! ':!M! $M! $M!Z!$! !M!.! "D! "M! "?!M! (
!7!8! !+!I! ".! "$!=! ":!$! "+! !M!.! !O! !M!I!M".! !=!~! ",!O! '=!M! $$!,! #N!:! ":!8!.! !D!~! !,!M!.! !:!M!.! &
!:!,!.! &Z" #D! !.!8!."M!.! !8!?!Z!M!.!M! #Z!~! !?!M!Z!.! %~!O!.!8!$!N!8!O!I!:!~! !+! #M!.! !.!M!.! !+!M! ".!~!M!+! $
!.! 'D!I! #?!M!.!M!,! !.!Z! !.!8! #M&O!I!?! (~!I!M"." !M!Z!.! !M!N!.! "+!$!.! "M!.! !M!?!.! "8!M! $
(O!8! $M! !M!.! ".!:! !+!=! #M! #.!M! !+" *$!M":!.! !M!~! "M!7! #M! #7!Z! "M"$!M!.! !.! #
'$!Z! #.!7!+!M! $.!,! !+!:! #N! #.!M!.!+!M! +D!M! #=!N! ":!O! #=!M! #Z!D! $M!I! %
$,! ".! $.!M" %$!.! !?!~! "+!7!." !.!M!,! !M! *,!N!M!.$M!?! "D!,! #M!.! #N! +
,M!Z! &M! "I!,! "M! %I!M! !?!=!.! (Z!8!M! $:!M!.! !,!M! $D! #.!M!.! )
+8!O! &.!8! "I!,! !~!M! &N!M! !M!D! '?!N!O!." $?!7! "?!~! #M!.! #I!D!.! (
3M!,! "N!.! !D" &.!+!M!.! !M":!.":!M!7!M!D! 'M!.! "M!.! "M!,! $I! )
3I! #M! "M!,! !:! &.!M" ".!,! !.!$!M!I! #.! !:! !.!M!?! "N!+! ".! /
1M!,! #.!M!8!M!=!.! +~!N"O!Z"~! *+!M!.! "M! 2
0.!M! &M!.! 8:! %.!M!Z! "M!=! *O!,! %
0?!$! &N! )." .,! %."M! ":!M!.! 0
0N!:! %?!O! #.! ..! &,! &.!D!,! "N!I! 0
CATHY
return _pic_decode($x);
}
sub _pic_decode {
my($compressed) = @_;
$compressed =~ s/(.)(.)/$1x(ord($2)-32)/eg;
App::Ack::print( $compressed );
exit 0;
}
=head2 show_help()
Dumps the help page to the user.
=cut
sub show_help {
App::Ack::print( <<"END_OF_HELP" );
Usage: ack [OPTION]... PATTERN [FILES OR DIRECTORIES]
Search for PATTERN in each source file in the tree from the current
directory on down. If any files or directories are specified, then
only those files and directories are checked. ack may also search
STDIN, but only if no file or directory arguments are specified,
or if one of them is "-".
Default switches may be specified in an .ackrc file. If you want no dependency
on the environment, turn it off with --noenv.
File select actions:
-f Only print the files selected, without
searching. The PATTERN must not be specified.
-g Same as -f, but only select files matching
PATTERN.
File listing actions:
-l, --files-with-matches Print filenames with at least one match
-L, --files-without-matches Print filenames with no matches
-c, --count Print filenames and count of matching lines
Searching:
-i, --ignore-case Ignore case distinctions in PATTERN
-S, --[no]smart-case Ignore case distinctions in PATTERN,
only if PATTERN contains no upper case.
Ignored if -i or -I are specified.
-I, --no-ignore-case Turns on case-sensitivity in PATTERN.
Negates -i and --smart-case.
-v, --invert-match Invert match: select non-matching lines
-w, --word-regexp Force PATTERN to match only whole words
-Q, --literal Quote all metacharacters; PATTERN is literal
--range-start PATTERN Specify PATTERN as the start of a match range.
--range-end PATTERN Specify PATTERN as the end of a match range.
--match PATTERN Specify PATTERN explicitly. Typically omitted.
--and PATTERN Specifies PATTERN that MUST also be found on
the line for a match to occur. Repeatable.
--or PATTERN Specifies PATTERN that MAY also be found on
the line for a match to occur. Repeatable.
--not PATTERN Specifies PATTERN that must NOT be found on
the line for a match to occur. Repeatable.
Search output:
--output=expr Output the evaluation of expr for each line
(turns off text highlighting)
-o Show only the part of a line matching PATTERN
Same as --output='\$&'
--passthru Print all lines, whether matching or not
-m, --max-count=NUM Stop searching in each file after NUM matches
-1 Stop searching after one match of any kind
-H, --with-filename Print the filename for each match (default:
on unless explicitly searching a single file)
-h, --no-filename Suppress the prefixing filename on output
--[no]column Show the column number of the first match
-A NUM, --after-context=NUM Print NUM lines of trailing context after
matching lines.
-B NUM, --before-context=NUM Print NUM lines of leading context before
matching lines.
-C [NUM], --context[=NUM] Print NUM lines (default 2) of output context.
--print0 Print null byte as separator between filenames,
only works with -f, -g, -l, -L or -c.
-s Suppress error messages about nonexistent or
unreadable files.
File presentation:
--pager=COMMAND Pipes all ack output through COMMAND. For
example, --pager="less -R". Ignored if output
is redirected.
--nopager Do not send output through a pager. Cancels
any setting in ~/.ackrc, ACK_PAGER or
ACK_PAGER_COLOR.
--[no]heading Print a filename heading above each file's
results. (default: on when used interactively)
--[no]break Print a break between results from different
files. (default: on when used interactively)
--group Same as --heading --break
--nogroup Same as --noheading --nobreak
-p, --proximate=LINES Separate match output with blank lines unless
they are within LINES lines from each other.
-P, --proximate=0 Negates --proximate.
--[no]underline Print a line of carets under the matched text.
--[no]color, --[no]colour Highlight the matching text (default: on unless
output is redirected, or on Windows)
--color-filename=COLOR
--color-match=COLOR
--color-colno=COLOR
--color-lineno=COLOR Set the color for filenames, matches, line and
column numbers.
--help-colors Show a list of possible color combinations.
--help-rgb-colors Show a list of advanced RGB colors.
--flush Flush output immediately, even when ack is used
non-interactively (when output goes to a pipe or
file).
File finding:
--sort-files Sort the found files lexically.
--show-types Show which types each file has.
--files-from=FILE Read the list of files to search from FILE.
-x Read the list of files to search from STDIN.
File inclusion/exclusion:
--[no]ignore-dir=name Add/remove directory from list of ignored dirs
--[no]ignore-directory=name Synonym for ignore-dir
--ignore-file=FILTER:ARGS Add filter for ignoring files.
-r, -R, --recurse Recurse into subdirectories (default: on)
-n, --no-recurse No descending into subdirectories
--[no]follow Follow symlinks. Default is off.
File type inclusion/exclusion:
-t X, --type=X Include only X files, where X is a filetype,
e.g. python, html, markdown, etc
-T X, --type=noX Exclude X files, where X is a filetype.
-k, --known-types Include only files of types that ack recognizes.
--help-types Display all known types, and how they're defined.
File type specification:
--type-set=TYPE:FILTER:ARGS Files with the given ARGS applied to the given
FILTER are recognized as being of type TYPE.
This replaces an existing definition for TYPE.
--type-add=TYPE:FILTER:ARGS Files with the given ARGS applied to the given
FILTER are recognized as being type TYPE.
--type-del=TYPE Removes all filters associated with TYPE.
Miscellaneous:
--version Display version & copyright
--[no]env Ignore environment variables and global ackrc
files. --env is legal but redundant.
--ackrc=filename Specify an ackrc file to use
--ignore-ack-defaults Ignore default definitions included with ack.
--create-ackrc Outputs a default ackrc for your customization
to standard output.
--dump Dump information on which options are loaded
and where they're defined.
--[no]filter Force ack to treat standard input as a pipe
(--filter) or tty (--nofilter)
--help This help
--man Print the manual.
--help-types Display all known types, and how they're defined.
--help-colors Show a list of possible color combinations.
--help-rgb-colors Show a list of advanced RGB colors.
--thpppt Bill the Cat
--bar The warning admiral
--cathy Chocolate! Chocolate! Chocolate!
Filter specifications:
If FILTER is "ext", ARGS is a list of extensions checked against the
file's extension.
If FILTER is "is", ARGS must match the file's name exactly.
If FILTER is "match", ARGS is matched as a case-insensitive regex
against the filename.
If FILTER is "firstlinematch", ARGS is matched as a regex the first
line of the file's contents.
Exit status is 0 if match, 1 if no match.
ack's home page is at https://beyondgrep.com/
The full ack manual is available by running "ack --man".
This is version $App::Ack::VERSION of ack. Run "ack --version" for full version info.
END_OF_HELP
return;
}
=head2 show_help_types()
Display the filetypes help subpage.
=cut
sub show_help_types {
App::Ack::print( <<'END_OF_HELP' );
Usage: ack [OPTION]... PATTERN [FILES OR DIRECTORIES]
The following is the list of filetypes supported by ack. You can specify a
filetype to include with -t TYPE or --type=TYPE. You can exclude a
filetype with -T TYPE or --type=noTYPE.
Note that some files may appear in multiple types. For example, a file
called Rakefile is both Ruby (--type=ruby) and Rakefile (--type=rakefile).
END_OF_HELP
my @types = keys %App::Ack::mappings;
my $maxlen = 0;
for ( @types ) {
$maxlen = length if $maxlen < length;
}
for my $type ( sort @types ) {
next if $type =~ /^-/; # Stuff to not show
my $ext_list = $mappings{$type};
if ( ref $ext_list ) {
$ext_list = join( '; ', map { $_->to_string } @{$ext_list} );
}
App::Ack::print( sprintf( " %-*.*s %s\n", $maxlen, $maxlen, $type, $ext_list ) );
}
return;
}
=head2 show_help_colors()
Display the colors help subpage.
=cut
sub show_help_colors {
App::Ack::print( <<'END_OF_HELP' );
ack allows customization of the colors it uses when presenting matches
onscreen. See the "ACK COLORS" section of the ack manual (ack --man).
Here is a chart of how various color combinations appear: Each of the eight
foreground colors, on each of the eight background colors or no background
color, with and without the bold modifier.
Run ack --help-rgb-colors for a chart of the RGB colors.
END_OF_HELP
_show_color_grid();
return;
}
=head2 show_help_rgb()
Display the RGB help subpage.
=cut
sub show_help_rgb {
App::Ack::print( <<'END_OF_HELP' );
ack allows customization of the colors it uses when presenting matches
onscreen. See the "ACK COLORS" section of the ack manual (ack --man).
Colors may be specified as "rgbNNN" where "NNN" is a triplet of digits
from 0 to 5 specifying the intensity of red, green and blue, respectively.
Here is a grid of the 216 possible values for NNN.
END_OF_HELP
_show_rgb_grid();
App::Ack::say( 'Here are the 216 possible colors with the "reverse" modifier applied.', "\n" );
_show_rgb_grid( 'reverse' );
return;
}
sub _show_color_grid {
my $cell_width = 7;
my @fg_colors = qw( black red green yellow blue magenta cyan white );
my @bg_colors = map { "on_$_" } @fg_colors;
App::Ack::say(
_color_cell( '' ),
map { _color_cell( $_ ) } @fg_colors
);
App::Ack::say(
_color_cell( '' ),
map { _color_cell( '-' x $cell_width ) } @fg_colors
);
for my $bg ( '', @bg_colors ) {
App::Ack::say(
_color_cell( '' ),
( map { _color_cell( $_, "$_ $bg" ) } @fg_colors ),
$bg
);
App::Ack::say(
_color_cell( 'bold' ),
( map { _color_cell( $_, "bold $_ $bg" ) } @fg_colors ),
$bg
);
App::Ack::say();
}
return;
}
sub _color_cell {
my $text = shift;
my $color = shift;
my $cell_width = 7;
$text = sprintf( '%-*s', $cell_width, $text );
return ($color ? Term::ANSIColor::colored( $text, $color ) : $text) . ' ';
}
sub _show_rgb_grid {
my $modifier = shift // '';
my $grid = <<'HERE';
544 544 544 544 544 554 554 554 554 554 454 454 454 454 454 455 455 455 455 455 445 445 445 445 445 545 545 545 545 545
533 533 533 543 543 553 553 553 453 453 353 353 353 354 354 355 355 355 345 345 335 335 335 435 435 535 535 535 534 534
511 521 531 531 541 551 451 451 351 251 151 152 152 153 154 155 145 145 135 125 115 215 215 315 415 515 514 514 513 512
500 510 520 530 540 550 450 350 250 150 050 051 052 053 054 055 045 035 025 015 005 105 205 305 405 505 504 503 502 501
400 410 410 420 430 440 340 340 240 140 040 041 041 042 043 044 034 034 024 014 004 104 104 204 304 404 403 403 402 401
300 300 310 320 320 330 330 230 130 130 030 030 031 032 032 033 033 023 013 013 003 003 103 203 203 303 303 302 301 301
200 200 200 210 210 220 220 220 120 120 020 020 020 021 021 022 022 022 012 012 002 002 002 102 102 202 202 202 201 201
100 100 100 100 100 110 110 110 110 110 010 010 010 010 010 011 011 011 011 011 001 001 001 001 001 101 101 101 101 101
522 522 532 542 542 552 552 452 352 352 252 252 253 254 254 255 255 245 235 235 225 225 325 425 425 525 525 524 523 523
411 411 421 431 431 441 441 341 241 241 141 141 142 143 143 144 144 134 124 124 114 114 214 314 314 414 414 413 412 412
422 422 432 432 432 442 442 442 342 342 242 242 242 243 243 244 244 244 234 234 224 224 224 324 324 424 424 424 423 423
311 311 311 321 321 331 331 331 231 231 131 131 131 132 132 133 133 133 123 123 113 113 113 213 213 313 313 313 312 312
433 433 433 433 433 443 443 443 443 443 343 343 343 343 343 344 344 344 344 344 334 334 334 334 334 434 434 434 434 434
211 211 211 211 211 221 221 221 221 221 121 121 121 121 121 122 122 122 122 122 112 112 112 112 112 212 212 212 212 212
322 322 322 322 322 332 332 332 332 332 232 232 232 232 232 233 233 233 233 233 223 223 223 223 223 323 323 323 323 323
555 555 555 555 555 555 555 555 555 555 555 555 555 555 555 555 555 555 555 555 555 555 555 555 555 555 555 555 555 555
444 444 444 444 444 444 444 444 444 444 444 444 444 444 444 444 444 444 444 444 444 444 444 444 444 444 444 444 444 444
333 333 333 333 333 333 333 333 333 333 333 333 333 333 333 333 333 333 333 333 333 333 333 333 333 333 333 333 333 333
222 222 222 222 222 222 222 222 222 222 222 222 222 222 222 222 222 222 222 222 222 222 222 222 222 222 222 222 222 222
111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111 111
000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000
HERE
$grid =~ s/(\d\d\d)/Term::ANSIColor::colored( "$1", "$modifier rgb$1" )/eg;
App::Ack::say( $grid );
return;
}
sub show_man {
require Pod::Usage;
Pod::Usage::pod2usage({
-input => $App::Ack::ORIGINAL_PROGRAM_NAME,
-verbose => 2,
-exitval => 0,
});
return;
}
=head2 get_version_statement
Returns the version information for ack.
=cut
sub get_version_statement {
require Config;
my $copyright = $App::Ack::COPYRIGHT;
my $this_perl = $Config::Config{perlpath};
if ($^O ne 'VMS') {
my $ext = $Config::Config{_exe};
$this_perl .= $ext unless $this_perl =~ m/$ext$/i;
}
my $perl_ver = sprintf( 'v%vd', $^V );
my $build_type = $App::Ack::STANDALONE ? 'standalone version' : 'standard build';
return <<"END_OF_VERSION";
ack $App::Ack::VERSION ($build_type)
Running under Perl $perl_ver at $this_perl
$copyright
This program is free software. You may modify or distribute it
under the terms of the Artistic License v2.0.
END_OF_VERSION
}
sub print { print {$fh} @_; return; }
sub say { print {$fh} @_, $ors; return; }
sub print_blank_line { print {$fh} "\n"; return; }
sub set_up_pager {
my $command = shift;
return if App::Ack::output_to_pipe();
my $pager;
if ( not open( $pager, '|-', $command ) ) {
App::Ack::die( qq{Unable to pipe to pager "$command": $!} );
}
$fh = $pager;
return;
}
=head2 output_to_pipe()
Returns true if ack's input is coming from a pipe.
=cut
sub output_to_pipe {
return $output_to_pipe;
}
=head2 exit_from_ack( $nmatches )
Exit from the application with the correct exit code.
Returns with 0 if a match was found, otherwise with 1. The number of matches is
handed in as the only argument.
=cut
sub exit_from_ack {
my $nmatches = shift;
my $rc = $nmatches ? 0 : 1;
exit $rc;
}
=head2 show_types( $file )
Shows the filetypes associated with a given file.
=cut
sub show_types {
my $file = shift;
my @types = filetypes( $file );
my $arrow = @types ? ' => ' : ' =>';
App::Ack::say( $file->name, $arrow, join( ',', @types ) );
return;
}
sub filetypes {
my ( $file ) = @_;
my @matches;
foreach my $k (keys %App::Ack::mappings) {
my $filters = $App::Ack::mappings{$k};
foreach my $filter (@{$filters}) {
# Clone the file.
my $clone = $file->clone;
if ( $filter->filter($clone) ) {
push @matches, $k;
last;
}
}
}
# https://metacpan.org/pod/distribution/Perl-Critic/lib/Perl/Critic/Policy/Subroutines/ProhibitReturnSort.pm
@matches = sort @matches;
return @matches;
}
sub is_lowercase {
my $pat = shift;
# The simplest case.
return 1 if lc($pat) eq $pat;
# If we have capitals, then go clean up any metacharacters that might have capitals.
# Get rid of any literal backslashes first to avoid confusion.
$pat =~ s/\\\\//g;
my $metacharacter = qr{
|\\A # Beginning of string
|\\B # Not word boundary
|\\c[a-zA-Z] # Control characters
|\\D # Non-digit character
|\\G # End-of-match position of prior match
|\\H # Not horizontal whitespace
|\\K # Keep to the left
|\\N(\{.+?\})? # Anything but \n, OR Unicode sequence
|\\[pP]\{.+?\} # Named property and negation
|\\[pP][A-Z] # Named property and negation, single-character shorthand
|\\R # Linebreak
|\\S # Non-space character
|\\V # Not vertical whitespace
|\\W # Non-word character
|\\X # ???
|\\x[0-9A-Fa-f]{2} # Hex sequence
|\\Z # End of string
}x;
$pat =~ s/$metacharacter//g;
my $name = qr/[_A-Za-z][_A-Za-z0-9]*?/;
# Eliminate named captures.
$pat =~ s/\(\?'$name'//g;
$pat =~ s/\(\?<$name>//g;
# Eliminate named backreferences.
$pat =~ s/\\k'$name'//g;
$pat =~ s/\\k<$name>//g;
$pat =~ s/\\k\{$name\}//g;
# Now with those metacharacters and named things removed, now see if it's lowercase.
return 1 if lc($pat) eq $pat;
return 0;
}
# Returns a regex object based on a string and command-line options.
# Dies when the regex $str is undefined (i.e. not given on command line).
sub build_regex {
my $str = shift;
my $opt = shift;
# Check for lowercaseness before we do any modifications.
my $regex_is_lc = App::Ack::is_lowercase( $str );
if ( $opt->{Q} ) {
$str = quotemeta( $str );
}
else {
# Compile the regex to see if it dies or throws warnings.
local $SIG{__WARN__} = sub { CORE::die @_ }; # Anything that warns becomes a die.
my $scratch_regex = eval { qr/$str/ };
if ( not $scratch_regex ) {
my $err = $@;
chomp $err;
if ( $err =~ m{^(.+?); marked by <-- HERE in m/(.+?) <-- HERE} ) {
my ($why, $where) = ($1,$2);
my $pointy = ' ' x (6+length($where)) . '^---HERE';
App::Ack::die( "Invalid regex '$str'\nRegex: $str\n$pointy $why" );
}
else {
App::Ack::die( "Invalid regex '$str'\n$err" );
}
}
}
my $scan_str = $str;
# Whole words only.
if ( $opt->{w} ) {
my $ok = 1;
if ( $str =~ /^\\[wd]/ ) {
# Explicit \w is good.
}
else {
# Can start with \w, (, [ or dot.
if ( $str !~ /^[\w\(\[\.]/ ) {
$ok = 0;
}
}
# Can end with \w, }, ), ], +, *, or dot.
if ( $str !~ /[\w\}\)\]\+\*\?\.]$/ ) {
$ok = 0;
}
# ... unless it's escaped.
elsif ( $str =~ /\\[\}\)\]\+\*\?\.]$/ ) {
$ok = 0;
}
if ( !$ok ) {
App::Ack::die( '-w will not do the right thing if your regex does not begin and end with a word character.' );
}
if ( $str =~ /^\w+$/ ) {
# No need for fancy regex if it's a simple word.
$str = sprintf( '\b(?:%s)\b', $str );
}
else {
$str = sprintf( '(?:^|\b|\s)\K(?:%s)(?=\s|\b|$)', $str );
}
}
if ( $opt->{i} || ($opt->{S} && $regex_is_lc) ) {
$_ = "(?i)$_" for ( $str, $scan_str );
}
my $scan_regex = undef;
my $regex = eval { qr/$str/ };
if ( $regex ) {
if ( $scan_str !~ /\$/ ) {
# No line_scan is possible if there's a $ in the regex.
$scan_regex = eval { qr/$scan_str/m };
}
}
else {
my $err = $@;
chomp $err;
App::Ack::die( "Invalid regex '$str':\n $err" );
}
return ($regex, $scan_regex);
}
sub build_all_regexes {
my $opt_regex = shift;
my $opt = shift;
my $re_match;
my $re_not;
my $re_hilite;
my $re_scan;
my @parts;
# AND: alpha and beta
if ( @parts = @{$opt->{and}} ) {
my @match_parts;
my @hilite_parts;
for my $part ( @parts ) {
my ($match, undef) = build_regex( $part, $opt );
push @match_parts, "(?=.*$match)";
push @hilite_parts, $match;
}
my ($match, $scan) = build_regex( $opt_regex, $opt );
push @match_parts, ".*$match";
push @hilite_parts, $match;
$re_match = join( '', @match_parts );
$re_hilite = join( '|', @hilite_parts );
$re_scan = $scan;
}
# OR: alpha OR beta
elsif ( @parts = @{$opt->{or}} ) {
my @match_parts;
my @scan_parts;
for my $part ( $opt_regex, @parts ) {
my ($match, $scan) = build_regex( $part, $opt );
push @match_parts, $match;
push @scan_parts, $scan;
}
$re_match = join( '|', @match_parts );
$re_hilite = $re_match;
$re_scan = join( '|', @scan_parts );
}
# NOT: alpha NOT beta
elsif ( @parts = @{$opt->{not}} ) {
($re_match, $re_scan) = build_regex( $opt_regex, $opt );
$re_hilite = $re_match;
my @not_parts;
for my $part ( @parts ) {
(my $re, undef) = build_regex( $part, $opt );
push @not_parts, $re;
}
$re_not = join( '|', @not_parts );
}
# No booleans.
else {
($re_match, $re_scan) = build_regex( $opt_regex, $opt );
$re_hilite = $re_match;
}
return ($re_match, $re_not, $re_hilite, $re_scan);
}
1; # End of App::Ack
ack-v3.8.1/lib/App/Ack/ 000755 000766 000024 00000000000 14735132536 014543 5 ustar 00andy staff 000000 000000 ack-v3.8.1/lib/App/Ack/Files.pm 000644 000766 000024 00000004532 14376470274 016154 0 ustar 00andy staff 000000 000000 package App::Ack::Files;
use App::Ack ();
use App::Ack::File ();
use File::Next 1.16 ();
use warnings;
use strict;
use 5.010;
=head1 NAME
App::Ack::Files
=head1 SYNOPSIS
A factory object for creating a stream of L objects.
=head1 METHODS
=head2 from_argv( \%opt, \@starting_points )
Return an iterator that does the file finding for us.
=cut
sub from_argv {
my $class = shift;
my $opt = shift;
my $start = shift;
my $self = bless {}, $class;
my $descend_filter = $opt->{descend_filter};
if ( $opt->{n} ) {
$descend_filter = sub {
return 0;
};
}
$self->{iter} =
File::Next::files( {
file_filter => $opt->{file_filter},
descend_filter => $descend_filter,
error_handler => _generate_error_handler(),
warning_handler => sub {},
sort_files => $opt->{sort_files},
follow_symlinks => $opt->{follow},
}, @{$start} );
return $self;
}
=head2 from_file( \%opt, $filename )
Return an iterator that reads the list of files to search from a
given file. If I<$filename> is '-', then it reads from STDIN.
=cut
sub from_file {
my $class = shift;
my $opt = shift;
my $file = shift;
my $error_handler = _generate_error_handler();
my $iter =
File::Next::from_file( {
error_handler => $error_handler,
warning_handler => $error_handler,
sort_files => $opt->{sort_files},
}, $file ) or return undef;
return bless {
iter => $iter,
}, $class;
}
=head2 from_stdin()
This is for reading input lines from STDIN, not the list of files
from STDIN.
=cut
sub from_stdin {
my $class = shift;
my $self = bless {}, $class;
$self->{iter} = sub {
state $has_been_called = 0;
if ( !$has_been_called ) {
$has_been_called = 1;
return '-';
}
return;
};
return $self;
}
sub next {
my $self = shift;
my $file = $self->{iter}->();
return unless defined($file);
return App::Ack::File->new( $file );
}
sub _generate_error_handler {
if ( $App::Ack::report_bad_filenames ) {
return sub {
my $msg = shift;
App::Ack::warn( $msg );
};
}
else {
return sub {};
}
}
1;
ack-v3.8.1/lib/App/Ack/ConfigFinder.pm 000644 000766 000024 00000006660 14376470274 017453 0 ustar 00andy staff 000000 000000 package App::Ack::ConfigFinder;
=head1 NAME
App::Ack::ConfigFinder
=head1 DESCRIPTION
A module that contains the logic for locating the various configuration
files.
=head1 LOCATING CONFIG FILES
First, ack looks for a global ackrc.
=over
=item On Windows, this is `ackrc` in either COMMON_APPDATA or APPDATA.
If `ackrc` is present in both directories, ack uses both files in that
order.
=item On a non-Windows OS, this is `/etc/ackrc`.
=back
Then, ack looks for a user-specific ackrc if the HOME environment
variable is set. This is either F<$HOME/.ackrc> or F<$HOME/_ackrc>.
Then, ack looks for a project-specific ackrc file. ack searches
up the directory hierarchy for the first `.ackrc` or `_ackrc` file.
If this is one of the ackrc files found in the previous steps, it is
not loaded again.
It is a fatal error if a directory contains both F<.ackrc> and F<_ackrc>.
After ack loads the options from the found ackrc files, ack looks
at the C environment variable.
Finally, ack takes settings from the command line.
=cut
use strict;
use warnings;
use App::Ack ();
use Cwd 3.00 ();
use File::Spec 3.00 ();
use if ($^O eq 'MSWin32'), 'Win32';
=head1 METHODS
=head2 new
Creates a new config finder.
=cut
sub new {
my ( $class ) = @_;
return bless {}, $class;
}
sub _remove_redundancies {
my @configs = @_;
my %seen;
my @uniq;
foreach my $config (@configs) {
my $path = $config->{path};
my $key = -e $path ? Cwd::realpath( $path ) : $path;
if ( not $App::Ack::is_windows ) {
# On Unix, uniquify on inode.
my ($dev, $inode) = (stat $key)[0, 1];
$key = "$dev:$inode" if defined $dev;
}
push( @uniq, $config ) unless $seen{$key}++;
}
return @uniq;
}
sub _check_for_ackrc {
return unless defined $_[0];
my @files = grep { -f }
map { File::Spec->catfile(@_, $_) }
qw(.ackrc _ackrc);
App::Ack::die( File::Spec->catdir(@_) . ' contains both .ackrc and _ackrc. Please remove one of those files.' )
if @files > 1;
return wantarray ? @files : $files[0];
} # end _check_for_ackrc
=head2 $finder->find_config_files
Locates config files, and returns a list of them.
=cut
sub find_config_files {
my @config_files;
if ( $App::Ack::is_windows ) {
push @config_files, map { +{ path => File::Spec->catfile($_, 'ackrc') } } (
Win32::GetFolderPath(Win32::CSIDL_COMMON_APPDATA()),
Win32::GetFolderPath(Win32::CSIDL_APPDATA()),
);
}
else {
push @config_files, { path => '/etc/ackrc' };
}
if ( $ENV{'ACKRC'} && -f $ENV{'ACKRC'} ) {
push @config_files, { path => $ENV{'ACKRC'} };
}
else {
push @config_files, map { +{ path => $_ } } _check_for_ackrc($ENV{'HOME'});
}
my $cwd = Cwd::getcwd();
return () unless defined $cwd;
# XXX This should go through some untainted cwd-fetching function, and not get untainted brute-force like this.
$cwd =~ /(.+)/;
$cwd = $1;
my @dirs = File::Spec->splitdir( $cwd );
while ( @dirs ) {
my $ackrc = _check_for_ackrc(@dirs);
if ( defined $ackrc ) {
push @config_files, { project => 1, path => $ackrc };
last;
}
pop @dirs;
}
# We only test for existence here, so if the file is deleted out from under us, this will fail later.
return _remove_redundancies( @config_files );
}
1;
ack-v3.8.1/lib/App/Ack/File.pm 000644 000766 000024 00000011054 14376470274 015766 0 ustar 00andy staff 000000 000000 package App::Ack::File;
use warnings;
use strict;
use App::Ack ();
use File::Spec ();
=head1 NAME
App::Ack::File
=head1 DESCRIPTION
Abstracts a file from the filesystem.
=head1 METHODS
=head2 new( $filename )
Opens the file specified by I<$filename> and returns a filehandle and
a flag that says whether it could be binary.
If there's a failure, it throws a warning and returns an empty list.
=cut
sub new {
my $class = shift;
my $filename = shift;
my $self = bless {
filename => $filename,
fh => undef,
}, $class;
if ( $self->{filename} eq '-' ) {
$self->{fh} = *STDIN;
}
return $self;
}
=head2 $file->name()
Returns the name of the file.
=cut
sub name {
return $_[0]->{filename};
}
=head2 $file->basename()
Returns the basename (the last component the path)
of the file.
=cut
sub basename {
my ( $self ) = @_;
return $self->{basename} //= (File::Spec->splitpath($self->name))[2];
}
=head2 $file->open()
Opens a filehandle for reading this file and returns it, or returns
undef if the operation fails (the error is in C<$!>). Instead of calling
C, C<$file-Eclose> should be called.
=cut
sub open {
my ( $self ) = @_;
if ( !$self->{fh} ) {
if ( open $self->{fh}, '<', $self->{filename} ) {
# Do nothing.
}
else {
$self->{fh} = undef;
}
}
return $self->{fh};
}
sub may_be_present {
my $self = shift;
my $regex = shift;
# Tells if the file needs a line-by-line scan. This is a big
# optimization because if you can tell from the outset that the pattern
# is not found in the file at all, then there's no need to do the
# line-by-line iteration.
# Slurp up an entire file up to 10M, see if there are any matches
# in it, and if so, let us know so we can iterate over it directly.
# The $regex may be undef if it had a "$" in it, and is therefore unsuitable for this heuristic.
my $may_be_present = 1;
if ( $regex && $self->open() && -f $self->{fh} ) {
my $buffer;
my $size = 10_000_000;
my $rc = sysread( $self->{fh}, $buffer, $size );
if ( !defined($rc) ) {
if ( $App::Ack::report_bad_filenames ) {
App::Ack::warn( $self->name . ": $!" );
}
$may_be_present = 0;
}
else {
# If we read all 10M, then we need to scan the rest.
# If there are any carriage returns, our results are flaky, so scan the rest.
if ( ($rc == $size) || (index($buffer,"\r") >= 0) ) {
$may_be_present = 1;
}
else {
if ( $buffer !~ /$regex/o ) {
$may_be_present = 0;
}
}
}
}
return $may_be_present;
}
=head2 $file->reset()
Resets the file back to the beginning. This is only called if
C is true, but not always if C
is true.
=cut
sub reset {
my $self = shift;
if ( defined($self->{fh}) ) {
return unless -f $self->{fh};
if ( !seek( $self->{fh}, 0, 0 ) && $App::Ack::report_bad_filenames ) {
App::Ack::warn( "$self->{filename}: $!" );
}
}
return;
}
=head2 $file->close()
Close the file.
=cut
sub close {
my $self = shift;
if ( $self->{fh} ) {
if ( !close($self->{fh}) && $App::Ack::report_bad_filenames ) {
App::Ack::warn( $self->name() . ": $!" );
}
$self->{fh} = undef;
}
return;
}
=head2 $file->clone()
Clones this file.
=cut
sub clone {
my ( $self ) = @_;
return __PACKAGE__->new($self->name);
}
=head2 $file->firstliney()
Returns the first line of a file (or first 250 characters, whichever
comes first).
=cut
sub firstliney {
my ( $self ) = @_;
if ( !exists $self->{firstliney} ) {
my $fh = $self->open();
if ( !$fh ) {
if ( $App::Ack::report_bad_filenames ) {
App::Ack::warn( $self->name . ': ' . $! );
}
$self->{firstliney} = '';
}
else {
my $buffer;
my $rc = sysread( $fh, $buffer, 250 );
if ( $rc ) {
$buffer =~ s/[\r\n].*//s;
}
else {
if ( !defined($rc) ) {
App::Ack::warn( $self->name . ': ' . $! );
}
$buffer = '';
}
$self->{firstliney} = $buffer;
$self->reset;
}
}
return $self->{firstliney};
}
1;
ack-v3.8.1/lib/App/Ack/Filter.pm 000644 000766 000024 00000004624 14376470274 016341 0 ustar 00andy staff 000000 000000 package App::Ack::Filter;
use strict;
use warnings;
use App::Ack ();
use App::Ack::Filter::Inverse ();
my %filter_types;
=head1 NAME
App::Ack::Filter - Filter objects to filter files
=head1 DESCRIPTION
An abstract superclass that represents objects that can filter
C objects. App::Ack::Filter implementations are
responsible for filtering filenames to be searched.
=head1 SYNOPSIS
# filter implementation
package MyFilter;
use strict;
use warnings;
use parent 'App::Ack::Filter';
sub filter {
my ( $self, $file ) = @_;
}
BEGIN {
App::Ack::Filter->register_filter('mine' => __PACKAGE__);
}
1;
# users
App::Ack::Filter->create_filter('mine', @args);
=head1 METHODS
=head2 App::Ack::Filter->create_filter($type, @args)
Creates a filter implementation, registered as C<$type>. C<@args>
are provided as additional arguments to the implementation's constructor.
=cut
sub create_filter {
my ( undef, $type, @args ) = @_;
if ( my $package = $filter_types{$type} ) {
return $package->new(@args);
}
my $allowed_types = join( ', ', sort keys %filter_types );
App::Ack::die( "Unknown filter type '$type'. Type must be one of: $allowed_types." );
}
=head2 App::Ack::Filter->register_filter($type, $package)
Registers a filter implementation package C<$package> under
the name C<$type>.
=cut
sub register_filter {
my ( undef, $type, $package ) = @_;
$filter_types{$type} = $package;
return;
}
=head2 $filter->filter( $file )
Must be implemented by filter implementations. Returns
true if the filter passes, false otherwise. This method
must B alter the passed-in C<$file> object.
=head2 $filter->invert()
Returns a filter whose L method returns the opposite of this filter.
=cut
sub invert {
my ( $self ) = @_;
return App::Ack::Filter::Inverse->new( $self );
}
=head2 $filter->is_inverted()
Returns true if this filter is an inverted filter; false otherwise.
=cut
sub is_inverted {
return 0;
}
=head2 $filter->to_string
Converts the filter to a string. This method is also
called implicitly by stringification.
=cut
sub to_string {
return '(unimplemented to_string)';
}
=head2 $filter->inspect
Prints a human-readable debugging string for this filter. Useful for,
you guessed it, debugging.
=cut
sub inspect {
my ( $self ) = @_;
return ref($self);
}
1;
ack-v3.8.1/lib/App/Ack/ConfigLoader.pm 000644 000766 000024 00000075476 14731437760 017463 0 ustar 00andy staff 000000 000000 package App::Ack::ConfigLoader;
use strict;
use warnings;
use 5.010;
use App::Ack ();
use App::Ack::ConfigDefault ();
use App::Ack::ConfigFinder ();
use App::Ack::Filter ();
use App::Ack::Filter::Collection ();
use App::Ack::Filter::Default ();
use App::Ack::Filter::IsPath ();
use File::Spec 3.00 ();
use Getopt::Long 2.38 ();
use Text::ParseWords 3.1 ();
sub configure_parser {
my @opts = @_;
my @standard = qw(
default
bundling
no_auto_help
no_auto_version
no_ignore_case
);
Getopt::Long::Configure( @standard, @opts );
return;
}
sub _generate_ignore_dir {
my ( $option_name, $opt ) = @_;
my $is_inverted = $option_name =~ /^--no/;
return sub {
my ( undef, $dir ) = @_;
$dir = _remove_directory_separator( $dir );
if ( $dir !~ /:/ ) {
$dir = 'is:' . $dir;
}
my ( $filter_type, $args ) = split /:/, $dir, 2;
if ( $filter_type eq 'firstlinematch' ) {
App::Ack::die( qq{Invalid filter specification "$filter_type" for option '$option_name'} );
}
my $filter = App::Ack::Filter->create_filter($filter_type, split(/,/, $args));
my $collection;
my $previous_inversion_matches = $opt->{idirs} && !($is_inverted xor $opt->{idirs}[-1]->is_inverted());
if ( $previous_inversion_matches ) {
$collection = $opt->{idirs}[-1];
if ( $is_inverted ) {
# This relies on invert of an inverted filter to return the original.
$collection = $collection->invert();
}
}
else {
$collection = App::Ack::Filter::Collection->new();
push @{ $opt->{idirs} }, $is_inverted ? $collection->invert() : $collection;
}
$collection->add($filter);
if ( $filter_type eq 'is' ) {
$collection->add(App::Ack::Filter::IsPath->new($args));
}
};
}
sub _remove_directory_separator {
my $path = shift;
state $dir_sep_chars = $App::Ack::is_windows ? quotemeta( '\\/' ) : quotemeta( File::Spec->catfile( '', '' ) );
$path =~ s/[$dir_sep_chars]$//;
return $path;
}
sub _process_filter_spec {
my ( $spec ) = @_;
if ( $spec =~ /^(\w+):(\w+):(.*)/ ) {
my ( $type_name, $ext_type, $arguments ) = ( $1, $2, $3 );
return ( $type_name,
App::Ack::Filter->create_filter($ext_type, split(/,/, $arguments)) );
}
elsif ( $spec =~ /^(\w+)=(.*)/ ) { # Check to see if we have ack1-style argument specification.
my ( $type_name, $extensions ) = ( $1, $2 );
my @extensions = split(/,/, $extensions);
foreach my $extension ( @extensions ) {
$extension =~ s/^[.]//;
}
return ( $type_name, App::Ack::Filter->create_filter('ext', @extensions) );
}
else {
App::Ack::die( "Invalid filter specification '$spec'" );
}
}
sub _uninvert_filter {
my ( $opt, @filters ) = @_;
return unless defined $opt->{filters} && @filters;
# Loop through all the registered filters. If we hit one that
# matches this extension and it's inverted, we need to delete it from
# the options.
for ( my $i = 0; $i < @{ $opt->{filters} }; $i++ ) {
my $opt_filter = @{ $opt->{filters} }[$i];
# XXX Do a real list comparison? This just checks string equivalence.
if ( $opt_filter->is_inverted() && "$opt_filter->{filter}" eq "@filters" ) {
splice @{ $opt->{filters} }, $i, 1;
$i--;
}
}
return;
}
sub _process_filetypes {
my ( $opt, $arg_sources ) = @_;
my %additional_specs;
my $add_spec = sub {
my ( undef, $spec ) = @_;
my ( $name, $filter ) = _process_filter_spec($spec);
push @{ $App::Ack::mappings{$name} }, $filter;
$additional_specs{$name . '!'} = sub {
my ( undef, $value ) = @_;
my @filters = @{ $App::Ack::mappings{$name} };
if ( not $value ) {
@filters = map { $_->invert() } @filters;
}
else {
_uninvert_filter( $opt, @filters );
}
push @{ $opt->{'filters'} }, @filters;
};
};
my $set_spec = sub {
my ( undef, $spec ) = @_;
my ( $name, $filter ) = _process_filter_spec($spec);
$App::Ack::mappings{$name} = [ $filter ];
$additional_specs{$name . '!'} = sub {
my ( undef, $value ) = @_;
my @filters = @{ $App::Ack::mappings{$name} };
if ( not $value ) {
@filters = map { $_->invert() } @filters;
}
push @{ $opt->{'filters'} }, @filters;
};
};
my $delete_spec = sub {
my ( undef, $name ) = @_;
delete $App::Ack::mappings{$name};
delete $additional_specs{$name . '!'};
};
my %type_arg_specs = (
'type-add=s' => $add_spec,
'type-set=s' => $set_spec,
'type-del=s' => $delete_spec,
);
configure_parser( 'no_auto_abbrev', 'pass_through' );
foreach my $source (@{$arg_sources}) {
my $args = $source->{contents};
if ( ref($args) ) {
# $args are modified in place, so no need to munge $arg_sources
Getopt::Long::GetOptionsFromArray( $args, %type_arg_specs );
}
else {
( undef, $source->{contents} ) =
Getopt::Long::GetOptionsFromString( $args, %type_arg_specs );
}
}
$additional_specs{'k|known-types'} = sub {
my @filters = map { @{$_} } values(%App::Ack::mappings);
push @{ $opt->{'filters'} }, @filters;
};
return \%additional_specs;
}
sub get_arg_spec {
my ( $opt, $extra_specs ) = @_;
=begin Adding-Options
*** IF YOU ARE MODIFYING ACK PLEASE READ THIS ***
If you plan to add a new option to ack, please make sure of
the following:
* Your new option has a test underneath the t/ directory.
* Your new option is explained when a user invokes ack --help.
(See App::Ack::show_help)
* Your new option is explained when a user invokes ack --man.
(See the POD at the end of ./ack)
* Add your option to t/config-loader.t
* Add your option to t/Util.pm#get_expected_options
* Add your option's description and aliases to dev/generate-completion-scripts.pl
* Go through the list of options already available, and consider
whether your new option can be considered mutex with another option.
=end Adding-Options
=cut
sub _type_handler {
my ( $getopt, $value ) = @_;
my $cb_value = 1;
if ( $value =~ s/^no// ) {
$cb_value = 0;
}
my $callback;
{
no warnings;
$callback = $extra_specs->{ $value . '!' };
}
if ( $callback ) {
$callback->( $getopt, $cb_value );
}
else {
App::Ack::die( "Unknown type '$value'" );
}
return;
}
$opt->{and} = [];
$opt->{or} = [];
$opt->{not} = [];
return {
1 => sub { $opt->{1} = $opt->{m} = 1 },
'and=s' => $opt->{and},
'A|after-context:-1' => sub { shift; $opt->{A} = _context_value(shift) },
'B|before-context:-1' => sub { shift; $opt->{B} = _context_value(shift) },
'C|context:-1' => sub { shift; $opt->{B} = $opt->{A} = _context_value(shift) },
'break!' => \$opt->{break},
'c|count' => \$opt->{c},
'color|colour!' => \$opt->{color},
'color-match=s' => \$ENV{ACK_COLOR_MATCH},
'color-filename=s' => \$ENV{ACK_COLOR_FILENAME},
'color-colno=s' => \$ENV{ACK_COLOR_COLNO},
'color-lineno=s' => \$ENV{ACK_COLOR_LINENO},
'column!' => \$opt->{column},
'create-ackrc' => sub { say for ( '--ignore-ack-defaults', App::Ack::ConfigDefault::options() ); exit; },
'debug' => \$opt->{debug},
'env!' => sub {
my ( undef, $value ) = @_;
if ( !$value ) {
$opt->{noenv_seen} = 1;
}
},
f => \$opt->{f},
'files-from=s' => \$opt->{files_from},
'filter!' => \$App::Ack::is_filter_mode,
flush => sub { $| = 1 },
'follow!' => \$opt->{follow},
g => \$opt->{g},
'group!' => sub { shift; $opt->{heading} = $opt->{break} = shift },
'heading!' => \$opt->{heading},
'h|no-filename' => \$opt->{h},
'H|with-filename' => \$opt->{H},
'i|ignore-case' => sub { $opt->{i} = 1; $opt->{S} = 0; },
'I|no-ignore-case' => sub { $opt->{i} = 0; $opt->{S} = 0; },
'ignore-directory|ignore-dir=s' => _generate_ignore_dir('--ignore-dir', $opt),
'ignore-file=s' => sub {
my ( undef, $file ) = @_;
my ( $filter_type, $args ) = split /:/, $file, 2;
my $filter = App::Ack::Filter->create_filter($filter_type, split(/,/, $args//''));
if ( !$opt->{ifiles} ) {
$opt->{ifiles} = App::Ack::Filter::Collection->new();
}
$opt->{ifiles}->add($filter);
},
'l|files-with-matches'
=> \$opt->{l},
'L|files-without-matches'
=> \$opt->{L},
'm|max-count=i' => \$opt->{m},
'match=s' => \$opt->{regex},
'n|no-recurse' => \$opt->{n},
o => sub { $opt->{output} = '$&' },
'output=s' => \$opt->{output},
'pager:s' => sub {
my ( undef, $value ) = @_;
$opt->{pager} = $value || $ENV{PAGER};
},
'noignore-directory|noignore-dir=s' => _generate_ignore_dir('--noignore-dir', $opt),
'nopager' => sub { $opt->{pager} = undef },
'not=s' => $opt->{not},
'or=s' => $opt->{or},
'passthru' => \$opt->{passthru},
'print0' => \$opt->{print0},
'p|proximate:1' => \$opt->{p},
'P' => sub { $opt->{p} = 0 },
'Q|literal' => \$opt->{Q},
'r|R|recurse' => sub { $opt->{n} = 0 },
'range-start=s' => \$opt->{range_start},
'range-end=s' => \$opt->{range_end},
'range-invert!' => \$opt->{range_invert},
's' => \$opt->{s},
'show-types' => \$opt->{show_types},
'S|smart-case!' => sub { my (undef,$value) = @_; $opt->{S} = $value; $opt->{i} = 0 if $value; },
'sort-files' => \$opt->{sort_files},
't|type=s' => \&_type_handler,
'T=s' => sub { my ($getopt,$value) = @_; $value="no$value"; _type_handler($getopt,$value); },
'underline!' => \$opt->{underline},
'v|invert-match' => \$opt->{v},
'w|word-regexp' => \$opt->{w},
'x' => sub { $opt->{files_from} = '-' },
'help' => sub { App::Ack::show_help(); exit; },
'help-types' => sub { App::Ack::show_help_types(); exit; },
'help-colors' => sub { App::Ack::show_help_colors(); exit; },
'help-rgb-colors' => sub { App::Ack::show_help_rgb(); exit; },
$extra_specs ? %{$extra_specs} : (),
}; # arg_specs
}
sub _context_value {
my $val = shift;
# Contexts default to 2.
return (!defined($val) || ($val < 0)) ? 2 : $val;
}
sub _process_other {
my ( $opt, $extra_specs, $arg_sources ) = @_;
my $argv_source;
my $is_help_types_active;
foreach my $source (@{$arg_sources}) {
if ( $source->{name} eq 'ARGV' ) {
$argv_source = $source->{contents};
last;
}
}
if ( $argv_source ) { # This *should* always be true, but you never know...
configure_parser( 'pass_through' );
Getopt::Long::GetOptionsFromArray( [ @{$argv_source} ],
'help-types' => \$is_help_types_active,
);
}
my $arg_specs = get_arg_spec( $opt, $extra_specs );
configure_parser();
foreach my $source (@{$arg_sources}) {
my ( $source_name, $args ) = @{$source}{qw/name contents/};
my $args_for_source = { %{$arg_specs} };
if ( $source->{is_ackrc} ) {
my $illegal = sub {
my $name = shift;
App::Ack::die( "Option --$name is forbidden in .ackrc files." );
};
$args_for_source = {
%{$args_for_source},
'output=s' => $illegal,
'match=s' => $illegal,
};
}
if ( $source->{project} ) {
my $illegal = sub {
my $name = shift;
App::Ack::die( "Option --$name is forbidden in project .ackrc files." );
};
$args_for_source = {
%{$args_for_source},
'pager:s' => $illegal,
};
}
my $ret;
if ( ref($args) ) {
$ret = Getopt::Long::GetOptionsFromArray( $args, %{$args_for_source} );
}
else {
( $ret, $source->{contents} ) =
Getopt::Long::GetOptionsFromString( $args, %{$args_for_source} );
}
if ( !$ret ) {
if ( !$is_help_types_active ) {
my $where = $source_name eq 'ARGV' ? 'on command line' : "in $source_name";
App::Ack::die( "Invalid option $where" );
}
}
if ( $opt->{noenv_seen} ) {
App::Ack::die( "--noenv found in $source_name" );
}
}
# XXX We need to check on a -- in the middle of a non-ARGV source
return;
}
sub _explode_sources {
my ( $sources ) = @_;
my @new_sources;
my %opt;
my $arg_spec = get_arg_spec( \%opt, {} );
my $dummy_sub = sub {};
my $add_type = sub {
my ( undef, $arg ) = @_;
if ( $arg =~ /(\w+)=/) {
$arg_spec->{$1} = $dummy_sub;
}
else {
( $arg ) = split /:/, $arg;
$arg_spec->{$arg} = $dummy_sub;
}
};
my $del_type = sub {
my ( undef, $arg ) = @_;
delete $arg_spec->{$arg};
};
configure_parser( 'pass_through' );
foreach my $source (@{$sources}) {
my ( $name, $options ) = @{$source}{qw/name contents/};
if ( ref($options) ne 'ARRAY' ) {
$source->{contents} = $options =
[ Text::ParseWords::shellwords($options) ];
}
for my $j ( 0 .. @{$options}-1 ) {
next unless $options->[$j] =~ /^-/;
my @chunk = ( $options->[$j] );
push @chunk, $options->[$j] while ++$j < @{$options} && $options->[$j] !~ /^-/;
$j--;
my @copy = @chunk;
Getopt::Long::GetOptionsFromArray( [@chunk],
'type-add=s' => $add_type,
'type-set=s' => $add_type,
'type-del=s' => $del_type,
%{$arg_spec}
);
push @new_sources, {
name => $name,
contents => \@copy,
};
}
}
return \@new_sources;
}
sub _compare_opts {
my ( $a, $b ) = @_;
my $first_a = $a->[0];
my $first_b = $b->[0];
$first_a =~ s/^--?//;
$first_b =~ s/^--?//;
return $first_a cmp $first_b;
}
sub _dump_options {
my ( $sources ) = @_;
$sources = _explode_sources($sources);
my %opts_by_source;
my @source_names;
foreach my $source (@{$sources}) {
my $name = $source->{name};
if ( not $opts_by_source{$name} ) {
$opts_by_source{$name} = [];
push @source_names, $name;
}
push @{$opts_by_source{$name}}, $source->{contents};
}
foreach my $name (@source_names) {
my $contents = $opts_by_source{$name};
say $name;
say '=' x length($name);
say ' ', join(' ', @{$_}) for sort { _compare_opts($a, $b) } @{$contents};
}
return;
}
sub _remove_default_options_if_needed {
my ( $sources ) = @_;
my $default_index;
foreach my $index ( 0 .. $#{$sources} ) {
if ( $sources->[$index]{'name'} eq 'Defaults' ) {
$default_index = $index;
last;
}
}
return $sources unless defined $default_index;
my $should_remove = 0;
configure_parser( 'no_auto_abbrev', 'pass_through' );
foreach my $index ( $default_index + 1 .. $#{$sources} ) {
my $args = $sources->[$index]->{contents};
if (ref($args)) {
Getopt::Long::GetOptionsFromArray( $args,
'ignore-ack-defaults' => \$should_remove,
);
}
else {
( undef, $sources->[$index]{contents} ) = Getopt::Long::GetOptionsFromString( $args,
'ignore-ack-defaults' => \$should_remove,
);
}
}
return $sources unless $should_remove;
my @copy = @{$sources};
splice @copy, $default_index, 1;
return \@copy;
}
sub process_args {
my $arg_sources = \@_;
my %opt = (
pager => $ENV{ACK_PAGER_COLOR} || $ENV{ACK_PAGER},
);
$arg_sources = _remove_default_options_if_needed($arg_sources);
# Check for --dump early.
foreach my $source (@{$arg_sources}) {
if ( $source->{name} eq 'ARGV' ) {
my $dump;
configure_parser( 'pass_through' );
Getopt::Long::GetOptionsFromArray( $source->{contents},
'dump' => \$dump,
);
if ( $dump ) {
_dump_options($arg_sources);
exit(0);
}
}
}
my $type_specs = _process_filetypes(\%opt, $arg_sources);
_check_for_mutex_options( $type_specs );
_process_other(\%opt, $type_specs, $arg_sources);
while ( @{$arg_sources} ) {
my $source = shift @{$arg_sources};
my $args = $source->{contents};
# All of our sources should be transformed into an array ref
if ( ref($args) ) {
my $source_name = $source->{name};
if ( $source_name eq 'ARGV' ) {
@ARGV = @{$args};
}
elsif (@{$args}) {
App::Ack::die( "Source '$source_name' has extra arguments!" );
}
}
else {
App::Ack::die( 'The impossible has occurred!' );
}
}
my $filters = ($opt{filters} ||= []);
# Throw the default filter in if no others are selected.
if ( not grep { !$_->is_inverted() } @{$filters} ) {
push @{$filters}, App::Ack::Filter::Default->new();
}
return \%opt;
}
sub retrieve_arg_sources {
my @arg_sources;
my $noenv;
my $ackrc;
configure_parser( 'no_auto_abbrev', 'pass_through' );
Getopt::Long::GetOptions(
'noenv' => \$noenv,
'ackrc=s' => \$ackrc,
);
my @files;
if ( !$noenv ) {
my $finder = App::Ack::ConfigFinder->new;
@files = $finder->find_config_files;
}
if ( $ackrc ) {
# We explicitly use open so we get a nice error message.
# XXX This is a potential race condition!.
if ( open my $fh, '<', $ackrc ) {
close $fh;
}
else {
App::Ack::die( "Unable to load ackrc '$ackrc': $!" );
}
push( @files, { path => $ackrc } );
}
push @arg_sources, {
name => 'Defaults',
contents => [ App::Ack::ConfigDefault::options_clean() ],
};
foreach my $file ( @files) {
my @lines = read_rcfile($file->{path});
if ( @lines ) {
push @arg_sources, {
name => $file->{path},
contents => \@lines,
project => $file->{project},
is_ackrc => 1,
};
}
}
push @arg_sources, {
name => 'ARGV',
contents => [ @ARGV ],
};
return @arg_sources;
}
sub read_rcfile {
my $file = shift;
return unless defined $file && -e $file;
my @lines;
open( my $fh, '<', $file ) or App::Ack::die( "Unable to read $file: $!" );
while ( defined( my $line = <$fh> ) ) {
chomp $line;
$line =~ s/^\s+//;
$line =~ s/\s+$//;
next if $line eq '';
next if $line =~ /^\s*#/;
push( @lines, $line );
}
close $fh or App::Ack::die( "Unable to close $file: $!" );
return @lines;
}
# Verifies no mutex options were passed. Dies if they were.
sub _check_for_mutex_options {
my $type_specs = shift;
my $mutex = mutex_options();
my ($raw,$used) = _options_used( $type_specs );
my @used = sort { lc $a cmp lc $b } keys %{$used};
for my $i ( @used ) {
for my $j ( @used ) {
next if $i eq $j;
if ( $mutex->{$i}{$j} ) {
my $x = $raw->[ $used->{$i} ];
my $y = $raw->[ $used->{$j} ];
App::Ack::die( "Options '$x' and '$y' can't be used together." );
}
}
}
return;
}
# Processes the command line option and returns a hash of the options that were
# used on the command line, using their full name. "--prox" shows up in the hash as "--proximate".
sub _options_used {
my $type_specs = shift;
my %dummy_opt;
my $real_spec = get_arg_spec( \%dummy_opt, $type_specs );
# The real argument parsing doesn't check for --type-add, --type-del or --type-set because
# they get removed by the argument processing. We have to account for them here.
my $sub_dummy = sub {};
$real_spec = {
%{$real_spec},
'type-add=s' => $sub_dummy,
'type-del=s' => $sub_dummy,
'type-set=s' => $sub_dummy,
'ignore-ack-defaults' => $sub_dummy,
};
my %parsed;
my @raw;
my %spec_capture_parsed;
my %spec_capture_raw;
=pod
We have to build two argument specs.
To populate the C<%parsed> hash: Capture the arguments that the user has
passed in, as parsed by the Getopt::Long::GetOptions function. Aliases are converted
down to their short options. If a user passes "--proximate", Getopt::Long
converts that to "-p" and we store it as "-p".
To populate the C<@raw> array: Capture the arguments raw, without having
been converted to their short options. If a user passes "--proximate",
we store it in C<@raw> as "--proximate".
=cut
# Capture the %parsed hash.
CAPTURE_PARSED: {
my $parsed_pos = 0;
my $sub_count = sub {
my $arg = shift;
$arg = "$arg";
$parsed{$arg} = $parsed_pos++;
};
%spec_capture_parsed = (
'<>' => sub { $parsed_pos++ }, # Bump forward one pos for non-options.
map { $_ => $sub_count } keys %{$real_spec}
);
}
# Capture the @raw array.
CAPTURE_RAW: {
my $raw_pos = 0;
%spec_capture_raw = (
'<>' => sub { $raw_pos++ }, # Bump forward one pos for non-options.
);
my $sub_count = sub {
my $arg = shift;
$arg = "$arg";
$raw[$raw_pos] = length($arg) == 1 ? "-$arg" : "--$arg";
$raw_pos++;
};
for my $opt_spec ( keys %{$real_spec} ) {
my $negatable;
my $type;
my $default;
$negatable = ($opt_spec =~ s/!$//);
if ( $opt_spec =~ s/(=[si])$// ) {
$type = $1;
}
if ( $opt_spec =~ s/(:.+)$// ) {
$default = $1;
}
my @aliases = split( /\|/, $opt_spec );
for my $alias ( @aliases ) {
$alias .= $type if defined $type;
$alias .= $default if defined $default;
$alias .= '!' if $negatable;
$spec_capture_raw{$alias} = $sub_count;
}
}
}
# Parse @ARGV twice, once with each capture spec.
configure_parser( 'pass_through' ); # Ignore invalid options.
Getopt::Long::GetOptionsFromArray( [@ARGV], %spec_capture_raw );
Getopt::Long::GetOptionsFromArray( [@ARGV], %spec_capture_parsed );
return (\@raw,\%parsed);
}
sub mutex_options {
# This list is machine-generated by dev/crank-mutex. Do not modify it by hand.
return {
1 => {
m => 1,
passthru => 1,
},
A => {
L => 1,
c => 1,
f => 1,
g => 1,
l => 1,
o => 1,
output => 1,
p => 1,
passthru => 1,
},
B => {
L => 1,
c => 1,
f => 1,
g => 1,
l => 1,
o => 1,
output => 1,
p => 1,
passthru => 1,
},
C => {
L => 1,
c => 1,
f => 1,
g => 1,
l => 1,
o => 1,
output => 1,
p => 1,
passthru => 1,
},
H => {
L => 1,
f => 1,
g => 1,
l => 1,
},
I => {
f => 1,
},
L => {
A => 1,
B => 1,
C => 1,
H => 1,
L => 1,
break => 1,
c => 1,
column => 1,
f => 1,
g => 1,
group => 1,
h => 1,
heading => 1,
l => 1,
'no-filename' => 1,
o => 1,
output => 1,
p => 1,
passthru => 1,
'show-types' => 1,
v => 1,
'with-filename' => 1,
},
and => {
g => 1,
not => 1,
or => 1,
},
break => {
L => 1,
c => 1,
f => 1,
g => 1,
l => 1,
},
c => {
A => 1,
B => 1,
C => 1,
L => 1,
break => 1,
column => 1,
f => 1,
g => 1,
group => 1,
heading => 1,
m => 1,
o => 1,
output => 1,
p => 1,
passthru => 1,
},
column => {
L => 1,
c => 1,
f => 1,
g => 1,
l => 1,
o => 1,
output => 1,
passthru => 1,
v => 1,
},
f => {
A => 1,
B => 1,
C => 1,
H => 1,
I => 1,
L => 1,
break => 1,
c => 1,
column => 1,
f => 1,
'files-from' => 1,
g => 1,
group => 1,
h => 1,
heading => 1,
i => 1,
l => 1,
m => 1,
match => 1,
o => 1,
output => 1,
p => 1,
passthru => 1,
'smart-case' => 1,
u => 1,
v => 1,
x => 1,
},
'files-from' => {
f => 1,
g => 1,
x => 1,
},
g => {
A => 1,
B => 1,
C => 1,
H => 1,
L => 1,
and => 1,
break => 1,
c => 1,
column => 1,
f => 1,
'files-from' => 1,
g => 1,
group => 1,
h => 1,
heading => 1,
l => 1,
m => 1,
match => 1,
not => 1,
o => 1,
or => 1,
output => 1,
p => 1,
passthru => 1,
u => 1,
x => 1,
},
group => {
L => 1,
c => 1,
f => 1,
g => 1,
l => 1,
},
h => {
L => 1,
f => 1,
g => 1,
l => 1,
},
heading => {
L => 1,
c => 1,
f => 1,
g => 1,
l => 1,
},
i => {
f => 1,
},
l => {
A => 1,
B => 1,
C => 1,
H => 1,
L => 1,
break => 1,
column => 1,
f => 1,
g => 1,
group => 1,
h => 1,
heading => 1,
l => 1,
'no-filename' => 1,
o => 1,
output => 1,
p => 1,
passthru => 1,
'show-types' => 1,
'with-filename' => 1,
},
m => {
1 => 1,
c => 1,
f => 1,
g => 1,
passthru => 1,
},
match => {
f => 1,
g => 1,
},
'no-filename' => {
L => 1,
l => 1,
},
not => {
and => 1,
g => 1,
},
o => {
A => 1,
B => 1,
C => 1,
L => 1,
c => 1,
column => 1,
f => 1,
g => 1,
l => 1,
o => 1,
output => 1,
p => 1,
passthru => 1,
'show-types' => 1,
v => 1,
},
or => {
and => 1,
g => 1,
},
output => {
A => 1,
B => 1,
C => 1,
L => 1,
c => 1,
column => 1,
f => 1,
g => 1,
l => 1,
o => 1,
output => 1,
p => 1,
passthru => 1,
'show-types' => 1,
u => 1,
v => 1,
},
p => {
A => 1,
B => 1,
C => 1,
L => 1,
c => 1,
f => 1,
g => 1,
l => 1,
o => 1,
output => 1,
p => 1,
passthru => 1,
},
passthru => {
1 => 1,
A => 1,
B => 1,
C => 1,
L => 1,
c => 1,
column => 1,
f => 1,
g => 1,
l => 1,
m => 1,
o => 1,
output => 1,
p => 1,
v => 1,
},
'show-types' => {
L => 1,
l => 1,
o => 1,
output => 1,
},
'smart-case' => {
f => 1,
},
u => {
f => 1,
g => 1,
output => 1,
},
v => {
L => 1,
column => 1,
f => 1,
o => 1,
output => 1,
passthru => 1,
},
'with-filename' => {
L => 1,
l => 1,
},
x => {
f => 1,
'files-from' => 1,
g => 1,
},
};
} # End of mutex_options()
1; # End of App::Ack::ConfigLoader
ack-v3.8.1/lib/App/Ack/Filter/ 000755 000766 000024 00000000000 14735132536 015770 5 ustar 00andy staff 000000 000000 ack-v3.8.1/lib/App/Ack/ConfigDefault.pm 000644 000766 000024 00000025753 14735132514 017623 0 ustar 00andy staff 000000 000000 package App::Ack::ConfigDefault;
use warnings;
use strict;
use App::Ack ();
=head1 NAME
App::Ack::ConfigDefault
=head1 DESCRIPTION
A module that contains the default configuration for ack.
=cut
sub options {
return split( /\n/, _options_block() );
}
sub options_clean {
return grep { /./ && !/^#/ } options();
}
sub _options_block {
my $lines = <<'HERE';
# This is the default ackrc for ack version ==VERSION==.
# There are four different ways to match
#
# is: Match the filename exactly
#
# ext: Match the extension of the filename exactly
#
# match: Match the filename against a Perl regular expression
#
# firstlinematch: Match the first 250 characters of the first line
# of text against a Perl regular expression. This is only for
# the --type-add option.
### Directories to ignore
# Bazaar
# https://bazaar.canonical.com/
--ignore-directory=is:.bzr
# Codeville
# http://freshmeat.sourceforge.net/projects/codeville
--ignore-directory=is:.cdv
# Interface Builder (Xcode)
# https://en.wikipedia.org/wiki/Interface_Builder
--ignore-directory=is:~.dep
--ignore-directory=is:~.dot
--ignore-directory=is:~.nib
--ignore-directory=is:~.plst
# Git
# https://git-scm.com/
--ignore-directory=is:.git
# When submodules are used, .git is a file.
--ignore-file=is:.git
# Mercurial
# https://www.mercurial-scm.org/
--ignore-directory=is:.hg
# Quilt
# https://directory.fsf.org/wiki/Quilt
--ignore-directory=is:.pc
# Subversion
# https://subversion.apache.org/
--ignore-directory=is:.svn
# Monotone
# https://www.monotone.ca/
--ignore-directory=is:_MTN
# CVS
# https://savannah.nongnu.org/projects/cvs
--ignore-directory=is:CVS
# RCS
# https://www.gnu.org/software/rcs/
--ignore-directory=is:RCS
# SCCS
# https://en.wikipedia.org/wiki/Source_Code_Control_System
--ignore-directory=is:SCCS
# darcs
# http://darcs.net/
--ignore-directory=is:_darcs
# Vault/Fortress
--ignore-directory=is:_sgbak
# autoconf
# https://www.gnu.org/software/autoconf/
--ignore-directory=is:autom4te.cache
# Perl module building
--ignore-directory=is:blib
--ignore-directory=is:_build
# Perl Devel::Cover module's output directory
# https://metacpan.org/release/Devel-Cover
--ignore-directory=is:cover_db
# Node modules created by npm
--ignore-directory=is:node_modules
# CMake cache
# https://www.cmake.org/
--ignore-directory=is:CMakeFiles
# Eclipse workspace folder
# https://eclipse.org/
--ignore-directory=is:.metadata
# Cabal (Haskell) sandboxes
# https://www.haskell.org/cabal/users-guide/installing-packages.html
--ignore-directory=is:.cabal-sandbox
# Python caches
# https://docs.python.org/3/tutorial/modules.html
--ignore-directory=is:__pycache__
--ignore-directory=is:.pytest_cache
# macOS Finder remnants
--ignore-directory=is:__MACOSX
--ignore-file=is:.DS_Store
### Files to ignore
# Backup files
--ignore-file=ext:bak
--ignore-file=match:/~$/
# Emacs swap files
--ignore-file=match:/^#.+#$/
# vi/vim swap files https://www.vim.org/
--ignore-file=match:/[._].*[.]swp$/
# core dumps
--ignore-file=match:/core[.]\d+$/
# minified JavaScript
--ignore-file=match:/[.-]min[.]js$/
--ignore-file=match:/[.]js[.]min$/
# minified CSS
--ignore-file=match:/[.]min[.]css$/
--ignore-file=match:/[.]css[.]min$/
# JS and CSS source maps
--ignore-file=match:/[.]js[.]map$/
--ignore-file=match:/[.]css[.]map$/
# PDFs, because they pass Perl's -T detection
--ignore-file=ext:pdf
# Common graphics, just as an optimization
--ignore-file=ext:gif,jpg,jpeg,png
# Common archives, as an optimization
--ignore-file=ext:gz,tar,tgz,zip
# Python compiled modules
--ignore-file=ext:pyc,pyd,pyo
# Python's pickle serialization format
# https://docs.python.org/2/library/pickle.html#example
# https://docs.python.org/3.7/library/pickle.html#examples
--ignore-file=ext:pkl,pickle
# C extensions
--ignore-file=ext:so
# Compiled gettext files
--ignore-file=ext:mo
# Visual Studio user and workspace settings
# https://code.visualstudio.com/docs/getstarted/settings
--ignore-dir=is:.vscode
### Filetypes defined
# Makefiles
# https://www.gnu.org/s/make/
--type-add=make:ext:mk
--type-add=make:ext:mak
--type-add=make:is:makefile
--type-add=make:is:Makefile
--type-add=make:is:Makefile.Debug
--type-add=make:is:Makefile.Release
--type-add=make:is:GNUmakefile
# Rakefiles
# https://rake.rubyforge.org/
--type-add=rake:is:Rakefile
# CMake
# https://cmake.org/
--type-add=cmake:is:CMakeLists.txt
--type-add=cmake:ext:cmake
# Bazel build tool
# https://docs.bazel.build/versions/master/skylark/bzl-style.html
--type-add=bazel:ext:bzl
# https://docs.bazel.build/versions/master/guide.html#bazelrc-the-bazel-configuration-file
--type-add=bazel:ext:bazelrc
# https://docs.bazel.build/versions/master/build-ref.html#BUILD_files
--type-add=bazel:is:BUILD
# https://docs.bazel.build/versions/master/build-ref.html#workspace
--type-add=bazel:is:WORKSPACE
# Actionscript
--type-add=actionscript:ext:as,mxml
# Ada
# https://www.adaic.org/
--type-add=ada:ext:ada,adb,ads
# ASP
# https://docs.microsoft.com/en-us/previous-versions/office/developer/server-technologies/aa286483(v=msdn.10)
--type-add=asp:ext:asp
# ASP.Net
# https://dotnet.microsoft.com/apps/aspnet
--type-add=aspx:ext:master,ascx,asmx,aspx,svc
# Assembly
--type-add=asm:ext:asm,s
# DOS/Windows batch
--type-add=batch:ext:bat,cmd
# ColdFusion
# https://en.wikipedia.org/wiki/ColdFusion
--type-add=cfmx:ext:cfc,cfm,cfml
# Clojure
# https://clojure.org/
--type-add=clojure:ext:clj,cljs,edn,cljc
# C
# .xs are Perl C files
--type-add=cc:ext:c,h,xs
# C header files
--type-add=hh:ext:h
# CoffeeScript
# https://coffeescript.org/
--type-add=coffeescript:ext:coffee
# C++
--type-add=cpp:ext:cpp,cc,cxx,m,hpp,hh,h,hxx
# C++ header files
--type-add=hpp:ext:hpp,hh,h,hxx
# C#
--type-add=csharp:ext:cs
# Crystal-lang
# https://crystal-lang.org/
--type-add=crystal:ext:cr,ecr
# CSS
# https://www.w3.org/Style/CSS/
--type-add=css:ext:css
# Dart
# https://dart.dev/
--type-add=dart:ext:dart
# Delphi
# https://en.wikipedia.org/wiki/Embarcadero_Delphi
--type-add=delphi:ext:pas,int,dfm,nfm,dof,dpk,dproj,groupproj,bdsgroup,bdsproj
# Elixir
# https://elixir-lang.org/
--type-add=elixir:ext:ex,exs
# Elm
# https://elm-lang.org
--type-add=elm:ext:elm
# Emacs Lisp
# https://www.gnu.org/software/emacs
--type-add=elisp:ext:el
# Erlang
# https://www.erlang.org/
--type-add=erlang:ext:erl,hrl
# Fortran
# https://en.wikipedia.org/wiki/Fortran
--type-add=fortran:ext:f,f77,f90,f95,f03,for,ftn,fpp
# Go
# https://golang.org/
--type-add=go:ext:go
# Groovy
# https://www.groovy-lang.org/
--type-add=groovy:ext:groovy,gtmpl,gpp,grunit,gradle
# GSP
# https://gsp.grails.org/
--type-add=gsp:ext:gsp
# Haskell
# https://www.haskell.org/
--type-add=haskell:ext:hs,lhs
# HTML
--type-add=html:ext:htm,html,xhtml
# Jade
# http://jade-lang.com/
--type-add=jade:ext:jade
# Java
# https://www.oracle.com/technetwork/java/index.html
--type-add=java:ext:java,properties
# JavaScript
--type-add=js:ext:js
# JSP
# https://www.oracle.com/technetwork/java/javaee/jsp/index.html
--type-add=jsp:ext:jsp,jspx,jspf,jhtm,jhtml
# JSON
# https://json.org/
--type-add=json:ext:json
# Kotlin
# https://kotlinlang.org/
--type-add=kotlin:ext:kt,kts
# Less
# http://www.lesscss.org/
--type-add=less:ext:less
# Common Lisp
# https://common-lisp.net/
--type-add=lisp:ext:lisp,lsp
# Lua
# https://www.lua.org/
--type-add=lua:ext:lua
--type-add=lua:firstlinematch:/^#!.*\blua(jit)?/
# Markdown
# https://en.wikipedia.org/wiki/Markdown
--type-add=markdown:ext:md,markdown
# We understand that there are many ad hoc extensions for markdown
# that people use. .md and .markdown are the two that ack recognizes.
# You are free to add your own in your ackrc file.
# Matlab
# https://en.wikipedia.org/wiki/MATLAB
--type-add=matlab:ext:m
# Objective-C
--type-add=objc:ext:m,h
# Objective-C++
--type-add=objcpp:ext:mm,h
# OCaml
# https://ocaml.org/
--type-add=ocaml:ext:ml,mli,mll,mly
# Perl
# https://perl.org/
--type-add=perl:ext:pl,pm,pod,t,psgi
--type-add=perl:firstlinematch:/^#!.*\bperl/
# Perl tests
--type-add=perltest:ext:t
# Perl's Plain Old Documentation format, POD
--type-add=pod:ext:pod
# PHP
# https://www.php.net/
--type-add=php:ext:php,phpt,php3,php4,php5,phtml
--type-add=php:firstlinematch:/^#!.*\bphp/
# Plone
# https://plone.org/
--type-add=plone:ext:pt,cpt,metadata,cpy,py
# PowerShell
# https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_scripts
# https://learn.microsoft.com/en-us/powershell/scripting/developer/module/understanding-a-windows-powershell-module
--type-add=powershell:ext:ps1,psm1
# PureScript
# https://www.purescript.org
--type-add=purescript:ext:purs
# Python
# https://www.python.org/
--type-add=python:ext:py
--type-add=python:firstlinematch:/^#!.*\bpython/
# Pytest
# https://pytest.org/
# Pytest files are *.py files that start with test_ or end with _test.py
# https://docs.pytest.org/en/stable/explanation/goodpractices.html#test-discovery
--type-add=pytest:match:_test\.py$
--type-add=pytest:match:^test_.*\.py$
# R
# https://www.r-project.org/
# https://r4ds.had.co.nz/r-markdown.html
--type-add=rr:ext:R,Rmd
# reStructured Text
# https://docutils.sourceforge.io/rst.html
--type-add=rst:ext:rst
# Ruby
# https://www.ruby-lang.org/
--type-add=ruby:ext:rb,rhtml,rjs,rxml,erb,rake,spec
--type-add=ruby:is:Rakefile
--type-add=ruby:firstlinematch:/^#!.*\bruby/
# Rust
# https://www.rust-lang.org/
--type-add=rust:ext:rs
# Sass
# https://sass-lang.com
--type-add=sass:ext:sass,scss
# Scala
# https://www.scala-lang.org/
--type-add=scala:ext:scala,sbt
# Scheme
# https://groups.csail.mit.edu/mac/projects/scheme/
--type-add=scheme:ext:scm,ss
# Shell
--type-add=shell:ext:sh,bash,csh,tcsh,ksh,zsh,fish
--type-add=shell:firstlinematch:/^#!.*\b(?:ba|t?c|k|z|fi)?sh\b/
# Smalltalk
# http://www.smalltalk.org/
--type-add=smalltalk:ext:st
# Smarty
# https://www.smarty.net/
--type-add=smarty:ext:tpl
# SQL
# https://www.iso.org/standard/45498.html
--type-add=sql:ext:sql,ctl
# Stylus
# http://stylus-lang.com/
--type-add=stylus:ext:styl
# SVG
# https://en.wikipedia.org/wiki/Scalable_Vector_Graphics
--type-add=svg:ext:svg
# Swift
# https://developer.apple.com/swift/
--type-add=swift:ext:swift
--type-add=swift:firstlinematch:/^#!.*\bswift/
# Tcl
# https://www.tcl.tk/
--type-add=tcl:ext:tcl,itcl,itk
# Terraform
# https://github.com/hashicorp/terraform
--type-add=terraform=.tf,.tfvars
# TeX & LaTeX
# https://www.latex-project.org/
--type-add=tex:ext:tex,cls,sty
# Template Toolkit (Perl)
# http//template-toolkit.org/
--type-add=ttml:ext:tt,tt2,ttml
# TOML
# https://toml.io/
--type-add=toml:ext:toml
# TypeScript
# https://www.typescriptlang.org/
--type-add=ts:ext:ts,tsx
# Visual Basic
--type-add=vb:ext:bas,cls,frm,ctl,vb,resx
# Verilog
--type-add=verilog:ext:v,vh,sv
# VHDL
# http://www.eda.org/twiki/bin/view.cgi/P1076/WebHome
--type-add=vhdl:ext:vhd,vhdl
# Vim
# https://www.vim.org/
--type-add=vim:ext:vim
# XML
# https://www.w3.org/TR/REC-xml/
--type-add=xml:ext:xml,dtd,xsd,xsl,xslt,ent,wsdl
--type-add=xml:firstlinematch:/<[?]xml/
# YAML
# https://yaml.org/
--type-add=yaml:ext:yaml,yml
HERE
$lines =~ s/==VERSION==/$App::Ack::VERSION/sm;
return $lines;
}
1;
ack-v3.8.1/lib/App/Ack/Filter/Is.pm 000644 000766 000024 00000001463 14376470274 016712 0 ustar 00andy staff 000000 000000 package App::Ack::Filter::Is;
=head1 NAME
App::Ack::Filter::Is
=head1 DESCRIPTION
Filters based on exact filename match.
=cut
use strict;
use warnings;
use parent 'App::Ack::Filter';
use File::Spec 3.00 ();
use App::Ack::Filter::IsGroup ();
sub new {
my ( $class, $filename ) = @_;
return bless {
filename => $filename,
groupname => 'IsGroup',
}, $class;
}
sub create_group {
return App::Ack::Filter::IsGroup->new();
}
sub filter {
my ( $self, $file ) = @_;
return (File::Spec->splitpath($file->name))[2] eq $self->{filename};
}
sub inspect {
my ( $self ) = @_;
return ref($self) . ' - ' . $self->{filename};
}
sub to_string {
my ( $self ) = @_;
return $self->{filename};
}
BEGIN {
App::Ack::Filter->register_filter(is => __PACKAGE__);
}
1;
ack-v3.8.1/lib/App/Ack/Filter/ExtensionGroup.pm 000644 000766 000024 00000001612 14376470274 021324 0 ustar 00andy staff 000000 000000 package App::Ack::Filter::ExtensionGroup;
=head1 NAME
App::Ack::Filter::ExtensionGroup
=head1 DESCRIPTION
The App::Ack::Filter::ExtensionGroup class optimizes multiple ::Extension
calls into one container. See App::Ack::Filter::IsGroup for details.
=cut
use strict;
use warnings;
use parent 'App::Ack::Filter';
sub new {
my ( $class ) = @_;
return bless {
data => {},
}, $class;
}
sub add {
my ( $self, $filter ) = @_;
foreach my $ext (@{$filter->{extensions}}) {
$self->{data}->{lc $ext} = 1;
}
return;
}
sub filter {
my ( $self, $file ) = @_;
if ($file->name =~ /[.]([^.]*)$/) {
return exists $self->{'data'}->{lc $1};
}
return 0;
}
sub inspect {
my ( $self ) = @_;
return ref($self) . " - $self";
}
sub to_string {
my ( $self ) = @_;
return join(' ', map { ".$_" } sort keys %{$self->{data}});
}
1;
ack-v3.8.1/lib/App/Ack/Filter/IsPathGroup.pm 000644 000766 000024 00000001401 14376470274 020534 0 ustar 00andy staff 000000 000000 package App::Ack::Filter::IsPathGroup;
=head1 NAME
App::Ack::Filter::IsPathGroup
=head1 DESCRIPTION
The App::Ack::Filter::IsPathGroup class optimizes multiple ::IsPath
calls into one container. See App::Ack::Filter::IsGroup for details.
=cut
use strict;
use warnings;
use parent 'App::Ack::Filter';
sub new {
my ( $class ) = @_;
return bless {
data => {},
}, $class;
}
sub add {
my ( $self, $filter ) = @_;
$self->{data}->{ $filter->{filename} } = 1;
return;
}
sub filter {
my ( $self, $file ) = @_;
return exists $self->{data}->{$file->name};
}
sub inspect {
my ( $self ) = @_;
return ref($self) . " - $self";
}
sub to_string {
my ( $self ) = @_;
return join(' ', keys %{$self->{data}});
}
1;
ack-v3.8.1/lib/App/Ack/Filter/Default.pm 000644 000766 000024 00000000645 14376470274 017724 0 ustar 00andy staff 000000 000000 package App::Ack::Filter::Default;
=head1 NAME
App::Ack::Filter::Default
=head1 DESCRIPTION
The class that implements the filter that ack uses by
default if you don't specify any filters on the command line.
=cut
use strict;
use warnings;
use parent 'App::Ack::Filter';
sub new {
my ( $class ) = @_;
return bless {}, $class;
}
sub filter {
my ( undef, $file ) = @_;
return -T $file->name;
}
1;
ack-v3.8.1/lib/App/Ack/Filter/MatchGroup.pm 000644 000766 000024 00000001531 14376470274 020404 0 ustar 00andy staff 000000 000000 package App::Ack::Filter::MatchGroup;
=head1 NAME
App::Ack::Filter::MatchGroup
=head1 DESCRIPTION
The App::Ack::Filter::MatchGroup class optimizes multiple ::Match calls
into one container. See App::Ack::Filter::IsGroup for details.
=cut
use strict;
use warnings;
use parent 'App::Ack::Filter';
sub new {
my ( $class ) = @_;
return bless {
matches => [],
big_re => undef,
}, $class;
}
sub add {
my ( $self, $filter ) = @_;
push @{ $self->{matches} }, $filter->{regex};
my $re = join('|', map { "(?:$_)" } @{ $self->{matches} });
$self->{big_re} = qr/$re/;
return;
}
sub filter {
my ( $self, $file ) = @_;
return $file->basename =~ /$self->{big_re}/;
}
# This class has no inspect() or to_string() method.
# It will just use the default one unless someone writes something useful.
1;
ack-v3.8.1/lib/App/Ack/Filter/IsPath.pm 000644 000766 000024 00000001276 14376470274 017531 0 ustar 00andy staff 000000 000000 package App::Ack::Filter::IsPath;
=head1 NAME
App::Ack::Filter::IsPath
=head1 DESCRIPTION
Filters based on path.
=cut
use strict;
use warnings;
use parent 'App::Ack::Filter';
use App::Ack::Filter::IsPathGroup ();
sub new {
my ( $class, $filename ) = @_;
return bless {
filename => $filename,
groupname => 'IsPathGroup',
}, $class;
}
sub create_group {
return App::Ack::Filter::IsPathGroup->new();
}
sub filter {
my ( $self, $file ) = @_;
return $file->name eq $self->{filename};
}
sub inspect {
my ( $self ) = @_;
return ref($self) . ' - ' . $self->{filename};
}
sub to_string {
my ( $self ) = @_;
return $self->{filename};
}
1;
ack-v3.8.1/lib/App/Ack/Filter/Collection.pm 000644 000766 000024 00000002476 14376470274 020437 0 ustar 00andy staff 000000 000000 package App::Ack::Filter::Collection;
=head1 NAME
App::Ack::Filter::Collection
=head1 DESCRIPTION
The Ack::Filter::Collection class can contain filters and internally sort
them into groups. The groups can then be optimized for faster filtering.
Filters are grouped and replaced by a fast hash lookup. This leads to
improved performance when many such filters are active, like when using
the C<--known> command line option.
=cut
use strict;
use warnings;
use parent 'App::Ack::Filter';
sub new {
my ( $class ) = @_;
return bless {
groups => {},
ungrouped => [],
}, $class;
}
sub filter {
my ( $self, $file ) = @_;
for my $group (values %{$self->{groups}}) {
return 1 if $group->filter($file);
}
for my $filter (@{$self->{ungrouped}}) {
return 1 if $filter->filter($file);
}
return 0;
}
sub add {
my ( $self, $filter ) = @_;
if (exists $filter->{'groupname'}) {
my $group = ($self->{groups}->{$filter->{groupname}} ||= $filter->create_group());
$group->add($filter);
}
else {
push @{$self->{'ungrouped'}}, $filter;
}
return;
}
sub inspect {
my ( $self ) = @_;
return ref($self) . " - $self";
}
sub to_string {
my ( $self ) = @_;
return join(', ', map { "($_)" } @{$self->{ungrouped}});
}
1;
ack-v3.8.1/lib/App/Ack/Filter/Extension.pm 000644 000766 000024 00000001727 14376470274 020316 0 ustar 00andy staff 000000 000000 package App::Ack::Filter::Extension;
=head1 NAME
App::Ack::Filter::Extension
=head1 DESCRIPTION
Implements filters based on extensions.
=cut
use strict;
use warnings;
use parent 'App::Ack::Filter';
use App::Ack::Filter ();
use App::Ack::Filter::ExtensionGroup ();
sub new {
my ( $class, @extensions ) = @_;
my $exts = join('|', map { "\Q$_\E"} @extensions);
my $re = qr/[.](?:$exts)$/i;
return bless {
extensions => \@extensions,
regex => $re,
groupname => 'ExtensionGroup',
}, $class;
}
sub create_group {
return App::Ack::Filter::ExtensionGroup->new();
}
sub filter {
my ( $self, $file ) = @_;
return $file->name =~ /$self->{regex}/;
}
sub inspect {
my ( $self ) = @_;
return ref($self) . ' - ' . $self->{regex};
}
sub to_string {
my ( $self ) = @_;
return join( ' ', map { ".$_" } @{$self->{extensions}} );
}
BEGIN {
App::Ack::Filter->register_filter(ext => __PACKAGE__);
}
1;
ack-v3.8.1/lib/App/Ack/Filter/FirstLineMatch.pm 000644 000766 000024 00000002002 14376470274 021201 0 ustar 00andy staff 000000 000000 package App::Ack::Filter::FirstLineMatch;
=head1 NAME
App::Ack::Filter::FirstLineMatch
=head1 DESCRIPTION
The class that implements filtering files by their first line.
=cut
use strict;
use warnings;
use parent 'App::Ack::Filter';
sub new {
my ( $class, $re ) = @_;
$re =~ s{^/|/$}{}g; # XXX validate?
$re = qr{$re}i;
return bless {
regex => $re,
}, $class;
}
# This test reads the first 250 characters of a file, then just uses the
# first line found in that. This prevents reading something like an entire
# .min.js file (which might be only one "line" long) into memory.
sub filter {
my ( $self, $file ) = @_;
return $file->firstliney =~ /$self->{regex}/;
}
sub inspect {
my ( $self ) = @_;
return ref($self) . ' - ' . $self->{regex};
}
sub to_string {
my ( $self ) = @_;
(my $re = $self->{regex}) =~ s{\([^:]*:(.*)\)$}{$1};
return "First line matches /$re/";
}
BEGIN {
App::Ack::Filter->register_filter(firstlinematch => __PACKAGE__);
}
1;
ack-v3.8.1/lib/App/Ack/Filter/Inverse.pm 000644 000766 000024 00000001151 14376470274 017744 0 ustar 00andy staff 000000 000000 package App::Ack::Filter::Inverse;
=head1 NAME
App::Ack::Filter::Inverse
=head1 DESCRIPTION
The filter class that inverts another filter.
=cut
use strict;
use warnings;
use parent 'App::Ack::Filter';
sub new {
my ( $class, $filter ) = @_;
return bless {
filter => $filter,
}, $class;
}
sub filter {
my ( $self, $file ) = @_;
return !$self->{filter}->filter( $file );
}
sub invert {
my $self = shift;
return $self->{'filter'};
}
sub is_inverted {
return 1;
}
sub inspect {
my ( $self ) = @_;
my $filter = $self->{'filter'};
return "!$filter";
}
1;
ack-v3.8.1/lib/App/Ack/Filter/Match.pm 000644 000766 000024 00000001551 14376470274 017371 0 ustar 00andy staff 000000 000000 package App::Ack::Filter::Match;
use strict;
use warnings;
use parent 'App::Ack::Filter';
use App::Ack::Filter::MatchGroup ();
=head1 NAME
App::Ack::Filter::Match
=head1 DESCRIPTION
Implements filtering files by their filename (regular expression).
=cut
sub new {
my ( $class, $re ) = @_;
$re =~ s{^/|/$}{}g; # XXX validate?
$re = qr/$re/i;
return bless {
regex => $re,
groupname => 'MatchGroup',
}, $class;
}
sub create_group {
return App::Ack::Filter::MatchGroup->new;
}
sub filter {
my ( $self, $file ) = @_;
return $file->basename =~ /$self->{regex}/;
}
sub inspect {
my ( $self ) = @_;
return ref($self) . ' - ' . $self->{regex};
}
sub to_string {
my ( $self ) = @_;
return "Filename matches $self->{regex}";
}
BEGIN {
App::Ack::Filter->register_filter(match => __PACKAGE__);
}
1;
ack-v3.8.1/lib/App/Ack/Filter/IsGroup.pm 000644 000766 000024 00000002073 14376470274 017725 0 ustar 00andy staff 000000 000000 package App::Ack::Filter::IsGroup;
=head1 NAME
App::Ack::Filter::IsGroup
=head1 DESCRIPTION
The App::Ack::Filter::IsGroup class optimizes multiple
App::Ack::Filter::Is calls into one container.
Let's say you have 100 C<--type-add=is:...> filters.
You could have
my @filters = map { make_is_filter($_) } 1..100;
and then do
if ( any { $_->filter($rsrc) } @filters ) { ... }
but that's slow, because of of method lookup overhead, function call
overhead, etc. So ::Is filters know how to organize themselves into an
::IsGroup filter.
=cut
use strict;
use warnings;
use parent 'App::Ack::Filter';
sub new {
my ( $class ) = @_;
return bless {
data => {},
}, $class;
}
sub add {
my ( $self, $filter ) = @_;
$self->{data}->{ $filter->{filename} } = 1;
return;
}
sub filter {
my ( $self, $file ) = @_;
return exists $self->{data}->{ $file->basename };
}
sub inspect {
my ( $self ) = @_;
return ref($self) . " - $self";
}
sub to_string {
my ( $self ) = @_;
return join(' ', keys %{$self->{data}});
}
1;
ack-v3.8.1/xt/pod.t 000644 000766 000024 00000000134 14376470274 014164 0 ustar 00andy staff 000000 000000 #!perl
use warnings;
use strict;
use Test::More;
use Test::Pod 1.14;
all_pod_files_ok();
ack-v3.8.1/xt/coding-standards.t 000644 000766 000024 00000002775 14376470274 016643 0 ustar 00andy staff 000000 000000 #!perl
use warnings;
use strict;
use lib 't';
use File::Next;
use Util;
use Test::More;
# Get all the ack component files.
my @files = ( 'ack' );
my $libs = File::Next::files( { descend_filter => sub { !/\Q.git/ }, file_filter => sub { /\.pm$/ } }, 'lib' );
while ( my $file = $libs->() ) {
push @files, $file;
}
@files == 20 or die 'I should have exactly 20 modules + ack';
# Get all the test files.
for my $spec ( 't/*.t', 'xt/*.t' ) {
my @these_files = glob( $spec ) or die "Couldn't find any $spec";
push( @files, @these_files );
}
@files = grep { !/lowercase.t/ } @files; # lowercase.t has hi-bit and it's OK.
plan tests => scalar @files;
for my $file ( @files ) {
subtest $file => sub {
plan tests => 3;
my @lines = read_file( $file );
my $text = join( '', @lines );
chomp @lines;
my $ok = 1;
my $lineno = 0;
for my $line ( @lines ) {
++$lineno;
if ( $line =~ /[^ -~]/ ) {
my $col = $-[0] + 1;
diag( "$file has hi-bit characters at $lineno:$col" );
$ok = 0;
}
if ( $line =~ /\s+$/ ) {
diag( "$file has trailing whitespace on line $lineno" );
$ok = 0;
}
}
ok( $ok, "$file: No hi-bit characters found and no trailing whitespace" );
ok( $lines[-1] ne '', "$file: Doesn't end with an empty line" );
is( index($text, "\t"), -1, "$file should have no embedded tabs" );
}
}
ack-v3.8.1/xt/coresubs.t 000644 000766 000024 00000003100 14376470274 015223 0 ustar 00andy staff 000000 000000 #!perl
# Checks that we are not using core C or C except in very specific places.
# Same with C and C.
# Ignore the App::Ack::Docs modules since they're nothing but text.
## no critic ( Bangs::ProhibitDebuggingModules )
use warnings;
use strict;
use Test::More tests => 4;
use lib 't';
use Util;
prep_environment();
my $ack_pm = quotemeta( reslash( 'blib/lib/App/Ack.pm' ) );
my @exclusions = qw(
--ignore-dir=dev
--ignore-file=is:ack-standalone
);
for my $word ( qw( warn die ) ) {
subtest "Finding $word" => sub {
plan tests => 4;
my @args = ( '(? or C. Use C and C.
my $util_pm = quotemeta( reslash( 't/Util.pm' ) );
for my $word ( qw( chdir mkdir ) ) {
subtest "Finding $word" => sub {
plan tests => 3;
my @args = ( '-w', '--ignore-file=is:coresubs.t', '--ignore-file=is:Dockerfile', '--ignore-dir=garage', @exclusions, $word );
my @results = run_ack( @args );
is( scalar @results, 1, 'Exactly one hit...' ) or do { require Data::Dumper; warn Data::Dumper::Dumper( \@results ) };
like( $results[0], qr/^$util_pm.+CORE::$word/, '... and it is in the function in Util.pm that wraps the core call' );
};
}
exit 0;
ack-v3.8.1/xt/man.t 000644 000766 000024 00000006516 14376470274 014167 0 ustar 00andy staff 000000 000000 #!perl
## no critic ( Bangs::ProhibitDebuggingModules )
use strict;
use warnings;
use lib 't';
use Test::More;
use Util;
sub strip_special_chars {
my ( $s ) = @_;
$s =~ s/.[\b]//g;
$s =~ s/\e\[?.*?[\@-~]//g;
return $s;
}
{
my $man_options;
sub _populate_man_options {
my ( $man_output, $man_stderr ) = run_ack_with_stderr( '--man' );
if ( !@{$man_stderr} ) {
pass( 'Nothing in stderr' );
}
elsif ( @{$man_stderr} > 1 ) {
fail( 'I have more than two lines in stderr' );
diag explain $man_stderr;
}
else {
# Sometimes "standard input" is in single quotes, and sometimes it's not.
like( $man_stderr->[0], qr/stty: '?standard input'?: Inappropriate ioctl for device/, 'The one warning is one we can ignore' );
}
my $in_options_section;
my @option_lines;
foreach my $line ( @{$man_output} ) {
$line = strip_special_chars($line);
if ( $line =~ /^OPTIONS/ ) {
$in_options_section = 1;
}
elsif ( $in_options_section ) {
if ( $line =~ /^\S/ ) {
$in_options_section = 0;
last;
}
else {
push @option_lines, $line;
}
}
}
my $min_indent;
foreach my $line ( @option_lines ) {
if ( my ( $indent ) = $line =~ /^(\s+)/ ) {
$indent =~ s/\t/ /;
$indent = length($indent);
if ( !defined($min_indent) || $indent < $min_indent ) {
$min_indent = $indent;
}
}
}
$man_options = [];
foreach my $line ( @option_lines ) {
if ( $line =~ /^(\s+)/ ) {
my $indent_str = $1;
$indent_str =~ s/\t/ /;
my $indent = length($indent_str);
next unless $indent == $min_indent;
while ( $line =~ /(-[^\s=,]+)/g ) {
my $option = $1;
chop $option if $option =~ /\[$/;
if ( $option =~ s/^--\[no\]/--/ ) {
my $negated_option = $option;
substr $negated_option, 2, 0, 'no';
push @{$man_options}, $negated_option;
}
push @{$man_options}, $option;
}
}
}
return;
}
sub get_man_options {
_populate_man_options() unless $man_options;
return @{ $man_options };
}
}
sub check_for_option_in_man_output {
local $Test::Builder::Level = $Test::Builder::Level + 1;
my $expected_option = shift;
my @options = get_man_options();
foreach my $option ( @options ) {
if ( $option eq $expected_option ) {
return pass( "Found $expected_option in --man output" );
}
}
require Data::Dumper;
diag Data::Dumper::Dumper( 'Returned options' => \@options );
return fail( "Option '$expected_option' not found in --man output" );
}
my @options = get_expected_options();
plan tests => scalar(@options) + 1;
prep_environment();
foreach my $option ( @options ) {
check_for_option_in_man_output( $option );
}
exit 0;
ack-v3.8.1/t/lowercase.t 000644 000766 000024 00000004636 14376470354 015210 0 ustar 00andy staff 000000 000000 #!/usr/bin/perl
use warnings;
use strict;
use 5.010;
use Test::More tests => 2;
use App::Ack;
my $lc_list = <<'END'; ## no critic ( CodeLayout::RequireASCII )
select . from table
select \S+ from table
select [^\s]+ from table
# Character specifications
find a tab -> \x09
"foo" in hex -> \x66\x6f\x6f with lowercase digits
"foo" in hex -> \x66\x6F\x6F with uppercase digits
control sequences: ctrl-x=\cX
# unicode sequences: \N{GRAVE ACCENT}
unicode sequences: \N{U+263D}
ladies and gentlemen, please welcome, ❤️!
# Regex metacharacters
keep stuff to the left -> \K
non-word character -> \W
non-space character -> \S
non-digit character -> \D
something something \X
not vertical whitespace -> \V
not horizontal whitespace -> \H
linebreak -> \R
# unicode regex metachars
# https://www.regular-expressions.info/unicode.html
named property -> \p{Word} same as \w
not the named property -> \P{Word} same as \W
single-character named property shorthand -> \pL is any letter
negation of single-character named property shorthand -> \PL is not any letter
# Not sure about \X
big combination: \W\S\D\V\H\R but still lowercase
# Zero-width assertions
not a word boundary -> \B
beginning of a string -> \A
end of a string -> \Z
end-of-match position of prior match -> \G
# Captures
named capture group and backref -> (?'NAME'pattern) \k'NAME'
named capture group and backref -> (?pattern) \k
# Weird combinations
\A\B\S{14}\G\Dfoo\W*\S+\Z
END
my $uc_list = <<'END';
This is \\Here.
foo[A-Z]+
[A-Z]*bar
parens([A-Z]*)
foo(?!lookahead)([A-Z]*)
# Don't get confused by regex metacharacters.
\WWhat now?
dumb \DDonald
lost in \SSpace
lost in \\\\Diskland
# Weird combinations
\A\\\B\S{14}\G\\\D\\Dog\\\W*\\\\\S+\\\\\Z
\\W//\\W//\\Larry//\\D//?
END
my @lc_list = _big_split($lc_list);
if ( $] >= 5.012 ) {
push( @lc_list, 'anything but \n -> \N' );
}
my @uc_list = _big_split($uc_list);
subtest 'Check lowercase' => sub {
plan tests => scalar @lc_list;
for my $lc ( @lc_list ) {
my $re = qr/$lc/;
ok( App::Ack::is_lowercase( $lc ), qq{"$lc" should be lowercase} );
}
};
subtest 'Check uppercase' => sub {
plan tests => scalar @uc_list;
for my $uc ( @uc_list ) {
my $re = qr/$uc/;
ok( !App::Ack::is_lowercase( $uc ), qq{"$uc" should not be lowercase} );
}
};
done_testing();
exit 0;
sub _big_split {
my $str = shift;
return grep { /./ && !/^#/ } split( /\n/, $str );
}
ack-v3.8.1/t/ack-output.t 000644 000766 000024 00000023262 14376470354 015314 0 ustar 00andy staff 000000 000000 #!perl
use warnings;
use strict;
use Test::More tests => 46;
use lib 't';
use Util;
prep_environment();
DOLLAR_1: {
my @files = qw( t/text/ );
my @args = qw/ --output=x$1x free(\\S+) --sort-files /;
my @target_file = map { reslash($_) } qw(
t/text/bill-of-rights.txt
t/text/gettysburg.txt
);
my @expected = (
"$target_file[0]:4:xdomx",
"$target_file[1]:23:xdomx",
);
ack_sets_match( [ @args, @files ], \@expected, 'Find all the things with --output function' );
}
DOLLAR_UNDERSCORE: {
my @expected = line_split( <<'HERE' );
shall have a new birth of freedom -- and that government of the people,xshall have a new birth of freedom -- and that government of the people,
HERE
my @files = qw( t/text/gettysburg.txt );
my @args = qw( free --output=$_x$_ );
my @results = run_ack( @args, @files );
lists_match( \@results, \@expected, 'Matching line' );
}
ARG_MULTIPLE_FILES: {
# Note the first line is there twice because it matches twice.
my @expected = line_split( <<'HERE' );
or prohibiting the free exercise thereof; or abridging the freedom of
or prohibiting the free exercise thereof; or abridging the freedom of
A well regulated Militia, being necessary to the security of a free State,
Number of free Persons, including those bound to Service for a Term
shall have a new birth of freedom -- and that government of the people,
HERE
my @files = qw( t/text );
my @args = qw( free --sort-files -h --output=$_ );
my @results = run_ack( @args, @files );
lists_match( \@results, \@expected, 'Matching line' );
}
# Find a match in multiple files, and output it in double quotes.
DOUBLE_QUOTES: {
my @files = qw( t/text/ );
my @args = ( '--output="$1"', '(free\\w*)', '--sort-files' );
my @target_file = map { reslash($_) } qw(
t/text/bill-of-rights.txt
t/text/constitution.txt
t/text/gettysburg.txt
);
my @expected = (
qq{$target_file[0]:4:"free"},
qq{$target_file[0]:4:"freedom"},
qq{$target_file[0]:10:"free"},
qq{$target_file[1]:32:"free"},
qq{$target_file[2]:23:"freedom"},
);
ack_sets_match( [ @args, @files ], \@expected, 'Find all the things with --output function' );
}
MATCH: {
my @expected = (
'free'
);
my @files = qw( t/text/gettysburg.txt );
my @args = qw( free --output=$& );
my @results = run_ack( @args, @files );
lists_match( \@results, \@expected, 'Part of a line matching pattern' );
}
MATCH_MULTIPLE_FILES: {
my @expected = line_split( <<'HERE' );
t/text/bill-of-rights.txt:4:free
t/text/bill-of-rights.txt:4:free
t/text/bill-of-rights.txt:10:free
t/text/constitution.txt:32:free
t/text/gettysburg.txt:23:free
HERE
my @files = qw ( t/text );
my @args = qw( free --sort-files --output=$& );
my @results = run_ack( @args, @files );
lists_match( \@results, \@expected, 'Part of a line matching pattern' );
}
PREMATCH: {
# No HEREDOC here since we do not want our editor/IDE messing with trailing whitespace.
my @expected = (
'shall have a new birth of '
);
my @files = qw( t/text/gettysburg.txt );
my @args = qw( freedom --output=$` );
my @results = run_ack( @args, @files );
lists_match( \@results, \@expected, 'Part of a line preceding match' );
}
PREMATCH_MULTIPLE_FILES: {
# No HEREDOC here since we do not want our editor/IDE messing with trailing whitespace.
my @expected = (
'or prohibiting the free exercise thereof; or abridging the ',
'shall have a new birth of '
);
my @files = qw( t/text/);
my @args = qw( freedom -h --sort-files --output=$` );
my @results = run_ack( @args, @files );
lists_match( \@results, \@expected, 'Part of a line preceding match' );
}
POSTMATCH: {
my @expected = split( /\n/, <<'HERE' );
-- and that government of the people,
HERE
my @files = qw( t/text/gettysburg.txt );
my @args = qw( freedom --output=$' );
my @results = run_ack( @args, @files );
lists_match( \@results, \@expected, 'Part of a line that follows match' );
}
POSTMATCH_MULTIPLE_FILES: {
my @expected = line_split( <<'HERE' );
of
-- and that government of the people,
HERE
my @files = qw( t/text/ );
my @args = qw( freedom -h --sort-files --output=$' );
my @results = run_ack( @args, @files );
lists_match( \@results, \@expected, 'Part of a line that follows match' );
}
SUBPATTERN_MATCH: {
my @expected = (
'love-God-Montresor'
);
my @files = qw( t/text/amontillado.txt );
my @args = qw( (love).+(God).+(Montresor) --output=$1-$2-$3 );
my @results = run_ack( @args, @files );
lists_match( \@results, \@expected, 'Capturing parentheses match' );
}
SUBPATTERN_MATCH_MULTIPLE_FILES: {
my @expected = line_split( <<'HERE' );
the-free-exercise
a-free-State
of-free-Persons
HERE
my @files = qw( t/text/ );
my @args = qw( (\w+)\s(free)\s(\w+) -h --sort-files --output=$1-$2-$3 );
my @results = run_ack( @args, @files );
lists_match( \@results, \@expected, 'Capturing parentheses match' );
}
INPUT_LINE_NUMBER: {
my @expected = (
'line:15'
);
my @files = qw( t/text/bill-of-rights.txt );
my @args = qw( quartered --output=line:$. );
my @results = run_ack( @args, @files );
lists_match( \@results, \@expected, 'Line number' );
}
INPUT_LINE_NUMBER_MULTIPLE_FILES: {
my @expected = line_split( <<'HERE' );
t/text/bill-of-rights.txt:4:line:4
t/text/bill-of-rights.txt:4:line:4
t/text/bill-of-rights.txt:10:line:10
t/text/constitution.txt:32:line:32
t/text/gettysburg.txt:23:line:23
HERE
my @files = qw( t/text/ );
my @args = qw( free --sort-files --output=line:$. );
my @results = run_ack( @args, @files );
lists_match( \@results, \@expected, 'Line number' );
}
LAST_PAREN_MATCH: {
my @expected = line_split( <<'HERE' );
t/text/amontillado.txt:124:love
t/text/amontillado.txt:309:love
t/text/amontillado.txt:311:love
t/text/constitution.txt:267:hate
HERE
my @files = qw( t/text/ );
my @args = qw( (love)|(hate) --sort-files --output=$+ );
my @results = run_ack( @args, @files );
lists_match( \@results, \@expected, 'Last paren match' );
}
COMBOS_1: {
my @expected = line_split( <<'HERE' );
t/text/amontillado.txt:124:love-124-d; you are happy,
t/text/amontillado.txt:309:love-309- of God, Montresor!"
t/text/amontillado.txt:311:love-311- of God!"
t/text/constitution.txt:267:hate-267-ver, from any King, Prince, or foreign State.
HERE
my @files = qw( t/text/ );
my @args = qw( (love)|(hate) --sort-files --output=$+-$.-$' );
my @results = run_ack( @args, @files );
lists_match( \@results, \@expected, 'Combos 1' );
}
COMBOS_2: {
my @expected = line_split( <<'HERE' );
t/text/amontillado.txt:124:happy-happy-happy
t/text/raven.txt:73:happy-happy-happy
HERE
my @files = qw( t/text/ );
my @args = qw( (happy) --sort-files -i --output=$1-$&-$1 );
my @results = run_ack( @args, @files );
lists_match( \@results, \@expected, 'Combos 2' );
}
COMBOS_3: {
my @expected = line_split( <<'HERE' );
t/text/amontillado.txt:124:precious. You are rich, respected, admired, beloved; you are ---,--happy
t/text/raven.txt:73:Caught from some un--- master whom unmerciful Disaster--happy
HERE
my @files = qw( t/text/ );
my @args = qw( (happy) --sort-files -i --output=$`---$'--$+ );
my @results = run_ack( @args, @files );
lists_match( \@results, \@expected, 'Combos 2' );
}
NUMERIC_SUBSTITUTIONS: {
# Make sure that substitutions don't affect future substitutions.
my @expected = line_split( <<'HERE' );
t/text/constitution.txt:269:Section 10 on line 269
HERE
my @files = qw( t/text/bill-of-rights.txt t/text/constitution.txt );
my @args = ( '(\d\d)', '--output=Section $1 on line $.' );
my @results = run_ack( @args, @files );
lists_match( \@results, \@expected, 'Numeric substitutions' );
}
CHARACTER_SUBSTITUTIONS: {
# Make sure that substitutions don't affect future substitutions.
my @expected = line_split( <<"HERE" );
t/text/bill-of-rights.txt:15:No Soldier shall, in time of peace be
in any house, without\tin any house, without
HERE
my @files = qw( t/text/ );
my @args = ( '\s+quartered\s+(.+)', '--output=$`\n$1\t$1' );
my @results = run_ack( @args, @files );
lists_match( \@results, \@expected, 'Character substitutions' );
}
# $f is the filename, needed for grep, emulating ack2 $filename:$lineno:$_
FILENAME_SUBSTITUTION_1 : {
my @expected = line_split( <<'HERE' );
t/text/ozymandias.txt:4:Half sunk, a shattered visage lies, whose frown,
HERE
my @files = qw( t/text/ozymandias.txt );
my @args = qw( visage --output=$f:$.:$_ );
my @results = run_ack( @args, @files );
lists_match( \@results, \@expected, 'Filename with matching line' );
}
FILENAME_SUBSTITUTION_2 : {
my @expected = line_split( <<'HERE' );
t/text/ozymandias.txt:4:visage
HERE
my @files = qw( t/text/ozymandias.txt );
my @args = qw( visage --output=$f:$.:$& );
my @results = run_ack( @args, @files );
lists_match( \@results, \@expected, 'Filename with match' );
}
FILENAME_SUBSTITUTION_3 : {
my @expected = line_split( <<'HERE' );
t/text/ozymandias.txt:4:visage
HERE
my @files = qw( t/text/ozymandias.txt );
my @args = qw( (visage) --output=$f:$.:$+ );
my @results = run_ack( @args, @files );
lists_match( \@results, \@expected, 'Filename with last match' );
}
NO_SPECIALS_IN_OUTPUT_EXPRESSION : {
my @expected = line_split( <<'HERE' );
literal
literal
HERE
my @files = qw( t/text/ozymandias.txt );
my @args = qw( sand --output=literal );
my @results = run_ack( @args, @files );
lists_match( \@results, \@expected, 'Filename with last match' );
}
done_testing();
exit 0;
ack-v3.8.1/t/from-stdin.t 000644 000766 000024 00000002462 14376470274 015302 0 ustar 00andy staff 000000 000000 #!perl
use warnings;
use strict;
use Test::More tests => 3;
use lib 't';
use Util;
prep_environment();
PIPE_INTO_ACK: {
my @expected = line_split( <<'END' );
Of 'Never -- nevermore.'
She shall press, ah, nevermore!
Shall be lifted--nevermore!
END
my $file = 't/text/raven.txt';
my @args = qw( nevermore );
my @results = pipe_into_ack( $file, @args );
is_deeply( \@results, \@expected, 'Piping a file' );
}
PIPE_INTO_DASH_I: {
my @expected = line_split( <<'END' );
Quoth the Raven, "Nevermore."
With such name as "Nevermore."
Then the bird said, "Nevermore."
Of 'Never -- nevermore.'
Meant in croaking "Nevermore."
She shall press, ah, nevermore!
Quoth the Raven, "Nevermore."
Quoth the Raven, "Nevermore."
Quoth the Raven, "Nevermore."
Quoth the Raven, "Nevermore."
Shall be lifted--nevermore!
END
my $file = 't/text/raven.txt';
my @args = qw( nevermore -i );
my @results = pipe_into_ack( $file, @args );
is_deeply( \@results, \@expected, 'Piping a file with -i' );
}
PIPE_INTO_DASH_C: {
my $file = 't/text/raven.txt';
my @args = qw( nevermore -i -c );
my @results = pipe_into_ack( $file, @args );
is_deeply( \@results, [ 11 ], 'Piping into ack --count should return one line of results' );
}
exit 0;
ack-v3.8.1/t/ack-i.barfly 000644 000766 000024 00000001766 14376470274 015226 0 ustar 00andy staff 000000 000000 BEGIN No -i, or -I
RUN
ack foo
ack -I foo
ack --no-smart-case foo
YES
football
foo bar
NO
Football
foOtball
END
BEGIN Normal -i
RUN
ack -i foo
ack -i Foo
ack --ignore-case foo
ack --ignore-case Foo
YES
football
foo bar
Football
foOtball
NO
END
BEGIN --smart-case invoked
RUN
ack --smart-case foo
ack -S foo
YES
football
foo bar
Football
foOtball
NO
END
BEGIN --smart-case bypassed
RUN
ack --smart-case Foo
ack -S Foo
YES
Football
NO
football
foo bar
foOtball
END
BEGIN --smart-case overrides -i
RUN
ack -i --smart-case Foo
ack -i -S Foo
YES
Football
NO
football
foo bar
foOtball
END
BEGIN -i overrides --smart-case
RUN
ack --smart-case -i Foo
ack --smart-case -i foo
ack -S -i Foo
ack -S -i foo
YES
Football
football
foo bar
foOtball
NO
END
BEGIN -I overrides -i
RUN
ack -i -I Foo
YES
Football
NO
foOtball
football
foo bar
END
BEGIN -I overrides --smart-case
RUN
ack --smart-case -I Foo
ack -S -I Foo
YES
Football
NO
football
foo bar
foOtball
END
# vi:set ft=barfly:
ack-v3.8.1/t/home/ 000755 000766 000024 00000000000 14735132536 013752 5 ustar 00andy staff 000000 000000 ack-v3.8.1/t/match-filter.t 000644 000766 000024 00000000477 14376470354 015602 0 ustar 00andy staff 000000 000000 #!perl
use strict;
use warnings;
use lib 't';
use FilterTest;
use Test::More tests => 1;
use App::Ack::Filter::Match;
filter_test(
[ match => '/^.akefile/' ], [
't/swamp/Makefile',
't/swamp/Makefile.PL',
't/swamp/Rakefile',
], 'only files matching /^.akefile/ should be matched',
);
ack-v3.8.1/t/ack-pager.t 000644 000766 000024 00000014264 14376470274 015055 0 ustar 00andy staff 000000 000000 #!perl
use strict;
use warnings;
use Test::More;
use lib 't';
use Util;
if ( not has_io_pty() ) {
plan skip_all => q{You need to install IO::Pty to run this test};
exit(0);
}
plan tests => 9;
prep_environment();
NO_PAGER: {
my @args = qw(--nocolor --sort-files -i nevermore t/text);
my @expected = line_split( <<'HERE' );
t/text/raven.txt
55: Quoth the Raven, "Nevermore."
62: With such name as "Nevermore."
69: Then the bird said, "Nevermore."
76: Of 'Never -- nevermore.'
83: Meant in croaking "Nevermore."
90: She shall press, ah, nevermore!
97: Quoth the Raven, "Nevermore."
104: Quoth the Raven, "Nevermore."
111: Quoth the Raven, "Nevermore."
118: Quoth the Raven, "Nevermore."
125: Shall be lifted--nevermore!
HERE
my @got = run_ack_interactive(@args);
lists_match( \@got, \@expected, 'NO_PAGER' );
}
PAGER: {
my @args = qw(--nocolor --pager=t/test-pager --sort-files -i nevermore t/text);
my @expected = line_split( <<'HERE' );
t/text/raven.txt
55: Quoth the Raven, "Nevermore."
62: With such name as "Nevermore."
69: Then the bird said, "Nevermore."
76: Of 'Never -- nevermore.'
83: Meant in croaking "Nevermore."
90: She shall press, ah, nevermore!
97: Quoth the Raven, "Nevermore."
104: Quoth the Raven, "Nevermore."
111: Quoth the Raven, "Nevermore."
118: Quoth the Raven, "Nevermore."
125: Shall be lifted--nevermore!
HERE
my @got = run_ack_interactive(@args);
lists_match( \@got, \@expected, 'PAGER' );
}
PAGER_WITH_OPTS: {
my @args = (
'--nocolor',
'--pager=t/test-pager --skip=2', # --skip is an argument passed to test-pager
'--sort-files',
'-i',
'nevermore',
't/text',
);
my @expected = line_split( <<'HERE' );
t/text/raven.txt
62: With such name as "Nevermore."
76: Of 'Never -- nevermore.'
90: She shall press, ah, nevermore!
104: Quoth the Raven, "Nevermore."
118: Quoth the Raven, "Nevermore."
HERE
my @got = run_ack_interactive(@args);
lists_match( \@got, \@expected, 'PAGER_WITH_OPTS' );
}
FORCE_NO_PAGER: {
my @args = (
'--nocolor',
'--pager=t/test-pager --skip=2', # --skip is an argument passed to test-pager
'--nopager',
'--sort-files',
'-i',
'nevermore',
't/text',
);
my @expected = line_split( <<'HERE' );
t/text/raven.txt
55: Quoth the Raven, "Nevermore."
62: With such name as "Nevermore."
69: Then the bird said, "Nevermore."
76: Of 'Never -- nevermore.'
83: Meant in croaking "Nevermore."
90: She shall press, ah, nevermore!
97: Quoth the Raven, "Nevermore."
104: Quoth the Raven, "Nevermore."
111: Quoth the Raven, "Nevermore."
118: Quoth the Raven, "Nevermore."
125: Shall be lifted--nevermore!
HERE
my @got = run_ack_interactive(@args);
lists_match( \@got, \@expected, 'FORCE_NO_PAGER' );
}
PAGER_ENV: {
local $ENV{'ACK_PAGER'} = 't/test-pager --skip=2';
local $TODO = q{Setting ACK_PAGER in tests won't work for the time being};
my @args = qw( --nocolor --sort-files -i nevermore t/text );
my @expected = line_split( <<'HERE' );
t/text/raven.txt
62: With such name as "Nevermore."
76: Of 'Never -- nevermore.'
90: She shall press, ah, nevermore!
104: Quoth the Raven, "Nevermore."
118: Quoth the Raven, "Nevermore."
HERE
my @got = run_ack_interactive(@args);
lists_match( \@got, \@expected, 'PAGER_ENV' );
}
PAGER_ENV_OVERRIDE: {
local $ENV{'ACK_PAGER'} = 't/test-pager --skip=2';
my @args = qw( --nocolor --nopager --sort-files -i nevermore t/text );
my @expected = line_split( <<'HERE' );
t/text/raven.txt
55: Quoth the Raven, "Nevermore."
62: With such name as "Nevermore."
69: Then the bird said, "Nevermore."
76: Of 'Never -- nevermore.'
83: Meant in croaking "Nevermore."
90: She shall press, ah, nevermore!
97: Quoth the Raven, "Nevermore."
104: Quoth the Raven, "Nevermore."
111: Quoth the Raven, "Nevermore."
118: Quoth the Raven, "Nevermore."
125: Shall be lifted--nevermore!
HERE
my @got = run_ack_interactive(@args);
lists_match( \@got, \@expected, 'PAGER_ENV_OVERRIDE' );
}
PAGER_ACKRC: {
my @args = qw( --nocolor --sort-files -i nevermore t/text );
my $ackrc = <<'HERE';
--pager=t/test-pager --skip=2
HERE
my @expected = line_split( <<'HERE' );
t/text/raven.txt
62: With such name as "Nevermore."
76: Of 'Never -- nevermore.'
90: She shall press, ah, nevermore!
104: Quoth the Raven, "Nevermore."
118: Quoth the Raven, "Nevermore."
HERE
my @got = run_ack_interactive(@args, {
ackrc => \$ackrc,
});
lists_match( \@got, \@expected, 'PAGER_ACKRC' );
}
PAGER_ACKRC_OVERRIDE: {
my @args = qw( --nocolor --nopager --sort-files -i nevermore t/text );
my $ackrc = <<'HERE';
--pager=t/test-pager --skip=2
HERE
my @expected = line_split( <<'HERE' );
t/text/raven.txt
55: Quoth the Raven, "Nevermore."
62: With such name as "Nevermore."
69: Then the bird said, "Nevermore."
76: Of 'Never -- nevermore.'
83: Meant in croaking "Nevermore."
90: She shall press, ah, nevermore!
97: Quoth the Raven, "Nevermore."
104: Quoth the Raven, "Nevermore."
111: Quoth the Raven, "Nevermore."
118: Quoth the Raven, "Nevermore."
125: Shall be lifted--nevermore!
HERE
my @got = run_ack_interactive(@args, {
ackrc => \$ackrc,
});
lists_match( \@got, \@expected, 'PAGER_ACKRC_OVERRIDE' );
}
PAGER_NOENV: {
local $ENV{'ACK_PAGER'} = 't/test-pager --skip=2';
my @args = qw( --nocolor --noenv --sort-files -i nevermore t/text );
my @expected = line_split( <<'HERE' );
t/text/raven.txt
55: Quoth the Raven, "Nevermore."
62: With such name as "Nevermore."
69: Then the bird said, "Nevermore."
76: Of 'Never -- nevermore.'
83: Meant in croaking "Nevermore."
90: She shall press, ah, nevermore!
97: Quoth the Raven, "Nevermore."
104: Quoth the Raven, "Nevermore."
111: Quoth the Raven, "Nevermore."
118: Quoth the Raven, "Nevermore."
125: Shall be lifted--nevermore!
HERE
my @got = run_ack_interactive(@args);
lists_match( \@got, \@expected, 'PAGER_NOENV' );
}
done_testing();
exit 0;
ack-v3.8.1/t/ack-o.t 000644 000766 000024 00000002362 14376470274 014211 0 ustar 00andy staff 000000 000000 #!perl
use warnings;
use strict;
use Test::More tests => 2;
use lib 't';
use Util;
prep_environment();
NO_O: {
my @files = qw( t/text/gettysburg.txt );
my @args = qw( the\\s+\\S+ );
my @expected = line_split( <<'HERE' );
but it can never forget what they did here. It is for us the living,
rather, to be dedicated here to the unfinished work which they who
here dedicated to the great task remaining before us -- that from these
the last full measure of devotion -- that we here highly resolve that
shall have a new birth of freedom -- and that government of the people,
by the people, for the people, shall not perish from the earth.
HERE
s/^\s+// for @expected;
ack_lists_match( [ @args, @files ], \@expected, 'Find all the things without -o' );
}
WITH_O: {
my @files = qw( t/text/gettysburg.txt );
my @args = qw( the\\s+\\S+ -o );
my @expected = line_split( <<'HERE' );
the living,
the unfinished
the great
the last
the people,
the people,
the people,
the earth.
HERE
s/^\s+// for @expected;
ack_lists_match( [ @args, @files ], \@expected, 'Find all the things with -o' );
}
done_testing();
exit 0;
ack-v3.8.1/t/ack-version.t 000644 000766 000024 00000000557 14376470354 015443 0 ustar 00andy staff 000000 000000 #!perl
use strict;
use warnings;
use Test::More tests => 2;
use lib 't';
use Util;
use App::Ack;
prep_environment();
my ( $stdout, $stderr ) = run_ack_with_stderr( '--version' );
is_empty_array( $stderr, 'Nothing in stderr' );
my @lines = @{$stdout};
like( $lines[0], qr/\Q$App::Ack::VERSION/, 'Found the version in the first line' );
done_testing();
exit 0;
ack-v3.8.1/t/ack-k.t 000644 000766 000024 00000006155 14735132514 014200 0 ustar 00andy staff 000000 000000 #!perl
use warnings;
use strict;
use Test::More tests => 3;
use lib 't';
use Util;
prep_environment();
subtest 'No restrictions on type' => sub {
my $expected = <<'HERE';
t/etc/buttonhook.xml.xxx => xml
t/etc/shebang.empty.xxx =>
t/etc/shebang.foobar.xxx =>
t/etc/shebang.php.xxx => php
t/etc/shebang.pl.xxx => perl
t/etc/shebang.py.xxx => python
t/etc/shebang.rb.xxx => ruby
t/etc/shebang.sh.xxx => shell
HERE
my @expected = reslash_all( line_split( $expected ) );
my @args = qw( -f --show-types t/etc );
ack_sets_match( [ @args ], \@expected, 'No restrictions on type' );
};
subtest 'Only known types' => sub {
my $expected = <<'HERE';
t/etc/buttonhook.xml.xxx => xml
t/etc/shebang.php.xxx => php
t/etc/shebang.pl.xxx => perl
t/etc/shebang.py.xxx => python
t/etc/shebang.rb.xxx => ruby
t/etc/shebang.sh.xxx => shell
HERE
my @expected = reslash_all( line_split( $expected ) );
my @args = qw( -f -k --show-types t/etc );
ack_sets_match( [ @args ], \@expected, 'Only known types' );
};
subtest 'More testing' => sub {
plan tests => 4;
my @files = qw(
t/swamp/0
t/swamp/constitution-100k.pl
t/swamp/Rakefile
t/swamp/options-crlf.pl
t/swamp/options.pl
t/swamp/javascript.js
t/swamp/html.html
t/swamp/perl-without-extension
t/swamp/sample.rake
t/swamp/perl.cgi
t/swamp/Makefile
t/swamp/pipe-stress-freaks.F
t/swamp/perl.pod
t/swamp/html.htm
t/swamp/perl-test.t
t/swamp/perl.handler.pod
t/swamp/perl.pl
t/swamp/Makefile.PL
t/swamp/MasterPage.master
t/swamp/c-source.c
t/swamp/perl.pm
t/swamp/c-header.h
t/swamp/crystallography-weenies.f
t/swamp/CMakeLists.txt
t/swamp/Sample.ascx
t/swamp/Sample.asmx
t/swamp/sample.asp
t/swamp/sample.aspx
t/swamp/service.svc
t/swamp/stuff.cmake
t/swamp/example.R
t/swamp/fresh.css
t/swamp/lua-shebang-test
t/swamp/notes.md
t/swamp/test.py
t/swamp/test_foo.py
t/swamp/foo_test.py
);
my @files_no_perl = qw(
t/swamp/Rakefile
t/swamp/javascript.js
t/swamp/html.html
t/swamp/sample.rake
t/swamp/Makefile
t/swamp/MasterPage.master
t/swamp/pipe-stress-freaks.F
t/swamp/html.htm
t/swamp/c-source.c
t/swamp/c-header.h
t/swamp/crystallography-weenies.f
t/swamp/CMakeLists.txt
t/swamp/Sample.ascx
t/swamp/Sample.asmx
t/swamp/sample.asp
t/swamp/sample.aspx
t/swamp/service.svc
t/swamp/stuff.cmake
t/swamp/example.R
t/swamp/fresh.css
t/swamp/lua-shebang-test
t/swamp/notes.md
t/swamp/test.py
t/swamp/test_foo.py
t/swamp/foo_test.py
);
for my $k_arg ( '-k', '--known-types' ) {
ack_sets_match( [ $k_arg, '-f', 't/swamp' ], \@files, "$k_arg test #1" );
ack_sets_match( [ $k_arg, '-T', 'perl', '-f', 't/swamp' ], \@files_no_perl, "$k_arg test #2" );
}
};
done_testing();
exit 0;
ack-v3.8.1/t/filetypes.t 000644 000766 000024 00000004723 14376470274 015226 0 ustar 00andy staff 000000 000000 #!perl
use warnings;
use strict;
use Test::More tests => 19;
use lib 't';
use Util;
prep_environment();
my %types_for_file;
populate_filetypes();
sets_match( [filetypes( 't/swamp/perl.pod' )], [qw( perl pod )], 'foo.pod can be multiple things' );
sets_match( [filetypes( 't/swamp/perl.pm' )], [qw( perl )], 't/swamp/perl.pm' );
sets_match( [filetypes( 't/swamp/Makefile.PL' )], [qw( perl )], 't/swamp/Makefile.PL' );
sets_match( [filetypes( 'Unknown.wango' )], [], 'Unknown' );
ok( is_filetype( 't/swamp/perl.pod', 'perl' ), 'foo.pod can be perl' );
ok( is_filetype( 't/swamp/perl.pod', 'pod' ), 'foo.pod can be pod' );
ok( !is_filetype( 't/swamp/perl.pod', 'ruby' ), 'foo.pod cannot be ruby' );
ok( is_filetype( 't/swamp/perl.handler.pod', 'perl' ), 'perl.handler.pod can be perl' );
ok( is_filetype( 't/swamp/Makefile', 'make' ), 'Makefile is a makefile' );
ok( is_filetype( 't/swamp/Rakefile', 'rake' ), 'Rakefile is a rakefile' );
is_empty_array( [filetypes('t/swamp/#emacs-workfile.pl#')], 'correctly skip files starting and ending with hash mark' );
MATCH_VIA_CONTENT: {
my %lookups = (
't/swamp/Makefile' => 'make',
't/swamp/Makefile.PL' => 'perl',
't/etc/shebang.php.xxx' => 'php',
't/etc/shebang.pl.xxx' => 'perl',
't/etc/shebang.py.xxx' => 'python',
't/etc/shebang.rb.xxx' => 'ruby',
't/etc/shebang.sh.xxx' => 'shell',
't/etc/buttonhook.xml.xxx' => 'xml',
);
for my $filename ( sort keys %lookups ) {
my $type = $lookups{$filename};
sets_match( [filetypes( $filename )], [ $type ], "Checking $filename" );
}
}
done_testing;
exit 0;
sub populate_filetypes {
my ( $type_lines, undef ) = run_ack_with_stderr('--help-types');
my @types_to_try;
foreach my $line ( @{$type_lines} ) {
if ( $line =~ /^ (\w+) / ) {
push @types_to_try, $1;
}
}
foreach my $type (@types_to_try) {
my ( $filenames, undef ) = run_ack_with_stderr('-f', '-t', $type, 't/swamp', 't/etc');
foreach my $filename ( @{$filenames} ) {
push @{ $types_for_file{$filename} }, $type;
}
}
return;
}
sub filetypes {
my $filename = reslash(shift);
return @{ $types_for_file{$filename} || [] };
}
sub is_filetype {
my ( $filename, $wanted_type ) = @_;
for my $maybe_type ( filetypes( $filename ) ) {
return 1 if $maybe_type eq $wanted_type;
}
return 0;
}
ack-v3.8.1/t/ack-passthru.t 000644 000766 000024 00000014255 14675155055 015627 0 ustar 00andy staff 000000 000000 #!perl
use warnings;
use strict;
use Test::More tests => 7;
use lib 't';
use Util;
prep_environment();
my @full_speech = ;
chomp @full_speech;
my @johnny_rebeck = read_file( 't/range/johnny-rebeck.txt' );
chomp @johnny_rebeck;
subtest 'Gettysburg without --passthru' => sub {
plan tests => 2;
my @expected = line_split( <<'HERE' );
Now we are engaged in a great civil war, testing whether that nation,
on a great battle-field of that war. We have come to dedicate a portion
HERE
@expected = color_match( qr/war/, @expected );
my @files = qw( t/text/gettysburg.txt );
my @args = qw( war --color );
my @results = run_ack( @args, @files );
lists_match( \@results, \@expected, 'Search for war' );
};
subtest 'Gettysburg with --passthru' => sub {
plan tests => 2;
my @expected = color_match( qr/war/, @full_speech );
my @files = qw( t/text/gettysburg.txt );
my @args = qw( war --passthru --color );
my @results = run_ack( @args, @files );
lists_match( \@results, \@expected, q{Still lookin' for war, in passthru mode} );
};
subtest '--passthru with/without ranges' => sub {
plan tests => 4;
my @args = qw( Rebeck --passthru --color t/range/johnny-rebeck.txt );
my @expected = color_match( qr/Rebeck/, @johnny_rebeck );
my @results = run_ack( @args );
lists_match( \@results, \@expected, q{Searching without a range} );
my @range_expected;
my $nmatches = 0;
for my $line ( @johnny_rebeck ) {
if ( $line =~ /Rebeck/ ) {
++$nmatches;
if ( $nmatches == 2 || $nmatches == 3 ) {
($line) = color_match( qr/Rebeck/, $line );
}
}
push( @range_expected, $line );
}
@results = run_ack( @args, '--range-start=CHORUS', '--range-end=VERSE' );
lists_match( \@results, \@range_expected, q{Searching with a range} );
};
# This tests the filename/lineno separators.
subtest 'With filename' => sub {
plan tests => 2;
my $ozy = reslash( 't/text/ozymandias.txt' );
my @expected = line_split( <<"HERE" );
$ozy-1-I met a traveller from an antique land
$ozy-2-Who said: Two vast and trunkless legs of stone
$ozy-3-Stand in the desert... Near them, on the sand,
$ozy:4:Half sunk, a shattered visage lies, whose frown,
$ozy:5:And wrinkled lip, and sneer of cold command,
$ozy-6-Tell that its sculptor well those passions read
$ozy:7:Which yet survive, stamped on these lifeless things,
$ozy-8-The hand that mocked them, and the heart that fed:
$ozy-9-And on the pedestal these words appear:
$ozy-10-'My name is Ozymandias, king of kings:
$ozy-11-Look on my works, ye Mighty, and despair!'
$ozy-12-Nothing beside remains. Round the decay
$ozy-13-Of that colossal wreck, boundless and bare
$ozy-14-The lone and level sands stretch far away.
HERE
my @results = run_ack( qw( li\w+ t/text/ozymandias.txt -H --passthru ) );
lists_match( \@results, \@expected, q{With filename} );
};
subtest 'With filename and --not' => sub {
plan tests => 2;
my $ozy = reslash( 't/text/ozymandias.txt' );
my @expected = line_split( <<"HERE" );
$ozy-1-I met a traveller from an antique land
$ozy-2-Who said: Two vast and trunkless legs of stone
$ozy-3-Stand in the desert... Near them, on the sand,
$ozy:4:Half sunk, a shattered visage lies, whose frown,
$ozy:5:And wrinkled lip, and sneer of cold command,
$ozy-6-Tell that its sculptor well those passions read
$ozy-7-Which yet survive, stamped on these lifeless things,
$ozy-8-The hand that mocked them, and the heart that fed:
$ozy-9-And on the pedestal these words appear:
$ozy-10-'My name is Ozymandias, king of kings:
$ozy-11-Look on my works, ye Mighty, and despair!'
$ozy-12-Nothing beside remains. Round the decay
$ozy-13-Of that colossal wreck, boundless and bare
$ozy-14-The lone and level sands stretch far away.
HERE
# Same results as the "With filename" test except that we exclude "survive".
my @results = run_ack( qw( li\w+ t/text/ozymandias.txt -H --passthru --not survive ) );
lists_match( \@results, \@expected, q{With filename} );
};
SKIP: {
skip 'Input options have not been implemented for Win32 yet', 2 if is_windows();
# Some lines will match, most won't.
my @ack_args = qw( war --passthru --color );
my @results = pipe_into_ack( 't/text/gettysburg.txt', @ack_args );
is( scalar @results, scalar @full_speech, 'Got all the lines back' );
my @escaped_lines = grep { /\e/ } @results;
is( scalar @escaped_lines, 2, 'Only two lines are highlighted' );
}
done_testing();
exit 0;
sub color_match {
my $re = shift;
my @lines = @_;
for my $line ( @lines ) {
if ( $line =~ /$re/ ) {
$line =~ s/($re)/\e[30;43m$1\e[0m/g;
$line .= "\e[0m\e[K";
}
}
return @lines;
}
__DATA__
Four score and seven years ago our fathers brought forth on this
continent, a new nation, conceived in Liberty, and dedicated to the
proposition that all men are created equal.
Now we are engaged in a great civil war, testing whether that nation,
or any nation so conceived and so dedicated, can long endure. We are met
on a great battle-field of that war. We have come to dedicate a portion
of that field, as a final resting place for those who here gave their
lives that that nation might live. It is altogether fitting and proper
that we should do this.
But, in a larger sense, we can not dedicate -- we can not consecrate --
we can not hallow -- this ground. The brave men, living and dead, who
struggled here, have consecrated it, far above our poor power to add or
detract. The world will little note, nor long remember what we say here,
but it can never forget what they did here. It is for us the living,
rather, to be dedicated here to the unfinished work which they who
fought here have thus far so nobly advanced. It is rather for us to be
here dedicated to the great task remaining before us -- that from these
honored dead we take increased devotion to that cause for which they gave
the last full measure of devotion -- that we here highly resolve that
these dead shall not have died in vain -- that this nation, under God,
shall have a new birth of freedom -- and that government of the people,
by the people, for the people, shall not perish from the earth.
ack-v3.8.1/t/ack-help-types.t 000644 000766 000024 00000001261 14376470274 016042 0 ustar 00andy staff 000000 000000 #!perl
use strict;
use warnings;
use List::Util qw(sum);
use Test::More;
use lib 't';
use Util;
prep_environment();
my @types = (
perl => [qw{.pl .pod .pl .t}],
python => [qw{.py}],
ruby => [qw{.rb Rakefile}],
);
plan tests => 11;
my @output = run_ack( '--help-types' );
while ( my ($type,$checks) = splice( @types, 0, 2 ) ) {
my ( $matching_line ) = grep { /^ $type / } @output;
ok( $matching_line, "A match should be found for $type in the output for --help-types" );
foreach my $check (@{$checks}) {
like( $matching_line, qr/\Q$check\E/, "Line for --$type in output for --help-types contains $check" );
}
}
done_testing();
exit 0;
ack-v3.8.1/t/firstlinematch-filter.t 000644 000766 000024 00000001312 14376470354 017507 0 ustar 00andy staff 000000 000000 #!perl
use strict;
use warnings;
use lib 't';
use FilterTest;
use Test::More tests => 1;
use App::Ack::Filter::FirstLineMatch;
filter_test(
[ firstlinematch => '/^#!.*perl/' ], [
't/swamp/#emacs-workfile.pl#',
't/swamp/0',
't/swamp/Makefile.PL',
't/swamp/__pycache__/notes.pl',
't/swamp/options-crlf.pl',
't/swamp/options.pl',
't/swamp/options.pl.bak',
't/swamp/perl-test.t',
't/swamp/perl-without-extension',
't/swamp/perl.cgi',
't/swamp/perl.pl',
't/swamp/perl.pm',
't/swamp/blib/ignore.pm',
't/swamp/blib/ignore.pod',
], 'only files with "perl" in their first line should be matched'
);
ack-v3.8.1/t/ack-show-types.t 000644 000766 000024 00000002121 14376470274 016066 0 ustar 00andy staff 000000 000000 #!perl
use warnings;
use strict;
use Test::More tests => 10;
use lib 't';
use Util;
prep_environment();
RUBY_AND_RAKE: {
do_ruby_test( qw( -f --show-types t/swamp/Rakefile ) );
do_ruby_test( qw( -g \bRakef --show-types t/swamp ) );
}
REQUIRE_F_OR_G: {
my ( $stdout, $stderr ) = run_ack_with_stderr('--show-types');
is_empty_array($stdout, 'No output');
is(scalar(@{$stderr}), 1, 'A single line should be present on standard error');
like($stderr->[0], qr/--show-types can only be used with -f or -g./, 'Right error message' );
is(get_rc(), 255, 'The ack command should not fail');
}
exit 0;
sub do_ruby_test {
local $Test::Builder::Level = $Test::Builder::Level + 1;
my @args = @_;
my @results = run_ack( @args );
is( scalar @results, 1, "Only one file should be returned from 'ack @args'" );
sets_match( get_types( $results[0] ), [qw( ruby rake )], "'ack @args' must return all the expected types" );
return;
}
sub get_types {
my $line = shift;
$line =~ s/.* => //;
my @types = split( /,/, $line );
return \@types;
}
ack-v3.8.1/t/ack-w.t 000644 000766 000024 00000015303 14376470274 014220 0 ustar 00andy staff 000000 000000 #!perl
use warnings;
use strict;
use Test::More tests => 15;
use lib 't';
use Util;
use Barfly;
prep_environment();
my $ACK = $ENV{ACK_TEST_STANDALONE} ? 'ack-standalone' : 'ack';
Barfly->run_tests( 't/ack-w.barfly' );
subtest '-w with trailing metachar \w' => sub {
plan tests => 1;
my @expected = line_split( <<'HERE' );
A well regulated Militia, being necessary to the security of a free State,
cases arising in the land or naval forces, or in the Militia, when in
HERE
my @files = qw( t/text/bill-of-rights.txt );
my @args = ( 'Milit\w\w', qw( -w -h --sort-files ) );
ack_lists_match( [ @args, @files ], \@expected, 'Looking for militia with metacharacters' );
};
subtest '-w with trailing dot' => sub {
plan tests => 1;
my @expected = line_split( <<'HERE' );
A well regulated Militia, being necessary to the security of a free State,
cases arising in the land or naval forces, or in the Militia, when in
HERE
my @files = qw( t/text/bill-of-rights.txt );
my @args = ( 'Milit..', qw( -w -h --sort-files ) );
ack_lists_match( [ @args, @files ], \@expected, 'Looking for Milit..' );
};
subtest 'Begins and ends with word char' => sub {
plan tests => 1;
# Normal case of whole word match.
my @expected = line_split( <<'HERE' );
A well regulated Militia, being necessary to the security of a free State,
cases arising in the land or naval forces, or in the Militia, when in
HERE
my @files = qw( t/text/bill-of-rights.txt );
my @args = qw( Militia -w -h --sort-files );
ack_lists_match( [ @args, @files ], \@expected, 'Looking for Militia as whole word' );
};
subtest 'Ends with grouping parens' => sub {
plan tests => 1;
# The last character of the regexp is not a word, disabling the word boundary check at the end of the match.
my @expected = line_split( <<'HERE' );
A well regulated Militia, being necessary to the security of a free State,
cases arising in the land or naval forces, or in the Militia, when in
HERE
my @files = qw( t/text/bill-of-rights.txt );
my @args = ( 'Militia()', qw( -w -h --sort-files ) );
ack_lists_match( [ @args, @files ], \@expected, 'Looking for Militia with word flag, but regexp does not end with word char' );
};
subtest 'Begins with grouping parens' => sub {
plan tests => 1;
my @expected = line_split( <<'HERE' );
A well regulated Militia, being necessary to the security of a free State,
cases arising in the land or naval forces, or in the Militia, when in
HERE
my @files = qw( t/text/bill-of-rights.txt );
my @args = ( '()Militia', qw( -w -h --sort-files ) );
ack_lists_match( [ @args, @files ], \@expected, 'Looking for Militia with word flag, but regexp does not begin with word char' );
};
subtest 'Wrapped in grouping parens' => sub {
plan tests => 1;
my @expected = line_split( <<'HERE' );
A well regulated Militia, being necessary to the security of a free State,
cases arising in the land or naval forces, or in the Militia, when in
HERE
my @files = qw( t/text/bill-of-rights.txt );
my @args = ( '(Militia)', qw( -w -h --sort-files ) );
ack_lists_match( [ @args, @files ], \@expected, 'Looking for Militia with word flag, but regexp does not begin or end with word char' );
};
# Test for issue ack2#443
subtest 'Alternating numbers' => sub {
plan tests => 1;
my @expected = ();
my @files = qw( t/text/number.txt );
my @args = ( '650|660|670|680', '-w' );
ack_lists_match( [ @args, @files ], \@expected, 'Alternations should also respect boundaries when using -w' );
};
# In ack3, we try to warn people if they are misusing -w.
subtest '-w warnings' => sub {
my ($good,$bad,$inv) = _get_good_and_bad();
plan tests => @{$good} + @{$bad} + @{$inv};
my $happy = reslash( 't/text/ozymandias.txt' );
for my $pattern ( @{$good} ) {
subtest "Good example: $pattern" => sub {
plan tests => 1;
my ( undef, $stderr ) = run_ack_with_stderr( $pattern, '-w', $happy );
# Don't care what stdout is.
is_empty_array( $stderr, 'Should not trigger any warnings' );
}
}
for my $pattern ( @{$bad} ) {
subtest "Bad example: $pattern" => sub {
plan tests => 3;
# Add the -- because the pattern may have hyphens.
my ( $stdout, $stderr ) = run_ack_with_stderr( '-w', '--', $pattern, $happy );
is_empty_array( $stdout, 'Should have no output' );
is( scalar @{$stderr}, 1, 'One warning' );
like( $stderr->[0], qr/$ACK: -w will not do the right thing/, 'Got the correct warning' );
};
}
for my $pattern ( @{$inv} ) {
subtest "Invalid regex: $pattern" => sub {
plan tests => 3;
# Add the -- because the pattern may have hyphens.
my ( $stdout, $stderr ) = run_ack_with_stderr( '-w', '--', $pattern, $happy );
is_empty_array( $stdout, 'Should have no output' );
is( scalar @{$stderr}, 3, 'One warning' );
like( $stderr->[0], qr/$ACK: Invalid regex '\Q$pattern'/ );
};
}
};
sub _get_good_and_bad {
# BAD = should throw a warning with -w
# OK = should not throw a warning with -w
# INV = is an invalid regex whether with -w or not
my @examples = line_split( <<'HERE' );
# Anchors
BAD $foo
BAD foo^
BAD ^foo
BAD foo$
# Dot
OK foo.
OK .foo
# Parentheses
OK (set|get)_foo
OK foo_(id|name)
OK func()
OK (all in one group)
INV )start with closing paren
INV end with opening paren(
BAD end with an escaped closing paren\)
# Character classes
OK [sg]et
OK foo[lt]
OK [one big character class]
OK [multiple][character][classes]
BAD ]starting with a closing bracket
INV ending with an opening bracket[
BAD ending with an escaped closing bracket \]
# Quantifiers
OK thpppt{1,5}
BAD }starting with an closing curly brace
BAD ending with an escaped closing curly brace\}
OK foo+
BAD foo\+
INV +foo
OK foo*
BAD foo\*
INV *foo
OK foo?
BAD foo\?
INV ?foo
# Miscellaneous debris
BAD -foo
BAD foo-
BAD &mpersand
BAD ampersand&
INV function(
BAD ->method
BAD
BAD =14
BAD /slashes/
BAD ::Class::Whatever
BAD Class::Whatever::
OK Class::Whatever
HERE
my $good = [];
my $bad = [];
my $inv = [];
for my $line ( @examples ) {
$line =~ s/\s*$//;
if ( $line eq '' || $line =~ /^#/ ) {
next;
}
elsif ( $line =~ /^OK\s+(.+)/ ) {
push( @{$good}, $1 );
}
elsif ( $line =~ /BAD\s+(.+)/ ) {
push( @{$bad}, $1 );
}
elsif ( $line =~ /INV\s+(.+)/ ) {
push( @{$inv}, $1 );
}
else {
die "Invalid line: $line";
}
}
return ($good, $bad, $inv);
}
done_testing();
exit 0;
ack-v3.8.1/t/exit-code.t 000644 000766 000024 00000000503 14376470274 015073 0 ustar 00andy staff 000000 000000 #!perl
use strict;
use warnings;
use lib 't';
use Test::More tests => 4;
use Util;
prep_environment();
run_ack( 'legislative', 't/text/constitution.txt' );
is( get_rc(), 0, 'Exit code with matches should be 0' );
run_ack( 'foo', 't/text/constitution.txt' );
is( get_rc(), 1, 'Exit code with no matches should be 1' );
ack-v3.8.1/t/ack-files-from.t 000644 000766 000024 00000005745 14376470274 016026 0 ustar 00andy staff 000000 000000 #!perl
use strict;
use warnings;
use lib 't';
use Test::More tests => 6;
use Util;
prep_environment();
my @textfiles = qw(
t/text/amontillado.txt
t/text/bill-of-rights.txt
t/text/constitution.txt
t/text/gettysburg.txt
t/text/ozymandias.txt
t/text/raven.txt
);
subtest 'Basic reading from files, no switches' => sub {
plan tests => 1;
my $target_file = reslash( 't/swamp/options.pl' );
my @expected = line_split( <<"HERE" );
$target_file:2:use strict;
HERE
my $tempfile = create_tempfile( qw( t/swamp/options.pl t/swamp/pipe-stress-freaks.F ) );
ack_lists_match( [ '--files-from=' . $tempfile->filename, 'strict' ], \@expected, 'Looking for strict in multiple files' );
unlink $tempfile->filename;
};
subtest 'Non-existent file specified' => sub {
plan tests => 3;
my @args = qw( strict );
my ( $stdout, $stderr ) = run_ack_with_stderr( '--files-from=non-existent-file', @args);
is_empty_array( $stdout, 'No STDOUT for non-existent file' );
is( scalar @{$stderr}, 1, 'One line of STDERR for non-existent file' );
like( $stderr->[0], qr/Unable to open non-existent-file:/,
'Correct warning message for non-existent file' );
};
subtest 'Source file exists, but non-existent files mentioned in the file' => sub {
plan tests => 4;
my $tempfile = create_tempfile( qw( t/swamp/options.pl file-that-isnt-there ) );
my ( $stdout, $stderr ) = run_ack_with_stderr( '--files-from=' . $tempfile->filename, 'CASE');
is( scalar @{$stdout}, 1, 'One hit found' );
like( $stdout->[0], qr/THIS IS ALL IN UPPER CASE/, 'Find the one line in the file' );
is( scalar @{$stderr}, 1, 'One line of STDERR for non-existent file' );
like( $stderr->[0], qr/file-that-isnt-there: No such file/, 'Correct warning message for non-existent file' );
};
subtest '-l and --files-from' => sub {
plan tests => 1;
my $tempfile = create_tempfile( @textfiles );
my @expected = qw(
t/text/amontillado.txt
t/text/gettysburg.txt
t/text/raven.txt
);
ack_sets_match( [ '--files-from=' . $tempfile->filename, 'God', '-l' ], \@expected, 'Looking for God files' );
};
subtest '-L and --files-from' => sub {
plan tests => 1;
my $tempfile = create_tempfile( @textfiles );
my @expected = qw(
t/text/bill-of-rights.txt
t/text/constitution.txt
t/text/ozymandias.txt
);
ack_sets_match( [ '--files-from=' . $tempfile->filename, 'God', '-L' ], \@expected, 'Looking for absence of God' );
};
subtest '-c and --files-from' => sub {
plan tests => 1;
my $tempfile = create_tempfile( @textfiles );
my @expected = qw(
t/text/amontillado.txt:2
t/text/bill-of-rights.txt:0
t/text/constitution.txt:0
t/text/gettysburg.txt:1
t/text/ozymandias.txt:0
t/text/raven.txt:2
);
ack_sets_match( [ '--files-from=' . $tempfile->filename, 'God', '-c' ], \@expected, 'Looking for God files' );
};
done_testing();
exit 0;
ack-v3.8.1/t/filetype-detection.t 000644 000766 000024 00000003061 14735132514 017000 0 ustar 00andy staff 000000 000000 #!perl
use strict;
use warnings;
use Test::More tests => 5;
use lib 't';
use Util;
prep_environment();
subtest 'Lua shebang' => sub {
plan tests => 1;
ack_sets_match(
[qw( -t lua -f t/swamp )],
[ 't/swamp/lua-shebang-test' ],
'Lua files should be detected by shebang'
);
};
subtest 'R extensions' => sub {
plan tests => 2;
my @expected = qw(
t/swamp/example.R
);
my @args = qw( -t rr -f );
my @results = run_ack( @args );
sets_match( \@results, \@expected, __FILE__ );
};
subtest 'ASP.NET' => sub {
my @expected = qw(
t/swamp/MasterPage.master
t/swamp/Sample.ascx
t/swamp/Sample.asmx
t/swamp/sample.aspx
t/swamp/service.svc
);
my @args = qw( -t aspx -f );
my @results = run_ack(@args);
sets_match( \@results, \@expected, __FILE__ );
};
subtest Python => sub {
my @expected = qw(
t/swamp/test.py
t/swamp/foo_test.py
t/swamp/test_foo.py
);
my @args = qw( -f -t python t/swamp );
ack_sets_match( [ @args ], \@expected, 'With -t python' );
@args = qw( -f --python t/swamp );
ack_sets_match( [ @args ], \@expected, 'With --python' );
};
subtest Pytest => sub {
my @expected = qw(
t/swamp/foo_test.py
t/swamp/test_foo.py
);
my @args = qw( -f -t pytest t/swamp );
ack_sets_match( [ @args ], \@expected, 'With -t pytest' );
@args = qw( -f --pytest t/swamp );
ack_sets_match( [ @args ], \@expected, 'With --pytest' );
};
done_testing();
exit 0;
ack-v3.8.1/t/ack-1.t 000644 000766 000024 00000003321 14376470274 014107 0 ustar 00andy staff 000000 000000 #!perl
use warnings;
use strict;
use Test::More tests => 12;
use lib 't';
use Util;
prep_environment();
SINGLE_TEXT_MATCH: {
my @expected = (
'the catacombs of the Montresors.'
);
my @files = qw( t/text );
my @args = qw( Montresor -1 -h --sort-files );
my @results = run_ack( @args, @files );
lists_match( \@results, \@expected, 'Looking for first instance of Montresor!' );
}
DASH_V: {
my @expected = (
' Only this and nothing more."'
);
my @files = qw( t/text/raven.txt );
my @args = qw( c -1 -h -v );
my @results = run_ack( @args, @files );
lists_match( \@results, \@expected, 'Looking for first non-match' );
}
DASH_F: {
my @files = qw( t/swamp );
my @args = qw( -1 -f );
my @results = run_ack( @args, @files );
my $test_path = reslash( 't/swamp/' );
is( scalar @results, 1, 'Should only get one file back' );
like( $results[0], qr{^\Q$test_path\E}, 'One of the files from the swamp' );
}
DASH_G: {
my $regex = '\bMakefile\b';
my @files = qw( t/ );
my @args = ( '-1', '-g', $regex );
my @results = run_ack( @args, @files );
my $test_path = reslash( 't/swamp/Makefile' );
is( scalar @results, 1, "Should only get one file back from $regex" );
like( $results[0], qr{^\Q$test_path\E(?:[.]PL)?$}, 'The one file matches one of the two Makefile files' );
}
DASH_L: {
my @files = reslash( 't/text' );
my @args = qw( -1 -l --sort-files the ); # --sort-files to make sure we get the same first file each time.
my @results = run_ack( @args, @files );
my $expected = reslash( 't/text/amontillado.txt' );
is_deeply( \@results, [$expected], 'Should only get one matching file back' );
}
ack-v3.8.1/t/invalid-options.t 000644 000766 000024 00000001135 14376470274 016333 0 ustar 00andy staff 000000 000000 #!perl
# https://github.com/beyondgrep/ack3/issues/192
use strict;
use warnings;
use Test::More tests => 5;
use lib 't';
use Util;
prep_environment();
my ( $stdout, $stderr ) = run_ack_with_stderr( '--bloofga' );
is_empty_array( $stdout, 'No output because of our bad option' );
is( $stderr->[0], 'Unknown option: bloofga', 'First line is the error, and should only appear once' );
like( $stderr->[1], qr/ack(?:-standalone)?: Invalid option on command line/, 'Second line is the general error' );
is( scalar @{$stderr}, 2, 'There are no more lines' );
is( get_rc(), 255, 'Should fail' );
exit 0;
ack-v3.8.1/t/ack-ignore-dir.t 000644 000766 000024 00000020240 14376470274 016005 0 ustar 00andy staff 000000 000000 #!perl
use warnings;
use strict;
use Test::More tests => 45;
use File::Spec;
use lib 't';
use Util;
prep_environment();
my @files_mentioning_apples = qw(
t/swamp/groceries/fruit
t/swamp/groceries/junk
t/swamp/groceries/another_subdir/fruit
t/swamp/groceries/another_subdir/junk
t/swamp/groceries/another_subdir/CVS/fruit
t/swamp/groceries/another_subdir/CVS/junk
t/swamp/groceries/another_subdir/RCS/fruit
t/swamp/groceries/another_subdir/RCS/junk
t/swamp/groceries/dir.d/fruit
t/swamp/groceries/dir.d/junk
t/swamp/groceries/dir.d/CVS/fruit
t/swamp/groceries/dir.d/CVS/junk
t/swamp/groceries/dir.d/RCS/fruit
t/swamp/groceries/dir.d/RCS/junk
t/swamp/groceries/subdir/fruit
t/swamp/groceries/subdir/junk
t/swamp/groceries/CVS/fruit
t/swamp/groceries/CVS/junk
t/swamp/groceries/RCS/fruit
t/swamp/groceries/RCS/junk
);
my @std_ignore = qw( RCS CVS );
my( @expected, @results, $test_description );
sub set_up_assertion_that_these_options_will_ignore_those_directories {
my( $options, $ignored_directories, $optional_test_description ) = @_;
local $Test::Builder::Level = $Test::Builder::Level + 1;
$test_description = $optional_test_description || join( ' ', @{$options} );
my $filter = join( '|', @{$ignored_directories} );
@expected = grep { ! m{/(?:$filter)/} } @files_mentioning_apples;
@results = run_ack( @{$options}, '--noenv', '-l', 'apple', 't/swamp' );
# ignore everything in .svn directories
my $svn_regex = quotemeta File::Spec->catfile( '', '.svn', '' ); # the respective filesystem equivalent of '/.svn/'
@results = grep { ! m/$svn_regex/ } @results;
return;
}
DASH_IGNORE_DIR: {
set_up_assertion_that_these_options_will_ignore_those_directories(
[ '--ignore-dir=subdir', ],
[ @std_ignore, 'subdir', ],
);
sets_match( \@results, \@expected, $test_description );
}
DASH_IGNORE_DIR_WITH_SLASH: {
set_up_assertion_that_these_options_will_ignore_those_directories(
[ '--ignore-dir=subdir/', ],
[ @std_ignore, 'subdir', ],
);
sets_match( \@results, \@expected, $test_description );
}
DASH_IGNORE_DIR_MULTIPLE_TIMES: {
set_up_assertion_that_these_options_will_ignore_those_directories(
[ '--ignore-dir=subdir', '--ignore-dir=another_subdir', ],
[ @std_ignore, 'subdir', 'another_subdir', ],
);
sets_match( \@results, \@expected, $test_description );
}
DASH_NOIGNORE_DIR: {
set_up_assertion_that_these_options_will_ignore_those_directories(
[ '--noignore-dir=CVS', ],
[ 'RCS', ],
);
sets_match( \@results, \@expected, $test_description );
}
DASH_NOIGNORE_DIR_MULTIPLE_TIMES: {
set_up_assertion_that_these_options_will_ignore_those_directories(
[ '--noignore-dir=CVS', '--noignore-dir=RCS', ],
[ ],
);
sets_match( \@results, \@expected, $test_description );
}
DASH_IGNORE_DIR_WITH_DASH_NOIGNORE_DIR: {
set_up_assertion_that_these_options_will_ignore_those_directories(
[ '--noignore-dir=CVS', '--ignore-dir=subdir', ],
[ 'RCS', 'subdir', ],
);
sets_match( \@results, \@expected, $test_description );
}
LAST_ONE_LISTED_WINS: {
set_up_assertion_that_these_options_will_ignore_those_directories(
[ '--noignore-dir=CVS', '--ignore-dir=CVS', ],
[ @std_ignore, ],
);
sets_match( \@results, \@expected, $test_description );
set_up_assertion_that_these_options_will_ignore_those_directories(
[ '--noignore-dir=CVS', '--ignore-dir=CVS', '--noignore-dir=CVS', ],
[ 'RCS', ],
);
sets_match( \@results, \@expected, $test_description );
set_up_assertion_that_these_options_will_ignore_those_directories(
[ '--ignore-dir=subdir', '--noignore-dir=subdir', ],
[ @std_ignore, ],
);
sets_match( \@results, \@expected, $test_description );
set_up_assertion_that_these_options_will_ignore_those_directories(
[ '--ignore-dir=subdir', '--noignore-dir=subdir', '--ignore-dir=subdir', ],
[ @std_ignore, 'subdir', ],
);
sets_match( \@results, \@expected, $test_description );
}
DASH_IGNORE_DIR_IGNORES_RELATIVE_PATHS: {
set_up_assertion_that_these_options_will_ignore_those_directories(
[ '--ignore-dir=' . File::Spec->catdir('t' ,'swamp', 'groceries' , 'another_subdir'), ],
[ @std_ignore, 'another_subdir', ],
'ignore relative paths instead of just directory names',
);
sets_match( \@results, \@expected, $test_description );
}
NOIGNORE_SUBDIR_WINS: {
set_up_assertion_that_these_options_will_ignore_those_directories(
[ '--ignore-dir=another_subdir', '--noignore-dir=CVS' ],
[ 'RCS', 'another_subdir(?!/CVS)' ],
);
sets_match( \@results, \@expected, $test_description );
}
IGNORE_DIR_MATCH: {
set_up_assertion_that_these_options_will_ignore_those_directories(
[ '--ignore-dir=match:/\w_subdir/' ],
[ @std_ignore, 'another_subdir', ],
);
sets_match( \@results, \@expected, $test_description );
}
IGNORE_DIR_EXT: {
set_up_assertion_that_these_options_will_ignore_those_directories(
[ '--ignore-dir=ext:d' ],
[ @std_ignore, 'dir.d', ],
);
sets_match( \@results, \@expected, $test_description );
}
IGNORE_DIR_FIRSTMATCH: {
my ( $stdout, $stderr ) = run_ack_with_stderr('--ignore-dir=firstlinematch:perl', '--noenv', '-l', 'apple', 't/swamp');
is(scalar(@{$stdout}), 0, '--ignore-dir=firstlinematch:perl is erroneous and should print nothing to standard output');
isnt(scalar(@{$stderr}), 0, '--ignore-dir=firstlinematch:perl is erroneous and should print something to standard error');
like($stderr->[0], qr/Invalid filter specification "firstlinematch" for option '--ignore-dir'/, '--ignore-dir=firstlinematch:perl should report an error message');
}
IGNORE_DIR_MATCH_NOIGNORE_DIR: {
set_up_assertion_that_these_options_will_ignore_those_directories(
[ '--ignore-dir=match:/\w_subdir/', '--noignore-dir=CVS' ],
[ 'RCS', 'another_subdir(?!/CVS)', ],
);
sets_match( \@results, \@expected, $test_description );
}
IGNORE_DIR_MATCH_NOIGNORE_DIR_IS: {
set_up_assertion_that_these_options_will_ignore_those_directories(
[ '--ignore-dir=match:/\w_subdir/', '--noignore-dir=is:CVS' ],
[ 'RCS', 'another_subdir(?!/CVS)', ],
);
sets_match( \@results, \@expected, $test_description );
}
IGNORE_DIR_MATCH_NOIGNORE_DIR_MATCH: {
set_up_assertion_that_these_options_will_ignore_those_directories(
[ '--ignore-dir=match:/\w_subdir/', '--noignore-dir=match:/^..S/' ],
[ 'another_subdir(?!/(?:CVS|RCS))', ],
);
sets_match( \@results, \@expected, $test_description );
}
NOIGNORE_DIR_RELATIVE_PATHS: {
set_up_assertion_that_these_options_will_ignore_those_directories(
[ '--noignore-dir=' . File::Spec->catdir('t' ,'swamp', 'groceries' , 'another_subdir', 'CVS'), ],
[ 'RCS', '(?