Merge pull request #1 from phpactor/multiple-segments

Multiple segments

Author: dantleech

.travis.yml

@@ -1,8 +1,6 @@
 language: php
 
 php:
-    - 7.1
-    - 7.2
     - 7.3
     - 7.4
 

README.md

@@ -3,18 +3,24 @@ Path Finder
 
 [![Build Status](https://travis-ci.org/phpactor/path-finder.svg?branch=master)](https://travis-ci.org/phpactor/path-finder)
 
-Library to infer paths from a given path where paths share the same "kernel"
-(common section of the path).
+Library to infer paths from a given path where paths share path segments.
 
-For example, infer unit test path from the source file, from a unit test to
-a bechmark, from the benchmark to the source file etc.
+For example, infer test paths for a given source file and vice-versa.
 
 Usage
 -----
 
 Path finder accepts a hash map of destinations and their schemas. The
-"kernel" is a place holder for the common path segment that all destinations
-share:
+placeholders can be used to identify common parts of the path.
+
+- The last placeholder is _greedy_ it will match all path segments until the
+  suffix.
+- Preceding placeholders will only match until the first path separator.
+
+Examples
+--------
+
+### Navigating between test files
 
 ```php
 $pathFinder = PathFinder::fromDestinations([
@@ -25,9 +31,25 @@ $pathFinder = PathFinder::fromDestinations([
 
 $targets = $pathFinder->targetsFor('lib/Acme/Post.php');
 
-var_dump($targets);
 // [
 //    'unit_test' => 'tests/Unit/Acme/PostTest.php',
 //    'benchmark' => 'benchmarks/Acme/PostBench.php',
 // ]
 ```
+
+### Navigating between files organized by domain/module
+
+```php
+$pathFinder = PathFinder::fromDestinations([
+    'source' => 'lib/<module>/<kernel>.php',
+    'unit_test' => 'tests/<module>/Unit/<kernel>Test.php',
+    'benchmark' => 'benchmarks/<module>/<kernel>Bench.php',
+]);
+
+$targets = $pathFinder->targetsFor('lib/MyModule/Acme/Post.php');
+
+// [
+//    'unit_test' => 'tests/MyModule/Unit/Acme/PostTest.php',
+//    'benchmark' => 'benchmarks/MyModule/Acme/PostBench.php',
+// ]
+```

composer.json

@@ -12,9 +12,10 @@
         "webmozart/path-util": "^2.3"
     },
     "require-dev": {
-        "phpunit/phpunit": "~7.0",
-        "phpstan/phpstan": "~0.11.0",
-        "friendsofphp/php-cs-fixer": "~2.15.0"
+        "php": "^7.3",
+        "phpunit/phpunit": "^9.0",
+        "phpstan/phpstan": "^0.12.0",
+        "friendsofphp/php-cs-fixer": "^2.15.0"
     },
     "autoload": {
         "psr-4": {
@@ -26,9 +27,16 @@
             "Phpactor\\ClassFileConverter\\Tests\\": "tests/"
         }
     },
+    "scripts": {
+        "integrate": [
+            "./vendor/bin/phpunit",
+            "./vendor/bin/phpstan analyze",
+            "./vendor/bin/php-cs-fixer fix"
+        ]
+    },
     "extra": {
         "branch-alias": {
             "dev-master": "1.0-dev"
         }
     }
-}
+}

lib/Exception/NoPlaceHoldersException.php

@@ -0,0 +1,9 @@
+<?php
+
+namespace Phpactor\ClassFileConverter\Exception;
+
+use RuntimeException;
+
+class NoPlaceHoldersException extends RuntimeException
+{
+}

lib/PathFinder.php

@@ -4,117 +4,72 @@
 
 use Phpactor\ClassFileConverter\Exception\NoMatchingSourceException;
 use Webmozart\PathUtil\Path;
