, false: non-empty-list} */ public array $allowCastingToBoolean, public bool $allowCastingToInteger, public bool $allowCastingToFloat, public bool $allowCastingToString, public bool $allowUndefinedValues, public bool $allowSuperfluousKeys, public bool $allowPermissiveTypes, /** @var array */ public array $allowedSuperfluousKeys, public bool $shouldApplyConverters, private NodeBuilder $nodeBuilder, private TypeDumper $typeDumper, /** @var non-negative-int */ public int $childrenCount, /** @var array */ private array $nameMap = [], /** @var array */ private array $pathMap = [], /** @var array */ private array $childrenWithScalarValueCasting = [], public bool $wrapSingleValueIfNeeded = false, ) {} public function build(): Node { if ($this->type instanceof UnresolvableType) { throw new UnresolvableShellType($this->type); } if (! $this->hasValue) { if (! $this->allowUndefinedValues) { return $this->error(MissingNodeValue::from($this->type)); } return $this->nodeBuilder->build($this->withValue(null)); } return $this->nodeBuilder->build($this); } public function child(string $name, Type $type): self { $this->childrenCount++; $self = clone $this; $self->name = $this->nameMap[$name] ?? $name; $self->type = $type; $self->path = $this->path === '*root*' ? $self->name : "$this->path.$self->name"; $self->hasValue = false; $self->value = null; $self->attributes = Attributes::empty(); $self->childrenCount = 0; $self->nameMap = []; $self->wrapSingleValueIfNeeded = false; if ($this->pathMap !== []) { $self->path = $this->pathMap["$this->path.$name"] ?? $self->path; } if (array_key_exists($name, $this->childrenWithScalarValueCasting)) { if ($self->allowCastingToBoolean === []) { $self->allowCastingToBoolean = ['true' => [1, '1', 'true'], 'false' => [0, '0', 'false']]; } $self->allowCastingToInteger = true; $self->allowCastingToFloat = true; $self->allowCastingToString = true; } return $self; } public function node(mixed $value): Node { return Node::new($value, $this->childrenCount); } public function error(Message $error): Node { return Node::error($this, $error); } /** * @param array $nodes */ public function errors(array $nodes): Node { return Node::branchWithErrors($nodes); } public function withType(Type $newType): self { $self = clone $this; $self->type = $newType; return $self; } public function withValue(mixed $newValue): self { // @infection-ignore-all / We don't want to test the clone behavior $self = clone $this; $self->value = $newValue; $self->hasValue = true; return $self; } // PHP8.4 replace with hook public function value(): mixed { assert($this->hasValue); return $this->value; } public function withAttributes(Attributes $attributes): self { // @infection-ignore-all / We don't want to test the clone behavior $self = clone $this; $self->attributes = $this->attributes->merge($attributes); return $self; } public function hasNameMap(): bool { return $this->nameMap !== []; } /** * @param array $nameMap */ public function withNameMap(array $nameMap): self { // @infection-ignore-all / We don't want to test the clone behavior $self = clone $this; $self->nameMap = $nameMap; return $self; } /** * @param array $pathMap */ public function withPathMap(array $pathMap): self { // @infection-ignore-all / We don't want to test the clone behavior $self = clone $this; $self->pathMap = [...$this->pathMap, ...$pathMap]; return $self; } /** * @param list $allowedSuperfluousKeys */ public function withAllowedSuperfluousKeys(array $allowedSuperfluousKeys): self { // @infection-ignore-all / We don't want to test the clone behavior $self = clone $this; $self->allowedSuperfluousKeys = array_fill_keys($allowedSuperfluousKeys, null); return $self; } public function allowSuperfluousKeys(): self { $self = clone $this; $self->allowSuperfluousKeys = true; return $self; } /** * @param list $childrenWithScalarValueCasting */ public function allowScalarValueCastingForChildren(array $childrenWithScalarValueCasting): self { // @infection-ignore-all / We don't want to test the clone behavior $self = clone $this; $self->childrenWithScalarValueCasting = array_fill_keys($childrenWithScalarValueCasting, null); return $self; } public function wrapSingleValueIfNeeded(): self { // @infection-ignore-all / We don't want to test the clone behavior $self = clone $this; $self->wrapSingleValueIfNeeded = true; return $self; } public function shouldApplyConverters(): self { // @infection-ignore-all / We don't want to test the clone behavior $self = clone $this; $self->shouldApplyConverters = true; return $self; } public function shouldNotApplyConverters(): self { // @infection-ignore-all / We don't want to test the clone behavior $self = clone $this; $self->shouldApplyConverters = false; return $self; } public function expectedSignature(): string { if ($this->type instanceof UnionType) { return implode(', ', array_map( $this->typeDumper->dump(...), $this->type->types(), )); } return $this->typeDumper->dump($this->type); } public function dumpValue(): string { return $this->hasValue ? ValueDumper::dump($this->value) : '*missing*'; } }