occam-verify-cli 0.0.262

package/bin/type.js

@@ -0,0 +1,120 @@
+"use strict";
+
+class Type {
+  constructor(name, superType) {
+    this.name = name;
+    this.superType = superType;
+  }
+
+  getName() {
+    return this.name;
+  }
+
+  getSuperType() {
+    return this.superType;
+  }
+
+  isEqualTo(type) {
+    const equalToType = (this === type);
+
+    return equalToType;
+  }
+
+  isSubTypeOf(type) {
+    let subTypeOfType = false;
+
+    if (this.superType === type) {
+      subTypeOfType = true;
+    } else {
+      if (this.superType !== null) {
+        subTypeOfType = this.superType.isSubTypeOf(type);
+      }
+    }
+
+    return subTypeOfType;
+  }
+
+  isSuperTypeOf(type) {
+    let superTypeOfType = false;
+
+    const superType = type.getSuperType();
+
+    if (superType === this) {
+      superTypeOfType = true;
+    } else {
+      if (superType !== null) {
+        superTypeOfType = superType.isSuperTypeOf(this);
+      }
+    }
+
+    return superTypeOfType;
+  }
+
+  isEqualToOrSubTypeOf(type) {
+    const equalToType = this.isEqualTo(type),
+          subTypeOfType = this.isSubTypeOf(type),
+          equalToTypeOrSubTypeOf = (equalToType || subTypeOfType);
+
+    return equalToTypeOrSubTypeOf;
+  }
+
+  isEqualToOrSuperTypeOf(type) {
+    const equalToType = this.isEqualTo(type),
+          superTypeOfType = this.isSuperTypeOf(type),
+          equalToTypeOrSuperTypeOf = (equalToType || superTypeOfType);
+
+    return equalToTypeOrSuperTypeOf;
+  }
+
+  isEqualToSubTypeOfOrSuperTypeOf(type) {
+    const equalToType = this.isEqualTo(type),
+          subTypeOfType = this.isSubTypeOf(type),
+          superTypeOfType = this.isSuperTypeOf(type),
+          equalToTypeSubTypeOfOrSuperTypeOf = (equalToType || subTypeOfType || superTypeOfType);
+
+    return equalToTypeSubTypeOfOrSuperTypeOf;
+  }
+
+  matchName(name) {
+    const matchesName = (this.name === name);
+
+    return matchesName;
+  }
+
+  matchTypeName(typeName) {
+    const matchesTypeName = (this.name === typeName);
+
+    return matchesTypeName;
+  }
+
+  asString(noSuperType = (this.superType === null)) {
+    let string;
+
+    if (noSuperType) {
+      string = `${this.name}`;
+    } else {
+      const superTypeName = this.superType.getName();
+
+      string = `${this.name}:${superTypeName}`;
+    }
+
+    return string;
+  }
+
+  static fromTypeName(typeName) {
+    const name = typeName,  ///
+          superType = null,
+          type = new Type(name, superType);
+
+    return type;
+  }
+
+  static fromTypeNameAndSuperType(typeName, superType) {
+    const name = typeName,  ///
+          type = new Type(name, superType);
+
+    return type;
+  }
+}
+
+module.exports = Type;

package/bin/utilities/array.js

