[PlaygroundLogger] Introduced a temporary loggingError function.

cwakamo · cwakamo · commit 4804597b76aa · 2018-02-23T17:29:54.000-08:00
This is intended as a placeholder for all of the places which should generate proper errors once error handling/generation is implemented.
This makes it easier to see what's actually unimplemented, what actually should call fatalError, and what actually should report proper errors to the user.
diff --git a/PlaygroundLogger/PlaygroundLogger.xcodeproj/project.pbxproj b/PlaygroundLogger/PlaygroundLogger.xcodeproj/project.pbxproj
@@ -77,6 +77,7 @@
 		5E5D77802040BD7D00EBC3A9 /* LogPolicyTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5E5D777F2040BD7D00EBC3A9 /* LogPolicyTests.swift */; };
 		5E5D77812040BD7D00EBC3A9 /* LogPolicyTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5E5D777F2040BD7D00EBC3A9 /* LogPolicyTests.swift */; };
 		5E5D77822040BD7D00EBC3A9 /* LogPolicyTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5E5D777F2040BD7D00EBC3A9 /* LogPolicyTests.swift */; };
+		5E5D77842040F5E900EBC3A9 /* LoggingError.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5E5D77832040F5E900EBC3A9 /* LoggingError.swift */; };
 		5E5F600B20409D4E007EF0A8 /* LogPolicy.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5E5F600A20409D4E007EF0A8 /* LogPolicy.swift */; };
 		5E5FE50B202D13C800E28C3C /* PGLConcurrentMap.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5E5FE50A202D13C800E28C3C /* PGLConcurrentMap.swift */; };
 		5ECE8F911FFCD2A70034D9BC /* LegacyPlaygroundLoggerTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5ECE8F901FFCD2A70034D9BC /* LegacyPlaygroundLoggerTests.swift */; };
@@ -243,6 +244,7 @@
 		5E4AF1AC1FDDBDE400B7C9D9 /* Unimplemented.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Unimplemented.swift; sourceTree = "<group>"; };
 		5E4AF1AE1FDDC12A00B7C9D9 /* LegacyEntrypoints.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = LegacyEntrypoints.swift; sourceTree = "<group>"; };
 		5E5D777F2040BD7D00EBC3A9 /* LogPolicyTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = LogPolicyTests.swift; sourceTree = "<group>"; };
+		5E5D77832040F5E900EBC3A9 /* LoggingError.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = LoggingError.swift; sourceTree = "<group>"; };
 		5E5F600A20409D4E007EF0A8 /* LogPolicy.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = LogPolicy.swift; sourceTree = "<group>"; };
 		5E5FE50A202D13C800E28C3C /* PGLConcurrentMap.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PGLConcurrentMap.swift; sourceTree = "<group>"; };
 		5ECE8F901FFCD2A70034D9BC /* LegacyPlaygroundLoggerTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = LegacyPlaygroundLoggerTests.swift; sourceTree = "<group>"; };
@@ -564,6 +566,7 @@
 			isa = PBXGroup;
 			children = (
 				5E4AF1AC1FDDBDE400B7C9D9 /* Unimplemented.swift */,
+				5E5D77832040F5E900EBC3A9 /* LoggingError.swift */,
 				5E184716202BB80200F01AD1 /* PGLConcurrentMap.h */,
 				5E184717202BB80200F01AD1 /* PGLConcurrentMap_MRR.m */,
 				5E5FE50A202D13C800E28C3C /* PGLConcurrentMap.swift */,
@@ -890,6 +893,7 @@
 				5E27566E1FC51F7E00B69C83 /* CGGeometry+CustomOpaqueLoggable.swift in Sources */,
 				5E2756201FC485AA00B69C83 /* TaggedOpaqueRepresentation.swift in Sources */,
 				5E2646431FB64B2A002DC6B6 /* LoggerEntrypoints.swift in Sources */,
+				5E5D77842040F5E900EBC3A9 /* LoggingError.swift in Sources */,
 				5E2646521FB65026002DC6B6 /* LoggerInitialization.swift in Sources */,
 				5E2755D51FB6807F00B69C83 /* LogPacket+Encoding.swift in Sources */,
 				5E2756461FC4DC0C00B69C83 /* ImageOpaqueRepresentation.swift in Sources */,
