defun

defun function defines a function that can recieve arguments as object.
ukyo · Mar 26, 2014 · 9d91c93 · 9d91c93
1 parent 2b65602
commit 9d91c93
Show file tree

Hide file tree

Showing 19 changed files with 118 additions and 106 deletions.
diff --git a/jsziptools.js b/jsziptools.js
diff --git a/src/ZipArchiveWriter.js b/src/ZipArchiveWriter.js
@@ -15,16 +15,15 @@
  * .write('a.mp3', mp3Buff)
  * .writeEnd();
  */
-function ZipArchiveWriter(shareMemory, chunkSize) {
-    var params = utils.getParams(arguments, ['shareMemory', 'chunkSize']);
-    this.shareMemory = params.shareMemory;
-    this.chunkSize = params.chunkSize;
+var ZipArchiveWriter = defun(['shareMemory', 'chunkSize'], function ZipArchiveWriter(shareMemory, chunkSize) {
+    this.shareMemory = shareMemory;
+    this.chunkSize = chunkSize;
     this.dirs = {};
     this.centralDirHeaders = [];
     this.offset = 0;
     this.date = new Date;
     this.listners = {};
-}
+});
 
 /**
  * @param {string}     path

diff --git a/src/algorithms/crc32.js b/src/algorithms/crc32.js
@@ -24,16 +24,15 @@ algorithms.crc32 = (function(){
         return table;
     })();
 
-    return function(buffer, crc){
-        var params = utils.getParams(arguments, ['buffer', 'crc']),
-            bytes = utils.toBytes(params.buffer),
-            crc = params.crc == null ? 0xFFFFFFFF : ~params.crc >>> 0,
+    return defun(['buffer', 'crc'], function(buffer, crc){
+        var bytes = utils.toBytes(buffer),
+            crc = crc == null ? 0xFFFFFFFF : ~crc >>> 0,
             i = 0,
             n = bytes.length,
             t = table;
         for(; i < n; ++i) crc = (crc >>> 8) ^ t[bytes[i] ^ (crc & 0xFF)];
         return ~crc >>> 0;
-    };
+    });
 })();
 
 expose('jz.algorithms.crc32', algorithms.crc32);
diff --git a/src/algorithms/deflate.js b/src/algorithms/deflate.js
@@ -9,9 +9,8 @@ utils.js
  * @param {number} level
  * @return {Uint8Array}
  */
-algorithms.deflate = function (buffer, level, chunkSize) {
-    var params = utils.getParams(arguments, ['buffer', 'level', 'chunkSize']);
-    return zlib['rawDeflate'](utils.toBytes(params.buffer), params.level, params.chunkSize);
-};
+algorithms.deflate = defun(['buffer', 'level', 'chunkSize'], function(buffer, level, chunkSize) {
+    return zlib['rawDeflate'](utils.toBytes(buffer), level, chunkSize);
+});
 
 expose('jz.algorithms.deflate', algorithms.deflate);
diff --git a/src/algorithms/inflate.js b/src/algorithms/inflate.js
@@ -3,9 +3,8 @@
  * @param {number} chunkSize
  * @return {Uint8Array}
  */
-algorithms.inflate = function(buffer, chunkSize){
-    var params = utils.getParams(arguments, ['buffer', 'chunkSize']);
-    return zlib['rawInflate'](utils.toBytes(params.buffer), params.chunkSize);
-};
+algorithms.inflate = defun(['buffer', 'chunkSize'], function(buffer, chunkSize){
+    return zlib['rawInflate'](utils.toBytes(buffer), chunkSize);
+});
 
 expose('jz.algorithms.inflate', algorithms.inflate);
diff --git a/src/gz.compress.js b/src/gz.compress.js
@@ -6,20 +6,19 @@
  * @param  {string}                              fcomment
  * @return {Uint8Array}
  */
-gz.compress = function(buffer, level, chunkSize, fname, fcomment) {
-    var params = utils.getParams(arguments, ['buffer', 'level', 'chunkSize', 'fname', 'fcomment']),
-        chunks = [];
+gz.compress = defun(['buffer', 'level', 'chunkSize', 'fname', 'fcomment'], function(buffer, level, chunkSize, fname, fcomment) {
+    var chunks = [];
     stream.gz.compress({
-        buffer: params.buffer,
-        level: params.level,
-        chunkSize: params.chunkSize,
-        fname: params.fname,
-        fcomment: params.fcomments,
+        buffer: buffer,
+        level: level,
+        chunkSize: chunkSize,
+        fname: fname,
+        fcomment: fcomment,
         streamFn: function(chunk) {
             chunks.push(chunk);
         }
     });
     return utils.concatBytes(chunks);
-};
+});
 
 expose('jz.gz.compress', gz.compress);
