@sdeverywhere/cli 0.7.0

package/src/sde-log.js

@@ -0,0 +1,104 @@
+import fs from 'fs'
+import path from 'path'
+
+import B from 'bufx'
+import byline from 'byline'
+import R from 'ramda'
+
+import { canonicalName } from '@sdeverywhere/compile'
+
+export let command = 'log [options] <logfile>'
+export let describe = 'process an SDEverywhere log file'
+export let builder = {
+  dat: {
+    describe: 'convert a TSV log file to a Vensim DAT file',
+    type: 'boolean',
+    alias: 'd'
+  }
+}
+export let handler = argv => {
+  log(argv.logfile, argv)
+}
+export let log = async (logPathname, opts) => {
+  if (opts.dat) {
+    let p = path.parse(logPathname)
+    let datPathname = path.format({ dir: p.dir, name: p.name, ext: '.dat' })
+    await exportDat(logPathname, datPathname)
+  }
+}
+let exportDat = async (logPathname, datPathname) => {
+  // Vensim var names found in the log file
+  let varNames = {}
+  // Vensim var names in canonical format serving as data keys
+  let varKeys = []
+  // Values at each time step
+  let steps = []
+
+  let readLog = async () => {
+    return new Promise(resolve => {
+      // Accumulate var values at each time step.
+      let stream = byline(fs.createReadStream(logPathname, 'utf8'))
+      stream.on('data', line => {
+        if (R.isEmpty(varNames)) {
+          // Turn the var names in the header line into acceptable keys in canonical format.
+          let header = line.split('\t')
+          varKeys = R.map(v => canonicalName(v), header)
+          varNames = R.zipObj(varKeys, header)
+        } else if (!R.isEmpty(line)) {
+          // Add an object with values at this time step.
+          steps.push(R.zipObj(varKeys, line.split('\t')))
+        }
+      })
+      stream.on('end', () => {
+        resolve()
+      })
+    })
+  }
+  let writeDat = async () => {
+    // Emit all time step values for each log var  as (time, value) pairs.
+    let stream = fs.createWriteStream(datPathname, 'utf8')
+    let iVarKey = 0
+    let finished = () => {}
+    stream.on('finish', () => {
+      // Resolve the promise after `stream.end()` has been called and all data has been flushed
+      // to the output file
+      finished()
+    })
+    let writeContinuation = () => {
+      while (iVarKey < varKeys.length) {
+        let varKey = varKeys[iVarKey++]
+        if (varKey !== '_time') {
+          B.clearBuf()
+          B.emitLine(varNames[varKey])
+          for (let step of steps) {
+            B.emitLine(`${step['_time']}\t${step[varKey]}`)
+          }
+          let status = stream.write(B.getBuf())
+          // Handle backpressure by waiting for the drain event to continue when the write buffer is congested.
+          if (!status) {
+            stream.once('drain', writeContinuation)
+            return
+          }
+        }
+      }
+      // End the stream after the last line is emitted; this will trigger a `finish` event after
+      // all data has been flushed to the output file
+      stream.end()
+    }
+    return new Promise(resolve => {
+      // Start the write on the next event loop tick so we can return immediately.
+      process.nextTick(writeContinuation)
+      // Hold on to the resolve function to call when we are finished.
+      finished = resolve
+    })
+  }
+  await readLog()
+  await writeDat()
+}
+export default {
+  command,
+  describe,
+  builder,
+  handler,
+  log
+}

package/src/sde-names.js

