patroon 0.4.2 → 1.1.1

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)
@@ -192,8 +193,8 @@ builtin node error constructors in this example.
 
 ```js ./tape-test
 patroon(
-  TypeError, 'is a type error',
-  Error, 'is an error'
+  instanceOf(TypeError), 'is a type error',
+  instanceOf(Error), 'is an error'
 )(new Error())
 ```
 ```
@@ -213,8 +214,8 @@ Because of this you can match a TypeError with an Error.
 
 ```js ./tape-test
 patroon(
-  Error, 'matches on error',
-  TypeError, 'matches on type error'
+  instanceOf(Error), 'matches on error',
+  instanceOf(TypeError), 'matches on type error'
 )(new TypeError())
 ```
 ```
@@ -226,9 +227,9 @@ Here you should use the every helper.
 
 ```js ./tape-test
 patroon(
-  every(TypeError, { value: 20 }), 'type error where value is 20',
-  every(Error, { value: 30 }), 'error where value is 30',
-  every(Error, { value: 20 }), 'error where value is 20'
+  every(instanceOf(TypeError), { value: 20 }), 'type error where value is 20',
+  every(instanceOf(Error), { value: 30 }), 'error where value is 30',
+  every(instanceOf(Error), { value: 20 }), 'error where value is 20'
 )(Object.assign(new TypeError(), { value: 20 }))
 ```
 ```
@@ -251,6 +252,35 @@ patroon([], 'is array')([])
 patroon(Array, 'is array')([])
 ```
 
+A less intuitive case:
+
+```js ./tape-test > /dev/null
+patroon({}, 'is object')([])
+patroon([], 'is array')({})
+```
+
+Patroon allows this because Arrays can have properties defined.
+
+```js ./tape-test > /dev/null
+const array = []
+array.prop = 42
+
+patroon({prop: _}, 'has prop')(array)
+```
+
+The other way around is also allowed even if it seems weird.
+
+```js ./tape-test > /dev/null
+const object = {0: 42}
+patroon([42], 'has 0th')(object)
+```
+
+If you do not desire this loose behavior you can use a predicate to make sure
+something is an array or object.
+
+```js ./tape-test > /dev/null
+patroon(Array.isArray, 'is array')([])
+```
 
 ### Reference
 
@@ -259,7 +289,7 @@ helper.
 
 ```js ./tape-test
 patroon(
-  Error, 'is an instance of Error',
+  instanceOf(Error), 'is an instance of Error',
   reference(Error), 'is the Error constructor'
 )(Error)
 ```
