Merge branch '0.10.2' of github.com:wkh237/react-native-fetch-blob into 0.10.2

src/ios/RNFetchBlobFS.h

 #define RNFetchBlobFS_h
 
 #import "RNFetchBlob.h"
-
 #import <Foundation/Foundation.h>
 
 #if __has_include(<React/RCTAssert.h>)

src/ios/RNFetchBlobFS.m

 
 // static member getter
 + (NSArray *) getFileStreams {
-    
+
     if(fileStreams == nil)
         fileStreams = [[NSMutableDictionary alloc] init];
     return fileStreams;
 }
 
 + (NSString *) getTempPath {
-    
+
     return NSTemporaryDirectory();
 }
 
 + (NSString *) getTempPath:(NSString*)taskId withExtension:(NSString *)ext {
-    
+
     NSString * documentDir = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) firstObject];
     NSString * filename = [NSString stringWithFormat:@"/RNFetchBlob_tmp/RNFetchBlobTmp_%@", taskId];
     if(ext != nil)
     return tempPath;
 }
 
-#pragma margk - readStream 
+#pragma margk - readStream
 
 + (void) readStream:(NSString *)uri
            encoding:(NSString * )encoding
           bridgeRef:(RCTBridge *)bridgeRef
 {
     [[self class] getPathFromUri:uri completionHandler:^(NSString *path, ALAssetRepresentation *asset) {
-    
+
         __block RCTEventDispatcher * event = bridgeRef.eventDispatcher;
         __block int read = 0;
         __block int backoff = tick *1000;
             // release buffer
             if(buffer != nil)
                 free(buffer);
-            
+
         }
         @catch (NSError * err)
         {
             NSDictionary * payload = @{ @"event": FS_EVENT_END, @"detail": @"" };
             [event sendDeviceEventWithName:streamId body:payload];
         }
-        
+
     }];
-    
-    
+
+
 }
 
 // send read stream chunks via native event emitter
         NSDictionary * payload = @{ @"event": FS_EVENT_DATA,  @"detail" : asciiArray };
         [event sendDeviceEventWithName:streamId body:payload];
     }
-    
-    
+
+
 }
 
 # pragma write file from file
         }
         else if(asset != nil)
         {
-            
+
             __block NSOutputStream * os = [[NSOutputStream alloc] initToFileAtPath:dest append:append];
             int read = 0;
             int cursor = 0;
         else
             callback(@"failed to resolve path", nil);
     }];
-    
+
     return 0;
 }
 
             [content writeToFile:path atomically:YES];
         }
         fm = nil;
-        
+
         resolve([NSNumber numberWithInteger:[content length]]);
     }
     @catch (NSException * e)
             else
             {
                 if(![[NSFileManager defaultManager] fileExistsAtPath:path]) {
-                    
+
                     reject(@"RNFetchBlobFS readFile error", @"file not exists", nil);
                     return;
                 }
                 fileContent = [NSData dataWithContentsOfFile:path];
-                
+
             }
             if(onComplete != nil)
                 onComplete(fileContent);
-            
+
             if([[encoding lowercaseString] isEqualToString:@"utf8"]) {
                 if(resolve != nil) {
                     NSString * utf8 = [[NSString alloc] initWithData:fileContent encoding:NSUTF8StringEncoding];
 
 + (NSDictionary *) stat:(NSString *) path error:(NSError **) error {
 
-    
+
     BOOL isDir = NO;
     NSFileManager * fm = [NSFileManager defaultManager];
     if([fm fileExistsAtPath:path isDirectory:&isDir] == NO) {
              @"lastModified" : [NSNumber numberWithLong:(time_t) [lastModified timeIntervalSince1970]*1000],
              @"type" : isDir ? @"directory" : @"file"
             };
-    
+
 }
 
 # pragma mark - exists
         [self.outStream close];
         self.outStream = nil;
     }
-    
+
 }
 
 // Slice a file into another file, generally for support Blob implementation.
             }
             long size = [fm attributesOfItemAtPath:path error:nil].fileSize;
             long max = MIN(size, [end longValue]);
-            
+
             if(![fm fileExistsAtPath:dest]) {
                 [fm createFileAtPath:dest contents:@"" attributes:nil];
             }
             [handle seekToFileOffset:[start longValue]];
             while(read < expected)
             {
-                
+
                 NSData * chunk;
                 long chunkSize = 0;
                 if([start longValue] + read + 10240 > max)
                 if([chunk length] <= 0)
                     break;
                 long remain = expected - read;
-                
+
                 [os write:[chunk bytes] maxLength:chunkSize];
                 read += [chunk length];
             }
             [os open];
             long size = asset.size;
             long max = MIN(size, [end longValue]);
-            
+
             while(read < expected)
             {
-                
+
                 uint8_t * chunk[10240];
                 long chunkSize = 0;
                 if([start longValue] + read + 10240 > max)
                 if( chunkRead <= 0)
                     break;
                 long remain = expected - read;
-                
+
                 [os write:chunk maxLength:chunkSize];
                 read += chunkRead;
             }
         {
             reject(@"slice error",  [NSString stringWithFormat: @"could not resolve URI %@", path ], nil);
         }
-        
+
     }];
 }
 
         [[RNFetchBlobFS getFileStreams] setValue:nil forKey:self.streamId];
         self.streamId = nil;
     }
-    
+
 }
 
 
     NSError *error = nil;
     NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
     NSDictionary *dictionary = [[NSFileManager defaultManager] attributesOfFileSystemForPath:[paths lastObject] error: &error];
-    
+
     if (dictionary) {
         NSNumber *fileSystemSizeInBytes = [dictionary objectForKey: NSFileSystemSize];
         NSNumber *freeFileSystemSizeInBytes = [dictionary objectForKey:NSFileSystemFreeSize];
     } else {
         callback(@[@"failed to get storage usage."]);
     }
-    
+
 }
 
 + (void) writeAssetToPath:(ALAssetRepresentation * )rep dest:(NSString *)dest

src/ios/RNFetchBlobNetwork.m

         [cookieStr appendString:cookie.name];
         [cookieStr appendString:@"="];
         [cookieStr appendString:cookie.value];
-        
+
         if(cookie.expiresDate == nil) {
             [cookieStr appendString:@"; max-age=0"];
         }
             NSString *strDate = [dateFormatter stringFromDate:cookie.expiresDate];
             [cookieStr appendString:strDate];
         }
-        
-        
+
+
         [cookieStr appendString:@"; domain="];
         [cookieStr appendString:hostname];
         [cookieStr appendString:@"; path="];
         [cookieStr appendString:cookie.path];
-        
-        
+
+
         if (cookie.isSecure) {
             [cookieStr appendString:@"; secure"];
         }
-        
+
         if (cookie.isHTTPOnly) {
             [cookieStr appendString:@"; httponly"];
         }
         respData = [[NSMutableData alloc] init];
         respFile = NO;
     }
-    
+
     __block NSURLSessionDataTask * task = [session dataTaskWithRequest:req];
     [taskTable setObject:task forKey:taskId];
     [task resume];
     if([[options objectForKey:CONFIG_INDICATOR] boolValue] == YES)
         [[UIApplication sharedApplication] setNetworkActivityIndicatorVisible:YES];
     __block UIApplication * app = [UIApplication sharedApplication];
-    
+
     // #115 handling task expired when application entering backgound for a long time
     UIBackgroundTaskIdentifier tid = [app beginBackgroundTaskWithName:taskId expirationHandler:^{
         NSLog([NSString stringWithFormat:@"session %@ expired", taskId ]);
         [bridge.eventDispatcher sendDeviceEventWithName:EVENT_EXPIRE body:args];
 
     }
-    
+
     // clear expired task entries
     [expirationTable removeAllObjects];
     expirationTable = [[NSMapTable alloc] init];
                 [cookiesTable setObject:cookies forKey:response.URL.host];
             }
         }
-        
+
         [self.bridge.eventDispatcher
          sendDeviceEventWithName: EVENT_STATE_CHANGE
          body:respInfo
             }
             BOOL overwrite = [options valueForKey:@"overwrite"] == nil ? YES : [[options valueForKey:@"overwrite"] boolValue];
             BOOL appendToExistingFile = [destPath RNFBContainsString:@"?append=true"];
-            
+
             appendToExistingFile = !overwrite;
 
             // For solving #141 append response data if the file already exists
         // if it turns out not to be `nil` that means the response data contains valid UTF8 string,
         // in order to properly encode the UTF8 string, use URL encoding before BASE64 encoding.
         NSString * utf8 = [[NSString alloc] initWithData:respData encoding:NSUTF8StringEncoding];
-        
+
         if(responseFormat == BASE64)
         {
             rnfbRespType = RESP_TYPE_BASE64;
 
 - (void) URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task willPerformHTTPRedirection:(NSHTTPURLResponse *)response newRequest:(NSURLRequest *)request completionHandler:(void (^)(NSURLRequest * _Nullable))completionHandler
 {
-    
+
     if(followRedirect)
     {
         if(request.URL != nil)

src/ios/RNFetchBlobReqBuilder.m

 {
     //    NSString * encodedUrl = [url stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding];
     NSString * encodedUrl = url;
-    
+
     // send request
     __block NSMutableURLRequest *request = [[NSMutableURLRequest alloc] initWithURL:[NSURL URLWithString: encodedUrl]];
     __block NSMutableDictionary *mheaders = [[NSMutableDictionary alloc] initWithDictionary:[RNFetchBlobNetwork normalizeHeaders:headers]];
                 {
                     [mheaders setValue:@"application/octet-stream" forKey:@"Content-Type"];
                 }
-                
+
                 // when body is a string contains file path prefix, try load file from the path
                 if([body hasPrefix:FILE_PREFIX]) {
                     __block NSString * orgPath = [body substringFromIndex:[FILE_PREFIX length]];
                 }
                 // otherwise convert it as BASE64 data string
                 else {
-                    
+
                     __block NSString * cType = [[self class]getHeaderIgnoreCases:@"content-type" fromHeaders:mheaders];
                     // when content-type is application/octet* decode body string using BASE64 decoder
                     if([[cType lowercaseString] hasPrefix:@"application/octet"] || [[cType lowercaseString] RNFBContainsString:@";base64"])
 }
 
 +(NSString *) getHeaderIgnoreCases:(NSString *)field fromHeaders:(NSMutableDictionary *) headers {
-    
+
     NSString * normalCase = [headers valueForKey:field];
     NSString * ignoredCase = [headers valueForKey:[field lowercaseString]];
     if( normalCase != nil)
         return normalCase;
     else
         return ignoredCase;
-    
+
 }
 
 

test/test-0.10.2.js

     let correct = date/Date.now() > 0.95 || date/Date.now() < 1.05;
     report(<Assert key="modification date should be correct"
       expect={true} actual={correct}/>);
-    done();
+    done()
 
   })
 
   .then((res) => {
     console.log(res.data)
     report(<Assert key="should not redirect twice" expect={1} actual={res.info().redirects.length}/>);
-    done();
+    done()
   })
 
 })
+
+describe('#241 null header silent failed issue', (report, done) => {
+
+  RNFetchBlob.fetch('GET', `${TEST_SERVER_URL}/public/github.png`, {
+    foo : null
+  })
+  .then(() => {
+    done()
+  })
+})