Code refactor

src/class/RNFetchBlobFile.js

+import {
+  NativeModules,
+  DeviceEventEmitter,
+  NativeAppEventEmitter,
+} from 'react-native'
+
+const RNFetchBlob = NativeModules.RNFetchBlob
+const emitter = DeviceEventEmitter
+
+export default class RNFetchBlobFile {
+
+}

src/class/RNFetchBlobReadStream.js

+import {
+  NativeModules,
+  DeviceEventEmitter,
+  NativeAppEventEmitter,
+} from 'react-native'
+
+const RNFetchBlob = NativeModules.RNFetchBlob
+const emitter = DeviceEventEmitter
+
+export default class RNFetchBlobReadStream {
+
+  path : string;
+  encoding : 'utf8' | 'ascii' | 'base64';
+  bufferSize : ?number;
+  closed : boolean;
+
+  constructor(path:string, encoding:string, bufferSize?:?number) {
+    if(!path)
+      throw Error('RNFetchBlob could not open file stream with empty `path`')
+    this.encoding = encoding || 'utf8'
+    this.bufferSize = bufferSize
+    this.path = path
+    this.closed = false
+    this._onData = () => {}
+    this._onEnd = () => {}
+    this._onError = () => {}
+
+    // register for file stream event
+    let subscription = emitter.addListener(`RNFetchBlobStream+${this.path}`, (e) => {
+    
+      let {event, detail} = e
+      if(this._onData && event === 'data')
+        this._onData(detail)
+      else if (this._onEnd && event === 'end') {
+        this._onEnd(detail)
+      }
+      else {
+        if(this._onError)
+          this._onError(detail)
+        else
+          throw new Error(detail)
+      }
+      // when stream closed or error, remove event handler
+      if (event === 'error' || event === 'end') {
+        subscription.remove()
+        this.closed = true
+      }
+    })
+
+  }
+
+  open() {
+    if(!this.closed)
+      RNFetchBlob.readStream(this.path, this.encoding, this.bufferSize || 0)
+    else
+      throw new Error('Stream closed')
+  }
+
+  onData(fn) {
+    if(this.encoding.toLowerCase() === 'ascii')
+      this._onData = (data) => {
+        fn(JSON.parse(data))
+      }
+    else
+      this._onData = fn
+  }
+
+  onError(fn) {
+    this._onError = fn
+  }
+
+  onEnd (fn) {
+    this._onEnd = fn
+  }
+
+}

src/class/RNFetchBlobSession.js

+/**
+ * Session class
+ * @class RNFetchBlobSession
+ */
+
+import {
+ NativeModules,
+ DeviceEventEmitter,
+ NativeAppEventEmitter,
+} from 'react-native'
+
+const RNFetchBlob = NativeModules.RNFetchBlob
+const emitter = DeviceEventEmitter
+
+export default class RNFetchBlobSession {
+
+  add : (path:string) => RNFetchBlobSession;
+  remove : (path:string) => RNFetchBlobSession;
+  dispose : () => Promise;
+  list : () => Array<string>;
+  name : string;
+
+  constructor(name:string, list:Array<string>) {
+    this.name = name
+    if(!sessions[name]) {
+      if(Array.isArray(list))
+      sessions[name] = list
+      else
+      sessions[name] = []
+    }
+  }
+
+  add(path:string):RNFetchBlobSession {
+    sessions[this.name].push(path)
+    return this
+  }
+
+  remove(path:string):RNFetchBlobSession {
+    let list = sessions[this.name]
+    for(let i in list) {
+      if(list[i] === path) {
+        sessions[this.name].splice(i, 1)
+        break;
+      }
+    }
+    return this
+  }
+
+  list():Array<string> {
+    return sessions[this.name]
+  }
+
+  dispose():Promise {
+    return new Promise((resolve, reject) => {
+      RNFetchBlob.removeSession(sessions[this.name], (err) => {
+        if(err)
+          reject(err)
+        else {
+          delete sessions[this.name]
+          resolve()
+        }
+      })
+    })
+  }
+
+}

src/class/RNFetchBlobWriteStream.js

