Publish v1.0

Reviewed-on: #1

Sources/ResgenSwift/Strings/Generator/StringsFileGenerator.swift

@@ -0,0 +1,163 @@
+//
+//  StringsFileGenerator.swift
+//  
+//
+//  Created by Thibaut Schmitt on 04/01/2022.
+//
+
+import Foundation
+import ToolCore
+
+class StringsFileGenerator {
+    
+    // MARK: - Strings Files
+    
+    static func writeStringsFiles(sections: [Section], langs: [String], defaultLang: String, tags: [String], outputPath: String, inputFilenameWithoutExt: String) {
+        var stringsFilesContent = [String: String]()
+        for lang in langs {
+            stringsFilesContent[lang] = Self.generateStringsFileContent(lang: lang,
+                                                                        defaultLang: defaultLang,
+                                                                        tags: tags,
+                                                                        sections: sections)
+        }
+        
+        // Write strings file content
+        langs.forEach { lang in
+            guard let fileContent = stringsFilesContent[lang] else { return }
+            
+            let stringsFilePath = "\(outputPath)/\(lang).lproj/\(inputFilenameWithoutExt).strings"
+            let stringsFilePathURL = URL(fileURLWithPath: stringsFilePath)
+            do {
+                try fileContent.write(to: stringsFilePathURL, atomically: false, encoding: .utf8)
+            } catch (let error) {
+                let error = StringiumError.writeFile(error.localizedDescription, stringsFilePath)
+                print(error.localizedDescription)
+                Stringium.exit(withError: error)
+            }
+        }
+    }
+    
+    static func generateStringsFileContent(lang: String, defaultLang: String, tags inputTags: [String], sections: [Section]) -> String {
+        var stringsFileContent = """
+        /**
+         * Apple Strings File
+         * Generated by ResgenSwift \(ResgenSwiftVersion)
+         * Language: \(lang)
+         */\n
+        """
+        
+        sections.forEach { section in
+            // Check that at least one string will be generated
+            guard section.hasOneOrMoreMatchingTags(tags: inputTags) else {
+                return // Go to next section
+            }
+            
+            stringsFileContent += "\n/********** \(section.name) **********/\n\n"
+            section.definitions.forEach { definition in
+                var skipDefinition = false // Set to true if not matching tag
+                let translationOpt: String? = {
+                    // If no matching tag => skip
+                    if definition.hasOneOrMoreMatchingTags(inputTags: inputTags) == false {
+                        skipDefinition = true
+                        return nil
+                    }
+                    
+                    // If tags contains `noTranslationTag` => get default lang
+                    if definition.tags.contains(Stringium.noTranslationTag) {
+                        return definition.translations[defaultLang]
+                    }
+                    
+                    // Else: get specific lang
+                    return definition.translations[lang]
+                }()
+                
+                if let translation = translationOpt {
+                    stringsFileContent += "\"\(definition.name)\" = \"\(translation)\";\n\n"
+                } else if skipDefinition == false {
+                    let error = StringiumError.langNotDefined(lang, definition.name, definition.reference != nil)
+                    print(error.localizedDescription)
+                    Stringium.exit(withError: error)
+                }
+            }
+        }
+        
+        return stringsFileContent
+    }
+    
+    // MARK: - Extension file
+    
+    static func writeExtensionFiles(sections: [Section], defaultLang lang: String, tags: [String], staticVar: Bool, inputFilename: String, extensionName: String, extensionFilePath: String) {
+        // Get extension content
+        let extensionFileContent = Self.getExtensionContent(sections: sections,
+                                                            defaultLang: lang,
+                                                            tags: tags,
+                                                            staticVar: staticVar,
+                                                            inputFilename: inputFilename,
+                                                            extensionName: extensionName)
+        
+        // Write content
+        let extensionFilePathURL = URL(fileURLWithPath: extensionFilePath)
+        do {
+            try extensionFileContent.write(to: extensionFilePathURL, atomically: false, encoding: .utf8)
+        } catch (let error) {
+            let error = StringiumError.writeFile(extensionFilePath, error.localizedDescription)
+            print(error.localizedDescription)
+            Stringium.exit(withError: error)
+        }
+    }
+    
+    // MARK: - Extension content
+    
+    static func getExtensionContent(sections: [Section], defaultLang lang: String, tags: [String], staticVar: Bool, inputFilename: String, extensionName: String) -> String {
+        [
+            Self.getHeader(stringsFilename: inputFilename, extensionClassname: extensionName),
+            Self.getProperties(sections: sections, defaultLang: lang, tags: tags, staticVar: staticVar),
+            Self.getFooter()
+        ]
+            .joined(separator: "\n")
+    }
+    
+    // MARK: - Extension part
+    
+    private static func getHeader(stringsFilename: String, extensionClassname: String) -> String {
+        """
+        // Generated by ResgenSwift.Strings.\(Stringium.toolName) \(ResgenSwiftVersion)
+        
+        import UIKit
+        
+        fileprivate let kStringsFileName = "\(stringsFilename)"
+        
+        extension \(extensionClassname) {
+        """
+    }
+    
+    private static func getProperties(sections: [Section], defaultLang lang: String, tags: [String], staticVar: Bool) -> String {
+        sections.compactMap { section in
+            // Check that at least one string will be generated
+            guard section.hasOneOrMoreMatchingTags(tags: tags) else {
+                return nil // Go to next section
+            }
+            
+            var res = "\n    // MARK: - \(section.name)\n"
+            res += section.definitions.compactMap { definition in
+                guard definition.hasOneOrMoreMatchingTags(inputTags: tags) == true else {
+                    return nil // Go to next definition
+                }
+                
+                if staticVar {
+                    return "\n\(definition.getNSLocalizedStringStaticProperty(forLang: lang))"
+                }
+                return "\n\(definition.getNSLocalizedStringProperty(forLang: lang))"
+            }
+            .joined(separator: "\n")
+            return res
+        }
+        .joined(separator: "\n")
+    }
+    
+    private static func getFooter() -> String {
+        """
+        }
+        """
+    }
+}

