patroon 0.0.0

package/src/index.test.js

@@ -0,0 +1,62 @@
+const { test } = require('tape')
+const { check, gen } = require('tape-check')
+const {
+  patroon,
+  typed,
+  NoMatchError,
+  _
+} = require('./index')
+
+test('Matches always when pattern equals value', check(gen.any, (t, val) => {
+  patroon(val, () => t.end())(val)
+}))
+
+test('Matches none of the patterns and throws', t => {
+  try {
+    patroon(
+      1, () => t.fail(),
+      2, () => t.fail()
+    )(3)
+    t.fail()
+  } catch (e) {
+    t.ok(e instanceof NoMatchError)
+    t.end()
+  }
+})
+
+test('Does not match when a value does not exist', t => {
+  patroon(
+    { a: { b: 2 } }, () => t.fail(),
+    _, () => t.end()
+  )({})
+})
+
+test('Throws when a typed does not receice a constructor', t => {
+  try {
+    console.log('XXX', typed(20))
+    typed(20)
+  } catch (e) {
+    t.ok(e instanceof Error)
+    t.end()
+  }
+})
+
+test('Throws in a predicate function', t => {
+  try {
+    patroon(
+      () => { throw new TypeError() }, () => {}
+    )()
+  } catch (e) {
+    t.ok(e instanceof TypeError)
+    t.end()
+  }
+})
+
+test('Throws when an uneven amount of arguments are passed', t => {
+  try {
+    patroon(1)
+  } catch (e) {
+    t.ok(e instanceof TypeError)
+    t.end()
+  }
+})

package/src/walkable.js

@@ -0,0 +1,86 @@
+const { isFunction, isDefined } = require('./helpers')
+
+function walk (config, transform, item, path = []) {
+  if (config.isLeafe(item)) { return transform(item, path) }
+
+  return config.map((v, i) => walk(config, transform, v, [...path, i]), item)
+}
+
+function reduce (config, cb, acc, item) {
+  walk(config, (item, path) => {
+    acc = cb(acc, item, path)
+
+    return item
+  }, item)
+
+  return acc
+}
+
+function isArray (v) {
+  return Array.isArray(v)
+}
+
+function isObject (v) {
+  return typeof v === 'object' && v !== null
+}
+
+function isLeafe (x) {
+  return Number.isNaN(x) || !isDefined(x) || isFunction(x) || (!isObject(x) && !isArray(x))
+}
+
+function mapLeaves (config, cb, item) {
+  return reduce(config, (acc, item, path) =>
+    [...acc, cb(item, path)], [], item)
+}
+
+class PathError extends TypeError {}
+
+function path (pth, 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)}`)
+  }
+
+  return path(rest, v[key])
+}
+
+function map (fn, x) {
+  // Should this code be here?
+  // if (!isDefined(x)) { throw new TypeError(`Cannot map over ${x}`) }
+
+  return isFunction(x.map)
+    ? x.map(fn)
+    : Object.keys(x).reduce((y, prop) => {
+      y[prop] = fn(x[prop], prop)
+      return y
+    }, {})
+}
+
+function walkable (config = {}) {
+  config = {
+    isLeafe,
+    map,
+    ...config
+  }
+
+  const api = {
+    PathError,
+    path
+  }
+
+  return [
+    walk,
+    reduce,
+    mapLeaves
+  ].reduce((api, fn) => {
+    api[fn.name] = fn.bind(null, config)
+
+    return api
+  }, api)
+}
+
+module.exports = walkable

package/tape-test

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+
+cat <(echo '
+const { test } = require("tape")
+const {
+  _, // placeholder,
+  t: typed,
+  ref,
+  patroon,
+  NoMatchError
+} = require("./src/index")
+
+const simpleObject = { a: 1 }
+const otherObject = { b: 1 }
+const emptyObject = {}
+
+class A { }
+class B { }
+
+
+test(t => {
+  const fail = () => t.fail()
+  const pass = () => t.pass()
+  const end = () => t.end()
+') \
+  - \
+  <(echo ' })') | node - 1>&2