refactor: Use tabs for indent

Sources/Stencil/KeyPath.swift

@@ -2,111 +2,111 @@ import Foundation
 
 /// A structure used to represent a template variable, and to resolve it in a given context.
 final class KeyPath {
-  private var components = [String]()
-  private var current = ""
-  private var partialComponents = [String]()
-  private var subscriptLevel = 0
+	private var components = [String]()
+	private var current = ""
+	private var partialComponents = [String]()
+	private var subscriptLevel = 0
 
-  let variable: String
-  let context: Context
+	let variable: String
+	let context: Context
 
-  // Split the keypath string and resolve references if possible
-  init(_ variable: String, in context: Context) {
-    self.variable = variable
-    self.context = context
-  }
+	// Split the keypath string and resolve references if possible
+	init(_ variable: String, in context: Context) {
+		self.variable = variable
+		self.context = context
+	}
 
-  func parse() throws -> [String] {
-    defer {
-      components = []
-      current = ""
-      partialComponents = []
-      subscriptLevel = 0
-    }
+	func parse() throws -> [String] {
+		defer {
+			components = []
+			current = ""
+			partialComponents = []
+			subscriptLevel = 0
+		}
 
-    for character in variable {
-      switch character {
-      case "." where subscriptLevel == 0:
-        try foundSeparator()
-      case "[":
-        try openBracket()
-      case "]":
-        try closeBracket()
-      default:
-        try addCharacter(character)
-      }
-    }
-    try finish()
+		for character in variable {
+			switch character {
+			case "." where subscriptLevel == 0:
+				try foundSeparator()
+			case "[":
+				try openBracket()
+			case "]":
+				try closeBracket()
+			default:
+				try addCharacter(character)
+			}
+		}
+		try finish()
 
-    return components
-  }
+		return components
+	}
 
-  private func foundSeparator() throws {
-    if !current.isEmpty {
-      partialComponents.append(current)
-    }
+	private func foundSeparator() throws {
+		if !current.isEmpty {
+			partialComponents.append(current)
+		}
 
-    guard !partialComponents.isEmpty else {
-      throw TemplateSyntaxError("Unexpected '.' in variable '\(variable)'")
-    }
+		guard !partialComponents.isEmpty else {
+			throw TemplateSyntaxError("Unexpected '.' in variable '\(variable)'")
+		}
 
-    components += partialComponents
-    current = ""
-    partialComponents = []
-  }
+		components += partialComponents
+		current = ""
+		partialComponents = []
+	}
 
-  // when opening the first bracket, we must have a partial component
-  private func openBracket() throws {
-    guard !partialComponents.isEmpty || !current.isEmpty else {
-      throw TemplateSyntaxError("Unexpected '[' in variable '\(variable)'")
-    }
+	// when opening the first bracket, we must have a partial component
+	private func openBracket() throws {
+		guard !partialComponents.isEmpty || !current.isEmpty else {
+			throw TemplateSyntaxError("Unexpected '[' in variable '\(variable)'")
+		}
 
-    if subscriptLevel > 0 {
-      current.append("[")
-    } else if !current.isEmpty {
-      partialComponents.append(current)
-      current = ""
-    }
+		if subscriptLevel > 0 {
+			current.append("[")
+		} else if !current.isEmpty {
+			partialComponents.append(current)
+			current = ""
+		}
 
-    subscriptLevel += 1
-  }
+		subscriptLevel += 1
+	}
 
-  // for a closing bracket at root level, try to resolve the reference
-  private func closeBracket() throws {
-    guard subscriptLevel > 0 else {
-      throw TemplateSyntaxError("Unbalanced ']' in variable '\(variable)'")
-    }
+	// for a closing bracket at root level, try to resolve the reference
+	private func closeBracket() throws {
+		guard subscriptLevel > 0 else {
+			throw TemplateSyntaxError("Unbalanced ']' in variable '\(variable)'")
+		}
 
-    if subscriptLevel > 1 {
-      current.append("]")
-    } else if !current.isEmpty,
-      let value = try Variable(current).resolve(context) {
-      partialComponents.append("\(value)")
-      current = ""
-    } else {
-      throw TemplateSyntaxError("Unable to resolve subscript '\(current)' in variable '\(variable)'")
-    }
+		if subscriptLevel > 1 {
+			current.append("]")
+		} else if !current.isEmpty,
+			let value = try Variable(current).resolve(context) {
+			partialComponents.append("\(value)")
+			current = ""
+		} else {
+			throw TemplateSyntaxError("Unable to resolve subscript '\(current)' in variable '\(variable)'")
+		}
 
-    subscriptLevel -= 1
-  }
+		subscriptLevel -= 1
+	}
 
-  private func addCharacter(_ character: Character) throws {
-    guard partialComponents.isEmpty || subscriptLevel > 0 else {
-      throw TemplateSyntaxError("Unexpected character '\(character)' in variable '\(variable)'")
-    }
+	private func addCharacter(_ character: Character) throws {
+		guard partialComponents.isEmpty || subscriptLevel > 0 else {
+			throw TemplateSyntaxError("Unexpected character '\(character)' in variable '\(variable)'")
+		}
 
-    current.append(character)
-  }
+		current.append(character)
+	}
 
-  private func finish() throws {
-    // check if we have a last piece
-    if !current.isEmpty {
-      partialComponents.append(current)
-    }
-    components += partialComponents
+	private func finish() throws {
+		// check if we have a last piece
+		if !current.isEmpty {
+			partialComponents.append(current)
+		}
+		components += partialComponents
 
-    guard subscriptLevel == 0 else {
-      throw TemplateSyntaxError("Unbalanced subscript brackets in variable '\(variable)'")
-    }
-  }
+		guard subscriptLevel == 0 else {
+			throw TemplateSyntaxError("Unbalanced subscript brackets in variable '\(variable)'")
+		}
+	}
 }