occam-furtle 2.0.342 → 3.0.2

package/src/utilities/term.js

@@ -8,8 +8,13 @@ export function termFromNode(node, context) {
   const { Term } = elements,
         variable = null,
         primitive = primitiveFromNode(node, context),
-        string = primitive.getString(),
-        term = new Term(string, variable, primitive);
+        string = primitive.getString();
+
+  node = null;
+
+  context = null;
+
+  const term = new Term(context, string, node, variable, primitive);
 
   return term;
 }
@@ -19,7 +24,11 @@ export function termFromNodes(nodes, context) {
         variable = null,
         primitive = primitiveFromNodes(nodes, context),
         string = primitive.getString(),
-        term = new Term(string, variable, primitive);
+        node = null;
+
+  context = null;
+
+  const term = new Term(context, string, node, variable, primitive);
 
   return term;
 }
@@ -29,7 +38,11 @@ export function termFromBoolean(boolean, context) {
         variable = null,
         primitive = primitiveFromBoolean(boolean, context),
         string = primitive.getString(),
-        term = new Term(string, variable, primitive);
+        node = null;
+
+  context = null;
+
+  const term = new Term(context, string, node, variable, primitive);
 
   return term;
 }
@@ -39,7 +52,11 @@ export function termFromStringLiteral(stringLiteral, context) {
         variable = null,
         primitive = primitiveFromStringLiteral(stringLiteral, context),
         string = primitive.getString(),
-        term = new Term(string, variable, primitive);
+        node = null;
+
+  context = null;
+
+  const term = new Term(context, string, node, variable, primitive);
 
   return term;
 }

package/src/utilities/terms.js

@@ -10,8 +10,12 @@ export function termsFromNodes(nodes, context) {
         termsArray = termsArrayFromNodes(nodes, context),
         termsString = termsStringFromTermsArray(termsArray),
         string = termsString, ///
-        array = termsArray, ///
-        terms = new Terms(string, array);
+        array = termsArray,  ///
+        node = null;
+
+  context = null;
+
+  const terms = new Terms(context, string, node, array);
 
   return terms;
 }
@@ -23,8 +27,12 @@ export function termsFromExpression(term, context) {
         ],
         termsString = termsStringFromTermsArray(termsArray),
         string = termsString, ///
-        array = termsArray, ///
-        terms = new Primitives(string, array);
+        array = termsArray,  ///
+        node = null;
+
+  context = null;
+
+  const terms = new Primitives(context, string, node, array);
 
   return terms;
 }

package/test/context/release.js

@@ -1,39 +1,255 @@
 "use strict";
 
-const { arrayUtilities } =require("necessary");
+import { arrayUtilities } from "necessary";
 
-const { Log, FileContext } =require("../../lib/index");  ///
+import { filePathUtilities } from "occam-model";
+import { FurtleFileContext } from "../../lib/index";  ///
+import { lexersUtilities, parsersUtilities } from "occam-custom-grammars";
 
-const { LEVELS } =require("../helpers/constants");
+import  from "../context/file/furtle";
 
-const { push } = arrayUtilities,
+import { LEVELS } from "../constants";
+import { getMetaTypes } from "../metaTypes";
+import { customGrammarFromNameAndEntries, combinedCustomGrammarFromReleaseContexts } from "../utilities/customGrammar";
+
+const { nominalLexerFromCombinedCustomGrammar } = lexersUtilities,
+      { nominalParserFromCombinedCustomGrammar } = parsersUtilities,
+      { tail, push, first, clear, resolve } = arrayUtilities,
+      { isFilePathFurtleFilePath, isFilePathNominalFilePath } = filePathUtilities,
       [ TRACE_LEVEL, DEBUG_LEVEL, INFO_LEVEL, WARNING_LEVEL, ERROR_LEVEL ] = LEVELS;
 
