Refactor + Bugs fixes on Strings + Gestion de la génération des images

Sources/Imagium/ConvertArgument.swift

@@ -0,0 +1,13 @@
+//
+//  ConvertArgument.swift
+//  
+//
+//  Created by Thibaut Schmitt on 24/01/2022.
+//
+
+import Foundation
+
+struct ConvertArgument {
+    let width: String?
+    let height: String?
+}

Sources/Imagium/FileManagerExtensions.swift

@@ -0,0 +1,56 @@
+//
+//  FileManagerExtensions.swift
+//  
+//
+//  Created by Thibaut Schmitt on 24/01/2022.
+//
+
+import Foundation
+
+extension FileManager {
+    func getAllRegularFileIn(directory: String) -> [String] {
+        var files = [String]()
+        guard let enumerator = self.enumerator(at: URL(string: directory)!, includingPropertiesForKeys: [.isRegularFileKey], options: [.skipsHiddenFiles, .skipsPackageDescendants]) else {
+            let error = ImagiumError.unknown("Cannot enumerate file in \(directory)")
+            print(error.localizedDescription)
+            Imagium.exit(withError: error)
+        }
+        
+        for case let fileURL as URL in enumerator {
+            do {
+                let fileAttributes = try fileURL.resourceValues(forKeys:[.isRegularFileKey])
+                if fileAttributes.isRegularFile! {
+                    files.append(fileURL.relativePath)
+                }
+            } catch {
+                let error = ImagiumError.getFileAttributed(fileURL.relativePath, error.localizedDescription)
+                print(error.localizedDescription)
+                Imagium.exit(withError: error)
+            }
+        }
+        return files
+    }
+    
+    func getAllImageSetFolderIn(directory: String) -> [String] {
+        var files = [String]()
+        guard let enumerator = self.enumerator(at: URL(string: directory)!, includingPropertiesForKeys: [.isDirectoryKey], options: [.skipsHiddenFiles, .skipsPackageDescendants]) else {
+            let error = ImagiumError.unknown("Cannot enumerate imageset directory in \(directory)")
+            print(error.localizedDescription)
+            Imagium.exit(withError: error)
+        }
+        
+        for case let fileURL as URL in enumerator {
+            do {
+                let fileAttributes = try fileURL.resourceValues(forKeys:[.isDirectoryKey])
+                if fileAttributes.isDirectory! && fileURL.lastPathComponent.hasSuffix(".imageset") {
+                    files.append(fileURL.lastPathComponent)
+                }
+            } catch {
+                let error = ImagiumError.getFileAttributed(fileURL.relativePath, error.localizedDescription)
+                print(error.localizedDescription)
+                Imagium.exit(withError: error)
+            }
+        }
+        return files
+    }
+}

Sources/Imagium/ImageExtensionGenerator.swift

