openium/resgen.swift
1
0
Fork 0
Code Pull Requests 1 Releases 8 Activity

feat(RES-34): Fix plist font filename (#14)
All checks were successful
gitea-openium/resgen.swift/pipeline/head This commit looks good
Details

Browse Source 
Reviewed-on: #14
This commit is contained in:
Thibaut Schmitt
2025-05-05 09:53:05 +02:00
parent 8442c89944
commit 756de4f1de
96 changed files with 3028 additions and 2852 deletions
Download Patch File Download Diff File Expand all files Collapse all files

171
Sources/ResgenSwift/Strings/Generator/StringsFileGenerator.swift
View File

@ -8,23 +8,29 @@
import Foundation
import ToolCore
class StringsFileGenerator {
// swiftlint:disable type_body_length file_length
enum StringsFileGenerator {
// MARK: - Strings Files
static func writeStringsFiles(sections: [Section],
langs: [String],
defaultLang: String,
tags: [String],
outputPath: String,
inputFilenameWithoutExt: String) {
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)
stringsFilesContent[lang] = Self.generateStringsFileContent(
lang: lang,
defaultLang: defaultLang,
tags: tags,
sections: sections
)
}
// Write strings file content
@ -35,7 +41,7 @@ class StringsFileGenerator {
let stringsFilePathURL = URL(fileURLWithPath: stringsFilePath)
do {
try fileContent.write(to: stringsFilePathURL, atomically: false, encoding: .utf8)
} catch let error {
} catch {
let error = StringiumError.writeFile(error.localizedDescription, stringsFilePath)
print(error.description)
Stringium.exit(withError: error)
@ -43,12 +49,14 @@ class StringsFileGenerator {
}
}
static func writeXcStringsFiles(sections: [Section],
langs: [String],
defaultLang: String,
tags: [String],
outputPath: String,
inputFilenameWithoutExt: String) {
static func writeXcStringsFiles(
sections: [Section],
langs: [String],
defaultLang: String,
tags: [String],
outputPath: String,
inputFilenameWithoutExt: String
) {
let fileContent: String = Self.generateXcStringsFileContent(
langs: langs,
@ -61,17 +69,19 @@ class StringsFileGenerator {
let stringsFilePathURL = URL(fileURLWithPath: stringsFilePath)
do {
try fileContent.write(to: stringsFilePathURL, atomically: false, encoding: .utf8)
} catch let error {
} catch {
let error = StringiumError.writeFile(error.localizedDescription, stringsFilePath)
print(error.description)
Stringium.exit(withError: error)
}
}
static func generateStringsFileContent(lang: String,
defaultLang: String,
tags inputTags: [String],
sections: [Section]) -> String {
static func generateStringsFileContent(
lang: String,
defaultLang: String,
tags inputTags: [String],
sections: [Section]
) -> String {
var stringsFileContent = """
/**
* Apple Strings File
@ -120,11 +130,18 @@ class StringsFileGenerator {
// MARK: - XcStrings Generation
static func generateXcStringsFileContent(langs: [String],
defaultLang: String,
tags inputTags: [String],
sections: [Section]) -> String {
let rootObject = generateRootObject(langs: langs, defaultLang: defaultLang, tags: inputTags, sections: sections)
static func generateXcStringsFileContent(
langs: [String],
defaultLang: String,
tags inputTags: [String],
sections: [Section]
) -> String {
let rootObject = generateRootObject(
langs: langs,
defaultLang: defaultLang,
tags: inputTags,
sections: sections
)
let file = generateXcStringsFileContentFromRootObject(rootObject: rootObject)
return file
@ -138,7 +155,6 @@ class StringsFileGenerator {
let json = try encoder.encode(rootObject)
return String(decoding: json, as: UTF8.self)
} catch {
debugPrint("Failed to encode: \(error)")
}
@ -146,20 +162,22 @@ class StringsFileGenerator {
return ""
}
static func generateRootObject(langs: [String],
defaultLang: String,
tags inputTags: [String],
sections: [Section]) -> Root {
static func generateRootObject(
langs: [String],
defaultLang: String,
tags inputTags: [String],
sections: [Section]
) -> Root {
var xcStringDefinitionTab: [XCStringDefinition] = []
sections.forEach { section in
// Check that at least one string will be generated
sections.forEach { section in // swiftlint:disable:this closure_body_length
// Check that at least one string will be generated
guard section.hasOneOrMoreMatchingTags(tags: inputTags) else {
return // Go to next section
}
section.definitions.forEach { definition in
section.definitions.forEach { definition in // swiftlint:disable:this closure_body_length
var skipDefinition = false
var isNoTranslation = false
@ -190,7 +208,6 @@ class StringsFileGenerator {
} else {
// Search for langs in twine
for (lang, value) in definition.translations where !value.isEmpty {
let localization = XCStringLocalization(
lang: lang,
content: XCStringLocalizationLangContent(
@ -219,7 +236,7 @@ class StringsFileGenerator {
}
let xcStringContainer = XCStringDefinitionContainer(strings: xcStringDefinitionTab)
return Root(
sourceLanguage: defaultLang,
strings: xcStringContainer,
@ -229,28 +246,32 @@ class StringsFileGenerator {
// MARK: - Extension file
static func writeExtensionFiles(sections: [Section],
defaultLang lang: String,
tags: [String],
staticVar: Bool,
inputFilename: String,
extensionName: String,
extensionFilePath: String,
extensionSuffix: String) {
static func writeExtensionFiles(
sections: [Section],
defaultLang lang: String,
tags: [String],
staticVar: Bool,
inputFilename: String,
extensionName: String,
extensionFilePath: String,
extensionSuffix: String
) {
// Get extension content
let extensionFileContent = Self.getExtensionContent(sections: sections,
defaultLang: lang,
tags: tags,
staticVar: staticVar,
inputFilename: inputFilename,
extensionName: extensionName,
extensionSuffix: extensionSuffix)
let extensionFileContent = Self.getExtensionContent(
sections: sections,
defaultLang: lang,
tags: tags,
staticVar: staticVar,
inputFilename: inputFilename,
extensionName: extensionName,
extensionSuffix: extensionSuffix
)
// Write content
let extensionFilePathURL = URL(fileURLWithPath: extensionFilePath)
do {
try extensionFileContent.write(to: extensionFilePathURL, atomically: false, encoding: .utf8)
} catch let error {
} catch {
let error = StringiumError.writeFile(extensionFilePath, error.localizedDescription)
print(error.description)
Stringium.exit(withError: error)
@ -259,17 +280,32 @@ class StringsFileGenerator {
// MARK: - Extension content
static func getExtensionContent(sections: [Section],
defaultLang lang: String,
tags: [String],
staticVar: Bool,
inputFilename: String,
extensionName: String,
extensionSuffix: String) -> String {
static func getExtensionContent(
sections: [Section],
defaultLang lang: String,
tags: [String],
staticVar: Bool,
inputFilename: String,
extensionName: String,
extensionSuffix: String
) -> String {
[
Self.getHeader(stringsFilename: inputFilename, extensionClassname: extensionName),
Self.getEnumKey(sections: sections, tags: tags, extensionClassname: extensionName, extensionSuffix: extensionSuffix),
Self.getProperties(sections: sections, defaultLang: lang, tags: tags, staticVar: staticVar),
Self.getHeader(
stringsFilename: inputFilename,
extensionClassname: extensionName
),
Self.getEnumKey(
sections: sections,
tags: tags,
extensionClassname: extensionName,
extensionSuffix: extensionSuffix
),
Self.getProperties(
sections: sections,
defaultLang: lang,
tags: tags,
staticVar: staticVar
),
Self.getFooter()
]
.joined(separator: "\n")
@ -289,7 +325,12 @@ class StringsFileGenerator {
"""
}
private static func getEnumKey(sections: [Section], tags: [String], extensionClassname: String, extensionSuffix: String) -> String {
private static func getEnumKey(
sections: [Section],
tags: [String],
extensionClassname: String,
extensionSuffix: String
) -> String {
var enumDefinition = "\n enum Key\(extensionSuffix.uppercasedFirst()): String {\n"
// Enum

83
Sources/ResgenSwift/Strings/Generator/TagsGenerator.swift
View File

@ -1,71 +1,100 @@
//
// TagsGenerator.swift
//
//
//
// Created by Thibaut Schmitt on 10/01/2022.
//
import CoreVideo
import Foundation
import ToolCore
import CoreVideo
class TagsGenerator {
static func writeExtensionFiles(sections: [Section], lang: String, tags: [String], staticVar: Bool, extensionName: String, extensionFilePath: String) {
enum 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)
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 {
} catch {
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 {
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.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 {
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
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 {
@ -76,11 +105,11 @@ class TagsGenerator {
}
.joined(separator: "\n")
}
private static func getFooter() -> String {
"""
}
"""
}
}

114
Sources/ResgenSwift/Strings/Model/Definition.swift
View File

@ -1,78 +1,93 @@
//
// Definition.swift
//
//
//
// Created by Thibaut Schmitt on 04/01/2022.
//
import Foundation
// swiftlint:disable force_unwrapping
class Definition {
// MARK: - Properties
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).isDisjoint(with: tags) {
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 }
let printfPlaceholderRegex = try! NSRegularExpression( // swiftlint:disable:this force_try
pattern: "%(?:\\d+\\$)?[+-]?(?:[ 0]|'.{1})?-?\\d*(?:\\.\\d+)?[blcdeEufFgGosxX@]*"
)
printfPlaceholderRegex.enumerateMatches(
in: input,
options: [],
range: NSRange(location: 0, length: input.count)
) { match, _, stop in // swiftlint:disable:this unused_closure_parameter
guard let 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() {
@ -80,10 +95,10 @@ class Definition {
translationArguments.append(paramName)
inputParameters.append("\(paramName): \(paramType)")
}
return (inputParameters: inputParameters, translationArguments: translationArguments)
}
private func getBaseProperty(lang: String, translation: String, isStatic: Bool, comment: String?) -> String {
"""
/// Translation in \(lang) :
@ -91,15 +106,20 @@ class Definition {
///
/// Comment :
/// \(comment?.isEmpty == false ? comment! : "No comment")
\(isStatic ? "static ": "")var \(name): String {
\(isStatic ? "static " : "")var \(name): String {
NSLocalizedString("\(name)", tableName: kStringsFileName, bundle: Bundle.main, value: "\(translation)", comment: "\(comment ?? "")")
}
"""
}
private func getBaseMethod(lang: String, translation: String, isStatic: Bool, inputParameters: [String], translationArguments: [String], comment: String?) -> String {
private func getBaseMethod(
lang: String,
translation: String,
isStatic: Bool,
inputParameters: [String],
translationArguments: [String],
comment: String?
) -> String {
"""
/// Translation in \(lang) :
@ -107,12 +127,12 @@ class Definition {
///
/// Comment :
/// \(comment?.isEmpty == false ? comment! : "No comment")
\(isStatic ? "static ": "")func \(name)(\(inputParameters.joined(separator: ", "))) -> String {
\(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)
@ -131,24 +151,26 @@ class Definition {
// 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,
comment: self.comment)
method = getBaseMethod(
lang: lang,
translation: translation,
isStatic: false,
inputParameters: parameters.inputParameters,
translationArguments: parameters.translationArguments,
comment: self.comment
)
}
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.description)
Stringium.exit(withError: error)
}
// Generate property
let property = getBaseProperty(
lang: lang,
@ -156,23 +178,25 @@ class Definition {
isStatic: true,
comment: self.comment
)
// 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,
comment: self.comment)
method = getBaseMethod(
lang: lang,
translation: translation,
isStatic: true,
inputParameters: parameters.inputParameters,
translationArguments: parameters.translationArguments,
comment: self.comment
)
}
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)
@ -192,14 +216,14 @@ class Definition {
}
"""
}
func getStaticProperty(forLang lang: String) -> String {
guard let translation = translations[lang] else {
let error = StringiumError.langNotDefined(lang, name, reference != nil)
print(error.description)
Stringium.exit(withError: error)
}
return """
/// Translation in \(lang) :
/// \(translation)

17
Sources/ResgenSwift/Strings/Model/Section.swift
View File

@ -8,28 +8,35 @@
import Foundation
class Section {
// MARK: - Properties
let name: String // OnBoarding
var definitions = [Definition]()
// MARK: - Init
init(name: String) {
self.name = name
}
// MARK: - Methods
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

47
Sources/ResgenSwift/Strings/Model/XcString.swift
View File

@ -8,25 +8,30 @@
import SwiftUI
struct DynamicKey: CodingKey {
var intValue: Int?
init?(intValue: Int) {
self.intValue = intValue
self.stringValue = "\(intValue)"
}
var stringValue: String
init?(stringValue: String) {
self.stringValue = stringValue
}
}
struct Root: Codable, Equatable {
let sourceLanguage: String
let strings: XCStringDefinitionContainer
let version: String
}
struct XCStringDefinitionContainer: Codable, Equatable {
let strings: [XCStringDefinition]
func encode(to encoder: Encoder) throws {
@ -39,19 +44,19 @@ struct XCStringDefinitionContainer: Codable, Equatable {
}
}
static func == (lhs: XCStringDefinitionContainer, rhs: XCStringDefinitionContainer) -> Bool {
return lhs.strings.sorted(by: {
$0.title < $1.title
}) == rhs.strings.sorted(by: { $0.title < $1.title })
static func == (lhs: Self, rhs: Self) -> Bool {
lhs.strings.sorted { $0.title < $1.title } == rhs.strings.sorted { $0.title < $1.title }
}
}
struct XCStringDefinition: Codable, Equatable {
let title: String // json key -> custom encoding methods
let content: XCStringDefinitionContent
}
struct XCStringDefinitionContent: Codable, Equatable {
let comment: String?
let extractionState: String
var localizations: XCStringLocalizationContainer
@ -64,6 +69,7 @@ struct XCStringDefinitionContent: Codable, Equatable {
}
struct XCStringLocalizationContainer: Codable, Equatable {
let localizations: [XCStringLocalization]
func encode(to encoder: Encoder) throws {
@ -76,34 +82,39 @@ struct XCStringLocalizationContainer: Codable, Equatable {
}
}
static func == (lhs: XCStringLocalizationContainer, rhs: XCStringLocalizationContainer) -> Bool {
return lhs.localizations.count == rhs.localizations.count && lhs.localizations.sorted(by: { $0.lang < $1.lang }) == rhs.localizations.sorted(by: { $0.lang < $1.lang })
static func == (lhs: Self, rhs: Self) -> Bool {
lhs.localizations.count == rhs.localizations.count
&& lhs.localizations.sorted { $0.lang < $1.lang } == rhs.localizations.sorted { $0.lang < $1.lang }
}
}
struct XCStringLocalization: Codable, Equatable {
let lang: String // json key -> custom encoding method
let content: XCStringLocalizationLangContent
}
struct XCStringLocalizationLangContent: Codable, Equatable {
let stringUnit: DefaultStringUnit
}
//enum VarationOrStringUnit: Encodable {
// case variations([Varation])
// case stringUnit: (DefaultStringUnit)
//
// func encode(to encoder: any Encoder) throws {
// if let varations {
//
// } else if let {
//
// }
// }
//}
// enum VarationOrStringUnit: Encodable
//
// case variations([Varation])
// case stringUnit: (DefaultStringUnit)
//
// func encode(to encoder: any Encoder) throws {
// if let varations {
//
// } else if let {
//
// }
// }
// }
struct DefaultStringUnit: Codable, Equatable {
let state: String
let value: String
}

48
Sources/ResgenSwift/Strings/Parser/TwineFileParser.swift
View File

@ -1,76 +1,74 @@
//
// TwineFileParser.swift
//
//
//
// Created by Thibaut Schmitt on 10/01/2022.
//
import Foundation
class TwineFileParser {
// swiftlint:disable function_body_length
enum TwineFileParser {
static func parse(_ inputFile: String) -> [Section] {
let inputFileContent = try! String(contentsOfFile: inputFile, encoding: .utf8)
let inputFileContent = try! String(contentsOfFile: inputFile, encoding: .utf8) // swiftlint:disable:this force_try
let stringsByLines = inputFileContent.components(separatedBy: .newlines)
var sections = [Section]()
// Parse file
stringsByLines.forEach {
stringsByLines.forEach { // swiftlint:disable:this closure_body_length
// 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
}
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
@ -83,10 +81,10 @@ class TwineFileParser {
return true
}
}
if invalidDefinitionNames.count > 0 {
if invalidDefinitionNames.isEmpty == false {
print("warning: [\(Stringium.toolName)] Found \(invalidDefinitionNames.count) definition (\(invalidDefinitionNames.joined(separator: ", "))")
}
return sections
}
}

104
Sources/ResgenSwift/Strings/Stringium/Stringium.swift
View File

@ -1,114 +1,122 @@
//
// Stringium.swift
//
//
//
// Created by Thibaut Schmitt on 10/01/2022.
//
import ToolCore
import Foundation
import ArgumentParser
import Foundation
import ToolCore
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
print(options.xcStrings)
if !options.xcStrings {
print("[\(Self.toolName)] Will generate strings")
StringsFileGenerator.writeStringsFiles(sections: sections,
langs: options.langs,
defaultLang: options.defaultLang,
tags: options.tags,
outputPath: options.stringsFileOutputPath,
inputFilenameWithoutExt: options.inputFilenameWithoutExt)
StringsFileGenerator.writeStringsFiles(
sections: sections,
langs: options.langs,
defaultLang: options.defaultLang,
tags: options.tags,
outputPath: options.stringsFileOutputPath,
inputFilenameWithoutExt: options.inputFilenameWithoutExt
)
} 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)
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)
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")
}
// 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)
Self.exit(withError: error)
}
// Langs
guard options.langs.isEmpty == false else {
let error = StringiumError.langsListEmpty
print(error.description)
Stringium.exit(withError: error)
Self.exit(withError: error)
}
guard options.langs.contains(options.defaultLang) else {
let error = StringiumError.defaultLangsNotInLangs
print(error.description)
Stringium.exit(withError: error)
Self.exit(withError: error)
}
// Check if needed to regenerate
guard GeneratorChecker.shouldGenerate(force: options.forceGeneration,
inputFilePath: options.inputFile,
extensionFilePath: options.extensionFilePath) else {
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
}
}

15
Sources/ResgenSwift/Strings/Stringium/StringiumError.swift
View File

@ -8,27 +8,28 @@
import Foundation
enum StringiumError: Error {
case fileNotExists(String)
case langsListEmpty
case defaultLangsNotInLangs
case writeFile(String, String)
case langNotDefined(String, String, Bool)
var description: 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):
case let .writeFile(subErrorDescription, filename):
return "error: [\(Stringium.toolName)] An error occured while writing content to \(filename): \(subErrorDescription)"
case .langNotDefined(let lang, let definitionName, let isReference):
case let .langNotDefined(lang, definitionName, isReference):
if isReference {
return "error: [\(Stringium.toolName)] Reference are handled only by Twine. Please use it or remove reference from you strings file."
}

29
Sources/ResgenSwift/Strings/Stringium/StringiumOptions.swift
View File

@ -5,31 +5,34 @@
// Created by Thibaut Schmitt on 10/01/2022.
//
import Foundation
import ArgumentParser
import Foundation
// swiftlint:disable no_grouping_extension
struct StringiumOptions: ParsableArguments {
@Flag(name: [.customShort("f"), .customShort("F")], help: "Should force generation")
var forceGeneration = false
@Argument(help: "Input files where strings are 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
@ -38,7 +41,7 @@ struct StringiumOptions: ParsableArguments {
@Option(help: "Extension name. If not specified, it will generate an String extension.")
var extensionName: String = Stringium.defaultExtensionName
@Option(help: "Extension suffix: {extensionName}+{extensionSuffix}.swift")
var extensionSuffix: String
}
@ -46,6 +49,7 @@ struct StringiumOptions: ParsableArguments {
// MARK: - Private var getter
extension StringiumOptions {
var stringsFileOutputPath: String {
var outputPath = outputPathRaw
if outputPath.last == "/" {
@ -53,13 +57,13 @@ extension StringiumOptions {
}
return outputPath
}
var langs: [String] {
langsRaw
.split(separator: " ")
.map { String($0) }
}
var tags: [String] {
tagsRaw
.split(separator: " ")
@ -70,14 +74,15 @@ extension StringiumOptions {
// MARK: - Computed var
extension StringiumOptions {
var extensionFileName: String {
"\(extensionName)+\(extensionSuffix).swift"
}
var extensionFilePath: String {
"\(extensionOutputPath)/\(extensionFileName)"
}
var inputFilenameWithoutExt: String {
URL(fileURLWithPath: inputFile)
.deletingPathExtension()

10
Sources/ResgenSwift/Strings/Strings.swift
View File

@ -5,12 +5,12 @@
// Created by Thibaut Schmitt on 10/01/2022.
//
import ToolCore
import Foundation
import ArgumentParser
import Foundation
import ToolCore
struct Strings: ParsableCommand {
static var configuration = CommandConfiguration(
abstract: "A utility for generate strings.",
version: ResgenSwiftVersion,
@ -22,8 +22,8 @@ struct Strings: ParsableCommand {
// A default subcommand, when provided, is automatically selected if a
// subcommand is not given on the command line.
//defaultSubcommand: Twine.self
// defaultSubcommand: Twine.self
)
}
//Strings.main()
// Strings.main()

64
Sources/ResgenSwift/Strings/Tag/Tags.swift
View File

@ -1,78 +1,82 @@
//
// Tag.swift
//
//
//
// Created by Thibaut Schmitt on 10/01/2022.
//
import ToolCore
import Foundation
import ArgumentParser
import Foundation
import ToolCore
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)
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 {
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
}
}

22
Sources/ResgenSwift/Strings/Tag/TagsOptions.swift
View File

@ -5,28 +5,31 @@
// Created by Thibaut Schmitt on 10/01/2022.
//
import Foundation
import ArgumentParser
import Foundation
// swiftlint:disable no_grouping_extension
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?
}
@ -34,13 +37,14 @@ struct TagsOptions: ParsableArguments {
// MARK: - Computed var
extension TagsOptions {
var extensionFileName: String {
if let extensionSuffix = extensionSuffix {
if let extensionSuffix {
return "\(extensionName)+\(extensionSuffix).swift"
}
return "\(extensionName).swift"
}
var extensionFilePath: String {
"\(extensionOutputPath)/\(extensionFileName)"
}

103
Sources/ResgenSwift/Strings/Twine/Twine.swift
View File

@ -1,96 +1,117 @@
//
// Twine.swift
//
//
//
// Created by Thibaut Schmitt on 10/01/2022.
//
import ToolCore
import Foundation
import ArgumentParser
import Foundation
import ToolCore
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"
static let twineExecutable: String = {
#if os(macOS)
"\(FileManager.default.homeDirectoryForCurrentUser.relativePath)/scripts/twine/twine"
#else
fatalError("This command should run on Mac only")
#endif
}()
// 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"])
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"])
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.description)
Twine.exit(withError: error)
Self.exit(withError: error)
}
// Langs
guard options.langs.isEmpty == false else {
let error = TwineError.langsListEmpty
print(error.description)
Twine.exit(withError: error)
Self.exit(withError: error)
}
guard options.langs.contains(options.defaultLang) else {
let error = TwineError.defaultLangsNotInLangs
print(error.description)
Twine.exit(withError: error)
Self.exit(withError: error)
}
// Check if needed to regenerate
guard GeneratorChecker.shouldGenerate(force: options.forceGeneration,
inputFilePath: options.inputFile,
extensionFilePath: options.extensionFilePathGenerated) else {
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
}
}

7
Sources/ResgenSwift/Strings/Twine/TwineError.swift
View File

@ -8,18 +8,19 @@
import Foundation
enum TwineError: Error {
case fileNotExists(String)
case langsListEmpty
case defaultLangsNotInLangs
var description: 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"
}

21
Sources/ResgenSwift/Strings/Twine/TwineOptions.swift
View File

@ -5,25 +5,28 @@
// Created by Thibaut Schmitt on 10/01/2022.
//
import Foundation
import ArgumentParser
import Foundation
// swiftlint:disable no_grouping_extension
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
}
@ -31,6 +34,7 @@ struct TwineOptions: ParsableArguments {
// MARK: - Private var getter
extension TwineOptions {
var langs: [String] {
langsRaw
.split(separator: " ")
@ -41,16 +45,17 @@ extension TwineOptions {
// 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"