Setup prettier

Author: mantoni

.github/workflows/ci.yml

@@ -34,6 +34,9 @@ jobs:
       - name: Lint
         if: matrix.node-version == '16.x'
         run: npm run lint
+      - name: Prettier
+        if: matrix.node-version == '16.x'
+        run: npm run prettier:check
       - name: Test Node
         run: npm run test:node
       - name: Test Browser

.prettierignore

@@ -0,0 +1,3 @@
+/package.json
+/package-lock.json
+/CHANGES.md

.prettierrc

@@ -0,0 +1,4 @@
+{
+  "singleQuote": true,
+  "trailingComma": "none"
+}

README.md

@@ -128,18 +128,18 @@ argument:
 
 - `null`: Requires a null value.
 - `boolean`: Defines whether the property must be present:
-    - `true`: The property must be present.
-    - `false`: The property is optional.
+  - `true`: The property must be present.
+  - `false`: The property is optional.
 - `string`: Defines a built-in type. These types are defined:
-    - `"null"`: Same as the `null` spec.
-    - `"defined"`: Same as the `true` spec.
-    - `"optional"`: Same as the `false` spec.
-    - `"boolean"`: Requires a boolean primitive.
-    - `"number"`: Requires a number primitive.
-    - `"integer"`: Requires a number primitive that has no fractions.
-    - `"string"`: Requires a string primitive.
-    - `"object"`: Requires an object.
-    - `"array"`: Requires an array.
+  - `"null"`: Same as the `null` spec.
+  - `"defined"`: Same as the `true` spec.
+  - `"optional"`: Same as the `false` spec.
+  - `"boolean"`: Requires a boolean primitive.
+  - `"number"`: Requires a number primitive.
+  - `"integer"`: Requires a number primitive that has no fractions.
+  - `"string"`: Requires a string primitive.
+  - `"object"`: Requires an object.
+  - `"array"`: Requires an array.
 - `regexp`: Requires the value to be a string and match the regular expression.
 - `function`: Defines a custom specification. The function is expected to
   return `false` if the value is not considered valid.
@@ -164,13 +164,13 @@ objects that validate reading from the object and assigning values:
   read an undefined property. When using the writer with `JSON.stringify` or
   `my_schema.verify(writer)` it will throw if non-optional values are missing.
   If `emitter` is specified, these events will be emitted:
-    - `set` when a property is assigned a new value
-    - `delete` when a property is deleted
-    - `push` when `push` is called on an array
-    - `pop` when `pop` is called on an array
-    - `unshift` when `unshift` is called on an array
-    - `shift` when `shift` is called on an array
-    - `splice` when `splice` is called on an array
+  - `set` when a property is assigned a new value
+  - `delete` when a property is deleted
+  - `push` when `push` is called on an array
+  - `pop` when `pop` is called on an array
+  - `unshift` when `unshift` is called on an array
+  - `shift` when `shift` is called on an array
+  - `splice` when `splice` is called on an array
 - `data = my_schema.verify(writer)`: Checks if any properties are missing in
   the given writer and returns the unwrapped data. Throws if the given object
   is not a schema writer.

lib/array-verifyer.js

@@ -5,11 +5,7 @@ const { arrayPath } = require('./path');
 const { type } = require('./type');
 const { stringify } = require('./stringify');
 const { specName } = require('./spec-name');
-const {
-  failSet,
-  failDelete,
-  failSchemaValidation
-} = require('./fail');
+const { failSet, failDelete, failSchemaValidation } = require('./fail');
 const { raw, unwrap } = require('./raw');
 const { createItemGetter } = require('./create-item-getter');
 
@@ -19,7 +15,8 @@ function arrayVerifyer(itemTest, item_spec) {
   const verify = (value, property) => {
     type.array.verify(value, property);
     value.forEach((element, index) =>
-      itemTest.verify(element, arrayPath(property, index)));
+      itemTest.verify(element, arrayPath(property, index))
+    );
     return value;
   };
   verify.raw = raw;
