occam-furtle 2.0.280 → 2.0.283

package/src/process/verify.js

@@ -0,0 +1,157 @@
+"use strict";
+
+import { nodeQuery } from "../utilities/query";
+
+import elements from "../elements";
+
+const nonTerminalNodeQuery = nodeQuery("/*"),
+      errorNodeQuery = nodeQuery("/error"),
+      procedureDeclarationNodeQuery = nodeQuery("/procedureDeclaration");
+
+class Pass {
+  run(node, ...remainingArguments) {
+    let success;
+
+    const visited = this.visitNode(node, ...remainingArguments);
+
+    success = visited;  ///
+
+    return success;
+  }
+
+  descend(childNodes, ...remainingArguments) {
+    let descended = false;
+
+    const visited = childNodes.every((childNode) => {
+      const node = childNode, ///
+            visited = this.visitNode(node, ...remainingArguments);
+
+      if (visited) {
+        return true;
+      }
+    });
+
+    if (visited) {
+      descended = true;
+    }
+
+    return descended;
+  }
+
+  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) {
+    const 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 TopLevelPass extends Pass {
+  static maps = [
+    {
+      nodeQuery: errorNodeQuery,
+      run: (errorNode, context) => {
+        let success = false;
+
+        const { Error } = elements,
+              error = Error.fromErrorNode(errorNode, context),
+              errorVerifies = error.verify(context);
+
+        if (errorVerifies) {
+          success = true;
+        }
+
+        return success;
+      }
+    },
+    {
+      nodeQuery: procedureDeclarationNodeQuery,
+      run: (procedureDeclarationNode, context) => {
+        let success = false;
+
+        const { ProcedureDeclaration } = elements,
+              procedureDeclaration = ProcedureDeclaration.fromProcedureDeclarationNode(procedureDeclarationNode, context),
+              procedureDeclarationVerifies = procedureDeclaration.verify(context);
+
+        if (procedureDeclarationVerifies) {
+          success = true;
+        }
+
+        return success;
+      }
+    }
+  ];
+}
+
+const topLevelPass = new TopLevelPass();
+
+export function verifyFile(fileNode, context) {
+  let fileVerifies = false;
+
+  const node = fileNode, ///
+        sucess = topLevelPass.run(node, context);
+
+  if (sucess) {
+    fileVerifies = true;
+  }
+
+  return fileVerifies;
+}

package/src/utilities/context.js

@@ -1,15 +1,31 @@
 "use strict";
 
-import { FUNCTION } from "../constants";
+import { LEVELS, FUNCTION, DOUBLE_SPACE } from "../constants";
 
 export function chainContext(context) {
   return new Proxy(context, {
     get: (instance, name, receiver) => {
+      const levelsIncludeName = LEVELS.includes(name);
+
+      if (levelsIncludeName) {
+        return (message, node = null) => {
+          const level = name, ///
+                depth = instance.getDepth(),
+                indent = DOUBLE_SPACE.repeat(depth);
+
+          message = `${indent}${message}`;
+
+          const fileContext = instance.getFileContext();
+
+          fileContext.writeToLog(level, message, node);
+        }
+      }
+
       if (name in instance) {
         return Reflect.get(instance, name, receiver);
       }
 
-      const context = instance.context,
+      const context = instance.getContext(),
             value = context[name];
 
       return (typeof value === FUNCTION) ?
@@ -18,3 +34,30 @@ export function chainContext(context) {
     }
   });
 }
+
+export function lineIndexFromNodeAndTokens(node, tokens, lineIndex) {
+  if (node !== null) {
+    lineIndex = 0;
+
+    const firstSignificantTokenIndex = node.getFirstSignificantTokenIndex(tokens);
+
+    tokens.some((token, tokenIndex) => {
+      const tokenEndOfLineToken = token.isEndOfLineToken();
+
+      if (tokenEndOfLineToken) {
+        lineIndex += 1;
+      }
+
+      if (tokenIndex === firstSignificantTokenIndex) {
+        return true;
+      }
+    });
+  }
+
+  return lineIndex;
+}
+
+export default {
+  chainContext,
+  lineIndexFromNodeAndTokens
+};

package/src/utilities/{string.js → node.js}

@@ -18,20 +18,21 @@ export function nodesAsString(nodes, tokens) {
   const string = nodes.reduce((string, node) => {
     const nodeString = nodeAsString(node, tokens);
 
-    string = (string === EMPTY_STRING) ?
-               nodeString :
-                `${string},${nodeString}`;
+    string = (string === null) ?
+      nodeString :
+      `${string}, ${nodeString}`;
 
     return string;
-  }, EMPTY_STRING);
+  }, null);
 
   return string;
 }
 
