@alloy-js/python 0.5.0-dev.1 → 0.5.0

package/test/variables.test.tsx

@@ -1,210 +1,230 @@
 import { namekey, refkey } from "@alloy-js/core";
-import { d } from "@alloy-js/core/testing";
 import { describe, expect, it } from "vitest";
 import * as py from "../src/index.js";
-import {
-  assertFileContents,
-  toSourceText,
-  toSourceTextMultiple,
-} from "./utils.jsx";
+import { TestOutput, TestOutputDirectory } from "./utils.js";
 
 describe("Python Variable", () => {
   it("declares a python variable", () => {
-    const res = toSourceText([
-      <py.VariableDeclaration name="myVar" type="int" initializer={42} />,
-    ]);
-    expect(res).toBe(`my_var: int = 42`);
+    expect(
+      <TestOutput>
+        <py.VariableDeclaration name="myVar" type="int" initializer={42} />
+      </TestOutput>,
+    ).toRenderTo("my_var: int = 42");
   });
 
   it("takes a namekey", () => {
-    const res = toSourceText([
-      <py.VariableDeclaration
-        name={namekey("my-var")}
-        type="int"
-        initializer={42}
-      />,
-    ]);
-    expect(res).toBe(`my_var: int = 42`);
+    expect(
+      <TestOutput>
+        <py.VariableDeclaration
+          name={namekey("my-var")}
+          type="int"
+          initializer={42}
+        />
+      </TestOutput>,
+    ).toRenderTo("my_var: int = 42");
   });
 
   it("takes a namekey", () => {
-    const res = toSourceText([
-      <py.VariableDeclaration
-        name={namekey("my-var")}
-        type="int"
-        initializer={42}
-      />,
-    ]);
-    expect(res).toBe(`my_var: int = 42`);
+    expect(
+      <TestOutput>
+        <py.VariableDeclaration
+          name={namekey("my-var")}
+          type="int"
+          initializer={42}
+        />
+      </TestOutput>,
+    ).toRenderTo("my_var: int = 42");
   });
 
   it("declares a python variable without value", () => {
-    const res = toSourceText([
-      <py.VariableDeclaration name="myVar" type="int" omitNone />,
-    ]);
-    expect(res).toBe(`my_var: int`);
+    expect(
+      <TestOutput>
+        <py.VariableDeclaration name="myVar" type="int" omitNone />
+      </TestOutput>,
+    ).toRenderTo("my_var: int");
   });
 
   it("declares a python variable without typeAnnotations", () => {
-    const res = toSourceText([
-      <py.VariableDeclaration name="myVar" initializer={42} />,
-    ]);
-    expect(res).toBe(`my_var = 42`);
+    expect(
+      <TestOutput>
+        <py.VariableDeclaration name="myVar" initializer={42} />
+      </TestOutput>,
+    ).toRenderTo("my_var = 42");
   });
 
   it("declares a python variable as None when undefined", () => {
-    const res = toSourceText([<py.VariableDeclaration name="myVar" />]);
-    expect(res).toBe(`my_var = None`);
+    expect(
+      <TestOutput>
+        <py.VariableDeclaration name="myVar" />
+      </TestOutput>,
+    ).toRenderTo("my_var = None");
   });
 
   it("declares a python variable as None when null", () => {
-    const res = toSourceText([
-      <py.VariableDeclaration
-        name="myVar"
-        initializer={<py.Atom jsValue={null} />}
-      />,
-    ]);
-    expect(res).toBe(`my_var = None`);
+    expect(
+      <TestOutput>
+        <py.VariableDeclaration
+          name="myVar"
+          initializer={<py.Atom jsValue={null} />}
+        />
+      </TestOutput>,
+    ).toRenderTo("my_var = None");
   });
 
   it("declares a python variable that's an array", () => {
-    const res = toSourceText([
-      <py.VariableDeclaration
-        name="numbers"
-        type={<py.TypeReference name="list" typeArgs={["int"]} />}
-        initializer={<py.Atom jsValue={[1, 2, 3]} />}
-      />,
-    ]);
-    expect(res).toBe(`numbers: list[int] = [1, 2, 3]`);
+    expect(
+      <TestOutput>
+        <py.VariableDeclaration
+          name="numbers"
+          type={<py.TypeReference name="list" typeArgs={["int"]} />}
+          initializer={<py.Atom jsValue={[1, 2, 3]} />}
+        />
+      </TestOutput>,
+    ).toRenderTo("numbers: list[int] = [1, 2, 3]");
   });
 
   it("declares a python variable with a python value", () => {
-    const res = toSourceText([
-      <py.VariableDeclaration
-        name="nameIdPairs"
-        initializer={<py.Atom jsValue={{ John: 123, Doe: 234 }} />}
-      />,
-    ]);
-    expect(res).toBe(`name_id_pairs = {"John": 123, "Doe": 234}`);
+    expect(
+      <TestOutput>
+        <py.VariableDeclaration
+          name="nameIdPairs"
+          initializer={<py.Atom jsValue={{ John: 123, Doe: 234 }} />}
+        />
+      </TestOutput>,
+    ).toRenderTo(`name_id_pairs = {"John": 123, "Doe": 234}`);
   });
 
   it("declares a python variable with omitNone", () => {
-    const res = toSourceText([
-      <py.VariableDeclaration name="omitNoneVar" type="int" omitNone={true} />,
-    ]);
-    expect(res).toBe(`omit_none_var: int`);
+    expect(
+      <TestOutput>
+        <py.VariableDeclaration name="omitNoneVar" type="int" omitNone={true} />
+      </TestOutput>,
+    ).toRenderTo("omit_none_var: int");
   });
 
   it("declares a call statement python variable", () => {
-    const res = toSourceText([
-      <py.VariableDeclaration
-        name="callStmtVar"
-        initializer={12}
-        callStatementVar={true}
-      />,
-    ]);
-    expect(res).toBe(`call_stmt_var=12`);
+    expect(
+      <TestOutput>
+        <py.VariableDeclaration
+          name="callStmtVar"
+          initializer={12}
+          callStatementVar={true}
+        />
+      </TestOutput>,
+    ).toRenderTo("call_stmt_var=12");
   });
 
   it("declares a call statement python variable without name", () => {
-    const res = toSourceText([
-      <py.VariableDeclaration
-        name=""
-        initializer={12}
-        callStatementVar={true}
-      />,
-    ]);
-    expect(res).toBe(`12`);
+    expect(
+      <TestOutput>
+        <py.VariableDeclaration
+          name=""
+          initializer={12}
+          callStatementVar={true}
+        />
+      </TestOutput>,
+    ).toRenderTo("12");
   });
 
   it("declares a python variable with an optional type", () => {
-    const res = toSourceText([
-      <py.StatementList>
-        <py.VariableDeclaration
-          name="my_var"
-          type={
-            <py.UnionTypeExpression>{["int", "None"]}</py.UnionTypeExpression>
-          }
-        />
-      </py.StatementList>,
-    ]);
-    expect(res).toBe(d`
-      my_var: int | None = None`);
+    expect(
+      <TestOutput>
+        <py.StatementList>
+          <py.VariableDeclaration
+            name="my_var"
+            type={
+              <py.UnionTypeExpression>{["int", "None"]}</py.UnionTypeExpression>
+            }
+          />
+        </py.StatementList>
+      </TestOutput>,
+    ).toRenderTo(
+      `
+      my_var: int | None = None`,
+    );
   });
 
   it("declares a python variable with an optional type omitting none", () => {
-    const res = toSourceText([
-      <py.StatementList>
-        <py.VariableDeclaration
-          name="my_var"
-          type={
-            <py.UnionTypeExpression>{["int", "None"]}</py.UnionTypeExpression>
-          }
-          omitNone
-        />
-      </py.StatementList>,
-    ]);
-    expect(res).toBe(d`
-      my_var: int | None`);
+    expect(
+      <TestOutput>
+        <py.StatementList>
+          <py.VariableDeclaration
+            name="my_var"
+            type={
+              <py.UnionTypeExpression>{["int", "None"]}</py.UnionTypeExpression>
+            }
+            omitNone
+          />
+        </py.StatementList>
+      </TestOutput>,
+    ).toRenderTo(
+      `
+      my_var: int | None`,
+    );
   });
 
   it("declares a python variable with a class type", () => {
     const classKey = refkey();
-    const res = toSourceText([
-      <py.StatementList>
-        <py.ClassDeclaration name="MyClass" refkey={classKey} />
-        <py.VariableDeclaration
-          name="my_var"
-          type={<py.Reference refkey={classKey} />}
-        />
-      </py.StatementList>,
-    ]);
-    expect(res).toBe(d`
+    expect(
+      <TestOutput>
+        <py.StatementList>
+          <py.ClassDeclaration name="MyClass" refkey={classKey} />
+          <py.VariableDeclaration
+            name="my_var"
+            type={<py.Reference refkey={classKey} />}
+          />
+        </py.StatementList>
+      </TestOutput>,
+    ).toRenderTo(
+      `
       class MyClass:
           pass
 
-      my_var: MyClass = None`);
+      my_var: MyClass = None`,
+    );
   });
 
   it("declares a python variable with a class type from a different module", () => {
     const classKey = refkey();
-    const res = toSourceTextMultiple([
-      <py.SourceFile path="classes.py">
-        <py.ClassDeclaration name="MyClass" refkey={classKey} />
-      </py.SourceFile>,
-      <py.SourceFile path="usage.py">
-        <py.VariableDeclaration name="my_var" type={classKey} />
-      </py.SourceFile>,
-    ]);
-    assertFileContents(res, {
+    expect(
+      <TestOutputDirectory>
+        <py.SourceFile path="classes.py">
+          <py.ClassDeclaration name="MyClass" refkey={classKey} />
+        </py.SourceFile>
+        <py.SourceFile path="usage.py">
+          <py.VariableDeclaration name="my_var" type={classKey} />
+        </py.SourceFile>
+      </TestOutputDirectory>,
+    ).toRenderTo({
       "classes.py": `
-        class MyClass:
-            pass
+          class MyClass:
+              pass
 
-      `,
+        `,
       "usage.py": `
-        from typing import TYPE_CHECKING
+          from typing import TYPE_CHECKING
 
-        if TYPE_CHECKING:
-            from classes import MyClass
+          if TYPE_CHECKING:
+              from classes import MyClass
 
-        my_var: MyClass = None
-      `,
+          my_var: MyClass = None
+        `,
     });
   });
 
   it("declares a python variable receiving other variable as value", () => {
     const varKey = refkey();
-    const res = toSourceText([
-      <py.StatementList>
-        <py.VariableDeclaration
-          name="my_var"
-          refkey={varKey}
-          initializer={42}
-        />
-        <py.VariableDeclaration name="my_other_var" initializer={varKey} />
-      </py.StatementList>,
-    ]);
-    expect(res).toBe(`my_var = 42\nmy_other_var = my_var`);
+    expect(
+      <TestOutput>
+        <py.StatementList>
+          <py.VariableDeclaration
+            name="my_var"
+            refkey={varKey}
+            initializer={42}
+          />
+          <py.VariableDeclaration name="my_other_var" initializer={varKey} />
+        </py.StatementList>
+      </TestOutput>,
+    ).toRenderTo("my_var = 42\nmy_other_var = my_var");
   });
 });

package/test/vitest.setup.ts

@@ -0,0 +1 @@
+import "@alloy-js/core/testing";

package/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.52.9"
+      "packageVersion": "7.58.8"
     }
   ]
 }

