1NAME
2 Path::Iterator::Rule - Iterative, recursive file finder
3
4VERSION
5 version 1.008
6
7SYNOPSIS
8 use Path::Iterator::Rule;
9
10 my $rule = Path::Iterator::Rule->new; # match anything
11 $rule->file->size(">10k"); # add/chain rules
12
13 # iterator interface
14 my $next = $rule->iter( @dirs );
15 while ( defined( my $file = $next->() ) ) {
16 ...
17 }
18
19 # list interface
20 for my $file ( $rule->all( @dirs ) ) {
21 ...
22 }
23
24DESCRIPTION
25 This module iterates over files and directories to identify ones
26 matching a user-defined set of rules. The API is based heavily on
27 File::Find::Rule, but with more explicit distinction between matching
28 rules and options that influence how directories are searched. A
29 "Path::Iterator::Rule" object is a collection of rules (match criteria)
30 with methods to add additional criteria. Options that control directory
31 traversal are given as arguments to the method that generates an
32 iterator.
33
34 Here is a summary of features for comparison to other file finding
35 modules:
36
37 * provides many "helper" methods for specifying rules
38
39 * offers (lazy) iterator and flattened list interfaces
40
41 * custom rules implemented with callbacks
42
43 * breadth-first (default) or pre- or post-order depth-first searching
44
45 * follows symlinks (by default, but can be disabled)
46
47 * directories visited only once (no infinite loop; can be disabled)
48
49 * doesn't chdir during operation
50
51 * provides an API for extensions
52
53 As a convenience, the PIR module is an empty subclass of this one that
54 is less arduous to type for one-liners.
55
56USAGE
57 Constructors
58 "new"
59 my $rule = Path::Iterator::Rule->new;
60
61 Creates a new rule object that matches any file or directory. It takes
62 no arguments. For convenience, it may also be called on an object, in
63 which case it still returns a new object that matches any file or
64 directory.
65
66 "clone"
67 my $common = Path::Iterator::Rule->new->file->not_empty;
68 my $big_files = $common->clone->size(">1M");
69 my $small_files = $common->clone->size("<10K");
70
71 Creates a copy of a rule object. Useful for customizing different rule
72 objects against a common base.
73
74 Matching and iteration
75 "iter"
76 my $next = $rule->iter( @dirs, \%options);
77 while ( defined( my $file = $next->() ) ) {
78 ...
79 }
80
81 Creates a subroutine reference iterator that returns a single result
82 when dereferenced. This iterator is "lazy" -- results are not
83 pre-computed.
84
85 It takes as arguments a list of directories to search and an optional
86 hash reference of control options. If no search directories are
87 provided, the current directory is used ("."). Valid options include:
88
89 * "depthfirst" -- Controls order of results. Valid values are "1"
90 (post-order, depth-first search), "0" (breadth-first search) or "-1"
91 (pre-order, depth-first search). Default is 0.
92
93 * "error_handler" -- Catches errors during execution of rule tests.
94 Default handler dies with the filename and error. If set to undef,
95 error handling is disabled.
96
97 * "follow_symlinks" -- Follow directory symlinks when true. Default is
98 1.
99
100 * "loop_safe" -- Prevents visiting the same directory more than once
101 when true. Default is 1.
102
103 * "relative" -- Return matching items relative to the search
104 directory. Default is 0.
105
106 * "sorted" -- Whether entries in a directory are sorted before
107 processing. Default is 1.
108
109 * "visitor" -- An optional coderef that will be called on items
110 matching all rules.
111
112 Filesystem loops might exist from either hard or soft links. The
113 "loop_safe" option prevents infinite loops, but adds some overhead by
114 making "stat" calls. Because directories are visited only once when
115 "loop_safe" is true, matches could come from a symlinked directory
116 before the real directory depending on the search order. To get only the
117 real files, turn off "follow_symlinks". Turning "loop_safe" off and
118 leaving "follow_symlinks" on avoids "stat" calls and will be fastest,
119 but with the risk of an infinite loop and repeated files. The default is
120 slow, but safe.
121
122 The "error_handler" parameter must be a subroutine reference. It will be
123 called when a rule test throws an exception. The first argument will be
124 the file name being inspected and the second argument will be the
125 exception.
126
127 The optional "visitor" parameter must be a subroutine reference. If set,
128 it will be called for any result that matches. It is called the same way
129 a custom rule would be (see "EXTENDING") but its return value is
130 ignored. It is called when an item is first inspected -- "postorder" is
131 not respected.
132
133 The paths inspected and returned will be relative to the search
134 directories provided. If these are absolute, then the paths returned
135 will have absolute paths. If these are relative, then the paths returned
136 will have relative paths.
137
138 If the search directories are absolute and the "relative" option is
139 true, files returned will be relative to the search directory. Note that
140 if the search directories are not mutually exclusive (whether containing
141 subdirectories like @INC or symbolic links), files found could be
142 returned relative to different initial search directories based on
143 "depthfirst", "follow_symlinks" or "loop_safe".
144
145 When the iterator is exhausted, it will return undef.
146
147 "iter_fast"
148 This works just like "iter", except that it optimizes for speed over
149 safety. Don't do this unless you're sure you need it and accept the
150 consequences. See "PERFORMANCE" for details.
151
152 "all"
153 my @matches = $rule->all( @dir, \%options );
154
155 Returns a list of paths that match the rule. It takes the same arguments
156 and has the same behaviors as the "iter" method. The "all" method uses
157 "iter" internally to fetch all results.
158
159 In scalar context, it will return the count of matched paths.
160
161 In void context, it is optimized to iterate over everything, but not
162 store results. This is most useful with the "visitor" option:
163
164 $rule->all( $path, { visitor => \&callback } );
165
166 "all_fast"
167 This works just like "all", except that it optimizes for speed over
168 safety. Don't do this unless you're sure you need it and accept the
169 consequences. See "PERFORMANCE" for details.
170
171 "test"
172 if ( $rule->test( $path, $basename, $stash ) ) { ... }
173
174 Test a file path against a rule. Used internally, but provided should
175 someone want to create their own, custom iteration algorithm.
176
177 Logic operations
178 "Path::Iterator::Rule" provides three logic operations for adding rules
179 to the object. Rules may be either a subroutine reference with specific
180 semantics (described below in "EXTENDING") or another
181 "Path::Iterator::Rule" object.
182
183 "and"
184 $rule->and( sub { -r -w -x $_ } ); # stacked filetest example
185 $rule->and( @more_rules );
186
187 Adds one or more constraints to the current rule. E.g. "old rule AND
188 new1 AND new2 AND ...". Returns the object to allow method chaining.
189
190 "or"
191 $rule->or(
192 $rule->new->name("foo*"),
193 $rule->new->name("bar*"),
194 sub { -r -w -x $_ },
195 );
196
197 Takes one or more alternatives and adds them as a constraint to the
198 current rule. E.g. "old rule AND ( new1 OR new2 OR ... )". Returns the
199 object to allow method chaining.
200
201 "not"
202 $rule->not( sub { -r -w -x $_ } );
203
204 Takes one or more alternatives and adds them as a negative constraint to
205 the current rule. E.g. "old rule AND NOT ( new1 AND new2 AND ...)".
206 Returns the object to allow method chaining.
207
208 "skip"
209 $rule->skip(
210 $rule->new->dir->not_writeable,
211 $rule->new->dir->name("foo"),
212 );
213
214 Takes one or more alternatives and will prune a directory if any of the
215 criteria match or if any of the rules already indicate the directory
216 should be pruned. Pruning means the directory will not be returned by
217 the iterator and will not be searched.
218
219 For files, it is equivalent to "$rule->not($rule->or(@rules))". Returns
220 the object to allow method chaining.
221
222 This method should be called as early as possible in the rule chain. See
223 "skip_dirs" below for further explanation and an example.
224
225RULE METHODS
226 Rule methods are helpers that add constraints. Internally, they generate
227 a closure to accomplish the desired logic and add it to the rule object
228 with the "and" method. Rule methods return the object to allow for
229 method chaining.
230
231 File name rules
232 "name"
233 $rule->name( "foo.txt" );
234 $rule->name( qr/foo/, "bar.*");
235
236 The "name" method takes one or more patterns and creates a rule that is
237 true if any of the patterns match the basename of the file or directory
238 path. Patterns may be regular expressions or glob expressions (or
239 literal names).
240
241 "iname"
242 $rule->iname( "foo.txt" );
243 $rule->iname( qr/foo/, "bar.*");
244
245 The "iname" method is just like the "name" method, but matches
246 case-insensitively.
247
248 "skip_dirs"
249 $rule->skip_dirs( @patterns );
250
251 The "skip_dirs" method skips directories that match one or more
252 patterns. Patterns may be regular expressions or globs (just like
253 "name"). Directories that match will not be returned from the iterator
254 and will be excluded from further search. This includes the starting
255 directories. If that isn't what you want, see "skip_subdirs" instead.
256
257 Note: this rule should be specified early so that it has a chance to
258 operate before a logical shortcut. E.g.
259
260 $rule->skip_dirs(".git")->file; # OK
261 $rule->file->skip_dirs(".git"); # Won't work
262
263 In the latter case, when a ".git" directory is seen, the "file" rule
264 shortcuts the rule before the "skip_dirs" rule has a chance to act.
265
266 "skip_subdirs"
267 $rule->skip_subdirs( @patterns );
268
269 This works just like "skip_dirs", except that the starting directories
270 (depth 0) are not skipped and may be returned from the iterator unless
271 excluded by other rules.
272
273 File test rules
274 Most of the "-X" style filetest are available as boolean rules. The
275 table below maps the filetest to its corresponding method name.
276
277 Test | Method Test | Method
278 ------|------------- ------|----------------
279 -r | readable -R | r_readable
280 -w | writeable -W | r_writeable
281 -w | writable -W | r_writable
282 -x | executable -X | r_executable
283 -o | owned -O | r_owned
284 | |
285 -e | exists -f | file
286 -z | empty -d | directory, dir
287 -s | nonempty -l | symlink
288 | -p | fifo
289 -u | setuid -S | socket
290 -g | setgid -b | block
291 -k | sticky -c | character
292 | -t | tty
293 -T | ascii
294 -B | binary
295
296 For example:
297
298 $rule->file->nonempty; # -f -s $file
299
300 The -X operators for timestamps take a single argument in a form that
301 Number::Compare can interpret.
302
303 Test | Method
304 ------|-------------
305 -A | accessed
306 -M | modified
307 -C | changed
308
309 For example:
310
311 $rule->modified(">1"); # -M $file > 1
312
313 Stat test rules
314 All of the "stat" elements have a method that takes a single argument in
315 a form understood by Number::Compare.
316
317 stat() | Method
318 --------------------
319 0 | dev
320 1 | ino
321 2 | mode
322 3 | nlink
323 4 | uid
324 5 | gid
325 6 | rdev
326 7 | size
327 8 | atime
328 9 | mtime
329 10 | ctime
330 11 | blksize
331 12 | blocks
332
333 For example:
334
335 $rule->size(">10K")
336
337 Depth rules
338 $rule->min_depth(3);
339 $rule->max_depth(5);
340
341 The "min_depth" and "max_depth" rule methods take a single argument and
342 limit the paths returned to a minimum or maximum depth (respectively)
343 from the starting search directory. A depth of 0 means the starting
344 directory itself. A depth of 1 means its children. (This is similar to
345 the Unix "find" utility.)
346
347 Perl file rules
348 # All perl rules
349 $rule->perl_file;
350
351 # Individual perl file rules
352 $rule->perl_module; # .pm files
353 $rule->perl_pod; # .pod files
354 $rule->perl_test; # .t files
355 $rule->perl_installer; # Makefile.PL or Build.PL
356 $rule->perl_script; # .pl or 'perl' in the shebang
357
358 These rule methods match file names (or a shebang line) that are typical
359 of Perl distribution files.
360
361 Version control file rules
362 # Skip all known VCS files
363 $rule->skip_vcs;
364
365 # Skip individual VCS files
366 $rule->skip_cvs;
367 $rule->skip_rcs;
368 $rule->skip_svn;
369 $rule->skip_git;
370 $rule->skip_bzr;
371 $rule->skip_hg;
372 $rule->skip_darcs;
373
374 Skips files and/or prunes directories related to a version control
375 system. Just like "skip_dirs", these rules should be specified early to
376 get the correct behavior.
377
378 File content rules
379 "contents_match"
380 $rule->contents_match(qr/BEGIN .* END/xs);
381
382 The "contents_match" rule takes a list of regular expressions and
383 returns files that match one of the expressions.
384
385 The expressions are applied to the file's contents as a single string.
386 For large files, this is likely to take significant time and memory.
387
388 Files are assumed to be encoded in UTF-8, but alternative Perl IO layers
389 can be passed as the first argument:
390
391 $rule->contents_match(":encoding(iso-8859-1)", qr/BEGIN .* END/xs);
392
393 See perlio for further details.
394
395 "line_match"
396 $rule->line_match(qr/^new/i, qr/^Addition/);
397
398 The "line_match" rule takes a list of regular expressions and returns
399 files with at least one line that matches one of the expressions.
400
401 Files are assumed to be encoded in UTF-8, but alternative Perl IO layers
402 can be passed as the first argument.
403
404 "shebang"
405 $rule->shebang(qr/#!.*\bperl\b/);
406
407 The "shebang" rule takes a list of regular expressions or glob patterns
408 and checks them against the first line of a file.
409
410 Other rules
411 "dangling"
412 $rule->symlink->dangling;
413 $rule->not_dangling;
414
415 The "dangling" rule method matches dangling symlinks. Use it or its
416 inverse to control how dangling symlinks should be treated.
417
418 Negated rules
419 Most rule methods have a negated form preceded by "not_".
420
421 $rule->not_name("foo.*")
422
423 Because this happens automatically, it includes somewhat silly ones like
424 "not_nonempty" (which is thus a less efficient way of saying "empty").
425
426 Rules that skip directories or version control files do not have a
427 negated version.
428
429EXTENDING
430 Custom rule subroutines
431 Rules are implemented as (usually anonymous) subroutine callbacks that
432 return a value indicating whether or not the rule matches. These
433 callbacks are called with three arguments. The first argument is a path,
434 which is also locally aliased as the $_ global variable for convenience
435 in simple tests.
436
437 $rule->and( sub { -r -w -x $_ } ); # tests $_
438
439 The second argument is the basename of the path, which is useful for
440 certain types of name checks:
441
442 $rule->and( sub { $_[1] =~ /foo|bar/ } ); "foo" or "bar" in basename;
443
444 The third argument is a hash reference that can be used to maintain
445 state. Keys beginning with an underscore are reserved for
446 "Path::Iterator::Rule" to provide additional data about the search in
447 progress. For example, the "_depth" key is used to support minimum and
448 maximum depth checks.
449
450 The custom rule subroutine must return one of four values:
451
452 * A true value -- indicates the constraint is satisfied
453
454 * A false value -- indicates the constraint is not satisfied
455
456 * "\1" -- indicate the constraint is satisfied, and prune if it's a
457 directory
458
459 * "\0" -- indicate the constraint is not satisfied, and prune if it's
460 a directory
461
462 A reference is a special flag that signals that a directory should not
463 be searched recursively, regardless of whether the directory should be
464 returned by the iterator or not.
465
466 The legacy "0 but true" value used previously for pruning is no longer
467 valid and will throw an exception if it is detected.
468
469 Here is an example. This is equivalent to the "max_depth" rule method
470 with a depth of 3:
471
472 $rule->and(
473 sub {
474 my ($path, $basename, $stash) = @_;
475 return 1 if $stash->{_depth} < 3;
476 return \1 if $stash->{_depth} == 3;
477 return \0; # should never get here
478 }
479 );
480
481 Files and directories and directories up to depth 3 will be returned and
482 directories will be searched. Files of depth 3 will be returned.
483 Directories of depth 3 will be returned, but their contents will not be
484 added to the search.
485
486 Returning a reference is "sticky" -- they will propagate through "and"
487 and "or" logic.
488
489 0 && \0 = \0 \0 && 0 = \0 0 || \0 = \0 \0 || 0 = \0
490 0 && \1 = \0 \0 && 1 = \0 0 || \1 = \1 \0 || 1 = \1
491 1 && \0 = \0 \1 && 0 = \0 1 || \0 = \1 \1 || 0 = \1
492 1 && \1 = \1 \1 && 1 = \1 1 || \1 = \1 \1 || 1 = \1
493
494 Once a directory is flagged to be pruned, it will be pruned regardless
495 of subsequent rules.
496
497 $rule->max_depth(3)->name(qr/foo/);
498
499 This will return files or directories with "foo" in the name, but all
500 directories at depth 3 will be pruned, regardless of whether they match
501 the name rule.
502
503 Generally, if you want to do directory pruning, you are encouraged to
504 use the "skip" method instead of writing your own logic using "\0" and
505 "\1".
506
507 Extension modules and custom rule methods
508 One of the strengths of File::Find::Rule is the many CPAN modules that
509 extend it. "Path::Iterator::Rule" provides the "add_helper" method to
510 provide a similar mechanism for extensions.
511
512 The "add_helper" class method takes three arguments, a "name" for the
513 rule method, a closure-generating callback, and a flag for not
514 generating a negated form of the rule. Unless the flag is true, an
515 inverted "not_*" method is generated automatically. Extension classes
516 should call this as a class method to install new rule methods. For
517 example, this adds a "foo" method that checks if the filename is "foo":
518
519 package Path::Iterator::Rule::Foo;
520
521 use Path::Iterator::Rule;
522
523 Path::Iterator::Rule->add_helper(
524 foo => sub {
525 my @args = @_; # do this to customize closure with arguments
526 return sub {
527 my ($item, $basename) = @_;
528 return if -d "$item";
529 return $basename =~ /^foo$/;
530 }
531 }
532 );
533
534 1;
535
536 This allows the following rule methods:
537
538 $rule->foo;
539 $fule->not_foo;
540
541 The "add_helper" method will warn and ignore a helper with the same name
542 as an existing method.
543
544 Subclassing
545 Instead of processing and returning strings, this module may be
546 subclassed to operate on objects that represent files. Such objects must
547 stringify to a file path.
548
549 The following private implementation methods must be overridden:
550
551 * _objectify -- given a path, return an object
552
553 * _children -- given a directory, return an (unsorted) list of [
554 basename, full path ] entries within it, excluding "." and ".."
555
556 Note that "_children" should return a *list* of *tuples*, where the
557 tuples are array references containing basename and full path.
558
559 See Path::Class::Rule source for an example.
560
561LEXICAL WARNINGS
562 If you run with lexical warnings enabled, "Path::Iterator::Rule" will
563 issue warnings in certain circumstances (such as an unreadable directory
564 that must be skipped). To disable these categories, put the following
565 statement at the correct scope:
566
567 no warnings 'Path::Iterator::Rule';
568
569PERFORMANCE
570 By default, "Path::Iterator::Rule" iterator options are "slow but safe".
571 They ensure uniqueness, return files in sorted order, and throw nice
572 error messages if something goes wrong.
573
574 If you want speed over safety, set these options:
575
576 %options = (
577 loop_safe => 0,
578 sorted => 0,
579 depthfirst => -1,
580 error_handler => undef
581 );
582
583 Alternatively, use the "iter_fast" and "all_fast" methods instead, which
584 set these options for you.
585
586 $iter = $rule->iter( @dirs, \%options );
587
588 $iter = $rule->iter_fast( @dirs ); # same thing
589
590 Depending on the file structure being searched, "depthfirst => -1" may
591 or may not be a good choice. If you have lots of nested directories and
592 all the files at the bottom, a depth first search might do less work or
593 use less memory, particularly if the search will be halted early (e.g.
594 finding the first N matches.)
595
596 Rules will shortcut on failure, so be sure to put rules likely to fail
597 early in a rule chain.
598
599 Consider:
600
601 $r1 = Path::Iterator::Rule->new->name(qr/foo/)->file;
602 $r2 = Path::Iterator::Rule->new->file->name(qr/foo/);
603
604 If there are lots of files, but only a few containing "foo", then $r1
605 above will be faster.
606
607 Rules are implemented as code references, so long chains have some
608 overhead. Consider testing with a custom coderef that combines several
609 tests into one.
610
611 Consider:
612
613 $r3 = Path::Iterator::Rule->new->and( sub { -x -w -r $_ } );
614 $r4 = Path::Iterator::Rule->new->executable->writeable->readable;
615
616 Rule $r3 above will be much faster, not only because it stacks the file
617 tests, but because it requires only a single code reference.
618
619CAVEATS
620 Some features are still unimplemented:
621
622 * Untainting options
623
624 * Some File::Find::Rule helpers (e.g. "grep")
625
626 * Extension class loading via "import()"
627
628 Filetest operators and stat rules are subject to the usual portability
629 considerations. See perlport for details.
630
631SEE ALSO
632 There are many other file finding modules out there. They all have
633 various features/deficiencies, depending on your preferences and needs.
634 Here is an (incomplete) list of alternatives, with some comparison
635 commentary.
636
637 Path::Class::Rule and IO::All::Rule are subclasses of
638 "Path::Iterator::Rule" and operate on Path::Class and IO::All objects,
639 respectively. Because of this, they are substantially slower on large
640 directory trees than just using this module directly.
641
642 File::Find is part of the Perl core. It requires the user to write a
643 callback function to process each node of the search. Callbacks must use
644 global variables to determine the current node. It only supports
645 depth-first search (both pre- and post-order). It supports pre- and
646 post-processing callbacks; the former is required for sorting files to
647 process in a directory. File::Find::Closures can be used to help create
648 a callback for File::Find.
649
650 File::Find::Rule is an object-oriented wrapper around File::Find. It
651 provides a number of helper functions and there are many more
652 "File::Find::Rule::*" modules on CPAN with additional helpers. It
653 provides an iterator interface, but precomputes all the results.
654
655 File::Next provides iterators for file, directories or "everything". It
656 takes two callbacks, one to match files and one to decide which
657 directories to descend. It does not allow control over breadth/depth
658 order, though it does provide means to sort files for processing within
659 a directory. Like File::Find, it requires callbacks to use global
660 variables.
661
662 Path::Class::Iterator walks a directory structure with an iterator. It
663 is implemented as Path::Class subclasses, which adds a degree of extra
664 complexity. It takes a single callback to define "interesting" paths to
665 return. The callback gets a Path::Class::Iterator::File or
666 Path::Class::Iterator::Dir object for evaluation.
667
668 File::Find::Object and companion File::Find::Object::Rule are like
669 File::Find and File::Find::Rule, but without File::Find inside. They use
670 an iterator that does not precompute results. They can return
671 File::Find::Object::Result objects, which give a subset of the utility
672 of Path::Class objects. File::Find::Object::Rule appears to be a literal
673 translation of File::Find::Rule, including oddities like making "-M"
674 into a boolean.
675
676 File::chdir::WalkDir recursively descends a tree, calling a callback on
677 each file. No iterator. Supports exclusion patterns. Depth-first
678 post-order by default, but offers pre-order option. Does not process
679 symlinks.
680
681 File::Find::Iterator is based on iterator patterns in Higher Order Perl.
682 It allows a filtering callback. Symlinks are followed automatically
683 without infinite loop protection. No control over order. It offers a
684 "state file" option for resuming interrupted work.
685
686 File::Find::Declare has declarative helper rules, no iterator, is
687 Moose-based and offers no control over ordering or following symlinks.
688
689 File::Find::Node has no iterator, does matching via callback and offers
690 no control over ordering.
691
692 File::Set builds up a set of files to operate on from a list of
693 directories to include or exclude, with control over recursion. A
694 callback is applied to each file (or directory) in the set. There is no
695 iterator. There is no control over ordering. Symlinks are not followed.
696 It has several extra features for checksumming the set and creating
697 tarballs with /bin/tar.
698
699THANKS
700 Thank you to Ricardo Signes (rjbs) for inspiring me to write yet another
701 file finder module, for writing file finder optimization benchmarks, and
702 tirelessly running my code over and over to see if it got faster.
703
704 * See the speed of Perl file finders
705 <http://rjbs.manxome.org/rubric/entry/1981>
706
707SUPPORT
708 Bugs / Feature Requests
709 Please report any bugs or feature requests through the issue tracker at
710 <https://github.com/dagolden/Path-Iterator-Rule/issues>. You will be
711 notified automatically of any progress on your issue.
712
713 Source Code
714 This is open source software. The code repository is available for
715 public review and contribution under the terms of the license.
716
717 <https://github.com/dagolden/Path-Iterator-Rule>
718
719 git clone https://github.com/dagolden/Path-Iterator-Rule.git
720
721AUTHOR
722 David Golden <dagolden@cpan.org>
723
724CONTRIBUTORS
725 * David Steinbrunner <dsteinbrunner@pobox.com>
726
727 * Gian Piero Carrubba <gpiero@butterfly.fdc.rm-rf.it>
728
729 * Graham Knop <haarg@cpan.org>
730
731 * Ricardo Signes <rjbs@cpan.org>
732
733 * Toby Inkster <tobyink@cpan.org>
734
735COPYRIGHT AND LICENSE
736 This software is Copyright (c) 2013 by David Golden.
737
738 This is free software, licensed under:
739
740 The Apache License, Version 2.0, January 2004
741
742