Repair to Code Final Commit

Task Master/Pods/GoogleToolboxForMac/Foundation/GTMNSData+zlib.h

@@ -0,0 +1,199 @@
+//
+//  GTMNSData+zlib.h
+//
+//  Copyright 2007-2008 Google Inc.
+//
+//  Licensed under the Apache License, Version 2.0 (the "License"); you may not
+//  use this file except in compliance with the License.  You may obtain a copy
+//  of the License at
+//
+//  http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+//  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+//  License for the specific language governing permissions and limitations under
+//  the License.
+//
+
+#import <Foundation/Foundation.h>
+#import "GTMDefines.h"
+
+/// Helpers for dealing w/ zlib inflate/deflate calls.
+@interface NSData (GTMZLibAdditions)
+
+// NOTE: For 64bit, none of these apis handle input sizes >32bits, they will
+// return nil when given such data.  To handle data of that size you really
+// should be streaming it rather then doing it all in memory.
+
+#pragma mark Gzip Compression
+
+/// Return an autoreleased NSData w/ the result of gzipping the bytes.
+//
+//  Uses the default compression level.
++ (NSData *)gtm_dataByGzippingBytes:(const void *)bytes
+                             length:(NSUInteger)length;
++ (NSData *)gtm_dataByGzippingBytes:(const void *)bytes
+                             length:(NSUInteger)length
+                              error:(NSError **)error;
+
+/// Return an autoreleased NSData w/ the result of gzipping the payload of |data|.
+//
+//  Uses the default compression level.
++ (NSData *)gtm_dataByGzippingData:(NSData *)data __attribute__((deprecated("Use error variant")));
++ (NSData *)gtm_dataByGzippingData:(NSData *)data
+                             error:(NSError **)error;
+
+/// Return an autoreleased NSData w/ the result of gzipping the bytes using |level| compression level.
+//
+// |level| can be 1-9, any other values will be clipped to that range.
++ (NSData *)gtm_dataByGzippingBytes:(const void *)bytes
+                             length:(NSUInteger)length
+                   compressionLevel:(int)level __attribute__((deprecated("Use error variant")));
++ (NSData *)gtm_dataByGzippingBytes:(const void *)bytes
+                             length:(NSUInteger)length
+                   compressionLevel:(int)level
+                              error:(NSError **)error;
+
+/// Return an autoreleased NSData w/ the result of gzipping the payload of |data| using |level| compression level.
++ (NSData *)gtm_dataByGzippingData:(NSData *)data
+                  compressionLevel:(int)level __attribute__((deprecated("Use error variant")));
++ (NSData *)gtm_dataByGzippingData:(NSData *)data
+                  compressionLevel:(int)level
+                             error:(NSError **)error;
+
+#pragma mark Zlib "Stream" Compression
+
+// NOTE: deflate is *NOT* gzip.  deflate is a "zlib" stream.  pick which one
+// you really want to create.  (the inflate api will handle either)
+
+/// Return an autoreleased NSData w/ the result of deflating the bytes.
+//
+//  Uses the default compression level.
++ (NSData *)gtm_dataByDeflatingBytes:(const void *)bytes
+                              length:(NSUInteger)length __attribute__((deprecated("Use error variant")));
++ (NSData *)gtm_dataByDeflatingBytes:(const void *)bytes
+                              length:(NSUInteger)length
+                               error:(NSError **)error;
+
+/// Return an autoreleased NSData w/ the result of deflating the payload of |data|.
+//
+//  Uses the default compression level.
++ (NSData *)gtm_dataByDeflatingData:(NSData *)data __attribute__((deprecated("Use error variant")));
++ (NSData *)gtm_dataByDeflatingData:(NSData *)data
+                              error:(NSError **)error;
+
+/// Return an autoreleased NSData w/ the result of deflating the bytes using |level| compression level.
+//
+// |level| can be 1-9, any other values will be clipped to that range.
++ (NSData *)gtm_dataByDeflatingBytes:(const void *)bytes
+                              length:(NSUInteger)length
+                    compressionLevel:(int)level __attribute__((deprecated("Use error variant")));
++ (NSData *)gtm_dataByDeflatingBytes:(const void *)bytes
+                              length:(NSUInteger)length
+                    compressionLevel:(int)level
+                               error:(NSError **)error;
+
+/// Return an autoreleased NSData w/ the result of deflating the payload of |data| using |level| compression level.
++ (NSData *)gtm_dataByDeflatingData:(NSData *)data
+                   compressionLevel:(int)level __attribute__((deprecated("Use error variant")));
++ (NSData *)gtm_dataByDeflatingData:(NSData *)data
+                   compressionLevel:(int)level
+                              error:(NSError **)error;
+
+#pragma mark Uncompress of Gzip or Zlib
+
+/// Return an autoreleased NSData w/ the result of decompressing the bytes.
+//
+// The bytes to decompress can be zlib or gzip payloads.
++ (NSData *)gtm_dataByInflatingBytes:(const void *)bytes
+                              length:(NSUInteger)length __attribute__((deprecated("Use error variant")));
++ (NSData *)gtm_dataByInflatingBytes:(const void *)bytes
+                              length:(NSUInteger)length
+                               error:(NSError **)error;
+
+/// Return an autoreleased NSData w/ the result of decompressing the payload of |data|.
+//
+// The data to decompress can be zlib or gzip payloads.
++ (NSData *)gtm_dataByInflatingData:(NSData *)data __attribute__((deprecated("Use error variant")));
++ (NSData *)gtm_dataByInflatingData:(NSData *)data
+                              error:(NSError **)error;
+
+#pragma mark "Raw" Compression Support
+
+// NOTE: raw deflate is *NOT* gzip or deflate.  it does not include a header
+// of any form and should only be used within streams here an external crc/etc.
+// is done to validate the data.  The RawInflate apis can be used on data
+// processed like this.
+
+/// Return an autoreleased NSData w/ the result of *raw* deflating the bytes.
+//
+//  Uses the default compression level.
+//  *No* header is added to the resulting data.
++ (NSData *)gtm_dataByRawDeflatingBytes:(const void *)bytes
+                                 length:(NSUInteger)length __attribute__((deprecated("Use error variant")));
++ (NSData *)gtm_dataByRawDeflatingBytes:(const void *)bytes
+                                 length:(NSUInteger)length
+                                  error:(NSError **)error;
+
+/// Return an autoreleased NSData w/ the result of *raw* deflating the payload of |data|.
+//
+//  Uses the default compression level.
+//  *No* header is added to the resulting data.
++ (NSData *)gtm_dataByRawDeflatingData:(NSData *)data __attribute__((deprecated("Use error variant")));
++ (NSData *)gtm_dataByRawDeflatingData:(NSData *)data
+                                 error:(NSError **)error;
+
+/// Return an autoreleased NSData w/ the result of *raw* deflating the bytes using |level| compression level.
+//
+// |level| can be 1-9, any other values will be clipped to that range.
+//  *No* header is added to the resulting data.
++ (NSData *)gtm_dataByRawDeflatingBytes:(const void *)bytes
+                                 length:(NSUInteger)length
+                       compressionLevel:(int)level __attribute__((deprecated("Use error variant")));
++ (NSData *)gtm_dataByRawDeflatingBytes:(const void *)bytes
+                                 length:(NSUInteger)length
+                       compressionLevel:(int)level
+                                  error:(NSError **)error;
+
+/// Return an autoreleased NSData w/ the result of *raw* deflating the payload of |data| using |level| compression level.
+//  *No* header is added to the resulting data.
++ (NSData *)gtm_dataByRawDeflatingData:(NSData *)data
+                      compressionLevel:(int)level __attribute__((deprecated("Use error variant")));
++ (NSData *)gtm_dataByRawDeflatingData:(NSData *)data
+                      compressionLevel:(int)level
+                                 error:(NSError **)error;
+
+/// Return an autoreleased NSData w/ the result of *raw* decompressing the bytes.
+//
+// The data to decompress, it should *not* have any header (zlib nor gzip).
++ (NSData *)gtm_dataByRawInflatingBytes:(const void *)bytes
+                                 length:(NSUInteger)length __attribute__((deprecated("Use error variant")));
++ (NSData *)gtm_dataByRawInflatingBytes:(const void *)bytes
+                                 length:(NSUInteger)length
+                                  error:(NSError **)error;
+
+/// Return an autoreleased NSData w/ the result of *raw* decompressing the payload of |data|.
+//
+// The data to decompress, it should *not* have any header (zlib nor gzip).
++ (NSData *)gtm_dataByRawInflatingData:(NSData *)data __attribute__((deprecated("Use error variant")));
++ (NSData *)gtm_dataByRawInflatingData:(NSData *)data
+                                 error:(NSError **)error;
+
+@end
+
+FOUNDATION_EXPORT NSString *const GTMNSDataZlibErrorDomain;
+FOUNDATION_EXPORT NSString *const GTMNSDataZlibErrorKey;  // NSNumber
+FOUNDATION_EXPORT NSString *const GTMNSDataZlibRemainingBytesKey;  // NSNumber
+
+typedef NS_ENUM(NSInteger, GTMNSDataZlibError) {
+  GTMNSDataZlibErrorGreaterThan32BitsToCompress = 1024,
+  // An internal zlib error.
+  // GTMNSDataZlibErrorKey will contain the error value.
+  // NSLocalizedDescriptionKey may contain an error string from zlib.
+  // Look in zlib.h for list of errors.
+  GTMNSDataZlibErrorInternal,
+  // There was left over data in the buffer that was not used.
+  // GTMNSDataZlibRemainingBytesKey will contain number of remaining bytes.
+  GTMNSDataZlibErrorDataRemaining
+};

