init

Author: kawasima

.gitignore

@@ -59,3 +59,7 @@ typings/
 
 # next.js build output
 .next
+
+.lein-*
+.nrepl-*
+target

package.json

@@ -0,0 +1,22 @@
+{
+  "name": "json-spec",
+  "version": "0.1.0-SNAPSHOT",
+  "description": "A tool for describing the structure of JSON data",
+  "license": "MIT",
+  "repository": "github:kawasima/json-spec",
+  "scripts": {
+    "test": "jest"
+  },
+  "jest": {
+    "moduleDirectories": [
+      "src",
+      "node_modules"
+    ]
+  },
+  "devDependencies": {
+    "jest": "^23.5.0"
+  },
+  "dependencies": {
+    "n64": "^0.2.1"
+  }
+}

project.clj

@@ -0,0 +1,4 @@
+(defproject json-spec "0.1.0-SNAPSHOT"
+  :dependencies [[org.clojure/clojure "1.9.0"]
+                 [org.clojure/spec.alpha "0.2.176"]]
+  :profiles {:docker {:local-repo "lib"}})

src/generators.js

@@ -0,0 +1,124 @@
+const { I64 } = require('n64');
+
+class Generator {
+  constructor(gen) {
+    this.gen = gen;
+  }
+}
+
+function makeGen(generatorFunc) {
+  return new Generator(generatorFunc);
+}
+
+function callGen(gen, rnd, size) {
+  return gen.call(null, rnd, size);
+}
+
+function choose(lower, upper) {
+  return (rnd, size) => {
+    const value = randRange(rnd, lower, upper);
+    return value;
+  };
+}
+
+function fmap(f, generator) {
+  return (rnd, size) => f(generator(rnd,size));
+}
+
+function repeat(n, el) {
+  return Array.apply(null, Array(10)).map(() => el);
+}
+
+function vector(generator) {
+  return (rnd, size) => repeat(size, generator).map(gen => gen(rnd, size));
+}
+
+function calcLong(factor, lower, upper) {
+  return Math.floor(lower + (factor * (upper + 1.0)) - (factor * lower));
+}
+
+function randRange(rnd, lower, upper) {
+  return calcLong(rnd.randDouble(), lower, upper);
+}
+
+function sized(sizedGen) {
+  return function(rnd, size) {
+    const gen = sizedGen.call(null, size);
+    return callGen(gen, rnd, size)
+  };
+}
+
+function join(coll) {
+  return coll.join('');
+}
+
+const generators = {
+  'int': sized((size) => choose(-size, size)),
+  'char': fmap(String.fromCharCode, choose(0, 255)),
+  'char-ascii': fmap(String.fromCharCode, choose(32, 126)),
+  'char-alphanumeric': fmap(String.fromCharCode, oneOf(
+    choose(48, 57),
+    choose(65, 90),
+    choose(97, 122)
+  )),
+  'char-alpha': fmap(String.fromCharCode, oneOf(
+    choose(65, 90),
+    choose(97, 122)
+  )),
+  'string': fmap(join, vector(fmap(String.fromCharCode, choose(0, 255))))
+}
+
+class RandomUnit {
+  constructor() {
+    let x = 1;
+    for (let i = 53; i > 0; i--) {
+      x /= 2;
+    }
+    this.doubleUnit = x;
+    this.bigDoubleUnit = this.doubleUnit * 4294967296;
+  }
+
+  randDouble() {
+    const long = this.randLong();
+    const x = long.ushrn(11);
+    return (this.doubleUnit * x.lo) + (this.bigDoubleUnit * x.hi);
+  }
+
+  randLong() {
+    return I64.random();
+  }
+}
+
+function elements(coll) {
+  return (rnd, size) => coll[choose(0, coll.length - 1)(rnd, size)];
+}
+
+function oneOf(...generators) {
+  return (rnd, size) => generators[choose(0, generators.length - 1)(rnd, size)](rnd,size);
+}
+
+function* rangeCyclic(from, to) {
+  let i = from;
+  while(true) {
+    yield i;
+    i = i >= to ? from : i + 1;
+  }
+}
+
+function sample(generator, numSample = 10) {
+  const randomUnit = new RandomUnit();
+  const range = rangeCyclic(0, numSample);
+  const result = new Array(numSample);
+  for (let i = 0; i < numSample; i++) {
+    result[i] = generator.call(null, randomUnit, range.next());
+  }
+  return result;
+}
+
+module.exports = {
+  generators,
+  fmap,
+  sample,
+  oneOf,
+  choose
+}

src/spec.js

@@ -0,0 +1,37 @@
+const INVALID = (function() {
+  function toString() {
+    return "INVALID";
+  }
+})();
+
+function Spec(form, pred, gfn, cpred) {
+  this.form = form;
+  this.pred = pred;
+  this.gfn = gfn;
+  this.cpred = cpred;
+}
+
+Spec.prototype = {
+  conform: function(x) {
+    const ret = this.pred.call(this, x);
+    return this.cpred ? ret : ret ? x : INVALID;
+  }
+}
+
+function specImpl(form, pred, gfn, cpred) {
+  return new Spec(form, pred, gfn, cpred);
+}
+
+function specize(spec) {
+  if (spec instanceof Spec) {
+    return spec;
+  } else {
+    return specImpl(spec, spec);
+  }
+}
+
+function conform(spec, x) {
+  return specize(spec).conform(x);
+}
+
+module.exports = { conform };

test/generators.test.js

@@ -0,0 +1,23 @@
+const { sample, choose,generators }  = require('generators');
+
+describe('generators', () => {
+  test('sample-choose', () => {
+    const v = sample(choose(200, 800));
+    console.log(v);
+  })
+
+  test('sample-char', () => {
+    const v = sample(generators['char']);
+    console.log(v);
+  })
+
+  test('sample-char-alphanumeric', () => {
+    const v = sample(generators['char-alphanumeric']);
+    console.log(v);
+  })
+
+  test('sample-string', () => {
+    const v = sample(generators['string']);
+    console.log(v);
+  })
+})

test/spec.test.js

@@ -0,0 +1,12 @@
+const { conform, INVALID } = require('spec');
+const { I64 } = require('n64');
+
+describe('conforms', () => {
+  test('conform', () => {
+    expect(conform(x => x%2 === 0, 1000)).toBe(1000);
+  })
+  test('conform invalid', () => {
+    expect(conform(x => x%2 === 0, 1001)).toBe(INVALID);
+  })
+
+});