@devicelab/maestro-runner-darwin-x64 1.1.25

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Vendor/RoutingHTTPServer/HTTPResponseProxy.m

@@ -0,0 +1,84 @@
+#import "HTTPResponseProxy.h"
+
+#pragma clang diagnostic ignored "-Wdirect-ivar-access"
+
+@implementation HTTPResponseProxy
+
+@synthesize response;
+@synthesize status;
+
+- (NSInteger)status {
+  if (status != 0) {
+    return status;
+  } else if ([response respondsToSelector:@selector(status)]) {
+    return [response status];
+  }
+  
+  return 200;
+}
+
+- (void)setStatus:(NSInteger)statusCode {
+  status = statusCode;
+}
+
+- (NSInteger)customStatus {
+  return status;
+}
+
+// Implement the required HTTPResponse methods
+- (UInt64)contentLength {
+  if (response) {
+    return [response contentLength];
+  } else {
+    return 0;
+  }
+}
+
+- (UInt64)offset {
+  if (response) {
+    return [response offset];
+  } else {
+    return 0;
+  }
+}
+
+- (void)setOffset:(UInt64)offset {
+  if (response) {
+    [response setOffset:offset];
+  }
+}
+
+- (NSData *)readDataOfLength:(NSUInteger)length {
+  if (response) {
+    return [response readDataOfLength:length];
+  } else {
+    return nil;
+  }
+}
+
+- (BOOL)isDone {
+  if (response) {
+    return [response isDone];
+  } else {
+    return YES;
+  }
+}
+
+// Forward all other invocations to the actual response object
+- (void)forwardInvocation:(NSInvocation *)invocation {
+  if ([response respondsToSelector:[invocation selector]]) {
+    [invocation invokeWithTarget:response];
+  } else {
+    [super forwardInvocation:invocation];
+  }
+}
+
+- (BOOL)respondsToSelector:(SEL)selector {
+  if ([super respondsToSelector:selector])
+    return YES;
+  
+  return [response respondsToSelector:selector];
+}
+
+@end
+

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Vendor/RoutingHTTPServer/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011 Matt Stevens
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Vendor/RoutingHTTPServer/Route.h

@@ -0,0 +1,18 @@
+#import <Foundation/Foundation.h>
+#import "RoutingHTTPServer.h"
+
+@interface Route : NSObject
+
+@property (nonatomic) NSRegularExpression *regex;
+@property (nonatomic, copy) RequestHandler handler;
+
+#if __has_feature(objc_arc_weak)
+@property (nonatomic, weak) id target;
+#else
+@property (nonatomic, assign) id target;
+#endif
+
+@property (nonatomic, assign) SEL selector;
+@property (nonatomic) NSArray *keys;
+
+@end

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Vendor/RoutingHTTPServer/Route.m

@@ -0,0 +1,11 @@
+#import "Route.h"
+
+@implementation Route
+
+@synthesize regex;
+@synthesize handler;
+@synthesize target;
+@synthesize selector;
+@synthesize keys;
+
+@end

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Vendor/RoutingHTTPServer/RouteRequest.h

@@ -0,0 +1,16 @@
+#import <Foundation/Foundation.h>
+@class HTTPMessage;
+
+@interface RouteRequest : NSObject
+
+@property (nonatomic, readonly) NSDictionary *headers;
+@property (nonatomic, readonly) NSDictionary *params;
+
+- (id)initWithHTTPMessage:(HTTPMessage *)msg parameters:(NSDictionary *)params;
+- (NSString *)header:(NSString *)field;
+- (id)param:(NSString *)name;
+- (NSString *)method;
+- (NSURL *)url;
+- (NSData *)body;
+
+@end

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Vendor/RoutingHTTPServer/RouteRequest.m

