occam-verify-cli 0.0.526 → 0.0.529

package/src/matcher/statementForMetavariable.js

@@ -1,99 +0,0 @@
-"use strict";
-
-import Matcher from "../matcher";
-import StatementForMetavariableSubstitution from "../substitution/statementForMetavariable";
-
-import { first } from "../utilities/array";
-import { metavariableNameFromMetavariableNode } from "../utilities/query";
-import { METAVARIABLE_RULE_NAME, METASTATEMENT_RULE_NAME } from "../ruleNames";
-
-export default class StatementForMetavariableMatcher extends Matcher {
-  matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions) {
-    let nonTerminalNodeMatches = false;
-
-    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
-          nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(),
-          nonTerminalNodeARuleNameMetastatementRuleName = (nonTerminalNodeARuleName === METASTATEMENT_RULE_NAME),
-          nonTerminalNodeBRuleNameStatementRuleName = (nonTerminalNodeBRuleName === STATEMENT_RULE_NAME);
-
-    if (nonTerminalNodeARuleNameMetastatementRuleName && nonTerminalNodeBRuleNameStatementRuleName) {
-      const metastatementNodeA = nonTerminalNodeA,  ///
-            statementNodeB = nonTerminalNodeB,  ///
-            statementNodeMatches = this.matchStatementNode(metastatementNodeA, statementNodeB, substitutions);
-
-      if (statementNodeMatches) {
-        nonTerminalNodeMatches = true;  ///
-      } else {
-        nonTerminalNodeMatches = super.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
-      }
-    } else if (nonTerminalNodeBRuleName === nonTerminalNodeARuleName) {
-      nonTerminalNodeMatches = super.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
-    }
-
-    return nonTerminalNodeMatches;
-  }
-
-  matchStatementNode(metastatementNodeA, statementNodeB, substitutions) {
-    let statementNodeMatches = false;
-
-    const nonTerminalNodeA = metastatementNodeA,  ///
-          nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
-          nonTerminalNodeAChildNodesLength = nonTerminalNodeAChildNodes.length;
-
-    if (nonTerminalNodeAChildNodesLength === 1) {
-      const firstNonTerminalNodeAChildNode = first(nonTerminalNodeAChildNodes),
-        cChildNodeA = firstNonTerminalNodeAChildNode,  ///
-        cChildNodeANonTerminalNode = cChildNodeA.isNonTerminalNode();
-
-      if (cChildNodeANonTerminalNode) {
-        const nonTerminalNodeA = cChildNodeA,  ///
-              nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
-              nonTerminalNodeARuleNameMetavariableRuleName = (nonTerminalNodeARuleName === METAVARIABLE_RULE_NAME);
-
-        if (nonTerminalNodeARuleNameMetavariableRuleName) {
-          const metavariableNodeA = nonTerminalNodeA,  ///
-                metaVariableNodeMatches = this.matchMetavariableNode(metavariableNodeA, statementNodeB, substitutions);
-
-          statementNodeMatches = metaVariableNodeMatches; ///
-        }
-      }
-    }
-
-    return statementNodeMatches;
-  }
-
-  matchMetavariableNode(metavariableNodeA, statementNodeB, substitutions) {
-    let metavariableNodeMatches;
-
-    const metavariableNameA = metavariableNameFromMetavariableNode(metavariableNodeA),
-          substitution = substitutions.find((substitution) => {
-            const metavariableName = substitution.getMetavariableName();
-
-            if (metavariableName === metavariableNameA) {
-              return true;
-            }
-          }) || null;
-
-    if (substitution !== null) {
-      const statementNode = statementNodeB, ///
-            substitutionNodesMatch = substitution.matchStatementNode(statementNode);
-
-      metavariableNodeMatches = substitutionNodesMatch;  ///
-    } else {
-      const { createSubstitutions } = this.constructor;
-
-      if (createSubstitutions) {
-        const metavariableName = metavariableNameA, ///
-              statementNode = statementNodeB, ///
-              statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromMetavariableNameAndStatementNode(metavariableName, statementNode),
-              substitution = statementForMetavariableSubstitution;  ///
-
-        substitutions.push(substitution);
-      }
-
-      metavariableNodeMatches = true;
-    }
-
-    return metavariableNodeMatches;
-  }
-}