@@ -0,0 +1,97 @@
+"use strict";
+
+const { arrayUtilities } = require("necessary");
+
+const { push, prune, first, second, filter } = arrayUtilities;
+
+function leftDifference(arrayA, arrayB) {
+  filter(arrayA, (elementA) => {
+    const arrayBIncludesElementA = arrayB.includes(elementA);
+
+    if (!arrayBIncludesElementA) {
+      return true;
+    }
+  });
+}
+
+function someCombination(array, callback) {
+  const combinations = combinationsFromArray(array),
+        found = combinations.some((combination) => {
+          const array = combination,  ///
+                passed = callback(array);
+
+          if (passed) {
+            return true;
+          }
+        });
+
+  return found;
+}
+
+module.exports = {
+  push,
+  prune,
+  first,
+  second,
+  filter,
+  leftDifference,
+  someCombination
+};
+
+function combinationsFromArray(array) {
+  const arrayLength = array.length,
+        indexCombinations = indexCombinationsFromArrayLength(arrayLength),
+        combinations = indexCombinations.map((indexCombination) => {
+          const elements = [];
+
+          for (let position = 0; position < arrayLength; position++) {
+            const index = indexCombination[position],
+                  element = array[index];
+
+            elements.push(element);
+          }
+
+          const combination = elements; ///
+
+          return combination;
+        });
+
+  return combinations;
+}
+
+function indexCombinationsFromArrayLength(arrayLength) {
+  let indexCombinations;
+
+  if (arrayLength === 0) {
+    indexCombinations = [];
+  } else if (arrayLength === 1) {
+    const indexCombination = [
+      0
+    ];
+
+    indexCombinations = [
+      indexCombination
+    ];
+  } else {
+    const innerArrayLength = arrayLength - 1,
+          innerIndexCombinations = indexCombinationsFromArrayLength(innerArrayLength);
+
+    indexCombinations = [];
+
+    innerIndexCombinations.forEach((innerIndexCombination) => {
+      const outerIndex = innerArrayLength;  ///
+
+      for (let position = innerArrayLength; position >= 0; position--) {
+        const indexCombination = innerIndexCombination.slice(),
+              start = position, ///
+              deleteCount = 0;
+
+        indexCombination.splice(start, deleteCount, outerIndex);
+
+        indexCombinations.push(indexCombination);
+      }
+    });
+  }
+
+  return indexCombinations;
+}

package/bin/utilities/fileSystem.js

@@ -0,0 +1,97 @@
+"use strict";
+
+const fs = require("fs");
+
+const { Query } = require("occam-dom"),
+      { filePathUtilities } = require("occam-open-cli"),
+      { fileSystemUtilities } = require("necessary"),
+      { MetaJSONLexer, MetaJSONParser } = require("occam-grammars");
+
+const { isFilePathFlorenceFilePath } = filePathUtilities,
+      { readFile, isEntryFile, isEntryDirectory, checkFileExists } = fileSystemUtilities;
+
+const metaJSONLexer = MetaJSONLexer.fromNothing(),
+      metaJSONParser = MetaJSONParser.fromNothing(),
+      dependencyStringLiteralNodesQuery = Query.fromExpression("//dependency//@string-literal");
+
+function filePathsFromPackageName(packageName) {
+  const directoryName = packageName,  ///
+        filePaths = readFilePaths(directoryName, (filePath) => {
+          const filePathFlorenceFilePath = isFilePathFlorenceFilePath(filePath);
+
+          if (filePathFlorenceFilePath) {
+            return true;
+          }
+        });
+
+  return filePaths;
+}
+
+function dependencyPackageNamesFromPackageName(packageName) {
+  let dependencyPackageNames = [];
+
+  const directoryName = packageName,  ///
+        metaJSONFilePath = `${directoryName}/meta.json`,
+        metaJSONFileExists = checkFileExists(metaJSONFilePath);
+
+  if (metaJSONFileExists) {
+    const metaJSONFileContent = readFile(metaJSONFilePath),
+          content = metaJSONFileContent,  ///
+          tokens = metaJSONLexer.tokenise(content),
+          node = metaJSONParser.parse(tokens),
+          dependencyStringLiteralNodes = dependencyStringLiteralNodesQuery.execute(node);
+
+    dependencyPackageNames = dependencyStringLiteralNodes.map((dependencyStringLiteralNode) => {
+      const dependencyStringLiteralNodeContent = dependencyStringLiteralNode.getContent(),
+            dependencyPackageName = trimDoubleQuotes(dependencyStringLiteralNodeContent); ///
+
+      return dependencyPackageName;
+    });
+  }
+
+  return dependencyPackageNames;
+}
+
+module.exports = {
+  filePathsFromPackageName,
+  dependencyPackageNamesFromPackageName
+};
+
+function trimDoubleQuotes(content) { return content.replace(/(^"|"$)/g, ""); } ///
+
+function readFilePaths(directoryPath, test, filePaths = []) {
+  const subEntryNames = fs.readdirSync(directoryPath);
+
+  subEntryNames.forEach((subEntryName) => {
+    const subEntryNameHiddenName = isNameHiddenName(subEntryName);
+
+    if (!subEntryNameHiddenName) {
+      const subEntryPath = `${directoryPath}/${subEntryName}`,
+            subEntryFile = isEntryFile(subEntryPath),
+            subEntryDirectory = isEntryDirectory(subEntryPath);
+
+      if (subEntryFile) {
+        const filePath = subEntryPath,  ///
+              pass = test(filePath);
+
+        if (pass) {
+          filePaths.push(filePath);
+        }
+      }
+
+      if (subEntryDirectory) {
+        const subDirectoryPath = subEntryPath;  ///
+
+        readFilePaths(subDirectoryPath, test, filePaths);
+      }
+    }
+  });
+
+  return filePaths;
+}
+
+function isNameHiddenName(name) {
+  const nameHiddenName = /^\..+/.test(name);
+
+  return nameHiddenName;
+}

