@typespec/emitter-framework 0.9.0-dev.1 → 0.9.0-dev.10

package/src/csharp/components/class/declaration.test.tsx

@@ -0,0 +1,339 @@
+import { Tester } from "#test/test-host.js";
+import { type Children } from "@alloy-js/core";
+import { createCSharpNamePolicy, Namespace, SourceFile } from "@alloy-js/csharp";
+import { t, type TesterInstance } from "@typespec/compiler/testing";
+import { beforeEach, describe, expect, it } from "vitest";
+import { Output } from "../../../core/index.js";
+import { ClassDeclaration, EnumDeclaration } from "../../index.js";
+
+let runner: TesterInstance;
+
+beforeEach(async () => {
+  runner = await Tester.createInstance();
+});
+
+function Wrapper(props: { children: Children }) {
+  const policy = createCSharpNamePolicy();
+  return (
+    <Output program={runner.program} namePolicy={policy}>
+      <Namespace name="TestNamespace">
+        <SourceFile path="test.cs">{props.children}</SourceFile>
+      </Namespace>
+    </Output>
+  );
+}
+
+it("renders an empty class declaration", async () => {
+  const { TestModel } = await runner.compile(t.code`
+    model ${t.model("TestModel")} {}
+  `);
+
+  expect(
+    <Wrapper>
+      <ClassDeclaration type={TestModel} />
+    </Wrapper>,
+  ).toRenderTo(`
+    namespace TestNamespace
+    {
+        class TestModel
+        {
+
+        }
+    }
+  `);
+});
+
+it("renders a class declaration with properties", async () => {
+  const { TestModel } = await runner.compile(t.code`
+    model ${t.model("TestModel")} {
+      @test Prop1: string;
+      @test Prop2: int32;
+    }
+  `);
+
+  expect(
+    <Wrapper>
+      <ClassDeclaration type={TestModel} />
+    </Wrapper>,
+  ).toRenderTo(`
+    namespace TestNamespace
+    {
+        class TestModel
+        {
+            public required string Prop1 { get; set; }
+            public required int Prop2 { get; set; }
+        }
+    }
+  `);
+});
+
+it("can override class name", async () => {
+  const { TestModel } = await runner.compile(t.code`
+    model ${t.model("TestModel")} {}
+  `);
+
+  expect(
+    <Wrapper>
+      <ClassDeclaration type={TestModel} name="CustomClassName" />
+    </Wrapper>,
+  ).toRenderTo(`
+    namespace TestNamespace
+    {
+        class CustomClassName
+        {
+
+        }
+    }
+  `);
+});
+
+it("renders a class with access modifiers", async () => {
+  const { TestModel } = await runner.compile(t.code`
+    model ${t.model("TestModel")} {
+    }
+  `);
+
+  expect(
+    <Wrapper>
+      <ClassDeclaration type={TestModel} protected />
+    </Wrapper>,
+  ).toRenderTo(`
+    namespace TestNamespace
+    {
+        protected class TestModel
+        {
+
+        }
+    }
+  `);
+});
+
+describe("from an interface", () => {
+  it("renders an empty class", async () => {
+    const { TestInterface } = await runner.compile(t.code`
+    interface ${t.interface("TestInterface")} {
+    }
+  `);
+
+    expect(
+      <Wrapper>
+        <ClassDeclaration type={TestInterface} />
+      </Wrapper>,
+    ).toRenderTo(`
+      namespace TestNamespace
+      {
+          class TestInterface
+          {
+
+          }
+      }
+    `);
+  });
+
+  it("renders a class with operations", async () => {
+    const { TestInterface } = await runner.compile(t.code`
+    interface ${t.interface("TestInterface")} {
+      op getName(id: string): string;
+    }
+  `);
+
+    expect(
+      <Wrapper>
+        <ClassDeclaration type={TestInterface} />
+      </Wrapper>,
+    ).toRenderTo(`
+      namespace TestNamespace
+      {
+          class TestInterface
+          {
+              public abstract string GetName(string id);
+          }
+      }
+    `);
+  });
+});
+
+it("renders a class with model members", async () => {
+  const { TestModel, TestReference } = await runner.compile(t.code`
+    model ${t.model("TestReference")} { }
+    model ${t.model("TestModel")} {
+      prop1: TestReference;
+    }
+  `);
+
+  expect(
+    <Wrapper>
+      <ClassDeclaration type={TestReference} />
+      <hbr />
+      <ClassDeclaration type={TestModel} />
+    </Wrapper>,
+  ).toRenderTo(`
+    namespace TestNamespace
+    {
+        class TestReference
+        {
+
+        }
+        class TestModel
+        {
+            public required TestReference Prop1 { get; set; }
+        }
+    }
+  `);
+});
+
+it("renders a class with enum members", async () => {
+  const { TestModel, TestEnum } = await runner.compile(t.code`
+    @test enum ${t.enum("TestEnum")} {
+      Value1;
+      Value2;
+    }
+    model ${t.model("TestModel")} {
+      @test prop1: TestEnum;
+    }
+  `);
+
+  expect(
+    <Wrapper>
+      <EnumDeclaration type={TestEnum} />
+      <hbr />
+      <ClassDeclaration type={TestModel} />
+    </Wrapper>,
+  ).toRenderTo(`
+    namespace TestNamespace
+    {
+        enum TestEnum
+        {
+            Value1,
+            Value2
+        }
+        class TestModel
+        {
+            public required TestEnum Prop1 { get; set; }
+        }
+    }
+  `);
+});
+
+it("maps prop: string | null to nullable property", async () => {
+  const { TestModel } = await runner.compile(t.code`
+    model ${t.model("TestModel")} {
+      prop1: string | null;
+    }
+  `);
+
+  expect(
+    <Wrapper>
+      <ClassDeclaration type={TestModel} />
+    </Wrapper>,
+  ).toRenderTo(`
+    namespace TestNamespace
+    {
+        class TestModel
+        {
+            public required string? Prop1 { get; set; }
+        }
+    }
+  `);
+});
+
+it("renders a class with string enums", async () => {
+  const { TestModel, TestEnum } = await runner.compile(t.code`
+    @test enum ${t.enum("TestEnum")} {
+      Value1;
+      Value2;
+    }
+    model ${t.model("TestModel")} {
+      @test prop1: TestEnum;
+    }
+  `);
+
+  expect(
+    <Wrapper>
+      <EnumDeclaration type={TestEnum} />
+      <hbr />
+      <ClassDeclaration type={TestModel} />
+    </Wrapper>,
+  ).toRenderTo(`
+    namespace TestNamespace
+    {
+        enum TestEnum
+        {
+            Value1,
+            Value2
+        }
+        class TestModel
+        {
+            public required TestEnum Prop1 { get; set; }
+        }
+    }
+  `);
+});
+
+describe("with doc comments", () => {
+  it("renders a model with docs", async () => {
+    const { TestModel } = await runner.compile(t.code`
+    @doc("This is a test model")
+    model ${t.model("TestModel")} {
+      @doc("This is a test property")
+        prop1: string;
+      }
+    
+  `);
+
+    expect(
+      <Wrapper>
+        <ClassDeclaration type={TestModel} />
+      </Wrapper>,
+    ).toRenderTo(`
+      namespace TestNamespace
+      {
+          /// <summary>
+          /// This is a test model
+          /// </summary>
+          class TestModel
+          {
+              /// <summary>
+              /// This is a test property
+              /// </summary>
+              public required string Prop1 { get; set; }
+          }
+      }
+    `);
+  });
+
+  it("renders an interface with docs", async () => {
+    const { TestInterface } = await runner.compile(t.code`
+      @doc("This is a test interface")
+      @test interface ${t.interface("TestInterface")} {
+        @doc("This is a test operation")
+        @returnsDoc("The name of the item")
+        op getName(id: string): string;
+      }
+    `);
+
+    expect(
+      <Wrapper>
+        <ClassDeclaration type={TestInterface} />
+      </Wrapper>,
+    ).toRenderTo(`
+      namespace TestNamespace
+      {
+          /// <summary>
+          /// This is a test interface
+          /// </summary>
+          class TestInterface
+          {
+              /// <summary>
+              /// This is a test operation
+              /// </summary>
+              ///
+              /// <returns>
+              /// The name of the item
+              /// </returns>
+              public abstract string GetName(string id);
+          }
+      }
+    `);
+  });
+});

