diff --git a/.eslintrc.js b/.eslintrc.js
index 0d0779434..4b8396bec 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -1,3 +1,7 @@
+'use strict'
+
+const version = require('./package.json').version
+
 module.exports = {
   root: true,
   parserOptions: {
@@ -15,8 +19,19 @@ module.exports = {
     'eslint-plugin'
   ],
   rules: {
-    'eslint-plugin/report-message-format': ['error', '^[A-Z].*\\.$'],
+    'eslint-plugin/report-message-format': ['error', '^[A-Z`\'].*\\.$'],
     'eslint-plugin/prefer-placeholders': 'error',
     'eslint-plugin/consistent-output': 'error'
-  }
+  },
+
+  overrides: [{
+    files: ['lib/rules/*.js'],
+    rules: {
+      "consistent-docs-description": "error",
+      "no-invalid-meta": "error",
+      "require-meta-docs-url": ["error", {
+        "pattern": `https://github.com/vuejs/eslint-plugin-vue/blob/v${version}/docs/rules/{{name}}.md`
+      }]
+    }
+  }]
 }
diff --git a/eslint-internal-rules/require-meta-docs-url.js b/eslint-internal-rules/require-meta-docs-url.js
new file mode 100644
index 000000000..1eb9d9ffb
--- /dev/null
+++ b/eslint-internal-rules/require-meta-docs-url.js
@@ -0,0 +1,244 @@
+/**
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ * @author Teddy Katz <https://github.com/not-an-aardvark>
+ *
+ * Three functions `isNormalFunctionExpression`, `getKeyName`, and `getRuleInfo`
+ * are copied from https://github.com/not-an-aardvark/eslint-plugin-eslint-plugin/blob/master/lib/utils.js
+ *
+ * I have a plan to send this rule to that plugin: https://github.com/not-an-aardvark/eslint-plugin-eslint-plugin/issues/55
+ */
+
+'use strict'
+
+// -----------------------------------------------------------------------------
+// Requirements
+// -----------------------------------------------------------------------------
+
+const path = require('path')
+
+// -----------------------------------------------------------------------------
+// Helpers
+// -----------------------------------------------------------------------------
+
+/**
+* Determines whether a node is a 'normal' (i.e. non-async, non-generator) function expression.
+* @param {ASTNode} node The node in question
+* @returns {boolean} `true` if the node is a normal function expression
+*/
+function isNormalFunctionExpression (node) {
+  return (node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression') && !node.generator && !node.async
+}
+
+/**
+ * Gets the key name of a Property, if it can be determined statically.
+ * @param {ASTNode} node The `Property` node
+ * @returns {string|null} The key name, or `null` if the name cannot be determined statically.
+ */
+function getKeyName (property) {
+  if (!property.computed && property.key.type === 'Identifier') {
+    return property.key.name
+  }
+  if (property.key.type === 'Literal') {
+    return '' + property.key.value
+  }
+  if (property.key.type === 'TemplateLiteral' && property.key.quasis.length === 1) {
+    return property.key.quasis[0].value.cooked
+  }
+  return null
+}
+
+/**
+* Performs static analysis on an AST to try to determine the final value of `module.exports`.
+* @param {ASTNode} ast The `Program` AST node
+* @returns {Object} An object with keys `meta`, `create`, and `isNewStyle`. `meta` and `create` correspond to the AST nodes
+for the final values of `module.exports.meta` and `module.exports.create`. `isNewStyle` will be `true` if `module.exports`
+is an object, and `false` if module.exports is just the `create` function. If no valid ESLint rule info can be extracted
+from the file, the return value will be `null`.
+*/
+function getRuleInfo (ast) {
+  const INTERESTING_KEYS = new Set(['create', 'meta'])
+  let exportsVarOverridden = false
+  let exportsIsFunction = false
+
+  const exportNodes = ast.body
+    .filter(statement => statement.type === 'ExpressionStatement')
+    .map(statement => statement.expression)
+    .filter(expression => expression.type === 'AssignmentExpression')
+    .filter(expression => expression.left.type === 'MemberExpression')
+    .reduce((currentExports, node) => {
+      if (
+        node.left.object.type === 'Identifier' && node.left.object.name === 'module' &&
+        node.left.property.type === 'Identifier' && node.left.property.name === 'exports'
+      ) {
+        exportsVarOverridden = true
+
+        if (isNormalFunctionExpression(node.right)) {
+          // Check `module.exports = function () {}`
+
+          exportsIsFunction = true
+          return { create: node.right, meta: null }
+        } else if (node.right.type === 'ObjectExpression') {
+          // Check `module.exports = { create: function () {}, meta: {} }`
+
+          exportsIsFunction = false
+          return node.right.properties.reduce((parsedProps, prop) => {
+            const keyValue = getKeyName(prop)
+            if (INTERESTING_KEYS.has(keyValue)) {
+              parsedProps[keyValue] = prop.value
+            }
+            return parsedProps
+          }, {})
+        }
+        return {}
+      } else if (
+        !exportsIsFunction &&
+        node.left.object.type === 'MemberExpression' &&
+        node.left.object.object.type === 'Identifier' && node.left.object.object.name === 'module' &&
+        node.left.object.property.type === 'Identifier' && node.left.object.property.name === 'exports' &&
+        node.left.property.type === 'Identifier' && INTERESTING_KEYS.has(node.left.property.name)
+      ) {
+        // Check `module.exports.create = () => {}`
+
+        currentExports[node.left.property.name] = node.right
+      } else if (
+        !exportsVarOverridden &&
+        node.left.object.type === 'Identifier' && node.left.object.name === 'exports' &&
+        node.left.property.type === 'Identifier' && INTERESTING_KEYS.has(node.left.property.name)
+      ) {
+        // Check `exports.create = () => {}`
+
+        currentExports[node.left.property.name] = node.right
+      }
+      return currentExports
+    }, {})
+
+  return Object.prototype.hasOwnProperty.call(exportNodes, 'create') && isNormalFunctionExpression(exportNodes.create)
+    ? Object.assign({ isNewStyle: !exportsIsFunction, meta: null }, exportNodes)
+    : null
+}
+
+// -----------------------------------------------------------------------------
+// Rule Definition
+// -----------------------------------------------------------------------------
+
+module.exports = {
+  meta: {
+    docs: {
+      description: 'require rules to implement a meta.docs.url property',
+      category: 'Rules',
+      recommended: false
+    },
+    fixable: 'code',
+    schema: [{
+      type: 'object',
+      properties: {
+        pattern: { type: 'string' }
+      },
+      additionalProperties: false
+    }]
+  },
+
+  /**
+   * Creates AST event handlers for require-meta-docs-url.
+   * @param {RuleContext} context - The rule context.
+   * @returns {Object} AST event handlers.
+   */
+  create (context) {
+    const options = context.options[0] || {}
+    const sourceCode = context.getSourceCode()
+    const filename = context.getFilename()
+    const ruleName = filename === '<input>' ? undefined : path.basename(filename, '.js')
+    const expectedUrl = !options.pattern || !ruleName
+      ? undefined
+      : options.pattern.replace(/{{\s*name\s*}}/g, ruleName)
+
+    /**
+     * Check whether a given node is the expected URL.
+     * @param {Node} node The node of property value to check.
+     * @returns {boolean} `true` if the node is the expected URL.
+     */
+    function isExpectedUrl (node) {
+      return Boolean(
+        node &&
+        node.type === 'Literal' &&
+        typeof node.value === 'string' &&
+        (
+          expectedUrl === undefined ||
+          node.value === expectedUrl
+        )
+      )
+    }
+
+    /**
+     * Insert a given property into a given object literal.
+     * @param {SourceCodeFixer} fixer The fixer.
+     * @param {Node} node The ObjectExpression node to insert a property.
+     * @param {string} propertyText The property code to insert.
+     * @returns {void}
+     */
+    function insertProperty (fixer, node, propertyText) {
+      if (node.properties.length === 0) {
+        return fixer.replaceText(node, `{\n${propertyText}\n}`)
+      }
+      return fixer.insertTextAfter(
+        sourceCode.getLastToken(node.properties[node.properties.length - 1]),
+        `,\n${propertyText}`
+      )
+    }
+
+    return {
+      Program (node) {
+        const info = getRuleInfo(node)
+        if (!info) {
+          return
+        }
+        const metaNode = info.meta
+        const docsPropNode =
+          metaNode &&
+          metaNode.properties &&
+          metaNode.properties.find(p => p.type === 'Property' && getKeyName(p) === 'docs')
+        const urlPropNode =
+          docsPropNode &&
+          docsPropNode.value.properties &&
+          docsPropNode.value.properties.find(p => p.type === 'Property' && getKeyName(p) === 'url')
+
+        if (isExpectedUrl(urlPropNode && urlPropNode.value)) {
+          return
+        }
+
+        context.report({
+          loc:
+            (urlPropNode && urlPropNode.value.loc) ||
+            (docsPropNode && docsPropNode.value.loc) ||
+            (metaNode && metaNode.loc) ||
+            node.loc.start,
+
+          message:
+            !urlPropNode ? 'Rules should export a `meta.docs.url` property.'
+              : !expectedUrl ? '`meta.docs.url` property must be a string.'
+                /* otherwise */ : '`meta.docs.url` property must be `{{expectedUrl}}`.',
+
+          data: {
+            expectedUrl
+          },
+
+          fix (fixer) {
+            if (expectedUrl) {
+              const urlString = JSON.stringify(expectedUrl)
+              if (urlPropNode) {
+                return fixer.replaceText(urlPropNode.value, urlString)
+              }
+              if (docsPropNode && docsPropNode.value.type === 'ObjectExpression') {
+                return insertProperty(fixer, docsPropNode.value, `url: ${urlString}`)
+              }
+              if (!docsPropNode && metaNode && metaNode.type === 'ObjectExpression') {
+                return insertProperty(fixer, metaNode, `docs: {\nurl: ${urlString}\n}`)
+              }
+            }
+            return null
+          }
+        })
+      }
+    }
+  }
+}
diff --git a/lib/rules/.eslintrc.json b/lib/rules/.eslintrc.json
deleted file mode 100644
index 936029a17..000000000
--- a/lib/rules/.eslintrc.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "rules": {
-    "consistent-docs-description": "error",
-    "no-invalid-meta": "error"
-  }
-}
diff --git a/lib/rules/attribute-hyphenation.js b/lib/rules/attribute-hyphenation.js
index 5dec55b99..c428f0fd5 100644
--- a/lib/rules/attribute-hyphenation.js
+++ b/lib/rules/attribute-hyphenation.js
@@ -11,56 +11,12 @@ const casing = require('../utils/casing')
 // Rule Definition
 // ------------------------------------------------------------------------------
 
-function create (context) {
-  const sourceCode = context.getSourceCode()
-  const options = context.options[0]
-  const useHyphenated = options !== 'never'
-
-  const caseConverter = casing.getConverter(useHyphenated ? 'kebab-case' : 'camelCase')
-
-  function reportIssue (node, name) {
-    const text = sourceCode.getText(node.key)
-
-    context.report({
-      node: node.key,
-      loc: node.loc,
-      message: useHyphenated ? "Attribute '{{text}}' must be hyphenated." : "Attribute '{{text}}' cann't be hyphenated.",
-      data: {
-        text
-      },
-      fix: fixer => fixer.replaceText(node.key, text.replace(name, caseConverter(name)))
-    })
-  }
-
-  function isIgnoredAttribute (value) {
-    if (value.indexOf('data-') !== -1 || value.indexOf('aria-') !== -1) {
-      return true
-    }
-    return useHyphenated ? value.toLowerCase() === value : !/-/.test(value)
-  }
-
-  // ----------------------------------------------------------------------
-  // Public
-  // ----------------------------------------------------------------------
-
-  return utils.defineTemplateBodyVisitor(context, {
-    VAttribute (node) {
-      if (!utils.isCustomComponent(node.parent.parent)) return
-
-      const name = !node.directive ? node.key.rawName : node.key.name === 'bind' ? node.key.raw.argument : false
-      if (!name || isIgnoredAttribute(name)) return
-
-      reportIssue(node, name)
-    }
-  })
-}
-
 module.exports = {
   meta: {
     docs: {
       description: 'enforce attribute naming style in template',
       category: 'strongly-recommended',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/attribute-hyphenation.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/attribute-hyphenation.md'
     },
     fixable: 'code',
     schema: [
@@ -70,5 +26,47 @@ module.exports = {
     ]
   },
 
-  create
+  create (context) {
+    const sourceCode = context.getSourceCode()
+    const options = context.options[0]
+    const useHyphenated = options !== 'never'
+
+    const caseConverter = casing.getConverter(useHyphenated ? 'kebab-case' : 'camelCase')
+
+    function reportIssue (node, name) {
+      const text = sourceCode.getText(node.key)
+
+      context.report({
+        node: node.key,
+        loc: node.loc,
+        message: useHyphenated ? "Attribute '{{text}}' must be hyphenated." : "Attribute '{{text}}' cann't be hyphenated.",
+        data: {
+          text
+        },
+        fix: fixer => fixer.replaceText(node.key, text.replace(name, caseConverter(name)))
+      })
+    }
+
+    function isIgnoredAttribute (value) {
+      if (value.indexOf('data-') !== -1 || value.indexOf('aria-') !== -1) {
+        return true
+      }
+      return useHyphenated ? value.toLowerCase() === value : !/-/.test(value)
+    }
+
+    // ----------------------------------------------------------------------
+    // Public
+    // ----------------------------------------------------------------------
+
+    return utils.defineTemplateBodyVisitor(context, {
+      VAttribute (node) {
+        if (!utils.isCustomComponent(node.parent.parent)) return
+
+        const name = !node.directive ? node.key.rawName : node.key.name === 'bind' ? node.key.raw.argument : false
+        if (!name || isIgnoredAttribute(name)) return
+
+        reportIssue(node, name)
+      }
+    })
+  }
 }
diff --git a/lib/rules/comment-directive.js b/lib/rules/comment-directive.js
index 2189d0892..69d381ff8 100644
--- a/lib/rules/comment-directive.js
+++ b/lib/rules/comment-directive.js
@@ -1,6 +1,7 @@
 /**
  * @author Toru Nagashima <https://github.com/mysticatea>
  */
+/* eslint-disable eslint-plugin/report-message-format, consistent-docs-description */
 
 'use strict'
 
@@ -99,33 +100,6 @@ function processLine (context, comment) {
   }
 }
 
-/**
- * The implementation of `vue/comment-directive` rule.
- * @param {Program} node The program node to parse.
- * @returns {Object} The visitor of this rule.
- */
-function create (context) {
-  return {
-    Program (node) {
-      if (!node.templateBody) {
-        return
-      }
-
-      // Send directives to the post-process.
-      for (const comment of node.templateBody.comments) {
-        processBlock(context, comment)
-        processLine(context, comment)
-      }
-
-      // Send a clear mark to the post-process.
-      context.report({
-        loc: node.templateBody.loc.end,
-        message: 'clear'
-      })
-    }
-  }
-}
-
 // -----------------------------------------------------------------------------
 // Rule Definition
 // -----------------------------------------------------------------------------
@@ -133,11 +107,32 @@ function create (context) {
 module.exports = {
   meta: {
     docs: {
-      description: 'support comment-directives in `<template>`', // eslint-disable-line consistent-docs-description
+      description: 'support comment-directives in `<template>`',
       category: 'base',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/comment-directive.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/comment-directive.md'
     },
     schema: []
   },
-  create
+
+  create (context) {
+    return {
+      Program (node) {
+        if (!node.templateBody) {
+          return
+        }
+
+        // Send directives to the post-process.
+        for (const comment of node.templateBody.comments) {
+          processBlock(context, comment)
+          processLine(context, comment)
+        }
+
+        // Send a clear mark to the post-process.
+        context.report({
+          loc: node.templateBody.loc.end,
+          message: 'clear'
+        })
+      }
+    }
+  }
 }
diff --git a/lib/rules/html-closing-bracket-newline.js b/lib/rules/html-closing-bracket-newline.js
index c68643761..724bef478 100644
--- a/lib/rules/html-closing-bracket-newline.js
+++ b/lib/rules/html-closing-bracket-newline.js
@@ -23,62 +23,16 @@ function getPhrase (lineBreaks) {
   }
 }
 
