checkSpacing = function (node, i, parent, parser, result) {
  if (node.is('operator') || node.is('unaryOperator')) {
    var previous = parent.content[i - 1] || false,
        next = parent.content[i + 1] || false,
        operator = node.content;

    //////////////////////////
    // Multi-part operators
    //////////////////////////

    // If second part of relational operator move on
    if (node.content === '=' && previous) {
      if (previous.content === '<' || previous.content === '>') {
        return false;
      }
    }

    // If first part of relational operator, carry on and build it
    if ((node.content === '<' || node.content === '>') && next) {
      if (next.content === '=') {
        operator = getRelationalOperator(node);
        next = parent.content[i + 2] || false;
      }
    }

    //////////////////////////
    // Exceptions
    //////////////////////////

    if (isException(operator, parent, i)) {
      return false;
    }

    // If the operator checks out in our valid operator list
    if (operators.indexOf(operator) !== -1) {

      if (parser.options.include) {
        if (
          (previous && !previous.is('space'))
          || (next && !next.is('space'))
        ) {
          result = helpers.addUnique(result, {
            'ruleId': parser.rule.name,
            'line': node.start.line,
            'column': node.start.column,
            'message': 'Space expected around operator',
            'severity': parser.severity
          });
        }
        else {
          if (
            (previous && (previous.end.line >= previous.start.line) && (previous.end.column > previous.start.column))
              || (next && (next.end.line >= next.start.line) && (next.end.column > next.start.column))
          ) {
            result = helpers.addUnique(result, {
              'ruleId': parser.rule.name,
              'line': node.start.line,
              'column': node.start.column,
              'message': 'Multiple spaces not allowed around operator',
              'severity': parser.severity
            });
          }
        }
      }
      else {
        if (
          (previous && previous.is('space'))
          || (next && next.is('space'))
        ) {
          result = helpers.addUnique(result, {
            'ruleId': parser.rule.name,
            'line': node.start.line,
            'column': node.start.column,
            'message': 'No spaces allowed around operator',
            'severity': parser.severity
          });
        }
      }
    }
  }
  return result;
}
Check the spacing around an operator

@param {Object} node - The node to check the spacing around
@param {int} i - The node's child index of it's parent
@param {Object} parent - The parent node
@param {Object} parser - The parser object
@param {Object} result - The result object
@returns {bool|null} false if exception