@flarum/cli 2.0.0-beta.9 → 3.0.0

package/php-subsystem/src/CustomPrettyPrinter.php

@@ -10,7 +10,7 @@ class CustomPrettyPrinter extends Standard
     /**
      * @todo this is just a temporary solution, we should look into formatters such as php cs fixer
      */
-    protected function pExpr_MethodCall(Expr\MethodCall $node) {
+    protected function pExpr_MethodCall(Expr\MethodCall $node): string {
         return $this->pDereferenceLhs($node->var) . "\n        ->" . $this->pObjectProperty($node->name)
              . '(' . $this->pMaybeMultiline($node->args) . ')';
     }

package/php-subsystem/src/ExtenderUtil.php

@@ -2,12 +2,11 @@
 
 namespace Flarum\CliPhpSubsystem;
 
-use Flarum\CliPhpSubsystem\CustomPrettyPrinter;
-use PhpParser\Lexer;
 use PhpParser\NodeTraverser;
 use PhpParser\NodeVisitor;
 use PhpParser\NodeVisitor\NameResolver;
 use PhpParser\Parser;
+use PhpParser\ParserFactory;
 use PhpParser\PrettyPrinter;
 
 class ExtenderUtil
@@ -50,9 +49,11 @@ class ExtenderUtil
     $this->traverser->addVisitor($this->nameResolver);
   }
 
-  public function add($params)
+  public function add($params): array
   {
-    return $this->run(new NodeVisitors\AddExtender($params, $this->nameResolver->getNameContext()));
+    return [
+        'code' => $this->run(new NodeVisitors\AddExtender($params, $this->nameResolver->getNameContext())),
+    ];
   }
 
   protected function run(NodeVisitor $visitor)
@@ -67,20 +68,13 @@ class ExtenderUtil
   }
 
   protected function backupOriginal($originalCode) {
-    $lexer = new Lexer\Emulative([
-      'usedAttributes' => [
-        'comments',
-        'startLine', 'endLine',
-        'startTokenPos', 'endTokenPos',
-      ],
-    ]);
-    $parser = new Parser\Php7($lexer);
+    $parser = (new ParserFactory())->createForHostVersion();
 
     $traverser = new NodeTraverser();
     $traverser->addVisitor(new NodeVisitor\CloningVisitor());
 
     $oldAst = $parser->parse($originalCode);
-    $oldTokens = $lexer->getTokens();
+    $oldTokens = $parser->getTokens();
 
     $ast = $traverser->traverse($oldAst);
 

package/php-subsystem/src/NodeUtil.php

@@ -0,0 +1,72 @@
+<?php
+
+namespace Flarum\CliPhpSubsystem;
+
+use PhpParser\Node;
+use PhpParser\Node\Identifier;
+use PhpParser\Node\Name;
+use PhpParser\Node\NullableType;
+use PhpParser\Node\UnionType;
+
+class NodeUtil
+{
+    public static function makeType(array $types): ?Node
+    {
+        $realTypes = array_map(function ($type) {
+            if (strpos($type, '\\') !== false || preg_match('/[A-Z]/', $type[0])) {
+                return new Name($type, [
+                    'resolvedName' => new Name($type)
+                ]);
+            }
+
+            return new Identifier($type);
+        }, array_filter($types, function ($type) {
+            return $type !== 'null';
+        }));
+
+        $returnType = null;
+
+        if (count($realTypes) > 1) {
+            $returnType = new UnionType($realTypes);
+        } elseif (! empty($realTypes[0])) {
+            $returnType = $realTypes[0];
+        }
+
+        if (in_array('null', $types)) {
+            $returnType = new NullableType($returnType);
+        }
+
+        return $returnType;
+    }
+
+    public static function addUsesToNamespace(Node\Stmt\Namespace_ $node, array $uses): void
+    {
+        $uses = array_map(function (string $fqn) {
+            return new \PhpParser\Node\Stmt\Use_([
+                new \PhpParser\Node\Stmt\UseUse(new Name($fqn))
+            ]);
+        }, array_filter($uses, function (string $fqn) use ($node) {
+            foreach ($node->stmts as $stmt) {
+                if ($stmt instanceof \PhpParser\Node\Stmt\Use_ && $stmt->uses[0]->name->toString() === $fqn) {
+                    return false;
+                }
+            }
+
+            return true;
+        }));
+
+        $lastUseStatement = null;
+
+        foreach ($node->stmts as $index => $stmt) {
+            if ($stmt instanceof \PhpParser\Node\Stmt\Use_) {
+                $lastUseStatement = $index;
+            } elseif (! is_null($lastUseStatement)) {
+                break;
+            }
+        }
+
+        if (! is_null($lastUseStatement)) {
+            array_splice($node->stmts, $lastUseStatement + 1, 0, $uses);
+        }
+    }
+}

package/php-subsystem/src/NodeVisitors/AddExtender.php

@@ -137,22 +137,36 @@ class AddExtender extends NodeVisitorAbstract
     return $option->isFullyQualified() ? $option->toCodeString() : $option->toString();
   }
 
