Added printing support via WebKit WebView

1 files changed, 673 insertions, 0 deletions

diff --git a/Source/MGTemplateEngine.m b/Source/MGTemplateEngine.m
new file mode 100644
index 00000000..bf99afec
--- /dev/null
+++ b/Source/MGTemplateEngine.m
@@ -0,0 +1,673 @@
+//
+//  MGTemplateEngine.m
+//
+//  Created by Matt Gemmell on 11/05/2008.
+//  Copyright 2008 Instinctive Code. All rights reserved.
+//
+
+#import "MGTemplateEngine.h"
+#import "MGTemplateStandardMarkers.h"
+#import "MGTemplateStandardFilters.h"
+#import "DeepMutableCopy.h"
+
+
+#define DEFAULT_MARKER_START		@"{%"
+#define DEFAULT_MARKER_END			@"%}"
+#define DEFAULT_EXPRESSION_START	@"{{"	// should always be different from marker-start
+#define DEFAULT_EXPRESSION_END		@"}}"
+#define DEFAULT_FILTER_START		@"|"
+#define DEFAULT_LITERAL_START		@"literal"
+#define DEFAULT_LITERAL_END			@"/literal"
+// example:	{% markername arg1 arg2|filter:arg1 arg2 %}
+
+#define GLOBAL_ENGINE_GROUP			@"engine"		// name of dictionary in globals containing engine settings
+#define GLOBAL_ENGINE_DELIMITERS	@"delimiters"	// name of dictionary in GLOBAL_ENGINE_GROUP containing delimiters
+#define GLOBAL_DELIM_MARKER_START	@"markerStart"	// name of key in GLOBAL_ENGINE_DELIMITERS containing marker start delimiter
+#define GLOBAL_DELIM_MARKER_END		@"markerEnd"
+#define GLOBAL_DELIM_EXPR_START		@"expressionStart"
+#define GLOBAL_DELIM_EXPR_END		@"expressionEnd"
+#define GLOBAL_DELIM_FILTER			@"filter"
+
+@interface MGTemplateEngine (PrivateMethods)
+
+- (NSObject *)valueForVariable:(NSString *)var parent:(NSObject **)parent parentKey:(NSString **)parentKey;
+- (void)setValue:(NSObject *)newValue forVariable:(NSString *)var forceCurrentStackFrame:(BOOL)inStackFrame;
+- (void)reportError:(NSString *)errorStr code:(int)code continuing:(BOOL)continuing;
+- (void)reportBlockBoundaryStarted:(BOOL)started;
+- (void)reportTemplateProcessingFinished;
+
+@end
+
+
+@implementation MGTemplateEngine
+
+
+#pragma mark Creation and destruction
+
+
++ (NSString *)version
+{
+	// 1.0.0	20 May 2008
+	return @"1.0.0";
+}
+
+
++ (MGTemplateEngine *)templateEngine
+{
+	return [[[MGTemplateEngine alloc] init] autorelease];
+}
+
+
+- (id)init
+{
+	if (self = [super init]) {
+		_openBlocksStack = [[NSMutableArray alloc] init];
+		_globals = [[NSMutableDictionary alloc] init];
+		_markers = [[NSMutableDictionary alloc] init];
+		_filters = [[NSMutableDictionary alloc] init];
+		_templateVariables = [[NSMutableDictionary alloc] init];
+		_outputDisabledCount = 0; // i.e. not disabled.
+		self.markerStartDelimiter = DEFAULT_MARKER_START;
+		self.markerEndDelimiter = DEFAULT_MARKER_END;
+		self.expressionStartDelimiter = DEFAULT_EXPRESSION_START;
+		self.expressionEndDelimiter = DEFAULT_EXPRESSION_END;
+		self.filterDelimiter = DEFAULT_FILTER_START;
+		self.literalStartMarker = DEFAULT_LITERAL_START;
+		self.literalEndMarker = DEFAULT_LITERAL_END;
+		
+		// Load standard markers and filters.
+		[self loadMarker:[[[MGTemplateStandardMarkers alloc] initWithTemplateEngine:self] autorelease]];
+		[self loadFilter:[[[MGTemplateStandardFilters alloc] init] autorelease]];
+	}
+	
+	return self;
+}
+
+
+- (void)dealloc
+{
+	[_openBlocksStack release];
+	_openBlocksStack = nil;
+	[_globals release];
+	_globals = nil;
+	[_filters release];
+	_filters = nil;
+	[_markers release];
+	_markers = nil;
+	self.delegate = nil;
+	[templateContents release];
+	templateContents = nil;
+	[_templateVariables release];
+	_templateVariables = nil;
+	self.markerStartDelimiter = nil;
+	self.markerEndDelimiter = nil;
+	self.expressionStartDelimiter = nil;
+	self.expressionEndDelimiter = nil;
+	self.filterDelimiter = nil;
+	self.literalStartMarker = nil;
+	self.literalEndMarker = nil;
+	
+	[super dealloc];
+}
+
+
+#pragma mark Managing persistent values.
+
+
+- (void)setObject:(id)anObject forKey:(id)aKey
+{
+	[_globals setObject:anObject forKey:aKey];
+}
+
+
+- (void)addEntriesFromDictionary:(NSDictionary *)dict
+{
+	[_globals addEntriesFromDictionary:dict];
+}
+
+
+- (id)objectForKey:(id)aKey
+{
+	return [_globals objectForKey:aKey];
+}
+
+
+#pragma mark Configuration and extensibility.
+
+
+- (void)loadMarker:(NSObject <MGTemplateMarker> *)marker
+{
+	if (marker) {
+		// Obtain claimed markers.
+		NSArray *markers = [marker markers];
+		if (markers) {
+			for (NSString *markerName in markers) {
+				NSObject *existingHandler = [_markers objectForKey:markerName];
+				if (!existingHandler) {
+					// Set this MGTemplateMaker instance as the handler for markerName.
+					[_markers setObject:marker forKey:markerName];
+				}
+			}
+		}
+	}
+}
+
+
+- (void)loadFilter:(NSObject <MGTemplateFilter> *)filter
+{
+	if (filter) {
+		// Obtain claimed filters.
+		NSArray *filters = [filter filters];
+		if (filters) {
+			for (NSString *filterName in filters) {
+				NSObject *existingHandler = [_filters objectForKey:filterName];
+				if (!existingHandler) {
+					// Set this MGTemplateFilter instance as the handler for filterName.
+					[_filters setObject:filter forKey:filterName];
+				}
+			}
+		}
+	}
+}
+
+
+#pragma mark  Delegate
+
+
+- (void)reportError:(NSString *)errorStr code:(int)code continuing:(BOOL)continuing
+{
+	if (delegate) {
+		NSString *errStr = NSLocalizedString(errorStr, nil);
+		if (!continuing) {
+			errStr = [NSString stringWithFormat:@"%@: %@", NSLocalizedString(@"Fatal Error", nil), errStr];
+		}
+		SEL selector = @selector(templateEngine:encounteredError:isContinuing:);
+		if ([(NSObject *)delegate respondsToSelector:selector]) {
+			NSError *error = [NSError errorWithDomain:TEMPLATE_ENGINE_ERROR_DOMAIN 
+												 code:code 
+											 userInfo:[NSDictionary dictionaryWithObject:errStr 
+																				  forKey:NSLocalizedDescriptionKey]];
+			[(NSObject <MGTemplateEngineDelegate> *)delegate templateEngine:self 
+														   encounteredError:error 
+															   isContinuing:continuing];
+		}
+	}
+}
+
+
+- (void)reportBlockBoundaryStarted:(BOOL)started
+{
+	if (delegate) {
+		SEL selector = (started) ? @selector(templateEngine:blockStarted:) : @selector(templateEngine:blockEnded:);
+		if ([(NSObject *)delegate respondsToSelector:selector]) {
+			[(NSObject *)delegate performSelector:selector withObject:self withObject:[_openBlocksStack lastObject]];
+		}
+	}
+}
+
+
+- (void)reportTemplateProcessingFinished
+{
+	if (delegate) {
+		SEL selector = @selector(templateEngineFinishedProcessingTemplate:);
+		if ([(NSObject *)delegate respondsToSelector:selector]) {
+			[(NSObject *)delegate performSelector:selector withObject:self];
+		}
+	}
+}
+
+
+#pragma mark Utilities.
+
+
+- (NSObject *)valueForVariable:(NSString *)var parent:(NSObject **)parent parentKey:(NSString **)parentKey
+{
+	// Returns value for given variable-path, and returns by reference the parent object the variable
+	// is contained in, and the key used on that parent object to access the variable.
+	// e.g. for var "thing.stuff.2", where thing = NSDictionary and stuff = NSArray,
+	// parent would be a pointer to the "stuff" array, and parentKey would be "2".
+	
+	NSString *dot = @".";
+	NSArray *dotBits = [var componentsSeparatedByString:dot];
+	NSObject *result = nil;
+	NSObject *currObj = nil;
+	
+	// Check to see if there's a top-level entry for first part of var in templateVariables.
+	NSString *firstVar = [dotBits objectAtIndex:0];
+	
+	if ([_templateVariables objectForKey:firstVar]) {
+		currObj = _templateVariables;
+	} else if ([_globals objectForKey:firstVar]) {
+		currObj = _globals;
+	} else {
+		// Attempt to find firstVar in stack variables.
+		NSEnumerator *stack = [_openBlocksStack reverseObjectEnumerator];
+		NSDictionary *stackFrame = nil;
+		while (stackFrame = [stack nextObject]) {
+			NSDictionary *vars = [stackFrame objectForKey:BLOCK_VARIABLES_KEY];
+			if (vars && [vars objectForKey:firstVar]) {
+				currObj = vars;
+				break;
+			}
+		}
+	}
+	
+	if (!currObj) {
+		return nil;
+	}
+	
+	// Try raw KVC.
+	@try {
+		result = [currObj valueForKeyPath:var];
+	}
+	@catch (NSException *exception) {
+		// do nothing
+	}
+	
+	if (result) {
+		// Got it with regular KVC. Work out parent and parentKey if necessary.
+		if (parent || parentKey) {
+			if ([dotBits count] > 1) {
+				if (parent) {
+					*parent = [currObj valueForKeyPath:[[dotBits subarrayWithRange:NSMakeRange(0, [dotBits count] - 1)] 
+													   componentsJoinedByString:dot]];
+				}
+				if (parentKey) {
+					*parentKey = [dotBits lastObject];
+				}
+			} else {
+				if (parent) {
+					*parent = currObj;
+				}
+				if (parentKey) {
+					*parentKey = var;
+				}
+			}
+		}
+	} else {
+		// Try iterative checking for array indices.
+		int numKeys = [dotBits count];
+		if (numKeys > 1) { // otherwise no point in checking
+			NSObject *thisParent = currObj;
+			NSString *thisKey = nil;
+			for (int i = 0; i < numKeys; i++) {
+				thisKey = [dotBits objectAtIndex:i];
+				NSObject *newObj = nil;
+				@try {
+					newObj = [currObj valueForKeyPath:thisKey];
+				}
+				@catch (NSException *e) {
+					// do nothing
+				}
+				// Check to see if this is an array which we can index into.
+				if (!newObj && [currObj isKindOfClass:[NSArray class]]) {
+					NSCharacterSet *numbersSet = [NSCharacterSet decimalDigitCharacterSet];
+					NSScanner *scanner = [NSScanner scannerWithString:thisKey];
+					NSString *digits;
+					BOOL scanned = [scanner scanCharactersFromSet:numbersSet intoString:&digits];
+					if (scanned && digits && [digits length] > 0) {
+						int index = [digits intValue];
+						if (index >= 0 && index < [((NSArray *)currObj) count]) {
+							newObj = [((NSArray *)currObj) objectAtIndex:index];
+						}
+					}
+				}
+				thisParent = currObj;
+				currObj = newObj;
+				if (!currObj) {
+					break;
+				}
+			}
+			result = currObj;
+			if (parent || parentKey) {
+				if (parent) {
+					*parent = thisParent;
+				}
+				if (parentKey) {
+					*parentKey = thisKey;
+				}
+			}
+		}
+	}
+	
+	return result;
+}
+
+
+- (void)setValue:(NSObject *)newValue forVariable:(NSString *)var forceCurrentStackFrame:(BOOL)inStackFrame
+{
+	NSObject *parent = nil;
+	NSString *parentKey = nil;
+	NSObject *currValue;
+	currValue = [self valueForVariable:var parent:&parent parentKey:&parentKey];
+	if (!inStackFrame && currValue && (currValue != newValue)) {
+		// Set new value appropriately.
+		if ([parent isKindOfClass:[NSMutableArray class]]) {
+			[(NSMutableArray *)parent replaceObjectAtIndex:[parentKey intValue] withObject:newValue];
+		} else {
+			// Try using setValue:forKey:
+			@try {
+				[parent setValue:newValue forKey:parentKey];
+			}
+			@catch (NSException *e) {
+				// do nothing
+			}
+		}
+	} else if (!currValue || inStackFrame) {
+		// Put the variable into the current block-stack frame, or _templateVariables otherwise.
+		NSMutableDictionary *vars;
+		if ([_openBlocksStack count] > 0) {
+			vars = [[_openBlocksStack lastObject] objectForKey:BLOCK_VARIABLES_KEY];
+		} else {
+			vars = _templateVariables;
+		}
+		if ([vars respondsToSelector:@selector(setValue:forKey:)]) {
+			[vars setValue:newValue forKey:var];
+		}
+	}
+}
+
+
+- (NSObject *)resolveVariable:(NSString *)var
+{
+	NSObject *parent = nil;
+	NSString *key = nil;
+	NSObject *result = [self valueForVariable:var parent:&parent parentKey:&key];
+	//NSLog(@"var: %@, parent: %@, key: %@, result: %@", var, parent, key, result);
+	return result;
+}
+
+
+- (NSDictionary *)templateVariables
+{
+	return [NSDictionary dictionaryWithDictionary:_templateVariables];
+}
+
+
+#pragma mark Processing templates.
+
+
+- (NSString *)processTemplate:(NSString *)templateString withVariables:(NSDictionary *)variables
+{
+	// Set up environment.
+	[_openBlocksStack release];
+	_openBlocksStack = [[NSMutableArray alloc] init];
+	[_globals setObject:[NSDictionary dictionaryWithObjectsAndKeys:
+						 [NSDictionary dictionaryWithObjectsAndKeys:
+						  self.markerStartDelimiter, GLOBAL_DELIM_MARKER_START, 
+						  self.markerEndDelimiter, GLOBAL_DELIM_MARKER_END, 
+						  self.expressionStartDelimiter, GLOBAL_DELIM_EXPR_START, 
+						  self.expressionEndDelimiter, GLOBAL_DELIM_EXPR_END, 
+						  self.filterDelimiter, GLOBAL_DELIM_FILTER, 
+						  nil], GLOBAL_ENGINE_DELIMITERS, 
+						 nil]
+				 forKey:GLOBAL_ENGINE_GROUP];
+	[_globals setObject:[NSNumber numberWithBool:YES] forKey:@"true"];
+	[_globals setObject:[NSNumber numberWithBool:NO] forKey:@"false"];
+	[_globals setObject:[NSNumber numberWithBool:YES] forKey:@"YES"];
+	[_globals setObject:[NSNumber numberWithBool:NO] forKey:@"NO"];
+	[_globals setObject:[NSNumber numberWithBool:YES] forKey:@"yes"];
+	[_globals setObject:[NSNumber numberWithBool:NO] forKey:@"no"];
+	_outputDisabledCount = 0;
+	[templateContents release];
+	templateContents = [templateString retain];
+	_templateLength = [templateString length];
+	[_templateVariables release];
+	_templateVariables = [variables deepMutableCopy];
+	remainingRange = NSMakeRange(0, [templateString length]);
+	_literal = NO;
+	
+	// Ensure we have a matcher.
+	if (!matcher) {
+		[self reportError:@"No matcher has been configured for the template engine" code:7 continuing:NO];
+		return nil;
+	}
+	
+	// Tell our matcher to take note of our settings.
+	[matcher engineSettingsChanged];
+	NSMutableString *output = [NSMutableString string];
+	
+	while (remainingRange.location != NSNotFound) {
+		NSDictionary *matchInfo = [matcher firstMarkerWithinRange:remainingRange];
+		if (matchInfo) {
+			// Append output before marker if appropriate.
+			NSRange matchRange = [[matchInfo objectForKey:MARKER_RANGE_KEY] rangeValue];
+			if (_outputDisabledCount == 0) {
+				NSRange preMarkerRange = NSMakeRange(remainingRange.location, matchRange.location - remainingRange.location);
+				[output appendFormat:@"%@", [templateContents substringWithRange:preMarkerRange]];
+			}
+			
+			// Adjust remainingRange.
+			remainingRange.location = NSMaxRange(matchRange);
+			remainingRange.length = _templateLength - remainingRange.location;
+			
+			// Process the marker we found.
+			//NSLog(@"Match: %@", matchInfo);
+			NSString *matchMarker = [matchInfo objectForKey:MARKER_NAME_KEY];
+			
+			// Deal with literal mode.
+			if ([matchMarker isEqualToString:self.literalStartMarker]) {
+				if (_literal && _outputDisabledCount == 0) {
+					// Output this tag literally.
+					[output appendFormat:@"%@", [templateContents substringWithRange:matchRange]];
+				} else {
+					// Enable literal mode.
+					_literal = YES;
+				}
+				continue;
+			} else if ([matchMarker isEqualToString:self.literalEndMarker]) {
+				// Disable literal mode.
+				_literal = NO;
+				continue;
+			} else if (_literal && _outputDisabledCount == 0) {
+				[output appendFormat:@"%@", [templateContents substringWithRange:matchRange]];
+				continue;
+			}
+			
+			// Check to see if the match is a marker.
+			BOOL isMarker = [[matchInfo objectForKey:MARKER_TYPE_KEY] isEqualToString:MARKER_TYPE_MARKER];
+			NSObject <MGTemplateMarker> *markerHandler = nil;
+			NSObject *val = nil;
+			if (isMarker) {
+				markerHandler = [_markers objectForKey:matchMarker];
+				
+				// Process marker with handler.
+				BOOL blockStarted = NO;
+				BOOL blockEnded = NO;
+				BOOL outputEnabled = (_outputDisabledCount == 0);
+				BOOL outputWasEnabled = outputEnabled;
+				NSRange nextRange = remainingRange;
+				NSDictionary *newVariables = nil;
+				NSDictionary *blockInfo = nil;
+				
+				// If markerHandler is same as that of current block, send blockInfo.
+				if ([_openBlocksStack count] > 0) {
+					NSDictionary *currBlock = [_openBlocksStack lastObject];
+					NSString *currBlockStartMarker = [currBlock objectForKey:BLOCK_NAME_KEY];
+					if ([_markers objectForKey:currBlockStartMarker] == markerHandler) {
+						blockInfo = currBlock;
+					}
+				}
+				
+				// Call marker's handler.
+				val = [markerHandler markerEncountered:matchMarker 
+										 withArguments:[matchInfo objectForKey:MARKER_ARGUMENTS_KEY] 
+											   inRange:matchRange 
+										  blockStarted:&blockStarted blockEnded:&blockEnded 
+										 outputEnabled:&outputEnabled nextRange:&nextRange 
+									  currentBlockInfo:blockInfo newVariables:&newVariables];
+				
+				if (outputEnabled != outputWasEnabled) {
+					if (outputEnabled) {
+						_outputDisabledCount--;
+					} else {
+						_outputDisabledCount++;
+					}
+				}
+				remainingRange = nextRange;
+				
+				// Check to see if remainingRange is valid.
+				if (NSMaxRange(remainingRange) > [self.templateContents length]) {
+					[self reportError:[NSString stringWithFormat:@"Marker handler \"%@\" specified an invalid range to resume processing from", 
+									   matchMarker] 
+								 code:5 continuing:NO];
+					break;
+				}
+				
+				BOOL forceVarsToStack = NO;
+				if (blockStarted && blockEnded) {
+					// This is considered an error on the part of the marker-handler. Report to delegate.
+					[self reportError:[NSString stringWithFormat:@"Marker \"%@\" reported that a block simultaneously began and ended", 
+									   matchMarker] 
+								 code:0 continuing:YES];
+				} else if (blockStarted) {
+					NSArray *endMarkers = [markerHandler endMarkersForMarker:matchMarker];
+					if (!endMarkers) {
+						// Report error to delegate.
+						[self reportError:[NSString stringWithFormat:@"Marker \"%@\" started a block but did not supply any suitable end-markers", 
+										   matchMarker] 
+									 code:4 continuing:YES];
+						continue;
+					}
+					
+					// A block has begun. Create relevant stack frame.
+					NSMutableDictionary *frame = [NSMutableDictionary dictionary];
+					[frame setObject:matchMarker forKey:BLOCK_NAME_KEY];
+					[frame setObject:endMarkers forKey:BLOCK_END_NAMES_KEY];
+					NSArray *arguments = [matchInfo objectForKey:MARKER_ARGUMENTS_KEY];
+					if (!arguments) {
+						arguments = [NSArray array];
+					}
+					[frame setObject:arguments forKey:BLOCK_ARGUMENTS_KEY];
+					[frame setObject:[matchInfo objectForKey:MARKER_RANGE_KEY] forKey:BLOCK_START_MARKER_RANGE_KEY];
+					[frame setObject:[NSMutableDictionary dictionary] forKey:BLOCK_VARIABLES_KEY];
+					[_openBlocksStack addObject:frame];
+					
+					forceVarsToStack = YES;
+					
+					// Report block start to delegate.
+					[self reportBlockBoundaryStarted:YES];
+				} else if (blockEnded) {
+					if (!blockInfo || 
+						([_openBlocksStack count] > 0 && 
+						 ![(NSArray *)[[_openBlocksStack lastObject] objectForKey:BLOCK_END_NAMES_KEY] containsObject:matchMarker])) {
+						// The marker-handler just told us a block ended, but the current block was not
+						// started by that marker-handler. This means a syntax error exists in the template,
+						// specifically an unterminated block (the current block).
+						// This is considered an unrecoverable error.
+						NSString *errMsg;
+						if ([_openBlocksStack count] == 0) {
+							errMsg = [NSString stringWithFormat:@"Marker \"%@\" reported that a non-existent block ended", 
+									  matchMarker];
+						} else {
+							NSString *currBlockName = [[_openBlocksStack lastObject] objectForKey:BLOCK_NAME_KEY];
+							errMsg = [NSString stringWithFormat:@"Marker \"%@\" reported that a block ended, \
+but current block was started by \"%@\" marker", 
+									  matchMarker, currBlockName];
+						}
+						[self reportError:errMsg code:1 continuing:YES];
+						break;
+					}
+					
+					// Report block end to delegate before removing stack frame, so we can send info dict.
+					[self reportBlockBoundaryStarted:NO];
+					
+					// Remove relevant stack frame.
+					if ([_openBlocksStack count] > 0) {
+						[_openBlocksStack removeLastObject];
+					}
+				}
+				
+				// Process newVariables
+				if (newVariables) {
+					//NSLog(@"new vars %@", newVariables);
+					for (NSString *key in newVariables) {
+						[self setValue:[newVariables objectForKey:key] forVariable:key forceCurrentStackFrame:forceVarsToStack];
+					}
+				}
+				
+			} else {
+				// Check to see if the first word of the match is a variable.
+				val = [self resolveVariable:matchMarker];
+			}
+			
+			// Prepare result for output, if we have a result.
+			if (val && _outputDisabledCount == 0) {
+				// Process filter if specified.
+				NSString *filter = [matchInfo objectForKey:MARKER_FILTER_KEY];
+				if (filter) {
+					NSObject <MGTemplateFilter> *filterHandler = [_filters objectForKey:filter];
+					if (filterHandler) {
+						val = [filterHandler filterInvoked:filter 
+											 withArguments:[matchInfo objectForKey:MARKER_FILTER_ARGUMENTS_KEY] onValue:val];
+					}
+				}
+				
+				// Output result.
+				[output appendFormat:@"%@", val];
+			} else if ((!val && !isMarker && _outputDisabledCount == 0) || (isMarker && !markerHandler)) {
+				// Call delegate's error-reporting method, if implemented.
+				[self reportError:[NSString stringWithFormat:@"\"%@\" is not a valid %@", 
+								   matchMarker, (isMarker) ? @"marker" : @"variable"] 
+							 code:((isMarker) ? 2 : 3)  continuing:YES];
+			}
+		} else {
+			// Append output to end of template.
+			if (_outputDisabledCount == 0) {
+				[output appendFormat:@"%@", [templateContents substringWithRange:remainingRange]];
+			}
+			
+			// Check to see if there are open blocks left over.
+			int openBlocks = [_openBlocksStack count];
+			if (openBlocks > 0) {
+				NSString *errMsg = [NSString stringWithFormat:@"Finished processing template, but %d %@ left open (%@).", 
+									openBlocks, 
+									(openBlocks == 1) ? @"block was" : @"blocks were", 
+									[[_openBlocksStack valueForKeyPath:BLOCK_NAME_KEY] componentsJoinedByString:@", "]];
+				[self reportError:errMsg code:6 continuing:YES];
+			}
+			
+			// Ensure we terminate the loop.
+			remainingRange.location = NSNotFound;
+		}
+	}
+	
+	// Tell all marker-handlers we're done.
+	[[_markers allValues] makeObjectsPerformSelector:@selector(engineFinishedProcessingTemplate)];
+	
+	// Inform delegate we're done.
+	[self reportTemplateProcessingFinished];
+	
+	return output;
+}
+
+
+- (NSString *)processTemplateInFileAtPath:(NSString *)templatePath withVariables:(NSDictionary *)variables
+{
+	NSString *result = nil;
+	NSStringEncoding enc;
+	NSString *templateString = [NSString stringWithContentsOfFile:templatePath usedEncoding:&enc error:NULL];
+	if (templateString) {
+		result = [self processTemplate:templateString withVariables:variables];
+	}
+	return result;
+}
+
+
+#pragma mark Properties
+
+
+@synthesize markerStartDelimiter;
+@synthesize markerEndDelimiter;
+@synthesize expressionStartDelimiter;
+@synthesize expressionEndDelimiter;
+@synthesize filterDelimiter;
+@synthesize literalStartMarker;
+@synthesize literalEndMarker;
+@synthesize remainingRange;
+@synthesize delegate;
+@synthesize matcher;
+@synthesize templateContents;
+
+
+@end