-/**
- * Creates AST event handlers for html-closing-bracket-newline.
- *
- * @param {RuleContext} context - The rule context.
- * @returns {object} AST event handlers.
- */
-function create (context) {
-  const options = context.options[0] || {}
-  const template = context.parserServices.getTemplateBodyTokenStore && context.parserServices.getTemplateBodyTokenStore()
-
-  return utils.defineTemplateBodyVisitor(context, {
-    'VStartTag, VEndTag' (node) {
-      const closingBracketToken = template.getLastToken(node)
-      if (closingBracketToken.type !== 'HTMLSelfClosingTagClose' && closingBracketToken.type !== 'HTMLTagClose') {
-        return
-      }
-
-      const prevToken = template.getTokenBefore(closingBracketToken)
-      const type = (node.loc.start.line === prevToken.loc.end.line) ? 'singleline' : 'multiline'
-      const expectedLineBreaks = (options[type] === 'always') ? 1 : 0
-      const actualLineBreaks = (closingBracketToken.loc.start.line - prevToken.loc.end.line)
-
-      if (actualLineBreaks !== expectedLineBreaks) {
-        context.report({
-          node,
-          loc: {
-            start: prevToken.loc.end,
-            end: closingBracketToken.loc.start
-          },
-          message: 'Expected {{expected}} before closing bracket, but {{actual}} found.',
-          data: {
-            expected: getPhrase(expectedLineBreaks),
-            actual: getPhrase(actualLineBreaks)
-          },
-          fix (fixer) {
-            const range = [prevToken.range[1], closingBracketToken.range[0]]
-            const text = '\n'.repeat(expectedLineBreaks)
-            return fixer.replaceTextRange(range, text)
-          }
-        })
-      }
-    }
-  })
-}
-
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
 module.exports = {
-  create,
   meta: {
     docs: {
       description: "require or disallow a line break before tag's closing brackets",
       category: undefined,
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/html-closing-bracket-newline.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/html-closing-bracket-newline.md'
     },
     fixable: 'whitespace',
     schema: [{
@@ -89,5 +43,44 @@ module.exports = {
       },
       additionalProperties: false
     }]
+  },
+
+  create (context) {
+    const options = context.options[0] || {}
+    const template = context.parserServices.getTemplateBodyTokenStore && context.parserServices.getTemplateBodyTokenStore()
+
+    return utils.defineTemplateBodyVisitor(context, {
+      'VStartTag, VEndTag' (node) {
+        const closingBracketToken = template.getLastToken(node)
+        if (closingBracketToken.type !== 'HTMLSelfClosingTagClose' && closingBracketToken.type !== 'HTMLTagClose') {
+          return
+        }
+
+        const prevToken = template.getTokenBefore(closingBracketToken)
+        const type = (node.loc.start.line === prevToken.loc.end.line) ? 'singleline' : 'multiline'
+        const expectedLineBreaks = (options[type] === 'always') ? 1 : 0
+        const actualLineBreaks = (closingBracketToken.loc.start.line - prevToken.loc.end.line)
+
+        if (actualLineBreaks !== expectedLineBreaks) {
+          context.report({
+            node,
+            loc: {
+              start: prevToken.loc.end,
+              end: closingBracketToken.loc.start
+            },
+            message: 'Expected {{expected}} before closing bracket, but {{actual}} found.',
+            data: {
+              expected: getPhrase(expectedLineBreaks),
+              actual: getPhrase(actualLineBreaks)
+            },
+            fix (fixer) {
+              const range = [prevToken.range[1], closingBracketToken.range[0]]
+              const text = '\n'.repeat(expectedLineBreaks)
+              return fixer.replaceTextRange(range, text)
+            }
+          })
+        }
+      }
+    })
   }
 }
diff --git a/lib/rules/html-closing-bracket-spacing.js b/lib/rules/html-closing-bracket-spacing.js
index b85d86c4b..198d7dd4d 100644
--- a/lib/rules/html-closing-bracket-spacing.js
+++ b/lib/rules/html-closing-bracket-spacing.js
@@ -53,7 +53,7 @@ module.exports = {
     docs: {
       description: 'require or disallow a space before tag\'s closing brackets',
       category: undefined,
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/html-closing-bracket-spacing.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/html-closing-bracket-spacing.md'
     },
     schema: [{
       type: 'object',
diff --git a/lib/rules/html-end-tags.js b/lib/rules/html-end-tags.js
index 39bb9a310..69222ec6b 100644
--- a/lib/rules/html-end-tags.js
+++ b/lib/rules/html-end-tags.js
@@ -11,60 +11,49 @@
 
 const utils = require('../utils')
 
-// ------------------------------------------------------------------------------
-// Helpers
-// ------------------------------------------------------------------------------
-
-/**
- * Creates AST event handlers for html-end-tags.
- *
- * @param {RuleContext} context - The rule context.
- * @returns {Object} AST event handlers.
- */
-function create (context) {
-  let hasInvalidEOF = false
-
-  return utils.defineTemplateBodyVisitor(context, {
-    VElement (node) {
-      if (hasInvalidEOF) {
-        return
-      }
-
-      const name = node.name
-      const isVoid = utils.isHtmlVoidElementName(name)
-      const isSelfClosing = node.startTag.selfClosing
-      const hasEndTag = node.endTag != null
-
-      if (!isVoid && !hasEndTag && !isSelfClosing) {
-        context.report({
-          node: node.startTag,
-          loc: node.startTag.loc,
-          message: "'<{{name}}>' should have end tag.",
-          data: { name },
-          fix: (fixer) => fixer.insertTextAfter(node, `</${name}>`)
-        })
-      }
-    }
-  }, {
-    Program (node) {
-      hasInvalidEOF = utils.hasInvalidEOF(node)
-    }
-  })
-}
-
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
 module.exports = {
-  create,
   meta: {
     docs: {
       description: 'enforce end tag style',
       category: 'strongly-recommended',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/html-end-tags.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/html-end-tags.md'
     },
     fixable: 'code',
     schema: []
+  },
+
+  create (context) {
+    let hasInvalidEOF = false
+
+    return utils.defineTemplateBodyVisitor(context, {
+      VElement (node) {
+        if (hasInvalidEOF) {
+          return
+        }
+
+        const name = node.name
+        const isVoid = utils.isHtmlVoidElementName(name)
+        const isSelfClosing = node.startTag.selfClosing
+        const hasEndTag = node.endTag != null
+
+        if (!isVoid && !hasEndTag && !isSelfClosing) {
+          context.report({
+            node: node.startTag,
+            loc: node.startTag.loc,
+            message: "'<{{name}}>' should have end tag.",
+            data: { name },
+            fix: (fixer) => fixer.insertTextAfter(node, `</${name}>`)
+          })
+        }
+      }
+    }, {
+      Program (node) {
+        hasInvalidEOF = utils.hasInvalidEOF(node)
+      }
+    })
   }
 }
diff --git a/lib/rules/html-indent.js b/lib/rules/html-indent.js
index da04989c6..3dbc27544 100644
--- a/lib/rules/html-indent.js
+++ b/lib/rules/html-indent.js
@@ -29,7 +29,7 @@ module.exports = {
     docs: {
       description: 'enforce consistent indentation in `<template>`',
       category: 'strongly-recommended',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/html-indent.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/html-indent.md'
     },
     fixable: 'whitespace',
     schema: [
diff --git a/lib/rules/html-quotes.js b/lib/rules/html-quotes.js
index bd6431af4..e8e9295f4 100644
--- a/lib/rules/html-quotes.js
+++ b/lib/rules/html-quotes.js
@@ -11,71 +11,59 @@
 
 const utils = require('../utils')
 
-// ------------------------------------------------------------------------------
-// Helpers
-// ------------------------------------------------------------------------------
-
-/**
- * Creates AST event handlers for html-quotes.
- *
- * @param {RuleContext} context - The rule context.
- * @returns {Object} AST event handlers.
- */
-function create (context) {
-  const sourceCode = context.getSourceCode()
-  const double = context.options[0] !== 'single'
-  const quoteChar = double ? '"' : "'"
-  const quoteName = double ? 'double quotes' : 'single quotes'
-  const quotePattern = double ? /"/g : /'/g
-  const quoteEscaped = double ? '&quot;' : '&apos;'
-  let hasInvalidEOF
-
-  return utils.defineTemplateBodyVisitor(context, {
-    'VAttribute[value!=null]' (node) {
-      if (hasInvalidEOF) {
-        return
-      }
-
-      const text = sourceCode.getText(node.value)
-      const firstChar = text[0]
-
-      if (firstChar !== quoteChar) {
-        context.report({
-          node: node.value,
-          loc: node.value.loc,
-          message: 'Expected to be enclosed by {{kind}}.',
-          data: { kind: quoteName },
-          fix (fixer) {
-            const contentText = (firstChar === "'" || firstChar === '"') ? text.slice(1, -1) : text
-            const replacement = quoteChar + contentText.replace(quotePattern, quoteEscaped) + quoteChar
-
-            return fixer.replaceText(node.value, replacement)
-          }
-        })
-      }
-    }
-  }, {
-    Program (node) {
-      hasInvalidEOF = utils.hasInvalidEOF(node)
-    }
-  })
-}
-
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
 module.exports = {
-  create,
   meta: {
     docs: {
       description: 'enforce quotes style of HTML attributes',
       category: 'recommended',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/html-quotes.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/html-quotes.md'
     },
     fixable: 'code',
     schema: [
       { enum: ['double', 'single'] }
     ]
+  },
+
+  create (context) {
+    const sourceCode = context.getSourceCode()
+    const double = context.options[0] !== 'single'
+    const quoteChar = double ? '"' : "'"
+    const quoteName = double ? 'double quotes' : 'single quotes'
+    const quotePattern = double ? /"/g : /'/g
+    const quoteEscaped = double ? '&quot;' : '&apos;'
+    let hasInvalidEOF
+
+    return utils.defineTemplateBodyVisitor(context, {
+      'VAttribute[value!=null]' (node) {
+        if (hasInvalidEOF) {
+          return
+        }
+
+        const text = sourceCode.getText(node.value)
+        const firstChar = text[0]
+
+        if (firstChar !== quoteChar) {
+          context.report({
+            node: node.value,
+            loc: node.value.loc,
+            message: 'Expected to be enclosed by {{kind}}.',
+            data: { kind: quoteName },
+            fix (fixer) {
+              const contentText = (firstChar === "'" || firstChar === '"') ? text.slice(1, -1) : text
+              const replacement = quoteChar + contentText.replace(quotePattern, quoteEscaped) + quoteChar
+              return fixer.replaceText(node.value, replacement)
+            }
+          })
+        }
+      }
+    }, {
+      Program (node) {
+        hasInvalidEOF = utils.hasInvalidEOF(node)
+      }
+    })
   }
 }
diff --git a/lib/rules/html-self-closing.js b/lib/rules/html-self-closing.js
index b3c5a7a90..51aa4b21c 100644
--- a/lib/rules/html-self-closing.js
+++ b/lib/rules/html-self-closing.js
@@ -79,81 +79,16 @@ function isEmpty (node, sourceCode) {
   return sourceCode.text.slice(start, end).trim() === ''
 }
 
-/**
- * Creates AST event handlers for html-self-closing.
- *
- * @param {RuleContext} context - The rule context.
- * @returns {object} AST event handlers.
- */
-function create (context) {
-  const sourceCode = context.getSourceCode()
-  const options = parseOptions(context.options[0])
-  let hasInvalidEOF = false
-
-  return utils.defineTemplateBodyVisitor(context, {
-    'VElement' (node) {
-      if (hasInvalidEOF) {
-        return
-      }
-
-      const elementType = getElementType(node)
-      const mode = options[elementType]
-
-      if (mode === 'always' && !node.startTag.selfClosing && isEmpty(node, sourceCode)) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: 'Require self-closing on {{elementType}} (<{{name}}>).',
-          data: { elementType, name: node.rawName },
-          fix: (fixer) => {
-            const tokens = context.parserServices.getTemplateBodyTokenStore()
-            const close = tokens.getLastToken(node.startTag)
-            if (close.type !== 'HTMLTagClose') {
-              return null
-            }
-            return fixer.replaceTextRange([close.range[0], node.range[1]], '/>')
-          }
-        })
-      }
-
-      if (mode === 'never' && node.startTag.selfClosing) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: 'Disallow self-closing on {{elementType}} (<{{name}}/>).',
-          data: { elementType, name: node.rawName },
-          fix: (fixer) => {
-            const tokens = context.parserServices.getTemplateBodyTokenStore()
-            const close = tokens.getLastToken(node.startTag)
-            if (close.type !== 'HTMLSelfClosingTagClose') {
-              return null
-            }
-            if (elementType === ELEMENT_TYPE.VOID) {
-              return fixer.replaceText(close, '>')
-            }
-            return fixer.replaceText(close, `></${node.rawName}>`)
-          }
-        })
-      }
-    }
-  }, {
-    Program (node) {
-      hasInvalidEOF = utils.hasInvalidEOF(node)
-    }
-  })
-}
-
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
 module.exports = {
-  create,
   meta: {
     docs: {
       description: 'enforce self-closing style',
       category: 'strongly-recommended',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/html-self-closing.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/html-self-closing.md'
     },
     fixable: 'code',
     schema: {
@@ -182,5 +117,63 @@ module.exports = {
       }],
       maxItems: 1
     }
+  },
+
+  create (context) {
+    const sourceCode = context.getSourceCode()
+    const options = parseOptions(context.options[0])
+    let hasInvalidEOF = false
+
+    return utils.defineTemplateBodyVisitor(context, {
+      'VElement' (node) {
+        if (hasInvalidEOF) {
+          return
+        }
+
+        const elementType = getElementType(node)
+        const mode = options[elementType]
+
+        if (mode === 'always' && !node.startTag.selfClosing && isEmpty(node, sourceCode)) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: 'Require self-closing on {{elementType}} (<{{name}}>).',
+            data: { elementType, name: node.rawName },
+            fix: (fixer) => {
+              const tokens = context.parserServices.getTemplateBodyTokenStore()
+              const close = tokens.getLastToken(node.startTag)
+              if (close.type !== 'HTMLTagClose') {
+                return null
+              }
+              return fixer.replaceTextRange([close.range[0], node.range[1]], '/>')
+            }
+          })
+        }
+
+        if (mode === 'never' && node.startTag.selfClosing) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: 'Disallow self-closing on {{elementType}} (<{{name}}/>).',
+            data: { elementType, name: node.rawName },
+            fix: (fixer) => {
+              const tokens = context.parserServices.getTemplateBodyTokenStore()
+              const close = tokens.getLastToken(node.startTag)
+              if (close.type !== 'HTMLSelfClosingTagClose') {
+                return null
+              }
+              if (elementType === ELEMENT_TYPE.VOID) {
+                return fixer.replaceText(close, '>')
+              }
+              return fixer.replaceText(close, `></${node.rawName}>`)
+            }
+          })
+        }
+      }
+    }, {
+      Program (node) {
+        hasInvalidEOF = utils.hasInvalidEOF(node)
+      }
+    })
   }
 }
diff --git a/lib/rules/jsx-uses-vars.js b/lib/rules/jsx-uses-vars.js
index a254c1093..653ed18fd 100644
--- a/lib/rules/jsx-uses-vars.js
+++ b/lib/rules/jsx-uses-vars.js
@@ -39,7 +39,7 @@ module.exports = {
     docs: {
       description: 'prevent variables used in JSX to be marked as unused', // eslint-disable-line consistent-docs-description
       category: 'base',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/jsx-uses-vars.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/jsx-uses-vars.md'
     },
     schema: []
   },