@@ -0,0 +1,87 @@
+//
+//  ImageExtensionGenerator.swift
+//  
+//
+//  Created by Thibaut Schmitt on 14/02/2022.
+//
+
+import CLIToolCore
+import Foundation
+
+class ImageExtensionGenerator {
+  
+    // MARK: - Extension files
+    
+    static func writeStringsFiles(images: [ImageToGen], staticVar: Bool, inputFilename: String, extensionName: String, extensionFilePath: String) {
+        // Get header/footer
+        let extensionHeader = Self.getHeader(inputFilename: inputFilename, extensionClassname: extensionName)
+        let extensionFooter = Self.getFooter()
+        
+        // Create content
+        let extensionContent: String = {
+            var content = ""
+            images.forEach { img in
+                if staticVar {
+                    content += "\n\(img.getStaticImageProperty())"
+                } else {
+                    content += "\n\(img.getImageProperty())"
+                }
+                content += "\n "
+            }
+            return content
+        }()
+        
+        // Create file if not exists
+        let fileManager = FileManager()
+        if fileManager.fileExists(atPath: extensionFilePath) == false {
+            Shell.shell("touch", "\(extensionFilePath)")
+        }
+        
+        // Generate extension
+        Self.generateExtensionFile(extensionFilePath: extensionFilePath, extensionHeader, extensionContent, extensionFooter)
+    }
+    
+    // MARK: - pragm
+    
+    private static func generateExtensionFile(extensionFilePath: String, _ args: String...) {
+        // Create file if not exists
+        let fileManager = FileManager()
+        if fileManager.fileExists(atPath: extensionFilePath) == false {
+            Shell.shell("touch", "\(extensionFilePath)")
+        }
+
+        // Create extension content
+        let extensionContent = args.joined(separator: "\n")
+
+        // Write content
+        let extensionFilePathURL = URL(fileURLWithPath: extensionFilePath)
+        do {
+            try extensionContent.write(to: extensionFilePathURL, atomically: true, encoding: .utf8)
+        } catch (let error) {
+            let error = ImagiumError.writeFile(extensionFilePath, error.localizedDescription)
+            print(error.localizedDescription)
+            Imagium.exit(withError: error)
+        }
+    }
+    
+    private static func getHeader(inputFilename: String, extensionClassname: String) -> String {
+        """
+        // Generated from Imagium at \(Date())
+        // Images from \(inputFilename)
+        
+        import UIKit
+        
+        extension \(extensionClassname) {
+        """
+    }
+    
+    private static func getFooter() -> String {
+        """
+        }
+        """
+    }
+}
+
+//@objc var onboarding_foreground3: UIImage {
+//        return UIImage(named: "onboarding_foreground3")!
+//    }

Sources/Imagium/ImageFileParser.swift

@@ -0,0 +1,47 @@
+//
+//  ImageFileParser.swift
+//  
+//
+//  Created by Thibaut Schmitt on 24/01/2022.
+//
+
+import Foundation
+
+class ImageFileParser {
+    
+    static func parse(_ inputFile: String, platform: PlatormTag) -> [ImageToGen] {
+        let inputFileContent = try! String(contentsOfFile: inputFile, encoding: .utf8)
+        let stringsByLines = inputFileContent.components(separatedBy: .newlines)
+        
+        var imagesToGenerate = [ImageToGen]()
+        
+        // Parse file
+        stringsByLines.forEach {
+            guard $0.removeLeadingTrailingWhitespace().isEmpty == false, $0.first != "#" else {
+                return
+            }
+            
+            let splittedLine = $0.split(separator: " ")
+            
+            let width: Int = {
+                if splittedLine[2] == "?" {
+                    return -1
+                }
+                return Int(splittedLine[2])!
+            }()
+            let height: Int = {
+                if splittedLine[3] == "?" {
+                    return -1
+                }
+                return Int(splittedLine[3])!
+            }()
+            
+            let image = ImageToGen(name: String(splittedLine[1]), tags: String(splittedLine[0]), width: width, height: height)
+            imagesToGenerate.append(image)
+        }
+        
+        return imagesToGenerate.filter {
+            $0.tags.contains(platform.rawValue)
+        }
+    }
+}

Sources/Imagium/ImageToGen.swift

