docs: function(context) {
  
                  var statements = {
                      'IfStatement': true,
                      'DoWhileStatement': true,
                      'WhileStatement': true,
                      'ForStatement': true
                  };
  
                  /**
                   * @description If the given node is surrounded by ()
                   * @param {Object} node The AST node
                   * @returns {Boolean} If the node is surrounded by ()
                   */
                  function isParenthesised(node) {
                      var type = node.parent.type;
                      if(statements[type]) {
                          //if its direct parent is the control statement, check for double parenthesis
                          if(type !== 'ForStatement') {
                              return context.getTokenBefore(node, 1).value === '(';
                          }
                      }
                      return context.getTokenBefore(node).value === '(';
                  }
                  /**
                   * @description If we should skip the node
                   * @param {Object} node The AST node
                   * @returns {Boolean} if we should skip checking the given node
                   */
                  function skip(node) {
                      switch(node.type) {
                          case 'FunctionExpression':
                          case 'ObjectExpression':
                          case 'CallExpression':
                          case 'ArrayExpression': {
                              return true;
                          }
                          default: return false;
                      }
                  }
                  /**
                   * @description Checks for assignment expressions
                   * @param {Object} node The AST node
                   */
                  function checkForAssignment(node) {
                      var assigns = [];
                      if(node.test === null) {
                          return;
                      }
                      node.test.parent = node;
                      Estraverse.traverse(node.test, {
                      	/* @callback */
                          enter: function(n, parent) {
                              if(n.range[0] > node.test.range[1]) {
                                  //once we've left the test object
                                  return Estraverse.VisitorOption.Break;
                              }
                              if(skip(n)) {
                                  return Estraverse.VisitorOption.Skip;
                              }
                              if(parent) {
                                  n.parent = parent;
                              }
                              if(n && n.type === 'AssignmentExpression') {
                                  assigns.push(n);
                              }
                          }
                      });
                      var len = assigns.length;
                      if(len > 0) {
                          for(var i = 0; i < len; i++) {
                              var assign = assigns[i];
                              if(!isParenthesised(assign)) {
                                  assign.range[0] = assign.left.range[0]; //mark only from the start of first part
                                  context.report(assign, ProblemMessages['no-cond-assign']);
                              }
                          }
                      }
                  }
  
                  return {
                    'IfStatement': checkForAssignment,
                    'WhileStatement': checkForAssignment,
                    'ForStatement': checkForAssignment,
                    'DoWhileStatement': checkForAssignment
                  };
          }