From 1824ae6360c9ce1897e75404163d39df08ee5fbf Mon Sep 17 00:00:00 2001 From: bamse16 Date: Sat, 11 Apr 2009 09:14:42 +0000 Subject: Added printing support via WebKit WebView --- Source/MGTemplateEngine.m | 673 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 673 insertions(+) create mode 100644 Source/MGTemplateEngine.m (limited to 'Source/MGTemplateEngine.m') 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 *)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 *)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 *)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 *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 *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 -- cgit v1.2.3