RubyGems - snowball - Versions diffs - 0.1.21 → 0.1.22 - Mend

snowball 0.1.21 → 0.1.22

Files changed (589) hide show

data/node_modules/browserify/node_modules/http-browserify/example/post/server.js ADDED

@@ -0,0 +1,19 @@
+var http = require('http');
+var ecstatic = require('ecstatic')(__dirname);
+var server = http.createServer(function (req, res) {
+    if (req.method === 'POST' && req.url === '/plusone') {
+        res.setHeader('content-type', 'text/plain');
+        var s = '';
+        req.on('data', function (buf) { s += buf.toString() });
+        req.on('end', function () {
+            var n = parseInt(s) + 1;
+            res.end(n.toString());
+        });
+    }
+    else ecstatic(req, res);
+});
+console.log('Listening on :8082');
+server.listen(8082);

data/node_modules/browserify/node_modules/http-browserify/example/streaming/index.html ADDED

@@ -0,0 +1,9 @@
+<html>
+  <head>
+    <title>xhr</title>
+  </head>
+  <body>
+    <div id="result"></div>
+    <script type="text/javascript" src="/bundle.js"></script>
+  </body>
+</html>

data/node_modules/browserify/node_modules/http-browserify/example/streaming/main.js ADDED

@@ -0,0 +1,16 @@
+var http = require('../../');
+http.get({ path : '/doom' }, function (res) {
+    var div = document.getElementById('result');
+    if (!div.style) div.style = {};
+    div.style.color = 'rgb(80,80,80)';
+    res.on('data', function (buf) {
+        div.innerHTML += buf;
+    });
+    res.on('end', function () {
+        div.style.color = 'black';
+        div.innerHTML += '!';
+    });
+});

data/node_modules/browserify/node_modules/http-browserify/example/streaming/server.js ADDED

@@ -0,0 +1,21 @@
+var http = require('http');
+var ecstatic = require('ecstatic')(__dirname);
+var server = http.createServer(function (req, res) {
+    if (req.url === '/doom') {
+        res.setHeader('content-type', 'multipart/octet-stream');
+        res.write('d');
+        var i = 0;
+        var iv = setInterval(function () {
+            res.write('o');
+            if (i++ >= 10) {
+                clearInterval(iv);
+                res.end('m');
+            }
+        }, 500);
+    }
+    else ecstatic(req, res);
+});
+console.log('Listening on :8082');
+server.listen(8082);

data/node_modules/browserify/node_modules/http-browserify/index.js ADDED

@@ -0,0 +1,59 @@
+var http = module.exports;
+var EventEmitter = require('events').EventEmitter;
+var Request = require('./lib/request');
+http.request = function (params, cb) {
+    if (!params) params = {};
+    if (!params.host) params.host = window.location.host.split(':')[0];
+    if (!params.port) params.port = window.location.port;
+    var req = new Request(new xhrHttp, params);
+    if (cb) req.on('response', cb);
+    return req;
+};
+http.get = function (params, cb) {
+    params.method = 'GET';
+    var req = http.request(params, cb);
+    req.end();
+    return req;
+};
+http.Agent = function () {};
+http.Agent.defaultMaxSockets = 4;
+var xhrHttp = (function () {
+    if (typeof window === 'undefined') {
+        throw new Error('no window object present');
+    }
+    else if (window.XMLHttpRequest) {
+        return window.XMLHttpRequest;
+    }
+    else if (window.ActiveXObject) {
+        var axs = [
+            'Msxml2.XMLHTTP.6.0',
+            'Msxml2.XMLHTTP.3.0',
+            'Microsoft.XMLHTTP'
+        ];
+        for (var i = 0; i < axs.length; i++) {
+            try {
+                var ax = new(window.ActiveXObject)(axs[i]);
+                return function () {
+                    if (ax) {
+                        var ax_ = ax;
+                        ax = null;
+                        return ax_;
+                    }
+                    else {
+                        return new(window.ActiveXObject)(axs[i]);
+                    }
+                };
+            }
+            catch (e) {}
+        }
+        throw new Error('ajax not supported in this browser')
+    }
+    else {
+        throw new Error('ajax not supported in this browser');
+    }
+})();

data/node_modules/browserify/node_modules/http-browserify/lib/request.js ADDED

