occam-verify-cli 1.0.438 → 1.0.444

package/src/process/verify.js

@@ -1,16 +1,14 @@
 "use strict";
 
 import { nodeQuery } from "../utilities/query";
-import { isLastRemainingArgumentFunction } from "../utilities/pass";
-import { termFromTermNode,
-         ruleFromRuleNode,
+import { termFromTermNode, statementFromStatementNode } from "../utilities/element";
+import { ruleFromRuleNode,
          errorFromErrorNode,
          axiomFromAxiomNode,
          lemmaFromLemmaNode,
          sectionFromSectionNode,
          theoremFromTheoremNode,
          metaLemmaFromMetaLemmaNode,
-         statementFromStatementNode,
          conjectureFromConjectureNode,
          metatheoremFromMetatheoremNode,
          variableDeclarationFromVariableDeclarationNode,
@@ -21,17 +19,18 @@ import { termFromTermNode,
          complexTypeDeclarationFromComplexTypeDeclarationNode,
          metavariableDeclarationFromMetavariableDeclarationNode } from "../utilities/element";
 
-const nonTerminalNodeQuery = nodeQuery("/*"),
+const nonTerminalNodeQuery = nodeQuery("/*");
+
+const ruleNodeQuery = nodeQuery("/rule"),
       termNodeQuery = nodeQuery("/term"),
       typeNodeQuery = nodeQuery("/type"),
-      ruleNodeQuery = nodeQuery("/rule"),
       errorNodeQuery = nodeQuery("/error"),
       axiomNodeQuery = nodeQuery("/axiom"),
       lemmaNodeQuery = nodeQuery("/lemma"),
       sectionNodeQuery = nodeQuery("/section"),
       theoremNodeQuery = nodeQuery("/theorem"),
-      statementNodeQuery = nodeQuery("/statement"),
       metaLemmaNodeQuery = nodeQuery("/metaLemma"),
+      statementNodeQuery = nodeQuery("/statement"),
       conjectureNodeQuery = nodeQuery("/conjecture"),
       metatheoremNodeQuery = nodeQuery("/metatheorem"),
       variableDeclarationNodeQuery = nodeQuery("/variableDeclaration"),
@@ -42,7 +41,7 @@ const nonTerminalNodeQuery = nodeQuery("/*"),
       complexTypeDeclarationNodeQuery = nodeQuery("/complexTypeDeclaration"),
       metavariableDeclarationNodeQuery = nodeQuery("/metavariableDeclaration");
 
-export default class Pass {
+class Pass {
   run(node, ...remainingArguments) {
     let success;
 
@@ -54,58 +53,22 @@ export default class Pass {
   }
 
   descend(childNodes, ...remainingArguments) {
-    let descendedAhead = false;
-
-    const lastRemainingArgumentFunction = isLastRemainingArgumentFunction(remainingArguments);
+    let descended = false;
 
-    if (lastRemainingArgumentFunction) {
-      const index = 0;
-
-      descendedAhead = this.descendAhead(index, childNodes, ...remainingArguments); ///
-    } else {
-      const visited = childNodes.every((childNode) => {
-        const node = childNode, ///
-              visited = this.visitNode(node, ...remainingArguments);
-
-        if (visited) {
-          return true;
-        }
-      });
+    const visited = childNodes.every((childNode) => {
+      const node = childNode, ///
+            visited = this.visitNode(node, ...remainingArguments);
 
       if (visited) {
-        descendedAhead = true;
+        return true;
       }
-    }
-
-    return descendedAhead;
-  }
-
-  descendAhead(index, childNodes, ...remainingArguments) {
-    let descendedAhead = false;
-
-    const descendAhead = remainingArguments.pop(), ///
-          childNodesLength = childNodes.length;
-
-    if (index === childNodesLength) {
-      descendedAhead = descendAhead();
-    } else {
-      const childNode = childNodes[index],
-            node = childNode, ///
-            visited = this.visitNode(node, ...remainingArguments, () => {
-              remainingArguments.push(descendAhead);
-
-              const aheadIndex = index + 1,
-                    descendedAhead = this.descendAhead(aheadIndex, childNodes, ...remainingArguments);
-
-              return descendedAhead;
-            });
+    });
 
-      if (visited) {
-        descendedAhead = true;
-      }
+    if (visited) {
+      descended = true;
     }
 
-    return descendedAhead;
+    return descended;
   }
 
   visitNode(node, ...remainingArguments) {
@@ -127,22 +90,7 @@ export default class Pass {
   }
 
   visitTerminalNode(terminalNode, ...remainingArguments) {
-    let visited = false;
-
-    const lastRemainingArgumentFunction = isLastRemainingArgumentFunction(remainingArguments);
-
-    if (lastRemainingArgumentFunction) {
-      const descendAhead = remainingArguments.pop(), ///
-            descendedAhead = descendAhead();
-
-      if (descendedAhead) {
-        visited = true;
-      }
-
-      remainingArguments.push(descendAhead);
-    } else {
-      visited = true;
-    }
+    const visited = true;
 
     return visited;
   }
@@ -434,21 +382,7 @@ class TopLevelPass extends Pass {
   ];
 }
 
-class CombinatorPass extends Pass {
-  run(statementNode, context) {
-    let success = false;
-
-    const nonTerminalNode = statementNode,  ///
-          childNodes = nonTerminalNode.getChildNodes(), ///
-          descended = this.descend(childNodes,context);
-
-    if (descended) {
-      success = true;
-    }
-
-    return success;
-  }
-
+class ConbinatorPass extends Pass {
   static maps = [
     {
       nodeQuery: statementNodeQuery,
@@ -458,9 +392,9 @@ class CombinatorPass extends Pass {
         const statement = statementFromStatementNode(statementNode, context),
               assignments = null,
               stated = false,
-              statementVerifies = statement.verify(assignments, stated, context);
+              statementValidates = statement.validate(assignments, stated, context);
 
-        if (statementVerifies) {
+        if (statementValidates) {
           success = true;
         }
 
@@ -473,13 +407,13 @@ class CombinatorPass extends Pass {
         let success = false;
 
         const term = termFromTermNode(termNode, context),
-              termVerifies = term.verify(context, () => {
+              termValidates = term.validate(context, () => {
                 const verifiesAhead = true;
 
                 return verifiesAhead;
               });
 
-        if (termVerifies) {
+        if (termValidates) {
           success = true;
         }
 
@@ -505,30 +439,20 @@ class CombinatorPass extends Pass {
 }
 
 class ConstructorPass extends Pass {
-  run(statementNode, context) {
-    let success = false;
-
-    const nonTerminalNode = statementNode,  ///
-          childNodes = nonTerminalNode.getChildNodes(), ///
-          descended = this.descend(childNodes,context);
-
-    if (descended) {
-      success = true;
-    }
-
-    return success;
-  }
-
   static maps = [
     {
       nodeQuery: termNodeQuery,
-      run: (termNode, context, verifyAhead) => {
+      run: (termNode, context) => {
         let success = false;
 
         const term = termFromTermNode(termNode, context),
-              termVerifies = term.verify(context, verifyAhead);
+              termValidates = term.validate(context, () => {
+                const verifiesAhead = true;
 
-        if (termVerifies) {
+                return verifiesAhead;
+              });
+
+        if (termValidates) {
           success = true;
         }
 
@@ -537,24 +461,14 @@ class ConstructorPass extends Pass {
     },
     {
       nodeQuery: typeNodeQuery,
-      run: (typeNode, context, verifyAhead) => {
+      run: (typeNode, context) => {
         let success = false;
 
         const nominalTypeName = typeNode.getNominalTypeName(),
               typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);
 
         if (typePresent) {
-          const verifiesAhead = verifyAhead();
-
-          if (verifiesAhead) {
-            success = true;
-          }
-        } else {
-          const typeString = nominalTypeName; ///
-
-          context.debug(`The '${typeString}' type is not present.`);
-
-          success = false;
+          success = true;
         }
 
         return success;
@@ -564,7 +478,7 @@ class ConstructorPass extends Pass {
 }
 
 const topLevelPass = new TopLevelPass(),
-      combinatorPass = new CombinatorPass(),
+      combinatorPass = new ConbinatorPass(),
       constructorPass = new ConstructorPass();
 
 export function verifyFile(fileNode, context) {
@@ -580,28 +494,26 @@ export function verifyFile(fileNode, context) {
   return fileVerifies;
 }
 
-export function verifyTerm(termNode, context) {
-  let termVerifies = false;
-
-  const node = termNode, ///
-        sucess = constructorPass.run(node, context);
+export function verifyCombinator(combintot) {
+  const context = combintot.getContext(),
+        statement = combintot.getStatement(),
+        statementNode = statement.getNode(),
+        nonTerminalNode = statementNode, ///
+        childNodes = nonTerminalNode.getChildNodes(),
+        descended = combinatorPass.descend(childNodes, context),
+        combinatorVerifies = descended;  ///
 
-  if (sucess) {
-    termVerifies = true;
-  }
-
-  return termVerifies;
+  return combinatorVerifies;
 }
 
-export function verifyStatement(statementNode, context) {
-  let statementVerifies = false;
-
-  const node = statementNode, ///
-        sucess = combinatorPass.run(node, context);
-
-  if (sucess) {
-    statementVerifies = true;
-  }
+export function verifyConstrcctor(constructor) {
+  const context = constructor.getContext(),
+        term = constructor.getStatement(),
+        termNode = term.getNode(),
+        nonTerminalNode = termNode, ///
+        childNodes = nonTerminalNode.getChildNodes(),
+        descended = constructorPass.descend(childNodes, context),
+        constrcctorVerifies = descended;  ///
 
-  return statementVerifies;
+  return constrcctorVerifies;
 }

package/src/types.js

@@ -0,0 +1,18 @@
+"use strict";
+
+import elements from "./elements";
+
+import { BASE_TYPE_SYMBOL } from "./constants";
+
+let baseType = null;
+
+export function baseTypeFromNothing() {
+  if (baseType === null) {
+    const { Type } = elements,
+          name = BASE_TYPE_SYMBOL;  ///
+
+    baseType = Type.fromName(name);
+  }
+
+  return baseType;
+}

package/src/utilities/brackets.js

@@ -3,7 +3,7 @@
 import elements from "../elements";
 
 import { BRACKETED_TERM_DEPTH, BRACKETED_STATEMENT_DEPTH } from "../constants";
-import { bracketedConstructorTermFromNothing, bracketedCombinatorStatementFromNothing } from "../utilities/instance";
+import { bracketedConstructorFromNothing, bracketedCombinatorFromNothing } from "../utilities/instance";
 
 export function stripBracketsFromTerm(term, context) {
   const termNode = term.getNode(),
@@ -57,10 +57,12 @@ function bracketedTermChildNodeFromTermNode(termNode) {
   let bracketedTermChildNode = null;
 
   const depth = BRACKETED_TERM_DEPTH,
-        bracketedConstructorTermNode = bracketedConstructorTermFromNothing(),
-        termNodeMatchBracketedConstructorTermNode = termNode.match(bracketedConstructorTermNode, depth);
+        bracketedConstructor = bracketedConstructorFromNothing(),
+        bracketedConstructorTerm = bracketedConstructor.getTerm(),
+        bracketedConstructorTermNode = bracketedConstructorTerm.getNode(),
+        termNodeMatchBracketedConstructorNode = termNode.match(bracketedConstructorTermNode, depth);
 
-  if (termNodeMatchBracketedConstructorTermNode) {
+  if (termNodeMatchBracketedConstructorNode) {
     const singularTermNode = termNode.getSingularTermNode();
 
     bracketedTermChildNode = singularTermNode;  ///
@@ -73,8 +75,10 @@ function bracketedStatementChildNodeFromStatementNode(statementNode) {
   let bracketedStatementChildNode = null;
 
   const depth = BRACKETED_STATEMENT_DEPTH,
-        bracketedCombinatorStatementNode = bracketedCombinatorStatementFromNothing(),
-        statementNodeMatchBracketedCombinatorStatementNode = statementNode.match(bracketedCombinatorStatementNode, depth);
+        bracketedCombinator = bracketedCombinatorFromNothing(),
+        bracketedCombinatorStatement = bracketedCombinator.getStatement(),
+        bracketedCombinatorStatementnNode = bracketedCombinatorStatement.getNode(),
+        statementNodeMatchBracketedCombinatorStatementNode = statementNode.match(bracketedCombinatorStatementnNode, depth);
 
   if (statementNodeMatchBracketedCombinatorStatementNode) {
     const singularStatementNode = statementNode.getSingularStatementNode();