0001    import Foundation
0002    
0003    
0004    class FilterExpression
Parser.swift:89
    return try FilterExpression(token: token, parser: self)
 : Resolvable {
0005      let filters
Variable.swift:11
      filters = []
Variable.swift:20
      filters = try filterBits.map { try parser.findFilter($0) }
Variable.swift:22
      filters = []
Variable.swift:30
    return try filters.reduce(result) { x, y in
: [Filter]
0006      let variable
Variable.swift:12
      variable = Variable("")
Variable.swift:16
    variable = Variable(bits[0])
Variable.swift:28
    let result = try variable.resolve(context)
: Variable
0007    
0008      init
Parser.swift:89
    return try FilterExpression(token: token, parser: self)
(token: String, parser: TokenParser) throws {
0009        let bits = token.characters.split("|").map({ String($0).trim(" ") })
0010        if bits.isEmpty {
0011          filters = []
0012          variable = Variable("")
0013          throw TemplateSyntaxError("Variable tags must include at least 1 argument")
0014        }
0015    
0016        variable = Variable(bits[0])
0017        let filterBits = bits[1 ..< bits.endIndex]
0018    
0019        do {
0020          filters = try filterBits.map { try parser.findFilter($0) }
0021        } catch {
0022          filters = []
0023          throw error
0024        }
0025      }
0026    
0027      func resolve(context: Context) throws -> Any? {
0028        let result = try variable.resolve(context)
0029    
0030        return try filters.reduce(result) { x, y in
0031          return try y(x)
0032        }
0033      }
0034    }
0035    
0036    /// A structure used to represent a template variable, and to resolve it in a given context.
0037    public struct Variable
Include.swift:5
  public let templateName: Variable
Include.swift:14
    return IncludeNode(templateName: Variable(bits[1]))
Include.swift:17
  public init(templateName: Variable) {
Inheritence.swift:30
  let templateName: Variable
Inheritence.swift:54
    return ExtendsNode(templateName: Variable(bits[1]), blocks: nodes)
Inheritence.swift:57
  init(templateName: Variable, blocks: [String: BlockNode]) {
Node.swift:61
    self.variable = Variable(variable)
Node.swift:80
  public let format:Variable
Node.swift:83
    var format:Variable?
Node.swift:90
      format = Variable(components[1])
Node.swift:96
  public init(format:Variable?) {
Node.swift:97
    self.format = format ?? Variable("\"yyyy-MM-dd 'at' HH:mm\"")
Node.swift:119
  let variable:Variable
Node.swift:151
    self.variable = Variable(variable)
Node.swift:182
  public let variable:Variable
Node.swift:233
    self.variable = Variable(variable)
Variable.swift:6
  let variable: Variable
Variable.swift:12
      variable = Variable("")
Variable.swift:16
    variable = Variable(bits[0])
Variable.swift:88
public func ==(lhs: Variable, rhs: Variable) -> Bool {
Variable.swift:88
public func ==(lhs: Variable, rhs: Variable) -> Bool {
 : Equatable, Resolvable {
0038      public let variable
Variable.swift:42
    self.variable = variable
Variable.swift:46
    return variable.characters.split(".").map(String.init)
Variable.swift:53
    if (variable.hasPrefix("'") && variable.hasSuffix("'")) || (variable.hasPrefix("\"") && variable.hasSuffix("\"")) {
Variable.swift:53
    if (variable.hasPrefix("'") && variable.hasSuffix("'")) || (variable.hasPrefix("\"") && variable.hasSuffix("\"")) {
Variable.swift:53
    if (variable.hasPrefix("'") && variable.hasSuffix("'")) || (variable.hasPrefix("\"") && variable.hasSuffix("\"")) {
Variable.swift:53
    if (variable.hasPrefix("'") && variable.hasSuffix("'")) || (variable.hasPrefix("\"") && variable.hasSuffix("\"")) {
Variable.swift:55
      return variable[variable.startIndex.successor() ..< variable.endIndex.predecessor()]
Variable.swift:55
      return variable[variable.startIndex.successor() ..< variable.endIndex.predecessor()]
Variable.swift:55
      return variable[variable.startIndex.successor() ..< variable.endIndex.predecessor()]
Variable.swift:89
  return lhs.variable == rhs.variable
Variable.swift:89
  return lhs.variable == rhs.variable
: String
0039    
0040      /// Create a variable with a string representing the variable
0041      public init
Include.swift:14
    return IncludeNode(templateName: Variable(bits[1]))
Inheritence.swift:54
    return ExtendsNode(templateName: Variable(bits[1]), blocks: nodes)
Node.swift:61
    self.variable = Variable(variable)
Node.swift:90
      format = Variable(components[1])
Node.swift:97
    self.format = format ?? Variable("\"yyyy-MM-dd 'at' HH:mm\"")
Node.swift:151
    self.variable = Variable(variable)
Node.swift:233
    self.variable = Variable(variable)
Variable.swift:12
      variable = Variable("")
Variable.swift:16
    variable = Variable(bits[0])
(_ variable: String) {
0042        self.variable = variable
0043      }
0044    
0045      private func lookup
Variable.swift:58
    for bit in lookup() {
() -> [String] {
0046        return variable.characters.split(".").map(String.init)
0047      }
0048    
0049      /// Resolve the variable in the given context
0050      public func resolve
Include.swift:26
    guard let templateName = try self.templateName.resolve(context) as? String else {
Inheritence.swift:67
    guard let templateName = try self.templateName.resolve(context) as? String else {
Node.swift:102
    let format = try self.format.resolve(context)
Node.swift:158
    let values = try variable.resolve(context)
Node.swift:239
    let result = try variable.resolve(context)
Variable.swift:28
    let result = try variable.resolve(context)
(context: Context) throws -> Any? {
0051        var current: Any? = context
0052    
0053        if (variable.hasPrefix("'") && variable.hasSuffix("'")) || (variable.hasPrefix("\"") && variable.hasSuffix("\"")) {
0054          // String literal
0055          return variable[variable.startIndex.successor() ..< variable.endIndex.predecessor()]
0056        }
0057    
0058        for bit in lookup() {
0059          if let context = current as? Context {
0060            current = context[bit]
0061          } else if let dictionary = resolveDictionary(current) {
0062            current = dictionary[bit]
0063          } else if let array = resolveArray(current) {
0064            if let index = Int(bit) {
0065              current = array[index]
0066            } else if bit == "first" {
0067              current = array.first
0068            } else if bit == "last" {
0069              current = array.last
0070            } else if bit == "count" {
0071              current = array.count
0072            }
0073          } else if let object = current as? NSObject {  // NSKeyValueCoding
0074    #if os(Linux)
0075            return nil
0076    #else
0077            current = object.valueForKey(bit)
0078    #endif
0079          } else {
0080            return nil
0081          }
0082        }
0083    
0084        return normalize(current)
0085      }
0086    }
0087    
0088    public func ==(lhs: Variable, rhs: Variable) -> Bool {
0089      return lhs.variable == rhs.variable
0090    }
0091    
0092    
0093    func resolveDictionary
Variable.swift:61
      } else if let dictionary = resolveDictionary(current) {
Variable.swift:134
  if let dictionary = resolveDictionary(current) {
(current: Any?) -> [String: Any]? {
0094      switch current {
0095      case let dictionary as [String: Any]:
0096          return dictionary
0097      case let dictionary as [String: AnyObject]:
0098          var result: [String: Any] = [:]
0099          for (k, v) in dictionary {
0100              result[k] = v as Any
0101          }
0102          return result
0103      case let dictionary as NSDictionary:
0104          var result: [String: Any] = [:]
0105          for (k, v) in dictionary {
0106              if let k = k as? String {
0107                  result[k] = v as Any
0108              }
0109          }
0110          return result
0111      default:
0112          return nil
0113      }
0114    }
0115    
0116    func resolveArray
Variable.swift:63
      } else if let array = resolveArray(current) {
Variable.swift:130
  if let array = resolveArray(current) {
(current: Any?) -> [Any]? {
0117      switch current {
0118      case let array as [Any]:
0119          return array
0120      case let array as [AnyObject]:
0121          return array.map { $0 as Any }
0122      case let array as NSArray:
0123          return array.map { $0 as Any }
0124      default:
0125          return nil
0126      }
0127    }
0128    
0129    func normalize
Variable.swift:84
    return normalize(current)
(current: Any?) -> Any? {
0130      if let array = resolveArray(current) {
0131        return array
0132      }
0133    
0134      if let dictionary = resolveDictionary(current) {
0135        return dictionary
0136      }
0137    
0138      return current
0139    }
0140