-class ReleaseContext {
-  constructor(log, files, fileContexts) {
+export default class ReleaseContext {
+  constructor(log, name, json, entries, lexer, parser, verified, initialised, fileContexts, customGrammar, dependencyReleaseContexts) {
     this.log = log;
-    this.files = files;
+    this.name = name;
+    this.json = json;
+    this.entries = entries;
+    this.lexer = lexer;
+    this.parser = parser;
+    this.verified = verified;
+    this.initialised = initialised;
     this.fileContexts = fileContexts;
+    this.customGrammar = customGrammar;
+    this.dependencyReleaseContexts = dependencyReleaseContexts;
   }
 
   getLog() {
-    return this.log;
+    return log;
+  }
+
+  getName() {
+    return this.name;
+  }
+
+  getJSON() {
+    return this.json;
+  }
+
+  getEntries() {
+    return this.entries;
   }
 
-  getFiles() {
-    return this.files;
+  getLexer() {
+    return this.lexer;
+  }
+
+  getParser() {
+    return this.parser;
+  }
+
+  getMetaTypes() {
+    const metaTypes = getMetaTypes();
+
+    return metaTypes;
+  }
+
+  isVerified() {
+    return this.verified;
+  }
+
+  isInitialised() {
+    return this.initialised;
   }
 
   getFileContexts() {
     return this.fileContexts;
   }
 
-  addFile(file) {
-    this.files.push(file);
+  getCustomGrammar() {
+    return this.customGrammar;
   }
 
-  addFileContext(fileContext) {
-    this.fileContexts.push(fileContext);
+  getDependencyReleaseContexts() {
+    return this.dependencyReleaseContexts;
+  }
+
+  isReleased() {
+    const released = (this.json !== null);
+
+    return released;
+  }
+
+  findFile(filePath) { return this.entries.findFile(filePath); }
+
+  findFileContext(filePath) {
+    const fileContext = this.fileContexts.find((fileContext) => {
+      const fileContextFilePath = fileContext.getFilePath();
+
+      if (fileContextFilePath === filePath) {
+        return true;
+      }
+    });
+
+    return fileContext;
+  }
+
+  getTypePrefix() {
+    let typePrefix = null;
+
+    const includeDependencies = false,
+          typePrefixes = this.getTypePrefixes(includeDependencies),
+          typePrefixesLength = typePrefixes.length;
+
+    if (typePrefixesLength === 1) {
+      const firstTypePrefix = first(typePrefixes);
+
+      typePrefix = firstTypePrefix; ///
+    }
+
+    return typePrefix;
+  }
+
+  getLabels(includeDependencies = true) {
+    const labels = [];
+
+    this.fileContexts.forEach((fileContext) => {
+      const includeRelease = false,
+            fileContextLabels = fileContext.getLabels(includeRelease);
+
+      push(labels, fileContextLabels);
+    });
+
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextLabels = releaseContext.getLabels(includeDependencies);
+
+        push(labels, releaseContextLabels);
+      });
+    }
+
+    return labels;
+  }
+
+  getTypes(includeDependencies = true) {
+    const types = [];
+
+    this.fileContexts.forEach((fileContext) => {
+      const includeRelease = false,
+            fileContextTypes = fileContext.getTypes(includeRelease);
+
+      push(types, fileContextTypes);
+    });
+
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextTypes = releaseContext.getTypes(includeDependencies);
+
+        push(types, releaseContextTypes);
+      });
+    }
+
+    return types;
+  }
+
+  getRules(includeDependencies = true) {
+    const rules = [];
+
+    this.fileContexts.forEach((fileContext) => {
+      const includeRelease = false,
+            fileContextRules = fileContext.getRules(includeRelease);
+
+      push(rules, fileContextRules);
+    });
+
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextRules = releaseContext.getRules(includeDependencies);
+
+        push(rules, releaseContextRules);
+      });
+    }
+
+    return rules;
+  }
+
+  getAxioms(includeDependencies = true) {
+    const axioms = [];
+
+    this.fileContexts.forEach((fileContext) => {
+      const includeRelease = false,
+            fileContextAxioms = fileContext.getAxioms(includeRelease);
+
+      push(axioms, fileContextAxioms);
+    });
+
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextAxioms = releaseContext.getAxioms(includeDependencies);
+
+        push(axioms, releaseContextAxioms);
+      });
+    }
+
+    return axioms;
+  }
+
+  getLemmas(includeDependencies = true) {
+    const lemmas = [];
+
+    this.fileContexts.forEach((fileContext) => {
+      const includeRelease = false,
+            fileContextLemmas = fileContext.getLemmas(includeRelease);
+
+      push(lemmas, fileContextLemmas);
+    });
+
+    return lemmas;
+  }
+
+  getTheorems(includeDependencies = true) {
+    const theorems = [];
+
+    this.fileContexts.forEach((fileContext) => {
+      const includeRelease = false,
+            fileContextTheorems = fileContext.getTheorems(includeRelease);
+
+      push(theorems, fileContextTheorems);
+    });
+
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextTheorems = releaseContext.getTheorems(includeDependencies);
+
+        push(theorems, releaseContextTheorems);
+      });
+    }
+
+    return theorems;
   }
 
   getProcedures(includeDependencies = true) {
@@ -46,41 +262,174 @@ class ReleaseContext {
       push(procedures, fileContextProcedures);
     });
 
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+          releaseContextProcedures = releaseContext.getProcedures(includeDependencies);
+
+        push(procedures, releaseContextProcedures);
+      });
+    }
+
     return procedures;
   }
 