diff --git a/lib/rules/max-attributes-per-line.js b/lib/rules/max-attributes-per-line.js
index 1ee73a549..d68e8f2db 100644
--- a/lib/rules/max-attributes-per-line.js
+++ b/lib/rules/max-attributes-per-line.js
@@ -14,7 +14,7 @@ module.exports = {
     docs: {
       description: 'enforce the maximum number of attributes per line',
       category: 'strongly-recommended',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/max-attributes-per-line.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/max-attributes-per-line.md'
     },
     fixable: null,
     schema: [
diff --git a/lib/rules/mustache-interpolation-spacing.js b/lib/rules/mustache-interpolation-spacing.js
index b7b491a18..4ef9252d9 100644
--- a/lib/rules/mustache-interpolation-spacing.js
+++ b/lib/rules/mustache-interpolation-spacing.js
@@ -19,7 +19,7 @@ module.exports = {
     docs: {
       description: 'enforce unified spacing in mustache interpolations',
       category: 'strongly-recommended',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/mustache-interpolation-spacing.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/mustache-interpolation-spacing.md'
     },
     fixable: 'whitespace',
     schema: [
diff --git a/lib/rules/name-property-casing.js b/lib/rules/name-property-casing.js
index e9422eb0e..42ecb6924 100644
--- a/lib/rules/name-property-casing.js
+++ b/lib/rules/name-property-casing.js
@@ -12,45 +12,12 @@ const allowedCaseOptions = ['PascalCase', 'kebab-case']
 // Rule Definition
 // ------------------------------------------------------------------------------
 
-function create (context) {
-  const options = context.options[0]
-  const caseType = allowedCaseOptions.indexOf(options) !== -1 ? options : 'PascalCase'
-
-  // ----------------------------------------------------------------------
-  // Public
-  // ----------------------------------------------------------------------
-
-  return utils.executeOnVue(context, (obj) => {
-    const node = obj.properties
-      .find(item => (
-        item.type === 'Property' &&
-        item.key.name === 'name' &&
-        item.value.type === 'Literal'
-      ))
-
-    if (!node) return
-
-    const value = casing.getConverter(caseType)(node.value.value)
-    if (value !== node.value.value) {
-      context.report({
-        node: node.value,
-        message: 'Property name "{{value}}" is not {{caseType}}.',
-        data: {
-          value: node.value.value,
-          caseType: caseType
-        },
-        fix: fixer => fixer.replaceText(node.value, node.value.raw.replace(node.value.value, value))
-      })
-    }
-  })
-}
-
 module.exports = {
   meta: {
     docs: {
       description: 'enforce specific casing for the name property in Vue components',
       category: 'strongly-recommended',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/name-property-casing.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/name-property-casing.md'
     },
     fixable: 'code', // or "code" or "whitespace"
     schema: [
@@ -60,5 +27,36 @@ module.exports = {
     ]
   },
 
-  create
+  create (context) {
+    const options = context.options[0]
+    const caseType = allowedCaseOptions.indexOf(options) !== -1 ? options : 'PascalCase'
+
+    // ----------------------------------------------------------------------
+    // Public
+    // ----------------------------------------------------------------------
+
+    return utils.executeOnVue(context, (obj) => {
+      const node = obj.properties
+        .find(item => (
+          item.type === 'Property' &&
+          item.key.name === 'name' &&
+          item.value.type === 'Literal'
+        ))
+
+      if (!node) return
+
+      const value = casing.getConverter(caseType)(node.value.value)
+      if (value !== node.value.value) {
+        context.report({
+          node: node.value,
+          message: 'Property name "{{value}}" is not {{caseType}}.',
+          data: {
+            value: node.value.value,
+            caseType: caseType
+          },
+          fix: fixer => fixer.replaceText(node.value, node.value.raw.replace(node.value.value, value))
+        })
+      }
+    })
+  }
 }
diff --git a/lib/rules/no-async-in-computed-properties.js b/lib/rules/no-async-in-computed-properties.js
index 5327f82b0..f73948e68 100644
--- a/lib/rules/no-async-in-computed-properties.js
+++ b/lib/rules/no-async-in-computed-properties.js
@@ -55,103 +55,102 @@ function isPromise (node) {
   return false
 }
 
-function create (context) {
-  const forbiddenNodes = []
-
-  const expressionTypes = {
-    promise: 'asynchronous action',
-    await: 'await operator',
-    async: 'async function declaration',
-    new: 'Promise object',
-    timed: 'timed function'
-  }
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
 
-  function onFunctionEnter (node) {
-    if (node.async) {
-      forbiddenNodes.push({
-        node: node,
-        type: 'async'
-      })
+module.exports = {
+  meta: {
+    docs: {
+      description: 'disallow asynchronous actions in computed properties',
+      category: 'essential',
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/no-async-in-computed-properties.md'
+    },
+    fixable: null,
+    schema: []
+  },
+
+  create (context) {
+    const forbiddenNodes = []
+
+    const expressionTypes = {
+      promise: 'asynchronous action',
+      await: 'await operator',
+      async: 'async function declaration',
+      new: 'Promise object',
+      timed: 'timed function'
     }
-  }
 
-  return Object.assign({},
-    {
-      FunctionDeclaration: onFunctionEnter,
+    function onFunctionEnter (node) {
+      if (node.async) {
+        forbiddenNodes.push({
+          node: node,
+          type: 'async'
+        })
+      }
+    }
 
-      FunctionExpression: onFunctionEnter,
+    return Object.assign({},
+      {
+        FunctionDeclaration: onFunctionEnter,
 
-      ArrowFunctionExpression: onFunctionEnter,
+        FunctionExpression: onFunctionEnter,
 
-      NewExpression (node) {
-        if (node.callee.name === 'Promise') {
-          forbiddenNodes.push({
-            node: node,
-            type: 'new'
-          })
-        }
-      },
+        ArrowFunctionExpression: onFunctionEnter,
 
-      CallExpression (node) {
-        if (isPromise(node)) {
-          forbiddenNodes.push({
-            node: node,
-            type: 'promise'
-          })
-        }
-        if (isTimedFunction(node)) {
+        NewExpression (node) {
+          if (node.callee.name === 'Promise') {
+            forbiddenNodes.push({
+              node: node,
+              type: 'new'
+            })
+          }
+        },
+
+        CallExpression (node) {
+          if (isPromise(node)) {
+            forbiddenNodes.push({
+              node: node,
+              type: 'promise'
+            })
+          }
+          if (isTimedFunction(node)) {
+            forbiddenNodes.push({
+              node: node,
+              type: 'timed'
+            })
+          }
+        },
+
+        AwaitExpression (node) {
           forbiddenNodes.push({
             node: node,
-            type: 'timed'
+            type: 'await'
           })
         }
       },
-
-      AwaitExpression (node) {
-        forbiddenNodes.push({
-          node: node,
-          type: 'await'
-        })
-      }
-    },
-    utils.executeOnVue(context, (obj) => {
-      const computedProperties = utils.getComputedProperties(obj)
-
-      computedProperties.forEach(cp => {
-        forbiddenNodes.forEach(el => {
-          if (
-            cp.value &&
-            el.node.loc.start.line >= cp.value.loc.start.line &&
-            el.node.loc.end.line <= cp.value.loc.end.line
-          ) {
-            context.report({
-              node: el.node,
-              message: 'Unexpected {{expressionName}} in "{{propertyName}}" computed property.',
-              data: {
-                expressionName: expressionTypes[el.type],
-                propertyName: cp.key
-              }
-            })
-          }
+      utils.executeOnVue(context, (obj) => {
+        const computedProperties = utils.getComputedProperties(obj)
+
+        computedProperties.forEach(cp => {
+          forbiddenNodes.forEach(el => {
+            if (
+              cp.value &&
+              el.node.loc.start.line >= cp.value.loc.start.line &&
+              el.node.loc.end.line <= cp.value.loc.end.line
+            ) {
+              context.report({
+                node: el.node,
+                message: 'Unexpected {{expressionName}} in "{{propertyName}}" computed property.',
+                data: {
+                  expressionName: expressionTypes[el.type],
+                  propertyName: cp.key
+                }
+              })
+            }
+          })
         })
       })
-    })
-  )
-}
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-module.exports = {
-  create,
-  meta: {
-    docs: {
-      description: 'disallow asynchronous actions in computed properties',
-      category: 'essential',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/no-async-in-computed-properties.md'
-    },
-    fixable: null,
-    schema: []
+    )
   }
 }
diff --git a/lib/rules/no-confusing-v-for-v-if.js b/lib/rules/no-confusing-v-for-v-if.js
index e931be723..76f3f8d4d 100644
--- a/lib/rules/no-confusing-v-for-v-if.js
+++ b/lib/rules/no-confusing-v-for-v-if.js
@@ -30,41 +30,34 @@ function isUsingIterationVar (vIf) {
   )
 }
 
-/**
- * Creates AST event handlers for no-confusing-v-for-v-if.
- *
- * @param {RuleContext} context - The rule context.
- * @returns {Object} AST event handlers.
- */
-function create (context) {
-  return utils.defineTemplateBodyVisitor(context, {
-    "VAttribute[directive=true][key.name='if']" (node) {
-      const element = node.parent.parent
-
-      if (utils.hasDirective(element, 'for') && !isUsingIterationVar(node)) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "This 'v-if' should be moved to the wrapper element."
-        })
-      }
-    }
-  })
-}
-
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
 module.exports = {
-  create,
   meta: {
     docs: {
       description: 'disallow confusing `v-for` and `v-if` on the same element',
       category: 'recommended',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/no-confusing-v-for-v-if.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/no-confusing-v-for-v-if.md'
     },
-    fixable: false,
+    fixable: null,
     schema: []
+  },
+
+  create (context) {
+    return utils.defineTemplateBodyVisitor(context, {
+      "VAttribute[directive=true][key.name='if']" (node) {
+        const element = node.parent.parent
+
+        if (utils.hasDirective(element, 'for') && !isUsingIterationVar(node)) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "This 'v-if' should be moved to the wrapper element."
+          })
+        }
+      }
+    })
   }
 }
diff --git a/lib/rules/no-dupe-keys.js b/lib/rules/no-dupe-keys.js
index eccb1a9dd..2dde2eed2 100644
--- a/lib/rules/no-dupe-keys.js
+++ b/lib/rules/no-dupe-keys.js
@@ -12,44 +12,12 @@ const utils = require('../utils')
 
 const GROUP_NAMES = ['props', 'computed', 'data', 'methods']
 
-function create (context) {
-  const options = context.options[0] || {}
-  const groups = new Set(GROUP_NAMES.concat(options.groups || []))
-
-  // ----------------------------------------------------------------------
-  // Public
-  // ----------------------------------------------------------------------
-
-  return utils.executeOnVue(context, (obj) => {
-    const usedNames = []
-    const properties = utils.iterateProperties(obj, groups)
-
-    for (const o of properties) {
-      if (usedNames.indexOf(o.name) !== -1) {
-        context.report({
-          node: o.node,
-          message: "Duplicated key '{{name}}'.",
-          data: {
-            name: o.name
-          }
-        })
-      }
-
-      usedNames.push(o.name)
-    }
-  })
-}
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
 module.exports = {
   meta: {
     docs: {
       description: 'disallow duplication of field names',
       category: 'essential',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/no-dupe-keys.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/no-dupe-keys.md'
     },
     fixable: null, // or "code" or "whitespace"
     schema: [
@@ -65,5 +33,31 @@ module.exports = {
     ]
   },
 
-  create
+  create (context) {
+    const options = context.options[0] || {}
+    const groups = new Set(GROUP_NAMES.concat(options.groups || []))
+
+    // ----------------------------------------------------------------------
+    // Public
+    // ----------------------------------------------------------------------
+
+    return utils.executeOnVue(context, (obj) => {
+      const usedNames = []
+      const properties = utils.iterateProperties(obj, groups)
+
+      for (const o of properties) {
+        if (usedNames.indexOf(o.name) !== -1) {
+          context.report({
+            node: o.node,
+            message: "Duplicated key '{{name}}'.",
+            data: {
+              name: o.name
+            }
+          })
+        }
+
+        usedNames.push(o.name)
+      }
+    })
+  }
 }
diff --git a/lib/rules/no-duplicate-attributes.js b/lib/rules/no-duplicate-attributes.js
index cab14a6c8..d239de612 100644
--- a/lib/rules/no-duplicate-attributes.js
+++ b/lib/rules/no-duplicate-attributes.js
@@ -30,69 +30,18 @@ function getName (attribute) {
   return null
 }
 
-/**
- * Creates AST event handlers for no-duplicate-attributes.
- *
- * @param {RuleContext} context - The rule context.
- * @returns {Object} AST event handlers.
- */
-function create (context) {
-  const options = context.options[0] || {}
-  const allowCoexistStyle = options.allowCoexistStyle !== false
-  const allowCoexistClass = options.allowCoexistClass !== false
-
-  const directiveNames = new Set()
-  const attributeNames = new Set()
-
-  function isDuplicate (name, isDirective) {
-    if ((allowCoexistStyle && name === 'style') || (allowCoexistClass && name === 'class')) {
-      return isDirective ? directiveNames.has(name) : attributeNames.has(name)
-    }
-    return directiveNames.has(name) || attributeNames.has(name)
-  }
-
-  return utils.defineTemplateBodyVisitor(context, {
-    'VStartTag' () {
-      directiveNames.clear()
-      attributeNames.clear()
-    },
-    'VAttribute' (node) {
-      const name = getName(node)
-      if (name == null) {
-        return
-      }
-
-      if (isDuplicate(name, node.directive)) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "Duplicate attribute '{{name}}'.",
-          data: { name }
-        })
-      }
-
-      if (node.directive) {
-        directiveNames.add(name)
-      } else {
-        attributeNames.add(name)
-      }
-    }
-  })
-}
-
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
 module.exports = {
-  create,
   meta: {
     docs: {
       description: 'disallow duplication of attributes',
       category: 'essential',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/no-duplicate-attributes.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/no-duplicate-attributes.md'
     },
-    fixable: false,
+    fixable: null,
 
     schema: [
       {
@@ -107,5 +56,49 @@ module.exports = {
         }
       }
     ]
+  },
+
+  create (context) {
+    const options = context.options[0] || {}
+    const allowCoexistStyle = options.allowCoexistStyle !== false
+    const allowCoexistClass = options.allowCoexistClass !== false
+
+    const directiveNames = new Set()
+    const attributeNames = new Set()
+
+    function isDuplicate (name, isDirective) {
+      if ((allowCoexistStyle && name === 'style') || (allowCoexistClass && name === 'class')) {
+        return isDirective ? directiveNames.has(name) : attributeNames.has(name)
+      }
+      return directiveNames.has(name) || attributeNames.has(name)
+    }
+
+    return utils.defineTemplateBodyVisitor(context, {
+      'VStartTag' () {
+        directiveNames.clear()
+        attributeNames.clear()
+      },
+      'VAttribute' (node) {
+        const name = getName(node)
+        if (name == null) {
+          return
+        }
+
+        if (isDuplicate(name, node.directive)) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "Duplicate attribute '{{name}}'.",
+            data: { name }
+          })
+        }
+
+        if (node.directive) {
+          directiveNames.add(name)
+        } else {
+          attributeNames.add(name)
+        }
+      }
+    })
   }
 }
diff --git a/lib/rules/no-multi-spaces.js b/lib/rules/no-multi-spaces.js
index b8116dbe2..b0b4e7c3c 100644
--- a/lib/rules/no-multi-spaces.js
+++ b/lib/rules/no-multi-spaces.js
@@ -13,7 +13,7 @@ module.exports = {
     docs: {
       description: 'disallow multiple spaces',
       category: 'strongly-recommended',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/no-multi-spaces.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/no-multi-spaces.md'
     },
     fixable: 'whitespace', // or "code" or "whitespace"
     schema: []
diff --git a/lib/rules/no-parsing-error.js b/lib/rules/no-parsing-error.js
index 720396bca..7a5d3f757 100644
--- a/lib/rules/no-parsing-error.js
+++ b/lib/rules/no-parsing-error.js
@@ -49,55 +49,18 @@ const DEFAULT_OPTIONS = Object.freeze(Object.assign(Object.create(null), {
   'x-invalid-namespace': true
 }))
 
-/**
- * Creates AST event handlers for no-parsing-error.
- *
- * @param {RuleContext} context - The rule context.
- * @returns {Object} AST event handlers.
- */
-function create (context) {
-  const options = Object.assign({}, DEFAULT_OPTIONS, context.options[0] || {})
-
-  return {
-    Program (program) {
-      const node = program.templateBody
-      if (node == null || node.errors == null) {
-        return
-      }
-
-      for (const error of node.errors) {
-        if (error.code && !options[error.code]) {
-          continue
-        }
-
-        context.report({
-          node,
-          loc: { line: error.lineNumber, column: error.column },
-          message: 'Parsing error: {{message}}.',
-          data: {
-            message: error.message.endsWith('.')
-              ? error.message.slice(0, -1)
-              : error.message
-          }
-        })
-      }
-    }
-  }
-}
-
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
 module.exports = {
-  create,
   meta: {
     docs: {
       description: 'disallow parsing errors in `<template>`',
       category: 'essential',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/no-parsing-error.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/no-parsing-error.md'
     },
-    fixable: false,
+    fixable: null,
     schema: [
       {
         type: 'object',
@@ -108,5 +71,35 @@ module.exports = {
         additionalProperties: false
       }
     ]
+  },
+
+  create (context) {
+    const options = Object.assign({}, DEFAULT_OPTIONS, context.options[0] || {})
+
+    return {
+      Program (program) {
+        const node = program.templateBody
+        if (node == null || node.errors == null) {
+          return
+        }
+
+        for (const error of node.errors) {
+          if (error.code && !options[error.code]) {
+            continue
+          }
+
+          context.report({
+            node,
+            loc: { line: error.lineNumber, column: error.column },
+            message: 'Parsing error: {{message}}.',
+            data: {
+              message: error.message.endsWith('.')
+                ? error.message.slice(0, -1)
+                : error.message
+            }
+          })
+        }
+      }
+    }
   }
 }
diff --git a/lib/rules/no-reserved-keys.js b/lib/rules/no-reserved-keys.js
index 61f91a9b6..6e49f5792 100644
--- a/lib/rules/no-reserved-keys.js
+++ b/lib/rules/no-reserved-keys.js
@@ -13,45 +13,12 @@ const utils = require('../utils')
 const RESERVED_KEYS = require('../utils/vue-reserved.json')
 const GROUP_NAMES = ['props', 'computed', 'data', 'methods']
 
-function create (context) {
-  const options = context.options[0] || {}
-  const reservedKeys = new Set(RESERVED_KEYS.concat(options.reserved || []))
-  const groups = new Set(GROUP_NAMES.concat(options.groups || []))
-
-  // ----------------------------------------------------------------------
-  // Public
-  // ----------------------------------------------------------------------
-
-  return utils.executeOnVue(context, (obj) => {
-    const properties = utils.iterateProperties(obj, groups)
-    for (const o of properties) {
-      if (o.groupName === 'data' && o.name[0] === '_') {
-        context.report({
-          node: o.node,
-          message: "Keys starting with with '_' are reserved in '{{name}}' group.",
-          data: {
-            name: o.name
-          }
-        })
-      } else if (reservedKeys.has(o.name)) {
-        context.report({
-          node: o.node,
-          message: "Key '{{name}}' is reserved.",
-          data: {
-            name: o.name
-          }
-        })
-      }
-    }
-  })
-}
-
 module.exports = {
   meta: {
     docs: {
       description: 'disallow overwriting reserved keys',
       category: 'essential',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/no-reserved-keys.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/no-reserved-keys.md'
     },
     fixable: null,
     schema: [
@@ -70,5 +37,36 @@ module.exports = {
     ]
   },
 
-  create
+  create (context) {
+    const options = context.options[0] || {}
+    const reservedKeys = new Set(RESERVED_KEYS.concat(options.reserved || []))
+    const groups = new Set(GROUP_NAMES.concat(options.groups || []))
+
+    // ----------------------------------------------------------------------
+    // Public
+    // ----------------------------------------------------------------------
+
+    return utils.executeOnVue(context, (obj) => {
+      const properties = utils.iterateProperties(obj, groups)
+      for (const o of properties) {
+        if (o.groupName === 'data' && o.name[0] === '_') {
+          context.report({
+            node: o.node,
+            message: "Keys starting with with '_' are reserved in '{{name}}' group.",
+            data: {
+              name: o.name
+            }
+          })
+        } else if (reservedKeys.has(o.name)) {
+          context.report({
+            node: o.node,
+            message: "Key '{{name}}' is reserved.",
+            data: {
+              name: o.name
+            }
+          })
+        }
+      }
+    })
+  }
 }
diff --git a/lib/rules/no-shared-component-data.js b/lib/rules/no-shared-component-data.js
index 99d7c5de5..d946a5cb0 100644
--- a/lib/rules/no-shared-component-data.js
+++ b/lib/rules/no-shared-component-data.js
@@ -31,42 +31,6 @@ function getFirstAndLastTokens (node, sourceCode) {
   }
 }
 
-function create (context) {
-  const sourceCode = context.getSourceCode()
-
-  return utils.executeOnVueComponent(context, (obj) => {
-    obj.properties
-      .filter(p =>
-        p.type === 'Property' &&
-        p.key.type === 'Identifier' &&
-        p.key.name === 'data' &&
-        p.value.type !== 'FunctionExpression' &&
-        p.value.type !== 'ArrowFunctionExpression' &&
-        p.value.type !== 'Identifier'
-      )
-      .forEach(p => {
-        context.report({
-          node: p,
-          message: '`data` property in component must be a function',
-          fix (fixer) {
-            const tokens = getFirstAndLastTokens(p.value, sourceCode)
-
-            // If we can upgrade requirements to `eslint@>4.1.0`, this code can be replaced by:
-            //     return [
-            //       fixer.insertTextBefore(tokens.first, 'function() {\nreturn '),
-            //       fixer.insertTextAfter(tokens.last, ';\n}')
-            //     ]
-            // See: https://eslint.org/blog/2017/06/eslint-v4.1.0-released#applying-multiple-autofixes-simultaneously
-            const range = [tokens.first.range[0], tokens.last.range[1]]
-            const valueText = sourceCode.text.slice(range[0], range[1])
-            const replacement = `function() {\nreturn ${valueText};\n}`
-            return fixer.replaceTextRange(range, replacement)
-          }
-        })
-      })
-  })
-}
-
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
@@ -76,11 +40,45 @@ module.exports = {
     docs: {
       description: "enforce component's data property to be a function",
       category: 'essential',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/no-shared-component-data.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/no-shared-component-data.md'
     },
     fixable: 'code',
     schema: []
   },
 
-  create
+  create (context) {
+    const sourceCode = context.getSourceCode()
+
+    return utils.executeOnVueComponent(context, (obj) => {
+      obj.properties
+        .filter(p =>
+          p.type === 'Property' &&
+          p.key.type === 'Identifier' &&
+          p.key.name === 'data' &&
+          p.value.type !== 'FunctionExpression' &&
+          p.value.type !== 'ArrowFunctionExpression' &&
+          p.value.type !== 'Identifier'
+        )
+        .forEach(p => {
+          context.report({
+            node: p,
+            message: '`data` property in component must be a function.',
+            fix (fixer) {
+              const tokens = getFirstAndLastTokens(p.value, sourceCode)
+
+              // If we can upgrade requirements to `eslint@>4.1.0`, this code can be replaced by:
+              //     return [
+              //       fixer.insertTextBefore(tokens.first, 'function() {\nreturn '),
+              //       fixer.insertTextAfter(tokens.last, ';\n}')
+              //     ]
+              // See: https://eslint.org/blog/2017/06/eslint-v4.1.0-released#applying-multiple-autofixes-simultaneously
+              const range = [tokens.first.range[0], tokens.last.range[1]]
+              const valueText = sourceCode.text.slice(range[0], range[1])
+              const replacement = `function() {\nreturn ${valueText};\n}`
+              return fixer.replaceTextRange(range, replacement)
+            }
+          })
+        })
+    })
+  }
 }
diff --git a/lib/rules/no-side-effects-in-computed-properties.js b/lib/rules/no-side-effects-in-computed-properties.js
index e531a3e39..8cb333544 100644
--- a/lib/rules/no-side-effects-in-computed-properties.js
+++ b/lib/rules/no-side-effects-in-computed-properties.js
@@ -6,68 +6,68 @@
 
 const utils = require('../utils')
 
-function create (context) {
-  const forbiddenNodes = []
-
-  return Object.assign({},
-    {
-      // this.xxx <=|+=|-=>
-      'AssignmentExpression' (node) {
-        if (node.left.type !== 'MemberExpression') return
-        if (utils.parseMemberExpression(node.left)[0] === 'this') {
-          forbiddenNodes.push(node)
-        }
-      },
-      // this.xxx <++|-->
-      'UpdateExpression > MemberExpression' (node) {
-        if (utils.parseMemberExpression(node)[0] === 'this') {
-          forbiddenNodes.push(node)
-        }
-      },
-      // this.xxx.func()
-      'CallExpression' (node) {
-        const code = context.getSourceCode().getText(node)
-        const MUTATION_REGEX = /(this.)((?!(concat|slice|map|filter)\().)[^\)]*((push|pop|shift|unshift|reverse|splice|sort|copyWithin|fill)\()/g
-
-        if (MUTATION_REGEX.test(code)) {
-          forbiddenNodes.push(node)
-        }
-      }
-    },
-    utils.executeOnVue(context, (obj) => {
-      const computedProperties = utils.getComputedProperties(obj)
-
-      computedProperties.forEach(cp => {
-        forbiddenNodes.forEach(node => {
-          if (
-            cp.value &&
-            node.loc.start.line >= cp.value.loc.start.line &&
-            node.loc.end.line <= cp.value.loc.end.line
-          ) {
-            context.report({
-              node: node,
-              message: `Unexpected side effect in "${cp.key}" computed property.`
-            })
-          }
-        })
-      })
-    })
-  )
-}
-
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
 module.exports = {
-  create,
   meta: {
     docs: {
       description: 'disallow side effects in computed properties',
       category: 'essential',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/no-side-effects-in-computed-properties.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/no-side-effects-in-computed-properties.md'
     },
     fixable: null,
     schema: []
+  },
+
+  create (context) {
+    const forbiddenNodes = []
+
+    return Object.assign({},
+      {
+        // this.xxx <=|+=|-=>
+        'AssignmentExpression' (node) {
+          if (node.left.type !== 'MemberExpression') return
+          if (utils.parseMemberExpression(node.left)[0] === 'this') {
+            forbiddenNodes.push(node)
+          }
+        },
+        // this.xxx <++|-->
+        'UpdateExpression > MemberExpression' (node) {
+          if (utils.parseMemberExpression(node)[0] === 'this') {
+            forbiddenNodes.push(node)
+          }
+        },
+        // this.xxx.func()
+        'CallExpression' (node) {
+          const code = context.getSourceCode().getText(node)
+          const MUTATION_REGEX = /(this.)((?!(concat|slice|map|filter)\().)[^\)]*((push|pop|shift|unshift|reverse|splice|sort|copyWithin|fill)\()/g
+
+          if (MUTATION_REGEX.test(code)) {
+            forbiddenNodes.push(node)
+          }
+        }
+      },
+      utils.executeOnVue(context, (obj) => {
+        const computedProperties = utils.getComputedProperties(obj)
+
+        computedProperties.forEach(cp => {
+          forbiddenNodes.forEach(node => {
+            if (
+              cp.value &&
+              node.loc.start.line >= cp.value.loc.start.line &&
+              node.loc.end.line <= cp.value.loc.end.line
+            ) {
+              context.report({
+                node: node,
+                message: 'Unexpected side effect in "{{key}}" computed property.',
+                data: { key: cp.key }
+              })
+            }
+          })
+        })
+      })
+    )
   }
 }
diff --git a/lib/rules/no-template-key.js b/lib/rules/no-template-key.js
index 1c0436755..97db9c8f4 100644
--- a/lib/rules/no-template-key.js
+++ b/lib/rules/no-template-key.js
@@ -11,43 +11,32 @@
 
 const utils = require('../utils')
 
-// ------------------------------------------------------------------------------
-// Helpers
-// ------------------------------------------------------------------------------
-
-/**
- * Creates AST event handlers for no-template-key.
- *
- * @param {RuleContext} context - The rule context.
- * @returns {Object} AST event handlers.
- */
-function create (context) {
-  return utils.defineTemplateBodyVisitor(context, {
-    "VElement[name='template']" (node) {
-      if (utils.hasAttribute(node, 'key') || utils.hasDirective(node, 'bind', 'key')) {
-        context.report({
-          node: node,
-          loc: node.loc,
-          message: "'<template>' cannot be keyed. Place the key on real elements instead."
-        })
-      }
-    }
-  })
-}
-
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
 module.exports = {
-  create,
   meta: {
     docs: {
       description: 'disallow `key` attribute on `<template>`',
       category: 'essential',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/no-template-key.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/no-template-key.md'
     },
-    fixable: false,
+    fixable: null,
     schema: []
+  },
+
+  create (context) {
+    return utils.defineTemplateBodyVisitor(context, {
+      "VElement[name='template']" (node) {
+        if (utils.hasAttribute(node, 'key') || utils.hasDirective(node, 'bind', 'key')) {
+          context.report({
+            node: node,
+            loc: node.loc,
+            message: "'<template>' cannot be keyed. Place the key on real elements instead."
+          })
+        }
+      }
+    })
   }
 }
diff --git a/lib/rules/no-textarea-mustache.js b/lib/rules/no-textarea-mustache.js
index b9e6009ee..833e52259 100644
--- a/lib/rules/no-textarea-mustache.js
+++ b/lib/rules/no-textarea-mustache.js
@@ -11,45 +11,34 @@
 
 const utils = require('../utils')
 
-// ------------------------------------------------------------------------------
-// Helpers
-// ------------------------------------------------------------------------------
-
-/**
- * Creates AST event handlers for no-textarea-mustache.
- *
- * @param {RuleContext} context - The rule context.
- * @returns {Object} AST event handlers.
- */
-function create (context) {
-  return utils.defineTemplateBodyVisitor(context, {
-    "VElement[name='textarea'] VExpressionContainer" (node) {
-      if (node.parent.type !== 'VElement') {
-        return
-      }
-
-      context.report({
-        node,
-        loc: node.loc,
-        message: "Unexpected mustache. Use 'v-model' instead."
-      })
-    }
-  })
-}
-
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
 module.exports = {
-  create,
   meta: {
     docs: {
       description: 'disallow mustaches in `<textarea>`',
       category: 'essential',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/no-textarea-mustache.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/no-textarea-mustache.md'
     },
-    fixable: false,
+    fixable: null,
     schema: []
+  },
+
+  create (context) {
+    return utils.defineTemplateBodyVisitor(context, {
+      "VElement[name='textarea'] VExpressionContainer" (node) {
+        if (node.parent.type !== 'VElement') {
+          return
+        }
+
+        context.report({
+          node,
+          loc: node.loc,
+          message: "Unexpected mustache. Use 'v-model' instead."
+        })
+      }
+    })
   }
 }
diff --git a/lib/rules/no-unused-vars.js b/lib/rules/no-unused-vars.js
index 13fa94a58..442269fe0 100644
--- a/lib/rules/no-unused-vars.js
+++ b/lib/rules/no-unused-vars.js
@@ -6,47 +6,40 @@
 
 const utils = require('../utils')
 
-/**
- * Creates AST event handlers for require-v-for-key.
- *
- * @param {RuleContext} context - The rule context.
- * @returns {Object} AST event handlers.
- */
-function create (context) {
-  return utils.defineTemplateBodyVisitor(context, {
-    VElement (node) {
-      const variables = node.variables
-
-      for (
-        let i = variables.length - 1;
-        i >= 0 && !variables[i].references.length;
-        i--
-      ) {
-        const variable = variables[i]
-        context.report({
-          node: variable.id,
-          loc: variable.id.loc,
-          message: `'{{name}}' is defined but never used.`,
-          data: variable.id
-        })
-      }
-    }
-  })
-}
-
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
 module.exports = {
-  create,
   meta: {
     docs: {
       description: 'disallow unused variable definitions of v-for directives or scope attributes',
       category: 'essential',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/no-unused-vars.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/no-unused-vars.md'
     },
     fixable: null,
     schema: []
+  },
+
+  create (context) {
+    return utils.defineTemplateBodyVisitor(context, {
+      VElement (node) {
+        const variables = node.variables
+
+        for (
+          let i = variables.length - 1;
+          i >= 0 && !variables[i].references.length;
+          i--
+        ) {
+          const variable = variables[i]
+          context.report({
+            node: variable.id,
+            loc: variable.id.loc,
+            message: `'{{name}}' is defined but never used.`,
+            data: variable.id
+          })
+        }
+      }
+    })
   }
 }
diff --git a/lib/rules/order-in-components.js b/lib/rules/order-in-components.js
index c941448c8..cb27e3edf 100644
--- a/lib/rules/order-in-components.js
+++ b/lib/rules/order-in-components.js
@@ -56,52 +56,16 @@ function getOrderMap (order) {
   return orderMap
 }
 
-function checkOrder (propertiesNodes, orderMap, context) {
-  const properties = propertiesNodes
-    .filter(property => property.type === 'Property')
-    .map(property => property.key)
-
-  properties.forEach((property, i) => {
-    const propertiesAbove = properties.slice(0, i)
-    const unorderedProperties = propertiesAbove
-      .filter(p => orderMap.get(p.name) > orderMap.get(property.name))
-      .sort((p1, p2) => orderMap.get(p1.name) > orderMap.get(p2.name))
-
-    const firstUnorderedProperty = unorderedProperties[0]
-
-    if (firstUnorderedProperty) {
-      const line = firstUnorderedProperty.loc.start.line
-      context.report({
-        node: property,
-        message: `The "${property.name}" property should be above the "${firstUnorderedProperty.name}" property on line ${line}.`
-      })
-    }
-  })
-}
-
-function create (context) {
-  const options = context.options[0] || {}
-  const order = options.order || defaultOrder
-
-  const extendedOrder = order.map(property => groups[property] || property)
-  const orderMap = getOrderMap(extendedOrder)
-
-  return utils.executeOnVue(context, (obj) => {
-    checkOrder(obj.properties, orderMap, context)
-  })
-}
-
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
 module.exports = {
-  create,
   meta: {
     docs: {
       description: 'enforce order of properties in components',
       category: 'recommended',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/order-in-components.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/order-in-components.md'
     },
     fixable: null,
     schema: [
@@ -115,5 +79,44 @@ module.exports = {
         additionalProperties: false
       }
     ]
+  },
+
+  create (context) {
+    const options = context.options[0] || {}
+    const order = options.order || defaultOrder
+    const extendedOrder = order.map(property => groups[property] || property)
+    const orderMap = getOrderMap(extendedOrder)
+
+    function checkOrder (propertiesNodes, orderMap) {
+      const properties = propertiesNodes
+        .filter(property => property.type === 'Property')
+        .map(property => property.key)
+
+      properties.forEach((property, i) => {
+        const propertiesAbove = properties.slice(0, i)
+        const unorderedProperties = propertiesAbove
+          .filter(p => orderMap.get(p.name) > orderMap.get(property.name))
+          .sort((p1, p2) => orderMap.get(p1.name) > orderMap.get(p2.name))
+
+        const firstUnorderedProperty = unorderedProperties[0]
+
+        if (firstUnorderedProperty) {
+          const line = firstUnorderedProperty.loc.start.line
+          context.report({
+            node: property,
+            message: `The "{{name}}" property should be above the "{{firstUnorderedPropertyName}}" property on line {{line}}.`,
+            data: {
+              name: property.name,
+              firstUnorderedPropertyName: firstUnorderedProperty.name,
+              line
+            }
+          })
+        }
+      })
+    }
+
+    return utils.executeOnVue(context, (obj) => {
+      checkOrder(obj.properties, orderMap)
+    })
   }
 }
diff --git a/lib/rules/require-component-is.js b/lib/rules/require-component-is.js
index b192288f3..1c945ae5d 100644
--- a/lib/rules/require-component-is.js
+++ b/lib/rules/require-component-is.js
@@ -11,43 +11,32 @@
 
 const utils = require('../utils')
 
-// ------------------------------------------------------------------------------
-// Helpers
-// ------------------------------------------------------------------------------
-
-/**
- * Creates AST event handlers for require-component-is.
- *
- * @param {RuleContext} context - The rule context.
- * @returns {Object} AST event handlers.
- */
-function create (context) {
-  return utils.defineTemplateBodyVisitor(context, {
-    "VElement[name='component']" (node) {
-      if (!utils.hasDirective(node, 'bind', 'is')) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "Expected '<component>' elements to have 'v-bind:is' attribute."
-        })
-      }
-    }
-  })
-}
-
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
 module.exports = {
-  create,
   meta: {
     docs: {
       description: 'require `v-bind:is` of `<component>` elements',
       category: 'essential',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/require-component-is.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/require-component-is.md'
     },
-    fixable: false,
+    fixable: null,
     schema: []
+  },
+
+  create (context) {
+    return utils.defineTemplateBodyVisitor(context, {
+      "VElement[name='component']" (node) {
+        if (!utils.hasDirective(node, 'bind', 'is')) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "Expected '<component>' elements to have 'v-bind:is' attribute."
+          })
+        }
+      }
+    })
   }
 }