@@ -0,0 +1,128 @@
+var Stream = require('stream');
+var Response = require('./response');
+var concatStream = require('concat-stream')
+var Buffer = require('buffer')
+var Request = module.exports = function (xhr, params) {
+    var self = this;
+    self.writable = true;
+    self.xhr = xhr;
+    self.body = concatStream()
+    var uri = params.host + ':' + params.port + (params.path || '/');
+    xhr.open(
+        params.method || 'GET',
+        (params.scheme || 'http') + '://' + uri,
+        true
+    );
+    if (params.headers) {
+        var keys = objectKeys(params.headers);
+        for (var i = 0; i < keys.length; i++) {
+            var key = keys[i];
+            if (!self.isSafeRequestHeader(key)) return;
+            var value = params.headers[key];
+            if (isArray(value)) {
+                for (var j = 0; j < value.length; j++) {
+                    xhr.setRequestHeader(key, value[j]);
+                }
+            }
+            else xhr.setRequestHeader(key, value)
+        }
+    }
+    if (params.auth) {
+        //basic auth
+        this.setHeader('Authorization', 'Basic ' + new Buffer(params.auth).toString('base64'));
+    }
+    var res = new Response;
+    res.on('close', function () {
+        self.emit('close');
+    });
+    res.on('ready', function () {
+        self.emit('response', res);
+    });
+    xhr.onreadystatechange = function () {
+        res.handle(xhr);
+    };
+};
+Request.prototype = new Stream;
+Request.prototype.setHeader = function (key, value) {
+    if (isArray(value)) {
+        for (var i = 0; i < value.length; i++) {
+            this.xhr.setRequestHeader(key, value[i]);
+        }
+    }
+    else {
+        this.xhr.setRequestHeader(key, value);
+    }
+};
+Request.prototype.write = function (s) {
+    this.body.write(s);
+};
+Request.prototype.destroy = function (s) {
+    this.xhr.abort();
+    this.emit('close');
+};
+Request.prototype.end = function (s) {
+    if (s !== undefined) this.body.write(s);
+    this.body.end()
+    this.xhr.send(this.body.getBody());
+};
+// Taken from http://dxr.mozilla.org/mozilla/mozilla-central/content/base/src/nsXMLHttpRequest.cpp.html
+Request.unsafeHeaders = [
+    "accept-charset",
+    "accept-encoding",
+    "access-control-request-headers",
+    "access-control-request-method",
+    "connection",
+    "content-length",
+    "cookie",
+    "cookie2",
+    "content-transfer-encoding",
+    "date",
+    "expect",
+    "host",
+    "keep-alive",
+    "origin",
+    "referer",
+    "te",
+    "trailer",
+    "transfer-encoding",
+    "upgrade",
+    "user-agent",
+    "via"
+];
+Request.prototype.isSafeRequestHeader = function (headerName) {
+    if (!headerName) return false;
+    return indexOf(Request.unsafeHeaders, headerName.toLowerCase()) === -1;
+};
+var objectKeys = Object.keys || function (obj) {
+    var keys = [];
+    for (var key in obj) keys.push(key);
+    return keys;
+};
+var isArray = Array.isArray || function (xs) {
+    return Object.prototype.toString.call(xs) === '[object Array]';
+};
+var indexOf = function (xs, x) {
+    if (xs.indexOf) return xs.indexOf(x);
+    for (var i = 0; i < xs.length; i++) {
+        if (xs[i] === x) return i;
+    }
+    return -1;
+};

data/node_modules/browserify/node_modules/http-browserify/lib/response.js ADDED

@@ -0,0 +1,119 @@
+var Stream = require('stream');
+var Response = module.exports = function (res) {
+    this.offset = 0;
+    this.readable = true;
+};
+Response.prototype = new Stream;
+var capable = {
+    streaming : true,
+    status2 : true
+};
+function parseHeaders (res) {
+    var lines = res.getAllResponseHeaders().split(/\r?\n/);
+    var headers = {};
+    for (var i = 0; i < lines.length; i++) {
+        var line = lines[i];
+        if (line === '') continue;
+        var m = line.match(/^([^:]+):\s*(.*)/);
+        if (m) {
+            var key = m[1].toLowerCase(), value = m[2];
+            if (headers[key] !== undefined) {
+                if (isArray(headers[key])) {
+                    headers[key].push(value);
+                }
+                else {
+                    headers[key] = [ headers[key], value ];
+                }
+            }
+            else {
+                headers[key] = value;
+            }
+        }
+        else {
+            headers[line] = true;
+        }
+    }
+    return headers;
+}
+Response.prototype.getResponse = function (xhr) {
+    var respType = String(xhr.responseType).toLowerCase();
+    if (respType === 'blob') return xhr.responseBlob || xhr.response;
+    if (respType === 'arraybuffer') return xhr.response;
+    return xhr.responseText;
+}
+Response.prototype.getHeader = function (key) {
+    return this.headers[key.toLowerCase()];
+};
+Response.prototype.handle = function (res) {
+    if (res.readyState === 2 && capable.status2) {
+        try {
+            this.statusCode = res.status;
+            this.headers = parseHeaders(res);
+        }
+        catch (err) {
+            capable.status2 = false;
+        }
+        if (capable.status2) {
+            this.emit('ready');
+        }
+    }
+    else if (capable.streaming && res.readyState === 3) {
+        try {
+            if (!this.statusCode) {
+                this.statusCode = res.status;
+                this.headers = parseHeaders(res);
+                this.emit('ready');
+            }
+        }
+        catch (err) {}
+        try {
+            this._emitData(res);
+        }
+        catch (err) {
+            capable.streaming = false;
+        }
+    }
+    else if (res.readyState === 4) {
+        if (!this.statusCode) {
+            this.statusCode = res.status;
+            this.emit('ready');
+        }
+        this._emitData(res);
+        if (res.error) {
+            this.emit('error', this.getResponse(res));
+        }
+        else this.emit('end');
+        this.emit('close');
+    }
+};
+Response.prototype._emitData = function (res) {
+    var respBody = this.getResponse(res);
+    if (respBody.toString().match(/ArrayBuffer/)) {
+        this.emit('data', new Uint8Array(respBody, this.offset));
+        this.offset = respBody.byteLength;
+        return;
+    }
+    if (respBody.length > this.offset) {
+        this.emit('data', respBody.slice(this.offset));
+        this.offset = respBody.length;
+    }
+};
+var isArray = Array.isArray || function (xs) {
+    return Object.prototype.toString.call(xs) === '[object Array]';
+};

