npm run format -ws

2023-01-09 19:02:19 -05:00
parent 3df70b2491
commit c49981ec64
113 changed files with 3252 additions and 4573 deletions
@@ -1,12 +1,8 @@
-import { Evaluator, Lexer, Parser } from "@github/actions-expressions"
-import { Expr } from "@github/actions-expressions/ast"
-import {
-  Dictionary,
-  ExpressionData,
-  Kind,
-} from "@github/actions-expressions/data/index"
-import { FunctionInfo } from "@github/actions-expressions/funcs/info"
-import { TemplateContext } from "./template-context"
+import {Evaluator, Lexer, Parser} from "@github/actions-expressions";
+import {Expr} from "@github/actions-expressions/ast";
+import {Dictionary, ExpressionData, Kind} from "@github/actions-expressions/data/index";
+import {FunctionInfo} from "@github/actions-expressions/funcs/info";
+import {TemplateContext} from "./template-context";
 import {
  BasicExpressionToken,
  BooleanToken,
@@ -16,115 +12,74 @@ import {
  NumberToken,
  SequenceToken,
  StringToken,
-  TemplateToken,
-} from "./tokens"
-import { TokenType } from "./tokens/types"
+  TemplateToken
+} from "./tokens";
+import {TokenType} from "./tokens/types";