diff --git a/lib/rules/require-default-prop.js b/lib/rules/require-default-prop.js
index c792ceeb1..6a3c0500a 100644
--- a/lib/rules/require-default-prop.js
+++ b/lib/rules/require-default-prop.js
@@ -15,7 +15,7 @@ module.exports = {
     docs: {
       description: 'require default value for props',
       category: 'strongly-recommended',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/require-default-prop.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/require-default-prop.md'
     },
     fixable: null, // or "code" or "whitespace"
     schema: []
diff --git a/lib/rules/require-prop-types.js b/lib/rules/require-prop-types.js
index 7f7ef11b7..44002b2cd 100644
--- a/lib/rules/require-prop-types.js
+++ b/lib/rules/require-prop-types.js
@@ -6,75 +6,6 @@
 
 const utils = require('../utils')
 
-function create (context) {
-  // ----------------------------------------------------------------------
-  // Helpers
-  // ----------------------------------------------------------------------
-
-  function objectHasType (node) {
-    const typeProperty = node.properties
-      .find(p =>
-        utils.getStaticPropertyName(p.key) === 'type' &&
-        (
-          p.value.type !== 'ArrayExpression' ||
-          p.value.elements.length > 0
-        )
-      )
-    return Boolean(typeProperty)
-  }
-
-  function checkProperties (items) {
-    for (const cp of items) {
-      if (cp.type !== 'Property') {
-        return
-      }
-      let hasType = true
-      if (cp.value.type === 'ObjectExpression') { // foo: {
-        hasType = objectHasType(cp.value)
-      } else if (cp.value.type === 'ArrayExpression') { // foo: [
-        hasType = cp.value.elements.length > 0
-      } else if (cp.value.type === 'FunctionExpression' || cp.value.type === 'ArrowFunctionExpression') {
-        hasType = false
-      }
-      if (!hasType) {
-        context.report({
-          node: cp,
-          message: 'Prop "{{name}}" should define at least its type.',
-          data: {
-            name: cp.key.name
-          }
-        })
-      }
-    }
-  }
-
-  // ----------------------------------------------------------------------
-  // Public
-  // ----------------------------------------------------------------------
-
-  return utils.executeOnVue(context, (obj) => {
-    const node = obj.properties
-      .find(p =>
-        p.type === 'Property' &&
-        p.key.type === 'Identifier' &&
-        p.key.name === 'props'
-      )
-
-    if (!node) return
-
-    if (node.value.type === 'ObjectExpression') {
-      checkProperties(node.value.properties)
-    }
-
-    if (node.value.type === 'ArrayExpression') {
-      context.report({
-        node,
-        message: 'Props should at least define their types.'
-      })
-    }
-  })
-}
-
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
@@ -84,7 +15,7 @@ module.exports = {
     docs: {
       description: 'require type definitions in props',
       category: 'strongly-recommended',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/require-prop-types.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/require-prop-types.md'
     },
     fixable: null, // or "code" or "whitespace"
     schema: [
@@ -92,5 +23,72 @@ module.exports = {
     ]
   },
 
-  create
+  create (context) {
+    // ----------------------------------------------------------------------
+    // Helpers
+    // ----------------------------------------------------------------------
+
+    function objectHasType (node) {
+      const typeProperty = node.properties
+        .find(p =>
+          utils.getStaticPropertyName(p.key) === 'type' &&
+          (
+            p.value.type !== 'ArrayExpression' ||
+            p.value.elements.length > 0
+          )
+        )
+      return Boolean(typeProperty)
+    }
+
+    function checkProperties (items) {
+      for (const cp of items) {
+        if (cp.type !== 'Property') {
+          return
+        }
+        let hasType = true
+        if (cp.value.type === 'ObjectExpression') { // foo: {
+          hasType = objectHasType(cp.value)
+        } else if (cp.value.type === 'ArrayExpression') { // foo: [
+          hasType = cp.value.elements.length > 0
+        } else if (cp.value.type === 'FunctionExpression' || cp.value.type === 'ArrowFunctionExpression') {
+          hasType = false
+        }
+        if (!hasType) {
+          context.report({
+            node: cp,
+            message: 'Prop "{{name}}" should define at least its type.',
+            data: {
+              name: cp.key.name
+            }
+          })
+        }
+      }
+    }
+
+    // ----------------------------------------------------------------------
+    // Public
+    // ----------------------------------------------------------------------
+
+    return utils.executeOnVue(context, (obj) => {
+      const node = obj.properties
+        .find(p =>
+          p.type === 'Property' &&
+          p.key.type === 'Identifier' &&
+          p.key.name === 'props'
+        )
+
+      if (!node) return
+
+      if (node.value.type === 'ObjectExpression') {
+        checkProperties(node.value.properties)
+      }
+
+      if (node.value.type === 'ArrayExpression') {
+        context.report({
+          node,
+          message: 'Props should at least define their types.'
+        })
+      }
+    })
+  }
 }
diff --git a/lib/rules/require-render-return.js b/lib/rules/require-render-return.js
index 565aa5b24..decedbdbe 100644
--- a/lib/rules/require-render-return.js
+++ b/lib/rules/require-render-return.js
@@ -6,36 +6,6 @@
 
 const utils = require('../utils')
 
-function create (context) {
-  const forbiddenNodes = []
-
-  // ----------------------------------------------------------------------
-  // Public
-  // ----------------------------------------------------------------------
-
-  return Object.assign({},
-    utils.executeOnFunctionsWithoutReturn(true, node => {
-      forbiddenNodes.push(node)
-    }),
-    utils.executeOnVue(context, obj => {
-      const node = obj.properties.find(item => item.type === 'Property' &&
-        utils.getStaticPropertyName(item) === 'render' &&
-        (item.value.type === 'ArrowFunctionExpression' || item.value.type === 'FunctionExpression')
-      )
-      if (!node) return
-
-      forbiddenNodes.forEach(el => {
-        if (node.value === el) {
-          context.report({
-            node: node.key,
-            message: 'Expected to return a value in render function.'
-          })
-        }
-      })
-    })
-  )
-}
-
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
@@ -45,11 +15,39 @@ module.exports = {
     docs: {
       description: 'enforce render function to always return value',
       category: 'essential',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/require-render-return.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/require-render-return.md'
     },
     fixable: null, // or "code" or "whitespace"
     schema: []
   },
 
-  create
+  create (context) {
+    const forbiddenNodes = []
+
+    // ----------------------------------------------------------------------
+    // Public
+    // ----------------------------------------------------------------------
+
+    return Object.assign({},
+      utils.executeOnFunctionsWithoutReturn(true, node => {
+        forbiddenNodes.push(node)
+      }),
+      utils.executeOnVue(context, obj => {
+        const node = obj.properties.find(item => item.type === 'Property' &&
+          utils.getStaticPropertyName(item) === 'render' &&
+          (item.value.type === 'ArrowFunctionExpression' || item.value.type === 'FunctionExpression')
+        )
+        if (!node) return
+
+        forbiddenNodes.forEach(el => {
+          if (node.value === el) {
+            context.report({
+              node: node.key,
+              message: 'Expected to return a value in render function.'
+            })
+          }
+        })
+      })
+    )
+  }
 }