diff --git a/src/gz.decompress.js b/src/gz.decompress.js
@@ -5,18 +5,16 @@
  * @param  {boolean}                             chunkSize
  * @return {Uint8Array}
  */
-gz.decompress = function(buffer, chunkSize) {
-    var params = utils.getParams(arguments, ['buffer', 'chunkSize']),
-        chunks = [];
+gz.decompress = defun(['buffer', 'chunkSize'], function(buffer, chunkSize) {
+    var chunks = [];
     stream.gz.decompress({
-        buffer: params.buffer,
+        buffer: buffer,
         streamFn: function(chunk) {
             chunks.push(chunk);
         },
-        shareMemory: false,
-        chunkSize: params.chunkSize
+        chunkSize: chunkSize
     });
     return utils.concatBytes(chunks);
-}
+});
 
 expose('jz.gz.decompress', gz.decompress);
diff --git a/src/jsziptools.js b/src/jsziptools.js
@@ -34,3 +34,17 @@ function expose(namespace, o) {
 function exposeProperty(name, cls, property) {
     cls.prototype[name] = property;
 }
+
+function defun(propertyNames, fn) {
+    return function() {
+        var args, params = arguments[0];
+        if (Object.prototype.toString.call(params) === '[object Object]') {
+            args = propertyNames.map(function(name) {
+                return params[name];
+            });
+        } else {
+            args = arguments;
+        }
+        return fn.apply(this, args);
+    };
+}
diff --git a/src/stream/algorithms/deflate.js b/src/stream/algorithms/deflate.js
@@ -14,10 +14,14 @@
  *   chunkSize: 0xf000
  * });
  */
-stream.algorithms.deflate = function(buffer, streamFn, level, shareMemory, chunkSize) {
-    var params = utils.getParams(arguments, ['buffer', 'streamFn', 'level', 'shareMemory', 'chunkSize']);
-    params.input = utils.toBytes(params.buffer);
-    zlib.stream.rawDeflate(params);
-};
+stream.algorithms.deflate = defun(['buffer', 'streamFn', 'level', 'shareMemory', 'chunkSize'], function(buffer, streamFn, level, shareMemory, chunkSize) {
+    zlib.stream.rawDeflate({
+        input: utils.toBytes(buffer),
+        streamFn: streamFn,
+        level: level,
+        shareMemory: shareMemory,
+        chunkSize: chunkSize
+    });
+});
 
 expose('jz.stream.algorithms.deflate', stream.algorithms.deflate);
diff --git a/src/stream/algorithms/inflate.js b/src/stream/algorithms/inflate.js
@@ -13,10 +13,13 @@
  *   chunkSize: 0xf000
  * });
  */
-stream.algorithms.inflate = function(buffer, streamFn, shareMemory, chunkSize) {
-    var params = utils.getParams(arguments, ['buffer', 'streamFn', 'shareMemory', 'chunkSize']);
-    params.input = utils.toBytes(params.buffer);
-    zlib.stream.rawInflate(params);
-};
+stream.algorithms.inflate = defun(['buffer', 'streamFn', 'shareMemory', 'chunkSize'], function(buffer, streamFn, shareMemory, chunkSize) {
+    zlib.stream.rawInflate({
+        input: utils.toBytes(buffer),
+        streamFn: streamFn,
+        shareMemory: shareMemory,
+        chunkSize: chunkSize
+    });
+});
 
 expose('jz.stream.algorithms.inflate', stream.algorithms.inflate);
diff --git a/src/stream/gz.compress.js b/src/stream/gz.compress.js
@@ -9,15 +9,10 @@
  * @param {string}                      fname - optional
  * @param {string}                      fcomment - optional
  */
