From 42adb2afd4a4d9e99e2b12ba4a1f4ede0ee8cc12 Mon Sep 17 00:00:00 2001 From: "ali.ibrahim" Date: Thu, 29 Sep 2016 15:24:28 +0200 Subject: [PATCH] Fixing lint-js issues. --- lib/browser/api/exports/electron.js | 8 +- lib/browser/api/net.js | 281 ++++++++++++++-------------- 2 files changed, 140 insertions(+), 149 deletions(-) diff --git a/lib/browser/api/exports/electron.js b/lib/browser/api/exports/electron.js index 09d5b0e47aa4..9a486b575dc7 100644 --- a/lib/browser/api/exports/electron.js +++ b/lib/browser/api/exports/electron.js @@ -108,10 +108,10 @@ Object.defineProperties(exports, { } }, net: { - enumerable: true, - get: function () { - return require('../net') - } + enumerable: true, + get: function () { + return require('../net') + } }, // The internal modules, invisible unless you know their names. diff --git a/lib/browser/api/net.js b/lib/browser/api/net.js index 398c30c07fd3..1471ae4f1dc7 100644 --- a/lib/browser/api/net.js +++ b/lib/browser/api/net.js @@ -1,5 +1,6 @@ 'use strict' +const url = require('url') const {EventEmitter} = require('events') const util = require('util') const binding = process.atomBinding('net') @@ -9,94 +10,91 @@ const {URLRequest} = net Object.setPrototypeOf(Net.prototype, EventEmitter.prototype) Object.setPrototypeOf(URLRequest.prototype, EventEmitter.prototype) -let kSupportedProtocols = new Set(); -kSupportedProtocols.add('http:'); -kSupportedProtocols.add('https:'); +let kSupportedProtocols = new Set() +kSupportedProtocols.add('http:') +kSupportedProtocols.add('https:') class IncomingMessage extends EventEmitter { - constructor(url_request) { - super(); - this._url_request = url_request; + constructor (urlRequest) { + super() + this._url_request = urlRequest } - get statusCode() { - return this._url_request.statusCode; + get statusCode () { + return this._url_request.statusCode } - get statusMessage() { - return this._url_request.statusMessage; + get statusMessage () { + return this._url_request.statusMessage } - get headers() { - return this._url_request.rawResponseHeaders; + get headers () { + return this._url_request.rawResponseHeaders } - get httpVersion() { - return `${this.httpVersionMajor}.${this.httpVersionMinor}`; + get httpVersion () { + return `${this.httpVersionMajor}.${this.httpVersionMinor}` } - get httpVersionMajor() { - return this._url_request.httpVersionMajor; + get httpVersionMajor () { + return this._url_request.httpVersionMajor } - get httpVersionMinor() { - return this._url_request.httpVersionMinor; + get httpVersionMinor () { + return this._url_request.httpVersionMinor } - get rawHeaders() { - return this._url_request.rawResponseHeaders; + get rawHeaders () { + return this._url_request.rawResponseHeaders } } -URLRequest.prototype._emitRequestEvent = function() { - this._request.emit.apply(this._request, arguments); +URLRequest.prototype._emitRequestEvent = function () { + this._request.emit.apply(this._request, arguments) } -URLRequest.prototype._emitResponseEvent = function() { - this._response.emit.apply(this._response, arguments); +URLRequest.prototype._emitResponseEvent = function () { + this._response.emit.apply(this._response, arguments) } class ClientRequest extends EventEmitter { - constructor(options, callback) { - super(); + constructor (options, callback) { + super() if (typeof options === 'string') { - options = url.parse(options); + options = url.parse(options) } else { - options = util._extend({}, options); + options = util._extend({}, options) } - const method = (options.method || 'GET').toUpperCase(); - let url_str = options.url; + const method = (options.method || 'GET').toUpperCase() + let urlStr = options.url - if (!url_str) { - let url_obj = {}; - - const protocol = options.protocol || 'http'; + if (!urlStr) { + let urlObj = {} + const protocol = options.protocol || 'http' if (!kSupportedProtocols.has(protocol)) { - throw new Error('Protocol "' + protocol + '" not supported. '); + throw new Error('Protocol "' + protocol + '" not supported. ') } - url_obj.protocol = protocol; - + urlObj.protocol = protocol if (options.host) { - url_obj.host = options.host; + urlObj.host = options.host } else { - if (options.hostname) { - url_obj.hostname = options.hostname; + urlObj.hostname = options.hostname } else { - url_obj.hostname = 'localhost'; + urlObj.hostname = 'localhost' } if (options.port) { - url_obj.port = options.port; + urlObj.port = options.port } } - const path = options.path || '/'; + const path = options.path || '/' if (options.path && / /.test(options.path)) { // The actual regex is more like /[^A-Za-z0-9\-._~!$&'()*+,;=/:@]/ // with an additional rule for ignoring percentage-escaped characters @@ -104,210 +102,203 @@ class ClientRequest extends EventEmitter { // well, and b) possibly too restrictive for real-world usage. That's // why it only scans for spaces because those are guaranteed to create // an invalid request. - throw new TypeError('Request path contains unescaped characters.'); + throw new TypeError('Request path contains unescaped characters.') } - url_obj.path = path; - - url_str = url.format(url_obj); + urlObj.path = path + urlStr = url.format(urlObj) } - const session_name = options.session || ''; - let url_request = new URLRequest({ + const sessionName = options.session || '' + let urlRequest = new URLRequest({ method: method, - url: url_str, - session: session_name - }); + url: urlStr, + session: sessionName + }) // Set back and forward links. - this._url_request = url_request; - url_request._request = this; + this._url_request = urlRequest + urlRequest._request = this if (options.headers) { - let keys = Object.keys(options.headers); + const keys = Object.keys(options.headers) for (let i = 0, l = keys.length; i < l; i++) { - let key = keys[i]; - this.setHeader(key, options.headers[key]); + const key = keys[i] + this.setHeader(key, options.headers[key]) } } - // Flag to prevent request's headers modifications after + // Flag to prevent request's headers modifications after // headers flush. - this._started = false; + this._started = false - this._aborted = false; + this._aborted = false // Flag to prevent writings after end. - this._finished = false; + this._finished = false // Set when the request uses chuned encoding. Can be switched // to true only once and never set back to false. - this._chunkedEncoding = false; + this._chunkedEncoding = false // This is a copy of the extra headers structure held by the native // net::URLRequest. The main reason is to keep the getHeader API synchronous // after the request starts. - this._extra_headers = {}; + this._extra_headers = {} - url_request.on('response', ()=> { - let response = new IncomingMessage(url_request); - url_request._response = response; - this.emit('response', response); - }); + urlRequest.on('response', () => { + const response = new IncomingMessage(urlRequest) + urlRequest._response = response + this.emit('response', response) + }) if (callback) { this.once('response', callback) } } - get chunkedEncoding() { - return this._chunkedEncoding; + get chunkedEncoding () { + return this._chunkedEncoding } - set chunkedEncoding(value) { + set chunkedEncoding (value) { if (this._started) { - throw new Error('Can\'t set the transfer encoding, headers have been sent.'); + throw new Error('Can\'t set the transfer encoding, headers have been sent.') } - this._chunkedEncoding = value; + this._chunkedEncoding = value } + setHeader (name, value) { + if (typeof name !== 'string') { + throw new TypeError('`name` should be a string in setHeader(name, value).') + } + if (value === undefined) { + throw new Error('`value` required in setHeader("' + name + '", value).') + } + if (this._started) { + throw new Error('Can\'t set headers after they are sent.') + } - setHeader(name, value) { - if (typeof name !== 'string') - throw new TypeError('`name` should be a string in setHeader(name, value).'); - if (value === undefined) - throw new Error('`value` required in setHeader("' + name + '", value).'); - if (this._started) - throw new Error('Can\'t set headers after they are sent.'); - - let key = name.toLowerCase(); - this._extra_headers[key] = value; + const key = name.toLowerCase() + this._extra_headers[key] = value this._url_request.setExtraHeader(name, value) } - - getHeader(name) { + getHeader (name) { if (arguments.length < 1) { - throw new Error('`name` is required for getHeader(name).'); + throw new Error('`name` is required for getHeader(name).') } if (!this._extra_headers) { - return; + return } - let key = name.toLowerCase(); - return this._extra_headers[key]; + const key = name.toLowerCase() + return this._extra_headers[key] } - - removeHeader(name) { + removeHeader (name) { if (arguments.length < 1) { - throw new Error('`name` is required for removeHeader(name).'); + throw new Error('`name` is required for removeHeader(name).') } if (this._started) { - throw new Error('Can\'t remove headers after they are sent.'); + throw new Error('Can\'t remove headers after they are sent.') } - let key = name.toLowerCase(); - delete this._extra_headers[key]; - this._url_request.removeExtraHeader(name); + const key = name.toLowerCase() + delete this._extra_headers[key] + this._url_request.removeExtraHeader(name) } - - _write(chunk, encoding, callback, is_last) { - - let chunk_is_string = typeof chunk === 'string'; - let chunk_is_buffer = chunk instanceof Buffer; - if (!chunk_is_string && !chunk_is_buffer) { - throw new TypeError('First argument must be a string or Buffer.'); + _write (chunk, encoding, callback, isLast) { + let chunkIsString = typeof chunk === 'string' + let chunkIsBuffer = chunk instanceof Buffer + if (!chunkIsString && !chunkIsBuffer) { + throw new TypeError('First argument must be a string or Buffer.') } - if (chunk_is_string) { + if (chunkIsString) { // We convert all strings into binary buffers. - chunk = Buffer.from(chunk, encoding); + chunk = Buffer.from(chunk, encoding) } // Headers are assumed to be sent on first call to _writeBuffer, // i.e. after the first call to write or end. - let result = this._url_request.write(chunk, is_last); + let result = this._url_request.write(chunk, isLast) - // Since writing to the network is asynchronous, we conservatively + // Since writing to the network is asynchronous, we conservatively // assume that request headers are written after delivering the first // buffer to the network IO thread. if (!this._started) { - this._url_request.setChunkedUpload(this.chunkedEncoding); - this._started = true; + this._url_request.setChunkedUpload(this.chunkedEncoding) + this._started = true } // The write callback is fired asynchronously to mimic Node.js. if (callback) { - process.nextTick(callback); + process.nextTick(callback) } - return result; + return result } - write(data, encoding, callback) { - + write (data, encoding, callback) { if (this._finished) { - let error = new Error('Write after end.'); - process.nextTick(writeAfterEndNT, this, error, callback); - return true; + let error = new Error('Write after end.') + process.nextTick(writeAfterEndNT, this, error, callback) + return true } - return this._write(data, encoding, callback, false); + return this._write(data, encoding, callback, false) } - - end(data, encoding, callback) { + end (data, encoding, callback) { if (this._finished) { - return false; + return false } - - this._finished = true; + + this._finished = true if (typeof data === 'function') { - callback = data; - encoding = null; - data = null; + callback = data + encoding = null + data = null } else if (typeof encoding === 'function') { - callback = encoding; - encoding = null; + callback = encoding + encoding = null } - data = data || ''; + data = data || '' - return this._write(data, encoding, callback, true); + return this._write(data, encoding, callback, true) } - abort() { + abort () { if (!this._started) { - // Does nothing if stream - return; + // Does nothing if stream + return } if (!this._aborted) { - this._url_request.abort(); - this._aborted = true; - process.nextTick( ()=>{ - this.emit('abort'); - } ); + this._url_request.abort() + this._aborted = true + process.nextTick(() => { + this.emit('abort') + }) } } } -function writeAfterEndNT(self, error, callback) { - self.emit('error', error); - if (callback) callback(error); +function writeAfterEndNT (self, error, callback) { + self.emit('error', error) + if (callback) callback(error) } - -Net.prototype.request = function(options, callback) { - return new ClientRequest(options, callback); +Net.prototype.request = function (options, callback) { + return new ClientRequest(options, callback) } -net.ClientRequest = ClientRequest; +net.ClientRequest = ClientRequest module.exports = net - \ No newline at end of file