Merge pull request #1059 from glimmerjs/refactor/remove-legacy-test-p…

…atterns-and-packages

[REFACTOR] Removes legacy test patterns and packages

packages/@glimmer/integration-tests/index.ts

@@ -8,7 +8,6 @@ export * from './lib/markers';
 export * from './lib/modes/aot/delegate';
 export * from './lib/modes/jit/delegate';
 export * from './lib/modes/jit/register';
-export * from './lib/modes/jit/test-context';
 export * from './lib/modes/node/env';
 export * from './lib/modes/rehydration/delegate';
 export * from './lib/render-test';

packages/@glimmer/integration-tests/lib/modes/aot/delegate.ts

@@ -21,7 +21,7 @@ import {
   ElementBuilder,
   DynamicScope,
 } from '@glimmer/interfaces';
-import { WrappedBuilder } from '@glimmer/opcode-compiler';
+import { WrappedBuilder, PartialDefinitionImpl } from '@glimmer/opcode-compiler';
 import { PathReference, UpdatableRootReference, StableState } from '@glimmer/reference';
 import {
   clientBuilder,
@@ -32,7 +32,13 @@ import {
   AotRuntime,
 } from '@glimmer/runtime';
 import { assert, assign, expect, Option } from '@glimmer/util';
-import { SimpleElement, SimpleDocument } from '@simple-dom/interface';
+import {
+  SimpleElement,
+  SimpleDocument,
+  SimpleText,
+  ElementNamespace,
+  SimpleDocumentFragment,
+} from '@simple-dom/interface';
 import { BasicComponent, BasicComponentManager } from '../../components/basic';
 import {
   EmberishCurlyComponent,
@@ -58,6 +64,7 @@ import {
 import AotRuntimeResolverImpl from './resolver';
 import { TestMacros } from '../../compile/macros';
 import AotCompilerDelegate from './compiler-delegate';
+import { preprocess } from '../../compile';
 
 export type RenderDelegateComponentDefinition = ComponentDefinition<TestComponentDefinitionState>;
 
@@ -97,14 +104,9 @@ export class AotRenderDelegate implements RenderDelegate {
   public constants!: DebugConstants;
   private doc: SimpleDocument;
 
-  constructor(doc?: SimpleDocument) {
+  constructor(options?: { doc?: SimpleDocument }) {
     this.registerInternalHelper('-get-dynamic-var', getDynamicVar);
-    this.doc = doc || (document as SimpleDocument);
-  }
-
-  private registerInternalHelper(name: string, helper: GlimmerHelper): GlimmerHelper {
-    this.registry.register(name, 'helper', { default: helper });
-    return helper;
+    this.doc = options?.doc || (document as SimpleDocument);
   }
 
   getElementBuilder(env: Environment, cursor: Cursor): ElementBuilder {
@@ -119,6 +121,18 @@ export class AotRenderDelegate implements RenderDelegate {
     return this.doc.createElement(tagName);
   }
 
+  createTextNode(content: string): SimpleText {
+    return this.doc.createTextNode(content);
+  }
+
+  createElementNS(namespace: ElementNamespace, tagName: string): SimpleElement {
+    return this.doc.createElementNS(namespace, tagName);
+  }
+
+  createDocumentFragment(): SimpleDocumentFragment {
+    return this.doc.createDocumentFragment();
+  }
+
   registerComponent(
     type: ComponentKind,
     testType: ComponentKind,
@@ -162,6 +176,15 @@ export class AotRenderDelegate implements RenderDelegate {
     this.registry.register(name, 'helper', { default: glimmerHelper });
   }
 
+  registerInternalHelper(name: string, helper: GlimmerHelper) {
+    this.registry.register(name, 'helper', { default: helper });
+  }
+
+  registerPartial(name: string, source: string) {
+    let definition = new PartialDefinitionImpl(name, preprocess(source));
+    this.registry.register(name, 'partial', { default: definition });
+  }
+
   registerModifier(name: string, ModifierClass: TestModifierConstructor): void {
     let state = new TestModifierDefinitionState(ModifierClass);
     let manager = new TestModifierManager();

packages/@glimmer/integration-tests/lib/modes/jit/delegate.ts

@@ -7,22 +7,39 @@ import {
   Dict,
   RenderResult,
   Option,
+  Helper,
+  HandleResult,
 } from '@glimmer/interfaces';
-import { SimpleDocument, SimpleElement } from '@simple-dom/interface';
+import {
+  SimpleDocument,
+  SimpleElement,
+  ElementNamespace,
+  SimpleText,
+  SimpleDocumentFragment,
+} from '@simple-dom/interface';
 import { TestJitRegistry } from './registry';
-import { getDynamicVar, clientBuilder, JitRuntime } from '@glimmer/runtime';
+import {
+  getDynamicVar,
+  clientBuilder,
+  JitRuntime,
+  EnvironmentDelegate,
+  CurriedComponentDefinition,
+} from '@glimmer/runtime';
 import {
   registerInternalHelper,
   registerStaticTaglessComponent,
   registerEmberishCurlyComponent,
   registerEmberishGlimmerComponent,
   registerModifier,
   registerHelper,
+  registerPartial,
+  registerTemplate,
+  componentHelper,
 } from './register';
 import { TestMacros } from '../../compile/macros';
 import JitCompileTimeLookup from './compilation-context';
 import TestJitRuntimeResolver from './resolver';
-import RenderDelegate from '../../render-delegate';
+import RenderDelegate, { RenderDelegateOptions } from '../../render-delegate';
 import { ComponentKind, ComponentTypes } from '../../components';
 import { BasicComponentFactory } from '../../components/basic';
 import { EmberishCurlyComponentFactory } from '../../components/emberish-curly';
@@ -32,6 +49,8 @@ import { UserHelper } from '../../helpers';
 import { UpdatableRootReference, ConstReference } from '@glimmer/reference';
 import { renderTemplate } from './render';
 import { JitContext } from '@glimmer/opcode-compiler';
+import { preprocess } from '../../compile';
+import { unwrapTemplate } from '@glimmer/util';
 
 export interface JitTestDelegateContext {
   runtime: JitRuntimeContext;
@@ -41,11 +60,12 @@ export interface JitTestDelegateContext {
 export function JitDelegateContext(
   doc: SimpleDocument,
   resolver: TestJitRuntimeResolver,
-  registry: TestJitRegistry
+  registry: TestJitRegistry,
+  env: EnvironmentDelegate = {}
 ): JitTestDelegateContext {
   registerInternalHelper(registry, '-get-dynamic-var', getDynamicVar);
   let context = JitContext(new JitCompileTimeLookup(resolver, registry), new TestMacros());
-  let runtime = JitRuntime({ document: doc }, {}, context, resolver);
+  let runtime = JitRuntime({ document: doc }, env, context, resolver);
   return { runtime, syntax: context };
 }
 
@@ -57,13 +77,17 @@ export class JitRenderDelegate implements RenderDelegate {
   private registry: TestJitRegistry = this.resolver.registry;
   private context: JitTestDelegateContext;
   private self: Option<UpdatableRootReference> = null;
+  private doc: SimpleDocument;
+  private env: EnvironmentDelegate;
 
-  constructor(private doc: SimpleDocument = document as SimpleDocument) {
+  constructor(options?: RenderDelegateOptions) {
+    this.doc = options?.doc ?? (document as SimpleDocument);
+    this.env = options?.env ?? {};
     this.context = this.getContext();
   }
 
   getContext(): JitTestDelegateContext {
-    return JitDelegateContext(this.doc, this.resolver, this.registry);
+    return JitDelegateContext(this.doc, this.resolver, this.registry, this.env);
   }
 
   getInitialElement(): SimpleElement {
@@ -78,12 +102,42 @@ export class JitRenderDelegate implements RenderDelegate {
     return this.doc.createElement(tagName);
   }
 
-  registerComponent<K extends ComponentKind, L extends ComponentKind>(
+  createTextNode(content: string): SimpleText {
+    return this.doc.createTextNode(content);
+  }
+
+  createElementNS(namespace: ElementNamespace, tagName: string): SimpleElement {
+    return this.doc.createElementNS(namespace, tagName);
+  }
+
+  createDocumentFragment(): SimpleDocumentFragment {
+    return this.doc.createDocumentFragment();
+  }
+
+  createCurriedComponent(name: string): Option<CurriedComponentDefinition> {
+    return componentHelper(this.resolver, this.registry, name);
+  }
+
+  registerComponent<K extends 'Basic' | 'Fragment' | 'Glimmer', L extends ComponentKind>(
     type: K,
     _testType: L,
     name: string,
     layout: string,
     Class?: ComponentTypes[K]
+  ): void;
+  registerComponent<K extends 'Curly' | 'Dynamic', L extends ComponentKind>(
+    type: K,
+    _testType: L,
+    name: string,
+    layout: Option<string>,
+    Class?: ComponentTypes[K]
+  ): void;
+  registerComponent<K extends ComponentKind, L extends ComponentKind>(
+    type: K,
+    _testType: L,
+    name: string,
+    layout: Option<string>,
+    Class?: ComponentTypes[K]
   ) {
     switch (type) {
       case 'Basic':
@@ -92,7 +146,7 @@ export class JitRenderDelegate implements RenderDelegate {
           this.registry,
           name,
           Class as BasicComponentFactory,
-          layout
+          layout!
         );
       case 'Curly':
       case 'Dynamic':
@@ -107,7 +161,7 @@ export class JitRenderDelegate implements RenderDelegate {
           this.registry,
           name,
           (Class as any) as EmberishGlimmerComponentFactory,
-          layout
+          layout!
         );
     }
   }
@@ -120,10 +174,22 @@ export class JitRenderDelegate implements RenderDelegate {
     registerHelper(this.registry, name, helper);
   }
 
+  registerInternalHelper(name: string, helper: Helper) {
+    registerInternalHelper(this.registry, name, helper);
+  }
+
   getElementBuilder(env: Environment, cursor: Cursor): ElementBuilder {
     return clientBuilder(env, cursor);
   }
 
+  registerPartial(name: string, content: string) {
+    registerPartial(this.registry, name, content);
+  }
+
+  registerTemplate(name: string, content: string) {
+    return registerTemplate(this.registry, name, content);
+  }
+
   getSelf(context: unknown): UpdatableRootReference | ConstReference {
     if (!this.self) {
       this.self = new UpdatableRootReference(context);
@@ -132,6 +198,14 @@ export class JitRenderDelegate implements RenderDelegate {
     return this.self;
   }
 
+  compileTemplate(template: string): HandleResult {
+    let compiled = preprocess(template);
+
+    return unwrapTemplate(compiled)
+      .asLayout()
+      .compile(this.context.syntax);
+  }
+
   renderTemplate(template: string, context: Dict<unknown>, element: SimpleElement): RenderResult {
     let cursor = { element, nextSibling: null };
 

packages/@glimmer/integration-tests/lib/modes/node/env.ts

@@ -4,7 +4,7 @@ import { SimpleDocument } from '@simple-dom/interface';
 import { JitRenderDelegate } from '../jit/delegate';
 import { AotRenderDelegate } from '../aot/delegate';
 import { RenderTest } from '../../render-test';
-import RenderDelegate from '../../render-delegate';
+import RenderDelegate, { RenderDelegateOptions } from '../../render-delegate';
 import { toInnerHTML, assertElement } from '../../dom/simple-utils';
 
 export interface NodeEnvironmentOptions {
@@ -16,16 +16,18 @@ export interface NodeEnvironmentOptions {
 export class NodeJitRenderDelegate extends JitRenderDelegate {
   static style = 'node jit';
 
-  constructor() {
-    super(createHTMLDocument());
+  constructor(options: RenderDelegateOptions = {}) {
+    options.doc = options.doc || createHTMLDocument();
+    super(options);
   }
 }
 
 export class NodeAotRenderDelegate extends AotRenderDelegate {
   static style = 'node aot';
 
-  constructor() {
-    super(createHTMLDocument());
+  constructor(options: RenderDelegateOptions = {}) {
+    options.doc = options.doc || createHTMLDocument();
+    super(options);
   }
 }
 
@@ -54,7 +56,8 @@ export class AbstractNodeTest extends RenderTest {
 }
 
 export class NodeRenderDelegate extends AotRenderDelegate {
-  constructor(doc: SimpleDocument = createHTMLDocument()) {
-    super(doc);
+  constructor(options: RenderDelegateOptions = {}) {
+    options.doc = options.doc ?? createHTMLDocument();
+    super(options);
   }
 }