Add a way of disabling exponential notation when encoding doubles

Sources/Yams/Emitter.swift

@@ -223,6 +223,11 @@ public final class Emitter {
         case crln
     }
 
+    public enum NumberFormatStyle {
+        case scientific
+        case decimal
+    }
+
     /// Retrieve this Emitter's binary output.
     public internal(set) var data = Data()
 
@@ -254,6 +259,14 @@ public final class Emitter {
 
         /// Set the style for mappings (dictionaries)
         public var mappingStyle: Node.Mapping.Style = .any
+
+        /// Set the style for formatting doubles
+        public static var doubleFormatStyle: NumberFormatStyle = .scientific
+
+        public static let doubleMaximumSignificantDigits = 15
+        public static let doubleMinimumFractionDigits = 1
+
+        public static let floatMaximumSignificantDigits = 7
     }
 
     /// Configuration options to use when emitting YAML.

Sources/Yams/Representer.swift

@@ -170,7 +170,12 @@ private let iso8601WithoutZFormatter: DateFormatter = {
 extension Double: ScalarRepresentable {
     /// This value's `Node.scalar` representation.
     public func represented() -> Node.Scalar {
-        return .init(doubleFormatter.string(for: self)!.replacingOccurrences(of: "+-", with: "-"), Tag(.float))
+        switch Emitter.Options.doubleFormatStyle {
+            case .scientific:
+                return .init(doubleScientificFormatter.string(for: self)!.replacingOccurrences(of: "+-", with: "-"), Tag(.float))
+            case .decimal:
+                return .init(doubleDecimalFormatter.string(for: self)!, Tag(.float))
+        }
     }
 }
 
@@ -181,21 +186,26 @@ extension Float: ScalarRepresentable {
     }
 }
 
-private func numberFormatter(with significantDigits: Int) -> NumberFormatter {
+private func numberFormatter(with significantDigits: Int, style: NumberFormatter.Style = .scientific, minimumFractionDigits: Int = 0) -> NumberFormatter {
     let formatter = NumberFormatter()
     formatter.locale = Locale(identifier: "en_US")
-    formatter.numberStyle = .scientific
-    formatter.usesSignificantDigits = true
-    formatter.maximumSignificantDigits = significantDigits
+    formatter.numberStyle = style
+    if style == .scientific {
+        formatter.usesSignificantDigits = true
+        formatter.maximumSignificantDigits = significantDigits
+    }
     formatter.positiveInfinitySymbol = ".inf"
     formatter.negativeInfinitySymbol = "-.inf"
     formatter.notANumberSymbol = ".nan"
     formatter.exponentSymbol = "e+"
+    formatter.minimumFractionDigits = minimumFractionDigits
     return formatter
 }
 
-private let doubleFormatter = numberFormatter(with: 15)
-private let floatFormatter = numberFormatter(with: 7)
+private let doubleDecimalFormatter = numberFormatter(with: Emitter.Options.doubleMaximumSignificantDigits, style: .decimal, minimumFractionDigits: Emitter.Options.doubleMinimumFractionDigits)
+private let doubleScientificFormatter = numberFormatter(with: Emitter.Options.doubleMaximumSignificantDigits, style: .scientific)
+
+private let floatFormatter = numberFormatter(with: Emitter.Options.floatMaximumSignificantDigits)
 
 // TODO: Support `Float80`
 // extension Float80: ScalarRepresentable {}
@@ -314,13 +324,17 @@ extension Float: YAMLEncodable {
 
 private extension FloatingPoint where Self: CVarArg {
     var formattedStringForCodable: String {
+        if Emitter.Options.doubleFormatStyle == .decimal {
+            return doubleDecimalFormatter.string(for: self)!
+        }
+
         // Since `NumberFormatter` creates a string with insufficient precision for Decode,
         // it uses with `String(format:...)`
         let string = String(format: "%.*g", DBL_DECIMAL_DIG, self)
         // "%*.g" does not use scientific notation if the exponent is less than –4.
         // So fallback to using `NumberFormatter` if string does not uses scientific notation.
         guard string.lazy.suffix(5).contains("e") else {
-            return doubleFormatter.string(for: self)!.replacingOccurrences(of: "+-", with: "-")
+            return doubleScientificFormatter.string(for: self)!.replacingOccurrences(of: "+-", with: "-")
         }
         return string
     }

Tests/LinuxMain.swift

@@ -13,5 +13,6 @@ XCTMain([
     testCase(ResolverTests.allTests),
     testCase(SpecTests.allTests),
     testCase(StringTests.allTests),
-    testCase(YamlErrorTests.allTests)
+    testCase(YamlErrorTests.allTests),
+    testCase(DoubleEncodingTests.allTests)
 ])

Tests/YamsTests/DoubleEncodingTests.swift

@@ -0,0 +1,36 @@
+import Foundation
+import XCTest
+import Yams
+
+class DoubleEncodingTests: XCTestCase {
+    override class func setUp() {
+        Emitter.Options.doubleFormatStyle = .decimal
+    }
+
+    func testDecimalDoubleStyle() throws {
+        XCTAssertEqual(try Node(Double(6.85)), "6.85")
+    }
+
+    func testMinimumFractionDigits() throws {
+        XCTAssertEqual(try Node(Double(6.0)), "6.0")
+    }
+
+    func testDecimalDoubleStyleBox() throws {
+        print(try Double(6.85).box(), "6.85")
+    }
+
+    func testMinimumFractionDigitsBox() throws {
+        print(try Double(6.0).box(), "6.0")
+    }
+}
+
+extension DoubleEncodingTests {
+    static var allTests: [(String, (DoubleEncodingTests) -> () throws -> Void)] {
+        return [
+            ("testDecimalDoubleStyle", testDecimalDoubleStyle),
+            ("testMinimumFractionDigits", testMinimumFractionDigits),
+            ("testDecimalDoubleStyleBox", testDecimalDoubleStyleBox),
+            ("testMinimumFractionDigitsBox", testMinimumFractionDigitsBox)
+        ]
+    }
+}