Package.resolved

@@ -14,8 +14,8 @@
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/krzyzanowskim/CryptoSwift.git",
       "state" : {
-        "revision" : "db51c407d3be4a051484a141bf0bff36c43d3b1e",
+        "revision" : "c9c3df6ab812de32bae61fc0cd1bf6d45170ebf0",
-        "version" : "1.8.0"
+        "version" : "1.8.2"
       }
     },
     {

Sources/ResgenSwift/Generate/Model/ConfigurationFile.swift

@@ -269,14 +269,22 @@ struct StringsConfiguration: Codable, CustomDebugStringConvertible {
     let extensionName: String?
     let extensionSuffix: String?
     private let staticMembers: Bool?
-    
+    private let xcStrings: Bool?
+
     var staticMembersOptions: Bool {
         if let staticMembers = staticMembers {
             return staticMembers
         }
         return false
     }
-    
+
+    var xcStringsOptions: Bool {
+        if let xcStrings = xcStrings {
+            return xcStrings
+        }
+        return false
+    }
+
     internal init(inputFile: String,
                   outputPath: String,
                   langs: String,
@@ -284,7 +292,8 @@ struct StringsConfiguration: Codable, CustomDebugStringConvertible {
                   extensionOutputPath: String,
                   extensionName: String?,
                   extensionSuffix: String?,
-                  staticMembers: Bool?) {
+                  staticMembers: Bool?,
+                  xcStrings: Bool?) {
         self.inputFile = inputFile
         self.outputPath = outputPath
         self.langs = langs
@@ -293,6 +302,7 @@ struct StringsConfiguration: Codable, CustomDebugStringConvertible {
         self.extensionName = extensionName
         self.extensionSuffix = extensionSuffix
         self.staticMembers = staticMembers
+        self.xcStrings = xcStrings
     }
     
     var debugDescription: String {

Sources/ResgenSwift/Generate/Runnable/StringsConfiguration+Runnable.swift

@@ -14,7 +14,7 @@ extension StringsConfiguration: Runnable {
         if force {
             args += ["-f"]
         }
-        
+
         args += [
             inputFile.prependIfRelativePath(projectDirectory),
             "--output-path",
@@ -26,7 +26,9 @@ extension StringsConfiguration: Runnable {
             "--extension-output-path",
             extensionOutputPath.prependIfRelativePath(projectDirectory),
             "--static-members",
-            "\(staticMembersOptions)"
+            "\(staticMembersOptions)",
+            "--xc-strings",
+            "\(xcStringsOptions)"
         ]
         
         if let extensionName = extensionName {

Sources/ResgenSwift/Strings/Generator/StringsFileGenerator.swift

@@ -17,41 +17,21 @@ class StringsFileGenerator {
                                   defaultLang: String,
                                   tags: [String],
                                   outputPath: String,
-                                  inputFilenameWithoutExt: String,
+                                  inputFilenameWithoutExt: String) {
-                                  isXcString: Bool = false) {
 
-        if !isXcString {
+        var stringsFilesContent = [String: String]()
-            var stringsFilesContent = [String: String]()
+        for lang in langs {
-            for lang in langs {
+            stringsFilesContent[lang] = Self.generateStringsFileContent(lang: lang,
-                stringsFilesContent[lang] = Self.generateStringsFileContent(lang: lang,
+                                                                        defaultLang: defaultLang,
-                                                                            defaultLang: defaultLang,
+                                                                        tags: tags,
-                                                                            tags: tags,
+                                                                        sections: sections)
-                                                                            sections: sections)
+        }
-            }
 
-            // Write strings file content
+        // Write strings file content
-            langs.forEach { lang in
+        langs.forEach { lang in
-                guard let fileContent = stringsFilesContent[lang] else { return }
+            guard let fileContent = stringsFilesContent[lang] else { return }
 
-                let stringsFilePath = "\(outputPath)/\(lang).lproj/\(inputFilenameWithoutExt).strings"
+            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.description)
-                    Stringium.exit(withError: error)
-                }
-            }
-        } else {
-            let fileContent: String = Self.generateXcStringsFileContent(
-                langs: langs,
-                defaultLang: defaultLang,
-                tags: tags,
-                sections: sections
-            )
-
-            let stringsFilePath = "\(outputPath)/Localizable.xcstrings"
             let stringsFilePathURL = URL(fileURLWithPath: stringsFilePath)
             do {
                 try fileContent.write(to: stringsFilePathURL, atomically: false, encoding: .utf8)
@@ -63,6 +43,31 @@ class StringsFileGenerator {
         }
     }
 
+    static func writeXcStringsFiles(sections: [Section],
+                                    langs: [String],
+                                    defaultLang: String,
+                                    tags: [String],
+                                    outputPath: String,
+                                    inputFilenameWithoutExt: String) {
+
+        let fileContent: String = Self.generateXcStringsFileContent(
+            langs: langs,
+            defaultLang: defaultLang,
+            tags: tags,
+            sections: sections
+        )
+
+        let stringsFilePath = "\(outputPath)/\(inputFilenameWithoutExt).xcstrings"
+        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.description)
+            Stringium.exit(withError: error)
+        }
+    }
+
     static func generateStringsFileContent(lang: String,
                                            defaultLang: String,
                                            tags inputTags: [String],

Sources/ResgenSwift/Strings/Model/XcString.swift

@@ -40,7 +40,9 @@ struct XCStringDefinitionContainer: Codable, Equatable {
     }
 
     static func == (lhs: XCStringDefinitionContainer, rhs: XCStringDefinitionContainer) -> Bool {
-        return lhs.strings.count == rhs.strings.count && lhs.strings.sorted(by: { $0.title < $1.title }) == rhs.strings.sorted(by: { $0.title < $1.title })
+        return lhs.strings.sorted(by: {
+            $0.title < $1.title
+        }) == rhs.strings.sorted(by: { $0.title < $1.title })
     }
 }
 

Sources/ResgenSwift/Strings/Stringium/Stringium.swift

@@ -43,24 +43,37 @@ struct Stringium: ParsableCommand {
         let sections = TwineFileParser.parse(options.inputFile)
         
         // Generate strings files
-        StringsFileGenerator.writeStringsFiles(sections: sections,
+        print(options.xcStrings)
-                                               langs: options.langs,
+        if !options.xcStrings {
-                                               defaultLang: options.defaultLang,
+            print("[\(Self.toolName)] Will generate strings")
-                                               tags: options.tags,
+
-                                               outputPath: options.stringsFileOutputPath,
+            StringsFileGenerator.writeStringsFiles(sections: sections,
-                                               inputFilenameWithoutExt: options.inputFilenameWithoutExt,
+                                                   langs: options.langs,
-                                               isXcString: options.isXcstring)
+                                                   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)
+
+        } 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)
+        }
 
-        // 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)
-        
         print("[\(Self.toolName)] Strings generated")
     }
     

Sources/ResgenSwift/Strings/Stringium/StringiumOptions.swift

@@ -12,10 +12,7 @@ struct StringiumOptions: ParsableArguments {
     @Flag(name: [.customShort("f"), .customShort("F")], help: "Should force generation")
     var forceGeneration = false
 
-    @Flag(name: [.customShort("x"), .customLong("xcstrings")], help: "Generate xcstrings catalog")
+    @Argument(help: "Input files where strings are defined.", transform: { $0.replaceTiltWithHomeDirectoryPath() })
-    var isXcstring = 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() })
@@ -35,7 +32,10 @@ struct StringiumOptions: ParsableArguments {
     
     @Option(help: "Tell if it will generate static properties or not")
     var staticMembers: Bool = false
-    
+
+    @Option(help: "Tell if it will generate xcStrings file or not")
+    var xcStrings: Bool = false
+
     @Option(help: "Extension name. If not specified, it will generate an String extension.")
     var extensionName: String = Stringium.defaultExtensionName