tape-six 0.9.0

package/src/Tester.js

@@ -0,0 +1,411 @@
+import {equal, match, any} from './deep6/index.js';
+
+const throwHelper = fn => {
+  try {
+    fn();
+  } catch (error) {
+    return error;
+  }
+  return null;
+};
+
+class Tester {
+  constructor(state, testNumber) {
+    this.state = state;
+    this.testNumber = testNumber;
+  }
+
+  plan(n) {
+    this.state.setPlan(n);
+  }
+
+  comment(msg) {
+    this.state.emit({type: 'comment', name: msg || 'comment', test: this.testNumber, marker: new Error(), time: this.state.timer.now()});
+  }
+
+  skipTest(...args) {
+    let msg;
+    for (let i = args.length - 1; i >= 0; --i) {
+      if (typeof args[i] == 'string') {
+        msg = args[i];
+        break;
+      }
+    }
+    this.state.emit({
+      name: msg || 'skipped test',
+      test: this.testNumber,
+      marker: new Error(),
+      time: this.state.timer.now(),
+      skip: true,
+      operator: 'skip'
+    });
+  }
+
+  bailOut(msg) {
+    this.state.emit({
+      type: 'bail-out',
+      name: msg || 'bail out',
+      test: this.testNumber,
+      marker: new Error(),
+      time: this.state.timer.now(),
+      operator: 'bailOut'
+    });
+  }
+
+  // asserts
+
+  pass(msg) {
+    this.state.emit({
+      name: msg || 'pass',
+      test: this.testNumber,
+      marker: new Error(),
+      time: this.state.timer.now(),
+      operator: 'pass',
+      data: {expected: true, actual: true}
+    });
+  }
+
+  fail(msg) {
+    this.state.emit({
+      name: msg || 'fail',
+      test: this.testNumber,
+      marker: new Error(),
+      time: this.state.timer.now(),
+      operator: 'fail',
+      fail: true,
+      data: {expected: true, actual: false}
+    });
+  }
+
+  ok(value, msg) {
+    this.state.emit({
+      name: msg || 'should be truthy',
+      test: this.testNumber,
+      marker: new Error(),
+      time: this.state.timer.now(),
+      operator: 'ok',
+      fail: !value,
+      data: {
+        expected: true,
+        actual: value
+      }
+    });
+  }
+
+  notOk(value, msg) {
+    this.state.emit({
+      name: msg || 'should be falsy',
+      test: this.testNumber,
+      marker: new Error(),
+      time: this.state.timer.now(),
+      operator: 'notOk',
+      fail: !!value,
+      data: {
+        expected: false,
+        actual: value
+      }
+    });
+  }
+
+  error(error, msg) {
+    this.state.emit({
+      name: msg || String(error),
+      test: this.testNumber,
+      marker: new Error(),
+      time: this.state.timer.now(),
+      operator: 'error',
+      fail: !!error,
+      data: {
+        expected: true,
+        actual: error
+      }
+    });
+  }
+
+  strictEqual(a, b, msg) {
+    this.state.emit({
+      name: msg || 'should be strictly equal',
+      test: this.testNumber,
+      marker: new Error(),
+      time: this.state.timer.now(),
+      operator: 'equal',
+      fail: typeof a == 'object' ? a !== b : !equal(a, b),
+      data: {
+        expected: b,
+        actual: a
+      }
+    });
+  }
+
+  notStrictEqual(a, b, msg) {
+    this.state.emit({
+      name: msg || 'should not be strictly equal',
+      test: this.testNumber,
+      marker: new Error(),
+      time: this.state.timer.now(),
+      operator: 'notEqual',
+      fail: typeof a == 'object' ? a === b : equal(a, b),
+      data: {
+        expected: b,
+        actual: a
+      }
+    });
+  }
+
+  looseEqual(a, b, msg) {
+    this.state.emit({
+      name: msg || 'should be loosely equal',
+      test: this.testNumber,
+      marker: new Error(),
+      time: this.state.timer.now(),
+      operator: 'looseEqual',
+      fail: a != b,
+      data: {
+        expected: b,
+        actual: a
+      }
+    });
+  }
+
+  notLooseEqual(a, b, msg) {
+    this.state.emit({
+      name: msg || 'should not be loosely equal',
+      test: this.testNumber,
+      marker: new Error(),
+      time: this.state.timer.now(),
+      operator: 'notLooseEqual',
+      fail: a == b,
+      data: {
+        expected: b,
+        actual: a
+      }
+    });
+  }
+
+  deepEqual(a, b, msg) {
+    this.state.emit({
+      name: msg || 'should be deeply equivalent',
+      test: this.testNumber,
+      marker: new Error(),
+      time: this.state.timer.now(),
+      operator: 'deepEqual',
+      fail: !equal(a, b),
+      data: {
+        expected: b,
+        actual: a
+      }
+    });
+  }
+
+  notDeepEqual(a, b, msg) {
+    this.state.emit({
+      name: msg || 'should not be deeply equivalent',
+      test: this.testNumber,
+      marker: new Error(),
+      time: this.state.timer.now(),
+      operator: 'notDeepEqual',
+      fail: equal(a, b),
+      data: {
+        expected: b,
+        actual: a
+      }
+    });
+  }
+
+  deepLooseEqual(a, b, msg) {
+    this.state.emit({
+      name: msg || 'should be loosely equal',
+      test: this.testNumber,
+      marker: new Error(),
+      time: this.state.timer.now(),
+      operator: 'deepLooseEqual',
+      fail: !equal(a, b, {circular: true, loose: true}),
+      data: {
+        expected: b,
+        actual: a
+      }
+    });
+  }
+
+  notDeepLooseEqual(a, b, msg) {
+    this.state.emit({
+      name: msg || 'should not be loosely equal',
+      test: this.testNumber,
+      marker: new Error(),
+      time: this.state.timer.now(),
+      operator: 'notDeepLooseEqual',
+      fail: equal(a, b, {circular: true, loose: true}),
+      data: {
+        expected: b,
+        actual: a
+      }
+    });
+  }
+
+  throws(fn, msg) {
+    if (typeof fn != 'function') throw new TypeError('the first argument should be a function');
+    const result = throwHelper(fn);
+    this.state.emit({
+      name: msg || 'should throw',
+      test: this.testNumber,
+      marker: new Error(),
+      time: this.state.timer.now(),
+      operator: 'throws',
+      fail: !result,
+      data: {
+        expected: null,
+        actual: result
+      }
+    });
+  }
+
+  doesNotThrow(fn, msg) {
+    if (typeof fn != 'function') throw new TypeError('the first argument should be a function');
+    const result = throwHelper(fn);
+    this.state.emit({
+      name: msg || 'should not throw',
+      test: this.testNumber,
+      marker: new Error(),
+      time: this.state.timer.now(),
+      operator: 'doesNotThrow',
+      fail: !!result,
+      data: {
+        expected: null,
+        actual: result
+      }
+    });
+  }
+
+  matchString(string, regexp, msg) {
+    if (typeof string != 'string') throw new TypeError('the first argument should be a string');
+    if (!regexp || typeof regexp != 'object' || typeof regexp.test != 'function')
+      throw new TypeError('the second argument should be a regular expression object');
+    this.state.emit({
+      name: msg || 'should match regular expression',
+      test: this.testNumber,
+      marker: new Error(),
+      time: this.state.timer.now(),
+      operator: 'matchString',
+      fail: !regexp.test(string),
+      data: {
+        expected: regexp,
+        actual: string
+      }
+    });
+  }
+
+  doesNotMatchString(string, regexp, msg) {
+    if (typeof string != 'string') throw new TypeError('the first argument should be a string');
+    if (!regexp || typeof regexp != 'object' || typeof regexp.test != 'function')
+      throw new TypeError('the second argument should be a regular expression object');
+    this.state.emit({
+      name: msg || 'should not match regular expression',
+      test: this.testNumber,
+      marker: new Error(),
+      time: this.state.timer.now(),
+      operator: 'doesNotMatch',
+      fail: regexp.test(string),
+      data: {
+        expected: regexp,
+        actual: string
+      }
+    });
+  }
+
+  match(a, b, msg) {
+    this.state.emit({
+      name: msg || 'should match object',
+      test: this.testNumber,
+      marker: new Error(),
+      time: this.state.timer.now(),
+      operator: 'match',
+      fail: !match(a, b),
+      data: {
+        expected: b,
+        actual: a
+      }
+    });
+  }
+
+  doesNotMatch(a, b, msg) {
+    this.state.emit({
+      name: msg || 'should not match object',
+      test: this.testNumber,
+      marker: new Error(),
+      time: this.state.timer.now(),
+      operator: 'doesNotMatchObject',
+      fail: match(a, b),
+      data: {
+        expected: b,
+        actual: a
+      }
+    });
+  }
+
+  rejects(promise, msg) {
+    if (!promise || typeof promise.then != 'function') throw new TypeError('the first argument should be a promise');
+    return promise
+      .then(
+        () => null,
+        error => error
+      )
+      .then(result => {
+        this.state.emit({
+          name: msg || 'should be rejected',
+          test: this.testNumber,
+          marker: new Error(),
+          time: this.state.timer.now(),
+          operator: 'rejects',
+          fail: !result,
+          data: {
+            expected: null,
+            actual: result
+          }
+        });
+      });
+  }
+
+  resolves(promise, msg) {
+    if (!promise || typeof promise.then != 'function') throw new TypeError('the first argument should be a promise');
+    return promise
+      .then(
+        () => null,
+        error => error
+      )
+      .then(result => {
+        this.state.emit({
+          name: msg || 'should not be rejected',
+          test: this.testNumber,
+          marker: new Error(),
+          time: this.state.timer.now(),
+          operator: 'resolves',
+          fail: !!result,
+          data: {
+            expected: null,
+            actual: result
+          }
+        });
+      });
+  }
+
+  // missing: T (eval)
+}
+Tester.prototype.any = Tester.prototype._ = any;
+
+const setAliases = (source, aliases) => aliases.split(', ').forEach(alias => (Tester.prototype[alias] = Tester.prototype[source]));
+
+setAliases('ok', 'true, assert');
+setAliases('notOk', 'false, notok');
+setAliases('error', 'ifError, ifErr, iferror');
+setAliases('strictEqual', 'is, equal, equals, isEqual, strictEquals');
+setAliases('notStrictEqual', 'not, notEqual, notEquals, isNotEqual, doesNotEqual, isInequal, notStrictEquals, isNot');
+setAliases('looseEqual', 'looseEquals');
+setAliases('notLooseEqual', 'notLooseEquals');
+setAliases('deepEqual', 'same, deepEquals, isEquivalent');
+setAliases('notDeepEqual', 'notSame, notDeepEquals, notEquivalent, notDeeply, isNotDeepEqual, isNotDeepEqual, isNotEquivalent, isInequivalent');
+setAliases('rejects', 'doesNotResolve');
+setAliases('resolves', 'doesNotReject');
+
+// test() (an embedded test runner) is added in ./test.js to avoid circular dependencies
+
+export default Tester;

