occam-verify-cli 0.0.333 → 0.0.335

package/src/axiom.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import { labelsAsString } from "./utilities/string";
+import {nodeAsString} from "./utilities/string";
 
 export default class Axiom {
   constructor(labels, statementNode, suppositionStatementNode, consequentStatementNode) {
@@ -26,10 +26,46 @@ export default class Axiom {
     return this.consequentStatementNode;
   }
 
-  asString() {
-    const string = labelsAsString(this.labels);
+  matchLabelName(labelName) {
+    const matchesLabelName = this.labels.some((label) => {
+      const name = labelName, ///
+            labelMatchesName = label.matchName(name);
 
-    return string;
+      if (labelMatchesName) {
+        return true;
+      }
+    });
+
+    return matchesLabelName;
+  }
+
+  toString() {
+    const labelsJSON = this.labels.map((label) => {
+            const labelJSON = label.asJSON();
+
+            return labelJSON;
+          }),
+          statementString = (this.statementNode === null) ?
+                               null :
+                                 nodeAsString(this.statementNode),
+          consequentStatementString = (this.consequentStatementNode === null) ?
+                                         null :
+                                           nodeAsString(this.consequentStatementNode),
+          suppositionStatementString = (this.suppositionStatementNode === null) ?
+                                          null :
+                                            nodeAsString(this.suppositionStatementNode),
+          labels = labelsJSON,  ///
+          statement = statementString,  ///
+          consequent = consequentStatementString, ///
+          supposition = suppositionStatementString, ///
+          json = {
+            labels,
+            statement,
+            consequent,
+            supposition
+          };
+
+    return json;
   }
 
   static fromStatementNodeAndLabels(statementNode, labels) {

package/src/combinator.js

@@ -17,6 +17,16 @@ export default class Combinator {
     return string;
   }
 
+  toJSON() {
+    const statementString = nodeAsString(this.statementNode),
+          statement = statementString,  ///
+          json = {
+            statement
+          };
+
+    return json;
+  }
+
   static fromStatementNode(statementNode) {
     const combinator = new Combinator(statementNode);
 

package/src/conclusion.js

@@ -1,6 +1,7 @@
 "use strict";
 
 import { first } from "./utilities/array";
+import { nodeAsString } from "./utilities/string";
 import { metavariableNameFromMetavariableNode } from "./utilities/query";
 import { METAVARIABLE_RULE_NAME, METASTATEMENT_RULE_NAME } from "./ruleNames";
 
@@ -22,6 +23,16 @@ export default class Conclusion {
     return metastatementNodeMatches;
   }
 
+  toJSON() {
+    const metastatementString = nodeAsString(this.metastatementNode),
+          metastatement = metastatementString,  ///
+          json = {
+            metastatement
+          };
+
+    return json;
+  }
+
   static fromMetastatementNode(metastatementNode) {
     const conclusion = new Conclusion(metastatementNode);
 

package/src/constructor.js

@@ -33,6 +33,21 @@ export default class Constructor {
     return string;
   }
 
+  toJSON() {
+    const termString = nodeAsString(this.termNode),
+          typeJSON = (this.type === null) ?
+                        null :
+                          this.type.toJSON(),
+          term = termString,  ///
+          type = typeJSON,  ///
+          json = {
+            term,
+            type
+          };
+
+    return json;
+  }
+
   static fromTermNodeAndType(termNode, type) {
     const constructor = new Constructor(termNode, type);
 

package/src/context/file.js

@@ -41,6 +41,27 @@ class FileContext {
     return this.variables;
   }
 
+  getLabels() {
+    const labels = [];
+
+    const rules = this.getRules(),
+          axioms = this.getAxioms();
+
+    rules.forEach((rule) => {
+      const ruleLabels = rule.getLabels();
+
+      push(labels, ruleLabels);
+    });
+
+    axioms.forEach((axiom) => {
+      const axiomLabels = axiom.getLabels();
+
+      push(labels, axiomLabels);
+    });
+
+    return labels;
+  }
+
   getRules(bubble = true) {
     const rules = [
       ...this.rules
@@ -136,14 +157,27 @@ class FileContext {
     return type;
   }
 
+  findLabelByLabelName(labelName) {
+    const name = labelName,  ///
+          labels = this.getLabels(),
+          label = labels.find((label) => {
+            const matches = label.matchName(name);
+
+            if (matches) {
+              return true;
+            }
+          }) || null;
+
+    return label;
+  }
+
   findRuleByReferenceName(referenceName) {
-    const label = referenceName,  ///
+    const labelName = referenceName,  ///
           rules = this.getRules(),
           rule = rules.find((rule) => {
-            const ruleLabels = rule.getLabels(),
-                  ruleLabelsIncludesLabel = ruleLabels.includes(label);
+            const ruleMatchesLabelName = rule.matchLabelName(labelName);
 
-            if (ruleLabelsIncludesLabel) {
+            if (ruleMatchesLabelName) {
               return true;
             }
           }) || null;
@@ -152,13 +186,12 @@ class FileContext {
   }
 
   findAxiomByReferenceName(referenceName) {
-    const label = referenceName,  ///
+    const labelName = referenceName,  ///
           axioms = this.getAxioms(),
           axiom = axioms.find((axiom) => {
-            const axiomLabels = axiom.getLabels(),
-                axiomLabelsIncludesLabel = axiomLabels.includes(label);
+            const axiomMatchesLabelName = axiom.matchLabelName(labelName);
 
-            if (axiomLabelsIncludesLabel) {
+            if (axiomMatchesLabelName) {
               return true;
             }
           }) || null;
@@ -180,14 +213,6 @@ class FileContext {
     return variable;
   }
 
-  isLabelPresent(label) {
-    const labels = this.getLabels(),
-        labelsIncludesLabel = labels.includes(label),
-        labelPresent = labelsIncludesLabel; ///
-
-    return labelPresent;
-  }
-
   isTypePresentByTypeName(typeName) {
     const type = this.findTypeByTypeName(typeName),
         typePresent = (type !== null);
@@ -195,24 +220,18 @@ class FileContext {
     return typePresent;
   }
 
-  isVariablePresentByVariableName(variableName) {
-    const variable = this.findVariableByVariableName(variableName),
-        variablePresent = (variable !== null);
+  isLabelPresentByLabelName(labelName) {
+    const label = this.findLabelByLabelName(labelName),
+          labelPresent = (label !== null);
 
-    return variablePresent;
+    return labelPresent;
   }
 
-  getLabels() {
-    const axioms = this.getAxioms(),
-          labels = axioms.reduce((labels, axiom) => {
-            const axiomLabels = axiom.getLabels();
-
-            push(labels, axiomLabels);
-
-            return labels;
-          }, []);
+  isVariablePresentByVariableName(variableName) {
+    const variable = this.findVariableByVariableName(variableName),
+          variablePresent = (variable !== null);
 
-    return labels;
+    return variablePresent;
   }
 
   addType(type) {
@@ -260,6 +279,51 @@ class FileContext {
     this.context.complete(this.filePath, leastLineIndex, greatestLineIndex);
   }
 
+  toJSON() {
+    const filePath = this.getFilePath(),
+          rulesJSON = this.rules.map((rule) => {
+            const ruleJSON = rule.toJSON(this.tokens);
+
+            return ruleJSON;
+          }),
+          typesJSON = this.types.map((type) => {
+            const typeJSON = type.toJSON(this.tokens);
+
+            return typeJSON;
+          }),
+          axiomsJSON = this.axioms.map((axiom) => {
+            const axiomJSON = axiom.toJSON(this.tokens);
+
+            return axiomJSON;
+          }),
+          combinatorsJSON = this.combinators.map((combinator) => {
+            const combinatorJSON = combinator.toJSON(this.tokens);
+
+            return combinatorJSON;
+          }),
+          constructorsJSON = this.constructors.map((constructor) => {
+            const constructorJSON = constructor.toJSON(this.tokens);
+
+            return constructorJSON;
+          }),
+          path = filePath,  ///
+          rules = rulesJSON,  ///
+          types = typesJSON,  ///
+          axioms = axiomsJSON,  ///
+          combinators = combinatorsJSON,  ///
+          constructors = constructorsJSON,  ///
+          json = {
+            path,
+            rules,
+            types,
+            axioms,
+            combinators,
+            constructors
+          };
+
+    return json;
+  }
+
   static fromReleaseContextAndFilePath(releaseContext, filePath) {
     const file = releaseContext.getFile(filePath),
           content = file.getContent(),

package/src/context/release.js

@@ -247,6 +247,20 @@ export default class ReleaseContext {
     this.releaseContexts = releaseContexts;
   }
 
+  toJSON() {
+    const fileContextsJSON = this.fileContexts.map((fileContext) => {
+            const fileContextJSON = fileContext.toJSON();
+
+            return fileContextJSON;
+          }),
+          files = fileContextsJSON, ///
+          json = {
+            files
+          };
+
+    return json;
+  }
+
   static fromLogReleaseAndCallbacks(log, release, callbacks, ...remainingArguments) {
     const verified = false,
           customGrammar = customGrammarFromRelease(release),

package/src/label.js

@@ -0,0 +1,42 @@
+"use strict";
+
+import { nodeAsString } from "./utilities/string";
+import { labelNameFromLabelNode } from "./utilities/query";
+
+export default class Label {
+  constructor(node) {
+    this.node = node;
+  }
+
+  getNode() {
+    return this.node;
+  }
+
+  matchName(name) {
+    const labelNode = this.node,
+          labelName = labelNameFromLabelNode(labelNode),
+          matchesName = (labelName === name);
+
+    return matchesName;
+  }
+
+  asString() {
+    const string = nodeAsString(this.node);
+
+    return string;
+  }
+
+  toJSON() {
+    const string = nodeAsString(this.node),
+          json = string; ///
+
+    return json;
+  }
+
+  static fromLabelNode(labelNode) {
+    const node = labelNode, ///
+          variable = new Label(node);
+
+    return variable;
+  }
+}

package/src/premise.js

@@ -2,6 +2,7 @@
 
 import MetaSubstitution from "./metaSubstitution";
 
+import { nodeAsString } from "./utilities/string";
 import { first, second } from "./utilities/array";
 import { nodeQuery, nodesQuery } from "./utilities/query";
 import { metavariableNameFromMetavariableNode } from "./utilities/query";
@@ -59,6 +60,16 @@ export default class Premise {
     return metastatementNodeMatches;
   }
 
+  toJSON() {
+    const metastatementString = nodeAsString(this.metastatementNode),
+          metastatement = metastatementString, ///
+          json = {
+            metastatement
+          };
+
+    return json;
+  }
+
   static fromMetastatementNode(metastatementNode) {
     const premise = new Premise(metastatementNode);
 

package/src/rule.js

@@ -2,7 +2,7 @@
 
 import { prune } from "./utilities/array";
 import { someSubArray } from "./utilities/array";
-import { labelsAsString } from "./utilities/string";
+import { lineIndexFromLabelsAndTokens } from "./utilities/tokens";
 
 export default class Rule {
   constructor(labels, premises, conclusion) {
@@ -23,6 +23,19 @@ export default class Rule {
     return this.conclusion;
   }
 
+  matchLabelName(labelName) {
+    const matchesLabelName = this.labels.some((label) => {
+      const name = labelName, ///
+            labelMatchesName = label.matchName(name);
+
+      if (labelMatchesName) {
+        return true;
+      }
+    });
+
+    return matchesLabelName;
+  }
+
   matchMetastatement(metastatementNode, metaproofContext) {
     let metastatementNatches;
 
@@ -48,13 +61,33 @@ export default class Rule {
     return metastatementNatches;
   }
 
-  asString() {
-    const string = labelsAsString(this.labels);
-
-    return string;
+  toJSON(tokens) {
+    const lineIndex = lineIndexFromLabelsAndTokens(this.labels, tokens),
+          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(),
+          labels = labelsJSON,  ///
+          premises = premisesJSON,  ///
+          conclusion = conclusionJSON,  ///
+          json = {
+            lineIndex,
+            labels,
+            premises,
+            conclusion
+          };
+
+    return json;
   }
 
-  static fromPremisesConclusionAndLabels(premises, conclusion, labels) {
+  static fromLabelsPremisesAndConclusion(labels, premises, conclusion) {
     const rule = new Rule(labels, premises, conclusion);
 
     return rule;

package/src/type.js

@@ -101,6 +101,20 @@ export default class Type {
     return string;
   }
 
+  toJSON() {
+    const superTypeJSON = (this.superType === null) ?
+                            null :
+                              this.superType.toJSON(),
+          name = this.name,
+          superType = superTypeJSON,  ///
+          json = {
+            name,
+            superType
+          };
+
+    return json;
+  }
+
   static fromTypeName(typeName) {
     const name = typeName,  ///
           superType = null,

package/src/utilities/string.js

@@ -37,9 +37,3 @@ export function nodesAsString(nodes) {
 
   return string;
 }
-
-export function labelsAsString(labels) {
-  const labelsString = labels.join(COMMA);
-
-  return labelsString;
-}

package/src/utilities/tokens.js

@@ -1,5 +1,19 @@
 "use strict";
 
+import { arrayUtilities } from "necessary";
+
+const { first } = arrayUtilities;
+
+export function lineIndexFromLabelsAndTokens(labels, tokens) {
+  const firstLabel = first(labels),
+        label = firstLabel, ///
+        node = label.getNode(),
+        leastLineIndex = leastLineIndexFromNodeAndTokens(node, tokens),
+        lineIndex = leastLineIndex; ///
+
+  return lineIndex;
+}
+
 export function leastLineIndexFromNodeAndTokens(node, tokens) {
   let leastLineIndex = undefined; ///
 

package/src/verify/files.js

@@ -2,13 +2,25 @@
 
 import verifyFile from "../verify/file";
 
-import { leftDifference } from "../utilities/array";
+import { filePathUtilities } from "occam-file-system";
+
+import { filter, leftDifference } from "../utilities/array";
+
+const { isFilePathFlorenceFilePath } = filePathUtilities;
 
 export default function verifyFiles(releaseContext) {
   let filesVerified = false;
 
   const filePaths = releaseContext.getFilePaths();
 
+  filter(filePaths, (filePath) => {
+    const filePathFlorenceFilePath = isFilePathFlorenceFilePath(filePath);
+
+    if (filePathFlorenceFilePath) {
+      return true;
+    }
+  })
+
   for (;;) {
     const filePathsLength = filePaths.length;
 

package/src/verify/label.js

@@ -1,5 +1,8 @@
 "use strict";
 
+import Label from "../label";
+
+import { nodesAsString } from "../utilities/string";
 import { labelNameFromLabelNode } from "../utilities/query";
 
 export default function verifyLabel(labelNode, labels, fileContext) {
@@ -8,12 +11,15 @@ export default function verifyLabel(labelNode, labels, fileContext) {
   fileContext.begin(labelNode);
 
   const labelName = labelNameFromLabelNode(labelNode),
-        label = labelName,  ///
-        labelPresent = fileContext.isLabelPresent(label);
+        labelPresent = fileContext.isLabelPresentByLabelName(labelName);
 
   if (labelPresent) {
-    fileContext.error(`The label ${label} is already present`, labelNode);
+    const labelString = nodesAsString(labelNode);
+
+    fileContext.error(`The label ${labelString} is already present`, labelNode);
   } else {
+    const label = Label.fromLabelNode(labelNode);
+
     labels.push(label);
 
     labelVerified = true;

package/src/verify/rule.js

@@ -59,7 +59,7 @@ export default function verifyRule(ruleNode, fileContext) {
       }
 
       if (metaproofVerified) {
-        const rule = Rule.fromPremisesConclusionAndLabels(premises, conclusion, labels);
+        const rule = Rule.fromLabelsPremisesAndConclusion(labels, premises, conclusion);
 
         fileContext.addRule(rule);