Add implementation

dhardiman · Jun 24, 2019 · cd4be1e · cd4be1e
1 parent 0666a0f
commit cd4be1e
Show file tree

Hide file tree

Showing 5 changed files with 74 additions and 20 deletions.
diff --git a/Sources/Config/ConfigurationFile.swift b/Sources/Config/ConfigurationFile.swift
@@ -26,12 +26,12 @@ struct Configuration {
     let properties: [String: Property]
     let childConfigurations: [String: Configuration]
 
-    init(config: [String: Any], referenceSource: [String: Any]?, customTypes: [CustomType], defaultType: PropertyType?) {
+    init(config: [String: Any], referenceSource: [String: Any]?, customTypes: [CustomType], defaultType: PropertyType?, commonPatterns: [OverridePattern]) {
         properties = config.reduce([String: Property]()) { properties, pair in
-            return parseNextProperty(properties: properties, pair: pair, config: config, referenceSource: referenceSource, customTypes: customTypes, defaultType: defaultType)
+            return parseNextProperty(properties: properties, pair: pair, config: config, referenceSource: referenceSource, customTypes: customTypes, defaultType: defaultType, patterns: commonPatterns)
         }
         childConfigurations = config.reduce([String: Configuration]()) { configurations, pair in
-            return parseNextConfiguration(configurations: configurations, pair: pair, config: config, referenceSource: referenceSource, customTypes: customTypes, defaultType: defaultType)
+            return parseNextConfiguration(configurations: configurations, pair: pair, config: config, referenceSource: referenceSource, customTypes: customTypes, defaultType: defaultType, patterns: commonPatterns)
         }
     }
 
@@ -90,7 +90,7 @@ extension String {
     }
 }
 
-func parseNextProperty(properties: [String: Property], pair: (key: String, value: Any), config: [String: Any], referenceSource: [String: Any]?, customTypes: [CustomType], defaultType: PropertyType?) -> [String: Property] {
+func parseNextProperty(properties: [String: Property], pair: (key: String, value: Any), config: [String: Any], referenceSource: [String: Any]?, customTypes: [CustomType], defaultType: PropertyType?, patterns: [OverridePattern]) -> [String: Property] {
     guard let dict = pair.value as? [String: Any] else {
         return properties
     }
@@ -101,21 +101,21 @@ func parseNextProperty(properties: [String: Property], pair: (key: String, value
     if let typeHint = PropertyType(rawValue: typeHintValue) {
         switch typeHint {
         case .string, .url, .encrypted, .encryptionKey, .colour, .image, .regex:
-            copy[pair.key] = ConfigurationProperty<String>(key: pair.key, typeHint: typeHintValue, dict: dict)
+            copy[pair.key] = ConfigurationProperty<String>(key: pair.key, typeHint: typeHintValue, dict: dict, patterns: patterns)
         case .optionalString:
-            copy[pair.key] = ConfigurationProperty<String?>(key: pair.key, typeHint: typeHintValue, dict: dict)
+            copy[pair.key] = ConfigurationProperty<String?>(key: pair.key, typeHint: typeHintValue, dict: dict, patterns: patterns)
         case .double, .float:
-            copy[pair.key] = ConfigurationProperty<Double>(key: pair.key, typeHint: typeHintValue, dict: dict)
+            copy[pair.key] = ConfigurationProperty<Double>(key: pair.key, typeHint: typeHintValue, dict: dict, patterns: patterns)
         case .int:
-            copy[pair.key] = ConfigurationProperty<Int>(key: pair.key, typeHint: typeHintValue, dict: dict)
+            copy[pair.key] = ConfigurationProperty<Int>(key: pair.key, typeHint: typeHintValue, dict: dict, patterns: patterns)
         case .optionalInt:
-            copy[pair.key] = ConfigurationProperty<Int?>(key: pair.key, typeHint: typeHintValue, dict: dict)
+            copy[pair.key] = ConfigurationProperty<Int?>(key: pair.key, typeHint: typeHintValue, dict: dict, patterns: patterns)
         case .dictionary:
-            copy[pair.key] = ConfigurationProperty<[String: Any]>(key: pair.key, typeHint: typeHintValue, dict: dict)
+            copy[pair.key] = ConfigurationProperty<[String: Any]>(key: pair.key, typeHint: typeHintValue, dict: dict, patterns: patterns)
         case .bool:
-            copy[pair.key] = ConfigurationProperty<Bool>(key: pair.key, typeHint: typeHintValue, dict: dict)
+            copy[pair.key] = ConfigurationProperty<Bool>(key: pair.key, typeHint: typeHintValue, dict: dict, patterns: patterns)
         case .stringArray:
-            copy[pair.key] = ConfigurationProperty<[String]>(key: pair.key, typeHint: typeHintValue, dict: dict)
+            copy[pair.key] = ConfigurationProperty<[String]>(key: pair.key, typeHint: typeHintValue, dict: dict, patterns: patterns)
         case .reference:
             guard let referenceType = referenceTypeHint(for: dict, in: config, referenceSource: referenceSource) else {
                 return properties
@@ -129,7 +129,7 @@ func parseNextProperty(properties: [String: Property], pair: (key: String, value
             copy[pair.key] = CustomPropertyArray(key: pair.key, customType: customType, dict: dict)
         }
         else {
-            copy[pair.key] = ConfigurationProperty<String>(key: pair.key, typeHint: typeHintValue, dict: dict)
+            copy[pair.key] = ConfigurationProperty<String>(key: pair.key, typeHint: typeHintValue, dict: dict, patterns: patterns)
         }
     }
     return copy
@@ -153,12 +153,12 @@ private func referenceDict(for key: String, from config: [String: Any], or refer
     return referenceSource?[key] as? [String: Any]
 }
 
-func parseNextConfiguration(configurations: [String: Configuration], pair: (key: String, value: Any), config: [String: Any], referenceSource: [String: Any]?, customTypes: [CustomType], defaultType: PropertyType?) -> [String: Configuration] {
+func parseNextConfiguration(configurations: [String: Configuration], pair: (key: String, value: Any), config: [String: Any], referenceSource: [String: Any]?, customTypes: [CustomType], defaultType: PropertyType?, patterns: [OverridePattern]) -> [String: Configuration] {
     guard let dict = pair.value as? [String: Any], dict["defaultValue"] == nil, pair.key != "template" else {
         return configurations
     }
     var copy = configurations
-    copy[pair.key] = Configuration(config: dict, referenceSource: referenceSource, customTypes: customTypes, defaultType: defaultType)
+    copy[pair.key] = Configuration(config: dict, referenceSource: referenceSource, customTypes: customTypes, defaultType: defaultType, commonPatterns: patterns)
     return copy
 }
 
@@ -177,6 +177,8 @@ struct ConfigurationFile: Template {
 
     let customTypes: [CustomType]
 
+    let commonPatterns: [OverridePattern]
+
     let defaultType: PropertyType?
 
     init(config: [String: Any], name: String, scheme: String, source: URL) throws {
@@ -188,6 +190,7 @@ struct ConfigurationFile: Template {
         self.imports = ["Foundation"] + ((self.template?["imports"] as? [String]) ?? [])
 
         self.customTypes = CustomType.typeArray(from: self.template)
+        self.commonPatterns = OverridePattern.patterns(from: self.template)
 
         if let defaultType = template?["defaultType"] as? String {
             self.defaultType = PropertyType(rawValue: defaultType)
@@ -203,15 +206,15 @@ struct ConfigurationFile: Template {
 
         iv = try IV(dict: config)
 
-        let root = Configuration(config: config, referenceSource: referenceSource, customTypes: customTypes, defaultType: defaultType)
+        let root = Configuration(config: config, referenceSource: referenceSource, customTypes: customTypes, defaultType: defaultType, commonPatterns: commonPatterns)
         var parsedProperties = root.properties
 
         encryptionKey = parsedProperties.values.compactMap { $0 as? ConfigurationProperty<String> }
             .first(where: { $0.type == .encryptionKey })?.defaultValue
         if encryptionKey != nil {
             parsedProperties[iv.key] = iv
         }
-        if template?["extensionOn"] == nil, let schemeProperty = ConfigurationProperty<String>(key: "schemeName", typeHint: "String", dict: ["defaultValue": scheme]) {
+        if template?["extensionOn"] == nil, let schemeProperty = ConfigurationProperty<String>(key: "schemeName", typeHint: "String", dict: ["defaultValue": scheme], patterns: commonPatterns) {
             parsedProperties[schemeProperty.key] = schemeProperty
         }
         rootConfiguration = Configuration(properties: parsedProperties, childConfigurations: root.childConfigurations)

diff --git a/Sources/Config/ConfigurationProperty.swift b/Sources/Config/ConfigurationProperty.swift
@@ -20,6 +20,7 @@ struct ConfigurationProperty<T>: Property, AssociatedPropertyKeyProviding {
     let defaultValue: T
     let associatedProperty: String?
     let overrides: [String: T]
+    let patterns: [OverridePattern]
 
     var typeName: String {
         if let type = type {
@@ -51,7 +52,7 @@ struct ConfigurationProperty<T>: Property, AssociatedPropertyKeyProviding {
         throw Failure.notConvertible
     }
 
-    init?(key: String, typeHint: String, dict: [String: Any]) {
+    init?(key: String, typeHint: String, dict: [String: Any], patterns: [OverridePattern] = []) {
         do {
             self.defaultValue = try ConfigurationProperty.transformValueToType(value: dict["defaultValue"])
 
@@ -60,6 +61,7 @@ struct ConfigurationProperty<T>: Property, AssociatedPropertyKeyProviding {
             self.associatedProperty = dict["associatedProperty"] as? String
             self.type = PropertyType(rawValue: typeHint)
             self.description = dict["description"] as? String
+            self.patterns = patterns
 
             let overrides = try? dict["overrides"]
                 .flatMap { $0 as? [String: Any] }?
@@ -71,12 +73,20 @@ struct ConfigurationProperty<T>: Property, AssociatedPropertyKeyProviding {
         }
     }
 
+    private func pattern(for override: String) -> String {
+        guard let pattern = patterns.first(where: { $0.alias == override }) else {
+            return override
+        }
+        return pattern.pattern
+    }
+
     func value(for scheme: String) -> T {
+
         if let override = overrides.first(where: { item in
             if associatedProperty != nil {
                 return item.key == scheme
             }
-            return scheme.range(of: item.key, options: .regularExpression) != nil
+            return scheme.range(of: pattern(for: item.key), options: .regularExpression) != nil
         }) {
             return override.value
         }

diff --git a/Sources/Config/EnumConfiguration.swift b/Sources/Config/EnumConfiguration.swift
@@ -44,7 +44,7 @@ struct EnumConfiguration: Template {
             var copy = properties
             switch type {
             case "String":
-                copy[pair.key] = ConfigurationProperty<String>(key: pair.key, typeHint: "", dict: dict)
+                copy[pair.key] = ConfigurationProperty<String>(key: pair.key, typeHint: "", dict: dict, patterns: OverridePattern.patterns(from: template))
             default: throw EnumError.unknownType
             }
             return copy

diff --git a/Sources/Config/OverridePattern.swift b/Sources/Config/OverridePattern.swift
@@ -0,0 +1,28 @@
+//
+//  OverridePattern.swift
+//  Config
+//
+//  Created by David Hardiman on 24/06/2019.
+//
+
+import Foundation
+
+struct OverridePattern {
+    let alias: String
+    let pattern: String
+
+    init?(source: [String: String]) {
+        guard let alias = source["alias"], let pattern = source["pattern"] else {
+            return nil
+        }
+        self.alias = alias
+        self.pattern = pattern
+    }
+
+    static func patterns(from template: [String: Any]?) -> [OverridePattern] {
+        guard let types = template?["patterns"] as? [[String: String]] else {
+            return []
+        }
+        return types.compactMap { OverridePattern(source: $0) }
+    }
+}
diff --git a/Tests/ConfigTests/ConfigurationPropertyTests.swift b/Tests/ConfigTests/ConfigurationPropertyTests.swift
@@ -294,4 +294,17 @@ class ConfigurationPropertyTests: XCTestCase {
         let actualValue = try whenTheDeclarationIsWritten(for: property)
         expect(actualValue).to(equal(expectedValue))
     }
+
+    func testItCanUseCommonPatternsForOverrides() throws {
+        let dict: [String: Any] = [
+            "defaultValue": "test value",
+            "overrides": [
+                "barry": "pattern value"
+            ]
+        ]
+        let property = ConfigurationProperty<String>(key: "test", typeHint: "String", dict: dict, patterns: [OverridePattern(source: ["alias": "barry", "pattern": "gary"])!])
+        let expectedValue = ##"    static let test: String = #"pattern value"#"##
+        let actualValue = try whenTheDeclarationIsWritten(for: property, scheme: "gary")
+        expect(actualValue).to(equal(expectedValue))
+    }
 }