Sources/ResgenSwift/Strings/Generator/TagsGenerator.swift

@@ -0,0 +1,85 @@
+//
+//  TagsGenerator.swift
+//  
+//
+//  Created by Thibaut Schmitt on 10/01/2022.
+//
+
+import Foundation
+import ToolCore
+import CoreVideo
+
+class TagsGenerator {
+    static func writeExtensionFiles(sections: [Section], lang: String, tags: [String], staticVar: Bool, extensionName: String, extensionFilePath: String) {
+        // Get extension content
+        let extensionFileContent = Self.getExtensionContent(sections: sections,
+                                                            lang: lang,
+                                                            tags: tags,
+                                                            staticVar: staticVar,
+                                                            extensionName: extensionName)
+        
+        // Write content
+        let extensionFilePathURL = URL(fileURLWithPath: extensionFilePath)
+        do {
+            try extensionFileContent.write(to: extensionFilePathURL, atomically: false, encoding: .utf8)
+        } catch (let error) {
+            let error = StringiumError.writeFile(extensionFilePath, error.localizedDescription)
+            print(error.localizedDescription)
+            Stringium.exit(withError: error)
+        }
+    }
+    
+    // MARK: - Extension content
+    
+    static func getExtensionContent(sections: [Section], lang: String, tags: [String], staticVar: Bool, extensionName: String) -> String {
+        [
+            Self.getHeader(extensionClassname: extensionName, staticVar: staticVar),
+            Self.getProperties(sections: sections, lang: lang, tags: tags, staticVar: staticVar),
+            Self.getFooter()
+        ]
+            .joined(separator: "\n")
+    }
+    
+    // MARK: - Extension part
+    
+    private static func getHeader(extensionClassname: String, staticVar: Bool) -> String {
+        """
+        // Generated by ResgenSwift.Strings.\(Tags.toolName) \(ResgenSwiftVersion)
+        
+        \(staticVar ? "typelias Tags = String\n\n" : "")import UIKit
+        
+        extension \(extensionClassname) {
+        """
+    }
+    
+    private static func getProperties(sections: [Section], lang: String, tags: [String], staticVar: Bool) -> String {
+        sections
+            .compactMap { section in
+                // Check that at least one string will be generated
+                guard section.hasOneOrMoreMatchingTags(tags: tags) else {
+                    return nil// Go to next section
+                }
+                
+                var res = "\n    // MARK: - \(section.name)"
+                section.definitions.forEach { definition in
+                    guard definition.hasOneOrMoreMatchingTags(inputTags: tags) == true else {
+                        return // Go to next definition
+                    }
+                    
+                    if staticVar {
+                        res += "\n\n\(definition.getStaticProperty(forLang: lang))"
+                    } else {
+                        res += "\n\n\(definition.getProperty(forLang: lang))"
+                    }
+                }
+                return res
+            }
+            .joined(separator: "\n")
+    }
+    
+    private static func getFooter() -> String {
+        """
+        }
+        """
+    }
+}

