Complete baking of enums.

src/Command/EnumCommand.php

@@ -18,6 +18,8 @@
 
 use Cake\Console\Arguments;
 use Cake\Console\ConsoleOptionParser;
+use Cake\Utility\Inflector;
+use InvalidArgumentException;
 
 /**
  * Enum code generator.
@@ -64,8 +66,20 @@ public function template(): string
      */
     public function templateData(Arguments $arguments): array
     {
+        $cases = $this->parseCases($arguments->getArgument('cases'), (bool)$arguments->getOption('int'));
+        $isOfTypeInt = $this->isOfTypeInt($cases);
+        $backingType = $isOfTypeInt ? 'int' : 'string';
+        if ($arguments->getOption('int')) {
+            if ($cases && !$isOfTypeInt) {
+                throw new InvalidArgumentException('The cases provided do not seem to match the int type you want to bake');
+            }
+
+            $backingType = 'int';
+        }
+
         $data = parent::templateData($arguments);
-        $data['backingType'] = $arguments->getOption('int') ? 'int' : 'string';
+        $data['backingType'] = $backingType;
+        $data['cases'] = $this->formatCases($cases);
 
         return $data;
     }
@@ -82,12 +96,82 @@ public function buildOptionParser(ConsoleOptionParser $parser): ConsoleOptionPar
 
         $parser->setDescription(
             'Bake backed enums for use in models.'
-        )->addOption('int', [
-            'help' => 'Using backed enums with int instead of string as return type',
+        )->addArgument('name', [
+            'help' => 'Name of the enum to bake. You can use Plugin.name to bake plugin enums.',
+            'required' => true,
+        ])->addArgument('cases', [
+            'help' => 'List of either `one,two` for string or `0:foo,1:bar` for int type.',
+        ])->addOption('int', [
+            'help' => 'Using backed enums with int instead of string as return type.',
             'boolean' => true,
             'short' => 'i',
         ]);
 
         return $parser;
     }
