resforge 0.4.0__tar.gz → 0.4.2__tar.gz

{resforge-0.4.0 → resforge-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: resforge
-Version: 0.4.0
+Version: 0.4.2
 Summary: A type-safe Python DSL for cross-platform mobile resource generation
 Project-URL: Homepage, https://kipila.dev
 Project-URL: Repository, https://github.com/kipila-dev/resforge

{resforge-0.4.0 → resforge-0.4.2}/pyproject.toml

@@ -47,7 +47,7 @@ target-version = "py312"
 
 [tool.ruff.lint]
 select = ["ALL"]
-ignore = ["D100", "D104", "D105", "ANN401", "PLR2004", "E741"]
+ignore = ["D100", "D104", "D105", "D107", "ANN401", "PLR2004", "E741"]
 
 [tool.ruff.lint.extend-per-file-ignores]
 "tests/**/*.py" = [

{resforge-0.4.0 → resforge-0.4.2}/src/resforge/__init__.py

@@ -1,4 +1,4 @@
 from .color import Color
 
 __all__ = ["Color"]
-__version__ = "0.4.0"
+__version__ = "0.4.2"

{resforge-0.4.0 → resforge-0.4.2}/src/resforge/_codegen/kotlin.py

@@ -1,5 +1,4 @@
 from dataclasses import dataclass
-from pathlib import Path
 from typing import IO, Literal, Self, final
 
 PropertyMutability = Literal["val", "var"]
@@ -96,11 +95,5 @@ class KotlinFile:
 
         return "\n\n".join(sections) + "\n"
 
-    def write(self, dest: str | Path | IO[bytes]) -> None:
-        if isinstance(dest, (str, Path)):
-            path = Path(dest)
-            path.parent.mkdir(parents=True, exist_ok=True)
-            with path.open("wb") as f:
-                f.write(self.render().encode())
-        else:
-            dest.write(self.render().encode())
+    def write(self, dest: IO[bytes]) -> None:
+        dest.write(self.render().encode())

resforge-0.4.2/src/resforge/_utils.py

@@ -0,0 +1,31 @@
+from collections.abc import Callable
+from functools import wraps
+from typing import Concatenate, Protocol, runtime_checkable
+
+__all__ = ["require_context"]
+
+
+@runtime_checkable
+class _HasActiveContext(Protocol):
+    _active: bool
+
+
+def require_context[T: _HasActiveContext, **P, R](
+    func: Callable[Concatenate[T, P], R],
+) -> Callable[Concatenate[T, P], R]:
+    """Ensures a method is only called within an active context.
+
+    Raises:
+        RuntimeError: If the method is called while the instance's
+            `_active` attribute is False.
+
+    """
+
+    @wraps(func)
+    def wrapper(self: T, *args: P.args, **kwargs: P.kwargs) -> R:
+        if not self._active:  # pyright: ignore[reportPrivateUsage]
+            msg = f"'{func.__name__}' requires an active 'with' context."
+            raise RuntimeError(msg)
+        return func(self, *args, **kwargs)
+
+    return wrapper

{resforge-0.4.0 → resforge-0.4.2}/src/resforge/android/compose.py

@@ -1,11 +1,13 @@
 from __future__ import annotations
 
+from io import BytesIO
 from pathlib import Path
 from typing import TYPE_CHECKING, Self, final, override
 
 from resforge import Color
 from resforge._codegen.kotlin import KotlinFile, KotlinObject
-from resforge._utils import atomic_write, require_context
+from resforge._utils import require_context
+from resforge.io import FileSystemSink, WriteSink
 
 if TYPE_CHECKING:
     from resforge.android.types import Dimension
@@ -73,7 +75,6 @@ class _BaseComposeScope:
 
         Raises:
             ValueError: If an unsupported unit (not dp, sp, or em) is provided.
-
         """
         mapping = {"dp": "Dp", "sp": "Sp", "em": "TextUnit"}
         for name, dimen in values.items():
@@ -110,24 +111,26 @@ class ComposeWriter(_BaseComposeScope):
                 object_name="AppColors"
             ) as compose:
         ...     compose.color(primary="#6200EE", background="#FFFFFF")
-
     """
 
     def __init__(  # pyright: ignore[reportMissingSuperCall]
         self,
         path: str | Path,
         package: str,
+        sink: WriteSink | None = None,
     ) -> None:
         """Initializes the ComposeWriter.
 
         Args:
             path: The filesystem path where the Kotlin file will be saved.
             package: The Kotlin package declaration.
-
+            sink: The custom output to write data to. If None,
+                defaults to a standard file write.
         """
+        self._active = False
         self._path = Path(path)
         self._package = package
-        self._active = False
+        self._sink = sink or FileSystemSink()
         self._kotlin_file = KotlinFile(package=self._package)
 
     @override
@@ -149,8 +152,9 @@ class ComposeWriter(_BaseComposeScope):
     ) -> None:
         try:
             if exc_type is None:
-                with atomic_write(self._path) as tf:
-                    self._kotlin_file.write(tf)
+                buf = BytesIO()
+                self._kotlin_file.write(buf)
+                self._sink.write(self._path, buf.getvalue())
         finally:
             self._active = False
 
@@ -163,7 +167,6 @@ class ComposeWriter(_BaseComposeScope):
 
         Returns:
             A new context tied to the generated object.
-
         """
         obj = KotlinObject(name=name)
         self._kotlin_file.member(obj)

{resforge-0.4.0 → resforge-0.4.2}/src/resforge/android/values.py

@@ -1,11 +1,13 @@
 import re
 import xml.etree.ElementTree as ET
+from io import BytesIO
 from pathlib import Path
 from re import Pattern
 from typing import Self, final
 
 from resforge import Color
-from resforge._utils import atomic_write, require_context
+from resforge._utils import require_context
+from resforge.io import FileSystemSink, WriteSink
 
 from .types import Dimension, PluralValues
 
@@ -28,15 +30,17 @@ class ValuesWriter:
 
     """
 
-    def __init__(self, path: str | Path) -> None:
+    def __init__(self, path: str | Path, sink: WriteSink | None = None) -> None:
         """Initializes the ValuesWriter.
 
         Args:
             path: The filesystem path where the XML will be saved.
-
+            sink: The custom output to write data to. If None,
+                defaults to a standard file write.
         """
-        self._path = Path(path)
         self._active = False
+        self._path = Path(path)
+        self._sink = sink or FileSystemSink()
 
         # Structure: {"string": ["app_name"], ...}
         self._names: dict[str, set[str]] = {}
@@ -52,14 +56,14 @@ class ValuesWriter:
         try:
             if exc_type is None:
                 ET.indent(self._root, space=" " * 4, level=0)
-                tree = ET.ElementTree(self._root)
-                with atomic_write(self._path) as tf:
-                    tree.write(
-                        tf,
-                        encoding="utf-8",
-                        xml_declaration=True,
-                        short_empty_elements=True,
-                    )
+                buf = BytesIO()
+                ET.ElementTree(self._root).write(
+                    buf,
+                    encoding="utf-8",
+                    xml_declaration=True,
+                    short_empty_elements=True,
+                )
+                self._sink.write(self._path, buf.getvalue())
         finally:
             self._active = False
 

resforge-0.4.2/src/resforge/apple/_base.py

@@ -0,0 +1,33 @@
+import json
+from abc import ABC, abstractmethod
+from io import BytesIO
+from pathlib import Path
+from typing import Self
+
+from resforge.io import WriteSink
+
+
+class AssetNode(ABC):
+    def __init__(
+        self,
+        path: str | Path,
+        name: str,
+        extension: str,
+        sink: WriteSink,
+    ) -> None:
+        self._path: Path = Path(path) / f"{name}.{extension}"
+        self._sink: WriteSink = sink
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, exc_type: type[BaseException] | None, *_: object) -> None:
+        if exc_type is None:
+            contents = self._create_contents()
+            buf = BytesIO()
+            buf.write(json.dumps(contents, indent=2).encode())
+            path = Path(self._path) / "Contents.json"
+            self._sink.write(path, buf.getvalue())
+
+    @abstractmethod
+    def _create_contents(self) -> dict[str, object]: ...