@@ -0,0 +1,50 @@
+#import "RouteRequest.h"
+#import "HTTPMessage.h"
+
+#pragma clang diagnostic ignored "-Wdirect-ivar-access"
+#pragma clang diagnostic ignored "-Widiomatic-parentheses"
+
+@implementation RouteRequest {
+  HTTPMessage *message;
+}
+
+@synthesize params;
+
+- (id)initWithHTTPMessage:(HTTPMessage *)msg parameters:(NSDictionary *)parameters {
+  if (self = [super init]) {
+    params = parameters;
+    message = msg;
+  }
+  return self;
+}
+
+- (NSDictionary *)headers {
+  return [message allHeaderFields];
+}
+
+- (NSString *)header:(NSString *)field {
+  return [message headerField:field];
+}
+
+- (id)param:(NSString *)name {
+  return [params objectForKey:name];
+}
+
+- (NSString *)method {
+  return [message method];
+}
+
+- (NSURL *)url {
+  return [message url];
+}
+
+- (NSData *)body {
+  return [message body];
+}
+
+- (NSString *)description {
+  NSData *data = [message messageData];
+  return [[NSString alloc] initWithData:data encoding:NSASCIIStringEncoding];
+}
+
+@end

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Vendor/RoutingHTTPServer/RouteResponse.h

@@ -0,0 +1,20 @@
+#import <Foundation/Foundation.h>
+#import "HTTPResponse.h"
+@class HTTPConnection;
+@class HTTPResponseProxy;
+
+@interface RouteResponse : NSObject
+
+@property (nonatomic, unsafe_unretained, readonly) HTTPConnection *connection;
+@property (nonatomic, readonly) NSDictionary *headers;
+@property (nonatomic, strong) NSObject<HTTPResponse> *response;
+@property (nonatomic, readonly) NSObject<HTTPResponse> *proxiedResponse;
+@property (nonatomic) NSInteger statusCode;
+
+- (id)initWithConnection:(HTTPConnection *)theConnection;
+- (void)setHeader:(NSString *)field value:(NSString *)value;
+- (void)respondWithString:(NSString *)string;
+- (void)respondWithString:(NSString *)string encoding:(NSStringEncoding)encoding;
+- (void)respondWithData:(NSData *)data;
+
+@end

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Vendor/RoutingHTTPServer/RouteResponse.m

@@ -0,0 +1,66 @@
+#import "RouteResponse.h"
+#import "HTTPConnection.h"
+#import "HTTPDataResponse.h"
+#import "HTTPResponseProxy.h"
+
+#pragma clang diagnostic ignored "-Wdirect-ivar-access"
+#pragma clang diagnostic ignored "-Widiomatic-parentheses"
+
+@implementation RouteResponse {
+  NSMutableDictionary *headers;
+  HTTPResponseProxy *proxy;
+}
+
+@synthesize connection;
+@synthesize headers;
+
+- (id)initWithConnection:(HTTPConnection *)theConnection {
+  if (self = [super init]) {
+    connection = theConnection;
+    headers = [[NSMutableDictionary alloc] init];
+    proxy = [[HTTPResponseProxy alloc] init];
+  }
+  return self;
+}
+
+- (NSObject <HTTPResponse>*)response {
+  return proxy.response;
+}
+
+- (void)setResponse:(NSObject <HTTPResponse>*)response {
+  proxy.response = response;
+}
+
+- (NSObject <HTTPResponse>*)proxiedResponse {
+  if (proxy.response != nil || proxy.customStatus != 0 || [headers count] > 0) {
+    return proxy;
+  }
+  
+  return nil;
+}
+
+- (NSInteger)statusCode {
+  return proxy.status;
+}
+
+- (void)setStatusCode:(NSInteger)status {
+  proxy.status = status;
+}
+
+- (void)setHeader:(NSString *)field value:(NSString *)value {
+  [headers setObject:value forKey:field];
+}
+
+- (void)respondWithString:(NSString *)string {
+  [self respondWithString:string encoding:NSUTF8StringEncoding];
+}
+
+- (void)respondWithString:(NSString *)string encoding:(NSStringEncoding)encoding {
+  [self respondWithData:[string dataUsingEncoding:encoding]];
+}
+
+- (void)respondWithData:(NSData *)data {
+  self.response = [[HTTPDataResponse alloc] initWithData:data];
+}
+
+@end

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Vendor/RoutingHTTPServer/RoutingConnection.h

@@ -0,0 +1,5 @@
+#import <Foundation/Foundation.h>
+#import "HTTPConnection.h"
+
+@interface RoutingConnection : HTTPConnection
+@end

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Vendor/RoutingHTTPServer/RoutingConnection.m

