How To Read Journal Article Date

@@ -337,12 +337,13 @@ await nugetConfigPrompter.PromptToCreateOrUpdateAsync(
  var appHostProjectDir = appHostProjects[0];
  var serviceDefaultsProjectDir = serviceDefaultsProjects[0];
 
- // Move the projects to the solution directory
+ // Copy the projects to the solution directory
+ // Using copy instead of move to support cross-drive operations on Windows
  var finalAppHostDir = Path.Combine(initContext.SolutionDirectory.FullName, appHostProjectDir.Name);
  var finalServiceDefaultsDir = Path.Combine(initContext.SolutionDirectory.FullName, serviceDefaultsProjectDir.Name);
 
- Directory.Move(appHostProjectDir.FullName, finalAppHostDir);
- Directory.Move(serviceDefaultsProjectDir.FullName, finalServiceDefaultsDir);
+ FileSystemHelper.CopyDirectory(appHostProjectDir.FullName, finalAppHostDir);
+ FileSystemHelper.CopyDirectory(serviceDefaultsProjectDir.FullName, finalServiceDefaultsDir);
 
  var appHostProjectFile = new FileInfo(Path.Combine(finalAppHostDir, $"{appHostProjectDir.Name}.csproj"));
  var serviceDefaultsProjectFile = new FileInfo(Path.Combine(finalServiceDefaultsDir, $"{serviceDefaultsProjectDir.Name}.csproj"));

How To Launch A New Brand On Social Media

@@ -0,0 +1,51 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Aspire.Cli.Utils;
+
+/// <summary>
+/// Helper class for file system operations.
+/// </summary>
+internal static class FileSystemHelper
+{
+ /// <summary>
+ /// Copies an entire directory and its contents to a new location.
+ /// </summary>
+ internal static void CopyDirectory(string sourceDir, string destinationDir)
+ {
+ ArgumentException.ThrowIfNullOrEmpty(sourceDir);
+ ArgumentException.ThrowIfNullOrEmpty(destinationDir);
+
+ var sourceDirInfo = new DirectoryInfo(sourceDir);
+ if (!sourceDirInfo.Exists)
+ {
+ throw new DirectoryNotFoundException($"Source directory not found: {sourceDir}");
+ }
+
+ // Use a stack to avoid recursion and potential stack overflow with deep directory structures
+ var stack = new Stack<(DirectoryInfo Source, string Destination)>();
+ stack.Push((sourceDirInfo, destinationDir));
+
+ while (stack.Count > 0)
+ {
+ var (currentSource, currentDestination) = stack.Pop();
+
+ // Create the destination directory if it doesn't exist
+ Directory.CreateDirectory(currentDestination);
+
+ // Copy all files in the current directory
+ foreach (var file in currentSource.GetFiles())
+ {
+ var targetFilePath = Path.Combine(currentDestination, file.Name);
+ file.CopyTo(targetFilePath, overwrite: false);
+ }
+
+ // Push all subdirectories onto the stack
+ foreach (var subDir in currentSource.GetDirectories())
+ {
+ var targetSubDir = Path.Combine(currentDestination, subDir.Name);
+ stack.Push((subDir, targetSubDir));
+ }
+ }
+ }
+}

News Section Layout Website

@@ -0,0 +1,202 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Aspire.Cli.Utils;
+
+namespace Aspire.Cli.Tests.Utils;
+
+public class FileSystemHelperTests(ITestOutputHelper outputHelper)
+{
+ [Fact]
+ public void CopyDirectory_WithSimpleFiles_CopiesAllFiles()
+ {
+ // Arrange
+ using var workspace = TemporaryWorkspace.Create(outputHelper);
+ var sourceDir = workspace.CreateDirectory("source");
+ var destDir = Path.Combine(workspace.WorkspaceRoot.FullName, "destination");
+
+ // Create some test files
+ File.WriteAllText(Path.Combine(sourceDir.FullName, "file1.txt"), "content1");
+ File.WriteAllText(Path.Combine(sourceDir.FullName, "file2.txt"), "content2");
+ File.WriteAllText(Path.Combine(sourceDir.FullName, "file3.cs"), "using System;");
+
+ // Act
+ FileSystemHelper.CopyDirectory(sourceDir.FullName, destDir);
+
+ // Assert
+ Assert.True(Directory.Exists(destDir));
+ Assert.True(File.Exists(Path.Combine(destDir, "file1.txt")));
+ Assert.True(File.Exists(Path.Combine(destDir, "file2.txt")));
+ Assert.True(File.Exists(Path.Combine(destDir, "file3.cs")));
+
+ Assert.Equal("content1", File.ReadAllText(Path.Combine(destDir, "file1.txt")));
+ Assert.Equal("content2", File.ReadAllText(Path.Combine(destDir, "file2.txt")));
+ Assert.Equal("using System;", File.ReadAllText(Path.Combine(destDir, "file3.cs")));
+ }
+
+ [Fact]
+ public void CopyDirectory_WithSubdirectories_CopiesRecursively()
+ {
+ // Arrange
+ using var workspace = TemporaryWorkspace.Create(outputHelper);
+ var sourceDir = workspace.CreateDirectory("source");
+ var destDir = Path.Combine(workspace.WorkspaceRoot.FullName, "destination");
+
+ // Create nested directory structure
+ var subDir1 = sourceDir.CreateSubdirectory("subdir1");
+ var subDir2 = subDir1.CreateSubdirectory("subdir2");
+
+ File.WriteAllText(Path.Combine(sourceDir.FullName, "root.txt"), "root content");
+ File.WriteAllText(Path.Combine(subDir1.FullName, "level1.txt"), "level 1 content");
+ File.WriteAllText(Path.Combine(subDir2.FullName, "level2.txt"), "level 2 content");
+
+ // Act
+ FileSystemHelper.CopyDirectory(sourceDir.FullName, destDir);
+
+ // Assert
+ Assert.True(Directory.Exists(destDir));
+ Assert.True(File.Exists(Path.Combine(destDir, "root.txt")));
+ Assert.True(Directory.Exists(Path.Combine(destDir, "subdir1")));
+ Assert.True(File.Exists(Path.Combine(destDir, "subdir1", "level1.txt")));
+ Assert.True(Directory.Exists(Path.Combine(destDir, "subdir1", "subdir2")));
+ Assert.True(File.Exists(Path.Combine(destDir, "subdir1", "subdir2", "level2.txt")));
+
+ Assert.Equal("root content", File.ReadAllText(Path.Combine(destDir, "root.txt")));
+ Assert.Equal("level 1 content", File.ReadAllText(Path.Combine(destDir, "subdir1", "level1.txt")));
+ Assert.Equal("level 2 content", File.ReadAllText(Path.Combine(destDir, "subdir1", "subdir2", "level2.txt")));
+ }
+
+ [Fact]
+ public void CopyDirectory_WithEmptyDirectory_CreatesDestination()
+ {
+ // Arrange
+ using var workspace = TemporaryWorkspace.Create(outputHelper);
+ var sourceDir = workspace.CreateDirectory("empty_source");
+ var destDir = Path.Combine(workspace.WorkspaceRoot.FullName, "empty_destination");
+
+ // Act
+ FileSystemHelper.CopyDirectory(sourceDir.FullName, destDir);
+
+ // Assert
+ Assert.True(Directory.Exists(destDir));
+ Assert.Empty(Directory.GetFiles(destDir));
+ Assert.Empty(Directory.GetDirectories(destDir));
+ }
+
+ [Fact]
+ public void CopyDirectory_WithNonExistentSource_ThrowsDirectoryNotFoundException()
+ {
+ // Arrange
+ using var workspace = TemporaryWorkspace.Create(outputHelper);
+ var nonExistentSource = Path.Combine(workspace.WorkspaceRoot.FullName, "nonexistent");
+ var destDir = Path.Combine(workspace.WorkspaceRoot.FullName, "destination");
+
+ // Act & Assert
+ Assert.Throws<DirectoryNotFoundException>(() => 
+ FileSystemHelper.CopyDirectory(nonExistentSource, destDir));
+ }
+
+ [Fact]
+ public void CopyDirectory_WithNullSource_ThrowsArgumentNullException()
+ {
+ // Arrange
+ using var workspace = TemporaryWorkspace.Create(outputHelper);
+ var destDir = Path.Combine(workspace.WorkspaceRoot.FullName, "destination");
+
+ // Act & Assert
+ Assert.Throws<ArgumentNullException>(() => 
+ FileSystemHelper.CopyDirectory(null!, destDir));
+ }
+
+ [Fact]
+ public void CopyDirectory_WithNullDestination_ThrowsArgumentNullException()
+ {
+ // Arrange
+ using var workspace = TemporaryWorkspace.Create(outputHelper);
+ var sourceDir = workspace.CreateDirectory("source");
+
+ // Act & Assert
+ Assert.Throws<ArgumentNullException>(() => 
+ FileSystemHelper.CopyDirectory(sourceDir.FullName, null!));
+ }
+
+ [Fact]
+ public void CopyDirectory_WithEmptySource_ThrowsArgumentException()
+ {
+ // Arrange
+ using var workspace = TemporaryWorkspace.Create(outputHelper);
+ var destDir = Path.Combine(workspace.WorkspaceRoot.FullName, "destination");
+
+ // Act & Assert
+ Assert.Throws<ArgumentException>(() => 
+ FileSystemHelper.CopyDirectory(string.Empty, destDir));
+ }
+
+ [Fact]
+ public void CopyDirectory_WithEmptyDestination_ThrowsArgumentException()
+ {
+ // Arrange
+ using var workspace = TemporaryWorkspace.Create(outputHelper);
+ var sourceDir = workspace.CreateDirectory("source");
+
+ // Act & Assert
+ Assert.Throws<ArgumentException>(() => 
+ FileSystemHelper.CopyDirectory(sourceDir.FullName, string.Empty));
+ }
+
+ [Fact]
+ public void CopyDirectory_PreservesFileContent_WithBinaryFiles()
+ {
+ // Arrange
+ using var workspace = TemporaryWorkspace.Create(outputHelper);
+ var sourceDir = workspace.CreateDirectory("source");
+ var destDir = Path.Combine(workspace.WorkspaceRoot.FullName, "destination");
+
+ // Create a binary file with random content
+ var binaryFilePath = Path.Combine(sourceDir.FullName, "binary.dat");
+ var randomBytes = new byte[1024];
+ Random.Shared.NextBytes(randomBytes);
+ File.WriteAllBytes(binaryFilePath, randomBytes);
+
+ // Act
+ FileSystemHelper.CopyDirectory(sourceDir.FullName, destDir);
+
+ // Assert
+ var copiedFilePath = Path.Combine(destDir, "binary.dat");
+ Assert.True(File.Exists(copiedFilePath));
+
+ var copiedBytes = File.ReadAllBytes(copiedFilePath);
+ Assert.Equal(randomBytes, copiedBytes);
+ }
+
+ [Fact]
+ public void CopyDirectory_WithMultipleLevelsOfSubdirectories_CopiesAll()
+ {
+ // Arrange
+ using var workspace = TemporaryWorkspace.Create(outputHelper);
+ var sourceDir = workspace.CreateDirectory("source");
+ var destDir = Path.Combine(workspace.WorkspaceRoot.FullName, "destination");
+
+ // Create a deep directory structure
+ var current = sourceDir;
+ for (int i = 0; i < 5; i++)
+ {
+ current = current.CreateSubdirectory($"level{i}");
+ File.WriteAllText(Path.Combine(current.FullName, $"file{i}.txt"), $"content at level {i}");
+ }
+
+ // Act
+ FileSystemHelper.CopyDirectory(sourceDir.FullName, destDir);
+
+ // Assert
+ var currentDest = destDir;
+ for (int i = 0; i < 5; i++)
+ {
+ currentDest = Path.Combine(currentDest, $"level{i}");
+ Assert.True(Directory.Exists(currentDest));
+ var filePath = Path.Combine(currentDest, $"file{i}.txt");
+ Assert.True(File.Exists(filePath));
+ Assert.Equal($"content at level {i}", File.ReadAllText(filePath));
+ }
+ }
+}