Sources/ResgenSwift/Strings/Model/Definition.swift

@@ -0,0 +1,188 @@
+//
+//  Definition.swift
+//  
+//
+//  Created by Thibaut Schmitt on 04/01/2022.
+//
+
+import Foundation
+
+class Definition {
+    let name: String
+    var tags = [String]()
+    var comment: String?
+    var translations = [String: String]()
+    var reference: String?
+    var isPlurals = false
+    
+    var isValid: Bool {
+        name.isEmpty == false &&
+        translations.isEmpty == false
+    }
+    
+    init(name: String) {
+        self.name = name
+    }
+    
+    static func match(_ line: String) -> Definition? {
+        guard line.range(of: "\\[(.*?)]$", options: .regularExpression, range: nil, locale: nil) != nil else {
+            return nil
+        }
+        
+        let definitionName = line
+            .replacingOccurrences(of: ["[", "]"], with: "")
+            .removeLeadingTrailingWhitespace()
+        
+        return Definition(name: definitionName)
+    }
+    
+    func hasOneOrMoreMatchingTags(inputTags: [String]) -> Bool {
+        if Set(inputTags).intersection(Set(self.tags)).isEmpty {
+            return false
+        }
+        return true
+    }
+    
+    // MARK: -
+    
+    private func getStringParameters(input: String) -> (inputParameters: [String], translationArguments: [String])? {
+        var methodsParameters = [String]()
+        
+        let printfPlaceholderRegex = try! NSRegularExpression(pattern: "%(?:\\d+\\$)?[+-]?(?:[ 0]|'.{1})?-?\\d*(?:\\.\\d+)?[blcdeEufFgGosxX@]*")
+        printfPlaceholderRegex.enumerateMatches(in: input, options: [], range: NSRange(location: 0, length: input.count)) { match, _, stop in
+            guard let match = match else { return }
+            
+            if let range = Range(match.range, in: input), let last = input[range].last {
+                switch last {
+                case "d", "u":
+                    methodsParameters.append("Int")
+                case "f", "F":
+                    methodsParameters.append("Double")
+                case "@", "s", "c":
+                    methodsParameters.append("String")
+                case "%":
+                    // if you need to print %, you have to add %%
+                    break
+                default:
+                    break
+                }
+            }
+        }
+        
+        if methodsParameters.isEmpty {
+            return nil
+        }
+        
+        var inputParameters = [String]()
+        var translationArguments = [String]()
+        for (index, paramType) in methodsParameters.enumerated() {
+            let paramName = "arg\(index)"
+            translationArguments.append(paramName)
+            inputParameters.append("\(paramName): \(paramType)")
+        }
+        
+        return (inputParameters: inputParameters, translationArguments: translationArguments)
+    }
+    
+    private func getBaseProperty(lang: String, translation: String, isStatic: Bool) -> String {
+        """
+            /// Translation in \(lang) :
+            /// \(translation)
+            \(isStatic ? "static ": "")var \(name): String {
+                NSLocalizedString("\(name)", tableName: kStringsFileName, bundle: Bundle.main, value: "\(translation)", comment: "")
+            }
+        """
+    }
+    
+    private func getBaseMethod(lang: String, translation: String, isStatic: Bool, inputParameters: [String], translationArguments: [String]) -> String {
+        """
+            
+        
+            /// Translation in \(lang) :
+            /// \(translation)
+            \(isStatic ? "static ": "")func \(name)(\(inputParameters.joined(separator: ", "))) -> String {
+                String(format: \(isStatic ? "Self" : "self").\(name), \(translationArguments.joined(separator: ", ")))
+            }
+        """
+    }
+    
+    func getNSLocalizedStringProperty(forLang lang: String) -> String {
+        guard let translation = translations[lang] else {
+            let error = StringiumError.langNotDefined(lang, name, reference != nil)
+            print(error.localizedDescription)
+            Stringium.exit(withError: error)
+        }
+
+        // Generate property
+        let property = getBaseProperty(lang: lang, translation: translation, isStatic: false)
+        
+        // Generate method
+        var method = ""
+        if let parameters = self.getStringParameters(input: translation) {
+            method = getBaseMethod(lang: lang,
+                                   translation: translation,
+                                   isStatic: false,
+                                   inputParameters: parameters.inputParameters,
+                                   translationArguments: parameters.translationArguments)
+        }
+        
+        return property + method
+    }
+    
+    func getNSLocalizedStringStaticProperty(forLang lang: String) -> String {
+        guard let translation = translations[lang] else {
+            let error = StringiumError.langNotDefined(lang, name, reference != nil)
+            print(error.localizedDescription)
+            Stringium.exit(withError: error)
+        }
+        
+        // Generate property
+        let property = getBaseProperty(lang: lang, translation: translation, isStatic: true)
+        
+        // Generate method
+        var method = ""
+        if let parameters = self.getStringParameters(input: translation) {
+            method = getBaseMethod(lang: lang,
+                                   translation: translation,
+                                   isStatic: true,
+                                   inputParameters: parameters.inputParameters,
+                                   translationArguments: parameters.translationArguments)
+        }
+        
+        return property + method
+    }
+    
+    // MARK: - Raw strings
+    
+    func getProperty(forLang lang: String) -> String {
+        guard let translation = translations[lang] else {
+            let error = StringiumError.langNotDefined(lang, name, reference != nil)
+            print(error.localizedDescription)
+            Stringium.exit(withError: error)
+        }
+        
+        return """
+            /// Translation in \(lang) :
+            /// \(translation)
+            var \(name): String {
+                "\(translation)"
+            }
+        """
+    }
+    
+    func getStaticProperty(forLang lang: String) -> String {
+        guard let translation = translations[lang] else {
+            let error = StringiumError.langNotDefined(lang, name, reference != nil)
+            print(error.localizedDescription)
+            Stringium.exit(withError: error)
+        }
+        
+        return """
+            /// Translation in \(lang) :
+            /// \(translation)
+            static var \(name): String {
+                "\(translation)"
+            }
+        """
+    }
+}