-stream.gz.compress = function(buffer, streamFn, level, shareMemory, chunkSize, fname, fcomment) {
-    var params = utils.getParams(arguments, ['buffer', 'streamFn', 'level', 'shareMemory', 'chunkSize', 'fname', 'fcomment']),
-        bytes = utils.toBytes(params.buffer),
-        level = params.level,
-        streamFn = params.streamFn,
-        shareMemory = params.shareMemory,
-        chunkSize = params.chunkSize,
-        fname = params.fname && utils.toBytes(params.fname),
-        fcomment = params.fcomment && utils.toBytes(params.fcomment),
+stream.gz.compress = defun(['buffer', 'streamFn', 'level', 'shareMemory', 'chunkSize', 'fname', 'fcomment'], function(buffer, streamFn, level, shareMemory, chunkSize, fname, fcomment) {
+    var bytes = utils.toBytes(buffer),
+        fname = fname && utils.toBytes(fname),
+        fcomment = fcomment && utils.toBytes(fcomment),
         flg = 0,
         headerLength = 10,
         offset = 0,
@@ -70,6 +65,6 @@ stream.gz.compress = function(buffer, streamFn, level, shareMemory, chunkSize, f
     view.setUint32(0, algorithms.crc32(bytes), true); // crc checksum
     view.setUint32(4, bytes.length, true); // isize
     streamFn(footer);
-};
+});
 
 expose('jz.stream.gz.compress', stream.gz.compress);
diff --git a/src/stream/gz.decompress.js b/src/stream/gz.decompress.js
@@ -4,12 +4,9 @@
  * @param  {boolean}                             shareMemory
  * @param  {number}                              chunkSize
  */
-stream.gz.decompress = function(buffer, streamFn, shareMemory, chunkSize) {
-    var params = utils.getParams(arguments, ['buffer', 'streamFn', 'shareMemory', 'chunkSize']),
-        bytes = utils.toBytes(params.buffer),
-        flg, ret, crc, streamFn = params.streamFn,
-        shareMemory = params.shareMemory,
-        chunkSize = params.chunkSize,
+stream.gz.decompress = defun(['buffer', 'streamFn', 'shareMemory', 'chunkSize'], function(buffer, streamFn, shareMemory, chunkSize) {
+    var bytes = utils.toBytes(buffer),
+        flg, ret, crc,
         offset = 10,
         view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
 
@@ -39,6 +36,6 @@ stream.gz.decompress = function(buffer, streamFn, shareMemory, chunkSize) {
     if (crc !== view.getUint32(bytes.length - 8, true)) {
         throw new Error('js.stream.gz.decompress: file is broken.');
     }
-};
+});
 
 expose('jz.stream.gz.decompress', stream.gz.decompress);
diff --git a/src/stream/zip.pack.js b/src/stream/zip.pack.js
@@ -30,11 +30,10 @@
  *   // no args.
  * });
  */
-stream.zip.pack = function(files, streamFn, level, shareMemory, chunkSize) {
-    var params = utils.getParams(arguments, ['files', 'streamFn', 'level', 'shareMemory', 'chunkSize']),
-        promises = [],
-        writer = new ZipArchiveWriter(params);
-    writer.on('data', params.streamFn);
+stream.zip.pack = defun(['files', 'streamFn', 'level', 'shareMemory', 'chunkSize'], function(files, streamFn, level, shareMemory, chunkSize) {
+    var promises = [],
+        writer = new ZipArchiveWriter(shareMemory, chunkSize);
+    writer.on('data', streamFn);
 
     function packItem(level, path, item) {
         var dir = item.children || item.dir || item.folder,
@@ -69,11 +68,11 @@ stream.zip.pack = function(files, streamFn, level, shareMemory, chunkSize) {
         }
     }
 
-    params.files.forEach(loadFile);
+    files.forEach(loadFile);
     return Promise.all(promises).then(function() {
-        params.files.forEach(packItem.bind(null, params.level, ''));
+        files.forEach(packItem.bind(null, level, ''));
         writer.writeEnd();
     });
-};
+});
 
 expose('jz.stream.zip.pack', stream.zip.pack);
diff --git a/src/stream/zlib.compress.js b/src/stream/zlib.compress.js
@@ -15,10 +15,14 @@
  *   chunkSize: 0xf000
  * });
  */
