Lines 98.38% 61 / 62
Functions and Methods 85.71% 6 / 7
Classes and Traits 0.00% 0 / 1
Name Lines Functions and Methods CRAP Classes and Traits
GenerationModelFactory 98.38% 61 / 62 85.71% 6 / 7 13 0.00% 0 / 1
 __construct 0.00% 0 / 1 0.00% 0 / 1 2
 buildModelFromSnapshot 100.00% 35 / 35 100.00% 1 / 1 2
 sortedDomainNames 100.00% 3 / 3 100.00% 1 / 1 1
 buildAttributeModels 100.00% 6 / 6 100.00% 1 / 1 2
 buildServiceModels 100.00% 9 / 9 100.00% 1 / 1 2
 selectParameterScope 100.00% 3 / 3 100.00% 1 / 1 3
 buildFieldModels 100.00% 5 / 5 100.00% 1 / 1 2
1<?php
2
3declare(strict_types=1);
4
5namespace Stewart\Codegen\Model;
6
7use Stewart\Codegen\Attribute\AttributeKind;
8use Stewart\Codegen\Attribute\AttributeKindInference;
9use Stewart\Codegen\Attribute\AttributeModel;
10use Stewart\Codegen\Attribute\AttributeSelector;
11use Stewart\Codegen\Entity\EntitySelector;
12use Stewart\Codegen\Entity\UnmatchedEntitySelector;
13use Stewart\Codegen\Exception\CodegenException;
14use Stewart\Codegen\GenerationOptions;
15use Stewart\Codegen\Model\Collection\DomainModelCollection;
16use Stewart\Codegen\Php\Identifier;
17use Stewart\Codegen\Php\MemberReservations;
18use Stewart\Codegen\Php\MemberScope;
19use Stewart\Codegen\Service\Collection\ServiceDefinitionCollection;
20use Stewart\Codegen\Service\FieldModel;
21use Stewart\Codegen\Service\ServiceCatalog;
22use Stewart\Codegen\Service\ServiceCatalogParser;
23use Stewart\Codegen\Service\ServiceDefinition;
24use Stewart\Codegen\Service\ServiceModel;
25use Stewart\Codegen\Snapshot\Snapshot;
26use Stewart\Contracts\Registry\Area;
27use Stewart\Contracts\Registry\AreaId;
28use Stewart\Contracts\Registry\Collection\AreaIdCollection;
29use Stewart\Contracts\Registry\Collection\FloorIdCollection;
30use Stewart\Contracts\Registry\Collection\LabelIdCollection;
31use Stewart\Contracts\Registry\Floor;
32use Stewart\Contracts\Registry\FloorId;
33use Stewart\Contracts\Registry\Label;
34use Stewart\Contracts\Registry\LabelId;
35use Stewart\Contracts\Selector\Selector;
36use Stewart\Contracts\State\Collection\EntityStateCollection;
37
38final readonly class GenerationModelFactory
39{
40    public function __construct(
41        private AttributeKindInference $attributeKinds,
42        private EntitySelector $entitySelector,
43        private AttributeSelector $attributeSelector,
44        private ServiceCatalogParser $serviceCatalogParser,
45        private MemberReservations $memberReservations,
46        private DomainCatalog $domainCatalog,
47    ) {}
48
49    /** @throws CodegenException */
50    public function buildModelFromSnapshot(Snapshot $snapshot, GenerationOptions $options): GenerationModel
51    {
52        $selection = $this->entitySelector->selectEntities($snapshot, $options->inclusionRules);
53        $catalog = $this->serviceCatalogParser->parseServicesResponse($snapshot->services);
54        $byDomain = $selection->generated->groupByDomain();
55
56        $accessors = $this->memberReservations->createAllocatorFor(MemberScope::RootClasses);
57        $classStems = $this->memberReservations->createAllocatorFor(MemberScope::ClassStems);
58        $domains = [];
59        $unseenAttributes = [];
60
61        foreach ($this->sortedDomainNames($selection->generated, $catalog) as $domain) {
62            $states = $byDomain[$domain] ?? EntityStateCollection::empty();
63            $attributes = $this->attributeSelector->selectAttributes($domain, $this->attributeKinds->inferKindsByAttributeName($states), $options->attributesFor($domain));
64            $unseenAttributes = [...$unseenAttributes, ...$attributes->unseen];
65
66            $domains[] = new DomainModel(
67                domain: $domain,
68                accessor: $accessors->claim(Identifier::convertToCamelCase($domain)),
69                classStem: $classStems->claim(Identifier::convertToPascalCase($domain)),
70                traits: $this->domainCatalog->getTraitsForDomain($domain),
71                entityIds: $states->sortedByEntityId()->listEntityIds(),
72                attributes: $this->buildAttributeModels($attributes->typed),
73                handleServices: $this->buildServiceModels($catalog->forEntityHandle($domain), MemberScope::EntityHandle),
74                services: $this->buildServiceModels($catalog->forDomain($domain), MemberScope::DomainServices),
75            );
76        }
77
78        return new GenerationModel(
79            domains: DomainModelCollection::fromList($domains),
80            entityIds: $selection->listEntityIds(),
81            ignoredEntityIds: $selection->ignored,
82            warnings: [
83                ...$options->inclusionRules->listUnmatchedIncludes($snapshot->states)->mapToList(
84                    static fn(Selector $include): UnmatchedEntitySelector => new UnmatchedEntitySelector($include->getPattern()),
85                ),
86                ...$unseenAttributes,
87            ],
88            areaIds: AreaIdCollection::fromList($snapshot->areas->mapToList(static fn(Area $area): AreaId => $area->areaId)),
89            floorIds: FloorIdCollection::fromList($snapshot->floors->mapToList(static fn(Floor $floor): FloorId => $floor->floorId)),
90            labelIds: LabelIdCollection::fromList($snapshot->labels->mapToList(static fn(Label $label): LabelId => $label->labelId)),
91        );
92    }
93
94    /** @return list<string> */
95    private function sortedDomainNames(EntityStateCollection $states, ServiceCatalog $catalog): array
96    {
97        $domains = array_values(array_unique([...$states->listDomains(), ...$catalog->listDomains()]));
98        sort($domains);
99
100        return $domains;
101    }
102
103    /**
104     * @param array<string, AttributeKind> $typed
105     * @return list<AttributeModel>
106     */
107    private function buildAttributeModels(array $typed): array
108    {
109        $names = $this->memberReservations->createAllocatorFor(MemberScope::StateView);
110        $attributes = [];
111
112        foreach ($typed as $key => $kind) {
113            $key = (string) $key;
114            $attributes[] = new AttributeModel($names->claim('get' . ucfirst(Identifier::convertToCamelCase($key))), $key, $kind);
115        }
116
117        return $attributes;
118    }
119
120    /** @return list<ServiceModel> */
121    private function buildServiceModels(ServiceDefinitionCollection $definitions, MemberScope $methodScope): array
122    {
123        $names = $this->memberReservations->createAllocatorFor($methodScope);
124        $services = [];
125
126        foreach ($definitions as $definition) {
127            $services[] = new ServiceModel(
128                $names->claim(Identifier::convertToCamelCase($definition->name)),
129                $definition,
130                $this->buildFieldModels($definition, $this->selectParameterScope($methodScope, $definition)),
131            );
132        }
133
134        return $services;
135    }
136
137    private function selectParameterScope(MemberScope $methodScope, ServiceDefinition $definition): MemberScope
138    {
139        return $methodScope === MemberScope::DomainServices && $definition->target->isTargetable
140            ? MemberScope::TargetedParameters
141            : MemberScope::Parameters;
142    }
143
144    /** @return list<FieldModel> */
145    private function buildFieldModels(ServiceDefinition $definition, MemberScope $parameterScope): array
146    {
147        $names = $this->memberReservations->createAllocatorFor($parameterScope);
148        $models = [];
149
150        foreach ($definition->fields as $field) {
151            $models[] = new FieldModel($names->claim(Identifier::convertToCamelCase($field->name)), $field);
152        }
153
154        return $models;
155    }
156}