├── bufferjs
    ├── index.js
    ├── package.json
    ├── add-chunk.js
    └── indexOf.js
├── examples
    ├── require-test.js
    ├── concat-test.js
    ├── indexOf-test.js
    └── add-chunk-test.js
├── LICENSE.MIT
└── README.md


/bufferjs/index.js:
--------------------------------------------------------------------------------
1 | /*jshint strict:true node:true es5:true onevar:true laxcomma:true laxbreak:true eqeqeq:true immed:true latedef:true*/
2 | (function () {
3 |   "use strict";
4 | 
5 |   require('./add-chunk');
6 |   require('./indexOf');
7 | }());
8 | 


--------------------------------------------------------------------------------
/examples/require-test.js:
--------------------------------------------------------------------------------
 1 | require('../bufferjs');
 2 | require('../bufferjs/concat');
 3 | require('../bufferjs/add-chunk');
 4 | require('../bufferjs/indexOf');
 5 | 
 6 | console.log('Buffer.concat:');
 7 | console.log(Buffer.concat);
 8 | 
 9 | console.log('buffer.addChunk:');
10 | console.log((new Buffer(1).addChunk));
11 | 


--------------------------------------------------------------------------------
/examples/concat-test.js:
--------------------------------------------------------------------------------
 1 | (function () {
 2 |   "use strict";
 3 | 
 4 |   require('../bufferjs/concat');
 5 |   var assert = require('assert');
 6 | 
 7 |   var abc = new Buffer('abc'),
 8 |     def = 'def', // Accepts Strings as well
 9 |     ghi = new Buffer('ghi'),
10 |     realResult = abc + def + ghi,
11 |     data = Buffer.concat(abc, def, ghi); 
12 | 
13 |   console.log(data.toString());
14 |   assert.equal(abc+def+ghi, data.toString());
15 | 
16 |   data = Buffer.concat([abc, def, ghi]);
17 |   console.log(data.toString());
18 |   assert.equal(abc+def+ghi, data.toString());
19 | }());
20 | 


--------------------------------------------------------------------------------
/bufferjs/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name"          : "bufferjs",
 3 |   "description"   : "Pure JavaScript Buffer utils.",
 4 |   "url"           : "http://github.com/coolaj86/node-bufferjs/",
 5 |   "repository"    : "coolaj86/node-bufferjs",
 6 |   "keywords"      : ["util", "buffer", "chunk", "indexOf"],
 7 |   "author"        : "AJ ONeal <coolaj86@gmail.com>",
 8 |   "license"       : "MIT",
 9 |   "contributors"  : [
10 |                       "Nathan Rajlich <nathan@tootallnate.net>",
11 |                       "Justin Freitag @justinfreitag"
12 |                     ],
13 |   "dependencies"  : {},
14 |   "version"       : "3.0.1",
15 |   "main"          : "./index",
16 |   "engines"       : {
17 |                       "node" : ">=0.2.0"
18 |                     }
19 | }
20 | 


--------------------------------------------------------------------------------
/bufferjs/add-chunk.js:
--------------------------------------------------------------------------------
 1 | /*jshint strict:true node:true es5:true onevar:true laxcomma:true laxbreak:true eqeqeq:true immed:true latedef:true*/
 2 | (function () {
 3 |   "use strict";
 4 | 
 5 |   Buffer.prototype.__addchunk_index = 0;
 6 | 
 7 |   Buffer.prototype.addChunk = function (chunk) {
 8 |     var  len = Math.min(chunk.length, this.length - this.__addchunk_index);
 9 | 
10 |     if (this.__addchunk_index === this.length) {
11 |       //throw new Error("Buffer is full");
12 |       return false;
13 |     }
14 | 
15 |     chunk.copy(this, this.__addchunk_index, 0, len);
16 | 
17 |     this.__addchunk_index += len;
18 | 
19 |     if (len < chunk.length) {
20 |       //remnant = new Buffer(chunk.length - len);
21 |       //chunk.copy(remnant, 0, len, chunk.length);
22 |       // return remnant;
23 |       return chunk.slice(len, chunk.length);
24 |     }
25 | 
26 |     if (this.__addchunk_index === this.length) {
27 |       return true;
28 |     }
29 |   };
30 | }());
31 | 


--------------------------------------------------------------------------------
/LICENSE.MIT:
--------------------------------------------------------------------------------
1 | Copyright (c) 2010 AJ ONeal (and Contributors)
2 | 
3 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
4 | 
5 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
6 | 
7 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
8 | 


--------------------------------------------------------------------------------
/bufferjs/indexOf.js:
--------------------------------------------------------------------------------
 1 | /*jshint strict:true node:true es5:true onevar:true laxcomma:true laxbreak:true eqeqeq:true immed:true latedef:true*/
 2 | (function () {
 3 |   "use strict";
 4 | 
 5 |   /**
 6 |    * A naiive 'Buffer.indexOf' function. Requires both the
 7 |    * needle and haystack to be Buffer instances.
 8 |    */
 9 |   function indexOf(haystack, needle, i) {
10 |     if (!Buffer.isBuffer(needle)) needle = new Buffer(needle);
11 |     if (typeof i === 'undefined') i = 0;
12 |     var l = haystack.length - needle.length + 1;
13 |     while (i<l) {
14 |       var good = true;
15 |       for (var j=0, n=needle.length; j<n; j++) {
16 |         if (haystack[i+j] !== needle[j]) {
17 |           good = false;
18 |           break;
19 |         }
20 |       }
21 |       if (good) return i;
22 |       i++;
23 |     }
24 |     return -1;
25 |   }
26 | 
27 |   if (!Buffer.indexOf) {
28 |     Buffer.indexOf = indexOf;
29 |   }
30 |   if (!Buffer.prototype.indexOf) {
31 |     Buffer.prototype.indexOf = function(needle, i) {
32 |       return Buffer.indexOf(this, needle, i);
33 |     };
34 |   }
35 | 
36 | })();
37 | 


--------------------------------------------------------------------------------
/examples/indexOf-test.js:
--------------------------------------------------------------------------------
 1 | (function () {
 2 |   "use strict";
 3 | 
 4 |   require('../bufferjs/indexOf');
 5 | 
 6 |   var assert = require('assert');
 7 | 
 8 |   // Test the static version, Buffer needle
 9 |   function test1() {
10 |     var haystack = new Buffer(10)
11 |       , needle = new Buffer(1);
12 | 
13 |     needle[0] = haystack[0] = 255;
14 |     assert.equal(Buffer.indexOf(haystack, needle), 0);
15 |     assert.equal(Buffer.indexOf(haystack, new Buffer(haystack.length)), -1);
16 |   }
17 | 
18 |   // Test the OO version, String needle
19 |   function test2() {
20 |     var haystack = new Buffer(20)
21 |       , needle = '\r\n'
22 |       , index = 5;
23 | 
24 |     haystack.write(needle, index);
25 |     assert.equal(haystack.indexOf(needle), index);
26 |     assert.equal(haystack.indexOf('should not be found'), -1);
27 |   }
28 | 
29 |   // Test starting from a specified index
30 |   function testFromSpecifiedIndex() {
31 |     var haystack = new Buffer('abracadabra')
32 |       , needle = new Buffer('a');
33 | 
34 |     assert.equal(haystack.indexOf(needle), 0);
35 |     assert.equal(Buffer.indexOf(haystack, needle, 1), 3);
36 |     assert.equal(haystack.indexOf(needle, 4), 5);
37 |     assert.equal(Buffer.indexOf(haystack, needle, 6), 7);
38 |     assert.equal(haystack.indexOf(needle, 8), 10);
39 |   }
40 | 
41 |   test1();
42 |   test2();
43 |   testFromSpecifiedIndex();
44 | 
45 |   console.log("Done. `indexOf` tests passed!");
46 | }());
47 | 