-use RuntimeException;
 
 class PathFinder
 {
-    const KERNEL = '<kernel>';
-
     /**
-     * @var array
+     * @var array<string,Pattern>
      */
     private $destinations = [];
 
+    /**
+     * @param array<string, Pattern> $destinations
+     */
     private function __construct(array $destinations)
     {
-        $this->validateTargets($destinations);
-
-        foreach ($destinations as $destinationName => $pattern) {
-            $this->add($destinationName, $pattern);
-        }
+        $this->destinations = $destinations;
     }
 
+    /**
+     * @param array<string, string> $destinations
+     */
     public static function fromDestinations(array $destinations): PathFinder
     {
-        return new self($destinations);
+        return new self(array_map(function (string $pattern) {
+            return Pattern::fromPattern($pattern);
+        }, $destinations));
     }
 
     /**
      * Return a hash map of destination names to paths representing
      * paths which relate to the given file path.
      *
      * @throws NoMatchingSourceException
+     * @return array<string,string>
      */
     public function destinationsFor(string $filePath): array
     {
-        $filePath = Path::canonicalize($filePath);
-        $source = $this->matchingSource($filePath);
-
-        return $this->resolveDestinations($filePath, $source);
-    }
+        $destinations = [];
+        $sourcePattern = $this->findSourcePattern($filePath);
 
-    private function matchingSource($filePath)
-    {
-        foreach ($this->destinations as $targetName => $pattern) {
-            if ($this->matches($filePath, $pattern)) {
-                return $targetName;
-            }
-        }
-
-        throw new NoMatchingSourceException(sprintf(
-            'Could not find a matching pattern for path "%s", known patterns: "%s"',
-            $filePath,
-            implode('", "', $this->destinations)
-        ));
-    }
-
-    private function matches(string $filePath, $pattern)
-    {
-        $pattern = $this->pattern($pattern);
-
-        return (bool) $this->matchPattern($filePath, $pattern);
-    }
-
-    private function resolveDestinations(string $filePath, $target)
-    {
-        $resolved = [];
-
-        foreach ($this->destinations as $targetName => $targetPattern) {
-            if ($target === $targetName) {
+        foreach ($this->destinations as $name => $pattern) {
+            assert($pattern instanceof Pattern);
+            if ($pattern === $sourcePattern) {
                 continue;
             }
 
-            $sourcePattern = $this->pattern($this->destinations[$target]);
-            $kernel = $this->matchPattern($filePath, $sourcePattern);
-
-            $resolved[$targetName] = str_replace(self::KERNEL, $kernel, $targetPattern);
-        }
-
-        return $resolved;
-    }
-
-    private function pattern(string $pattern): string
-    {
-        $pattern = preg_quote($pattern);
-
-        return str_replace(preg_quote(self::KERNEL), '(.*?)', $pattern);
-    }
-
-    private function matchPattern(string $filePath, string $pattern)
-    {
-        if (preg_match('{' . $pattern . '$}', $filePath, $matches)) {
-            return $matches[1];
+            $tokens = $sourcePattern->tokens($filePath);
+            $destinations[$name] = $pattern->replaceTokens($tokens);
         }
 
-        return;
+        return $destinations;
     }
 
-    private function validateTargets(array $destinations)
+    private function findSourcePattern(string $filePath): Pattern
     {
-        foreach ($destinations as $destination) {
-            if (strpos($destination, self::KERNEL)) {
-                continue;
+        foreach ($this->destinations as $name => $pattern) {
+            assert($pattern instanceof Pattern);
+            if ($pattern->fits($filePath)) {
+                return $pattern;
             }
-
-            throw new RuntimeException(sprintf(
-                'Destination "%s" contains no <kernel> placeholder',
-                $destination
-            ));
         }
-    }
 
-    private function add(string $destinationName, string $pattern)
-    {
-        $this->destinations[$destinationName] = $pattern;
+        throw new NoMatchingSourceException(sprintf(
+            'Could not find matching source pattern for "%s", known patterns: "%s"',
+            $filePath,
+            implode('", "', array_map(function (Pattern $pattern) {
+                return $pattern->toString();
+            }, $this->destinations))
+        ));
     }
 }

lib/Pattern.php

@@ -0,0 +1,112 @@
+<?php
+
+namespace Phpactor\ClassFileConverter;
+
+use Phpactor\ClassFileConverter\Exception\NoPlaceHoldersException;
+use RuntimeException;
+use Webmozart\PathUtil\Path;
+
+class Pattern
+{
+    const TOKEN_REGEX = '{<([a-z-]+?)>}';
+
+    /**
+     * @var string
+     */
+    private $regex;
+
+    /**
+     * @var array<string>
+     */
+    private $tokenNames;
+
+    /**
+     * @var string
+     */
+    private $pattern;
+
+    /**
+     * @param array<string> $tokenNames
+     */
+    public function __construct(string $regex, string $pattern, array $tokenNames)
+    {
+        $this->regex = $regex;
+        $this->tokenNames = $tokenNames;
+        $this->pattern = $pattern;
+    }
+
+    public static function fromPattern(string $pattern): self
+    {
+        preg_match_all(self::TOKEN_REGEX, $pattern, $matches);
+
+        [$tokens, $tokenNames] = $matches;
+
+        $regex = $pattern;
+        foreach (array_values($matches[0]) as $index => $token) {
+            $greedy = $index + 1 !== count($tokenNames);
+            $regex = strtr($regex, [$token => sprintf('(?%s%s+)', $token, $greedy ? '[^/]' : '.')]);
+        }
+
+        if (empty($tokenNames)) {
+            throw new NoPlaceHoldersException(sprintf(
+                'File pattern "%s" does not contain any <placeholders>',
+                $pattern
+            ));
+        }
+
+        return new self(sprintf('{%s$}', $regex), $pattern, $tokenNames);
+    }
+
+    public function fits(string $filePath): bool
+    {
+        return (bool)preg_match($this->regex, Path::canonicalize($filePath));
+    }
+
+    /**
+     * @return array<string, string>
+     */
+    public function tokens(string $filePath): array
+    {
+        $filePath = Path::canonicalize($filePath);
+
+        if (!preg_match($this->regex, $filePath, $matches)) {
+            throw new RuntimeException(sprintf(
+                'Error occurred performing regex on filepath "%s" with regex "%s"',
+                $filePath,
+                $this->regex
+            ));
+        }
+
+        return array_intersect_key($matches, (array)array_combine($this->tokenNames, $this->tokenNames));
+    }
+
+    /**
+     * @param array<string,string> $tokens
+     */
+    public function replaceTokens(array $tokens): string
+    {
+        return $this->cleanRemainingTokens($this->replaceTokensWithValues($tokens));
+    }
+
+    public function toString(): string
+    {
+        return $this->pattern;
+    }
+
+    /**
+     * @param array<string,string> $tokens
+     */
+    private function replaceTokensWithValues(array $tokens): string
+    {
+        return strtr($this->pattern, (array)array_combine(array_map(function (string $key) {
+            return '<' . $key . '>';
+        }, array_keys($tokens)), array_values($tokens)));
+    }
+
+    private function cleanRemainingTokens(string $filePath): string
+    {
+        return strtr($filePath, (array)array_combine(array_map(function (string $tokenName) {
+            return '<' . $tokenName . '>';
+        }, $this->tokenNames), array_fill(0, count($this->tokenNames), '')));
+    }
+}

phpstan.neon

@@ -1,7 +1,5 @@
-includes:
-    - vendor/phpstan/phpstan/conf/config.level7.neon
-
 parameters:
+    level: 7
     inferPrivatePropertyTypeFromConstructor: true
     ignoreErrors: