Context extraction

src/tokens.js

@@ -576,7 +576,7 @@
   /**
    * Takes any number of Contexts and merges them into a single context.
    *
-   * @param { ...VariableContext } contexts
+   * @param  { ...ContextValue } contexts
    * @returns { VariableContext }
    */
   static of(...contexts) {
@@ -1026,6 +1026,11 @@
         if (name?.raw === 'get value') {
           variables = getContextValue(variables, args);
         }
+
+        // construct context type through context(entries) utility
+        if (name?.raw === 'context') {
+          variables = getContextFromEntries(variables, args);
+        }
       }
 
       const start = contextStarts[term];
@@ -1246,6 +1251,76 @@
   });
 }
 
+function getContextFromEntries(variables, args) {
+
+  const VariableContext = /** @type { typeof VariableContext } */ (
+    variables.context.constructor
+  );
+
+  if (!args.length) {
+    return variables.assign({
+      value: null
+    });
+  }
+
+  if (args[0].name === 'Name') {
+    args = extractNamedArgs(args, [ 'entries' ]);
+  }
+
+  if (args.length !== 1) {
+    return variables.assign({
+      value: null
+    });
+  }
+
+  const [
+    key
+  ] = args;
+
+  console.log('\n\n\n------------');
+
+  const keyValue = key?.computedValue();
+
+  console.log('%o', {
+    keyValue,
+    children: keyValue?.children
+  });
+
+  const entryContexts = keyValue?.get('$$entries')?.value || (keyValue && [ keyValue ]) || [];
+
+  const context = reduce(entryContexts, (context, entryContext) => {
+
+    console.log('%o', { entryContext });
+
+    const keyValue = entryContext?.get('key');
+    const valueValue = entryContext?.get('value');
+
+    console.log('%o', {
+      keyValue,
+      valueValue
+    });
+
+    const value = entryContext?.value;
+
+    if (!value) {
+      return context;
+    }
+
+    if (has(value, 'key') && has(value, 'value')) {
+      return {
+        ...context,
+        [ value.key ]: value.value
+      };
+    }
+
+    return context;
+  }, {});
+
+  return variables.assign({
+    value: context
+  });
+}
+
 function extractNamedArgs(args, argNames) {
 
   const context = {};

test/expressions.txt

@@ -197,7 +197,7 @@ Expression(
 )
 
 
-# Built in (get value) { "top": "Expressions" }
+# Built-in (get value) { "top": "Expressions" }
 
 get value();
 get value(null, 1);
@@ -222,7 +222,7 @@ Expressions(
 )
 
 
-# Built in (get value, literal key) { "context": { "x": { "a+b": { "c+": 1 } } } }
+# Built-in (get value, literal key) { "context": { "x": { "a+b": { "c+": 1 } } } }
 
 get value(x, "a+b").c+
 
@@ -242,7 +242,7 @@ Expression(
 )
 
 
-# Built in (get value, literal key, named args) { "context": { "x": { "a+b": { "c+": 1 } } } }
+# Built-in (get value, literal key, named args) { "context": { "x": { "a+b": { "c+": 1 } } } }
 
 get value(key: "a+b", m: x).c+;
 
@@ -260,7 +260,7 @@ Expression(
 )
 
 
-# Built in (get value, special key)
+# Built-in (get value, special key)
 
 get value({
   foo-bar: {
@@ -295,7 +295,7 @@ Expression(
 )
 
 
-# Built in (get value, special key, named args)
+# Built-in (get value, special key, named args)
 
 get value(key: "foo-bar", m: {
   foo-bar: {
@@ -329,6 +329,175 @@ Expression(
 )
 
 
+# Built-in (context)
+
+context([
+  { key: "b+", value: { c-: 1} }
+]).b+.c-
+
+==>
+
+Expression(...)
+
+
+# Built-in (context, referenced)
+
+{
+  entries: [
+    {
+      "key": "a + b",
+      "value": 1
+    },
+    {
+      "key": "b--",
+      "value": 2
+    }
+  ],
+  ctx: context(entries),
+  value: ctx.a + b + ctx.b--
+}
+
+==>
+
+Expression(
+  Context("{",
+    ContextEntry(
+      Key(...),List(...)
+    ),
+    ContextEntry(
+      Key(...),FunctionInvocation(...)
+    ),
+    ContextEntry(
+      Key(...),ArithmeticExpression(
+        PathExpression(
+          VariableName(...),
+          VariableName(...)
+        ),
+        ArithOp,
+        PathExpression(
+          VariableName(...),
+          VariableName(...)
+        )
+      )
+    ),
+  "}")
+)
+
+
+# Built-in (context, dynamic entry)
+
+{
+  dynamicEntry: {
+    "key": "a + b",
+    "value": {
+      d-e: 1000
+    }
+  },
+  entries: [
+    dynamicEntry
+  ],
+  ctx: context(entries),
+  value: ctx.a+b.d-e
+}
+
+==>
+
+Expression(
+  Context("{",
+    ContextEntry(
+      Key(...),Context(...)
+    ),
+    ContextEntry(
+      Key(...),List("[",
+        VariableName(...),
+      "]")
+    ),
+    ContextEntry(
+      Key(...),FunctionInvocation(...)
+    ),
+    ContextEntry(
+      Key(Name(...)),PathExpression(
+        PathExpression(
+          VariableName(...),
+          VariableName(...)
+        ),
+        VariableName(...)
+      )
+    ),
+  "}")
+)
+
+
+# Built-in (context, dynamic key/value)
+
+{
+  dynamicKey: "a + b",
+  dynamicValue: {
+    d-e: 1000
+  },
+  entries: [
+    {
+      "key": dynamicKey,
+      "value": dynamicValue
+    }
+  ],
+  ctx: context(entries),
+  value: ctx.a + b.d-e
+}
+
+==>
+
+Expression(
+  Context("{",
+    ContextEntry(
+      Key(...),StringLiteral
+    ),
+    ContextEntry(
+      Key(...),Context(...)
+    ),
+    ContextEntry(
+      Key(...),List("[",
+        Context("{",
+          ContextEntry(...),
+          ContextEntry(...),
+        "}")
+      "]")
+    ),
+    ContextEntry(
+      Key(...),FunctionInvocation(...)
+    ),
+    ContextEntry(
+      Key(Name(...)),PathExpression(
+        PathExpression(
+          VariableName(...),
+          VariableName(...)
+        ),
+        VariableName(...)
+      )
+    ),
+  "}")
+)
+
+
+# Built-in (context, error)
+
+[
+  context(),
+  context(null),
+  context([]),
+  context([ { foo: bar }, 1 ]),
+  context([ nope ]),
+  context([ { key: nope, value: 100 } ]),
+  context([ { key: 'abc' } ])
+]
+
+==>
+
+Expression(
+  List(...)
+)
+
+
 # null { "top": "Expressions" }
 
 null[1];
@@ -2075,6 +2244,20 @@ Expression(
 )
 
 
+# Context (simple)
+
+{
+  a: 1,
+  b: "BAR"
+}
+
+==>
+
+Expression(
+  Context(...)
+)
+
+
 # Context (variable scopes)
 
 {