Release 0.11.0

Iterating array of tuples with more than two values

.travis.yml

@@ -6,6 +6,9 @@ matrix:
     - os: osx
       osx_image: xcode9
       env: SWIFT_VERSION=4.0
+    - os: osx
+      osx_image: xcode9.1
+      env: SWIFT_VERSION=4.0
     - os: linux
       env: SWIFT_VERSION=3.1.1
     - os: linux

CHANGELOG.md

@@ -1,5 +1,39 @@
 # Stencil Changelog
 
+## 0.11.0 (2018-04-04)
+
+### Enhancements
+
+- Added support for resolving superclass properties for not-NSObject subclasses
+- The `{% for %}` tag can now iterate over tuples, structures and classes via
+  their stored properties.
+- Added `split` filter
+- Allow default string filters to be applied to arrays
+- Similar filters are suggested when unknown filter is used
+- Added `indent` filter
+- Allow using new lines inside tags
+- Added support for iterating arrays of tuples
+- Added support for ranges in if-in expression
+- Added property `forloop.length` to get number of items in the loop
+- Now you can construct ranges for loops using `a...b` syntax, i.e. `for i in 1...array.count`
+
+### Bug Fixes
+
+- Fixed rendering `{{ block.super }}` with several levels of inheritance
+- Fixed checking dictionary values for nil in `default` filter
+- Fixed comparing string variables with string literals, in Swift 4 string literals became `Substring` and thus couldn't be directly compared to strings.
+- Integer literals now resolve into Int values, not Float
+- Fixed accessing properties of optional properties via reflection
+- No longer render optional values in arrays as `Optional(..)`
+- Fixed subscription tuples by value index, i.e. `{{ tuple.0 }}`
+
+
+## 0.10.1
+
+### Enhancements
+
+- Add support for Xcode 9.1.
+
 ## 0.10.0
 
 ### Enhancements

Package.swift

@@ -1,11 +1,10 @@
+// swift-tools-version:3.1
 import PackageDescription
 
 let package = Package(
   name: "Stencil",
   dependencies: [
-    .Package(url: "https://github.com/kylef/PathKit.git", majorVersion: 0, minor: 8),
-
-    // https://github.com/apple/swift-package-manager/pull/597
-    .Package(url: "https://github.com/kylef/Spectre.git", majorVersion: 0, minor: 7),
+    .Package(url: "https://github.com/kylef/PathKit.git", majorVersion: 0, minor: 9),
+    .Package(url: "https://github.com/kylef/Spectre.git", majorVersion: 0, minor: 8),
   ]
 )

Package@swift-3.swift

@@ -0,0 +1,10 @@
+// swift-tools-version:3.1
+import PackageDescription
+
+let package = Package(
+  name: "Stencil",
+  dependencies: [
+    .Package(url: "https://github.com/kylef/PathKit.git", majorVersion: 0, minor: 8),
+    .Package(url: "https://github.com/kylef/Spectre.git", majorVersion: 0, minor: 7),
+  ]
+)

README.md