Sources/ResgenSwift/Strings/Model/Section.swift

@@ -0,0 +1,39 @@
+//
+//  Section.swift
+//  
+//
+//  Created by Thibaut Schmitt on 04/01/2022.
+//
+
+import Foundation
+
+class Section {
+    let name: String // OnBoarding
+    var definitions = [Definition]()
+    
+    init(name: String) {
+        self.name = name
+    }
+    
+    static func match(_ line: String) -> Section? {
+        guard line.range(of: "\\[\\[(.*?)]]$", options: .regularExpression, range: nil, locale: nil) != nil else {
+            return nil
+        }
+        
+        let sectionName = line
+            .replacingOccurrences(of: ["[", "]"], with: "")
+            .removeLeadingTrailingWhitespace()
+        return Section(name: sectionName)
+    }
+    
+    func hasOneOrMoreMatchingTags(tags: [String]) -> Bool {
+        let allTags = definitions.flatMap { $0.tags }
+        let allTagsSet = Set(allTags)
+        
+        let intersection = Set(tags).intersection(allTagsSet)
+        if intersection.isEmpty {
+            return false
+        }
+        return true
+    }
+}

Sources/ResgenSwift/Strings/Parser/TwineFileParser.swift

@@ -0,0 +1,92 @@
+//
+//  TwineFileParser.swift
+//  
+//
+//  Created by Thibaut Schmitt on 10/01/2022.
+//
+
+import Foundation
+
+class TwineFileParser {
+    static func parse(_ inputFile: String) -> [Section] {
+        let inputFileContent = try! String(contentsOfFile: inputFile, encoding: .utf8)
+        let stringsByLines = inputFileContent.components(separatedBy: .newlines)
+        
+        var sections = [Section]()
+        
+        // Parse file
+        stringsByLines.forEach {
+            // Section
+            if let section = Section.match($0) {
+                sections.append(section)
+                return
+            }
+            
+            // Definition
+            if let definition = Definition.match($0) {
+                sections.last?.definitions.append(definition)
+                return
+            }
+            
+            // Definition content
+            if $0.isEmpty == false {
+                // fr = Test => ["fr ", " Test"]
+                let splitLine = $0
+                    .removeLeadingTrailingWhitespace()
+                    .split(separator: "=")
+                
+                guard let lastDefinition = sections.last?.definitions.last,
+                      let leftElement = splitLine.first else {
+                          return
+                      }
+                
+                let rightElement: String = splitLine.dropFirst().joined(separator: "=")
+                    
+                // "fr " => "fr"
+                let leftHand = String(leftElement).removeTrailingWhitespace()
+                // " Test" => "Test"
+                let rightHand = String(rightElement).removeLeadingWhitespace()
+                
+                // Handle comments, tags and translation
+                switch leftHand {
+                case "comments":
+                    lastDefinition.comment = rightHand
+                    
+                case "tags":
+                    lastDefinition.tags = rightHand
+                        .split(separator: ",")
+                        .map { String($0) }
+                    
+                case "ref":
+                    lastDefinition.reference = rightHand
+                    
+                default:
+                    lastDefinition.translations[leftHand] = rightHand.escapeDoubleQuote()
+                    // Is a plurals strings (fr:one = Test)
+                    // Will be handle later
+                    //if leftHand.split(separator: ":").count > 1 {
+                    //    lastDefinition.isPlurals = true
+                    //}
+                }
+            }
+        }
+        
+        // Keep only valid definition
+        var invalidDefinitionNames = [String]()
+        sections.forEach { section in
+            section.definitions = section.definitions
+                .filter {
+                    if $0.isValid == false {
+                        invalidDefinitionNames.append($0.name)
+                        return false
+                    }
+                    return true
+                }
+        }
+        if invalidDefinitionNames.count > 0 {
+            print(" warning:[\(Stringium.toolName)] Found \(invalidDefinitionNames.count) definition (\(invalidDefinitionNames.joined(separator: ", "))")
+        }
+        
+        return sections
+    }
+}

