wip

Author: rubenvanassche

src/Actions/TransformTypesAction.php

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

src/Handlers/Watch/DirectoryDeletedWatchEventHandler.php

@@ -6,6 +6,6 @@ class DirectoryDeletedWatchEventHandler implements WatchEventHandler
 {
     public function handle($event): void
     {
-
+        // TODO: Implement handle() method.
     }
 }

src/PhpNodes/PhpAttributeNode.php

@@ -3,10 +3,13 @@
 namespace Spatie\TypeScriptTransformer\PhpNodes;
 
 use ReflectionAttribute;
+use ReflectionMethod;
 use Roave\BetterReflection\Reflection\ReflectionAttribute as RoaveReflectionAttribute;
 
 class PhpAttributeNode
 {
+    protected ?array $arguments = null;
+
     public function __construct(
         public readonly ReflectionAttribute|RoaveReflectionAttribute $reflection
     ) {
@@ -22,9 +25,27 @@ public function getArguments(): array
         return $this->reflection->getArguments();
     }
 
+    public function hasArgument(string $name): bool
+    {
+        if ($this->arguments === null) {
+            $this->initializeArguments();
+        }
+
+        return array_key_exists($name, $this->arguments);
+    }
+
+    public function getArgument(string $name): mixed
+    {
+        if ($this->arguments === null) {
+            $this->initializeArguments();
+        }
+
+        return $this->arguments[$name] ?? null;
+    }
+
     public function newInstance(): object
     {
-        if($this->reflection instanceof ReflectionAttribute) {
+        if ($this->reflection instanceof ReflectionAttribute) {
             return $this->reflection->newInstance();
         }
 
@@ -33,4 +54,44 @@ public function newInstance(): object
         // TODO: maybe we can do a little better here
         return (new $className())($this->reflection->getArguments());
     }
+
+    /** @return array<string, mixed> */
+    protected function initializeArguments(): array
+    {
+        // TODO: this is a quickly written thing, test it to be sure it works
+        if ($this->arguments !== null) {
+            return $this->arguments;
+        }
+
+        $this->arguments = [];
+
+        $values = $this->getArguments();
+
+        foreach ($values as $name => $value) {
+            if (is_string($name)) {
+                $this->arguments[$name] = $value;
+                unset($values[$name]);
+            }
+        }
+
+        if (count($values) === 0) {
+            return $this->arguments;
+        }
+
+        $constructor = new ReflectionMethod($this->reflection->getName(), '__construct');
+
+        foreach ($constructor->getParameters() as $index => $param) {
+            if(array_key_exists($param->getName(), $this->arguments)) {
+                continue;
+            }
+
+            if(! array_key_exists($index, $values)) {
+                continue;
+            }
+
+            $this->arguments[$param->getName()] = $values[$index];
+        }
+
+        return $this->arguments;
+    }
 }

src/Support/TransformationContext.php

@@ -18,11 +18,15 @@ public function __construct(
     public static function createFromPhpClass(
         PhpClassNode $node
     ): TransformationContext {
-        $attributeArguments = ($node->getAttributes(TypeScript::class)[0] ?? null)?->getArguments() ?? [];
+        $attribute = $node->getAttributes(TypeScript::class)[0] ?? null;
 
-        $name = $attributeArguments['name'] ?? $node->getShortName();
+        $name = $attribute && $attribute->hasArgument('name')
+            ? $attribute->getArgument('name')
+            : $node->getShortName();
 
-        $nameSpaceSegments = $attributeArguments['location'] ?? explode('\\', $node->getNamespaceName());
+        $nameSpaceSegments = $attribute && $attribute->hasArgument('location')
+            ? $attribute->getArgument('location')
+            : explode('\\', $node->getNamespaceName());
 
         return new TransformationContext(
             $name,

src/Writers/ModuleWriter.php

@@ -27,14 +27,15 @@ public function output(TransformedCollection $collection): array
 
         $writtenFiles = [];
 
-        foreach ($locations as $location) {
-            if ($location->hasChanges() === false) {
-                continue;
-            }
+        // TODO: remove files which still exists due to previous run
 
+        foreach ($locations as $location) {
             $writtenFiles[] = $this->writeLocation($location, $collection);
         }
 
+        // TODO: we probably can be a bit smarter about this
+        // -> only write files which have changed
+
         return $writtenFiles;
     }
 

tests/Actions/TransformTypesActionTest.php

@@ -2,7 +2,6 @@
 
 use Spatie\TypeScriptTransformer\Actions\TransformTypesAction;
 use Spatie\TypeScriptTransformer\PhpNodes\PhpClassNode;
-use Spatie\TypeScriptTransformer\Support\TypeScriptTransformerLog;
 use Spatie\TypeScriptTransformer\Tests\Fakes\TypesToProvide\HiddenAttributedClass;
 use Spatie\TypeScriptTransformer\Tests\Fakes\TypesToProvide\SimpleClass;
 use Spatie\TypeScriptTransformer\Tests\Fakes\TypesToProvide\StringBackedEnum;
@@ -52,19 +51,3 @@
 
     expect($types)->toBeEmpty();
 });
-
-it('will log errors when a type cannot be reflected', function () {
-    $types = (new TransformTypesAction())->execute(
-        [
-            new AllClassTransformer(),
-        ],
-        [
-            PhpClassNode::fromClassString('NonExistentClass'),
-        ]
-    );
-
-    expect($types)->toBeEmpty();
-
-    expect(TypeScriptTransformerLog::resolve()->errorMessages)
-        ->toHaveCount(1);
-});