@@ -86,8 +83,11 @@ function createArrayItemWriter(itemTest, item_spec) {
 function getArrayIndex(key, base) {
   const index = parseInt(key, 10);
   if (String(index) !== key || index < 0) {
-    failSchemaValidation(new TypeError(`Expected property "${
-      arrayPath(base, key)}" to be a valid array index`));
+    failSchemaValidation(
+      new TypeError(
+        `Expected property "${arrayPath(base, key)}" to be a valid array index`
+      )
+    );
   }
   return index;
 }
@@ -120,13 +120,25 @@ function emitArrayEvents(array, emitter, base, itemTest, item_spec) {
   Object.setPrototypeOf(array, proto);
 }
 
-function verifyArrayMethodValues(base, method, offset, values, itemTest,
-    item_spec) {
+function verifyArrayMethodValues(
+  base,
+  method,
+  offset,
+  values,
+  itemTest,
+  item_spec
+) {
   values.forEach((value, i) => {
     if (itemTest(value) === false) {
-      failSchemaValidation(new TypeError(`Expected argument ${
-        i + offset + 1} of ${base}.${method} to be ${
-        specName(item_spec)} but got ${stringify(value)}`));
+      failSchemaValidation(
+        new TypeError(
+          `Expected argument ${
+            i + offset + 1
+          } of ${base}.${method} to be ${specName(
+            item_spec
+          )} but got ${stringify(value)}`
+        )
+      );
     }
   });
 }

lib/create-item-getter.js

@@ -19,8 +19,10 @@ function createItemGetter(valueTest, emitter, parent, read_write) {
     if (type.string(key) && !type.function(value) && type.defined(value)) {
       const factory = valueTest.verify && valueTest.verify[read_write];
       if (factory) {
-        return (cache[key]
-          || (cache[key] = factory(value, emitter, objectPath(parent, key))));
+        return (
+          cache[key] ||
+          (cache[key] = factory(value, emitter, objectPath(parent, key)))
+        );
       }
     }
     return value;

lib/fail.js

@@ -28,4 +28,3 @@ function failNotSchemaObject() {
 function failSpec(spec) {
   throw new TypeError(`Invalid spec ${stringify(spec)}`);
 }
-

lib/literal.js

@@ -15,12 +15,15 @@ function literal() {
   const values = slice.call(arguments);
 
   const literalTest = literalTester(values);
-  lazy(literalTest, SPEC_NAME,
-    () => `literal(${values.map(stringify).join(', ')})`);
+  lazy(
+    literalTest,
+    SPEC_NAME,
+    () => `literal(${values.map(stringify).join(', ')})`
+  );
 
   return literalTest;
 }
 
 function literalTester(values) {
-  return (value) => values.some(v => v === value);
+  return (value) => values.some((v) => v === value);
 }

lib/map.js

@@ -15,23 +15,31 @@ function map(key_spec, value_spec) {
 
   const mapTest = mapTester(keyTest, valueTest);
   mapTest.verify = mapVerifyer(keyVerifyer(keyTest, key_spec), valueTest);
-  lazy(mapTest, SPEC_NAME,
-    () => `map(${specName(key_spec)}, ${specName(value_spec)})`);
+  lazy(
+    mapTest,
+    SPEC_NAME,
+    () => `map(${specName(key_spec)}, ${specName(value_spec)})`
+  );
 
   return mapTest;
 }
 
 function mapTester(keyTest, valueTest) {
-  return (value) => type.object(value)
-    && Object.keys(value).every(key => keyTest(key) && valueTest(value[key]));
+  return (value) =>
+    type.object(value) &&
+    Object.keys(value).every((key) => keyTest(key) && valueTest(value[key]));
 }
 
 function keyVerifyer(fn, spec) {
   return (key, property) => {
     if (fn(key, property) === false) {
-      failSchemaValidation(new TypeError(property && property !== key
-        ? `Expected key "${key}" in "${property}" to be ${specName(spec)}`
-        : `Expected key "${key}" to be ${specName(spec)}`));
+      failSchemaValidation(
+        new TypeError(
+          property && property !== key
+            ? `Expected key "${key}" in "${property}" to be ${specName(spec)}`
+            : `Expected key "${key}" to be ${specName(spec)}`
+        )
+      );
     }
     return property;
   };

lib/object-verifyer.js

@@ -3,11 +3,7 @@
 const { objectPath } = require('./path');
 const { lazy } = require('./lazy');
 const { type } = require('./type');
-const {
-  failSchemaValidation,
-  failSet,
-  failDelete
-} = require('./fail');
+const { failSchemaValidation, failSet, failDelete } = require('./fail');
 const { raw, unwrap } = require('./raw');
 
 exports.objectVerifyer = objectVerifyer;
@@ -17,12 +13,14 @@ function objectVerifyer(tests) {
   const verify = (value, property, opt) => {
     type.object.verify(value, property);
     const value_keys = Object.keys(value);
-    (opt ? value_keys : test_keys)
-      .forEach(key => getTest(tests, key, property)
-        .verify(value[key], objectPath(property, key))
-      );
+    (opt ? value_keys : test_keys).forEach((key) =>
+      getTest(tests, key, property).verify(
+        value[key],
+        objectPath(property, key)
+      )
+    );
     if (!opt && value_keys.length !== test_keys.length) {
-      value_keys.forEach(key => getTest(tests, key, property));
+      value_keys.forEach((key) => getTest(tests, key, property));
     }
     return value;
   };
@@ -34,8 +32,12 @@ function objectVerifyer(tests) {
 }
 
 function getTest(tests, key, base) {
-  return tests[key] || failSchemaValidation(
-    new ReferenceError(`Invalid property "${objectPath(base, key)}"`));
+  return (
+    tests[key] ||
+    failSchemaValidation(
+      new ReferenceError(`Invalid property "${objectPath(base, key)}"`)
+    )
+  );
 }
 
 function verifyWriter(verify) {
@@ -56,8 +58,9 @@ function createWriter(tests) {
   return (object, emitter, base) => {
     object = unwrap(object);
     type.object.verify(object);
-    Object.keys(object).forEach(key => getTest(tests, key, base)
-      .verify(object[key], key, true));
+    Object.keys(object).forEach((key) =>
+      getTest(tests, key, base).verify(object[key], key, true)
+    );
     return new Proxy(object, {
       get: createPropertyGetter(tests, emitter, base, 'write'),
       set(target, key, value) {
@@ -113,8 +116,10 @@ function createPropertyGetter(tests, emitter, base, read_write) {
       }
       const factory = test.verify && test.verify[read_write];
       if (factory) {
-        return (cache[key]
-          || (cache[key] = factory(value, emitter, objectPath(base, key))));
+        return (
+          cache[key] ||
+          (cache[key] = factory(value, emitter, objectPath(base, key)))
+        );
       }
     }
     return value;