diff --git a/lib/rules/require-v-for-key.js b/lib/rules/require-v-for-key.js
index ebe18dcca..d007f6f4f 100644
--- a/lib/rules/require-v-for-key.js
+++ b/lib/rules/require-v-for-key.js
@@ -11,58 +11,46 @@
 
 const utils = require('../utils')
 
-// ------------------------------------------------------------------------------
-// Helpers
-// ------------------------------------------------------------------------------
-
-/**
- * Check the given element about `v-bind:key` attributes.
- * @param {RuleContext} context The rule context to report.
- * @param {ASTNode} element The element node to check.
- */
-function checkKey (context, element) {
-  if (element.name === 'template' || element.name === 'slot') {
-    for (const child of element.children) {
-      if (child.type === 'VElement') {
-        checkKey(context, child)
-      }
-    }
-  } else if (!utils.isCustomComponent(element) && !utils.hasDirective(element, 'bind', 'key')) {
-    context.report({
-      node: element.startTag,
-      loc: element.startTag.loc,
-      message: "Elements in iteration expect to have 'v-bind:key' directives."
-    })
-  }
-}
-
-/**
- * Creates AST event handlers for require-v-for-key.
- *
- * @param {RuleContext} context - The rule context.
- * @returns {Object} AST event handlers.
- */
-function create (context) {
-  return utils.defineTemplateBodyVisitor(context, {
-    "VAttribute[directive=true][key.name='for']" (node) {
-      checkKey(context, node.parent.parent)
-    }
-  })
-}
-
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
 module.exports = {
-  create,
   meta: {
     docs: {
       description: 'require `v-bind:key` with `v-for` directives',
       category: 'essential',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/require-v-for-key.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/require-v-for-key.md'
     },
-    fixable: false,
+    fixable: null,
     schema: []
+  },
+
+  create (context) {
+    /**
+     * Check the given element about `v-bind:key` attributes.
+     * @param {ASTNode} element The element node to check.
+     */
+    function checkKey (element) {
+      if (element.name === 'template' || element.name === 'slot') {
+        for (const child of element.children) {
+          if (child.type === 'VElement') {
+            checkKey(child)
+          }
+        }
+      } else if (!utils.isCustomComponent(element) && !utils.hasDirective(element, 'bind', 'key')) {
+        context.report({
+          node: element.startTag,
+          loc: element.startTag.loc,
+          message: "Elements in iteration expect to have 'v-bind:key' directives."
+        })
+      }
+    }
+
+    return utils.defineTemplateBodyVisitor(context, {
+      "VAttribute[directive=true][key.name='for']" (node) {
+        checkKey(node.parent.parent)
+      }
+    })
   }
 }
