Something went wrong. Try again.
Parse and validate AT Protocol Lexicons with DTO generation for Laravel
Something went wrong. Try again.
13 kB · 399 lines
PHP
at dev
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400<?php
namespace SocialDept\AtpSchema\Generator;
use SocialDept\AtpSchema\Data\LexiconDocument;use SocialDept\AtpSchema\Exceptions\GenerationException;use SocialDept\AtpSchema\Support\ExtensionManager;
class ClassGenerator{ /** * Naming converter instance. */ protected NamingConverter $naming;
/** * Type mapper instance. */ protected TypeMapper $typeMapper;
/** * Stub renderer instance. */ protected StubRenderer $renderer;
/** * Method generator instance. */ protected MethodGenerator $methodGenerator;
/** * DocBlock generator instance. */ protected DocBlockGenerator $docBlockGenerator;
/** * Extension manager instance. */ protected ExtensionManager $extensions;
/** * Create a new ClassGenerator. */ public function __construct( ?NamingConverter $naming = null, ?TypeMapper $typeMapper = null, ?StubRenderer $renderer = null, ?MethodGenerator $methodGenerator = null, ?DocBlockGenerator $docBlockGenerator = null, ?ExtensionManager $extensions = null ) { $this->naming = $naming ?? new NamingConverter(); $this->typeMapper = $typeMapper ?? new TypeMapper($this->naming); $this->renderer = $renderer ?? new StubRenderer(); $this->methodGenerator = $methodGenerator ?? new MethodGenerator($this->naming, $this->typeMapper, $this->renderer); $this->docBlockGenerator = $docBlockGenerator ?? new DocBlockGenerator($this->typeMapper); $this->extensions = $extensions ?? new ExtensionManager(); }
/** * Generate a complete PHP class from a lexicon document. */ public function generate(LexiconDocument $document): string { $nsid = $document->getNsid(); $mainDef = $document->getMainDefinition();
if ($mainDef === null) { throw GenerationException::withContext('No main definition found', ['nsid' => $nsid]); }
$type = $mainDef['type'] ?? null;
if (! in_array($type, ['record', 'object'])) { throw GenerationException::withContext( 'Can only generate classes for record and object types', ['nsid' => $nsid, 'type' => $type] ); }
// For record types, extract the actual record definition $recordDef = $type === 'record' ? ($mainDef['record'] ?? []) : $mainDef;
// Build local definition map for type resolution $localDefinitions = $this->buildLocalDefinitionMap($document); $this->typeMapper->setLocalDefinitions($localDefinitions);
// Get class components $namespace = $this->extensions->filter('filter:class:namespace', $this->naming->nsidToNamespace($nsid), $document); $className = $this->extensions->filter('filter:class:className', $this->naming->toClassName($document->id->getName()), $document); $useStatements = $this->extensions->filter('filter:class:useStatements', $this->collectUseStatements($recordDef, $namespace, $className), $document, $recordDef); $properties = $this->extensions->filter('filter:class:properties', $this->generateProperties($recordDef), $document, $recordDef); $constructor = $this->extensions->filter('filter:class:constructor', $this->generateConstructor($recordDef), $document, $recordDef); $methods = $this->extensions->filter('filter:class:methods', $this->generateMethods($document), $document); $docBlock = $this->extensions->filter('filter:class:docBlock', $this->generateClassDocBlock($document, $mainDef), $document, $mainDef);
// Render the class $rendered = $this->renderer->render('class', [ 'namespace' => $namespace, 'imports' => $this->formatUseStatements($useStatements), 'docBlock' => $docBlock, 'className' => $className, 'extends' => ' extends Data', 'implements' => '', 'properties' => $properties, 'constructor' => $constructor, 'methods' => $methods, ]);
// Fix blank lines when there's no constructor or properties if (empty($properties) && empty($constructor)) { // Remove double blank lines after class opening brace $rendered = preg_replace('/\{\n\n\n/', "{\n", $rendered); }
// Execute post-generation hooks $this->extensions->execute('action:class:generated', $rendered, $document);
return $rendered; }
/** * Generate class properties. * * Since we use constructor property promotion, we don't need separate property declarations. * This method returns empty string but is kept for compatibility. * * @param array<string, mixed> $definition */ protected function generateProperties(array $definition): string { // Properties are defined via constructor promotion return ''; }
/** * Generate class constructor. * * @param array<string, mixed> $definition */ protected function generateConstructor(array $definition): string { $properties = $definition['properties'] ?? []; $required = $definition['required'] ?? [];
if (empty($properties)) { return ''; }
// Build constructor parameters - required first, then optional $requiredParams = []; $optionalParams = []; $requiredDocParams = []; $optionalDocParams = [];
foreach ($properties as $name => $propDef) { $isRequired = in_array($name, $required); $phpType = $this->typeMapper->toPhpType($propDef, ! $isRequired); $phpDocType = $this->typeMapper->toPhpDocType($propDef, ! $isRequired); $description = $propDef['description'] ?? ''; $param = ' public readonly '.$phpType.' $'.$name;
if ($isRequired) { $requiredParams[] = $param.','; if ($description) { $requiredDocParams[] = ' * @param '.$phpDocType.' $'.$name.' '.$description; } } else { $optionalParams[] = $param.' = null,'; if ($description) { $optionalDocParams[] = ' * @param '.$phpDocType.' $'.$name.' '.$description; } } }
// Combine required and optional parameters $params = array_merge($requiredParams, $optionalParams);
// Remove trailing comma from last parameter if (! empty($params)) { $params[count($params) - 1] = rtrim($params[count($params) - 1], ','); }
// Build constructor DocBlock with parameter descriptions in the correct order $docParams = array_merge($requiredDocParams, $optionalDocParams);
// Only add docblock if there are parameter descriptions if (! empty($docParams)) { $docLines = [' /**']; $docLines = array_merge($docLines, $docParams); $docLines[] = ' */'; $docBlock = implode("\n", $docLines)."\n"; } else { $docBlock = ''; }
return $docBlock." public function __construct(\n".implode("\n", $params)."\n ) {\n }"; }
/** * Generate class methods. */ protected function generateMethods(LexiconDocument $document): string { $methods = $this->methodGenerator->generateAll($document);
return implode("\n\n", $methods); }
/** * Generate class-level documentation block. * * @param array<string, mixed> $definition */ protected function generateClassDocBlock(LexiconDocument $document, array $definition): string { return $this->docBlockGenerator->generateClassDocBlock($document, $definition); }
/** * Collect all use statements needed for the class. * * @param array<string, mixed> $definition * @return array<string> */ protected function collectUseStatements(array $definition, string $currentNamespace = '', string $currentClassName = ''): array { $uses = ['SocialDept\\AtpSchema\\Data\\Data']; $properties = $definition['properties'] ?? []; $hasUnions = false; $localRefs = [];
foreach ($properties as $propDef) { $propUses = $this->typeMapper->getUseStatements($propDef); $uses = array_merge($uses, $propUses);
// Check if this property uses unions if (isset($propDef['type']) && $propDef['type'] === 'union') { $hasUnions = true; }
// Collect local references for import if (isset($propDef['type']) && $propDef['type'] === 'ref' && isset($propDef['ref'])) { $ref = $propDef['ref']; if (str_starts_with($ref, '#')) { $localRefs[] = ltrim($ref, '#'); } }
// Handle array items if (isset($propDef['items'])) { $itemUses = $this->typeMapper->getUseStatements($propDef['items']); $uses = array_merge($uses, $itemUses);
// Check for local refs in array items if (isset($propDef['items']['type']) && $propDef['items']['type'] === 'ref' && isset($propDef['items']['ref'])) { $ref = $propDef['items']['ref']; if (str_starts_with($ref, '#')) { $localRefs[] = ltrim($ref, '#'); } } } }
// Add local ref imports // For local refs, check if they should be nested or siblings if (! empty($localRefs) && $currentNamespace) { foreach ($localRefs as $localRef) { $refClassName = $this->naming->toClassName($localRef);
// If this is a nested definition (has currentClassName) and it's a record type, // then local refs are nested under the record if ($currentClassName && $definition['type'] === 'record') { $uses[] = $currentNamespace . '\\' . $currentClassName . '\\' . $refClassName; } else { // For object definitions or defs lexicons, local refs are siblings $uses[] = $currentNamespace . '\\' . $refClassName; } } }
// Add UnionHelper if unions are used if ($hasUnions) { $uses[] = 'SocialDept\\AtpSchema\\Support\\UnionHelper'; }
// Remove duplicates and sort $uses = array_unique($uses);
// Filter out classes from the same namespace if ($currentNamespace) { $uses = array_filter($uses, function ($use) use ($currentNamespace) { // Get namespace from FQCN by removing class name $parts = explode('\\', ltrim($use, '\\')); array_pop($parts); // Remove class name $useNamespace = implode('\\', $parts);
return $useNamespace !== $currentNamespace; }); }
sort($uses);
return $uses; }
/** * Format use statements for output. * * @param array<string> $uses */ protected function formatUseStatements(array $uses): string { if (empty($uses)) { return ''; }
$lines = []; foreach ($uses as $use) { $lines[] = 'use '.ltrim($use, '\\').';'; }
return implode("\n", $lines); }
/** * Build a map of local definitions for type resolution. * * Maps local references (#defName) to their generated class names. * * @return array<string, string> Map of local ref => class name */ protected function buildLocalDefinitionMap(LexiconDocument $document): array { $localDefs = []; $allDefs = $document->defs ?? [];
foreach ($allDefs as $defName => $definition) { // Skip the main definition if ($defName === 'main') { continue; }
// Convert definition name to class name $className = $this->naming->toClassName($defName); $localDefs["#{$defName}"] = $className; }
return $localDefs; }
/** * Get the naming converter. */ public function getNaming(): NamingConverter { return $this->naming; }
/** * Get the type mapper. */ public function getTypeMapper(): TypeMapper { return $this->typeMapper; }
/** * Get the stub renderer. */ public function getRenderer(): StubRenderer { return $this->renderer; }
/** * Get the method generator. */ public function getMethodGenerator(): MethodGenerator { return $this->methodGenerator; }
/** * Get the docblock generator. */ public function getDocBlockGenerator(): DocBlockGenerator { return $this->docBlockGenerator; }
/** * Get the extension manager. */ public function getExtensions(): ExtensionManager { return $this->extensions; }}