@@ -0,0 +1,41 @@
+import { parseAndGenerate, preprocessModel, printNames } from '@sdeverywhere/compile'
+
+import { modelPathProps, parseSpec } from './utils.js'
+
+let command = 'names [options] <model> <namesfile>'
+let describe = 'convert variable names in a model'
+let builder = {
+  toc: {
+    describe: 'convert a file with Vensim variable names to C names',
+    type: 'boolean'
+  },
+  tovml: {
+    describe: 'convert a file with C variable names to Vensim names',
+    type: 'boolean'
+  },
+  spec: {
+    describe: 'pathname of the I/O specification JSON file',
+    type: 'string',
+    alias: 's'
+  }
+}
+let handler = argv => {
+  names(argv.model, argv.namesfile, argv)
+}
+let names = async (model, namesPathname, opts) => {
+  // Get the model name and directory from the model argument.
+  let { modelDirname, modelPathname, modelName } = modelPathProps(model)
+  let spec = parseSpec(opts.spec)
+  // Preprocess model text into parser input.
+  let input = preprocessModel(modelPathname, spec)
+  // Parse the model to get variable and subscript information.
+  await parseAndGenerate(input, spec, 'convertNames', modelDirname, modelName, '')
+  // Read each variable name from the names file and convert it.
+  printNames(namesPathname, opts.toc ? 'to-c' : 'to-vensim')
+}
+export default {
+  command,
+  describe,
+  builder,
+  handler
+}

package/src/sde-run.js

@@ -0,0 +1,37 @@
+import { build } from './sde-build.js'
+import { exec } from './sde-exec.js'
+
+export let command = 'run [options] <model>'
+export let describe = 'build a model, run it, and capture its output to a file'
+export let builder = {
+  spec: {
+    describe: 'pathname of the I/O specification JSON file',
+    type: 'string',
+    alias: 's'
+  },
+  builddir: {
+    describe: 'build directory',
+    type: 'string',
+    alias: 'b'
+  },
+  outfile: {
+    describe: 'output pathname',
+    type: 'string',
+    alias: 'o'
+  }
+}
+export let handler = argv => {
+  run(argv.model, argv)
+}
+export let run = async (model, opts) => {
+  await build(model, opts)
+  exec(model, opts)
+}
+
+export default {
+  command,
+  describe,
+  builder,
+  handler,
+  run
+}

package/src/sde-test.js

@@ -0,0 +1,70 @@
+import path from 'path'
+
+import { run } from './sde-run.js'
+import { log } from './sde-log.js'
+import { compare } from './sde-compare.js'
+import { modelPathProps, outputDir } from './utils.js'
+
+export let command = 'test [options] <model>'
+export let describe = 'build the model, run it, process the log, and compare to Vensim data'
+export let builder = {
+  spec: {
+    describe: 'pathname of the I/O specification JSON file',
+    type: 'string',
+    alias: 's'
+  },
+  builddir: {
+    describe: 'build directory',
+    type: 'string',
+    alias: 'b'
+  },
+  outfile: {
+    describe: 'output pathname',
+    type: 'string',
+    alias: 'o'
+  },
+  precision: {
+    describe: 'precision to which values must agree (default 1e-5)',
+    type: 'number',
+    alias: 'p'
+  }
+}
+export let handler = argv => {
+  test(argv.model, argv)
+}
+export let test = async (model, opts) => {
+  try {
+    // Run the model and save output to an SDE log file.
+    let { modelDirname, modelName } = modelPathProps(model)
+    let logPathname
+    if (opts.outfile) {
+      logPathname = opts.outfile
+    } else {
+      let outputDirname = outputDir(opts.outfile, modelDirname)
+      logPathname = path.join(outputDirname, `${modelName}.txt`)
+      opts.outfile = logPathname
+    }
+    await run(model, opts)
+    // Convert the TSV log file to a DAT file in the same directory.
+    opts.dat = true
+    await log(logPathname, opts)
+    // Assume there is a Vensim-created DAT file named {modelName}.dat in the model directory.
+    // Compare it to the SDE DAT file.
+    let vensimPathname = path.join(modelDirname, `${modelName}.dat`)
+    let p = path.parse(logPathname)
+    let sdePathname = path.format({ dir: p.dir, name: p.name, ext: '.dat' })
+    await compare(vensimPathname, sdePathname, opts)
+  } catch (e) {
+    // Exit with a non-zero error code if any step failed
+    console.error(`ERROR: ${e.message}\n`)
+    process.exit(1)
+  }
+}
+
+export default {
+  command,
+  describe,
+  builder,
+  handler,
+  test
+}