Sources/ResgenSwift/Strings/Stringium/Stringium.swift

@@ -0,0 +1,100 @@
+//
+//  Stringium.swift
+//  
+//
+//  Created by Thibaut Schmitt on 10/01/2022.
+//
+
+import ToolCore
+import Foundation
+import ArgumentParser
+
+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
+        StringsFileGenerator.writeStringsFiles(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)
+        
+        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.localizedDescription)
+            Stringium.exit(withError: error)
+        }
+        
+        // Langs
+        guard options.langs.isEmpty == false else {
+            let error = StringiumError.langsListEmpty
+            print(error.localizedDescription)
+            Stringium.exit(withError: error)
+        }
+        
+        guard options.langs.contains(options.defaultLang) else {
+            let error = StringiumError.defaultLangsNotInLangs
+            print(error.localizedDescription)
+            Stringium.exit(withError: error)
+        }
+        
+        // Check if needed to regenerate
+        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

@@ -0,0 +1,38 @@
+//
+//  StringToolError.swift
+//  
+//
+//  Created by Thibaut Schmitt on 05/01/2022.
+//
+
+import Foundation
+
+enum StringiumError: Error {
+    case fileNotExists(String)
+    case langsListEmpty
+    case defaultLangsNotInLangs
+    case writeFile(String, String)
+    case langNotDefined(String, String, Bool)
+    
+    var localizedDescription: 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):
+            return " error:[\(Stringium.toolName)] An error occured while writing content to \(filename): \(subErrorDescription)"
+            
+        case .langNotDefined(let lang, let definitionName, let isReference):
+            if isReference {
+                return " error:[\(Stringium.toolName)] Reference are handled only by TwineTool. Please use it or remove reference from you strings file."
+            }
+            return " error:[\(Stringium.toolName)] Lang \"\(lang)\" not found for \"\(definitionName)\""
+        }
+    }
+}

