occam-furtle 2.0.340 → 3.0.1

package/src/element/ternary.js

@@ -1,22 +1,20 @@
 "use strict";
 
+import Element from "../element";
 import Exception from "../exception";
 
 import { define } from "../elements";
 import { BOOLEAN_TYPE } from "../types";
 
-export default define(class Ternary {
-  constructor(string, term, ifExpression, elseExpression) {
-    this.string = string;
+export default define(class Ternary extends Element {
+  constructor(context, string, node, term, ifExpression, elseExpression) {
+    super(context, string, node)
+
     this.term = term;
     this.ifExpression = ifExpression;
     this.elseExpression = elseExpression;
   }
 
-  getString() {
-    return this.string;
-  }
-
   getTerm() {
     return this.term;
   }
@@ -32,7 +30,7 @@ export default define(class Ternary {
   evaluate(context) {
     let term;
 
-    const ternaryString = this.string; ///
+    const ternaryString = this.getString(); ///
 
     context.trace(`Evaluating the '${ternaryString}' ternary...`);
 
@@ -48,7 +46,8 @@ export default define(class Ternary {
       throw exception;
     }
 
-    const boolean = term.getBoolean();
+    const primitiveValue = term.getPrimitiveValue(),
+          boolean = primitiveValue; ///
 
     term = boolean ?
               this.ifExpression.evaluate(context) :

package/src/element/variable.js

@@ -1,22 +1,20 @@
 "use strict";
 
+import Element from "../element";
 import Exception from "../exception";
 
 import { define } from "../elements";
 import { variableStringFromName } from "../utilities/string";
 
-export default define(class Variable {
-  constructor(string, type, name, term) {
-    this.string = string;
+export default define(class Variable extends Element {
+  constructor(context, string, node, type, name, term) {
+    super(context, string, node)
+
     this.type = type;
     this.name = name;
     this.term = term;
   }
 
-  getString() {
-    return this.string;
-  }
-
   getType() {
     return this.type;
   }
@@ -36,7 +34,7 @@ export default define(class Variable {
   }
 
   evaluate(context) {
-    const variableString = this.string; ///
+    const variableString = this.getString(); ///
 
     context.trace(`Evaluating the '${variableString}' variable...`);
 
@@ -64,7 +62,7 @@ export default define(class Variable {
     const nested = false,
           termString = term.getString(),
           variableName = this.name, ///
-          variableString = this.string, ///
+          variableString = this.getString(), ///
           variablePresent = context.isVariablePresentByVariableName(variableName, nested);
 
     context.trace(`Assigning the '${termString}' term to the '${variableString}' variable...`);
@@ -100,10 +98,14 @@ export default define(class Variable {
   static fromParameter(parameter, context) {
     const type = parameter.getType(),
           name = parameter.getName(),
-          primitive = null,
+          term = null,
           variableString = variableStringFromName(name),
           string = variableString,  ///
-          variable = new Variable(string, type, name, primitive);
+          node = null;
+
+    context = null;
+
+    const variable = new Variable(context, string, node, type, name, term);
 
     return variable;
   }
@@ -112,10 +114,14 @@ export default define(class Variable {
     const aliasedName = namedParameter.getAliasedName(),
           type = namedParameter.getType(),
           name = aliasedName, ///
-          primitive = null,
+          term = null,
           variableString = variableStringFromName(name),
           string = variableString,  ///
-          variable = new Variable(string, type, name, primitive);
+          node = null;
+
+    context = null;
+
+    const variable = new Variable(context, string, node, type, name, term);
 
     return variable;
   }
@@ -125,7 +131,11 @@ export default define(class Variable {
           name = parameter.getName(),
           variableString = variableStringFromName(name),
           string = variableString,  ///
-          variable = new Variable(string, type, name, term);
+          node = null;
+
+    context = null;
+
+    const variable = new Variable(context, string, node, type, name, term);
 
     return variable;
   }

package/src/element.js

@@ -32,12 +32,4 @@ export default class Element {
   }
 
   matchNode(node) { return this.node.match(node); }
-
-  isEqualTo(element) {
-    const elementNode = element.getNode(),
-          matches = this.node.match(elementNode),
-          equalTo = matches;  ///
-
-    return equalTo;
-  }
 }

package/src/index.js

@@ -7,7 +7,9 @@ export { default as Terms } from "./element/terms";
 export { default as Log } from "./log";
 export { default as Element } from "./element";
 export { default as FileContext } from "./context/file";
+export { default as ReleaseContext } from "./context/release";
 export { default as NonTerminalNode } from "./nonTerminalNode";
+export { default as FurtleFileContext } from "./context/file/furtle";
 
 export { default as nodeUtilities } from "./utilities/node";
 export { default as queryUtilities } from "./utilities/query";

package/src/log.js

@@ -23,37 +23,37 @@ export default class Log {
     return this.follow;
   }
 
-  trace(message, filePath = null, lineIndex = null) {
+  trace(message, filePath = null) {
     const level = TRACE_LEVEL;
 
-    this.write(level, message, filePath, lineIndex);
+    this.write(level, message, filePath);
   }
 
-  debug(message, filePath = null, lineIndex = null) {
+  debug(message, filePath = null) {
     const level = DEBUG_LEVEL;
 
-    this.write(level, message, filePath, lineIndex);
+    this.write(level, message, filePath);
   }
 
-  info(message, filePath = null, lineIndex = null) {
+  info(message, filePath = null) {
     const level = INFO_LEVEL;
 
-    this.write(level, message, filePath, lineIndex);
+    this.write(level, message, filePath);
   }
 
-  warning(message, filePath = null, lineIndex = null) {
+  warning(message, filePath = null) {
     const level = WARNING_LEVEL;
 
-    this.write(level, message, filePath, lineIndex);
+    this.write(level, message, filePath);
   }
 
-  error(message, filePath = null, lineIndex = null) {
+  error(message, filePath = null) {
     const level = ERROR_LEVEL;
 
-    this.write(level, message, filePath, lineIndex);
+    this.write(level, message, filePath);
   }
 
-  write(level, message, filePath, lineIndex) {
+  write(level, message, filePath, lineIndex = null) {
     const levelIndex = LEVELS.indexOf(level),
           logLevelIndex = LEVELS.indexOf(this.logLevel);
 

package/src/metaTypeNames.js

@@ -0,0 +1,5 @@
+"use strict";
+
+export const FRAME_META_TYPE_NAME = "Frame";
+export const REFERENCE_META_TYPE_NAME = "Reference";
+export const STATEMENT_META_TYPE_NAME = "Statement";

package/src/metaTypes.js

@@ -0,0 +1,71 @@
+"use strict";
+
+import elements from "./elements";
+
+import { FRAME_META_TYPE_NAME, REFERENCE_META_TYPE_NAME, STATEMENT_META_TYPE_NAME } from "./metaTypeNames";
+
+let frameMetaType = null,
+    referenceMetaType = null,
+    statementMetaType = null;
+
+export function getMetaTypes() {
+  const frameMetaType = frameMetaTypeFromNothing(),
+        referenceMetaType = referenceMetaTypeFromNothing(),
+        statementMetaType = statementMetaTypeFromNothing(),
+        metaTypes = [
+          frameMetaType,
+          referenceMetaType,
+          statementMetaType
+        ];
+
+  return metaTypes;
+}
+
+export function findMetaTypeByMetaTypeName(metaTypeName) {
+  const metaTypes = getMetaTypes(),
+        metaType = metaTypes.find((metaType) => {
+          const metaTypeComparesToMetaTypeName = metaType.compareMetaTypeName(metaTypeName);
+
+          if (metaTypeComparesToMetaTypeName) {
+            return true;
+          }
+        }) || null;
+
+  return metaType;
+}
+
+function frameMetaTypeFromNothing() {
+  if (frameMetaType === null) {
+    const { MetaType } = elements,
+          name = FRAME_META_TYPE_NAME,  ///
+          context = null;
+
+    frameMetaType = MetaType.fromName(name, context);
+  }
+
+  return frameMetaType;
+}
+
+function statementMetaTypeFromNothing() {
+  if (statementMetaType === null) {
+    const { MetaType } = elements,
+          name = STATEMENT_META_TYPE_NAME,  ///
+          context = null;
+
+    statementMetaType = MetaType.fromName(name, context);
+  }
+
+  return statementMetaType;
+}
+
+function referenceMetaTypeFromNothing() {
+  if (referenceMetaType === null) {
+    const { MetaType } = elements,
+          name = REFERENCE_META_TYPE_NAME,  ///
+          context = null;
+
+    referenceMetaType = MetaType.fromName(name, context);
+  }
+
+  return referenceMetaType;
+}

package/src/node/expression.js

@@ -2,18 +2,24 @@
 
 import NonTerminalNode from "../nonTerminalNode";
 
-import { SOME_RULE_NAME,
+import { TERM_RULE_NAME,
+         SOME_RULE_NAME,
          EVERY_RULE_NAME,
          REDUCE_RULE_NAME,
          TERNARY_RULE_NAME,
-         VARIABLE_RULE_NAME,
-         PRIMITIVE_RULE_NAME,
          NODE_QUERY_RULE_NAME,
          NODES_QUERY_RULE_NAME,
          RETURN_BLOCK_RULE_NAME,
          PROCEDURE_CALL_RULE_NAME } from "../ruleNames";
 
 export default class ExpressionNode extends NonTerminalNode {
+  getTermNode() {
+    const ruleName = TERM_RULE_NAME,
+          termNode = this.getNodeByRuleName(ruleName);
+
+    return termNode;
+  }
+
   getSomeNode() {
     const ruleName = SOME_RULE_NAME,
           someNode = this.getNodeByRuleName(ruleName);
@@ -42,20 +48,6 @@ export default class ExpressionNode extends NonTerminalNode {
     return ternaryNode;
   }
 
-  getVariableNode() {
-    const ruleName = VARIABLE_RULE_NAME,
-          variableNode = this.getNodeByRuleName(ruleName);
-
-    return variableNode;
-  }
-
-  getPrimitiveNode() {
-    const ruleName = PRIMITIVE_RULE_NAME,
-          primitiveNode = this.getNodeByRuleName(ruleName);
-
-    return primitiveNode;
-  }
-
   getNodeQueryNode() {
     const ruleName = NODE_QUERY_RULE_NAME,
           nodeQueryNode = this.getNodeByRuleName(ruleName);

package/src/nodeProperties.js

@@ -4,19 +4,9 @@ import Exception from "./exception";
 import NodeProperty from "./nodeProperty";
 
 import { NODES_TYPE, STRING_TYPE, BOOLEAN_TYPE } from "./types";
+import { nodePropertiesStringFromNodePropertiesArray } from "./utilities/string";
 import { CONTENT_PARAMETER_NAME, TERMINAL_PARAMETER_NAME, CHILD_NODES_PARAMETER_NAME } from "./parameterNames";
 
-const types = [
-        STRING_TYPE,
-        BOOLEAN_TYPE,
-        NODES_TYPE,
-      ],
-      names = [
-        CONTENT_PARAMETER_NAME,
-        TERMINAL_PARAMETER_NAME,
-        CHILD_NODES_PARAMETER_NAME
-      ];
-
 class NodeProperties {
   constructor(string, array) {
     this.string = string;
@@ -64,14 +54,9 @@ class NodeProperties {
   }
 
   static fromNothing() {
-    const context = null,
-          array = names.map((name, index) => {
-            const type = types[index],
-                  nodeProperty = NodeProperty.fromNameAndType(name, type, context);
-
-            return nodeProperty;
-          }),
-          string = stringFromArray(array, context),
+    const nodePropertiesArray = nodePropertiesArrayFromNothing(),
+          string = nodePropertiesStringFromNodePropertiesArray(nodePropertiesArray),
+          array = nodePropertiesArray,  ///
           nodeProperties = new NodeProperties(string, array);
 
     return nodeProperties;
@@ -82,17 +67,23 @@ const nodeProperties = NodeProperties.fromNothing();
 
 export default nodeProperties;
 
-function stringFromArray(array, context) {
-  const nodePropertiesString = array.reduce((nodePropertiesString, nodeProperty) => {
-          const nodePropertyString = nodeProperty.getString();
-
-          nodePropertiesString = (nodePropertiesString === null) ?
-                                   nodePropertyString :
-                                    `${nodePropertiesString}, ${nodePropertyString}`;
-
-          return nodePropertiesString;
-        }, null),
-        string = nodePropertiesString;  ///
-
-  return string;
+function nodePropertiesArrayFromNothing() {
+  const types = [
+          STRING_TYPE,
+          BOOLEAN_TYPE,
+          NODES_TYPE,
+        ],
+        names = [
+          CONTENT_PARAMETER_NAME,
+          TERMINAL_PARAMETER_NAME,
+          CHILD_NODES_PARAMETER_NAME
+        ],
+        nodePropertiesArray = names.map((name, index) => {
+          const type = types[index],
+                nodeProperty = NodeProperty.fromNameAndType(name, type);
+
+          return nodeProperty;
+        });
+
+  return nodePropertiesArray;
 }

package/src/nodeProperty.js

@@ -1,5 +1,7 @@
 "use strict";
 
+import { nodePropertyStringFromNameAndType } from "./utilities/string";
+
 export default class NodeProperty {
   constructor(string, type, name) {
     this.string = string;
@@ -41,18 +43,11 @@ export default class NodeProperty {
 
   static name = "Parameter";
 
-  static fromNameAndType(name, type, context) {
-    const string = stringFromNameAndType(name, type, context),
+  static fromNameAndType(name, type) {
+    const nodePropertyString = nodePropertyStringFromNameAndType(name, type),
+          string = nodePropertyString,  ///
           nodeProperty = new NodeProperty(string, type, name);
 
     return nodeProperty;
   }
 };
-
-function stringFromNameAndType(name, type, context) {
-  const typeString = type,  ///
-        nameString = name,  ///
-        string = `${typeString} ${nameString}`;
-
-  return string;
-}

package/src/utilities/context.js

@@ -1,32 +1,17 @@
 "use strict";
 
-import { LEVELS, FUNCTION, DOUBLE_SPACE } from "../constants";
+import { FUNCTION } 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);
-        }
+    get: (context, name, receiver) => {
+      if (name in context) {
+        return Reflect.get(context, name, receiver);
       }
 
-      if (name in instance) {
-        return Reflect.get(instance, name, receiver);
-      }
+      context = context.getContext(); ///
 
-      const context = instance.getContext(),
-            value = context[name];
+      const value = context[name];
 
       return (typeof value === FUNCTION) ?
                value.bind(context) :
@@ -35,29 +20,6 @@ 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
+  chainContext
 };

package/src/utilities/customGrammar.js

@@ -0,0 +1,40 @@
+"use strict";
+
+import { CustomGrammar, CombinedCustomGrammar } from "occam-custom-grammars";
+
+export function customGrammarFromNameAndEntries(name, entries) {
+  const termBNF = entries.getTermBNF(),
+        statementBNF = entries.getStatementBNF(),
+        typeVocabulary = entries.getTypeVocabulary(),
+        symbolVocabulary = entries.getSymbolVocabulary(),
+        customGrammar = CustomGrammar.fromNameTermBNFStatementBNFTypeVocabularyAndSymbolVocabulary(name, termBNF, statementBNF, typeVocabulary, symbolVocabulary);
+
+  return customGrammar;
+}
+
+export function combinedCustomGrammarFromNothing() {
+  const customGrammars = [],
+        combinedCustomGrammar = CombinedCustomGrammar.fromCustomGrammars(customGrammars);
+
+  return combinedCustomGrammar;
+}
+
+export function combinedCustomGrammarFromReleaseContexts(releaseContexts) {
+  const customGrammars = releaseContexts.map((releaseContext) => {
+    const customGrammar = releaseContext.getCustomGrammar();
+
+    return customGrammar;
+  });
+
+  customGrammars.reverse(); ///
+
+  const combinedCustomGrammar = CombinedCustomGrammar.fromCustomGrammars(customGrammars);
+
+  return combinedCustomGrammar;
+}
+
+export default {
+  customGrammarFromNameAndEntries,
+  combinedCustomGrammarFromNothing,
+  combinedCustomGrammarFromReleaseContexts
+};