occam-verify-cli 1.0.438 → 1.0.444

package/src/process/unify.js

@@ -1,8 +1,7 @@
 "use strict";
 
-import elements from "../elements";
-
 import { nodeQuery } from "../utilities/query";
+import { termFromTermNode, frameFromFrameNode, statementFromStatementNode } from "../utilities/element";
 import { terminalNodeMapFromNodes, areTerminalNodeMapsEqual, isLastRemainingArgumentFunction } from "../utilities/pass";
 
 const nonTerminalNodeQuery = nodeQuery("/*");
@@ -29,7 +28,7 @@ class Pass {
   }
 
   descend(generalChildNodes, specificChildNodes, ...remainingArguments) {
-    let descendedAhead = false;
+    let descended = false;
 
     const generalChildNodesLength = generalChildNodes.length,
           specificChildNodesLength = specificChildNodes.length;
@@ -43,9 +42,12 @@ class Pass {
         const lastRemainingArgumentFunction = isLastRemainingArgumentFunction(remainingArguments);
 
         if (lastRemainingArgumentFunction) {
-          const index = 0;
+          const index = 0,
+                descendedAhead = this.descendAhead(index, generalChildNodes, specificChildNodes,...remainingArguments);
 
-          descendedAhead = this.descendAhead(index, generalChildNodes, specificChildNodes,...remainingArguments);
+          if (descendedAhead) {
+            descended = true;
+          }
         } else {
           const visited = generalChildNodes.every((generalChildNode, index) => {
             const specificChildNode = specificChildNodes[index],
@@ -59,13 +61,13 @@ class Pass {
           });
 
           if (visited) {
-            descendedAhead = true;
+            descended = true;
           }
         }
       }
     }
 
-    return descendedAhead;
+    return descended;
   }
 
   descendAhead(index, generalChildNodes, specificChildNodes, ...remainingArguments) {
@@ -346,11 +348,10 @@ class CombinatorPass extends Pass {
 
         context = specificContext;  ///
 
-        const { Statement } = elements,
-              statement = Statement.fromStatementNode(statementNode, context),
-              statementVerifiesGivenType = statement.verifyGivenMetaType(metaType, assignments, stated, context);
+        const statement = statementFromStatementNode(statementNode, context),
+              statementValidatesGivenType = statement.validateGivenMetaType(metaType, assignments, stated, context);
 
-        if (statementVerifiesGivenType) {
+        if (statementValidatesGivenType) {
           success = true;
         }
 
@@ -375,11 +376,10 @@ class CombinatorPass extends Pass {
 
         context = specificContext;  ///
 
-        const { Frame } = elements,
-              frame = Frame.fromFrameNode(frameNode, context),
-              frameVerifiesGivenType = frame.verifyGivenMetaType(metaType, assignments, stated, context);
+        const frame = frameFromFrameNode(frameNode, context),
+              frameValidatesGivenMetaType = frame.validateGivenMetaType(metaType, assignments, stated, context);
 
-        if (frameVerifiesGivenType) {
+        if (frameValidatesGivenMetaType) {
           success = true;
         }
 
@@ -405,11 +405,10 @@ class CombinatorPass extends Pass {
         if (type !== null) {
           context = specificContext;  ///
 
-          const { Term } = elements,
-                term = Term.fromTermNode(termNode, context),
-                termVerifiesGivenType = term.verifyGivenType(type, generalContext, specificContext);
+          const term = termFromTermNode(termNode, context),
+                termValidatesGivenType = term.validateGivenType(type, generalContext, specificContext);
 
-          if (termVerifiesGivenType) {
+          if (termValidatesGivenType) {
             success = true;
           }
         }
@@ -441,11 +440,10 @@ class ConstructorPass extends Pass {
         if (type !== null) {
           context = specificContext;  ///
 
-          const { Term } = elements,
-                term = Term.fromTermNode(termNode, context),
-                termVerifiesGivenType = term.verifyGivenType(type, generalContext, specificContext);
+          const term = termFromTermNode(termNode, context),
+                termValidatesGivenType = term.validateGivenType(type, generalContext, specificContext);
 
-          if (termVerifiesGivenType) {
+          if (termValidatesGivenType) {
             success = true;
           }
         }
@@ -470,9 +468,9 @@ class MetavariablePass extends Pass {
               type = generalContext.findTypeByNominalTypeName(nominalTypeName),
               context = specificContext, ///
               term = context.findTermByTermNode(termNode),
-              termVerifiesGivenType = term.verifyGivenType(type, generalContext, specificContext);
+              termValidatesGivenType = term.validateGivenType(type, generalContext, specificContext);
 
-        if (termVerifiesGivenType) {
+        if (termValidatesGivenType) {
           success = true;
         }
 
@@ -567,6 +565,21 @@ export function unifyMetavariable(generalMetavariable, specificMetavariable, gen
   return metavariableUnifies;
 }
 
+export function unifyTermWithConstructor(term, constructor, generalContext, specificContext) {
+  let termUnifiesWithConstructor = false;
+
+  const termNode = term.getNode(),
+        constructorTerm = constructor.getTerm(),
+        constructorTermNode = constructorTerm.getNode(),
+        success = constructorPass.run(constructorTermNode, termNode, generalContext, specificContext);
+
+  if (success) {
+    termUnifiesWithConstructor = true;
+  }
+
+  return termUnifiesWithConstructor;
+}
+
 export function unifyStatementIntrinsically(generalStatement, specificStatement, substitutions, generalContext, specificContext) {
   let statementUnifiesIntrinsically = false;
 
@@ -583,6 +596,21 @@ export function unifyStatementIntrinsically(generalStatement, specificStatement,
   return statementUnifiesIntrinsically;
 }
 
+export function unifyStatementWithCombinator(statement, combinator, assignments, stated, generalContext, specificContext) {
+  let statementUnifiesWithCombinator = false;
+
+  const statementNode = statement.getNode(),
+        combinatorStatement = combinator.getStatement(),
+        combinatorStatementNode = combinatorStatement.getNode(),
+        success = combinatorPass.run(combinatorStatementNode, statementNode, assignments, stated, generalContext, specificContext);
+
+  if (success) {
+    statementUnifiesWithCombinator = true;
+  }
+
+  return statementUnifiesWithCombinator;
+}
+
 export function unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, substitutions, generalContext, specificContext) {
   let metavariableUnifiesIntrinsically = false;
 
@@ -598,35 +626,3 @@ export function unifyMetavariableIntrinsically(generalMetavariable, specificMeta
 
   return metavariableUnifiesIntrinsically;
 }
-
-export function unifyTermWithConstructorTerm(term, constructorTerm, context) {
-  let termUnifiesWithConstructor = false;
-
-  const termNode = term.getNode(),
-        generalContext = context, ///
-        specificContext = context,  ///
-        constructorTermNode = constructorTerm.getNode(),
-        success = constructorPass.run(constructorTermNode, termNode, generalContext, specificContext);
-
-  if (success) {
-    termUnifiesWithConstructor = true;
-  }
-
-  return termUnifiesWithConstructor;
-}
-
-export function unifyStatementWithCombinatorStatement(statement, combinatorStatement, assignments, stated, context) {
-  let statementUnifiesWithCombinator = false;
-
-  const statementNode = statement.getNode(),
-        generalContext = context, ///
-        specificContext = context,  ///
-        combinatorStatementNode = combinatorStatement.getNode(),
-        success = combinatorPass.run(combinatorStatementNode, statementNode, assignments, stated, generalContext, specificContext);
-
-  if (success) {
-    statementUnifiesWithCombinator = true;
-  }
-
-  return statementUnifiesWithCombinator;
-}

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