@@ -0,0 +1,90 @@
+//
+//  File.swift
+//  
+//
+//  Created by Thibaut Schmitt on 24/01/2022.
+//
+
+import Foundation
+
+struct ImageToGen {
+    let name: String
+    let tags: String
+    let width: Int
+    let height: Int
+    
+    // MARK: - Convert
+    
+    var convertArguments: (x1: ConvertArgument, x2: ConvertArgument, x3: ConvertArgument) {
+        var width1x = ""
+        var height1x = ""
+        var width2x = ""
+        var height2x = ""
+        var width3x = ""
+        var height3x = ""
+        
+        if width != -1 {
+            width1x = "\(width)"
+            width2x = "\(width * 2)"
+            width3x = "\(width * 3)"
+        }
+        
+        if height != -1 {
+            height1x = "\(height)"
+            height2x = "\(height * 2)"
+            height3x = "\(height * 3)"
+        }
+        
+        return (x1: ConvertArgument(width: width1x, height: height1x),
+                x2: ConvertArgument(width: width2x, height: height2x),
+                x3: ConvertArgument(width: width3x, height: height3x))
+    }
+    
+    // MARK: - Assets
+    
+    var contentJson: String {
+        """
+        {
+          "images" : [
+            {
+              "idiom" : "universal",
+              "scale" : "1x",
+              "filename" : "\(name).\(XcassetsGenerator.outputImageExtension)"
+            },
+            {
+              "idiom" : "universal",
+              "scale" : "2x",
+              "filename" : "\(name)@2x.\(XcassetsGenerator.outputImageExtension)"
+            },
+            {
+              "idiom" : "universal",
+              "scale" : "3x",
+              "filename" : "\(name)@3x.\(XcassetsGenerator.outputImageExtension)"
+            }
+          ],
+          "info" : {
+            "version" : 1,
+            "author" : "ResgenSwift-Imagium"
+          }
+        }
+        """
+    }
+    
+    // MARK: - Extension property
+    
+    func getImageProperty() -> String {
+        """
+            var \(name): UIImage {
+                UIImage(named: "\(name)")!
+            }
+        """
+    }
+    
+    func getStaticImageProperty() -> String {
+        """
+            static var \(name): UIImage {
+                UIImage(named: "\(name)")!
+            }
+        """
+    }
+}

Sources/Imagium/ImagiumError.swift

@@ -0,0 +1,43 @@
+//
+//  ImagiumError.swift
+//  
+//
+//  Created by Thibaut Schmitt on 24/01/2022.
+//
+
+import Foundation
+
+enum ImagiumError: Error {
+    case inputFolderNotFound(String)
+    case fileNotExists(String)
+    case unknownImageExtension(String)
+    case getFileAttributed(String, String)
+    case rsvgConvertNotFound
+    case writeFile(String, String)
+    case unknown(String)
+    
+    var localizedDescription: String {
+        switch self {
+        case .inputFolderNotFound(let inputFolder):
+            return " error:[\(Imagium.toolName)] Input folder not found: \(inputFolder)"
+            
+        case .fileNotExists(let filename):
+            return " error:[\(Imagium.toolName)] File \(filename) does not exists"
+            
+        case .unknownImageExtension(let filename):
+            return " error:[\(Imagium.toolName)] File \(filename) have an unhandled file extension. Cannot generate image."
+            
+        case .getFileAttributed(let filename, let errorDescription):
+            return " error:[\(Imagium.toolName)] Getting file attributes of \(filename) failed with error: \(errorDescription)"
+            
+        case .rsvgConvertNotFound:
+            return " error:[\(Imagium.toolName)] Can't find rsvg-convert (can be installed with 'brew remove imagemagick && brew install imagemagick --with-librsvg')"
+            
+        case .writeFile(let subErrorDescription, let filename):
+            return " error:[\(Imagium.toolName)] An error occured while writing content to \(filename): \(subErrorDescription)"
+            
+        case .unknown(let errorDescription):
+            return " error:[\(Imagium.toolName)] Unknown error: \(errorDescription)"
+        }
+    }
+}

Sources/Imagium/ImagiumOptions.swift

@@ -0,0 +1,41 @@
+//
+//  ImagiumOptions.swift
+//  
+//
+//  Created by Thibaut Schmitt on 24/01/2022.
+//
+
+import Foundation
+import ArgumentParser
+
+struct ImagiumOptions: ParsableArguments {
+    @Flag(name: .customShort("f"), help: "Should force script execution")
+    var forceExecution = false
+    
+    @Flag(name: .customShort("F"), help: "Regenerate all images")
+    var forceExecutionAndGeneration = false
+    
+    @Argument(help: "Input files where strings ared defined.", transform: { $0.replaceTiltWithHomeDirectoryPath() })
+    var inputFile: String
+    
+    @Option(help: "Xcassets path where to generate images.", transform: { $0.replaceTiltWithHomeDirectoryPath() })
+    var xcassetsPath: 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 UIImage extension. Using default extension name will generate static property.")
+    var extensionName: String = Imagium.defaultExtensionName
+    
+    @Option(help: "Extension suffix. Ex: MyApp, it will generate {extensionName}+Image{extensionSuffix}.swift")
+    var extensionSuffix: String = ""
+}
+
+
+/*
+ swift run -c release Imagium $FORCE_FLAG "./Images/sampleImages.txt" \
+    --xcassets-path "./Images/imagium.xcassets" \
+    --extension-output-path "./Images/Generated" \
+    --extension-name "UIImage" \
+    --extension-suffix "GenAllScript"
+ */