package/src/sde-which.js

@@ -0,0 +1,20 @@
+import path from 'path'
+
+let command = 'which'
+let describe = 'print the SDEverywhere home directory'
+let builder = {}
+let handler = argv => {
+  which(argv)
+}
+let which = () => {
+  // The SDEverywhere home directory is one level above the src directory where this code runs.
+  let homeDir = path.resolve(new URL('..', import.meta.url).pathname)
+  console.log(homeDir)
+}
+export default {
+  command,
+  describe,
+  builder,
+  handler,
+  which
+}

package/src/utils.js

@@ -0,0 +1,103 @@
+import fs from 'fs'
+import path from 'path'
+
+import B from 'bufx'
+import R from 'ramda'
+import sh from 'shelljs'
+
+import { canonicalName } from '@sdeverywhere/compile'
+
+/**
+ * Run a command line silently in the "sh" shell. Print error output on error.
+ *
+ * @return The exit code of the exec'd process.
+ */
+export function execCmd(cmd) {
+  let exitCode = 0
+  let result = sh.exec(cmd, { silent: true })
+  if (result.code !== 0) {
+    console.error(result.stderr)
+    exitCode = result.code
+  }
+  return exitCode
+}
+
+/**
+ * Normalize a model pathname that may or may not include the .mdl extension.
+ * If there is not a path in the model argument, default to the current working directory.
+ * Return an object with properties that look like this:
+ *   modelDirname: '/Users/todd/src/models/arrays'
+ *   modelName: 'arrays'
+ *   modelPathname: '/Users/todd/src/models/arrays/arrays.mdl'
+ *
+ * @param model A path to a Vensim model file.
+ * @return An object with the properties specified above.
+ */
+export function modelPathProps(model) {
+  let p = R.merge({ ext: '.mdl' }, R.pick(['dir', 'name'], path.parse(model)))
+  if (R.isEmpty(p.dir)) {
+    p.dir = process.cwd()
+  }
+  return {
+    modelDirname: p.dir,
+    modelName: p.name,
+    modelPathname: path.format(p)
+  }
+}
+
+/**
+ * Read and parse a model spec JSON file.
+ *
+ * @param specFilename The name of the model spec JSON file, relative to the
+ * current working directory.
+ * @return An object containing the model spec properties, or an empty object if
+ * the spec file does not exist.
+ */
+export function parseSpec(specFilename) {
+  // Parse the JSON file if it exists.
+  let spec = {}
+  try {
+    let json = B.read(specFilename)
+    spec = JSON.parse(json)
+  } catch (ex) {
+    // If the file doesn't exist, use an empty object without complaining.
+    // TODO: This needs to be fixed to fail fast instead of staying silent
+  }
+
+  // Translate dimension families in the spec to canonical form.
+  if (spec.dimensionFamilies) {
+    let f = {}
+    for (let dimName in spec.dimensionFamilies) {
+      let family = spec.dimensionFamilies[dimName]
+      f[canonicalName(dimName)] = canonicalName(family)
+    }
+    spec.dimensionFamilies = f
+  }
+
+  return spec
+}
+
+export function outputDir(outfile, modelDirname) {
+  if (outfile) {
+    outfile = path.dirname(outfile)
+  }
+  return ensureDir(outfile, 'output', modelDirname)
+}
+
+/**
+ * Ensure the given build directory or {modelDir}/build exists.
+ */
+export function buildDir(build, modelDirname) {
+  return ensureDir(build, 'build', modelDirname)
+}
+
+/**
+ * Ensure the directory exists as given or under the model directory.
+ */
+function ensureDir(dir, defaultDir, modelDirname) {
+  let dirName = dir || path.join(modelDirname, defaultDir)
+  if (!fs.existsSync(dirName)) {
+    fs.mkdirSync(dirName, { recursive: true })
+  }
+  return dirName
+}