@@ -63,6 +63,12 @@ Resources to help you integrate Stencil into a Swift project:
 - [API Reference](http://stencil.fuller.li/en/latest/api.html)
 - [Custom Template Tags and Filters](http://stencil.fuller.li/en/latest/custom-template-tags-and-filters.html)
 
+## Projects that use Stencil
+
+[Sourcery](https://github.com/krzysztofzablocki/Sourcery),
+[SwiftGen](https://github.com/SwiftGen/SwiftGen),
+[Kitura](https://github.com/IBM-Swift/Kitura)
+
 ## License
 
 Stencil is licensed under the BSD license. See [LICENSE](LICENSE) for more

Sources/Expression.swift

@@ -105,6 +105,10 @@ final class InExpression: Expression, InfixOperator, CustomStringConvertible {
       
       if let lhs = lhsValue as? AnyHashable, let rhs = rhsValue as? [AnyHashable] {
         return rhs.contains(lhs)
+      } else if let lhs = lhsValue as? Int, let rhs = rhsValue as? CountableClosedRange<Int> {
+        return rhs.contains(lhs)
+      } else if let lhs = lhsValue as? Int, let rhs = rhsValue as? CountableRange<Int> {
+        return rhs.contains(lhs)
       } else if let lhs = lhsValue as? String, let rhs = rhsValue as? String {
         return rhs.contains(lhs)
       } else if lhsValue == nil && rhsValue == nil {

Sources/Extension.swift

@@ -57,6 +57,8 @@ class DefaultExtension: Extension {
     registerFilter("uppercase", filter: uppercase)
     registerFilter("lowercase", filter: lowercase)
     registerFilter("join", filter: joinFilter)
+    registerFilter("split", filter: splitFilter)
+    registerFilter("indent", filter: indentFilter)
   }
 }
 

Sources/Filters.swift

@@ -1,17 +1,30 @@
 func capitalise(_ value: Any?) -> Any? {
-  return stringify(value).capitalized
+  if let array = value as? [Any?] {
+    return array.map { stringify($0).capitalized }
+  } else {
+    return stringify(value).capitalized
+  }
 }
 
 func uppercase(_ value: Any?) -> Any? {
-  return stringify(value).uppercased()
+  if let array = value as? [Any?] {
+    return array.map { stringify($0).uppercased() }
+  } else {
+    return stringify(value).uppercased()
+  }
 }
 
 func lowercase(_ value: Any?) -> Any? {
-  return stringify(value).lowercased()
+  if let array = value as? [Any?] {
+    return array.map { stringify($0).lowercased() }
+  } else {
+    return stringify(value).lowercased()
+  }
 }
 
 func defaultFilter(value: Any?, arguments: [Any?]) -> Any? {
-  if let value = value {
+  // value can be optional wrapping nil, so this way we check for underlying value
+  if let value = value, String(describing: value) != "nil" {
     return value
   }
 
@@ -39,3 +52,62 @@ func joinFilter(value: Any?, arguments: [Any?]) throws -> Any? {
 
   return value
 }
+
+func splitFilter(value: Any?, arguments: [Any?]) throws -> Any? {
+  guard arguments.count < 2 else {
+    throw TemplateSyntaxError("'split' filter takes a single argument")
+  }
+
+  let separator = stringify(arguments.first ?? " ")
+  if let value = value as? String {
+    return value.components(separatedBy: separator)
+  }
+
+  return value
+}
+
+func indentFilter(value: Any?, arguments: [Any?]) throws -> Any? {
+  guard arguments.count <= 3 else {
+    throw TemplateSyntaxError("'indent' filter can take at most 3 arguments")
+  }
+
+  var indentWidth = 4
+  if arguments.count > 0 {
+    guard let value = arguments[0] as? Int else {
+      throw TemplateSyntaxError("'indent' filter width argument must be an Integer (\(String(describing: arguments[0])))")
+    }
+    indentWidth = value
+  }
+
+  var indentationChar = " "
+  if arguments.count > 1 {
+    guard let value = arguments[1] as? String else {
+      throw TemplateSyntaxError("'indent' filter indentation argument must be a String (\(String(describing: arguments[1]))")
+    }
+    indentationChar = value
+  }
+
+  var indentFirst = false
+  if arguments.count > 2 {
+    guard let value = arguments[2] as? Bool else {
+      throw TemplateSyntaxError("'indent' filter indentFirst argument must be a Bool")
+    }
+    indentFirst = value
+  }
+
+  let indentation = [String](repeating: indentationChar, count: indentWidth).joined(separator: "")
+  return indent(stringify(value), indentation: indentation, indentFirst: indentFirst)
+}
+
+
+func indent(_ content: String, indentation: String, indentFirst: Bool) -> String {
+  guard !indentation.isEmpty else { return content }
+
+  var lines = content.components(separatedBy: .newlines)
+  let firstLine = (indentFirst ? indentation : "") + lines.removeFirst()
+  let result = lines.reduce([firstLine]) { (result, line) in
+    return result + [(line.isEmpty ? "" : "\(indentation)\(line)")]
+  }
+  return result.joined(separator: "\n")
+}
+

Sources/ForTag.swift

@@ -10,9 +10,15 @@ class ForNode : NodeType {
   class func parse(_ parser:TokenParser, token:Token) throws -> NodeType {
     let components = token.components()
 
-    guard components.count >= 3 && components[2] == "in" &&
-        (components.count == 4 || (components.count >= 6 && components[4] == "where")) else {
-      throw TemplateSyntaxError("'for' statements should use the following 'for x in y where condition' `\(token.contents)`.")
+    func hasToken(_ token: String, at index: Int) -> Bool {
+      return components.count > (index + 1) && components[index] == token
+    }
+    func endsOrHasToken(_ token: String, at index: Int) -> Bool {
+      return components.count == index || hasToken(token, at: index)
+    }
+
+    guard hasToken("in", at: 2) && endsOrHasToken("where", at: 4) else {
+      throw TemplateSyntaxError("'for' statements should use the syntax: `for <x> in <y> [where <condition>]")
     }
 
     let loopVariables = components[1].characters
@@ -20,8 +26,6 @@ class ForNode : NodeType {
       .map(String.init)
       .map { $0.trimmingCharacters(in: CharacterSet.whitespaces) }
 
-    let variable = components[3]
-
     var emptyNodes = [NodeType]()
 
     let forNodes = try parser.parse(until(["endfor", "empty"]))
@@ -35,14 +39,13 @@ class ForNode : NodeType {
       _ = parser.nextToken()
     }
 
-    let filter = try parser.compileFilter(variable)
-    let `where`: Expression?
-    if components.count >= 6 {
-      `where` = try parseExpression(components: Array(components.suffix(from: 5)), tokenParser: parser)
-    } else {
-      `where` = nil
-    }
-    return ForNode(resolvable: filter, loopVariables: loopVariables, nodes: forNodes, emptyNodes:emptyNodes, where: `where`)
+    let resolvable = try parser.compileResolvable(components[3])
+
+    let `where` = hasToken("where", at: 4)
+      ? try parseExpression(components: Array(components.suffix(from: 5)), tokenParser: parser)
+      : nil
+
+    return ForNode(resolvable: resolvable, loopVariables: loopVariables, nodes: forNodes, emptyNodes:emptyNodes, where: `where`)
   }
 
   init(resolvable: Resolvable, loopVariables: [String], nodes:[NodeType], emptyNodes:[NodeType], where: Expression? = nil) {
@@ -53,25 +56,26 @@ class ForNode : NodeType {
     self.where = `where`
   }
 
-  func push<Result>(value: Any, context: Context, closure: () throws -> (Result)) rethrows -> Result {
+  func push<Result>(value: Any, context: Context, closure: () throws -> (Result)) throws -> Result {
     if loopVariables.isEmpty {
       return try context.push() {
         return try closure()
       }
     }
 
-    if let value = value as? (Any, Any) {
-      let first = loopVariables[0]
-
-      if loopVariables.count == 2 {
-        let second = loopVariables[1]
-
-        return try context.push(dictionary: [first: value.0, second: value.1]) {
-          return try closure()
-        }
+    let valueMirror = Mirror(reflecting: value)
+    if case .tuple? = valueMirror.displayStyle {
+      if loopVariables.count > Int(valueMirror.children.count) {
+        throw TemplateSyntaxError("Tuple '\(value)' has less values than loop variables")
       }
+      var variablesContext = [String: Any]()
+      valueMirror.children.prefix(loopVariables.count).enumerated().forEach({ (offset, element) in
+        if loopVariables[offset] != "_" {
+          variablesContext[loopVariables[offset]] = element.value
+        }
+      })
 
-      return try context.push(dictionary: [first: value.0]) {
+      return try context.push(dictionary: variablesContext) {
         return try closure()
       }
     }
@@ -94,6 +98,22 @@ class ForNode : NodeType {
       values = Array(range)
     } else if let range = resolved as? CountableRange<Int> {
       values = Array(range)
+    } else if let resolved = resolved {
+      let mirror = Mirror(reflecting: resolved)
+      switch mirror.displayStyle {
+      case .struct?, .tuple?:
+        values = Array(mirror.children)
+      case .class?:
+        var children = Array(mirror.children)
+        var currentMirror: Mirror? = mirror
+        while let superclassMirror = currentMirror?.superclassMirror {
+          children.append(contentsOf: superclassMirror.children)
+          currentMirror = superclassMirror
+        }
+        values = Array(children)
+      default:
+        values = []
+      }
     } else {
       values = []
     }
@@ -115,6 +135,7 @@ class ForNode : NodeType {
           "last": index == (count - 1),
           "counter": index + 1,
           "counter0": index,
+          "length": count
         ]
 
         return try context.push(dictionary: ["forloop": forContext]) {

Sources/IfTag.swift

@@ -111,7 +111,7 @@ final class IfExpressionParser {
         }
       }
 
-      return .variable(try tokenParser.compileFilter(component))
+      return .variable(try tokenParser.compileResolvable(component))
     }
   }
 

Sources/Inheritence.swift

@@ -1,14 +1,36 @@
 class BlockContext {
   class var contextKey: String { return "block_context" }
 
-  var blocks: [String: BlockNode]
+  var blocks: [String: [BlockNode]]
 
   init(blocks: [String: BlockNode]) {
-    self.blocks = blocks
+    self.blocks = [:]
+    blocks.forEach { (key, value) in
+      self.blocks[key] = [value]
+    }
   }
 
+  func push(_ block: BlockNode, forKey blockName: String) {
+    if var blocks = blocks[blockName] {
+      blocks.append(block)
+      self.blocks[blockName] = blocks
+    } else {
+      self.blocks[blockName] = [block]
+    }
+  }
+  
   func pop(_ blockName: String) -> BlockNode? {
-    return blocks.removeValue(forKey: blockName)
+    if var blocks = blocks[blockName] {
+      let block = blocks.removeFirst()
+      if blocks.isEmpty {
+        self.blocks.removeValue(forKey: blockName)
+      } else {
+        self.blocks[blockName] = blocks
+      }
+      return block
+    } else {
+      return nil
+    }
   }
 }
 
@@ -70,9 +92,7 @@ class ExtendsNode : NodeType {
       blockContext = context
 
       for (key, value) in blocks {
-        if !blockContext.blocks.keys.contains(key) {
-          blockContext.blocks[key] = value
-        }
+        blockContext.push(value, forKey: key)
       }
     } else {
       blockContext = BlockContext(blocks: blocks)
@@ -109,7 +129,11 @@ class BlockNode : NodeType {
 
   func render(_ context: Context) throws -> String {
     if let blockContext = context[BlockContext.contextKey] as? BlockContext, let node = blockContext.pop(name) {
-      return try context.push(dictionary: ["block": ["super": self]]) {
+      let newContext: [String: Any] = [
+        BlockContext.contextKey: blockContext,
+        "block": ["super": try self.render(context)]
+      ]
+      return try context.push(dictionary: newContext) {
         return try node.render(context)
       }
     }

Sources/Lexer.swift

@@ -10,7 +10,12 @@ struct Lexer {
       guard string.characters.count > 4 else { return "" }
       let start = string.index(string.startIndex, offsetBy: 2)
       let end = string.index(string.endIndex, offsetBy: -2)
-      return string[start..<end].trim(character: " ")
+      let trimmed = String(string[start..<end])
+        .components(separatedBy: "\n")
+        .filter({ !$0.isEmpty })
+        .map({ $0.trim(character: " ") })
+        .joined(separator: " ")
+      return trimmed
     }
 
     if string.hasPrefix("{{") {
@@ -149,6 +154,6 @@ extension String {
   func trim(character: Character) -> String {
     let first = findFirstNot(character: character) ?? startIndex
     let last = findLastNot(character: character) ?? endIndex
-    return self[first..<last]
+    return String(self[first..<last])
   }
 }

Sources/Node.swift

@@ -78,6 +78,8 @@ public class VariableNode : NodeType {
 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 {
@@ -86,3 +88,16 @@ func stringify(_ result: Any?) -> String {
 
   return ""
 }
+
+func unwrap(_ array: [Any?]) -> [Any] {
+  return 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 }
+  }
+}

Sources/Parser.swift

@@ -40,7 +40,7 @@ public class TokenParser {
       case .text(let text):
         nodes.append(TextNode(text: text))
       case .variable:
-        nodes.append(VariableNode(variable: try compileFilter(token.contents)))
+        nodes.append(VariableNode(variable: try compileResolvable(token.contents)))
       case .block:
         if let parse_until = parse_until , parse_until(self, token) {
           prependToken(token)
@@ -88,11 +88,77 @@ public class TokenParser {
       }
     }
 
-    throw TemplateSyntaxError("Unknown filter '\(name)'")
+    let suggestedFilters = self.suggestedFilters(for: name)
+    if suggestedFilters.isEmpty {
+      throw TemplateSyntaxError("Unknown filter '\(name)'.")
+    } else {
+      throw TemplateSyntaxError("Unknown filter '\(name)'. Found similar filters: \(suggestedFilters.map({ "'\($0)'" }).joined(separator: ", "))")
+    }
+  }
+
+  private func suggestedFilters(for name: String) -> [String] {
+    let allFilters = environment.extensions.flatMap({ $0.filters.keys })
+
+    let filtersWithDistance = allFilters
+                .map({ (filterName: $0, distance: $0.levenshteinDistance(name)) })
+                // do not suggest filters which names are shorter than the distance
+                .filter({ $0.filterName.characters.count > $0.distance })
+    guard let minDistance = filtersWithDistance.min(by: { $0.distance < $1.distance })?.distance else {
+      return []
+    }
+    // suggest all filters with the same distance
+    return filtersWithDistance.filter({ $0.distance == minDistance }).map({ $0.filterName })
   }
 
   public func compileFilter(_ token: String) throws -> Resolvable {
     return try FilterExpression(token: token, parser: self)
   }
 
+  public func compileResolvable(_ token: String) throws -> Resolvable {
+    return try RangeVariable(token, parser: self)
+      ?? compileFilter(token)
+  }
+
+}
+
+// https://en.wikipedia.org/wiki/Levenshtein_distance#Iterative_with_two_matrix_rows
+extension String {
+
+  subscript(_ i: Int) -> Character {
+    return self[self.index(self.startIndex, offsetBy: i)]
+  }
+
+  func levenshteinDistance(_ target: String) -> Int {
+    // create two work vectors of integer distances
+    var last, current: [Int]
+
+    // initialize v0 (the previous row of distances)
+    // this row is A[0][i]: edit distance for an empty s
+    // the distance is just the number of characters to delete from t
+    last = [Int](0...target.characters.count)
+    current = [Int](repeating: 0, count: target.characters.count + 1)
+
+    for i in 0..<self.characters.count {
+      // calculate v1 (current row distances) from the previous row v0
+
+      // first element of v1 is A[i+1][0]
+      //   edit distance is delete (i+1) chars from s to match empty t
+      current[0] = i + 1
+
+      // use formula to fill in the rest of the row
+      for j in 0..<target.characters.count {
+        current[j+1] = Swift.min(
+          last[j+1] + 1,
+          current[j] + 1,
+          last[j] + (self[i] == target[j] ? 0 : 1)
+        )
+      }
+
+      // copy v1 (current row) to v0 (previous row) for next iteration
+      last = current
+    }
+
+    return current[target.characters.count]
+  }
+
 }

Sources/Variable.swift

@@ -60,13 +60,20 @@ public struct Variable : Equatable, Resolvable {
 
     if (variable.hasPrefix("'") && variable.hasSuffix("'")) || (variable.hasPrefix("\"") && variable.hasSuffix("\"")) {
       // String literal
-      return variable[variable.characters.index(after: variable.startIndex) ..< variable.characters.index(before: variable.endIndex)]
+      return String(variable[variable.characters.index(after: variable.startIndex) ..< variable.characters.index(before: variable.endIndex)])
     }
 
+    // Number literal
+    if let int = Int(variable) {
+      return int
+    }
     if let number = Number(variable) {
-      // Number literal
       return number
     }
+    // Boolean literal
+    if let bool = Bool(variable) {
+      return bool
+    }
 
     for bit in lookup() {
       current = normalize(current)
@@ -100,15 +107,9 @@ public struct Variable : Equatable, Resolvable {
         current = object.value(forKey: bit)
 #endif
       } else if let value = current {
-        let mirror = Mirror(reflecting: value)
-        current = mirror.descendant(bit)
-
+        current = Mirror(reflecting: value).getValue(for: bit)
         if current == nil {
           return nil
-          // mirror returns non-nil value even for nil-containing properties
-          // so we have to check if its value is actually nil or not
-        } else if let current = current, String(describing: current) == "nil" {
-          return nil
         }
       } else {
         return nil
@@ -129,6 +130,42 @@ public func ==(lhs: Variable, rhs: Variable) -> Bool {
   return lhs.variable == rhs.variable
 }
 
+/// A structure used to represet range of two integer values expressed as `from...to`.
+/// Values should be numbers (they will be converted to integers).
+/// Rendering this variable produces array from range `from...to`.
+/// If `from` is more than `to` array will contain values of reversed range.
+public struct RangeVariable: Resolvable {
+  public let from: Resolvable
+  public let to: Resolvable
+
+  public init?(_ token: String, parser: TokenParser) throws {
+    let components = token.components(separatedBy: "...")
+    guard components.count == 2 else {
+      return nil
+    }
+
+    self.from = try parser.compileFilter(components[0])
+    self.to = try parser.compileFilter(components[1])
+  }
+
+  public func resolve(_ context: Context) throws -> Any? {
+    let fromResolved = try from.resolve(context)
+    let toResolved = try to.resolve(context)
+
+    guard let from = fromResolved.flatMap(toNumber(value:)).flatMap(Int.init) else {
+      throw TemplateSyntaxError("'from' value is not an Integer (\(fromResolved ?? "nil"))")
+    }
+
+    guard let to = toResolved.flatMap(toNumber(value:)).flatMap(Int.init) else {
+      throw TemplateSyntaxError("'to' value is not an Integer (\(toResolved ?? "nil") )")
+    }
+
+    let range = min(from, to)...max(from, to)
+    return from > to ? Array(range.reversed()) : Array(range)
+  }
+
+}
+
 
 func normalize(_ current: Any?) -> Any? {
   if let current = current as? Normalizable {
@@ -179,3 +216,40 @@ func parseFilterComponents(token: String) -> (String, [Variable]) {
     .map { Variable($0) }
   return (name, variables)
 }
+
+extension Mirror {
+  func getValue(for key: String) -> Any? {
+    let result = descendant(key) ?? Int(key).flatMap({ descendant($0) })
+    if result == nil {
+      // go through inheritance chain to reach superclass properties
+      return superclassMirror?.getValue(for: key)
+    } else if let result = result {
+      guard String(describing: result) != "nil" else {
+        // mirror returns non-nil value even for nil-containing properties
+        // so we have to check if its value is actually nil or not
+        return nil
+      }
+      if let result = (result as? AnyOptional)?.wrapped {
+        return result
+      } else {
+        return result
+      }
+    }
+    return result
+  }
+}
+
+protocol AnyOptional {
+  var wrapped: Any? { get }
+}
+
+extension Optional: AnyOptional {
+  var wrapped: Any? {
+    switch self {
+    case let .some(value): return value
+    case .none: return nil
+    }
+  }
+}
+
+

Stencil.podspec.json

@@ -1,6 +1,6 @@
 {
   "name": "Stencil",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "summary": "Stencil is a simple and powerful template language for Swift.",
   "homepage": "https://stencil.fuller.li",
   "license": {
@@ -13,7 +13,7 @@
   "social_media_url": "https://twitter.com/kylefuller",
   "source": {
     "git": "https://github.com/kylef/Stencil.git",
-    "tag": "0.10.0"
+    "tag": "0.11.0"
   },
   "source_files": [
     "Sources/*.swift"
@@ -25,6 +25,8 @@
   },
   "requires_arc": true,
   "dependencies": {
-    "PathKit": [ "~> 0.8.0" ]
+    "PathKit": [
+      "~> 0.8.0"
+    ]
   }
 }

Tests/StencilTests/ExpressionSpec.swift

@@ -287,12 +287,16 @@ func testExpressions() {
           try expect(expression.evaluate(context: Context(dictionary: ["lhs": 1, "rhs": [1, 2, 3]]))).to.beTrue()
           try expect(expression.evaluate(context: Context(dictionary: ["lhs": "a", "rhs": ["a", "b", "c"]]))).to.beTrue()
           try expect(expression.evaluate(context: Context(dictionary: ["lhs": "a", "rhs": "abc"]))).to.beTrue()
+          try expect(expression.evaluate(context: Context(dictionary: ["lhs": 1, "rhs": 1...3]))).to.beTrue()
+          try expect(expression.evaluate(context: Context(dictionary: ["lhs": 1, "rhs": 1..<3]))).to.beTrue()
         }
         
         $0.it("evaluates to false when rhs does not contain lhs") {
           try expect(expression.evaluate(context: Context(dictionary: ["lhs": 1, "rhs": [2, 3, 4]]))).to.beFalse()
           try expect(expression.evaluate(context: Context(dictionary: ["lhs": "a", "rhs": ["b", "c", "d"]]))).to.beFalse()
           try expect(expression.evaluate(context: Context(dictionary: ["lhs": "a", "rhs": "bcd"]))).to.beFalse()
+          try expect(expression.evaluate(context: Context(dictionary: ["lhs": 4, "rhs": 1...3]))).to.beFalse()
+          try expect(expression.evaluate(context: Context(dictionary: ["lhs": 3, "rhs": 1..<3]))).to.beFalse()
         }
       }
     }

Tests/StencilTests/FilterSpec.swift

@@ -89,32 +89,45 @@ func testFilter() {
     }
   }
 
+  describe("string filters") {
+    $0.context("given string") {
+      $0.it("transforms a string to be capitalized") {
+        let template = Template(templateString: "{{ name|capitalize }}")
+        let result = try template.render(Context(dictionary: ["name": "kyle"]))
+        try expect(result) == "Kyle"
+      }
 
-  describe("capitalize filter") {
-    let template = Template(templateString: "{{ name|capitalize }}")
+      $0.it("transforms a string to be uppercase") {
+        let template = Template(templateString: "{{ name|uppercase }}")
+        let result = try template.render(Context(dictionary: ["name": "kyle"]))
+        try expect(result) == "KYLE"
+      }
 
-    $0.it("capitalizes a string") {
-      let result = try template.render(Context(dictionary: ["name": "kyle"]))
-      try expect(result) == "Kyle"
+      $0.it("transforms a string to be lowercase") {
+        let template = Template(templateString: "{{ name|lowercase }}")
+        let result = try template.render(Context(dictionary: ["name": "Kyle"]))
+        try expect(result) == "kyle"
+      }
     }
-  }
 
+    $0.context("given array of strings") {
+      $0.it("transforms a string to be capitalized") {
+        let template = Template(templateString: "{{ names|capitalize }}")
+        let result = try template.render(Context(dictionary: ["names": ["kyle", "kyle"]]))
+        try expect(result) == "[\"Kyle\", \"Kyle\"]"
+      }
 
-  describe("uppercase filter") {
-    let template = Template(templateString: "{{ name|uppercase }}")
+      $0.it("transforms a string to be uppercase") {
+        let template = Template(templateString: "{{ names|uppercase }}")
+        let result = try template.render(Context(dictionary: ["names": ["kyle", "kyle"]]))
+        try expect(result) == "[\"KYLE\", \"KYLE\"]"
+      }
 
-    $0.it("transforms a string to be uppercase") {
-      let result = try template.render(Context(dictionary: ["name": "kyle"]))
-      try expect(result) == "KYLE"
-    }
-  }
-
-  describe("lowercase filter") {
-    let template = Template(templateString: "{{ name|lowercase }}")
-
-    $0.it("transforms a string to be lowercase") {
-      let result = try template.render(Context(dictionary: ["name": "Kyle"]))
-      try expect(result) == "kyle"
+      $0.it("transforms a string to be lowercase") {
+        let template = Template(templateString: "{{ names|lowercase }}")
+        let result = try template.render(Context(dictionary: ["names": ["Kyle", "Kyle"]]))
+        try expect(result) == "[\"kyle\", \"kyle\"]"
+      }
     }
   }
 
@@ -136,6 +149,26 @@ func testFilter() {
       let result = try template.render(Context(dictionary: [:]))
       try expect(result) == "Hello World"
     }
+
+    $0.it("can use int as default") {
+      let template = Template(templateString: "{{ value|default:1 }}")
+      let result = try template.render(Context(dictionary: [:]))
+      try expect(result) == "1"
+    }
+
+    $0.it("can use float as default") {
+      let template = Template(templateString: "{{ value|default:1.5 }}")
+      let result = try template.render(Context(dictionary: [:]))
+      try expect(result) == "1.5"
+    }
+
+    $0.it("checks for underlying nil value correctly") {
+      let template = Template(templateString: "Hello {{ user.name|default:\"anonymous\" }}")
+      let nilName: String? = nil
+      let user: [String: Any?] = ["name": nilName]
+      let result = try template.render(Context(dictionary: ["user": user]))
+      try expect(result) == "Hello anonymous"
+    }
   }
 
   describe("join filter") {
@@ -163,4 +196,78 @@ func testFilter() {
       try expect(result) == "OneTwo"
     }
   }
+
+  describe("split filter") {
+    let template = Template(templateString: "{{ value|split:\", \" }}")
+
+    $0.it("split a string into array") {
+      let result = try template.render(Context(dictionary: ["value": "One, Two"]))
+      try expect(result) == "[\"One\", \"Two\"]"
+    }
+
+    $0.it("can split without arguments") {
+      let template = Template(templateString: "{{ value|split }}")
+      let result = try template.render(Context(dictionary: ["value": "One, Two"]))
+      try expect(result) == "[\"One,\", \"Two\"]"
+    }
+  }
+
+
+  describe("filter suggestion") {
+
+    $0.it("made for unknown filter") {
+      let template = Template(templateString: "{{ value|unknownFilter }}")
+      let expectedError = TemplateSyntaxError("Unknown filter 'unknownFilter'. Found similar filters: 'knownFilter'")
+
+      let filterExtension = Extension()
+      filterExtension.registerFilter("knownFilter") { value, _ in value }
+
+      try expect(template.render(Context(dictionary: [:], environment: Environment(extensions: [filterExtension])))).toThrow(expectedError)
+    }
+
+    $0.it("made for multiple similar filters") {
+      let template = Template(templateString: "{{ value|lowerFirst }}")
+      let expectedError = TemplateSyntaxError("Unknown filter 'lowerFirst'. Found similar filters: 'lowerFirstWord', 'lowercase'")
+
+      let filterExtension = Extension()
+      filterExtension.registerFilter("lowerFirstWord") { value, _ in value }
+      filterExtension.registerFilter("lowerFirstLetter") { value, _ in value }
+
+      try expect(template.render(Context(dictionary: [:], environment: Environment(extensions: [filterExtension])))).toThrow(expectedError)
+    }
+
+    $0.it("not made when can't find similar filter") {
+      let template = Template(templateString: "{{ value|unknownFilter }}")
+      let expectedError = TemplateSyntaxError("Unknown filter 'unknownFilter'.")
+      try expect(template.render(Context(dictionary: [:]))).toThrow(expectedError)
+    }
+
+  }
+
+
+  describe("indent filter") {
+    $0.it("indents content") {
+      let template = Template(templateString: "{{ value|indent:2 }}")
+      let result = try template.render(Context(dictionary: ["value": "One\nTwo"]))
+      try expect(result) == "One\n  Two"
+    }
+
+    $0.it("can indent with arbitrary character") {
+      let template = Template(templateString: "{{ value|indent:2,\"\t\" }}")
+      let result = try template.render(Context(dictionary: ["value": "One\nTwo"]))
+      try expect(result) == "One\n\t\tTwo"
+    }
+
+    $0.it("can indent first line") {
+      let template = Template(templateString: "{{ value|indent:2,\" \",true }}")
+      let result = try template.render(Context(dictionary: ["value": "One\nTwo"]))
+      try expect(result) == "  One\n  Two"
+    }
+
+    $0.it("does not indent empty lines") {
+      let template = Template(templateString: "{{ value|indent }}")
+      let result = try template.render(Context(dictionary: ["value": "One\n\n\nTwo\n\n"]))
+      try expect(result) == "One\n\n\n    Two\n\n"
+    }
+  }
 }

Tests/StencilTests/FilterTagSpec.swift

@@ -21,5 +21,14 @@ func testFilterTag() {
       try expect(try template.render()).toThrow()
     }
 
+    $0.it("can render filters with arguments") {
+      let ext = Extension()
+      ext.registerFilter("split", filter: {
+        return ($0 as! String).components(separatedBy: $1[0] as! String)
+      })
+      let env = Environment(extensions: [ext])
+      let result = try env.renderTemplate(string: "{% filter split:\",\"|join:\";\"  %}{{ items|join:\",\" }}{% endfilter %}", context: ["items": [1, 2]])
+      try expect(result) == "1;2"
+    }
   }
 }

Tests/StencilTests/ForNodeSpec.swift

@@ -11,7 +11,8 @@ func testForNode() {
       "dict": [
         "one": "I",
         "two": "II",
-      ]
+      ],
+      "tuples": [(1, 2, 3), (4, 5, 6)]
     ])
 
     $0.it("renders the given nodes for each item") {
@@ -89,6 +90,12 @@ func testForNode() {
       try expect(try node.render(context)) == "102132"
     }
 
+    $0.it("renders the given nodes while providing loop length") {
+      let nodes: [NodeType] = [VariableNode(variable: "item"), VariableNode(variable: "forloop.length")]
+      let node = ForNode(resolvable: Variable("items"), loopVariables: ["item"], nodes: nodes, emptyNodes: [])
+      try expect(try node.render(context)) == "132333"
+    }
+
     $0.it("renders the given nodes while filtering items using where expression") {
         let nodes: [NodeType] = [VariableNode(variable: "item"), VariableNode(variable: "forloop.counter")]
         let `where` = try parseExpression(components: ["item", ">", "1"], tokenParser: TokenParser(tokens: [], environment: Environment()))
@@ -127,30 +134,92 @@ func testForNode() {
       try expect(result) == fixture
     }
 
+    $0.context("given array of tuples") {
+      $0.it("can iterate over all tuple values") {
+        let templateString = "{% for first,second,third in tuples %}" +
+          "{{ first }}, {{ second }}, {{ third }}\n" +
+        "{% endfor %}\n"
+
+        let template = Template(templateString: templateString)
+        let result = try template.render(context)
+
+        let fixture = "1, 2, 3\n4, 5, 6\n\n"
+        try expect(result) == fixture
+      }
+
+      $0.it("can iterate with less number of variables") {
+        let templateString = "{% for first,second in tuples %}" +
+          "{{ first }}, {{ second }}\n" +
+        "{% endfor %}\n"
+
+        let template = Template(templateString: templateString)
+        let result = try template.render(context)
+
+        let fixture = "1, 2\n4, 5\n\n"
+        try expect(result) == fixture
+      }
+
+      $0.it("can use _ to skip variables") {
+        let templateString = "{% for first,_,third in tuples %}" +
+          "{{ first }}, {{ third }}\n" +
+        "{% endfor %}\n"
+
+        let template = Template(templateString: templateString)
+        let result = try template.render(context)
+
+        let fixture = "1, 3\n4, 6\n\n"
+        try expect(result) == fixture
+      }
+
+      $0.it("throws when number of variables is more than number of tuple values") {
+        let templateString = "{% for key,value,smth in dict %}" +
+        "{% endfor %}\n"
+
+        let template = Template(templateString: templateString)
+        try expect(template.render(context)).toThrow()
+      }
+
+    }
+
     $0.it("can iterate over dictionary") {
       let templateString = "{% for key,value in dict %}" +
-        "{{ key }}: {{ value }}\n" +
-        "{% endfor %}\n"
+        "{{ key }}: {{ value }}," +
+        "{% endfor %}"
 
       let template = Template(templateString: templateString)
       let result = try template.render(context)
 
-      let fixture = "one: I\ntwo: II\n\n"
-      try expect(result) == fixture
+      let sortedResult = result.characters.split(separator: ",").map(String.init).sorted(by: <)
+      try expect(sortedResult) == ["one: I", "two: II"]
     }
 
     $0.it("renders supports iterating over dictionary") {
-      let nodes: [NodeType] = [VariableNode(variable: "key")]
+      let nodes: [NodeType] = [
+        VariableNode(variable: "key"),
+        TextNode(text: ","),
+      ]
       let emptyNodes: [NodeType] = [TextNode(text: "empty")]
       let node = ForNode(resolvable: Variable("dict"), loopVariables: ["key"], nodes: nodes, emptyNodes: emptyNodes, where: nil)
-      try expect(try node.render(context)) == "onetwo"
+      let result = try node.render(context)
+
+      let sortedResult = result.characters.split(separator: ",").map(String.init).sorted(by: <)
+      try expect(sortedResult) == ["one", "two"]
     }
 
     $0.it("renders supports iterating over dictionary") {
-      let nodes: [NodeType] = [VariableNode(variable: "key"), VariableNode(variable: "value")]
+      let nodes: [NodeType] = [
+        VariableNode(variable: "key"),
+        TextNode(text: "="),
+        VariableNode(variable: "value"),
+        TextNode(text: ","),
+      ]
       let emptyNodes: [NodeType] = [TextNode(text: "empty")]
       let node = ForNode(resolvable: Variable("dict"), loopVariables: ["key", "value"], nodes: nodes, emptyNodes: emptyNodes, where: nil)
-      try expect(try node.render(context)) == "oneItwoII"
+
+      let result = try node.render(context)
+
+      let sortedResult = result.characters.split(separator: ",").map(String.init).sorted(by: <)
+      try expect(sortedResult) == ["one=I", "two=II"]
     }
 
     $0.it("handles invalid input") {
@@ -158,10 +227,92 @@ func testForNode() {
           .block(value: "for i"),
       ]
       let parser = TokenParser(tokens: tokens, environment: Environment())
-      let error = TemplateSyntaxError("'for' statements should use the following 'for x in y where condition' `for i`.")
+      let error = TemplateSyntaxError("'for' statements should use the syntax: `for <x> in <y> [where <condition>]")
       try expect(try parser.parse()).toThrow(error)
     }
+
+    $0.it("can iterate over struct properties") {
+      struct MyStruct {
+        let string: String
+        let number: Int
+      }
+
+      let context = Context(dictionary: [
+        "struct": MyStruct(string: "abc", number: 123)
+      ])
+
+      let nodes: [NodeType] = [
+        VariableNode(variable: "property"),
+        TextNode(text: "="),
+        VariableNode(variable: "value"),
+        TextNode(text: "\n"),
+      ]
+      let node = ForNode(resolvable: Variable("struct"), loopVariables: ["property", "value"], nodes: nodes, emptyNodes: [])
+      let result = try node.render(context)
+
+      try expect(result) == "string=abc\nnumber=123\n"
+    }
+
+    $0.it("can iterate tuple items") {
+      let context = Context(dictionary: [
+        "tuple": (one: 1, two: "dva"),
+      ])
+
+      let nodes: [NodeType] = [
+        VariableNode(variable: "label"),
+        TextNode(text: "="),
+        VariableNode(variable: "value"),
+        TextNode(text: "\n"),
+      ]
+
+      let node = ForNode(resolvable: Variable("tuple"), loopVariables: ["label", "value"], nodes: nodes, emptyNodes: [])
+      let result = try node.render(context)
+
+      try expect(result) == "one=1\ntwo=dva\n"
+    }
+
+    $0.it("can iterate over class properties") {
+      class MyClass {
+        var baseString: String
+        var baseInt: Int
+        init(_ string: String, _ int: Int) {
+          baseString = string
+          baseInt = int
+        }
+      }
+
+      class MySubclass: MyClass {
+        var childString: String
+        init(_ childString: String, _ string: String, _ int: Int) {
+          self.childString = childString
+          super.init(string, int)
+        }
+      }
+
+      let context = Context(dictionary: [
+        "class": MySubclass("child", "base", 1)
+      ])
+
+      let nodes: [NodeType] = [
+        VariableNode(variable: "label"),
+        TextNode(text: "="),
+        VariableNode(variable: "value"),
+        TextNode(text: "\n"),
+      ]
+
+      let node = ForNode(resolvable: Variable("class"), loopVariables: ["label", "value"], nodes: nodes, emptyNodes: [])
+      let result = try node.render(context)
+
+      try expect(result) == "childString=child\nbaseString=base\nbaseInt=1\n"
+    }
+
+    $0.it("can iterate in range of variables") {
+      let template: Template = "{% for i in 1...j %}{{ i }}{% endfor %}"
+      try expect(try template.render(Context(dictionary: ["j": 3]))) == "123"
+    }
+
   }
+
 }
 
 

Tests/StencilTests/IfNodeSpec.swift

@@ -270,5 +270,22 @@ func testIfNode() {
       let result = try renderNodes(nodes, Context(dictionary: ["instance": SomeType()]))
       try expect(result) == ""
     }
+
+    $0.it("supports closed range variables") {
+      let tokens: [Token] = [
+        .block(value: "if value in 1...3"),
+        .text(value: "true"),
+        .block(value: "else"),
+        .text(value: "false"),
+        .block(value: "endif")
+      ]
+
+      let parser = TokenParser(tokens: tokens, environment: Environment())
+      let nodes = try parser.parse()
+
+      try expect(renderNodes(nodes, Context(dictionary: ["value": 3]))) == "true"
+      try expect(renderNodes(nodes, Context(dictionary: ["value": 4]))) == "false"
+    }
+
   }
 }

Tests/StencilTests/InheritenceSpec.swift

@@ -11,17 +11,17 @@ func testInheritence() {
 
     $0.it("can inherit from another template") {
       let template = try environment.loadTemplate(name: "child.html")
-      try expect(try template.render()) == "Header\nChild"
+      try expect(try template.render()) == "Super_Header Child_Header\nChild_Body"
     }
 
     $0.it("can inherit from another template inheriting from another template") {
       let template = try environment.loadTemplate(name: "child-child.html")
-      try expect(try template.render()) == "Child Child Header\nChild"
+      try expect(try template.render()) == "Super_Header Child_Header Child_Child_Header\nChild_Body"
     }
 
     $0.it("can inherit from a template that calls a super block") {
       let template = try environment.loadTemplate(name: "child-super.html")
-      try expect(try template.render()) == "Header\nChild Body"
+      try expect(try template.render()) == "Header\nChild_Body"
     }
   }
 }

Tests/StencilTests/LexerSpec.swift

@@ -64,5 +64,27 @@ func testLexer() {
       let lexer = Lexer(templateString: "{{}}")
       let _ = lexer.tokenize()
     }
+
+    $0.it("can tokenize with new lines") {
+        let lexer = Lexer(templateString:
+        "My name is {%\n" +
+        "    if name\n" +
+        "     and\n" +
+        "    name\n" +
+        "%}{{\n" +
+        "name\n" +
+        "}}{%\n" +
+        "endif %}.")
+
+        let tokens = lexer.tokenize()
+
+        try expect(tokens.count) == 5
+        try expect(tokens[0]) == Token.text(value: "My name is ")
+        try expect(tokens[1]) == Token.block(value: "if name and name")
+        try expect(tokens[2]) == Token.variable(value: "name")
+        try expect(tokens[3]) == Token.block(value: "endif")
+        try expect(tokens[4]) == Token.text(value: ".")
+
+    }
   }
 }

Tests/StencilTests/VariableSpec.swift

@@ -4,8 +4,11 @@ import Spectre
 
 
 #if os(OSX)
-@objc class Object : NSObject {
-  let title = "Hello World"
+@objc class Superclass: NSObject {
+  @objc let name = "Foo"
+}
+@objc class Object : Superclass {
+  @objc let title = "Hello World"
 }
 #endif
 
@@ -17,6 +20,14 @@ fileprivate struct Article {
   let author: Person
 }
 
+fileprivate class WebSite {
+  let url: String = "blog.com"
+}
+
+fileprivate class Blog: WebSite {
+  let articles: [Article] = [Article(author: Person(name: "Kyle"))]
+  let featuring: Article? = Article(author: Person(name: "Jhon"))
+}
 
 func testVariable() {
   describe("Variable") {
@@ -29,12 +40,14 @@ func testVariable() {
       "counter": [
         "count": "kylef",
         ],
-      "article": Article(author: Person(name: "Kyle"))
+      "article": Article(author: Person(name: "Kyle")),
+      "tuple": (one: 1, two: 2)
     ])
 
 #if os(OSX)
     context["object"] = Object()
 #endif
+    context["blog"] = Blog()
 
     $0.it("can resolve a string literal with double quotes") {
       let variable = Variable("\"name\"")
@@ -50,7 +63,7 @@ func testVariable() {
 
     $0.it("can resolve an integer literal") {
       let variable = Variable("5")
-      let result = try variable.resolve(context) as? Number
+      let result = try variable.resolve(context) as? Int
       try expect(result) == 5
     }
 
@@ -60,6 +73,13 @@ func testVariable() {
       try expect(result) == 3.14
     }
 
+    $0.it("can resolve boolean literal") {
+      try expect(Variable("true").resolve(context) as? Bool) == true
+      try expect(Variable("false").resolve(context) as? Bool) == false
+      try expect(Variable("0").resolve(context) as? Int) == 0
+      try expect(Variable("1").resolve(context) as? Int) == 1
+    }
+
     $0.it("can resolve a string variable") {
       let variable = Variable("name")
       let result = try variable.resolve(context) as? String
@@ -122,6 +142,99 @@ func testVariable() {
       let result = try variable.resolve(context) as? String
       try expect(result) == "Hello World"
     }
+
+    $0.it("can resolve a superclass value via KVO") {
+      let variable = Variable("object.name")
+      let result = try variable.resolve(context) as? String
+      try expect(result) == "Foo"
+    }
 #endif
+
+    $0.it("can resolve a value via reflection") {
+      let variable = Variable("blog.articles.0.author.name")
+      let result = try variable.resolve(context) as? String
+      try expect(result) == "Kyle"
+    }
+
+    $0.it("can resolve a superclass value via reflection") {
+      let variable = Variable("blog.url")
+      let result = try variable.resolve(context) as? String
+      try expect(result) == "blog.com"
+    }
+
+    $0.it("can resolve optional variable property using reflection") {
+      let variable = Variable("blog.featuring.author.name")
+      let result = try variable.resolve(context) as? String
+      try expect(result) == "Jhon"
+    }
+
+    $0.it("does not render Optional") {
+      var array: [Any?] = [1, nil]
+      array.append(array)
+      let context = Context(dictionary: ["values": array])
+
+      try expect(VariableNode(variable: "values").render(context)) == "[1, nil, [1, nil]]"
+      try expect(VariableNode(variable: "values.1").render(context)) == ""
+    }
+
+    $0.it("can subscript tuple by index") {
+      let variable = Variable("tuple.0")
+      let result = try variable.resolve(context) as? Int
+      try expect(result) == 1
+    }
+
+    $0.it("can subscript tuple by label") {
+      let variable = Variable("tuple.two")
+      let result = try variable.resolve(context) as? Int
+      try expect(result) == 2
+    }
+  }
+
+  describe("RangeVariable") {
+
+    let context: Context = {
+      let ext = Extension()
+      ext.registerFilter("incr", filter: { (arg: Any?) in toNumber(value: arg!)! + 1 })
+      let environment = Environment(extensions: [ext])
+      return Context(dictionary: [:], environment: environment)
+    }()
+
+    func makeVariable(_ token: String) throws -> RangeVariable? {
+      return try RangeVariable(token, parser: TokenParser(tokens: [], environment: context.environment))
+    }
+
+    $0.it("can resolve closed range as array") {
+      let result = try makeVariable("1...3")?.resolve(context) as? [Int]
+      try expect(result) == [1, 2, 3]
+    }
+
+    $0.it("can resolve decreasing closed range as reversed array") {
+      let result = try makeVariable("3...1")?.resolve(context) as? [Int]
+      try expect(result) == [3, 2, 1]
+    }
+
+    $0.it("can use filter on range variables") {
+      let result = try makeVariable("1|incr...3|incr")?.resolve(context) as? [Int]
+      try expect(result) == [2, 3, 4]
+    }
+
+    $0.it("throws when left value is not int") {
+      let template: Template = "{% for i in k...j %}{{ i }}{% endfor %}"
+      try expect(try template.render(Context(dictionary: ["j": 3, "k": "1"]))).toThrow()
+    }
+
+    $0.it("throws when right value is not int") {
+      let variable = try makeVariable("k...j")
+      try expect(try variable?.resolve(Context(dictionary: ["j": "3", "k": 1]))).toThrow()
+    }
+
+    $0.it("throws is left range value is missing") {
+      try  expect(makeVariable("...1")).toThrow()
+    }
+
+    $0.it("throws is right range value is missing") {
+      try  expect(makeVariable("1...")).toThrow()
+    }
+
   }
 }

Tests/StencilTests/fixtures/child-child.html

@@ -1,2 +1,2 @@
 {% extends "child.html" %}
-{% block header %}Child Child Header{% endblock %}
+{% block header %}{{ block.super }} Child_Child_Header{% endblock %}

Tests/StencilTests/fixtures/child-super.html

@@ -1,3 +1,3 @@
 {% extends "base.html" %}
-{% block body %}Child {{ block.super }}{% endblock %}
+{% block body %}Child_{{ block.super }}{% endblock %}
 

Tests/StencilTests/fixtures/child.html

@@ -1,2 +1,3 @@
 {% extends "base.html" %}
-{% block body %}Child{% endblock %}
+{% block header %}Super_{{ block.super }} Child_Header{% endblock %}
+{% block body %}Child_Body{% endblock %}