first commit

themes/ceras/node_modules/promised-io/engines/node/http-client.js

@@ -0,0 +1,113 @@
+/**
+* HTTP Client using the JSGI standard objects
+*/
+var defer = require("../../promise").defer,
+	when = require("../../promise").when,
+	LazyArray = require("../../lazy-array").LazyArray,
+	http = require("http"),
+	https = require("https"),
+	parse = require("url").parse;
+
+// configurable proxy server setting, defaults to http_proxy env var
+exports.proxyServer = require("../../process").env.http_proxy;
+
+exports.request = function(originalRequest){
+	// make a shallow copy of original request object
+	var request = {};
+	for(var key in originalRequest){
+		if(originalRequest.hasOwnProperty(key)){
+			request[key] = originalRequest[key];
+		}
+	}
+
+	if(request.timeout === undefined)request.timeout= 20000; // default timeout.
+	if(request.url){
+		var parsed = parse(request.url);
+		if (parsed.pathname) {
+			parsed.pathInfo = parsed.pathname;
+		} else {
+			parsed.pathInfo = "/";
+		}
+		request.queryString = parsed.query || "";
+		for(var i in parsed){
+			request[i] = parsed[i];
+		}
+	}
+	var deferred = defer();
+	if(exports.proxyServer){
+		request.pathname = request.url;
+		var proxySettings = parse(exports.proxyServer);
+		request.port = proxySettings.port;
+		request.protocol = proxySettings.protocol;
+		request.hostname = proxySettings.hostname;
+	}
+	if(!request.protocol){
+		throw new Error("No valid protocol/URL provided");
+	}
+	var timedOut, bodyDeferred;
+	// Limits the time of sending the request + receiving the response header to 20 seconds.
+	// No timeout is used on the client stream, but we do destroy the stream if a timeout is reached.
+	var timeout = setTimeout(function(){
+		timedOut = true;
+		req.destroy();
+		deferred.reject(new Error("Timeout"));
+	}, request.timeout);
+
+	var secure = request.protocol.indexOf("s") > -1;
+	request.port = request.port || (secure ? 443 : 80);
+	request.headers = request.headers || {host: request.host || request.hostname + (request.port ? ":" + request.port : "")};
+	request.host = request.hostname;
+	request.method = request.method || "GET";
+	request.path = request.pathname || request.pathInfo || "";
+	if (request.queryString) {
+		request.path += "?"+request.queryString;
+	}
+	var timedOut;
+
+	var req = (secure ? https : http).request(request);
+	req.on("response", function (response){
+		if(timedOut){
+			return;
+		}
+		response.status = response.statusCode;
+		var sendData = function(block){
+			buffer.push(block);
+		};
+		var buffer = [];
+		bodyDeferred = defer();
+		var body = response.body = LazyArray({
+			some: function(callback){
+				buffer.forEach(callback);
+				sendData = callback;
+				return bodyDeferred.promise;
+			}
+		});
+		response.setEncoding(request.encoding || "utf8");
+
+		response.on("data", function (chunk) {
+			sendData(chunk);
+		});
+		response.on("end", function(){
+			bodyDeferred.resolve();
+		});
+		deferred.resolve(response);
+		clearTimeout(timeout);
+	});
+	req.on('error', function(e) {
+		if (!timedOut) {
+            deferred.reject(e);
+            clearTimeout(timeout);
+        }
+	});
+	if(request.body){
+		return when(request.body.forEach(function(block){
+			req.write(block);
+		}), function(){
+			req.end();
+			return deferred.promise;
+		});
+	}else{
+		req.end();
+		return deferred.promise;
+	}
+};

themes/ceras/node_modules/promised-io/engines/rhino/delay.js

@@ -0,0 +1,79 @@
+/*
+ * Provides time-based promise-returning delay and schedule functions for Rhino
+ */
+var defer = require("../../promise").defer,
+	LazyArray = require("../../lazy-array").LazyArray;
+// returns a promise that is fulfilled after the given number of milliseconds
+exports.delay = function(ms){
+	var deferred = defer();
+	_scheduleTimeout(deferred.resolve, ms, false);
+	return deferred.promise;
+};
+// returns a lazy array that iterates one every given number of milliseconds
+exports.schedule = function(ms){
+	var callbacks = [];
+	_scheduleTimeout(function(){
+		callbacks.forEach(function(callback){
+			if(callback()){
+				callbacks.splice(callbacks.indexOf(callback), 1);
+			}
+		});
+	}, ms, true);
+	return LazyArray({
+		some: function(callback){
+			callbacks.push(callback);
+		}
+	});
+};
+
+var nextId = 1,
+    timeouts = {},
+    timer,
+    queue;
+
+var _scheduleTimeout = function(callback, delay, repeat)
+{
+    if (typeof callback == "function")
+        var func = callback;
+    else if (typeof callback == "string")
+        var func = new Function(callback);
+    else
+        return;
+
+    var timeout = {
+    };
+    var id = nextId++;
+    timeouts[id] = timeout;
+
+    timer = timer || new java.util.Timer("JavaScript timer thread", true);
+    queue = queue || require("event-loop");
+    var lastFinished = true;
+    var task = timeout.task = new java.util.TimerTask({
+        run: function(){
+        	if(lastFinished){
+	        	lastFinished = false;
+	            queue.enqueue(function(){
+	                if(!timeout.cancelled){ // check to make sure it wasn't enqueued and then later cancelled
+		            	try{
+		                    func();
+		            	}finally{
+		                	lastFinished = true;
+		            	}
+	                }
+	            });
+        	}
+        }
+    });
+    delay = Math.floor(delay);
+
+    if(repeat){
+        timer.schedule(task, delay, delay);
+    }
+    else{
+        timer.schedule(task, delay);
+    }
+
+    return id;
+}
+
+