{resforge-0.4.0 → resforge-0.4.2}/src/resforge/apple/_colorset.py

@@ -1,13 +1,15 @@
 from pathlib import Path
 from typing import Self, override
 
+from resforge.io import WriteSink
+
 from ._base import AssetNode
 from .types import AppleColor
 
 
 class ColorSet(AssetNode):
-    def __init__(self, path: str | Path, name: str) -> None:
-        super().__init__(path, name, "colorset")
+    def __init__(self, path: str | Path, name: str, sink: WriteSink) -> None:
+        super().__init__(path, name, "colorset", sink)
         self._colors: list[AppleColor] = []
 
     def color(self, *colors: AppleColor) -> Self:

{resforge-0.4.0 → resforge-0.4.2}/src/resforge/apple/catalog.py

@@ -1,10 +1,12 @@
+import json
 import shutil
+from io import BytesIO
 from pathlib import Path
 from typing import Self, final
 
 from resforge._utils import require_context
+from resforge.io import FileSystemSink, WriteSink
 
-from ._base import write_contents
 from ._colorset import ColorSet
 from .types import AppleColor
 
@@ -21,39 +23,54 @@ class AssetCatalog:
     Example:
         >>> with AssetCatalog("App", "Assets") as assets:
         ...     assets.colorset("primary", "#FF0000")