diff --git a/PlaygroundLogger/PlaygroundLogger/CustomLoggable/CoreImage/CIColor+CustomOpaqueLoggable.swift b/PlaygroundLogger/PlaygroundLogger/CustomLoggable/CoreImage/CIColor+CustomOpaqueLoggable.swift
@@ -15,8 +15,7 @@ import CoreImage
 extension CIColor: CustomOpaqueLoggable {
     var opaqueRepresentation: LogEntry.OpaqueRepresentation {
         guard let color = CGColor(colorSpace: self.colorSpace, components: self.components) else {
-            // TODO: don't crash in this case
-            fatalError("Unable to convert CIColor to CGColor")
+            loggingError("Unable to convert CIColor to CGColor")
         }
         
         return color
diff --git a/PlaygroundLogger/PlaygroundLogger/CustomLoggable/SpriteKit/SpriteKitOpaqueLoggable.swift b/PlaygroundLogger/PlaygroundLogger/CustomLoggable/SpriteKit/SpriteKitOpaqueLoggable.swift
@@ -23,7 +23,7 @@ fileprivate protocol SpriteKitOpaqueLoggable: class, OpaqueImageRepresentable, C
 extension SpriteKitOpaqueLoggable {
     func encodeImage(into encoder: LogEncoder, withFormat format: LogEncoder.Format) {
         guard let copyImageDataMethod = (self as AnyObject)._copyImageData, let imageData = copyImageDataMethod() else {
-            unimplemented("Handle case where we don't have any image data")
+            loggingError("SpriteKit did not return any image data")
         }
         
         encoder.encode(number: UInt64(imageData.count))
diff --git a/PlaygroundLogger/PlaygroundLogger/LegacySupport/PlaygroundQuickLook+OpaqueRepresentationSupport.swift b/PlaygroundLogger/PlaygroundLogger/LegacySupport/PlaygroundQuickLook+OpaqueRepresentationSupport.swift
@@ -36,51 +36,51 @@ extension PlaygroundQuickLook {
         case let .image(image):
             #if os(macOS)
                 guard let image = image as? NSImage else {
-                    fatalError("Must be an NSImage")
+                    loggingError("Must be an NSImage")
                 }
                 
                 return ImageOpaqueRepresentation(kind: .image, backedBy: image)
             #elseif os(iOS) || os(tvOS)
                 guard let image = image as? UIImage else {
-                    fatalError("Must be an IOImage")
+                    loggingError("Must be an IOImage")
                 }
                 
                 return ImageOpaqueRepresentation(kind: .image, backedBy: image)
                 
             #endif
         case .sound:
-            fatalError("Sounds not yet supported")
+            loggingError("Sounds not supported")
         case let .color(color):
             #if os(macOS)
                 guard let color = color as? NSColor else {
-                    fatalError("Must be an NSColor")
+                    loggingError("Must be an NSColor")
                 }
                 
                 return color.cgColor
             #elseif os(iOS) || os(tvOS)
                 guard let color = color as? UIColor else {
-                    fatalError("Must be a UIColor")
+                    loggingError("Must be a UIColor")
                 }
                 
                 return color.cgColor
             #endif
         case let .bezierPath(bezierPath):
             #if os(macOS)
                 guard let bezierPath = bezierPath as? NSBezierPath else {
-                    fatalError("Must be an NSBezierPath")
+                    loggingError("Must be an NSBezierPath")
                 }
                 
                 return bezierPath
             #elseif os(iOS) || os(tvOS)
                 guard let bezierPath = bezierPath as? UIBezierPath else {
-                    fatalError("Must be a UIBezierPath")
+                    loggingError("Must be a UIBezierPath")
                 }
                 
                 return bezierPath
             #endif
         case let .attributedString(attributedString):
             guard let attributedString = attributedString as? NSAttributedString else {
-                fatalError("Must be an NSAttributedString")
+                loggingError("Must be an NSAttributedString")
             }
             
             return attributedString
@@ -103,7 +103,7 @@ extension PlaygroundQuickLook {
                     return ImageOpaqueRepresentation(kind: .view, backedBy: image)
                 }
                 else {
-                    fatalError("Must be an NSView or NSImage")
+                    loggingError("Must be an NSView or NSImage")
                 }
             #elseif os(iOS) || os(tvOS)
                 if let view = viewOrImage as? UIView {
@@ -113,27 +113,27 @@ extension PlaygroundQuickLook {
                     return ImageOpaqueRepresentation(kind: .view, backedBy: image)
                 }
                 else {
-                    fatalError("Must be a UIView or UIImage")
+                    loggingError("Must be a UIView or UIImage")
                 }
             #endif
         case let .sprite(image):
             // TODO: figure out if this is even a little bit right. (The previous implementation just logged a string for sprites?)
             #if os(macOS)
                 guard let image = image as? NSImage else {
-                    fatalError("Must be an NSImage")
+                    loggingError("Must be an NSImage")
                 }
                 
                 return ImageOpaqueRepresentation(kind: .sprite, backedBy: image)
             #elseif os(iOS) || os(tvOS)
                 guard let image = image as? UIImage else {
-                    fatalError("Must be a UIImage")
+                    loggingError("Must be a UIImage")
                 }
                 
                 return ImageOpaqueRepresentation(kind: .sprite, backedBy: image)
             #endif
         case let .url(urlString):
             guard let url = URL(string: urlString) else {
-                fatalError("Must be a valid URL string!")
+                loggingError("Must be a valid URL string!")
             }
             
             return url
diff --git a/PlaygroundLogger/PlaygroundLogger/OpaqueRepresentations/AppKit/NSBitmapImageRep+OpaqueImageRepresentable.swift b/PlaygroundLogger/PlaygroundLogger/OpaqueRepresentations/AppKit/NSBitmapImageRep+OpaqueImageRepresentable.swift
@@ -16,7 +16,7 @@
     extension NSBitmapImageRep: OpaqueImageRepresentable {
         func encodeImage(into encoder: LogEncoder, withFormat format: LogEncoder.Format) {
             guard let pngData = self.representation(using: .png, properties: [:]) else {
-                unimplemented("Need to handle error when we couldn't generate PNG data")
+                loggingError("Failed to generate PNG data")
             }
 
             encoder.encode(number: UInt64(pngData.count))
diff --git a/PlaygroundLogger/PlaygroundLogger/OpaqueRepresentations/AppKit/NSImage+OpaqueImageRepresentable.swift b/PlaygroundLogger/PlaygroundLogger/OpaqueRepresentations/AppKit/NSImage+OpaqueImageRepresentable.swift
@@ -34,7 +34,7 @@
 
         func encodeImage(into encoder: LogEncoder, withFormat format: LogEncoder.Format) {
             guard let bitmapRep = self.bestBitmapRepresentation else {
-                unimplemented("Need to figure out how to handle when we can't get the best bitmap rep!")
+                loggingError("Failed to convert image to a bitmap representation")
             }
 
             bitmapRep.encodeImage(into: encoder, withFormat: format)
diff --git a/PlaygroundLogger/PlaygroundLogger/OpaqueRepresentations/AppKit/NSView+OpaqueImageRepresentable.swift b/PlaygroundLogger/PlaygroundLogger/OpaqueRepresentations/AppKit/NSView+OpaqueImageRepresentable.swift
@@ -16,7 +16,7 @@
     extension NSView: OpaqueImageRepresentable {
         func encodeImage(into encoder: LogEncoder, withFormat format: LogEncoder.Format) {
             guard let bitmapRep = self.bitmapImageRepForCachingDisplay(in: self.bounds) else {
-                unimplemented("Need to handle cases where we can't get a bitmap rep!")
+                loggingError("Failed to get a bitmap representation of a view")
             }
 
             self.cacheDisplay(in: self.bounds, to: bitmapRep)
diff --git a/PlaygroundLogger/PlaygroundLogger/OpaqueRepresentations/CoreGraphics/CGColor+KeyedArchiveOpaqueRepresentation.swift b/PlaygroundLogger/PlaygroundLogger/OpaqueRepresentations/CoreGraphics/CGColor+KeyedArchiveOpaqueRepresentation.swift
@@ -23,15 +23,15 @@ extension CGColor: KeyedArchiveOpaqueRepresentation {
     
     func encodeOpaqueRepresentation(with encoder: NSCoder, usingFormat format: LogEncoder.Format) {
         guard let colorSpace = self.colorSpace else {
-            unimplemented("Need to handle colors without a color space somehow")
+            loggingError("Unable to log colors without a colorspace")
         }
         
         guard colorSpace.model != .pattern else {
             unimplemented("Need to handle pattern colors")
         }
         
         guard let colorSpaceName = colorSpace.name, let components = self.components else {
-            unimplemented("Need to handle colors with an unnamed color space or with missing components")
+            loggingError("Unable to log non-pattern colors with unnamed colorspaces or which are missing components")
         }
         
         encoder.encode(colorSpaceName as NSString, forKey: colorSpaceKey)
diff --git a/PlaygroundLogger/PlaygroundLogger/OpaqueRepresentations/UIKit/UIImage+OpaqueImageRepresentable.swift b/PlaygroundLogger/PlaygroundLogger/OpaqueRepresentations/UIKit/UIImage+OpaqueImageRepresentable.swift
@@ -16,7 +16,7 @@
     extension UIImage: OpaqueImageRepresentable {
         func encodeImage(into encoder: LogEncoder, withFormat format: LogEncoder.Format) {
             guard let pngData = UIImagePNGRepresentation(self) else {
-                unimplemented("Need to handle when we can't convert a UIImage to a PNG")
+                loggingError("Failed to convert an image to a PNG")
             }
 
             encoder.encode(number: UInt64(pngData.count))
diff --git a/PlaygroundLogger/PlaygroundLogger/Utilities/LoggingError.swift b/PlaygroundLogger/PlaygroundLogger/Utilities/LoggingError.swift
@@ -0,0 +1,22 @@
+//===--- LoggingError.swift -----------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+/// A temporary function intended as a placeholder for real error handling, so that realistic error situations can be marked differently than a plain fatalError.
+func loggingError(_ message: String? = nil) -> Never {
+    if let message = message {
+        fatalError("Error encountered while logging: \(message)")
+    }
+    else {
+        fatalError("Error encountered while logging")
+    }
+}
+

Original file line number	Diff line number	Diff line change
`@@ -15,8 +15,7 @@ import CoreImage`
`15`	`15`	`extension CIColor: CustomOpaqueLoggable {`
`16`	`16`	`var opaqueRepresentation: LogEntry.OpaqueRepresentation {`
`17`	`17`	`guard let color = CGColor(colorSpace: self.colorSpace, components: self.components) else {`
`18`		`- // TODO: don't crash in this case`
`19`		`- fatalError("Unable to convert CIColor to CGColor")`
	`18`	`+ loggingError("Unable to convert CIColor to CGColor")`
`20`	`19`	`}`
`21`	`20`
`22`	`21`	`return color`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ fileprivate protocol SpriteKitOpaqueLoggable: class, OpaqueImageRepresentable, C`
`23`	`23`	`extension SpriteKitOpaqueLoggable {`
`24`	`24`	`func encodeImage(into encoder: LogEncoder, withFormat format: LogEncoder.Format) {`
`25`	`25`	`guard let copyImageDataMethod = (self as AnyObject)._copyImageData, let imageData = copyImageDataMethod() else {`
`26`		`- unimplemented("Handle case where we don't have any image data")`
	`26`	`+ loggingError("SpriteKit did not return any image data")`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`encoder.encode(number: UInt64(imageData.count))`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@`
`16`	`16`	`extension NSBitmapImageRep: OpaqueImageRepresentable {`
`17`	`17`	`func encodeImage(into encoder: LogEncoder, withFormat format: LogEncoder.Format) {`
`18`	`18`	`guard let pngData = self.representation(using: .png, properties: [:]) else {`
`19`		`- unimplemented("Need to handle error when we couldn't generate PNG data")`
	`19`	`+ loggingError("Failed to generate PNG data")`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`encoder.encode(number: UInt64(pngData.count))`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@`
`34`	`34`
`35`	`35`	`func encodeImage(into encoder: LogEncoder, withFormat format: LogEncoder.Format) {`
`36`	`36`	`guard let bitmapRep = self.bestBitmapRepresentation else {`
`37`		`- unimplemented("Need to figure out how to handle when we can't get the best bitmap rep!")`
	`37`	`+ loggingError("Failed to convert image to a bitmap representation")`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`bitmapRep.encodeImage(into: encoder, withFormat: format)`
Original file line number	Diff line number	Diff line change
`@@ -23,15 +23,15 @@ extension CGColor: KeyedArchiveOpaqueRepresentation {`
`23`	`23`
`24`	`24`	`func encodeOpaqueRepresentation(with encoder: NSCoder, usingFormat format: LogEncoder.Format) {`
`25`	`25`	`guard let colorSpace = self.colorSpace else {`
`26`		`- unimplemented("Need to handle colors without a color space somehow")`
	`26`	`+ loggingError("Unable to log colors without a colorspace")`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`guard colorSpace.model != .pattern else {`
`30`	`30`	`unimplemented("Need to handle pattern colors")`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`guard let colorSpaceName = colorSpace.name, let components = self.components else {`
`34`		`- unimplemented("Need to handle colors with an unnamed color space or with missing components")`
	`34`	`+ loggingError("Unable to log non-pattern colors with unnamed colorspaces or which are missing components")`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`encoder.encode(colorSpaceName as NSString, forKey: colorSpaceKey)`