themes/ceras/node_modules/promised-io/engines/rhino/fs.js

@@ -0,0 +1,74 @@
+var File = require("fs"),
+	LazyArray = require("../../lazy-array").LazyArray,
+    defer = require("../../promise").defer;
+for(var i in File){
+	exports[i] = File[i];
+}
+
+exports.readFileSync = File.read;
+exports.writeFileSync = File.write;
+exports.mkdirSync = File.mkdir;
+exports.readdir = exports.list;
+exports.stat = exports.statSync = function(path) {
+	try{
+		return {
+			isFile: function(){
+				return File.isFile(path);
+			},
+			size: File.size(path)
+		};
+	}catch(e){
+		var deferred = defer();
+		deferred.reject(e);
+		return deferred.promise;
+	}
+};
+
+exports.makeTree = File.mkdirs;
+exports.makeDirectory = File.mkdir;
+
+exports.open = function(){
+	var file = File.open.apply(this, arguments);
+	var array = LazyArray({
+		some: function(callback){
+			while(true){
+				var buffer = file.read(4096);
+				if(buffer.length <= 0){
+					return;
+				}
+				if(callback(buffer)){
+					return;
+				}
+			}
+		}
+	});
+	for(var i in array){
+		file[i] = array[i];
+	}
+	return file;
+};
+exports.openSync = exports.open;
+
+exports.createWriteStream = function(path, options) {
+    options = options || {};
+    options.flags = options.flags || "w";
+    var flags = options.flags || "w",
+        f = File.open(path, flags);
+    return {
+        writable: true,
+        write: function() {
+            var deferred = defer();
+            try {
+                f.write.apply(this, arguments);
+                f.flush();
+            }
+            catch (e) {
+                return stream.writable = false;
+            }
+            deferred.resolve();
+            return deferred.promise;
+        },
+        end: f.close,
+        destroy: f.close
+    }
+}

themes/ceras/node_modules/promised-io/engines/rhino/rhino-http-client.js

@@ -0,0 +1,84 @@
+/**
+* HTTP Client using the JSGI standard objects
+*/
+
+var LazyArray = require("../../lazy-array").LazyArray;
+
+// configurable proxy server setting, defaults to http_proxy env var
+exports.proxyServer = require("../../process").env.http_proxy;
+
+exports.request = function(request){
+	var url = new java.net.URL(request.url),
+		connection = url.openConnection(),
+		method = request.method || "GET",
+		is = null,
+		promised = true;
+
+	if (request.jsgi && "async" in request.jsgi) promised = request.jsgi.async;
+
+	for (var header in this.headers) {
+		var value = this.headers[header];
+		connection.addRequestProperty(String(header), String(value));
+	}
+	connection.setFollowRedirects(false)
+	connection.setDoInput(true);
+	connection.setRequestMethod(method);
+	if (request.body && typeof request.body.forEach === "function") {
+		connection.setDoOutput(true);
+		var writer = new java.io.OutputStreamWriter(connection.getOutputStream());
+		request.body.forEach(function(chunk) {
+			writer.write(chunk);
+			writer.flush();
+		});
+	}
+	if (typeof writer !== "undefined") writer.close();
+
+	try {
+		connection.connect();
+		is = connection.getInputStream();
+	}
+	catch (e) {
+		is = connection.getErrorStream();
+	}
+
+	var status = Number(connection.getResponseCode()),
+		headers = {};
+	for (var i = 0;; i++) {
+		var key = connection.getHeaderFieldKey(i),
+			value = connection.getHeaderField(i);
+		if (!key && !value)
+			break;
+		// returns the HTTP status code with no key, ignore it.
+		if (key) {
+			key = String(key).toLowerCase();
+			value = String(value);
+			if (headers[key]) {
+				if (!Array.isArray(headers[key])) headers[key] = [headers[key]];
+				headers[key].push(value);
+			}
+			else {
+				headers[key] = value;
+			}
+		}
+	}
+
+	var reader = new java.io.BufferedReader(new java.io.InputStreamReader(is)),
+		builder = new java.lang.StringBuilder(),
+		line;
+	// FIXME create deferred and LazyArray
+	while((line = reader.readLine()) != null){
+		builder.append(line + '\n');
+	}
+	if (typeof writer !== "undefined") writer.close();
+	reader.close();
+
+	return {
+		status: status,
+		headers: headers,
+		body: LazyArray({
+			some: function(write) {
+				write(builder.toString());
+			}
+		})
+	}
+};