package/src/deep6/env.js

@@ -0,0 +1,174 @@
+// Env
+
+const keyDepth = Symbol.for('deep6.env.depth');
+
+const collectSymbols = object => {
+  const symbols = new Set();
+  while (object && typeof object == 'object') {
+    Object.getOwnPropertySymbols(object).forEach(symbol => symbols.add(symbol));
+    object = Object.getPrototypeOf(object);
+  }
+  symbols.delete(keyDepth);
+  return Array.from(symbols);
+};
+
+const ensure = (object, depth) => {
+  while (object[keyDepth] > depth) object = object.getPrototypeOf(object);
+  if (object[keyDepth] < depth) {
+    object = Object.create(object);
+    object[keyDepth] = depth;
+  }
+  return object;
+};
+
+class Env {
+  constructor() {
+    this.variables = Object.create(null);
+    this.values = Object.create(null);
+    this.depth = this.variables[keyDepth] = this.values[keyDepth] = 0;
+  }
+  push() {
+    ++this.depth;
+  }
+  pop() {
+    if (this.depth < 1) throw new Error('attempt to pop a frame with an empty stack');
+    --this.depth;
+    while (this.variables[keyDepth] > this.depth) this.variables = Object.getPrototypeOf(this.variables);
+    while (this.values[keyDepth] > this.depth) this.values = Object.getPrototypeOf(this.values);
+  }
+  revert(depth) {
+    if (this.depth < depth) throw new Error('attempt to revert a stack to a higher depth');
+    while (this.variables[keyDepth] > depth) this.variables = Object.getPrototypeOf(this.variables);
+    while (this.values[keyDepth] > depth) this.values = Object.getPrototypeOf(this.values);
+    this.depth = depth;
+  }
+  bindVar(name1, name2) {
+    const depth = this.depth,
+      vars = (this.variables = ensure(this.variables, depth));
+    let u1 = vars[name1],
+      u2 = vars[name2];
+    u1 && (u1 = vars[name1] = ensure(u1, depth));
+    u2 && (u2 = vars[name2] = ensure(u2, depth));
+    if (u1) {
+      if (u2) {
+        for (const k in u2) {
+          vars[k] = u1;
+          u1[k] = 1;
+        }
+        collectSymbols(u2).forEach(k => ((vars[k] = u1), (u1[k] = 1)));
+      } else {
+        vars[name2] = u1;
+        u1[name2] = 1;
+      }
+    } else {
+      if (u2) {
+        vars[name1] = u2;
+        u2[name1] = 1;
+      } else {
+        u2 = Object.create(null);
+        u2[keyDepth] = depth;
+        vars[name1] = vars[name2] = u2;
+        u2[name1] = u2[name2] = 1;
+      }
+    }
+  }
+  bindVal(name, val) {
+    const depth = this.depth,
+      values = (this.values = ensure(this.values, depth)),
+      vars = (this.variables = ensure(this.variables, depth));
+    let u = vars[name];
+    u && (u = vars[name] = ensure(u, depth));
+    if (u) {
+      for (const k in u) {
+        values[k] = val;
+        vars[k] = null;
+      }
+      collectSymbols(u).forEach(k => ((values[k] = val), (vars[k] = null)));
+    } else {
+      values[name] = val;
+    }
+  }
+  // helpers
+  isBound(name) {
+    return name in env.values;
+  }
+  isAlias(name1, name2) {
+    const u = env.variables[name2];
+    return u && u[name1] === 1;
+  }
+  get(name) {
+    return env.values[name];
+  }
+  // debugging
+  getAllValues() {
+    const values = this.values,
+      result = collectSymbols(values).map(k => ({name: k, value: values[k]}));
+    for (const k in values) {
+      result.push({name: k, value: values[k]});
+    }
+    return result;
+  }
+}
+
+// Custom unifier
+
+class Unifier {}
+
+const isUnifier = x => x instanceof Unifier;
+
+// Unifier should define a method:
+// unify(val, ls, rs, env):
+// val is a value we are unifying with
+// ls is a stack of left arguments
+// rs is a stack of right arguments corresponding to ls
+// env is an environment
+// the result should be true/false for success/failure
+
+// AnyVar
+
+const _ = Symbol.for('deep6.any'),
+  any = _;
+
+// Variable
+
+class Variable extends Unifier {
+  constructor(name) {
+    super();
+    this.name = name || Symbol();
+  }
+  isBound(env) {
+    return this.name in env.values;
+  }
+  isAlias(name, env) {
+    const u = env.variables[this.name];
+    return u && u[name instanceof Variable ? name.name : name] === 1;
+  }
+  get(env) {
+    return env.values[this.name];
+  }
+  unify(val, ls, rs, env) {
+    if (this.name in env.values) {
+      // isBound
+      ls.push(env.values[this.name]);
+      rs.push(val);
+      return true;
+    }
+    if (val === _ || val === this) return true;
+    if (val instanceof Variable) {
+      if (val.name in env.values) {
+        // isBound
+        env.bindVal(this.name, env.values[val.name]);
+        return true;
+      }
+      env.bindVar(this.name, val.name);
+      return true;
+    }
+    env.bindVal(this.name, val);
+    return true;
+  }
+}
+
+const isVariable = x => x instanceof Variable,
+  variable = name => new Variable(name);
+
+export {Env, Unifier, isUnifier, Variable, variable, isVariable, _, any};

package/src/deep6/index.js

@@ -0,0 +1,21 @@
+import {any, _} from './env.js';
+import unify from './unify.js';
+import originalClone from './traverse/clone.js';
+import preprocess from './traverse/preprocess.js';
+
+const defaultOptions = {circular: true};
+const equal = (a, b, options = defaultOptions) => !!unify(a, b, null, options);
+
+const defaultMatchOptions = {openObjects: true, openMaps: true, openSets: true, circular: true};
+const match = (object, pattern, options = defaultMatchOptions) =>
+  !!unify(object, preprocess(pattern, options), null, {
+    circular: options.circular,
+    symbols: options.symbols,
+    loose: options.loose,
+    ignoreFunctions: options.ignoreFunctions
+  });
+
+const clone = (a, options = defaultOptions) => originalClone(a, null, options);
+
+export {equal, clone, match, match as isShape, any, _};
+export default equal;