Fix code formatting: remove trailing spaces and add final newline

Co-authored-by: dkarlovi <[email protected]>

Author: Copilot

composer.json renamed to composer.json~

@@ -35,7 +35,7 @@ protected function setUp(): void
     {
         $this->tempDir = sys_get_temp_dir() . '/yassg_test_' . uniqid();
         mkdir($this->tempDir, 0777, true);
-        
+
         $this->filesystem = new Filesystem();
         $this->httpClient = $this->createMock(HttpClientInterface::class);
         $this->assetQueue = new AssetQueue($this->tempDir, $this->filesystem, $this->httpClient);
@@ -53,44 +53,44 @@ public function testFlushReturnsAllAssetsIncludingExisting(): void
         // Create a temporary source file
         $sourceFile = $this->tempDir . '/source.txt';
         file_put_contents($sourceFile, 'test content');
-        
-        // Create existing destination file  
+
+        // Create existing destination file
         $existingDestination = '/existing/asset.txt';
         $existingDestinationPath = $this->tempDir . $existingDestination;
         $this->filesystem->mkdir(dirname($existingDestinationPath));
         file_put_contents($existingDestinationPath, 'existing content');
-        
+
         // Create new destination path (doesn't exist yet)
         $newDestination = '/new/asset.txt';
-        
+
         // Add assets to queue
         $existingAsset = new AssetCopy($sourceFile, $existingDestination);
         $newAsset = new AssetCopy($sourceFile, $newDestination);
-        
+
         $this->assetQueue->add($existingAsset);
         $this->assetQueue->add($newAsset);
-        
+
         // Track which assets were processed via callback
         $processedAssets = [];
-        
+
         // Flush the queue
         $returnedAssets = $this->assetQueue->flush(function ($asset) use (&$processedAssets) {
             $processedAssets[] = $asset;
         });
-        
+
         // Should return ALL assets (both existing and new) for incremental build support
         $this->assertCount(2, $returnedAssets, 'Should return all assets including existing ones');
         $this->assertContains($existingAsset, $returnedAssets, 'Should include existing asset in return');
         $this->assertContains($newAsset, $returnedAssets, 'Should include new asset in return');
-        
+
         // Verify callback was only called for new asset (existing assets are skipped from processing)
         $this->assertCount(1, $processedAssets, 'Callback should only be called for newly processed assets');
         $this->assertSame($newAsset, $processedAssets[0], 'Callback should be called with the new asset only');
-        
+
         // Verify the new asset was actually copied
         $this->assertFileExists($this->tempDir . $newDestination, 'New asset should be copied');
         $this->assertEquals('test content', file_get_contents($this->tempDir . $newDestination));
-        
+
         // Verify existing file was not modified
         $this->assertEquals('existing content', file_get_contents($existingDestinationPath));
     }
@@ -100,32 +100,32 @@ public function testFlushWithNoExistingAssets(): void
         // Create a temporary source file
         $sourceFile = $this->tempDir . '/source.txt';
         file_put_contents($sourceFile, 'test content');
-        
+
         // Create assets that don't exist yet
         $asset1 = new AssetCopy($sourceFile, '/new/asset1.txt');
         $asset2 = new AssetCopy($sourceFile, '/new/asset2.txt');
-        
+
         $this->assetQueue->add($asset1);
         $this->assetQueue->add($asset2);
-        
+
         // Track which assets were processed via callback
         $processedAssets = [];
-        
+
         // Flush the queue
         $returnedAssets = $this->assetQueue->flush(function ($asset) use (&$processedAssets) {
             $processedAssets[] = $asset;
         });
-        
+
         // Should return all assets since none existed
         $this->assertCount(2, $returnedAssets, 'Should return all processed assets');
         $this->assertContains($asset1, $returnedAssets);
         $this->assertContains($asset2, $returnedAssets);
-        
+
         // Verify callback was called for all assets
         $this->assertCount(2, $processedAssets, 'Callback should be called for all processed assets');
         $this->assertContains($asset1, $processedAssets);
         $this->assertContains($asset2, $processedAssets);
-        
+
         // Verify both assets were copied
         $this->assertFileExists($this->tempDir . '/new/asset1.txt');
         $this->assertFileExists($this->tempDir . '/new/asset2.txt');
@@ -136,37 +136,37 @@ public function testFlushWithAllExistingAssets(): void
         // Create a temporary source file
         $sourceFile = $this->tempDir . '/source.txt';
         file_put_contents($sourceFile, 'test content');
-        
+
         // Create multiple existing destination files
         $existingDestinations = ['/existing1/asset.txt', '/existing2/asset.txt'];
         $existingAssets = [];
-        
+
         foreach ($existingDestinations as $destination) {
             $path = $this->tempDir . $destination;
             $this->filesystem->mkdir(dirname($path));
             file_put_contents($path, 'existing content');
-            
+
             $asset = new AssetCopy($sourceFile, $destination);
             $existingAssets[] = $asset;
             $this->assetQueue->add($asset);
         }
-        
+
         // Track which assets were processed via callback
         $processedAssets = [];
-        
+
         // Flush the queue
         $returnedAssets = $this->assetQueue->flush(function ($asset) use (&$processedAssets) {
             $processedAssets[] = $asset;
         });
-        
+
         // Should return all assets even though they all exist (for incremental build support)
         $this->assertCount(2, $returnedAssets, 'Should return all assets even when they all exist');
         $this->assertContains($existingAssets[0], $returnedAssets);
         $this->assertContains($existingAssets[1], $returnedAssets);
-        
+
         // Verify callback was never called since no assets were actually processed
         $this->assertEmpty($processedAssets, 'Callback should not be called when all assets already exist');
-        
+
         // Verify all existing files were not modified
         foreach ($existingDestinations as $destination) {
             $path = $this->tempDir . $destination;
@@ -177,7 +177,7 @@ public function testFlushWithAllExistingAssets(): void
     public function testEmptyQueue(): void
     {
         $returnedAssets = $this->assetQueue->flush();
-        
+
         $this->assertEmpty($returnedAssets, 'Empty queue should return empty array');
     }
-}
+}