Normalize indentation in code listings (#53)

Some parts of the book were written before Swift style was standardized
for Swift 1.  A bunch of code listings use 3 space indentation instead of
4 space indentation.  There are also some `switch` statements whose cases
are indented, following an older C-like style.  In Swift, a case doesn't
start a scope, so we write it at the same level of indentation.

Under the legacy Sphinx-based publication pipeline, this wasn't an
issue: The publication process used SourceKit to add syntax
highlighting, which also reindented the code listings, so the published
version matched Swift style.  Because DocC preserves indentation, we
needed to normalize these in source.

Fixes #43

Fixes rdar://96988058

Author: amartini51

Sources/TSPL/TSPL.docc/GuidedTour/GuidedTour.md

@@ -514,14 +514,14 @@ and tests for equality.
 ```swift
 let vegetable = "red pepper"
 switch vegetable {
-    case "celery":
-        print("Add some raisins and make ants on a log.")
-    case "cucumber", "watercress":
-        print("That would make a good tea sandwich.")
-    case let x where x.hasSuffix("pepper"):
-        print("Is it a spicy \(x)?")
-    default:
-        print("Everything tastes good in soup.")
+case "celery":
+    print("Add some raisins and make ants on a log.")
+case "cucumber", "watercress":
+    print("That would make a good tea sandwich.")
+case let x where x.hasSuffix("pepper"):
+    print("Is it a spicy \(x)?")
+default:
+    print("Everything tastes good in soup.")
 }
 // Prints "Is it a spicy red pepper?"
 ```
@@ -1461,16 +1461,16 @@ enum Rank: Int {
 
     func simpleDescription() -> String {
         switch self {
-            case .ace:
-                return "ace"
-            case .jack:
-                return "jack"
-            case .queen:
-                return "queen"
-            case .king:
-                return "king"
-            default:
-                return String(self.rawValue)
+        case .ace:
+            return "ace"
+        case .jack:
+            return "jack"
+        case .queen:
+            return "queen"
+        case .king:
+            return "king"
+        default:
+            return String(self.rawValue)
         }
     }
 }
@@ -1558,14 +1558,14 @@ enum Suit {
 
     func simpleDescription() -> String {
         switch self {
-            case .spades:
-                return "spades"
-            case .hearts:
-                return "hearts"
-            case .diamonds:
-                return "diamonds"
-            case .clubs:
-                return "clubs"
+        case .spades:
+            return "spades"
+        case .hearts:
+            return "hearts"
+        case .diamonds:
+            return "diamonds"
+        case .clubs:
+            return "clubs"
         }
     }
 }
@@ -1681,10 +1681,10 @@ let success = ServerResponse.result("6:00 am", "8:09 pm")
 let failure = ServerResponse.failure("Out of cheese.")
 
 switch success {
-    case let .result(sunrise, sunset):
-        print("Sunrise is at \(sunrise) and sunset is at \(sunset).")
-    case let .failure(message):
-        print("Failure...  \(message)")
+case let .result(sunrise, sunset):
+    print("Sunrise is at \(sunrise) and sunset is at \(sunset).")
+case let .failure(message):
+    print("Failure...  \(message)")
 }
 // Prints "Sunrise is at 6:00 am and sunset is at 8:09 pm."
 ```

Sources/TSPL/TSPL.docc/LanguageGuide/AccessControl.md

@@ -230,25 +230,25 @@ the default access level of the type's members will be internal.
 
 ```swift
 public class SomePublicClass {                  // explicitly public class
-   public var somePublicProperty = 0            // explicitly public class member
-   var someInternalProperty = 0                 // implicitly internal class member
-   fileprivate func someFilePrivateMethod() {}  // explicitly file-private class member
-   private func somePrivateMethod() {}          // explicitly private class member
+    public var somePublicProperty = 0            // explicitly public class member
+    var someInternalProperty = 0                 // implicitly internal class member
+    fileprivate func someFilePrivateMethod() {}  // explicitly file-private class member
+    private func somePrivateMethod() {}          // explicitly private class member
 }
 
 class SomeInternalClass {                       // implicitly internal class
-   var someInternalProperty = 0                 // implicitly internal class member
-   fileprivate func someFilePrivateMethod() {}  // explicitly file-private class member
-   private func somePrivateMethod() {}          // explicitly private class member
+    var someInternalProperty = 0                 // implicitly internal class member
+    fileprivate func someFilePrivateMethod() {}  // explicitly file-private class member
+    private func somePrivateMethod() {}          // explicitly private class member
 }
 
 fileprivate class SomeFilePrivateClass {        // explicitly file-private class
-   func someFilePrivateMethod() {}              // implicitly file-private class member
-   private func somePrivateMethod() {}          // explicitly private class member
+    func someFilePrivateMethod() {}              // implicitly file-private class member
+    private func somePrivateMethod() {}          // explicitly private class member
 }
 
 private class SomePrivateClass {                // explicitly private class
-   func somePrivateMethod() {}                  // implicitly private class member
+    func somePrivateMethod() {}                  // implicitly private class member
 }
 ```
 
@@ -378,7 +378,7 @@ In fact, `someFunction()` won't compile as written below:
 
 ```swift
 func someFunction() -> (SomeInternalClass, SomePrivateClass) {
-   // function implementation goes here
+    // function implementation goes here
 }
 ```
 
@@ -410,7 +410,7 @@ for the function declaration to be valid:
 
 ```swift
 private func someFunction() -> (SomeInternalClass, SomePrivateClass) {
-   // function implementation goes here
+    // function implementation goes here
 }
 ```
 
@@ -445,10 +445,10 @@ therefore also have an access level of public:
 
 ```swift
 public enum CompassPoint {
-   case north
-   case south
-   case east
-   case west
+    case north
+    case south
+    case east
+    case west
 }
 ```
 
@@ -668,11 +668,11 @@ the original implementation of `someMethod()`:
 
 ```swift
 public class A {
-   fileprivate func someMethod() {}
+    fileprivate func someMethod() {}
 }
 
 internal class B: A {
-   override internal func someMethod() {}
+    override internal func someMethod() {}
 }
 ```
 
@@ -700,13 +700,13 @@ or within the same module as the superclass for an internal member call):
 
 ```swift
 public class A {
-   fileprivate func someMethod() {}
+    fileprivate func someMethod() {}
 }
 
 internal class B: A {
-   override internal func someMethod() {
-      super.someMethod()
-   }
+    override internal func someMethod() {
+        super.someMethod()
+    }
 }
 ```
 
@@ -811,12 +811,12 @@ which keeps track of the number of times a string property is modified:
 
 ```swift
 struct TrackedString {
-   private(set) var numberOfEdits = 0
-   var value: String = "" {
-      didSet {
-         numberOfEdits += 1
-      }
-   }
+    private(set) var numberOfEdits = 0
+    var value: String = "" {
+        didSet {
+            numberOfEdits += 1
+        }
+    }
 }
 ```
 
@@ -923,13 +923,13 @@ by combining the `public` and `private(set)` access-level modifiers:
 
 ```swift
 public struct TrackedString {
-   public private(set) var numberOfEdits = 0
-   public var value: String = "" {
-      didSet {
-         numberOfEdits += 1
-      }
-   }
-   public init() {}
+    public private(set) var numberOfEdits = 0
+    public var value: String = "" {
+        didSet {
+            numberOfEdits += 1
+        }
+    }
+    public init() {}
 }
 ```
 

Sources/TSPL/TSPL.docc/LanguageGuide/AdvancedOperators.md

@@ -715,7 +715,7 @@ to add together instances of the `Vector2D` structure:
 
 ```swift
 struct Vector2D {
-   var x = 0.0, y = 0.0
+    var x = 0.0, y = 0.0
 }
 
 extension Vector2D {
@@ -989,7 +989,7 @@ You can now use this operator to check whether two `Vector2D` instances are equi
 let twoThree = Vector2D(x: 2.0, y: 3.0)
 let anotherTwoThree = Vector2D(x: 2.0, y: 3.0)
 if twoThree == anotherTwoThree {
-   print("These two vectors are equivalent.")
+    print("These two vectors are equivalent.")
 }
 // Prints "These two vectors are equivalent."
 ```
@@ -1047,10 +1047,10 @@ you add a type method called `+++` to `Vector2D` as follows:
 
 ```swift
 extension Vector2D {
-   static prefix func +++ (vector: inout Vector2D) -> Vector2D {
-      vector += vector
-      return vector
-   }
+    static prefix func +++ (vector: inout Vector2D) -> Vector2D {
+        vector += vector
+        return vector
+    }
 }
 
 var toBeDoubled = Vector2D(x: 1.0, y: 4.0)
@@ -1099,9 +1099,9 @@ which belongs to the precedence group `AdditionPrecedence`:
 ```swift
 infix operator +-: AdditionPrecedence
 extension Vector2D {
-   static func +- (left: Vector2D, right: Vector2D) -> Vector2D {
-      return Vector2D(x: left.x + right.x, y: left.y - right.y)
-   }
+    static func +- (left: Vector2D, right: Vector2D) -> Vector2D {
+        return Vector2D(x: left.x + right.x, y: left.y - right.y)
+    }
 }
 let firstVector = Vector2D(x: 1.0, y: 2.0)
 let secondVector = Vector2D(x: 3.0, y: 4.0)