feat: Add method to manage withRouting options

README.md

@@ -102,11 +102,49 @@ 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();
+```
+
+#### addRoutingOption
+
+Adds or updates a named argument in the `withRouting` method call. Supports all keys of Laravel's `withRouting` method.
+If `withRouting` does not exist, it will be automatically created.
+
+**Note:** Use `PreformattedExpression` for complex values like closures or PHP expressions.
+
+Example usage:
+
+```php
+new AppBootstrapBuilder()
+    ->addRoutingOption('api', new PreformattedExpression("__DIR__.'/../routes/api.php'"))
+    ->addRoutingOption('apiPrefix', '')
+    ->save();
+```
+
 ## Contributing
 
 Thank you for considering contributing to Laravel Builder package! The contribution guide
 can be found in the [Contributing guide](CONTRIBUTING.md).
 
 ## License
 
-Laravel Builder package is open-sourced software licensed under the [MIT license](LICENSE).
+Laravel Builder package is open-sourced software licensed under the [MIT license](LICENSE).

src/Builders/AppBootstrapBuilder.php

@@ -2,7 +2,11 @@
 
 namespace RonasIT\Larabuilder\Builders;
 
+use RonasIT\Larabuilder\Nodes\PreformattedExpression;
+use RonasIT\Larabuilder\ValueOptions\ScheduleOption;
 use RonasIT\Larabuilder\Visitors\AppBootstrapVisitors\AddExceptionsRender;
+use RonasIT\Larabuilder\Visitors\AppBootstrapVisitors\AddRoutingOption;
+use RonasIT\Larabuilder\Visitors\AppBootstrapVisitors\AddScheduleCommand;
 
 class AppBootstrapBuilder extends PHPFileBuilder
 {
@@ -15,7 +19,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 +29,22 @@ 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;
+    }
+
+    public function addRoutingOption(string $key, string|PreformattedExpression $value): self
+    {
+        $this->traverser->addVisitor(new AddRoutingOption($key, $value));
+
+        return $this;
+    }
 }

src/Enums/StatementAttributeEnum.php

@@ -7,4 +7,5 @@ enum StatementAttributeEnum: string
     case Parent = 'parent';
     case Previous = 'previous';
     case Comments = 'comments';
+    case WasCreated = 'wasCreated';
 }

src/Nodes/PreformattedCode.php

@@ -2,28 +2,26 @@
 
 namespace RonasIT\Larabuilder\Nodes;
 
-use Illuminate\Support\Str;
 use PhpParser\Error;
 use PhpParser\Node\Stmt;
 use PhpParser\ParserFactory;
 use RonasIT\Larabuilder\Exceptions\InvalidPHPCodeException;
+use RonasIT\Larabuilder\Traits\PreformattedNodesHelperTrait;
 
 /**
  * Used to insert code with saving original formatting
  */
 class PreformattedCode extends Stmt
 {
-    public readonly array $code;
+    use PreformattedNodesHelperTrait;
 
     public function __construct(
         public string $value,
         public array $attributes = [],
     ) {
         parent::__construct($this->attributes);
 
-        $this->value = Str::chopStart($this->value, '<?php');
-
-        $this->code = $this->parsePHPCode($this->value);
+        $this->initPreformattedNode($this->value);
     }
 
     public function getSubNodeNames(): array

src/Nodes/PreformattedExpression.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace RonasIT\Larabuilder\Nodes;
+
+use PhpParser\Node\Expr;
+use RonasIT\Larabuilder\Traits\PreformattedNodesHelperTrait;
+
+/**
+ * Used to insert expression code with saving original formatting
+ */
+class PreformattedExpression extends Expr
+{
+    use PreformattedNodesHelperTrait;
+
+    public function __construct(
+        public string $value,
+        public array $attributes = [],
+    ) {
+        parent::__construct($this->attributes);
+
+        $this->initPreformattedNode($this->value);
+    }
+
+    public function getSubNodeNames(): array
+    {
+        return ['value'];
+    }
+
+    public function getType(): string
+    {
+        return 'Expr_PreformattedExpression';
+    }
+}

src/Printer.php

@@ -4,13 +4,15 @@
 
 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;
 use PhpParser\Node\Stmt\Property;
 use PhpParser\PrettyPrinter\Standard;
 use RonasIT\Larabuilder\Enums\StatementAttributeEnum;
 use RonasIT\Larabuilder\Nodes\PreformattedCode;
+use RonasIT\Larabuilder\Nodes\PreformattedExpression;
 
 class Printer extends Standard
 {
@@ -98,9 +100,19 @@ protected function shouldAddNewlineBeforeIfTypeSame(Node $node, string $type): b
         return $previousNode !== null && $previousNode instanceof $type;
     }
 
+    protected function pExpr_PreformattedExpression(PreformattedExpression $node): string
+    {
+        return $this->formatPreformattedCode($node->value);
+    }
+
     protected function pStmt_PreformattedCode(PreformattedCode $node): string
     {
-        $value = $this->preparePreformattedCode($node->value);
+        return $this->formatPreformattedCode($node->value);
+    }
+
+    private function formatPreformattedCode(string $value): string
+    {
+        $value = $this->preparePreformattedCode($value);
 
         $indentLength = strspn($value, " \t");
         $indent = substr($value, 0, $indentLength);
@@ -122,4 +134,28 @@ protected function preparePreformattedCode(string $value): string
 
         return rtrim($value);
     }
+
+    protected function pExpr_MethodCall(MethodCall $node): string
+    {
+        if ($node->getAttribute(StatementAttributeEnum::WasCreated->value)) {
+            $this->indent();
+
+            $args = $this->isMultilineMethodCall($node)
+                ? $this->pCommaSeparatedMultiline($node->args, true) . $this->nl
+                : $this->pMaybeMultiline($node->args);
+
+            $newCall = $this->nl . '->' . $this->pObjectProperty($node->name) . '(' . $args . ')';
+
+            $this->outdent();
+
+            return $this->pDereferenceLhs($node->var) . $newCall;
+        }
+
+        return parent::pExpr_MethodCall($node);
+    }
+
+    protected function isMultilineMethodCall(MethodCall $node): bool
+    {
+        return $node->name->toString() === 'withRouting';
+    }
 }

src/Traits/PreformattedNodesHelperTrait.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace RonasIT\Larabuilder\Traits;
+
+use Illuminate\Support\Str;
+use PhpParser\Node\Stmt\Nop;
+use PhpParser\ParserFactory;
+
+trait PreformattedNodesHelperTrait
+{
+    public readonly array $code;
+
+    protected function initPreformattedNode(string &$value): void
+    {
+        $value = Str::chopStart($value, '<?php');
+
+        $this->code = $this->parsePHPCode($value);
+    }
+
+    protected function parsePHPCode(string $code): array
+    {
+        $nodes = new ParserFactory()->createForHostVersion()->parse("<?php\n{$code};");
+
+        if (end($nodes) instanceof Nop) {
+            array_pop($nodes);
+        }
+
+        return $nodes;
+    }
+}

src/ValueOptions/RoutingOption.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace RonasIT\Larabuilder\ValueOptions;
+
+use Illuminate\Foundation\Configuration\ApplicationBuilder;
+use InvalidArgumentException;
+use ReflectionMethod;
+
+readonly class RoutingOption
+{
+    public function __construct(string $key)
+    {
+        $this->validateKey($key);
+    }
+
+    private function validateKey(string $key): void
+    {
+        $params = new ReflectionMethod(ApplicationBuilder::class, 'withRouting')->getParameters();
+
+        $allowed = array_map(fn ($param) => $param->getName(), $params);
+
+        if (!in_array($key, $allowed)) {
+            $list = implode("\n", $allowed);
+
+            throw new InvalidArgumentException("Unknown routing key `{$key}`.\nAllowed keys:\n{$list}");
+        }
+    }
+}

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);
+    }
+}