mirror of
https://github.com/yu-i-i/overleaf-cep.git
synced 2026-11-13 21:53:43 +01:00
prettier: convert miscellaneous files to Prettier format
This commit is contained in:
decaffeinate
committed by
Jakob Ackermann
Jakob Ackermann
parent
92dede867f
commit
53058452ee
@@ -1,51 +1,51 @@
|
||||
// EventEmitter has been removed from process in node >= 7
|
||||
// https://github.com/nodejs/node/commit/62b544290a075fe38e233887a06c408ba25a1c71
|
||||
if(process.versions.node.split('.')[0] >= 7) {
|
||||
if (process.versions.node.split('.')[0] >= 7) {
|
||||
process.EventEmitter = require('events')
|
||||
}
|
||||
|
||||
var io = require("socket.io");
|
||||
var io = require('socket.io')
|
||||
|
||||
if (io.version === "0.9.16" || io.version === "0.9.19") {
|
||||
console.log("patching socket.io hybi-16 transport frame prototype");
|
||||
var transports = require("socket.io/lib/transports/websocket/hybi-16.js");
|
||||
transports.prototype.frame = patchedFrameHandler;
|
||||
if (io.version === '0.9.16' || io.version === '0.9.19') {
|
||||
console.log('patching socket.io hybi-16 transport frame prototype')
|
||||
var transports = require('socket.io/lib/transports/websocket/hybi-16.js')
|
||||
transports.prototype.frame = patchedFrameHandler
|
||||
// file hybi-07-12 has the same problem but no browsers are using that protocol now
|
||||
}
|
||||
|
||||
function patchedFrameHandler(opcode, str) {
|
||||
var dataBuffer = new Buffer(str),
|
||||
dataLength = dataBuffer.length,
|
||||
startOffset = 2,
|
||||
secondByte = dataLength;
|
||||
var dataBuffer = new Buffer(str)
|
||||
var dataLength = dataBuffer.length
|
||||
var startOffset = 2
|
||||
var secondByte = dataLength
|
||||
if (dataLength === 65536) {
|
||||
console.log("fixing invalid frame length in socket.io");
|
||||
console.log('fixing invalid frame length in socket.io')
|
||||
}
|
||||
if (dataLength > 65535) {
|
||||
// original code had > 65536
|
||||
startOffset = 10;
|
||||
secondByte = 127;
|
||||
startOffset = 10
|
||||
secondByte = 127
|
||||
} else if (dataLength > 125) {
|
||||
startOffset = 4;
|
||||
secondByte = 126;
|
||||
startOffset = 4
|
||||
secondByte = 126
|
||||
}
|
||||
var outputBuffer = new Buffer(dataLength + startOffset);
|
||||
outputBuffer[0] = opcode;
|
||||
outputBuffer[1] = secondByte;
|
||||
dataBuffer.copy(outputBuffer, startOffset);
|
||||
var outputBuffer = new Buffer(dataLength + startOffset)
|
||||
outputBuffer[0] = opcode
|
||||
outputBuffer[1] = secondByte
|
||||
dataBuffer.copy(outputBuffer, startOffset)
|
||||
switch (secondByte) {
|
||||
case 126:
|
||||
outputBuffer[2] = dataLength >>> 8;
|
||||
outputBuffer[3] = dataLength % 256;
|
||||
break;
|
||||
outputBuffer[2] = dataLength >>> 8
|
||||
outputBuffer[3] = dataLength % 256
|
||||
break
|
||||
case 127:
|
||||
var l = dataLength;
|
||||
var l = dataLength
|
||||
for (var i = 1; i <= 8; ++i) {
|
||||
outputBuffer[startOffset - i] = l & 0xff;
|
||||
l >>>= 8;
|
||||
outputBuffer[startOffset - i] = l & 0xff
|
||||
l >>>= 8
|
||||
}
|
||||
}
|
||||
return outputBuffer;
|
||||
return outputBuffer
|
||||
}
|
||||
|
||||
const parser = require('socket.io/lib/parser')
|
||||
|
||||
@@ -11,100 +11,96 @@
|
||||
* @license MIT
|
||||
*/
|
||||
|
||||
var Url = require("url")
|
||||
, spawn = require("child_process").spawn
|
||||
, fs = require('fs');
|
||||
var Url = require('url')
|
||||
var spawn = require('child_process').spawn
|
||||
var fs = require('fs')
|
||||
|
||||
exports.XMLHttpRequest = function() {
|
||||
exports.XMLHttpRequest = function () {
|
||||
/**
|
||||
* Private variables
|
||||
*/
|
||||
var self = this;
|
||||
var http = require('http');
|
||||
var https = require('https');
|
||||
var self = this
|
||||
var http = require('http')
|
||||
var https = require('https')
|
||||
|
||||
// Holds http.js objects
|
||||
var client;
|
||||
var request;
|
||||
var response;
|
||||
var client
|
||||
var request
|
||||
var response
|
||||
|
||||
// Request settings
|
||||
var settings = {};
|
||||
var settings = {}
|
||||
|
||||
// Set some default headers
|
||||
var defaultHeaders = {
|
||||
"User-Agent": "node-XMLHttpRequest",
|
||||
"Accept": "*/*",
|
||||
};
|
||||
'User-Agent': 'node-XMLHttpRequest',
|
||||
Accept: '*/*'
|
||||
}
|
||||
|
||||
var headers = defaultHeaders;
|
||||
var headers = defaultHeaders
|
||||
|
||||
// These headers are not user setable.
|
||||
// The following are allowed but banned in the spec:
|
||||
// * user-agent
|
||||
var forbiddenRequestHeaders = [
|
||||
"accept-charset",
|
||||
"accept-encoding",
|
||||
"access-control-request-headers",
|
||||
"access-control-request-method",
|
||||
"connection",
|
||||
"content-length",
|
||||
"content-transfer-encoding",
|
||||
//"cookie",
|
||||
"cookie2",
|
||||
"date",
|
||||
"expect",
|
||||
"host",
|
||||
"keep-alive",
|
||||
"origin",
|
||||
"referer",
|
||||
"te",
|
||||
"trailer",
|
||||
"transfer-encoding",
|
||||
"upgrade",
|
||||
"via"
|
||||
];
|
||||
'accept-charset',
|
||||
'accept-encoding',
|
||||
'access-control-request-headers',
|
||||
'access-control-request-method',
|
||||
'connection',
|
||||
'content-length',
|
||||
'content-transfer-encoding',
|
||||
// "cookie",
|
||||
'cookie2',
|
||||
'date',
|
||||
'expect',
|
||||
'host',
|
||||
'keep-alive',
|
||||
'origin',
|
||||
'referer',
|
||||
'te',
|
||||
'trailer',
|
||||
'transfer-encoding',
|
||||
'upgrade',
|
||||
'via'
|
||||
]
|
||||
|
||||
// These request methods are not allowed
|
||||
var forbiddenRequestMethods = [
|
||||
"TRACE",
|
||||
"TRACK",
|
||||
"CONNECT"
|
||||
];
|
||||
var forbiddenRequestMethods = ['TRACE', 'TRACK', 'CONNECT']
|
||||
|
||||
// Send flag
|
||||
var sendFlag = false;
|
||||
var sendFlag = false
|
||||
// Error flag, used when errors occur or abort is called
|
||||
var errorFlag = false;
|
||||
var errorFlag = false
|
||||
|
||||
// Event listeners
|
||||
var listeners = {};
|
||||
var listeners = {}
|
||||
|
||||
/**
|
||||
* Constants
|
||||
*/
|
||||
|
||||
this.UNSENT = 0;
|
||||
this.OPENED = 1;
|
||||
this.HEADERS_RECEIVED = 2;
|
||||
this.LOADING = 3;
|
||||
this.DONE = 4;
|
||||
this.UNSENT = 0
|
||||
this.OPENED = 1
|
||||
this.HEADERS_RECEIVED = 2
|
||||
this.LOADING = 3
|
||||
this.DONE = 4
|
||||
|
||||
/**
|
||||
* Public vars
|
||||
*/
|
||||
|
||||
// Current state
|
||||
this.readyState = this.UNSENT;
|
||||
this.readyState = this.UNSENT
|
||||
|
||||
// default ready state change handler in case one is not set or is set late
|
||||
this.onreadystatechange = null;
|
||||
this.onreadystatechange = null
|
||||
|
||||
// Result & response
|
||||
this.responseText = "";
|
||||
this.responseXML = "";
|
||||
this.status = null;
|
||||
this.statusText = null;
|
||||
this.responseText = ''
|
||||
this.responseXML = ''
|
||||
this.status = null
|
||||
this.statusText = null
|
||||
|
||||
/**
|
||||
* Private methods
|
||||
@@ -116,9 +112,11 @@ exports.XMLHttpRequest = function() {
|
||||
* @param string header Header to validate
|
||||
* @return boolean False if not allowed, otherwise true
|
||||
*/
|
||||
var isAllowedHttpHeader = function(header) {
|
||||
return (header && forbiddenRequestHeaders.indexOf(header.toLowerCase()) === -1);
|
||||
};
|
||||
var isAllowedHttpHeader = function (header) {
|
||||
return (
|
||||
header && forbiddenRequestHeaders.indexOf(header.toLowerCase()) === -1
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if the specified method is allowed.
|
||||
@@ -126,9 +124,9 @@ exports.XMLHttpRequest = function() {
|
||||
* @param string method Request method to validate
|
||||
* @return boolean False if not allowed, otherwise true
|
||||
*/
|
||||
var isAllowedHttpMethod = function(method) {
|
||||
return (method && forbiddenRequestMethods.indexOf(method) === -1);
|
||||
};
|
||||
var isAllowedHttpMethod = function (method) {
|
||||
return method && forbiddenRequestMethods.indexOf(method) === -1
|
||||
}
|
||||
|
||||
/**
|
||||
* Public methods
|
||||
@@ -143,26 +141,26 @@ exports.XMLHttpRequest = function() {
|
||||
* @param string user Username for basic authentication (optional)
|
||||
* @param string password Password for basic authentication (optional)
|
||||
*/
|
||||
this.open = function(method, url, async, user, password) {
|
||||
this.abort();
|
||||
errorFlag = false;
|
||||
this.open = function (method, url, async, user, password) {
|
||||
this.abort()
|
||||
errorFlag = false
|
||||
|
||||
// Check for valid request method
|
||||
if (!isAllowedHttpMethod(method)) {
|
||||
throw "SecurityError: Request method not allowed";
|
||||
return;
|
||||
throw 'SecurityError: Request method not allowed'
|
||||
return
|
||||
}
|
||||
|
||||
settings = {
|
||||
"method": method,
|
||||
"url": url.toString(),
|
||||
"async": (typeof async !== "boolean" ? true : async),
|
||||
"user": user || null,
|
||||
"password": password || null
|
||||
};
|
||||
method: method,
|
||||
url: url.toString(),
|
||||
async: typeof async !== 'boolean' ? true : async,
|
||||
user: user || null,
|
||||
password: password || null
|
||||
}
|
||||
|
||||
setState(this.OPENED);
|
||||
};
|
||||
setState(this.OPENED)
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets a header for the request.
|
||||
@@ -170,19 +168,19 @@ exports.XMLHttpRequest = function() {
|
||||
* @param string header Header name
|
||||
* @param string value Header value
|
||||
*/
|
||||
this.setRequestHeader = function(header, value) {
|
||||
this.setRequestHeader = function (header, value) {
|
||||
if (this.readyState != this.OPENED) {
|
||||
throw "INVALID_STATE_ERR: setRequestHeader can only be called when state is OPEN";
|
||||
throw 'INVALID_STATE_ERR: setRequestHeader can only be called when state is OPEN'
|
||||
}
|
||||
if (!isAllowedHttpHeader(header)) {
|
||||
console.warn('Refused to set unsafe header "' + header + '"');
|
||||
return;
|
||||
console.warn('Refused to set unsafe header "' + header + '"')
|
||||
return
|
||||
}
|
||||
if (sendFlag) {
|
||||
throw "INVALID_STATE_ERR: send flag is true";
|
||||
throw 'INVALID_STATE_ERR: send flag is true'
|
||||
}
|
||||
headers[header] = value;
|
||||
};
|
||||
headers[header] = value
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets a header from the server response.
|
||||
@@ -190,37 +188,38 @@ exports.XMLHttpRequest = function() {
|
||||
* @param string header Name of header to get.
|
||||
* @return string Text of the header or null if it doesn't exist.
|
||||
*/
|
||||
this.getResponseHeader = function(header) {
|
||||
if (typeof header === "string"
|
||||
&& this.readyState > this.OPENED
|
||||
&& response.headers[header.toLowerCase()]
|
||||
&& !errorFlag
|
||||
this.getResponseHeader = function (header) {
|
||||
if (
|
||||
typeof header === 'string' &&
|
||||
this.readyState > this.OPENED &&
|
||||
response.headers[header.toLowerCase()] &&
|
||||
!errorFlag
|
||||
) {
|
||||
return response.headers[header.toLowerCase()];
|
||||
return response.headers[header.toLowerCase()]
|
||||
}
|
||||
|
||||
return null;
|
||||
};
|
||||
return null
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets all the response headers.
|
||||
*
|
||||
* @return string A string with all response headers separated by CR+LF
|
||||
*/
|
||||
this.getAllResponseHeaders = function() {
|
||||
this.getAllResponseHeaders = function () {
|
||||
if (this.readyState < this.HEADERS_RECEIVED || errorFlag) {
|
||||
return "";
|
||||
return ''
|
||||
}
|
||||
var result = "";
|
||||
var result = ''
|
||||
|
||||
for (var i in response.headers) {
|
||||
// Cookie headers are excluded
|
||||
if (i !== "set-cookie" && i !== "set-cookie2") {
|
||||
result += i + ": " + response.headers[i] + "\r\n";
|
||||
if (i !== 'set-cookie' && i !== 'set-cookie2') {
|
||||
result += i + ': ' + response.headers[i] + '\r\n'
|
||||
}
|
||||
}
|
||||
return result.substr(0, result.length - 2);
|
||||
};
|
||||
return result.substr(0, result.length - 2)
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets a request header
|
||||
@@ -228,13 +227,13 @@ exports.XMLHttpRequest = function() {
|
||||
* @param string name Name of header to get
|
||||
* @return string Returns the request header or empty string if not set
|
||||
*/
|
||||
this.getRequestHeader = function(name) {
|
||||
this.getRequestHeader = function (name) {
|
||||
// @TODO Make this case insensitive
|
||||
if (typeof name === "string" && headers[name]) {
|
||||
return headers[name];
|
||||
if (typeof name === 'string' && headers[name]) {
|
||||
return headers[name]
|
||||
}
|
||||
|
||||
return "";
|
||||
return ''
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -242,103 +241,104 @@ exports.XMLHttpRequest = function() {
|
||||
*
|
||||
* @param string data Optional data to send as request body.
|
||||
*/
|
||||
this.send = function(data) {
|
||||
this.send = function (data) {
|
||||
if (this.readyState != this.OPENED) {
|
||||
throw "INVALID_STATE_ERR: connection must be opened before send() is called";
|
||||
throw 'INVALID_STATE_ERR: connection must be opened before send() is called'
|
||||
}
|
||||
|
||||
if (sendFlag) {
|
||||
throw "INVALID_STATE_ERR: send has already been called";
|
||||
throw 'INVALID_STATE_ERR: send has already been called'
|
||||
}
|
||||
|
||||
var ssl = false, local = false;
|
||||
var url = Url.parse(settings.url);
|
||||
var ssl = false
|
||||
var local = false
|
||||
var url = Url.parse(settings.url)
|
||||
|
||||
// Determine the server
|
||||
switch (url.protocol) {
|
||||
case 'https:':
|
||||
ssl = true;
|
||||
// SSL & non-SSL both need host, no break here.
|
||||
ssl = true
|
||||
// SSL & non-SSL both need host, no break here.
|
||||
case 'http:':
|
||||
var host = url.hostname;
|
||||
break;
|
||||
var host = url.hostname
|
||||
break
|
||||
|
||||
case 'file:':
|
||||
local = true;
|
||||
break;
|
||||
local = true
|
||||
break
|
||||
|
||||
case undefined:
|
||||
case '':
|
||||
var host = "localhost";
|
||||
break;
|
||||
var host = 'localhost'
|
||||
break
|
||||
|
||||
default:
|
||||
throw "Protocol not supported.";
|
||||
throw 'Protocol not supported.'
|
||||
}
|
||||
|
||||
// Load files off the local filesystem (file://)
|
||||
if (local) {
|
||||
if (settings.method !== "GET") {
|
||||
throw "XMLHttpRequest: Only GET method is supported";
|
||||
if (settings.method !== 'GET') {
|
||||
throw 'XMLHttpRequest: Only GET method is supported'
|
||||
}
|
||||
|
||||
if (settings.async) {
|
||||
fs.readFile(url.pathname, 'utf8', function(error, data) {
|
||||
fs.readFile(url.pathname, 'utf8', (error, data) => {
|
||||
if (error) {
|
||||
self.handleError(error);
|
||||
self.handleError(error)
|
||||
} else {
|
||||
self.status = 200;
|
||||
self.responseText = data;
|
||||
setState(self.DONE);
|
||||
self.status = 200
|
||||
self.responseText = data
|
||||
setState(self.DONE)
|
||||
}
|
||||
});
|
||||
})
|
||||
} else {
|
||||
try {
|
||||
this.responseText = fs.readFileSync(url.pathname, 'utf8');
|
||||
this.status = 200;
|
||||
setState(self.DONE);
|
||||
} catch(e) {
|
||||
this.handleError(e);
|
||||
this.responseText = fs.readFileSync(url.pathname, 'utf8')
|
||||
this.status = 200
|
||||
setState(self.DONE)
|
||||
} catch (e) {
|
||||
this.handleError(e)
|
||||
}
|
||||
}
|
||||
|
||||
return;
|
||||
return
|
||||
}
|
||||
|
||||
// Default to port 80. If accessing localhost on another port be sure
|
||||
// to use http://localhost:port/path
|
||||
var port = url.port || (ssl ? 443 : 80);
|
||||
var port = url.port || (ssl ? 443 : 80)
|
||||
// Add query string if one is used
|
||||
var uri = url.pathname + (url.search ? url.search : '');
|
||||
var uri = url.pathname + (url.search ? url.search : '')
|
||||
|
||||
// Set the Host header or the server may reject the request
|
||||
headers["Host"] = host;
|
||||
headers.Host = host
|
||||
if (!((ssl && port === 443) || port === 80)) {
|
||||
headers["Host"] += ':' + url.port;
|
||||
headers.Host += ':' + url.port
|
||||
}
|
||||
|
||||
// Set Basic Auth if necessary
|
||||
if (settings.user) {
|
||||
if (typeof settings.password == "undefined") {
|
||||
settings.password = "";
|
||||
if (typeof settings.password === 'undefined') {
|
||||
settings.password = ''
|
||||
}
|
||||
var authBuf = new Buffer(settings.user + ":" + settings.password);
|
||||
headers["Authorization"] = "Basic " + authBuf.toString("base64");
|
||||
var authBuf = new Buffer(settings.user + ':' + settings.password)
|
||||
headers.Authorization = 'Basic ' + authBuf.toString('base64')
|
||||
}
|
||||
|
||||
// Set content length header
|
||||
if (settings.method === "GET" || settings.method === "HEAD") {
|
||||
data = null;
|
||||
if (settings.method === 'GET' || settings.method === 'HEAD') {
|
||||
data = null
|
||||
} else if (data) {
|
||||
headers["Content-Length"] = Buffer.byteLength(data);
|
||||
headers['Content-Length'] = Buffer.byteLength(data)
|
||||
|
||||
if (!headers["Content-Type"]) {
|
||||
headers["Content-Type"] = "text/plain;charset=UTF-8";
|
||||
if (!headers['Content-Type']) {
|
||||
headers['Content-Type'] = 'text/plain;charset=UTF-8'
|
||||
}
|
||||
} else if (settings.method === "POST") {
|
||||
} else if (settings.method === 'POST') {
|
||||
// For a post with no data set Content-Length: 0.
|
||||
// This is required by buggy servers that don't meet the specs.
|
||||
headers["Content-Length"] = 0;
|
||||
headers['Content-Length'] = 0
|
||||
}
|
||||
|
||||
var options = {
|
||||
@@ -347,202 +347,229 @@ exports.XMLHttpRequest = function() {
|
||||
path: uri,
|
||||
method: settings.method,
|
||||
headers: headers
|
||||
};
|
||||
}
|
||||
|
||||
// Reset error flag
|
||||
errorFlag = false;
|
||||
errorFlag = false
|
||||
|
||||
// Handle async requests
|
||||
if (settings.async) {
|
||||
// Use the proper protocol
|
||||
var doRequest = ssl ? https.request : http.request;
|
||||
var doRequest = ssl ? https.request : http.request
|
||||
|
||||
// Request is being sent, set send flag
|
||||
sendFlag = true;
|
||||
sendFlag = true
|
||||
|
||||
// As per spec, this is called here for historical reasons.
|
||||
self.dispatchEvent("readystatechange");
|
||||
self.dispatchEvent('readystatechange')
|
||||
|
||||
// Create the request
|
||||
request = doRequest(options, function(resp) {
|
||||
response = resp;
|
||||
response.setEncoding("utf8");
|
||||
request = doRequest(options, (resp) => {
|
||||
response = resp
|
||||
response.setEncoding('utf8')
|
||||
|
||||
setState(self.HEADERS_RECEIVED);
|
||||
self.status = response.statusCode;
|
||||
setState(self.HEADERS_RECEIVED)
|
||||
self.status = response.statusCode
|
||||
|
||||
response.on('data', function(chunk) {
|
||||
response.on('data', (chunk) => {
|
||||
// Make sure there's some data
|
||||
if (chunk) {
|
||||
self.responseText += chunk;
|
||||
self.responseText += chunk
|
||||
}
|
||||
// Don't emit state changes if the connection has been aborted.
|
||||
if (sendFlag) {
|
||||
setState(self.LOADING);
|
||||
setState(self.LOADING)
|
||||
}
|
||||
});
|
||||
})
|
||||
|
||||
response.on('end', function() {
|
||||
response.on('end', () => {
|
||||
if (sendFlag) {
|
||||
// Discard the 'end' event if the connection has been aborted
|
||||
setState(self.DONE);
|
||||
sendFlag = false;
|
||||
setState(self.DONE)
|
||||
sendFlag = false
|
||||
}
|
||||
});
|
||||
})
|
||||
|
||||
response.on('error', function(error) {
|
||||
self.handleError(error);
|
||||
});
|
||||
}).on('error', function(error) {
|
||||
self.handleError(error);
|
||||
});
|
||||
response.on('error', (error) => {
|
||||
self.handleError(error)
|
||||
})
|
||||
}).on('error', (error) => {
|
||||
self.handleError(error)
|
||||
})
|
||||
|
||||
// Node 0.4 and later won't accept empty data. Make sure it's needed.
|
||||
if (data) {
|
||||
request.write(data);
|
||||
request.write(data)
|
||||
}
|
||||
|
||||
request.end();
|
||||
request.end()
|
||||
|
||||
self.dispatchEvent("loadstart");
|
||||
} else { // Synchronous
|
||||
self.dispatchEvent('loadstart')
|
||||
} else {
|
||||
// Synchronous
|
||||
// Create a temporary file for communication with the other Node process
|
||||
var syncFile = ".node-xmlhttprequest-sync-" + process.pid;
|
||||
fs.writeFileSync(syncFile, "", "utf8");
|
||||
var syncFile = '.node-xmlhttprequest-sync-' + process.pid
|
||||
fs.writeFileSync(syncFile, '', 'utf8')
|
||||
// The async request the other Node process executes
|
||||
var execString = "var http = require('http'), https = require('https'), fs = require('fs');"
|
||||
+ "var doRequest = http" + (ssl ? "s" : "") + ".request;"
|
||||
+ "var options = " + JSON.stringify(options) + ";"
|
||||
+ "var responseText = '';"
|
||||
+ "var req = doRequest(options, function(response) {"
|
||||
+ "response.setEncoding('utf8');"
|
||||
+ "response.on('data', function(chunk) {"
|
||||
+ "responseText += chunk;"
|
||||
+ "});"
|
||||
+ "response.on('end', function() {"
|
||||
+ "fs.writeFileSync('" + syncFile + "', 'NODE-XMLHTTPREQUEST-STATUS:' + response.statusCode + ',' + responseText, 'utf8');"
|
||||
+ "});"
|
||||
+ "response.on('error', function(error) {"
|
||||
+ "fs.writeFileSync('" + syncFile + "', 'NODE-XMLHTTPREQUEST-ERROR:' + JSON.stringify(error), 'utf8');"
|
||||
+ "});"
|
||||
+ "}).on('error', function(error) {"
|
||||
+ "fs.writeFileSync('" + syncFile + "', 'NODE-XMLHTTPREQUEST-ERROR:' + JSON.stringify(error), 'utf8');"
|
||||
+ "});"
|
||||
+ (data ? "req.write('" + data.replace(/'/g, "\\'") + "');":"")
|
||||
+ "req.end();";
|
||||
var execString =
|
||||
"var http = require('http'), https = require('https'), fs = require('fs');" +
|
||||
'var doRequest = http' +
|
||||
(ssl ? 's' : '') +
|
||||
'.request;' +
|
||||
'var options = ' +
|
||||
JSON.stringify(options) +
|
||||
';' +
|
||||
"var responseText = '';" +
|
||||
'var req = doRequest(options, function(response) {' +
|
||||
"response.setEncoding('utf8');" +
|
||||
"response.on('data', function(chunk) {" +
|
||||
'responseText += chunk;' +
|
||||
'});' +
|
||||
"response.on('end', function() {" +
|
||||
"fs.writeFileSync('" +
|
||||
syncFile +
|
||||
"', 'NODE-XMLHTTPREQUEST-STATUS:' + response.statusCode + ',' + responseText, 'utf8');" +
|
||||
'});' +
|
||||
"response.on('error', function(error) {" +
|
||||
"fs.writeFileSync('" +
|
||||
syncFile +
|
||||
"', 'NODE-XMLHTTPREQUEST-ERROR:' + JSON.stringify(error), 'utf8');" +
|
||||
'});' +
|
||||
"}).on('error', function(error) {" +
|
||||
"fs.writeFileSync('" +
|
||||
syncFile +
|
||||
"', 'NODE-XMLHTTPREQUEST-ERROR:' + JSON.stringify(error), 'utf8');" +
|
||||
'});' +
|
||||
(data ? "req.write('" + data.replace(/'/g, "\\'") + "');" : '') +
|
||||
'req.end();'
|
||||
// Start the other Node Process, executing this string
|
||||
syncProc = spawn(process.argv[0], ["-e", execString]);
|
||||
while((self.responseText = fs.readFileSync(syncFile, 'utf8')) == "") {
|
||||
syncProc = spawn(process.argv[0], ['-e', execString])
|
||||
while ((self.responseText = fs.readFileSync(syncFile, 'utf8')) == '') {
|
||||
// Wait while the file is empty
|
||||
}
|
||||
// Kill the child process once the file has data
|
||||
syncProc.stdin.end();
|
||||
syncProc.stdin.end()
|
||||
// Remove the temporary file
|
||||
fs.unlinkSync(syncFile);
|
||||
fs.unlinkSync(syncFile)
|
||||
if (self.responseText.match(/^NODE-XMLHTTPREQUEST-ERROR:/)) {
|
||||
// If the file returned an error, handle it
|
||||
var errorObj = self.responseText.replace(/^NODE-XMLHTTPREQUEST-ERROR:/, "");
|
||||
self.handleError(errorObj);
|
||||
var errorObj = self.responseText.replace(
|
||||
/^NODE-XMLHTTPREQUEST-ERROR:/,
|
||||
''
|
||||
)
|
||||
self.handleError(errorObj)
|
||||
} else {
|
||||
// If the file returned okay, parse its data and move to the DONE state
|
||||
self.status = self.responseText.replace(/^NODE-XMLHTTPREQUEST-STATUS:([0-9]*),.*/, "$1");
|
||||
self.responseText = self.responseText.replace(/^NODE-XMLHTTPREQUEST-STATUS:[0-9]*,(.*)/, "$1");
|
||||
setState(self.DONE);
|
||||
self.status = self.responseText.replace(
|
||||
/^NODE-XMLHTTPREQUEST-STATUS:([0-9]*),.*/,
|
||||
'$1'
|
||||
)
|
||||
self.responseText = self.responseText.replace(
|
||||
/^NODE-XMLHTTPREQUEST-STATUS:[0-9]*,(.*)/,
|
||||
'$1'
|
||||
)
|
||||
setState(self.DONE)
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Called when an error is encountered to deal with it.
|
||||
*/
|
||||
this.handleError = function(error) {
|
||||
this.status = 503;
|
||||
this.statusText = error;
|
||||
this.responseText = error.stack;
|
||||
errorFlag = true;
|
||||
setState(this.DONE);
|
||||
};
|
||||
this.handleError = function (error) {
|
||||
this.status = 503
|
||||
this.statusText = error
|
||||
this.responseText = error.stack
|
||||
errorFlag = true
|
||||
setState(this.DONE)
|
||||
}
|
||||
|
||||
/**
|
||||
* Aborts a request.
|
||||
*/
|
||||
this.abort = function() {
|
||||
this.abort = function () {
|
||||
if (request) {
|
||||
request.abort();
|
||||
request = null;
|
||||
request.abort()
|
||||
request = null
|
||||
}
|
||||
|
||||
headers = defaultHeaders;
|
||||
this.responseText = "";
|
||||
this.responseXML = "";
|
||||
headers = defaultHeaders
|
||||
this.responseText = ''
|
||||
this.responseXML = ''
|
||||
|
||||
errorFlag = true;
|
||||
errorFlag = true
|
||||
|
||||
if (this.readyState !== this.UNSENT
|
||||
&& (this.readyState !== this.OPENED || sendFlag)
|
||||
&& this.readyState !== this.DONE) {
|
||||
sendFlag = false;
|
||||
setState(this.DONE);
|
||||
if (
|
||||
this.readyState !== this.UNSENT &&
|
||||
(this.readyState !== this.OPENED || sendFlag) &&
|
||||
this.readyState !== this.DONE
|
||||
) {
|
||||
sendFlag = false
|
||||
setState(this.DONE)
|
||||
}
|
||||
this.readyState = this.UNSENT;
|
||||
};
|
||||
this.readyState = this.UNSENT
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds an event listener. Preferred method of binding to events.
|
||||
*/
|
||||
this.addEventListener = function(event, callback) {
|
||||
this.addEventListener = function (event, callback) {
|
||||
if (!(event in listeners)) {
|
||||
listeners[event] = [];
|
||||
listeners[event] = []
|
||||
}
|
||||
// Currently allows duplicate callbacks. Should it?
|
||||
listeners[event].push(callback);
|
||||
};
|
||||
listeners[event].push(callback)
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove an event callback that has already been bound.
|
||||
* Only works on the matching funciton, cannot be a copy.
|
||||
*/
|
||||
this.removeEventListener = function(event, callback) {
|
||||
this.removeEventListener = function (event, callback) {
|
||||
if (event in listeners) {
|
||||
// Filter will return a new array with the callback removed
|
||||
listeners[event] = listeners[event].filter(function(ev) {
|
||||
return ev !== callback;
|
||||
});
|
||||
listeners[event] = listeners[event].filter((ev) => {
|
||||
return ev !== callback
|
||||
})
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Dispatch any events, including both "on" methods and events attached using addEventListener.
|
||||
*/
|
||||
this.dispatchEvent = function(event) {
|
||||
if (typeof self["on" + event] === "function") {
|
||||
self["on" + event]();
|
||||
this.dispatchEvent = function (event) {
|
||||
if (typeof self['on' + event] === 'function') {
|
||||
self['on' + event]()
|
||||
}
|
||||
if (event in listeners) {
|
||||
for (var i = 0, len = listeners[event].length; i < len; i++) {
|
||||
listeners[event][i].call(self);
|
||||
listeners[event][i].call(self)
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Changes readyState and calls onreadystatechange.
|
||||
*
|
||||
* @param int state New state
|
||||
*/
|
||||
var setState = function(state) {
|
||||
var setState = function (state) {
|
||||
if (self.readyState !== state) {
|
||||
self.readyState = state;
|
||||
self.readyState = state
|
||||
|
||||
if (settings.async || self.readyState < self.OPENED || self.readyState === self.DONE) {
|
||||
self.dispatchEvent("readystatechange");
|
||||
if (
|
||||
settings.async ||
|
||||
self.readyState < self.OPENED ||
|
||||
self.readyState === self.DONE
|
||||
) {
|
||||
self.dispatchEvent('readystatechange')
|
||||
}
|
||||
|
||||
if (self.readyState === self.DONE && !errorFlag) {
|
||||
self.dispatchEvent("load");
|
||||
self.dispatchEvent('load')
|
||||
// @TODO figure out InspectorInstrumentation::didLoadXHR(cookie)
|
||||
self.dispatchEvent("loadend");
|
||||
self.dispatchEvent('loadend')
|
||||
}
|
||||
}
|
||||
};
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user