-
     """
 
-    def __init__(self, path: str | Path, name: str) -> None:
+    def __init__(
+        self,
+        path: str | Path,
+        name: str,
+        sink: WriteSink | None = None,
+    ) -> None:
         """Initializes the AssetCatalog.
 
         Args:
             path: The filesystem path where the asset catalog will be saved.
             name: The name of the catalog (without .xcassets extension).
-
+            sink: The custom output to write data to. If None,
+                defaults to a standard file write.
         """
-        output_dir = Path(path).resolve()
-        self._temp_path = output_dir / f".tmp_{name}.xcassets"
-        self._final_path = output_dir / f"{name}.xcassets"
         self._active = False
+        output_dir = Path(path)
+        self._final_path = output_dir / f"{name}.xcassets"
+        self._sink = sink or FileSystemSink()
+        self._temp_path = (
+            (output_dir / f".tmp_{name}.xcassets")
+            if isinstance(self._sink, FileSystemSink)
+            else self._final_path
+        )
 
     def __enter__(self) -> Self:
         self._active = True
-        if self._temp_path.exists():
-            shutil.rmtree(self._temp_path)
-        self._temp_path.mkdir(parents=True)
+        if isinstance(self._sink, FileSystemSink):
+            if self._temp_path.exists():
+                shutil.rmtree(self._temp_path)
+            self._temp_path.mkdir(parents=True)
         return self
 
     def __exit__(self, exc_type: type[BaseException] | None, *_: object) -> None:
         try:
             if exc_type is None:
+                buf = BytesIO()
                 contents = {"info": {"author": "xcode", "version": 1}}
-                write_contents(self._temp_path, contents)
-                if self._final_path.exists():
-                    shutil.rmtree(self._final_path)
-                self._temp_path.rename(self._final_path)
+                buf.write(json.dumps(contents, indent=2).encode())
+                path = Path(self._temp_path) / "Contents.json"
+                self._sink.write(path, buf.getvalue())
+                if isinstance(self._sink, FileSystemSink):
+                    if self._final_path.exists():
+                        shutil.rmtree(self._final_path)
+                    self._temp_path.rename(self._final_path)
         finally:
-            if self._temp_path.exists():
+            if isinstance(self._sink, FileSystemSink) and self._temp_path.exists():
                 shutil.rmtree(self._temp_path)
             self._active = False
 
@@ -66,6 +83,6 @@ class AssetCatalog:
             *colors: One or more AppleColor definitions.
 
         """
-        with ColorSet(self._temp_path, name) as colorset:
+        with ColorSet(self._temp_path, name, self._sink) as colorset:
             colorset.color(*colors)
         return self

resforge-0.4.0/src/resforge/_utils.py → resforge-0.4.2/src/resforge/io.py

@@ -1,43 +1,16 @@
 import os
 import shutil
-from collections.abc import Callable, Generator
+from collections.abc import Generator
 from contextlib import contextmanager, suppress
-from functools import wraps
 from pathlib import Path
 from tempfile import NamedTemporaryFile
-from typing import IO, Concatenate, Protocol, runtime_checkable
+from typing import IO, Protocol, runtime_checkable
 