package/src/matcher/statementForVariable/consequence.js

@@ -1,9 +0,0 @@
-"use strict";
-
-import StatementForVariableMatcher from "../../matcher/statementForVariable";
-
-class ConsequenceStatementForVariableMatcher extends StatementForVariableMatcher {
-  static createSubstitutions = false;
-}
-
-export const consequenceStatementForVariableMatcher = new ConsequenceStatementForVariableMatcher();

package/src/matcher/statementForVariable/supposition.js

@@ -1,9 +0,0 @@
-"use strict";
-
-import StatementForVariableMatcher from "../../matcher/statementForVariable";
-
-class SuppositionStatementForVariableMatcher extends StatementForVariableMatcher {
-  static createSubstitutions = true;
-}
-
-export const suppositionStatementForVariableMatcher = new SuppositionStatementForVariableMatcher();

package/src/matcher/statementForVariable.js

@@ -1,99 +0,0 @@
-"use strict";
-
-import Matcher from "../matcher";
-import StatementForVariableSubstitution from "../substitution/statementForVariable";
-
-import { first } from "../utilities/array";
-import { variableNameFromVariableNode } from "../utilities/query";
-import { VARIABLE_RULE_NAME, STATEMENT_RULE_NAME } from "../ruleNames";
-
-export default class StatementForVariableMatcher extends Matcher {
-  matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions) {
-    let nonTerminalNodeMatches = false;
-
-    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
-          nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(),
-          nonTerminalNodeARuleNameMetastatementRuleName = (nonTerminalNodeARuleName === STATEMENT_RULE_NAME),
-          nonTerminalNodeBRuleNameMetastatementRuleName = (nonTerminalNodeBRuleName === STATEMENT_RULE_NAME);
-
-    if (nonTerminalNodeARuleNameMetastatementRuleName && nonTerminalNodeBRuleNameMetastatementRuleName) {
-      const statementNodeA = nonTerminalNodeA,  ///
-            statementNodeB = nonTerminalNodeB,  ///
-            statementNodeMatches = this.matchStatementNode(statementNodeA, statementNodeB, substitutions);
-
-      if (statementNodeMatches) {
-        nonTerminalNodeMatches = true;  ///
-      } else {
-        nonTerminalNodeMatches = super.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
-      }
-    } else if (nonTerminalNodeBRuleName === nonTerminalNodeARuleName) {
-      nonTerminalNodeMatches = super.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
-    }
-
-    return nonTerminalNodeMatches;
-  }
-
-  matchStatementNode(statementNodeA, statementNodeB, substitutions) {
-    let statementNodeMatches = false;
-
-    const nonTerminalNodeA = statementNodeA,  ///
-          nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
-          nonTerminalNodeAChildNodesLength = nonTerminalNodeAChildNodes.length;
-
-    if (nonTerminalNodeAChildNodesLength === 1) {
-      const firstNonTerminalNodeAChildNode = first(nonTerminalNodeAChildNodes),
-            childNodeA = firstNonTerminalNodeAChildNode,  ///
-            childNodeANonTerminalNode = childNodeA.isNonTerminalNode();
-
-      if (childNodeANonTerminalNode) {
-        const nonTerminalNodeA = childNodeA,  ///
-              nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
-              nonTerminalNodeARuleNameVariableRuleName = (nonTerminalNodeARuleName === VARIABLE_RULE_NAME);
-
-        if (nonTerminalNodeARuleNameVariableRuleName) {
-          const variableNodeA = nonTerminalNodeA,  ///
-                variableMatches = this.matchVariableNode(variableNodeA, statementNodeB, substitutions);
-
-          statementNodeMatches = variableMatches; ///
-        }
-      }
-    }
-
-    return statementNodeMatches;
-  }
-
-  matchVariableNode(variableNodeB, statementNodeB, substitutions) {
-    let variableMatches;
-
-    const variableNameA = variableNameFromVariableNode(variableNodeB),
-          substitution = substitutions.find((substitution) => {
-            const variableName = substitution.getVariableName();
-
-            if (variableName === variableNameA) {
-              return true;
-            }
-          }) || null;
-
-    if (substitution !== null) {
-      const statementNode = statementNodeB, ///
-            substitutionNodesMatch = substitution.matchStatementNode(statementNode);
-
-      variableMatches = substitutionNodesMatch;  ///
-    } else {
-      const { createSubstitutions } = this.constructor;
-
-      if (createSubstitutions) {
-        const variableName = variableNameA, ///
-              statementNode = statementNodeB, ///
-              statementForVariableSubstitution = StatementForVariableSubstitution.fromVariableNameAndStatementNode(variableName, statementNode),
-              substitution = statementForVariableSubstitution;  ///
-
-        substitutions.push(substitution);
-      }
-
-      variableMatches = true;
-    }
-
-    return variableMatches;
-  }
-}

