bin/ack

   1 #!/usr/bin/env perl
   2 #
   3 # This file, ack, is generated code.
   4 # Please DO NOT EDIT or send patches for it.
   5 #
   6 # Please take a look at the source from
   7 # http://github.com/petdance/ack2
   8 # and submit patches against the individual files
   9 # that build ack.
  10 #
  11
  12 use strict;
  13 use warnings;
  14
  15 use 5.008;
  16
  17
  18 # XXX Don't make this so brute force
  19 # See also: https://github.com/petdance/ack2/issues/89
  20
  21 use Getopt::Long 2.36 ();
  22
  23 use Carp 1.10 ();
  24
  25 our $VERSION = '2.00b06';
  26 # Check http://betterthangrep.com/ for updates
  27
  28 # These are all our globals.
  29
  30 MAIN: {
  31     $App::Ack::orig_program_name = $0;
  32     $0 = join(' ', 'ack', $0);
  33     if ( $App::Ack::VERSION ne $main::VERSION ) {
  34         App::Ack::die( "Program/library version mismatch\n\t$0 is $main::VERSION\n\t$INC{'App/Ack.pm'} is $App::Ack::VERSION" );
  35     }
  36
  37     # Do preliminary arg checking;
  38     my $env_is_usable = 1;
  39     for ( @ARGV ) {
  40         last if ( $_ eq '--' );
  41
  42         # Get the --thpppt and --bar checking out of the way.
  43         /^--th[pt]+t+$/ && App::Ack::_thpppt($_);
  44         /^--bar$/ && App::Ack::_bar();
  45
  46         # See if we want to ignore the environment. (Don't tell Al Gore.)
  47         if ( /^--(no)?env$/ ) {
  48             $env_is_usable = defined $1 ? 0 : 1;
  49         }
  50     }
  51     if ( !$env_is_usable ) {
  52         my @keys = ( 'ACKRC', grep { /^ACK_/ } keys %ENV );
  53         delete @ENV{@keys};
  54     }
  55     App::Ack::load_colors();
  56
  57     Getopt::Long::Configure('default', 'no_auto_help', 'no_auto_version');
  58     Getopt::Long::Configure('pass_through', 'no_auto_abbrev');
  59     Getopt::Long::GetOptions(
  60         'help'       => sub { App::Ack::show_help(); exit; },
  61         'version'    => sub { App::Ack::print_version_statement(); exit; },
  62         'man'        => sub { App::Ack::show_man(); exit; },
  63     );
  64     Getopt::Long::Configure('default', 'no_auto_help', 'no_auto_version');
  65
  66     if ( !@ARGV ) {
  67         App::Ack::show_help();
  68         exit 1;
  69     }
  70
  71     main();
  72 }
  73
  74 sub _compile_descend_filter {
  75     my ( $opt ) = @_;
  76
  77     my $idirs = $opt->{idirs};
  78     return unless $idirs && @{$idirs};
  79
  80     my %ignore_dirs;
  81
  82     foreach my $idir (@{$idirs}) {
  83         if ( $idir =~ /^(\w+):(.*)/ ) {
  84             if ( $1 eq 'is') {
  85                 $ignore_dirs{$2} = 1;
  86             }
  87             else {
  88                 Carp::croak( 'Non-is filters are not yet supported for --ignore-dir' );
  89             }
  90         }
  91         else {
  92             Carp::croak( qq{Invalid filter specification "$_"} );
  93         }
  94     }
  95
  96     return sub {
  97         return !exists $ignore_dirs{$_} && !exists $ignore_dirs{$File::Next::dir};
  98     };
  99 }
 100
 101 sub _compile_file_filter {
 102     my ( $opt, $start ) = @_;
 103
 104     my $ifiles = $opt->{ifiles};
 105     $ifiles  ||= [];
 106
 107     my @ifiles_filters = map {
 108         my $filter;
 109
 110         if ( /^(\w+):(.+)/ ) {
 111             my ($how,$what) = ($1,$2);
 112             $filter = App::Ack::Filter->create_filter($how, split(/,/, $what));
 113         }
 114         else {
 115             Carp::croak( qq{Invalid filter specification "$_"} );
 116         }
 117         $filter
 118     } @{$ifiles};
 119
 120     my $filters         = $opt->{'filters'} || [];
 121     my $inverse_filters = [ grep {  $_->is_inverted() } @{$filters} ];
 122     @{$filters}         =   grep { !$_->is_inverted() } @{$filters};
 123
 124     my %is_member_of_starting_set = map { (App::Ack::get_file_id($_) => 1) } @{$start};
 125
 126     return sub {
 127         # ack always selects files that are specified on the command
 128         # line, regardless of filetype.  If you want to ack a JPEG,
 129         # and say "ack foo whatever.jpg" it will do it for you.
 130         return 1 if $is_member_of_starting_set{ App::Ack::get_file_id($File::Next::name) };
 131
 132         # Ignore named pipes found in directory searching.  Named
 133         # pipes created by subprocesses get specified on the command
 134         # line, so the rule of "always select whatever is on the
 135         # command line" wins.
 136         return 0 if -p $File::Next::name;
 137
 138         foreach my $filter (@ifiles_filters) {
 139             my $resource = App::Ack::Resource::Basic->new($File::Next::name);
 140             return 0 if ! $resource || $filter->filter($resource);
 141         }
 142         my $match_found = 1;
 143         if ( @{$filters} ) {
 144             $match_found = 0;
 145
 146             foreach my $filter (@{$filters}) {
 147                 my $resource = App::Ack::Resource::Basic->new($File::Next::name);
 148                 return 0 if ! $resource;
 149                 if ($filter->filter($resource)) {
 150                     $match_found = 1;
 151                     last;
 152                 }
 153             }
 154         }
 155         # Don't bother invoking inverse filters unless we consider the current resource a match
 156         if ( $match_found && @{$inverse_filters} ) {
 157             foreach my $filter ( @{$inverse_filters} ) {
 158                 my $resource = App::Ack::Resource::Basic->new($File::Next::name);
 159                 return 0 if ! $resource;
 160                 if ( not $filter->filter( $resource ) ) {
 161                     $match_found = 0;
 162                     last;
 163                 }
 164             }
 165         }
 166         return $match_found;
 167     };
 168 }
 169
 170 sub show_types {
 171     my $resource = shift;
 172     my $ors      = shift;
 173
 174     my @types = App::Ack::filetypes( $resource );
 175     my $types = join( ',', @types );
 176     my $arrow = @types ? ' => ' : ' =>';
 177     App::Ack::print( $resource->name, $arrow, join( ',', @types ), $ors );
 178
 179     return;
 180 }
 181
 182 sub main {
 183     my @arg_sources = App::Ack::retrieve_arg_sources();
 184
 185     my $opt = App::Ack::ConfigLoader::process_args( @arg_sources );
 186
 187     $App::Ack::report_bad_filenames = !$opt->{dont_report_bad_filenames};
 188
 189     if ( $opt->{flush} ) {
 190         $| = 1;
 191     }
 192
 193     if ( not defined $opt->{color} ) {
 194         $opt->{color} = !App::Ack::output_to_pipe() && !$App::Ack::is_windows;
 195     }
 196     if ( not defined $opt->{heading} and not defined $opt->{break}  ) {
 197         $opt->{heading} = $opt->{break} = !App::Ack::output_to_pipe();
 198     }
 199
 200     if ( defined($opt->{H}) || defined($opt->{h}) ) {
 201         $opt->{show_filename}= $opt->{H} && !$opt->{h};
 202     }
 203
 204     if ( my $output = $opt->{output} ) {
 205         $output        =~ s{\\}{\\\\}g;
 206         $output        =~ s{"}{\\"}g;
 207         $opt->{output} = qq{"$output"};
 208     }
 209
 210     my $resources;
 211     if ( $App::Ack::is_filter_mode && !$opt->{files_from} ) { # probably -x
 212         $resources    = App::Ack::Resources->from_stdin( $opt );
 213         my $regex = $opt->{regex};
 214         $regex = shift @ARGV if not defined $regex;
 215         $opt->{regex} = App::Ack::build_regex( $regex, $opt );
 216     }
 217     else {
 218         if ( $opt->{f} || $opt->{lines} ) {
 219             if ( $opt->{regex} ) {
 220                 App::Ack::warn( "regex ($opt->{regex}) specified with -f or --lines" );
 221                 App::Ack::exit_from_ack( 0 ); # XXX the 0 is misleading
 222             }
 223         }
 224         else {
 225             my $regex = $opt->{regex};
 226             $regex = shift @ARGV if not defined $regex;
 227             $opt->{regex} = App::Ack::build_regex( $regex, $opt );
 228         }
 229         my @start;
 230         if ( not defined $opt->{files_from} ) {
 231             @start = @ARGV;
 232         }
 233         if ( !exists($opt->{show_filename}) ) {
 234             unless(@start == 1 && !(-d $start[0])) {
 235                 $opt->{show_filename} = 1;
 236             }
 237         }
 238
 239         if ( defined $opt->{files_from} ) {
 240             $resources = App::Ack::Resources->from_file( $opt, $opt->{files_from} );
 241             exit 1 unless $resources;
 242         }
 243         else {
 244             @start = ('.') unless @start;
 245             foreach my $target (@start) {
 246                 if ( !-e $target && $App::Ack::report_bad_filenames) {
 247                     App::Ack::warn( "$target: No such file or directory" );
 248                 }
 249             }
 250
 251             $opt->{file_filter}    = _compile_file_filter($opt, \@start);
 252             $opt->{descend_filter} = _compile_descend_filter($opt);
 253
 254             $resources = App::Ack::Resources->from_argv( $opt, \@start );
 255         }
 256     }
 257     App::Ack::set_up_pager( $opt->{pager} ) if defined $opt->{pager};
 258
 259     my $print_filenames = $opt->{show_filename};
 260     my $max_count       = $opt->{m};
 261     my $ors             = $opt->{print0} ? "\0" : "\n";
 262     my $only_first      = $opt->{1};
 263
 264     my $nmatches    = 0;
 265     my $total_count = 0;
 266 RESOURCES:
 267     while ( my $resource = $resources->next ) {
 268         # XXX this variable name combined with what we're trying
 269         # to do makes no sense.
 270
 271         # XXX Combine the -f and -g functions
 272         if ( $opt->{f} ) {
 273             # XXX printing should probably happen inside of App::Ack
 274             if ( $opt->{show_types} ) {
 275                 show_types( $resource, $ors );
 276             }
 277             else {
 278                 App::Ack::print( $resource->name, $ors );
 279             }
 280             ++$nmatches;
 281             last RESOURCES if defined($max_count) && $nmatches >= $max_count;
 282         }
 283         elsif ( $opt->{g} ) {
 284             my $is_match = ( $resource->name =~ /$opt->{regex}/o );
 285             if ( $opt->{v} ? !$is_match : $is_match ) {
 286                 if ( $opt->{show_types} ) {
 287                     show_types( $resource, $ors );
 288                 }
 289                 else {
 290                     App::Ack::print( $resource->name, $ors );
 291                 }
 292                 ++$nmatches;
 293                 last RESOURCES if defined($max_count) && $nmatches >= $max_count;
 294             }
 295         }
 296         elsif ( $opt->{lines} ) {
 297             my $print_filename = $opt->{show_filename};
 298             my $passthru       = $opt->{passthru};
 299
 300             my %line_numbers;
 301             foreach my $line ( @{ $opt->{lines} } ) {
 302                 my @lines             = split /,/, $line;
 303                 @lines                = map {
 304                     /^(\d+)-(\d+)$/
 305                         ? ( $1 .. $2 )
 306                         : $_
 307                 } @lines;
 308                 @line_numbers{@lines} = (1) x @lines;
 309             }
 310
 311             my $filename = $resource->name;
 312
 313             local $opt->{color} = 0;
 314
 315             App::Ack::iterate($resource, $opt, sub {
 316                 chomp;
 317
 318                 if ( $line_numbers{$.} ) {
 319                     App::Ack::print_line_with_context($opt, $filename, $_, $.);
 320                 }
 321                 elsif ( $passthru ) {
 322                     App::Ack::print_line_with_options($opt, $filename, $_, $., ':');
 323                 }
 324                 return 1;
 325             });
 326         }
 327         elsif ( $opt->{count} ) {
 328             my $matches_for_this_file = App::Ack::count_matches_in_resource( $resource, $opt );
 329
 330             unless ( $opt->{show_filename} ) {
 331                 $total_count += $matches_for_this_file;
 332                 next RESOURCES;
 333             }
 334
 335             if ( !$opt->{l} || $matches_for_this_file > 0) {
 336                 if ( $print_filenames ) {
 337                     App::Ack::print( $resource->name, ':', $matches_for_this_file, $ors );
 338                 }
 339                 else {
 340                     App::Ack::print( $matches_for_this_file, $ors );
 341                 }
 342             }
 343         }
 344         elsif ( $opt->{l} || $opt->{L} ) {
 345             my $is_match = App::Ack::resource_has_match( $resource, $opt );
 346
 347             if ( $opt->{L} ? !$is_match : $is_match ) {
 348                 App::Ack::print( $resource->name, $ors );
 349                 ++$nmatches;
 350
 351                 last RESOURCES if $only_first;
 352                 last RESOURCES if defined($max_count) && $nmatches >= $max_count;
 353             }
 354         }
 355         else {
 356             $nmatches += App::Ack::print_matches_in_resource( $resource, $opt );
 357             if ( $nmatches && $only_first ) {
 358                 last RESOURCES;
 359             }
 360         }
 361     }
 362
 363     if ( $opt->{count} && !$opt->{show_filename} ) {
 364         App::Ack::print( $total_count, "\n" );
 365     }
 366
 367     close $App::Ack::fh;
 368     App::Ack::exit_from_ack( $nmatches );
 369 }
 370
 371
 372 =head1 NAME
 373
 374 ack - grep-like text finder
 375
 376 =head1 SYNOPSIS
 377
 378     ack [options] PATTERN [FILE...]
 379     ack -f [options] [DIRECTORY...]
 380
 381 =head1 DESCRIPTION
 382
 383 Ack is designed as a replacement for 99% of the uses of F<grep>.
 384
 385 Ack searches the named input FILEs (or standard input if no files
 386 are named, or the file name - is given) for lines containing a match
 387 to the given PATTERN.  By default, ack prints the matching lines.
 388
 389 PATTERN is a Perl regular expression.  Perl regular expressions
 390 are commonly found in other programming languages, but for the particulars
 391 of their behavior, please consult
 392 L<http://perldoc.perl.org/perlreref.html|perlreref>.  If you don't know
 393 how to use regular expression but are interested in learning, you may
 394 consult L<http://perldoc.perl.org/perlretut.html|perlretut>.  If you do not
 395 need or want ack to use regular expressions, please see the
 396 C<-Q>/C<--literal> option.
 397
 398 Ack can also list files that would be searched, without actually
 399 searching them, to let you take advantage of ack's file-type filtering
 400 capabilities.
 401
 402 =head1 FILE SELECTION
 403
 404 If files are not specified for searching, either on the command
 405 line or piped in with the C<-x> option, I<ack> delves into
 406 subdirectories selecting files for searching.
 407
 408 I<ack> is intelligent about the files it searches.  It knows about
 409 certain file types, based on both the extension on the file and,
 410 in some cases, the contents of the file.  These selections can be
 411 made with the B<--type> option.
 412
 413 With no file selection, I<ack> searches through regular files that
 414 are not explicitly excluded by B<--ignore-dir> and B<--ignore-file>
 415 options, either present in F<ackrc> files or on the command line.
 416
 417 The default options for I<ack> ignore certain files and directories.  These
 418 include:
 419
 420 =over 4
 421
 422 =item * Backup files: Files matching F<#*#> or ending with F<~>.
 423
 424 =item * Coredumps: Files matching F<core.\d+>
 425
 426 =item * Version control directories like F<.svn> and F<.git>.
 427
 428 =back
 429
 430 Run I<ack> with the C<--dump> option to see what settings are set.
 431
 432 However, I<ack> always searches the files given on the command line,
 433 no matter what type.  If you tell I<ack> to search in a coredump,
 434 it will search in a coredump.
 435
 436 =head1 DIRECTORY SELECTION
 437
 438 I<ack> descends through the directory tree of the starting directories
 439 specified.  If no directories are specified, the current working directory is
 440 used.  However, it will ignore the shadow directories used by
 441 many version control systems, and the build directories used by the
 442 Perl MakeMaker system.  You may add or remove a directory from this
 443 list with the B<--[no]ignore-dir> option. The option may be repeated
 444 to add/remove multiple directories from the ignore list.
 445
 446 For a complete list of directories that do not get searched, run
 447 C<ack --dump>.
 448
 449 =head1 WHEN TO USE GREP
 450
 451 I<ack> trumps I<grep> as an everyday tool 99% of the time, but don't
 452 throw I<grep> away, because there are times you'll still need it.
 453
 454 E.g., searching through huge files looking for regexes that can be
 455 expressed with I<grep> syntax should be quicker with I<grep>.
 456
 457 If your script or parent program uses I<grep> C<--quiet> or C<--silent>
 458 or needs exit 2 on IO error, use I<grep>.
 459
 460 =head1 OPTIONS
 461
 462 =over 4
 463
 464 =item B<-A I<NUM>>, B<--after-context=I<NUM>>
 465
 466 Print I<NUM> lines of trailing context after matching lines.
 467
 468 =item B<-B I<NUM>>, B<--before-context=I<NUM>>
 469
 470 Print I<NUM> lines of leading context before matching lines.
 471
 472 =item B<--[no]break>
 473
 474 Print a break between results from different files. On by default
 475 when used interactively.
 476
 477 =item B<-C [I<NUM>]>, B<--context[=I<NUM>]>
 478
 479 Print I<NUM> lines (default 2) of context around matching lines.
 480
 481 =item B<-c>, B<--count>
 482
 483 Suppress normal output; instead print a count of matching lines for
 484 each input file.  If B<-l> is in effect, it will only show the
 485 number of lines for each file that has lines matching.  Without
 486 B<-l>, some line counts may be zeroes.
 487
 488 If combined with B<-h> (B<--no-filename>) ack outputs only one total
 489 count.
 490
 491 =item B<--color>, B<--nocolor>, B<--colour>, B<--nocolour>
 492
 493 B<--color> highlights the matching text.  B<--nocolor> supresses
 494 the color.  This is on by default unless the output is redirected.
 495
 496 On Windows, this option is off by default unless the
 497 L<Win32::Console::ANSI> module is installed or the C<ACK_PAGER_COLOR>
 498 environment variable is used.
 499
 500 =item B<--color-filename=I<color>>
 501
 502 Sets the color to be used for filenames.
 503
 504 =item B<--color-match=I<color>>
 505
 506 Sets the color to be used for matches.
 507
 508 =item B<--color-lineno=I<color>>
 509
 510 Sets the color to be used for line numbers.
 511
 512 =item B<--[no]column>
 513
 514 Show the column number of the first match.  This is helpful for
 515 editors that can place your cursor at a given position.
 516
 517 =item B<--create-ackrc>
 518
 519 Dumps the default ack options to standard output.  This is useful for
 520 when you want to customize the defaults.
 521
 522 =item B<--dump>
 523
 524 Writes the list of options loaded and where they came from to standard
 525 output.  Handy for debugging.
 526
 527 =item B<--env>, B<--noenv>
 528
 529 B<--noenv> disables all environment processing. No F<.ackrc> is
 530 read and all environment variables are ignored. By default, F<ack>
 531 considers F<.ackrc> and settings in the environment.
 532
 533 =item B<--flush>
 534
 535 B<--flush> flushes output immediately.  This is off by default
 536 unless ack is running interactively (when output goes to a pipe or
 537 file).
 538
 539 =item B<-f>
 540
 541 Only print the files that would be searched, without actually doing
 542 any searching.  PATTERN must not be specified, or it will be taken
 543 as a path to search.
 544
 545 =item B<--files-from=I<FILE>>
 546
 547 The list of files to be searched is specified in I<FILE>.  The list of
 548 files are seperated by newlines.  If I<FILE> is C<->, the list is loaded
 549 from standard input.
 550
 551 =item B<--[no]filter>
 552
 553 Forces ack to act as if it were recieving input via a pipe.
 554
 555 =item B<--follow>, B<--nofollow>
 556
 557 Follow or don't follow symlinks, other than whatever starting files
 558 or directories were specified on the command line.
 559
 560 This is off by default.
 561
 562 =item B<-g I<REGEX>>
 563
 564 Print files where the relative path + filename matches I<REGEX>.
 565
 566 =item B<--group>, B<--nogroup>
 567
 568 B<--group> groups matches by file name.  This is the default
 569 when used interactively.
 570
 571 B<--nogroup> prints one result per line, like grep.  This is the
 572 default when output is redirected.
 573
 574 =item B<-H>, B<--with-filename>
 575
 576 Print the filename for each match.
 577
 578 =item B<-h>, B<--no-filename>
 579
 580 Suppress the prefixing of filenames on output when multiple files are
 581 searched.
 582
 583 =item B<--[no]heading>
 584
 585 Print a filename heading above each file's results.  This is the default
 586 when used interactively.
 587
 588 =item B<--help>, B<-?>
 589
 590 Print a short help statement.
 591
 592 =item B<--help-types>, B<--help=types>
 593
 594 Print all known types.
 595
 596 =item B<-i>, B<--ignore-case>
 597
 598 Ignore case in the search strings.
 599
 600 =item B<--ignore-ack-defaults>
 601
 602 Tells ack to completely ignore the default definitions provided with ack.
 603 This is useful in combination with B<--create-ackrc> if you I<really> want
 604 to customize ack.
 605
 606 =item B<--[no]ignore-dir=I<DIRNAME>>, B<--[no]ignore-directory=I<DIRNAME>>
 607
 608 Ignore directory (as CVS, .svn, etc are ignored). May be used
 609 multiple times to ignore multiple directories. For example, mason
 610 users may wish to include B<--ignore-dir=data>. The B<--noignore-dir>
 611 option allows users to search directories which would normally be
 612 ignored (perhaps to research the contents of F<.svn/props> directories).
 613
 614 The I<DIRNAME> must always be a simple directory name. Nested
 615 directories like F<foo/bar> are NOT supported. You would need to
 616 specify B<--ignore-dir=foo> and then no files from any foo directory
 617 are taken into account by ack unless given explicitly on the command
 618 line.
 619
 620 =item B<--ignore-file=I<FILTERTYPE:FILTERARGS>>
 621
 622 Ignore files matching I<FILTERTYPE:FILTERARGS>.  The filters are specified
 623 identically to file type filters as seen in L</"Defining your own types">.
 624
 625 =item B<-k>, B<--known-types>
 626
 627 Limit selected files to those with types that ack knows about.  This is
 628 equivalent to the default behavior found in ack 1.
 629
 630 =item B<--lines=I<NUM>>
 631
 632 Only print line I<NUM> of each file. Multiple lines can be given with multiple
 633 B<--lines> options or as a comma separated list (B<--lines=3,5,7>). B<--lines=4-7>
 634 also works. The lines are always output in ascending order, no matter the
 635 order given on the command line.
 636
 637 =item B<-l>, B<--files-with-matches>
 638
 639 Only print the filenames of matching files, instead of the matching text.
 640
 641 =item B<-L>, B<--files-without-matches>
 642
 643 Only print the filenames of files that do I<NOT> match.
 644
 645 =item B<--match I<REGEX>>
 646
 647 Specify the I<REGEX> explicitly. This is helpful if you don't want to put the
 648 regex as your first argument, e.g. when executing multiple searches over the
 649 same set of files.
 650
 651     # search for foo and bar in given files
 652     ack file1 t/file* --match foo
 653     ack file1 t/file* --match bar
 654
 655 =item B<-m=I<NUM>>, B<--max-count=I<NUM>>
 656
 657 Stop reading a file after I<NUM> matches.
 658
 659 =item B<--man>
 660
 661 Print this manual page.
 662
 663 =item B<-n>, B<--no-recurse>
 664
 665 No descending into subdirectories.
 666
 667 =item B<-o>
 668
 669 Show only the part of each line matching PATTERN (turns off text
 670 highlighting)
 671
 672 =item B<--output=I<expr>>
 673
 674 Output the evaluation of I<expr> for each line (turns off text
 675 highlighting)
 676 If PATTERN matches more than once then a line is output for each non-overlapping match.
 677 For more information please see the section L</"Examples of F<--output>">.
 678
 679 =item B<--pager=I<program>>, B<--nopager>
 680
 681 B<--pager> directs ack's output through I<program>.  This can also be specified
 682 via the C<ACK_PAGER> and C<ACK_PAGER_COLOR> environment variables.
 683
 684 Using --pager does not suppress grouping and coloring like piping
 685 output on the command-line does.
 686
 687 B<--nopager> cancels any setting in ~/.ackrc, C<ACK_PAGER> or C<ACK_PAGER_COLOR>.
 688 No output will be sent through a pager.
 689
 690 =item B<--passthru>
 691
 692 Prints all lines, whether or not they match the expression.  Highlighting
 693 will still work, though, so it can be used to highlight matches while
 694 still seeing the entire file, as in:
 695
 696     # Watch a log file, and highlight a certain IP address
 697     $ tail -f ~/access.log | ack --passthru 123.45.67.89
 698
 699 =item B<--print0>
 700
 701 Only works in conjunction with -f, -g, -l or -c (filename output). The filenames
 702 are output separated with a null byte instead of the usual newline. This is
 703 helpful when dealing with filenames that contain whitespace, e.g.
 704
 705     # remove all files of type html
 706     ack -f --html --print0 | xargs -0 rm -f
 707
 708 =item B<-Q>, B<--literal>
 709
 710 Quote all metacharacters in PATTERN, it is treated as a literal.
 711
 712 =item B<-r>, B<-R>, B<--recurse>
 713
 714 Recurse into sub-directories. This is the default and just here for
 715 compatibility with grep. You can also use it for turning B<--no-recurse> off.
 716
 717 =item B<-s>
 718
 719 Suppress error messages about nonexistent or unreadable files.  This is taken
 720 from fgrep.
 721
 722 =item B<--[no]smart-case>, B<--no-smart-case>
 723
 724 Ignore case in the search strings if PATTERN contains no uppercase
 725 characters. This is similar to C<smartcase> in vim. This option is
 726 off by default.
 727
 728 B<-i> always overrides this option.
 729
 730 =item B<--sort-files>
 731
 732 Sorts the found files lexicographically.  Use this if you want your file
 733 listings to be deterministic between runs of I<ack>.
 734
 735 =item B<--show-types>
 736
 737 Outputs the filetypes that ack associates with each file.
 738
 739 Works with B<-f> and B<-g> options.
 740
 741 =item B<--type=TYPE>, B<--type=noTYPE>
 742
 743 Specify the types of files to include or exclude from a search.
 744 TYPE is a filetype, like I<perl> or I<xml>.  B<--type=perl> can
 745 also be specified as B<--perl>, and B<--type=noperl> can be done
 746 as B<--noperl>.
 747
 748 If a file is of both type "foo" and "bar", specifying --foo and
 749 --nobar will exclude the file, because an exclusion takes precedence
 750 over an inclusion.
 751
 752 Type specifications can be repeated and are ORed together.
 753
 754 See I<ack --help=types> for a list of valid types.
 755
 756 =item B<--type-add I<TYPE>:I<FILTER>:I<FILTERARGS>>
 757
 758 Files with the given FILTERARGS applied to the given FILTER
 759 are recognized as being of (the existing) type TYPE.
 760 See also L</"Defining your own types">.
 761
 762
 763 =item B<--type-set I<TYPE>:I<FILTER>:I<FILTERARGS>>
 764
 765 Files with the given FILTERARGS applied to the given FILTER are recognized as
 766 being of type TYPE. This replaces an existing definition for type TYPE.  See
 767 also L</"Defining your own types">.
 768
 769 =item B<--type-del I<TYPE>>
 770
 771 The filters associated with TYPE are removed from Ack, and are no longer considered
 772 for searches.
 773
 774 =item B<-v>, B<--invert-match>
 775
 776 Invert match: select non-matching lines
 777
 778 =item B<--version>
 779
 780 Display version and copyright information.
 781
 782 =item B<-w>, B<--word-regexp>
 783
 784 Force PATTERN to match only whole words.  The PATTERN is wrapped with
 785 C<\b> metacharacters.
 786
 787 =item B<-x>
 788
 789 An abbreviation for B<--files-from=->; the list of files to search are read
 790 from standard input, with one line per file.
 791
 792 =item B<-1>
 793
 794 Stops after reporting first match of any kind.  This is different
 795 from B<--max-count=1> or B<-m1>, where only one match per file is
 796 shown.  Also, B<-1> works with B<-f> and B<-g>, where B<-m> does
 797 not.
 798
 799 =item B<--thpppt>
 800
 801 Display the all-important Bill The Cat logo.  Note that the exact
 802 spelling of B<--thpppppt> is not important.  It's checked against
 803 a regular expression.
 804
 805 =item B<--bar>
 806
 807 Check with the admiral for traps.
 808
 809 =back
 810
 811 =head1 THE .ackrc FILE
 812
 813 The F<.ackrc> file contains command-line options that are prepended
 814 to the command line before processing.  Multiple options may live
 815 on multiple lines.  Lines beginning with a # are ignored.  A F<.ackrc>
 816 might look like this:
 817
 818     # Always sort the files
 819     --sort-files
 820
 821     # Always color, even if piping to a another program
 822     --color
 823
 824     # Use "less -r" as my pager
 825     --pager=less -r
 826
 827 Note that arguments with spaces in them do not need to be quoted,
 828 as they are not interpreted by the shell. Basically, each I<line>
 829 in the F<.ackrc> file is interpreted as one element of C<@ARGV>.
 830
 831 F<ack> looks in several locations for F<.ackrc> files; the searching
 832 process is detailed in L</"ACKRC LOCATION SEMANTICS">.  These
 833 files are not considered if B<--noenv> is specified on the command line.
 834
 835 =head1 Defining your own types
 836
 837 ack allows you to define your own types in addition to the predefined
 838 types. This is done with command line options that are best put into
 839 an F<.ackrc> file - then you do not have to define your types over and
 840 over again. In the following examples the options will always be shown
 841 on one command line so that they can be easily copy & pasted.
 842
 843 I<ack --perl foo> searches for foo in all perl files. I<ack --help=types>
 844 tells you, that perl files are files ending
 845 in .pl, .pm, .pod or .t. So what if you would like to include .xs
 846 files as well when searching for --perl files? I<ack --type-add perl:ext:xs --perl foo>
 847 does this for you. B<--type-add> appends
 848 additional extensions to an existing type.
 849
 850 If you want to define a new type, or completely redefine an existing
 851 type, then use B<--type-set>. I<ack --type-set eiffel:ext:e,eiffel> defines
 852 the type I<eiffel> to include files with
 853 the extensions .e or .eiffel. So to search for all eiffel files
 854 containing the word Bertrand use I<ack --type-set eiffel:ext:e,eiffel --eiffel Bertrand>.
 855 As usual, you can also write B<--type=eiffel>
 856 instead of B<--eiffel>. Negation also works, so B<--noeiffel> excludes
 857 all eiffel files from a search. Redefining also works: I<ack --type-set cc:ext:c,h>
 858 and I<.xs> files no longer belong to the type I<cc>.
 859
 860 When defining your own types in the F<.ackrc> file you have to use
 861 the following:
 862
 863   --type-set=eiffel:ext:e,eiffel
 864
 865 or writing on separate lines
 866
 867   --type-set
 868   eiffel:ext:e,eiffel
 869
 870 The following does B<NOT> work in the F<.ackrc> file:
 871
 872   --type-set eiffel:ext:e,eiffel
 873
 874
 875 In order to see all currently defined types, use I<--help-types>, e.g.
 876 I<ack --type-set backup:ext:bak --type-add perl:ext:perl --help-types>
 877
 878 In addition to filtering based on extension (like ack 1.x allowed), ack 2
 879 offers additional filter types.  The generic syntax is
 880 I<--type-set TYPE:FILTER:FILTERARGS>; I<FILTERARGS> depends on the value
 881 of I<FILTER>.
 882
 883 =over 4
 884
 885 =item is:I<FILENAME>
 886
 887 I<is> filters match the target filename exactly.  It takes exactly one
 888 argument, which is the name of the file to match.
 889
 890 Example:
 891
 892     --type-set make:is:Makefile
 893
 894 =item ext:I<EXTENSION>[,I<EXTENSION2>[,...]]
 895
 896 I<ext> filters match the extension of the target file against a list
 897 of extensions.  No leading dot is needed for the extensions.
 898
 899 Example:
 900
 901     --type-set perl:ext:pl,pm,t
 902
 903 =item match:I<REGEX>
 904
 905 I<match> filters match the target filename against a regular expression.
 906 The regular expression is made case insensitive for the search.
 907
 908 Example:
 909
 910     --type-set make:match:/(gnu)?makefile/
 911
 912 =item firstlinematch:I<REGEX>
 913
 914 I<firstlinematch> matches the first line of the target file against a
 915 regular expression.  Like I<match>, the regular expression is made
 916 case insensitive.
 917
 918 Example:
 919
 920     --type-add perl:firstlinematch:/perl/
 921
 922 =back
 923
 924 More filter types may be made available in the future.
 925
 926 =head1 ENVIRONMENT VARIABLES
 927
 928 For commonly-used ack options, environment variables can make life
 929 much easier.  These variables are ignored if B<--noenv> is specified
 930 on the command line.
 931
 932 =over 4
 933
 934 =item ACKRC
 935
 936 Specifies the location of the user's F<.ackrc> file.  If this file doesn't
 937 exist, F<ack> looks in the default location.
 938
 939 =item ACK_OPTIONS
 940
 941 This variable specifies default options to be placed in front of
 942 any explicit options on the command line.
 943
 944 =item ACK_COLOR_FILENAME
 945
 946 Specifies the color of the filename when it's printed in B<--group>
 947 mode.  By default, it's "bold green".
 948
 949 The recognized attributes are clear, reset, dark, bold, underline,
 950 underscore, blink, reverse, concealed black, red, green, yellow,
 951 blue, magenta, on_black, on_red, on_green, on_yellow, on_blue,
 952 on_magenta, on_cyan, and on_white.  Case is not significant.
 953 Underline and underscore are equivalent, as are clear and reset.
 954 The color alone sets the foreground color, and on_color sets the
 955 background color.
 956
 957 This option can also be set with B<--color-filename>.
 958
 959 =item ACK_COLOR_MATCH
 960
 961 Specifies the color of the matching text when printed in B<--color>
 962 mode.  By default, it's "black on_yellow".
 963
 964 This option can also be set with B<--color-match>.
 965
 966 See B<ACK_COLOR_FILENAME> for the color specifications.
 967
 968 =item ACK_COLOR_LINENO
 969
 970 Specifies the color of the line number when printed in B<--color>
 971 mode.  By default, it's "bold yellow".
 972
 973 This option can also be set with B<--color-lineno>.
 974
 975 See B<ACK_COLOR_FILENAME> for the color specifications.
 976
 977 =item ACK_PAGER
 978
 979 Specifies a pager program, such as C<more>, C<less> or C<most>, to which
 980 ack will send its output.
 981
 982 Using C<ACK_PAGER> does not suppress grouping and coloring like
 983 piping output on the command-line does, except that on Windows
 984 ack will assume that C<ACK_PAGER> does not support color.
 985
 986 C<ACK_PAGER_COLOR> overrides C<ACK_PAGER> if both are specified.
 987
 988 =item ACK_PAGER_COLOR
 989
 990 Specifies a pager program that understands ANSI color sequences.
 991 Using C<ACK_PAGER_COLOR> does not suppress grouping and coloring
 992 like piping output on the command-line does.
 993
 994 If you are not on Windows, you never need to use C<ACK_PAGER_COLOR>.
 995
 996 =back
 997
 998 =head1 ACK & OTHER TOOLS
 999
