Fix/Directory access errors (#218)

Author: EgzonArifi

Lingua-App/Lingua/Lingua/Utils/Components/UI/ValidatingTextField.swift

@@ -37,8 +37,9 @@ struct ValidatingTextField: View {
     VStack(alignment: .leading, spacing: 5) {
       TextField(title, text: $localText)
         .disabled(isDisabled)
-        .cornerRadius(8)
         .focused($isFocused)
+        .frame(minHeight: 20)
+        .padding(.trailing)
         .onChange(of: isFocused) { focused in
           if !focused {
             validate()
@@ -51,6 +52,10 @@ struct ValidatingTextField: View {
           .font(.caption)
       }
     }
+    .contentShape(Rectangle())
+    .onTapGesture {
+      isFocused = true
+    }
     .onAppear {
       isValid = validation.validate(text)
     }

Sources/LinguaLib/Infrastructure/DirectoryOperations/DirectoryOperable.swift

@@ -14,13 +14,25 @@ public final class DirectoryOperator: DirectoryOperable {
   }
 
   public func createDirectory(named directoryName: String, in outputDirectory: String) throws -> URL {
-    let mainFolder = URL(fileURLWithPath: outputDirectory)
+    guard !directoryName.isEmpty else {
+      throw DirectoryOperationError.folderCreationFailed("Directory name is empty.")
+    }
+    
+    guard let decodedPath = outputDirectory.removingPercentEncoding else {
+      throw DirectoryOperationError.folderCreationFailed("Invalid output directory path.")
+    }
+    
+    let mainFolder = URL(fileURLWithPath: decodedPath)
     let outputFolder = mainFolder.appendingPathComponent(directoryName)
+    
     do {
       try fileManagerProvider.manager.createDirectory(at: outputFolder, withIntermediateDirectories: true, attributes: nil)
+    } catch let error as DirectoryOperationError {
+      throw error
     } catch {
-      throw DirectoryOperationError.folderCreationFailed
+      throw DirectoryOperationError.folderCreationFailed(error.localizedDescription)
     }
+    
     return outputFolder
   }
 
@@ -32,8 +44,10 @@ public final class DirectoryOperator: DirectoryOperable {
     for fileURL in fileURLs where fileURL.lastPathComponent.hasPrefix(prefix) {
       do {
         try fileManager.removeItem(at: fileURL)
+      } catch let error as DirectoryOperationError {
+        throw error
       } catch {
-        throw DirectoryOperationError.removeItemFailed
+        throw DirectoryOperationError.removeItemFailed(error.localizedDescription)
       }
     }
   }
@@ -47,7 +61,7 @@ public final class DirectoryOperator: DirectoryOperable {
       do {
         try fileManager.removeItem(at: fileURL)
       } catch {
-        throw DirectoryOperationError.removeItemFailed
+        throw DirectoryOperationError.removeItemFailed(error.localizedDescription)
       }
     }
   }

Sources/LinguaLib/Infrastructure/DirectoryOperations/DirectoryOperationError.swift

@@ -1,15 +1,15 @@
 import Foundation
 
-public enum DirectoryOperationError: LocalizedError {
-  case folderCreationFailed
-  case removeItemFailed
+public enum DirectoryOperationError: LocalizedError, Equatable {
+  case folderCreationFailed(String)
+  case removeItemFailed(String)
 
   public var errorDescription: String? {
     switch self {
-    case .folderCreationFailed:
-      return "Failed to create the folder in given directory"
-    case .removeItemFailed:
-      return "Failed to remove item in this folder"
+    case .folderCreationFailed(let error):
+      return "Failed to create the folder in given directory.\nReason: \(error)"
+    case .removeItemFailed(let error):
+      return "Failed to remove item in this folder.\nReason: \(error)"
     }
   }
 }

Sources/LinguaLib/Infrastructure/LocalizationGenerator/Generator/PlatformLocalizationGenerator.swift

@@ -11,8 +11,8 @@ final class PlatformLocalizationGenerator: PlatformLocalizationGenerating {
   }
 
   func generateLocalizationFiles(data: [LocalizationSheet], config: Config.Localization) throws {
-    data.forEach { data in
-      try? localizedFileGenerator.generate(for: data, config: config)
+    try data.forEach { data in
+      try localizedFileGenerator.generate(for: data, config: config)
     }
   }
 }

Tests/LinguaTests/Application/Processor/LocalizationProcessorTests.swift

@@ -35,7 +35,7 @@ final class LocalizationProcessorTests: XCTestCase {
   }
 
   func test_process_throwsErrorWhenModuleLocalizationFails() async throws {
-    let localizationModule = MockLocalizationModule(shouldThrow: true)
+    let localizationModule = MockLocalizationModule(errorMessage: "Error_message")
     let (sut, actors) = makeSUT(localizationModule: localizationModule)
     let tempDirectoryURL = try createTemporaryDirectoryURL()
     let configPath = try createTemporaryConfigFile(data: createConfigData(in: tempDirectoryURL), tempDirectoryURL: tempDirectoryURL)
@@ -47,7 +47,7 @@ final class LocalizationProcessorTests: XCTestCase {
       XCTAssertEqual(actors.logger.messages, [.message(message: "Loading configuration file...", level: .info),
                                               .message(message: "Initializing localization module...", level: .info),
                                               .message(message: "Starting localization...", level: .info),
-                                              .message(message: DirectoryOperationError.folderCreationFailed.localizedDescription, level: .error)])
+                                              .message(message: DirectoryOperationError.folderCreationFailed("Error_message").localizedDescription, level: .error)])
       XCTAssertEqual(actors.mockLocalizationModule.messages, [])
     }
   }
@@ -85,7 +85,7 @@ private extension LocalizationProcessorTests {
     let mockLocalizationModule: MockLocalizationModule
   }
 
-  func makeSUT(localizationModule: MockLocalizationModule = MockLocalizationModule(),
+  func makeSUT(localizationModule: MockLocalizationModule = MockLocalizationModule(errorMessage: .none),
                configFileGenerator: ConfigInitialFileGenerating = ConfigInitialFileGenerator.make()) -> (sut: LocalizationProcessor, actors: Actors) {
     let argumentParser = CommandLineParser()
     let logger = MockLogger()

Tests/LinguaTests/Application/Processor/Mock/MockLocalizationModule.swift

@@ -6,15 +6,15 @@ final class MockLocalizationModule: ModuleLocalizing {
     case localize(LocalizationPlatform)
   }
   private(set) var messages = [Message]()
-  private let shouldThrow: Bool
+  private let errorMessage: String?
 
-  init(shouldThrow: Bool = false) {
-    self.shouldThrow = shouldThrow
+  init(errorMessage: String?) {
+    self.errorMessage = errorMessage
   }
 
   func localize(for platform: LocalizationPlatform) async throws {
-    if shouldThrow {
-      throw DirectoryOperationError.folderCreationFailed
+    if let errorMessage {
+      throw DirectoryOperationError.folderCreationFailed(errorMessage)
     }
     messages.append(.localize(platform))
   }

Tests/LinguaTests/Infrastructure/DirectoryOperations/DirectoryOperatorTests.swift

@@ -13,13 +13,25 @@ final class DirectoryOperatorTests: XCTestCase {
 
   func test_createDirectory_throwsError_onFailure() {
     let errorFileManager = MockFileManager()
-    errorFileManager.shouldThrowErrorOnCreateDirectory = true
+    errorFileManager.onCreateDirectoryError = "Create_failed"
     let sut = makeSUT(fileManager: errorFileManager)
     let outputDirectory = NSTemporaryDirectory()
     let directoryName = "TestDirectory"
 
     XCTAssertThrowsError(try sut.createDirectory(named: directoryName, in: outputDirectory)) { error in
-      XCTAssertEqual(error as? DirectoryOperationError, DirectoryOperationError.folderCreationFailed)
+      XCTAssertEqual((error as? DirectoryOperationError), DirectoryOperationError.folderCreationFailed("Create_failed"))
+    }
+  }
+  
+  func test_createDirectory_throwsError_onEmptyDirectory() {
+    let errorFileManager = MockFileManager()
+    errorFileManager.onCreateDirectoryError = "Directory name is empty."
+    let sut = makeSUT(fileManager: errorFileManager)
+    let outputDirectory = NSTemporaryDirectory()
+    let directoryName = ""
+    
+    XCTAssertThrowsError(try sut.createDirectory(named: directoryName, in: outputDirectory)) { error in
+      XCTAssertEqual((error as? DirectoryOperationError)?.errorDescription, DirectoryOperationError.folderCreationFailed("Directory name is empty.").errorDescription)
     }
   }
 
@@ -47,7 +59,7 @@ final class DirectoryOperatorTests: XCTestCase {
 
   func test_removeFiles_throwsError_onRemoveItem() throws {
     let errorFileManager = MockFileManager()
-    errorFileManager.shouldThrowErrorOnRemoveItem = true
+    errorFileManager.onRemoveItemError = "Remove_failed"
     let sut = makeSUT(fileManager: errorFileManager)
     let outputDirectory = NSTemporaryDirectory()
     let directoryName = "TestDirectory"
@@ -64,7 +76,7 @@ final class DirectoryOperatorTests: XCTestCase {
     // Test the error case
     XCTAssertThrowsError(try sut.removeFiles(withPrefix: .packageName, in: createdDirectoryURL)) { error in
       XCTAssertEqual((error as? DirectoryOperationError)?.localizedDescription,
-                     DirectoryOperationError.removeItemFailed.localizedDescription)
+                     DirectoryOperationError.removeItemFailed("Remove_failed").localizedDescription)
     }
   }
 }

Tests/LinguaTests/Infrastructure/DirectoryOperations/Mock/MockFileManager.swift

@@ -3,8 +3,8 @@ import Foundation
 
 final class MockFileManager: FileManager {
   let files: [String]
-  var shouldThrowErrorOnRemoveItem = false
-  var shouldThrowErrorOnCreateDirectory = false
+  var onRemoveItemError: String?
+  var onCreateDirectoryError: String?
 
   init(files: [String] = []) {
     self.files = files
@@ -17,16 +17,16 @@ final class MockFileManager: FileManager {
   override func createDirectory(at url: URL,
                                 withIntermediateDirectories createIntermediates: Bool,
                                 attributes: [FileAttributeKey : Any]? = nil) throws {
-    if shouldThrowErrorOnCreateDirectory {
-      throw DirectoryOperationError.folderCreationFailed
+    if let onCreateDirectoryError {
+      throw DirectoryOperationError.folderCreationFailed(onCreateDirectoryError)
     } else {
       try super.createDirectory(at: url, withIntermediateDirectories: createIntermediates, attributes: attributes)
     }
   }
 
   override func removeItem(at URL: URL) throws {
-    if shouldThrowErrorOnRemoveItem {
-      throw NSError(domain: NSCocoaErrorDomain, code: NSFileWriteUnknownError, userInfo: nil)
+    if let onRemoveItemError {
+      throw DirectoryOperationError.removeItemFailed(onRemoveItemError)
     } else {
       try super.removeItem(at: URL)
     }

Tests/LinguaTests/Infrastructure/LocalizationGenerator/Generator/ConfigInitialFileGeneratorTests.swift

@@ -16,7 +16,7 @@ final class ConfigInitialFileGeneratorTests: XCTestCase {
   }
 
   func test_generate_throwsErrorOnFailure() {
-    let (sut, _) = makeSUT(shouldFail: true)
+    let (sut, _) = makeSUT(shouldFail: "error")
 
     XCTAssertThrowsError(try sut.generate())
   }
@@ -38,9 +38,9 @@ private extension ConfigInitialFileGeneratorTests {
     let fileName: String
   }
 
-  func makeSUT(shouldFail: Bool = false, encoder: JSONEncoding? = nil) -> (sut: ConfigInitialFileGenerator, actors: Actors) {
+  func makeSUT(shouldFail: String? = .none, encoder: JSONEncoding? = nil) -> (sut: ConfigInitialFileGenerator, actors: Actors) {
     let contentFilesCreator = MockContentFilesCreator()
-    contentFilesCreator.shouldThrowError = shouldFail
+    contentFilesCreator.errorMessage = shouldFail
     let config = Config.createTemplateConfig()
     let transformer = ConfigTransformer()
     let fileName = "config.json"

Tests/LinguaTests/Infrastructure/LocalizationGenerator/Generator/LocalizedPlatformFilesGeneratorTests.swift

@@ -3,7 +3,7 @@ import XCTest
 
 final class LocalizedPlatformFilesGeneratorTests: XCTestCase {
   func test_createPlatformFiles_createsFilesSuccessfully() throws {
-    let (contentGenerator, filesCreator) = makeContentGeneratorAndCreator()
+    let (contentGenerator, filesCreator) = makeContentGeneratorAndCreator(filesCreatorThrownErrorMessage: .none)
     let fileExtension = "txt"
     let fileNameGenerator = MockPlatformFilesNameGenerator(fileExtension: fileExtension)
     let sut = makeSUT(contentGenerator: contentGenerator, filesCreator: filesCreator, fileNameGenerator: fileNameGenerator)
@@ -18,7 +18,7 @@ final class LocalizedPlatformFilesGeneratorTests: XCTestCase {
   }
 
   func test_createPlatformFiles_throwsErrorAndLogsMessage_onCreateFilesFailure() {
-    let (contentGenerator, filesCreator) = makeContentGeneratorAndCreator(shouldFilesCreatorThrowError: true)
+    let (contentGenerator, filesCreator) = makeContentGeneratorAndCreator(filesCreatorThrownErrorMessage: "Error_message")
     let sut = makeSUT(contentGenerator: contentGenerator, filesCreator: filesCreator)
     let entries: [LocalizationEntry] = [.create(plural: true)]
     let outputFolder = URL(fileURLWithPath: NSTemporaryDirectory())
@@ -27,17 +27,17 @@ final class LocalizedPlatformFilesGeneratorTests: XCTestCase {
                                                      sectionName: "SectionName",
                                                      outputFolder: outputFolder,
                                                      language: "en")) { error in
-      XCTAssertEqual(error as? DirectoryOperationError, DirectoryOperationError.folderCreationFailed)
+      XCTAssertEqual(error as? DirectoryOperationError, DirectoryOperationError.folderCreationFailed("Error_message"))
     }
   }
 
   func makeContentGeneratorAndCreator(
-    shouldFilesCreatorThrowError: Bool = false
+    filesCreatorThrownErrorMessage: String?
   ) -> (contentGenerator: MockLocalizedContentGenerator, filesCreator: MockContentFilesCreator) {
     let contentGenerator = MockLocalizedContentGenerator()
     contentGenerator.content = ("stringsContent", "stringsDictContent")
     let filesCreator = MockContentFilesCreator()
-    filesCreator.shouldThrowError = shouldFilesCreatorThrowError
+    filesCreator.errorMessage = filesCreatorThrownErrorMessage
     return (contentGenerator, filesCreator)
   }
 }