Merge pull request #1 from jhermsmeier/next

bencode.js update/rewrite

Author: themasch

AUTHORS

@@ -0,0 +1,2 @@
+Mark Schmale <[email protected]>
+Jonas Hermsmeier <[email protected]>

README.md

@@ -1,4 +1,120 @@
-### Usage
 
-    var bencode = require("bencode");
-    var data = bencode.decode(benstring);
+# node-bencode
+
+A node library for encoding and decoding bencoded data,  
+according to the [BitTorrent specification](http://www.bittorrent.org/beps/bep_0003.html).
+
+## Index
+
+- [About BEncoding](#about-bencoding)
+- [Installation](#install-with-npm)
+- [Usage](#usage)
+- [API](#api)
+
+## About BEncoding
+
+from [Wikipedia](https://en.wikipedia.org/wiki/Bencoding):
+
+Bencode (pronounced like B encode) is the encoding used by the peer-to-peer
+file sharing system BitTorrent for storing and transmitting loosely structured data.
+
+It supports four different types of values:
+- byte strings
+- integers
+- lists
+- dictionaries
+
+Bencoding is most commonly used in torrent files.
+These metadata files are simply bencoded dictionaries.
+
+## Install with [npm](http://npmjs.org)
+
+```
+npm install bencode
+```
+
+## Usage
+
+```javascript
+var bencode = require( 'bencode' )
+```
+
+### Encoding
+
+```javascript
+
+var data = {
+  string: 'Hello World',
+  integer: 12345,
+  dict: {
+    key: 'This is a string within a dictionary'
+  },
+  list: [ 1, 2, 3, 4, 'string', 5, {} ]
+}
+
+var result = bencode.encode( data )
+
+```
+
+#### Output
+
+```
+d6:string11:Hello World7:integeri12345e4:dictd3:key36:This is a string within a dictionarye4:litli1ei2ei3ei4e6:stringi5edeee
+```
+
+### Decoding
+
+```javascript
+var data   = new Buffer( 'd6:string11:Hello World7:integeri12345e4:dictd3:key36:This is a string within a dictionarye4:litli1ei2ei3ei4e6:stringi5edeee' )
+var result = bencode.decode( data )
+```
+
+#### Output
+
+```javascript
+{
+  string: <Buffer 48 65 6c 6c 6f 20 57 6f 72 6c 64>,
+  integer: 12345,
+  dict: {
+    key: <Buffer 54 68 69 73 20 69 73 20 61 20 73 74 72 69 6e 67 20 77 69 74 68 69 6e 20 61 20 64 69 63 74 69 6f 6e 61 72 79>
+  },
+  list: [ 1, 2, 3, 4, <Buffer 73 74 72 69 6e 67>, 5, {} ]
+}
+```
+
+Automagically convert bytestrings to strings:
+
+```javascript
+var result = bencode.decode( data, true )
+```
+
+#### Output
+
+```javascript
+{
+  string: 'Hello World',
+  integer: 12345,
+  dict: {
+    key: 'This is a string within a dictionary'
+  },
+  list: [ 1, 2, 3, 4, 'string', 5, {} ]
+}
+```
+
+## API
+
+### bencode.encode( *data* )
+
+> `Buffer` | `Array` | `String` | `Object` | `Number` __data__
+
+Returns `String`
+
+### bencode.decode( *data*, *toString* )
+
+> `Buffer` __data__  
+> `Boolean` __toString__
+
+If `toString` is set to something truthy,  
+bytestrings are automatically converted to strings.
+
+Returns `Object` | `Array` | `Buffer` | `String` | `Number`

benchmark/bencode.old.js

@@ -0,0 +1,163 @@
+/*
+ * ----------------------------------------------------------------------------
+ * node-bencode v0.1.0
+ * <[email protected]> wrote this file. As long as you retain this notice 
+ * you can do whatever you want with this stuff. If we meet some day, and you 
+ * think this stuff is worth it, you can buy me a beer in return. Mark Schmale
+ * ----------------------------------------------------------------------------
+ */
+var sys = require('sys');
+
+/**
+ * decodes a bencoded string 
+ */
+exports.decode = function decode(str) {
+    var arr = str.split('');
+
+    function integer(start) {
+        var c = '', n = '', i = 0, mul = 1;
+        var len = arr.length;
+        if(arr[start] === '-') {
+            mul = -1;
+            start = start+1;
+        }
+        for(i=start;i<len;i++) {
+            c = arr[i];
+            if(c == parseInt(c)) {
+                n = n  + c;
+            } else {
+                break;
+            }
+        } 
+        return {next: i+1, ret: mul*parseInt(n)};
+    }
+    
+    function text(start) {
+        var   nfo = integer(start), 
+            start = nfo.next,
+              len = nfo.ret
+                i = 0
+             full = '';
+
+        for(i=start;i<len+start;i++) {
+            full = full + arr[i]
+        }
+        return {next: i, ret: full};
+    }
+
+    function list(start) {
+        var len  = arr.length, 
+            i    = start+1,
+            list = [], 
+            tmp  = {}, 
+            lcnt = 0;
+        while(i<len && arr[i] !== 'e') {
+            tmp        = next(i);
+            i          = tmp.next;
+            list[lcnt] = tmp.ret;
+            lcnt++;
+        }
+        return {next: i+1, ret: list};
+    }
+
+    function dictionary(start) {
+        var len   = arr.length, 
+            i     = start+1,
+            list  = {}, 
+            tmp   = {}, 
+            isKey = true,
+            key   = '';
+        while(i<len && arr[i] !== 'e') {
+            tmp        = next(i);
+            i          = tmp.next;
+            if(isKey === true) {
+                key = tmp.ret;
+            } else {
+                list[key] = tmp.ret;
+            }
+            isKey = !isKey;
+        }
+        return {next: i+1, ret: list};
+    }
+
+
+    function next(start) {
+        var data = 0;
+        start = start || 0;
+        switch(arr[start]) { 
+            case 'i':   // integer
+                data = integer(start+1);
+                break;
+            case 'l':   // liste
+                data = list(start);
+                break;
+            case 'd':   // dict
+                data = dictionary(start);
+                break; 
+            default:    // string
+                data = text(start);
+        }
+        return data;
+    }
+
+    return next(0).ret;
+}
+
+exports.encode = function encode(data) {
+/*    sys.puts(sys.inspect(typeof(data)));
+    sys.puts(sys.inspect(is_array(data)));*/
+ 
+    function encode_string(data) {
+        return data.length + ":" + data;
+    }
+
+    function encode_integer(data) {
+        return "i" + data + "e";
+    }
+
+    function encode_list(data) {
+        var max = data.length;
+        var i   = 0;
+        var str = "l";
+        for(i=0;i<max;i++) {
+            str = str + encode(data[i]);
+        }
+        str = str + "e";
+        return str;
+    }
+
+    function encode_dict(data) {
+        var str = "d";
+        for(var key in data) {
+            str = str + encode_string(key) + encode(data[key]);
+        }
+        str = str + "e";
+        return str;
+    }
+
+    /** helper **/
+    function is_array(obj) {
+        return obj.constructor == Array;
+    }
+
+    var str = "";
+   
+    switch(typeof(data)) {
+        case 'object':
+            if(is_array(data) === true) {
+                str = encode_list(data);
+            } else {
+                str = encode_dict(data);
+            }
+            break;
+
+        case 'number':
+            str = encode_integer(data);
+            break;
+
+        case 'string': 
+            str = encode_string(data);
+            break;
+    }
+    return str;
+}

benchmark/index.js

@@ -0,0 +1,32 @@
+
+var bencode   = require( '../' )
+var old       = require( './bencode.old' )
+var Benchmark = require( 'benchmark' )
+var fs        = require( 'fs' )
+
+var suite = new Benchmark.Suite
+
+var buffer = fs.readFileSync( __dirname + '/test.torrent' )
+var data   = bencode.decode( buffer, true )
+var string = bencode.encode( data )
+
+suite
+  .add( 'new#encode( Object )', function () {
+    bencode.encode( data )
+  })
+  .add( 'old#encode( Object )', function () {
+    old.encode( data )
+  })
+  .add( 'new#decode( Buffer )', function () {
+    bencode.decode( buffer )
+  })
+  .add( 'new#decode( Buffer, true )', function () {
+    bencode.decode( buffer, true )
+  })
+  .add( 'old#decode( String )', function () {
+    old.decode( string )
+  })
+  .on( 'cycle', function ( event, bench ) {
+    console.log( bench.toString(), bench.error || '' )
+  })
+  .run()