implements packer PR-04 workspace scan and studio read adapter

This commit is contained in:
2026-03-24 13:42:42 +00:00
parent 12f2311d08
commit 924ab587e8
11 changed files with 486 additions and 1 deletions
@@ -0,0 +1,151 @@
package p.packer.workspace;
import p.packer.api.PackerOperationClass;
import p.packer.api.PackerOperationStatus;
import p.packer.api.PackerProjectContext;
import p.packer.api.assets.PackerAssetIdentity;
import p.packer.api.assets.PackerAssetState;
import p.packer.api.assets.PackerAssetSummary;
import p.packer.api.diagnostics.PackerDiagnostic;
import p.packer.api.diagnostics.PackerDiagnosticCategory;
import p.packer.api.diagnostics.PackerDiagnosticSeverity;
import p.packer.api.workspace.GetAssetDetailsRequest;
import p.packer.api.workspace.GetAssetDetailsResult;
import p.packer.api.workspace.InitWorkspaceRequest;
import p.packer.api.workspace.InitWorkspaceResult;
import p.packer.api.workspace.ListAssetsRequest;
import p.packer.api.workspace.ListAssetsResult;
import p.packer.api.workspace.PackerWorkspaceService;
import p.packer.declarations.PackerAssetDeclarationParseResult;
import p.packer.declarations.PackerAssetDeclarationParser;
import p.packer.declarations.PackerAssetDetailsService;
import p.packer.foundation.PackerRegistryEntry;
import p.packer.foundation.PackerRegistryState;
import p.packer.foundation.PackerWorkspaceFoundation;
import p.packer.foundation.PackerWorkspacePaths;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.*;
import java.util.stream.Stream;
public final class FileSystemPackerWorkspaceService implements PackerWorkspaceService {
private final PackerWorkspaceFoundation workspaceFoundation;
private final PackerAssetDeclarationParser parser;
private final PackerAssetDetailsService detailsService;
public FileSystemPackerWorkspaceService() {
this(new PackerWorkspaceFoundation(), new PackerAssetDeclarationParser());
}
public FileSystemPackerWorkspaceService(
PackerWorkspaceFoundation workspaceFoundation,
PackerAssetDeclarationParser parser) {
this.workspaceFoundation = Objects.requireNonNull(workspaceFoundation, "workspaceFoundation");
this.parser = Objects.requireNonNull(parser, "parser");
this.detailsService = new PackerAssetDetailsService(workspaceFoundation, parser);
}
@Override
public PackerOperationClass operationClass() {
return PackerOperationClass.READ_ONLY;
}
@Override
public InitWorkspaceResult initWorkspace(InitWorkspaceRequest request) {
return workspaceFoundation.initWorkspace(request);
}
@Override
public ListAssetsResult listAssets(ListAssetsRequest request) {
final PackerProjectContext project = Objects.requireNonNull(request, "request").project();
final Path assetsRoot = PackerWorkspacePaths.assetsRoot(project);
final PackerRegistryState registry = workspaceFoundation.loadRegistry(project);
final Map<Path, PackerRegistryEntry> registryByRoot = new HashMap<>();
for (PackerRegistryEntry entry : registry.assets()) {
registryByRoot.put(PackerWorkspacePaths.assetRoot(project, entry.root()), entry);
}
final List<PackerAssetSummary> assets = new ArrayList<>();
final List<PackerDiagnostic> diagnostics = new ArrayList<>();
final Set<Path> discoveredRoots = new HashSet<>();
if (Files.isDirectory(assetsRoot)) {
try (Stream<Path> paths = Files.find(assetsRoot, Integer.MAX_VALUE, (path, attrs) ->
attrs.isRegularFile() && path.getFileName().toString().equals("asset.json"))) {
paths.forEach(assetManifestPath -> {
final Path assetRoot = assetManifestPath.getParent().toAbsolutePath().normalize();
discoveredRoots.add(assetRoot);
final PackerRegistryEntry registryEntry = registryByRoot.get(assetRoot);
final PackerAssetDeclarationParseResult parsed = parser.parse(assetManifestPath);
diagnostics.addAll(parsed.diagnostics());
assets.add(buildSummary(assetRoot, registryEntry, parsed));
});
} catch (IOException exception) {
diagnostics.add(new PackerDiagnostic(
PackerDiagnosticSeverity.ERROR,
PackerDiagnosticCategory.STRUCTURAL,
"Unable to scan assets workspace: " + exception.getMessage(),
assetsRoot,
true));
}
}
for (PackerRegistryEntry entry : registry.assets()) {
final Path registeredRoot = PackerWorkspacePaths.assetRoot(project, entry.root());
if (!discoveredRoots.contains(registeredRoot)) {
diagnostics.add(new PackerDiagnostic(
PackerDiagnosticSeverity.ERROR,
PackerDiagnosticCategory.STRUCTURAL,
"Registered asset root is missing asset.json: " + entry.root(),
registeredRoot.resolve("asset.json"),
true));
}
}
assets.sort(Comparator
.comparing((PackerAssetSummary asset) -> asset.identity().assetRoot().toString(), String.CASE_INSENSITIVE_ORDER)
.thenComparing(summary -> summary.identity().assetName(), String.CASE_INSENSITIVE_ORDER));
final PackerOperationStatus status = diagnostics.stream().anyMatch(PackerDiagnostic::blocking)
? PackerOperationStatus.PARTIAL
: PackerOperationStatus.SUCCESS;
return new ListAssetsResult(
status,
"Packer asset snapshot ready.",
assets,
diagnostics);
}
@Override
public GetAssetDetailsResult getAssetDetails(GetAssetDetailsRequest request) {
return detailsService.getAssetDetails(request);
}
private PackerAssetSummary buildSummary(
Path assetRoot,
PackerRegistryEntry registryEntry,
PackerAssetDeclarationParseResult parsed) {
final String assetName = parsed.declaration() != null
? parsed.declaration().name()
: assetRoot.getFileName().toString();
final String assetFamily = parsed.declaration() != null
? parsed.declaration().type()
: "unknown";
final boolean preload = parsed.declaration() != null && parsed.declaration().preloadEnabled();
final boolean hasDiagnostics = !parsed.diagnostics().isEmpty();
final PackerAssetState state = parsed.valid()
? (registryEntry == null ? PackerAssetState.ORPHAN : PackerAssetState.MANAGED)
: PackerAssetState.INVALID;
return new PackerAssetSummary(
new PackerAssetIdentity(
registryEntry == null ? null : registryEntry.assetId(),
registryEntry == null ? null : registryEntry.assetUuid(),
assetName,
assetRoot),
state,
assetFamily,
preload,
hasDiagnostics);
}
}
@@ -0,0 +1,76 @@
package p.packer.workspace;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import p.packer.api.PackerOperationStatus;
import p.packer.api.PackerProjectContext;
import p.packer.api.assets.PackerAssetState;
import p.packer.api.workspace.ListAssetsRequest;
import p.packer.testing.PackerFixtureLocator;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Comparator;
import static org.junit.jupiter.api.Assertions.*;
final class FileSystemPackerWorkspaceServiceTest {
@TempDir
Path tempDir;
@Test
void listsManagedAndOrphanAssetsFromWorkspaceScan() throws Exception {
final Path projectRoot = copyFixture("workspaces/read-mixed", tempDir.resolve("mixed"));
final FileSystemPackerWorkspaceService service = new FileSystemPackerWorkspaceService();
final var result = service.listAssets(new ListAssetsRequest(project(projectRoot)));
assertEquals(PackerOperationStatus.SUCCESS, result.status());
assertEquals(2, result.assets().size());
assertTrue(result.assets().stream().anyMatch(asset -> asset.state() == PackerAssetState.MANAGED));
assertTrue(result.assets().stream().anyMatch(asset -> asset.state() == PackerAssetState.ORPHAN));
}
@Test
void surfacesMissingRegisteredRootAsStructuralDiagnostic() throws Exception {
final Path projectRoot = copyFixture("workspaces/read-missing-root", tempDir.resolve("missing-root"));
final FileSystemPackerWorkspaceService service = new FileSystemPackerWorkspaceService();
final var result = service.listAssets(new ListAssetsRequest(project(projectRoot)));
assertEquals(PackerOperationStatus.PARTIAL, result.status());
assertTrue(result.diagnostics().stream().anyMatch(diagnostic -> diagnostic.message().contains("missing asset.json")));
}
@Test
void includesInvalidDeclarationsInSnapshotWithDiagnostics() throws Exception {
final Path projectRoot = copyFixture("workspaces/read-invalid", tempDir.resolve("invalid"));
final FileSystemPackerWorkspaceService service = new FileSystemPackerWorkspaceService();
final var result = service.listAssets(new ListAssetsRequest(project(projectRoot)));
assertEquals(1, result.assets().size());
assertEquals(PackerAssetState.INVALID, result.assets().getFirst().state());
assertTrue(result.assets().getFirst().hasDiagnostics());
}
private PackerProjectContext project(Path root) {
return new PackerProjectContext("main", root);
}
private Path copyFixture(String relativePath, Path targetRoot) throws Exception {
final Path sourceRoot = PackerFixtureLocator.fixtureRoot(relativePath);
try (var stream = Files.walk(sourceRoot)) {
for (Path source : stream.sorted(Comparator.naturalOrder()).toList()) {
final Path target = targetRoot.resolve(sourceRoot.relativize(source).toString());
if (Files.isDirectory(source)) {
Files.createDirectories(target);
} else {
Files.createDirectories(target.getParent());
Files.copy(source, target);
}
}
}
return targetRoot;
}
}
@@ -0,0 +1,11 @@
{
"schema_version": 1,
"type": "image_bank",
"inputs": "wrong",
"output": {
"codec": ""
},
"preload": {
"enabled": true
}
}
@@ -0,0 +1,11 @@
{
"schema_version": 1,
"next_asset_id": 2,
"assets": [
{
"asset_id": 1,
"asset_uuid": "uuid-1",
"root": "missing/atlas"
}
]
}
@@ -0,0 +1,11 @@
{
"schema_version": 1,
"next_asset_id": 2,
"assets": [
{
"asset_id": 1,
"asset_uuid": "uuid-1",
"root": "ui/atlas"
}
]
}
@@ -0,0 +1,15 @@
{
"schema_version": 1,
"name": "ui_sounds",
"type": "sound_bank",
"inputs": {
"sources": ["confirm.wav"]
},
"output": {
"format": "SOUND/bank_v1",
"codec": "RAW"
},
"preload": {
"enabled": false
}
}
@@ -0,0 +1,15 @@
{
"schema_version": 1,
"name": "ui_atlas",
"type": "image_bank",
"inputs": {
"sprites": ["sprites/confirm.png"]
},
"output": {
"format": "TILES/indexed_v1",
"codec": "RAW"
},
"preload": {
"enabled": true
}
}