Task Master/Pods/GoogleToolboxForMac/Foundation/GTMNSData+zlib.m

@@ -0,0 +1,531 @@
+//
+//  GTMNSData+zlib.m
+//
+//  Copyright 2007-2008 Google Inc.
+//
+//  Licensed under the Apache License, Version 2.0 (the "License"); you may not
+//  use this file except in compliance with the License.  You may obtain a copy
+//  of the License at
+//
+//  http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+//  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+//  License for the specific language governing permissions and limitations under
+//  the License.
+//
+
+#import "GTMNSData+zlib.h"
+#import <zlib.h>
+#import "GTMDefines.h"
+
+#define kChunkSize 1024
+
+NSString *const GTMNSDataZlibErrorDomain = @"com.google.GTMNSDataZlibErrorDomain";
+NSString *const GTMNSDataZlibErrorKey = @"GTMNSDataZlibErrorKey";
+NSString *const GTMNSDataZlibRemainingBytesKey = @"GTMNSDataZlibRemainingBytesKey";
+
+typedef enum {
+  CompressionModeZlib,
+  CompressionModeGzip,
+  CompressionModeRaw,
+} CompressionMode;
+
+@interface NSData (GTMZlibAdditionsPrivate)
++ (NSData *)gtm_dataByCompressingBytes:(const void *)bytes
+                                length:(NSUInteger)length
+                      compressionLevel:(int)level
+                                  mode:(CompressionMode)mode
+                                 error:(NSError **)error;
++ (NSData *)gtm_dataByInflatingBytes:(const void *)bytes
+                              length:(NSUInteger)length
+                           isRawData:(BOOL)isRawData
+                               error:(NSError **)error;
+@end
+
+@implementation NSData (GTMZlibAdditionsPrivate)
+
++ (NSData *)gtm_dataByCompressingBytes:(const void *)bytes
+                                length:(NSUInteger)length
+                      compressionLevel:(int)level
+                                  mode:(CompressionMode)mode
+                                 error:(NSError **)error {
+  if (!bytes || !length) {
+    return nil;
+  }
+
+#if defined(__LP64__) && __LP64__
+  // Don't support > 32bit length for 64 bit, see note in header.
+  if (length > UINT_MAX) {
+    if (error) {
+      *error = [NSError errorWithDomain:GTMNSDataZlibErrorDomain
+                                   code:GTMNSDataZlibErrorGreaterThan32BitsToCompress
+                               userInfo:nil];
+    }
+    return nil;
+  }
+#endif
+
+  if (level == Z_DEFAULT_COMPRESSION) {
+    // the default value is actually outside the range, so we have to let it
+    // through specifically.
+  } else if (level < Z_BEST_SPEED) {
+    level = Z_BEST_SPEED;
+  } else if (level > Z_BEST_COMPRESSION) {
+    level = Z_BEST_COMPRESSION;
+  }
+
+  z_stream strm;
+  bzero(&strm, sizeof(z_stream));
+
+  int memLevel = 8; // the default
+  int windowBits = 15; // the default
+  switch (mode) {
+    case CompressionModeZlib:
+      // nothing to do
+      break;
+
+    case CompressionModeGzip:
+      windowBits += 16; // enable gzip header instead of zlib header
+      break;
+
+    case CompressionModeRaw:
+      windowBits *= -1; // Negative to mean no header.
+      break;
+  }
+  int retCode;
+  if ((retCode = deflateInit2(&strm, level, Z_DEFLATED, windowBits,
+                              memLevel, Z_DEFAULT_STRATEGY)) != Z_OK) {
+    // COV_NF_START - no real way to force this in a unittest (we guard all args)
+    if (error) {
+      NSDictionary *userInfo = [NSDictionary dictionaryWithObject:[NSNumber numberWithInt:retCode]
+                                                           forKey:GTMNSDataZlibErrorKey];
+      *error = [NSError errorWithDomain:GTMNSDataZlibErrorDomain
+                                   code:GTMNSDataZlibErrorInternal
+                               userInfo:userInfo];
+    }
+    return nil;
+    // COV_NF_END
+  }
+
+  // hint the size at 1/4 the input size
+  NSMutableData *result = [NSMutableData dataWithCapacity:(length/4)];
+  unsigned char output[kChunkSize];
+
+  // setup the input
+  strm.avail_in = (unsigned int)length;
+  strm.next_in = (unsigned char*)bytes;
+
+  // loop to collect the data
+  do {
+    // update what we're passing in
+    strm.avail_out = kChunkSize;
+    strm.next_out = output;
+    retCode = deflate(&strm, Z_FINISH);
+    if ((retCode != Z_OK) && (retCode != Z_STREAM_END)) {
+      // COV_NF_START - no real way to force this in a unittest
+      // (in inflate, we can feed bogus/truncated data to test, but an error
+      // here would be some internal issue w/in zlib, and there isn't any real
+      // way to test it)
+      if (error) {
+        NSDictionary *userInfo = [NSDictionary dictionaryWithObject:[NSNumber numberWithInt:retCode]
+                                                             forKey:GTMNSDataZlibErrorKey];
+        *error = [NSError errorWithDomain:GTMNSDataZlibErrorDomain
+                                     code:GTMNSDataZlibErrorInternal
+                                 userInfo:userInfo];
+      }
+      deflateEnd(&strm);
+      return nil;
+      // COV_NF_END
+    }
+    // collect what we got
+    unsigned gotBack = kChunkSize - strm.avail_out;
+    if (gotBack > 0) {
+      [result appendBytes:output length:gotBack];
+    }
+
+  } while (retCode == Z_OK);
+
+  // if the loop exits, we used all input and the stream ended
+  _GTMDevAssert(strm.avail_in == 0,
+                @"thought we finished deflate w/o using all input, %u bytes left",
+                strm.avail_in);
+  _GTMDevAssert(retCode == Z_STREAM_END,
+                @"thought we finished deflate w/o getting a result of stream end, code %d",
+                retCode);
+
+  // clean up
+  deflateEnd(&strm);
+
+  return result;
+} // gtm_dataByCompressingBytes:length:compressionLevel:useGzip:
+
++ (NSData *)gtm_dataByInflatingBytes:(const void *)bytes
+                              length:(NSUInteger)length
+                           isRawData:(BOOL)isRawData
+                               error:(NSError **)error {
+  if (!bytes || !length) {
+    return nil;
+  }
+
+#if defined(__LP64__) && __LP64__
+  // Don't support > 32bit length for 64 bit, see note in header.
+  if (length > UINT_MAX) {
+    return nil;
+  }
+#endif
+
+  z_stream strm;
+  bzero(&strm, sizeof(z_stream));
+
+  // setup the input
+  strm.avail_in = (unsigned int)length;
+  strm.next_in = (unsigned char*)bytes;
+
+  int windowBits = 15; // 15 to enable any window size
+  if (isRawData) {
+    windowBits *= -1; // make it negative to signal no header.
+  } else {
+    windowBits += 32; // and +32 to enable zlib or gzip header detection.
+  }
+
+  int retCode;
+  if ((retCode = inflateInit2(&strm, windowBits)) != Z_OK) {
+    // COV_NF_START - no real way to force this in a unittest (we guard all args)
+    if (error) {
+      NSDictionary *userInfo = [NSDictionary dictionaryWithObject:[NSNumber numberWithInt:retCode]
+                                                           forKey:GTMNSDataZlibErrorKey];
+      *error = [NSError errorWithDomain:GTMNSDataZlibErrorDomain
+                                   code:GTMNSDataZlibErrorInternal
+                               userInfo:userInfo];
+    }
+    return nil;
+    // COV_NF_END
+  }
+
+  // hint the size at 4x the input size
+  NSMutableData *result = [NSMutableData dataWithCapacity:(length*4)];
+  unsigned char output[kChunkSize];
+
+  // loop to collect the data
+  do {
+    // update what we're passing in
+    strm.avail_out = kChunkSize;
+    strm.next_out = output;
+    retCode = inflate(&strm, Z_NO_FLUSH);
+    if ((retCode != Z_OK) && (retCode != Z_STREAM_END)) {
+      if (error) {
+        NSMutableDictionary *userInfo =
+            [NSMutableDictionary dictionaryWithObject:[NSNumber numberWithInt:retCode]
+                                               forKey:GTMNSDataZlibErrorKey];
+        if (strm.msg) {
+          NSString *message = [NSString stringWithUTF8String:strm.msg];
+          if (message) {
+            [userInfo setObject:message forKey:NSLocalizedDescriptionKey];
+          }
+        }
+        *error = [NSError errorWithDomain:GTMNSDataZlibErrorDomain
+                                     code:GTMNSDataZlibErrorInternal
+                                 userInfo:userInfo];
+      }
+      inflateEnd(&strm);
+      return nil;
+    }
+    // collect what we got
+    unsigned gotBack = kChunkSize - strm.avail_out;
+    if (gotBack > 0) {
+      [result appendBytes:output length:gotBack];
+    }
+
+  } while (retCode == Z_OK);
+
+  // make sure there wasn't more data tacked onto the end of a valid compressed
+  // stream.
+  if (strm.avail_in != 0) {
+    if (error) {
+      NSDictionary *userInfo =
+          [NSDictionary dictionaryWithObject:[NSNumber numberWithUnsignedInt:strm.avail_in]
+                                      forKey:GTMNSDataZlibRemainingBytesKey];
+      *error = [NSError errorWithDomain:GTMNSDataZlibErrorDomain
+                                   code:GTMNSDataZlibErrorDataRemaining
+                               userInfo:userInfo];
+    }
+    result = nil;
+  }
+  // the only way out of the loop was by hitting the end of the stream
+  _GTMDevAssert(retCode == Z_STREAM_END,
+                @"thought we finished inflate w/o getting a result of stream end, code %d",
+                retCode);
+
+  // clean up
+  inflateEnd(&strm);
+
+  return result;
+} // gtm_dataByInflatingBytes:length:windowBits:
+
+@end
+
+
+@implementation NSData (GTMZLibAdditions)
+
++ (NSData *)gtm_dataByGzippingBytes:(const void *)bytes
+                             length:(NSUInteger)length {
+  return [self gtm_dataByGzippingBytes:bytes length:length error:NULL];
+} // gtm_dataByGzippingBytes:length:
+
++ (NSData *)gtm_dataByGzippingBytes:(const void *)bytes
+                             length:(NSUInteger)length
+                              error:(NSError **)error {
+  return [self gtm_dataByCompressingBytes:bytes
+                                   length:length
+                         compressionLevel:Z_DEFAULT_COMPRESSION
+                                     mode:CompressionModeGzip
+                                    error:error];
+} // gtm_dataByGzippingBytes:length:error:
+
++ (NSData *)gtm_dataByGzippingData:(NSData *)data {
+  return [self gtm_dataByGzippingData:data error:NULL];
+} // gtm_dataByGzippingData:
+
++ (NSData *)gtm_dataByGzippingData:(NSData *)data error:(NSError **)error {
+  return [self gtm_dataByCompressingBytes:[data bytes]
+                                   length:[data length]
+                         compressionLevel:Z_DEFAULT_COMPRESSION
+                                     mode:CompressionModeGzip
+                                    error:error];
+} // gtm_dataByGzippingData:error:
+
++ (NSData *)gtm_dataByGzippingBytes:(const void *)bytes
+                             length:(NSUInteger)length
+                   compressionLevel:(int)level {
+  return [self gtm_dataByGzippingBytes:bytes
+                                length:length
+                      compressionLevel:level
+                                 error:NULL];
+} // gtm_dataByGzippingBytes:length:level:
+
++ (NSData *)gtm_dataByGzippingBytes:(const void *)bytes
+                             length:(NSUInteger)length
+                   compressionLevel:(int)level
+                              error:(NSError **)error{
+  return [self gtm_dataByCompressingBytes:bytes
+                                   length:length
+                         compressionLevel:level
+                                     mode:CompressionModeGzip
+                                    error:error];
+} // gtm_dataByGzippingBytes:length:level:error
+
++ (NSData *)gtm_dataByGzippingData:(NSData *)data
+                  compressionLevel:(int)level {
+  return [self gtm_dataByGzippingData:data
+                     compressionLevel:level
+                                error:NULL];
+} // gtm_dataByGzippingData:level:
+
++ (NSData *)gtm_dataByGzippingData:(NSData *)data
+                  compressionLevel:(int)level
+                             error:(NSError **)error{
+  return [self gtm_dataByCompressingBytes:[data bytes]
+                                   length:[data length]
+                         compressionLevel:level
+                                     mode:CompressionModeGzip
+                                    error:error];
+} // gtm_dataByGzippingData:level:error
+
+#pragma mark -
+
++ (NSData *)gtm_dataByDeflatingBytes:(const void *)bytes
+                              length:(NSUInteger)length {
+  return [self gtm_dataByDeflatingBytes:bytes
+                                 length:length
+                                  error:NULL];
+} // gtm_dataByDeflatingBytes:length:
+
++ (NSData *)gtm_dataByDeflatingBytes:(const void *)bytes
+                              length:(NSUInteger)length
+                               error:(NSError **)error{
+  return [self gtm_dataByCompressingBytes:bytes
+                                   length:length
+                         compressionLevel:Z_DEFAULT_COMPRESSION
+                                     mode:CompressionModeZlib
+                                    error:error];
+} // gtm_dataByDeflatingBytes:length:error
+
++ (NSData *)gtm_dataByDeflatingData:(NSData *)data {
+  return [self gtm_dataByDeflatingData:data error:NULL];
+} // gtm_dataByDeflatingData:
+
++ (NSData *)gtm_dataByDeflatingData:(NSData *)data error:(NSError **)error {
+  return [self gtm_dataByCompressingBytes:[data bytes]
+                                   length:[data length]
+                         compressionLevel:Z_DEFAULT_COMPRESSION
+                                     mode:CompressionModeZlib
+                                    error:error];
+} // gtm_dataByDeflatingData:
+
++ (NSData *)gtm_dataByDeflatingBytes:(const void *)bytes
+                              length:(NSUInteger)length
+                    compressionLevel:(int)level {
+  return [self gtm_dataByDeflatingBytes:bytes
+                                 length:length
+                       compressionLevel:level
+                                  error:NULL];
+} // gtm_dataByDeflatingBytes:length:level:
+
++ (NSData *)gtm_dataByDeflatingBytes:(const void *)bytes
+                              length:(NSUInteger)length
+                    compressionLevel:(int)level
+                               error:(NSError **)error {
+  return [self gtm_dataByCompressingBytes:bytes
+                                   length:length
+                         compressionLevel:level
+                                     mode:CompressionModeZlib
+                                    error:error];
+} // gtm_dataByDeflatingBytes:length:level:error:
+
++ (NSData *)gtm_dataByDeflatingData:(NSData *)data
+                   compressionLevel:(int)level {
+  return [self gtm_dataByDeflatingData:data
+                      compressionLevel:level
+                                 error:NULL];
+} // gtm_dataByDeflatingData:level:
+
++ (NSData *)gtm_dataByDeflatingData:(NSData *)data
+                   compressionLevel:(int)level
+                              error:(NSError **)error {
+  return [self gtm_dataByCompressingBytes:[data bytes]
+                                   length:[data length]
+                         compressionLevel:level
+                                     mode:CompressionModeZlib
+                                    error:error];
+} // gtm_dataByDeflatingData:level:error:
+
+#pragma mark -
+
++ (NSData *)gtm_dataByInflatingBytes:(const void *)bytes
+                              length:(NSUInteger)length {
+  return [self gtm_dataByInflatingBytes:bytes
+                                 length:length
+                                  error:NULL];
+} // gtm_dataByInflatingBytes:length:
+
++ (NSData *)gtm_dataByInflatingBytes:(const void *)bytes
+                              length:(NSUInteger)length
+                               error:(NSError **)error {
+  return [self gtm_dataByInflatingBytes:bytes
+                                 length:length
+                              isRawData:NO
+                                  error:error];
+} // gtm_dataByInflatingBytes:length:error:
+
++ (NSData *)gtm_dataByInflatingData:(NSData *)data {
+  return [self gtm_dataByInflatingData:data error:NULL];
+} // gtm_dataByInflatingData:
+
++ (NSData *)gtm_dataByInflatingData:(NSData *)data
+                              error:(NSError **)error {
+  return [self gtm_dataByInflatingBytes:[data bytes]
+                                 length:[data length]
+                              isRawData:NO
+                                  error:error];
+} // gtm_dataByInflatingData:
+
+#pragma mark -
+
++ (NSData *)gtm_dataByRawDeflatingBytes:(const void *)bytes
+                                 length:(NSUInteger)length {
+  return [self gtm_dataByRawDeflatingBytes:(const void *)bytes
+                                    length:(NSUInteger)length
+                                     error:NULL];
+} // gtm_dataByRawDeflatingBytes:length:
+
++ (NSData *)gtm_dataByRawDeflatingBytes:(const void *)bytes
+                                 length:(NSUInteger)length
+                                  error:(NSError **)error {
+  return [self gtm_dataByCompressingBytes:bytes
+                                   length:length
+                         compressionLevel:Z_DEFAULT_COMPRESSION
+                                     mode:CompressionModeRaw
+                                    error:error];
+} // gtm_dataByRawDeflatingBytes:length:error:
+
++ (NSData *)gtm_dataByRawDeflatingData:(NSData *)data {
+  return [self gtm_dataByRawDeflatingData:data error:NULL];
+} // gtm_dataByRawDeflatingData:
+
++ (NSData *)gtm_dataByRawDeflatingData:(NSData *)data error:(NSError **)error {
+  return [self gtm_dataByCompressingBytes:[data bytes]
+                                   length:[data length]
+                         compressionLevel:Z_DEFAULT_COMPRESSION
+                                     mode:CompressionModeRaw
+                                    error:error];
+} // gtm_dataByRawDeflatingData:error:
+
++ (NSData *)gtm_dataByRawDeflatingBytes:(const void *)bytes
+                                 length:(NSUInteger)length
+                       compressionLevel:(int)level {
+  return [self gtm_dataByRawDeflatingBytes:bytes
+                                    length:length
+                          compressionLevel:level
+                                     error:NULL];
+} // gtm_dataByRawDeflatingBytes:length:compressionLevel:
+
++ (NSData *)gtm_dataByRawDeflatingBytes:(const void *)bytes
+                                 length:(NSUInteger)length
+                       compressionLevel:(int)level
+                                  error:(NSError **)error{
+  return [self gtm_dataByCompressingBytes:bytes
+                                   length:length
+                         compressionLevel:level
+                                     mode:CompressionModeRaw
+                                    error:error];
+} // gtm_dataByRawDeflatingBytes:length:compressionLevel:error:
+
++ (NSData *)gtm_dataByRawDeflatingData:(NSData *)data
+                      compressionLevel:(int)level {
+  return [self gtm_dataByRawDeflatingData:data
+                         compressionLevel:level
+                                    error:NULL];
+} // gtm_dataByRawDeflatingData:compressionLevel:
+
++ (NSData *)gtm_dataByRawDeflatingData:(NSData *)data
+                      compressionLevel:(int)level
+                                 error:(NSError **)error {
+  return [self gtm_dataByCompressingBytes:[data bytes]
+                                   length:[data length]
+                         compressionLevel:level
+                                     mode:CompressionModeRaw
+                                    error:error];
+} // gtm_dataByRawDeflatingData:compressionLevel:error:
+
++ (NSData *)gtm_dataByRawInflatingBytes:(const void *)bytes
+                                 length:(NSUInteger)length {
+  return [self gtm_dataByInflatingBytes:bytes
+                                 length:length
+                                  error:NULL];
+} // gtm_dataByRawInflatingBytes:length:
+
++ (NSData *)gtm_dataByRawInflatingBytes:(const void *)bytes
+                                 length:(NSUInteger)length
+                                  error:(NSError **)error{
+  return [self gtm_dataByInflatingBytes:bytes
+                                 length:length
+                              isRawData:YES
+                                  error:error];
+} // gtm_dataByRawInflatingBytes:length:error:
+
++ (NSData *)gtm_dataByRawInflatingData:(NSData *)data {
+  return [self gtm_dataByRawInflatingData:data
+                                    error:NULL];
+} // gtm_dataByRawInflatingData:
+
++ (NSData *)gtm_dataByRawInflatingData:(NSData *)data
+                                 error:(NSError **)error {
+  return [self gtm_dataByInflatingBytes:[data bytes]
+                                 length:[data length]
+                              isRawData:YES
+                                  error:error];
+} // gtm_dataByRawInflatingData:error:
+
+@end

