Refactor and add tests for MakePublicationTagCommand

packages/framework/src/Console/Commands/Helpers/InputStreamHandler.php

@@ -0,0 +1,58 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Hyde\Console\Commands\Helpers;
+
+use function array_shift;
+use function explode;
+use function fgets;
+use Hyde\Framework\Concerns\InvokableAction;
+use Illuminate\Support\Str;
+use function trim;
+
+/**
+ * Collects an array of lines from the standard input stream. Feed is terminated by a blank line.
+ *
+ * @todo Add dynamic support for detecting and using comma separated values?
+ */
+class InputStreamHandler extends InvokableAction
+{
+    /** @internal Allows for mocking of the standard input stream */
+    private static ?array $streamBuffer = null;
+
+    public function __invoke(): array
+    {
+        return $this->getLinesFromInputStream();
+    }
+
+    protected function getLinesFromInputStream(): array
+    {
+        $lines = [];
+        do {
+            $line = Str::replace(["\n", "\r"], '', $this->readInputStream());
+            if ($line === '') {
+                break;
+            }
+            $lines[] = trim($line);
+        } while (true);
+
+        return $lines;
+    }
+
+    /** @codeCoverageIgnore Allows for mocking of the standard input stream */
+    protected function readInputStream(): array|string|false
+    {
+        if (self::$streamBuffer) {
+            return array_shift(self::$streamBuffer);
+        }
+
+        return fgets(STDIN);
+    }
+
+    /** @internal Allows for mocking of the standard input stream */
+    public static function mockInput(string $input): void
+    {
+        self::$streamBuffer = explode("\n", $input);
+    }
+}

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

@@ -4,55 +4,101 @@
 
 namespace Hyde\Console\Commands;
 
+use function array_merge;
+use Hyde\Console\Commands\Helpers\InputStreamHandler;
 use Hyde\Console\Commands\Interfaces\CommandHandleInterface;
 use Hyde\Console\Concerns\ValidatingCommand;
+use Hyde\Facades\Filesystem;
 use Hyde\Framework\Features\Publications\PublicationService;
+use Hyde\Framework\Services\DiscoveryService;
 use Hyde\Hyde;
-use Illuminate\Support\Str;
+use function implode;
 use LaravelZero\Framework\Commands\Command;
-use function Safe\file_put_contents;
+use RuntimeException;
 use function Safe\json_encode;
+use function sprintf;
 
 /**
  * Hyde Command to create a new publication type.
  *
- * @see \Hyde\Framework\Testing\Feature\Commands\MakePublicationTypeCommandTest
+ * @see \Hyde\Framework\Testing\Feature\Commands\MakePublicationTagCommandTest
  */
 class MakePublicationTagCommand extends ValidatingCommand implements CommandHandleInterface
 {
     /** @var string */
-    protected $signature = 'make:publicationTag';
+    protected $signature = 'make:publicationTag {tagName? : The name of the tag to create}';
 
     /** @var string */
     protected $description = 'Create a new publication type tag definition';
 
-    public function handle(): int
+    protected array $tags;
+    protected string $tagName;
+
+    public function safeHandle(): int
     {
         $this->title('Creating a new Publication Type Tag!');
 
-        $filename = Hyde::pathToRelative('tags.json');
-        $tags = PublicationService::getAllTags();
-        $tagName = $this->askWithValidation('name', 'Tag name', ['required', 'string']);
-        if (isset($tags[$tagName])) {
-            $this->output->error("Tag [$tagName] already exists");
+        $this->getTagName();
 
-            return Command::FAILURE;
-        }
+        $this->validateTagName();
 
-        $lines = [];
-        $this->output->writeln('<bg=magenta;fg=white>Enter the tag values (end with an empty line):</>');
-        do {
-            $line = Str::replace(["\n", "\r"], '', fgets(STDIN));
-            if ($line === '') {
-                break;
-            }
-            $lines[] = trim($line);
-        } while (true);
-        $tags[$tagName] = $lines;
+        $this->collectTags();
 
-        $this->output->writeln(sprintf('Saving tag data to [%s]', $filename));
-        file_put_contents($filename, json_encode($tags, JSON_PRETTY_PRINT));
+        $this->printSelectionInformation();
+
+        $this->saveTagsToDisk();
 
         return Command::SUCCESS;
     }
+
+    protected function getTagName(): void
+    {
+        $this->tagName = $this->getTagNameFromArgument($this->argument('tagName'))
+            ?? $this->askWithValidation('name', 'Tag name', ['required', 'string']);
+    }
+
+    protected function getTagNameFromArgument(?string $value): ?string
+    {
+        if ($value) {
+            $this->infoComment('Using tag name', $value, 'from command line argument');
+            $this->newLine();
+
+            return $value;
+        }
+
+        return null;
+    }
+
+    protected function validateTagName(): void
+    {
+        if (PublicationService::getAllTags()->has($this->tagName)) {
+            throw new RuntimeException("Tag [$this->tagName] already exists");
+        }
+    }
+
+    protected function collectTags(): void
+    {
+        $this->info('Enter the tag values: (end with an empty line)');
+        $this->tags = [$this->tagName => InputStreamHandler::call()];
+    }
+
+    protected function printSelectionInformation(): void
+    {
+        $this->line('Adding the following tags:');
+        foreach ($this->tags as $tag => $values) {
+            $this->line(sprintf('  <comment>%s</comment>: %s', $tag, implode(', ', $values)));
+        }
+        $this->newLine();
+    }
+
+    protected function saveTagsToDisk(): void
+    {
+        $this->infoComment('Saving tag data to',
+            DiscoveryService::createClickableFilepath(Hyde::path('tags.json'))
+        );
+
+        Filesystem::putContents('tags.json', json_encode(array_merge(
+            PublicationService::getAllTags()->toArray(), $this->tags
+        ), JSON_PRETTY_PRINT));
+    }
 }

