Generation des strings sans twine et generation des tags. Refactor de toutes les commandes strings (Twine, CustomStrings, Tags) dans une commande avec des sous commandes

Sources/Strings/Generator/StringsFileGenerator.swift

@@ -0,0 +1,143 @@
+//
+//  StringsFileGenerator.swift
+//  
+//
+//  Created by Thibaut Schmitt on 04/01/2022.
+//
+
+import Foundation
+import CLIToolCore
+
+extension Strings {
+    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: true, encoding: .utf8)
+                } catch (let error) {
+                    let error = StringiumError.writeFile(error.localizedDescription, stringsFilePath)
+                    print(error.localizedDescription)
+                    Stringium.exit(withError: error)
+                }
+            }
+        }
+        
+        private static func generateStringsFileContent(lang: String, defaultLang: String, tags inputTags: [String], sections: [Section]) -> String {
+            var stringsFileContent = """
+        /**
+         * Apple Strings File
+         * Generated by ResgenSwift 1.0.0
+         * 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
+                    let translationOpt: String? = {
+                        if definition.tags.contains(Stringium.noTranslationTag) {
+                            return definition.translations[defaultLang]
+                        }
+                        return definition.translations[lang]
+                    }()
+                    
+                    if let translation = translationOpt {
+                        stringsFileContent += "\"\(definition.name)\" = \"\(translation)\"\n\n"
+                    } else {
+                        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) {
+            let extensionHeader = Self.getHeader(stringsFilename: inputFilename, extensionClassname: extensionName)
+            let extensionFooter = Self.getFooter()
+            
+            let extensionContent: String = {
+                var content = ""
+                sections.forEach { section in
+                    // Check that at least one string will be generated
+                    guard section.hasOneOrMoreMatchingTags(tags: tags) else {
+                        return // Go to next section
+                    }
+                    
+                    content += "\n\t// MARK: - \(section.name)"
+                    section.definitions.forEach { definition in
+                        if staticVar {
+                            content += "\n\n\(definition.getNSLocalizedStringStaticProperty(forLang: lang))"
+                        } else {
+                            content += "\n\n\(definition.getNSLocalizedStringProperty(forLang: lang))"
+                        }
+                    }
+                    content += "\n"
+                }
+                return content
+            }()
+            
+            // Create file if not exists
+            let fileManager = FileManager()
+            if fileManager.fileExists(atPath: extensionFilePath) == false {
+                Shell.shell("touch", "\(extensionFilePath)")
+            }
+            
+            // Create extension content
+            let extensionFileContent = [extensionHeader, extensionContent, extensionFooter].joined(separator: "\n")
+            
+            // Write content
+            let extensionFilePathURL = URL(fileURLWithPath: extensionFilePath)
+            do {
+                try extensionFileContent.write(to: extensionFilePathURL, atomically: true, encoding: .utf8)
+            } catch (let error) {
+                let error = StringiumError.writeFile(extensionFilePath, error.localizedDescription)
+                print(error.localizedDescription)
+                Stringium.exit(withError: error)
+            }
+        }
+        
+        private static func getHeader(stringsFilename: String, extensionClassname: String) -> String {
+        """
+        // Generated from Strings-Stringium at \(Date())
+        
+        import UIKit
+        
+        fileprivate let kStringsFileName = "\(stringsFilename)"
+        
+        extension \(extensionClassname) {
+        """
+        }
+        
+        private static func getFooter() -> String {
+        """
+        }
+        """
+        }
+    }
+}

Sources/Strings/Generator/TagsGenerator.swift

@@ -0,0 +1,77 @@
+//
+//  TagsGenerator.swift
+//  
+//
+//  Created by Thibaut Schmitt on 10/01/2022.
+//
+
+import Foundation
+import CLIToolCore
+import CoreVideo
+
+extension Strings {
+    class TagsGenerator {
+        static func writeExtensionFiles(sections: [Section], lang: String, tags: [String], staticVar: Bool, extensionName: String, extensionFilePath: String) {
+            let extensionHeader = Self.getHeader(extensionClassname: extensionName)
+            let extensionFooter = Self.getFooter()
+            
+            let extensionContent: String = {
+                var content = ""
+                sections.forEach { section in
+                    // Check that at least one string will be generated
+                    guard section.hasOneOrMoreMatchingTags(tags: tags) else {
+                        return // Go to next section
+                    }
+                    
+                    content += "\n\t// MARK: - \(section.name)"
+                    section.definitions.forEach { definition in
+                        if staticVar {
+                            content += "\n\n\(definition.getStaticProperty(forLang: lang))"
+                        } else {
+                            content += "\n\n\(definition.getProperty(forLang: lang))"
+                        }
+                    }
+                    content += "\n"
+                }
+                return content
+            }()
+            
+            // Create file if not exists
+            let fileManager = FileManager()
+            if fileManager.fileExists(atPath: extensionFilePath) == false {
+                Shell.shell("touch", "\(extensionFilePath)")
+            }
+            
+            // Create extension content
+            let extensionFileContent = [extensionHeader, extensionContent, extensionFooter].joined(separator: "\n")
+            
+            // Write content
+            let extensionFilePathURL = URL(fileURLWithPath: extensionFilePath)
+            do {
+                try extensionFileContent.write(to: extensionFilePathURL, atomically: true, encoding: .utf8)
+            } catch (let error) {
+                let error = StringiumError.writeFile(extensionFilePath, error.localizedDescription)
+                print(error.localizedDescription)
+                Stringium.exit(withError: error)
+            }
+        }
+        
+        private static func getHeader(extensionClassname: String) -> String {
+            """
+            // Generated from Strings-Tags at \(Date())
+            
+            // typelias Tags = String
+            
+            import UIKit
+            
+            extension \(extensionClassname) {
+            """
+        }
+        
+        private static func getFooter() -> String {
+            """
+            }
+            """
+        }
+    }
+}

Sources/Strings/Model/Definition.swift

@@ -0,0 +1,108 @@
+//
+//  Definition.swift
+//  
+//
+//  Created by Thibaut Schmitt on 04/01/2022.
+//
+
+import Foundation
+
+extension Strings {
+    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)
+        }
+        
+        // MARK: -
+        
+        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)
+            }
+            
+            return """
+            /// Translation in \(lang) :
+            /// \(translation)
+            var \(name): String {
+                NSLocalizedString("\(name)", tableName: kStringsFileName, bundle: Bundle.main, value: "\(translation)", comment: "")
+            }
+        """
+        }
+        
+        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)
+            }
+            
+            return """
+            /// Translation in \(lang) :
+            /// \(translation)
+            static var \(name): String {
+                NSLocalizedString("\(name)", tableName: kStringsFileName, bundle: Bundle.main, value: "\(translation)", comment: "")
+            }
+        """
+        }
+        
+        // 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/Strings/Model/Section.swift

@@ -0,0 +1,41 @@
+//
+//  Section.swift
+//  
+//
+//  Created by Thibaut Schmitt on 04/01/2022.
+//
+
+import Foundation
+
+extension Strings {
+    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 }
+            
+            for tag in tags {
+                if allTags.contains(tag) {
+                    return true
+                }
+            }
+            return false
+        }
+    }
+}

Sources/Strings/Parser/TwineFileParser.swift

@@ -0,0 +1,94 @@
+//
+//  TwineFileParser.swift
+//  
+//
+//  Created by Thibaut Schmitt on 10/01/2022.
+//
+
+import Foundation
+
+extension Strings {
+    
+    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,
+                          let rightElement = splitLine.last  else {
+                              return
+                          }
+                    
+                    // "fr " => "fr"
+                    let leftHand = String(leftElement.dropLast())
+                    // " Test" => "Test"
+                    let rightHand = String(rightElement.dropFirst())
+                    
+                    // 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/Strings/Stringium/Stringium.swift

@@ -0,0 +1,111 @@
+//
+//  Stringium.swift
+//  
+//
+//  Created by Thibaut Schmitt on 10/01/2022.
+//
+
+import Foundation
+import CLIToolCore
+import ArgumentParser
+
+extension Strings {
+    
+    struct Stringium: ParsableCommand {
+        static var configuration = CommandConfiguration(abstract: "Generate strings with custom scripts.")
+        
+        static let toolName = "Stringium"
+        static let defaultExtensionName = "String"
+        static let noTranslationTag: String = "notranslation"
+        
+        var extensionFileName: String { "\(options.extensionName)+String\(options.extensionSuffix).swift" }
+        var extensionFilePath: String { "\(options.extensionOutputPath)/\(extensionFileName)" }
+        
+        var langs: [String] {
+            options.langsRaw
+                .split(separator: " ")
+                .map { String($0) }
+        }
+        var inputFilenameWithoutExt: String {
+            URL(fileURLWithPath: options.inputFile)
+                .deletingPathExtension()
+                .lastPathComponent
+        }
+        var stringsFileOutputPath: String {
+            var outputPath = options.outputPathRaw
+            if outputPath.last == "/" {
+                outputPath = String(outputPath.dropLast())
+            }
+            return outputPath
+        }
+        
+        // The `@OptionGroup` attribute includes the flags, options, and
+        // arguments defined by another `ParsableArguments` type.
+        @OptionGroup var options: StringiumOptions
+        
+        mutating func run() {
+            print("[\(Self.toolName)] Starting strings generation")
+            
+            // 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: langs,
+                                                   defaultLang: options.defaultLang,
+                                                   tags: ["ios", "iosonly", Self.noTranslationTag],
+                                                   outputPath: stringsFileOutputPath,
+                                                   inputFilenameWithoutExt: inputFilenameWithoutExt)
+            
+            // Generate extension
+            StringsFileGenerator.writeExtensionFiles(sections: sections,
+                                                     defaultLang: options.defaultLang,
+                                                     tags: ["ios", "iosonly", Self.noTranslationTag],
+                                                     staticVar: options.extensionName == Self.defaultExtensionName,
+                                                     inputFilename: inputFilenameWithoutExt,
+                                                     extensionName: options.extensionName,
+                                                     extensionFilePath: 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 langs.isEmpty == false else {
+                let error = StringiumError.langsListEmpty
+                print(error.localizedDescription)
+                Stringium.exit(withError: error)
+            }
+            
+            guard 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: extensionFilePath) else {
+                print("[\(Self.toolName)] Strings are already up to date :) ")
+                return false
+            }
+            
+            return true
+        }
+    }
+}

Sources/Strings/Stringium/StringiumError.swift

@@ -0,0 +1,40 @@
+//
+//  StringToolError.swift
+//  
+//
+//  Created by Thibaut Schmitt on 05/01/2022.
+//
+
+import Foundation
+
+extension Strings {
+    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/Strings/Stringium/StringiumOptions.swift

@@ -0,0 +1,37 @@
+//
+//  StringiumOptions.swift
+//  
+//
+//  Created by Thibaut Schmitt on 10/01/2022.
+//
+
+import Foundation
+import ArgumentParser
+
+extension Strings {
+    struct StringiumOptions: ParsableArguments {
+        @Flag(name: .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() })
+        var outputPathRaw: String
+        
+        @Option(name: .customLong("langs"), help: "Langs to generate.")
+        var langsRaw: String
+        
+        @Option(help: "Default langs.")
+        var defaultLang: String
+        
+        @Option(help: "Path where to generate the extension.", transform: { $0.replaceTiltWithHomeDirectoryPath() })
+        var extensionOutputPath: String
+        
+        @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}+String{extensionSuffix}.swift")
+        var extensionSuffix: String = ""
+    }
+}

Sources/Strings/Tag/Tags.swift

@@ -0,0 +1,71 @@
+//
+//  Tag.swift
+//  
+//
+//  Created by Thibaut Schmitt on 10/01/2022.
+//
+
+import Foundation
+import CLIToolCore
+import ArgumentParser
+
+extension Strings {
+    
+    struct Tags: ParsableCommand {
+        static var configuration = CommandConfiguration(abstract: "Generate tags extension file.")
+        
+        static let toolName = "Tags"
+        static let defaultExtensionName = "Tags"
+        static let noTranslationTag: String = "notranslation"
+        
+        var extensionFileName: String { "\(options.extensionName)+Tag\(options.extensionSuffix).swift" }
+        var extensionFilePath: String { "\(options.extensionOutputPath)/\(extensionFileName)" }
+        
+        // The `@OptionGroup` attribute includes the flags, options, and
+        // arguments defined by another `ParsableArguments` type.
+        @OptionGroup var options: TagsOptions
+        
+        mutating func run() {
+            print("[\(Self.toolName)] Starting tagss generation")
+            
+            // 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.extensionName == Self.defaultExtensionName,
+                                              extensionName: options.extensionName,
+                                              extensionFilePath: 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: extensionFilePath) else {
+                print("[\(Self.toolName)] Tags are already up to date :) ")
+                return false
+            }
+            
+            return true
+        }
+    }
+}

Sources/Strings/Tag/TagsOptions.swift

@@ -0,0 +1,31 @@
+//
+//  TagOptions.swift
+//  
+//
+//  Created by Thibaut Schmitt on 10/01/2022.
+//
+
+import Foundation
+import ArgumentParser
+
+extension Strings {
+    struct TagsOptions: ParsableArguments {
+        @Flag(name: .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: "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 = ""
+    }
+}

Sources/Strings/Twine/Twine.swift

@@ -0,0 +1,97 @@
+//
+//  Twine.swift
+//  
+//
+//  Created by Thibaut Schmitt on 10/01/2022.
+//
+
+import Foundation
+import CLIToolCore
+import ArgumentParser
+
+extension Strings {
+    
+    struct Twine: ParsableCommand {
+        static var configuration = CommandConfiguration(abstract: "Generate strings with twine.")
+        
+        static let toolName = "Twine"
+        static let defaultExtensionName = "String"
+        static let twineExecutable = "\(FileManager.default.homeDirectoryForCurrentUser.relativePath)/scripts/twine/twine"
+        
+        var langs: [String] { options.langsRaw.split(separator: " ").map { String($0) } }
+        var inputFilenameWithoutExt: String { URL(fileURLWithPath: options.inputFile)
+                .deletingPathExtension()
+                .lastPathComponent
+        }
+        
+        // The `@OptionGroup` attribute includes the flags, options, and
+        // arguments defined by another `ParsableArguments` type.
+        @OptionGroup var options: TwineOptions
+        
+        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 langs {
+                Shell.shell(Self.twineExecutable,
+                            "generate-localization-file", options.inputFile,
+                            "--lang", "\(lang)",
+                            "\(options.outputPath)/\(lang).lproj/\(inputFilenameWithoutExt).strings",
+                            "--tags=ios,iosonly,iosOnly")
+            }
+            
+            // Generate extension
+            var extensionFilePath: String { "\(options.extensionOutputPath)/\(inputFilenameWithoutExt).swift" }
+            Shell.shell(Self.twineExecutable,
+                        "generate-localization-file", options.inputFile,
+                        "--format", "apple-swift",
+                        "--lang", "\(options.defaultLang)",
+                        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 langs.isEmpty == false else {
+                let error = TwineError.langsListEmpty
+                print(error.localizedDescription)
+                Twine.exit(withError: error)
+            }
+            
+            guard langs.contains(options.defaultLang) else {
+                let error = TwineError.defaultLangsNotInLangs
+                print(error.localizedDescription)
+                Twine.exit(withError: error)
+            }
+            
+            // "R2String+" is hardcoded in Twine formatter
+            let extensionFilePathGenerated = "\(options.extensionOutputPath)/R2String+\(inputFilenameWithoutExt).swift"
+            
+            // Check if needed to regenerate
+            guard GeneratorChecker.shouldGenerate(force: options.forceGeneration, inputFilePath: options.inputFile, extensionFilePath: extensionFilePathGenerated) else {
+                print("[\(Self.toolName)] Strings are already up to date :) ")
+                return false
+            }
+            
+            return true
+        }
+    }
+}

Sources/Strings/Twine/TwineError.swift

@@ -0,0 +1,31 @@
+//
+//  TwineError.swift
+//  
+//
+//  Created by Thibaut Schmitt on 10/01/2022.
+//
+
+import Foundation
+
+extension Strings {
+    
+    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/Strings/Twine/TwineOptions.swift

@@ -0,0 +1,29 @@
+//
+//  File.swift
+//  
+//
+//  Created by Thibaut Schmitt on 10/01/2022.
+//
+
+import Foundation
+import ArgumentParser
+
+struct TwineOptions: ParsableArguments {
+    @Flag(name: .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.")
+    var langsRaw: String
+    
+    @Option(help: "Default langs.")
+    var defaultLang: String
+    
+    @Option(help: "Path where to generate the extension.", transform: { $0.replaceTiltWithHomeDirectoryPath() })
+    var extensionOutputPath: String
+}

Sources/Strings/main.swift

@@ -0,0 +1,28 @@
+//
+//  main.swift
+//  
+//
+//  Created by Thibaut Schmitt on 10/01/2022.
+//
+
+import Foundation
+import ArgumentParser
+
+struct Strings: ParsableCommand {
+    
+    static var configuration = CommandConfiguration(
+        abstract: "A utility for generate strings.",
+        version: "0.1.0",
+
+        // 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()