OptionsMethods::__invoke() - Code Metrics - Inspection of "#[Input] Domain Parameters" - bearsunday/BEAR.Resource - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — 1.x (#321)

by Akihito

created 2025-06-26 20:12 UTC

OptionsMethods::__invoke() A

↳ Parent: OptionsMethods

Complexity

Conditions	4
Paths	8

Size

Total Lines	23
Code Lines	16

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	4
eloc	16
nc	8
nop	2
dl	0
loc	23
rs	9.7333
c	0
b	0
f	0

<?php

declare(strict_types=1);

namespace BEAR\Resource\Options;

use BEAR\Resource\Annotation\Embed;
use BEAR\Resource\Annotation\JsonSchema;
use BEAR\Resource\Annotation\Link;
use BEAR\Resource\ResourceObject;
use Ray\Aop\ReflectionMethod;
use Ray\Di\Di\Named;
use Ray\WebContextParam\Annotation\AbstractWebContextParam;
use Ray\WebContextParam\Annotation\CookieParam;
use Ray\WebContextParam\Annotation\EnvParam;
use Ray\WebContextParam\Annotation\FilesParam;
use Ray\WebContextParam\Annotation\FormParam;
use Ray\WebContextParam\Annotation\QueryParam;
use Ray\WebContextParam\Annotation\ServerParam;

use function array_merge;
use function array_unique;
use function array_values;
use function file_exists;
use function file_get_contents;
use function json_decode;

use const JSON_THROW_ON_ERROR;

/**
 * @psalm-type WebContextKey = class-string<AbstractWebContextParam>
 * @psalm-type WebContextValue = 'cookie'|'env'|'formData'|'query'|'server'|'files'
 * @psalm-type OptionParamDoc = array{description?: string, embed?: mixed, links?: mixed, request?: mixed, schema?: mixed, summary?: string}
 * @psalm-import-type OptionMethodMeta from InputParamMetaInterface
 */
final class OptionsMethods
{
    /**
     * Constants for annotation name and "in" name
     */
    private const WEB_CONTEXT_NAME = [
        CookieParam::class => 'cookie',
        EnvParam::class => 'env',
        FormParam::class => 'formData',
        QueryParam::class => 'query',
        ServerParam::class => 'server',
        FilesParam::class => 'files',
    ];

    public function __construct(
        private readonly InputParamMetaInterface $inputParamMeta,
        #[Named('json_schema_dir')]
        private readonly string $schemaDir = '',
    ) {
    }

    /** @return OptionParamDoc */
filter:
    dependency_paths: ["lib/*"]
    public function __invoke(ResourceObject $ro, string $requestMethod): array
    {
        $method = new ReflectionMethod($ro::class, 'on' . $requestMethod);
        $ins = $this->getInMap($method);
        [$doc, $paramDoc] = (new OptionsMethodDocBolck())($method);
        $methodOption = $doc;
        $paramMetas = (new OptionsMethodRequest())($method, $paramDoc, $ins);
        $inputMetas = $this->inputParamMeta->get($method);
        $paramMetas = $this->mergeParameterMetas($paramMetas, $inputMetas);
        $schema = $this->getJsonSchema($method);
        $request = $paramMetas ? ['request' => $paramMetas] : [];
        $methodOption += $request;
        if (! empty($schema)) {
            $methodOption += ['schema' => $schema];
        }

        $extras = $this->getMethodExtras($method);
        if (! empty($extras)) {
            $methodOption += $extras;
        }

        /** @var OptionParamDoc $methodOption */
        return $methodOption;

    }

    /**
     * @return (Embed|Link)[][]
     * @psalm-return array{links?: non-empty-list<Link>, embed?: non-empty-list<Embed>}
     * @phpstan-return (Embed|Link)[][]
     */
    private function getMethodExtras(ReflectionMethod $method): array
    {
        $extras = [];
        $annotations = $method->getAnnotations();
        foreach ($annotations as $annotation) {
            if ($annotation instanceof Link) {
                $extras['links'][] = $annotation;
            }

            if (! ($annotation instanceof Embed)) {
                continue;
            }

            $extras['embed'][] = $annotation;
        }

        return $extras;
    }

    /** @return array<string, string> */
    private function getInMap(ReflectionMethod $method): array
    {
        $ins = [];
        bc_for_annotation: {
            // @codeCoverageIgnoreStart
            $annotations = $method->getAnnotations();
            $ins = $this->getInsFromMethodAnnotations($annotations, $ins);
        if ($ins) {
            return $ins;
        }
            // @codeCoverageIgnoreEnd
        }

        /** @var array<string, string> $insParam */
        $insParam = $this->getInsFromParameterAttributes($method, $ins);

        return $insParam;
    }

    /** @return array<string, mixed> */
    private function getJsonSchema(ReflectionMethod $method): array
    {
        $schema = $method->getAnnotation(JsonSchema::class);
        if (! $schema instanceof JsonSchema) {
            return [];
        }

        $schemaFile = $this->schemaDir . '/' . $schema->schema;
        if (! file_exists($schemaFile)) {
            return [];
        }

        /** @var array<string, mixed> $schema */
        $schema = (array) json_decode((string) file_get_contents($schemaFile), null, 512, JSON_THROW_ON_ERROR);

        return $schema;
    }

    /**
     * @param array<object>         $annotations
     * @param array<string, string> $ins
     *
     * @return array<string, string>
     *
     * @codeCoverageIgnore BC for annotation
     */
    public function getInsFromMethodAnnotations(array $annotations, array $ins): array
    {
        foreach ($annotations as $annotation) {
            if (! ($annotation instanceof AbstractWebContextParam)) {
                continue;
            }

            $class = $annotation::class;
            if (! isset(self::WEB_CONTEXT_NAME[$class])) {
                continue;
            }

            $ins[$annotation->param] = self::WEB_CONTEXT_NAME[$class];
        }

        return $ins;
    }

    /**
     * @param array<string, string> $ins
     *
     * @return array<string, string>
     */
    public function getInsFromParameterAttributes(ReflectionMethod $method, array $ins): array|null
    {
        $parameters = $method->getParameters();
        foreach ($parameters as $parameter) {
            $attributes = $parameter->getAttributes();
            foreach ($attributes as $attribute) {
                $instance = $attribute->newInstance();
                if (! ($instance instanceof AbstractWebContextParam)) {
                    continue;
                }

                $class = $instance::class;
                if (! isset(self::WEB_CONTEXT_NAME[$class])) {
                    continue;
                }

                $webContextName = self::WEB_CONTEXT_NAME[$class];
                $ins[$parameter->name] = $webContextName;
            }
        }

        return $ins;
    }

    /**
     * Merge parameter metadata from OptionsMethodRequest and InputParamMeta
     *
     * @param OptionMethodMeta $regularParams
     * @param OptionMethodMeta $inputParams
filter:
    dependency_paths: ["lib/*"]
     *
     * @return OptionMethodMeta
     */
    private function mergeParameterMetas(array $regularParams, array $inputParams): array
    {
        $regularParameters = $regularParams['parameters'] ?? [];
        $inputParameters   = $inputParams['parameters'] ?? [];

        $regularRequired = $regularParams['required'] ?? [];
        $inputRequired   = $inputParams['required'] ?? [];

        $parameters = array_merge($regularParameters, $inputParameters);
        $required = array_values(array_unique(array_merge($regularRequired, $inputRequired)));

        if ($parameters === [] && $required === []) {
            return [];

        }

        return [

            'parameters' => $parameters,
            'required'   => $required,
        ];
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace BEAR\Resource\Options;
6
7			use BEAR\Resource\Annotation\Embed;
8			use BEAR\Resource\Annotation\JsonSchema;
9			use BEAR\Resource\Annotation\Link;
10			use BEAR\Resource\ResourceObject;
11			use Ray\Aop\ReflectionMethod;
12			use Ray\Di\Di\Named;
13			use Ray\WebContextParam\Annotation\AbstractWebContextParam;
14			use Ray\WebContextParam\Annotation\CookieParam;
15			use Ray\WebContextParam\Annotation\EnvParam;
16			use Ray\WebContextParam\Annotation\FilesParam;
17			use Ray\WebContextParam\Annotation\FormParam;
18			use Ray\WebContextParam\Annotation\QueryParam;
19			use Ray\WebContextParam\Annotation\ServerParam;
20
21			use function array_merge;
22			use function array_unique;
23			use function array_values;
24			use function file_exists;
25			use function file_get_contents;
26			use function json_decode;
27
28			use const JSON_THROW_ON_ERROR;
29
30			/**
31			* @psalm-type WebContextKey = class-string<AbstractWebContextParam>
32			* @psalm-type WebContextValue = 'cookie'\|'env'\|'formData'\|'query'\|'server'\|'files'
33			* @psalm-type OptionParamDoc = array{description?: string, embed?: mixed, links?: mixed, request?: mixed, schema?: mixed, summary?: string}
34			* @psalm-import-type OptionMethodMeta from InputParamMetaInterface
35			*/
36			final class OptionsMethods
37			{
38			/**
39			* Constants for annotation name and "in" name
40			*/
41			private const WEB_CONTEXT_NAME = [
42			CookieParam::class => 'cookie',
43			EnvParam::class => 'env',
44			FormParam::class => 'formData',
45			QueryParam::class => 'query',
46			ServerParam::class => 'server',
47			FilesParam::class => 'files',
48			];
49
50			public function __construct(
51			private readonly InputParamMetaInterface $inputParamMeta,
52			#[Named('json_schema_dir')]
53			private readonly string $schemaDir = '',
54			) {
55			}
56
57			/** @return OptionParamDoc */
			0 ignored issues – show Bug introduced 2025-06-26 17:49 UTC by Report Bug Copy Issue Report The type `BEAR\Resource\Options\OptionParamDoc` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
58			public function __invoke(ResourceObject $ro, string $requestMethod): array
59			{
60			$method = new ReflectionMethod($ro::class, 'on' . $requestMethod);
61			$ins = $this->getInMap($method);
62			[$doc, $paramDoc] = (new OptionsMethodDocBolck())($method);
63			$methodOption = $doc;
64			$paramMetas = (new OptionsMethodRequest())($method, $paramDoc, $ins);
65			$inputMetas = $this->inputParamMeta->get($method);
66			$paramMetas = $this->mergeParameterMetas($paramMetas, $inputMetas);
67			$schema = $this->getJsonSchema($method);
68			$request = $paramMetas ? ['request' => $paramMetas] : [];
69			$methodOption += $request;
70			if (! empty($schema)) {
71			$methodOption += ['schema' => $schema];
72			}
73
74			$extras = $this->getMethodExtras($method);
75			if (! empty($extras)) {
76			$methodOption += $extras;
77			}
78
79			/** @var OptionParamDoc $methodOption */
80			return $methodOption;
			0 ignored issues – show Bug Best Practice introduced 2025-06-26 17:49 UTC by Report Bug Copy Issue Report The expression `return $methodOption` returns the type `BEAR\Resource\Options\OptionParamDoc` which is incompatible with the type-hinted return `array`. Loading history...
81			}
82
83			/**
84			* @return (Embed\|Link)[][]
85			* @psalm-return array{links?: non-empty-list<Link>, embed?: non-empty-list<Embed>}
86			* @phpstan-return (Embed\|Link)[][]
87			*/
88			private function getMethodExtras(ReflectionMethod $method): array
89			{
90			$extras = [];
91			$annotations = $method->getAnnotations();
92			foreach ($annotations as $annotation) {
93			if ($annotation instanceof Link) {
94			$extras['links'][] = $annotation;
95			}
96
97			if (! ($annotation instanceof Embed)) {
98			continue;
99			}
100
101			$extras['embed'][] = $annotation;
102			}
103
104			return $extras;
105			}
106
107			/** @return array<string, string> */
108			private function getInMap(ReflectionMethod $method): array
109			{
110			$ins = [];
111			bc_for_annotation: {
112			// @codeCoverageIgnoreStart
113			$annotations = $method->getAnnotations();
114			$ins = $this->getInsFromMethodAnnotations($annotations, $ins);
115			if ($ins) {
116			return $ins;
117			}
118			// @codeCoverageIgnoreEnd
119			}
120
121			/** @var array<string, string> $insParam */
122			$insParam = $this->getInsFromParameterAttributes($method, $ins);
123
124			return $insParam;
125			}
126
127			/** @return array<string, mixed> */
128			private function getJsonSchema(ReflectionMethod $method): array
129			{
130			$schema = $method->getAnnotation(JsonSchema::class);
131			if (! $schema instanceof JsonSchema) {
132			return [];
133			}
134
135			$schemaFile = $this->schemaDir . '/' . $schema->schema;
136			if (! file_exists($schemaFile)) {
137			return [];
138			}
139
140			/** @var array<string, mixed> $schema */
141			$schema = (array) json_decode((string) file_get_contents($schemaFile), null, 512, JSON_THROW_ON_ERROR);
142
143			return $schema;
144			}
145
146			/**
147			* @param array<object> $annotations
148			* @param array<string, string> $ins
149			*
150			* @return array<string, string>
151			*
152			* @codeCoverageIgnore BC for annotation
153			*/
154			public function getInsFromMethodAnnotations(array $annotations, array $ins): array
155			{
156			foreach ($annotations as $annotation) {
157			if (! ($annotation instanceof AbstractWebContextParam)) {
158			continue;
159			}
160
161			$class = $annotation::class;
162			if (! isset(self::WEB_CONTEXT_NAME[$class])) {
163			continue;
164			}
165
166			$ins[$annotation->param] = self::WEB_CONTEXT_NAME[$class];
167			}
168
169			return $ins;
170			}
171
172			/**
173			* @param array<string, string> $ins
174			*
175			* @return array<string, string>
176			*/
177			public function getInsFromParameterAttributes(ReflectionMethod $method, array $ins): array\|null
178			{
179			$parameters = $method->getParameters();
180			foreach ($parameters as $parameter) {
181			$attributes = $parameter->getAttributes();
182			foreach ($attributes as $attribute) {
183			$instance = $attribute->newInstance();
184			if (! ($instance instanceof AbstractWebContextParam)) {
185			continue;
186			}
187
188			$class = $instance::class;
189			if (! isset(self::WEB_CONTEXT_NAME[$class])) {
190			continue;
191			}
192
193			$webContextName = self::WEB_CONTEXT_NAME[$class];
194			$ins[$parameter->name] = $webContextName;
195			}
196			}
197
198			return $ins;
199			}
200
201			/**
202			* Merge parameter metadata from OptionsMethodRequest and InputParamMeta
203			*
204			* @param OptionMethodMeta $regularParams
205			* @param OptionMethodMeta $inputParams
			0 ignored issues – show Bug introduced 2025-06-26 20:02 UTC by Report Bug Copy Issue Report The type `BEAR\Resource\Options\OptionMethodMeta` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
206			*
207			* @return OptionMethodMeta
208			*/
209			private function mergeParameterMetas(array $regularParams, array $inputParams): array
210			{
211			$regularParameters = $regularParams['parameters'] ?? [];
212			$inputParameters = $inputParams['parameters'] ?? [];
213
214			$regularRequired = $regularParams['required'] ?? [];
215			$inputRequired = $inputParams['required'] ?? [];
216
217			$parameters = array_merge($regularParameters, $inputParameters);
218			$required = array_values(array_unique(array_merge($regularRequired, $inputRequired)));
219
220			if ($parameters === [] && $required === []) {
221			return [];
			0 ignored issues – show Bug Best Practice introduced 2025-06-26 20:02 UTC by Report Bug Copy Issue Report The expression `return array()` returns the type `array` which is incompatible with the documented return type `BEAR\Resource\Options\OptionMethodMeta`. Loading history...
222			}
223
224			return [
			0 ignored issues – show Bug Best Practice introduced 2025-06-26 20:02 UTC by Report Bug Copy Issue Report The expression `return array('parameters...required' => $required)` returns the type `array<string,array>` which is incompatible with the documented return type `BEAR\Resource\Options\OptionMethodMeta`. Loading history...
225			'parameters' => $parameters,
226			'required' => $required,
227			];
228			}
229			}
230

bearsunday / BEAR.Resource

Pull Request — 1.x (#321)

OptionsMethods::__invoke() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like