occam-furtle 2.0.330 → 2.0.331

package/src/element/{comparison.js → expression/comparison.js}

@@ -1,11 +1,11 @@
 "use strict";
 
-import Exception from "../exception";
+import Exception from "../../exception";
 
-import { define } from "../elements";
-import { termFromBoolean } from "../utilities/term";
+import { define } from "../../elements";
+import { termFromBoolean } from "../../utilities/term";
 
-export default define(class Comparison {
+export default define(class ComparisonExpression {
   constructor(string, negated, leftExpression, rightExpression) {
     this.string = string;
     this.negated = negated;
@@ -32,9 +32,9 @@ export default define(class Comparison {
   evaluate(context) {
     let term;
 
-    const comparisonString = this.string; ///
+    const comparisonExpressionString = this.string; ///
 
-    context.trace(`Evaluating the '${comparisonString}' comparison...`);
+    context.trace(`Evaluating the '${comparisonExpressionString}' comparison expression...`);
 
     const leftTerm = this.leftExpression.evaluate(context),
           rightTerm = this.rightExpression.evaluate(context),
@@ -60,10 +60,10 @@ export default define(class Comparison {
 
     term = termFromBoolean(boolean, context);
 
-    context.debug(`...evaluated the '${comparisonString}' comparison.`);
+    context.debug(`...evaluated the '${comparisonExpressionString}' comparison expression.`);
 
     return term;
   }
 
-  static name = "Comparison";
+  static name = "ComparisonExpression";
 });

package/src/element/expression.js

@@ -3,7 +3,7 @@
 import { define } from "../elements";
 
 export default define(class Expression {
-  constructor(string, variable, primitive, some, every, reduce, ternary, nodeQuery, nodesQuery, comparison, returnBlock, procedureCall, negatedExpression, logicalExpression, bracketedExpression) {
+  constructor(string, variable, primitive, some, every, reduce, ternary, nodeQuery, nodesQuery, returnBlock, procedureCall, negatedExpression, logicalExpression, bracketedExpression, comparisonExpression) {
     this.string = string;
     this.variable = variable;
     this.primitive = primitive;
@@ -13,12 +13,12 @@ export default define(class Expression {
     this.ternary = ternary;
     this.nodeQuery = nodeQuery;
     this.nodesQuery = nodesQuery;
-    this.comparison = comparison;
     this.returnBlock = returnBlock;
     this.procedureCall = procedureCall;
     this.negatedExpression = negatedExpression;
     this.logicalExpression = logicalExpression;
     this.bracketedExpression = bracketedExpression;
+    this.comparisonExpression = comparisonExpression;
   }
 
   getString() {
@@ -57,10 +57,6 @@ export default define(class Expression {
     return this.nodesQuery;
   }
 
-  getComparison() {
-    return this.comparison;
-  }
-
   getReturnBlock() {
     return this.returnBlock;
   }
@@ -81,6 +77,10 @@ export default define(class Expression {
     return this.bracketedExpression;
   }
 
+  getComparisonExpression() {
+    return this.comparisonExpression;
+  }
+
   getNode() { return this.primitive.getNode(); }
 
   getNodes() { return this.primitive.getNodes(); }
@@ -112,8 +112,6 @@ export default define(class Expression {
       type = this.nodeQuery.getType();
     } else if (this.nodesQuery !== null) {
       type = this.nodesQuery.getType();
-    } else if (this.comparison !== null) {
-      type = this.comparison.getType();
     } else if (this.returnBlock !== null) {
       type = this.returnBlock.getType();
     } else if (this.procedureCall !== null) {
@@ -124,6 +122,8 @@ export default define(class Expression {
       type = this.logicalExpression.getType();
     } else if (this.bracketedExpression !== null) {
       type = this.bracketedExpression.getType();
+    } else if (this.comparisonExpression !== null) {
+      type = this.comparisonExpression.getType();
     }
 
     return type;
@@ -150,8 +150,6 @@ export default define(class Expression {
       term = this.nodeQuery.evaluate(context);
     } else if (this.nodesQuery !== null) {
       term = this.nodesQuery.evaluate(context);
-    } else if (this.comparison !== null) {
-      term = this.comparison.evaluate(context);
     } else if (this.returnBlock !== null) {
       term = this.returnBlock.evaluate(context);
     } else if (this.procedureCall !== null) {
@@ -162,6 +160,8 @@ export default define(class Expression {
       term = this.logicalExpression.evaluate(context);
     } else if (this.bracketedExpression !== null) {
       term = this.bracketedExpression.evaluate(context);
+    } else if (this.comparisonExpression !== null) {
+      term = this.comparisonExpression.evaluate(context);
     }
 
     return term;

package/src/element/term/bracketed.js

@@ -0,0 +1,36 @@
+"use strict";
+
+import { define } from "../../elements";
+
+export default define(class BracketedTerm {
+  constructor(string, term) {
+    this.string = string;
+    this.term = term;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getTerm() {
+    return this.term;
+  }
+
+  getType() { return this.term.getType(); }
+
+  evaluate(context) {
+    let term;
+
+    const bracketedTermString = this.string; ///
+
+    context.trace(`Evaluating the '${bracketedTermString}' bracketed term...`);
+
+    term = this.term.evaluate(context);
+
+    context.debug(`...evaluated the '${bracketedTermString}' bracketed term.`);
+
+    return term;
+  }
+
+  static name = "BracketedTerm";
+});

package/src/element/term/comparison.js

@@ -0,0 +1,69 @@
+"use strict";
+
+import Exception from "../../exception";
+
+import { define } from "../../elements";
+import { termFromBoolean } from "../../utilities/term";
+
+export default define(class ComparisonTerm {
+  constructor(string, negated, leftTerm, rightTerm) {
+    this.string = string;
+    this.negated = negated;
+    this.leftTerm = leftTerm;
+    this.rightTerm = rightTerm;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  isNegated() {
+    return this.negated;
+  }
+
+  getLeftTerm() {
+    return this.leftTerm;
+  }
+
+  getRightTerm() {
+    return this.rightTerm;
+  }
+
+  evaluate(context) {
+    let term;
+
+    const comparisonTermString = this.string; ///
+
+    context.trace(`Evaluating the '${comparisonTermString}' comparison term...`);
+
+    const leftTerm = this.leftTerm.evaluate(context),
+          rightTerm = this.rightTerm.evaluate(context),
+          leftTermType = leftTerm.getType(),
+          rightTermType = rightTerm.getType();
+
+    if (leftTermType !== rightTermType) {
+      const leftTermString = leftTerm.getString(),
+            rightTermString = rightTerm.getString(),
+            message = `The '${leftTermString}' left term's type is '${leftTermType}' whereas the '${rightTermString}' right term's type is '${rightTermType}'.`,
+            exception = Exception.fromMessage(message);
+
+      throw exception;
+    }
+
+    const leftTermEqualToRightTerm = leftTerm.isEqualTo(rightTerm);
+
+    let boolean = leftTermEqualToRightTerm; ///
+
+    if (this.negated) {
+      boolean = !boolean; ///
+    }
+
+    term = termFromBoolean(boolean, context);
+
+    context.debug(`...evaluated the '${comparisonTermString}' comparison term.`);
+
+    return term;
+  }
+
+  static name = "ComparisonTerm";
+});

package/src/element/term/logical.js

@@ -0,0 +1,80 @@
+"use strict";
+
+import Exception from "../../exception";
+
+import { define } from "../../elements";
+import { BOOLEAN_TYPE } from "../../types";
+import { termFromBoolean } from "../../utilities/term";
+
+export default define(class LogicaTerm {
+  constructor(string, type, disjunction, leftTerm, rightTerm) {
+    this.string = string;
+    this.type = type;
+    this.disjunction = disjunction;
+    this.leftTerm = leftTerm;
+    this.rightTerm = rightTerm;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getType() {
+    return this.type;
+  }
+
+  isDisjunction() {
+    return this.disjunction;
+  }
+
+  getLeftTerm() {
+    return this.leftTerm;
+  }
+
+  getRightTerm() {
+    return this.rightTerm;
+  }
+
+  evaluate(context) {
+    let term;
+
+    const logicaTermString = this.string; ///
+
+    context.trace(`Evaluating the '${logicaTermString}' logical term...`);
+
+    const leftTerm = this.leftTerm.evaluate(context),
+          rightTerm = this.rightTerm.evaluate(context),
+          leftTermType = leftTerm.getType(),
+          rightTermType = rightTerm.getType();
+
+    if (leftTermType !== BOOLEAN_TYPE) {
+      const leftTermString = leftTerm.getString(),
+            message = `The '${leftTermString}' left term's type is '${leftTermType}' when it should be of type '${BOOLEAN_TYPE}'.`,
+            exception = Exception.fromMessage(message);
+
+      throw exception;
+    }
+
+    if (rightTermType !== BOOLEAN_TYPE) {
+      const rightTermString = rightTerm.getString(),
+            message = `The '${rightTermString}' right term's type is '${rightTermType}' when it should be of type '${BOOLEAN_TYPE}'.`,
+            exception = Exception.fromMessage(message);
+
+      throw exception;
+    }
+
+    const leftTermBoolean = leftTerm.getBoolean(),
+          rightTermBoolean = rightTerm.getBoolean(),
+          boolean = this.disjunction ?
+                      (leftTermBoolean || rightTermBoolean) :
+                        (leftTermBoolean && rightTermBoolean);
+
+    term = termFromBoolean(boolean, context);
+
+    context.debug(`...evaluated the '${logicaTermString}' logical term.`);
+
+    return term;
+  }
+
+  static name = "LogicaTerm";
+});

package/src/element/term/negated.js

@@ -0,0 +1,59 @@
+"use strict";
+
+import Exception from "../../exception";
+
+import { define } from "../../elements";
+import { BOOLEAN_TYPE } from "../../types";
+import { termFromBoolean } from "../../utilities/term";
+
+export default define(class NegatedTerm {
+  constructor(string, type, term) {
+    this.string = string;
+    this.type = type;
+    this.term = term;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getType() {
+    return this.type;
+  }
+
+  getTerm() {
+    return this.term;
+  }
+
+  evaluate(context) {
+    let term;
+
+    const negatedTermString = this.string; ///
+
+    context.trace(`Evaluating the '${negatedTermString}' negated term...`);
+
+    term = this.term.evaluate(context);
+
+    const termType = term.getType();
+
+    if (termType !== BOOLEAN_TYPE) {
+      const termString = term.getString(),
+            message = `The '${termString}' left term's type is '${termType}' when it should be of type '${BOOLEAN_TYPE}'.`,
+            exception = Exception.fromMessage(message);
+
+      throw exception;
+    }
+
+    let boolean = term.getBoolean();
+
+    boolean = !boolean;
+
+    term = termFromBoolean(boolean, context);
+
+    context.debug(`...evaluated the '${negatedTermString}' negated term.`);
+
+    return term;
+  }
+
+  static name = "NegatedTerm";
+});

package/src/element/term.js

@@ -3,10 +3,14 @@
 import { define } from "../elements";
 
 export default define(class Term {
-  constructor(string, variable, primitive) {
+  constructor(string, variable, primitive, negatedTerm, logicalTerm, bracketedTerm, comparisonTerm) {
     this.string = string;
     this.variable = variable;
     this.primitive = primitive;
+    this.negatedTerm = negatedTerm;
+    this.logicalTerm = logicalTerm;
+    this.bracketedTerm = bracketedTerm;
+    this.comparisonTerm = comparisonTerm;
   }
 
   getString() {
@@ -21,6 +25,22 @@ export default define(class Term {
     return this.primitive;
   }
 
+  getNegatedTerm() {
+    return this.negatedTerm;
+  }
+
+  getLogicalTerm() {
+    return this.logicalTerm;
+  }
+
+  getBreedingTerm() {
+    return this.bracketedTerm;
+  }
+
+  getComparisonTerm() {
+    return this.comparisonTerm;
+  }
+
   getNode() { return this.primitive.getNode(); }
 
   getNodes() { return this.primitive.getNodes(); }
@@ -40,6 +60,14 @@ export default define(class Term {
       type = this.variable.getType();
     } else if (this.primitive !== null) {
       type = this.primitive.getType();
+    } else if (this.negatedTerm !== null) {
+      type = this.negatedTerm.getType();
+    } else if (this.logicalTerm !== null) {
+      type = this.logicalTerm.getType();
+    } else if (this.bracketedTerm !== null) {
+      type = this.bracketedTerm.getType();
+    } else if (this.comparisonTerm !== null) {
+      type = this.comparisonTerm.getType();
     }
 
     return type;
@@ -54,14 +82,29 @@ export default define(class Term {
       term = this.variable.evaluate(context);
     } else if (this.primitive !== null) {
       term = this.primitive.evaluate(context);
+    } else if (this.negatedTerm !== null) {
+      term = this.negatedTerm.evaluate(context);
+    } else if (this.logicalTerm !== null) {
+      term = this.logicalTerm.evaluate(context);
+    } else if (this.bracketedTerm !== null) {
+      term = this.bracketedTerm.evaluate(context);
+    } else if (this.comparisonTerm !== null) {
+      term = this.comparisonTerm.evaluate(context);
     }
 
     return term;
   }
 
   isEqualTo(expression) {
-    const primitive = expression.getPrimitive(),
-          equalTo = this.primitive.isEqualTo(primitive);
+    let equalTo;
+
+    if (false) {
+      ///
+    } else if (this.variable !== null) {
+      equalTo = this.variable.isEqualTo();
+    } else if (this.primitive !== null) {
+      equalTo = this.primitive.isEqualTo();
+    }
 
     return equalTo;
   }

package/src/element/ternary.js

@@ -6,9 +6,9 @@ import { define } from "../elements";
 import { BOOLEAN_TYPE } from "../types";
 
 export default define(class Ternary {
-  constructor(string, expression, ifExpression, elseExpression) {
+  constructor(string, term, ifExpression, elseExpression) {
     this.string = string;
-    this.expression = expression;
+    this.term = term;
     this.ifExpression = ifExpression;
     this.elseExpression = elseExpression;
   }
@@ -17,8 +17,8 @@ export default define(class Ternary {
     return this.string;
   }
 
-  getExpression() {
-    return this.expression;
+  getTerm() {
+    return this.term;
   }
 
   getIfBlock() {
@@ -36,7 +36,7 @@ export default define(class Ternary {
 
     context.trace(`Evaluating the '${ternaryString}' ternary...`);
 
-    term = this.expression.evaluate(context);
+    term = this.term.evaluate(context);
 
     const termType = term.getType();
 

package/src/node/{comparison.js → expression/comparison.js}

@@ -2,15 +2,15 @@
 
 import { arrayUtilities } from "necessary";
 
-import NonTerminalNode from "../nonTerminalNode";
+import ExpressionNode from "../../node/expression";
 
-import { NOT_EQUAL_TO } from "../constants";
-import { SPECIAL_TOKEN_TYPE } from "../tokenTypes";
-import { EXPRESSION_RULE_NAME } from "../ruleNames";
+import { NOT_EQUAL_TO } from "../../constants";
+import { SPECIAL_TOKEN_TYPE } from "../../tokenTypes";
+import { EXPRESSION_RULE_NAME } from "../../ruleNames";
 
 const { first, second } = arrayUtilities;
 
-export default class ComparisonNode extends NonTerminalNode {
+export default class ComparisonExpressionNode extends ExpressionNode {
   isNegated() {
     let negated = false;
 
@@ -31,7 +31,7 @@ export default class ComparisonNode extends NonTerminalNode {
 
   getExpressionNodes() {
     const ruleName = EXPRESSION_RULE_NAME,
-      expressionNodes = this.getNodesByRuleName(ruleName);
+          expressionNodes = this.getNodesByRuleName(ruleName);
 
     return expressionNodes;
   }
@@ -64,5 +64,5 @@ export default class ComparisonNode extends NonTerminalNode {
     return secondExpressionNode;
   }
 
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ComparisonNode, ruleName, childNodes, opacity, precedence); }
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return ExpressionNode.fromRuleNameChildNodesOpacityAndPrecedence(ComparisonExpressionNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/expression.js

@@ -8,14 +8,14 @@ import { SOME_RULE_NAME,
          TERNARY_RULE_NAME,
          VARIABLE_RULE_NAME,
          PRIMITIVE_RULE_NAME,
-         COMPARISON_RULE_NAME,
          NODE_QUERY_RULE_NAME,
          NODES_QUERY_RULE_NAME,
          RETURN_BLOCK_RULE_NAME,
          PROCEDURE_CALL_RULE_NAME,
          NEGATED_EXPRESSION_RULE_NAME,
          LOGICAL_EXPRESSION_RULE_NAME,
-         BRACKETED_EXPRESSION_RULE_NAME } from "../ruleNames";
+         BRACKETED_EXPRESSION_RULE_NAME,
+         COMPARISON_EXPRESSION_RULE_NAME } from "../ruleNames";
 
 export default class ExpressionNode extends NonTerminalNode {
   getSomeNode() {
@@ -74,13 +74,6 @@ export default class ExpressionNode extends NonTerminalNode {
     return nodeSQueryNode;
   }
 
-  getComparisonNode() {
-    const ruleName = COMPARISON_RULE_NAME,
-      comparisonNode = this.getNodeByRuleName(ruleName);
-
-    return comparisonNode;
-  }
-
   getReturnBlockNode() {
     const ruleName = RETURN_BLOCK_RULE_NAME,
           returnBlockNode = this.getNodeByRuleName(ruleName);
@@ -116,6 +109,13 @@ export default class ExpressionNode extends NonTerminalNode {
     return bracketedExpressionRuleName;
   }
 
+  getComparisonExpressionNode() {
+    const ruleName = COMPARISON_EXPRESSION_RULE_NAME,
+          comparisonNode = this.getNodeByRuleName(ruleName);
+
+    return comparisonNode;
+  }
+
   static fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence) {
     if (precedence === undefined) {
       precedence = opacity; ///

package/src/node/term/bracketed.js

@@ -0,0 +1,16 @@
+"use strict";
+
+import TermNode from "../../node/term";
+
+import { TERM_RULE_NAME } from "../../ruleNames";
+
+export default class BracketedTermNode extends TermNode {
+  getTermNode() {
+    const ruleName = TERM_RULE_NAME,
+          termNode = this.getNodeByRuleName(ruleName);
+
+    return termNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return TermNode.fromRuleNameChildNodesOpacityAndPrecedence(BracketedTermNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/term/comparison.js

@@ -0,0 +1,68 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import TermNode from "../../node/term";
+
+import { NOT_EQUAL_TO } from "../../constants";
+import { TERM_RULE_NAME } from "../../ruleNames";
+import { SPECIAL_TOKEN_TYPE } from "../../tokenTypes";
+
+const { first, second } = arrayUtilities;
+
+export default class ComparisonTermNode extends TermNode {
+  isNegated() {
+    let negated = false;
+
+    const tokenType = SPECIAL_TOKEN_TYPE;
+
+    this.someTerminalNode((terminalNode) => {
+      const content = terminalNode.getContent();
+
+      if (content === NOT_EQUAL_TO) {
+        negated = true;
+      }
+
+      return true;
+    }, tokenType);
+
+    return negated;
+  }
+
+  getTermNodes() {
+    const ruleName = TERM_RULE_NAME,
+          termNodes = this.getNodesByRuleName(ruleName);
+
+    return termNodes;
+  }
+
+  getLeftTermNode() {
+    const firstTermNode = this.getFirstTermNode(),
+          leftTermNode = firstTermNode; ///
+
+    return leftTermNode;
+  }
+
+  getRightTermNode() {
+    const secondTermNode = this.getSecondTermNode(),
+          rightTermNode = secondTermNode;  ///
+
+    return rightTermNode;
+  }
+
+  getFirstTermNode() {
+    const termNodes = this.getTermNodes(),
+          firstTermNode = first(termNodes);
+
+    return firstTermNode;
+  }
+
+  getSecondTermNode() {
+    const termNodes = this.getTermNodes(),
+          secondTermNode = second(termNodes);
+
+    return secondTermNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return TermNode.fromRuleNameChildNodesOpacityAndPrecedence(ComparisonTermNode, ruleName, childNodes, opacity, precedence); }
+}