Refactor the make:publicationType command class

packages/framework/src/Console/Commands/MakePublicationTypeCommand.php

@@ -4,19 +4,18 @@
 
 namespace Hyde\Console\Commands;
 
-use function array_flip;
 use function array_keys;
-use function array_merge;
-use function file_exists;
 use Hyde\Console\Concerns\ValidatingCommand;
 use Hyde\Framework\Actions\CreatesNewPublicationType;
 use Hyde\Framework\Features\Publications\Models\PublicationField;
 use Hyde\Framework\Features\Publications\PublicationFieldTypes;
-use Hyde\Framework\Features\Publications\PublicationService;
+use Hyde\Hyde;
 use Illuminate\Support\Collection;
 use Illuminate\Support\Str;
+use function in_array;
 use InvalidArgumentException;
 use function is_dir;
+use function is_file;
 use LaravelZero\Framework\Commands\Command;
 use function scandir;
 use function strtolower;
@@ -32,179 +31,178 @@ class MakePublicationTypeCommand extends ValidatingCommand
 {
     /** @var string */
     protected $signature = 'make:publicationType
-		{title? : The name of the Publication Type to create. Will be used to generate the storage directory}';
+		{name? : The name of the publication type to create}
+        {--use-defaults : Select the default options wherever possible}';
 
     /** @var string */
     protected $description = 'Create a new publication type definition';
 
+    protected Collection $fields;
+
     public function safeHandle(): int
     {
         $this->title('Creating a new Publication Type!');
 
-        $title = $this->argument('title');
-        if (! $title) {
-            $title = trim($this->askWithValidation('name', 'Publication type name', ['required', 'string']));
-            $dirname = Str::slug($title);
-            if (file_exists($dirname) && is_dir($dirname) && count(scandir($dirname)) > 2) {
-                throw new InvalidArgumentException("Storage path [$dirname] already exists");
-            }
-        }
-
-        $fields = $this->captureFieldsDefinitions();
+        $title = $this->getTitle();
 
-        $sortField = $this->getSortField($fields);
+        $this->validateStorageDirectory(Str::slug($title));
 
-        $sortAscending = $this->getSortDirection();
+        $this->fields = $this->captureFieldsDefinitions();
 
-        $pageSize = $this->getPageSize();
-        $prevNextLinks = $this->getPrevNextLinks();
+        [$sortField, $sortAscending, $prevNextLinks, $pageSize] = ($this->getPaginationSettings());
 
-        $canonicalField = $this->getCanonicalField($fields);
+        $canonicalField = $this->getCanonicalField();
 
-        $creator = new CreatesNewPublicationType($title, $fields, $canonicalField, $sortField, $sortAscending, $prevNextLinks, $pageSize, $this->output);
+        $creator = new CreatesNewPublicationType($title, $this->fields, $canonicalField->name, $sortField, $sortAscending, $prevNextLinks, $pageSize, $this->output);
         $creator->create();
 
         $this->info('Publication type created successfully!');
 
         return Command::SUCCESS;
     }
 
+    protected function getTitle(): string
+    {
+        return $this->argument('name') ?: trim($this->askWithValidation('name', 'Publication type name', ['required', 'string']));
+    }
+
+    protected function validateStorageDirectory(string $directoryName): void
+    {
+        if (is_file(Hyde::path($directoryName)) || (is_dir(Hyde::path($directoryName)) && (count(scandir($directoryName)) > 2))) {
+            throw new InvalidArgumentException("Storage path [$directoryName] already exists");
+        }
+    }
+
     protected function captureFieldsDefinitions(): Collection
     {
-        $this->output->writeln('<bg=magenta;fg=white>You now need to define the fields in your publication type:</>');
-        $count = 1;
-        $fields = Collection::make();
-        do {
-            $this->line('');
-            $this->output->writeln("<bg=cyan;fg=white>Field #$count:</>");
+        $this->line('You now need to define the fields in your publication type:');
+        $this->fields = Collection::make();
 
-            $fieldData = [];
-            do {
-                $fieldData['name'] = Str::kebab(trim($this->askWithValidation('name', 'Field name', ['required'])));
-                $duplicate = $this->checkIfFieldIsDuplicate($fields, $fieldData['name']);
-            } while ($duplicate);
+        $this->addCreatedAtMetaField();
 
-            $type = $this->getFieldType();
+        do {
+            $this->fields->add($this->captureFieldDefinition());
 
-            if ($type === 10) {
-                $fieldData = $this->getFieldDataForTag($fieldData);
+            if ($this->option('use-defaults') === true) {
+                $addAnother = false;
+            } else {
+                $addAnother = $this->confirm("Field #{$this->getCount(-1)} added! Add another field?");
             }
-            $addAnother = $this->askWithValidation('addAnother', '<bg=magenta;fg=white>Add another field (y/n)</>', ['required', 'string', 'in:y,n'], 'n');
+        } while ($addAnother);
 
-            // map field choice to actual field type
-            $fieldData['type'] = PublicationFieldTypes::values()[$type - 1];
+        return $this->fields;
+    }
+
+    protected function captureFieldDefinition(): PublicationField
+    {
+        $this->line('');
+
+        $fieldName = $this->getFieldName();
+
+        $fieldType = $this->getFieldType();
+
+        if ($fieldType === PublicationFieldTypes::Tag) {
+            $this->comment('Tip: Hyde will look for tags matching the name of the publication!');
+        }
 
-            $fields->add(PublicationField::fromArray($fieldData));
-            $count++;
-        } while (strtolower($addAnother) !== 'n');
+        // TODO: Here we could collect other data like the "rules" array for the field.
 
-        return $fields;
+        return new PublicationField($fieldType, $fieldName);
     }
 
-    protected function getFieldType(): int
+    protected function getFieldName(?string $message = null): string
     {
-        $options = PublicationFieldTypes::cases();
-        foreach ($options as $key => $value) {
-            $options[$key] = $value->name;
+        $selected = Str::kebab(trim($this->askWithValidation('name', $message ?? "Enter name for field #{$this->getCount()}", ['required'])));
+
+        if ($this->checkIfFieldIsDuplicate($selected)) {
+            return $this->getFieldName("Try again: Enter name for field #{$this->getCount()}");
         }
-        $options[4] = 'Datetime (YYYY-MM-DD (HH:MM:SS))';
-        $options[5] = 'URL';
-        $options[8] = 'Local Image';
-        $options[9] = 'Tag (select value from list)';
 
-        return (int) $this->choice('Field type', $options, 1) + 1;
+        return $selected;
     }
 
-    protected function getSortField(Collection $fields): string
+    protected function getFieldType(): PublicationFieldTypes
     {
-        $options = array_merge(['dateCreated (meta field)'], $fields->pluck('name')->toArray());
+        $options = PublicationFieldTypes::names();
 
-        $selected = $this->choice('Choose the default field you wish to sort by', $options, 'dateCreated (meta field)');
+        $choice = $this->choice("Enter type for field #{$this->getCount()}", $options, 'String');
 
-        return $selected === 'dateCreated (meta field)' ? '__createdAt' : $options[(array_flip($options)[$selected])];
+        return PublicationFieldTypes::from(strtolower($choice));
     }
 
-    protected function getSortDirection(): bool
+    protected function getCanonicalField(): PublicationField
     {
-        $options = [
-            'Ascending (oldest items first if sorting by dateCreated)'  => true,
-            'Descending (newest items first if sorting by dateCreated)' => false,
-        ];
+        $selectableFields = $this->fields->reject(function (PublicationField $field): bool {
+            return in_array($field, PublicationFieldTypes::canonicable());
+        });
+
+        if ($this->option('use-defaults')) {
+            return $selectableFields->first();
+        }
+
+        $options = $selectableFields->pluck('name');
+
+        $selected = $this->choice('Choose a canonical name field (this will be used to generate filenames, so the values need to be unique)',
+            $options->toArray(),
+            $options->first()
+        );
 
-        return $options[$this->choice('Choose the default sort direction', array_keys($options), 'Ascending (oldest items first if sorting by dateCreated)')];
+        return $this->fields->firstWhere('name', $selected);
     }
 
-    protected function getPageSize(): int
+    protected function checkIfFieldIsDuplicate($name): bool
     {
-        return (int) $this->askWithValidation(
-            'pageSize',
-            'Enter the pageSize (0 for no limit)',
-            ['required', 'integer', 'between:0,100'],
-            25
-        );
+        if ($this->fields->where('name', $name)->count() > 0) {
+            $this->error("Field name [$name] already exists!");
+
+            return true;
+        }
+
+        return false;
     }
 
-    protected function getPrevNextLinks(): bool
+    protected function addCreatedAtMetaField(): void
     {
-        return (bool) $this->askWithValidation(
-            'prevNextLinks',
-            'Generate previous/next links in detail view (y/n)',
-            ['required', 'string', 'in:y,n'],
-            'y'
-        );
+        $this->fields->add(new PublicationField(PublicationFieldTypes::Datetime, '__createdAt'));
     }
 
-    protected function getCanonicalField(Collection $fields): string
+    protected function getPaginationSettings(): array
     {
-        $options = $fields->reject(function (PublicationField $field): bool {
-            // Temporary verbose check to see code coverage
-            if ($field->type === 'image') {
-                return true;
-            } elseif ($field->type === 'tag') {
-                return true;
-            } else {
-                return false;
-            }
-        })->pluck('name');
+        if ($this->option('use-defaults') || ! $this->confirm('Do you want to configure pagination settings?')) {
+            return [null, null, null, null];
+        }
 
-        return $this->choice('Choose a canonical name field (the values of this field have to be unique!)', $options->toArray(), $options->first());
+        return [$this->getSortField(), $this->getSortDirection(), $this->getPrevNextLinks(), $this->getPageSize()];
     }
 
-    protected function validateLengths(string $min, string $max): bool
+    protected function getSortField(): string
     {
-        if ($max < $min) {
-            $this->error('Field length [max] cannot be less than [min]');
+        return $this->choice('Choose the default field you wish to sort by', $this->fields->pluck('name')->toArray(), '__dateCreated');
+    }
 
-            return false;
-        }
+    protected function getSortDirection(): bool
+    {
+        $options = ['Ascending' => true, 'Descending' => false];
 
-        return true;
+        return $options[$this->choice('Choose the default sort direction', array_keys($options), 'Ascending')];
     }
 
-    protected function getFieldDataForTag(array $fieldData): array
+    protected function getPrevNextLinks(): bool
     {
-        $allTags = PublicationService::getAllTags();
-        $offset = 1;
-        foreach ($allTags as $k => $v) {
-            $this->line("  $offset - $k");
-            $offset++;
-        }
-        $offset--; // The above loop overcounts by 1
-        $selected = $this->askWithValidation('tagGroup', 'Tag Group', ['required', 'integer', "between:1,$offset"], 0);
-        $fieldData['tagGroup'] = $allTags->keys()->{$selected - 1};
-        $fieldData['min'] = 0;
-        $fieldData['max'] = 0;
-
-        return $fieldData;
+        return $this->confirm('Generate previous/next links in detail view?', true);
     }
 
-    protected function checkIfFieldIsDuplicate(Collection $fields, $name): bool
+    protected function getPageSize(): int
     {
-        $duplicate = $fields->where('name', $name)->count();
-        if ($duplicate) {
-            $this->error("Field name [$name] already exists!");
-        }
+        return (int) $this->askWithValidation('pageSize',
+            'Enter the page size (0 for no limit)',
+            ['required', 'integer', 'between:0,100'],
+            25
+        );
+    }
 
-        return (bool) $duplicate;
+    protected function getCount(int $offset = 0): int
+    {
+        return $this->fields->count() + $offset;
     }
 }

packages/framework/src/Framework/Actions/CreatesNewPublicationType.php

@@ -24,10 +24,10 @@ public function __construct(
         protected string $name,
         protected Collection $fields,
         protected string $canonicalField,
-        protected string $sortField,
-        protected bool $sortAscending,
-        protected bool $prevNextLinks,
-        protected int $pageSize,
+        protected ?string $sortField,
+        protected ?bool $sortAscending,
+        protected ?bool $prevNextLinks,
+        protected ?int $pageSize,
         protected ?OutputStyle $output = null,
     ) {
         $this->dirName = $this->formatStringForStorage($this->name);
@@ -42,10 +42,10 @@ protected function handleCreate(): void
             "{$this->dirName}_detail",
             "{$this->dirName}_list",
             [
-                $this->sortField,
-                $this->sortAscending,
-                $this->prevNextLinks,
-                $this->pageSize,
+                $this->sortField ?? '__createdAt',
+                $this->sortAscending ?? true,
+                $this->prevNextLinks ?? true,
+                $this->pageSize ?? 25,
             ],
             $this->fields->toArray()
         );

packages/framework/src/Framework/Features/Publications/Models/PaginationSettings.php

@@ -13,6 +13,7 @@ class PaginationSettings implements SerializableContract
 
     public string $sortField = '__createdAt';
     public bool $sortAscending = true;
+    /** @deprecated This setting might be deprecated as its unlikely one would enable page size limits without a way to traverse them */
     public bool $prevNextLinks = true;
     public int $pageSize = 25;
 

packages/framework/src/Framework/Features/Publications/Models/PublicationField.php

@@ -13,6 +13,7 @@
 use Illuminate\Contracts\Support\Arrayable;
 use Illuminate\Support\Collection;
 use Illuminate\Support\Str;
+use function str_starts_with;
 use function strtolower;
 
 /**
@@ -37,7 +38,7 @@ public static function fromArray(array $array): static
     public function __construct(PublicationFieldTypes|string $type, string $name, array $rules = [])
     {
         $this->type = $type instanceof PublicationFieldTypes ? $type : PublicationFieldTypes::from(strtolower($type));
-        $this->name = Str::kebab($name);
+        $this->name = str_starts_with($name, '__') ? $name : Str::kebab($name);
         $this->rules = $rules;
     }