@@ -0,0 +1,142 @@
+#import "RoutingConnection.h"
+#import "RoutingHTTPServer.h"
+#import "HTTPMessage.h"
+#import "HTTPResponseProxy.h"
+
+#pragma clang diagnostic ignored "-Wdirect-ivar-access"
+#pragma clang diagnostic ignored "-Widiomatic-parentheses"
+#pragma clang diagnostic ignored "-Wundeclared-selector"
+
+@implementation RoutingConnection {
+  __unsafe_unretained RoutingHTTPServer *http;
+  NSDictionary *headers;
+}
+
+- (id)initWithAsyncSocket:(GCDAsyncSocket *)newSocket configuration:(HTTPConfig *)aConfig {
+  if (self = [super initWithAsyncSocket:newSocket configuration:aConfig]) {
+    NSAssert([config.server isKindOfClass:[RoutingHTTPServer class]],
+             @"A RoutingConnection is being used with a server that is not a %@",
+             NSStringFromClass([RoutingHTTPServer class]));
+    
+    http = (RoutingHTTPServer *)config.server;
+  }
+  return self;
+}
+
+- (BOOL)supportsMethod:(NSString *)method atPath:(NSString *)path {
+  
+  if ([http supportsMethod:method])
+    return YES;
+  
+  return [super supportsMethod:method atPath:path];
+}
+
+- (BOOL)shouldHandleRequestForMethod:(NSString *)method atPath:(NSString *)path {
+  // The default implementation is strict about the use of Content-Length. Either
+  // a given method + path combination must *always* include data or *never*
+  // include data. The routing connection is lenient, a POST that sometimes does
+  // not include data or a GET that sometimes does is fine. It is up to the route
+  // implementations to decide how to handle these situations.
+  return YES;
+}
+
+- (void)processBodyData:(NSData *)postDataChunk {
+  BOOL result = [request appendData:postDataChunk];
+  if (!result) {
+    // TODO: Log
+  }
+}
+
+- (NSObject<HTTPResponse> *)httpResponseForMethod:(NSString *)method URI:(NSString *)path {
+  NSURL *url = [request url];
+  NSString *query = nil;
+  NSDictionary *params = [NSDictionary dictionary];
+  headers = nil;
+  
+  if (url) {
+    path = [url path]; // Strip the query string from the path
+    query = [url query];
+    if (query) {
+      params = [self parseParams:query];
+    }
+  }
+  
+  RouteResponse *response = [http routeMethod:method withPath:path parameters:params request:request connection:self];
+  if (response != nil) {
+    headers = response.headers;
+    return response.proxiedResponse;
+  }
+  
+  // Set a MIME type for static files if possible
+  NSObject<HTTPResponse> *staticResponse = [super httpResponseForMethod:method URI:path];
+  if (staticResponse && [staticResponse respondsToSelector:@selector(filePath)]) {
+    NSString *mimeType = [http mimeTypeForPath:[staticResponse performSelector:@selector(filePath)]];
+    if (mimeType) {
+      headers = [NSDictionary dictionaryWithObject:mimeType forKey:@"Content-Type"];
+    }
+  }
+  return staticResponse;
+}
+
+- (void)responseHasAvailableData:(NSObject<HTTPResponse> *)sender {
+  HTTPResponseProxy *proxy = (HTTPResponseProxy *)httpResponse;
+  if (proxy.response == sender) {
+    [super responseHasAvailableData:httpResponse];
+  }
+}
+
+- (void)responseDidAbort:(NSObject<HTTPResponse> *)sender {
+  HTTPResponseProxy *proxy = (HTTPResponseProxy *)httpResponse;
+  if (proxy.response == sender) {
+    [super responseDidAbort:httpResponse];
+  }
+}
+
+- (void)setHeadersForResponse:(HTTPMessage *)response isError:(BOOL)isError {
+  [http.defaultHeaders enumerateKeysAndObjectsUsingBlock:^(id field, id value, BOOL *stop) {
+    [response setHeaderField:field value:value];
+  }];
+  
+  if (headers && !isError) {
+    [headers enumerateKeysAndObjectsUsingBlock:^(id field, id value, BOOL *stop) {
+      [response setHeaderField:field value:value];
+    }];
+  }
+  
+  // Set the connection header if not already specified
+  NSString *connection = [response headerField:@"Connection"];
+  if (!connection) {
+    connection = [self shouldDie] ? @"close" : @"keep-alive";
+    [response setHeaderField:@"Connection" value:connection];
+  }
+}
+
+- (NSData *)preprocessResponse:(HTTPMessage *)response {
+  [self setHeadersForResponse:response isError:NO];
+  return [super preprocessResponse:response];
+}
+
+- (NSData *)preprocessErrorResponse:(HTTPMessage *)response {
+  [self setHeadersForResponse:response isError:YES];
+  return [super preprocessErrorResponse:response];
+}
+
+- (BOOL)shouldDie {
+  __block BOOL shouldDie = [super shouldDie];
+  
+  // Allow custom headers to determine if the connection should be closed
+  if (!shouldDie && headers) {
+    [headers enumerateKeysAndObjectsUsingBlock:^(id field, id value, BOOL *stop) {
+      if ([field caseInsensitiveCompare:@"connection"] == NSOrderedSame) {
+        if ([value caseInsensitiveCompare:@"close"] == NSOrderedSame) {
+          shouldDie = YES;
+        }
+        *stop = YES;
+      }
+    }];
+  }
+  
+  return shouldDie;
+}
+
+@end