package/vitest.config.ts

@@ -14,5 +14,9 @@ export default defineConfig({
     jsx: "preserve",
     sourcemap: "both",
   },
+  test: {
+    exclude: ["**/dist/**", "**/node_modules/**"],
+    setupFiles: ["./test/vitest.setup.ts"],
+  },
   plugins: [alloyPlugin()],
 });

package/docs/api/components/Reference.md

@@ -1,31 +0,0 @@
-# Reference
-
-A Python reference to a symbol, such as a variable, function, or class.
-
-* jsx
-
-  ```tsx
-  import { Reference } from "@alloy-js/python";
-
-
-  <Reference refkey={Refkey} />
-  ```
-
-* stc
-
-  ```ts
-  import { Reference } from "@alloy-js/python/stc";
-
-
-  Reference({ refkey: Refkey }).children(children)
-  ```
-
-## Props
-
-|        |                                       |   |
-| ------ | ------------------------------------- | - |
-| refkey | [Refkey](../../../core/types/refkey/) |   |
-
-## Remarks
-
-This component is used to render references to symbols in Python code. It takes a `refkey` prop which is the key of the symbol to reference.

package/docs/api/components/TypeRefContext.md

@@ -1,41 +0,0 @@
-# TypeRefContext
-
-Set the current context of reference to be type reference.
-
-* jsx
-
-  ```tsx
-  import { TypeRefContext } from "@alloy-js/python";
-
-
-  <TypeRefContext >
-    {children}
-  </TypeRefContext>
-  ```
-
-* stc
-
-  ```ts
-  import { TypeRefContext } from "@alloy-js/python/stc";
-
-
-  TypeRefContext({  }).children(children)
-  ```
-
-## Props
-
-|          |                                           |          |
-| -------- | ----------------------------------------- | -------- |
-| children | [Children](../../../core/types/children/) | Children |
-
-## Remarks
-
-References used inside the children of this component will be treated as type-only references. When a symbol is only referenced in type contexts, it will be imported inside a `if TYPE_CHECKING:` block.
-
-## Example
-
-```tsx
-<TypeRefContext>
-  {someTypeRefkey}
-</TypeRefContext>
-```