-  findFile(filePath) {
-    const file = this.files.find((file) => {
-      const filePathMatches = file.matchFilePath(filePath);
+  getMetaLemmas(includeDependencies = true) {
+    const metaLemmas = [];
 
-      if (filePathMatches) {
-        return true;
-      }
-    }) || null;
+    this.fileContexts.forEach((fileContext) => {
+      const includeRelease = false,
+            fileContextMetaLemmas = fileContext.getMetaLemmas(includeRelease);
+
+      push(metaLemmas, fileContextMetaLemmas);
+    });
 
-    return file;
+    return metaLemmas;
   }
 
-  findProcedureByName(name) {
-    const procedures = this.getProcedures(),
-          procedure = procedures.find((procedure) => {
-            const nameMatches = procedure.matchName(name);
+  getConjectures(includeDependencies = true) {
+    const conjectures = [];
 
-            if (nameMatches) {
-              return true;
-            }
-          }) || null;
+    this.fileContexts.forEach((fileContext) => {
+      const includeRelease = false,
+            fileContextConjectures = fileContext.getConjectures(includeRelease);
 
-    return procedure;
+      push(conjectures, fileContextConjectures);
+    });
+
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextConjectures = releaseContext.getConjectures(includeDependencies);
+
+        push(conjectures, releaseContextConjectures);
+      });
+    }
+
+    return conjectures;
   }
 
-  isProcedurePresentByName(name) {
-    const procedure = this.findProcedureByName(name),
-          procedurePresent = (procedure !== null);
+  getCombinators(includeDependencies = true) {
+    const combinators = [];
+
+    this.fileContexts.forEach((fileContext) => {
+      const includeRelease = false,
+            fileContextCombinators = fileContext.getCombinators(includeRelease);
+
+      push(combinators, fileContextCombinators);
+    });
+
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextCombinators = releaseContext.getCombinators(includeDependencies);
+
+        push(combinators, releaseContextCombinators);
+      });
+    }
 
-    return procedurePresent;
+    return combinators;
   }
 