package/src/mixins/callbacks.js

@@ -1,15 +0,0 @@
-"use strict";
-
-function halt(node) { this.context.halt(node); }
-
-function begin(node) { this.context.begin(node); }
-
-function complete(node) { this.context.complete(node); }
-
-const callbacksMixins = {
-  halt,
-  begin,
-  complete
-};
-
-export default callbacksMixins;

package/src/substitution/statementForVariable.js

@@ -1,64 +0,0 @@
-"use strict";
-
-import { matcher } from "../matcher";
-import { STATEMENT_RULE_NAME } from "../ruleNames";
-import { bracketedNonTerminalChildNodeFromChildNodes } from "../utilities/substitution";
-
-export default class StatementForVariableSubstitution {
-  constructor(variableName, statementNode) {
-    this.variableName = variableName;
-    this.statementNode = statementNode;
-  }
-
-  getVariableName() {
-    return this.variableName;
-  }
-
-  getStatementNode() {
-    return this.statementNode;
-  }
-
-  matchStatementNode(statementNode) {
-    let matchesStatementNode;
-
-    const nodeA = this.statementNode,  ///
-          nodeB = statementNode,
-          nodeMatches = matcher.matchNode(nodeA, nodeB);
-
-    matchesStatementNode = nodeMatches;  ///
-
-    if (!matchesStatementNode) {
-      const nonTerminalNode = statementNode,  ///
-            childNodes = nonTerminalNode.getChildNodes(), ///
-            ruleName = STATEMENT_RULE_NAME;
-
-      statementNode = bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName);  ///
-
-      if (statementNode !== null) {
-        const nodeA = this.statementNode,  ///
-              nodeB = statementNode,
-              nodeMatches = matchNode(nodeA, nodeB);
-
-        matchesStatementNode = nodeMatches;  ///
-      }
-    }
-
-    return matchesStatementNode;
-  }
-
-  static fromVariableNameAndStatementNode(variableName, statementNode) {
-    let statementForVariableSubstitution = new StatementForVariableSubstitution(variableName, statementNode);
-
-    const nonTerminalNode = statementNode,  ///
-          childNodes = nonTerminalNode.getChildNodes(),
-          ruleName = STATEMENT_RULE_NAME;
-
-    statementNode = bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName);  ///
-
-    if (statementNode !== null) {
-      statementForVariableSubstitution = new StatementForVariableSubstitution(variableName, statementNode);
-    }
-
-    return statementForVariableSubstitution;
-  }
-}

package/src/utilities/json.js

