RubyGems - appjam - Versions diffs - 0.1.8.8 → 0.1.8.9 - Mend

appjam 0.1.8.8 → 0.1.8.9

Files changed (168) hide show

data/lib/appjam/generators/templates/blank/EiffelApplication/libs/toolkit/CocoaHTTPServer/Core/Responses/HTTPDataResponse.h ADDED

@@ -0,0 +1,13 @@
+#import <Foundation/Foundation.h>
+#import "HTTPResponse.h"
+@interface HTTPDataResponse : NSObject <HTTPResponse>
+{
+	NSUInteger offset;
+	NSData *data;
+}
+- (id)initWithData:(NSData *)data;
+@end

data/lib/appjam/generators/templates/blank/EiffelApplication/libs/toolkit/CocoaHTTPServer/Core/Responses/HTTPDataResponse.m ADDED

@@ -0,0 +1,79 @@
+#import "HTTPDataResponse.h"
+#import "HTTPLogging.h"
+#if ! __has_feature(objc_arc)
+#warning This file must be compiled with ARC. Use -fobjc-arc flag (or convert project to ARC).
+#endif
+// Log levels : off, error, warn, info, verbose
+// Other flags: trace
+static const int httpLogLevel = HTTP_LOG_LEVEL_OFF; // | HTTP_LOG_FLAG_TRACE;
+@implementation HTTPDataResponse
+- (id)initWithData:(NSData *)dataParam
+{
+	if((self = [super init]))
+	{
+		HTTPLogTrace();
+		offset = 0;
+		data = dataParam;
+	}
+	return self;
+}
+- (void)dealloc
+{
+	HTTPLogTrace();
+}
+- (UInt64)contentLength
+{
+	UInt64 result = (UInt64)[data length];
+	HTTPLogTrace2(@"%@[%p]: contentLength - %llu", THIS_FILE, self, result);
+	return result;
+}
+- (UInt64)offset
+{
+	HTTPLogTrace();
+	return offset;
+}
+- (void)setOffset:(UInt64)offsetParam
+{
+	HTTPLogTrace2(@"%@[%p]: setOffset:%lu", THIS_FILE, self, (unsigned long)offset);
+	offset = (NSUInteger)offsetParam;
+}
+- (NSData *)readDataOfLength:(NSUInteger)lengthParameter
+{
+	HTTPLogTrace2(@"%@[%p]: readDataOfLength:%lu", THIS_FILE, self, (unsigned long)lengthParameter);
+	NSUInteger remaining = [data length] - offset;
+	NSUInteger length = lengthParameter < remaining ? lengthParameter : remaining;
+	void *bytes = (void *)([data bytes] + offset);
+	offset += length;
+	return [NSData dataWithBytesNoCopy:bytes length:length freeWhenDone:NO];
+}
+- (BOOL)isDone
+{
+	BOOL result = (offset == [data length]);
+	HTTPLogTrace2(@"%@[%p]: isDone - %@", THIS_FILE, self, (result ? @"YES" : @"NO"));
+	return result;
+}
+@end

data/lib/appjam/generators/templates/blank/EiffelApplication/libs/toolkit/CocoaHTTPServer/Core/Responses/HTTPDynamicFileResponse.h ADDED

@@ -0,0 +1,52 @@
+#import <Foundation/Foundation.h>
+#import "HTTPResponse.h"
+#import "HTTPAsyncFileResponse.h"
+/**
+ * This class is designed to assist with dynamic content.
+ * Imagine you have a file that you want to make dynamic:
+ *
+ * <html>
+ * <body>
+ *   <h1>ComputerName Control Panel</h1>
+ *   ...
+ *   <li>System Time: SysTime</li>
+ * </body>
+ * </html>
+ *
+ * Now you could generate the entire file in Objective-C,
+ * but this would be a horribly tedious process.
+ * Beside, you want to design the file with professional tools to make it look pretty.
+ *
+ * So all you have to do is escape your dynamic content like this:
+ *
+ * ...
+ *   <h1>%%ComputerName%% Control Panel</h1>
+ * ...
+ *   <li>System Time: %%SysTime%%</li>
+ *
+ * And then you create an instance of this class with:
+ *
+ * - separator = @"%%"
+ * - replacementDictionary = { "ComputerName"="Black MacBook", "SysTime"="2010-04-30 03:18:24" }
+ *
+ * This class will then perform the replacements for you, on the fly, as it reads the file data.
+ * This class is also asynchronous, so it will perform the file IO using its own GCD queue.
+ *
+ * All keys for the replacementDictionary must be NSString's.
+ * Values for the replacementDictionary may be NSString's, or any object that
+ * returns what you want when its description method is invoked.
+**/
+@interface HTTPDynamicFileResponse : HTTPAsyncFileResponse
+{
+	NSData *separator;
+	NSDictionary *replacementDict;
+}
+- (id)initWithFilePath:(NSString *)filePath
+         forConnection:(HTTPConnection *)connection
+             separator:(NSString *)separatorStr
+ replacementDictionary:(NSDictionary *)dictionary;
+@end

