feat: ability generate withSchedule for boostrap/app.php file

README.md

@@ -76,6 +76,27 @@ render for the passed exception class.
 
 **Note** Need to provide the full exception class name (FQCN) to the method, it automatically imports it.
 
+#### addScheduleCommand
+
+Adds a scheduled command into the `withSchedule` method closure.
+If `withSchedule` does not exist, it will be automatically created. The new scheduled command will then be inserted into its closure.
+Automatically adds `use Illuminate\Support\Facades\Schedule;` to the file imports.
+
+Example usage:
+
+```php
+new AppBootstrapBuilder()
+    ->addScheduleCommand(
+        'command', 
+        new ScheduleOptionDTO('environments', ['production']),
+        new ScheduleOptionDTO('daily'),
+        new ScheduleOptionDTO(
+            method: 'timezone',
+            attributes: ['America/New_York'],
+        ),
+    )
+    ->save();
+```
 ## Contributing
 
 Thank you for considering contributing to Laravel Builder package! The contribution guide

src/Builders/AppBootstrapBuilder.php

@@ -2,7 +2,9 @@
 
 namespace RonasIT\Larabuilder\Builders;
 
+use RonasIT\Larabuilder\ValueOptions\ScheduleOption;
 use RonasIT\Larabuilder\Visitors\AppBootstrapVisitors\AddExceptionsRender;