Sources/Imagium/XcassetsGenerator.swift

@@ -0,0 +1,189 @@
+//
+//  File.swift
+//  
+//
+//  Created by Thibaut Schmitt on 24/01/2022.
+//
+
+import Foundation
+import CLIToolCore
+
+class XcassetsGenerator {
+    
+    static let outputImageExtension = "png"
+    
+    let forceGeneration: Bool
+    
+    // MARK: - Init
+    
+    init(forceGeneration: Bool) {
+        self.forceGeneration = forceGeneration
+    }
+    
+    // MARK: - Assets generation
+    
+    func generateXcassets(inputPath: String, imagesToGenerate: [ImageToGen], xcassetsPath: String) {
+        let fileManager = FileManager()
+        let svgConverter = Imagium.getSvgConverterPath()
+        let allSubFiles = fileManager.getAllRegularFileIn(directory: inputPath)
+        
+        var generatedAssetsPaths = [String]()
+        
+        // Generate new assets
+        imagesToGenerate.forEach { imageToGen in
+            // Get image path
+            let imageData: (path: String, ext: String) = {
+                for subfile in allSubFiles {
+                    if subfile.hasSuffix("/" + imageToGen.name + ".svg") {
+                        return (subfile, "svg")
+                    }
+                    if subfile.hasSuffix("/" + imageToGen.name + ".png") {
+                        return (subfile, "png")
+                    }
+                    if subfile.hasSuffix("/" + imageToGen.name + ".jpg") {
+                        return (subfile, "jpg")
+                    }
+                    if subfile.hasSuffix("/" + imageToGen.name + ".jepg") {
+                        return (subfile, "jepg")
+                    }
+                }
+                let error = ImagiumError.unknownImageExtension(imageToGen.name)
+                print(error.localizedDescription)
+                Imagium.exit(withError: error)
+            }()
+            
+            // Create imageset folder
+            let imagesetName = "\(imageToGen.name).imageset"
+            let imagesetPath = "\(xcassetsPath)/\(imagesetName)"
+            Shell.shell("mkdir", "-p", imagesetPath)
+            
+            // Store managed images path
+            generatedAssetsPaths.append(imagesetName)
+            
+            // Generate output images path
+            let output1x = "\(imagesetPath)/\(imageToGen.name).\(XcassetsGenerator.outputImageExtension)"
+            let output2x = "\(imagesetPath)/\(imageToGen.name)@2x.\(XcassetsGenerator.outputImageExtension)"
+            let output3x = "\(imagesetPath)/\(imageToGen.name)@3x.\(XcassetsGenerator.outputImageExtension)"
+            
+            // Check if we need to convert image
+            if self.shouldBypassGeneration(for: imageToGen, xcassetImagePath: output1x) {
+                print("\(imageToGen.name) -> Not regenerating")
+                return
+            }
+            
+            // Convert image
+            let convertArguments = imageToGen.convertArguments
+            if imageData.ext == "svg" {
+                // /usr/local/bin/rsvg-convert path/to/image.png -w 200 -h 300 -o path/to/output.png
+                // /usr/local/bin/rsvg-convert path/to/image.png -w 200 -o path/to/output.png
+                // /usr/local/bin/rsvg-convert path/to/image.png -h 300 -o path/to/output.png
+                var command1x = ["\(svgConverter)", "\(imageData.path)"]
+                var command2x = ["\(svgConverter)", "\(imageData.path)"]
+                var command3x = ["\(svgConverter)", "\(imageData.path)"]
+                
+                self.addConvertArgument(command: &command1x, convertArgument: convertArguments.x1)
+                self.addConvertArgument(command: &command2x, convertArgument: convertArguments.x2)
+                self.addConvertArgument(command: &command3x, convertArgument: convertArguments.x3)
+                
+                command1x.append(contentsOf: ["-o", output1x])
+                command2x.append(contentsOf: ["-o", output2x])
+                command3x.append(contentsOf: ["-o", output3x])
+                
+                Shell.shell(command1x)
+                Shell.shell(command2x)
+                Shell.shell(command3x)
+            } else {
+                // convert path/to/image.png -resize 200x300 path/to/output.png
+                // convert path/to/image.png -resize 200x path/to/output.png
+                // convert path/to/image.png -resize x300 path/to/output.png
+                Shell.shell("convert", "\(imageData.path)", "-resize", "\(convertArguments.x1.width ?? "")x\(convertArguments.x1.height ?? "")", output1x)
+                Shell.shell("convert", "\(imageData.path)", "-resize", "\(convertArguments.x2.width ?? "")x\(convertArguments.x2.height ?? "")", output2x)
+                Shell.shell("convert", "\(imageData.path)", "-resize", "\(convertArguments.x3.width ?? "")x\(convertArguments.x3.height ?? "")", output3x)
+            }
+            
+            // Write Content.json
+            let imagesetContentJson = imageToGen.contentJson
+            let contentJsonFilePath = "\(imagesetPath)/Contents.json"
+            if fileManager.fileExists(atPath: contentJsonFilePath) == false {
+                Shell.shell("touch", "\(contentJsonFilePath)")
+            }
+            
+            let contentJsonFilePathURL = URL(fileURLWithPath: contentJsonFilePath)
+            try! imagesetContentJson.write(to: contentJsonFilePathURL, atomically: true, encoding: .utf8)
+            
+            print("\(imageToGen.name) -> Generated")
+        }
+        
+        // Success info
+        let generatedAssetsCount = generatedAssetsPaths.count
+        print("Images generated: \(generatedAssetsCount)")
+        
+        // Delete old assets
+        let allImagesetName = Set(fileManager.getAllImageSetFolderIn(directory: xcassetsPath))        
+        let imagesetToRemove = allImagesetName.subtracting(Set(generatedAssetsPaths))
+        
+        imagesetToRemove.forEach {
+            print("Will remove: \($0)")
+        }
+        
+        imagesetToRemove.forEach { itemToRemove in
+            try! fileManager.removeItem(atPath: "\(xcassetsPath)/\(itemToRemove)")
+        }
+        print("Removed \(imagesetToRemove.count) images")
+    }
+    
+    // MARK: - Helpers: SVG command
+    
+    private func addConvertArgument(command: inout [String], convertArgument: ConvertArgument) {
+        if let width = convertArgument.width, width.isEmpty == false {
+            command.append("-w")
+            command.append("\(width)")
+        }
+        if let height = convertArgument.height, height.isEmpty == false {
+            command.append("-h")
+            command.append("\(height)")
+        }
+    }
+    
+    // MARK: - Helpers: bypass generation
+    
+    private func shouldBypassGeneration(for image: ImageToGen, xcassetImagePath: String) -> Bool {
+        guard forceGeneration == false else {
+            return false
+        }
+        
+        let fileManager = FileManager()
+            
+        // File not exists -> do not bypass
+        guard fileManager.fileExists(atPath: xcassetImagePath) else {
+            return false
+        }
+        
+        // Info unavailable -> do not bypass
+        let taskWidth = Shell.shell("identify", "-format", "%w", xcassetImagePath)
+        let taskHeight = Shell.shell("identify", "-format", "%h", xcassetImagePath)
+        guard taskWidth.terminationStatus == 0,
+              taskHeight.terminationStatus == 0 else {
+                  return false
+              }
+        
+        let currentWidth = Int(taskWidth.output ?? "-1") ?? -1
+        let currentheight = Int(taskHeight.output ?? "-1") ?? -1
+        
+        // Info unavailable -> do not bypass
+        guard currentWidth > 0 && currentheight > 0 else {
+            return false
+        }
+        
+        // Check width and height
+        if image.width != -1 && currentWidth == image.width {
+            return true
+        }
+        if image.height != -1 && currentheight == image.height {
+            return true
+        }
+        
+        return false
+    }
+    
+}

