Merge branch 'master' into no-negated-ok-checkBooleanAssertions

* master:
  Update: Ensure boolean assertions are not missed by several rules (platinumazure#172)
  Chore: add eslint-plugin-eslint-comments (platinumazure#178)
  Docs: enable/autofix indent rule in markdown JS code samples (platinumazure#177)
  Docs: Add eslint-plugin-markdown for JavaScript code samples in documentation (platinumazure#176)
  Upgrade: Bump y18n from 4.0.0 to 4.0.1 (platinumazure#163)

.eslintrc.json

@@ -1,5 +1,5 @@
 {
-    "extends": ["plugin:node/recommended", "plugin:eslint-plugin/recommended"],
+    "extends": ["plugin:node/recommended", "plugin:eslint-comments/recommended", "plugin:eslint-plugin/recommended"],
 
     "env": {
         "node": true
@@ -173,5 +173,32 @@
         "eslint-plugin/require-meta-type": "error",
         "eslint-plugin/test-case-property-ordering": "error",
         "eslint-plugin/test-case-shorthand-strings": "error"
-    }
+    },
+
+    "overrides": [
+        {
+            "files": ["**/*.md"],
+            "processor": "markdown/markdown"
+          },
+          {
+            "files": ["**/*.md/*.js", "**/*.md/*.javascript"],
+            "plugins": ["markdown"],
+            "parserOptions": {
+              "sourceType": "module"
+            },
+            "rules": {
+                "brace-style": "off",
+                "eqeqeq": "off",
+                "guard-for-in": "off",
+                "no-constant-condition": "off",
+                "no-empty-function": "off",
+                "no-undef": "off",
+                "no-unused-expressions": "off",
+                "no-unused-vars": "off",
+                "no-var": "off",
+                "quotes": "off",
+                "space-before-function-paren": "off"
+            }
+        }
+    ]
 }

docs/rules/no-assert-ok.md

@@ -5,8 +5,8 @@
 An example when using `assert.ok` can involuntarily go wrong:
 
 ```js
-test('test myFunc returns a truthy value' (assert) => {
-  assert.ok(myFunc);
+test('test myFunc returns a truthy value', (assert) => {
+    assert.ok(myFunc);
 });
 ```
 

docs/rules/no-async-module-callbacks.md

@@ -12,15 +12,15 @@ if it was within the last `module` that QUnit processes.
 
 ```js
 QUnit.module('An async module', async function () {
-  QUnit.test('a passing test', function (assert) {
-    assert.ok(true);
-  });
+    QUnit.test('a passing test', function (assert) {
+        assert.ok(true);
+    });
 
-  await Promise.resolve();
+    await Promise.resolve();
 
-  QUnit.test('another passing test', function (assert) {
-    assert.ok(true);
-  });
+    QUnit.test('another passing test', function (assert) {
+        assert.ok(true);
+    });
 });
 
 QUnit.module('Some other module');

docs/rules/no-early-return.md

@@ -31,8 +31,11 @@ QUnit[shouldRunTest() ? "test" : "skip"]("a test", function (assert) {
 // Nested function scopes are okay because they do not cause the test to abort
 QUnit.test("a test", function (assert) {
     (function () {
-        return;
-    })();
+        if (true) {
+            return;
+        }
+        assert.ok(true);
+    }());
 });
 
 if (shouldRunTest()) {

docs/rules/no-global-assertions.md

@@ -28,9 +28,9 @@ notDeepEqual(a, b);
 
 notPropEqual(a, b);
 
-raises(function (), TypeError);
+raises(function () {}, TypeError);
 
-throws(function (), TypeError);
+throws(function () {}, TypeError);
 
 ```
 
@@ -56,9 +56,9 @@ assert.notDeepEqual(a, b);
 
 assert.notPropEqual(a, b);
 
-assert.raises(function (), TypeError);
+assert.raises(function () {}, TypeError);
 
-assert.throws(function (), TypeError);
+assert.throws(function () {}, TypeError);
 
 ```
 

docs/rules/no-hooks-from-ancestor-modules.md

@@ -15,23 +15,23 @@ The following patterns are considered warnings:
 
 ```js
 QUnit.module("outer module", function(hooks) {
-  QUnit.module("inner module", function() {
-    hooks.beforeEach(function() {});
-  });
+    QUnit.module("inner module", function() {
+        hooks.beforeEach(function() {});
+    });
 });
 
 QUnit.module("outer module", function(outerHooks) {
-  QUnit.module("inner module", function(innerHooks) {
-    outerHooks.beforeEach(function() {});
-  });
+    QUnit.module("inner module", function(innerHooks) {
+        outerHooks.beforeEach(function() {});
+    });
 });
 ```
 
 The following patterns are not warnings:
 
 ```js
 QUnit.module("example module", function(hooks) {
-  hooks.beforeEach(function() {});
+    hooks.beforeEach(function() {});
 });
 ```
 

docs/rules/no-loose-assertions.md

@@ -7,8 +7,8 @@ The `assert.equal`/`assert.notEqual` assertion methods in QUnit use loose equali
 An example when using `assert.ok` can involuntarily go wrong:
 
 ```js
-test('test myFunc returns a truthy value' (assert) => {
-  assert.ok(myFunc);
+test('test myFunc returns a truthy value', (assert) => {
+    assert.ok(myFunc);
 });
 ```
 
@@ -83,7 +83,7 @@ QUnit.test('Name', function (foo) { foo.propEqual(a, b); });
 
 QUnit.test('Name', function () { propEqual(a, b); });
 
-/* eslint no-loose-assertions: ["error", ["strictEqual", "ok", "notOk"]] */
+/* With rule config: ["error", ["strictEqual", "ok", "notOk"]] */
 QUnit.test('Name', function (assert) { assert.notEqual(a, b); });
 
 ```

docs/rules/no-nested-tests.md

@@ -39,7 +39,7 @@ QUnit.module('ParentModule', function () {
     QUnit.module('ChildModule', function () {
         QUnit.test('ChildTest', function () {});
     });
-})
+});
 
 ```
 

docs/rules/no-qunit-stop.md

@@ -24,7 +24,7 @@ The following patterns are not warnings:
 
 ```js
 
-var done = assert.async():
+var done = assert.async();
 
 ```
 

docs/rules/require-expect.md

@@ -74,7 +74,7 @@ test('name', function(assert) {
 });
 
 test('name', function(assert) {
-    var callback = function() {
+    function callback() {
         assert.ok(true);
     }
     callback();