-__all__ = ["atomic_write", "require_context"]
-
-
-@runtime_checkable
-class _HasActiveContext(Protocol):
-    _active: bool
-
-
-def require_context[T: _HasActiveContext, **P, R](
-    func: Callable[Concatenate[T, P], R],
-) -> Callable[Concatenate[T, P], R]:
-    """Ensures a method is only called within an active context.
-
-    Raises:
-        RuntimeError: If the method is called while the instance's
-            `_active` attribute is False.
-
-    """
-
-    @wraps(func)
-    def wrapper(self: T, *args: P.args, **kwargs: P.kwargs) -> R:
-        if not self._active:  # pyright: ignore[reportPrivateUsage]
-            msg = f"'{func.__name__}' requires an active 'with' context."
-            raise RuntimeError(msg)
-        return func(self, *args, **kwargs)
-
-    return wrapper
+__all__ = ["FileSystemSink", "MemorySink", "WriteSink", "atomic_write"]
 
 
 @contextmanager
-def atomic_write(target_path: Path) -> Generator[IO[bytes], None, None]:
+def atomic_write(target_path: str | Path) -> Generator[IO[bytes], None, None]:
     """Yields a temporary file, then atomically replaces target_path on success.
 
     Preserves file permissions of target_path, if target_path already exists.
@@ -80,3 +53,32 @@ def atomic_write(target_path: Path) -> Generator[IO[bytes], None, None]:
         if temp_path and temp_path.exists():
             with suppress(OSError):
                 temp_path.unlink()
+
+
+@runtime_checkable
+class WriteSink(Protocol):
+    """An interface for writing binary content to a file path."""
+
+    def write(self, path: Path, content: bytes) -> None:
+        """Write the given binary content to the specified path."""
+        ...
+
+
+class FileSystemSink:
+    """A write sink that writes directly to the file system."""
+
+    def write(self, path: Path, content: bytes) -> None:
+        """Atomically write binary content to a physical file path."""
+        with atomic_write(path) as f:
+            f.write(content)
+
+
+class MemorySink:
+    """A write sink that stores files in a dictionary."""
+
+    def __init__(self) -> None:
+        self.files: dict[str, bytes] = {}
+
+    def write(self, path: Path, content: bytes) -> None:
+        """Store the binary content in memory using the string path as a key."""
+        self.files[str(path)] = content

{resforge-0.4.0 → resforge-0.4.2}/tests/test_atomic_write.py

@@ -1,6 +1,6 @@
 import pytest
 
-from resforge._utils import atomic_write
+from resforge.io import atomic_write
 
 
 def test_atomic_replace_existing(tmp_path):

{resforge-0.4.0 → resforge-0.4.2}/tests/test_codegen_kotlin.py

@@ -102,21 +102,3 @@ def test_top_level_property():
     assert f.render() == (
         "package com.example\n\nval primary: Color = Color(0xFF6200EE)\n"
     )
-
-
-def test_file_write(tmp_path):
-    f = KotlinFile(package="com.example")
-    f.import_("androidx.compose.ui.graphics.Color")
-    f.member(
-        KotlinObject("AppColors").property(
-            "primary",
-            type_="Color",
-            value="Color(0xFF6200EE)",
-        ),
-    )
-
-    output = tmp_path / "ui" / "theme" / "Color.kt"
-    f.write(output)
-
-    assert output.exists()
-    assert output.read_text() == f.render()

resforge-0.4.0/src/resforge/apple/_base.py

@@ -1,33 +0,0 @@
-import json
-import shutil
-import typing
-from abc import ABC, abstractmethod
-from pathlib import Path
-from typing import Self
-
-from resforge._utils import atomic_write
-
-
-def write_contents(path: str | Path, contents: dict[str, typing.Any]) -> None:
-    path = Path(path) / "Contents.json"
-    with atomic_write(path) as tf:
-        tf.write(json.dumps(contents, indent=2).encode())
-
-
-class AssetNode(ABC):
-    def __init__(self, path: str | Path, name: str, extension: str) -> None:
-        self._path: Path = Path(path) / f"{name}.{extension}"
-
-    def __enter__(self) -> Self:
-        self._path.mkdir(parents=True, exist_ok=True)
-        return self
-
-    def __exit__(self, exc_type: type[BaseException] | None, *_: object) -> None:
-        if exc_type is None:
-            contents = self._create_contents()
-            write_contents(self._path, contents)
-        elif self._path.exists():
-            shutil.rmtree(self._path)
-
-    @abstractmethod
-    def _create_contents(self) -> dict[str, object]: ...