@@ -1,264 +0,0 @@
-"use strict";
-
-import { arrayUtilities } from "necessary";
-
-import { STRING, NUMBER, BOOLEAN } from "../constants";
-import { NULL_JSON_TYPE, ARRAY_JSON_TYPE, OBJECT_JSON_TYPE, PRIMITIVE_JSON_TYPE } from "../jsonTypes";
-import { BREAKING_VERSION_CHANGE, ADDITIVE_VERSION_CHANGE, COSMETIC_VERSION_CHANGE } from "../versionChanges";
-
-const { first } = arrayUtilities;
-
-function compareJSON(jsonA, jsonB) {
-  let result = BREAKING_VERSION_CHANGE;
-
-  const jsonAType = typeOf(jsonA),
-        jsonBType = typeOf(jsonB);
-
-  if (jsonAType === jsonBType) {
-    const jsonType = jsonAType; ///
-
-    switch (jsonType) {
-      case ARRAY_JSON_TYPE: {
-        const arrayA = jsonA, ///
-              arrayB = jsonB; ///
-
-        result = compareArrays(arrayA, arrayB);
-
-        break;
-      }
-
-      case OBJECT_JSON_TYPE: {
-        const objectA = jsonA, ///
-              objectB = jsonB; ///
-
-        result = compareObjects(objectA, objectB);
-
-        break;
-      }
-
-      case PRIMITIVE_JSON_TYPE: {
-        const primitiveA = jsonA, ///
-              primitiveB = jsonB; ///
-
-        result = comparePrimitives(primitiveA, primitiveB);
-
-        break;
-      }
-    }
-  }
-
-  return result;
-}
-
-export default {
-  compareJSON
-};
-
-function compareArrays(arrayA, arrayB) {
-  let result;
-
-  const arrayALength = arrayA.length,
-        arrayBLength = arrayB.length;
-
-  if (arrayALength === 0) {
-    if (arrayBLength === 0) {
-      result = COSMETIC_VERSION_CHANGE;
-    } else {
-      result = ADDITIVE_VERSION_CHANGE;
-    }
-  } else {
-    if (arrayBLength === 0) {
-      result = BREAKING_VERSION_CHANGE;
-    } else {
-      const firstElementA = first(arrayA),  ///
-            elementA = firstElementA, ///
-            elementB = arrayB.find((elementB) => {
-              const jsonA = elementA, ///
-                    jsonB = elementB, ///
-                    result = compareJSON(jsonA, jsonB);
-
-              if (result === COSMETIC_VERSION_CHANGE) {
-                return true;
-              }
-            }) || null;
-
-      if (elementB !== null) {
-        arrayA = deleteElement(arrayA, elementA);
-
-        arrayB = deleteElement(arrayB, elementB);
-
-        result = compareArrays(arrayA, arrayB);
-      } else {
-        result = BREAKING_VERSION_CHANGE;
-      }
-    }
-  }
-
-  return result;
-}
-
-function compareObjects(objectA, objectB) {
-  let result;
-
-  const keysA = Object.keys(objectA),
-        keysB = Object.keys(objectB),
-        keysALength = keysA.length,
-        keysBLength = keysB.length;
-
-  if (keysALength === 0) {
-    if (keysBLength === 0) {
-      result = COSMETIC_VERSION_CHANGE;
-    } else {
-      result = ADDITIVE_VERSION_CHANGE;
-    }
-  } else {
-    if (keysBLength === 0) {
-      result = BREAKING_VERSION_CHANGE;
-    } else {
-      const firstKeyA = first(keysA),  ///
-            keyA = firstKeyA, ///
-            keyB = keysB.find((keyB, index) => {
-              if (keyA === keyB) {
-                const valueA = objectA[keyA],
-                      valueB = objectB[keyB],
-                      jsonA = valueA, ///
-                      jsonB = valueB, ///
-                      result = compareJSON(jsonA, jsonB);
-
-                if (result === COSMETIC_VERSION_CHANGE) {  ///
-                  return true;
-                }
-              }
-            }) || null;
-
-      if (keyB !== null) {
-        objectA = deleteKey(objectA, keyA);
-
-        objectB = deleteKey(objectB, keyB);
-
-        result = compareObjects(objectA, objectB);
-      } else {
-        result = BREAKING_VERSION_CHANGE;
-      }
-    }
-  }
-
-  return result;
-}
-
-function comparePrimitives(primitiveA, primitiveB) {
-  let result = BREAKING_VERSION_CHANGE;
-
-  if (primitiveA === primitiveB) {
-    result = COSMETIC_VERSION_CHANGE;
-  }
-
-  return result;
-}
-
-function typeOf(json) {
-  let type;
-
-  const _null = isNull(json),
-        array = isArray(json),
-        object = isObject(json),
-        primitive = isPrimitive(json);
-
-  if (_null) {
-    type = NULL_JSON_TYPE;
-  }
-
-  if (array) {
-    type = ARRAY_JSON_TYPE;
-  }
-
-  if (object) {
-    type = OBJECT_JSON_TYPE;
-  }
-
-  if (primitive) {
-    type = PRIMITIVE_JSON_TYPE;
-  }
-
-  return type;
-}
-
-function isNull(json) {
-  const _null = (json === null);
-
-  return _null;
-}
-
-function isArray(json) {
-  const array = Array.isArray(json);
-
-  return array;
-}
-
-function isObject(json) {
-  const array = isArray(json),
-        primitive = isPrimitive(json),
-        object = (!array && !primitive);
-
-  return object;
-}
-
-function isString(json) {
-  const string = ((typeof json) === STRING);
-
-  return string;
-}
-
-function isNumber(json) {
-  const number = ((typeof json) === NUMBER);
-
-  return number;
-}
-
-function isBoolean(json) {
-  const boolean = ((typeof json) === BOOLEAN);
-
-  return boolean;
-}
-
-function isPrimitive(json) {
-  const _null = isNull(json),
-        string = isString(json),
-        number = isNumber(json),
-        boolean = isBoolean(json),
-        primitive = (_null || string || number || boolean);
-
-  return primitive;
-}
-
-function deleteElement(array, element) {
-  const deletedElement = element; ///
-
-  array = array.reduce((array, element) => {  ///
-    if (element !== deletedElement) {
-      array.push(element);
-    }
-
-    return array;
-  }, []);
-
-  return array;
-}
-
-function deleteKey(object, key) {
-  const deletedKey = key, ///
-        keys = Object.keys(object),
-        values = Object.values(object);
-
-  object = keys.reduce((object, key, index) => {  ///
-    if (key !== deletedKey) {
-      const value = values[index];
-
-      object[key] = value;
-    }
-
-    return object;
-  }, {});
-
-  return object;
-}

