Adds liniting into the workflow (#3082)

* initial linting of src

* fix indent to 2 spaces

* Removes unnecessary rules

* ignore spec folder for now

* Spec linting

* Fix spec indent

* nits

* nits

* no no-empty rule

src/LiveQuery/Client.js

@@ -1,4 +1,3 @@
-import Parse from 'parse/node';
 import logger from '../logger';
 
 import type { FlattenedObjectData } from './Subscription';
@@ -54,7 +53,7 @@ class Client {
     this.subscriptionInfos.set(requestId, subscriptionInfo);
   }
 
-  getSubscriptionInfo(requestId: numner): any {
+  getSubscriptionInfo(requestId: number): any {
     return this.subscriptionInfos.get(requestId);
   }
 

src/LiveQuery/ParseLiveQueryServer.js

@@ -251,21 +251,21 @@ class ParseLiveQueryServer {
       }
 
       switch(request.op) {
-        case 'connect':
-          this._handleConnect(parseWebsocket, request);
-          break;
-        case 'subscribe':
-          this._handleSubscribe(parseWebsocket, request);
-          break;
-        case 'update':
-          this._handleUpdateSubscription(parseWebsocket, request);
-          break;
-        case 'unsubscribe':
-          this._handleUnsubscribe(parseWebsocket, request);
-          break;
-        default:
-          Client.pushError(parseWebsocket, 3, 'Get unknown operation');
-          logger.error('Get unknown operation', request.op);
+      case 'connect':
+        this._handleConnect(parseWebsocket, request);
+        break;
+      case 'subscribe':
+        this._handleSubscribe(parseWebsocket, request);
+        break;
+      case 'update':
+        this._handleUpdateSubscription(parseWebsocket, request);
+        break;
+      case 'unsubscribe':
+        this._handleUnsubscribe(parseWebsocket, request);
+        break;
+      default:
+        Client.pushError(parseWebsocket, 3, 'Get unknown operation');
+        logger.error('Get unknown operation', request.op);
       }
     });
 
@@ -335,48 +335,48 @@ class ParseLiveQueryServer {
         // Resolve false right away if the acl doesn't have any roles
         const acl_has_roles = Object.keys(acl.permissionsById).some(key => key.startsWith("role:"));
         if (!acl_has_roles) {
-            return resolve(false);
+          return resolve(false);
         }
 
         this.sessionTokenCache.getUserId(subscriptionSessionToken)
         .then((userId) => {
 
             // Pass along a null if there is no user id
-            if (!userId) {
-                return Parse.Promise.as(null);
-            }
+          if (!userId) {
+            return Parse.Promise.as(null);
+          }
 
             // Prepare a user object to query for roles
             // To eliminate a query for the user, create one locally with the id
-            var user = new Parse.User();
-            user.id = userId;
-            return user;
+          var user = new Parse.User();
+          user.id = userId;
+          return user;
 
         })
         .then((user) => {
 
             // Pass along an empty array (of roles) if no user
-            if (!user) {
-                return Parse.Promise.as([]);
-            }
+          if (!user) {
+            return Parse.Promise.as([]);
+          }
 
             // Then get the user's roles
-            var rolesQuery = new Parse.Query(Parse.Role);
-            rolesQuery.equalTo("users", user);
-            return rolesQuery.find();
+          var rolesQuery = new Parse.Query(Parse.Role);
+          rolesQuery.equalTo("users", user);
+          return rolesQuery.find();
         }).
         then((roles) => {
 
             // Finally, see if any of the user's roles allow them read access
-            for (let role of roles) {
-                if (acl.getRoleReadAccess(role)) {
-                    return resolve(true);
-                }
+          for (let role of roles) {
+            if (acl.getRoleReadAccess(role)) {
+              return resolve(true);
             }
-            resolve(false);
+          }
+          resolve(false);
         })
         .catch((error) => {
-            reject(error);
+          reject(error);
         });
 
       });