-export default {
-  nodeAsString,
-  nodesAsString
-};
+function trimString(string) {
+  string = string.replace(/\s+$/, EMPTY_STRING);  ///
+
+  return string;
+}
 
 function tokensAsString(tokens) {
   const string = tokens.reduce((string, token) => {
@@ -61,12 +62,6 @@ function nodeAsTokens(node, tokens) {
   return tokens;
 }
 
-function trimString(string) {
-  string = string.replace(/\s+$/, EMPTY_STRING);  ///
-
-  return string;
-}
-
 function terminalNodeAsTokens(terminalNode, tokens) {
   const significantToken = terminalNode.getSignificantToken(),
         token = significantToken; ///

package/test/Free and bound variables.ftl

@@ -0,0 +1,112 @@
+Boolean isVariableFree(Node termNode, Node statementNode) {
+  Boolean variableBound = isVariableBound(termNode, statementNode);
+
+  Boolean variableFree = !variableBound;
+
+  Return variableFree;
+}
+
+Boolean isVariableBound(Node termNode, Node statementNode) {
+  String variableIdentitifer = variableIdentitiferFromTermNode(termNode);
+
+  Boolean variableBound =
+
+    If (variableIdentitifer != "")
+      variableBoundFromVariableIdentifierAndStatementNode(variableIdentitifer, statementNode)
+
+    Else
+      false
+  ;
+
+  Return variableBound;
+}
+
+String variableIdentitiferFromTermNode(Node termNode) {
+  Node variableIdentifierTerminalNode = nodeQuery(termNode, "/term/variable!/@identifier");
+
+  String variableIdentitifer =
+
+    If (variableIdentifierTerminalNode != null) {
+      { String content As variableIdentitifer } = variableIdentifierTerminalNode;
+
+      Return variableIdentitifer;
+    }
+
+    Else
+      ""
+  ;
+
+  Return variableIdentitifer;
+}
+
+String boundVariableIdentifierFromStatementNode(Node statementNode) {
+  { Nodes childNodes As statementChildNodes } = statementNode;
+
+  [ Node firstStatementChildNode ] = statementChildNodes;
+
+  { Boolean terminal } = firstStatementChildNode;
+
+  String boundVariableIdentifier =
+
+    If (terminal)
+      boundVariableIdentifierFromStatementChildNodes(statementChildNodes)
+
+    Else
+      ""
+  ;
+
+  Return boundVariableIdentifier;
+}
+
+String boundVariableIdentifierFromStatementChildNodes(Nodes statementChildNodes) {
+  [ Node terminalNode ] = statementChildNodes;
+
+  { String content } = terminalNode;
+
+  String boundVariableIdentifier =
+
+    If ((content == "∀") || (content == "∃")) {
+      [ _, Node argumentNode ] = statementChildNodes;
+
+      String boundVariableIdentifier = boundVariableIdentifierFromArgumentNode(argumentNode);
+
+      Return boundVariableIdentifier;
+    }
+    Else
+     ""
+  ;
+
+  Return boundVariableIdentifier;
+}
+
+String boundVariableIdentifierFromArgumentNode(Node argumentNode) {
+  Node boundVariableIdentityTerminalNode = nodeQuery(argumentNode, "/argument/term/variable!/@identifier");
+
+  String boundVariableIdentifier =
+
+    If (boundVariableIdentityTerminalNode != null) {
+      { String content As boundVariableIdentifier } = boundVariableIdentityTerminalNode;
+
+      Return boundVariableIdentifier;
+    }
+
+    Else
+      ""
+  ;
+
+  Return boundVariableIdentifier;
+}
+
+Boolean variableBoundFromVariableIdentifierAndStatementNode(String variableIdentitifer, Node statementNode) {
+  Nodes statementNodes = nodesQuery(statementNode, "//statement");
+
+  Boolean variableBound = Some(statementNodes, Boolean (Node statementNode) {
+    String boundVariableIdentifier = boundVariableIdentifierFromStatementNode(statementNode);
+
+    Boolean variableBound = (boundVariableIdentifier == variableIdentitifer);
+
+    Return variableBound;
+  });
+
+  Return variableBound;
+}

package/test/context/file.js

@@ -0,0 +1,127 @@
+"use strict";
+
+const { stringUtilities, contextUtilities } = require("../../lib/index");
+
+const { nodeAsString, nodesAsString } = stringUtilities,
+      { chainContext, lineIndexFromNodeAndTokens } = contextUtilities;
+
+class FileContext {
+  constructor(context, filePath, lineIndex, node, tokens) {
+    this.context = context;
+    this.filePath = filePath;
+    this.lineIndex = lineIndex;
+    this.node = node;
+    this.tokens = tokens;
+
+    return chainContext(this);
+  }
+
+  getContext() {
+    return this.context;
+  }
+
+  getFilePath() {
+    return this.filePath;
+  }
+
+  getLineIndex() {
+    return this.lineIndex;
+  }
+
+  getNode() {
+    return this.node;
+  }
+
+  getTokens() {
+    return this.tokens;
+  }
+
+  getVariables() {
+    const variables = [];
+
+    return variables;
+  }
+
+  getProcedures() {
+    const procedures = [];
+
+    return procedures;
+  }
+
+  nodeAsString(node) {
+    const string = nodeAsString(node, this.tokens);
+
+    return string;
+  }
+
+  nodesAsString(nodes) {
+    const string = nodesAsString(nodes, this.tokens);
+
+    return string;
+  }
+
+  trace(message, node = null) {
+    const level = TRACE_LEVEL;
+
+    this.writeToLog(level, message, node);
+  }
+
+  debug(message, node = null) {
+    const level = DEBUG_LEVEL;
+
+    this.writeToLog(level, message, node);
+  }
+
+  info(message, node = null) {
+    const level = INFO_LEVEL;
+
+    this.writeToLog(level, message, node);
+  }
+
+  warning(message, node = null) {
+    const level = WARNING_LEVEL;
+
+    this.writeToLog(level, message, node);
+  }
+
+  error(message, node = null) {
+    const level = ERROR_LEVEL;
+
+    this.writeToLog(level, message, node);
+  }
+
+  writeToLog(level, message, node) {
+    const lineIndex = lineIndexFromNodeAndTokens(node, this.tokens, this.lineIndex),
+      filePath = (lineIndex === null) ?
+        this.filePath :
+        null;
+
+    this.context.writeToLog(level, message, filePath, lineIndex);
+
+    this.lineIndex = lineIndex;
+  }
+
+  getFileContext() {
+    const fileContext = this; ///
+
+    return fileContext;
+  }
+
+  getDepth() {
+    let depth = this.context.getDepth();
+
+    depth++;
+
+    return depth;
+  }
+
+  static fromNodeTokensAndFilePath(node, tokens, filePath, context) {
+    const lineIndex = null,
+          fileContext = new FileContext(context, filePath, lineIndex, node, tokens);
+
+    return fileContext;
+  }
+}
+
+module.exports = FileContext;
+

package/{src/example → test}/context/release.js

@@ -1,16 +1,25 @@
 "use strict";
 
-import { FileContext } from "../../index";  ///
-import { arrayUtilities } from "necessary";
+const { arrayUtilities } =require("necessary");
 
-const { push } = arrayUtilities;
+const { Log, FileContext } =require("../../lib/index");  ///
 
-export class ReleaseContext {
-  constructor(files, fileContexts) {
+const { LEVELS } =require("../helpers/constants");
+
+const { push } = arrayUtilities,
+      [ TRACE_LEVEL, DEBUG_LEVEL, INFO_LEVEL, WARNING_LEVEL, ERROR_LEVEL ] = LEVELS;
+
+class ReleaseContext {
+  constructor(log, files, fileContexts) {
+    this.log = log;
     this.files = files;
     this.fileContexts = fileContexts;
   }
 
+  getLog() {
+    return this.log;
+  }
+
   getFiles() {
     return this.files;
   }
@@ -72,15 +81,51 @@ export class ReleaseContext {
     return procedurePresent;
   }
 
-  trace(message) { console.log(message); }
+  trace(message, filePath = null, lineIndex = null) {
+    const level = TRACE_LEVEL;
+
+    this.writeToLog(level, message, filePath, lineIndex);
+  }
+
+  debug(message, filePath = null, lineIndex = null) {
+    const level = DEBUG_LEVEL
+
+    this.writeToLog(level, message, filePath, lineIndex);
+  }
+
+  info(message, filePath = null, lineIndex = null) {
+    const level = INFO_LEVEL;
 
-  debug(message) { console.log(message); }
+    this.writeToLog(level, message, filePath, lineIndex);
+  }
 
-  info(message) { console.log(message); }
+  warning(message, filePath = null, lineIndex = null) {
+    const level = WARNING_LEVEL;
 
-  warning(message) { console.log(message); }
+    this.writeToLog(level, message, filePath, lineIndex);
+  }
 
-  error(message) { console.log(message); }
+  error(message, filePath = null, lineIndex = null) {
+    const level = ERROR_LEVEL;
+
+    this.writeToLog(level, message, filePath, lineIndex);
+  }
+
+  writeToLog(level, message, filePath, lineIndex) {
+    this.log.write(level, message, filePath, lineIndex);
+  }
+
+  getFileContext() {
+    const fileContext = null;
+
+    return fileContext;
+  }
+
+  getDepth() {
+    const depth = -1;
+
+    return depth;
+  }
 
   verify() {
     this.files.forEach((file) => {
@@ -94,10 +139,13 @@ export class ReleaseContext {
   }
 
   static fromNothing() {
-    const files = [],
+    const log = Log.fromNothing(),
+          files = [],
           fileContexts = [],
-          releaseContext = new ReleaseContext(files, fileContexts);
+          releaseContext = new ReleaseContext(log, files, fileContexts);
 
     return releaseContext;
   }
 }
+
+module.exports = ReleaseContext;

package/test/helpers/constants.js

@@ -0,0 +1,17 @@
+"use strict";
+
+const { levels } = require("necessary");
+
+const { TRACE_LEVEL, DEBUG_LEVEL, INFO_LEVEL, WARNING_LEVEL, ERROR_LEVEL } = levels;
+
+const LEVELS = [
+  TRACE_LEVEL,
+  DEBUG_LEVEL,
+  INFO_LEVEL,
+  WARNING_LEVEL,
+  ERROR_LEVEL
+];
+
+module.exports = {
+  LEVELS
+};

package/{src/example/utilities → test/helpers}/expressions.js

@@ -1,15 +1,15 @@
 "use strict";
 
-import { Query } from "occam-query";
-import { Expressions } from "../../index"; ///
-import { arrayUtilities } from "necessary";
+const { Query } = require("occam-query"),
+      { Expressions } = require("../../lib/index"), ///
+      { arrayUtilities } = require("necessary");
 
 const { first } = arrayUtilities;
 
 const freeTermNodeQuery = Query.fromExpressionString("//term[1]"),
       boundTermNodeQuery = Query.fromExpressionString("//term[0]");
 
-export function expressionsFromFileContext(fileContext, free = true) {
+function expressionsFromFileContext(fileContext, free = true) {
   const context = fileContext,  ///
         nodes = nodesFromFileContext(fileContext, free),
         expressions = Expressions.fromNodes(nodes, context);
@@ -17,6 +17,10 @@ export function expressionsFromFileContext(fileContext, free = true) {
   return expressions;
 }
 
+module.exports = {
+  expressionsFromFileContext
+};
+
 function nodesFromFileContext(fileContext, free) {
   const termNodeQuery = free ?
                           freeTermNodeQuery :

package/{src/example/utilities → test/helpers}/furtle.js

@@ -1,12 +1,12 @@
 "use strict";
 
-import { File } from "occam-entities";
-import { fileSystemUtilities } from "necessary";
+const { File } = require("occam-entities"),
+      { fileSystemUtilities } = require("necessary");
 
 const { readFile } = fileSystemUtilities;
 
-export function furtleFileFromNothing() {
-  const filePath = "/Users/djalbat/Logic/first-order-logic/Functions/Free and bound variables.ftl",
+function furtleFileFromNothing() {
+  const filePath = "test/Free and bound variables.ftl",
         fileContent = readFile(filePath),
         path = filePath,  ///
         content = fileContent,  ///
@@ -16,3 +16,7 @@ export function furtleFileFromNothing() {
 
   return furtleFile;
 }
+
+module.exports = {
+  furtleFileFromNothing
+};