--------------------------------------------------------------------------------
/examples/add-chunk-test.js:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env node
 2 | (function () {
 3 |   "use strict";
 4 | 
 5 |   require('../bufferjs/add-chunk');
 6 | 
 7 |   var buffer, remnant, result;
 8 | 
 9 |   function initBuffer() {
10 |     buffer = new Buffer(16);
11 | 
12 |     buffer.addChunk(new Buffer("abcde"));
13 |     buffer.addChunk(new Buffer("fghij"));
14 |   }
15 | 
16 |   function testExactSize() {
17 |     initBuffer();
18 | 
19 |     remnant = buffer.addChunk(new Buffer("klmnop"));
20 | 
21 |     if ("abcdefghijklmnop" !== buffer.toString()) {
22 |       console.log("FAIL: expected the letters a-p, but saw: ", buffer.toString());
23 |     } else {
24 |       console.log("pass: ", 'buffer becomes full');
25 |     }
26 | 
27 |     if ("true" !== remnant.toString()) {
28 |       console.log("FAIL: expected true, indicating exact amount of data, but saw: ", remnant.toString());
29 |     } else {
30 |       console.log("pass: ", 'exact amount, no overflow');
31 |     }
32 | 
33 |     /*
34 |     try {
35 |       result = buffer.addChunk(new Buffer("uvwxyz"));
36 |       console.log("expected 'false', but saw: ", result);
37 |     } catch(e) {
38 |       console.log("pass: ", 'adding fails when full');
39 |     }
40 |     */
41 | 
42 |     result = buffer.addChunk(new Buffer("uvwxyz"));
43 |     if (false !== result) {
44 |       console.log("FAIL: expected 'false', but saw: ", result);
45 |     } else {
46 |       console.log("pass: ", 'adding fails when full');
47 |     }
48 |   }
49 | 
50 |   function testTooBig() {
51 |     initBuffer();
52 | 
53 |     remnant = buffer.addChunk(new Buffer("klmno"));
54 |     remnant = buffer.addChunk(new Buffer("pqrst"));
55 | 
56 |     if ("qrst" !== remnant.toString()) {
57 |       console.log("FAIL: expected the letters 'qrst', but saw:", remnant.toString());
58 |     } else {
59 |       console.log("pass: ", 'remnant catches overflow');
60 |     }
61 |   }
62 | 
63 |   testExactSize();
64 |   testTooBig();
65 | }());
66 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | node-bufferjs
  2 | ====
  3 | 
  4 | Pure JavaScript utils which extend the global `Buffer` object in Node.JS.
  5 | 
  6 |     npm install bufferjs
  7 | 
  8 | API
  9 | ====
 10 | 
 11 |     require('bufferjs');
 12 | 
 13 |   * buffer.addChunk(chunk)
 14 |   * Buffer.indexOf(haystack, needle, startIndex)
 15 |   * buffer.indexOf(needle, startIndex)
 16 | 
 17 | buffer.addChunk(chunk)
 18 | ----
 19 | 
 20 | Adds a buffer `chunk` to `buffer`.
 21 | 
 22 | Returns `true` when full
 23 | 
 24 | Returns `new Buffer` if buffer overflows
 25 | 
 26 |     require('bufferjs/add-chunk');
 27 | 
 28 |     var buffer = new Buffer(9),
 29 |       overflow;
 30 | 
 31 |     buffer.addChunk(new Buffer("abc"));
 32 |     buffer.addChunk(new Buffer("def"));
 33 |     buffer.toString(); // "abcdef???"
 34 |     // Note: "???" is whatever random garbage was internally `malloc`d.    
 35 | 
 36 | 
 37 |     console.log(true === buffer.addChunk(new Buffer("ghi"))); // true, buffer is full
 38 |     // true when buffer is full
 39 | 
 40 | 
 41 |     // adding past the index will throw an error
 42 |     overflow = buffer.addChunk(new Buffer("jkl"));
 43 |     buffer.toString(); // abcdefghi
 44 |     overflow.toString(); // jkl
 45 | 
 46 | 
 47 | Buffer.indexOf(haystack, needle, startIndex)
 48 | ----
 49 | 
 50 | Searches the given _haystack_ Buffer for the given _needle_ Buffer. Returns the index
 51 | of the first occurence of `needle`, or `-1` if the pattern was not found. `needle` may also
 52 | be a regular String, for convenience. `startIndex` tells at which index to begin the search.
 53 | 
 54 |     require('bufferjs/indexOf');
 55 | 
 56 |     var haystack = new Buffer(10);
 57 |     var needle = '\r\n';
 58 |     haystack.write(needle, 5);
 59 |     
 60 |     Buffer.indexOf(haystack, needle); // 5
 61 |     Buffer.indexOf(haystack, 'NOT_IN_HAYSTACK'); // -1
 62 | 
 63 | 
 64 | buffer.indexOf(needle, startIndex)
 65 | ----
 66 | 
 67 | OO-style variant of `Buffer.indexOf`. `this` is the _haystack_, and only _needle_ needs
 68 | to be supplied when called.
 69 | 
 70 |     require('bufferjs/indexOf');
 71 |   
 72 |     var haystack = new Buffer(10);
 73 |     var needle = '\r\n';
 74 |     haystack.write(needle, 5);
 75 | 
 76 |     haystack.indexOf(needle); // 5
 77 |     haystack.indexOf('NOT_IN_HAYSTACK'); // -1
 78 | 
 79 | Buffer.concat(list, [totalLength])
 80 | ----
 81 | 
 82 | **Deprecated**: Node.JS 0.8.x has Buffer.concat built-in (compatible).
 83 | See http://nodejs.org/api/buffer.html#buffer_class_method_buffer_concat_list_totallength
 84 | 
 85 | **WARNING**: v1.2.1 uses NON-NATIVE concat. v2.0.0 uses NATIVE concat ONLY.
 86 | 
 87 | Returns a new `Buffer` with the contents of all buffers in the `Array`.
 88 | 
 89 |     require('bufferjs/concat');
 90 | 
 91 |     var buffers = [
 92 |             new Buffer("abc")
 93 |           , new Buffer("def")
 94 |           , new Buffer("ghi")
 95 |         ]
 96 |       , buffer
 97 |       ;
 98 | 
 99 |     buffer = Buffer.concat(buffers);
100 |     console.log(buffer.toString('utf8'));
101 |     // abcdefghi
102 | 


--------------------------------------------------------------------------------