Sources/ResgenSwift/Strings/Stringium/StringiumOptions.swift

@@ -0,0 +1,86 @@
+//
+//  StringiumOptions.swift
+//  
+//
+//  Created by Thibaut Schmitt on 10/01/2022.
+//
+
+import Foundation
+import ArgumentParser
+
+struct StringiumOptions: ParsableArguments {
+    @Flag(name: [.customShort("f"), .customShort("F")], help: "Should force generation")
+    var forceGeneration = false
+    
+    @Argument(help: "Input files where strings ared 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
+    
+    @Option(help: "Extension name. If not specified, it will generate an String extension. Using default extension name will generate static property.")
+    var extensionName: String = Stringium.defaultExtensionName
+    
+    @Option(help: "Extension suffix. Ex: MyApp, it will generate {extensionName}+{extensionSuffix}.swift")
+    var extensionSuffix: String?
+}
+
+// MARK: - Private var getter
+
+extension StringiumOptions {
+    var stringsFileOutputPath: String {
+        var outputPath = outputPathRaw
+        if outputPath.last == "/" {
+            outputPath = String(outputPath.dropLast())
+        }
+        return outputPath
+    }
+    
+    var langs: [String] {
+        langsRaw
+            .split(separator: " ")
+            .map { String($0) }
+    }
+    
+    var tags: [String] {
+        tagsRaw
+            .split(separator: " ")
+            .map { String($0) }
+    }
+}
+
+// MARK: - Computed var
+
+extension StringiumOptions {
+    var extensionFileName: String {
+        if let extensionSuffix = extensionSuffix {
+            return "\(extensionName)+\(extensionSuffix).swift"
+        }
+        return "\(extensionName).swift"
+    }
+    
+    var extensionFilePath: String {
+        "\(extensionOutputPath)/\(extensionFileName)"
+    }
+    
+    var inputFilenameWithoutExt: String {
+        URL(fileURLWithPath: inputFile)
+            .deletingPathExtension()
+            .lastPathComponent
+    }
+}

Sources/ResgenSwift/Strings/Strings.swift

@@ -0,0 +1,30 @@
+//
+//  main.swift
+//  
+//
+//  Created by Thibaut Schmitt on 10/01/2022.
+//
+
+import ToolCore
+import Foundation
+import ArgumentParser
+
+struct Strings: ParsableCommand {
+    
+    static var configuration = CommandConfiguration(
+        abstract: "A utility for generate strings.",
+        version: ResgenSwiftVersion,
+
+        // Pass an array to `subcommands` to set up a nested tree of subcommands.
+        // With language support for type-level introspection, this could be
+        // provided by automatically finding nested `ParsableCommand` types.
+        subcommands: [Twine.self, Stringium.self, Tags.self]
+
+        // A default subcommand, when provided, is automatically selected if a
+        // subcommand is not given on the command line.
+        //defaultSubcommand: Twine.self
+    )
+}
+
+//Strings.main()
+

Sources/ResgenSwift/Strings/Tag/Tags.swift

@@ -0,0 +1,79 @@
+//
+//  Tag.swift
+//  
+//
+//  Created by Thibaut Schmitt on 10/01/2022.
+//
+
+import ToolCore
+import Foundation
+import ArgumentParser
+
+struct Tags: ParsableCommand {
+    
+    // MARK: - Command Configuration
+    
+    static var configuration = CommandConfiguration(
+        abstract: "Generate tags extension file.",
+        version: ResgenSwiftVersion
+    )
+    
+    
+    // MARK: - Static
+    
+    static let toolName = "Tags"
+    static let defaultExtensionName = "Tags"
+    static let noTranslationTag: String = "notranslation"
+    
+    // MARK: - Command Options
+    
+    @OptionGroup var options: TagsOptions
+    
+    // MARK: - Run
+    
+    mutating func run() {
+        print("[\(Self.toolName)] Starting tags generation")
+        print("[\(Self.toolName)] Will use inputFile \(options.inputFile) to generate strings for lang: \(options.lang)")
+        
+        // Check requirements
+        guard checkRequirements() else { return }
+        
+        print("[\(Self.toolName)] Will generate tags")
+        
+        // Parse input file
+        let sections = TwineFileParser.parse(options.inputFile)
+        
+        // Generate extension
+        TagsGenerator.writeExtensionFiles(sections: sections,
+                                          lang: options.lang,
+                                          tags: ["ios", "iosonly", Self.noTranslationTag],
+                                          staticVar: options.staticMembers,
+                                          extensionName: options.extensionName,
+                                          extensionFilePath: options.extensionFilePath)
+        
+        print("[\(Self.toolName)] Tags 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.localizedDescription)
+            Stringium.exit(withError: error)
+        }
+        
+        // Check if needed to regenerate
+        guard GeneratorChecker.shouldGenerate(force: options.forceGeneration,
+                                              inputFilePath: options.inputFile,
+                                              extensionFilePath: options.extensionFilePath) else {
+            print("[\(Self.toolName)] Tags are already up to date :) ")
+            return false
+        }
+        
+        return true
+    }
+}

Sources/ResgenSwift/Strings/Tag/TagsOptions.swift

@@ -0,0 +1,47 @@
+//
+//  TagOptions.swift
+//  
+//
+//  Created by Thibaut Schmitt on 10/01/2022.
+//
+
+import Foundation
+import ArgumentParser
+
+struct TagsOptions: ParsableArguments {
+    @Flag(name: [.customShort("f"), .customShort("F")], help: "Should force generation")
+    var forceGeneration = false
+    
+    @Argument(help: "Input files where tags ared defined.", transform: { $0.replaceTiltWithHomeDirectoryPath() })
+    var inputFile: String
+    
+    @Option(help: "Lang to generate. (\"ium\" by default)")
+    var lang: String = "ium"
+    
+    @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
+    
+    @Option(help: "Extension name. If not specified, it will generate a Tag extension. Using default extension name will generate static property.")
+    var extensionName: String = Tags.defaultExtensionName
+    
+    @Option(help: "Extension suffix. Ex: MyApp, it will generate {extensionName}+Tag{extensionSuffix}.swift")
+    var extensionSuffix: String?
+}
+
+// MARK: - Computed var
+
+extension TagsOptions {
+    var extensionFileName: String {
+        if let extensionSuffix = extensionSuffix {
+            return "\(extensionName)+\(extensionSuffix).swift"
+        }
+        return "\(extensionName).swift"
+    }
+    
+    var extensionFilePath: String {
+        "\(extensionOutputPath)/\(extensionFileName)"
+    }
+}

Sources/ResgenSwift/Strings/Twine/Twine.swift

@@ -0,0 +1,96 @@
+//
+//  Twine.swift
+//  
+//
+//  Created by Thibaut Schmitt on 10/01/2022.
+//
+
+import ToolCore
+import Foundation
+import ArgumentParser
+
+struct Twine: ParsableCommand {
+    
+    // MARK: - Command Configuration
+    
+    static var configuration = CommandConfiguration(
+        abstract: "Generate strings with twine.",
+        version: ResgenSwiftVersion
+    )
+    
+    // MARK: - Static
+    
+    static let toolName = "Twine"
+    static let defaultExtensionName = "String"
+    static let twineExecutable = "\(FileManager.default.homeDirectoryForCurrentUser.relativePath)/scripts/twine/twine"
+    
+    // MARK: - Command Options
+    
+    @OptionGroup var options: TwineOptions
+    
+    // MARK: - Run
+    
+    mutating func run() {
+        print("[\(Self.toolName)] Starting strings generation")
+        
+        // Check requirements
+        guard checkRequirements() else { return }
+        
+        print("[\(Self.toolName)] Will generate strings")
+        
+        // Generate strings files (lproj files)
+        for lang in options.langs {
+            Shell.shell([Self.twineExecutable,
+                        "generate-localization-file", options.inputFile,
+                        "--lang", "\(lang)",
+                        "\(options.outputPath)/\(lang).lproj/\(options.inputFilenameWithoutExt).strings",
+                        "--tags=ios,iosonly,iosOnly"])
+        }
+        
+        // Generate extension
+        Shell.shell([Self.twineExecutable,
+                    "generate-localization-file", options.inputFile,
+                    "--format", "apple-swift",
+                    "--lang", "\(options.defaultLang)",
+                    options.extensionFilePath,
+                    "--tags=ios,iosonly,iosOnly"])
+        
+        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 = TwineError.fileNotExists(options.inputFile)
+            print(error.localizedDescription)
+            Twine.exit(withError: error)
+        }
+        
+        // Langs
+        guard options.langs.isEmpty == false else {
+            let error = TwineError.langsListEmpty
+            print(error.localizedDescription)
+            Twine.exit(withError: error)
+        }
+        
+        guard options.langs.contains(options.defaultLang) else {
+            let error = TwineError.defaultLangsNotInLangs
+            print(error.localizedDescription)
+            Twine.exit(withError: error)
+        }
+        
+        // Check if needed to regenerate
+        guard GeneratorChecker.shouldGenerate(force: options.forceGeneration,
+                                              inputFilePath: options.inputFile,
+                                              extensionFilePath: options.extensionFilePathGenerated) else {
+            print("[\(Self.toolName)] Strings are already up to date :) ")
+            return false
+        }
+        
+        return true
+    }
+}

