0001    public func until
Inheritence.swift:97
    let nodes = try parser.parse(until(["endblock"]))
Node.swift:136
    let forNodes = try parser.parse(until(["endfor", "empty"]))
Node.swift:143
      emptyNodes = try parser.parse(until(["endfor"]))
Node.swift:195
    trueNodes = try parser.parse(until(["endif", "else"]))
Node.swift:202
      falseNodes = try parser.parse(until(["endif"]))
Node.swift:218
    falseNodes = try parser.parse(until(["endif", "else"]))
Node.swift:225
      trueNodes = try parser.parse(until(["endif"]))
(tags: [String]) -> ((TokenParser, Token) -> Bool) {
0002      return { parser, token in
0003        if let name = token.components().first {
0004          for tag in tags {
0005            if name == tag {
0006              return true
0007            }
0008          }
0009        }
0010    
0011        return false
0012      }
0013    }
0014    
0015    public typealias Filter
Namespace.swift:5
  var filters = [String: Filter]()
Namespace.swift:41
  public func registerFilter(name: String, filter: Filter) {
Parser.swift:80
  public func findFilter(name: String) throws -> Filter {
Variable.swift:5
  let filters: [Filter]
 = Any? throws -> Any?
0016    
0017    /// A class for parsing an array of tokens and converts them into a collection of Node's
0018    public class TokenParser
Include.swift:7
  public class func parse(parser: TokenParser, token: Token) throws -> NodeType {
Inheritence.swift:33
  class func parse(parser: TokenParser, token: Token) throws -> NodeType {
Inheritence.swift:89
  class func parse(parser: TokenParser, token: Token) throws -> NodeType {
Namespace.swift:2
  public typealias TagParser = (TokenParser, Token) throws -> NodeType
Node.swift:82
  public class func parse(parser:TokenParser, token:Token) throws -> NodeType {
Node.swift:124
  public class func parse(parser:TokenParser, token:Token) throws -> NodeType {
Node.swift:186
  public class func parse(parser:TokenParser, token:Token) throws -> NodeType {
Node.swift:209
  public class func parse_ifnot(parser:TokenParser, token:Token) throws -> NodeType {
Parser.swift:1
public func until(tags: [String]) -> ((TokenParser, Token) -> Bool) {
Parser.swift:19
  public typealias TagParser = (TokenParser, Token) throws -> NodeType
Parser.swift:34
  public func parse(parse_until:((parser:TokenParser, token:Token) -> (Bool))?) throws -> [NodeType] {
Template.swift:40
    let parser = TokenParser(tokens: tokens, namespace: namespace ?? Namespace())
Variable.swift:8
  init(token: String, parser: TokenParser) throws {
 {
0019      public typealias TagParser = (TokenParser, Token) throws -> NodeType
0020    
0021      private var tokens
Parser.swift:25
    self.tokens = tokens
Parser.swift:37
    while tokens.count > 0 {
Parser.swift:69
    if tokens.count > 0 {
Parser.swift:70
      return tokens.removeAtIndex(0)
Parser.swift:77
    tokens.insert(token, atIndex: 0)
: [Token]
0022      private let namespace
Parser.swift:26
    self.namespace = namespace
Parser.swift:54
          if let parser = namespace.tags[tag] {
Parser.swift:81
    if let filter = namespace.filters[name] {
: Namespace
0023    
0024      public init
Template.swift:40
    let parser = TokenParser(tokens: tokens, namespace: namespace ?? Namespace())
(tokens: [Token], namespace: Namespace) {
0025        self.tokens = tokens
0026        self.namespace = namespace
0027      }
0028    
0029      /// Parse the given tokens into nodes
0030      public func parse
Inheritence.swift:40
    let parsedNodes = try parser.parse()
Template.swift:41
    let nodes = try parser.parse()
() throws -> [NodeType] {
0031        return try parse(nil)
0032      }
0033    
0034      public func parse
Inheritence.swift:97
    let nodes = try parser.parse(until(["endblock"]))
Node.swift:136
    let forNodes = try parser.parse(until(["endfor", "empty"]))
Node.swift:143
      emptyNodes = try parser.parse(until(["endfor"]))
Node.swift:195
    trueNodes = try parser.parse(until(["endif", "else"]))
Node.swift:202
      falseNodes = try parser.parse(until(["endif"]))
Node.swift:218
    falseNodes = try parser.parse(until(["endif", "else"]))
Node.swift:225
      trueNodes = try parser.parse(until(["endif"]))
Parser.swift:31
    return try parse(nil)
(parse_until:((parser:TokenParser, token:Token) -> (Bool))?) throws -> [NodeType] {
0035        var nodes = [NodeType]()
0036    
0037        while tokens.count > 0 {
0038          let token = nextToken()!
0039    
0040          switch token {
0041          case .Text(let text):
0042            nodes.append(TextNode(text: text))
0043          case .Variable:
0044            nodes.append(VariableNode(variable: try compileFilter(token.contents)))
0045          case .Block:
0046            let tag = token.components().first
0047    
0048            if let parse_until = parse_until where parse_until(parser: self, token: token) {
0049              prependToken(token)
0050              return nodes
0051            }
0052    
0053            if let tag = tag {
0054              if let parser = namespace.tags[tag] {
0055                nodes.append(try parser(self, token))
0056              } else {
0057                throw TemplateSyntaxError("Unknown template tag '\(tag)'")
0058              }
0059            }
0060          case .Comment:
0061            continue
0062          }
0063        }
0064    
0065        return nodes
0066      }
0067    
0068      public func nextToken
Inheritence.swift:98
    parser.nextToken()
Node.swift:138
    guard let token = parser.nextToken() else {
Node.swift:144
      parser.nextToken()
Node.swift:197
    guard let token = parser.nextToken() else {
Node.swift:203
      parser.nextToken()
Node.swift:220
    guard let token = parser.nextToken() else {
Node.swift:226
      parser.nextToken()
Parser.swift:38
      let token = nextToken()!
() -> Token? {
0069        if tokens.count > 0 {
0070          return tokens.removeAtIndex(0)
0071        }
0072    
0073        return nil
0074      }
0075    
0076      public func prependToken
Parser.swift:49
          prependToken(token)
(token:Token) {
0077        tokens.insert(token, atIndex: 0)
0078      }
0079    
0080      public func findFilter
Variable.swift:20
      filters = try filterBits.map { try parser.findFilter($0) }
(name: String) throws -> Filter {
0081        if let filter = namespace.filters[name] {
0082          return filter
0083        }
0084    
0085        throw TemplateSyntaxError("Invalid filter '\(name)'")
0086      }
0087    
0088      func compileFilter
Parser.swift:44
        nodes.append(VariableNode(variable: try compileFilter(token.contents)))
(token: String) throws -> Resolvable {
0089        return try FilterExpression(token: token, parser: self)
0090      }
0091    }
0092