data/node_modules/browserify/node_modules/http-browserify/node_modules/concat-stream/index.js ADDED

@@ -0,0 +1,48 @@
+var stream = require('stream')
+var util = require('util')
+function ConcatStream(cb) {
+  stream.Stream.call(this)
+  this.writable = true
+  if (cb) this.cb = cb
+  this.body = []
+  if (this.cb) this.on('error', cb)
+}
+util.inherits(ConcatStream, stream.Stream)
+ConcatStream.prototype.write = function(chunk) {
+  this.body.push(chunk)
+}
+ConcatStream.prototype.arrayConcat = function(arrs) {
+  if (arrs.length === 0) return []
+  if (arrs.length === 1) return arrs[0]
+  return arrs.reduce(function (a, b) { return a.concat(b) })
+}
+ConcatStream.prototype.isArray = function(arr) {
+  var isArray = Array.isArray(arr)
+  var isTypedArray = arr.toString().match(/Array/)
+  return isArray || isTypedArray
+}
+ConcatStream.prototype.getBody = function () {
+  if (this.body.length === 0) return
+  if (typeof(this.body[0]) === "string") return this.body.join('')
+  if (this.isArray(this.body[0])) return this.arrayConcat(this.body)
+  if (typeof(Buffer) !== "undefined" && Buffer.isBuffer(this.body[0])) {
+    return Buffer.concat(this.body)
+  }
+  return this.body
+}
+ConcatStream.prototype.end = function() {
+  if (this.cb) this.cb(false, this.getBody())
+}
+module.exports = function(cb) {
+  return new ConcatStream(cb)
+}
+module.exports.ConcatStream = ConcatStream

data/node_modules/browserify/node_modules/http-browserify/node_modules/concat-stream/package.json ADDED

@@ -0,0 +1,30 @@
+{
+  "name": "concat-stream",
+  "description": "writable stream that concatenates strings or data and calls a callback with the result",
+  "tags": [
+    "stream",
+    "simple",
+    "util",
+    "utility"
+  ],
+  "version": "0.0.8",
+  "author": {
+    "name": "Max Ogden",
+    "email": "max@maxogden.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "http://github.com/maxogden/node-concat-stream.git"
+  },
+  "bugs": {
+    "url": "http://github.com/maxogden/node-concat-stream/issues"
+  },
+  "engines": [
+    "node >= 0.8.0"
+  ],
+  "readme": "# concat-stream\n\n    npm install concat-stream\n\nthen\n\n    var concat = require('concat-stream')\n    var fs = require('fs')\n    \n    var read = fs.createReadStream('readme.md')\n    var write = concat(function(err, data) {})\n    \n    read.pipe(write)\n    \nworks with arrays too!\n\n    var write = concat(function(err, data) {})\n    write.write([1,2,3])\n    write.write([4,5,6])\n    write.end()\n    // data will be [1,2,3,4,5,6] in the above callback\n\nworks with buffers too! can't believe the deals!\n\n    var write = concat(function(err, data) {})\n    write.write(new Buffer('hello '))\n    write.write(new Buffer('world'))\n    write.end()\n    // data will be a buffer that toString()s to 'hello world' in the above callback\n    \nMIT LICENSE\n",
+  "readmeFilename": "readme.md",
+  "homepage": "https://github.com/maxogden/node-concat-stream",
+  "_id": "concat-stream@0.0.8",
+  "_from": "concat-stream@0.0.8"
+}