Task Master/Pods/GoogleToolboxForMac/Foundation/GTMNSDictionary+URLArguments.h

@@ -0,0 +1,40 @@
+//
+//  GTMNSDictionary+URLArguments.h
+//
+//  Copyright 2006-2008 Google Inc.
+//
+//  Licensed under the Apache License, Version 2.0 (the "License"); you may not
+//  use this file except in compliance with the License.  You may obtain a copy
+//  of the License at
+// 
+//  http://www.apache.org/licenses/LICENSE-2.0
+// 
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+//  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+//  License for the specific language governing permissions and limitations under
+//  the License.
+//
+
+#import <Foundation/Foundation.h>
+
+/// Utility for building a URL or POST argument string.
+@interface NSDictionary (GTMNSDictionaryURLArgumentsAdditions)
+
+/// Returns a dictionary of the decoded key-value pairs in a http arguments
+/// string of the form key1=value1&key2=value2&...&keyN=valueN.
+/// Keys and values will be unescaped automatically.
+/// Only the first value for a repeated key is returned.
+///
+/// NOTE: Apps targeting iOS 8 or OS X 10.10 and later should use
+///       NSURLComponents and NSURLQueryItem to create URLs with
+///       query arguments instead of using these category methods.
++ (NSDictionary *)gtm_dictionaryWithHttpArgumentsString:(NSString *)argString;
+
+/// Gets a string representation of the dictionary in the form
+/// key1=value1&key2=value2&...&keyN=valueN, suitable for use as either
+/// URL arguments (after a '?') or POST body. Keys and values will be escaped
+/// automatically, so should be unescaped in the dictionary.
+- (NSString *)gtm_httpArgumentsString;
+
+@end

