Methods for individual enums

Author: brandonferens

src/Commands/GenerateEnumsCommand.php

@@ -28,17 +28,26 @@ public function handle(): int
     {
         $builder = $this->builder();
 
+        $this->generateEnums($builder);
+        $this->generateAbstractEnum($builder);
+
+        return self::SUCCESS;
+    }
+
+    protected function generateEnums(EnumBuilder $builder): void
+    {
         $generatedEnums = $this->enums()
             ->map(fn (ReflectionEnum $enum) => app(EnumGenerator::class, ['enum' => $enum, 'builder' => $builder])())
             ->filter();
 
         $this->components->info("{$generatedEnums->count()} enums have been (re)generated.");
+    }
 
+    protected function generateAbstractEnum(EnumBuilder $builder): void
+    {
         app(AbstractEnumGenerator::class, ['builder' => $builder])();
 
         $this->components->info('Abstract enum class has been (re)generated.');
-
-        return self::SUCCESS;
     }
 
     /**

src/Commands/MakeEnumMethodCommand.php

@@ -5,14 +5,25 @@
 use Exception;
 use Illuminate\Console\GeneratorCommand;
 use Illuminate\Contracts\Filesystem\FileNotFoundException;
+use Illuminate\Support\Str;
+use InvalidArgumentException;
 use Kirschbaum\Paragon\Concerns\Builders\EnumBuilder;
 use Kirschbaum\Paragon\Concerns\Builders\EnumJsBuilder;
 use Kirschbaum\Paragon\Concerns\Builders\EnumTsBuilder;
+use Kirschbaum\Paragon\Concerns\DiscoverEnums;
 use Kirschbaum\Paragon\Generators\AbstractEnumGenerator;
+use Kirschbaum\Paragon\Generators\EnumGenerator;
+use ReflectionEnum;
+use ReflectionException;
 use Symfony\Component\Console\Attribute\AsCommand;
 use Symfony\Component\Console\Input\InputArgument;
+use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Input\InputOption;
+use Symfony\Component\Console\Output\OutputInterface;
+use Throwable;
+use UnitEnum;
 
+use function Laravel\Prompts\search;
 use function Laravel\Prompts\text;
 
 #[AsCommand(name: 'paragon:enum:add-method', description: 'Create a new global typescript method to be applied to every generated enum')]
@@ -28,9 +39,9 @@ public function handle(): ?bool
     {
         parent::handle();
 
-        app(AbstractEnumGenerator::class, ['builder' => $this->builder()])();
+        $this->runGenerator();
 
-        $this->components->info("Abstract enum class has been rebuilt to include new [{$this->name()}] method.");
+        $this->writeInfo();
 
         return true;
     }
@@ -70,6 +81,38 @@ protected function promptForMissingArgumentsUsing(): array
         ];
     }
 
+    /**
+     * Interact further with the user if they were prompted for missing arguments.
+     *
+     * @phpcsSuppress SlevomatCodingStandard.Functions.UnusedParameter
+     */
+    protected function afterPromptingForMissingArguments(InputInterface $input, OutputInterface $output): void
+    {
+        if (
+            is_string($this->option('enum'))
+            || $this->option('global')
+        ) {
+            return;
+        }
+
+        /**
+         * @var string $enumPath
+         */
+        $enumPath = config('paragon.enums.paths.php');
+
+        $enums = DiscoverEnums::within(app_path($enumPath))
+            ->mapWithKeys(fn (ReflectionEnum $reflector) => [$reflector->getName() => $reflector->getName()]);
+
+        $enum = search(
+            label: 'Which enum should this method be created for?',
+            options: fn (string $value) => strlen($value) > 0
+                ? $enums->filter(fn (string $enum): bool => Str::contains($enum, $value, ignoreCase: true))->all()
+                : []
+        );
+
+        $input->setOption('enum', $enum);
+    }
+
     /**
      * Build the file with the given name.
      *
@@ -88,15 +131,30 @@ protected function buildClass($name): string
     /**
      * Get the destination class path.
      *
-     * @throws Exception
+     * @throws Throwable
      */
     protected function getPath($name): string
     {
-        /** @var string */
-        $methods = config('paragon.enums.paths.methods');
+        /**
+         * @var string $path
+         */
+        $path = config('paragon.enums.paths.methods');
         $extension = $this->option('javascript') ? 'js' : 'ts';
 
-        return resource_path($methods) . "/{$this->name()}.{$extension}";
+        if (! $this->option('global')) {
+            $enum = str($this->enumOption())->replace('/', '\\');
+
+            throw_unless(
+                enum_exists($enum->toString()),
+                ReflectionException::class,
+                "Class \"{$enum}\" does not exist"
+            );
+
+            $path = $enum->replace('\\', '/')
+                ->prepend(Str::finish($path, '/'));
+        }
+
+        return resource_path($path) . "/{$this->name()}.{$extension}";
     }
 
     /**
@@ -120,7 +178,48 @@ protected function builder(): EnumBuilder
         return $this->option('javascript')
             ? app(EnumJsBuilder::class)
             : app(EnumTsBuilder::class);
+    }
+
+    /**
+     * @throws ReflectionException
+     * @throws Throwable
+     */
+    protected function runGenerator(): void
+    {
+        $this->option('global')
+            ? app(AbstractEnumGenerator::class, ['builder' => $this->builder()])()
+            : app(EnumGenerator::class, [
+                'enum' => new ReflectionEnum($this->enumOption()),
+                'builder' => $this->builder(),
+                'forceRegenerate' => true,
+            ])();
+    }
+
+    protected function writeInfo(): void
+    {
+        $name = $this->option('global')
+            ? 'Abstract'
+            : Str::afterLast($this->enumOption(), '\\');
 
+        $this->components->info("[{$name}] enum class has been rebuilt to include new [{$this->name()}()] method.");
+    }
+
+    /**
+     * @return class-string<UnitEnum>
+     *
+     * @throws Throwable
+     */
+    protected function enumOption(): string
+    {
+        $enum = $this->option('enum');
+
+        throw_unless(
+            is_string($enum) && is_a($enum, UnitEnum::class, true),
+            InvalidArgumentException::class,
+            'The enum option must be a valid class-string of a UnitEnum'
+        );
+
+        return $enum;
     }
 
     /**
@@ -131,6 +230,18 @@ protected function builder(): EnumBuilder
     protected function getOptions(): array
     {
         return [
+            new InputOption(
+                name: 'enum',
+                shortcut: 'e',
+                mode: InputOption::VALUE_REQUIRED,
+                description: 'Fully qualified namespace of enum to use',
+            ),
+            new InputOption(
+                name: 'global',
+                shortcut: 'g',
+                mode: InputOption::VALUE_NONE,
+                description: 'Create global enum method',
+            ),
             new InputOption(
                 name: 'javascript',
                 shortcut: 'j',

src/Concerns/DiscoverEnums.php

@@ -5,8 +5,8 @@
 use Illuminate\Support\Collection;
 use ReflectionEnum;
 use ReflectionException;
-use SplFileInfo;
 use Symfony\Component\Finder\Finder;
+use Symfony\Component\Finder\SplFileInfo;
 use UnitEnum;
 
 class DiscoverEnums

src/Generators/AbstractEnumGenerator.php

@@ -6,18 +6,20 @@
 use Illuminate\Support\Collection;
 use Illuminate\Support\Facades\Storage;
 use Kirschbaum\Paragon\Concerns\Builders\EnumBuilder;
-use SplFileInfo;
 use Symfony\Component\Filesystem\Filesystem as FileUtility;
 use Symfony\Component\Finder\Exception\DirectoryNotFoundException;
 use Symfony\Component\Finder\Finder;
+use Symfony\Component\Finder\SplFileInfo;
 
 class AbstractEnumGenerator
 {
     protected Filesystem $files;
 
     public function __construct(protected EnumBuilder $builder)
     {
-        /** @var string */
+        /**
+         * @var string $generatedPath
+         */
         $generatedPath = config('paragon.enums.paths.generated');
 
         $this->files = Storage::createLocalDriver([
@@ -37,7 +39,9 @@ protected function contents(): string
     {
         $imports = $this->imports();
         $suffix = $imports->count() ? PHP_EOL : '';
-        /** @var string */
+        /**
+         * @var string $abstractClass
+         */
         $abstractClass = config('paragon.enums.abstract-class');
 
         return str((string) file_get_contents($this->builder->abstractStubPath()))
@@ -53,12 +57,15 @@ protected function contents(): string
      */
     protected function imports(): Collection
     {
-        /** @var string */
+        /**
+         * @var string $methodsPath
+         */
         $methodsPath = config('paragon.enums.paths.methods');
 
         try {
             $files = Finder::create()
                 ->files()
+                ->depth(0)
                 ->in(resource_path($methodsPath));
         } catch (DirectoryNotFoundException) {
             return collect();
@@ -72,17 +79,21 @@ protected function imports(): Collection
         return $fileCollection
             ->mapWithKeys(function (SplFileInfo $file): array {
                 $filesystem = new FileUtility();
-                /** @var string */
+                /**
+                 * @var string $generatedPath
+                 */
                 $generatedPath = config('paragon.enums.paths.generated');
 
                 $relativeFilePath = $filesystem->makePathRelative(
                     $file->getPath(),
                     resource_path($generatedPath)
                 );
 
-                $name = (string) str($file->getFileName())->before('.');
+                $name = $file->getBasename($this->builder->fileExtension());
 
-                /** @var array<string,string> */
+                /**
+                 * @var array<string,string>
+                 */
                 return [$name => "import {$name} from '{$relativeFilePath}{$file->getFilename()}';" . PHP_EOL];
             })
             ->sort();