diff --git a/lib/rules/require-valid-default-prop.js b/lib/rules/require-valid-default-prop.js
index 022123e25..e3c07c39b 100644
--- a/lib/rules/require-valid-default-prop.js
+++ b/lib/rules/require-valid-default-prop.js
@@ -24,7 +24,7 @@ module.exports = {
     docs: {
       description: 'enforce props default values to be valid',
       category: 'essential',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/require-valid-default-prop.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/require-valid-default-prop.md'
     },
     fixable: null,
     schema: []
diff --git a/lib/rules/return-in-computed-property.js b/lib/rules/return-in-computed-property.js
index a931b669e..fc3584eeb 100644
--- a/lib/rules/return-in-computed-property.js
+++ b/lib/rules/return-in-computed-property.js
@@ -6,40 +6,6 @@
 
 const utils = require('../utils')
 
-function create (context) {
-  const options = context.options[0] || {}
-  const treatUndefinedAsUnspecified = !(options.treatUndefinedAsUnspecified === false)
-
-  const forbiddenNodes = []
-
-  // ----------------------------------------------------------------------
-  // Public
-  // ----------------------------------------------------------------------
-
-  return Object.assign({},
-    utils.executeOnFunctionsWithoutReturn(treatUndefinedAsUnspecified, node => {
-      forbiddenNodes.push(node)
-    }),
-    utils.executeOnVue(context, properties => {
-      const computedProperties = utils.getComputedProperties(properties)
-
-      computedProperties.forEach(cp => {
-        forbiddenNodes.forEach(el => {
-          if (cp.value && cp.value.parent === el) {
-            context.report({
-              node: el,
-              message: 'Expected to return a value in "{{name}}" computed property.',
-              data: {
-                name: cp.key
-              }
-            })
-          }
-        })
-      })
-    })
-  )
-}
-
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
@@ -49,7 +15,7 @@ module.exports = {
     docs: {
       description: 'enforce that a return statement is present in computed property',
       category: 'essential',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/return-in-computed-property.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/return-in-computed-property.md'
     },
     fixable: null, // or "code" or "whitespace"
     schema: [
@@ -65,5 +31,37 @@ module.exports = {
     ]
   },
 
-  create
+  create (context) {
+    const options = context.options[0] || {}
+    const treatUndefinedAsUnspecified = !(options.treatUndefinedAsUnspecified === false)
+
+    const forbiddenNodes = []
+
+    // ----------------------------------------------------------------------
+    // Public
+    // ----------------------------------------------------------------------
+
+    return Object.assign({},
+      utils.executeOnFunctionsWithoutReturn(treatUndefinedAsUnspecified, node => {
+        forbiddenNodes.push(node)
+      }),
+      utils.executeOnVue(context, properties => {
+        const computedProperties = utils.getComputedProperties(properties)
+
+        computedProperties.forEach(cp => {
+          forbiddenNodes.forEach(el => {
+            if (cp.value && cp.value.parent === el) {
+              context.report({
+                node: el,
+                message: 'Expected to return a value in "{{name}}" computed property.',
+                data: {
+                  name: cp.key
+                }
+              })
+            }
+          })
+        })
+      })
+    )
+  }
 }
diff --git a/lib/rules/script-indent.js b/lib/rules/script-indent.js
index 8d25ade84..1f6f74ee8 100644
--- a/lib/rules/script-indent.js
+++ b/lib/rules/script-indent.js
@@ -15,14 +15,11 @@ const indentCommon = require('../utils/indent-common')
 // ------------------------------------------------------------------------------
 
 module.exports = {
-  create (context) {
-    return indentCommon.defineVisitor(context, context.getSourceCode(), {})
-  },
   meta: {
     docs: {
       description: 'enforce consistent indentation in `<script>`',
       category: undefined,
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/script-indent.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/script-indent.md'
     },
     fixable: 'whitespace',
     schema: [
@@ -53,5 +50,8 @@ module.exports = {
         additionalProperties: false
       }
     ]
+  },
+  create (context) {
+    return indentCommon.defineVisitor(context, context.getSourceCode(), {})
   }
 }
diff --git a/lib/rules/this-in-template.js b/lib/rules/this-in-template.js
index ed5ae1197..9813133b2 100644
--- a/lib/rules/this-in-template.js
+++ b/lib/rules/this-in-template.js
@@ -20,7 +20,7 @@ module.exports = {
     docs: {
       description: 'enforce usage of `this` in template',
       category: 'recommended',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/this-in-template.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/this-in-template.md'
     },
     fixable: null,
     schema: [
diff --git a/lib/rules/v-bind-style.js b/lib/rules/v-bind-style.js
index deafc6e8a..e4d3e98b4 100644
--- a/lib/rules/v-bind-style.js
+++ b/lib/rules/v-bind-style.js
@@ -11,54 +11,43 @@
 
 const utils = require('../utils')
 
-// ------------------------------------------------------------------------------
-// Helpers
-// ------------------------------------------------------------------------------
-
-/**
- * Creates AST event handlers for v-bind-style.
- *
- * @param {RuleContext} context - The rule context.
- * @returns {Object} AST event handlers.
- */
-function create (context) {
-  const shorthand = context.options[0] !== 'longform'
-
-  return utils.defineTemplateBodyVisitor(context, {
-    "VAttribute[directive=true][key.name='bind'][key.argument!=null]" (node) {
-      if (node.key.shorthand === shorthand) {
-        return
-      }
-
-      context.report({
-        node,
-        loc: node.loc,
-        message: shorthand
-          ? "Unexpected 'v-bind' before ':'."
-          : "Expected 'v-bind' before ':'.",
-        fix: (fixer) => shorthand
-          ? fixer.removeRange([node.range[0], node.range[0] + 6])
-          : fixer.insertTextBefore(node, 'v-bind')
-      })
-    }
-  })
-}
-
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
 module.exports = {
-  create,
   meta: {
     docs: {
       description: 'enforce `v-bind` directive style',
       category: 'strongly-recommended',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/v-bind-style.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/v-bind-style.md'
     },
     fixable: 'code',
     schema: [
       { enum: ['shorthand', 'longform'] }
     ]
+  },
+
+  create (context) {
+    const shorthand = context.options[0] !== 'longform'
+
+    return utils.defineTemplateBodyVisitor(context, {
+      "VAttribute[directive=true][key.name='bind'][key.argument!=null]" (node) {
+        if (node.key.shorthand === shorthand) {
+          return
+        }
+
+        context.report({
+          node,
+          loc: node.loc,
+          message: shorthand
+            ? "Unexpected 'v-bind' before ':'."
+            : "Expected 'v-bind' before ':'.",
+          fix: (fixer) => shorthand
+            ? fixer.removeRange([node.range[0], node.range[0] + 6])
+            : fixer.insertTextBefore(node, 'v-bind')
+        })
+      }
+    })
   }
 }
diff --git a/lib/rules/v-on-style.js b/lib/rules/v-on-style.js
index fe83564df..bf4068846 100644
--- a/lib/rules/v-on-style.js
+++ b/lib/rules/v-on-style.js
@@ -11,55 +11,44 @@
 
 const utils = require('../utils')
 
-// ------------------------------------------------------------------------------
-// Helpers
-// ------------------------------------------------------------------------------
-
-/**
- * Creates AST event handlers for v-on-style.
- *
- * @param {RuleContext} context - The rule context.
- * @returns {Object} AST event handlers.
- */
-function create (context) {
-  const shorthand = context.options[0] !== 'longform'
-
-  return utils.defineTemplateBodyVisitor(context, {
-    "VAttribute[directive=true][key.name='on'][key.argument!=null]" (node) {
-      if (node.key.shorthand === shorthand) {
-        return
-      }
-
-      const pos = node.range[0]
-      context.report({
-        node,
-        loc: node.loc,
-        message: shorthand
-          ? "Expected '@' instead of 'v-on:'."
-          : "Expected 'v-on:' instead of '@'.",
-        fix: (fixer) => shorthand
-          ? fixer.replaceTextRange([pos, pos + 5], '@')
-          : fixer.replaceTextRange([pos, pos + 1], 'v-on:')
-      })
-    }
-  })
-}
-
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
 module.exports = {
-  create,
   meta: {
     docs: {
       description: 'enforce `v-on` directive style',
       category: 'strongly-recommended',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/v-on-style.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/v-on-style.md'
     },
     fixable: 'code',
     schema: [
       { enum: ['shorthand', 'longform'] }
     ]
+  },
+
+  create (context) {
+    const shorthand = context.options[0] !== 'longform'
+
+    return utils.defineTemplateBodyVisitor(context, {
+      "VAttribute[directive=true][key.name='on'][key.argument!=null]" (node) {
+        if (node.key.shorthand === shorthand) {
+          return
+        }
+
+        const pos = node.range[0]
+        context.report({
+          node,
+          loc: node.loc,
+          message: shorthand
+            ? "Expected '@' instead of 'v-on:'."
+            : "Expected 'v-on:' instead of '@'.",
+          fix: (fixer) => shorthand
+            ? fixer.replaceTextRange([pos, pos + 5], '@')
+            : fixer.replaceTextRange([pos, pos + 1], 'v-on:')
+        })
+      }
+    })
   }
 }
diff --git a/lib/rules/valid-template-root.js b/lib/rules/valid-template-root.js
index 756ffecdd..21d6604f5 100644
--- a/lib/rules/valid-template-root.js
+++ b/lib/rules/valid-template-root.js
@@ -12,111 +12,100 @@
 const utils = require('../utils')
 
 // ------------------------------------------------------------------------------
-// Helpers
+// Rule Definition
 // ------------------------------------------------------------------------------
 
-/**
- * Creates AST event handlers for valid-template-root.
- *
- * @param {RuleContext} context - The rule context.
- * @returns {Object} AST event handlers.
- */
-function create (context) {
-  const sourceCode = context.getSourceCode()
+module.exports = {
+  meta: {
+    docs: {
+      description: 'enforce valid template root',
+      category: 'essential',
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/valid-template-root.md'
+    },
+    fixable: null,
+    schema: []
+  },
 
-  return {
-    Program (program) {
-      const element = program.templateBody
-      if (element == null) {
-        return
-      }
+  create (context) {
+    const sourceCode = context.getSourceCode()
 
-      const hasSrc = utils.hasAttribute(element, 'src')
-      const rootElements = []
-      let extraText = null
-      let extraElement = null
-      let vIf = false
-      for (const child of element.children) {
-        if (child.type === 'VElement') {
-          if (rootElements.length === 0 && !hasSrc) {
-            rootElements.push(child)
-            vIf = utils.hasDirective(child, 'if')
-          } else if (vIf && utils.hasDirective(child, 'else-if')) {
-            rootElements.push(child)
-          } else if (vIf && utils.hasDirective(child, 'else')) {
-            rootElements.push(child)
-            vIf = false
-          } else {
-            extraElement = child
+    return {
+      Program (program) {
+        const element = program.templateBody
+        if (element == null) {
+          return
+        }
+
+        const hasSrc = utils.hasAttribute(element, 'src')
+        const rootElements = []
+        let extraText = null
+        let extraElement = null
+        let vIf = false
+        for (const child of element.children) {
+          if (child.type === 'VElement') {
+            if (rootElements.length === 0 && !hasSrc) {
+              rootElements.push(child)
+              vIf = utils.hasDirective(child, 'if')
+            } else if (vIf && utils.hasDirective(child, 'else-if')) {
+              rootElements.push(child)
+            } else if (vIf && utils.hasDirective(child, 'else')) {
+              rootElements.push(child)
+              vIf = false
+            } else {
+              extraElement = child
+            }
+          } else if (sourceCode.getText(child).trim() !== '') {
+            extraText = child
           }
-        } else if (sourceCode.getText(child).trim() !== '') {
-          extraText = child
         }
-      }
 
-      if (hasSrc && (extraText != null || extraElement != null)) {
-        context.report({
-          node: extraText || extraElement,
-          loc: (extraText || extraElement).loc,
-          message: "The template root with 'src' attribute is required to be empty."
-        })
-      } else if (extraText != null) {
-        context.report({
-          node: extraText,
-          loc: extraText.loc,
-          message: 'The template root requires an element rather than texts.'
-        })
-      } else if (extraElement != null) {
-        context.report({
-          node: extraElement,
-          loc: extraElement.loc,
-          message: 'The template root requires exactly one element.'
-        })
-      } else if (rootElements.length === 0 && !hasSrc) {
-        context.report({
-          node: element,
-          loc: element.loc,
-          message: 'The template root requires exactly one element.'
-        })
-      } else {
-        for (const element of rootElements) {
-          const tag = element.startTag
-          const name = element.name
+        if (hasSrc && (extraText != null || extraElement != null)) {
+          context.report({
+            node: extraText || extraElement,
+            loc: (extraText || extraElement).loc,
+            message: "The template root with 'src' attribute is required to be empty."
+          })
+        } else if (extraText != null) {
+          context.report({
+            node: extraText,
+            loc: extraText.loc,
+            message: 'The template root requires an element rather than texts.'
+          })
+        } else if (extraElement != null) {
+          context.report({
+            node: extraElement,
+            loc: extraElement.loc,
+            message: 'The template root requires exactly one element.'
+          })
+        } else if (rootElements.length === 0 && !hasSrc) {
+          context.report({
+            node: element,
+            loc: element.loc,
+            message: 'The template root requires exactly one element.'
+          })
+        } else {
+          for (const element of rootElements) {
+            const tag = element.startTag
+            const name = element.name
 
-          if (name === 'template' || name === 'slot') {
-            context.report({
-              node: tag,
-              loc: tag.loc,
-              message: "The template root disallows '<{{name}}>' elements.",
-              data: { name }
-            })
-          }
-          if (utils.hasDirective(element, 'for')) {
-            context.report({
-              node: tag,
-              loc: tag.loc,
-              message: "The template root disallows 'v-for' directives."
-            })
+            if (name === 'template' || name === 'slot') {
+              context.report({
+                node: tag,
+                loc: tag.loc,
+                message: "The template root disallows '<{{name}}>' elements.",
+                data: { name }
+              })
+            }
+            if (utils.hasDirective(element, 'for')) {
+              context.report({
+                node: tag,
+                loc: tag.loc,
+                message: "The template root disallows 'v-for' directives."
+              })
+            }
           }
         }
       }
     }
   }
 }
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
-
-module.exports = {
-  create,
-  meta: {
-    docs: {
-      description: 'enforce valid template root',
-      category: 'essential',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/valid-template-root.md'
-    },
-    fixable: false,
-    schema: []
-  }
-}
diff --git a/lib/rules/valid-v-bind.js b/lib/rules/valid-v-bind.js
index 0437dfccf..b82105a9c 100644
--- a/lib/rules/valid-v-bind.js
+++ b/lib/rules/valid-v-bind.js
@@ -17,50 +17,43 @@ const utils = require('../utils')
 
 const VALID_MODIFIERS = new Set(['prop', 'camel', 'sync'])
 
-/**
- * Creates AST event handlers for valid-v-bind.
- *
- * @param {RuleContext} context - The rule context.
- * @returns {Object} AST event handlers.
- */
-function create (context) {
-  return utils.defineTemplateBodyVisitor(context, {
-    "VAttribute[directive=true][key.name='bind']" (node) {
-      for (const modifier of node.key.modifiers) {
-        if (!VALID_MODIFIERS.has(modifier)) {
-          context.report({
-            node,
-            loc: node.key.loc,
-            message: "'v-bind' directives don't support the modifier '{{name}}'.",
-            data: { name: modifier }
-          })
-        }
-      }
-
-      if (!utils.hasAttributeValue(node)) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-bind' directives require an attribute value."
-        })
-      }
-    }
-  })
-}
-
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
 module.exports = {
-  create,
   meta: {
     docs: {
       description: 'enforce valid `v-bind` directives',
       category: 'essential',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/valid-v-bind.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/valid-v-bind.md'
     },
-    fixable: false,
+    fixable: null,
     schema: []
+  },
+
+  create (context) {
+    return utils.defineTemplateBodyVisitor(context, {
+      "VAttribute[directive=true][key.name='bind']" (node) {
+        for (const modifier of node.key.modifiers) {
+          if (!VALID_MODIFIERS.has(modifier)) {
+            context.report({
+              node,
+              loc: node.key.loc,
+              message: "'v-bind' directives don't support the modifier '{{name}}'.",
+              data: { name: modifier }
+            })
+          }
+        }
+
+        if (!utils.hasAttributeValue(node)) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-bind' directives require an attribute value."
+          })
+        }
+      }
+    })
   }
 }
diff --git a/lib/rules/valid-v-cloak.js b/lib/rules/valid-v-cloak.js
index 3d1ce77a9..6bdf9f55d 100644
--- a/lib/rules/valid-v-cloak.js
+++ b/lib/rules/valid-v-cloak.js
@@ -11,57 +11,46 @@
 
 const utils = require('../utils')
 
-// ------------------------------------------------------------------------------
-// Helpers
-// ------------------------------------------------------------------------------
-
-/**
- * Creates AST event handlers for valid-v-cloak.
- *
- * @param {RuleContext} context - The rule context.
- * @returns {Object} AST event handlers.
- */
-function create (context) {
-  return utils.defineTemplateBodyVisitor(context, {
-    "VAttribute[directive=true][key.name='cloak']" (node) {
-      if (node.key.argument) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-cloak' directives require no argument."
-        })
-      }
-      if (node.key.modifiers.length > 0) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-cloak' directives require no modifier."
-        })
-      }
-      if (node.value) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-cloak' directives require no attribute value."
-        })
-      }
-    }
-  })
-}
-
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
 module.exports = {
-  create,
   meta: {
     docs: {
       description: 'enforce valid `v-cloak` directives',
       category: 'essential',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/valid-v-cloak.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/valid-v-cloak.md'
     },
-    fixable: false,
+    fixable: null,
     schema: []
+  },
+
+  create (context) {
+    return utils.defineTemplateBodyVisitor(context, {
+      "VAttribute[directive=true][key.name='cloak']" (node) {
+        if (node.key.argument) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-cloak' directives require no argument."
+          })
+        }
+        if (node.key.modifiers.length > 0) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-cloak' directives require no modifier."
+          })
+        }
+        if (node.value) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-cloak' directives require no attribute value."
+          })
+        }
+      }
+    })
   }
 }