-stream.zlib.compress = function(buffer, streamFn, level, shareMemory, chunkSize) {
-    var params = utils.getParams(arguments, ['buffer', 'streamFn', 'level', 'shareMemory', 'chunkSize']);
-    params.input = utils.toBytes(params.buffer);
-    zlib.stream.deflate(params);
-};
+stream.zlib.compress = defun(['buffer', 'streamFn', 'level', 'shareMemory', 'chunkSize'], function(buffer, streamFn, level, shareMemory, chunkSize) {
+    zlib.stream.deflate({
+        input: utils.toBytes(buffer),
+        streamFn: streamFn,
+        level: level,
+        shareMemory: shareMemory,
+        chunkSize: chunkSize
+    });
+});
 
 expose('jz.stream.zlib.compress', stream.zlib.compress);
diff --git a/src/stream/zlib.decompress.js b/src/stream/zlib.decompress.js
@@ -12,10 +12,13 @@
  *   chunkSize: 0xf000
  * });
  */
-stream.zlib.decompress = function(buffer, streamFn, shareMemory, chunkSize) {
-    var params = utils.getParams(arguments, ['buffer', 'streamFn', 'shareMemory', 'chunkSize']);
-    params.input = utils.toBytes(params.buffer);
-    zlib.stream.inflate(params);
-};
+stream.zlib.decompress = defun(['buffer', 'streamFn', 'shareMemory', 'chunkSize'], function(buffer, streamFn, shareMemory, chunkSize) {
+    zlib.stream.inflate({
+        input: buffer,
+        streamFn: streamFn,
+        shareMemory: shareMemory,
+        chunkSize: chunkSize
+    });
+});
 
 expose('jz.stream.zlib.decompress', stream.zlib.decompress);
diff --git a/src/zip.pack.js b/src/zip.pack.js
@@ -23,20 +23,19 @@
  *   // buffer is Uint8Array.
  * });
  */
-zip.pack = function(files, level, chunkSize) {
-    var params = utils.getParams(arguments, ['files', 'level', 'chunkSize']),
-        chunks = [];
+zip.pack = defun(['files', 'level', 'chunkSize'], function(files, level, chunkSize) {
+    var chunks = [];
     return stream.zip.pack({
-        files: params.files,
+        files: files,
         shareMemory: false,
-        level: params.level,
-        chunkSize: params.chunkSize,
+        level: level,
+        chunkSize: chunkSize,
         streamFn: function(chunk) {
             chunks.push(chunk);
         }
     }).then(function() {
         return utils.concatBytes(chunks);
     });
-};
+});
 
 expose('jz.zip.pack', zip.pack);
diff --git a/src/zip.unpack.js b/src/zip.unpack.js
@@ -136,11 +136,11 @@ ZipArchiveReader.prototype._completeInit = function() {
 
     return Promise.all(localFileHeaders.map(function(header, i) {
         return utils.bytesToString(header.filename, params.encoding).then(function(filename) {
-    header.filename = filename;
-});
-})).then(function() {
-    return self
-});
+            header.filename = filename;
+        });
+    })).then(function() {
+        return self
+    });
 };
 
 /**
@@ -602,9 +602,12 @@ exposeProperty('readFileAsDataURLSync', ZipArchiveReaderBlob, ZipArchiveReaderBl
  *   });
  * });
  */
-zip.unpack = function(buffer, encoding, chunkSize) {
-    var params = utils.getParams(arguments, ['buffer', 'encoding', 'chunkSize']);
-    return new(params.buffer instanceof Blob ? ZipArchiveReaderBlob : ZipArchiveReader)(params).init();
-};
+zip.unpack = defun(['buffer', 'encoding', 'chunkSize'], function(buffer, encoding, chunkSize) {
+    return new(buffer instanceof Blob ? ZipArchiveReaderBlob : ZipArchiveReader)({
+        buffer: buffer,
+        encoding: encoding,
+        chunkSize: chunkSize
+    }).init();
+});
 
 expose('jz.zip.unpack', zip.unpack);
diff --git a/src/zlib.compress.js b/src/zlib.compress.js
@@ -5,7 +5,6 @@
  * @param {integer} level compression level.
  * @return {Uint8Array}
  */
-expose('jz.zlib.compress', function (buffer, level, chunkSize) {
-  var params = utils.getParams(arguments, ['buffer', 'level', 'chunkSize']);
-  return zlib['deflate'](utils.toBytes(params.buffer), params.level, params.chunkSize);
-});
+expose('jz.zlib.compress', defun(['buffer', 'level', 'chunkSize'], function (buffer, level, chunkSize) {
+  return zlib['deflate'](utils.toBytes(buffer), level, chunkSize);
+}));