patroon 1.0.0 → 1.2.0

package/README.md

@@ -27,6 +27,7 @@ Pattern matching in JavaScript without additional syntax.
     + [NoMatchError](#nomatcherror)
     + [UnevenArgumentCountError](#unevenargumentcounterror)
     + [PatroonError](#patroonerror)
+- [Examples](#examples)
 - [Tests](#tests)
 - [Contribute](#contribute)
   * [Contributors](#contributors)
@@ -517,12 +518,12 @@ const oneIsTwo = patroon(1, 2)
 oneIsTwo(3)
 ```
 ```
-[ 3 ]
-/home/ant/projects/patroon/src/index.js:92
+/home/ant/projects/patroon/src/index.js:96
       throw error
       ^
 
 NoMatchError: Not able to match any pattern for arguments
+    at /home/ant/projects/patroon/src/index.js:90:21
 ```
 
 #### UnevenArgumentCountError
@@ -533,12 +534,12 @@ Another error that occurs is when the patroon function is not used correctly.
 patroon(1)
 ```
 ```
-/home/ant/projects/patroon/src/index.js:79
+/home/ant/projects/patroon/src/index.js:82
   if (!isEven(list.length)) { throw new UnevenArgumentCountError('Patroon should have an even amount of arguments.') }
                               ^
 
 UnevenArgumentCountError: Patroon should have an even amount of arguments.
-    at patroon (/home/ant/projects/patroon/src/index.js:79:37)
+    at patroon (/home/ant/projects/patroon/src/index.js:82:37)
 ```
 
 #### PatroonError
@@ -555,6 +556,14 @@ isPatroonError(new UnevenArgumentCountError())
 patroon is causing an error
 ```
 
+## Examples
+
+Patroon can be used in any context that can benefit from pattern matching.
+
+- The following tests show how patroon can help you test your JSON API by
+  pattern matching on status codes and the body:
+  https://github.com/bas080/didomi/blob/master/index.test.js.
+
 ## Tests
 
 [./src/index.test.js][5] - Contains some tests for edge cases and it defines
@@ -564,8 +573,8 @@ We also care about code coverage so we'll use [nyc][8] to generate a coverage
 report.
 
 ```bash bash -eo pipefail
-# Install and prune dependencies
-{ npm i && npm prune; } &> /dev/null
+# Clean install dependencies.
+npm ci &> /dev/null
 
 # Run tests and generate a coverage report
 npx nyc npm t | npx tap-nyc
@@ -574,7 +583,7 @@ npx nyc npm t | npx tap-nyc
 npx nyc check-coverage
 ```
 ```
-    > patroon@1.0.0 test
+    > patroon@1.2.0 test
     > tape ./src/index.test.js
     -------------|---------|----------|---------|---------|-------------------
     File         | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s 
@@ -585,10 +594,10 @@ npx nyc check-coverage
      walkable.js |     100 |      100 |     100 |     100 |                   
     -------------|---------|----------|---------|---------|-------------------
 
-  total:     15
-  passing:   15
+  total:     28
+  passing:   28
 
-  duration:  1s
+  duration:  8.8s
 
 ```
 

package/README.mz

@@ -425,6 +425,14 @@ isPatroonError(new NoMatchError())
 isPatroonError(new UnevenArgumentCountError())
 ```
 
+## Examples
+
+Patroon can be used in any context that can benefit from pattern matching.
+
+- The following tests show how patroon can help you test your JSON API by
+  pattern matching on status codes and the body:
+  https://github.com/bas080/didomi/blob/master/index.test.js.
+
 ## Tests
 
 [./src/index.test.js][5] - Contains some tests for edge cases and it defines
@@ -434,8 +442,8 @@ We also care about code coverage so we'll use [nyc][8] to generate a coverage
 report.
 
 ```bash bash -eo pipefail
-# Install and prune dependencies
-{ npm i && npm prune; } &> /dev/null
+# Clean install dependencies.
+npm ci &> /dev/null
 
 # Run tests and generate a coverage report
 npx nyc npm t | npx tap-nyc

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patroon",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Pattern matching library",
   "repository": "github:bas080/patroon",
   "main": "./src/index.js",

package/src/helpers.js

@@ -17,7 +17,17 @@ const T = () => true
 const is = Ctor => instance => isDefined(instance) && (instance.constructor ===
   Ctor || instance instanceof Ctor)
 
+function isPrimitive (x) {
+  return x !== Object(x)
+}
+
+function isEmpty (x) {
+  return !isPrimitive(x) && (Object.keys(x).length === 0)
+}
+
 module.exports = {
+  isPrimitive,
+  isEmpty,
   isDefined,
   always: x => () => x,
   is,

package/src/index.js

@@ -1,5 +1,6 @@
 const { mapLeaves, path, PathError } = require('./walkable')()
-const { isFunction, equals, T, is, tryCatch, isEven, isNil, toPairs, always } = require('./helpers')
+const { isFunction, equals, T, is, tryCatch, isEven, isNil, toPairs, always, isEmpty, isPrimitive } = require('./helpers')
+const { inspect } = require('util')
 
 const deprecated = (fn, message) => (...args) => {
   console.error(`[patroon] deprecated: ${message}`)
@@ -39,10 +40,12 @@ const predicate = pattern => {
   if (pattern && pattern[multiSymbol]) { return (...args) => pattern(...args) }
 
   const normalize = (value, pth) => {
-    if (isRegExp(value)) return arg => value.test(arg)
+    if (isRegExp(value)) return arg => value.test(path(pth, arg))
 
     if (isFunction(value)) { return arg => value(path(pth, arg)) }
 
+    if (isEmpty(value)) { return arg => !isPrimitive(path(pth, arg)) }
+
     return arg => equals(path(pth, arg), value)
   }
 
@@ -86,8 +89,9 @@ const patroon = (...list) => {
     if (isNil(found)) {
       const error = new NoMatchError('Not able to match any pattern for arguments')
       error.arguments = args
-
-      console.error(args)
+      error.patterns = list
+      error.arguments_inspect = inspect(args)
+      error.patterns_inspect = inspect(list)
 
       throw error
     }

package/src/index.test.js

@@ -1,5 +1,7 @@
 const { test } = require('tape')
+const { isNil } = require('./helpers')
 const { check, gen } = require('tape-check')
+const { version } = require('../package')
 const {
   reference,
   instanceOf,
@@ -24,6 +26,11 @@ test('Matches on a simple primitive', t => {
 })
 
 test('Matches using a RegExp', t => {
+  patroon(
+    { a: /^bunion/ }, () => t.fail(),
+    { a: /^banana/ }, () => t.pass()
+  )({ a: 'banana tree' })
+
   patroon(
     /^bunion/, () => t.fail(),
     /^banana/, () => t.end()
@@ -51,16 +58,12 @@ test('Matches always when pattern equals value', check(gen.any, (t, val) => {
 }))
 
 test('Matches none of the patterns and throws', t => {
-  try {
+  t.plan(1)
+  t.throws(() =>
     patroon(
       1, () => t.fail(),
       2, () => t.fail()
-    )(3)
-    t.fail()
-  } catch (e) {
-    t.ok(e instanceof NoMatchError)
-    t.end()
-  }
+    )(3), NoMatchError)
 })
 
 test('Does not match when a value does not exist', t => {
@@ -145,11 +148,10 @@ test('Matches always when pattern equals value', check(gen.any, (t, val) => {
   t.end()
 }))
 
-test('Matches when arguments match multi pattern', check(gen.any, (t, val) => {
+test('Matches always when arguments match multi pattern', check(gen.array(gen.any, {}), (t, args) => {
   patroon(
-    multi(0, 1, 2), () => t.fail(),
-    multi(1, 2, 3), () => t.end()
-  )(1, 2, 3)
+    multi(...args), () => t.end()
+  )(...args)
 }))
 
 test('Deprecated functions', ts => {
@@ -166,3 +168,59 @@ test('Deprecated functions', ts => {
   console.error = consoleError
   ts.end()
 })
+
+test('Returns primitive values', check(gen.primitive, (t, primitive) => {
+  t.equals(patroon(true, primitive)(true), primitive)
+  t.end()
+}))
+
+test(
+  'Does not match primitive with empty object or array',
+  check(gen.primitive, (t, primitive) => {
+    t.plan(2)
+    t.throws(() => patroon([], true)(primitive), NoMatchError)
+    t.throws(() => patroon({}, true)(primitive), NoMatchError)
+  }))
+
+test('Matching on nil values', check(gen.any, v => !isNil(v), (t, any) => {
+  t.plan(2)
+  t.throws(() => patroon(any, true)(undefined), NoMatchError)
+  t.throws(() => patroon(any, true)(null), NoMatchError)
+}))
+
+// Circular reference
+const circular = {}
+circular.a = circular
+
+test('Allows recursive patterns', t => {
+  t.plan(1)
+  t.ok(patroon(circular, true)(circular))
+})
+
+test('Throws and prints because path is not defined', t => {
+  t.plan(1)
+  t.throws(() => patroon({ b: _ }, true)(circular), NoMatchError)
+})
+
+test('Does not throw when value is recursive', t => {
+  t.plan(1)
+  t.ok(patroon({ a: _ }, true)(circular))
+})
+
+test('Does not match on reference', t => {
+  t.plan(4)
+  t.ok(patroon({ a: {} }, true)({ a: {} }))
+  t.ok(patroon({ a: [] }, true)({ a: [] }))
+  t.ok(patroon({ a: [] }, true)({ a: {} }))
+  t.ok(patroon({ a: {} }, true)({ a: [] }))
+  t.end()
+})
+
+if (version.startsWith('2')) {
+  test('Deprecated functions in version 2', t => {
+    t.plan(3)
+    t.ok(isNil(require('./index').typed))
+    t.ok(isNil(require('./index').t))
+    t.ok(isNil(require('./index').ref))
+  })
+}

package/src/walkable.js

@@ -1,8 +1,10 @@
-const { isFunction, isNil } = require('./helpers')
+const { isEmpty, isFunction, isNil } = require('./helpers')
 
 function walk (config, transform, item, path = []) {
   if (config.isLeafe(item)) { return transform(item, path) }
 
+  if (config.isCircular(item)) { return transform(item, path) }
+
   return config.map((v, i) => walk(config, transform, v, [...path, i]), item)
 }
 
@@ -24,8 +26,16 @@ function isObject (v) {
   return typeof v === 'object' && v !== null
 }
 
+const isCircular = (visited = []) => x => {
+  const isCircular = visited.includes(x)
+
+  visited.push(x)
+
+  return isCircular
+}
+
 function isLeafe (x) {
-  return Number.isNaN(x) || isNil(x) || x instanceof RegExp || isFunction(x) || (!isObject(x) && !isArray(x))
+  return Number.isNaN(x) || isNil(x) || x instanceof RegExp || isFunction(x) || isEmpty(x) || (!isObject(x) && !isArray(x))
 }
 
 function mapLeaves (config, cb, item) {
@@ -42,9 +52,9 @@ function path (pth, v, errorData) {
 
   const [key, ...rest] = pth
 
-  if (!(key in v)) {
+  if (isNil(v) || !(key in v)) {
     const error = new PathError(
-      `Cannot read property '${JSON.stringify(pth)}' of ${JSON.stringify(v)}`)
+      `Cannot read path ${pth}.`)
 
     Object.assign(error, errorData)
 
@@ -83,7 +93,10 @@ function walkable (config = {}) {
     reduce,
     mapLeaves
   ].reduce((api, fn) => {
-    api[fn.name] = fn.bind(null, config)
+    api[fn.name] = (...args) => fn({
+      isCircular: isCircular(),
+      ...config
+    }, ...args)
 
     return api
   }, api)