+  getTypePrefixes(includeDependencies = true) {
+    const typePrefixes = [];
+
+    this.fileContexts.forEach((fileContext) => {
+      const includeRelease = false,
+            fileContextTypePrefixes = fileContext.getTypePrefixes(includeRelease);
+
+      push(typePrefixes, fileContextTypePrefixes);
+    });
+
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextTypePrefixes = releaseContext.getTypePrefixes(includeDependencies);
+
+        push(typePrefixes, releaseContextTypePrefixes);
+      });
+    }
+
+    return typePrefixes;
+  }
+
+  getConstructors(includeDependencies = true) {
+    const constructors = [];
+
+    this.fileContexts.forEach((fileContext) => {
+      const includeRelease = false,
+            fileContextConstructors = fileContext.getConstructors(includeRelease);
+
+      push(constructors, fileContextConstructors);
+    });
+
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextConstructors = releaseContext.getConstructors(includeDependencies);
+
+        push(constructors, releaseContextConstructors);
+      });
+    }
+
+    return constructors;
+  }
+
+  getMetatheorems(includeDependencies = true) {
+    const metatheorems = [];
+
+    this.fileContexts.forEach((fileContext) => {
+      const includeRelease = false,
+            fileContextMetatheorems = fileContext.getMetatheorems(includeRelease);
+
+      push(metatheorems, fileContextMetatheorems);
+    });
+
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextMetatheorems = releaseContext.getMetatheorems(includeDependencies);
+
+        push(metatheorems, releaseContextMetatheorems);
+      });
+    }
+
+    return metatheorems;
+  }
+
+  addFileContext(fileContext) {
+    this.fileContexts.push(fileContext);
+  }
+
+  getReleaseName() {
+    const name = this.getName(),
+          releaseName = name; ///
+
+    return releaseName;
+  }
+
+  getFile(filePath) { return this.entries.getFile(filePath); }
+
+  getVersion() { return this.entries.getVersion(); }
+
+  getFilePaths() { return this.entries.getFilePaths(); }
+
+  getDependencies() { return this.entries.getDependencies(); }
+
+  matchShortenedVersion(shortenedVersion) { return this.entries.matchShortenedVersion(shortenedVersion); }
+
   trace(message, filePath = null, lineIndex = null) {
     const level = TRACE_LEVEL;
 
@@ -127,25 +476,107 @@ class ReleaseContext {
     return depth;
   }
 
+  initialise(releaseContexts) {
+    const combinedCustomGrammar = combinedCustomGrammarFromReleaseContexts(releaseContexts),
+          nominalLexer = nominalLexerFromCombinedCustomGrammar(NominalLexer, combinedCustomGrammar),
+          nominalParser = nominalParserFromCombinedCustomGrammar(NominalParser, combinedCustomGrammar),
+          releaseContext = this,  ///
+          released = this.isReleased();
+
+    this.dependencyReleaseContexts = tail(releaseContexts); ///
+
+    this.lexer = nominalLexer; ///
+
+    this.parser = nominalParser; ///
+
+    clear(this.fileContexts);
+
+    released ?
+      fileContextsFromJSON(this.json, this.fileContexts, releaseContext) :
+        fileContextsFromEntries(this.entries, this.fileContexts, releaseContext);
+
+    this.initialised = true;
+  }
+
   verify() {
-    this.files.forEach((file) => {
-      const context = this, ///
-            fileContext = FileContext.fromFile(file, context);
+    let verifies = false;
 
-      fileContext.verify();
+    const typePrefixes = this.getTypePrefixes(),
+          releaseContext = this, ///
+          typePrefixesVerify = verifyTypePrefixes(typePrefixes, releaseContext);
 
-      this.fileContexts.push(fileContext);
-    });
+    if (typePrefixesVerify) {
+      const verifiedFileContexts = [],
+            fileContextsVerify = verifyFileContexts(this.fileContexts, verifiedFileContexts, releaseContext);
+
+      if (fileContextsVerify) {
+        this.fileContexts = verifiedFileContexts; ///
+
+        this.verified = true;
+
+        verifies = true;
+      }
+    }
+
+    return verifies;
+  }
+
+  toJSON() {
+    const fileContextsJSON = this.fileContexts.map((fileContext) => {
+            const fileContextJSON = fileContext.toJSON();
+
+            return fileContextJSON;
+          }),
+          json = fileContextsJSON;  ///
+
+    return json;
   }
 
-  static fromNothing() {
-    const log = Log.fromNothing(),
-          files = [],
+  static fromLogNameJSONAndEntries(log, name, json, entries) {
+    const lexer = null,
+          parser = null,
+          verifies = false,
+          initialised = false,
           fileContexts = [],
-          releaseContext = new ReleaseContext(log, files, fileContexts);
+          customGrammar = customGrammarFromNameAndEntries(name, entries),
+          dependencyReleaseContexts = null,
+          releaseContext = new ReleaseContext(log, name, json, entries, lexer, parser, verifies, initialised, fileContexts, customGrammar, dependencyReleaseContexts);
 
     return releaseContext;
   }
 }
 
-module.exports = ReleaseContext;
+function verifyFileContexts(fileContexts, verifiedFileContexts) {
+  const resolved = resolve(fileContexts, verifiedFileContexts, (fileContext) => {
+          const fileContextVerifies = fileContext.verify();
+
+          if (fileContextVerifies) {
+            return true;
+          }
+        }),
+        fileContextsVerify = resolved;  ///
+
+  return fileContextsVerify;
+}
+
+function fileContextsFromEntries(entries, fileContexts, releaseContext) {
+  entries.forEachFile((file) => {
+    const filePath = file.getPath(),
+          filePathFurtleFilePath = isFilePathFurtleFilePath(filePath),
+          filePathNominalFilePath = isFilePathNominalFilePath(filePath);
+
+    if (filePathFurtleFilePath) {
+      const furtleFileContext = FurtleFileContext.fromFile(file, releaseContext),
+            fileContext = furtleFileContext;  ///
+
+      fileContexts.push(fileContext);
+    }
+
+    if (filePathNominalFilePath) {
+      const context = releaseContext, ///
+            fileContext = NominalFileContext.fromFile(file, context);
+
+      fileContexts.push(fileContext);
+    }
+  });
+}

package/test/helpers/furtle.js

@@ -1,6 +1,6 @@
 "use strict";
 
-const { File } = require("occam-entities"),
+const { File } = require("occam-model"),
       { fileSystemUtilities } = require("necessary");
 
 const { readFile } = fileSystemUtilities;

package/test/helpers/nominal.js

@@ -1,9 +1,8 @@
 "use strict";
 
+const { NominalFileContext } = require("../../lib/index"); ///
 const { lexersUtilities, parsersUtilities } = require("occam-custom-grammars");
 
-const FileContext = require("../context/file");
-
 const { combinedCustomGrammarFromNothing } = require("../helpers/grammar");
 
 const { nominalLexerFromCombinedCustomGrammar } = lexersUtilities,
@@ -21,7 +20,7 @@ function nominalFileContextFromReleaseContext(releaseContext) {
         node = parser.parse(tokens),
         context = releaseContext, ///
         filePath = "lemmas.nml",
-        fileContext = FileContext.fromNodeTokensAndFilePath(node, tokens, filePath, context),
+        fileContext = NominalFileContext.fromFilePathNodeAndTokens(filePath, tokens, node, context),
         nominalFileContext = fileContext;  ///
 
   return nominalFileContext;

package/test/main.js

@@ -1,6 +1,6 @@
 "use strict";
 
-const ReleaseContext = require("./context/release");
+const { ReleaseContext } = require("../lib/index"); ///
 
 const { termsFromFileContext } = require("./helpers/terms"),
       { furtleFileFromNothing } = require("./helpers/furtle"),