package/drivers/ios/WebDriverAgent/WebDriverAgentLib/Vendor/RoutingHTTPServer/RoutingHTTPServer.h

@@ -0,0 +1,55 @@
+#import <Foundation/Foundation.h>
+
+//! Project version number for Peertalk.
+FOUNDATION_EXPORT double RoutingHTTPServerVersionNumber;
+
+//! Project version string for Peertalk.
+FOUNDATION_EXPORT const unsigned char RoutingHTTPServerVersionString[];
+
+#import "HTTPServer.h"
+#import "HTTPConnection.h"
+#import "HTTPResponse.h"
+#import "RouteResponse.h"
+#import "RouteRequest.h"
+#import "RoutingConnection.h"
+
+#import "GCDAsyncSocket.h"
+
+typedef void (^RequestHandler)(RouteRequest *request, RouteResponse *response);
+
+@interface RoutingHTTPServer : HTTPServer
+
+@property (nonatomic, readonly) NSDictionary *defaultHeaders;
+
+// Specifies headers that will be set on every response.
+// These headers can be overridden by RouteResponses.
+- (void)setDefaultHeaders:(NSDictionary *)headers;
+- (void)setDefaultHeader:(NSString *)field value:(NSString *)value;
+
+// Returns the dispatch queue on which routes are processed.
+// By default this is NULL and routes are processed on CocoaHTTPServer's
+// connection queue. You can specify a queue to process routes on, such as
+// dispatch_get_main_queue() to process all routes on the main thread.
+- (dispatch_queue_t)routeQueue;
+- (void)setRouteQueue:(dispatch_queue_t)queue;
+
+- (NSDictionary *)mimeTypes;
+- (void)setMIMETypes:(NSDictionary *)types;
+- (void)setMIMEType:(NSString *)type forExtension:(NSString *)ext;
+- (NSString *)mimeTypeForPath:(NSString *)path;
+
+// Convenience methods. Yes I know, this is Cocoa and we don't use convenience
+// methods because typing lengthy primitives over and over and over again is
+// elegant with the beauty and the poetry. These are just, you know, here.
+- (void)get:(NSString *)path withBlock:(RequestHandler)block;
+- (void)post:(NSString *)path withBlock:(RequestHandler)block;
+- (void)put:(NSString *)path withBlock:(RequestHandler)block;
+- (void)delete:(NSString *)path withBlock:(RequestHandler)block;
+
+- (void)handleMethod:(NSString *)method withPath:(NSString *)path block:(RequestHandler)block;
+- (void)handleMethod:(NSString *)method withPath:(NSString *)path target:(id)target selector:(SEL)selector;
+
+- (BOOL)supportsMethod:(NSString *)method;
+- (RouteResponse *)routeMethod:(NSString *)method withPath:(NSString *)path parameters:(NSDictionary *)params request:(HTTPMessage *)request connection:(HTTPConnection *)connection;
+
+@end