@sdeverywhere/cli 0.7.39 → 0.7.40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdeverywhere/cli",
-  "version": "0.7.39",
+  "version": "0.7.40",
   "description": "Contains the `sde` command line interface for the SDEverywhere tool suite.",
   "type": "module",
   "files": [
@@ -11,8 +11,8 @@
     "sde": "src/main.js"
   },
   "dependencies": {
-    "@sdeverywhere/build": "^0.3.10",
-    "@sdeverywhere/compile": "^0.7.27",
+    "@sdeverywhere/build": "^0.3.11",
+    "@sdeverywhere/compile": "^0.7.28",
     "byline": "^5.0.0",
     "ramda": "^0.27.0",
     "shelljs": "^0.10.0",

package/src/sde-causes.js

@@ -18,11 +18,11 @@ let handler = argv => {
 }
 let causes = async (model, varname, opts) => {
   // Get the model name and directory from the model argument.
-  let { modelDirname, modelPathname, modelName } = modelPathProps(model)
+  let { modelDirname, modelPathname, modelName, modelKind } = modelPathProps(model)
   let spec = parseSpec(opts.spec)
   // Parse the model to get variable and subscript information.
   let input = readFileSync(modelPathname, 'utf8')
-  await parseAndGenerate(input, spec, ['printRefGraph'], modelDirname, modelName, '', varname)
+  await parseAndGenerate(input, modelKind, spec, ['printRefGraph'], modelDirname, modelName, '', varname)
 }
 export default {
   command,

package/src/sde-generate.js

@@ -57,7 +57,7 @@ export let handler = async argv => {
 
 export let generate = async (model, opts) => {
   // Get the model name and directory from the model argument.
-  let { modelDirname, modelName, modelPathname } = modelPathProps(model)
+  let { modelDirname, modelName, modelPathname, modelKind } = modelPathProps(model)
   // Ensure the build directory exists.
   let buildDirname = buildDir(opts.builddir, modelDirname)
   let spec = parseSpec(opts.spec)
@@ -87,7 +87,7 @@ export let generate = async (model, opts) => {
   if (opts.refidtest) {
     operations.push('printRefIdTest')
   }
-  await parseAndGenerate(mdlContent, spec, operations, modelDirname, modelName, buildDirname)
+  await parseAndGenerate(mdlContent, modelKind, spec, operations, modelDirname, modelName, buildDirname)
 }
 
 export default {

package/src/sde-names.js

@@ -26,11 +26,11 @@ let handler = argv => {
 }
 let names = async (model, namesPathname, opts) => {
   // Get the model name and directory from the model argument.
-  let { modelDirname, modelPathname, modelName } = modelPathProps(model)
+  let { modelDirname, modelPathname, modelName, modelKind } = modelPathProps(model)
   let spec = parseSpec(opts.spec)
   // Parse the model to get variable and subscript information.
   let input = readFileSync(modelPathname, 'utf8')
-  await parseAndGenerate(input, spec, ['convertNames'], modelDirname, modelName, '')
+  await parseAndGenerate(input, modelKind, spec, ['convertNames'], modelDirname, modelName, '')
   // Read each variable name from the names file and convert it.
   printNames(namesPathname, opts.toc ? 'to-c' : 'to-vensim')
 }

package/src/sde-test.js

@@ -18,6 +18,10 @@ export let builder = {
     choices: ['js', 'c'],
     default: 'js'
   },
+  tooldat: {
+    describe: 'pathname of the tool DAT file to compare to SDE output',
+    type: 'string'
+  },
   builddir: {
     describe: 'build directory',
     type: 'string',
@@ -53,12 +57,19 @@ export let test = async (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 toolDatPathname
+    if (opts.tooldat) {
+      // Use the provided DAT file for comparison
+      toolDatPathname = opts.tooldat
+    } else {
+      // Assume there is a DAT file created by the modeling tool named {modelName}.dat
+      // in the model directory
+      toolDatPathname = path.join(modelDirname, `${modelName}.dat`)
+    }
     let p = path.parse(logPathname)
-    let sdePathname = path.format({ dir: p.dir, name: p.name, ext: '.dat' })
-    let noDiffs = await compare(vensimPathname, sdePathname, opts)
+    let sdeDatPathname = path.format({ dir: p.dir, name: p.name, ext: '.dat' })
+    // Compare SDE-generated DAT file to the tool-generated DAT file
+    let noDiffs = await compare(toolDatPathname, sdeDatPathname, opts)
     if (!noDiffs) {
       // Exit with a non-zero error code if differences were detected
       console.error()

package/src/utils.js

@@ -25,25 +25,45 @@ export function execCmd(cmd) {
 }
 
 /**
- * Normalize a model pathname that may or may not include the .mdl extension.
+ * Normalize a model pathname that may or may not include the .mdl or .xmile/.stmx/.itmx extension.
+ * If the pathname does not end with .mdl, .xmile, .stmx, or .itmx, this will attempt to find a
+ * file with one of those extensions.
  * 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'
+ *   modelKind: 'vensim'
  *
  * @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)))
+  const parsedPath = path.parse(model)
+  if (parsedPath.ext === '') {
+    const exts = ['.mdl', '.xmile', '.stmx', '.itmx']
+    const paths = exts.map(ext => path.join(parsedPath.dir, parsedPath.name + ext))
+    const existingPaths = paths.filter(path => fs.existsSync(path))
+    if (existingPaths.length > 1) {
+      throw new Error(
+        `Found multiple files that match '${model}'; please specify a file with a .mdl, .xmile, .stmx, or .itmx extension`
+      )
+    }
+    if (existingPaths.length === 0) {
+      throw new Error(`No {mdl,xmile,stmx,itmx} file found for ${model}`)
+    }
+    parsedPath.ext = path.extname(existingPaths[0])
+  }
+  let p = R.merge({ ext: parsedPath.ext }, R.pick(['dir', 'name'], parsedPath))
   if (R.isEmpty(p.dir)) {
     p.dir = process.cwd()
   }
   return {
     modelDirname: p.dir,
     modelName: p.name,
-    modelPathname: path.format(p)
+    modelPathname: path.format(p),
+    modelKind: p.ext === '.mdl' ? 'vensim' : 'xmile'
   }
 }