data/lib/appjam/generators/templates/blank/EiffelApplication/libs/toolkit/CocoaHTTPServer/Core/Responses/HTTPDynamicFileResponse.m ADDED

@@ -0,0 +1,292 @@
+#import "HTTPDynamicFileResponse.h"
+#import "HTTPConnection.h"
+#import "HTTPLogging.h"
+#if ! __has_feature(objc_arc)
+#warning This file must be compiled with ARC. Use -fobjc-arc flag (or convert project to ARC).
+#endif
+// Log levels : off, error, warn, info, verbose
+// Other flags: trace
+static const int httpLogLevel = HTTP_LOG_LEVEL_WARN; // | HTTP_LOG_FLAG_TRACE;
+#define NULL_FD  -1
+@implementation HTTPDynamicFileResponse
+- (id)initWithFilePath:(NSString *)fpath
+         forConnection:(HTTPConnection *)parent
+             separator:(NSString *)separatorStr
+ replacementDictionary:(NSDictionary *)dict
+{
+	if ((self = [super initWithFilePath:fpath forConnection:parent]))
+	{
+		HTTPLogTrace();
+		separator = [separatorStr dataUsingEncoding:NSUTF8StringEncoding];
+		replacementDict = dict;
+	}
+	return self;
+}
+- (BOOL)isChunked
+{
+	HTTPLogTrace();
+	return YES;
+}
+- (UInt64)contentLength
+{
+	// This method shouldn't be called since we're using a chunked response.
+	// We override it just to be safe.
+	HTTPLogTrace();
+	return 0;
+}
+- (void)setOffset:(UInt64)offset
+{
+	// This method shouldn't be called since we're using a chunked response.
+	// We override it just to be safe.
+	HTTPLogTrace();
+}
+- (BOOL)isDone
+{
+	BOOL result = (readOffset == fileLength) && (readBufferOffset == 0);
+	HTTPLogTrace2(@"%@[%p]: isDone - %@", THIS_FILE, self, (result ? @"YES" : @"NO"));
+	return result;
+}
+- (void)processReadBuffer
+{
+	HTTPLogTrace();
+	// At this point, the readBuffer has readBufferOffset bytes available.
+	// This method is in charge of updating the readBufferOffset.
+	NSUInteger bufLen = readBufferOffset;
+	NSUInteger sepLen = [separator length];
+	// We're going to start looking for the separator at the beginning of the buffer,
+	// and stop when we get to the point where the separator would no longer fit in the buffer.
+	NSUInteger offset = 0;
+	NSUInteger stopOffset = (bufLen > sepLen) ? bufLen - sepLen + 1 : 0;
+	// In order to do the replacement, we need to find the starting and ending separator.
+	// For example:
+	//
+	// %%USER_NAME%%
+	//
+	// Where "%%" is the separator.
+	BOOL found1 = NO;
+	BOOL found2 = NO;
+	NSUInteger s1 = 0;
+	NSUInteger s2 = 0;
+	const void *sep = [separator bytes];
+	while (offset < stopOffset)
+	{
+		const void *subBuffer = readBuffer + offset;
+		if (memcmp(subBuffer, sep, sepLen) == 0)
+		{
+			if (!found1)
+			{
+				// Found the first separator
+				found1 = YES;
+				s1 = offset;
+				offset += sepLen;
+				HTTPLogVerbose(@"%@[%p]: Found s1 at %lu", THIS_FILE, self, (unsigned long)s1);
+			}
+			else
+			{
+				// Found the second separator
+				found2 = YES;
+				s2 = offset;
+				offset += sepLen;
+				HTTPLogVerbose(@"%@[%p]: Found s2 at %lu", THIS_FILE, self, (unsigned long)s2);
+			}
+			if (found1 && found2)
+			{
+				// We found our separators.
+				// Now extract the string between the two separators.
+				NSRange fullRange = NSMakeRange(s1, (s2 - s1 + sepLen));
+				NSRange strRange = NSMakeRange(s1 + sepLen, (s2 - s1 - sepLen));
+				// Wish we could use the simple subdataWithRange method.
+				// But that method copies the bytes...
+				// So for performance reasons, we need to use the methods that don't copy the bytes.
+				void *strBuf = readBuffer + strRange.location;
+				NSUInteger strLen = strRange.length;
+				NSString *key = [[NSString alloc] initWithBytes:strBuf length:strLen encoding:NSUTF8StringEncoding];
+				if (key)
+				{
+					// Is there a given replacement for this key?
+					id value = [replacementDict objectForKey:key];
+					if (value)
+					{
+						// Found the replacement value.
+						// Now perform the replacement in the buffer.
+						HTTPLogVerbose(@"%@[%p]: key(%@) -> value(%@)", THIS_FILE, self, key, value);
+						NSData *v = [[value description] dataUsingEncoding:NSUTF8StringEncoding];
+						NSUInteger vLength = [v length];
+						if (fullRange.length == vLength)
+						{
+							// Replacement is exactly the same size as what it is replacing
+							// memcpy(void *restrict dst, const void *restrict src, size_t n);
+							memcpy(readBuffer + fullRange.location, [v bytes], vLength);
+						}
+						else // (fullRange.length != vLength)
+						{
+							NSInteger diff = (NSInteger)vLength - (NSInteger)fullRange.length;
+							if (diff > 0)
+							{
+								// Replacement is bigger than what it is replacing.
+								// Make sure there is room in the buffer for the replacement.
+								if (diff > (readBufferSize - bufLen))
+								{
+									NSUInteger inc = MAX(diff, 256);
+									readBufferSize += inc;
+									readBuffer = reallocf(readBuffer, readBufferSize);
+								}
+							}
+							// Move the data that comes after the replacement.
+							//
+							// If replacement is smaller than what it is replacing,
+							// then we are shifting the data toward the beginning of the buffer.
+							//
+							// If replacement is bigger than what it is replacing,
+							// then we are shifting the data toward the end of the buffer.
+							//
+							// memmove(void *dst, const void *src, size_t n);
+							//
+							// The memmove() function copies n bytes from src to dst.
+							// The two areas may overlap; the copy is always done in a non-destructive manner.
+							void *src = readBuffer + fullRange.location + fullRange.length;
+							void *dst = readBuffer + fullRange.location + vLength;
+							NSUInteger remaining = bufLen - (fullRange.location + fullRange.length);
+							memmove(dst, src, remaining);
+							// Now copy the replacement into its location.
+							//
+							// memcpy(void *restrict dst, const void *restrict src, size_t n)
+							//
+							// The memcpy() function copies n bytes from src to dst.
+							// If the two areas overlap, behavior is undefined.
+							memcpy(readBuffer + fullRange.location, [v bytes], vLength);
+							// And don't forget to update our indices.
+							bufLen     += diff;
+							offset     += diff;
+							stopOffset += diff;
+						}
+					}
+				}
+				found1 = found2 = NO;
+			}
+		}
+		else
+		{
+			offset++;
+		}
+	}
+	// We've gone through our buffer now, and performed all the replacements that we could.
+	// It's now time to update the amount of available data we have.
+	if (readOffset == fileLength)
+	{
+		// We've read in the entire file.
+		// So there can be no more replacements.
+		data = [[NSData alloc] initWithBytes:readBuffer length:bufLen];
+		readBufferOffset = 0;
+	}
+	else
+	{
+		// There are a couple different situations that we need to take into account here.
+		//
+		// Imagine the following file:
+		// My name is %%USER_NAME%%
+		//
+		// Situation 1:
+		// The first chunk of data we read was "My name is %%".
+		// So we found the first separator, but not the second.
+		// In this case we can only return the data that precedes the first separator.
+		//
+		// Situation 2:
+		// The first chunk of data we read was "My name is %".
+		// So we didn't find any separators, but part of a separator may be included in our buffer.
+		NSUInteger available;
+		if (found1)
+		{
+			// Situation 1
+			available = s1;
+		}
+		else
+		{
+			// Situation 2
+			available = stopOffset;
+		}
+		// Copy available data
+		data = [[NSData alloc] initWithBytes:readBuffer length:available];
+		// Remove the copied data from the buffer.
+		// We do this by shifting the remaining data toward the beginning of the buffer.
+		NSUInteger remaining = bufLen - available;
+		memmove(readBuffer, readBuffer + available, remaining);
+		readBufferOffset = remaining;
+	}
+	[connection responseHasAvailableData:self];
+}
+- (void)dealloc
+{
+	HTTPLogTrace();
+}
+@end

data/lib/appjam/generators/templates/blank/EiffelApplication/libs/toolkit/CocoaHTTPServer/Core/Responses/HTTPErrorResponse.h ADDED

@@ -0,0 +1,9 @@
+#import "HTTPResponse.h"
+@interface HTTPErrorResponse : NSObject <HTTPResponse> {
+    NSInteger _status;
+}
+- (id)initWithErrorCode:(int)httpErrorCode;
+@end