-  protected function specToExpr(array $spec): Node\Expr {
-    switch ($spec['type']) {
-      case 'scalar':
-        $value = $spec['value'];
-        if (is_string($value)) {
+  protected function scalarToExpr($value): Node\Expr {
+      if (is_string($value)) {
           return new Node\Scalar\String_($value);
-        }
-        if (is_integer($value)) {
+      }
+
+      if (is_integer($value)) {
           return new Node\Scalar\LNumber($value, ['kind' => Node\Scalar\LNumber::KIND_DEC]);
-        }
-        if (is_float($value)) {
+      }
+
+      if (is_float($value)) {
           return new Node\Scalar\DNumber($value);
-        }
-        if (is_bool($value)) {
+      }
+
+      if (is_bool($value)) {
           return new Node\Scalar\LNumber($value, ['kind' => Node\Scalar\LNumber::KIND_BIN]);
-        }
+      }
+
+      if (is_array($value)) {
+          return new Node\Expr\Array_(
+              array_map([$this, 'scalarToExpr'], $value)
+          );
+      }
+
+    throw new \Exception("Unrecognized scalar type: " . gettype($value));
+  }
+
+  protected function specToExpr(array $spec): Node\Expr {
+    switch ($spec['type']) {
+      case 'scalar':
+        return $this->scalarToExpr($spec['value']);
       case 'class_const':
         return $this->nodeFactory->classConstFetch(
           $this->resolveName($spec['value']),
@@ -185,6 +199,8 @@ class AddExtender extends NodeVisitorAbstract
         }
 
         return $closure->getNode();
+      case 'raw':
+        return $spec['value'];
       default:
         $type = $spec['type'];
         throw new \Exception("Unrecognized type: $type");

package/php-subsystem/src/NodeVisitors/AddUses.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Flarum\CliPhpSubsystem\NodeVisitors;
+
+use Flarum\CliPhpSubsystem\NodeUtil;
+use PhpParser\Node;
+use PhpParser\NodeVisitorAbstract;
+
+class AddUses extends NodeVisitorAbstract
+{
+    private $uses;
+
+    public function __construct($replacements)
+    {
+        $this->uses = $replacements;
+    }
+
+    public function leaveNode(Node $node)
+    {
+        if ($node instanceof Node\Stmt\Namespace_) {
+            NodeUtil::addUsesToNamespace($node, $this->uses);
+        }
+    }
+}

package/php-subsystem/src/NodeVisitors/ChangeSignatures.php

@@ -0,0 +1,200 @@
+<?php
+
+namespace Flarum\CliPhpSubsystem\NodeVisitors;
+
+use Closure;
+use Flarum\CliPhpSubsystem\NodeUtil;
+use PhpParser\Node;
+use PhpParser\Node\Stmt\Class_;
+use PhpParser\NodeVisitorAbstract;
+
+class ChangeSignatures extends NodeVisitorAbstract
+{
+    protected $changes = [];
+    protected $custom = null;
+    protected $valid = false;
+    protected $uses = [];
+
+    public function __construct(array $changes, Closure $custom = null)
+    {
+        $this->changes = $changes;
+        $this->custom = $custom;
+    }
+
+    public function enterNode(Node $node)
+    {
+        if ($node instanceof Node\Stmt\Use_) {
+            foreach ($node->uses as $use) {
+                $this->uses[($use->alias ? $use->alias->name : null) ?? $use->name->getLast()] = $use->name->toString();
+            }
+        }
+
+        if (! $this->valid && $node instanceof Class_) {
+            $implements = array_map(function (Node\Name $interface) {
+                return $interface->getAttribute('resolvedName')->name;
+            }, $node->implements);
+
+            $extends = $node->extends ? $node->extends->getAttribute('resolvedName')->name : null;
+
+            if ($extends && isset($this->changes[$extends])) {
+                $this->valid = true;
+                return;
+            }
+
+            foreach ($implements as $interface) {
+                if (isset($this->changes[$interface])) {
+                    $this->valid = true;
+                    return;
+                }
+            }
+        }
+    }
+
+    public function leaveNode(\PhpParser\Node $node)
+    {
+        if (! $this->valid) {
+            return;
+        }
+
+        if ($node instanceof \PhpParser\Node\Stmt\ClassMethod) {
+            foreach ($this->changes as $methods) {
+                foreach ($methods as $method => $types) {
+                    // property not method.
+                    if (strpos($method, '$') === 0) {
+                        continue;
+                    }
+
+                    if ($method !== $node->name->name) {
+                        continue;
+                    }
+
+                    if ($returnType = NodeUtil::makeType($types['return'] ?? [])) {
+                        $node->returnType = $returnType;
+                    }
+
+                    $k = 0;
+                    foreach ($types['params'] ?? [] as $param => $paramTypes) {
+                        foreach ($node->params as $i => $paramNode) {
+                            if ($i === $k) {
+                                if ($paramType = NodeUtil::makeType($paramTypes)) {
+                                    if (! ($paramType instanceof Node\Name)
+                                        || ($paramType->getAttribute('resolvedName')
+                                            && $paramNode->type->getAttribute('resolvedName')
+                                            && ltrim($paramType->getAttribute('resolvedName')->name, '\\') !== ltrim($paramNode->type->getAttribute('resolvedName')->name, '\\')
+                                        )
+                                    ) {
+                                        $paramNode->type = $paramType;
+                                    }
+                                }
+
+                                if ($paramNode->var->name !== $param) {
+                                    $oldName = $paramNode->var->name;
+                                    $paramNode->var->name = $param;
+
+                                    // If the parameter name is changed, we need to update the parameter name inside the method.
+                                    $this->updateVariableName($node, $oldName, $param);
+                                }
+                            }
+                        }
+                        $k++;
+                    }
+
+                    if (isset($types['rename'])) {
+                        $node->name->name = $types['rename'];
+                    }
+
+                    if (! empty($types['visibility'])) {
+                        $node->flags = $types['visibility'];
+                    }
+                }
+            }
+        }
+
+        if ($node instanceof Node\Stmt\Property) {
+            foreach ($this->changes as $properties) {
+                foreach ($properties as $property => $changes) {
+                    if (strpos($property, '$') !== 0) {
+                        continue;
+                    }
+
+                    if ($property !== '$' . $node->props[0]->name->name) {
+                        continue;
+                    }
+
+                    if (! empty($changes['type']) && ($type = NodeUtil::makeType($changes['type']))) {
+                        $node->type = $type;
+                    }
+                }
+            }
+        }
+
+        $this->custom && ($this->custom)($node);
+    }
+
+    private function updateVariableName($node, string $oldName, string $newName): void
+    {
+        if (! $node instanceof Node) {
+            return;
+        }
+
+        if (($node instanceof Node\Expr\Variable || $node instanceof Node\Arg) && $node->name === $oldName) {
+            $node->name = $newName;
+        }
+
+        if ($node instanceof Node\Stmt\Function_ || $node instanceof Node\Stmt\ClassMethod) {
+            foreach ($node->params as $param) {
+                if ($param->var->name === $oldName) {
+                    $param->var->name = $newName;
+                }
+            }
+        }
+
+        if (property_exists($node, 'var') && $node->var) {
+            if ($node->var->name === $oldName) {
+                $node->var->name = $newName;
+            } else {
+                $this->updateVariableName($node->var, $oldName, $newName);
+            }
+        }
+
+        if (is_iterable($node)) {
+            foreach ($node as $child) {
+                $this->updateVariableName($child, $oldName, $newName);
+            }
+        }
+
+        if (property_exists($node, 'stmts') && $node->stmts) {
+            foreach ($node->stmts as $stmt) {
+                $this->updateVariableName($stmt, $oldName, $newName);
+            }
+        }
+
+        if (property_exists($node, 'expr') && $node->expr) {
+            $this->updateVariableName($node->expr, $oldName, $newName);
+        }
+
+        if (property_exists($node, 'items') && $node->items) {
+            foreach ($node->items as $item) {
+                $this->updateVariableName($item, $oldName, $newName);
+            }
+        }
+
+        if (property_exists($node, 'args') && $node->args) {
+            foreach ($node->args as $arg) {
+                $this->updateVariableName($arg, $oldName, $newName);
+            }
+        }
+
+        if (property_exists($node, 'cond') && $node->cond) {
+            $this->updateVariableName($node->cond, $oldName, $newName);
+        }
+
+        if (property_exists($node, 'stmt') && $node->stmt) {
+            $this->updateVariableName($node->stmt, $oldName, $newName);
+        }
+
+        if (property_exists($node, 'value') && $node->value) {
+            $this->updateVariableName($node->value, $oldName, $newName);
+        }
+    }
+}

package/php-subsystem/src/NodeVisitors/ReplaceUses.php

@@ -0,0 +1,175 @@
+<?php
+
+namespace Flarum\CliPhpSubsystem\NodeVisitors;
+
+use PhpParser\Node;
+use PhpParser\NodeAbstract;
+use PhpParser\NodeVisitor;
+use PhpParser\NodeVisitorAbstract;
+
+class ReplaceUses extends NodeVisitorAbstract
+{
+    private $replacements;
+
+    private $uses = [];
+
+    public function __construct($replacements)
+    {
+        $this->replacements = $replacements;
+    }
+
+    public function enterNode(Node $node)
+    {
+        if ($node instanceof \PhpParser\Node\Stmt\Namespace_) {
+            foreach ($node->stmts as $stmt) {
+                if ($stmt instanceof \PhpParser\Node\Stmt\Use_) {
+                    foreach ($stmt->uses as $use) {
+                        $this->uses[] = $use->name->name;
+                    }
+                }
+            }
+        }
+    }
+
+    public function leaveNode(\PhpParser\Node $node)
+    {
+        if ($node instanceof \PhpParser\Node\Stmt\Use_) {
+            foreach ($node->uses as $i => $use) {
+                foreach ($this->replacements as $replacement) {
+                    $wouldBecome = $this->replace($use->name->name, $replacement);
+
+                    if ($use->name->name !== $wouldBecome && in_array($wouldBecome, $this->uses)) {
+                        if (count($node->uses) === 1) {
+                            return NodeVisitor::REMOVE_NODE;
+                        } else {
+                            unset($node->uses[$i]);
+                        }
+                    } elseif (! in_array($wouldBecome, $this->uses)) {
+                        $use->name->name = $wouldBecome;
+                    }
+                }
+            }
+        }
+
+        if ($node instanceof \PhpParser\Node\Expr\New_) {
+            foreach ($this->replacements as $replacement) {
+                $node->class->name = $this->replace($node->class->name, $replacement);
+            }
+        }
+
+        if ($node instanceof \PhpParser\Node\Stmt\Class_) {
+            foreach ($this->replacements as $replacement) {
+                if ($node->extends) {
+                    $node->extends->name = $this->replace($node->extends->name, $replacement);
+                }
+            }
+        }
+
+        if ($node instanceof \PhpParser\Node\FunctionLike) {
+            $this->replaceOnType($node->getReturnType());
+
+            foreach ($node->getParams() as $param) {
+                $this->replaceOnType($param->type);
+            }
+        }
+
+        if ($node instanceof Node\Stmt\Property) {
+            $this->replaceOnType($node->type);
+        }
+
+        if ($node instanceof \PhpParser\Node\Expr\Instanceof_) {
+            foreach ($this->replacements as $replacement) {
+                $node->class->name = $this->replace($node->class->name, $replacement);
+            }
+        }
+
+        if ($node instanceof \PhpParser\Node\Expr\ClassConstFetch) {
+            foreach ($this->replacements as $replacement) {
+                if ($node->class instanceof \PhpParser\Node\Scalar\InterpolatedString ) {
+                    $node->class->parts[0] = $this->replace($node->class->parts[0], $replacement);
+                }
+            }
+        }
+
+        if ($node instanceof \PhpParser\Node\Expr\StaticCall) {
+            foreach ($this->replacements as $replacement) {
+                if ($node->class instanceof \PhpParser\Node\Scalar\InterpolatedString) {
+                    $node->class->parts[0] = $this->replace($node->class->parts[0], $replacement);
+                }
+            }
+        }
+
+        if ($node instanceof \PhpParser\Node\Expr\MethodCall) {
+            foreach ($this->replacements as $replacement) {
+                if ($node->var instanceof \PhpParser\Node\Expr\Variable) {
+                    $node->var->name = $this->replace($node->var->name, $replacement);
+                }
+            }
+        }
+
+        if ($node instanceof \PhpParser\Node\Expr\PropertyFetch) {
+            foreach ($this->replacements as $replacement) {
+                if ($node->var instanceof \PhpParser\Node\Expr\Variable) {
+                    $node->var->name = $this->replace($node->var->name, $replacement);
+                }
+            }
+        }
+
+        if ($node instanceof \PhpParser\Node\Expr\StaticPropertyFetch) {
+            foreach ($this->replacements as $replacement) {
+                if ($node->class instanceof \PhpParser\Node\Scalar\InterpolatedString) {
+                    $node->class->parts[0] = $this->replace($node->class->parts[0], $replacement);
+                }
+            }
+        }
+
+        return $node;
+    }
+
+    protected function replaceOnType(?NodeAbstract $type): void
+    {
+        if (! $type) {
+            return;
+        }
+
+        foreach ($this->replacements as $replacement) {
+            if ($type instanceof \PhpParser\Node\UnionType || $type instanceof \PhpParser\Node\IntersectionType) {
+                foreach ($type->types as $type) {
+                    $type->name = $this->replace($type->name, $replacement);
+                }
+            } elseif ($type instanceof \PhpParser\Node\NullableType) {
+                $type->type->name = $this->replace($type->type->name, $replacement);
+            } else {
+                $type->name = $this->replace($type->name, $replacement);
+            }
+        }
+    }
+
+    protected function replace(string $value, array $replacement): string
+    {
+        $from = $replacement['from'];
+        $to = $replacement['to'];
+        $partial = $replacement['partial'] ?? false;
+
+        if ($value === $from) {
+            return $to;
+        }
+
+        if ($partial && strpos($value, $from) !== false) {
+            $new = str_replace($from, $to, $value);
+
+            if (! in_array($new, $this->uses)) {
+                return $new;
+            }
+        }
+
+        $exploded = explode('\\', $from);
+
+        if ($value === array_pop($exploded)) {
+            $exploded = explode('\\', $to);
+            return array_pop($exploded);
+        }
+
+        return $value;
+    }
+}

package/php-subsystem/src/Upgrade/Replacement.php

@@ -0,0 +1,51 @@
+<?php
+
+namespace Flarum\CliPhpSubsystem\Upgrade;
+
+use PhpParser\NodeTraverser;
+use PhpParser\NodeVisitor\CloningVisitor;
+use PhpParser\ParserFactory;
+use PhpParser\PrettyPrinter;
+
+abstract class Replacement
+{
+    protected function operations(): array
+    {
+        return ['run'];
+    }
+
+    protected function run(string $file, string $code, array $ast, array $data): ?ReplacementResult {
+        return null;
+    }
+
+    public function handle(string $file, ?string $code, array $data = []): array
+    {
+        $parser = (new ParserFactory())->createForHostVersion();
+        $printer = new PrettyPrinter\Standard();
+
+        $code = $code ?: file_get_contents($file);
+
+        foreach ($this->operations() as $operation) {
+            $ast = $parser->parse($code);
+            $tokens = $parser->getTokens();
+
+            /** @var ReplacementResult $result */
+            $result = $this->$operation($file, $code, $ast, $data);
+
+            if ($result) {
+                $code = is_string($result->updated)
+                    ? $result->updated
+                    : $printer->printFormatPreserving($result->updated, $ast, $tokens);
+
+                $data = array_merge($data, $result->data);
+            }
+        }
+
+        return array_merge(compact('code'), $data);
+    }
+
+    protected function traverser(): NodeTraverser
+    {
+        return new NodeTraverser(new CloningVisitor());
+    }
+}

package/php-subsystem/src/Upgrade/ReplacementResult.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Flarum\CliPhpSubsystem\Upgrade;
+
+class ReplacementResult
+{
+    /** @var string|array */
+    public $updated;
+
+    public $data;
+
+    public function __construct($updated, $data = [])
+    {
+        $this->updated = $updated;
+        $this->data = $data;
+    }
+}