Task Master/Pods/GoogleToolboxForMac/Foundation/GTMNSDictionary+URLArguments.m

@@ -0,0 +1,77 @@
+//
+//  GTMNSDictionary+URLArguments.m
+//
+//  Copyright 2006-2008 Google Inc.
+//
+//  Licensed under the Apache License, Version 2.0 (the "License"); you may not
+//  use this file except in compliance with the License.  You may obtain a copy
+//  of the License at
+//
+//  http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+//  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+//  License for the specific language governing permissions and limitations under
+//  the License.
+//
+
+#import "GTMNSDictionary+URLArguments.h"
+#import "GTMNSString+URLArguments.h"
+#import "GTMMethodCheck.h"
+#import "GTMDefines.h"
+
+
+// Export a nonsense symbol to suppress a libtool warning when this is linked alone in a static lib.
+__attribute__((visibility("default")))
+    char GTMNSDictionaryURLArgumentsExportToSuppressLibToolWarning = 0;
+
+
+@implementation NSDictionary (GTMNSDictionaryURLArgumentsAdditions)
+
+GTM_METHOD_CHECK(NSString, gtm_stringByEscapingForURLArgument);
+GTM_METHOD_CHECK(NSString, gtm_stringByUnescapingFromURLArgument);
+
++ (NSDictionary *)gtm_dictionaryWithHttpArgumentsString:(NSString *)argString {
+  NSMutableDictionary* ret = [NSMutableDictionary dictionary];
+  NSArray* components = [argString componentsSeparatedByString:@"&"];
+  NSString* component;
+  // Use reverse order so that the first occurrence of a key replaces
+  // those subsequent.
+  for (component in [components reverseObjectEnumerator]) {
+    if ([component length] == 0)
+      continue;
+    NSRange pos = [component rangeOfString:@"="];
+    NSString *key;
+    NSString *val;
+    if (pos.location == NSNotFound) {
+      key = [component gtm_stringByUnescapingFromURLArgument];
+      val = @"";
+    } else {
+      key = [[component substringToIndex:pos.location]
+             gtm_stringByUnescapingFromURLArgument];
+      val = [[component substringFromIndex:pos.location + pos.length]
+             gtm_stringByUnescapingFromURLArgument];
+    }
+    // gtm_stringByUnescapingFromURLArgument returns nil on invalid UTF8
+    // and NSMutableDictionary raises an exception when passed nil values.
+    if (!key) key = @"";
+    if (!val) val = @"";
+    [ret setObject:val forKey:key];
+  }
+  return ret;
+}
+
+- (NSString *)gtm_httpArgumentsString {
+  NSMutableArray* arguments = [NSMutableArray arrayWithCapacity:[self count]];
+  NSString* key;
+  for (key in self) {
+    [arguments addObject:[NSString stringWithFormat:@"%@=%@",
+                          [key gtm_stringByEscapingForURLArgument],
+                          [[[self objectForKey:key] description] gtm_stringByEscapingForURLArgument]]];
+  }
+
+  return [arguments componentsJoinedByString:@"&"];
+}
+
+@end

