occam-furtle 2.0.279 → 2.0.282

package/src/{dom → element}/reduce.js

@@ -1,15 +1,15 @@
 "use strict";
 
-import dom from "../dom";
+import elements from "../elements";
 import Exception from "../exception";
 
+import { define } from "../elements";
 import { nodeQuery } from "../utilities/query";
 import { NODES_TYPE } from "../types";
-import { domAssigned } from "../dom";
 
 const expressionReduceNodeQuery = nodeQuery("/expression/reduce");
 
-export default domAssigned(class Reduce {
+export default define(class Reduce {
   constructor(string, variable, initialExpression, anonymousProcedure) {
     this.string = string;
     this.variable = variable;
@@ -58,7 +58,7 @@ export default domAssigned(class Reduce {
     expression = nodes.reduce((currentExpression, node) => {
       let expression;
 
-      const { Expression, Expressions } = dom;
+      const { Expression, Expressions } = elements;
 
       expression = currentExpression; ///
 
@@ -96,7 +96,7 @@ export default domAssigned(class Reduce {
 });
 
 function reduceFromReduceNode(reduceNode, context) {
-  const { Reduce, Variable, Expression, AnonymousProcedure } = dom,
+  const { Reduce, Variable, Expression, AnonymousProcedure } = elements,
         expression = Expression.fromReduceNode(reduceNode, context),
         variable = Variable.fromReduceNode(reduceNode, context),
         initialExpression = expression, ///

package/src/{dom → element}/reference.js

@@ -1,14 +1,14 @@
 "use strict";
 
-import dom from "../dom";
+import elements from "../elements";
 
+import { define } from "../elements";
 import { nodeQuery } from "../utilities/query";
-import { domAssigned } from "../dom";
 
 const procedureCallReferenceNodeQuery = nodeQuery("/procedureCall/reference!"),
       referenceNameTerminalNodeQuery = nodeQuery("/reference/@name");
 
-export default domAssigned(class Reference {
+export default define(class Reference {
   constructor(string, name) {
     this.string = string;
     this.name = name;
@@ -40,7 +40,7 @@ export default domAssigned(class Reference {
 });
 
 function referenceFromReferenceNode(referenceNode, context) {
-  const { Reference } = dom,
+  const { Reference } = elements,
         name = nameFromReferenceNode(referenceNode, context),
         string = stringFromName(name, context),
         reference = new Reference(string, name);

package/src/{dom → element}/some.js

@@ -1,15 +1,15 @@
 "use strict";
 
-import dom from "../dom";
+import elements from "../elements";
 import Exception from "../exception";
 
+import { define } from "../elements";
 import { nodeQuery } from "../utilities/query";
-import { domAssigned } from "../dom";
 import { NODES_TYPE, BOOLEAN_TYPE } from "../types";
 
 const expressionSomeNodeQuery = nodeQuery("/expression/some");
 
-export default domAssigned(class Some {
+export default define(class Some {
   constructor(string, variable, anonymousProcedure) {
     this.string = string;
     this.variable = variable;
@@ -51,7 +51,7 @@ export default domAssigned(class Some {
           boolean = nodes.some((node) => {
             let expression;
 
-            const { Expression, Expressions } = dom;
+            const { Expression, Expressions } = elements;
 
             expression = Expression.fromNode(node, context);
 
@@ -74,7 +74,7 @@ export default domAssigned(class Some {
             return boolean;
           });
 
-    const { Expression } = dom;
+    const { Expression } = elements;
 
     expression = Expression.fromBoolean(boolean, context);
 
@@ -101,7 +101,7 @@ export default domAssigned(class Some {
 });
 
 function someFromSomeNode(someNode, context) {
-  const { Some, Variable, AnonymousProcedure } = dom,
+  const { Some, Variable, AnonymousProcedure } = elements,
         anonymousProcedure = AnonymousProcedure.fromSomeNode(someNode, context),
         variable = Variable.fromSomeNode(someNode, context),
         string = stringFromVariableAndAnonymousProcedure(variable, anonymousProcedure, context),

package/src/{dom → element}/statement/return.js

@@ -1,13 +1,13 @@
 "use strict";
 
-import dom from "../../dom";
+import elements from "../../elements";
 
+import { define } from "../../elements";
 import { nodeQuery } from "../../utilities/query";
-import { domAssigned } from "../../dom";
 
 const returnBlockReturnStatementNodeQuery = nodeQuery("/returnBlock/returnStatement");
 
-export default domAssigned(class ReturnStatement {
+export default define(class ReturnStatement {
   constructor(string, expression) {
     this.string = string;
     this.expression = expression;
@@ -47,7 +47,7 @@ export default domAssigned(class ReturnStatement {
 });
 
 function returnStatementFromReturnStatementNode(returnStatementNode, context) {
-  const { Expression, ReturnStatement } = dom,
+  const { Expression, ReturnStatement } = elements,
         expression = Expression.fromReturnStatementNode(returnStatementNode, context),
         string = stringFromExpression(expression, context),
         returnStatement = new ReturnStatement(string, expression);

package/src/{dom → element}/step.js

@@ -1,11 +1,11 @@
 "use strict";
 
-import dom from "../dom";
+import elements from "../elements";
 
-import { domAssigned } from "../dom";
+import { define } from "../elements";
 import { EMPTY_STRING } from "../constants";
 
-export default domAssigned(class Step {
+export default define(class Step {
   constructor(string, arrayAssignment, objectAssigment, variablesDeclaration) {
     this.string = string;
     this.arrayAssignment = arrayAssignment;
@@ -51,7 +51,7 @@ export default domAssigned(class Step {
 });
 
 function stepFromStepNode(stepNode, context) {
-  const { Step, ArrayAssignment, ObjectAssigment, VariableAssignments } = dom,
+  const { Step, ArrayAssignment, ObjectAssigment, VariableAssignments } = elements,
         string = stringFromNothing(context),
         arrayAssignment = ArrayAssignment.fromStepNode(stepNode, context),
         objectAssigment = ObjectAssigment.fromStepNode(stepNode, context),

package/src/{dom → element}/ternary.js

@@ -1,17 +1,17 @@
 "use strict";
 
-import dom from "../dom";
+import elements from "../elements";
 import Exception from "../exception";
 
+import { define } from "../elements";
 import { nodeQuery } from "../utilities/query";
-import { domAssigned } from "../dom";
 import { BOOLEAN_TYPE } from "../types";
 
 const ifExpressionNodeQuery = nodeQuery("/ternary/expression[1]"),
       elseExpressionNodeQuery = nodeQuery("/ternary/expression[2]"),
       expressionTernaryNodeQuery = nodeQuery("/expression/ternary");
 
-export default domAssigned(class Ternary {
+export default define(class Ternary {
   constructor(string, expression, ifExpression, elseExpression) {
     this.string = string;
     this.expression = expression;
@@ -83,7 +83,7 @@ export default domAssigned(class Ternary {
 });
 
 function ternaryFromTernaryNode(ternaryNode, context) {
-  const { Expression, Ternary } = dom,
+  const { Expression, Ternary } = elements,
         ifExpressionNode = ifExpressionNodeQuery(ternaryNode),
         elseExpressionNode = elseExpressionNodeQuery(ternaryNode),
         expression = Expression.fromTernaryNode(ternaryNode, context),

package/src/{dom → element}/variable.js

@@ -1,10 +1,10 @@
 "use strict";
 
-import dom from "../dom";
+import elements from "../elements";
 import Exception from "../exception";
 
+import { define } from "../elements";
 import { nodeQuery } from "../utilities/query";
-import { domAssigned } from "../dom";
 
 const someVariableNodeQuery = nodeQuery("/some/variable"),
       everyVariableNodeQuery = nodeQuery("/every/variable"),
@@ -17,7 +17,7 @@ const someVariableNodeQuery = nodeQuery("/some/variable"),
       objectAssignmentVariableNodeQuery = nodeQuery("/objectAssignment/variable"),
       variableAssignmentVariableNodeQuery = nodeQuery("/variableAssignment/variable");
 
-export default domAssigned(class Variable {
+export default define(class Variable {
   constructor(string, type, name, expression) {
     this.string = string;
     this.type = type;
@@ -221,7 +221,7 @@ export default domAssigned(class Variable {
 });
 
 function variableFromTypeAndVariableNode(type, variableNode, context) {
-  const { Variable } = dom,
+  const { Variable } = elements,
         name = nameFromVariableNode(variableNode),
         expression = null,
         string = stringFromName(name, context),
@@ -231,7 +231,7 @@ function variableFromTypeAndVariableNode(type, variableNode, context) {
 }
 
 function variableFromVariableNode(variableNode, context) {
-  const { Variable } = dom,
+  const { Variable } = elements,
         type = null,
         name = nameFromVariableNode(variableNode),
         expression = null,

package/src/elements.js

@@ -0,0 +1,13 @@
+"use strict";
+
+const elements = {};
+
+export function define(Class) {
+  const { name } = Class;
+
+  elements[name] = Class;
+
+  return Class;
+}
+
+export default elements;

package/src/index.js

@@ -2,6 +2,10 @@
 
 import "./preamble";
 
-export { default as Expressions } from "./dom/expressions";
+export { default as Expressions } from "./element/expressions";
+
+export { default as Log } from "./log";
 export { default as FileContext } from "./context/file";
+
 export { default as stringUtilities } from "./utilities/string";
+export { default as contextUtilities } from "./utilities/context";

package/src/log.js

@@ -0,0 +1,139 @@
+"use strict";
+
+import { LEVELS, SINGLE_SPACE, EMPTY_STRING, LEVEL_MAXIMUM_LENGTH, LINE_INDEX_MAXIMUM_LENGTH } from "./constants";
+
+const [ TRACE_LEVEL, DEBUG_LEVEL, INFO_LEVEL, WARNING_LEVEL, ERROR_LEVEL ] = LEVELS;
+
+export default class Log {
+  constructor(messages, logLevel, follow) {
+    this.messages = messages;
+    this.logLevel = logLevel;
+    this.follow = follow;
+  }
+
+  getMessages() {
+    return this.messages;
+  }
+
+  getLogLevel() {
+    return this.logLevel;
+  }
+
+  getFollow() {
+    return this.follow;
+  }
+
+  trace(message, filePath = null, lineIndex = null) {
+    const level = TRACE_LEVEL;
+
+    this.write(level, message, filePath, lineIndex);
+  }
+
+  debug(message, filePath = null, lineIndex = null) {
+    const level = DEBUG_LEVEL;
+
+    this.write(level, message, filePath, lineIndex);
+  }
+
+  info(message, filePath = null, lineIndex = null) {
+    const level = INFO_LEVEL;
+
+    this.write(level, message, filePath, lineIndex);
+  }
+
+  warning(message, filePath = null, lineIndex = null) {
+    const level = WARNING_LEVEL;
+
+    this.write(level, message, filePath, lineIndex);
+  }
+
+  error(message, filePath = null, lineIndex = null) {
+    const level = ERROR_LEVEL;
+
+    this.write(level, message, filePath, lineIndex);
+  }
+
+  write(level, message, filePath, lineIndex) {
+    const levelIndex = LEVELS.indexOf(level),
+          logLevelIndex = LEVELS.indexOf(this.logLevel);
+
+    if (levelIndex < logLevelIndex) {
+      return;
+    }
+
+    message = formatMessage(level, message, filePath, lineIndex);  ///
+
+    this.follow ?
+      console.log(message) :
+        this.messages.push(message);
+  }
+
+  static fromNothing() {
+    const messages = null,
+          logLevel = TRACE_LEVEL,
+          follow = true,
+          log = new Log(messages, logLevel, follow);
+
+    return log;
+  }
+
+  static fromFollowAndLogLevel(follow, logLevel) {
+    const messages = follow ?
+                       null :
+                         [],
+          log = new Log(messages, logLevel, follow);
+
+    return log;
+  }
+}
+
+function formatMessage(level, message, filePath, lineIndex) {
+  let formattedMessage = EMPTY_STRING;
+
+  const leftPaddedLevel = leftPadLevel(level),
+        upperCaseLeftPaddedLevel = leftPaddedLevel.toUpperCase();
+
+  formattedMessage += `${upperCaseLeftPaddedLevel}:`;
+
+  if (filePath !== null) {
+    formattedMessage += ` ${filePath}`;
+  }
+
+  if (lineIndex !== null) {
+    const leftPaddedLineIndex = leftPadLineIndex(lineIndex);
+
+    formattedMessage += ` [${leftPaddedLineIndex}]`;
+  }
+
+  formattedMessage += ` - ${message}`;
+
+  message = formattedMessage; ///
+
+  return message;
+}
+
+function leftPadLineIndex(lineIndex) {
+  lineIndex = `${lineIndex}`;
+
+  const maximumLength = LINE_INDEX_MAXIMUM_LENGTH,
+        leftPaddedLineIndex = leftPad(lineIndex, maximumLength);
+
+  return leftPaddedLineIndex;
+}
+
+function leftPadLevel(level) {
+  const maximumLength = LEVEL_MAXIMUM_LENGTH,
+        leftPaddedLevel = leftPad(level, maximumLength);
+
+  return leftPaddedLevel;
+}
+
+function leftPad(string, maximumLength) {
+  const stringLength = string.length,
+        length = maximumLength - stringLength,
+        indent = SINGLE_SPACE.repeat(length),
+        leftPaddedString = `${indent}${string}`;
+
+  return leftPaddedString;
+}
+

package/src/preamble.js

@@ -1,33 +1,33 @@
 "use strict";
 
-import Step from "./dom/step";
-import Some from "./dom/some";
-import Label from "./dom/label";
-import Error from "./dom/error";
-import Every from "./dom/every";
-import Reduce from "./dom/reduce";
-import Ternary from "./dom/ternary";
-import Variable from "./dom/variable";
-import Reference from "./dom/reference";
-import Procedure from "./dom/procedure";
-import NodeQuery from "./dom/query/node";
-import Parameter from "./dom/parameter";
-import Parameters from "./dom/parameters";
-import NodesQuery from "./dom/query/nodes";
-import Comparison from "./dom/comparison";
-import Expression from "./dom/expression";
-import Expressions from "./dom/expressions";
-import ReturnBlock from "./dom/block/return";
-import ProcedureCall from "./dom/procedureCall";
-import NamedParameter from "./dom/parameter/named";
-import ArrayAssigment from "./dom/assignment/array";
-import ReturnStatement from "./dom/statement/return";
-import NamedParameters from "./dom/parameters/named";
-import ObjectAssignment from "./dom/assignment/object";
-import NegatedExpression from "./dom/expression/negated";
-import BitwiseExpression from "./dom/expression/bitwise";
-import AnonymousProcedure from "./dom/procedure/anonymous";
-import VariableAssignment from "./dom/assignment/variable";
-import BracketedExpression from "./dom/expression/bracketed";
-import VariableAssignments from "./dom/assignments/variable";
-import ProcedureDeclaration from "./dom/declaration/procedure";
+import Step from "./element/step";
+import Some from "./element/some";
+import Label from "./element/label";
+import Error from "./element/error";
+import Every from "./element/every";
+import Reduce from "./element/reduce";
+import Ternary from "./element/ternary";
+import Variable from "./element/variable";
+import Reference from "./element/reference";
+import Procedure from "./element/procedure";
+import NodeQuery from "./element/query/node";
+import Parameter from "./element/parameter";
+import Parameters from "./element/parameters";
+import NodesQuery from "./element/query/nodes";
+import Comparison from "./element/comparison";
+import Expression from "./element/expression";
+import Expressions from "./element/expressions";
+import ReturnBlock from "./element/block/return";
+import ProcedureCall from "./element/procedureCall";
+import NamedParameter from "./element/parameter/named";
+import ArrayAssigment from "./element/assignment/array";
+import ReturnStatement from "./element/statement/return";
+import NamedParameters from "./element/parameters/named";
+import ObjectAssignment from "./element/assignment/object";
+import NegatedExpression from "./element/expression/negated";
+import BitwiseExpression from "./element/expression/bitwise";
+import AnonymousProcedure from "./element/procedure/anonymous";
+import VariableAssignment from "./element/assignment/variable";
+import BracketedExpression from "./element/expression/bracketed";
+import VariableAssignments from "./element/assignments/variable";
+import ProcedureDeclaration from "./element/declaration/procedure";

package/src/process/verify.js

@@ -0,0 +1,157 @@
+"use strict";
+
+import { nodeQuery } from "../utilities/query";
+
+import elements from "../elements";
+
+const nonTerminalNodeQuery = nodeQuery("/*"),
+      errorNodeQuery = nodeQuery("/error"),
+      procedureDeclarationNodeQuery = nodeQuery("/procedureDeclaration");
+
+class Pass {
+  run(node, ...remainingArguments) {
+    let success;
+
+    const visited = this.visitNode(node, ...remainingArguments);
+
+    success = visited;  ///
+
+    return success;
+  }
+
+  descend(childNodes, ...remainingArguments) {
+    let descended = false;
+
+    const visited = childNodes.every((childNode) => {
+      const node = childNode, ///
+            visited = this.visitNode(node, ...remainingArguments);
+
+      if (visited) {
+        return true;
+      }
+    });
+
+    if (visited) {
+      descended = true;
+    }
+
+    return descended;
+  }
+
+  visitNode(node, ...remainingArguments) {
+    let visited;
+
+    const nodeTerminalNode = node.isTerminalNode();
+
+    if (nodeTerminalNode) {
+      const terminalNode = node;  ///
+
+      visited = this.visitTerminalNode(terminalNode, ...remainingArguments);
+    } else {
+      const nonTerminalNode = node;  ///
+
+      visited = this.visitNonTerminalNode(nonTerminalNode, ...remainingArguments);
+    }
+
+    return visited;
+  }
+
+  visitTerminalNode(terminalNode, ...remainingArguments) {
+    const visited = true;
+
+    return visited;
+  }
+
+  visitNonTerminalNode(nonTerminalNode, ...remainingArguments) {
+    let visited = false;
+
+    let { maps } = this.constructor;
+
+    maps = [ ///
+      ...maps,
+      {
+        nodeQuery: nonTerminalNodeQuery,
+        run: (node, ...remainingArguments) => {
+          let visited = false;
+
+          const childNodes = nonTerminalNode.getChildNodes(), ///
+                descended = this.descend(childNodes, ...remainingArguments);
+
+          if (descended) {
+            visited = true;
+          }
+
+          return visited;
+        }
+      }
+    ]
+
+    maps.some((map) => {
+      const { nodeQuery, run } = map;
+
+      const node = nodeQuery(nonTerminalNode);
+
+      if (node !== null) {
+        const success = run(node, ...remainingArguments);
+
+        visited = success;
+
+        return true;
+      }
+    });
+
+    return visited;
+  }
+}
+
+class TopLevelPass extends Pass {
+  static maps = [
+    {
+      nodeQuery: errorNodeQuery,
+      run: (errorNode, context) => {
+        let success = false;
+
+        const { Error } = elements,
+              error = Error.fromErrorNode(errorNode, context),
+              errorVerifies = error.verify(context);
+
+        if (errorVerifies) {
+          success = true;
+        }
+
+        return success;
+      }
+    },
+    {
+      nodeQuery: procedureDeclarationNodeQuery,
+      run: (procedureDeclarationNode, context) => {
+        let success = false;
+
+        const { ProcedureDeclaration } = elements,
+              procedureDeclaration = ProcedureDeclaration.fromProcedureDeclarationNode(procedureDeclarationNode, context),
+              procedureDeclarationVerifies = procedureDeclaration.verify(context);
+
+        if (procedureDeclarationVerifies) {
+          success = true;
+        }
+
+        return success;
+      }
+    }
+  ];
+}
+
+const topLevelPass = new TopLevelPass();
+
+export function verifyFile(fileNode, context) {
+  let fileVerifies = false;
+
+  const node = fileNode, ///
+        sucess = topLevelPass.run(node, context);
+
+  if (sucess) {
+    fileVerifies = true;
+  }
+
+  return fileVerifies;
+}

package/src/utilities/context.js

@@ -1,15 +1,31 @@
 "use strict";
 
-import { FUNCTION } from "../constants";
+import { LEVELS, FUNCTION, DOUBLE_SPACE } 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);
+        }
+      }
+
       if (name in instance) {
         return Reflect.get(instance, name, receiver);
       }
 
-      const context = instance.context,
+      const context = instance.getContext(),
             value = context[name];
 
       return (typeof value === FUNCTION) ?
@@ -18,3 +34,30 @@ 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
+};