dependency and segment improvements

- added possibility to exclude directories from dependency scanning
- added more flexibility to control max number of files per segment

lib/GPH/PHPStan/Cache.pm

@@ -3,6 +3,8 @@ package GPH::PHPStan::Cache;
 use strict;
 use warnings FATAL => 'all';
 
+use Cwd;
+
 sub new {
     my ($class, %args) = @_;
 
@@ -26,7 +28,7 @@ sub parseResultCache {
 
     (exists($args{path})) or die "$!";
 
-    open $fh, '<', $args{path} or die "unable to open cache file: $!";
+    open $fh, '<', getcwd() . '/' . $args{path} or die "unable to open cache file: $!";
 
 
     while ($line = <$fh>) {
@@ -119,7 +121,7 @@ the C<new> method creates a new GPH::PHPUnit::Config. it takes a hash of options
 
 =item path B<(required)>
 
-path to the C<resultCache.php> file
+path to the C<resultCache.php> file relative to the script execution path.
 
 =item depth
 

lib/GPH/Util/Files.pm

@@ -25,16 +25,17 @@ sub segment {
         push(@{$result{$group}}, $path);
     }
 
-    return(%result) unless defined $args{max};
+    return(%result) unless exists($args{max}) or exists($args{segment_max});
 
     foreach $key (keys %result) {
+        my $max = $args{segment_max}{$key} || $args{max} || 1000;
         $size = scalar(@{$result{$key}});
-        next unless $size > $args{max};
+        next unless $size > $max;
 
         my $index = 1;
 
-        while (scalar(@{$result{$key}}) > $args{max}) {
-            my @segment = splice @{$result{$key}}, 0, $args{max};
+        while (scalar(@{$result{$key}}) > $max) {
+            my @segment = splice @{$result{$key}}, 0, $max;
             $result{$key . '.' . $index} = \@segment;
             $index++;
         }
@@ -85,6 +86,10 @@ the path depth from which to create the segments. defaults to 1.
 
 the maximum number of files per segment.
 
+=item segment_max
+
+a hash defining the max number of files per segment name (e.g. C<< segment_max => {'tests.Unit' => 1000} >>)
+
 =back
 
 =back

lib/GPH/Util/PhpDependencyParser.pm

@@ -19,15 +19,29 @@ sub new {
 }
 
 sub dir {
-    my ($self, $dir, $strip) = @_;
+    my ($self, %args) = @_;
 
-    my @files = File::Find::Rule->file()
-        ->name('*.php')
-        ->in($dir)
-    ;
+    (exists($args{directories}) && exists($args{strip})) or die "$!";
+
+    my $rule = File::Find::Rule->new;
+
+    if (exists($args{excludes})) {
+        $rule->or(
+            $rule->new->exec(sub {
+                my ($shortname, $path, $fullname) = @_;
+                foreach my $exclude (@{$args{excludes}}) {
+                    return 1 if $fullname =~ $exclude;
+                }
+                return 0;
+            })->prune->discard,
+            $rule->new
+        );
+    }
+
+    my @files = $rule->name('*.php')->in(@{$args{directories}});
 
     foreach my $file (@files) {
-        $self->parse($file, $strip);
+        $self->parse($file, $args{strip});
     }
 
     return ($self);
@@ -226,10 +240,26 @@ GPH::Util::PhpDependencyParser - parses one or more php files and builds a depen
 
 the C<new> method creates a new GPH::Util::PhpDependencyParser.
 
-=item C<< -E<gt>dir($directory, $strip) >>
+=item C<< -E<gt>dir(%args) >>
 
-scans and builds a dependency map from all php files in C< $directory >. the resulting paths will be stripped of the
-prefix defined in C<$strip>
+scans and builds a dependency map from all php files in defined directories. the resulting paths will be stripped of the
+prefix if defined in the C<$strip> argument. the dir method takes a hash of options, valid option keys include:
+
+=over
+
+=item directories B<(required)>
+
+an array of directory paths (relative to script execution) to scan
+
+=item strip B<(required)>
+
+the prefix to strip from the paths
+
+=item excludes
+
+an array of directory paths (relative to script execution) to exclude from the scan
+
+=back
 
 =item C<< -E<gt>parse($filepath, $strip) >>
 

t/unit/GPH/Util/Files.t

@@ -132,6 +132,68 @@ describe "class `$CLASS` segment method" => sub {
             'object as expected'
         ) or diag Dumper(%segments);
     };
+
+    tests 'segment with depth 2 and max 1 and segment max' => sub {
+        my ($object, $exception, $warnings, %segments);
+
+        $exception = dies {
+            $warnings = warns {
+                $object = $CLASS->new();
+                %segments = $object->segment((paths => @files, depth => 2, max => 1, segment_max => {'tests.Functional' => 2}));
+            };
+        };
+
+        is($exception, undef, 'no exception thrown');
+        is($warnings, 0, 'no warnings generated');
+
+        is(
+            \%segments,
+            hash {
+                field "tests.Unit" => array {
+                    item 'tests/Unit/Parser/MapperTest.php';
+                    end;
+                };
+                field "tests.Functional" => array {
+                    item 'tests/Functional/Parser/MapperTest.php';
+                    item 'tests/Functional/Parser/MapperTestCase.php';
+                    end;
+                };
+                end;
+            },
+                'object as expected'
+        ) or diag Dumper(%segments);
+    };
+
+    tests 'segment with depth 2, without max and segment max' => sub {
+        my ($object, $exception, $warnings, %segments);
+
+        $exception = dies {
+            $warnings = warns {
+                $object = $CLASS->new();
+                %segments = $object->segment((paths => @files, depth => 2, segment_max => {'tests.Unit' => 1}));
+            };
+        };
+
+        is($exception, undef, 'no exception thrown');
+        is($warnings, 0, 'no warnings generated');
+
+        is(
+            \%segments,
+            hash {
+                field "tests.Unit" => array {
+                    item 'tests/Unit/Parser/MapperTest.php';
+                    end;
+                };
+                field "tests.Functional" => array {
+                    item 'tests/Functional/Parser/MapperTest.php';
+                    item 'tests/Functional/Parser/MapperTestCase.php';
+                    end;
+                };
+                end;
+            },
+                'object as expected'
+        ) or diag Dumper(%segments);
+    };
 };
 
 done_testing();