Task Master/Pods/GoogleToolboxForMac/Foundation/GTMNSString+URLArguments.h

@@ -0,0 +1,45 @@
+//
+//  GTMNSString+URLArguments.h
+//
+//  Copyright 2006-2008 Google Inc.
+//
+//  Licensed under the Apache License, Version 2.0 (the "License"); you may not
+//  use this file except in compliance with the License.  You may obtain a copy
+//  of the License at
+// 
+//  http://www.apache.org/licenses/LICENSE-2.0
+// 
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+//  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+//  License for the specific language governing permissions and limitations under
+//  the License.
+//
+
+#import <Foundation/Foundation.h>
+
+/// Utilities for encoding and decoding URL arguments.
+@interface NSString (GTMNSStringURLArgumentsAdditions)
+
+/// Returns a string that is escaped properly to be a URL argument.
+///
+/// This differs from stringByAddingPercentEscapesUsingEncoding: in that it
+/// will escape all the reserved characters (per RFC 3986
+/// <http://www.ietf.org/rfc/rfc3986.txt>) which
+/// stringByAddingPercentEscapesUsingEncoding would leave.
+///
+/// This will also escape '%', so this should not be used on a string that has
+/// already been escaped unless double-escaping is the desired result.
+///
+/// NOTE: Apps targeting iOS 8 or OS X 10.10 and later should use
+///       NSURLComponents and NSURLQueryItem to create properly-escaped
+///       URLs instead of using these category methods.
+- (NSString*)gtm_stringByEscapingForURLArgument;
+
+/// Returns the unescaped version of a URL argument
+///
+/// This has the same behavior as stringByReplacingPercentEscapesUsingEncoding:,
+/// except that it will also convert '+' to space.
+- (NSString*)gtm_stringByUnescapingFromURLArgument;
+
+@end