package/src/utilities/substitution.js

@@ -1,79 +0,0 @@
-"use strict";
-
-import { matcher } from "../matcher";
-import { first, second, third } from "../utilities/array";
-import { METASTATEMENT_RULE_NAME } from "../ruleNames";
-import { BRACKETED_CHILD_NODES_LENGTH, LEFT_BRACKET, RIGHT_BRACKET } from "../constants";
-
-export function matchBracketedNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB) {
-  let bracketedNodeMatches = false;
-
-  if (!bracketedNodeMatches) {
-    const nonTerminalNodeMatches = matcher.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB);
-
-    bracketedNodeMatches = nonTerminalNodeMatches;  ///
-  }
-
-  if (!bracketedNodeMatches) {
-    const nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
-          childNodesA = nonTerminalNodeAChildNodes, ///
-          bracketedNonTerminalChildNodeA = bracketedNonTerminalChildNodeFromChildNodes(childNodesA);
-
-    if (bracketedNonTerminalChildNodeA !== null) {
-      const nodeA = bracketedNonTerminalChildNodeA,  ///
-            nodeB = nonTerminalNodeB, ///
-            nodeMatches = matcher.matchNode(nodeA, nodeB);
-
-      bracketedNodeMatches = nodeMatches; ///
-    }
-  }
-
-  if (!bracketedNodeMatches) {
-    const nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
-          childNodesB = nonTerminalNodeBChildNodes, ///
-          bracketedNonTerminalChildNodeB = bracketedNonTerminalChildNodeFromChildNodes(childNodesB);
-
-    if (bracketedNonTerminalChildNodeB !== null) {
-      const nodeB = bracketedNonTerminalChildNodeB,  ///
-            nodeA = nonTerminalNodeA, ///
-            nodeMatches = matchNode(nodeA, nodeB);
-
-      bracketedNodeMatches = nodeMatches; ///
-    }
-  }
-
-  return bracketedNodeMatches;
-}
-
-export function bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName = METASTATEMENT_RULE_NAME) {
-  let bracketedNonTerminalChildNode = null;
-
-  const childNodesLength = childNodes.length;
-
-  if (childNodesLength === BRACKETED_CHILD_NODES_LENGTH) {
-    const firstChildNode = first(childNodes),
-          thirdChildNode = third(childNodes),
-          secondChildNode = second(childNodes),
-          firstChildNodeTerminalNode = firstChildNode.isTerminalNode(),
-          thirdChildNodeTerminalNode = thirdChildNode.isTerminalNode(),
-          secondChildNodeNonTerminalNode = secondChildNode.isNonTerminalNode();
-
-    if (firstChildNodeTerminalNode && secondChildNodeNonTerminalNode && thirdChildNodeTerminalNode) {
-      const nonTerminalNode = secondChildNode,  ///
-            firstTerminalNode = firstChildNode, ///
-            secondTerminalNode = thirdChildNode,  ///
-            nonTerminalNodeRuleName = nonTerminalNode.getRuleName(),
-            firstTerminalNodeContent = firstTerminalNode.getContent(),
-            secondTerminalNodeContent = secondTerminalNode.getContent(),
-            nonTerminalNodeRuleNameRuleName = (nonTerminalNodeRuleName === ruleName),
-            firstTerminalNodeContentLeftBracket = (firstTerminalNodeContent === LEFT_BRACKET),
-            secondTerminalNodeContentRightBracket = (secondTerminalNodeContent === RIGHT_BRACKET);
-
-      if (nonTerminalNodeRuleNameRuleName && firstTerminalNodeContentLeftBracket && secondTerminalNodeContentRightBracket) {
-        bracketedNonTerminalChildNode = nonTerminalNode;  ///
-      }
-    }
-  }
-
-  return bracketedNonTerminalChildNode;
-}