+
+    /**
+     * @param string|null $casesString
+     * @return array<int|string, string>
+     */
+    protected function parseCases(?string $casesString, bool $int): array
+    {
+        if ($casesString === null) {
+            return [];
+        }
+
+        $enumCases = explode(',', $casesString);
+
+        $definition = [];
+        foreach ($enumCases as $k => $enumCase) {
+            $key = $value = trim($enumCase);
+            if (str_contains($key, ':')) {
+                $value = trim(mb_substr($key, strpos($key, ':') + 1));
+                $key = mb_substr($key, 0, strpos($key, ':'));
+            } elseif ($int) {
+                $key = $k;
+            }
+
+            $definition[$key] = $value;
+        }
+
+        return $definition;
+    }
+
+    /**
+     * @param array<int|string, string> $definition
+     * @return bool
+     */
+    protected function isOfTypeInt(array $definition): bool
+    {
+        if (!$definition) {
+            return false;
+        }
+
+        foreach ($definition as $key => $value) {
+            if (!is_int($key)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * @param array<int|string, string> $cases
+     * @return array<string>
+     */
+    protected function formatCases(array $cases): array
+    {
+        $formatted = [];
+        foreach ($cases as $case => $alias) {
+            $alias = mb_strtoupper(Inflector::underscore($alias));
+            if (is_string($case)) {
+                $case = '\'' . $case . '\'';
+            }
+            $formatted[] = 'case ' . $alias . ' = ' . $case . ';';
+        }
+
+        return $formatted;
+    }
 }

src/Command/ModelCommand.php

@@ -111,6 +111,8 @@ public function bake(string $name, Arguments $args, ConsoleIo $io): void
         $tableObject = $this->getTableObject($name, $table);
         $this->validateNames($tableObject->getSchema(), $io);
         $data = $this->getTableContext($tableObject, $table, $name, $args, $io);
+
+        $this->bakeEnums($tableObject, $data, $args, $io);
         $this->bakeTable($tableObject, $data, $args, $io);
         $this->bakeEntity($tableObject, $data, $args, $io);
         $this->bakeFixture($tableObject->getAlias(), $tableObject->getTable(), $args, $io);
@@ -168,6 +170,7 @@ public function getTableContext(
         $behaviors = $this->getBehaviors($tableObject);
         $connection = $this->connection;
         $hidden = $this->getHiddenFields($tableObject, $args);
+        $enumSchema = $this->getEnumDefinitions($tableObject->getSchema());
 
         return compact(
             'associations',
@@ -181,7 +184,8 @@ public function getTableContext(
             'rulesChecker',
             'behaviors',
             'connection',
-            'hidden'
+            'hidden',
+            'enumSchema',
         );
     }
 
@@ -1118,7 +1122,7 @@ public function getCounterCache(Table $model): array
      * Bake an entity class.
      *
      * @param \Cake\ORM\Table $model Model name or object
-     * @param array $data An array to use to generate the Table
+     * @param array<string, mixed> $data An array to use to generate the Table
      * @param \Cake\Console\Arguments $args CLI Arguments
      * @param \Cake\Console\ConsoleIo $io CLI io
      * @return void
@@ -1170,7 +1174,7 @@ public function bakeEntity(Table $model, array $data, Arguments $args, ConsoleIo
      * Bake a table class.
      *
      * @param \Cake\ORM\Table $model Model name or object
-     * @param array $data An array to use to generate the Table
+     * @param array<string, mixed> $data An array to use to generate the Table
      * @param \Cake\Console\Arguments $args CLI Arguments
      * @param \Cake\Console\ConsoleIo $io CLI Arguments
      * @return void
@@ -1444,4 +1448,94 @@ protected function possibleEnumFields(TableSchemaInterface $schema): array
 
         return $fields;
     }
+
+    /**
+     * @param \Cake\Database\Schema\TableSchemaInterface $schema
+     * @return array<string, mixed>
+     */
+    protected function getEnumDefinitions(TableSchemaInterface $schema): array
+    {
+        $enums = [];
+
+        foreach ($schema->columns() as $column) {
+            $columnSchema = $schema->getColumn($column);
+            if (!in_array($columnSchema['type'], ['string', 'integer', 'tinyinteger', 'smallinteger'], true)) {
+                continue;
+            }
+
+            if (empty($columnSchema['comment']) || strpos($columnSchema['comment'], '[enum]') === false) {
+                continue;
+            }
+
+            $enumsDefinitionString = mb_substr($columnSchema['comment'], strpos($columnSchema['comment'], '[enum]') + 6);
+            $enumsDefinition = $this->parseEnumsDefinition($enumsDefinitionString);
+            if (!$enumsDefinition) {
+                continue;
+            }
+
+            $enums[$column] = $enumsDefinition;
+        }
+
+        return $enums;
+    }
+
+    /**
+     * @param string $enumsDefinitionString
+     * @return array<int|string, string>
+     */
+    protected function parseEnumsDefinition(string $enumsDefinitionString): array
+    {
+        $enumCases = explode(',', $enumsDefinitionString);
+
+        $definition = [];
+        foreach ($enumCases as $enumCase) {
+            $key = $value = trim($enumCase);
+            if (str_contains($key, ':')) {
+                $value = trim(mb_substr($key, strpos($key, ':') + 1));
+                $key = mb_substr($key, 0, strpos($key, ':'));
+            }
+
+            $definition[$key] = mb_strtolower($value);
+        }
+
+        return $definition;
+    }
+
+    /**
+     * @param \Cake\ORM\Table $model
+     * @param array<string, mixed> $data
+     * @param \Cake\Console\Arguments $args
+     * @param \Cake\Console\ConsoleIo $io
+     * @return void
+     */
+    protected function bakeEnums(Table $model, array $data, Arguments $args, ConsoleIo $io): void
+    {
+        $enums = $data['enumSchema'];
+        if (!$enums) {
+            return;
+        }
+
+        $entity = $this->_entityName($model->getAlias());
+
+        foreach ($enums as $column => $enum) {
+            $enumCommand = new EnumCommand();
+
+            $name = $entity . Inflector::camelize($column);
+            if ($this->plugin) {
+                $name = $this->plugin . '.' . $name;
+            }
+
+            $cases = [];
+            foreach ($enum as $k => $v) {
+                $cases[] = $k . ':' . $v;
+            }
+
+            $args = new Arguments(
+                [$name, implode(',', $cases)],
+                ['int' => false] + $args->getOptions(),
+                ['name', 'cases']
+            );
+            $enumCommand->execute($args, $io);
+        }
+    }
 }

templates/bake/Model/enum.twig

@@ -24,11 +24,15 @@
 {{ DocBlock.classDescription(name, 'Enum', [])|raw }}
 enum {{ name }}: {{ backingType }} implements EnumLabelInterface
 {
+{% if cases %}
+    {{ Bake.concat('\n    ', cases) }}
+
+{% endif %}
     /**
      * @return string
      */
     public function label(): string
     {
-        return Inflector::humanize(Inflector::underscore($this->name));
+        return Inflector::humanize(mb_strtolower($this->name));
     }
 }

tests/comparisons/Model/testBakeEnum.php

@@ -16,6 +16,6 @@ enum FooBar: string implements EnumLabelInterface
      */
     public function label(): string
     {
-        return Inflector::humanize(Inflector::underscore($this->name));
+        return Inflector::humanize(mb_strtolower($this->name));
     }
 }

tests/comparisons/Model/testBakeEnumBackedInt.php

@@ -16,6 +16,6 @@ enum FooBar: int implements EnumLabelInterface
      */
     public function label(): string
     {
-        return Inflector::humanize(Inflector::underscore($this->name));
+        return Inflector::humanize(mb_strtolower($this->name));
     }
 }