patroon 0.4.1 → 1.1.0

package/README.md

@@ -1,5 +1,7 @@
 # Patroon
 
+Pattern matching in JavaScript without additional syntax.
+
 [![NPM](https://img.shields.io/npm/v/patroon?color=blue&style=flat-square)](https://www.npmjs.com/package/patroon)
 [![NPM Downloads](https://img.shields.io/npm/dm/patroon?style=flat-square)](https://www.npmjs.com/package/patroon)
 [![100% Code Coverage](https://img.shields.io/badge/coverage-100%25-brightgreen?style=flat-square)](#tests)
@@ -7,8 +9,6 @@
 [![Standard Code Style](https://img.shields.io/badge/code_style-standard-brightgreen.svg?style=flat-square)](https://standardjs.com)
 [![License](https://img.shields.io/npm/l/patroon?color=brightgreen&style=flat-square)](./LICENSE)
 
-Pattern matching in JavaScript without additional syntax.
-
 - [Installation](#installation)
 - [Usage](#usage)
   * [Primitive](#primitive)
@@ -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)
@@ -43,6 +44,8 @@ npm install patroon
 
 Let's see what valid and less valid uses of patroon are.
 
+> You can try out patroon over at [RunKit][runkit].
+
 ### Primitive
 
 The simplest thing one can do is to match on a [primitive][1].
@@ -190,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())
 ```
 ```
@@ -211,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())
 ```
 ```
@@ -224,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 }))
 ```
 ```
@@ -249,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
 
@@ -257,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)
 ```
@@ -307,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
@@ -472,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
@@ -488,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
@@ -501,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())
@@ -510,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
@@ -529,7 +583,7 @@ npx nyc npm t | npx tap-nyc
 npx nyc check-coverage
 ```
 ```
-    > patroon@0.4.0 test
+    > patroon@1.1.0 test
     > tape ./src/index.test.js
     -------------|---------|----------|---------|---------|-------------------
     File         | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s 
@@ -540,10 +594,10 @@ npx nyc check-coverage
      walkable.js |     100 |      100 |     100 |     100 |                   
     -------------|---------|----------|---------|---------|-------------------
 
-  total:     12
-  passing:   12
+  total:     15
+  passing:   15
 
-  duration:  1.5s
+  duration:  1.4s
 
 ```
 
@@ -566,3 +620,4 @@ polite and read the [CONTRIBUTING.md][10].
 [8]:https://github.com/istanbuljs/nyc
 [9]:https://www.npmjs.com/package/patroon
 [10]:./CONTRIBUTING.md
+[runkit]:https://npm.runkit.com/patroon

package/README.mz

@@ -1,5 +1,7 @@
 # Patroon
 
+Pattern matching in JavaScript without additional syntax.
+
 [![NPM](https://img.shields.io/npm/v/patroon?color=blue&style=flat-square)](https://www.npmjs.com/package/patroon)
 [![NPM Downloads](https://img.shields.io/npm/dm/patroon?style=flat-square)](https://www.npmjs.com/package/patroon)
 [![100% Code Coverage](https://img.shields.io/badge/coverage-100%25-brightgreen?style=flat-square)](#tests)
@@ -7,8 +9,6 @@
 [![Standard Code Style](https://img.shields.io/badge/code_style-standard-brightgreen.svg?style=flat-square)](https://standardjs.com)
 [![License](https://img.shields.io/npm/l/patroon?color=brightgreen&style=flat-square)](./LICENSE)
 
-Pattern matching in JavaScript without additional syntax.
-
 <toc
 
 ## Installation
@@ -23,6 +23,8 @@ npm install patroon
 
 Let's see what valid and less valid uses of patroon are.
 
+> You can try out patroon over at [RunKit][runkit].
+
 ### Primitive
 
 The simplest thing one can do is to match on a [primitive][1].
@@ -140,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())
 ```
 
@@ -155,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())
 ```
 
@@ -165,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 }))
 ```
 
@@ -187,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
 
@@ -195,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)
 ```
@@ -233,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
@@ -377,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
@@ -419,3 +469,4 @@ polite and read the [CONTRIBUTING.md][10].
 [8]:https://github.com/istanbuljs/nyc
 [9]:https://www.npmjs.com/package/patroon
 [10]:./CONTRIBUTING.md
+[runkit]:https://npm.runkit.com/patroon

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patroon",
-  "version": "0.4.1",
+  "version": "1.1.0",
   "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}`)
@@ -8,7 +8,7 @@ const deprecated = (fn, message) => (...args) => {
 
 const typed = deprecated(function typed (Ctor, pattern) {
   return every(Ctor, pattern)
-}, 'replace "typed(Constructor, [pattern])" with "every(Constructor, pattern)"')
+}, 'replace "typed" or "t" helpers with "every(Constructor, pattern)"')
 
 const isRegExp = is(RegExp)
 
@@ -41,8 +41,6 @@ const predicate = pattern => {
   const normalize = (value, pth) => {
     if (isRegExp(value)) return arg => value.test(arg)
 
-    if (isConstructor(value)) { return is(value) }
-
     if (isFunction(value)) { return arg => value(path(pth, arg)) }
 
     return arg => equals(path(pth, arg), value)
@@ -85,16 +83,25 @@ 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)
 
-    const [, doFn] = found
+      throw error
+    }
 
-    return doFn(...args)
+    return found[1](...args)
   }
 }
 
-function reference (fn) {
-  return (arg) => fn === arg
+function reference (any) {
+  return value => any === value
+}
+
+function instanceOf (ctor) {
+  return value => value instanceof ctor
 }
 
 module.exports = Object.assign(patroon, {
@@ -109,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,
@@ -39,9 +40,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 }))
 })
 
@@ -152,9 +153,16 @@ test('Matches when arguments match multi pattern', check(gen.any, (t, val) => {
 }))
 
 test('Deprecated functions', ts => {
-  ts.plan(0)
+  ts.plan(3)
+
+  const consoleError = console.error
+
+  console.error = message =>
+    ts.ok(message.startsWith('[patroon] deprecated: '))
+
   typed(Error, null)(new Error())
   t(Error, null)(new Error())
   ref(Error, null)(Error)
+  console.error = consoleError
   ts.end()
 })

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,