coniadev / registry

src/Entry.php

Indentation +151 added lines, -151 removed lines

@@ -15,155 +15,155 @@
  */
 class Entry
 {
-	/** @psalm-var null|Args */
-	protected array|Closure|null $args = null;
-
-	protected ?string $constructor = null;
-	protected bool $asIs = false;
-	protected bool $reify;
-	protected mixed $instance = null;
-
-	/** @psalm-var list<Call> */
-	protected array $calls = [];
-
-	/**
-	 * @psalm-param non-empty-string $id
-	 * */
-	public function __construct(
-		readonly public string $id,
-		protected mixed $definition,
-	) {
-		$this->reify = $this->negotiateReify($definition);
-	}
-
-	public function reify(bool $reify = true): static
-	{
-		$this->reify = $reify;
-
-		return $this;
-	}
-
-	public function shouldReify(): bool
-	{
-		return $this->reify;
-	}
-
-	public function asIs(bool $asIs = true): static
-	{
-		// An update call is unecessary
-		if ($asIs) {
-			$this->reify = false;
-		}
-
-		$this->asIs = $asIs;
-
-		return $this;
-	}
-
-	public function shouldReturnAsIs(): bool
-	{
-		return $this->asIs;
-	}
-
-	public function args(mixed ...$args): static
-	{
-		$numArgs = count($args);
-
-		if ($numArgs === 1) {
-			if (is_string(array_key_first($args))) {
-				/** @psalm-var Args */
-				$this->args = $args;
-			} elseif (is_array($args[0]) || $args[0] instanceof Closure) {
-				/** @psalm-var Args */
-				$this->args = $args[0];
-			} else {
-				throw new ContainerException(
-					'Registry entry arguments can be passed as a single associative array, ' .
-					'as named arguments, or as a Closure',
-				);
-			}
-		} elseif ($numArgs > 1) {
-			if (!is_string(array_key_first($args))) {
-				throw new ContainerException(
-					'Registry entry arguments can be passed as a single associative array, ' .
-					'as named arguments, or as a Closure',
-				);
-			}
-
-			$this->args = $args;
-		}
-
-		return $this;
-	}
-
-	public function getArgs(): array|Closure|null
-	{
-		return $this->args;
-	}
-
-	public function constructor(string $methodName): static
-	{
-		$this->constructor = $methodName;
-
-		return $this;
-	}
-
-	public function getConstructor(): ?string
-	{
-		return $this->constructor;
-	}
-
-	public function call(string $method, mixed ...$args): static
-	{
-		$this->calls[] = new Call($method, ...$args);
-
-		return $this;
-	}
-
-	/** @psalm-return list<Call> */
-	public function getCalls(): array
-	{
-		return $this->calls;
-	}
-
-	public function definition(): mixed
-	{
-		return $this->definition;
-	}
-
-	public function instance(): mixed
-	{
-		return $this->instance;
-	}
-
-	public function get(): mixed
-	{
-		return $this->instance ?? $this->definition;
-	}
-
-	public function set(mixed $instance): void
-	{
-		$this->instance = $instance;
-	}
-
-	protected function negotiateReify(mixed $definition): bool
-	{
-		if (is_string($definition)) {
-			if (is_callable($definition)) {
-				return true;
-			}
-
-			if (!class_exists($definition)) {
-				return false;
-			}
-		} elseif ($definition instanceof Closure) {
-			return true;
-		} else {
-			if (is_scalar($definition) || is_array($definition) || is_object($definition)) {
-				return false;
-			}
-		}
-
-		return true;
-	}
+    /** @psalm-var null|Args */
+    protected array|Closure|null $args = null;
+
+    protected ?string $constructor = null;
+    protected bool $asIs = false;
+    protected bool $reify;
+    protected mixed $instance = null;
+
+    /** @psalm-var list<Call> */
+    protected array $calls = [];
+
+    /**
+     * @psalm-param non-empty-string $id
+     * */
+    public function __construct(
+        readonly public string $id,
+        protected mixed $definition,
+    ) {
+        $this->reify = $this->negotiateReify($definition);
+    }
+
+    public function reify(bool $reify = true): static
+    {
+        $this->reify = $reify;
+
+        return $this;
+    }
+
+    public function shouldReify(): bool
+    {
+        return $this->reify;
+    }
+
+    public function asIs(bool $asIs = true): static
+    {
+        // An update call is unecessary
+        if ($asIs) {
+            $this->reify = false;
+        }
+
+        $this->asIs = $asIs;
+
+        return $this;
+    }
+
+    public function shouldReturnAsIs(): bool
+    {
+        return $this->asIs;
+    }
+
+    public function args(mixed ...$args): static
+    {
+        $numArgs = count($args);
+
+        if ($numArgs === 1) {
+            if (is_string(array_key_first($args))) {
+                /** @psalm-var Args */
+                $this->args = $args;
+            } elseif (is_array($args[0]) || $args[0] instanceof Closure) {
+                /** @psalm-var Args */
+                $this->args = $args[0];
+            } else {
+                throw new ContainerException(
+                    'Registry entry arguments can be passed as a single associative array, ' .
+                    'as named arguments, or as a Closure',
+                );
+            }
+        } elseif ($numArgs > 1) {
+            if (!is_string(array_key_first($args))) {
+                throw new ContainerException(
+                    'Registry entry arguments can be passed as a single associative array, ' .
+                    'as named arguments, or as a Closure',
+                );
+            }
+
+            $this->args = $args;
+        }
+
+        return $this;
+    }
+
+    public function getArgs(): array|Closure|null
+    {
+        return $this->args;
+    }
+
+    public function constructor(string $methodName): static
+    {
+        $this->constructor = $methodName;
+
+        return $this;
+    }
+
+    public function getConstructor(): ?string
+    {
+        return $this->constructor;
+    }
+
+    public function call(string $method, mixed ...$args): static
+    {
+        $this->calls[] = new Call($method, ...$args);
+
+        return $this;
+    }
+
+    /** @psalm-return list<Call> */
+    public function getCalls(): array
+    {
+        return $this->calls;
+    }
+
+    public function definition(): mixed
+    {
+        return $this->definition;
+    }
+
+    public function instance(): mixed
+    {
+        return $this->instance;
+    }
+
+    public function get(): mixed
+    {
+        return $this->instance ?? $this->definition;
+    }
+
+    public function set(mixed $instance): void
+    {
+        $this->instance = $instance;
+    }
+
+    protected function negotiateReify(mixed $definition): bool
+    {
+        if (is_string($definition)) {
+            if (is_callable($definition)) {
+                return true;
+            }
+
+            if (!class_exists($definition)) {
+                return false;
+            }
+        } elseif ($definition instanceof Closure) {
+            return true;
+        } else {
+            if (is_scalar($definition) || is_array($definition) || is_object($definition)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
 }

src/Registry.php

Indentation +227 added lines, -227 removed lines

@@ -19,231 +19,231 @@
  */
 class Registry implements Container
 {
-	protected Creator $creator;
-	protected readonly ?Container $wrappedContainer;
-
-	/** @psalm-var EntryArray */
-	protected array $entries = [];
-
-	/** @psalm-var array<never, never>|array<non-empty-string, self> */
-	protected array $tags = [];
-
-	public function __construct(
-		public readonly bool $autowire = true,
-		?Container $container = null,
-		protected readonly string $tag = '',
-		protected readonly ?Registry $parent = null,
-	) {
-		if ($container) {
-			$this->wrappedContainer = $container;
-			$this->add(Container::class, $container);
-			$this->add($container::class, $container);
-		} else {
-			$this->wrappedContainer = null;
-			$this->add(Container::class, $this);
-		}
-		$this->add(Registry::class, $this);
-		$this->creator = new Creator($this);
-	}
-
-	public function has(string $id): bool
-	{
-		return isset($this->entries[$id]) || $this->parent?->has($id) || $this->wrappedContainer?->has($id);
-	}
-
-	/** @psalm-return list<string> */
-	public function entries(bool $includeRegistry = false): array
-	{
-		$keys = array_keys($this->entries);
-
-		if ($includeRegistry) {
-			return $keys;
-		}
-
-		return array_values(array_filter($keys, function ($item) {
-			return $item !== Container::class && !is_subclass_of($item, Container::class);
-		}));
-	}
-
-	public function entry(string $id): Entry
-	{
-		return $this->entries[$id];
-	}
-
-	public function get(string $id): mixed
-	{
-		$entry = $this->entries[$id] ?? null;
-
-		try {
-			if ($entry) {
-				return $this->resolveEntry($entry);
-			}
-
-			if ($this->wrappedContainer?->has($id)) {
-				return $this->wrappedContainer->get($id);
-			}
-
-			// We are in a tag. See if the $id can be resolved by the parent
-			// be registered on the root.
-			if ($this->parent) {
-				return $this->parent->get($id);
-			}
-
-			// Autowiring: $id does not exists as an entry in the registry
-			if ($this->autowire && class_exists($id)) {
-				return $this->creator->create($id);
-			}
-		} catch (WireException $e) {
-			throw new NotFoundException('Unresolvable id: ' . $id . ' - Details: ' . $e->getMessage());
-		}
-
-		throw new NotFoundException('Unresolvable id: ' . $id);
-	}
-
-	/**
-	 * @psalm-param non-empty-string $id
-	 */
-	public function add(
-		string $id,
-		mixed $value = null,
-	): Entry {
-		$entry = new Entry($id, $value ?? $id);
-		$this->entries[$id] = $entry;
-
-		return $entry;
-	}
-
-	public function addEntry(
-		Entry $entry,
-	): Entry {
-		$this->entries[$entry->id] = $entry;
-
-		return $entry;
-	}
-
-	/** @psalm-param non-empty-string $tag */
-	public function tag(string $tag): Registry
-	{
-		if (!isset($this->tags[$tag])) {
-			$this->tags[$tag] = new self(tag: $tag, parent: $this);
-		}
-
-		return $this->tags[$tag];
-	}
-
-	public function new(string $id, mixed ...$args): object
-	{
-		$entry = $this->entries[$id] ?? null;
-
-		if ($entry) {
-			/** @var mixed */
-			$value = $entry->definition();
-
-			if (is_string($value)) {
-				if (interface_exists($value)) {
-					return $this->new($value, ...$args);
-				}
-
-				if (class_exists($value)) {
-					/** @psalm-suppress MixedMethodCall */
-					return new $value(...$args);
-				}
-			}
-		}
-
-		if (class_exists($id)) {
-			/** @psalm-suppress MixedMethodCall */
-			return new $id(...$args);
-		}
-
-		throw new NotFoundException('Cannot instantiate ' . $id);
-	}
-
-	protected function callAndReify(Entry $entry, mixed $value): mixed
-	{
-		foreach ($entry->getCalls() as $call) {
-			$methodToResolve = $call->method;
-
-			/** @psalm-var callable */
-			$callable = [$value, $methodToResolve];
-			$args = (new CallableResolver($this->creator))->resolve($callable, $call->args);
-			$callable(...$args);
-		}
-
-		if ($entry->shouldReify()) {
-			$entry->set($value);
-		}
-
-		return $value;
-	}
-
-	protected function resolveEntry(Entry $entry): mixed
-	{
-		if ($entry->shouldReturnAsIs()) {
-			return $entry->definition();
-		}
-
-		/** @var mixed - the current value, instantiated or definition */
-		$value = $entry->get();
-
-		if (is_string($value)) {
-			if (class_exists($value)) {
-				$constructor = $entry->getConstructor();
-				$args = $entry->getArgs();
-
-				if (isset($args)) {
-					// Don't autowire if $args are given
-					if ($args instanceof Closure) {
-						/** @psalm-var array<string, mixed> */
-						$args = $args(...(new CallableResolver($this->creator))->resolve($args));
-
-						return $this->callAndReify(
-							$entry,
-							$this->creator->create($value, $args),
-						);
-					}
-
-					return $this->callAndReify(
-						$entry,
-						$this->creator->create(
-							$value,
-							predefinedArgs: $args,
-							constructor: $constructor,
-						),
-					);
-				}
-
-				return $this->callAndReify(
-					$entry,
-					$this->creator->create($value, constructor: $constructor),
-				);
-			}
-
-			if ($this->has($value)) {
-				return $this->get($value);
-			}
-		}
-
-		if ($value instanceof Closure) {
-			$args = $entry->getArgs();
-
-			if (is_null($args)) {
-				$args = (new CallableResolver($this->creator))->resolve($value);
-			} elseif ($args instanceof Closure) {
-				/** @var array<string, mixed> */
-				$args = $args();
-			}
-
-			/** @var mixed */
-			$result = $value(...$args);
-
-			return $this->callAndReify($entry, $result);
-		}
-
-		if (is_object($value)) {
-			return $value;
-		}
-
-		throw new NotFoundException('Unresolvable id: ' . (string) $value);
-	}
+    protected Creator $creator;
+    protected readonly ?Container $wrappedContainer;
+
+    /** @psalm-var EntryArray */
+    protected array $entries = [];
+
+    /** @psalm-var array<never, never>|array<non-empty-string, self> */
+    protected array $tags = [];
+
+    public function __construct(
+        public readonly bool $autowire = true,
+        ?Container $container = null,
+        protected readonly string $tag = '',
+        protected readonly ?Registry $parent = null,
+    ) {
+        if ($container) {
+            $this->wrappedContainer = $container;
+            $this->add(Container::class, $container);
+            $this->add($container::class, $container);
+        } else {
+            $this->wrappedContainer = null;
+            $this->add(Container::class, $this);
+        }
+        $this->add(Registry::class, $this);
+        $this->creator = new Creator($this);
+    }
+
+    public function has(string $id): bool
+    {
+        return isset($this->entries[$id]) || $this->parent?->has($id) || $this->wrappedContainer?->has($id);
+    }
+
+    /** @psalm-return list<string> */
+    public function entries(bool $includeRegistry = false): array
+    {
+        $keys = array_keys($this->entries);
+
+        if ($includeRegistry) {
+            return $keys;
+        }
+
+        return array_values(array_filter($keys, function ($item) {
+            return $item !== Container::class && !is_subclass_of($item, Container::class);
+        }));
+    }
+
+    public function entry(string $id): Entry
+    {
+        return $this->entries[$id];
+    }
+
+    public function get(string $id): mixed
+    {
+        $entry = $this->entries[$id] ?? null;
+
+        try {
+            if ($entry) {
+                return $this->resolveEntry($entry);
+            }
+
+            if ($this->wrappedContainer?->has($id)) {
+                return $this->wrappedContainer->get($id);
+            }
+
+            // We are in a tag. See if the $id can be resolved by the parent
+            // be registered on the root.
+            if ($this->parent) {
+                return $this->parent->get($id);
+            }
+
+            // Autowiring: $id does not exists as an entry in the registry
+            if ($this->autowire && class_exists($id)) {
+                return $this->creator->create($id);
+            }
+        } catch (WireException $e) {
+            throw new NotFoundException('Unresolvable id: ' . $id . ' - Details: ' . $e->getMessage());
+        }
+
+        throw new NotFoundException('Unresolvable id: ' . $id);
+    }
+
+    /**
+     * @psalm-param non-empty-string $id
+     */
+    public function add(
+        string $id,
+        mixed $value = null,
+    ): Entry {
+        $entry = new Entry($id, $value ?? $id);
+        $this->entries[$id] = $entry;
+
+        return $entry;
+    }
+
+    public function addEntry(
+        Entry $entry,
+    ): Entry {
+        $this->entries[$entry->id] = $entry;
+
+        return $entry;
+    }
+
+    /** @psalm-param non-empty-string $tag */
+    public function tag(string $tag): Registry
+    {
+        if (!isset($this->tags[$tag])) {
+            $this->tags[$tag] = new self(tag: $tag, parent: $this);
+        }
+
+        return $this->tags[$tag];
+    }
+
+    public function new(string $id, mixed ...$args): object
+    {
+        $entry = $this->entries[$id] ?? null;
+
+        if ($entry) {
+            /** @var mixed */
+            $value = $entry->definition();
+
+            if (is_string($value)) {
+                if (interface_exists($value)) {
+                    return $this->new($value, ...$args);
+                }
+
+                if (class_exists($value)) {
+                    /** @psalm-suppress MixedMethodCall */
+                    return new $value(...$args);
+                }
+            }
+        }
+
+        if (class_exists($id)) {
+            /** @psalm-suppress MixedMethodCall */
+            return new $id(...$args);
+        }
+
+        throw new NotFoundException('Cannot instantiate ' . $id);
+    }
+
+    protected function callAndReify(Entry $entry, mixed $value): mixed
+    {
+        foreach ($entry->getCalls() as $call) {
+            $methodToResolve = $call->method;
+
+            /** @psalm-var callable */
+            $callable = [$value, $methodToResolve];
+            $args = (new CallableResolver($this->creator))->resolve($callable, $call->args);
+            $callable(...$args);
+        }
+
+        if ($entry->shouldReify()) {
+            $entry->set($value);
+        }
+
+        return $value;
+    }
+
+    protected function resolveEntry(Entry $entry): mixed
+    {
+        if ($entry->shouldReturnAsIs()) {
+            return $entry->definition();
+        }
+
+        /** @var mixed - the current value, instantiated or definition */
+        $value = $entry->get();
+
+        if (is_string($value)) {
+            if (class_exists($value)) {
+                $constructor = $entry->getConstructor();
+                $args = $entry->getArgs();
+
+                if (isset($args)) {
+                    // Don't autowire if $args are given
+                    if ($args instanceof Closure) {
+                        /** @psalm-var array<string, mixed> */
+                        $args = $args(...(new CallableResolver($this->creator))->resolve($args));
+
+                        return $this->callAndReify(
+                            $entry,
+                            $this->creator->create($value, $args),
+                        );
+                    }
+
+                    return $this->callAndReify(
+                        $entry,
+                        $this->creator->create(
+                            $value,
+                            predefinedArgs: $args,
+                            constructor: $constructor,
+                        ),
+                    );
+                }
+
+                return $this->callAndReify(
+                    $entry,
+                    $this->creator->create($value, constructor: $constructor),
+                );
+            }
+
+            if ($this->has($value)) {
+                return $this->get($value);
+            }
+        }
+
+        if ($value instanceof Closure) {
+            $args = $entry->getArgs();
+
+            if (is_null($args)) {
+                $args = (new CallableResolver($this->creator))->resolve($value);
+            } elseif ($args instanceof Closure) {
+                /** @var array<string, mixed> */
+                $args = $args();
+            }
+
+            /** @var mixed */
+            $result = $value(...$args);
+
+            return $this->callAndReify($entry, $result);
+        }
+
+        if (is_object($value)) {
+            return $value;
+        }
+
+        throw new NotFoundException('Unresolvable id: ' . (string) $value);
+    }
 }

Spacing +2 added lines, -2 removed lines

@@ -60,7 +60,7 @@ 
 			return $keys;
 		}
 
-		return array_values(array_filter($keys, function ($item) {
+		return array_values(array_filter($keys, function($item) {
 			return $item !== Container::class && !is_subclass_of($item, Container::class);
 		}));
 	}
@@ -244,6 +244,6 @@ 
 			return $value;
 		}
 
-		throw new NotFoundException('Unresolvable id: ' . (string) $value);
+		throw new NotFoundException('Unresolvable id: ' . (string)$value);
 	}
 }