Sources/ResgenSwift/Strings/Twine/TwineError.swift

@@ -0,0 +1,27 @@
+//
+//  TwineError.swift
+//  
+//
+//  Created by Thibaut Schmitt on 10/01/2022.
+//
+
+import Foundation
+
+enum TwineError: Error {
+    case fileNotExists(String)
+    case langsListEmpty
+    case defaultLangsNotInLangs
+    
+    var localizedDescription: String {
+        switch self {
+        case .fileNotExists(let filename):
+            return " error:[\(Twine.toolName)] File \(filename) does not exists "
+            
+        case .langsListEmpty:
+            return " error:[\(Twine.toolName)] Langs list is empty"
+            
+        case .defaultLangsNotInLangs:
+            return " error:[\(Twine.toolName)] Langs list does not contains the default lang"
+        }
+    }
+}

Sources/ResgenSwift/Strings/Twine/TwineOptions.swift

@@ -0,0 +1,58 @@
+//
+//  TwineOptions.swift
+//  
+//
+//  Created by Thibaut Schmitt on 10/01/2022.
+//
+
+import Foundation
+import ArgumentParser
+
+struct TwineOptions: ParsableArguments {
+    @Flag(name: [.customShort("f"), .customShort("F")], help: "Should force generation")
+    var forceGeneration = false
+    
+    @Argument(help: "Input files where strings ared defined.", transform: { $0.replaceTiltWithHomeDirectoryPath() })
+    var inputFile: String
+    
+    @Option(help: "Path where to strings file.", transform: { $0.replaceTiltWithHomeDirectoryPath() })
+    var outputPath: String
+    
+    @Option(name: .customLong("langs"), help: "Langs to generate.")
+    fileprivate var langsRaw: String
+    
+    @Option(help: "Default langs.")
+    var defaultLang: String
+    
+    @Option(help: "Path where to generate the extension.", transform: { $0.replaceTiltWithHomeDirectoryPath() })
+    var extensionOutputPath: String
+}
+
+// MARK: - Private var getter
+
+extension TwineOptions {
+    var langs: [String] {
+        langsRaw
+            .split(separator: " ")
+            .map { String($0) }
+    }
+}
+
+// MARK: - Computed var
+
+extension TwineOptions {
+    var inputFilenameWithoutExt: String {
+        URL(fileURLWithPath: inputFile)
+            .deletingPathExtension()
+            .lastPathComponent
+    }
+    
+    var extensionFilePath: String {
+        "\(extensionOutputPath)/\(inputFilenameWithoutExt).swift"
+    }
+    
+    // "R2String+" is hardcoded in Twine formatter
+    var extensionFilePathGenerated: String {
+        "\(extensionOutputPath)/R2String+\(inputFilenameWithoutExt).swift"
+    }
+}