Sources/Imagium/main.swift

@@ -0,0 +1,111 @@
+//
+//  Imagium.swift
+//  
+//
+//  Created by Thibaut Schmitt on 24/01/2022.
+//
+
+import Foundation
+import ArgumentParser
+import CLIToolCore
+
+enum PlatormTag: String {
+    case droid = "d"
+    case ios = "i"
+}
+
+struct Imagium: ParsableCommand {
+    
+    static var configuration = CommandConfiguration(
+        abstract: "A utility for generate images.",
+        version: "0.1.0"
+    )
+    
+    static let toolName = "Imagium"
+    static let defaultExtensionName = "UIImage"
+    
+    var extensionFileName: String { "\(options.extensionName)+Image\(options.extensionSuffix).swift" }
+    var extensionFilePath: String { "\(options.extensionOutputPath)/\(extensionFileName)" }
+    var inputFilenameWithoutExt: String {
+        URL(fileURLWithPath: options.inputFile)
+            .deletingPathExtension()
+            .lastPathComponent
+    }
+    
+    @OptionGroup var options: ImagiumOptions
+    
+    mutating func run() {
+        print("[\(Self.toolName)] Starting images generation")
+        
+        // Check requirements
+        guard checkRequirements() else { return }
+        
+        print("[\(Self.toolName)] Will generate images")
+        
+        // Parse input file
+        let imagesToGenerate = ImageFileParser.parse(options.inputFile, platform: PlatormTag.ios)
+        
+        // Generate xcassets files
+        let inputFolder = URL(fileURLWithPath: options.inputFile)
+            .deletingLastPathComponent()
+            .relativePath
+        let xcassetsGenerator = XcassetsGenerator(forceGeneration: options.forceExecutionAndGeneration)
+        xcassetsGenerator.generateXcassets(inputPath: inputFolder,
+                                           imagesToGenerate: imagesToGenerate,
+                                           xcassetsPath: options.xcassetsPath)
+        
+        // Generate extension
+        ImageExtensionGenerator.writeStringsFiles(images: imagesToGenerate,
+                                                  staticVar: options.extensionName == Self.defaultExtensionName,
+                                                  inputFilename: inputFilenameWithoutExt,
+                                                  extensionName: options.extensionName,
+                                                  extensionFilePath: extensionFilePath)
+        
+        
+        print("[\(Self.toolName)] Images generated")
+    }
+    
+    // MARK: - Requirements
+    
+    private func checkRequirements() -> Bool {
+        guard options.forceExecutionAndGeneration == false else {
+            return true
+        }
+        
+        let fileManager = FileManager()
+
+        // Input file
+        guard fileManager.fileExists(atPath: options.inputFile) else {
+            let error = ImagiumError.fileNotExists(options.inputFile)
+            print(error.localizedDescription)
+            Imagium.exit(withError: error)
+        }
+
+        // RSVG-Converter
+        _ = Imagium.getSvgConverterPath()
+
+        // Check if needed to regenerate
+        guard GeneratorChecker.shouldGenerate(force: options.forceExecution, inputFilePath: options.inputFile, extensionFilePath: extensionFilePath) else {
+            print("[\(Self.toolName)] Images are already up to date :) ")
+            return false
+        }
+        
+        return true
+    }
+    
+    // MARK: - Helpers
+    
+    @discardableResult
+    static func getSvgConverterPath() -> String {
+        let taskSvgConverter = Shell.shell("which", "rsvg-convert")
+        if taskSvgConverter.terminationStatus == 0 {
+            return taskSvgConverter.output!.removeCharacters(from: CharacterSet.whitespacesAndNewlines)
+        }
+        
+        let error = ImagiumError.rsvgConvertNotFound
+        print(error.localizedDescription)
+        Imagium.exit(withError: error)
+    }
+}
+
+Imagium.main()