generate-random-ast.js

import { check, gen, property } from 'testcheck';
import generate from 'babel-generator'
import babel from 'babel-core';

const genTrue = gen.suchThat((v) => v, gen.boolean);
const genFalse = gen.suchThat((v) => !v, gen.boolean);

const letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
  'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'];

const genAlphaString = gen.suchThat(
  (v) => letters.indexOf(v[0].toLowerCase()) !== -1,
  gen.notEmpty(gen.alphaNumString)
);

function Identifier() {
  return gen.object({
    type: gen.return('Identifier'),
    name: genAlphaString
  });
}

function StringLiteral() {
  return gen.object({
    type: gen.return('StringLiteral'),
    value: gen.alphaNumString
  });
}

function BooleanLiteral() {
  return gen.object({
    type: gen.return('BooleanLiteral'),
    value: gen.boolean
  });
}

function VariableDeclarator() {
  return gen.object({
    type: gen.return('VariableDeclarator'),
    id: Identifier(),
    init: gen.oneOf([
      ArrowFunctionExpression()
    ])
  });
}

function VariableDeclaration() {
  return gen.object({
    type: gen.return('VariableDeclaration'),
    declarations: gen.array(VariableDeclarator(), 1),
    kind: gen.returnOneOf(['var', 'let', 'const']),
  });
}

function ArrowFunctionExpression() {
  return gen.object({
    type: gen.return('ArrowFunctionExpression'),
    id: gen.null,
    generator: genFalse,
    expression: genFalse,
    async: genFalse,
    params: gen.array(Identifier(), 0, 3),
    body: gen.oneOf([
      JSXElement(),
      BlockStatement()
    ])
  });
}

function BlockStatement() {
  return gen.object({
    type: gen.return('BlockStatement'),
    directives: gen.return([]),
    body: gen.array(ReturnStatement(), 0, 1)
  });
}

function ReturnStatement() {
  return gen.object({
    type: gen.return('ReturnStatement'),
    argument: gen.oneOf([
      JSXElement()
    ])
  });
}

function JSXIdentifier() {
  return gen.object({
    type: gen.return('JSXIdentifier'),
    name: genAlphaString
  });
}

function JSXExpressionContainer() {
  return gen.object({
    type: gen.return('JSXExpressionContainer'),
    expression: gen.oneOf([
      BooleanLiteral(),
      StringLiteral(),
    ])
  });
}

function JSXAttribute() {
  return gen.object({
    type: gen.return('JSXAttribute'),
    name: JSXIdentifier(),
    value: gen.oneOf([
      StringLiteral(),
      JSXExpressionContainer()
    ])
  });
}

function JSXOpeningElement() {
  return gen.object({
    type: gen.return('JSXOpeningElement'),
    attributes: gen.array(JSXAttribute(), 0, 3),
    name: JSXIdentifier(),
    selfClosing: genTrue
  });
}

function JSXElement() {
  return gen.object({
    type: gen.return('JSXElement'),
    openingElement: JSXOpeningElement(),
    closingElement: genFalse,
    children: gen.return([])
  });
}

const File = (statements) => ({
  type: 'File',
  program: {
    type: 'Program',
    sourceType: 'module',
    body: statements,
    directives: []
  },
  comments: []
});

const result = check(
  property(
    [gen.array(VariableDeclaration(), 3)],
    (x) => {
      const { code } = generate(File(x));

      return true;
    }
  )
);