create-neon

.gitignore

@@ -7,6 +7,7 @@ Cargo.lock
 **/index.node
 **/artifacts.json
 cli/lib
+create-neon/dist
 test/cli/lib
 npm-debug.log
 rls*.log

create-neon/data/templates/.gitignore.hbs

@@ -0,0 +1,4 @@
+target
+index.node
+**/node_modules
+**/.DS_Store

create-neon/data/templates/Cargo.toml.hbs

@@ -0,0 +1,22 @@
+[package]
+name = "{{project.name}}"
+version = "{{project.version}}"
+{{#if project.description}}
+description = {{project.description.quoted}}
+{{/if}}
+{{#if project.author}}
+authors = [{{project.author.quoted}}]
+{{/if}}
+{{#if project.license}}
+license = "{{project.license}}"
+{{/if}}
+edition = "2018"
+exclude = ["index.node"]
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies.neon]
+version = "{{versions.neon}}"
+default-features = false
+features = ["napi-{{versions.napi}}"]

create-neon/data/templates/README.md.hbs

@@ -0,0 +1,5 @@
+# {{project.name}}
+
+{{#if project.description}}
+{{project.description.raw}}
+{{/if}}

create-neon/data/templates/lib.rs.hbs

@@ -0,0 +1,11 @@
+use neon::prelude::*;
+
+fn hello(mut cx: FunctionContext) -> JsResult<JsString> {
+    Ok(cx.string("hello node"))
+}
+
+#[neon::main]
+fn main(mut cx: ModuleContext) -> NeonResult<()> {
+    cx.export_function("hello", hello)?;
+    Ok(())
+}

create-neon/data/versions.json

@@ -0,0 +1,5 @@
+{
+    "neon": "0.7",
+    "napi": "6",
+    "cargo-cp-artifact": "0.1"
+}

create-neon/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "create-neon",
+  "version": "0.1.0",
+  "description": "Create Neon projects with no build configuration.",
+  "author": "Dave Herman <david.herman@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/neon-bindings/neon/issues"
+  },
+  "homepage": "https://github.com/neon-bindings/neon#readme",
+  "bin": {
+    "create-neon": "dist/src/bin/create-neon.js"
+  },
+  "files": [
+    "dist/**/*"
+  ],
+  "scripts": {
+    "build": "tsc && cp -r data/templates dist/data",
+    "prepublishOnly": "npm run build",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "manual-test": "npm run build && rm -rf throwaway-test && mkdir throwaway-test && cd throwaway-test && node ../dist/src/bin/create-neon.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/neon-bindings/neon.git"
+  },
+  "keywords": [
+    "neon"
+  ],
+  "devDependencies": {
+    "@types/node": "^14.14.31",
+    "typescript": "^4.2.2"
+  },
+  "dependencies": {
+    "handlebars": "^4.7.7"
+  }
+}

create-neon/src/bin/create-neon.ts

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+
+import { mkdir } from 'fs/promises';
+import npmInit from '../npm-init';
+import versions from '../../data/versions.json';
+import { Project, Metadata } from '../metadata';
+import * as path from 'path';
+import Template from '../template';
+import die from '../die';
+
+async function main() {
+  await npmInit();
+
+  let project: Project;
+
+  try {
+    project = await Project.load('package.json', versions['cargo-cp-artifact']);
+  } catch (err) {
+    die("Could not read `package.json`: " + err.message);
+  }
+
+  try {
+    project.save('package.json');
+  } catch (err) {
+    die("Could not update `package.json`: " + err.message);
+  }
+
+  // Select the N-API version associated with the current
+  // running Node process.
+  let inferred = process.versions.napi;
+
+  let napi = inferred
+    ? Math.min(Number(versions.napi), Number(inferred))
+    : Number(versions.napi);
+
+  let metadata: Metadata = {
+    project,
+    versions: {
+      neon: versions.neon,
+      napi: napi
+    }
+  };
+
+  await mkdir('src');
+
+  let gitignore = new Template('.gitignore.hbs', '.gitignore');
+  let manifest = new Template('Cargo.toml.hbs', 'Cargo.toml');
+  let readme = new Template('README.md.hbs', 'README.md');
+  let lib = new Template('lib.rs.hbs', path.join('src', 'lib.rs'));
+
+  for (let template of [gitignore, manifest, readme, lib]) {
+    try {
+      await template.expand(metadata);
+    } catch (err) {
+      die(`Could not save ${template.target}: ${err.message}`);
+    }
+  }
+
+  console.log(`✨ Initialized Neon project \`${metadata.project.name}\`. Happy 🦀 hacking! ✨`);
+}
+
+main();

create-neon/src/die.ts

@@ -0,0 +1,4 @@
+export default function die(message: string): never {
+  console.error(`❌ ${message}`);
+  process.exit(1);
+}

create-neon/src/metadata.ts

@@ -0,0 +1,85 @@
+import { readFile, writeFile } from "fs/promises";
+
+export interface Metadata {
+  project: Project,
+  versions: Versions
+}
+
+export class Project {
+  private json: any;
+
+  name: string;
+  version: string;
+  author: FreeText | undefined;
+  license: string;
+  description: FreeText | undefined;
+
+  static async load(source: string, cargoCpArtifact: string): Promise<Project> {
+    return new Project(JSON.parse(await readFile(source, 'utf8')), cargoCpArtifact);
+  }
+
+  constructor(json: any, cargoCpArtifact: string) {
+    this.json = json;
+    this.name = json.name || "";
+    this.version = json.version || "";
+    this.author = quote(json.author);
+    this.license = json.license || "";
+    this.description = quote(json.description);
+
+    json.name = this.name;
+    json.version = this.version;
+    json.author = this.author?.raw;
+    json.license = this.license;
+    json.description = this.description?.raw;
+
+    json.main = "index.node";
+
+    let test = "cargo test";
+
+    // If the user specifies a non-default test command, use theirs instead.
+    // Ideally there would be better extensibility hooks in `npm init` for
+    // this but there aren't any environment variables or command-line flags
+    // we can use, so we have to guess based on the default value. This also
+    // unfortunately leaks to the user when `npm init` shows the values for
+    // the package.json it's going to use in the final user confirmation.
+    if (!/\s*echo \".*\" && exit 1\s*/.test(json.scripts.test)) {
+      test = json.scripts.test;
+    }
+
+    json.scripts = {
+      "build": "cargo-cp-artifact -nc index.node -- cargo build --message-format=json-render-diagnostics",
+      "install": "npm run build",
+      "test": test
+    };
+
+    json.devDependencies = {
+      "cargo-cp-artifact": `^${cargoCpArtifact}`
+    };
+  }
+
+  async save(target: string): Promise<null> {
+    await writeFile(target, JSON.stringify(this.json, undefined, 2))
+    return null;
+  }
+}
+
+export interface FreeText {
+  raw: string;
+  quoted: string;
+}
+
+function quote(text: string): FreeText | undefined {
+  if (!text) {
+    return undefined;
+  }
+
+  return {
+    raw: text,
+    quoted: JSON.stringify(text)
+  };
+}
+
+export interface Versions {
+  neon: string,
+  napi: number
+}

create-neon/src/npm-init.ts

@@ -0,0 +1,15 @@
+import shell from './shell';
+
+export default async function npmInit(): Promise<number> {
+  let code = await shell('npm', ['init']);
+
+  if (code == null) {
+    process.exit(1);
+  }
+
+  if (code !== 0) {
+    process.exit(code);
+  }
+
+  return 0;
+}

create-neon/src/shell.ts

@@ -0,0 +1,27 @@
+import { spawn } from 'child_process';
+
+/**
+ * Transparently shell out to an executable with a list of arguments.
+ * All stdio is inherited directly from the current process.
+ */
+export default function shell(cmd: string, args: string[]): Promise<number | null> {
+  let child = spawn(cmd, args, { stdio: 'inherit' });
+
+  let resolve: (result: number | null) => void;
+  let reject: (error: Error) => void;
+
+  let result: Promise<number | null> = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+
+  child.on('exit', (code) => {
+    resolve(code);
+  });
+
+  child.on('error', (error) => {
+    reject(error);
+  });
+
+  return result;
+}

create-neon/src/template.ts

@@ -0,0 +1,27 @@
+import { readFile, writeFile } from 'fs/promises';
+import handlebars, { TemplateDelegate } from 'handlebars';
+import * as path from 'path';
+import { Metadata } from './metadata';
+
+const TEMPLATES_DIR = path.join(__dirname, '..', 'data', 'templates');
+
+export default class Template {
+  source: string;
+  target: string;
+  private compiled: Promise<TemplateDelegate<Metadata>>;
+
+  constructor(source: string, target: string) {
+    this.source = source;
+    this.target = target;
+    this.compiled = readFile(path.join(TEMPLATES_DIR, source), {
+      encoding: 'utf8'
+    }).then(source => handlebars.compile(source, { noEscape: true }));
+  }
+
+  async expand(ctx: Metadata): Promise<null> {
+    let expanded = (await this.compiled)(ctx);
+    // The 'wx' flag creates the file but fails if it already exists.
+    await writeFile(this.target, expanded, { flag: 'wx' });
+    return null;
+  }
+}