diff --git a/lib/rules/valid-v-else-if.js b/lib/rules/valid-v-else-if.js
index 4af050f5b..cdc5e170d 100644
--- a/lib/rules/valid-v-else-if.js
+++ b/lib/rules/valid-v-else-if.js
@@ -11,80 +11,69 @@
 
 const utils = require('../utils')
 
-// ------------------------------------------------------------------------------
-// Helpers
-// ------------------------------------------------------------------------------
-
-/**
- * Creates AST event handlers for valid-v-else-if.
- *
- * @param {RuleContext} context - The rule context.
- * @returns {Object} AST event handlers.
- */
-function create (context) {
-  return utils.defineTemplateBodyVisitor(context, {
-    "VAttribute[directive=true][key.name='else-if']" (node) {
-      const element = node.parent.parent
-
-      if (!utils.prevElementHasIf(element)) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-else-if' directives require being preceded by the element which has a 'v-if' or 'v-else-if' directive."
-        })
-      }
-      if (utils.hasDirective(element, 'if')) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-else-if' and 'v-if' directives can't exist on the same element."
-        })
-      }
-      if (utils.hasDirective(element, 'else')) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-else-if' and 'v-else' directives can't exist on the same element."
-        })
-      }
-      if (node.key.argument) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-else-if' directives require no argument."
-        })
-      }
-      if (node.key.modifiers.length > 0) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-else-if' directives require no modifier."
-        })
-      }
-      if (!utils.hasAttributeValue(node)) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-else-if' directives require that attribute value."
-        })
-      }
-    }
-  })
-}
-
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
 module.exports = {
-  create,
   meta: {
     docs: {
       description: 'enforce valid `v-else-if` directives',
       category: 'essential',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/valid-v-else-if.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/valid-v-else-if.md'
     },
-    fixable: false,
+    fixable: null,
     schema: []
+  },
+
+  create (context) {
+    return utils.defineTemplateBodyVisitor(context, {
+      "VAttribute[directive=true][key.name='else-if']" (node) {
+        const element = node.parent.parent
+
+        if (!utils.prevElementHasIf(element)) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-else-if' directives require being preceded by the element which has a 'v-if' or 'v-else-if' directive."
+          })
+        }
+        if (utils.hasDirective(element, 'if')) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-else-if' and 'v-if' directives can't exist on the same element."
+          })
+        }
+        if (utils.hasDirective(element, 'else')) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-else-if' and 'v-else' directives can't exist on the same element."
+          })
+        }
+        if (node.key.argument) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-else-if' directives require no argument."
+          })
+        }
+        if (node.key.modifiers.length > 0) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-else-if' directives require no modifier."
+          })
+        }
+        if (!utils.hasAttributeValue(node)) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-else-if' directives require that attribute value."
+          })
+        }
+      }
+    })
   }
 }
diff --git a/lib/rules/valid-v-else.js b/lib/rules/valid-v-else.js
index b4eef35a8..6a08523c3 100644
--- a/lib/rules/valid-v-else.js
+++ b/lib/rules/valid-v-else.js
@@ -11,80 +11,69 @@
 
 const utils = require('../utils')
 
-// ------------------------------------------------------------------------------
-// Helpers
-// ------------------------------------------------------------------------------
-
-/**
- * Creates AST event handlers for valid-v-else.
- *
- * @param {RuleContext} context - The rule context.
- * @returns {Object} AST event handlers.
- */
-function create (context) {
-  return utils.defineTemplateBodyVisitor(context, {
-    "VAttribute[directive=true][key.name='else']" (node) {
-      const element = node.parent.parent
-
-      if (!utils.prevElementHasIf(element)) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-else' directives require being preceded by the element which has a 'v-if' or 'v-else' directive."
-        })
-      }
-      if (utils.hasDirective(element, 'if')) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-else' and 'v-if' directives can't exist on the same element. You may want 'v-else-if' directives."
-        })
-      }
-      if (utils.hasDirective(element, 'else-if')) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-else' and 'v-else-if' directives can't exist on the same element."
-        })
-      }
-      if (node.key.argument) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-else' directives require no argument."
-        })
-      }
-      if (node.key.modifiers.length > 0) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-else' directives require no modifier."
-        })
-      }
-      if (utils.hasAttributeValue(node)) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-else' directives require no attribute value."
-        })
-      }
-    }
-  })
-}
-
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
 module.exports = {
-  create,
   meta: {
     docs: {
       description: 'enforce valid `v-else` directives',
       category: 'essential',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/valid-v-else.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/valid-v-else.md'
     },
-    fixable: false,
+    fixable: null,
     schema: []
+  },
+
+  create (context) {
+    return utils.defineTemplateBodyVisitor(context, {
+      "VAttribute[directive=true][key.name='else']" (node) {
+        const element = node.parent.parent
+
+        if (!utils.prevElementHasIf(element)) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-else' directives require being preceded by the element which has a 'v-if' or 'v-else' directive."
+          })
+        }
+        if (utils.hasDirective(element, 'if')) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-else' and 'v-if' directives can't exist on the same element. You may want 'v-else-if' directives."
+          })
+        }
+        if (utils.hasDirective(element, 'else-if')) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-else' and 'v-else-if' directives can't exist on the same element."
+          })
+        }
+        if (node.key.argument) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-else' directives require no argument."
+          })
+        }
+        if (node.key.modifiers.length > 0) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-else' directives require no modifier."
+          })
+        }
+        if (utils.hasAttributeValue(node)) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-else' directives require no attribute value."
+          })
+        }
+      }
+    })
   }
 }
diff --git a/lib/rules/valid-v-for.js b/lib/rules/valid-v-for.js
index 62e05d5a4..479f9b84c 100644
--- a/lib/rules/valid-v-for.js
+++ b/lib/rules/valid-v-for.js
@@ -97,102 +97,95 @@ function checkKey (context, vFor, element) {
   }
 }
 
-/**
- * Creates AST event handlers for valid-v-for.
- *
- * @param {RuleContext} context - The rule context.
- * @returns {Object} AST event handlers.
- */
-function create (context) {
-  const sourceCode = context.getSourceCode()
-
-  return utils.defineTemplateBodyVisitor(context, {
-    "VAttribute[directive=true][key.name='for']" (node) {
-      const element = node.parent.parent
-
-      checkKey(context, node, element)
-
-      if (node.key.argument) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-for' directives require no argument."
-        })
-      }
-      if (node.key.modifiers.length > 0) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-for' directives require no modifier."
-        })
-      }
-      if (!utils.hasAttributeValue(node)) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-for' directives require that attribute value."
-        })
-        return
-      }
-
-      const expr = node.value.expression
-      if (expr == null) {
-        return
-      }
-      if (expr.type !== 'VForExpression') {
-        context.report({
-          node: node.value,
-          loc: node.value.loc,
-          message: "'v-for' directives require the special syntax '<alias> in <expression>'."
-        })
-        return
-      }
-
-      const lhs = expr.left
-      const value = lhs[0]
-      const key = lhs[1]
-      const index = lhs[2]
-
-      if (value === null) {
-        context.report({
-          node: value || expr,
-          loc: value && value.loc,
-          message: "Invalid alias ''."
-        })
-      }
-      if (key !== undefined && (!key || key.type !== 'Identifier')) {
-        context.report({
-          node: key || expr,
-          loc: key && key.loc,
-          message: "Invalid alias '{{text}}'.",
-          data: { text: key ? sourceCode.getText(key) : '' }
-        })
-      }
-      if (index !== undefined && (!index || index.type !== 'Identifier')) {
-        context.report({
-          node: index || expr,
-          loc: index && index.loc,
-          message: "Invalid alias '{{text}}'.",
-          data: { text: index ? sourceCode.getText(index) : '' }
-        })
-      }
-    }
-  })
-}
-
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
 module.exports = {
-  create,
   meta: {
     docs: {
       description: 'enforce valid `v-for` directives',
       category: 'essential',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/valid-v-for.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/valid-v-for.md'
     },
-    fixable: false,
+    fixable: null,
     schema: []
+  },
+
+  create (context) {
+    const sourceCode = context.getSourceCode()
+
+    return utils.defineTemplateBodyVisitor(context, {
+      "VAttribute[directive=true][key.name='for']" (node) {
+        const element = node.parent.parent
+
+        checkKey(context, node, element)
+
+        if (node.key.argument) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-for' directives require no argument."
+          })
+        }
+        if (node.key.modifiers.length > 0) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-for' directives require no modifier."
+          })
+        }
+        if (!utils.hasAttributeValue(node)) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-for' directives require that attribute value."
+          })
+          return
+        }
+
+        const expr = node.value.expression
+        if (expr == null) {
+          return
+        }
+        if (expr.type !== 'VForExpression') {
+          context.report({
+            node: node.value,
+            loc: node.value.loc,
+            message: "'v-for' directives require the special syntax '<alias> in <expression>'."
+          })
+          return
+        }
+
+        const lhs = expr.left
+        const value = lhs[0]
+        const key = lhs[1]
+        const index = lhs[2]
+
+        if (value === null) {
+          context.report({
+            node: value || expr,
+            loc: value && value.loc,
+            message: "Invalid alias ''."
+          })
+        }
+        if (key !== undefined && (!key || key.type !== 'Identifier')) {
+          context.report({
+            node: key || expr,
+            loc: key && key.loc,
+            message: "Invalid alias '{{text}}'.",
+            data: { text: key ? sourceCode.getText(key) : '' }
+          })
+        }
+        if (index !== undefined && (!index || index.type !== 'Identifier')) {
+          context.report({
+            node: index || expr,
+            loc: index && index.loc,
+            message: "Invalid alias '{{text}}'.",
+            data: { text: index ? sourceCode.getText(index) : '' }
+          })
+        }
+      }
+    })
   }
 }
diff --git a/lib/rules/valid-v-html.js b/lib/rules/valid-v-html.js
index 427b9b3b1..302fef51c 100644
--- a/lib/rules/valid-v-html.js
+++ b/lib/rules/valid-v-html.js
@@ -11,57 +11,46 @@
 
 const utils = require('../utils')
 
-// ------------------------------------------------------------------------------
-// Helpers
-// ------------------------------------------------------------------------------
-
-/**
- * Creates AST event handlers for valid-v-html.
- *
- * @param {RuleContext} context - The rule context.
- * @returns {Object} AST event handlers.
- */
-function create (context) {
-  return utils.defineTemplateBodyVisitor(context, {
-    "VAttribute[directive=true][key.name='html']" (node) {
-      if (node.key.argument) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-html' directives require no argument."
-        })
-      }
-      if (node.key.modifiers.length > 0) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-html' directives require no modifier."
-        })
-      }
-      if (!utils.hasAttributeValue(node)) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-html' directives require that attribute value."
-        })
-      }
-    }
-  })
-}
-
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
 module.exports = {
-  create,
   meta: {
     docs: {
       description: 'enforce valid `v-html` directives',
       category: 'essential',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/valid-v-html.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/valid-v-html.md'
     },
-    fixable: false,
+    fixable: null,
     schema: []
+  },
+
+  create (context) {
+    return utils.defineTemplateBodyVisitor(context, {
+      "VAttribute[directive=true][key.name='html']" (node) {
+        if (node.key.argument) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-html' directives require no argument."
+          })
+        }
+        if (node.key.modifiers.length > 0) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-html' directives require no modifier."
+          })
+        }
+        if (!utils.hasAttributeValue(node)) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-html' directives require that attribute value."
+          })
+        }
+      }
+    })
   }
 }
diff --git a/lib/rules/valid-v-if.js b/lib/rules/valid-v-if.js
index 18cbf56a9..e08d59b27 100644
--- a/lib/rules/valid-v-if.js
+++ b/lib/rules/valid-v-if.js
@@ -11,73 +11,62 @@
 
 const utils = require('../utils')
 
-// ------------------------------------------------------------------------------
-// Helpers
-// ------------------------------------------------------------------------------
-
-/**
- * Creates AST event handlers for valid-v-if.
- *
- * @param {RuleContext} context - The rule context.
- * @returns {Object} AST event handlers.
- */
-function create (context) {
-  return utils.defineTemplateBodyVisitor(context, {
-    "VAttribute[directive=true][key.name='if']" (node) {
-      const element = node.parent.parent
-
-      if (utils.hasDirective(element, 'else')) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-if' and 'v-else' directives can't exist on the same element. You may want 'v-else-if' directives."
-        })
-      }
-      if (utils.hasDirective(element, 'else-if')) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-if' and 'v-else-if' directives can't exist on the same element."
-        })
-      }
-      if (node.key.argument) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-if' directives require no argument."
-        })
-      }
-      if (node.key.modifiers.length > 0) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-if' directives require no modifier."
-        })
-      }
-      if (!utils.hasAttributeValue(node)) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-if' directives require that attribute value."
-        })
-      }
-    }
-  })
-}
-
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
 module.exports = {
-  create,
   meta: {
     docs: {
       description: 'enforce valid `v-if` directives',
       category: 'essential',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/valid-v-if.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/valid-v-if.md'
     },
-    fixable: false,
+    fixable: null,
     schema: []
+  },
+
+  create (context) {
+    return utils.defineTemplateBodyVisitor(context, {
+      "VAttribute[directive=true][key.name='if']" (node) {
+        const element = node.parent.parent
+
+        if (utils.hasDirective(element, 'else')) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-if' and 'v-else' directives can't exist on the same element. You may want 'v-else-if' directives."
+          })
+        }
+        if (utils.hasDirective(element, 'else-if')) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-if' and 'v-else-if' directives can't exist on the same element."
+          })
+        }
+        if (node.key.argument) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-if' directives require no argument."
+          })
+        }
+        if (node.key.modifiers.length > 0) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-if' directives require no modifier."
+          })
+        }
+        if (!utils.hasAttributeValue(node)) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-if' directives require that attribute value."
+          })
+        }
+      }
+    })
   }
 }
