occam-furtle 2.0.279 → 2.0.282

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

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

@@ -1,12 +1,12 @@
 "use strict";
 
-import { fileSystemUtilities } from "necessary";
-import { CustomGrammar, CombinedCustomGrammar } from "occam-custom-grammars";
+const { fileSystemUtilities } = require("necessary"),
+      { CustomGrammar, CombinedCustomGrammar } = require("occam-custom-grammars");
 
 const { readFile } = fileSystemUtilities;
 
-export function combinedCustomGrammarFromNothing() {
-  const filePath = "example/customGrammars.json",
+function combinedCustomGrammarFromNothing() {
+  const filePath = "test/customGrammars.json",
         fileContent = readFile(filePath),
         json = JSON.parse(fileContent),
         customGrammars = customGrammarsFromJSON(json),
@@ -16,6 +16,10 @@ export function combinedCustomGrammarFromNothing() {
   return combinedCustomGrammar;
 }
 
+module.exports = {
+  combinedCustomGrammarFromNothing
+};
+
 function customGrammarsFromJSON(json) {
   const customGrammarsJSON = json,  ///
         customGrammars = customGrammarsJSON.map((customGrammarsJSON) => {

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

@@ -1,15 +1,15 @@
 "use strict";
 
-import { lexersUtilities, parsersUtilities } from "occam-custom-grammars";
+const { lexersUtilities, parsersUtilities } = require("occam-custom-grammars");
 
-import FileContext from "../context/file";
+const FileContext = require("../context/file");
 
-import { combinedCustomGrammarFromNothing } from "../utilities/grammar";
+const { combinedCustomGrammarFromNothing } = require("../helpers/grammar");
 
 const { nominalLexerFromCombinedCustomGrammar } = lexersUtilities,
       { nominalParserFromStartRuleNameAndCombinedCustomGrammar } = parsersUtilities;
 
-export function nominalFileContextFromReleaseContext(releaseContext) {
+function nominalFileContextFromReleaseContext(releaseContext) {
   const content = `∀n m = m`,
         startRuleName = "statement",
         combinedCustomGrammar = combinedCustomGrammarFromNothing(),
@@ -20,8 +20,13 @@ export function nominalFileContextFromReleaseContext(releaseContext) {
         tokens = lexer.tokenise(content),
         node = parser.parse(tokens),
         context = releaseContext, ///
-        fileContext = FileContext.fromNodeAndTokens(node, tokens, context),
+        filePath = "lemmas.nml",
+        fileContext = FileContext.fromNodeTokensAndFilePath(node, tokens, filePath, context),
         nominalFileContext = fileContext;  ///
 
   return nominalFileContext;
 }
+
+module.exports = {
+  nominalFileContextFromReleaseContext
+};

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

@@ -1,13 +1,17 @@
 "use strict";
 
-import { arrayUtilities } from "necessary";
+const { arrayUtilities } = require("necessary");
 
 const { first } = arrayUtilities;
 
-export function procedureFromReleaseContext(releaseContext) {
+function procedureFromReleaseContext(releaseContext) {
   const procedures = releaseContext.getProcedures(),
         firstProcedure = first(procedures),
         procedure = firstProcedure; ///
 
   return procedure;
 }
+
+module.exports = {
+  procedureFromReleaseContext
+};

package/test/main.js

@@ -0,0 +1,55 @@
+"use strict";
+
+const { assert } = require("chai");
+
+const ReleaseContext = require("./context/release");
+
+const { furtleFileFromNothing } = require("./helpers/furtle"),
+      { expressionsFromFileContext } = require("./helpers/expressions"),
+      { procedureFromReleaseContext } = require("./helpers/procedure"),
+      { nominalFileContextFromReleaseContext } = require("./helpers/nominal");
+
+describe("src/eliminateLeftRecursion", () => {
+  let fileContext,
+      releaseContext;
+
+  before(() => {
+    releaseContext = ReleaseContext.fromNothing();
+
+    const furtleFile = furtleFileFromNothing(),
+          file = furtleFile;  ///
+
+    releaseContext.addFile(file);
+
+    releaseContext.verify();
+  });
+
+  before(() => {
+    const nominalFileContext = nominalFileContextFromReleaseContext(releaseContext);
+
+    fileContext = nominalFileContext; ///
+
+    releaseContext.addFileContext(fileContext);
+  });
+
+  it("returns true", () => {
+    const free = true,
+          procedure = procedureFromReleaseContext(releaseContext),
+          expressions = expressionsFromFileContext(fileContext, free);
+
+// try {
+    const context = fileContext,  ///
+          expression = procedure.call(expressions, context),
+          boolean = expression.getBoolean();
+
+    assert.isTrue(boolean);
+
+    console.log(boolean);
+// } catch (exception) {
+//   const message = exception.getMessage();
+//
+//   console.log(message);
+// }
+
+  });
+});

package/example/Free and bound variables.ftl

@@ -1,75 +0,0 @@
-Boolean isVariableFree(Node termNode, Node statementNode) {
-  Boolean variableFree = true;
-
-  Boolean variableBound = isVariableBound(termNode, statementNode);
-
-  If (variableBound) {
-    variableFree = false;
-  }
-
-  Return variableFree;
-}
-
-Boolean isVariableBound(Node termNode, Node statementNode) {
-  Boolean variableBound = false;
-
-  String variableName = variableNameFromTermNode(termNode);
-
-  If (variableName != "") {
-    Nodes statementNodes = nodesQuery(statementNode, //statement);
-
-    ForEach(statementNodes, (Node statementNode) {
-      If (!variableBound) {
-        String boundVariableName = boundVariableNameFromStatementNode(statementNode);
-
-        If (boundVariableName == variableName) {
-          variableBound = true;
-        }
-      }
-    });
-  }
-
-  Return variableBound;
-}
-
-String variableNameFromTermNode(Node termNode) {
-  String variableName = "";
-
-  Node variableIdentifierTerminalNode = nodeQuery(termNode, /term/variable/@identifier);
-
-  If (variableIdentifierTerminalNode != null) {
-    { String content } = variableIdentifierTerminalNode;
-
-    variableName = content;
-  }
-
-  Return variableName;
-}
-
-String boundVariableNameFromStatementNode(Node statementNode) {
-  String boundVariableName = "";
-
-  { Nodes childNodes } = statementNode;
-
-  [ Node firstChildNode ] = childNodes;
-
-  { Boolean terminal } = firstChildNode;
-
-  If (terminal) {
-    { String content } = firstChildNode;
-
-    If ((content == "∀") || (content == "∃")) {
-      [ _, Node argumentNode ] = childNodes;
-
-      Node boundVariableIdentifierTerminalNode = nodeQuery(argumentNode, /argument/term/variable!/@identifier);
-
-      If (boundVariableIdentifierTerminalNode != null) {
-        { String content } = boundVariableIdentifierTerminalNode;
-
-        boundVariableName = content;
-      }
-    }
-  }
-
-  Return boundVariableName;
-}