packages/framework/src/Console/Concerns/ValidatingCommand.php

@@ -101,6 +101,14 @@ public function handleException(Exception $exception, ?string $file = null, ?int
         return Command::FAILURE;
     }
 
+    /**
+     * Write a nicely formatted and consistent message to the console. Using InfoComment for a lack of a better term.
+     */
+    public function infoComment(string $info, string $comment, ?string $moreInfo = null): void
+    {
+        $this->line("<info>$info</info> [<comment>$comment</comment>]".($moreInfo ? " <info>$moreInfo</info>" : ''));
+    }
+
     protected function translate($name, string $error): string
     {
         return $this->makeReplacements($name, Str::after($error, 'validation.'), $this->getTranslationLines());

packages/framework/src/Framework/Features/Publications/PublicationService.php

@@ -22,24 +22,6 @@
  */
 class PublicationService
 {
-    /**
-     * Get all available/tags.
-     *
-     * @return \Rgasch\Collection\Collection
-     *
-     * @throws \Safe\Exceptions\FilesystemException
-     * @throws \Safe\Exceptions\JsonException
-     */
-    public static function getAllTags(): Collection
-    {
-        $filename = Hyde::pathToRelative('tags.json');
-        if (! file_exists($filename)) {
-            return Collection::create();
-        }
-
-        return Collection::create(json_decode(file_get_contents($filename), true))->sortKeys();
-    }
-
     /**
      * Return a collection of all defined publication types, indexed by the directory name.
      *
@@ -76,19 +58,36 @@ public static function getMediaForPubType(PublicationType $pubType): Collection
         });
     }
 
+    /**
+     * Get all available tags.
+     *
+     * @return \Rgasch\Collection\Collection
+     *
+     * @throws \Safe\Exceptions\FilesystemException
+     * @throws \Safe\Exceptions\JsonException
+     */
+    public static function getAllTags(): Collection
+    {
+        $filename = Hyde::pathToRelative('tags.json');
+        if (! file_exists($filename)) {
+            return Collection::create();
+        }
+
+        return Collection::create(json_decode(file_get_contents($filename), true))->sortKeys();
+    }
+
     /**
      * Get all values for a given tag name.
      *
      * @param  string  $tagName
-     * @param  \Hyde\Framework\Features\Publications\Models\PublicationType  $publicationType
      * @return \Rgasch\Collection\Collection|null
      *
      * @throws \Safe\Exceptions\FilesystemException
      * @throws \Safe\Exceptions\JsonException
      */
-    public static function getValuesForTagName(string $tagName, PublicationType $publicationType): ?Collection
+    public static function getValuesForTagName(string $tagName): ?Collection
     {
-        $tags = self::getAllTags($publicationType);
+        $tags = static::getAllTags();
         if ($tags->has($tagName)) {
             return $tags->$tagName;
         }

packages/framework/src/Framework/Services/DiscoveryService.php

@@ -93,6 +93,9 @@ public static function getModelSourceDirectory(string $model): string
 
     /**
      * Create a filepath that can be opened in the browser from a terminal.
+     *
+     * @todo Add support for custom label?
+     * @todo Add option to treat path as already validated so paths that are not created yet can be printed?
      */
     public static function createClickableFilepath(string $filepath): string
     {

packages/framework/tests/Feature/Commands/MakePublicationTagCommandTest.php

@@ -0,0 +1,90 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Hyde\Framework\Testing\Feature\Commands;
+
+use Hyde\Console\Commands\Helpers\InputStreamHandler;
+use Hyde\Hyde;
+use Hyde\Testing\TestCase;
+use function unlink;
+
+/**
+ * @covers \Hyde\Console\Commands\MakePublicationTagCommand
+ * @covers \Hyde\Console\Commands\Helpers\InputStreamHandler {@todo Extract this to a separate test class}
+ */
+class MakePublicationTagCommandTest extends TestCase
+{
+    protected function tearDown(): void
+    {
+        unlink(Hyde::path('tags.json'));
+
+        parent::tearDown();
+    }
+
+    public function testCanCreateNewPublicationTag()
+    {
+        InputStreamHandler::mockInput("foo\nbar\nbaz\n");
+
+        $this->artisan('make:publicationTag')
+            ->expectsQuestion('Tag name', 'foo')
+            ->expectsOutput('Enter the tag values: (end with an empty line)')
+            ->expectsOutput('Adding the following tags:')
+            ->expectsOutput('  foo: foo, bar, baz')
+            ->expectsOutput('Saving tag data to ['.Hyde::path('tags.json').']')
+            ->assertExitCode(0);
+
+        $this->assertFileExists(Hyde::path('tags.json'));
+        $this->assertSame(
+            json_encode(['foo' => ['foo', 'bar', 'baz']], 128),
+            file_get_contents(Hyde::path('tags.json'))
+        );
+    }
+
+    public function testCanCreateNewPublicationTagWithTagNameArgument()
+    {
+        InputStreamHandler::mockInput("foo\nbar\nbaz\n");
+
+        $this->artisan('make:publicationTag foo')
+            ->expectsOutput('Using tag name [foo] from command line argument')
+            ->expectsOutput('Enter the tag values: (end with an empty line)')
+            ->expectsOutput('Adding the following tags:')
+            ->expectsOutput('  foo: foo, bar, baz')
+            ->expectsOutput('Saving tag data to ['.Hyde::path('tags.json').']')
+            ->assertExitCode(0);
+
+        $this->assertFileExists(Hyde::path('tags.json'));
+        $this->assertSame(
+            json_encode(['foo' => ['foo', 'bar', 'baz']], 128),
+            file_get_contents(Hyde::path('tags.json'))
+        );
+    }
+
+    public function testCommandFailsIfTagNameIsAlreadySet()
+    {
+        InputStreamHandler::mockInput("foo\nbar\nbaz\n");
+
+        $this->artisan('make:publicationTag foo')
+             ->assertExitCode(0);
+
+        InputStreamHandler::mockInput("foo\nbar\nbaz\n");
+
+        $this->artisan('make:publicationTag foo')
+            ->expectsOutput('Error: Tag [foo] already exists')
+             ->assertExitCode(1);
+    }
+
+    public function testCanTerminateWithCarriageReturns()
+    {
+        InputStreamHandler::mockInput("foo\r\nbar\r\nbaz\r\n");
+
+        $this->artisan('make:publicationTag foo')->assertExitCode(0);
+    }
+
+    public function testCanTerminateWithUnixEndings()
+    {
+        InputStreamHandler::mockInput("foo\nbar\nbaz\n");
+
+        $this->artisan('make:publicationTag foo')->assertExitCode(0);
+    }
+}