prettier --write '**/*.{js,json,md}'

Author: papandreou

CHANGELOG.md

@@ -59,19 +59,19 @@
 
 ### v1.19.0 (2018-08-11)
 
-- [#14](https://github.com/unexpectedjs/unexpected-check/pull/14)  Use proximity as a feedback loop  ([Sune Simonsen](mailto:[email protected]))
+- [#14](https://github.com/unexpectedjs/unexpected-check/pull/14) Use proximity as a feedback loop ([Sune Simonsen](mailto:[email protected]))
 
 ### v1.18.0 (2018-01-13)
 
-- [#13](https://github.com/unexpectedjs/unexpected-check/pull/13)  Use of conditional proximity ([Andreas Lind](mailto:[email protected]), [Andreas Lind](mailto:[email protected]), [Sune Simonsen](mailto:[email protected]))
+- [#13](https://github.com/unexpectedjs/unexpected-check/pull/13) Use of conditional proximity ([Andreas Lind](mailto:[email protected]), [Andreas Lind](mailto:[email protected]), [Sune Simonsen](mailto:[email protected]))
 
 ### v1.17.0 (2018-01-08)
 
 - [#12](https://github.com/unexpectedjs/unexpected-check/pull/12) I found that is yields better to results to start using the feedback quicker ([Sune Simonsen](mailto:[email protected]))
 
 ### v1.16.0 (2018-01-08)
 
-- [#11](https://github.com/unexpectedjs/unexpected-check/pull/11) Report when the first error was found.  ([Sune Simonsen](mailto:[email protected]))
+- [#11](https://github.com/unexpectedjs/unexpected-check/pull/11) Report when the first error was found. ([Sune Simonsen](mailto:[email protected]))
 
 ### v1.15.0 (2018-01-06)
 
@@ -93,4 +93,3 @@
 ### v1.8.0 (2016-07-17)
 
 - [#3](https://github.com/unexpectedjs/unexpected-check/pull/3) Support specifying the default max number of iterations ([Andreas Lind](mailto:[email protected]))
-

documentation/assertions/any/when-fuzzed-by.md

@@ -6,10 +6,10 @@ generator that "fuzzes", or somehow creates test cases, based on the subject.
 ```js
 const { integer } = require('chance-generators');
 
-function makePrefixGenerator (str) {
-  return integer({min: 1, max: str.length - 1}).map(prefixLength => (
+function makePrefixGenerator(str) {
+  return integer({ min: 1, max: str.length - 1 }).map((prefixLength) =>
     str.substr(0, prefixLength)
-  ))
+  );
 }
 
 expect('abc', 'when fuzzed by', makePrefixGenerator, 'to match', /^a/);
@@ -21,9 +21,9 @@ prefix length to 0, we will see it generate the empty string fail:
 
 ```js
 function makePrefixGenerator(str) {
-    return integer({ min: 0, max: str.length - 1 }).map(prefixLength => (
-      str.substr(0, prefixLength)
-    ))
+  return integer({ min: 0, max: str.length - 1 }).map((prefixLength) =>
+    str.substr(0, prefixLength)
+  );
 }
 
 expect('abc', 'when fuzzed by', makePrefixGenerator, 'to match', /^a/);

documentation/assertions/function/to-be-valid-for-all.md

@@ -11,9 +11,13 @@ const escape = require('lodash.escape');
 const unescape = require('lodash.unescape');
 const { string } = require('chance-generators');
 
-expect(text => {
-  expect(unescape(escape(text)), 'to equal', text);
-}, 'to be valid for all', string({ max: 200 }));
+expect(
+  (text) => {
+    expect(unescape(escape(text)), 'to equal', text);
+  },
+  'to be valid for all',
+  string({ max: 200 })
+);
 ```
 
 This will run 300 tests with random strings of length 0-200 and succeed.
@@ -22,16 +26,20 @@ You can specify the max number of iterations that the test should run and the
 number of errors it should collect before stopping.
 
 The algorithm searches for the smallest error output, so the more errors you
-allow it to collect the better the output will be. 
+allow it to collect the better the output will be.
 
 ```js
-expect(text => {
-  expect(unescape(escape(text)), 'to equal', text);
-}, 'to be valid for all', {
-  generators: [string({ max: 200 })],
-  maxIterations: 1000,
-  maxErrors: 30
-});
+expect(
+  (text) => {
+    expect(unescape(escape(text)), 'to equal', text);
+  },
+  'to be valid for all',
+  {
+    generators: [string({ max: 200 })],
+    maxIterations: 1000,
+    maxErrors: 30,
+  }
+);
 ```
 
 I found to following code for
@@ -42,23 +50,27 @@ if that code also fulfill our round trip test:
 ```js
 function rleEncode(input) {
   var encoding = [];
-  input.match(/(.)\1*/g).forEach(substr => {
+  input.match(/(.)\1*/g).forEach((substr) => {
     encoding.push([substr.length, substr[0]]);
   });
   return encoding;
 }
 
 function rleDecode(encoded) {
-  var output = "";
-  encoded.forEach(pair => {
-    output += new Array(1+pair[0]).join(pair[1]);
+  var output = '';
+  encoded.forEach((pair) => {
+    output += new Array(1 + pair[0]).join(pair[1]);
   });
   return output;
 }
 
-expect(text => {
-  expect(rleDecode(rleEncode(text)), 'to equal', text);
-}, 'to be valid for all', string({ max: 200 }));
+expect(
+  (text) => {
+    expect(rleDecode(rleEncode(text)), 'to equal', text);
+  },
+  'to be valid for all',
+  string({ max: 200 })
+);
 ```
 
 <!-- unexpected-markdown cleanStackTrace: true -->
@@ -91,12 +103,17 @@ Here is a test that uses more than one generator:
 ```js
 const { word } = require('chance-generators');
 
-expect((a, b) => {
-  return (a + b).length === a.length + b.length;
-}, 'to be valid for all', word, word);
+expect(
+  (a, b) => {
+    return (a + b).length === a.length + b.length;
+  },
+  'to be valid for all',
+  word,
+  word
+);
 ```
 
-Another example could be to generate actions. 
+Another example could be to generate actions.
 
 Let's create a simple queue:
 
@@ -125,30 +142,31 @@ Now let's test that items enqueued always comes out in the right order:
 ```js
 const { array, pickone } = require('chance-generators');
 
-var action = pickone([
-  { name: 'enqueue', value: string }, 
-  { name: 'dequeue' }
-]);
+var action = pickone([{ name: 'enqueue', value: string }, { name: 'dequeue' }]);
 
 var actions = array(action, 200);
 
-expect(function (actions) {
-  var queue = new Queue();
-  var enqueued = [];
-  var dequeued = [];
-  actions.forEach(function (action) {
-    if (action.name === 'enqueue') {
-      enqueued.push(action.value);
-      queue.enqueue(action.value);
-    } else if (!queue.isEmpty()) {
-      dequeued.push(queue.dequeue());
-    }
-  });
-
-  queue.drainTo(dequeued);
-
-  expect(dequeued, 'to equal', enqueued);
-}, 'to be valid for all', actions);
+expect(
+  function (actions) {
+    var queue = new Queue();
+    var enqueued = [];
+    var dequeued = [];
+    actions.forEach(function (action) {
+      if (action.name === 'enqueue') {
+        enqueued.push(action.value);
+        queue.enqueue(action.value);
+      } else if (!queue.isEmpty()) {
+        dequeued.push(queue.dequeue());
+      }
+    });
+
+    queue.drainTo(dequeued);
+
+    expect(dequeued, 'to equal', enqueued);
+  },
+  'to be valid for all',
+  actions
+);
 ```
 
 Support for asynchronous testing by returning a promise from the subject
@@ -157,18 +175,20 @@ function:
 ```js#async:true
 expect.use(require('unexpected-stream'));
 
-return expect(function (text) {
-  return expect(
-    text,
-    'when piped through',
-    [
-      require('zlib').Gzip(),
-      require('zlib').Gunzip()
-    ],
-    'to yield output satisfying',
-    'when decoded as', 'utf-8',
-    'to equal',
-    text
-  );
-}, 'to be valid for all', string);
+return expect(
+  function (text) {
+    return expect(
+      text,
+      'when piped through',
+      [require('zlib').Gzip(), require('zlib').Gunzip()],
+      'to yield output satisfying',
+      'when decoded as',
+      'utf-8',
+      'to equal',
+      text
+    );
+  },
+  'to be valid for all',
+  string
+);
 ```