wip

Author: rubenvanassche

src/Actions/DiscoverTypesAction.php

@@ -28,7 +28,7 @@ public function execute(
         return array_values(array_filter(array_map(function (string $discovered) {
             try {
                 return PhpClassNode::fromReflection(new ReflectionClass($discovered));
-            } catch (\ReflectionException) {
+            } catch (\Throwable) {
                 return null;
             }
         }, $discovered)));

src/Actions/TransformTypesAction.php

@@ -43,6 +43,7 @@ public function transformClassNode(
         if (count($node->getAttributes(Hidden::class)) > 0) {
             return null;
         }
+
         $transformationContext = TransformationContext::createFromPhpClass($node);
 
         foreach ($transformers as $transformer) {

src/Actions/WriteFilesAction.php

@@ -2,8 +2,10 @@
 
 namespace Spatie\TypeScriptTransformer\Actions;
 
+use JsonException;
 use Spatie\TypeScriptTransformer\Support\WriteableFile;
 use Spatie\TypeScriptTransformer\TypeScriptTransformerConfig;
+use Spatie\TypeScriptTransformer\Writers\MultipleFilesWriter;
 
 class WriteFilesAction
 {
@@ -12,13 +14,34 @@ public function __construct(
     ) {
     }
 
-    /** @param  array<WriteableFile>  $writeableFiles */
+    /** @param array<WriteableFile> $writeableFiles */
     public function execute(
         array $writeableFiles
     ): void {
+        $oldManifest = $this->fetchManifest();
+
         foreach ($writeableFiles as $writeableFile) {
+            if ($oldManifest !== null
+                && array_key_exists($writeableFile->path, $oldManifest)
+                && $oldManifest[$writeableFile->path] === $writeableFile->hash
+            ) {
+                continue;
+            }
+
             $this->writeFile($writeableFile);
         }
+
+        $writer = $this->config->writer;
+
+        if (! $writer instanceof MultipleFilesWriter) {
+            return;
+        }
+
+        $newManifest = $this->buildManifest($writeableFiles);
+
+        $this->deleteOldFiles($oldManifest, $newManifest);
+
+        $this->storeManifest($writer, $newManifest);
     }
 
     protected function writeFile(WriteableFile $file): void
@@ -31,4 +54,88 @@ protected function writeFile(WriteableFile $file): void
 
         file_put_contents($file->path, $file->contents);
     }
+
+    /** @return array<string, string>|null */
+    protected function fetchManifest(): ?array
+    {
+        $writer = $this->config->writer;
+
+        if (! $writer instanceof MultipleFilesWriter) {
+            return null;
+        }
+
+        $manifestPath = $this->getManifestPath($writer);
+
+        if (! file_exists($manifestPath)) {
+            return null;
+        }
+
+        $manifestContent = file_get_contents($manifestPath);
+
+        if ($manifestContent === false) {
+            return null;
+        }
+
+        try {
+            return json_decode($manifestContent, associative: true, flags: JSON_THROW_ON_ERROR);
+        } catch (JsonException) {
+            return null;
+        }
+    }
+
+    /**
+     * @param array<WriteableFile> $writeableFiles
+     *
+     * @return array<string, string>
+     */
+    protected function buildManifest(
+        array $writeableFiles,
+    ): array {
+        $manifest = [];
+
+        foreach ($writeableFiles as $writeableFile) {
+            $manifest[$writeableFile->path] = $writeableFile->hash;
+        }
+
+        return $manifest;
+    }
+
+    /**
+     * @param array<string, string>|null $oldManifest
+     * @param array<string, string> $newManifest
+     */
+    protected function deleteOldFiles(
+        ?array $oldManifest,
+        array $newManifest,
+    ): void {
+        if ($oldManifest === null) {
+            return;
+        }
+
+        $filesToDelete = array_keys(array_diff_key(
+            $oldManifest,
+            $newManifest,
+        ));
+
+        foreach ($filesToDelete as $fileToDelete) {
+            if (file_exists($fileToDelete)) {
+                unlink($fileToDelete);
+            }
+        }
+    }
+
+    protected function storeManifest(
+        MultipleFilesWriter $writer,
+        array $manifest,
+    ): void {
+        file_put_contents(
+            $this->getManifestPath($writer),
+            json_encode($manifest)
+        );
+    }
+
+    protected function getManifestPath(MultipleFilesWriter $writer): string
+    {
+        return "{$writer->getPath()}/typescript-transformer-manifest.json";
+    }
 }

src/Collections/TransformedCollection.php

@@ -7,6 +7,7 @@
 use IteratorAggregate;
 use Spatie\TypeScriptTransformer\References\FilesystemReference;
 use Spatie\TypeScriptTransformer\References\Reference;
+use Spatie\TypeScriptTransformer\Support\TypeScriptTransformerLog;
 use Spatie\TypeScriptTransformer\Transformed\Transformed;
 use Traversable;
 
@@ -21,22 +22,31 @@ class TransformedCollection implements IteratorAggregate
     /** @var array<string, Transformed> */
     protected array $fileMapping = [];
 
+    protected bool $requireCompleteRewrite = false;
+
+    protected TypeScriptTransformerLog $log;
+
     public function __construct(
         array $items = [],
     ) {
         $this->add(...$items);
+        $this->log = TypeScriptTransformerLog::instance();
     }
 
     public function add(Transformed ...$transformed): self
     {
         foreach ($transformed as $item) {
+            $this->log->debug($item, 'Adding transformed');
+
             $this->items[$item->reference->getKey()] = $item;
 
             if ($item->reference instanceof FilesystemReference) {
                 $this->fileMapping[$this->cleanupFilePath($item->reference->getFilesystemOriginPath())] = $item;
             }
         }
 
+        ray($this);
+
         return $this;
     }
 
@@ -54,10 +64,15 @@ public function remove(Reference|string $reference): void
     {
         $transformed = $this->get($reference);
 
+        $this->log->debug($reference, 'Removing reference');
+        $this->log->debug($transformed, 'Removing transformed');
+
         if ($transformed === null) {
             return;
         }
 
+        $this->log->debug($transformed->referencedBy, 'Marking references as missing');
+
         foreach (array_unique($transformed->referencedBy) as $referencedBy) {
             $referencedBy = $this->get($referencedBy);
 
@@ -72,6 +87,8 @@ public function remove(Reference|string $reference): void
 
             unset($this->fileMapping[$path]);
         }
+
+        ray($this);
     }
 
     public function getIterator(): Traversable
@@ -113,6 +130,10 @@ public function findTransformedByDirectory(string $path): Generator
 
     public function hasChanges(): bool
     {
+        if ($this->requireCompleteRewrite) {
+            return true;
+        }
+
         foreach ($this->items as $item) {
             if ($item->changed) {
                 return true;
@@ -122,6 +143,16 @@ public function hasChanges(): bool
         return false;
     }
 
+    public function requireCompleteRewrite(): void
+    {
+        $this->requireCompleteRewrite = true;
+    }
+
+    public function rewriteExecuted(): void
+    {
+        $this->requireCompleteRewrite = false;
+    }
+
     protected function cleanupFilePath(string $path): string
     {
         return realpath($path);

src/FileSystemWatcher.php

@@ -9,6 +9,7 @@
 use Spatie\TypeScriptTransformer\Events\Watch\FileDeletedWatchEvent;
 use Spatie\TypeScriptTransformer\Events\Watch\FileUpdatedWatchEvent;
 use Spatie\TypeScriptTransformer\Events\Watch\WatchEvent;
+use Spatie\TypeScriptTransformer\Handlers\Watch\DirectoryDeletedWatchEventHandler;
 use Spatie\TypeScriptTransformer\Handlers\Watch\FileDeletedWatchEventHandler;
 use Spatie\TypeScriptTransformer\Handlers\Watch\FileUpdatedOrCreatedWatchEventHandler;
 use Spatie\TypeScriptTransformer\Handlers\Watch\WatchEventHandler;
@@ -70,7 +71,7 @@ public function run(): void
             });
 
         try {
-            $this->typeScriptTransformer->log->info('Starting watcher');
+            $this->typeScriptTransformer->log->info('Now watching for changes ...');
 
             $watcher->start();
         } catch (CouldNotStartWatcher $e) {
@@ -82,8 +83,6 @@ public function run(): void
 
     protected function initializeHandlers(): void
     {
-        // TODO: handle directory deleted
-
         $this->handlers[FileCreatedWatchEvent::class] = new FileUpdatedOrCreatedWatchEventHandler(
             $this->typeScriptTransformer,
             $this->transformedCollection,
@@ -98,6 +97,11 @@ protected function initializeHandlers(): void
             $this->typeScriptTransformer,
             $this->transformedCollection,
         );
+
+        $this->handlers[DirectoryDeletedWatchEvent::class] = new DirectoryDeletedWatchEventHandler(
+            $this->typeScriptTransformer,
+            $this->transformedCollection,
+        );
     }
 
     protected function processBuffer(): void
@@ -127,8 +131,6 @@ protected function processBuffer(): void
         $this->typeScriptTransformer->outputTransformed(
             $this->transformedCollection,
         );
-
-        $this->typeScriptTransformer->log->info('Processed events');
     }
 
     protected function tryToConnectMissingReferencesWithNewTransformed(): void

src/Handlers/Watch/DirectoryDeletedWatchEventHandler.php

@@ -4,8 +4,12 @@
 
 use Spatie\TypeScriptTransformer\Collections\TransformedCollection;
 use Spatie\TypeScriptTransformer\Events\Watch\DirectoryDeletedWatchEvent;
+use Spatie\TypeScriptTransformer\Events\Watch\WatchEvent;
 use Spatie\TypeScriptTransformer\TypeScriptTransformer;
 
+/**
+ * @implements WatchEventHandler<DirectoryDeletedWatchEvent>
+ */
 class DirectoryDeletedWatchEventHandler implements WatchEventHandler
 {
     public function __construct(
@@ -15,10 +19,12 @@ public function __construct(
     }
 
     /**
-     * @param DirectoryDeletedWatchEvent $event
+     * @param WatchEvent $event
      */
     public function handle($event): void
     {
+        $this->typeScriptTransformer->log->debug($event->path, 'Directory Deleted');
+
         $transformedItems = $this->transformedCollection->findTransformedByDirectory($event->path);
 
         foreach ($transformedItems as $transformed) {

src/Handlers/Watch/FileDeletedWatchEventHandler.php

@@ -6,6 +6,9 @@
 use Spatie\TypeScriptTransformer\Events\Watch\FileDeletedWatchEvent;
 use Spatie\TypeScriptTransformer\TypeScriptTransformer;
 
+/**
+ * @implements  WatchEventHandler<FileDeletedWatchEvent>
+ */
 class FileDeletedWatchEventHandler implements WatchEventHandler
 {
     public function __construct(
@@ -14,11 +17,10 @@ public function __construct(
     ) {
     }
 
-    /**
-     * @param FileDeletedWatchEvent $event
-     */
     public function handle($event): void
     {
+        $this->typeScriptTransformer->log->debug($event->path, 'File Deleted');
+
         $transformed = $this->transformedCollection->findTransformedByFile($event->path);
 
         if ($transformed === null) {