package/bin/utilities/query.js

@@ -0,0 +1,92 @@
+"use strict";
+
+const { Query } = require("occam-dom");
+
+const typeTerminalNodeQuery = nodeQuery("/type/@type"),
+      labelNameTerminalNodeQuery = nodeQuery("/label/@name"),
+      variableNameTerminalNodeQuery = nodeQuery("/variable/@name"),
+      referenceNameTerminalNodeQuery = nodeQuery("/reference/@name"),
+      metavariableNameTerminalNodeQuery = nodeQuery("/metavariable/@name");
+
+function nodeQuery(expression) {
+  const query = Query.fromExpression(expression);
+
+  return function(node) {
+    if (node !== null) {
+      const nodes = query.execute(node);
+
+      node = nodes.shift() || null; ///
+    }
+
+    return node;
+  };
+}
+
+function nodesQuery(expression) {
+  const query = Query.fromExpression(expression);
+
+  return function(node) {
+    let nodes = null;
+
+    if (node !== null) {
+      nodes = query.execute(node);
+    }
+
+    return nodes;
+  };
+}
+
+function typeNameFromTypeNode(typeNode) {
+  let typeName = null;
+
+  if (typeNode !== null) {
+    const typeTerminalNode = typeTerminalNodeQuery(typeNode),
+          typeTerminalNodeContent = typeTerminalNode.getContent();
+
+    typeName = typeTerminalNodeContent; ///
+  }
+
+  return typeName;
+}
+
+function labelNameFromLabelNode(labelNode) {
+  const labelNameTerminalNode = labelNameTerminalNodeQuery(labelNode),
+        labelNameTerminalNodeContent = labelNameTerminalNode.getContent(),
+        labelName = labelNameTerminalNodeContent; ///
+
+  return labelName;
+}
+
+function variableNameFromVariableNode(variableNode) {
+  const variableNameTerminalNode = variableNameTerminalNodeQuery(variableNode),
+        variableNameTerminalNodeContent = variableNameTerminalNode.getContent(),
+        variableName = variableNameTerminalNodeContent; ///
+
+  return variableName;
+}
+
+function referenceNameFromReferenceNode(referenceNode) {
+  const referenceNameTerminalNode = referenceNameTerminalNodeQuery(referenceNode),
+        referenceNameTerminalNodeContent = referenceNameTerminalNode.getContent(),
+        referenceName = referenceNameTerminalNodeContent; ///
+
+  return referenceName;
+}
+
+function metavariableNameFromMetavariableNode(metavariableNode) {
+  const metavariableNameTerminalNode = metavariableNameTerminalNodeQuery(metavariableNode),
+        metavariableNameTerminalNodeContent = metavariableNameTerminalNode.getContent(),
+        metavariableName = metavariableNameTerminalNodeContent; ///
+
+  return metavariableName;
+}
+
+module.exports = {
+  nodeQuery,
+  nodesQuery,
+  typeNameFromTypeNode,
+  labelNameFromLabelNode,
+  variableNameFromVariableNode,
+  referenceNameFromReferenceNode,
+  metavariableNameFromMetavariableNode
+};