-export function evaluateStringToken(
-  token: BasicExpressionToken,
-  context: TemplateContext
-): TemplateToken {
-  const expr = parseExpression(
-    token.expression,
-    context.expressionNamedContexts,
-    context.expressionFunctions
-  )
+export function evaluateStringToken(token: BasicExpressionToken, context: TemplateContext): TemplateToken {
+  const expr = parseExpression(token.expression, context.expressionNamedContexts, context.expressionFunctions);
  if (!expr) {
-    throw new Error("Unexpected empty expression")
+    throw new Error("Unexpected empty expression");
  }
  // TODO: Pass in context
-  const evaluator = new Evaluator(expr, new Dictionary())
-  const result = evaluator.evaluate()
+  const evaluator = new Evaluator(expr, new Dictionary());
+  const result = evaluator.evaluate();
  if (!result.primitive) {
-    context.error(token, "Expected a string")
-    return new StringToken(
-      token.file,
-      token.range,
-      token.expression,
-      token.definitionInfo
-    )
+    context.error(token, "Expected a string");
+    return new StringToken(token.file, token.range, token.expression, token.definitionInfo);
  }

-  return new StringToken(
-    token.file,
-    token.range,
-    result.coerceString(),
-    token.definitionInfo
-  )
+  return new StringToken(token.file, token.range, result.coerceString(), token.definitionInfo);
 }

-export function evaluateSequenceToken(
-  token: BasicExpressionToken,
-  context: TemplateContext
-): TemplateToken {
-  const expr = parseExpression(
-    token.expression,
-    context.expressionNamedContexts,
-    context.expressionFunctions
-  )
+export function evaluateSequenceToken(token: BasicExpressionToken, context: TemplateContext): TemplateToken {
+  const expr = parseExpression(token.expression, context.expressionNamedContexts, context.expressionFunctions);
  if (!expr) {
-    throw new Error("Unexpected empty expression")
+    throw new Error("Unexpected empty expression");
  }
  // TODO: Pass in context
-  const evaluator = new Evaluator(expr, new Dictionary())
-  const result = evaluator.evaluate()
-  const value = convertToTemplateToken(token, result)
+  const evaluator = new Evaluator(expr, new Dictionary());
+  const result = evaluator.evaluate();
+  const value = convertToTemplateToken(token, result);
  if (value.templateTokenType !== TokenType.Sequence) {
-    context.error(token, "Expected a sequence")
-    return new SequenceToken(token.file, token.range, token.definitionInfo)
+    context.error(token, "Expected a sequence");
+    return new SequenceToken(token.file, token.range, token.definitionInfo);
  }
-  return value
+  return value;
 }

-export function evaluateMappingToken(
-  token: BasicExpressionToken,
-  context: TemplateContext
-): MappingToken {
-  const expr = parseExpression(
-    token.expression,
-    context.expressionNamedContexts,
-    context.expressionFunctions
-  )
+export function evaluateMappingToken(token: BasicExpressionToken, context: TemplateContext): MappingToken {
+  const expr = parseExpression(token.expression, context.expressionNamedContexts, context.expressionFunctions);
  if (!expr) {
-    throw new Error("Unexpected empty expression")
+    throw new Error("Unexpected empty expression");
  }
  // TODO: Pass in context
-  const evaluator = new Evaluator(expr, new Dictionary())
-  const result = evaluator.evaluate()
-  const value = convertToTemplateToken(token, result)
+  const evaluator = new Evaluator(expr, new Dictionary());
+  const result = evaluator.evaluate();
+  const value = convertToTemplateToken(token, result);
  if (value.templateTokenType !== TokenType.Mapping) {
-    context.error(token, "Expected a mapping")
-    return new MappingToken(token.file, token.range, token.definitionInfo)
+    context.error(token, "Expected a mapping");
+    return new MappingToken(token.file, token.range, token.definitionInfo);
  }
-  return value as MappingToken
+  return value as MappingToken;
 }

-export function evaluateTemplateToken(
-  token: BasicExpressionToken,
-  context: TemplateContext
-): TemplateToken {
-  const expr = parseExpression(
-    token.expression,
-    context.expressionNamedContexts,
-    context.expressionFunctions
-  )
+export function evaluateTemplateToken(token: BasicExpressionToken, context: TemplateContext): TemplateToken {
+  const expr = parseExpression(token.expression, context.expressionNamedContexts, context.expressionFunctions);
  if (!expr) {
-    throw new Error("Unexpected empty expression")
+    throw new Error("Unexpected empty expression");
  }
  // TODO: Pass in context
-  const evaluator = new Evaluator(expr, new Dictionary())
-  const result = evaluator.evaluate()
-  return convertToTemplateToken(token, result)
+  const evaluator = new Evaluator(expr, new Dictionary());
+  const result = evaluator.evaluate();
+  return convertToTemplateToken(token, result);
 }

-function convertToTemplateToken(
-  token: BasicExpressionToken,
-  result: ExpressionData
-): TemplateToken {
+function convertToTemplateToken(token: BasicExpressionToken, result: ExpressionData): TemplateToken {
  // Literal
-  const literal = convertToLiteralToken(token, result)
+  const literal = convertToLiteralToken(token, result);
  if (literal) {
-    return literal
+    return literal;
  }

  // TODO: Support expressions that return a sequence or mapping token
@@ -132,80 +87,45 @@ function convertToTemplateToken(
  // Leverage the expression SDK to traverse the object
  switch (result.kind) {
    case Kind.Dictionary: {
-      const mapping = new MappingToken(
-        token.file,
-        token.range,
-        token.definitionInfo
-      )
-      for (const { key, value } of result.pairs()) {
-        const keyToken = new StringToken(
-          token.file,
-          token.range,
-          key,
-          token.definitionInfo
-        )
-        const valueToken = convertToTemplateToken(token, value)
-        mapping.add(keyToken, valueToken)
+      const mapping = new MappingToken(token.file, token.range, token.definitionInfo);
+      for (const {key, value} of result.pairs()) {
+        const keyToken = new StringToken(token.file, token.range, key, token.definitionInfo);
+        const valueToken = convertToTemplateToken(token, value);
+        mapping.add(keyToken, valueToken);
      }
-      return mapping
+      return mapping;
    }
    case Kind.Array: {
-      const sequence = new SequenceToken(
-        token.file,
-        token.range,
-        token.definitionInfo
-      )
+      const sequence = new SequenceToken(token.file, token.range, token.definitionInfo);
      for (const value of result.values()) {
-        const itemToken = convertToTemplateToken(token, value)
-        sequence.add(itemToken)
+        const itemToken = convertToTemplateToken(token, value);
+        sequence.add(itemToken);
      }
-      return sequence
+      return sequence;
    }
    default:
-      throw new Error("Unable to convert the object to a template token")
+      throw new Error("Unable to convert the object to a template token");
  }
 }

-function convertToLiteralToken(
-  token: BasicExpressionToken,
-  result: ExpressionData
-): LiteralToken | undefined {
+function convertToLiteralToken(token: BasicExpressionToken, result: ExpressionData): LiteralToken | undefined {
  switch (result.kind) {
    case Kind.Null:
-      return new NullToken(token.file, token.range, token.definitionInfo)
+      return new NullToken(token.file, token.range, token.definitionInfo);
    case Kind.Boolean:
-      return new BooleanToken(
-        token.file,
-        token.range,
-        result.value,
-        token.definitionInfo
-      )
+      return new BooleanToken(token.file, token.range, result.value, token.definitionInfo);
    case Kind.Number:
-      return new NumberToken(
-        token.file,
-        token.range,
-        result.value,
-        token.definitionInfo
-      )
+      return new NumberToken(token.file, token.range, result.value, token.definitionInfo);
    case Kind.String:
-      return new StringToken(
-        token.file,
-        token.range,
-        result.value,
-        token.definitionInfo
-      )
+      return new StringToken(token.file, token.range, result.value, token.definitionInfo);
  }

-  return undefined
+  return undefined;
 }

-function parseExpression(
-  expression: string,
-  contexts: string[],
-  functions: FunctionInfo[]
-): Expr {
-  const lexer = new Lexer(expression)
-  const result = lexer.lex()
-  const p = new Parser(result.tokens, contexts, functions)
-  return p.parse()
+function parseExpression(expression: string, contexts: string[], functions: FunctionInfo[]): Expr {
+  const lexer = new Lexer(expression);
+  const result = lexer.lex();
+  const p = new Parser(result.tokens, contexts, functions);
+  return p.parse();
 }