package/src/csharp/components/class/declaration.tsx

@@ -0,0 +1,86 @@
+import { type Children, For } from "@alloy-js/core";
+import * as cs from "@alloy-js/csharp";
+import type { Interface, Model } from "@typespec/compiler";
+import { useTsp } from "../../../core/index.js";
+import { Property } from "../property/property.jsx";
+import { TypeExpression } from "../type-expression.jsx";
+import { getDocComments } from "../utils/doc-comments.jsx";
+import { declarationRefkeys } from "../utils/refkey.js";
+
+export interface ClassDeclarationProps extends Omit<cs.ClassDeclarationProps, "name"> {
+  /** Set an alternative name for the class. Otherwise default to the type name. */
+  name?: string;
+  /** Type to use to create this class. */
+  type: Model | Interface;
+  /** If set the property will add the json serialization attributes(using System.Text.Json). */
+  jsonAttributes?: boolean;
+}
+
+interface ClassPropertiesProps {
+  type: Model;
+  /** If set the property will add the json serialization attributes(using System.Text.Json). */
+  jsonAttributes?: boolean;
+}
+
+interface ClassMethodsProps {
+  type: Interface;
+}
+
+export function ClassDeclaration(props: ClassDeclarationProps): Children {
+  const { $ } = useTsp();
+
+  const namePolicy = cs.useCSharpNamePolicy();
+  const className = props.name ?? namePolicy.getName(props.type.name, "class");
+
+  const refkeys = declarationRefkeys(props.refkey, props.type)[0]; // TODO: support multiple refkeys for declarations in alloy
+
+  return (
+    <>
+      <cs.ClassDeclaration
+        {...props}
+        name={className}
+        refkey={refkeys}
+        doc={getDocComments($, props.type)}
+      >
+        {props.type.kind === "Model" && (
+          <ClassProperties type={props.type} jsonAttributes={props.jsonAttributes} />
+        )}
+        {props.type.kind === "Interface" && <ClassMethods type={props.type} />}
+      </cs.ClassDeclaration>
+    </>
+  );
+}
+
+function ClassProperties(props: ClassPropertiesProps): Children {
+  return (
+    <For each={props.type.properties.entries()} hardline>
+      {([name, property]) => <Property type={property} jsonAttributes={props.jsonAttributes} />}
+    </For>
+  );
+}
+
+function ClassMethods(props: ClassMethodsProps): Children {
+  const { $ } = useTsp();
+  const namePolicy = cs.useCSharpNamePolicy();
+
+  const abstractMethods: Children = [];
+  for (const [name, method] of props.type.operations) {
+    abstractMethods.push(
+      <cs.ClassMethod
+        name={namePolicy.getName(name, "class-method")}
+        abstract
+        parameters={[...method.parameters.properties.entries()].map(([name, prop]) => {
+          return {
+            name: namePolicy.getName(name, "type-parameter"),
+            type: <TypeExpression type={prop.type} />,
+          };
+        })}
+        public
+        doc={getDocComments($, method)}
+        returns={<TypeExpression type={method.returnType} />}
+      />,
+    );
+  }
+
+  return <>{abstractMethods}</>;
+}