+use RonasIT\Larabuilder\Visitors\AppBootstrapVisitors\AddScheduleCommand;
 
 class AppBootstrapBuilder extends PHPFileBuilder
 {
@@ -15,7 +17,7 @@ public function addExceptionsRender(string $exceptionClass, string $renderBody,
     {
         $this->traverser->addVisitor(new AddExceptionsRender($exceptionClass, $renderBody, $includeRequestArg));
 
-        $imports = [$exceptionClass];
+        $imports = ['Illuminate\Foundation\Configuration\Exceptions', $exceptionClass];
 
         if ($includeRequestArg) {
             $imports[] = 'Illuminate\Http\Request';
@@ -25,4 +27,15 @@ public function addExceptionsRender(string $exceptionClass, string $renderBody,
 
         return $this;
     }
+
+    public function addScheduleCommand(string $command, ScheduleOption ...$options): self
+    {
+        $this->traverser->addVisitor(new AddScheduleCommand($command, ...$options));
+
+        $this->addImports([
+            'Illuminate\Support\Facades\Schedule',
+        ]);
+
+        return $this;
+    }
 }

src/Printer.php

@@ -4,6 +4,7 @@
 
 use PhpParser\Node;
 use PhpParser\Node\Expr\Array_;
+use PhpParser\Node\Expr\MethodCall;
 use PhpParser\Node\PropertyItem;
 use PhpParser\Node\Stmt\ClassMethod;
 use PhpParser\Node\Stmt\Expression;
@@ -122,4 +123,19 @@ protected function preparePreformattedCode(string $value): string
 
         return rtrim($value);
     }
+
+    protected function pExpr_MethodCall(MethodCall $node): string
+    {
+        if ($node->getAttribute('wasCreated')) {
+            $this->indent();
+
+            $newCall = $this->nl . '->' . $this->pObjectProperty($node->name) . '(' . $this->pMaybeMultiline($node->args) . ')';
+
+            $this->outdent();
+
+            return $this->pDereferenceLhs($node->var) . $newCall;
+        }
+
+        return parent::pExpr_MethodCall($node);
+    }
 }

src/ValueOptions/ScheduleOption.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace RonasIT\Larabuilder\ValueOptions;
+
+use Illuminate\Console\Scheduling\Event;
+use Illuminate\Console\Scheduling\ManagesAttributes;
+use Illuminate\Console\Scheduling\ManagesFrequencies;
+use InvalidArgumentException;
+use ReflectionClass;
+use ReflectionMethod;
+
+readonly class ScheduleOption
+{
+    public function __construct(
+        public string $method,
+        public array $arguments = [],
+    ) {
+        $this->validateMethod($this->method);
+    }
+
+    private function validateMethod(string $method): void
+    {
+        $methods = array_merge(
+            $this->getMethods(ManagesAttributes::class),
+            $this->getMethods(ManagesFrequencies::class),
+            $this->getMethods(Event::class),
+        );
+
+        if (!in_array($method, $methods, true)) {
+            $methods = implode("\n", $methods);
+
+            throw new InvalidArgumentException("Unknown schedule method `{$method}`.\nAllowed methods:\n{$methods}");
+        }
+    }
+
+    private function getMethods(string $class): array
+    {
+        $schedulePublicMethods = new ReflectionClass($class)->getMethods(ReflectionMethod::IS_PUBLIC);
+
+        return array_map(fn (ReflectionMethod $method) => $method->getName(), $schedulePublicMethods);
+    }
+}

src/Visitors/AppBootstrapVisitors/AbstractAppBootstrapVisitor.php

@@ -3,43 +3,71 @@
 namespace RonasIT\Larabuilder\Visitors\AppBootstrapVisitors;
 
 use PhpParser\Node;
+use PhpParser\Node\Arg;
+use PhpParser\Node\Expr\Closure;
 use PhpParser\Node\Expr\MethodCall;
+use PhpParser\Node\Identifier;
 use PhpParser\Node\Stmt\Class_;
 use PhpParser\Node\Stmt\Enum_;
 use PhpParser\Node\Stmt\Expression;
 use PhpParser\Node\Stmt\Interface_;
+use PhpParser\Node\Stmt\Nop;
 use PhpParser\Node\Stmt\Trait_;
 use PhpParser\NodeVisitorAbstract;
 use RonasIT\Larabuilder\Exceptions\InvalidBootstrapAppFileException;
 
 abstract class AbstractAppBootstrapVisitor extends NodeVisitorAbstract
 {
-    protected const FORBIDDEN_NODES = [
+    protected const array FORBIDDEN_NODES = [
         Class_::class,
         Trait_::class,
         Interface_::class,
         Enum_::class,
     ];
 
-    abstract protected function insertNode(MethodCall $node): MethodCall;
+    protected static array $existingParentNodes = [];
+
+    abstract protected function getInsertableNode(): Expression;
 
     public function __construct(
         protected string $parentMethod,
         protected string $targetMethod,
+        protected array $closureParams = [],
     ) {
     }
 
+    public function afterTraverse(array $nodes): ?array
+    {
+        static::$existingParentNodes = [];
+
+        return null;
+    }
+
     public function enterNode(Node $node): void
     {
-        $isBootstrapAppFile = array_any(self::FORBIDDEN_NODES, fn ($type) => $node instanceof $type);
+        $isNotBootstrapAppFile = array_any(self::FORBIDDEN_NODES, fn ($type) => $node instanceof $type);
 
-        if ($isBootstrapAppFile) {
+        if ($isNotBootstrapAppFile) {
             throw new InvalidBootstrapAppFileException(class_basename($node));
         }
+
+        if ($node instanceof MethodCall && $node->name->toString() === $this->parentMethod) {
+            static::$existingParentNodes[] = $this->parentMethod;
+        }
     }
 
     public function leaveNode(Node $node): Node
     {
+        if ($node instanceof MethodCall && $node->name->toString() === 'create') {
+            if (!in_array($this->parentMethod, static::$existingParentNodes)) {
+                $node = $this->insertParentNode($node);
+            }
+
+            if ($node->var->getAttribute('wasCreated')) {
+                $node->var = $this->handleParentNode($node->var);
+            }
+        }
+
         if (!$node instanceof MethodCall) {
             return $node;
         }
@@ -51,6 +79,30 @@ public function leaveNode(Node $node): Node
         return $node;
     }
 
+    protected function insertParentNode(Node $node): Node
+    {
+        static::$existingParentNodes[] = $this->parentMethod;
+
+        $closure = new Closure([
+            'params' => $this->closureParams,
+            'returnType' => new Identifier('void'),
+        ]);
+
+        $parentCall = new MethodCall($node->var, new Identifier($this->parentMethod), [new Arg($closure)]);
+        $parentCall->setAttribute('wasCreated', true);
+
+        return new MethodCall($parentCall, new Identifier('create'));
+    }
+
+    protected function handleParentNode(MethodCall $node): Node
+    {
+        if ($this->isParentNode($node) && $this->shouldInsertNode($node)) {
+            return $this->insertNode($node);
+        }
+
+        return $node;
+    }
+
     protected function isParentNode(Node $node): bool
     {
         return $node instanceof MethodCall && $node->name->toString() === $this->parentMethod;
@@ -75,6 +127,26 @@ protected function shouldInsertNode(MethodCall $node): bool
         return true;
     }
 
+    protected function insertNode(MethodCall $node): MethodCall
+    {
+        $currentStatements = $node->args[0]->value->stmts;
+        $statement = $this->getInsertableNode();
+
+        if (count($currentStatements) === 1 && $currentStatements[0] instanceof Nop) {
+            $node->args[0]->value->stmts = [$statement];
+
+            return $node;
+        }
+
+        $lastExistingStatement = end($currentStatements);
+
+        $statement->setAttribute('previous', $lastExistingStatement);
+
+        $node->args[0]->value->stmts[] = $statement;
+
+        return $node;
+    }
+
     protected function matchesCustomCriteria(Expression $statement): bool
     {
         return false;

src/Visitors/AppBootstrapVisitors/AddExceptionsRender.php

@@ -28,22 +28,15 @@ public function __construct(
         parent::__construct(
             parentMethod: 'withExceptions',
             targetMethod: 'render',
+            closureParams: [
+                new Param(
+                    var: new Variable('exceptions'),
+                    type: new Name('Exceptions'),
+                ),
+            ],
         );
     }
 
-    protected function matchesCustomCriteria(Expression $stmt): bool
-    {
-        $paramType = $stmt->expr->args[0]?->value?->params[0]?->type ?? null;
-
-        if (!($paramType instanceof Name)) {
-            return false;
-        }
-
-        $typeName = $paramType->toString();
-
-        return $typeName === $this->exceptionClass || $typeName === class_basename($this->exceptionClass);
-    }
-
     protected function insertNode(MethodCall $node): MethodCall
     {
         $currentStatements = $node->args[0]->value->stmts;
@@ -97,4 +90,22 @@ protected function buildClosure(): Closure
             'stmts' => [new PreformattedCode($this->renderBody)],
         ]);
     }
+
+    protected function matchesCustomCriteria(Expression $stmt): bool
+    {
+        $paramType = $stmt->expr->args[0]?->value?->params[0]?->type ?? null;
+
+        if (!($paramType instanceof Name)) {
+            return false;
+        }
+
+        $typeName = $paramType->toString();
+
+        return $typeName === $this->exceptionClass || $typeName === class_basename($this->exceptionClass);
+    }
+
+    protected function getInsertableNode(): Expression
+    {
+        return $this->renderStatement;
+    }
 }

src/Visitors/AppBootstrapVisitors/AddScheduleCommand.php

@@ -0,0 +1,60 @@
+<?php
+
+namespace RonasIT\Larabuilder\Visitors\AppBootstrapVisitors;
+
+use PhpParser\Node\Arg;
+use PhpParser\Node\Expr\MethodCall;
+use PhpParser\Node\Expr\StaticCall;
+use PhpParser\Node\Identifier;
+use PhpParser\Node\Name;
+use PhpParser\Node\Stmt\Expression;
+use RonasIT\Larabuilder\Support\NodeValueFactory;
+use RonasIT\Larabuilder\ValueOptions\ScheduleOption;
+
+class AddScheduleCommand extends AbstractAppBootstrapVisitor
+{
+    protected Expression $scheduleStatement;
+    protected array $options = [];
+
+    public function __construct(
+        protected string $command,
+        ScheduleOption ...$options,
+    ) {
+        $this->options = $options;
+
+        $this->scheduleStatement = $this->buildScheduleCall();
+
+        parent::__construct(
+            parentMethod: 'withSchedule',
+            targetMethod: 'command',
+        );
+    }
+
+    protected function buildScheduleCall(): Expression
+    {
+        $call = new StaticCall(
+            class: new Name('Schedule'),
+            name: new Identifier('command'),
+            args: [
+                new Arg(NodeValueFactory::make($this->command)->node),
+            ],
+        );
+
+        foreach ($this->options as $option) {
+            $arguments = array_map(fn ($argument) => new Arg(NodeValueFactory::make($argument)->node), $option->arguments);
+
+            $call = new MethodCall(
+                var: $call,
+                name: new Identifier($option->method),
+                args: $arguments,
+            );
+        }
+
+        return new Expression($call);
+    }
+
+    protected function getInsertableNode(): Expression
+    {
+        return $this->scheduleStatement;
+    }
+}