package/src/utilities/version.js

@@ -1,30 +0,0 @@
-"use strict";
-
-import { BREAKING_VERSION_CHANGE, ADDITIVE_VERSION_CHANGE, COSMETIC_VERSION_CHANGE } from "../versionChanges";
-
-function updateVersion(version, versionChange) {
-  switch (versionChange) {
-    case BREAKING_VERSION_CHANGE:
-      version.bumpMajorNumber();
-      version.resetMinorNumber();
-      version.resetPatchNumber();
-
-      break;
-
-    case ADDITIVE_VERSION_CHANGE:
-      version.bumpMinorNumber();
-      version.resetPatchNumber();
-
-      break;
-
-    case COSMETIC_VERSION_CHANGE:
-      version.bumpPatchNumber();
-
-      break;
-  }
-}
-
-export default {
-  updateVersion
-};
-

package/src/versionChanges.js

@@ -1,11 +0,0 @@
-"use strict";
-
-export const BREAKING_VERSION_CHANGE = "breaking";
-export const ADDITIVE_VERSION_CHANGE = "additive";
-export const COSMETIC_VERSION_CHANGE = "cosmetic";
-
-export default {
-  BREAKING_VERSION_CHANGE,
-  ADDITIVE_VERSION_CHANGE,
-  COSMETIC_VERSION_CHANGE
-};