@@ -309,6 +339,20 @@ patroon(
 Index 6 has value 7
 ```
 
+A function that returns the lenght of an array:
+
+```js ./tape-test
+const count = patroon(
+  [_], ([, ...xs]) => 1 + count(xs),
+  [], 0
+)
+
+count([0,1,2,3])
+```
+```
+4
+```
+
 A function that looks for a certain pattern in an array:
 
 ```js ./tape-test
@@ -474,12 +518,12 @@ const oneIsTwo = patroon(1, 2)
 oneIsTwo(3)
 ```
 ```
-/home/ant/projects/patroon/src/index.js:88
-    if (isNil(found)) { throw new NoMatchError(`Not able to match any pattern for value ${JSON.stringify(args)}`) }
-                        ^
+[ 3 ]
+/home/ant/projects/patroon/src/index.js:92
+      throw error
+      ^
 
-NoMatchError: Not able to match any pattern for value [3]
-    at /home/ant/projects/patroon/src/index.js:88:31
+NoMatchError: Not able to match any pattern for arguments
 ```
 
 #### UnevenArgumentCountError
@@ -490,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:81
+/home/ant/projects/patroon/src/index.js:79
   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:81:37)
+    at patroon (/home/ant/projects/patroon/src/index.js:79:37)
 ```
 
 #### PatroonError
@@ -503,7 +547,7 @@ UnevenArgumentCountError: Patroon should have an even amount of arguments.
 All errors patroon produces can be matched against the PatroonError using `instanceof`.
 
 ```js ./tape-test
-const isPatroonError = patroon(PatroonError, 'patroon is causing an error')
+const isPatroonError = patroon(instanceOf(PatroonError), 'patroon is causing an error')
 
 isPatroonError(new NoMatchError())
 isPatroonError(new UnevenArgumentCountError())
@@ -512,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
@@ -531,7 +583,7 @@ npx nyc npm t | npx tap-nyc
 npx nyc check-coverage
 ```
 ```
-    > patroon@0.4.1 test
+    > patroon@1.1.1 test
     > tape ./src/index.test.js
     -------------|---------|----------|---------|---------|-------------------
     File         | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s 
@@ -542,10 +594,10 @@ npx nyc check-coverage
      walkable.js |     100 |      100 |     100 |     100 |                   
     -------------|---------|----------|---------|---------|-------------------
 
-  total:     15
-  passing:   15
+  total:     16
+  passing:   16
 
-  duration:  703ms
+  duration:  1.6s
 
 ```
 

package/README.mz

@@ -142,8 +142,8 @@ builtin node error constructors in this example.
 
 ```js ./tape-test
 patroon(
-  TypeError, 'is a type error',
-  Error, 'is an error'
+  instanceOf(TypeError), 'is a type error',
+  instanceOf(Error), 'is an error'
 )(new Error())
 ```
 
@@ -157,8 +157,8 @@ Because of this you can match a TypeError with an Error.
 
 ```js ./tape-test
 patroon(
-  Error, 'matches on error',
-  TypeError, 'matches on type error'
+  instanceOf(Error), 'matches on error',
+  instanceOf(TypeError), 'matches on type error'
 )(new TypeError())
 ```
 
@@ -167,9 +167,9 @@ Here you should use the every helper.
 
 ```js ./tape-test
 patroon(
-  every(TypeError, { value: 20 }), 'type error where value is 20',
-  every(Error, { value: 30 }), 'error where value is 30',
-  every(Error, { value: 20 }), 'error where value is 20'
+  every(instanceOf(TypeError), { value: 20 }), 'type error where value is 20',
+  every(instanceOf(Error), { value: 30 }), 'error where value is 30',
+  every(instanceOf(Error), { value: 20 }), 'error where value is 20'
 )(Object.assign(new TypeError(), { value: 20 }))
 ```
 
@@ -189,6 +189,35 @@ patroon([], 'is array')([])
 patroon(Array, 'is array')([])
 ```
 
+A less intuitive case:
+
+```js ./tape-test > /dev/null
+patroon({}, 'is object')([])
+patroon([], 'is array')({})
+```
+
+Patroon allows this because Arrays can have properties defined.
+
+```js ./tape-test > /dev/null
+const array = []
+array.prop = 42
+
+patroon({prop: _}, 'has prop')(array)
+```
+
+The other way around is also allowed even if it seems weird.
+
+```js ./tape-test > /dev/null
+const object = {0: 42}
+patroon([42], 'has 0th')(object)
+```
+
+If you do not desire this loose behavior you can use a predicate to make sure
+something is an array or object.
+
+```js ./tape-test > /dev/null
+patroon(Array.isArray, 'is array')([])
+```
 
 ### Reference
 
@@ -197,7 +226,7 @@ helper.
 
 ```js ./tape-test
 patroon(
-  Error, 'is an instance of Error',
+  instanceOf(Error), 'is an instance of Error',
   reference(Error), 'is the Error constructor'
 )(Error)
 ```
@@ -235,6 +264,17 @@ patroon(
 )([1, 2, 3, 4, 5, 6, 7])
 ```
 
+A function that returns the lenght of an array:
+
+```js ./tape-test
+const count = patroon(
+  [_], ([, ...xs]) => 1 + count(xs),
+  [], 0
+)
+
+count([0,1,2,3])
+```
+
 A function that looks for a certain pattern in an array:
 
 ```js ./tape-test
@@ -379,12 +419,20 @@ patroon(1)
 All errors patroon produces can be matched against the PatroonError using `instanceof`.
 
 ```js ./tape-test
-const isPatroonError = patroon(PatroonError, 'patroon is causing an error')
+const isPatroonError = patroon(instanceOf(PatroonError), 'patroon is causing an error')
 
 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

package/package.json

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

package/src/helpers.js

@@ -8,10 +8,6 @@ const toPairs = items => {
 
 const isNil = x => !(x != null)
 
-function isConstructor (func) {
-  return Boolean(func && typeof func === 'function' && func.prototype && func.prototype.constructor)
-}
-
 function isDefined (x) {
   return x != null
 }
@@ -24,7 +20,6 @@ const is = Ctor => instance => isDefined(instance) && (instance.constructor ===
 module.exports = {
   isDefined,
   always: x => () => x,
-  isConstructor,
   is,
   toPairs,
   isNil,

package/src/index.js

@@ -1,5 +1,5 @@
 const { mapLeaves, path, PathError } = require('./walkable')()
-const { isConstructor, isFunction, equals, T, is, tryCatch, isEven, isNil, toPairs, always } = require('./helpers')
+const { isFunction, equals, T, is, tryCatch, isEven, isNil, toPairs, always } = require('./helpers')
 
 const deprecated = (fn, message) => (...args) => {
   console.error(`[patroon] deprecated: ${message}`)
@@ -39,9 +39,7 @@ const predicate = pattern => {
   if (pattern && pattern[multiSymbol]) { return (...args) => pattern(...args) }
 
   const normalize = (value, pth) => {
-    if (isRegExp(value)) return arg => value.test(arg)
-
-    if (isConstructor(value)) { return is(value) }
+    if (isRegExp(value)) return arg => value.test(path(pth, arg))
 
     if (isFunction(value)) { return arg => value(path(pth, arg)) }
 
@@ -85,7 +83,14 @@ const patroon = (...list) => {
   return (...args) => {
     const found = patterns.find(([matches]) => matches(...args))
 
-    if (isNil(found)) { throw new NoMatchError(`Not able to match any pattern for value ${JSON.stringify(args)}`) }
+    if (isNil(found)) {
+      const error = new NoMatchError('Not able to match any pattern for arguments')
+      error.arguments = args
+
+      console.error(args)
+
+      throw error
+    }
 
     return found[1](...args)
   }
@@ -95,6 +100,10 @@ function reference (any) {
   return value => any === value
 }
 
+function instanceOf (ctor) {
+  return value => value instanceof ctor
+}
+
 module.exports = Object.assign(patroon, {
   NoMatchError,
   UnevenArgumentCountError,
@@ -107,5 +116,6 @@ module.exports = Object.assign(patroon, {
   reference,
   typed,
   t: typed,
+  instanceOf,
   _: T
 })

package/src/index.test.js

@@ -2,6 +2,7 @@ const { test } = require('tape')
 const { check, gen } = require('tape-check')
 const {
   reference,
+  instanceOf,
   typed,
   t,
   ref,
@@ -23,6 +24,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()
@@ -39,9 +45,9 @@ test('Match using reference', t => {
 
 test('Matches on type and value', t => {
   patroon(
-    every(Error, { x: 20 }), () => t.fail(),
-    every(Error, { x: 10 }), () => t.end(),
-    every(Error), () => t.fail()
+    every(instanceOf(Error), { x: 20 }), () => t.fail(),
+    every(instanceOf(Error), { x: 10 }), () => t.end(),
+    instanceOf(Error), () => t.fail()
   )(Object.assign(new Error(), { x: 10 }))
 })
 

package/src/walkable.js

@@ -35,17 +35,23 @@ function mapLeaves (config, cb, item) {
 
 class PathError extends TypeError {}
 
-function path (pth, v) {
+function path (pth, v, errorData) {
+  if (isNil(errorData)) { return path(pth, v, { path: pth, value: v }) }
+
   if (pth.length === 0) { return v }
 
   const [key, ...rest] = pth
 
   if (!(key in v)) {
-    throw new PathError(
-      `Cannot read path '${JSON.stringify(pth)}' on ${JSON.stringify(v)}`)
+    const error = new PathError(
+      `Cannot read property '${JSON.stringify(pth)}' of ${JSON.stringify(v)}`)
+
+    Object.assign(error, errorData)
+
+    throw error
   }
 
-  return path(rest, v[key])
+  return path(rest, v[key], errorData)
 }
 
 function map (fn, x) {

package/tape-test

@@ -4,6 +4,7 @@ cat <(echo '
 const {
   _,
   every,
+  instanceOf,
   some,
   multi,
   reference,