@@ -393,7 +393,7 @@ class ParseLiveQueryServer {
       });
     }).then((isMatched) => {
       return Parse.Promise.as(isMatched);
-    }, (error) => {
+    }, () => {
       return Parse.Promise.as(false);
     });
   }

src/LiveQuery/ParseWebSocketServer.js

@@ -38,7 +38,7 @@ export class ParseWebSocket {
     this.ws.on(wsType, callback);
   }
 
-  send(message: any, channel: string): void {
+  send(message: any): void {
     this.ws.send(message);
   }
 }

src/LiveQuery/QueryTools.js

@@ -167,117 +167,118 @@ function matchesKeyConstraints(object, key, constraints) {
       compareTo = Parse._decode(key, compareTo);
     }
     switch (condition) {
-      case '$lt':
-        if (object[key] >= compareTo) {
+    case '$lt':
+      if (object[key] >= compareTo) {
+        return false;
+      }
+      break;
+    case '$lte':
+      if (object[key] > compareTo) {
+        return false;
+      }
+      break;
+    case '$gt':
+      if (object[key] <= compareTo) {
+        return false;
+      }
+      break;
+    case '$gte':
+      if (object[key] < compareTo) {
+        return false;
+      }
+      break;
+    case '$ne':
+      if (equalObjects(object[key], compareTo)) {
+        return false;
+      }
+      break;
+    case '$in':
+      if (compareTo.indexOf(object[key]) < 0) {
+        return false;
+      }
+      break;
+    case '$nin':
+      if (compareTo.indexOf(object[key]) > -1) {
+        return false;
+      }
+      break;
+    case '$all':
+      for (i = 0; i < compareTo.length; i++) {
+        if (object[key].indexOf(compareTo[i]) < 0) {
           return false;
         }
-        break;
-      case '$lte':
-        if (object[key] > compareTo) {
-          return false;
-        }
-        break;
-      case '$gt':
-        if (object[key] <= compareTo) {
-          return false;
-        }
-        break;
-      case '$gte':
-        if (object[key] < compareTo) {
-          return false;
-        }
-        break;
-      case '$ne':
-        if (equalObjects(object[key], compareTo)) {
-          return false;
-        }
-        break;
-      case '$in':
-        if (compareTo.indexOf(object[key]) < 0) {
-          return false;
-        }
-        break;
-      case '$nin':
-        if (compareTo.indexOf(object[key]) > -1) {
-          return false;
-        }
-        break;
-      case '$all':
-        for (i = 0; i < compareTo.length; i++) {
-          if (object[key].indexOf(compareTo[i]) < 0) {
-            return false;
-          }
-        }
-        break;
-      case '$exists':
-        let propertyExists = typeof object[key] !== 'undefined';
-        let existenceIsRequired = constraints['$exists'];
-        if (typeof constraints['$exists'] !== 'boolean') {
+      }
+      break;
+    case '$exists': {
+      let propertyExists = typeof object[key] !== 'undefined';
+      let existenceIsRequired = constraints['$exists'];
+      if (typeof constraints['$exists'] !== 'boolean') {
           // The SDK will never submit a non-boolean for $exists, but if someone
           // tries to submit a non-boolean for $exits outside the SDKs, just ignore it.
-          break;
-        }
-        if ((!propertyExists && existenceIsRequired) || (propertyExists && !existenceIsRequired)) {
-          return false;
-        }
         break;
-      case '$regex':
-        if (typeof compareTo === 'object') {
-          return compareTo.test(object[key]);
-        }
+      }
+      if ((!propertyExists && existenceIsRequired) || (propertyExists && !existenceIsRequired)) {
+        return false;
+      }
+      break;
+    }
+    case '$regex':
+      if (typeof compareTo === 'object') {
+        return compareTo.test(object[key]);
+      }
         // JS doesn't support perl-style escaping
-        var expString = '';
-        var escapeEnd = -2;
-        var escapeStart = compareTo.indexOf('\\Q');
-        while (escapeStart > -1) {
+      var expString = '';
+      var escapeEnd = -2;
+      var escapeStart = compareTo.indexOf('\\Q');
+      while (escapeStart > -1) {
           // Add the unescaped portion
-          expString += compareTo.substring(escapeEnd + 2, escapeStart);
-          escapeEnd = compareTo.indexOf('\\E', escapeStart);
-          if (escapeEnd > -1) {
-            expString += compareTo.substring(escapeStart + 2, escapeEnd)
+        expString += compareTo.substring(escapeEnd + 2, escapeStart);
+        escapeEnd = compareTo.indexOf('\\E', escapeStart);
+        if (escapeEnd > -1) {
+          expString += compareTo.substring(escapeStart + 2, escapeEnd)
               .replace(/\\\\\\\\E/g, '\\E').replace(/\W/g, '\\$&');
-          }
+        }
 
-          escapeStart = compareTo.indexOf('\\Q', escapeEnd);
-        }
-        expString += compareTo.substring(Math.max(escapeStart, escapeEnd + 2));
-        var exp = new RegExp(expString, constraints.$options || '');
-        if (!exp.test(object[key])) {
-          return false;
-        }
-        break;
-      case '$nearSphere':
-        var distance = compareTo.radiansTo(object[key]);
-        var max = constraints.$maxDistance || Infinity;
-        return distance <= max;
-      case '$within':
-        var southWest = compareTo.$box[0];
-        var northEast = compareTo.$box[1];
-        if (southWest.latitude > northEast.latitude ||
+        escapeStart = compareTo.indexOf('\\Q', escapeEnd);
+      }
+      expString += compareTo.substring(Math.max(escapeStart, escapeEnd + 2));
+      var exp = new RegExp(expString, constraints.$options || '');
+      if (!exp.test(object[key])) {
+        return false;
+      }
+      break;
+    case '$nearSphere':
+      var distance = compareTo.radiansTo(object[key]);
+      var max = constraints.$maxDistance || Infinity;
+      return distance <= max;
+    case '$within':
+      var southWest = compareTo.$box[0];
+      var northEast = compareTo.$box[1];
+      if (southWest.latitude > northEast.latitude ||
             southWest.longitude > northEast.longitude) {
           // Invalid box, crosses the date line
-          return false;
-        }
-        return (
+        return false;
+      }
+      return (
           object[key].latitude > southWest.latitude &&
           object[key].latitude < northEast.latitude &&
           object[key].longitude > southWest.longitude &&
           object[key].longitude < northEast.longitude
-        );
-      case '$options':
+      );
+    case '$options':
         // Not a query type, but a way to add options to $regex. Ignore and
         // avoid the default
-        break;
-      case '$maxDistance':
+      break;
+    case '$maxDistance':
         // Not a query type, but a way to add a cap to $nearSphere. Ignore and
         // avoid the default
-        break;
-      case '$select':
-        return false;
-      case '$dontSelect':
-        return false;
-      default:
-        return false;
+      break;
+    case '$select':
+      return false;
+    case '$dontSelect':
+      return false;
+    default:
+      return false;
     }
   }
   return true;

src/LiveQuery/RequestSchema.js

@@ -61,7 +61,7 @@ let subscribe = {
         'fields': {
           "type": "array",
           "items": {
-              "type": "string"
+            "type": "string"
           },
           "minItems": 1,
           "uniqueItems": true
@@ -99,7 +99,7 @@ let update = {
         'fields': {
           "type": "array",
           "items": {
-              "type": "string"
+            "type": "string"
           },
           "minItems": 1,
           "uniqueItems": true

src/LiveQuery/Subscription.js

@@ -1,4 +1,3 @@
-import {matchesQuery, queryHash}  from './QueryTools';
 import logger from '../logger';
 
 export type FlattenedObjectData = { [attr: string]: any };