feat(RES-34): Fix plist font filename (#14)

Reviewed-on: #14

Sources/ResgenSwift/Strings/Stringium/Stringium.swift

@@ -1,114 +1,122 @@
 //
 //  Stringium.swift
-//  
+//
 //
 //  Created by Thibaut Schmitt on 10/01/2022.
 //
 
-import ToolCore
-import Foundation
 import ArgumentParser
+import Foundation
+import ToolCore
 
 struct Stringium: ParsableCommand {
-    
+
     // MARK: - Command Configuration
-    
+
     static var configuration = CommandConfiguration(
         abstract: "Generate strings with custom scripts.",
         version: ResgenSwiftVersion
     )
-    
+
     // MARK: - Static
-    
+
     static let toolName = "Stringium"
     static let defaultExtensionName = "String"
     static let noTranslationTag: String = "notranslation"
-    
+
     // MARK: - Command options
-    
+
     @OptionGroup var options: StringiumOptions
-    
+
     // MARK: - Run
-    
+
     mutating func run() {
         print("[\(Self.toolName)] Starting strings generation")
         print("[\(Self.toolName)] Will use inputFile \(options.inputFile) to generate strings for \(options.langs) (default lang: \(options.defaultLang)")
-        
+
         // Check requirements
         guard checkRequirements() else { return }
-        
+
         print("[\(Self.toolName)] Will generate strings")
-        
+
         // Parse input file
         let sections = TwineFileParser.parse(options.inputFile)
-        
+
         // Generate strings files
         print(options.xcStrings)
         if !options.xcStrings {
             print("[\(Self.toolName)] Will generate strings")
 
-            StringsFileGenerator.writeStringsFiles(sections: sections,
-                                                   langs: options.langs,
-                                                   defaultLang: options.defaultLang,
-                                                   tags: options.tags,
-                                                   outputPath: options.stringsFileOutputPath,
-                                                   inputFilenameWithoutExt: options.inputFilenameWithoutExt)
+            StringsFileGenerator.writeStringsFiles(
+                sections: sections,
+                langs: options.langs,
+                defaultLang: options.defaultLang,
+                tags: options.tags,
+                outputPath: options.stringsFileOutputPath,
+                inputFilenameWithoutExt: options.inputFilenameWithoutExt
+            )
         } else {
             print("[\(Self.toolName)] Will generate xcStrings")
-            StringsFileGenerator.writeXcStringsFiles(sections: sections,
-                                                     langs: options.langs,
-                                                     defaultLang: options.defaultLang,
-                                                     tags: options.tags,
-                                                     outputPath: options.stringsFileOutputPath,
-                                                     inputFilenameWithoutExt: options.inputFilenameWithoutExt)
+            StringsFileGenerator.writeXcStringsFiles(
+                sections: sections,
+                langs: options.langs,
+                defaultLang: options.defaultLang,
+                tags: options.tags,
+                outputPath: options.stringsFileOutputPath,
+                inputFilenameWithoutExt: options.inputFilenameWithoutExt
+            )
         }
 
         // Generate extension
-        StringsFileGenerator.writeExtensionFiles(sections: sections,
-                                                 defaultLang: options.defaultLang,
-                                                 tags: options.tags,
-                                                 staticVar: options.staticMembers,
-                                                 inputFilename: options.inputFilenameWithoutExt,
-                                                 extensionName: options.extensionName,
-                                                 extensionFilePath: options.extensionFilePath,
-                                                 extensionSuffix: options.extensionSuffix)
+        StringsFileGenerator.writeExtensionFiles(
+            sections: sections,
+            defaultLang: options.defaultLang,
+            tags: options.tags,
+            staticVar: options.staticMembers,
+            inputFilename: options.inputFilenameWithoutExt,
+            extensionName: options.extensionName,
+            extensionFilePath: options.extensionFilePath,
+            extensionSuffix: options.extensionSuffix
+        )
 
         print("[\(Self.toolName)] Strings generated")
     }
-    
+
     // MARK: - Requirements
-    
+
     private func checkRequirements() -> Bool {
         let fileManager = FileManager()
-        
+
         // Input file
         guard fileManager.fileExists(atPath: options.inputFile) else {
             let error = StringiumError.fileNotExists(options.inputFile)
             print(error.description)
-            Stringium.exit(withError: error)
+            Self.exit(withError: error)
         }
-        
+
         // Langs
         guard options.langs.isEmpty == false else {
             let error = StringiumError.langsListEmpty
             print(error.description)
-            Stringium.exit(withError: error)
+            Self.exit(withError: error)
         }
-        
+
         guard options.langs.contains(options.defaultLang) else {
             let error = StringiumError.defaultLangsNotInLangs
             print(error.description)
-            Stringium.exit(withError: error)
+            Self.exit(withError: error)
         }
-        
+
         // Check if needed to regenerate
-        guard GeneratorChecker.shouldGenerate(force: options.forceGeneration,
-                                              inputFilePath: options.inputFile,
-                                              extensionFilePath: options.extensionFilePath) else {
+        guard GeneratorChecker.shouldGenerate(
+            force: options.forceGeneration,
+            inputFilePath: options.inputFile,
+            extensionFilePath: options.extensionFilePath
+        ) else {
             print("[\(Self.toolName)] Strings are already up to date :) ")
             return false
         }
-        
+
         return true
     }
 }

Sources/ResgenSwift/Strings/Stringium/StringiumError.swift

@@ -8,27 +8,28 @@
 import Foundation
 
 enum StringiumError: Error {
+
     case fileNotExists(String)
     case langsListEmpty
     case defaultLangsNotInLangs
     case writeFile(String, String)
     case langNotDefined(String, String, Bool)
-    
+
     var description: String {
         switch self {
         case .fileNotExists(let filename):
             return "error: [\(Stringium.toolName)] File \(filename) does not exists "
-            
+
         case .langsListEmpty:
             return "error: [\(Stringium.toolName)] Langs list is empty"
-            
+
         case .defaultLangsNotInLangs:
             return "error: [\(Stringium.toolName)] Langs list does not contains the default lang"
-            
-        case .writeFile(let subErrorDescription, let filename):
+
+        case let .writeFile(subErrorDescription, filename):
             return "error: [\(Stringium.toolName)] An error occured while writing content to \(filename): \(subErrorDescription)"
-            
-        case .langNotDefined(let lang, let definitionName, let isReference):
+
+        case let .langNotDefined(lang, definitionName, isReference):
             if isReference {
                 return "error: [\(Stringium.toolName)] Reference are handled only by Twine. Please use it or remove reference from you strings file."
             }

Sources/ResgenSwift/Strings/Stringium/StringiumOptions.swift

@@ -5,31 +5,34 @@
 //  Created by Thibaut Schmitt on 10/01/2022.
 //
 
-import Foundation
 import ArgumentParser
+import Foundation
+
+// swiftlint:disable no_grouping_extension
 
 struct StringiumOptions: ParsableArguments {
+
     @Flag(name: [.customShort("f"), .customShort("F")], help: "Should force generation")
     var forceGeneration = false
 
     @Argument(help: "Input files where strings are defined.", transform: { $0.replaceTiltWithHomeDirectoryPath() })
     var inputFile: String
-    
+
     @Option(name: .customLong("output-path"), help: "Path where to strings file.", transform: { $0.replaceTiltWithHomeDirectoryPath() })
     fileprivate var outputPathRaw: String
-    
+
     @Option(name: .customLong("langs"), help: "Langs to generate.")
     fileprivate var langsRaw: String
-    
+
     @Option(help: "Default langs.")
     var defaultLang: String
-    
+
     @Option(name: .customLong("tags"), help: "Tags to generate.")
     fileprivate var tagsRaw: String = "ios iosonly iosOnly notranslation"
-    
+
     @Option(help: "Path where to generate the extension.", transform: { $0.replaceTiltWithHomeDirectoryPath() })
     var extensionOutputPath: String
-    
+
     @Option(help: "Tell if it will generate static properties or not")
     var staticMembers: Bool = false
 
@@ -38,7 +41,7 @@ struct StringiumOptions: ParsableArguments {
 
     @Option(help: "Extension name. If not specified, it will generate an String extension.")
     var extensionName: String = Stringium.defaultExtensionName
-    
+
     @Option(help: "Extension suffix: {extensionName}+{extensionSuffix}.swift")
     var extensionSuffix: String
 }
@@ -46,6 +49,7 @@ struct StringiumOptions: ParsableArguments {
 // MARK: - Private var getter
 
 extension StringiumOptions {
+
     var stringsFileOutputPath: String {
         var outputPath = outputPathRaw
         if outputPath.last == "/" {
@@ -53,13 +57,13 @@ extension StringiumOptions {
         }
         return outputPath
     }
-    
+
     var langs: [String] {
         langsRaw
             .split(separator: " ")
             .map { String($0) }
     }
-    
+
     var tags: [String] {
         tagsRaw
             .split(separator: " ")
@@ -70,14 +74,15 @@ extension StringiumOptions {
 // MARK: - Computed var
 
 extension StringiumOptions {
+
     var extensionFileName: String {
         "\(extensionName)+\(extensionSuffix).swift"
     }
-    
+
     var extensionFilePath: String {
         "\(extensionOutputPath)/\(extensionFileName)"
     }
-    
+
     var inputFilenameWithoutExt: String {
         URL(fileURLWithPath: inputFile)
             .deletingPathExtension()