1000 =head2 Vim integration
1001
1002 F<ack> integrates easily with the Vim text editor. Set this in your
1003 F<.vimrc> to use F<ack> instead of F<grep>:
1004
1005     set grepprg=ack\ -k
1006
1007 That example uses C<-k> to search through only files of the types ack
1008 knows about, but you may use other default flags. Now you can search
1009 with F<ack> and easily step through the results in Vim:
1010
1011   :grep Dumper perllib
1012
1013 =head2 Emacs integration
1014
1015 Phil Jackson put together an F<ack.el> extension that "provides a
1016 simple compilation mode ... has the ability to guess what files you
1017 want to search for based on the major-mode."
1018
1019 L<http://www.shellarchive.co.uk/content/emacs.html>
1020
1021 =head2 TextMate integration
1022
1023 Pedro Melo is a TextMate user who writes "I spend my day mostly
1024 inside TextMate, and the built-in find-in-project sucks with large
1025 projects.  So I hacked a TextMate command that was using find +
1026 grep to use ack.  The result is the Search in Project with ack, and
1027 you can find it here:
1028 L<http://www.simplicidade.org/notes/archives/2008/03/search_in_proje.html>"
1029
1030 =head2 Shell and Return Code
1031
1032 For greater compatibility with I<grep>, I<ack> in normal use returns
1033 shell return or exit code of 0 only if something is found and 1 if
1034 no match is found.
1035
1036 (Shell exit code 1 is C<$?=256> in perl with C<system> or backticks.)
1037
1038 The I<grep> code 2 for errors is not used.
1039
1040 If C<-f> or C<-g> are specified, then 0 is returned if at least one
1041 file is found.  If no files are found, then 1 is returned.
1042
1043 =cut
1044
1045 =head1 DEBUGGING ACK PROBLEMS
1046
1047 If ack gives you output you're not expecting, start with a few simple steps.
1048
1049 =head2 Use B<--noenv>
1050
1051 Your environment variables and F<.ackrc> may be doing things you're
1052 not expecting, or forgotten you specified.  Use B<--noenv> to ignore
1053 your environment and F<.ackrc>.
1054
1055 =head2 Use B<-f> to see what files have been selected
1056
1057 Ack's B<-f> was originally added as a debugging tool.  If ack is
1058 not finding matches you think it should find, run F<ack -f> to see
1059 what files have been selected.  You can also add the C<--show-types>
1060 options to show the type of each file selected.
1061
1062 =head2 Use B<--dump>
1063
1064 This lists the ackrc files that are loaded and the options loaded
1065 from them.
1066 So for example you can find a list of directories that do not get searched or where filetypes are defined.
1067
1068 =head1 TIPS
1069
1070 =head2 Use the F<.ackrc> file.
1071
1072 The F<.ackrc> is the place to put all your options you use most of
1073 the time but don't want to remember.  Put all your --type-add and
1074 --type-set definitions in it.  If you like --smart-case, set it
1075 there, too.  I also set --sort-files there.
1076
1077 =head2 Use F<-f> for working with big codesets
1078
1079 Ack does more than search files.  C<ack -f --perl> will create a
1080 list of all the Perl files in a tree, ideal for sending into F<xargs>.
1081 For example:
1082
1083     # Change all "this" to "that" in all Perl files in a tree.
1084     ack -f --perl | xargs perl -p -i -e's/this/that/g'
1085
1086 or if you prefer:
1087
1088     perl -p -i -e's/this/that/g' $(ack -f --perl)
1089
1090 =head2 Use F<-Q> when in doubt about metacharacters
1091
1092 If you're searching for something with a regular expression
1093 metacharacter, most often a period in a filename or IP address, add
1094 the -Q to avoid false positives without all the backslashing.  See
1095 the following example for more...
1096
1097 =head2 Use ack to watch log files
1098
1099 Here's one I used the other day to find trouble spots for a website
1100 visitor.  The user had a problem loading F<troublesome.gif>, so I
1101 took the access log and scanned it with ack twice.
1102
1103     ack -Q aa.bb.cc.dd /path/to/access.log | ack -Q -B5 troublesome.gif
1104
1105 The first ack finds only the lines in the Apache log for the given
1106 IP.  The second finds the match on my troublesome GIF, and shows
1107 the previous five lines from the log in each case.
1108
1109 =head2 Examples of F<--output>
1110
1111 Following variables are useful in the expansion string:
1112
1113 =over 4
1114
1115 =item C<$&>
1116
1117 The whole string matched by PATTERN.
1118
1119 =item C<$1>, C<$2>, ...
1120
1121 The contents of the 1st, 2nd ... bracketed group in PATTERN.
1122
1123 =item C<$`>
1124
1125 The string before the match.
1126
1127 =item C<$'>
1128
1129 The string after the match.
1130
1131 =back
1132
1133 For more details and other variables see
1134 L<http://perldoc.perl.org/perlvar.html#Variables-related-to-regular-expressions|perlvar>.
1135
1136 This example shows how to add text around a particular pattern
1137 (in this case adding _ around word with "e")
1138
1139     ack2.pl "\w*e\w*" quick.txt --output="$`_$&_$'"
1140     _The_ quick brown fox jumps over the lazy dog
1141     The quick brown fox jumps _over_ the lazy dog
1142     The quick brown fox jumps over _the_ lazy dog
1143
1144 This shows how to pick out particular parts of a match using ( ) within regular expression.
1145
1146   ack '=head(\d+)\s+(.*)' --output=' $1 : $2'
1147   input file contains "=head1 NAME"
1148   output  "1 : NAME"
1149
1150 =head2 Share your knowledge
1151
1152 Join the ack-users mailing list.  Send me your tips and I may add
1153 them here.
1154
1155 =head1 FAQ
1156
1157 =head2 Why isn't ack finding a match in (some file)?
1158
1159 Probably because it's of a type that ack doesn't recognize.  ack's
1160 searching behavior is driven by filetype.  B<If ack doesn't know
1161 what kind of file it is, ack ignores the file.>
1162
1163 Use the C<-f> switch to see a list of files that ack will search
1164 for you.
1165
1166 If you want ack to search files that it doesn't recognize, use the
1167 C<-a> switch.
1168
1169 If you want ack to search every file, even ones that it always
1170 ignores like coredumps and backup files, use the C<-u> switch.
1171
1172 =head2 Why does ack ignore unknown files by default?
1173
1174 ack is designed by a programmer, for programmers, for searching
1175 large trees of code.  Most codebases have a lot files in them which
1176 aren't source files (like compiled object files, source control
1177 metadata, etc), and grep wastes a lot of time searching through all
1178 of those as well and returning matches from those files.
1179
1180 That's why ack's behavior of not searching things it doesn't recognize
1181 is one of its greatest strengths: the speed you get from only
1182 searching the things that you want to be looking at.
1183
1184 =head2 Wouldn't it be great if F<ack> did search & replace?
1185
1186 No, ack will always be read-only.  Perl has a perfectly good way
1187 to do search & replace in files, using the C<-i>, C<-p> and C<-n>
1188 switches.
1189
1190 You can certainly use ack to select your files to update.  For
1191 example, to change all "foo" to "bar" in all PHP files, you can do
1192 this from the Unix shell:
1193
1194     $ perl -i -p -e's/foo/bar/g' $(ack -f --php)
1195
1196 =head2 Can you make ack recognize F<.xyz> files?
1197
1198 Yes!  Please see L</"Defining your own types">.  If you think
1199 that F<ack> should recognize a type by default, please see
1200 L</"ENHANCEMENTS">.
1201
1202 =head2 There's already a program/package called ack.
1203
1204 Yes, I know.
1205
1206 =head2 Why is it called ack if it's called ack-grep?
1207
1208 The name of the program is "ack".  Some packagers have called it
1209 "ack-grep" when creating packages because there's already a package
1210 out there called "ack" that has nothing to do with this ack.
1211
1212 I suggest you make a symlink named F<ack> that points to F<ack-grep>
1213 because one of the crucial benefits of ack is having a name that's
1214 so short and simple to type.
1215
1216 To do that, run this with F<sudo> or as root:
1217
1218    ln -s /usr/bin/ack-grep /usr/bin/ack
1219
1220 Alternatively, you could use a shell alias:
1221
1222     # bash/zsh
1223     alias ack=ack-grep
1224
1225     # csh
1226     alias ack ack-grep
1227
1228 =head2 What does F<ack> mean?
1229
1230 Nothing.  I wanted a name that was easy to type and that you could
1231 pronounce as a single syllable.
1232
1233 =head2 Can I do multi-line regexes?
1234
1235 No, ack does not support regexes that match multiple lines.  Doing
1236 so would require reading in the entire file at a time.
1237
1238 If you want to see lines near your match, use the C<--A>, C<--B>
1239 and C<--C> switches for displaying context.
1240
1241 =head2 Why is ack telling me I have an invalid option when searching for C<+foo>?
1242
1243 ack treats command line options beginning with C<+> or C<-> as options; if you
1244 would like to search for these, you may prefix your search term with C<--> or
1245 use the C<--match> option.  (However, don't forget that C<+> is a regular
1246 expression metacharacter!)
1247
1248 =head1 ACKRC LOCATION SEMANTICS
1249
1250 Ack can load its configuration from many sources.  This list
1251 specifies the sources Ack looks for configuration; each one
1252 that is found is loaded in the order specified here, and
1253 each one overrides options set in any of the sources preceding
1254 it.  (For example, if I set --sort-files in my user ackrc, and
1255 --nosort-files on the command line, the command line takes
1256 precedence)
1257
1258 =over 4
1259
1260 =item *
1261
1262 Defaults are loaded from App::Ack::ConfigDefaults.  This can be omitted
1263 using C<--ignore-ack-defaults>.
1264
1265 =item * Global ackrc
1266
1267 Options are then loaded from the global ackrc.  This is located at
1268 C</etc/ackrc> on Unix-like systems, and
1269 C<C:\Documents and Settings\All Users\Application Data> on Windows.
1270 This can be omitted using C<--noenv>.
1271
1272 =item * User ackrc
1273
1274 Options are then loaded from the user's ackrc.  This is located at
1275 C<$HOME/.ackrc> on Unix-like systems, and
1276 C<C:\Documents and Settings\$USER\Application Data>.  If a different
1277 ackrc is desired, it may be overriden with the C<$ACKRC> environment
1278 variable.
1279 This can be omitted using C<--noenv>.
1280
1281 =item * Project ackrc
1282
1283 Options are then loaded from the project ackrc.  The project ackrc is
1284 the first ackrc file with the name C<.ackrc> or C<_ackrc>, first searching
1285 in the current directory, then the parent directory, then the grandparent
1286 directory, etc.  This can be omitted using C<--noenv>.
1287
1288 =item * ACK_OPTIONS
1289
1290 Options are then loaded from the enviroment variable C<ACK_OPTIONS>.  This can
1291 be omitted using C<--noenv>.
1292
1293 =item * Command line
1294
1295 Options are then loaded from the command line.
1296
1297 =back
1298
1299 =head1 DIFFERENCES BETWEEN ACK 1.X AND ACK 2.X
1300
1301 A lot of changes were made for ack 2; here is a list of them.
1302
1303 =head2 GENERAL CHANGES
1304
1305 =over 4
1306
1307 =item *
1308
1309 When no selectors are specified, ack 1.x only searches through files that
1310 it can map to a file type.  ack 2.x, by constrast, will search through
1311 every regular, non-binary file that is not explicitly ignored via
1312 B<--ignore-file> or B<--ignore-dir>.  This is similar to the behavior of the
1313 B<-a/--all> option in ack 1.x.
1314
1315 =item *
1316
1317 A more flexible filter system has been added, so that more powerful file types
1318 may be created by the user.  For details, please consult
1319 L</"Defining your own types">.
1320
1321 =item *
1322
1323 ack now loads multiple ackrc files; see L</"ACKRC LOCATION SEMANTICS"> for
1324 details.
1325
1326 =item *
1327
1328 ack's default filter definitions aren't special; you may tell ack to
1329 completely disregard them if you don't like them.
1330
1331 =back
1332
1333 =head2 REMOVED OPTIONS
1334
1335 =over 4
1336
1337 =item *
1338
1339 Because of the change in default search behavior, the B<-a/--all> and
1340 B<-u/--unrestricted> options have been removed.  In addition, the
1341 B<-k/--known-types> option was added to cause ack to behave with
1342 the default search behavior of ack 1.x.
1343
1344 =item *
1345
1346 The B<-G> option has been removed.  Two regular expressions on the
1347 command line was considered too confusing; to simulate B<-G>'s functionality,
1348 you may use the new B<-x> option to pipe filenames from one invocation of
1349 ack into another.
1350
1351 =item *
1352
1353 The B<--binary> option has been removed.
1354
1355 =item *
1356
1357 The B<--skipped> option has been removed.
1358
1359 =item *
1360
1361 The B<--text> option has been removed.
1362
1363 =item *
1364
1365 The B<--invert-file-match> option has been removed.  Instead, you may
1366 use B<-v> with B<-g>.
1367
1368 =back
1369
1370 =head2 CHANGED OPTIONS
1371
1372 =over 4
1373
1374 =item *
1375
1376 The options that modify the regular expression's behavior (B<-i>, B<-w>,
1377 B<-Q>, and B<-v>) may now be used with B<-g>.
1378
1379 =back
1380
1381 =head2 ADDED OPTIONS
1382
1383 =over 4
1384
1385 =item *
1386
1387 B<--files-from> was added so that a user may submit a list of filenames as
1388 a list of files to search.
1389
1390 =item *
1391
1392 B<-x> was added to tell ack to accept a list of filenames via standard input;
1393 this list is the list of filenames that will be used for the search.
1394
1395 =item *
1396
1397 B<-s> was added to tell ack to suppress error messages about non-existent or
1398 unreadable files.
1399
1400 =item *
1401
1402 B<--ignore-directory> and B<--noignore-directory> were added as aliases for
1403 B<--ignore-dir> and B<--noignore-dir> respectively.
1404
1405 =item *
1406
1407 B<--ignore-file> was added so that users may specify patterns of files to
1408 ignore (ex. /.*~$/).
1409
1410 =item *
1411
1412 B<--dump> was added to allow users to easily find out which options are
1413 set where.
1414
1415 =item *
1416
1417 B<--create-ackrc> was added so that users may create custom ackrc files based
1418 on the default settings loaded by ack, and so that users may easily view those
1419 defaults.
1420
1421 =item *
1422
1423 B<--type-del> was added to selectively remove file type definitions.
1424
1425 =item *
1426
1427 B<--ignore-ack-defaults> was added so that users may ignore ack's default
1428 options in favor of their own.
1429
1430 =item *
1431
1432 B<--bar> was added so ack users may consult Admiral Ackbar.
1433
1434 =back
1435
1436 =head1 AUTHOR
1437
1438 Andy Lester, C<< <andy at petdance.com> >>
1439
1440 =head1 BUGS
1441
1442 Please report any bugs or feature requests to the issues list at
1443 Github: L<https://github.com/petdance/ack2/issues>
1444
1445 =head1 ENHANCEMENTS
1446
1447 All enhancement requests MUST first be posted to the ack-users
1448 mailing list at L<http://groups.google.com/group/ack-users>.  I
1449 will not consider a request without it first getting seen by other
1450 ack users.  This includes requests for new filetypes.
1451
1452 There is a list of enhancements I want to make to F<ack> in the ack
1453 issues list at Github: L<https://github.com/petdance/ack2/issues>
1454
1455 Patches are always welcome, but patches with tests get the most
1456 attention.
1457
1458 =head1 SUPPORT
1459
1460 Support for and information about F<ack> can be found at:
1461
1462 =over 4
1463
1464 =item * The ack homepage
1465
1466 L<http://betterthangrep.com/>
1467
1468 =item * The ack-users mailing list
1469
1470 L<http://groups.google.com/group/ack-users>
1471
1472 =item * The ack issues list at Github
1473
1474 L<https://github.com/petdance/ack2/issues>
1475
1476 =item * AnnoCPAN: Annotated CPAN documentation
1477
1478 L<http://annocpan.org/dist/ack>
1479
1480 =item * CPAN Ratings
1481
1482 L<http://cpanratings.perl.org/d/ack>
1483
1484 =item * Search CPAN
1485
1486 L<http://search.cpan.org/dist/ack>
1487
1488 =item * Git source repository
1489
1490 L<https://github.com/petdance/ack2>
1491
1492 =back
1493
1494 =head1 ACKNOWLEDGEMENTS
1495
1496 How appropriate to have I<ack>nowledgements!
1497
1498 Thanks to everyone who has contributed to ack in any way, including
1499 Andrew Black,
1500 Ralph Bodenner,
1501 Shaun Patterson,
1502 Ryan Olson,
1503 Shlomi Fish,
1504 Karen Etheridge,
1505 Olivier Mengue,
1506 Matthew Wild,
1507 Scott Kyle,
1508 Nick Hooey,
1509 Bo Borgerson,
1510 Mark Szymanski,
1511 Marq Schneider,
1512 Packy Anderson,
1513 JR Boyens,
1514 Dan Sully,
1515 Ryan Niebur,
1516 Kent Fredric,
1517 Mike Morearty,
1518 Ingmar Vanhassel,
1519 Eric Van Dewoestine,
1520 Sitaram Chamarty,
1521 Adam James,
1522 Richard Carlsson,
1523 Pedro Melo,
1524 AJ Schuster,
1525 Phil Jackson,
1526 Michael Schwern,
1527 Jan Dubois,
1528 Christopher J. Madsen,
1529 Matthew Wickline,
1530 David Dyck,
1531 Jason Porritt,
1532 Jjgod Jiang,
1533 Thomas Klausner,
1534 Uri Guttman,
1535 Peter Lewis,
1536 Kevin Riggle,
1537 Ori Avtalion,
1538 Torsten Blix,
1539 Nigel Metheringham,
1540 GE<aacute>bor SzabE<oacute>,
1541 Tod Hagan,
1542 Michael Hendricks,
1543 E<AElig>var ArnfjE<ouml>rE<eth> Bjarmason,
1544 Piers Cawley,
1545 Stephen Steneker,
1546 Elias Lutfallah,
1547 Mark Leighton Fisher,
1548 Matt Diephouse,
1549 Christian Jaeger,
1550 Bill Sully,
1551 Bill Ricker,
1552 David Golden,
1553 Nilson Santos F. Jr,
1554 Elliot Shank,
1555 Merijn Broeren,
1556 Uwe Voelker,
1557 Rick Scott,
1558 Ask BjE<oslash>rn Hansen,
1559 Jerry Gay,
1560 Will Coleda,
1561 Mike O'Regan,
1562 Slaven ReziE<0x107>,
1563 Mark Stosberg,
1564 David Alan Pisoni,
1565 Adriano Ferreira,
1566 James Keenan,
1567 Leland Johnson,
1568 Ricardo Signes,
1569 Pete Krawczyk and
1570 Rob Hoelz.
1571
1572 =head1 COPYRIGHT & LICENSE
1573
1574 Copyright 2005-2013 Andy Lester.
1575
1576 This program is free software; you can redistribute it and/or modify
1577 it under the terms of the Artistic License v2.0.
1578
1579 See http://www.perlfoundation.org/artistic_license_2_0 or the LICENSE.md
1580 file that comes with the ack distribution.
1581
1582 =cut
1583 package File::Next;
1584
1585 use strict;
1586 use warnings;
1587
1588
1589 our $VERSION = '1.12';
1590
1591
1592
1593 use File::Spec ();
1594
1595 our $name; # name of the current file
1596 our $dir;  # dir of the current file
1597
1598 our %files_defaults;
1599 our %skip_dirs;
1600
1601 BEGIN {
1602     %files_defaults = (
1603         file_filter     => undef,
1604         descend_filter  => undef,
1605         error_handler   => sub { CORE::die @_ },
1606         warning_handler => sub { CORE::warn @_ },
1607         sort_files      => undef,
1608         follow_symlinks => 1,
1609         nul_separated   => 0,
1610     );
1611     %skip_dirs = map {($_,1)} (File::Spec->curdir, File::Spec->updir);
1612 }
1613
1614
1615 sub files {
1616     die _bad_invocation() if @_ && defined($_[0]) && ($_[0] eq __PACKAGE__);
1617
1618     my ($parms,@queue) = _setup( \%files_defaults, @_ );
1619     my $filter = $parms->{file_filter};
1620
1621     return sub {
1622         while (@queue) {
1623             my ($dirname,$file,$fullpath) = splice( @queue, 0, 3 );
1624             if ( -f $fullpath || -p $fullpath || $fullpath =~ m{^/dev/fd} ) {
1625                 if ( $filter ) {
1626                     local $_ = $file;
1627                     local $File::Next::dir = $dirname;
1628                     local $File::Next::name = $fullpath;
1629                     next if not $filter->();
1630                 }
1631                 return wantarray ? ($dirname,$file,$fullpath) : $fullpath;
1632             }
1633             elsif ( -d _ ) {
1634                 unshift( @queue, _candidate_files( $parms, $fullpath ) );
1635             }
1636         } # while
1637
1638         return;
1639     }; # iterator
1640 }
1641
1642
1643
1644
1645
1646
1647 sub from_file {
1648     die _bad_invocation() if @_ && defined($_[0]) && ($_[0] eq __PACKAGE__);
1649
1650     my ($parms,@queue) = _setup( \%files_defaults, @_ );
1651     my $err  = $parms->{error_handler};
1652     my $warn = $parms->{error_handler};
1653
1654     my $filename = $queue[1];
1655
1656     if ( !defined($filename) ) {
1657         $err->( 'Must pass a filename to from_file()' );
1658         return undef;
1659     }
1660
1661     my $fh;
1662     if ( $filename eq '-' ) {
1663         $fh = \*STDIN;
1664     }
1665     else {
1666         if ( !open( $fh, '<', $filename ) ) {
1667             $err->( "Unable to open $filename: $!" );
1668             return undef;
1669         }
1670     }
1671     my $filter = $parms->{file_filter};
1672
1673     return sub {
1674         local $/ = $parms->{nul_separated} ? "\x00" : $/;
1675         while ( my $fullpath = <$fh> ) {
1676             chomp $fullpath;
1677             next unless $fullpath =~ /./;
1678             if ( not ( -f $fullpath || -p _ ) ) {
1679                 $warn->( "$fullpath: No such file" );
1680                 next;
1681             }
1682
1683             my ($volume,$dirname,$file) = File::Spec->splitpath( $fullpath );
1684             if ( $filter ) {
1685                 local $_ = $file;
1686                 local $File::Next::dir  = $dirname;
1687                 local $File::Next::name = $fullpath;
1688                 next if not $filter->();
1689             }
1690             return wantarray ? ($dirname,$file,$fullpath) : $fullpath;
1691         } # while
1692         close $fh;
1693
1694         return;
1695     }; # iterator
1696 }
1697
1698 sub _bad_invocation {
1699     my $good = (caller(1))[3];
1700     my $bad  = $good;
1701     $bad =~ s/(.+)::/$1->/;
1702     return "$good must not be invoked as $bad";
1703 }
1704
1705 sub sort_standard($$)   { return $_[0]->[1] cmp $_[1]->[1] }
1706 sub sort_reverse($$)    { return $_[1]->[1] cmp $_[0]->[1] }
1707
1708 sub reslash {
1709     my $path = shift;
1710
1711     my @parts = split( /\//, $path );
1712
1713     return $path if @parts < 2;
1714
1715     return File::Spec->catfile( @parts );
1716 }
1717
1718
1719
1720 sub _setup {
1721     my $defaults = shift;
1722     my $passed_parms = ref $_[0] eq 'HASH' ? {%{+shift}} : {}; # copy parm hash
1723
1724     my %passed_parms = %{$passed_parms};
1725
1726     my $parms = {};
1727     for my $key ( keys %{$defaults} ) {
1728         $parms->{$key} =
1729             exists $passed_parms{$key}
1730                 ? delete $passed_parms{$key}
1731                 : $defaults->{$key};
1732     }
1733
1734     # Any leftover keys are bogus
1735     for my $badkey ( keys %passed_parms ) {
1736         my $sub = (caller(1))[3];
1737         $parms->{error_handler}->( "Invalid option passed to $sub(): $badkey" );
1738     }
1739
1740     # If it's not a code ref, assume standard sort
1741     if ( $parms->{sort_files} && ( ref($parms->{sort_files}) ne 'CODE' ) ) {
1742         $parms->{sort_files} = \&sort_standard;
1743     }
1744     my @queue;
1745
1746     for ( @_ ) {
1747         my $start = reslash( $_ );
1748         if (-d $start) {
1749             push @queue, ($start,undef,$start);
1750         }
1751         else {
1752             push @queue, (undef,$start,$start);
1753         }
1754     }
1755
1756     return ($parms,@queue);
1757 }
1758
1759
1760 sub _candidate_files {
1761     my $parms   = shift;
1762     my $dirname = shift;
1763
1764     my $dh;
1765     if ( !opendir $dh, $dirname ) {
1766         $parms->{error_handler}->( "$dirname: $!" );
1767         return;
1768     }
1769
1770     my @newfiles;
1771     my $descend_filter = $parms->{descend_filter};
1772     my $follow_symlinks = $parms->{follow_symlinks};
1773     my $sort_sub = $parms->{sort_files};
1774
1775     for my $file ( grep { !exists $skip_dirs{$_} } readdir $dh ) {
1776         my $has_stat;
1777
1778         # Only do directory checking if we have a descend_filter
1779         my $fullpath = File::Spec->catdir( $dirname, $file );
1780         if ( !$follow_symlinks ) {
1781             next if -l $fullpath;
1782             $has_stat = 1;
1783         }
1784
1785         if ( $descend_filter ) {
1786             if ( $has_stat ? (-d _) : (-d $fullpath) ) {
1787                 local $File::Next::dir = $fullpath;
1788                 local $_ = $file;
1789                 next if not $descend_filter->();
1790             }
1791         }
1792         if ( $sort_sub ) {
1793             push( @newfiles, [ $dirname, $file, $fullpath ] );
1794         }
1795         else {
1796             push( @newfiles, $dirname, $file, $fullpath );
1797         }
1798     }
1799     closedir $dh;
1800
1801     if ( $sort_sub ) {
1802         return map { @{$_} } sort $sort_sub @newfiles;
1803     }
1804
1805     return @newfiles;
1806 }
1807
1808
1809 1; # End of File::Next
1810 package App::Ack;
1811
1812 use warnings;
1813 use strict;
1814
1815 use Getopt::Long 2.36 ();
1816
1817
1818 our $VERSION;
1819 our $GIT_REVISION;
1820 our $COPYRIGHT;
1821 BEGIN {
1822     $VERSION = '2.00b06';
1823     $COPYRIGHT = 'Copyright 2005-2013 Andy Lester.';
1824     $GIT_REVISION = q{04e8986};
1825 }
1826
1827 our $fh;
1828
1829 BEGIN {
1830     $fh = *STDOUT;
1831 }
1832
1833
1834 our %types;
1835 our %type_wanted;
1836 our %mappings;
1837 our %ignore_dirs;
1838
1839 our $is_filter_mode;
1840 our $output_to_pipe;
1841
1842 our $dir_sep_chars;
1843 our $is_cygwin;
1844 our $is_windows;
1845
1846 use File::Spec 1.00015 ();
1847 use File::Glob 1.00015 ':glob';
1848
1849 BEGIN {
1850     # These have to be checked before any filehandle diddling.
1851     $output_to_pipe  = not -t *STDOUT;
1852     $is_filter_mode = -p STDIN;
1853
1854     $is_cygwin       = ($^O eq 'cygwin');
1855     $is_windows      = ($^O =~ /MSWin32/);
1856     $dir_sep_chars   = $is_windows ? quotemeta( '\\/' ) : quotemeta( File::Spec->catfile( '', '' ) );
1857 }
1858
1859
1860 sub retrieve_arg_sources {
1861     my @arg_sources;
1862
1863     my $noenv;
1864     my $ackrc;
1865
1866     Getopt::Long::Configure('default', 'no_auto_help', 'no_auto_version');
1867     Getopt::Long::Configure('pass_through');
1868     Getopt::Long::Configure('no_auto_abbrev');
1869
1870     Getopt::Long::GetOptions(
1871         'noenv'   => \$noenv,
1872         'ackrc=s' => \$ackrc,
1873     );
1874
1875     Getopt::Long::Configure('default', 'no_auto_help', 'no_auto_version');
1876
1877     my @files;
1878
1879     if ( !$noenv ) {
1880         my $finder = App::Ack::ConfigFinder->new;
1881         @files  = $finder->find_config_files;
1882     }
1883     if ( $ackrc ) {
1884         # we explicitly use open so we get a nice error message
1885         # XXX this is a potential race condition!
1886         if(open my $fh, '<', $ackrc) {
1887             close $fh;
1888         }
1889         else {
1890             die "Unable to load ackrc '$ackrc': $!"
1891         }
1892         push( @files, $ackrc );
1893     }
1894
1895     push @arg_sources, Defaults => [ App::Ack::ConfigDefault::options() ];
1896
1897     foreach my $file ( @files) {
1898         my @lines = read_rcfile($file);
1899         push ( @arg_sources, $file, \@lines ) if @lines;
1900     }
1901
1902     if ( $ENV{ACK_OPTIONS} && !$noenv ) {
1903         push( @arg_sources, 'ACK_OPTIONS' => $ENV{ACK_OPTIONS} );
1904     }
1905
1906     push( @arg_sources, 'ARGV' => [ @ARGV ] );
1907
1908     return @arg_sources;
1909 }
1910
1911 sub read_rcfile {
1912     my $file = shift;
1913
1914     return unless defined $file && -e $file;
1915
1916     my @lines;
1917
1918     open( my $fh, '<', $file ) or App::Ack::die( "Unable to read $file: $!" );
1919     while ( my $line = <$fh> ) {
1920         chomp $line;
1921         $line =~ s/^\s+//;
1922         $line =~ s/\s+$//;
1923
1924         next if $line eq '';
1925         next if $line =~ /^#/;
1926
1927         push( @lines, $line );
1928     }
1929     close $fh;
1930
1931     return @lines;
1932 }
1933
1934
1935 sub create_ignore_rules {
1936     my $what  = shift;
1937     my $where = shift;
1938     my $opts  = shift;
1939
1940     my @opts = @{$opts};
1941
1942     my %rules;
1943
1944     for my $opt ( @opts ) {
1945         if ( $opt =~ /^(is|ext|regex),(.+)$/ ) {
1946             my $method = $1;
1947             my $arg    = $2;
1948             if ( $method eq 'regex' ) {
1949                 push( @{$rules{regex}}, qr/$arg/ );
1950             }
1951             else {
1952                 ++$rules{$method}{$arg};
1953             }
1954         }
1955         else {
1956             App::Ack::die( "Invalid argument for --$what: $opt" );
1957         }
1958     }
1959
1960     return \%rules;
1961 }
1962
1963
1964 sub remove_dir_sep {
1965     my $path = shift;
1966     $path =~ s/[$dir_sep_chars]$//;
1967
1968     return $path;
1969 }
1970
1971
1972 sub build_regex {
1973     my $str = shift;
1974     my $opt = shift;
1975
1976     defined $str or App::Ack::die( 'No regular expression found.' );
1977
1978     $str = quotemeta( $str ) if $opt->{Q};
1979     if ( $opt->{w} ) {
1980         $str = "\\b$str" if $str =~ /^\w/;
1981         $str = "$str\\b" if $str =~ /\w$/;
1982     }
1983
1984     my $regex_is_lc = $str eq lc $str;
1985     if ( $opt->{i} || ($opt->{smart_case} && $regex_is_lc) ) {
1986         $str = "(?i)$str";
1987     }
1988
1989     my $ok = eval {
1990         qr/$str/
1991     };
1992
1993     my $error = $@;
1994
1995     if ( !$ok ) {
1996         die "Invalid regex '$str':\n  $error";
1997     }
1998
1999     return $str;
2000 }
2001
2002
2003 sub check_regex {
2004     my $regex = shift;
2005
2006     return unless defined $regex;
2007
2008     eval { qr/$regex/ };
2009     if ($@) {
2010         (my $error = $@) =~ s/ at \S+ line \d+.*//;
2011         chomp($error);
2012         App::Ack::die( "Invalid regex '$regex':\n  $error" );
2013     }
2014
2015     return;
2016 }
2017
2018
2019
2020
2021 sub warn {
2022     return CORE::warn( _my_program(), ': ', @_, "\n" );
2023 }
2024
2025
2026 sub die {
2027     return CORE::die( _my_program(), ': ', @_, "\n" );
2028 }
2029
2030 sub _my_program {
2031     require File::Basename;
2032     return File::Basename::basename( $0 );
2033 }
2034
2035
2036
2037 sub filetypes_supported {
2038     return keys %mappings;
2039 }
2040
2041 sub _get_thpppt {
2042     my $y = q{_   /|,\\'!.x',=(www)=,   U   };
2043     $y =~ tr/,x!w/\nOo_/;
2044     return $y;
2045 }
2046
2047 sub _thpppt {
2048     my $y = _get_thpppt();
2049     App::Ack::print( "$y ack $_[0]!\n" );
2050     exit 0;
2051 }
2052
2053 sub _bar {
2054     my $x;
2055     $x = <<'_BAR';
2056  6?!I'7!I"?%+!
2057  3~!I#7#I"7#I!?!+!="+"="+!:!
2058  2?#I!7!I!?#I!7!I"+"=%+"=#
2059  1?"+!?*+!=#~"=!+#?"="+!
2060  0?"+!?"I"?&+!="~!=!~"=!+%="+"
2061  /I!+!?)+!?!+!=$~!=!~!="+!="+"?!="?!
2062  .?%I"?%+%='?!=#~$="
2063  ,,!?%I"?(+$=$~!=#:"~$:!~!
2064  ,I!?!I!?"I"?!+#?"+!?!+#="~$:!~!:!~!:!,!:!,":#~!
2065  +I!?&+!="+!?#+$=!~":!~!:!~!:!,!:#,!:!,%:"
2066  *+!I!?!+$=!+!=!+!?$+#=!~":!~":#,$:",#:!,!:!
2067  *I!?"+!?!+!=$+!?#+#=#~":$,!:",!:!,&:"
2068  )I!?$=!~!=#+"?!+!=!+!=!~!="~!:!~":!,'.!,%:!~!
2069  (=!?"+!?!=!~$?"+!?!+!=#~"=",!="~$,$.",#.!:!=!
2070  (I"+"="~"=!+&=!~"=!~!,!~!+!=!?!+!?!=!I!?!+"=!.",!.!,":!
2071  %I$?!+!?!=%+!~!+#~!=!~#:#=!~!+!~!=#:!,%.!,!.!:"
2072  $I!?!=!?!I!+!?"+!=!~!=!~!?!I!?!=!+!=!~#:",!~"=!~!:"~!=!:",&:" '-/
2073  $?!+!I!?"+"=!+"~!,!:"+#~#:#,"=!~"=!,!~!,!.",!:".!:! */! !I!t!'!s! !a! !g!r!e!p!!! !/!
2074  $+"=!+!?!+"~!=!:!~!:"I!+!,!~!=!:!~!,!:!,$:!~".&:"~!,# (-/
2075  %~!=!~!=!:!.!+"~!:!,!.!,!~!=!:$.!,":!,!.!:!~!,!:!=!.#="~!,!:" ./!
2076  %=!~!?!+"?"+!=!~",!.!:!?!~!.!:!,!:!,#.!,!:","~!:!=!~!=!:",!~! ./!
2077  %+"~":!~!=#~!:!~!,!.!~!:",!~!=!~!.!:!,!.",!:!,":!=":!.!,!:!7! -/!
2078  %~",!:".#:!=!:!,!:"+!:!~!:!.!,!~!,!.#,!.!,$:"~!,":"~!=! */!
2079  &=!~!=#+!=!~",!.!:",#:#,!.",+:!,!.",!=!+!?!
2080  &~!=!~!=!~!:"~#:",!.!,#~!:!.!+!,!.",$.",$.#,!+!I!?!
2081  &~!="~!:!~":!~",!~!=!~":!,!:!~!,!:!,&.$,#."+!?!I!?!I!
2082  &~!=!~!=!+!,!:!~!:!=!,!:!~&:$,!.!,".!,".!,#."~!+!?$I!
2083  &~!=!~!="~!=!:!~":!,!~%:#,!:",!.!,#.",#I!7"I!?!+!?"I"
2084  &+!I!7!:#~"=!~!:!,!:"~$.!=!.!,!~!,$.#,!~!7!I#?!+!?"I"7!
2085  %7#?!+!~!:!=!~!=!~":!,!:"~":#.!,)7#I"?"I!7&
2086  %7#I!=":!=!~!:"~$:"~!:#,!:!,!:!~!:#,!7#I!?#7)
2087  $7$+!,!~!=#~!:!~!:!~$:#,!.!~!:!=!,":!7#I"?#7+=!?!
2088  $7#I!~!,!~#=!~!:"~!:!,!:!,#:!=!~",":!7$I!?#I!7*+!=!+"
2089  "I!7$I!,":!,!.!=":$,!:!,$:$7$I!+!?"I!7+?"I!7!I!7!,!
2090  !,!7%I!:",!."~":!,&.!,!:!~!I!7$I!+!?"I!7,?!I!7',!
2091  !7(,!.#~":!,%.!,!7%I!7!?#I"7,+!?!7*
2092 7+:!,!~#,"=!7'I!?#I"7/+!7+
2093 77I!+!7!?!7!I"71+!7,
2094 _BAR
2095
2096     $x =~ s/(.)(.)/$1x(ord($2)-32)/eg;
2097     App::Ack::print( $x );
2098     exit 0;
2099 }
2100
2101
2102 sub show_help {
2103     my $help_arg = shift || 0;
2104
2105     return show_help_types() if $help_arg =~ /^types?/;
2106
2107     App::Ack::print( <<"END_OF_HELP" );
2108 Usage: ack [OPTION]... PATTERN [FILES OR DIRECTORIES]
2109
2110 Search for PATTERN in each source file in the tree from the current
2111 directory on down.  If any files or directories are specified, then
2112 only those files and directories are checked.  ack may also search
2113 STDIN, but only if no file or directory arguments are specified,
2114 or if one of them is "-".
2115
2116 Default switches may be specified in ACK_OPTIONS environment variable or
2117 an .ackrc file. If you want no dependency on the environment, turn it
2118 off with --noenv.
2119
2120 Example: ack -i select
2121
2122 Searching:
2123   -i, --ignore-case             Ignore case distinctions in PATTERN
2124   --[no]smart-case              Ignore case distinctions in PATTERN,
2125                                 only if PATTERN contains no upper case.
2126                                 Ignored if -i is specified
2127   -v, --invert-match            Invert match: select non-matching lines
2128   -w, --word-regexp             Force PATTERN to match only whole words
2129   -Q, --literal                 Quote all metacharacters; PATTERN is literal
2130
2131 Search output:
2132   --lines=NUM                   Only print line(s) NUM of each file
2133   -l, --files-with-matches      Only print filenames containing matches
2134   -L, --files-without-matches   Only print filenames with no matches
2135   --output=expr                 Output the evaluation of expr for each line
2136                                 (turns off text highlighting)
2137   -o                            Show only the part of a line matching PATTERN
2138                                 Same as --output='\$&'
2139   --passthru                    Print all lines, whether matching or not
2140   --match PATTERN               Specify PATTERN explicitly.
2141   -m, --max-count=NUM           Stop searching in each file after NUM matches
2142   -1                            Stop searching after one match of any kind
2143   -H, --with-filename           Print the filename for each match
2144   -h, --no-filename             Suppress the prefixing filename on output
2145   -c, --count                   Show number of lines matching per file
2146   --[no]column                  Show the column number of the first match
2147
2148   -A NUM, --after-context=NUM   Print NUM lines of trailing context after matching
2149                                 lines.
2150   -B NUM, --before-context=NUM  Print NUM lines of leading context before matching
2151                                 lines.
2152   -C [NUM], --context[=NUM]     Print NUM lines (default 2) of output context.
2153
2154   --print0                      Print null byte as separator between filenames,
2155                                 only works with -f, -g, -l, -L or -c.
2156
2157   -s                            Suppress error messages about nonexistent or
2158                                 unreadable files.
2159
2160
2161 File presentation:
2162   --pager=COMMAND               Pipes all ack output through COMMAND.  For example,
2163                                 --pager="less -R".  Ignored if output is redirected.
2164   --nopager                     Do not send output through a pager.  Cancels any
2165                                 setting in ~/.ackrc, ACK_PAGER or ACK_PAGER_COLOR.
2166   --[no]heading                 Print a filename heading above each file's results.
2167                                 (default: on when used interactively)
2168   --[no]break                   Print a break between results from different files.
2169                                 (default: on when used interactively)
2170   --group                       Same as --heading --break
2171   --nogroup                     Same as --noheading --nobreak
2172   --[no]color                   Highlight the matching text (default: on unless
2173                                 output is redirected, or on Windows)
2174   --[no]colour                  Same as --[no]color
2175   --color-filename=COLOR
2176   --color-match=COLOR
2177   --color-lineno=COLOR          Set the color for filenames, matches, and line numbers.
2178   --flush                       Flush output immediately, even when ack is used
2179                                 non-interactively (when output goes to a pipe or
2180                                 file).
2181
2182
2183 File finding:
2184   -f                            Only print the files selected, without searching.
2185                                 The PATTERN must not be specified.
2186   -g                            Same as -f, but only select files matching PATTERN.
2187   --sort-files                  Sort the found files lexically.
2188   --show-types                  Show which types each file has.
2189   --files-from=FILE             Read the list of files to search from FILE.
2190   -x                            Read the list of files to search from STDIN.
2191
2192 File inclusion/exclusion:
2193   --[no]ignore-dir=name         Add/Remove directory from the list of ignored dirs
2194   --[no]ignore-directory=name   Synonym for ignore-dir
2195   --ignore-file=filter          Add filter for ignoring files
2196   -r, -R, --recurse             Recurse into subdirectories (ack's default behavior)
2197   -n, --no-recurse              No descending into subdirectories
2198   --[no]follow                  Follow symlinks.  Default is off.
2199   -k, --known-types             Include only files with types that ack recognizes.
2200
2201   --type=X                      Include only X files, where X is a recognized filetype.
2202   --type=noX                    Exclude X files.
2203                                 See "ack --help-types" for supported filetypes.
2204
2205 File type specification:
2206   --type-set TYPE:FILTER:FILTERARGS
2207                                 Files with the given FILTERARGS applied to the given
2208                                 FILTER are recognized as being of type TYPE. This
2209                                 replaces an existing definition for type TYPE.
2210   --type-add TYPE:FILTER:FILTERARGS
2211                                 Files with the given FILTERARGS applied to the given
2212                                 FILTER are recognized as being of type TYPE.
2213   --type-del TYPE               Removes all filters associated with TYPE.
2214
2215
2216 Miscellaneous:
2217   --[no]env                     Ignore environment variables and global ackrc files.  --env is legal but redundant.
2218   --ackrc=filename              Specify an ackrc file to use
2219   --ignore-ack-defaults         Ignore the default definitions that ack includes.
2220   --create-ackrc                Outputs a default ackrc for your customization to standard output.
2221   --help, -?                    This help
2222   --help-types                  Display all known types
2223   --dump                        Dump information on which options are loaded from which RC files
2224   --[no]filter                  Force ack to treat standard input as a pipe (--filter) or tty (--nofilter)
2225   --man                         Man page
2226   --version                     Display version & copyright
2227   --thpppt                      Bill the Cat
2228   --bar                         The warning admiral
2229
2230 Exit status is 0 if match, 1 if no match.
2231
2232 This is version $VERSION of ack.
2233 END_OF_HELP
2234
2235     return;
2236  }
2237
2238
2239
2240 sub show_help_types {
2241     App::Ack::print( <<'END_OF_HELP' );
2242 Usage: ack [OPTION]... PATTERN [FILES OR DIRECTORIES]
2243
2244 The following is the list of filetypes supported by ack.  You can
2245 specify a file type with the --type=TYPE format, or the --TYPE
2246 format.  For example, both --type=perl and --perl work.
2247
2248 Note that some extensions may appear in multiple types.  For example,
2249 .pod files are both Perl and Parrot.
2250
2251 END_OF_HELP
2252
2253     my @types = filetypes_supported();
2254     my $maxlen = 0;
2255     for ( @types ) {
2256         $maxlen = length if $maxlen < length;
2257     }
2258     for my $type ( sort @types ) {
2259         next if $type =~ /^-/; # Stuff to not show
2260         my $ext_list = $mappings{$type};
2261
2262         if ( ref $ext_list ) {
2263             $ext_list = join( ' ', map { $_->to_string } @{$ext_list} );
2264         }
2265         App::Ack::print( sprintf( "    --[no]%-*.*s %s\n", $maxlen, $maxlen, $type, $ext_list ) );
2266     }
2267
2268     return;
2269 }
2270
2271 sub show_man {
2272     require Pod::Usage;
2273
2274     Pod::Usage::pod2usage({
2275         -input   => $App::Ack::orig_program_name,
2276         -verbose => 2,
2277         -exitval => 0,
2278     });
2279
2280     return;
2281 }
2282
2283
2284 sub get_version_statement {
2285     require Config;
2286
2287     my $copyright = get_copyright();
2288     my $this_perl = $Config::Config{perlpath};
2289     if ($^O ne 'VMS') {
2290         my $ext = $Config::Config{_exe};
2291         $this_perl .= $ext unless $this_perl =~ m/$ext$/i;
2292     }
2293     my $ver = sprintf( '%vd', $^V );
2294
2295     my $git_revision = $GIT_REVISION ? " (git commit $GIT_REVISION)" : '';
2296
2297     return <<"END_OF_VERSION";
2298 ack ${VERSION}${git_revision}
2299 Running under Perl $ver at $this_perl
2300
2301 $copyright
2302
2303 This program is free software.  You may modify or distribute it
2304 under the terms of the Artistic License v2.0.
2305 END_OF_VERSION
2306 }
2307
2308
2309 sub print_version_statement {
2310     App::Ack::print( get_version_statement() );
2311
2312     return;
2313 }
2314
2315
2316 sub get_copyright {
2317     return $COPYRIGHT;
2318 }
2319
2320
2321 sub load_colors {
2322     eval 'use Term::ANSIColor 1.12 ()';
2323
2324     $ENV{ACK_COLOR_MATCH}    ||= 'black on_yellow';
2325     $ENV{ACK_COLOR_FILENAME} ||= 'bold green';
2326     $ENV{ACK_COLOR_LINENO}   ||= 'bold yellow';
2327
2328     return;
2329 }
2330
2331
2332 # print subs added in order to make it easy for a third party
2333 # module (such as App::Wack) to redefine the display methods
2334 # and show the results in a different way.
2335 sub print                   { print {$fh} @_; return; }
2336 sub print_first_filename    { App::Ack::print( $_[0], "\n" ); return; }
2337 sub print_blank_line        { App::Ack::print( "\n" ); return; }
2338 sub print_separator         { App::Ack::print( "--\n" ); return; }
2339 sub print_filename          { App::Ack::print( $_[0], $_[1] ); return; }
2340 sub print_line_no           { App::Ack::print( $_[0], $_[1] ); return; }
2341 sub print_column_no         { App::Ack::print( $_[0], $_[1] ); return; }
2342 sub print_count {
2343     my $filename = shift;
2344     my $nmatches = shift;
2345     my $ors = shift;
2346     my $count = shift;
2347     my $show_filename = shift;
2348
2349     if ($show_filename) {
2350         App::Ack::print( $filename );
2351         App::Ack::print( ':', $nmatches ) if $count;
2352     }
2353     else {
2354         App::Ack::print( $nmatches ) if $count;
2355     }
2356     App::Ack::print( $ors );
2357
2358     return;
2359 }
2360
2361 sub print_count0 {
2362     my $filename = shift;
2363     my $ors = shift;
2364     my $show_filename = shift;
2365
2366     if ($show_filename) {
2367         App::Ack::print( $filename, ':0', $ors );
2368     }
2369     else {
2370         App::Ack::print( '0', $ors );
2371     }
2372
2373     return;
2374 }
2375
2376 sub set_up_pager {
2377     my $command = shift;
2378
2379     return if App::Ack::output_to_pipe();
2380
2381     my $pager;
2382     if ( not open( $pager, '|-', $command ) ) {
2383         App::Ack::die( qq{Unable to pipe to pager "$command": $!} );
2384     }
2385     $fh = $pager;
2386
2387     return;
2388 }
2389
2390
2391 sub output_to_pipe {
2392     return $output_to_pipe;
2393 }
2394
2395
2396 sub exit_from_ack {
2397     my $nmatches = shift;
2398
2399     my $rc = $nmatches ? 0 : 1;
2400     exit $rc;
2401 }
2402
2403 {
2404
2405 my @capture_indices;
2406 my $match_column_number;
2407
2408 sub does_match {
2409     my ( $opt, $line ) = @_;
2410
2411     my $re     = $opt->{regex};
2412     my $invert = $opt->{v};
2413
2414     return unless $re;
2415
2416     $match_column_number = undef;
2417     @capture_indices     = ();
2418
2419     if ( $invert ? $line !~ /$re/ : $line =~ /$re/ ) {
2420         if ( not $invert ) {
2421             # @- = @LAST_MATCH_START
2422             # @+ = @LAST_MATCH_END
2423             $match_column_number = $-[0] + 1;
2424
2425             if ( @- > 1 ) {
2426                 @capture_indices = map {
2427                     [ $-[$_], $+[$_] ]
2428                 } ( 1 .. $#- );
2429             }
2430         }
2431         return 1;
2432     }
2433     else {
2434         return;
2435     }
2436 }
2437
2438 sub get_capture_indices {
2439     return @capture_indices;
2440 }
2441
2442 sub get_match_column {
2443     return $match_column_number;
2444 }
2445
2446 }
2447
2448 sub print_matches_in_resource {
2449     my ( $resource, $opt ) = @_;
2450
2451     my $passthru       = $opt->{passthru};
2452     my $max_count      = $opt->{m} || -1;
2453     my $nmatches       = 0;
2454     my $filename       = $resource->name;
2455     my $break          = $opt->{break};
2456     my $heading        = $opt->{heading};
2457     my $ors            = $opt->{print0} ? "\0" : "\n";
2458     my $color          = $opt->{color};
2459     my $print_filename = $opt->{show_filename};
2460
2461     my $has_printed_for_this_resource = 0;
2462
2463     App::Ack::iterate($resource, $opt, sub {
2464         if ( App::Ack::does_match($opt, $_) ) {
2465             if( !$has_printed_for_this_resource ) {
2466                 if( $break && has_printed_something() ) {
2467                     App::Ack::print_blank_line();
2468                 }
2469                 if( $print_filename) {
2470                     if( $heading ) {
2471                         my $filename = $resource->name;
2472                         if($color) {
2473                             $filename = Term::ANSIColor::colored($filename,
2474                                 $ENV{ACK_COLOR_FILENAME});
2475                         }
2476                         App::Ack::print_filename( $filename, $ors );
2477                     }
2478                 }
2479             }
2480             App::Ack::print_line_with_context($opt, $filename, $_, $.);
2481             $has_printed_for_this_resource = 1;
2482             $nmatches++;
2483             $max_count--;
2484         }
2485         elsif ( $passthru ) {
2486             chomp;
2487             if( $break && !$has_printed_for_this_resource && has_printed_something() ) {
2488                 App::Ack::print_blank_line();
2489             }
2490             App::Ack::print_line_with_options($opt, $filename, $_, $., ':');
2491             $has_printed_for_this_resource = 1;
2492         }
2493         return $max_count != 0;
2494     });
2495
2496     return $nmatches;
2497 }
2498
2499 sub count_matches_in_resource {
2500     my ( $resource, $opt ) = @_;
2501
2502     my $nmatches = 0;
2503
2504     App::Ack::iterate( $resource, $opt, sub {
2505         ++$nmatches if App::Ack::does_match($opt, $_);
2506         return 1;
2507     } );
2508
2509     return $nmatches;
2510 }
2511
2512 sub resource_has_match {
2513     my ( $resource, $opt ) = @_;
2514
2515     return count_matches_in_resource($resource, $opt) > 0;
2516 }
2517
2518 {
2519
2520 my @before_ctx_lines;
2521 my @after_ctx_lines;
2522 my $is_iterating;
2523
2524 sub get_context {
2525     if ( not $is_iterating ) {
2526         Carp::croak( 'get_context() called outside of iterate()' );
2527     }
2528
2529     return (
2530         scalar(@before_ctx_lines) ? \@before_ctx_lines : undef,
2531         scalar(@after_ctx_lines)  ? \@after_ctx_lines  : undef,
2532     );
2533 }
2534
2535 sub iterate {
2536     my ( $resource, $opt, $cb ) = @_;
2537
2538     $is_iterating = 1;
2539
2540     local $opt->{before_context} = $opt->{output} ? 0 : $opt->{before_context};
2541     local $opt->{after_context}  = $opt->{output} ? 0 : $opt->{after_context};
2542
2543     my $n_before_ctx_lines = $opt->{before_context} || 0;
2544     my $n_after_ctx_lines  = $opt->{after_context}  || 0;
2545     my $current_line;
2546
2547     @after_ctx_lines = @before_ctx_lines = ();
2548
2549     if ( $resource->next_text() ) {
2550         $current_line = $_; # prime the first line of input
2551     }
2552
2553     while ( defined $current_line ) {
2554         while ( (@after_ctx_lines < $n_after_ctx_lines) && $resource->next_text() ) {
2555             push @after_ctx_lines, $_;
2556         }
2557
2558         local $_ = $current_line;
2559         my $former_dot_period = $.;
2560         $. = $. - @after_ctx_lines;
2561
2562         last unless $cb->();
2563
2564         # I tried doing this with local(), but for some reason,
2565         # $. continued to have its new value after the exit of the
2566         # enclosing block.  I'm guessing that $. has some extra
2567         # magic associated with it or something.  If someone can
2568         # tell me why this happened, I would love to know!
2569         $. = $former_dot_period; # XXX this won't happen on an exception
2570
2571         push @before_ctx_lines, $current_line;
2572 if($n_after_ctx_lines) {
2573             $current_line = shift @after_ctx_lines;
2574         }
2575         elsif($resource->next_text()) {
2576             $current_line = $_;
2577         }
2578         else {
2579             undef $current_line;
2580         }
2581         shift @before_ctx_lines while @before_ctx_lines > $n_before_ctx_lines;
2582     }
2583
2584     $is_iterating = 0; # XXX this won't happen on an exception
2585                        #     then again, do we care? ack doesn't really
2586                        #     handle exceptions anyway.
2587
2588     return;
2589 }
2590
2591 }
2592
2593 my $has_printed_something;
2594
2595 BEGIN {
2596     $has_printed_something = 0;
2597 }
2598
2599 sub has_printed_something {
2600     return $has_printed_something;
2601 }
2602
2603 sub print_line_with_options {
2604     my ( $opt, $filename, $line, $line_no, $separator ) = @_;
2605
2606     $has_printed_something = 1;
2607
2608     my $print_filename = $opt->{show_filename};
2609     my $print_column   = $opt->{column};
2610     my $ors            = $opt->{print0} ? "\0" : "\n";
2611     my $heading        = $opt->{heading};
2612     my $output_expr    = $opt->{output};
2613     my $re             = $opt->{regex};
2614     my $color          = $opt->{color};
2615
2616     my @line_parts;
2617
2618     if( $color ) {
2619         $filename = Term::ANSIColor::colored($filename,
2620             $ENV{ACK_COLOR_FILENAME});
2621         $line_no  = Term::ANSIColor::colored($line_no,
2622             $ENV{ACK_COLOR_LINENO});
2623     }
2624
2625     if($print_filename) {
2626         if( $heading ) {
2627             push @line_parts, $line_no;
2628         }
2629         else {
2630             push @line_parts, $filename, $line_no;
2631         }
2632
2633         if( $print_column ) {
2634             push @line_parts, get_match_column();
2635         }
2636     }
2637     if( $output_expr ) {
2638         # XXX avoid re-evaluation if we can
2639         while( $line =~ /$re/g ) {
2640             my $output = eval $output_expr;
2641             App::Ack::print( join( $separator, @line_parts, $output ), $ors );
2642         }
2643     }
2644     else {
2645         my @capture_indices = get_capture_indices();
2646         if( @capture_indices ) {
2647             my $offset = 0; # additional offset for when we add stuff
2648
2649             foreach my $index_pair ( @capture_indices ) {
2650                 my ( $match_start, $match_end ) = @{$index_pair};
2651
2652                 my $substring = substr( $line,
2653                     $offset + $match_start, $match_end - $match_start );
2654                 my $substitution = Term::ANSIColor::colored( $substring,
2655                     $ENV{ACK_COLOR_MATCH} );
2656
2657                 substr( $line, $offset + $match_start,
2658                     $match_end - $match_start, $substitution );
2659
2660                 $offset += length( $substitution ) - length( $substring );
2661             }
2662         }
2663         elsif( $color ) {
2664             # XXX I know $& is a no-no; fix it later
2665             if($line  =~ s/$re/Term::ANSIColor::colored($&, $ENV{ACK_COLOR_MATCH})/ge) {
2666                 $line .= "\033[0m\033[K";
2667             }
2668         }
2669
2670         push @line_parts, $line;
2671         App::Ack::print( join( $separator, @line_parts ), $ors );
2672     }
2673
2674     return;
2675 }
2676
2677 {
2678
2679 my $is_first_match;
2680 my $previous_file_processed;
2681 my $previous_line_printed;
2682
2683 BEGIN {
2684     $is_first_match        = 1;
2685     $previous_line_printed = -1;
2686 }
2687
2688 sub print_line_with_context {
2689     my ( $opt, $filename, $matching_line, $line_no ) = @_;
2690
2691     my $heading = $opt->{heading};
2692
2693     if( !defined($previous_file_processed) ||
2694       $previous_file_processed ne $filename ) {
2695         $previous_file_processed = $filename;
2696         $previous_line_printed   = -1;
2697
2698         if( $heading ) {
2699             $is_first_match = 1;
2700         }
2701     }
2702
2703     my $ors                 = $opt->{print0} ? "\0" : "\n";
2704     my $match_word          = $opt->{w};
2705     my $re                  = $opt->{regex};
2706     my $is_tracking_context = $opt->{after_context} || $opt->{before_context};
2707     my $output_expr         = $opt->{output};
2708
2709     chomp $matching_line;
2710
2711     my ( $before_context, $after_context ) = get_context();
2712
2713     if ( $before_context ) {
2714         my $first_line = $. - @{$before_context};
2715
2716         if ( $first_line <= $previous_line_printed ) {
2717             splice @{$before_context}, 0, $previous_line_printed - $first_line + 1;
2718             $first_line = $. - @{$before_context};
2719         }
2720         if ( @{$before_context} ) {
2721             my $offset = @{$before_context};
2722
2723             if( !$is_first_match && $previous_line_printed != $first_line - 1 ) {
2724                 App::Ack::print('--', $ors);
2725             }
2726             foreach my $line (@{$before_context}) {
2727                 my $context_line_no = $. - $offset;
2728                 if ( $context_line_no <= $previous_line_printed ) {
2729                     next;
2730                 }
2731
2732                 chomp $line;
2733                 App::Ack::print_line_with_options($opt, $filename, $line, $context_line_no, '-');
2734                 $previous_line_printed = $context_line_no;
2735                 $offset--;
2736             }
2737         }
2738     }
2739
2740     if ( $. > $previous_line_printed ) {
2741         if( $is_tracking_context && !$is_first_match && $previous_line_printed != $. - 1 ) {
2742             App::Ack::print('--', $ors);
2743         }
2744
2745         App::Ack::print_line_with_options($opt, $filename, $matching_line, $line_no, ':');
2746         $previous_line_printed = $.;
2747     }
2748
2749     if($after_context) {
2750         my $offset = 1;
2751         foreach my $line (@{$after_context}) {
2752             # XXX improve this!
2753             if ( $previous_line_printed >= $. + $offset ) {
2754                 $offset++;
2755                 next;
2756             }
2757             chomp $line;
2758             my $separator = App::Ack::does_match( $opt, $line ) ? ':' : '-';
2759             App::Ack::print_line_with_options($opt, $filename, $line, $. + $offset, $separator);
2760             $previous_line_printed = $. + $offset;
2761             $offset++;
2762         }
2763     }
2764
2765     $is_first_match = 0;
2766
2767     return;
2768 }
2769
2770 }
2771
2772 # inefficient, but functional
2773 sub filetypes {
2774     my ( $resource ) = @_;
2775
2776     my @matches;
2777
2778     foreach my $k (keys %mappings) {
2779         my $filters = $mappings{$k};
2780
2781         foreach my $filter (@{$filters}) {
2782             # clone the resource
2783             my $clone = $resource->clone;
2784             if ( $filter->filter($clone) ) {
2785                 push @matches, $k;
2786                 last;
2787             }
2788         }
2789     }
2790
2791     return sort @matches;
2792 }
2793
2794 # returns a (fairly) unique identifier for a file
2795 # use this function to compare two files to see if they're
2796 # equal (ie. the same file, but with a different path/links/etc)
2797 sub get_file_id {
2798     my ( $filename ) = @_;
2799
2800     if ( $is_windows ) {
2801         return File::Next::reslash( $filename );
2802     }
2803     else {
2804         # XXX is this the best method? it always hits the FS
2805         if( my ( $dev, $inode ) = (stat($filename))[0, 1] ) {
2806             return join(':', $dev, $inode);
2807         }
2808         else {
2809             # XXX this could be better
2810             return $filename;
2811         }
2812     }
2813 }
2814
2815 sub create_ackrc {
2816     my @lines = App::Ack::ConfigDefault::options();
2817
2818     print join("\n", '--ignore-ack-defaults', @lines);
2819 }
2820
2821
2822
2823 1; # End of App::Ack
2824 package App::Ack::Resource;
2825
2826
2827 use warnings;
2828 use strict;
2829 use overload
2830     '""' => 'name';
2831
2832 sub FAIL {
2833     require Carp;
2834     Carp::confess( 'Must be overloaded' );
2835 }
2836
2837
2838 sub new {
2839     return FAIL();
2840 }
2841
2842
2843 sub name {
2844     return FAIL();
2845 }
2846
2847
2848 sub is_binary {
2849     return FAIL();
2850 }
2851
2852
2853
2854 sub needs_line_scan {
2855     return FAIL();
2856 }
2857
2858
2859 sub reset {
2860     return FAIL();
2861 }
2862
2863
2864 sub next_text {
2865     return FAIL();
2866 }
2867
2868
2869 sub close {
2870     return FAIL();
2871 }
2872
2873
2874 sub clone {
2875     return FAIL();
2876 }
2877
2878 1;
2879 package App::Ack::Resources;
2880
2881
2882
2883 use warnings;
2884 use strict;
2885
2886
2887 sub from_argv {
2888     my $class = shift;
2889     my $opt   = shift;
2890     my $start = shift;
2891
2892     my $self = bless {}, $class;
2893
2894     my $file_filter    = undef;
2895     my $descend_filter = $opt->{descend_filter};
2896
2897     if( $opt->{n} ) {
2898         $descend_filter = sub {
2899             return 0;
2900         };
2901     }
2902
2903     $self->{iter} =
2904         File::Next::files( {
2905             file_filter     => $opt->{file_filter},
2906             descend_filter  => $descend_filter,
2907             error_handler   => sub { my $msg = shift; App::Ack::warn( $msg ) },
2908             sort_files      => $opt->{sort_files},
2909             follow_symlinks => $opt->{follow},
2910         }, @{$start} );
2911
2912     return $self;
2913 }
2914
2915
2916 sub from_file {
2917     my $class = shift;
2918     my $opt   = shift;
2919     my $file  = shift;
2920
2921     my $iter =
2922         File::Next::from_file( {
2923             error_handler   => sub { my $msg = shift; App::Ack::warn( $msg ) },
2924             warning_handler => sub { my $msg = shift; App::Ack::warn( $msg ) },
2925             sort_files      => $opt->{sort_files},
2926         }, $file ) or return undef;
2927
2928     return bless {
2929         iter => $iter,
2930     }, $class;
2931 }
2932
2933 # This is for reading input lines from STDIN, not the list of files from STDIN
2934 sub from_stdin {
2935     my $class = shift;
2936     my $opt   = shift;
2937
2938     my $self  = bless {}, $class;
2939
2940     my $has_been_called = 0;
2941
2942     $self->{iter} = sub {
2943         if ( !$has_been_called ) {
2944             $has_been_called = 1;
2945             return '-';
2946         }
2947         return;
2948     };
2949
2950     return $self;
2951 }
2952
2953 sub next {
2954     my $self = shift;
2955
2956     my $file = $self->{iter}->() or return;
2957
2958     return App::Ack::Resource::Basic->new( $file );
2959 }
2960
2961 1;
2962 package App::Ack::Resource::Basic;
2963
2964
2965 use warnings;
2966 use strict;
2967
2968 BEGIN {
2969     our @ISA = 'App::Ack::Resource';
2970 }
2971
2972
2973 sub new {
2974     my $class    = shift;
2975     my $filename = shift;
2976
2977     my $self = bless {
2978         filename => $filename,
2979         fh       => undef,
2980         opened   => undef,
2981     }, $class;
2982
2983     if ( $self->{filename} eq '-' ) {
2984         $self->{fh} = *STDIN;
2985     }
2986     else {
2987         if ( !open( $self->{fh}, '<', $self->{filename} ) && $App::Ack::report_bad_filenames ) {
2988             App::Ack::warn( "$self->{filename}: $!" );
2989             return;
2990         }
2991     }
2992
2993     return $self;
2994 }
2995
2996
2997 sub name {
2998     my $self = shift;
2999
3000     return $self->{filename};
3001 }
3002
3003
3004
3005 sub needs_line_scan {
3006     my $self  = shift;
3007     my $opt   = shift;
3008
3009     return 1 if $opt->{v};
3010
3011     my $size = -s $self->{fh};
3012     if ( $size == 0 ) {
3013         return 0;
3014     }
3015     elsif ( $size > 100_000 ) {
3016         return 1;
3017     }
3018
3019     my $buffer;
3020     my $rc = sysread( $self->{fh}, $buffer, $size );
3021     if ( !defined($rc) && $App::Ack::report_bad_filenames ) {
3022         App::Ack::warn( "$self->{filename}: $!" );
3023         return 1;
3024     }
3025     return 0 unless $rc && ( $rc == $size );
3026
3027     my $regex = $opt->{regex};
3028     return $buffer =~ /$regex/m;
3029 }
3030
3031
3032 sub reset {
3033     my $self = shift;
3034
3035     if( !seek( $self->{fh}, 0, 0 ) && $App::Ack::report_bad_filenames ) {
3036         App::Ack::warn( "$self->{filename}: $!" );
3037     }
3038
3039     return;
3040 }
3041
3042
3043 sub next_text {
3044     if ( defined ($_ = readline $_[0]->{fh}) ) {
3045         $. = ++$_[0]->{line};
3046         s/[\r\n]+$//; # chomp may not handle this
3047         $_ .= "\n"; # add back newline (XXX make it native)
3048         return 1;
3049     }
3050
3051     return;
3052 }
3053
3054
3055 sub close {
3056     my $self = shift;
3057
3058     if ( !close($self->{fh}) && $App::Ack::report_bad_filenames ) {
3059         App::Ack::warn( $self->name() . ": $!" );
3060     }
3061
3062     return;
3063 }
3064
3065
3066 sub clone {
3067     my ( $self ) = @_;
3068
3069     return __PACKAGE__->new($self->name);
3070 }
3071
3072
3073 1;
3074 package App::Ack::Filter;
3075
3076 use strict;
3077 use warnings;
3078 use overload
3079     '""' => 'to_string';
3080
3081 use Carp 1.10 ();
3082
3083 my %filter_types;
3084
3085
3086 sub create_filter {
3087     my ( undef, $type, @args ) = @_;
3088
3089     if ( my $package = $filter_types{$type} ) {
3090         return $package->new(@args);
3091     }
3092     Carp::croak "Unknown filter type '$type'";
3093 }
3094
3095
3096 sub register_filter {
3097     my ( undef, $type, $package ) = @_;
3098
3099     $filter_types{$type} = $package;
3100
3101     return;
3102 }
3103
3104
3105 sub invert {
3106     my ( $self ) = @_;
3107
3108     return App::Ack::Filter::Inverse->new( $self );
3109 }
3110
3111
3112 sub is_inverted {
3113     return 0;
3114 }
3115
3116
3117 sub to_string {
3118     my ( $self ) = @_;
3119
3120     return '(unimplemented to_string)';
3121 }
3122
3123
3124 sub inspect {
3125     my ( $self ) = @_;
3126
3127     return ref($self);
3128 }
3129
3130 1;
3131 package App::Ack::Filter::Extension;
3132
3133 use strict;
3134 use warnings;
3135 BEGIN {
3136     our @ISA = 'App::Ack::Filter';
3137 }
3138
3139 sub new {
3140     my ( $class, @extensions ) = @_;
3141
3142     my $exts = join('|', map { "\Q$_\E"} @extensions);
3143     my $re   = qr/[.](?:$exts)$/i;
3144
3145     return bless {
3146         extensions => \@extensions,
3147         regex      => $re,
3148     }, $class;
3149 }
3150
3151 sub filter {
3152     my ( $self, $resource ) = @_;
3153
3154     my $re = $self->{'regex'};
3155
3156     return $resource->name =~ /$re/;
3157 }
3158
3159 sub inspect {
3160     my ( $self ) = @_;
3161
3162     my $re = $self->{'regex'};
3163
3164     return ref($self) . " - $re";
3165 }
3166
3167 sub to_string {
3168     my ( $self ) = @_;
3169
3170     my $exts = $self->{'extensions'};
3171
3172     return join(' ', map { ".$_" } @{$exts});
3173 }
3174
3175 BEGIN {
3176     App::Ack::Filter->register_filter(ext => __PACKAGE__);
3177 }
3178
3179 1;
3180 package App::Ack::Filter::FirstLineMatch;
3181
3182 use strict;
3183 use warnings;
3184 BEGIN {
3185     our @ISA = 'App::Ack::Filter';
3186 }
3187
3188 sub new {
3189     my ( $class, $re ) = @_;
3190
3191     $re =~ s{^/|/$}{}g; # XXX validate?
3192     $re = qr{$re}i;
3193
3194     return bless {
3195         regex => $re,
3196     }, $class;
3197 }
3198
3199 # XXX This test checks the first "line" of the file, but we need
3200 # it to be less piggy.  If it's something like a .min.js file, then
3201 # the "line" could be the entire file.  Instead, it should read the
3202 # first, say, 100 characters of the first line.
3203
3204 sub filter {
3205     my ( $self, $resource ) = @_;
3206
3207     my $re = $self->{'regex'};
3208
3209     local $_;
3210     return unless $resource->next_text;
3211
3212     return /$re/;
3213 }
3214
3215 sub inspect {
3216     my ( $self ) = @_;
3217
3218     my $re = $self->{'regex'};
3219
3220     return ref($self) . " - $re";
3221 }
3222
3223 sub to_string {
3224     my ( $self ) = @_;
3225
3226     my $re = $self->{'regex'};
3227
3228     return "first line matches $re";
3229 }
3230
3231 BEGIN {
3232     App::Ack::Filter->register_filter(firstlinematch => __PACKAGE__);
3233 }
3234
3235 1;
3236 package App::Ack::Filter::Is;
3237
3238 use strict;
3239 use warnings;
3240 BEGIN {
3241     our @ISA = 'App::Ack::Filter';
3242 }
3243
3244 use File::Spec 3.00 ();
3245
3246 sub new {
3247     my ( $class, $filename ) = @_;
3248
3249     return bless {
3250         filename => $filename,
3251     }, $class;
3252 }
3253
3254 sub filter {
3255     my ( $self, $resource ) = @_;
3256
3257     my $filename = $self->{'filename'};
3258     my $base     = (File::Spec->splitpath($resource->name))[2];
3259
3260     return $base eq $filename;
3261 }
3262
3263 sub inspect {
3264     my ( $self ) = @_;
3265
3266     my $filename = $self->{'filename'};
3267
3268     return ref($self) . " - $filename";
3269 }
3270
3271 sub to_string {
3272     my ( $self ) = @_;
3273
3274     my $filename = $self->{'filename'};
3275 }
3276
3277 BEGIN {
3278     App::Ack::Filter->register_filter(is => __PACKAGE__);
3279 }
3280
3281 1;
3282 package App::Ack::Filter::Match;
3283
3284 use strict;
3285 use warnings;
3286 BEGIN {
3287     our @ISA = 'App::Ack::Filter';
3288 }
3289
3290 use File::Spec 3.00;
3291
3292 sub new {
3293     my ( $class, $re ) = @_;
3294
3295     $re =~ s{^/|/$}{}g; # XXX validate?
3296     $re = qr/$re/i;
3297
3298     return bless {
3299         regex => $re,
3300     }, $class;
3301 }
3302
3303 sub filter {
3304     my ( $self, $resource ) = @_;
3305
3306     my $re   = $self->{'regex'};
3307     my $base = (File::Spec->splitpath($resource->name))[2];
3308
3309     return $base =~ /$re/;
3310 }
3311
3312 sub inspect {
3313     my ( $self ) = @_;
3314
3315     my $re = $self->{'regex'};
3316
3317     print ref($self) . " - $re";
3318 }
3319
3320 sub to_string {
3321     my ( $self ) = @_;
3322
3323     my $re = $self->{'regex'};
3324
3325     return "filename matches $re";
3326 }
3327
3328 BEGIN {
3329     App::Ack::Filter->register_filter(match => __PACKAGE__);
3330 }
3331
3332 1;
3333 package App::Ack::Filter::Default;
3334
3335 use strict;
3336 use warnings;
3337 BEGIN {
3338     our @ISA = 'App::Ack::Filter';
3339 }
3340
3341 sub new {
3342     my ( $class ) = @_;
3343
3344     return bless {}, $class;
3345 }
3346
3347 sub filter {
3348     my ( $self, $resource ) = @_;
3349
3350     return -T $resource->name;
3351 }
3352
3353 1;
3354 package App::Ack::Filter::Inverse;
3355
3356 use strict;
3357 use warnings;
3358 BEGIN {
3359     our @ISA = 'App::Ack::Filter';
3360 }
3361
3362 sub new {
3363     my ( $class, $filter ) = @_;
3364
3365     return bless {
3366         filter => $filter,
3367     }, $class;
3368 }
3369
3370 sub filter {
3371     my ( $self, $resource ) = @_;
3372
3373     my $filter = $self->{'filter'};
3374     return !$filter->filter( $resource );
3375 }
3376
3377 sub invert {
3378     my $self = shift;
3379
3380     return $self->{'filter'};
3381 }
3382
3383 sub is_inverted {
3384     return 1;
3385 }
3386
3387 sub inspect {
3388     my ( $self ) = @_;
3389
3390     my $filter = $self->{'filter'};
3391
3392     return "!$filter";
3393 }
3394
3395 1;
3396 package App::Ack::ConfigFinder;
3397
3398
3399 use strict;
3400 use warnings;
3401
3402 use Cwd 3.00 ();
3403 use File::Spec 3.00;
3404
3405 BEGIN {
3406     if ($App::Ack::is_windows) {
3407         require Win32;
3408     }
3409 }
3410
3411
3412 sub new {
3413     my ( $class ) = @_;
3414
3415     return bless {}, $class;
3416 }
3417
3418 sub _remove_redundancies {
3419     my ( @configs ) = @_;
3420
3421     my %dev_and_inode_seen;
3422
3423     foreach my $path ( @configs ) {
3424         my ( $dev, $inode ) = (stat $path)[0, 1];
3425
3426         if( defined($dev) ) {
3427             if( $dev_and_inode_seen{"$dev:$inode"} ) {
3428                 undef $path;
3429             }
3430             else {
3431                 $dev_and_inode_seen{"$dev:$inode"} = 1;
3432             }
3433         }
3434     }
3435     return grep { defined() } @configs;
3436 }
3437
3438 sub _check_for_ackrc {
3439     return unless defined $_[0];
3440
3441     my @files = grep { -f }
3442                 map { File::Spec->catfile(@_, $_) }
3443                 qw(.ackrc _ackrc);
3444
3445     die File::Spec->catdir(@_) . " contains both .ackrc and _ackrc.\n" .
3446         "Please remove one of those files.\n"
3447             if @files > 1;
3448
3449     return wantarray ? @files : $files[0];
3450 } # end _check_for_ackrc
3451
3452
3453 sub find_config_files {
3454     my @config_files;
3455
3456     if($App::Ack::is_windows) {
3457         push @config_files, map { File::Spec->catfile($_, 'ackrc') } (
3458             Win32::GetFolderPath(Win32::CSIDL_COMMON_APPDATA()),
3459             Win32::GetFolderPath(Win32::CSIDL_APPDATA()),
3460         );
3461     }
3462     else {
3463         push @config_files, '/etc/ackrc';
3464     }
3465
3466     if ( $ENV{'ACKRC'} && -f $ENV{'ACKRC'} ) {
3467         push @config_files, $ENV{'ACKRC'};
3468     }
3469     else {
3470         push @config_files, _check_for_ackrc($ENV{'HOME'});
3471     }
3472
3473     my @dirs = File::Spec->splitdir(Cwd::getcwd());
3474     while(@dirs) {
3475         my $ackrc = _check_for_ackrc(@dirs);
3476         if(defined $ackrc) {
3477             push @config_files, $ackrc;
3478             last;
3479         }
3480         pop @dirs;
3481     }
3482
3483     # XXX we only test for existence here, so if the file is
3484     #     deleted out from under us, this will fail later. =(
3485     return _remove_redundancies( @config_files );
3486 }
3487
3488 1;
3489 package App::Ack::ConfigLoader;
3490
3491 use strict;
3492 use warnings;
3493
3494 use Carp 1.10 ();
3495 use Getopt::Long 2.36 ();
3496 use Text::ParseWords 3.1 ();
3497
3498
3499 my @INVALID_COMBINATIONS;
3500
3501 BEGIN {
3502     my @context  = qw( -A -B -C --after-context --before-context --context );
3503     my @pretty   = qw( --heading --group --break );
3504     my @filename = qw( -h -H --with-filename --no-filename );
3505
3506     @INVALID_COMBINATIONS = (
3507         # XXX normalize
3508         [qw(-l)]                 => [@context, @pretty, @filename, qw(-L -o --passthru --output --max-count --column -f -g --show-types)],
3509         [qw(-L)]                 => [@context, @pretty, @filename, qw(-l -o --passthru --output --max-count --column -f -g --show-types -c --count)],
3510         [qw(--line)]             => [@context, @pretty, @filename, qw(-l --files-with-matches --files-without-matches -L -o --passthru --match -m --max-count -1 -c --count --column --print0 -f -g --show-types)],
3511         [qw(-o)]                 => [@context, qw(--output -c --count --column --column -f --show-types)],
3512         [qw(--passthru)]         => [@context, qw(--output --column -m --max-count -1 -c --count -f -g)],
3513         [qw(--output)]           => [@context, qw(-c --count -f -g)],
3514         [qw(--match)]            => [qw(-f -g)],
3515         [qw(-m --max-count)]     => [qw(-1 -f -g -c --count)],
3516         [qw(-h --no-filename)]   => [qw(-H --with-filename -f -g --group --heading)],
3517         [qw(-H --with-filename)] => [qw(-h --no-filename -f -g)],
3518         [qw(-c --count)]         => [@context, @pretty, qw(--column -f -g)],
3519         [qw(--column)]           => [qw(-f -g)],
3520         [@context]               => [qw(-f -g)],
3521         [qw(-f)]                 => [qw(-g), @pretty],
3522         [qw(-g)]                 => [qw(-f), @pretty],
3523     );
3524 }
3525
3526 sub process_filter_spec {
3527     my ( $spec ) = @_;
3528
3529     if ( $spec =~ /^(\w+):(\w+):(.*)/ ) {
3530         my ( $type_name, $ext_type, $arguments ) = ( $1, $2, $3 );
3531
3532         return ( $type_name,
3533             App::Ack::Filter->create_filter($ext_type, split(/,/, $arguments)) );
3534     }
3535     elsif ( $spec =~ /^(\w+)=(.*)/ ) { # Check to see if we have ack1-style argument specification.
3536         my ( $type_name, $extensions ) = ( $1, $2 );
3537
3538         my @extensions = split(/,/, $extensions);
3539         foreach my $extension ( @extensions ) {
3540             $extension =~ s/^[.]//;
3541         }
3542
3543         return ( $type_name, App::Ack::Filter->create_filter('ext', @extensions) );
3544     }
3545     else {
3546         Carp::croak "invalid filter specification '$spec'";
3547     }
3548 }
3549
3550 sub process_filetypes {
3551     my ( $opt, $arg_sources ) = @_;
3552
3553     Getopt::Long::Configure('default', 'no_auto_help', 'no_auto_version'); # start with default options, minus some annoying ones
3554     Getopt::Long::Configure(
3555         'no_ignore_case',
3556         'no_auto_abbrev',
3557         'pass_through',
3558     );
3559     my %additional_specs;
3560
3561     my $add_spec = sub {
3562         my ( undef, $spec ) = @_;
3563
3564         my ( $name, $filter ) = process_filter_spec($spec);
3565
3566         push @{ $App::Ack::mappings{$name} }, $filter;
3567
3568         $additional_specs{$name . '!'} = sub {
3569             my ( undef, $value ) = @_;
3570
3571             my @filters = @{ $App::Ack::mappings{$name} };
3572             if ( not $value ) {
3573                 @filters = map { $_->invert() } @filters;
3574             }
3575
3576             push @{ $opt->{'filters'} }, @filters;
3577         };
3578     };
3579
3580     my $set_spec = sub {
3581         my ( undef, $spec ) = @_;
3582
3583         my ( $name, $filter ) = process_filter_spec($spec);
3584
3585         $App::Ack::mappings{$name} = [ $filter ];
3586
3587         $additional_specs{$name . '!'} = sub {
3588             my ( undef, $value ) = @_;
3589
3590             my @filters = @{ $App::Ack::mappings{$name} };
3591             if ( not $value ) {
3592                 @filters = map { $_->invert() } @filters;
3593             }
3594
3595             push @{ $opt->{'filters'} }, @filters;
3596         };
3597     };
3598
3599     my $delete_spec = sub {
3600         my ( undef, $name ) = @_;
3601
3602         delete $App::Ack::mappings{$name};
3603         delete $additional_specs{$name . '!'};
3604     };
3605
3606     my %type_arg_specs = (
3607         'type-add=s' => $add_spec,
3608         'type-set=s' => $set_spec,
3609         'type-del=s' => $delete_spec,
3610     );
3611
3612     for ( my $i = 0; $i < @{$arg_sources}; $i += 2) {
3613         my ( $source_name, $args ) = @{$arg_sources}[ $i, $i + 1];
3614
3615         if ( ref($args) ) {
3616             # $args are modified in place, so no need to munge $arg_sources
3617             Getopt::Long::GetOptionsFromArray($args, %type_arg_specs);
3618         }
3619         else {
3620             ( undef, $arg_sources->[$i + 1] ) =
3621                 Getopt::Long::GetOptionsFromString($args, %type_arg_specs);
3622         }
3623     }
3624
3625     $additional_specs{'k|known-types'} = sub {
3626         my ( undef, $value ) = @_;
3627
3628         my @filters = map { @{$_} } values(%App::Ack::mappings);
3629
3630         push @{ $opt->{'filters'} }, @filters;
3631     };
3632
3633     return \%additional_specs;
3634 }
3635
3636 sub removed_option {
3637     my ( $option, $explanation ) = @_;
3638
3639     $explanation ||= '';
3640     return sub {
3641         warn "Option '$option' is not valid in ack 2\n$explanation";
3642         exit 1;
3643     };
3644 }
3645
3646 sub get_arg_spec {
3647     my ( $opt, $extra_specs ) = @_;
3648
3649     my $dash_a_explanation = <<EOT;
3650 This is because we now have -k/--known-types which makes it only select files
3651 of known types, rather than any text file (which is the behavior of ack 1.x).
3652 EOT
3653
3654     return {
3655         1                   => sub { $opt->{1} = $opt->{m} = 1 },
3656         'A|after-context=i' => \$opt->{after_context},
3657         'B|before-context=i'
3658                             => \$opt->{before_context},
3659         'C|context:i'       => sub { shift; my $val = shift; $opt->{before_context} = $opt->{after_context} = ($val || 2) },
3660         'a'                 => removed_option('-a', $dash_a_explanation),
3661         'all'               => removed_option('--all', $dash_a_explanation),
3662         'break!'            => \$opt->{break},
3663         c                   => \$opt->{count},
3664         'color|colour!'     => \$opt->{color},
3665         'color-match=s'     => \$ENV{ACK_COLOR_MATCH},
3666         'color-filename=s'  => \$ENV{ACK_COLOR_FILENAME},
3667         'color-lineno=s'    => \$ENV{ACK_COLOR_LINENO},
3668         'column!'           => \$opt->{column},
3669         count               => \$opt->{count},
3670         'create-ackrc'      => sub { App::Ack::create_ackrc(); exit; },
3671         'env!'              => sub {
3672             my ( undef, $value ) = @_;
3673
3674             if ( !$value ) {
3675                 $opt->{noenv_seen} = 1;
3676             }
3677         },
3678         f                   => \$opt->{f},
3679         'files-from=s'      => \$opt->{files_from},
3680         'filter!'           => \$App::Ack::is_filter_mode,
3681         flush               => \$opt->{flush},
3682         'follow!'           => \$opt->{follow},
3683         g                   => \$opt->{g},
3684         G                   => removed_option('-G'),
3685         'group!'            => sub { shift; $opt->{heading} = $opt->{break} = shift },
3686         'heading!'          => \$opt->{heading},
3687         'h|no-filename'     => \$opt->{h},
3688         'H|with-filename'   => \$opt->{H},
3689         'i|ignore-case'     => \$opt->{i},
3690         'ignore-directory|ignore-dir=s' # XXX Combine this version with the negated version below
3691                             => sub {
3692                                 my ( undef, $dir ) = @_;
3693
3694                                 $dir = App::Ack::remove_dir_sep( $dir );
3695                                 if ( $dir !~ /^(?:is|match):/ ) {
3696                                     $dir = 'is:' . $dir;
3697                                 }
3698                                 push @{ $opt->{idirs} }, $dir;
3699                                },
3700         'ignore-file=s'    => sub {
3701                                     my ( undef, $file ) = @_;
3702                                     push @{ $opt->{ifiles} }, $file;
3703                                },
3704         'lines=s'           => sub { shift; my $val = shift; push @{$opt->{lines}}, $val },
3705         'l|files-with-matches'
3706                             => \$opt->{l},
3707         'L|files-without-matches'
3708                             => \$opt->{L},
3709         'm|max-count=i'     => \$opt->{m},
3710         'match=s'           => \$opt->{regex},
3711         'n|no-recurse'      => \$opt->{n},
3712         o                   => sub { $opt->{output} = '$&' },
3713         'output=s'          => \$opt->{output},
3714         'pager=s'           => \$opt->{pager},
3715         'noignore-directory|noignore-dir=s'
3716                             => sub {
3717                                 my ( undef, $dir ) = @_;
3718
3719                                 # XXX can you do --noignore-dir=match,...?
3720                                 $dir = App::Ack::remove_dir_sep( $dir );
3721                                 if ( $dir !~ /^(?:is|match):/ ) {
3722                                     $dir = 'is:' . $dir;
3723                                 }
3724                                 if ( $dir !~ /^(?:is|match):/ ) {
3725                                     Carp::croak("invalid noignore-directory argument: '$dir'");
3726                                 }
3727
3728                                 @{ $opt->{idirs} } = grep {
3729                                     $_ ne $dir
3730                                 } @{ $opt->{idirs} };
3731                                },
3732         'nopager'           => sub { $opt->{pager} = undef },
3733         'passthru'          => \$opt->{passthru},
3734         'print0'            => \$opt->{print0},
3735         'Q|literal'         => \$opt->{Q},
3736         'r|R|recurse'       => sub { $opt->{n} = 0 },
3737         's'                 => \$opt->{dont_report_bad_filenames},
3738         'show-types'        => \$opt->{show_types},
3739         'smart-case!'       => \$opt->{smart_case},
3740         'sort-files'        => \$opt->{sort_files},
3741         'type=s'            => sub {
3742             my ( $getopt, $value ) = @_;
3743
3744             my $cb_value = 1;
3745             if ( $value =~ s/^no// ) {
3746                 $cb_value = 0;
3747             }
3748
3749             my $callback = $extra_specs->{ $value . '!' };
3750
3751             if ( $callback ) {
3752                 $callback->( $getopt, $cb_value );
3753             }
3754             else {
3755                 Carp::croak( "Unknown type '$value'" );
3756             }
3757         },
3758         'u'                 => removed_option('-u'),
3759         'unrestricted'      => removed_option('--unrestricted'),
3760         'v|invert-match'    => \$opt->{v},
3761         'w|word-regexp'     => \$opt->{w},
3762         'x'                 => sub { $opt->{files_from} = '-' },
3763
3764         'version'           => sub { App::Ack::print_version_statement(); exit; },
3765         'help|?:s'          => sub { shift; App::Ack::show_help(@_); exit; },
3766         'help-types'        => sub { App::Ack::show_help_types(); exit; },
3767         'man'               => sub { App::Ack::show_man(); exit; },
3768         $extra_specs ? %{$extra_specs} : (),
3769     }; # arg_specs
3770 }
3771
3772 sub process_other {
3773     my ( $opt, $extra_specs, $arg_sources ) = @_;
3774
3775     Getopt::Long::Configure('default', 'no_auto_help', 'no_auto_version'); # start with default options, minus some annoying ones
3776     Getopt::Long::Configure(
3777         'bundling',
3778         'no_ignore_case',
3779     );
3780
3781     my $argv_source;
3782     my $is_help_types_active;
3783
3784     for ( my $i = 0; $i < @{$arg_sources}; $i += 2 ) {
3785         my ( $source_name, $args ) = @{$arg_sources}[ $i, $i + 1 ];
3786
3787         if ( $source_name eq 'ARGV' ) {
3788             $argv_source = $args;
3789             last;
3790         }
3791     }
3792
3793     if ( $argv_source ) { # this *should* always be true, but you never know...
3794         my @copy = @{$argv_source};
3795
3796         Getopt::Long::Configure('pass_through');
3797
3798         Getopt::Long::GetOptionsFromArray( \@copy,
3799             'help-types' => \$is_help_types_active,
3800         );
3801
3802         Getopt::Long::Configure('no_pass_through');
3803     }
3804
3805     my $arg_specs = get_arg_spec($opt, $extra_specs);
3806
3807     for ( my $i = 0; $i < @{$arg_sources}; $i += 2) {
3808         my ($source_name, $args) = @{$arg_sources}[$i, $i + 1];
3809
3810         my $ret;
3811         if ( ref($args) ) {
3812             $ret = Getopt::Long::GetOptionsFromArray( $args, %{$arg_specs} );
3813         }
3814         else {
3815             ( $ret, $arg_sources->[$i + 1] ) =
3816                 Getopt::Long::GetOptionsFromString( $args, %{$arg_specs} );
3817         }
3818         if ( !$ret ) {
3819             if ( !$is_help_types_active ) {
3820                 my $where = $source_name eq 'ARGV' ? 'on command line' : "in $source_name";
3821                 App::Ack::die( "Invalid option $where" );
3822             }
3823         }
3824         if ( $opt->{noenv_seen} ) {
3825             App::Ack::die( "--noenv found in $source_name" );
3826         }
3827     }
3828
3829     # XXX We need to check on a -- in the middle of a non-ARGV source
3830
3831     return;
3832 }
3833
3834 sub should_dump_options {
3835     my ( $sources ) = @_;
3836
3837     for(my $i = 0; $i < @{$sources}; $i += 2) {
3838         my ( $name, $options ) = @{$sources}[$i, $i + 1];
3839         if($name eq 'ARGV') {
3840             my $dump;
3841             Getopt::Long::Configure('default', 'pass_through', 'no_auto_help', 'no_auto_version');
3842             Getopt::Long::GetOptionsFromArray($options,
3843                 'dump' => \$dump,
3844             );
3845             return $dump;
3846         }
3847     }
3848     return;
3849 }
3850
3851 sub explode_sources {
3852     my ( $sources ) = @_;
3853
3854     my @new_sources;
3855
3856     Getopt::Long::Configure('default', 'pass_through', 'no_auto_help', 'no_auto_version');
3857
3858     my %opt;
3859     my $arg_spec = get_arg_spec(\%opt);
3860
3861     my $add_type = sub {
3862         my ( undef, $arg ) = @_;
3863
3864         # XXX refactor?
3865         if ( $arg =~ /(\w+)=/) {
3866             $arg_spec->{$1} = sub {};
3867         }
3868         else {
3869             ( $arg ) = split /:/, $arg;
3870             $arg_spec->{$arg} = sub {};
3871         }
3872     };
3873
3874     my $del_type = sub {
3875         my ( undef, $arg ) = @_;
3876
3877         delete $arg_spec->{$arg};
3878     };
3879
3880     for(my $i = 0; $i < @{$sources}; $i += 2) {
3881         my ( $name, $options ) = @{$sources}[$i, $i + 1];
3882         if ( ref($options) ne 'ARRAY' ) {
3883             $sources->[$i + 1] = $options =
3884                 [ Text::ParseWords::shellwords($options) ];
3885         }
3886         for ( my $j = 0; $j < @{$options}; $j++ ) {
3887             next unless $options->[$j] =~ /^-/;
3888             my @chunk = ( $options->[$j] );
3889             push @chunk, $options->[$j] while ++$j < @{$options} && $options->[$j] !~ /^-/;
3890             $j--;
3891
3892             my @copy = @chunk;
3893             Getopt::Long::GetOptionsFromArray(\@chunk,
3894                 'type-add=s' => $add_type,
3895                 'type-set=s' => $add_type,
3896                 'type-del=s' => $del_type,
3897             );
3898             Getopt::Long::GetOptionsFromArray(\@chunk, %{$arg_spec});
3899
3900             splice @copy, -1 * @chunk if @chunk; # XXX explain this
3901             push @new_sources, $name, \@copy;
3902         }
3903     }
3904
3905     return \@new_sources;
3906 }
3907
3908 sub compare_opts {
3909     my ( $a, $b ) = @_;
3910
3911     my $first_a = $a->[0];
3912     my $first_b = $b->[0];
3913
3914     $first_a =~ s/^--?//;
3915     $first_b =~ s/^--?//;
3916
3917     return $first_a cmp $first_b;
3918 }
3919
3920 sub dump_options {
3921     my ( $sources ) = @_;
3922
3923     $sources = explode_sources($sources);
3924
3925     my %opts_by_source;
3926     my @source_names;
3927
3928     for(my $i = 0; $i < @{$sources}; $i += 2) {
3929         my ( $name, $contents ) = @{$sources}[$i, $i + 1];
3930         if ( not $opts_by_source{$name} ) {
3931             $opts_by_source{$name} = [];
3932             push @source_names, $name;
3933         }
3934         push @{$opts_by_source{$name}}, $contents;
3935     }
3936
3937     foreach my $name (@source_names) {
3938         my $contents = $opts_by_source{$name};
3939
3940         print $name, "\n";
3941         print '=' x length($name), "\n";
3942         print '  ', join(' ', @{$_}), "\n" foreach sort { compare_opts($a, $b) } @{$contents};
3943     }
3944
3945     return;
3946 }
3947
3948 sub remove_default_options_if_needed {
3949     my ( $sources ) = @_;
3950
3951     my $default_index;
3952
3953     foreach my $index ( 0 .. $#$sources ) {
3954         if ( $sources->[$index] eq 'Defaults' ) {
3955             $default_index = $index;
3956             last;
3957         }
3958     }
3959
3960     return $sources unless defined $default_index;
3961
3962     my $should_remove = 0;
3963
3964     Getopt::Long::Configure('default', 'no_auto_help', 'no_auto_version'); # start with default options, minus some annoying ones
3965     Getopt::Long::Configure(
3966         'no_ignore_case',
3967         'no_auto_abbrev',
3968         'pass_through',
3969     );
3970
3971     foreach my $index ( $default_index + 2 .. $#$sources ) {
3972         next if $index % 2 != 0;
3973
3974         my ( $name, $args ) = @{$sources}[ $index, $index + 1 ];
3975
3976         if (ref($args)) {
3977             Getopt::Long::GetOptionsFromArray($args,
3978                 'ignore-ack-defaults' => \$should_remove,
3979             );
3980         }
3981         else {
3982             ( undef, $sources->[$index + 1] ) = Getopt::Long::GetOptionsFromString($args,
3983                 'ignore-ack-defaults' => \$should_remove,
3984             );
3985         }
3986     }
3987
3988     Getopt::Long::Configure('default');
3989     Getopt::Long::Configure('default', 'no_auto_help', 'no_auto_version');
3990
3991     return $sources unless $should_remove;
3992
3993     my @copy = @{$sources};
3994     splice @copy, $default_index, 2;
3995     return \@copy;
3996 }
3997
3998 sub check_for_mutually_exclusive_options {
3999     my ( $arg_sources ) = @_;
4000
4001     my %mutually_exclusive_with;
4002     my @copy = @{$arg_sources};
4003
4004     for(my $i = 0; $i < @INVALID_COMBINATIONS; $i += 2) {
4005         my ( $lhs, $rhs ) = @INVALID_COMBINATIONS[ $i, $i + 1 ];
4006
4007         foreach my $l_opt ( @{$lhs} ) {
4008             foreach my $r_opt ( @{$rhs} ) {
4009                 push @{ $mutually_exclusive_with{ $l_opt } }, $r_opt;
4010                 push @{ $mutually_exclusive_with{ $r_opt } }, $l_opt;
4011             }
4012         }
4013     }
4014
4015     while( @copy ) {
4016         my %set_opts;
4017
4018         my ( $source_name, $args ) = splice @copy, 0, 2;
4019         $args = ref($args) ? [ @{$args} ] : [ Text::ParseWords::shellwords($args) ];
4020
4021         foreach my $opt ( @{$args} ) {
4022             next unless $opt =~ /^[-+]/;
4023             last if $opt eq '--';
4024
4025             if( $opt =~ /^(.*)=/ ) {
4026                 $opt = $1;
4027             }
4028             elsif ( $opt =~ /^(-[^-]).+/ ) {
4029                 $opt = $1;
4030             }
4031
4032             $set_opts{ $opt } = 1;
4033
4034             my $mutex_opts = $mutually_exclusive_with{ $opt };
4035
4036             next unless $mutex_opts;
4037
4038             foreach my $mutex_opt ( @{$mutex_opts} ) {
4039                 if($set_opts{ $mutex_opt }) {
4040                     die "Options '$mutex_opt' and '$opt' are mutually exclusive\n";
4041                 }
4042             }
4043         }
4044     }
4045 }
4046
4047 sub process_args {
4048     my $arg_sources = \@_;
4049
4050     my %opt;
4051
4052     check_for_mutually_exclusive_options($arg_sources);
4053
4054     $arg_sources = remove_default_options_if_needed($arg_sources);
4055
4056     if ( should_dump_options($arg_sources) ) {
4057         dump_options($arg_sources);
4058         exit(0);
4059     }
4060
4061     my $type_specs = process_filetypes(\%opt, $arg_sources);
4062     process_other(\%opt, $type_specs, $arg_sources);
4063     while ( @{$arg_sources} ) {
4064         my ( $source_name, $args ) = splice( @{$arg_sources}, 0, 2 );
4065
4066         # All of our sources should be transformed into an array ref
4067         if ( ref($args) ) {
4068             if ( $source_name eq 'ARGV' ) {
4069                 @ARGV = @{$args};
4070             }
4071             elsif (@{$args}) {
4072                 Carp::croak "source '$source_name' has extra arguments!";
4073             }
4074         }
4075         else {
4076             Carp::croak 'The impossible has occurred!';
4077         }
4078     }
4079     my $filters = ($opt{filters} ||= []);
4080
4081     # throw the default filter in if no others are selected
4082     if ( not grep { !$_->is_inverted() } @{$filters} ) {
4083         push @{$filters}, App::Ack::Filter::Default->new();
4084     }
4085     return \%opt;
4086 }
4087
4088 1; # End of App::Ack::ConfigLoader
4089 package App::Ack::ConfigDefault;
4090
4091 use warnings;
4092 use strict;
4093
4094 sub options {
4095     my @options = split( /\n/, _options_block() );
4096     @options = grep { /./ && !/^#/ } @options;
4097
4098     return @options;
4099 }
4100
4101 sub _options_block {
4102     return <<'HERE';
4103 # This is the default ackrc for ack 2.0
4104
4105 # There are four different ways to match
4106 # is:  Match the filename exactly
4107 # ext: Match the extension of the filename exactly
4108 # match: Match the filename against a Perl regular expression
4109 # firstlinematch: Match the first 80 characters of the first line
4110 #   of text against a Perl regular expression.  This is only for
4111 #   the --type-add option.
4112
4113
4114 # Directories to ignore
4115 # Bazaar
4116 --ignore-directory=is:.bzr
4117
4118 # Codeville
4119 --ignore-directory=is:.cdv
4120
4121 # Interface Builder
4122 --ignore-directory=is:~.dep
4123 --ignore-directory=is:~.dot
4124 --ignore-directory=is:~.nib
4125 --ignore-directory=is:~.plst
4126
4127 # Git
4128 --ignore-directory=is:.git
4129
4130 # Mercurial
4131 --ignore-directory=is:.hg
4132
4133 # quilt
4134 --ignore-directory=is:.pc
4135
4136 # Subversion
4137 --ignore-directory=is:.svn
4138
4139 # Monotone
4140 --ignore-directory=is:_MTN
4141
4142 # CVS
4143 --ignore-directory=is:CVS
4144
4145 # RCS
4146 --ignore-directory=is:RCS
4147
4148 # SCCS
4149 --ignore-directory=is:SCCS
4150
4151 # darcs
4152 --ignore-directory=is:_darcs
4153
4154 # Vault/Fortress
4155 --ignore-directory=is:_sgbak
4156
4157 # autoconf
4158 --ignore-directory=is:autom4te.cache
4159
4160 # Perl module building
4161 --ignore-directory=is:blib
4162 --ignore-directory=is:_build
4163
4164 # Perl Devel::Cover module's output directory
4165 --ignore-directory=is:cover_db
4166
4167
4168
4169 # Files to ignore
4170 # Backup files
4171 --ignore-file=ext:bak
4172 --ignore-file=match:/~$/
4173
4174 # Emacs swap files
4175 --ignore-file=match:/^#.+#$/
4176
4177 # vi/vim swap files
4178 --ignore-file=match:/[._].*\.swp$/
4179
4180 # core dumps
4181 --ignore-file=match:/core\.\d+$/
4182
4183 # minified Javascript
4184 --ignore-file=match:/[.]min[.]js$/
4185
4186
4187 # Filetypes defined
4188
4189 # Perl http://perl.org/
4190 --type-add=perl:ext:pl,pm,pod,t
4191 --type-add=perl:firstlinematch:/#!.*\bperl/
4192
4193 # Makefiles http://www.gnu.org/s/make/
4194 --type-add=make:ext:mk
4195 --type-add=make:ext:mak
4196 --type-add=make:is:makefile
4197 --type-add=make:is:Makefile
4198 --type-add=make:is:GNUmakefile
4199
4200 # Rakefiles http://rake.rubyforge.org/
4201 --type-add=rake:is:Rakefile
4202
4203 # CMake http://www.cmake.org/
4204 --type-add=cmake:is:CMakeLists.txt
4205 --type-add=cmake:ext:cmake
4206
4207 # Actionscript
4208 --type-add=actionscript:ext:as,mxml
4209
4210 # Ada http://www.adaic.org/
4211 --type-add=ada:ext:ada,adb,ads
4212
4213 # ASP http://msdn.microsoft.com/en-us/library/aa286483.aspx
4214 --type-add=asp:ext:asp
4215
4216 # ASP.Net http://www.asp.net/
4217 --type-add=aspx:ext:master,ascx,asmx,aspx,svc
4218
4219 # Assembly
4220 --type-add=asm:ext:asm,s
4221
4222 # Batch
4223 --type-add=batch:ext:bat,cmd
4224
4225 # ColdFusion http://en.wikipedia.org/wiki/ColdFusion
4226 --type-add=cfmx:ext:cfc,cfm,cfml
4227
4228 # Clojure http://clojure.org/
4229 --type-add=clojure:ext:clj
4230
4231 # C
4232 # .xs are Perl C files
4233 --type-add=cc:ext:c,h,xs
4234
4235 # C header files
4236 --type-add=hh:ext:h
4237
4238 # C++
4239 --type-add=cpp:ext:cpp,cc,cxx,m,hpp,hh,h,hxx
4240
4241 # C#
4242 --type-add=csharp:ext:cs
4243
4244 # CSS http://www.w3.org/Style/CSS/
4245 --type-add=css:ext:css
4246
4247 # Delphi http://en.wikipedia.org/wiki/Embarcadero_Delphi
4248 --type-add=delphi:ext:pas,int,dfm,nfm,dof,dpk,dproj,groupproj,bdsgroup,bdsproj
4249
4250 # Emacs Lisp http://www.gnu.org/software/emacs
4251 --type-add=elisp:ext:el
4252
4253 # Erlang http://www.erlang.org/
4254 --type-add=erlang:ext:erl,hrl
4255
4256 # Fortran http://en.wikipedia.org/wiki/Fortran
4257 --type-add=fortran:ext:f,f77,f90,f95,f03,for,ftn,fpp
4258
4259 # Google Go http://golang.org/
4260 --type-add=go:ext:go
4261
4262 # Groovy http://groovy.codehaus.org/
4263 --type-add=groovy:ext:groovy,gtmpl,gpp,grunit,gradle
4264
4265 # Haskell http://www.haskell.org/
4266 --type-add=haskell:ext:hs,lhs
4267
4268 # HTML
4269 --type-add=html:ext:htm,html
4270
4271 # Java http://www.oracle.com/technetwork/java/index.html
4272 --type-add=java:ext:java,properties
4273
4274 # JavaScript
4275 --type-add=js:ext:js
4276
4277 # JSP http://www.oracle.com/technetwork/java/javaee/jsp/index.html
4278 --type-add=jsp:ext:jsp,jspx,jhtm,jhtml
4279
4280 # Common Lisp http://common-lisp.net/
4281 --type-add=lisp:ext:lisp,lsp
4282
4283 # Lua http://www.lua.org/
4284 --type-add=lua:ext:lua
4285
4286 # Objective-C
4287 --type-add=objc:ext:m,h
4288
4289 # Objective-C++
4290 --type-add=objcpp:ext:mm,h
4291
4292 # OCaml http://caml.inria.fr/
4293 --type-add=ocaml:ext:ml,mli
4294
4295 # Parrot http://www.parrot.org/
4296 --type-add=parrot:ext:pir,pasm,pmc,ops,pod,pg,tg
4297
4298 # PHP http://www.php.net/
4299 --type-add=php:ext:php,phpt,php3,php4,php5,phtml
4300 --type-add=php:firstlinematch:/#!.*\bphp/
4301
4302 # Plone http://plone.org/
4303 --type-add=plone:ext:pt,cpt,metadata,cpy,py
4304
4305 # Python http://www.python.org/
4306 --type-add=python:ext:py
4307 --type-add=python:firstlinematch:/#!.*\bpython/
4308
4309 # R http://www.r-project.org/
4310 --type-add=rr:ext:R
4311
4312 # Ruby http://www.ruby-lang.org/
4313 --type-add=ruby:ext:rb,rhtml,rjs,rxml,erb,rake,spec
4314 --type-add=ruby:is:Rakefile
4315 --type-add=ruby:firstlinematch:/#!.*\bruby/
4316
4317 # Scala http://www.scala-lang.org/
4318 --type-add=scala:ext:scala
4319
4320 # Scheme http://groups.csail.mit.edu/mac/projects/scheme/
4321 --type-add=scheme:ext:scm,ss
4322
4323 # Shell
4324 --type-add=shell:ext:sh,bash,csh,tcsh,ksh,zsh
4325 --type-add=shell:firstlinematch:/(?:ba|t?c|k|z)?sh\b/
4326
4327 # Smalltalk http://www.smalltalk.org/
4328 --type-add=smalltalk:ext:st
4329
4330 # SQL http://www.iso.org/iso/catalogue_detail.htm?csnumber=45498
4331 --type-add=sql:ext:sql,ctl
4332
4333 # Tcl http://www.tcl.tk/
4334 --type-add=tcl:ext:tcl,itcl,itk
4335
4336 # LaTeX http://www.latex-project.org/
4337 --type-add=tex:ext:tex,cls,sty
4338
4339 # Template Toolkit http://template-toolkit.org/
4340 --type-add=tt:ext:tt,tt2,ttml
4341
4342 # Visual Basic
4343 --type-add=vb:ext:bas,cls,frm,ctl,vb,resx
4344
4345 # Verilog
4346 --type-add=verilog:ext:v,vh,sv
4347
4348 # VHDL http://www.eda.org/twiki/bin/view.cgi/P1076/WebHome
4349 --type-add=vhdl:ext:vhd,vhdl
4350
4351 # Vim http://www.vim.org/
4352 --type-add=vim:ext:vim
4353
4354 # XML http://www.w3.org/TR/REC-xml/
4355 --type-add=xml:ext:xml,dtd,xsl,xslt,ent
4356 --type-add=xml:firstlinematch:/<[?]xml/
4357
4358 # YAML http://yaml.org/
4359 --type-add=yaml:ext:yaml,yml
4360 HERE
4361 }
4362
4363 1;