Add minimum_fraction_length to number_separator

CHANGELOG.md

@@ -13,6 +13,11 @@
   [Aaron McTavish](https://github.com/aamctustwo)
   [#1169](https://github.com/realm/SwiftLint/issues/1169)
 
+* Update `number_separator` rule to allow for specifying
+  minimum length of fraction.
+  [Bjarke Søndergaard](https://github.com/bjarkehs)
+  [#1200](https://github.com/realm/SwiftLint/issues/1200)
+
 ##### Bug Fixes
 
 * Fix false positives on `shorthand_operator` rule.  

Source/SwiftLintFramework/Rules/NumberSeparatorRule.swift

@@ -10,7 +10,7 @@ import Foundation
 import SourceKittenFramework
 
 public struct NumberSeparatorRule: OptInRule, CorrectableRule, ConfigurationProviderRule {
-    public var configuration = NumberSeparatorConfiguration(minimumLength: 0)
+    public var configuration = NumberSeparatorConfiguration(minimumLength: 0, minimumFractionLength: nil)
 
     public init() {}
 
@@ -51,13 +51,13 @@ public struct NumberSeparatorRule: OptInRule, CorrectableRule, ConfigurationProv
             var validFraction = true
             var expectedFraction: String?
             if components.count == 2, let fractionSubstring = components.last {
-                let result = isValid(number: fractionSubstring, reversed: false)
+                let result = isValid(number: fractionSubstring, reversed: false, isFraction: true)
                 validFraction = result.0
                 expectedFraction = result.1
             }
 
             guard let integerSubstring = components.first,
-                case let (valid, expected) = isValid(number: integerSubstring, reversed: true),
+                case let (valid, expected) = isValid(number: integerSubstring, reversed: true, isFraction: false),
                 !valid || !validFraction,
                 let range = file.contents.bridge().byteRangeToNSRange(start: token.offset,
                                                                       length: token.length) else {
@@ -113,10 +113,18 @@ public struct NumberSeparatorRule: OptInRule, CorrectableRule, ConfigurationProv
         return prefixes.filter { lowercased.hasPrefix($0) }.isEmpty
     }
 
-    private func isValid(number: String, reversed: Bool) -> (Bool, String) {
+    private func isValid(number: String, reversed: Bool, isFraction: Bool) -> (Bool, String) {
         var correctComponents = [String]()
         let clean = number.replacingOccurrences(of: "_", with: "")
-        let shouldAddSeparators = clean.characters.count >= configuration.minimumLength
+
+        let minimumLength: Int
+        if isFraction {
+            minimumLength = configuration.minimumFractionLength ?? configuration.minimumLength
+        } else {
+            minimumLength = configuration.minimumLength
+        }
+
+        let shouldAddSeparators = clean.characters.count >= minimumLength
 
         for (idx, char) in reversedIfNeeded(Array(clean.characters),
                                             reversed: reversed).enumerated() {

Source/SwiftLintFramework/Rules/RuleConfigurations/NumberSeparatorConfiguration.swift

@@ -9,13 +9,23 @@
 public struct NumberSeparatorConfiguration: RuleConfiguration, Equatable {
     private(set) var severityConfiguration = SeverityConfiguration(.warning)
     private(set) var minimumLength: Int
+    private(set) var minimumFractionLength: Int?
 
     public var consoleDescription: String {
-        return severityConfiguration.consoleDescription + ", minimum_length: \(minimumLength)"
+        let minimumFractionLengthDescription: String
+        if let minimumFractionLength = self.minimumFractionLength {
+            minimumFractionLengthDescription = ", minimum_fraction_length: \(minimumFractionLength)"
+        } else {
+            minimumFractionLengthDescription = ""
+        }
+        return severityConfiguration.consoleDescription
+            + ", minimum_length: \(minimumLength)"
+            + minimumFractionLengthDescription
     }
 
-    public init(minimumLength: Int) {
+    public init(minimumLength: Int, minimumFractionLength: Int?) {
         self.minimumLength = minimumLength
+        self.minimumFractionLength = minimumFractionLength
     }
 
     public mutating func apply(configuration: Any) throws {
@@ -27,6 +37,10 @@ public struct NumberSeparatorConfiguration: RuleConfiguration, Equatable {
             self.minimumLength = minimumLength
         }
 
+        if let minimumFractionLength = configuration["minimum_fraction_length"] as? Int {
+            self.minimumFractionLength = minimumFractionLength
+        }
+
         if let severityString = configuration["severity"] as? String {
             try severityConfiguration.apply(configuration: severityString)
         }
@@ -35,6 +49,7 @@ public struct NumberSeparatorConfiguration: RuleConfiguration, Equatable {
     public static func == (lhs: NumberSeparatorConfiguration,
                            rhs: NumberSeparatorConfiguration) -> Bool {
         return lhs.minimumLength == rhs.minimumLength &&
+            lhs.minimumFractionLength == rhs.minimumFractionLength &&
             lhs.severityConfiguration == rhs.severityConfiguration
     }
 }