swiftpm-stencil/Sources/Stencil/Node.swift

import Foundation

/// Represents a parsed node
public protocol NodeType {
  /// Render the node in the given context
  func render(_ context: Context) throws -> String

  /// Reference to this node's token
  var token: Token? { get }
}

/// Render the collection of nodes in the given context
public func renderNodes(_ nodes: [NodeType], _ context: Context) throws -> String {
  var result = ""

  for node in nodes {
    do {
      result += try node.render(context)
    } catch {
      throw error.withToken(node.token)
    }

    let shouldBreak = context[LoopTerminationNode.breakContextKey] != nil
    let shouldContinue = context[LoopTerminationNode.continueContextKey] != nil

    if shouldBreak || shouldContinue {
      break
    }
  }

  return result
}

/// Simple node, used for triggering a closure during rendering
public class SimpleNode: NodeType {
  public let handler: (Context) throws -> String
  public let token: Token?

  public init(token: Token, handler: @escaping (Context) throws -> String) {
    self.token = token
    self.handler = handler
  }

  public func render(_ context: Context) throws -> String {
    try handler(context)
  }
}

/// Represents a block of text, renders the text
public class TextNode: NodeType {
  public let text: String
  public let token: Token?
  public let trimBehaviour: TrimBehaviour

  public init(text: String, trimBehaviour: TrimBehaviour = .nothing) {
    self.text = text
    self.token = nil
    self.trimBehaviour = trimBehaviour
  }

  public func render(_ context: Context) throws -> String {
    var string = self.text
    if trimBehaviour.leading != .nothing, !string.isEmpty {
      let range = NSRange(..<string.endIndex, in: string)
      string = TrimBehaviour.leadingRegex(trim: trimBehaviour.leading)
        .stringByReplacingMatches(in: string, options: [], range: range, withTemplate: "")
    }
    if trimBehaviour.trailing != .nothing, !string.isEmpty {
      let range = NSRange(..<string.endIndex, in: string)
      string = TrimBehaviour.trailingRegex(trim: trimBehaviour.trailing)
        .stringByReplacingMatches(in: string, options: [], range: range, withTemplate: "")
    }
    return string
  }
}

/// Representing something that can be resolved in a context
public protocol Resolvable {
  /// Try to resolve this with the given context
  func resolve(_ context: Context) throws -> Any?
}

/// Represents a variable, renders the variable, may have conditional expressions.
public class VariableNode: NodeType {
  public let variable: Resolvable
  public var token: Token?
  let condition: Expression?
  let elseExpression: Resolvable?

  class func parse(_ parser: TokenParser, token: Token) throws -> NodeType {
    let components = token.components

    func hasToken(_ token: String, at index: Int) -> Bool {
      components.count > (index + 1) && components[index] == token
    }
    func compileResolvable(_ components: [String], containedIn token: Token) throws -> Resolvable {
      try (try? parser.compileExpression(components: components, token: token)) ??
        parser.compileFilter(components.joined(separator: " "), containedIn: token)
    }

    let variable: Resolvable
    let condition: Expression?
    let elseExpression: Resolvable?

    if hasToken("if", at: 1) {
      variable = try compileResolvable([components[0]], containedIn: token)

      let components = components.suffix(from: 2)
      if let elseIndex = components.firstIndex(of: "else") {
        condition = try parser.compileExpression(components: Array(components.prefix(upTo: elseIndex)), token: token)
        let elseToken = Array(components.suffix(from: elseIndex.advanced(by: 1)))
        elseExpression = try compileResolvable(elseToken, containedIn: token)
      } else {
        condition = try parser.compileExpression(components: Array(components), token: token)
        elseExpression = nil
      }
    } else if !components.isEmpty {
      variable = try compileResolvable(components, containedIn: token)
      condition = nil
      elseExpression = nil
    } else {
      throw TemplateSyntaxError(reason: "Missing variable name", token: token)
    }

    return VariableNode(variable: variable, token: token, condition: condition, elseExpression: elseExpression)
  }

  public init(variable: Resolvable, token: Token? = nil) {
    self.variable = variable
    self.token = token
    self.condition = nil
    self.elseExpression = nil
  }

  init(variable: Resolvable, token: Token? = nil, condition: Expression?, elseExpression: Resolvable?) {
    self.variable = variable
    self.token = token
    self.condition = condition
    self.elseExpression = elseExpression
  }

  public init(variable: String, token: Token? = nil) {
    self.variable = Variable(variable)
    self.token = token
    self.condition = nil
    self.elseExpression = nil
  }

  public func render(_ context: Context) throws -> String {
    if let condition = self.condition, try condition.evaluate(context: context) == false {
      return try elseExpression?.resolve(context).map(stringify) ?? ""
    }

    let result = try variable.resolve(context)
    return stringify(result)
  }
}

func stringify(_ result: Any?) -> String {
  if let result = result as? String {
    return result
  } else if let array = result as? [Any?] {
    return unwrap(array).description
  } else if let result = result as? CustomStringConvertible {
    return result.description
  } else if let result = result as? NSObject {
    return result.description
  }

  return ""
}

func unwrap(_ array: [Any?]) -> [Any] {
  array.map { (item: Any?) -> Any in
    if let item = item {
      if let items = item as? [Any?] {
        return unwrap(items)
      } else {
        return item
      }
    } else { return item as Any }
  }
}