occam-verify-cli 1.0.438 → 1.0.448

package/src/process/validate.js

@@ -0,0 +1,316 @@
+"use strict";
+
+import { nodeQuery } from "../utilities/query";
+import { isLastRemainingArgumentFunction } from "../utilities/pass";
+import { termFromTermNode, statementFromStatementNode } from "../utilities/element";
+
+const nonTerminalNodeQuery = nodeQuery("/*");
+
+const termNodeQuery = nodeQuery("/term"),
+      typeNodeQuery = nodeQuery("/type"),
+      statementNodeQuery = nodeQuery("/statement");
+
+class Pass {
+  run(node, ...remainingArguments) {
+    let success;
+
+    const visited = this.visitNode(node, ...remainingArguments);
+
+    success = visited;  ///
+
+    return success;
+  }
+
+  descend(childNodes, ...remainingArguments) {
+    let descended = false;
+
+    const lastRemainingArgumentFunction = isLastRemainingArgumentFunction(remainingArguments);
+
+    if (lastRemainingArgumentFunction) {
+      const index = 0;
+
+      descended = this.descendAhead(index, childNodes, ...remainingArguments); ///
+    } else {
+      const visited = childNodes.every((childNode) => {
+        const node = childNode, ///
+              visited = this.visitNode(node, ...remainingArguments);
+
+        if (visited) {
+          return true;
+        }
+      });
+
+      if (visited) {
+        descended = true;
+      }
+    }
+
+    return descended;
+  }
+
+  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;
+      }
+    }
+
+    return descendedAhead;
+  }
+
+  visitNode(node, ...remainingArguments) {
+    let visited;
+
+    const nodeTerminalNode = node.isTerminalNode();
+
+    if (nodeTerminalNode) {
+      const terminalNode = node;  ///
+
+      visited = this.visitTerminalNode(terminalNode, ...remainingArguments);
+    } else {
+      const nonTerminalNode = node;  ///
+
+      visited = this.visitNonTerminalNode(nonTerminalNode, ...remainingArguments);
+    }
+
+    return visited;
+  }
+
+  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;
+    }
+
+    return visited;
+  }
+
+  visitNonTerminalNode(nonTerminalNode, ...remainingArguments) {
+    let visited = false;
+
+    let { maps } = this.constructor;
+
+    maps = [ ///
+      ...maps,
+      {
+        nodeQuery: nonTerminalNodeQuery,
+        run: (node, ...remainingArguments) => {
+          let visited = false;
+
+          const childNodes = nonTerminalNode.getChildNodes(), ///
+                descended = this.descend(childNodes, ...remainingArguments);
+
+          if (descended) {
+            visited = true;
+          }
+
+          return visited;
+        }
+      }
+    ]
+
+    maps.some((map) => {
+      const { nodeQuery, run } = map;
+
+      const node = nodeQuery(nonTerminalNode);
+
+      if (node !== null) {
+        const success = run(node, ...remainingArguments);
+
+        visited = success;
+
+        return true;
+      }
+    });
+
+    return visited;
+  }
+}
+
+class TermPass 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, validateAhead) => {
+        let success = false;
+
+        const term = termFromTermNode(termNode, context),
+              termValidates = term.validate(context, validateAhead);
+
+        if (termValidates) {
+          success = true;
+        }
+
+        return success;
+      }
+    },
+    {
+      nodeQuery: typeNodeQuery,
+      run: (typeNode, context, validateAhead) => {
+        let success = false;
+
+        const nominalTypeName = typeNode.getNominalTypeName(),
+              typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);
+
+        if (typePresent) {
+          const verifiesAhead = validateAhead();
+
+          if (verifiesAhead) {
+            success = true;
+          }
+        } else {
+          const typeString = nominalTypeName; ///
+
+          context.debug(`The '${typeString}' type is not present.`);
+
+          success = false;
+        }
+
+        return success;
+      }
+    }
+  ];
+}
+
+class StatementPass 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: statementNodeQuery,
+      run: (statementNode, context) => {
+        let success = false;
+
+        const statement = statementFromStatementNode(statementNode, context),
+              assignments = null,
+              stated = false,
+              statementValidates = statement.validate(assignments, stated, context);
+
+        if (statementValidates) {
+          success = true;
+        }
+
+        return success;
+      }
+    },
+    {
+      nodeQuery: termNodeQuery,
+      run: (termNode, context) => {
+        let success = false;
+
+        const term = termFromTermNode(termNode, context),
+              termValidates = term.validate(context, () => {
+                const verifiesAhead = true;
+
+                return verifiesAhead;
+              });
+
+        if (termValidates) {
+          success = true;
+        }
+
+        return success;
+      }
+    },
+    {
+      nodeQuery: typeNodeQuery,
+      run: (typeNode, context) => {
+        let success = false;
+
+        const nominalTypeName = typeNode.getNominalTypeName(),
+              typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);
+
+        if (typePresent) {
+          success = true;
+        }
+
+        return success;
+      }
+    }
+  ];
+}
+
+const termPass = new TermPass(),
+      statementPass = new StatementPass();
+
+export function validateTerm(termNode, context) {
+  let termValidates = false;
+
+  const node = termNode, ///
+        sucess = termPass.run(node, context);
+
+  if (sucess) {
+    termValidates = true;
+  }
+
+  return termValidates;
+}
+
+export function validateStatement(statementNode, context) {
+  let statementValidates = false;
+
+  const node = statementNode, ///
+        sucess = statementPass.run(node, context);
+
+  if (sucess) {
+    statementValidates = true;
+  }
+
+  return statementValidates;
+}

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;
+}