occam-verify-cli 0.0.373 → 0.0.375

package/src/premise.js

@@ -70,6 +70,17 @@ export default class Premise {
     return json;
   }
 
+  static fromJSON(json, callback) {
+    const { metastatement } = json,
+          ruleName = METASTATEMENT_RULE_NAME,
+          content = metastatement,  ///
+          node = callback(content, ruleName),
+          metastatementNode = node, ///
+          premise = new Premise(metastatementNode);
+
+    return premise;
+  }
+
   static fromMetastatementNode(metastatementNode) {
     const premise = new Premise(metastatementNode);
 

package/src/rule.js

@@ -1,5 +1,9 @@
 "use strict";
 
+import Label from "./label";
+import Premise from "./premise";
+import Conclusion from "./conclusion";
+
 import { prune } from "./utilities/array";
 import { RULE_KIND } from "./kinds";
 import { someSubArray } from "./utilities/array";
@@ -62,29 +66,57 @@ export default class Rule {
   }
 
   toJSON() {
-    const premisesJSON = this.premises.map((premise) => {
+    const labelsJSON = this.labels.map((label) => {
+            const labelJSON = label.toJSON();
+
+            return labelJSON;
+          }),
+          premisesJSON = this.premises.map((premise) => {
             const premiseJSON = premise.toJSON();
 
             return premiseJSON;
           }),
           conclusionJSON = this.conclusion.toJSON(),
           kind = RULE_KIND,
+          labels = labelsJSON,  ///
           premises = premisesJSON,  ///
           conclusion = conclusionJSON,  ///
-          json = this.labels.map((label) => {
-            const labelString = label.asString();
+          json = {
+            kind,
+            labels,
+            premises,
+            conclusion
+          };
+
+    return json;
+  }
 
-            label = labelString;  ///
+  static fromJSON(json, callback) {
+    let { labels, premises, conclusion } = json;
 
-            return ({
-              kind,
-              label,
-              premises,
-              conclusion
-            });
-          });
+    labels = labels.map((label) => {
+      const json = label; ///
 
-    return json;
+      label = Label.fromJSON(json, callback);
+
+      return label;
+    });
+
+    premises = premises.map((premise) => {
+      const json = premise; ///
+
+      premise = Premise.fromJSON(json, callback);
+
+      return premise;
+    });
+
+    json = conclusion;  ///
+
+    conclusion = Conclusion.fromJSON(json, callback);
+
+    const rule = new Rule(labels, premises, conclusion);
+
+    return rule;
   }
 
   static fromLabelsPremisesAndConclusion(labels, premises, conclusion) {

package/src/ruleNames.js

@@ -3,6 +3,7 @@
 export const TERM_RULE_NAME = "term";
 export const TYPE_RULE_NAME = "type";
 export const ARGUMENT_RULE_NAME = "argument";
+export const STATEMENT_RULE_NAME = "statement";
 export const METAVARIABLE_RULE_NAME = "metavariable";
 export const METASTATEMENT_RULE_NAME = "metastatement";
 export const META_SUBPROOF_RULE_NAME = "metaSubproof";

package/src/type.js

@@ -110,15 +110,32 @@ export default class Type {
           kind = TYPE_KIND,
           name = this.name,
           superType = superTypeJSON,  ///
-          json = [{
+          json = {
             kind,
             name,
             superType
-          }];
+          };
 
     return json;
   }
 
+  static fromJSON(json) {
+    const { name } = json;
+
+    let { superType } = json;
+
+    if (superType !== null) {
+      json = superType; ///
+
+      superType = Type.fromJSON(json);
+    }
+
+    const type = new Type(name, superType);
+
+    return type;
+  }
+
+
   static fromTypeName(typeName) {
     const name = typeName,  ///
           superType = null,

package/src/utilities/releaseContext.js

@@ -43,10 +43,39 @@ export function createReleaseContext(releaseName, dependentNames, shortenedVersi
   }, context);
 }
 
+export function initialiseReleaseContexts(releaseName, releaseContextMap) {
+  const releaseContext = releaseContextMap[releaseName];
+
+  initialiseReleaseContext(releaseContext, releaseContextMap);
+}
+
 export default {
-  createReleaseContext
+  createReleaseContext,
+  initialiseReleaseContexts
 };
 
+function initialiseReleaseContext(releaseContext, releaseContextMap) {
+  const initialised = releaseContext.isInitialised();
+
+  if (initialised) {
+    return;
+  }
+
+  const dependencies = releaseContext.getDependencies();
+
+  dependencies.forEachDependency((dependency) => {
+    const name = dependency.getName(),
+          releaseName = name, ///
+          releaseContext = releaseContextMap[releaseName];
+
+    initialiseReleaseContext(releaseContext, releaseContextMap);
+  });
+
+  const dependencyReleaseContexts = retrieveDependencyReleaseContexts(releaseContext, releaseContextMap);
+
+  releaseContext.initialise(dependencyReleaseContexts);
+}
+
 function checkCyclicDependencyExists(releaseName, dependentNames, releaseContext) {
   const dependentNamesIncludesReleaseName = dependentNames.includes(releaseName),
         cyclicDependencyExists = dependentNamesIncludesReleaseName;  ///
@@ -101,6 +130,27 @@ function createDependencyReleaseContexts(releaseContext, dependentNames, context
   }, done);
 }
 
+function retrieveDependencyReleaseContexts(releaseContext, releaseContextMap, dependencyReleaseContexts = []) {
+  const dependencies = releaseContext.getDependencies();
+
+  dependencies.forEachDependency((dependency) => {
+    const dependencyName = dependency.getName(),
+          dependencyReleaseName = dependencyName, ///
+          dependencyReleaseContext = releaseContextMap[dependencyReleaseName],
+          dependencyReleaseContextsIncludesDependencyReleaseContext = dependencyReleaseContexts.includes(dependencyReleaseContext);
+
+    if (!dependencyReleaseContextsIncludesDependencyReleaseContext) {
+      const releaseContext = dependencyReleaseContext;  ///
+
+      retrieveDependencyReleaseContexts(releaseContext, releaseContextMap, dependencyReleaseContexts);
+
+      dependencyReleaseContexts.push(dependencyReleaseContext);
+    }
+  });
+
+  return dependencyReleaseContexts;
+}
+
 function checkReleaseMatchesShortenedVersion(releaseContext, shortenedVersion) {
   const entries = releaseContext.getEntries(),
         releaseMatchesShortedVersion = entries.matchShortenedVersion(shortenedVersion);

package/src/verify/release.js

@@ -14,7 +14,7 @@ export default function verifyRelease(releaseName, releaseContextMap) {
     const dependencyReleasesVVerified = verifyDependencyReleases(releaseContext, releaseContextMap);
 
     if (dependencyReleasesVVerified) {
-      const releaseFilesVerified = verifyReleaseFiles(releaseContext, releaseContextMap);
+      const releaseFilesVerified = verifyReleaseFiles(releaseContext);
 
       if (releaseFilesVerified) {
         releaseVerified = true;
@@ -33,19 +33,7 @@ export default function verifyRelease(releaseName, releaseContextMap) {
   return releaseVerified;
 }
 
-function verifyReleaseFiles(releaseContext, releaseContextMap) {
-  const dependencies = releaseContext.getDependencies(),
-        releaseContexts = dependencies.mapDependency((dependency) => {
-          const name = dependency.getName(),
-                releaseName = name, ///
-                releaseContext = releaseContextMap[releaseName];
-
-          return releaseContext;
-        }),
-        dependencyReleaseContexts = retrieveDependencyReleaseContexts(dependencies, releaseContextMap);
-
-  releaseContext.initialise(releaseContexts, dependencyReleaseContexts);
-
+function verifyReleaseFiles(releaseContext) {
   const filesVerified = verifyFiles(releaseContext),
         releaseFilesVerified = filesVerified; ///
 
@@ -66,23 +54,3 @@ function verifyDependencyReleases(releaseContext, releaseContextMap) {
 
   return dependencyReleasesVVerified;
 }
-
-function retrieveDependencyReleaseContexts(dependencies, releaseContextMap, dependencyReleaseContexts = []) {
-  dependencies.forEachDependency((dependency) => {
-    const dependencyName = dependency.getName(),
-          dependencyReleaseName = dependencyName, ///
-          dependencyReleaseContext = releaseContextMap[dependencyReleaseName],
-          dependencyReleaseContextsIncludesDependencyReleaseContext = dependencyReleaseContexts.includes(dependencyReleaseContext);
-
-    if (!dependencyReleaseContextsIncludesDependencyReleaseContext) {
-      const releaseContext = dependencyReleaseContext,  ///
-            dependencies = releaseContext.getDependencies();
-
-      retrieveDependencyReleaseContexts(dependencies, releaseContextMap, dependencyReleaseContexts);
-
-      dependencyReleaseContexts.push(dependencyReleaseContext);
-    }
-  });
-
-  return dependencyReleaseContexts;
-}