Factor out the common nanosecond formatting

Formatting nanoseconds to 3, 6, or 9 digits occurs in
two different places.  Factor that out to reduce duplication.

Author: tbkka

Sources/SwiftProtobuf/Google_Protobuf_Duration+Extensions.swift

@@ -99,16 +99,8 @@ private func formatDuration(seconds: Int64, nanos: Int32) -> String? {
   guard seconds >= minDurationSeconds && seconds <= maxDurationSeconds else {
     return nil
   }
-
-  if nanos == 0 {
-    return String(seconds) + "s"
-  } else if nanos % 1000000 == 0 {
-    return "\(seconds).\(threeDigit(abs(nanos) / 1000000))s"
-  } else if nanos % 1000 == 0 {
-    return "\(seconds).\(sixDigit(abs(nanos) / 1000))s"
-  } else {
-    return "\(seconds).\(nineDigit(abs(nanos)))s"
-  }
+  let nanosString = nanosToString(nanos: nanos) // Includes leading '.' if needed
+  return "\(seconds)\(nanosString)s"
 }
 
 extension Google_Protobuf_Duration {

Sources/SwiftProtobuf/Google_Protobuf_Timestamp+Extensions.swift

@@ -193,16 +193,9 @@ private func formatTimestamp(seconds: Int64, nanos: Int32) -> String? {
 
   let dateString = "\(fourDigit(YY))-\(twoDigit(MM))-\(twoDigit(DD))"
   let timeString = "\(twoDigit(hh)):\(twoDigit(mm)):\(twoDigit(ss))"
+  let nanosString = nanosToString(nanos: nanos) // Includes leading '.' if needed
 
-  if nanos == 0 {
-    return "\(dateString)T\(timeString)Z"
-  } else if nanos % 1000000 == 0 {
-    return "\(dateString)T\(timeString).\(threeDigit(nanos / 1000000))Z"
-  } else if nanos % 1000 == 0 {
-    return "\(dateString)T\(timeString).\(sixDigit(nanos / 1000))Z"
-  } else {
-    return "\(dateString)T\(timeString).\(nineDigit(nanos))Z"
-  }
+  return "\(dateString)T\(timeString)\(nanosString)Z"
 }
 
 extension Google_Protobuf_Timestamp {

Sources/SwiftProtobuf/TimeUtils.swift

@@ -51,3 +51,15 @@ internal func gregorianDateFromSecondsSince1970(seconds: Int64) -> (YY: Int32, M
 
     return (YY: Int32(YY), MM: Int32(MM), DD: Int32(DD))
 }
+
+internal func nanosToString(nanos: Int32) -> String {
+  if nanos == 0 {
+    return ""
+  } else if nanos % 1000000 == 0 {
+    return ".\(threeDigit(abs(nanos) / 1000000))"
+  } else if nanos % 1000 == 0 {
+    return ".\(sixDigit(abs(nanos) / 1000))"
+  } else {
+    return ".\(nineDigit(abs(nanos)))"
+  }
+}