fix: Rebase tags

Sources/ResgenSwift/Generate/Generate.swift

@@ -34,6 +34,7 @@ struct Generate: ParsableCommand {
         // Parse
         let configuration = ConfigurationFileParser.parse(options.configurationFile)
         print("Found configurations :")
+        print("  - \(configuration.analytics.count) analytics configuration(s)")
         print("  - \(configuration.colors.count) colors configuration(s)")
         print("  - \(configuration.fonts.count) fonts configuration(s)")
         print("  - \(configuration.images.count) images configuration(s)")

Sources/ResgenSwift/Generate/GenerateError.swift

@@ -13,6 +13,11 @@ enum GenerateError: Error {
     case commandError([String], String)
     case writeFile(String, String)
     
+    // Analytics
+    
+    case missingElement(String)
+    case invalidParameter(String)
+    
     var description: String {
         switch self {
         case .fileNotExists(let filename):
@@ -29,6 +34,12 @@ enum GenerateError: Error {
             
         case .writeFile(let filename, let info):
             return "error: [\(Generate.toolName)] An error occured while writing file in \(filename): \(info)"
+            
+        case .missingElement(let element):
+            return "error: [\(Generate.toolName)] Missing \(element) for Matomo"
+            
+        case .invalidParameter(let reason):
+            return "error: [\(Generate.toolName)] Invalid parameter \(reason)"
         }
     }
 }

Sources/ResgenSwift/Generate/Model/ConfigurationFile.swift

@@ -9,6 +9,7 @@ import Foundation
 
 struct ConfigurationFile: Codable, CustomDebugStringConvertible {
     var architecture: ConfigurationArchitecture?
+    var analytics: [AnalyticsConfiguration]
     var colors: [ColorsConfiguration]
     var fonts: [FontsConfiguration]
     var images: [ImagesConfiguration]
@@ -16,12 +17,15 @@ struct ConfigurationFile: Codable, CustomDebugStringConvertible {
     var tags: [TagsConfiguration]
     
     var runnableConfigurations: [Runnable] {
-        let runnables: [[Runnable]] = [colors, fonts, images, strings, tags]
+        let runnables: [[Runnable]] = [analytics, colors, fonts, images, strings, tags]
         return Array(runnables.joined())
     }
     
     var debugDescription: String {
         """
+        \(analytics)
+        -----------
+        -----------
         \(colors)
         -----------
         -----------
@@ -76,6 +80,47 @@ struct ConfigurationArchitecture: Codable {
     }
 }
 
+struct AnalyticsConfiguration: Codable, CustomDebugStringConvertible {
+    let inputFile: String
+    let target: String
+    let extensionOutputPath: String
+    let extensionName: String?
+    let extensionSuffix: String?
+    private let staticMembers: Bool?
+    
+    var staticMembersOptions: Bool {
+        if let staticMembers = staticMembers {
+            return staticMembers
+        }
+        return false
+    }
+    
+    internal init(inputFile: String,
+                  target: String,
+                  extensionOutputPath: String,
+                  extensionName: String?,
+                  extensionSuffix: String?,
+                  staticMembers: Bool?) {
+        self.inputFile = inputFile
+        self.target = target
+        self.extensionOutputPath = extensionOutputPath
+        self.extensionName = extensionName
+        self.extensionSuffix = extensionSuffix
+        self.staticMembers = staticMembers
+    }
+    
+    var debugDescription: String {
+        """
+        Analytics configuration:
+            - Input file: \(inputFile)
+            - Target: \(target)
+            - Extension output path: \(extensionOutputPath)
+            - Extension name: \(extensionName ?? "-")
+            - Extension suffix: \(extensionSuffix ?? "-")
+        """
+    }
+}
+
 struct ColorsConfiguration: Codable, CustomDebugStringConvertible {
     let inputFile: String
     let style: String
@@ -266,7 +311,7 @@ struct StringsConfiguration: Codable, CustomDebugStringConvertible {
 
 struct TagsConfiguration: Codable, CustomDebugStringConvertible {
     let inputFile: String
-    let target: String
+    let lang: String
     let extensionOutputPath: String
     let extensionName: String?
     let extensionSuffix: String?
@@ -280,13 +325,13 @@ struct TagsConfiguration: Codable, CustomDebugStringConvertible {
     }
     
     internal init(inputFile: String,
-                  target: String,
+                  lang: String,
                   extensionOutputPath: String,
                   extensionName: String?,
                   extensionSuffix: String?,
                   staticMembers: Bool?) {
         self.inputFile = inputFile
-        self.target = target
+        self.lang = lang
         self.extensionOutputPath = extensionOutputPath
         self.extensionName = extensionName
         self.extensionSuffix = extensionSuffix
@@ -297,7 +342,7 @@ struct TagsConfiguration: Codable, CustomDebugStringConvertible {
         """
         Tags configuration:
             - Input file: \(inputFile)
-            - Target: \(target)
+            - Lang: \(lang)
             - Extension output path: \(extensionOutputPath)
             - Extension name: \(extensionName ?? "-")
             - Extension suffix: \(extensionSuffix ?? "-")

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

@@ -17,8 +17,8 @@ extension TagsConfiguration: Runnable {
         
         args += [
             inputFile.prependIfRelativePath(projectDirectory),
-            "--target",
-            target,
+            "--lang",
+            lang,
             "--extension-output-path",
             extensionOutputPath.prependIfRelativePath(projectDirectory),
             "--static-members",

Sources/ResgenSwift/Strings/Generator/TagsGenerator.swift

@@ -0,0 +1,86 @@
+//
+//  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.description)
+            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/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.description)
+            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.")
+    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/main.swift

@@ -19,10 +19,12 @@ struct ResgenSwift: ParsableCommand {
         // With language support for type-level introspection, this could be
         // provided by automatically finding nested `ParsableCommand` types.
         subcommands: [
+            Analytics.self,
             Colors.self,
             Fonts.self,
             Images.self,
             Strings.self,
+            Tags.self,
             Generate.self
         ]