package/bin/utilities/rule.js

@@ -0,0 +1,279 @@
+"use strict";
+
+const MetaSubstitution = require("../metaSubstitution");
+
+const { nodeAsString } = require("../utilities/string"),
+      { prune, someCombination } = require("../utilities/array"),
+      { METAVARIABLE_RULE_NAME } = require("../ruleNames"),
+      { metavariableNameFromMetavariableNode } = require("../utilities/query");
+
+function matchRule(rule, metastatementNode, context) {
+  let metastatementNodes = context.getMetastatementNodes();
+
+  const premiseMetastatementNodes = rule.getPremiseMetastatementNodes(),
+        conclusionMetastatementNode = rule.getConclusionMetastatementNode(),
+        premiseMetastatementNodesLength = premiseMetastatementNodes.length,
+        start = -premiseMetastatementNodesLength;
+
+  metastatementNodes = metastatementNodes.slice(start); ///
+
+  const ruleMatches = someCombination(metastatementNodes, (metastatementNodes) => {
+    const premisesMatchConclusion = matchPremisesAndConclusion(premiseMetastatementNodes, conclusionMetastatementNode, metastatementNodes, metastatementNode, context);
+
+    if (premisesMatchConclusion) {
+      return true;
+    }
+  });
+
+  return ruleMatches;
+}
+
+module.exports = {
+  matchRule
+};
+
+function matchPremisesAndConclusion(premiseMetastatementNodes, conclusionMetastatementNode, metastatementNodes, metastatementNode, context) {
+  let premisesMatchConclusion = false;
+
+  const metaSubstitutions = [],
+        premisesMatch = matchPremises(premiseMetastatementNodes, metastatementNodes, metaSubstitutions, context);
+
+  if (premisesMatch) {
+    const conclusionNonTerminalNode = matchConclusion(conclusionMetastatementNode, metaSubstitutions), ///
+          conclusionMetastatementString = nodeAsString(conclusionNonTerminalNode),
+          metastatementString = nodeAsString(metastatementNode);
+
+    premisesMatchConclusion = (metastatementString === conclusionMetastatementString);
+  }
+
+  return premisesMatchConclusion;
+}
+
+function matchPremises(premiseMetastatementNodes, metastatementNodes, metaSubstitutions) {
+  const premisesMatches = premiseMetastatementNodes.every((premiseMetastatementNode) => {
+    const premiseMatches = matchPremise(premiseMetastatementNode, metastatementNodes, metaSubstitutions);
+
+    if (premiseMatches) {
+      return true;
+    }
+  });
+
+  return premisesMatches;
+}
+
+function matchPremise(premiseMetastatementNode, metastatementNodes, metaSubstitutions) {
+  const metastatementNode = prune(metastatementNodes, (metastatementNode) => {
+    const nonTerminalNode = metastatementNode,  ///
+          premiseNonTerminalNode = premiseMetastatementNode,  ///
+          premiseNonTerminalNodeMatches = matchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions);
+
+    if (!premiseNonTerminalNodeMatches) {
+      return true;
+    }
+  }) || null;
+
+  const premiseMatches = (metastatementNode !== null);
+
+  return premiseMatches;
+}
+
+function matchPremiseNode(premiseNode, node, metaSubstitutions) {
+  let premiseNodeMatches = false;
+
+  const nodeTerminalNode = node.isTerminalNode(),
+        ruleNodeTerminalNode = premiseNode.isTerminalNode();
+
+  if (nodeTerminalNode === ruleNodeTerminalNode) {
+    if (nodeTerminalNode) {
+      const terminalNode = node,  ///
+            premiseTerminalNode = premiseNode,  ///
+            premiseTerminalNodeMatches = matchPremiseTerminalNode(premiseTerminalNode, terminalNode, metaSubstitutions);
+
+      premiseNodeMatches = premiseTerminalNodeMatches;  ///
+    } else {
+      const nonTerminalNode = node, ///
+            premiseNonTerminalNode = premiseNode,  ///
+            premiseNonTerminalNodeMatches = matchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions);
+
+      premiseNodeMatches = premiseNonTerminalNodeMatches; ///
+    }
+  }
+
+  return premiseNodeMatches;
+}
+
+function matchPremiseChildNodes(premiseChildNodes, childNodes, metaSubstitutions) {
+  let premiseChildNodesMatches = false;
+
+  const childNodesLength = childNodes.length,
+        premiseChildNodesLength = premiseChildNodes.length;
+
+  if (childNodesLength === premiseChildNodesLength) {
+    premiseChildNodesMatches = childNodes.every((childNode, index) => {
+      const premiseChildNode = premiseChildNodes[index],
+            premiseNode = premiseChildNode, ///
+            node = childNode, ///
+            premiseNodeMatches = matchPremiseNode(premiseNode, node, metaSubstitutions);
+
+      if (premiseNodeMatches) {
+        return true;
+      }
+    })
+  }
+
+  return premiseChildNodesMatches;
+}
+
+function matchPremiseMetavariable(premiseMetavariableNode, nonTerminalNode, metaSubstitutions) {
+  let premiseMetavariableMatches = false;
+
+  const premiseMetavariableName = metavariableNameFromMetavariableNode(premiseMetavariableNode),
+        nonTerminalString = nodeAsString(nonTerminalNode),
+        metaSubstitution = metaSubstitutions.find((metaSubstitution) => {
+          const metavariableName = metaSubstitution.getMetavariableName();
+
+          if (metavariableName === premiseMetavariableName) {
+            return true;
+          }
+        }) || null;
+
+  if (metaSubstitution !== null) {
+    const metaSubstitutionNonTerminalNode = metaSubstitution.getNonTerminalNode(),
+          metaSubstitutionNonTerminalString = nodeAsString(metaSubstitutionNonTerminalNode);
+
+    if (nonTerminalString === metaSubstitutionNonTerminalString) {
+      premiseMetavariableMatches = true;
+    }
+  } else {
+    const metavariableName = premiseMetavariableName, ///
+          metaSubstitution = MetaSubstitution.fromMetavariableNameAndNonTerminalNode(metavariableName, nonTerminalNode);
+
+    metaSubstitutions.push(metaSubstitution);
+
+    premiseMetavariableMatches = true;
+  }
+
+  return premiseMetavariableMatches;
+}
+
+function matchPremiseTerminalNode(premiseTerminalNode, terminalNode, metaSubstitutions) {
+  let premiseTerminalNodeMatches = false;
+
+  const matches = premiseTerminalNode.match(terminalNode);
+
+  if (matches) {
+    premiseTerminalNodeMatches = true;
+  }
+
+  return premiseTerminalNodeMatches;
+}
+
+function matchPremiseNonTerminalNode(premiseNonTerminalNode, nonTerminalNode, metaSubstitutions) {
+  let premiseNonTerminalNodeMatches = false;
+
+  const premiseRuleName = premiseNonTerminalNode.getRuleName(); ///
+
+  switch (premiseRuleName) {
+    case METAVARIABLE_RULE_NAME: {
+      const premiseMetavariableNode = premiseNonTerminalNode, ///
+            premiseMetavariableMatches = matchPremiseMetavariable(premiseMetavariableNode, nonTerminalNode, metaSubstitutions);
+
+      premiseNonTerminalNodeMatches = premiseMetavariableMatches;
+
+      break;
+    }
+
+    default: {
+      const ruleName = nonTerminalNode.getRuleName();
+
+      if (ruleName === premiseRuleName) {
+        const childNodes = nonTerminalNode.getChildNodes(),
+              premiseChildNodes = premiseNonTerminalNode.getChildNodes(),
+              premiseChildNodesMatches = matchPremiseChildNodes(premiseChildNodes, childNodes, metaSubstitutions);
+
+        premiseNonTerminalNodeMatches = premiseChildNodesMatches; ///
+      }
+    }
+  }
+
+  return premiseNonTerminalNodeMatches;
+}
+
+function matchConclusion(conclusionMetastatementNode, metaSubstitutions) {
+  let conclusionNonTerminalNode = conclusionMetastatementNode;  ///
+
+  conclusionNonTerminalNode = conclusionNonTerminalNode.clone();
+
+  conclusionNonTerminalNode = matchConclusionNonTerminalNode(conclusionNonTerminalNode, metaSubstitutions);
+
+  return conclusionNonTerminalNode;
+}
+
+function matchConclusionNode(conclusionNode, metaSubstitutions) {
+  const conclusionNodeNonTerminalNode = conclusionNode.isNonTerminalNode();
+
+  if (conclusionNodeNonTerminalNode) {
+    let conclusionNonTerminalNode = conclusionNode; ///
+
+    conclusionNonTerminalNode = matchConclusionNonTerminalNode(conclusionNonTerminalNode, metaSubstitutions);
+
+    conclusionNode = conclusionNonTerminalNode; ///
+  }
+
+  return conclusionNode;
+}
+
+function matchConclusionChildNodes(conclusionChildNodes, metaSubstitutions) {
+  conclusionChildNodes = conclusionChildNodes.map((conclusionChildNode) => {
+    let conclusionNode = conclusionChildNode; ///
+
+    conclusionNode = matchConclusionNode(conclusionNode, metaSubstitutions);
+
+    conclusionChildNode = conclusionNode; ///
+
+    return conclusionChildNode;
+  });
+
+  return conclusionChildNodes;
+}
+
+function matchConclusionNonTerminalNode(conclusinNonTerminalNode, metaSubstitutions) {
+  const ruleName = conclusinNonTerminalNode.getRuleName();
+
+  if (ruleName === METAVARIABLE_RULE_NAME) {
+    let conclusionMetaVariableNode = conclusinNonTerminalNode; ///
+
+    conclusinNonTerminalNode = matchConclusionMetavariableNode(conclusionMetaVariableNode, metaSubstitutions);
+  } else {
+    let childNodes = conclusinNonTerminalNode.getChildNodes();
+
+    let conclusionChildNodes = childNodes;  ///
+
+    conclusionChildNodes = matchConclusionChildNodes(conclusionChildNodes, metaSubstitutions);
+
+    childNodes = conclusionChildNodes;  ///
+
+    conclusinNonTerminalNode.setChildNodes(childNodes);
+  }
+
+  return conclusinNonTerminalNode;
+}
+
+function matchConclusionMetavariableNode(conclusionMetavariableNode, metaSubstitutions) {
+  const conclusionMetavariableName = metavariableNameFromMetavariableNode(conclusionMetavariableNode),
+        metaSubstitution = metaSubstitutions.find((metaSubstitution) => {
+          const metavariableName = metaSubstitution.getMetavariableName();
+
+          if (metavariableName === conclusionMetavariableName) {
+            return true;
+          }
+        });
+
+  let nonTerminalNode = metaSubstitution.getNonTerminalNode();  ///
+
+  nonTerminalNode = nonTerminalNode.clone();  ///
+
+  const conclusionNonTerminalNode = nonTerminalNode;  ///
+
+  return conclusionNonTerminalNode;
+}