Task Master/Pods/GoogleToolboxForMac/Foundation/GTMNSString+URLArguments.m

@@ -0,0 +1,48 @@
+//
+//  GTMNSString+URLArguments.m
+//
+//  Copyright 2006-2008 Google Inc.
+//
+//  Licensed under the Apache License, Version 2.0 (the "License"); you may not
+//  use this file except in compliance with the License.  You may obtain a copy
+//  of the License at
+//
+//  http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+//  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+//  License for the specific language governing permissions and limitations under
+//  the License.
+//
+
+#import "GTMNSString+URLArguments.h"
+
+@implementation NSString (GTMNSStringURLArgumentsAdditions)
+
+- (NSString *)gtm_stringByEscapingForURLArgument {
+  // Encode all the reserved characters, per RFC 3986
+  // (<http://www.ietf.org/rfc/rfc3986.txt>)
+  CFStringRef escaped =
+    CFURLCreateStringByAddingPercentEscapes(kCFAllocatorDefault,
+                                            (CFStringRef)self,
+                                            NULL,
+                                            (CFStringRef)@"!*'();:@&=+$,/?%#[]",
+                                            kCFStringEncodingUTF8);
+#if defined(__has_feature) && __has_feature(objc_arc)
+  return CFBridgingRelease(escaped);
+#else
+  return [(NSString *)escaped autorelease];
+#endif
+}
+
+- (NSString *)gtm_stringByUnescapingFromURLArgument {
+  NSMutableString *resultString = [NSMutableString stringWithString:self];
+  [resultString replaceOccurrencesOfString:@"+"
+                                withString:@" "
+                                   options:NSLiteralSearch
+                                     range:NSMakeRange(0, [resultString length])];
+  return [resultString stringByReplacingPercentEscapesUsingEncoding:NSUTF8StringEncoding];
+}
+
+@end