+import {
+ NativeModules,
+ DeviceEventEmitter,
+ NativeAppEventEmitter,
+} from 'react-native'
+
+const RNFetchBlob = NativeModules.RNFetchBlob
+const emitter = DeviceEventEmitter
+
+export default class RNFetchBlobWriteStream {
+
+  id : string;
+  encoding : string;
+  append : bool;
+
+  constructor(streamId:string, encoding:string, append:string) {
+    this.id = streamId
+    this.encoding = encoding
+    this.append = append
+  }
+
+  write(data:string) {
+    return new Promise((resolve, reject) => {
+      try {
+        let method = this.encoding === 'ascii' ? 'writeArrayChunk' : 'writeChunk'
+        if(this.encoding.toLocaleLowerCase() === 'ascii' && !Array.isArray(data)) {
+            reject('ascii input data must be an Array')
+            return
+        }
+        RNFetchBlob[method](this.id, data, (error) => {
+          if(error)
+            reject(error)
+          else
+            resolve()
+        })
+      } catch(err) {
+        reject(err)
+      }
+    })
+  }
+
+  close() {
+    return new Promise((resolve, reject) => {
+      try {
+        RNFetchBlob.closeStream(this.id, () => {
+          resolve()
+        })
+      } catch (err) {
+        reject(err)
+      }
+    })
+  }
+
+}

src/fs.js

   DeviceEventEmitter,
   NativeAppEventEmitter,
 } from 'react-native'
+import RNFetchBlobSession from './class/RNFetchBlobSession'
+import RNFetchBlobWriteStream from './class/RNFetchBlobWriteStream'
+import RNFetchBlobReadStream from './class/RNFetchBlobReadStream'
+import RNFetchBlobFile from './class/RNFetchBlobFile'
 import type {
   RNFetchBlobNative,
   RNFetchBlobConfig,
   path : string,
   encoding : 'utf8' | 'ascii' | 'base64',
   append? : ?bool,
-):Promise<WriteStream> {
+):Promise<RNFetchBlobWriteStream> {
   if(!path)
     throw Error('RNFetchBlob could not open file stream with empty `path`')
-
+  encoding = encoding || 'utf8'
+  append = append || false
   return new Promise((resolve, reject) => {
     RNFetchBlob.writeStream(path, encoding || 'base64', append || false, (err, streamId:string) => {
       if(err)
         reject(err)
       else
-        resolve(new WriteStream(streamId, encoding))
+        resolve(new RNFetchBlobWriteStream(streamId, encoding))
     })
   })
 }
   path : string,
   encoding : 'utf8' | 'ascii' | 'base64',
   bufferSize? : ?number
-):RNFetchBlobStream {
-
-  if(!path)
-    throw Error('RNFetchBlob could not open file stream with empty `path`')
-  encoding = encoding || 'utf8'
-  let stream:RNFetchBlobStream = {
-    // parse JSON array when encoding is ASCII
-    onData : function(fn) {
-      if(encoding.toLowerCase() === 'ascii')
-        this._onData = (data) => {
-          fn(JSON.parse(data))
-        }
-      else
-        this._onData = fn
-    },
-    onError : function(fn) {
-      this._onError = fn
-    },
-    onEnd : function(fn) {
-      this._onEnd = fn
-    },
-  }
-
-  // register for file stream event
-  let subscription = emitter.addListener(`RNFetchBlobStream+${path}`, (e) => {
-
-    let {event, detail} = e
-    if(stream._onData && event === 'data')
-      stream._onData(detail)
-    else if (stream._onEnd && event === 'end') {
-      stream._onEnd(detail)
-    }
-    else {
-      if(stream._onError)
-        stream._onError(detail)
-      else
-        throw new Error(detail)
-    }
-    // when stream closed or error, remove event handler
-    if (event === 'error' || event === 'end') {
-      subscription.remove()
-    }
-  })
-
-  RNFetchBlob.readStream(path, encoding, bufferSize || 0)
-  return stream
-
+):Promise<RNFetchBlobReadStream> {
+  return Promise.resolve(new RNFetchBlobReadStream(path, encoding, bufferSize))
 }
 
