Reimagine PR #18 (follow-symlinks support)

Author: lizmat

Changes

@@ -1,6 +1,8 @@
 Revision history for File-Find
 
 {{$NEXT}}
+    - Add support for :follow-symlinks argument (re-imagined
+      from PR #18, Garland-g++)
     - Modernize pod, META and test-file extensions
     - Add coverage tests (at 100%)
     - Add CI badge for each OS

README.md

@@ -45,15 +45,22 @@ Exclude is meant to be used for skipping certain big and uninteresting directori
 
 The value of `exclude` will be smartmatched against each IO object found by File::Find. It's recommended that it's passed as an IO object (or a Junction of those) so we avoid silly things like slashes vs backslashes on different platforms.
 
+Default is `False`, which means that no files will be excluded.
+
 keep-going
 ----------
 
-Parameter `keep-going` tells `find()` to not stop finding files on errors such as 'Access is denied', but rather ignore the errors and keep going.
+Parameter `keep-going` tells `find()` to not stop finding files on errors such as 'Access is denied', but rather ignore the errors and keep going. Default is `False`
 
 recursive
 ---------
 
-By default, `find` will recursively traverse a directory tree, descending into any subdirectories it finds. This behaviour can be changed by setting `recursive` to a false value. In this case, only the first level entries will be processed.
+By default, `find` will recursively traverse a directory tree, descending into any subdirectories it finds. This behaviour can be changed by setting `recursive` to a false value. In this case, only the first level entries will be processed. Default is `True`.
+
+follow-symlinks
+---------------
+
+Parameter `follow-symlinks` tells `find()` whether or not it should follow symlinks during recursive searches. This will still return symlinks in its results, if the type parameter allows. The default is `True`.
 
 CAVEATS
 =======

doc/File-Find.rakudoc

@@ -57,18 +57,27 @@ found by File::Find. It's recommended that it's passed as an IO object
 (or a Junction of those) so we avoid silly things like slashes
 vs backslashes on different platforms.
 
+Default is C<False>, which means that no files will be excluded.
+
 =head2 keep-going
 
 Parameter C<keep-going> tells C<find()> to not stop finding files
 on errors such as 'Access is denied', but rather ignore the errors
-and keep going.
+and keep going.  Default is C<False>
 
 =head2 recursive
 
 By default, C<find> will recursively traverse a directory tree, descending
 into any subdirectories it finds. This behaviour can be changed by setting
 C<recursive> to a false value. In this case, only the first level entries
-will be processed.
+will be processed.  Default is C<True>.
+
+=head2 follow-symlinks
+
+Parameter C<follow-symlinks> tells C<find()> whether or not it should
+follow symlinks during recursive searches. This will still return
+symlinks in its results, if the type parameter allows.  The default
+is C<True>.
 
 =head1 CAVEATS
 

lib/File/Find.rakumod

@@ -24,9 +24,10 @@ my sub find(
        :$dir!,
   Mu   :$name,
        :$type,
-  Mu   :$exclude    = False,
-  Bool :$recursive  = True,
-  Bool :$keep-going = False
+  Mu   :$exclude         = False,
+  Bool :$recursive       = True,
+  Bool :$keep-going      = False,
+  Bool :$follow-symlinks = True
 ) is export {
 
     my @targets = dir($dir);
@@ -35,14 +36,19 @@ my sub find(
         # exclude is special because it also stops traversing inside,
         # which checkrules does not
         next if $elem ~~ $exclude;
+
         take $elem if checkrules($elem, { :$name, :$type, :$exclude });
+
         if $recursive {
-            if $elem.IO.d {
-                @targets.append: dir($elem);
-                CATCH {
-                    when X::IO::Dir {
-                        $_.throw unless $keep-going;
-                        next;
+            my $io := $elem.IO;
+            if $follow-symlinks || !$io.l {
+                if $io.d {
+                    @targets.append: dir($elem);
+                    CATCH {
+                        when X::IO::Dir {
+                            .rethrow unless $keep-going;
+                            next;
+                        }
                     }
                 }
             }
@@ -52,6 +58,6 @@ my sub find(
 
 #- hack ------------------------------------------------------------------------
 # To allow version fetching in test files
-unit module File::Find:ver<0.2.0>:auth<zef:raku-community-modules>;
+unit module File::Find:ver<0.2.1>:auth<zef:raku-community-modules>;
 
 # vim: expandtab shiftwidth=4

t/01-file-find.rakutest

@@ -1,7 +1,7 @@
 use Test;
 use File::Find;
 
-plan 25;
+plan 29;
 
 my $res = find(:dir<t/dir1>);
 my @test = $res.map({ .Str }).sort;
@@ -70,6 +70,15 @@ dies-ok { find(:dir<t/dir1>, :type<foo>) }, "dies on incorrect type";
 my $skip-first = True;
 my $throw = True;
 
+#follow-symlinks
+$res = find(:dir<t/dir2>);
+@test = $res.map({ .Str }).sort;
+equals @test, <t/dir2/file.foo t/dir2/symdir t/dir2/symdir/empty_file t/dir2/symdir/file.bar>, 'follow-syminks is True';
+
+$res = find(:dir<t/dir2>, follow-symlinks => False);
+@test = $res.map({ .Str }).sort;
+equals @test, <t/dir2/file.foo t/dir2/symdir>, 'follow-symlinks is False';
+
 # Wrap dir to throw when we want it to.
 my $w = &dir.wrap(sub ($_) {
     if $skip-first {

t/dir2/file.foo

@@ -0,0 +1 @@
+../dir1/another_dir