diff --git a/lib/rules/valid-v-model.js b/lib/rules/valid-v-model.js
index b46d827c4..fc19ba893 100644
--- a/lib/rules/valid-v-model.js
+++ b/lib/rules/valid-v-model.js
@@ -73,103 +73,95 @@ function getVariable (name, leafNode) {
   return null
 }
 
-/**
- * Creates AST event handlers for valid-v-model.
- *
- * @param {RuleContext} context - The rule context.
- * @returns {Object} AST event handlers.
- */
-function create (context) {
-  return utils.defineTemplateBodyVisitor(context, {
-    "VAttribute[directive=true][key.name='model']" (node) {
-      const element = node.parent.parent
-      const name = element.name
-
-      if (!isValidElement(element)) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-model' directives aren't supported on <{{name}}> elements.",
-          data: { name }
-        })
-      }
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
 
-      if (name === 'input' && utils.hasAttribute(element, 'type', 'file')) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-model' directives don't support 'file' input type.",
-          data: { name }
-        })
-      }
+module.exports = {
+  meta: {
+    docs: {
+      description: 'enforce valid `v-model` directives',
+      category: 'essential',
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/valid-v-model.md'
+    },
+    fixable: null,
+    schema: []
+  },
 
-      if (node.key.argument) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-model' directives require no argument."
-        })
-      }
+  create (context) {
+    return utils.defineTemplateBodyVisitor(context, {
+      "VAttribute[directive=true][key.name='model']" (node) {
+        const element = node.parent.parent
+        const name = element.name
 
-      for (const modifier of node.key.modifiers) {
-        if (!VALID_MODIFIERS.has(modifier)) {
+        if (!isValidElement(element)) {
           context.report({
             node,
             loc: node.loc,
-            message: "'v-model' directives don't support the modifier '{{name}}'.",
-            data: { name: modifier }
+            message: "'v-model' directives aren't supported on <{{name}}> elements.",
+            data: { name }
           })
         }
-      }
-      if (!utils.hasAttributeValue(node)) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-model' directives require that attribute value."
-        })
-      }
-      if (node.value) {
-        if (!isLhs(node.value.expression)) {
+
+        if (name === 'input' && utils.hasAttribute(element, 'type', 'file')) {
           context.report({
             node,
             loc: node.loc,
-            message: "'v-model' directives require the attribute value which is valid as LHS."
+            message: "'v-model' directives don't support 'file' input type."
           })
         }
 
-        for (const reference of node.value.references) {
-          const id = reference.id
-          if (id.parent.type === 'MemberExpression' || id.parent.type === 'BinaryExpression') {
-            continue
-          }
+        if (node.key.argument) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-model' directives require no argument."
+          })
+        }
 
-          const variable = getVariable(id.name, element)
-          if (variable != null) {
+        for (const modifier of node.key.modifiers) {
+          if (!VALID_MODIFIERS.has(modifier)) {
             context.report({
               node,
               loc: node.loc,
-              message: "'v-model' directives cannot update the iteration variable 'x' itself."
+              message: "'v-model' directives don't support the modifier '{{name}}'.",
+              data: { name: modifier }
             })
           }
         }
-      }
-    }
-  })
-}
-
-// ------------------------------------------------------------------------------
-// Rule Definition
-// ------------------------------------------------------------------------------
+        if (!utils.hasAttributeValue(node)) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-model' directives require that attribute value."
+          })
+        }
+        if (node.value) {
+          if (!isLhs(node.value.expression)) {
+            context.report({
+              node,
+              loc: node.loc,
+              message: "'v-model' directives require the attribute value which is valid as LHS."
+            })
+          }
 
-module.exports = {
-  create,
-  meta: {
-    docs: {
-      description: 'enforce valid `v-model` directives',
-      category: 'essential',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/valid-v-model.md'
-    },
-    fixable: false,
-    schema: []
+          for (const reference of node.value.references) {
+            const id = reference.id
+            if (id.parent.type === 'MemberExpression' || id.parent.type === 'BinaryExpression') {
+              continue
+            }
+
+            const variable = getVariable(id.name, element)
+            if (variable != null) {
+              context.report({
+                node,
+                loc: node.loc,
+                message: "'v-model' directives cannot update the iteration variable 'x' itself."
+              })
+            }
+          }
+        }
+      }
+    })
   }
 }
diff --git a/lib/rules/valid-v-on.js b/lib/rules/valid-v-on.js
index d44fc7200..ef0f4baa9 100644
--- a/lib/rules/valid-v-on.js
+++ b/lib/rules/valid-v-on.js
@@ -24,49 +24,42 @@ const VERB_MODIFIERS = new Set([
   'stop', 'prevent'
 ])
 
-/**
- * Creates AST event handlers for valid-v-on.
- *
- * @param {RuleContext} context - The rule context.
- * @returns {Object} AST event handlers.
- */
-function create (context) {
-  return utils.defineTemplateBodyVisitor(context, {
-    "VAttribute[directive=true][key.name='on']" (node) {
-      for (const modifier of node.key.modifiers) {
-        if (!VALID_MODIFIERS.has(modifier) && !Number.isInteger(parseInt(modifier, 10))) {
-          context.report({
-            node,
-            loc: node.loc,
-            message: "'v-on' directives don't support the modifier '{{modifier}}'.",
-            data: { modifier }
-          })
-        }
-      }
-      if (!utils.hasAttributeValue(node) && !node.key.modifiers.some(VERB_MODIFIERS.has, VERB_MODIFIERS)) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-on' directives require that attribute value or verb modifiers."
-        })
-      }
-    }
-  })
-}
-
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
 module.exports = {
-  create,
   meta: {
     docs: {
       description: 'enforce valid `v-on` directives',
       category: 'essential',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/valid-v-on.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/valid-v-on.md'
     },
-    fixable: false,
+    fixable: null,
     schema: []
+  },
+
+  create (context) {
+    return utils.defineTemplateBodyVisitor(context, {
+      "VAttribute[directive=true][key.name='on']" (node) {
+        for (const modifier of node.key.modifiers) {
+          if (!VALID_MODIFIERS.has(modifier) && !Number.isInteger(parseInt(modifier, 10))) {
+            context.report({
+              node,
+              loc: node.loc,
+              message: "'v-on' directives don't support the modifier '{{modifier}}'.",
+              data: { modifier }
+            })
+          }
+        }
+        if (!utils.hasAttributeValue(node) && !node.key.modifiers.some(VERB_MODIFIERS.has, VERB_MODIFIERS)) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-on' directives require that attribute value or verb modifiers."
+          })
+        }
+      }
+    })
   }
 }
diff --git a/lib/rules/valid-v-once.js b/lib/rules/valid-v-once.js
index 19aa48239..7f01e3548 100644
--- a/lib/rules/valid-v-once.js
+++ b/lib/rules/valid-v-once.js
@@ -11,57 +11,46 @@
 
 const utils = require('../utils')
 
-// ------------------------------------------------------------------------------
-// Helpers
-// ------------------------------------------------------------------------------
-
-/**
- * Creates AST event handlers for valid-v-once.
- *
- * @param {RuleContext} context - The rule context.
- * @returns {Object} AST event handlers.
- */
-function create (context) {
-  return utils.defineTemplateBodyVisitor(context, {
-    "VAttribute[directive=true][key.name='once']" (node) {
-      if (node.key.argument) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-once' directives require no argument."
-        })
-      }
-      if (node.key.modifiers.length > 0) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-once' directives require no modifier."
-        })
-      }
-      if (node.value) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-once' directives require no attribute value."
-        })
-      }
-    }
-  })
-}
-
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
 module.exports = {
-  create,
   meta: {
     docs: {
       description: 'enforce valid `v-once` directives',
       category: 'essential',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/valid-v-once.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/valid-v-once.md'
     },
-    fixable: false,
+    fixable: null,
     schema: []
+  },
+
+  create (context) {
+    return utils.defineTemplateBodyVisitor(context, {
+      "VAttribute[directive=true][key.name='once']" (node) {
+        if (node.key.argument) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-once' directives require no argument."
+          })
+        }
+        if (node.key.modifiers.length > 0) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-once' directives require no modifier."
+          })
+        }
+        if (node.value) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-once' directives require no attribute value."
+          })
+        }
+      }
+    })
   }
 }
diff --git a/lib/rules/valid-v-pre.js b/lib/rules/valid-v-pre.js
index 4ff08c32b..0ff88a867 100644
--- a/lib/rules/valid-v-pre.js
+++ b/lib/rules/valid-v-pre.js
@@ -11,57 +11,46 @@
 
 const utils = require('../utils')
 
-// ------------------------------------------------------------------------------
-// Helpers
-// ------------------------------------------------------------------------------
-
-/**
- * Creates AST event handlers for valid-v-pre.
- *
- * @param {RuleContext} context - The rule context.
- * @returns {Object} AST event handlers.
- */
-function create (context) {
-  return utils.defineTemplateBodyVisitor(context, {
-    "VAttribute[directive=true][key.name='pre']" (node) {
-      if (node.key.argument) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-pre' directives require no argument."
-        })
-      }
-      if (node.key.modifiers.length > 0) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-pre' directives require no modifier."
-        })
-      }
-      if (node.value) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-pre' directives require no attribute value."
-        })
-      }
-    }
-  })
-}
-
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
 module.exports = {
-  create,
   meta: {
     docs: {
       description: 'enforce valid `v-pre` directives',
       category: 'essential',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/valid-v-pre.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/valid-v-pre.md'
     },
-    fixable: false,
+    fixable: null,
     schema: []
+  },
+
+  create (context) {
+    return utils.defineTemplateBodyVisitor(context, {
+      "VAttribute[directive=true][key.name='pre']" (node) {
+        if (node.key.argument) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-pre' directives require no argument."
+          })
+        }
+        if (node.key.modifiers.length > 0) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-pre' directives require no modifier."
+          })
+        }
+        if (node.value) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-pre' directives require no attribute value."
+          })
+        }
+      }
+    })
   }
 }
diff --git a/lib/rules/valid-v-show.js b/lib/rules/valid-v-show.js
index 96d43cd3a..147e86ec4 100644
--- a/lib/rules/valid-v-show.js
+++ b/lib/rules/valid-v-show.js
@@ -11,57 +11,46 @@
 
 const utils = require('../utils')
 
-// ------------------------------------------------------------------------------
-// Helpers
-// ------------------------------------------------------------------------------
-
-/**
- * Creates AST event handlers for valid-v-show.
- *
- * @param {RuleContext} context - The rule context.
- * @returns {Object} AST event handlers.
- */
-function create (context) {
-  return utils.defineTemplateBodyVisitor(context, {
-    "VAttribute[directive=true][key.name='show']" (node) {
-      if (node.key.argument) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-show' directives require no argument."
-        })
-      }
-      if (node.key.modifiers.length > 0) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-show' directives require no modifier."
-        })
-      }
-      if (!utils.hasAttributeValue(node)) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-show' directives require that attribute value."
-        })
-      }
-    }
-  })
-}
-
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
 module.exports = {
-  create,
   meta: {
     docs: {
       description: 'enforce valid `v-show` directives',
       category: 'essential',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/valid-v-show.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/valid-v-show.md'
     },
-    fixable: false,
+    fixable: null,
     schema: []
+  },
+
+  create (context) {
+    return utils.defineTemplateBodyVisitor(context, {
+      "VAttribute[directive=true][key.name='show']" (node) {
+        if (node.key.argument) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-show' directives require no argument."
+          })
+        }
+        if (node.key.modifiers.length > 0) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-show' directives require no modifier."
+          })
+        }
+        if (!utils.hasAttributeValue(node)) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-show' directives require that attribute value."
+          })
+        }
+      }
+    })
   }
 }
diff --git a/lib/rules/valid-v-text.js b/lib/rules/valid-v-text.js
index 9e897e100..19bf9d467 100644
--- a/lib/rules/valid-v-text.js
+++ b/lib/rules/valid-v-text.js
@@ -11,57 +11,46 @@
 
 const utils = require('../utils')
 
-// ------------------------------------------------------------------------------
-// Helpers
-// ------------------------------------------------------------------------------
-
-/**
- * Creates AST event handlers for valid-v-text.
- *
- * @param {RuleContext} context - The rule context.
- * @returns {Object} AST event handlers.
- */
-function create (context) {
-  return utils.defineTemplateBodyVisitor(context, {
-    "VAttribute[directive=true][key.name='text']" (node) {
-      if (node.key.argument) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-text' directives require no argument."
-        })
-      }
-      if (node.key.modifiers.length > 0) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-text' directives require no modifier."
-        })
-      }
-      if (!utils.hasAttributeValue(node)) {
-        context.report({
-          node,
-          loc: node.loc,
-          message: "'v-text' directives require that attribute value."
-        })
-      }
-    }
-  })
-}
-
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
 module.exports = {
-  create,
   meta: {
     docs: {
       description: 'enforce valid `v-text` directives',
       category: 'essential',
-      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/master/docs/rules/valid-v-text.md'
+      url: 'https://github.com/vuejs/eslint-plugin-vue/blob/v4.2.0/docs/rules/valid-v-text.md'
     },
-    fixable: false,
+    fixable: null,
     schema: []
+  },
+
+  create (context) {
+    return utils.defineTemplateBodyVisitor(context, {
+      "VAttribute[directive=true][key.name='text']" (node) {
+        if (node.key.argument) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-text' directives require no argument."
+          })
+        }
+        if (node.key.modifiers.length > 0) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-text' directives require no modifier."
+          })
+        }
+        if (!utils.hasAttributeValue(node)) {
+          context.report({
+            node,
+            loc: node.loc,
+            message: "'v-text' directives require that attribute value."
+          })
+        }
+      }
+    })
   }
 }
diff --git a/package.json b/package.json
index 8f3d698c7..990d591f5 100644
--- a/package.json
+++ b/package.json
@@ -9,7 +9,8 @@
     "test": "nyc npm run test:base -- \"tests/integrations/*.js\" --timeout 60000",
     "lint": "eslint . --rulesdir eslint-internal-rules",
     "pretest": "npm run lint",
-    "preversion": "npm run update && npm test",
+    "preversion": "npm test && npm run update && git add .",
+    "version": "npm run lint -- --fix && git add .",
     "update": "node ./tools/update.js"
   },
   "files": [
diff --git a/tests/lib/rules/no-shared-component-data.js b/tests/lib/rules/no-shared-component-data.js
index 29d70c9ea..d1616dd37 100644
--- a/tests/lib/rules/no-shared-component-data.js
+++ b/tests/lib/rules/no-shared-component-data.js
@@ -141,7 +141,7 @@ return {
       `,
       parserOptions,
       errors: [{
-        message: '`data` property in component must be a function',
+        message: '`data` property in component must be a function.',
         line: 3
       }]
     },
@@ -165,7 +165,7 @@ return {
       `,
       parserOptions,
       errors: [{
-        message: '`data` property in component must be a function',
+        message: '`data` property in component must be a function.',
         line: 3
       }]
     },
@@ -189,7 +189,7 @@ return (/*b*/{
       `,
       parserOptions,
       errors: [{
-        message: '`data` property in component must be a function',
+        message: '`data` property in component must be a function.',
         line: 3
       }]
     }