+/**
+ * Create a directory.
+ * @param  {string} path Path of directory to be created
+ * @return {Promise}
+ */
 function mkdir(path:string):Promise {
 
   return new Promise((resolve, reject) => {
 
 }
 
+/**
+ * Show statistic data of a path.
+ * @param  {string} path Target path
+ * @return {RNFetchBlobFile}
+ */
+function stat(path:string):Promise<RNFetchBlobFile> {
+
+}
+
+/**
+ * Android only method, request media scanner to scan the file.
+ * @param  {Array<string>} paths Paths of files to be scanned.
+ * @param  {Array<string>} mimes Optional array of MIME types for each path.
+ *                               If mimeType is null, then the mimeType will be
+ *                               inferred from the file extension.
+ * @return {Promise}
+ */
+function scanFile(paths:Array<string>, mimes: Array<string>):Promise {
+
+}
+
 function cp(path:string, dest:string):Promise<boolean> {
   return new Promise((resolve, reject) => {
     RNFetchBlob.cp(path, dest, (err, res) => {
 
 }
 
-
-/**
- * Session class
- * @class RNFetchBlobSession
- */
-class RNFetchBlobSession {
-
-  add : (path:string) => RNFetchBlobSession;
-  remove : (path:string) => RNFetchBlobSession;
-  dispose : () => Promise;
-  list : () => Array<string>;
-  name : string;
-
-  constructor(name:string, list:Array<string>) {
-    this.name = name
-    if(!sessions[name]) {
-      if(Array.isArray(list))
-      sessions[name] = list
-      else
-      sessions[name] = []
-    }
-  }
-
-  add(path:string):RNFetchBlobSession {
-    sessions[this.name].push(path)
-    return this
-  }
-
-  remove(path:string):RNFetchBlobSession {
-    let list = sessions[this.name]
-    for(let i in list) {
-      if(list[i] === path) {
-        sessions[this.name].splice(i, 1)
-        break;
-      }
-    }
-    return this
-  }
-
-  list():Array<string> {
-    return sessions[this.name]
-  }
-
-  dispose():Promise {
-    return new Promise((resolve, reject) => {
-      RNFetchBlob.removeSession(sessions[this.name], (err) => {
-        if(err)
-          reject(err)
-        else {
-          delete sessions[this.name]
-          resolve()
-        }
-      })
-    })
-  }
-
-}
-
-class WriteStream {
-
-  id : string;
-  encoding : string;
-  append : bool;
-
-  constructor(streamId:string, encoding:string, append:string) {
-    this.id = streamId
-    this.encoding = encoding
-    this.append = append
-  }
-
-  write(data:string) {
-    return new Promise((resolve, reject) => {
-      try {
-        let method = this.encoding === 'ascii' ? 'writeArrayChunk' : 'writeChunk'
-        if(this.encoding.toLocaleLowerCase() === 'ascii' && !Array.isArray(data)) {
-            reject('ascii input data must be an Array')
-            return
-        }
-        RNFetchBlob[method](this.id, data, (error) => {
-          if(error)
-            reject(error)
-          else
-            resolve()
-        })
-      } catch(err) {
-        reject(err)
-      }
-    })
-  }
-
-  close() {
-    return new Promise((resolve, reject) => {
-      try {
-        RNFetchBlob.closeStream(this.id, () => {
-          resolve()
-        })
-      } catch (err) {
-        reject(err)
-      }
-    })
-  }
-
-}
-
 export default {
   RNFetchBlobSession,
   unlink,

test/test-0.5.x.js

 
 describe('Read cached file via file stream', (report, done) => {
   let data = 'data:image/png;base64, '
-  let stream = fs.readStream(tmpFilePath, 'base64')
-  stream.onData((chunk) => {
-    data += chunk
-  })
-  stream.onEnd(() => {
-    report(
-      <Assert key="image should have value"
-        expect={0}
-        comparer={Comparer.smaller}
-        actual={data.length}/>,
-      <Info key="image from read stream">
-        <Image source={{uri : data}} style={styles.image}/>
-      </Info>)
-    done()
-  })
-  stream.onError((err) => {
-    console.log('stream err', err)
-  })
+  fs.readStream(tmpFilePath, 'base64')
+    .then((stream) => {
+      stream.open()
+      stream.onData((chunk) => {
+        data += chunk
+      })
+      stream.onEnd(() => {
+        report(
+          <Assert key="image should have value"
+            expect={0}
+            comparer={Comparer.smaller}
+            actual={data.length}/>,
+          <Info key="image from read stream">
+            <Image source={{uri : data}} style={styles.image}/>
+          </Info>)
+        done()
+      })
+      stream.onError((err) => {
+        console.log('stream err', err)
+      })
+    })
 })
 
 describe('File stream reader error should be able to handled', (report, done) => {
-  let stream = fs.readStream('^_^ not exists', 'base64')
-  stream.onError((err) => {
-    report(<Info key="error message">
-      <Text>
-        {err}
-      </Text>
-    </Info>)
-    done()
+  fs.readStream('^_^ not exists', 'base64')
+    .then((stream) => {
+      stream.open()
+      stream.onError((err) => {
+        report(<Info key="error message">
+          <Text>
+            {err}
+          </Text>
+        </Info>)
+        done()
 
-  })
+      })
+    })
 })
 
 let localFile = null

test/test-fs.js

 
   fs.createFile(p, raw, 'utf8')
     .then(() => {
-      let stream = fs.readStream(p, 'utf8')
       let d = ''
-      stream.onData((chunk) => {
-        d += chunk
-      })
-      stream.onEnd(() => {
-        report(<Assert key="utf8 content test"  expect={raw} actual={d}/>)
-        testBase64()
-      })
-    })
-  function testBase64() {
-    fs.createFile(p + '-base64', RNFetchBlob.base64.encode(raw), 'base64')
-      .then(() => {
-        let stream = fs.readStream(p + '-base64', 'utf8')
-        let d = ''
+      fs.readStream(p, 'utf8').then((stream) => {
+        stream.open()
         stream.onData((chunk) => {
           d += chunk
         })
         stream.onEnd(() => {
-          report(<Assert
-            key="base64 content test"
-            expect={raw}
-            actual={d}/>)
-          // testASCII()
-          done()
+          report(<Assert key="utf8 content test"  expect={raw} actual={d}/>)
+          testBase64()
         })
       })
-      .catch((err) => {
-        console.log(err)
-      })
-  }
-  function testASCII() {
-    fs.createFile(p + '-ascii', raw, 'ascii')
+    })
+  function testBase64() {
+    fs.createFile(p + '-base64', RNFetchBlob.base64.encode(raw), 'base64')
       .then(() => {
-        let stream = fs.readStream(p + '-ascii', 'ascii')
-        let d = ''
-        stream.onData((chunk) => {
-          d += chunk
-        })
-        stream.onEnd(() => {
-          report(<Assert
-            key="ASCII content test"
-            expect={raw}
-            actual={d}/>)
-          done()
+        fs.readStream(p + '-base64', 'utf8').then((stream) => {
+            stream.open()
+            let d = ''
+            stream.onData((chunk) => {
+              d += chunk
+            })
+            stream.onEnd(() => {
+              report(<Assert
+                key="base64 content test"
+                expect={raw}
+                actual={d}/>)
+                done()
+              })
         })
       })
       .catch((err) => {
       return ws.close()
     })
     .then(() => {
-      let rs = fs.readStream(p, 'utf8')
       let d1 = ''
-      rs.onData((chunk) => {
-        d1 += chunk
-      })
-      rs.onEnd(() => {
-        report(
-          <Assert key="write data async test"
-            expect={'123456789011121314'}
-            actual={d1}/>)
-          base64Test()
+      fs.readStream(p, 'utf8').then((stream) => {
+        stream.open()
+        stream.onData((chunk) => {
+          d1 += chunk
+        })
+        stream.onEnd(() => {
+          report(
+            <Assert key="write data async test"
+              expect={'123456789011121314'}
+              actual={d1}/>)
+            base64Test()
+        })
       })
     })
   function base64Test() {
       return ws.close()
     })
     .then(() => {
-      let rs = fs.readStream(p, 'base64')
+      return fs.readStream(p, 'base64')
+    })
+    .then((stream) => {
       let d2 = ''
-      rs.onData((chunk) => {
+      stream.open()
+      stream.onData((chunk) => {
         d2 += chunk
       })
-      rs.onEnd(() => {
+      stream.onEnd(() => {
         report(
           <Assert key="file should be overwritten by base64 encoded data"
             expect={RNFetchBlob.base64.encode(expect)}
   })
   .then((files) => {
     report(<Assert key="file name should be correct" expect={'moved'} actual={files[0]}/>)
-    let rs = fs.readStream(dest + '/moved')
-    let actual = ''
-    rs.onData((chunk) => {
-      actual += chunk
-    })
-    rs.onEnd(() => {
-      report(<Assert key="file content should be correct" expect={content} actual={actual}/>)
-      done()
+    fs.readStream(dest + '/moved').then((rs) => {
+      rs.open()
+      let actual = ''
+      rs.onData((chunk) => {
+        actual += chunk
+      })
+      rs.onEnd(() => {
+        report(<Assert key="file content should be correct" expect={content} actual={actual}/>)
+        done()
+      })
     })
   })
 })
   })
   .then((files) => {
     report(<Assert key="file name should be correct" expect={'cp'} actual={files[0]}/>)
-    let rs = fs.readStream(dest + '/cp')
-    let actual = ''
-    rs.onData((chunk) => {
-      actual += chunk
-    })
-    rs.onEnd(() => {
-      report(<Assert key="file content should be correct" expect={content} actual={actual}/>)
-      done()
+    fs.readStream(dest + '/cp').then((rs) => {
+      rs.open()
+      let actual = ''
+      rs.onData((chunk) => {
+        actual += chunk
+      })
+      rs.onEnd(() => {
+        report(<Assert key="file content should be correct" expect={content} actual={actual}/>)
+        done()
+      })
     })
   })
 })
       return fs.writeStream(p, 'ascii', false)
     })
     .then((ofstream) => {
-      let qq = []
       for(let i=0;i<expect.length;i++) {
-        qq.push(expect[i].charCodeAt(0))
         ofstream.write([expect[i].charCodeAt(0)])
       }
       ofstream.write(['g'.charCodeAt(0), 'g'.charCodeAt(0)])
       return ofstream.close()
     })
     .then(() => {
-      let ifstream = fs.readStream(p, 'ascii')
-      let res = []
-      ifstream.onData((chunk) => {
-        res = res.concat(chunk)
-      })
-      ifstream.onEnd(() => {
-        res = res.map((byte) => {
-          return String.fromCharCode(byte)
-        }).join('')
-        report(
-          <Assert key="data written in ASCII format should correct"
-            expect={expect + 'gg'}
-            actual={res}
-          />)
-        done()
+      fs.readStream(p, 'ascii').then((ifstream) => {
+        let res = []
+        ifstream.open()
+        ifstream.onData((chunk) => {
+          res = res.concat(chunk)
+        })
+        ifstream.onEnd(() => {
+          res = res.map((byte) => {
+            return String.fromCharCode(byte)
+          }).join('')
+          report(
+            <Assert key="data written in ASCII format should correct"
+              expect={expect + 'gg'}
+              actual={res}
+            />)
+              done()
+            })
       })
     })
 })
     return fs.createFile(p + filename, getASCIIArray(expect), 'ascii')
   })
   .then(() => {
-    let rs = fs.readStream(p + filename, 'base64')
-    let actual = ''
-    rs.onData((chunk) => {
-      actual += chunk
+    fs.readStream(p + filename, 'base64').then((rs) => {
+      let actual = ''
+      rs.open()
+      rs.onData((chunk) => {
+        actual += chunk
+      })
+      rs.onEnd(() => {
+        report(<Assert key="written data verify"
+          expect={expect}
+          actual={base64.decode(actual)}/>)
+        done()
+      })
     })
-    rs.onEnd(() => {
-      report(<Assert key="written data verify"
-        expect={expect}
-        actual={base64.decode(actual)}/>)
-      done()
+  })
+})
+
+describe('format conversion', (report, done) => {
+  let p = ''
+  fs.getSystemDirs().then((dirs) => {
+    p = dirs.DocumentDir + '/foo'
+    return fs.createFile(p, [102, 111, 111], 'ascii')
+  })
+  .then(() => {
+    fs.readStream(p, 'utf8').then((stream) => {
+      let res = []
+      stream.open()
+      stream.onData((chunk) => {
+        res+=chunk
+      })
+      stream.onEnd(() => {
+        report(
+          <Assert key="write utf8 and read by ascii"
+            expect="foo"
+            actual={res}/>)
+            done()
+      })
     })
   })
 })