Merge feature-nested-sets into develop

app/imports/parser/parseTree/_index.js

@@ -1,16 +1,16 @@
-import accessor from './accessor.js';
-import array from './array.js';
-import call from './call.js';
-import constant from './constant.js';
-import error from './error.js';
-import ifNode from './if.js';
-import index from './index.js';
-import not from './not.js';
-import operator from './operator.js';
-import parenthesis from './parenthesis.js';
-import roll from './roll.js';
-import rollArray from './rollArray.js';
-import unaryOperator from './unaryOperator.js';
+import accessor from './accessor';
+import array from './array';
+import call from './call';
+import constant from './constant';
+import error from './error';
+import ifNode from './if';
+import index from './index';
+import not from './not';
+import operator from './operator';
+import parenthesis from './parenthesis';
+import roll from './roll';
+import rollArray from './rollArray';
+import unaryOperator from './unaryOperator';
 
 export default Object.freeze({
   accessor,

app/imports/parser/parseTree/accessor.js

@@ -1,6 +1,6 @@
-import constant from './constant.js';
-import array from './array.js';
-import resolve from '../resolve.js';
+import constant from './constant';
+import array from './array';
+import resolve from '../resolve';
 import { getFromScope } from '/imports/api/creature/creatures/CreatureVariables';
 
 const accessor = {
@@ -39,10 +39,7 @@ const accessor = {
     // Return a parse node based on the constant type returned
     if (valueType === 'string' || valueType === 'number' || valueType === 'boolean') {
       return {
-        result: constant.create({
-          value,
-          valueType
-        }),
+        result: constant.create({ value }),
         context,
       };
     }

app/imports/parser/parseTree/array.js

@@ -1,5 +1,5 @@
-import resolve, { toString, traverse, map } from '../resolve.js';
-import constant from './constant.js';
+import resolve, { toString, traverse, map } from '../resolve';
+import constant from './constant';
 
 const array = {
   create({ values }) {

app/imports/parser/parseTree/call.js

@@ -1,7 +1,7 @@
-import error from './error.js';
-import constant from './constant.js';
-import functions from '/imports/parser/functions.js';
-import resolve, { toString, traverse, map } from '../resolve.js';
+import error from './error';
+import constant from './constant';
+import functions from '/imports/parser/functions';
+import resolve, { toString, traverse, map } from '../resolve';
 
 const call = {
   create({ functionName, args }) {

app/imports/parser/parseTree/not.js

@@ -1,16 +1,16 @@
-import resolve, { toString, traverse, map } from '../resolve.js';
-import constant from './constant.js';
+import resolve, { toString, traverse, map } from '../resolve';
+import constant from './constant';
 
 const not = {
-  create({right}) {
+  create({ right }) {
     return {
       parseType: 'not',
       right,
     }
   },
-  resolve(fn, node, scope, context){
-    const {result: right} = resolve(fn, node.right, scope, context);
-    if (right.parseType !== 'constant'){
+  resolve(fn, node, scope, context) {
+    const { result: right } = resolve(fn, node.right, scope, context);
+    if (right.parseType !== 'constant') {
       return {
         result: not.create({
           right: right,
@@ -25,16 +25,16 @@ const not = {
       context,
     };
   },
-  toString(node){
+  toString(node) {
     return `!${toString(node.right)}`;
   },
-  traverse(node, fn){
+  traverse(node, fn) {
     fn(node);
     traverse(node.right, fn);
   },
-  map(node, fn){
+  map(node, fn) {
     const resultingNode = fn(node);
-    if (resultingNode === node){
+    if (resultingNode === node) {
       node.right = map(node.right, fn);
     }
     return resultingNode;

app/imports/parser/parseTree/operator.js

@@ -1,18 +1,17 @@
-import resolve, { toString, traverse, map } from '../resolve.js';
-import constant from './constant.js';
+import resolve, { toString, traverse, map } from '../resolve';
+import constant from './constant';
 
 // Which operators can be considered commutative by the parser
 // i.e. 1 + 2 + 3 === 2 + 3 + 1
 const commutativeOperators = ['+', '*']
 
 const operator = {
-  create({ left, right, operator, fn }) {
+  create({ left, right, operator }) {
     return {
       parseType: 'operator',
       left,
       right,
       operator,
-      fn
     };
   },
   resolve(fn, node, scope, context) {

app/imports/parser/parseTree/parenthesis.js

@@ -1,37 +1,37 @@
-import resolve, { toString, traverse, map } from '../resolve.js';
+import resolve, { toString, traverse, map } from '../resolve';
 
 const parenthesis = {
-  create({content}) {
+  create({ content }) {
     return {
       parseType: 'parenthesis',
       content,
     };
   },
-  resolve(fn, node, scope, context){
-    const {result: content} = resolve(fn, node.content, scope, context);
+  resolve(fn, node, scope, context) {
+    const { result: content } = resolve(fn, node.content, scope, context);
     if (
       fn === 'reduce' ||
       content.parseType === 'constant' ||
       content.parseType === 'error'
-    ){
-      return {result: content, context};
+    ) {
+      return { result: content, context };
     } else {
       return {
-        result: parenthesis.create({content}),
+        result: parenthesis.create({ content }),
         context
       };
     }
   },
-  toString(node){
+  toString(node) {
     return `(${toString(node.content)})`;
   },
-  traverse(node, fn){
+  traverse(node, fn) {
     fn(node);
     traverse(node.content, fn);
   },
-  map(node, fn){
+  map(node, fn) {
     const resultingNode = fn(node);
-    if (resultingNode === node){
+    if (resultingNode === node) {
       node.content = map(node.content, fn);
     }
     return resultingNode;

app/imports/parser/parseTree/roll.js

@@ -1,8 +1,8 @@
-import resolve, { toString, traverse, map } from '../resolve.js';
-import error from './error.js';
-import rollArray from './rollArray.js';
-import rollDice from '/imports/parser/rollDice.js';
-import STORAGE_LIMITS from '/imports/constants/STORAGE_LIMITS.js';
+import resolve, { toString, traverse, map } from '../resolve';
+import error from './error';
+import rollArray from './rollArray';
+import rollDice from '/imports/parser/rollDice';
+import STORAGE_LIMITS from '/imports/constants/STORAGE_LIMITS';
 
 const rollNode = {
   create({ left, right }) {

app/imports/parser/parseTree/rollArray.js

@@ -1,4 +1,4 @@
-import constant from './constant.js';
+import constant from './constant';
 
 const rollArray = {
   create({ values, diceSize, diceNum }) {

app/imports/parser/parseTree/unaryOperator.js

@@ -1,17 +1,17 @@
-import resolve, { toString, traverse, map } from '../resolve.js';
-import constant from './constant.js';
+import resolve, { toString, traverse, map } from '../resolve';
+import constant from './constant';
 
 const unaryOperator = {
-  create({operator, right}) {
+  create({ operator, right }) {
     return {
       parseType: 'unaryOperator',
       operator,
       right,
     };
   },
-  resolve(fn, node, scope, context){
-    const {result: rightNode} = resolve(fn, node.right, scope, context);
-    if (rightNode.valueType !== 'number'){
+  resolve(fn, node, scope, context) {
+    const { result: rightNode } = resolve(fn, node.right, scope, context);
+    if (rightNode.valueType !== 'number') {
       return {
         result: unaryOperator.create({
           operator: node.operator,
@@ -22,7 +22,7 @@ const unaryOperator = {
     }
     let right = rightNode.value;
     let result;
-    switch(node.operator){
+    switch (node.operator) {
       case '-': result = -right; break;
       case '+': result = +right; break;
     }
@@ -34,16 +34,16 @@ const unaryOperator = {
       context,
     };
   },
-  toString(node){
+  toString(node) {
     return `${node.operator}${toString(node.right)}`;
   },
-  traverse(node, fn){
+  traverse(node, fn) {
     fn(node);
     traverse(node.right, fn);
   },
-  map(node, fn){
+  map(node, fn) {
     const resultingNode = fn(node);
-    if (resultingNode === node){
+    if (resultingNode === node) {
       node.right = map(node.right, fn);
     }
     return resultingNode;