package/src/csharp/components/enum/declaration.test.tsx

@@ -0,0 +1,267 @@
+import { Tester } from "#test/test-host.js";
+import { type Children } from "@alloy-js/core";
+import { createCSharpNamePolicy, Namespace, SourceFile } from "@alloy-js/csharp";
+import { t, type TesterInstance } from "@typespec/compiler/testing";
+import { beforeEach, expect, it } from "vitest";
+import { Output } from "../../../core/index.js";
+import { EnumDeclaration } from "../../index.js";
+
+let runner: TesterInstance;
+
+beforeEach(async () => {
+  runner = await Tester.createInstance();
+});
+
+function Wrapper(props: { children: Children }) {
+  const policy = createCSharpNamePolicy();
+  return (
+    <Output program={runner.program} namePolicy={policy}>
+      <Namespace name="TestNamespace">
+        <SourceFile path="test.cs">{props.children}</SourceFile>
+      </Namespace>
+    </Output>
+  );
+}
+
+it("renders a basic enum declaration", async () => {
+  const { TestEnum } = await runner.compile(t.code`
+    @test enum ${t.enum("TestEnum")} {
+      Value1;
+      Value2;
+      Value3;
+    }
+  `);
+
+  expect(
+    <Wrapper>
+      <EnumDeclaration type={TestEnum} />
+    </Wrapper>,
+  ).toRenderTo(`
+    namespace TestNamespace
+    {
+        enum TestEnum
+        {
+            Value1,
+            Value2,
+            Value3
+        }
+    }
+  `);
+});
+
+it("renders an empty enum declaration", async () => {
+  const { TestEnum } = await runner.compile(t.code`
+    @test enum ${t.enum("TestEnum")} {}
+  `);
+
+  expect(
+    <Wrapper>
+      <EnumDeclaration type={TestEnum} />
+    </Wrapper>,
+  ).toRenderTo(`
+    namespace TestNamespace
+    {
+        enum TestEnum
+        {
+
+        }
+    }
+  `);
+});
+
+it("can override enum name", async () => {
+  const { TestEnum } = await runner.compile(t.code`
+    @test enum ${t.enum("TestEnum")} {
+      Value1;
+      Value2;
+    }
+  `);
+
+  expect(
+    <Wrapper>
+      <EnumDeclaration type={TestEnum} name="CustomEnumName" />
+    </Wrapper>,
+  ).toRenderTo(`
+    namespace TestNamespace
+    {
+        enum CustomEnumName
+        {
+            Value1,
+            Value2
+        }
+    }
+  `);
+});
+
+it("renders an enum with access modifiers", async () => {
+  const { TestEnum } = await runner.compile(t.code`
+    @test enum ${t.enum("TestEnum")} {
+      Value1;
+      Value2;
+    }
+  `);
+
+  expect(
+    <Wrapper>
+      <EnumDeclaration type={TestEnum} internal />
+    </Wrapper>,
+  ).toRenderTo(`
+    namespace TestNamespace
+    {
+        internal enum TestEnum
+        {
+            Value1,
+            Value2
+        }
+    }
+  `);
+});
+
+it("renders enum with C# naming conventions", async () => {
+  const { TestEnum } = await runner.compile(t.code`
+    @test enum ${t.enum("TestEnum")} {
+      value_one;
+      value_two;
+      value_three;
+    }
+  `);
+
+  expect(
+    <Output program={runner.program} namePolicy={createCSharpNamePolicy()}>
+      <Namespace name="TestNamespace">
+        <SourceFile path="test.cs">
+          <EnumDeclaration type={TestEnum} />
+        </SourceFile>
+      </Namespace>
+    </Output>,
+  ).toRenderTo(`
+    namespace TestNamespace
+    {
+        enum TestEnum
+        {
+            ValueOne,
+            ValueTwo,
+            ValueThree
+        }
+    }
+  `);
+});
+
+it("renders enum with single value", async () => {
+  const { TestEnum } = await runner.compile(t.code`
+    @test enum ${t.enum("TestEnum")} {
+      OnlyValue;
+    }
+  `);
+
+  expect(
+    <Wrapper>
+      <EnumDeclaration type={TestEnum} />
+    </Wrapper>,
+  ).toRenderTo(`
+    namespace TestNamespace
+    {
+        enum TestEnum
+        {
+            OnlyValue
+        }
+    }
+  `);
+});
+
+it("renders enum with numeric-like member names", async () => {
+  const { TestEnum } = await runner.compile(t.code`
+    @test enum ${t.enum("TestEnum")} {
+      Value0;
+      Value1;
+      Value10;
+      Value100;
+    }
+  `);
+
+  expect(
+    <Wrapper>
+      <EnumDeclaration type={TestEnum} />
+    </Wrapper>,
+  ).toRenderTo(`
+    namespace TestNamespace
+    {
+        enum TestEnum
+        {
+            Value0,
+            Value1,
+            Value10,
+            Value100
+        }
+    }
+  `);
+});
+
+it("renders multiple enums in the same namespace", async () => {
+  const { TestEnum1, TestEnum2 } = await runner.compile(t.code`
+    @test enum ${t.enum("TestEnum1")} {
+      Value1;
+      Value2;
+    }
+    @test enum ${t.enum("TestEnum2")} {
+      OptionA;
+      OptionB;
+      OptionC;
+    }
+  `);
+
+  expect(
+    <Wrapper>
+      <EnumDeclaration type={TestEnum1} />
+      <hbr />
+      <EnumDeclaration type={TestEnum2} />
+    </Wrapper>,
+  ).toRenderTo(`
+    namespace TestNamespace
+    {
+        enum TestEnum1
+        {
+            Value1,
+            Value2
+        }
+        enum TestEnum2
+        {
+            OptionA,
+            OptionB,
+            OptionC
+        }
+    }
+  `);
+});
+
+it("renders an enum with doc comments", async () => {
+  const { TestEnum } = await runner.compile(t.code`
+    @test enum ${t.enum("TestEnum")} {
+      @doc("This is value one")
+      Value1;
+      /** This is value two */
+      Value2;
+    }
+  `);
+
+  expect(
+    <Wrapper>
+      <EnumDeclaration type={TestEnum} />
+    </Wrapper>,
+  ).toRenderTo(`
+    namespace TestNamespace
+    {
+        enum TestEnum
+        {
+            /// <summary>
+            /// This is value one
+            /// </summary>
+            Value1,
+            /// <summary>
+            /// This is value two
+            /// </summary>
+            Value2
+        }
+    }
+  `);
+});