Merge remote-tracking branch 'origin/1.2.x' into php-8

Lansoweb · Sep 19, 2023 · 86ddeca · 86ddeca
2 parents d7ec4cf + 6a61718
commit 86ddeca
Show file tree

Hide file tree

Showing 8 changed files with 114 additions and 19 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -2,6 +2,28 @@
 
 All notable changes to this project will be documented in this file, in reverse chronological order by release.
 
+## 1.2.0 - TBD
+
+### Added
+
+- Nothing.
+
+### Changed
+
+- Nothing.
+
+### Deprecated
+
+- Nothing.
+
+### Removed
+
+- Nothing.
+
+### Fixed
+
+- Nothing.
+
 ## 1.0.0 - 2020-01-02
 
 ### Added

diff --git a/composer.json b/composer.json
@@ -39,7 +39,7 @@
             "@phpstan",
             "@test"
         ],
-        "cs-check": "phpcs",
+        "cs-check": "phpcs -s",
         "cs-fix": "phpcbf",
         "phpstan": "phpstan analyse",
         "test": "phpunit --colors=always",

diff --git a/phpcs.xml b/phpcs.xml
@@ -0,0 +1,37 @@
+<?xml version="1.0"?>
+<ruleset name="App coding standard">
+	<description>App coding standard</description>
+
+	<!-- display progress -->
+	<arg value="p"/>
+	<arg name="colors"/>
+
+	<!-- inherit rules from: -->
+	<rule ref="Doctrine">
+		<exclude name="SlevomatCodingStandard.TypeHints.ReturnTypeHint.MissingTraversableTypeHintSpecification"/>
+		<exclude name="SlevomatCodingStandard.TypeHints.PropertyTypeHint.MissingTraversableTypeHintSpecification"/>
+		<exclude name="SlevomatCodingStandard.TypeHints.PropertyTypeHint.MissingAnyTypeHint"/>
+		<exclude name="SlevomatCodingStandard.TypeHints.ParameterTypeHint.MissingTraversableTypeHintSpecification"/>
+		<!--        <exclude name="SlevomatCodingStandard.TypeHints.ParameterTypeHint.MissingAnyTypeHint"/>-->
+		<exclude name="SlevomatCodingStandard.Classes.SuperfluousInterfaceNaming.SuperfluousSuffix"/>
+		<exclude name="SlevomatCodingStandard.TypeHints.TypeHintDeclaration.MissingTraversableParameterTypeHintSpecification"/>
+		<exclude name="SlevomatCodingStandard.TypeHints.TypeHintDeclaration.MissingTraversablePropertyTypeHintSpecification"/>
+		<exclude name="SlevomatCodingStandard.TypeHints.TypeHintDeclaration.MissingTraversableReturnTypeHintSpecification"/>
+<!--		<exclude name="Squiz.Commenting.FunctionComment.WrongStyle"/>-->
+	</rule>
+	<rule ref="Generic.Arrays.DisallowLongArraySyntax"/>
+	<rule ref="Squiz.WhiteSpace.SuperfluousWhitespace"/>
+	<rule ref="Generic.Files.LineLength">
+		<properties>
+			<property name="lineLimit" value="160"/>
+			<property name="absoluteLineLimit" value="180"/>
+		</properties>
+	</rule>
+
+	<rule ref="Generic.CodeAnalysis.EmptyStatement.DetectedCatch">
+		<severity>5</severity>
+	</rule>
+
+	<!-- Paths to check -->
+	<file>src</file>
+</ruleset>
diff --git a/phpstan.neon.dist b/phpstan.neon.dist
@@ -5,6 +5,5 @@ parameters:
     paths:
         - ./src
     ignoreErrors:
-        - '#no type specified#'
         - '#mixed#'
         - '#on a separate line does not do anything#'
diff --git a/src/BuilderInterface.php b/src/BuilderInterface.php
@@ -4,6 +4,7 @@
 
 namespace Los\Uql;
 
+use Laminas\Db\Sql\Select;
 use Psr\Http\Message\ServerRequestInterface;
 
 interface BuilderInterface
@@ -52,7 +53,13 @@ interface BuilderInterface
     public const HINT_ORDER_ASC  = ['asc', 'ASC', 1, '1'];
     public const HINT_ORDER_DESC = ['desc', 'DESC', -1, '-1'];
 
-    public function fromRequest(ServerRequestInterface $request): mixed;
+    /**
+     * @phpcs:disable SlevomatCodingStandard.TypeHints.ReturnTypeHint.MissingNativeTypeHint
+     *
+     * @return Select|array
+     */
+    public function fromRequest(ServerRequestInterface $request);
 
-    public function fromParams(array $query, array $hint = []): mixed;
+    /** @return Select|array */
+    public function fromParams(array $query, array $hint = []);
 }
diff --git a/src/ElasticSearchBuilder.php b/src/ElasticSearchBuilder.php
@@ -7,26 +7,28 @@
 use Psr\Http\Message\ServerRequestInterface;
 
 use function array_merge;
+use function assert;
 use function in_array;
 use function is_array;
+use function is_string;
 use function json_decode;
 use function key;
 use function reset;
 use function str_replace;
 
 final class ElasticSearchBuilder implements BuilderInterface
 {
-    private $params = [];
+    private array $params = [];
 
-    public function __construct()
+    public function __construct(private string $queryName = 'q', private string $hintName = 'h')
     {
     }
 
     public function fromRequest(ServerRequestInterface $request): array
     {
         $queryParams = $request->getQueryParams();
-        $query       = json_decode($queryParams['q'] ?? '{}', true);
-        $hint        = json_decode($queryParams['h'] ?? '{}', true);
+        $query       = json_decode($queryParams[$this->queryName] ?? '{}', true);
+        $hint        = json_decode($queryParams[$this->hintName] ?? '{}', true);
 
         if (! is_array($query) || ! is_array($hint)) {
             throw new Exception\MalformedException('Invalid query or hint');
@@ -55,6 +57,11 @@ public function fromParams(array $query, array $hint = []): array
         return $result;
     }
 
+    /**
+     * @phpcs:disable SlevomatCodingStandard.TypeHints.ParameterTypeHint.MissingNativeTypeHint
+     *
+     * @param mixed $value
+     */
     private function parseQuery(string $key, $value, bool $withoutOperator = false): array
     {
         if ($key === BuilderInterface::OP_NULL) {
@@ -100,6 +107,8 @@ private function parseQuery(string $key, $value, bool $withoutOperator = false):
         $opValue = reset($value);
         $op      = key($value);
 
+        assert(is_string($op));
+
         if (in_array($op, BuilderInterface::OP_LOGIC)) {
             return $this->parseLogic($key, $op, $opValue);
         }
@@ -111,7 +120,12 @@ private function parseQuery(string $key, $value, bool $withoutOperator = false):
         return [];
     }
 
-    private function parseLogic(string $key, $op, $value): array
+    /**
+     * @phpcs:disable SlevomatCodingStandard.TypeHints.ParameterTypeHint.MissingNativeTypeHint
+     *
+     * @param mixed $value
+     */
+    private function parseLogic(string $key, string $op, $value): array
     {
         if ($op === BuilderInterface::OP_NOT) {
             return ['must_not' => ['term' => [$key => $value]]];
@@ -129,7 +143,12 @@ private function parseLogic(string $key, $op, $value): array
         return ['wildcard' => [$key => str_replace('%', '*', $value)]];
     }
 
-    private function parseConditional(string $key, $op, $value): array
+    /**
+     * @phpcs:disable SlevomatCodingStandard.TypeHints.ParameterTypeHint.MissingNativeTypeHint
+     *
+     * @param mixed $value
+     */
+    private function parseConditional(string $key, string $op, $value): array
     {
         if ($op === BuilderInterface::OP_GREATER) {
             return ['filter' => ['range' => [$key => ['gt' => $value]]]];
@@ -151,7 +170,12 @@ private function parseConditional(string $key, $op, $value): array
         return ['filter' => ['range' => [$key => ['gt' => $value[0], 'lt' => $value[1]]]]];
     }
 
-    private function parseHint($key, $value): array
+    /**
+     * @phpcs:disable SlevomatCodingStandard.TypeHints.ParameterTypeHint.MissingNativeTypeHint
+     *
+     * @param mixed $value
+     */
+    private function parseHint(string $key, $value): array
     {
         if ($key === BuilderInterface::HINT_SORT) {
             if (! is_array($value)) {

diff --git a/src/Exception/MalformedException.php b/src/Exception/MalformedException.php
@@ -6,6 +6,7 @@
 
 use RuntimeException;
 
+/** @phpcs:disable SlevomatCodingStandard.Classes.SuperfluousExceptionNaming.SuperfluousSuffix */
 class MalformedException extends RuntimeException
 {
 }
diff --git a/src/LaminasDbBuilder.php b/src/LaminasDbBuilder.php
@@ -20,18 +20,18 @@
 
 final class LaminasDbBuilder implements BuilderInterface
 {
-    private $select;
+    private Select $select;
 
-    public function __construct(Select $select)
+    public function __construct(Select $select, private string $queryName = 'q', private string $hintName = 'h')
     {
         $this->select = clone $select;
     }
 
     public function fromRequest(ServerRequestInterface $request): Select
     {
         $queryParams = $request->getQueryParams();
-        $query       = json_decode($queryParams['q'] ?? '{}', true);
-        $hint        = json_decode($queryParams['h'] ?? '{}', true);
+        $query       = json_decode($queryParams[$this->queryName] ?? '{}', true);
+        $hint        = json_decode($queryParams[$this->hintName] ?? '{}', true);
 
         if (! is_array($query) || ! is_array($hint)) {
             throw new Exception\MalformedException('Invalid query or hint');
@@ -57,7 +57,12 @@ public function fromParams(array $query, array $hint = []): Select
         return $this->select;
     }
 
-    private function parseQuery(mixed $key, mixed $value, Predicate $where): void
+    /**
+     * @phpcs:disable SlevomatCodingStandard.TypeHints.ParameterTypeHint.MissingNativeTypeHint
+     *
+     * @param mixed $value
+     */
+    private function parseQuery(string $key, $value, Predicate $where): void
     {
         if ($key === BuilderInterface::OP_NULL) {
             $where->addPredicate(new IsNull($value));
@@ -119,7 +124,7 @@ private function parseQuery(mixed $key, mixed $value, Predicate $where): void
         }
     }
 
-    private function parseLogic(mixed $key, string $op, mixed $value, Predicate $where): void
+    private function parseLogic(string $key, string $op, mixed $value, Predicate $where): void
     {
         if ($op === BuilderInterface::OP_NOT) {
             $where->notEqualTo($key, $value);
@@ -143,7 +148,7 @@ private function parseLogic(mixed $key, string $op, mixed $value, Predicate $whe
         $where->like($key, $value);
     }
 
-    private function parseConditional(mixed $key, string $op, mixed $value, Predicate $where): void
+    private function parseConditional(string $key, string $op, mixed $value, Predicate $where): void
     {
         if ($op === BuilderInterface::OP_GREATER) {
             $where->greaterThan($key, $value);
@@ -173,7 +178,7 @@ private function parseConditional(mixed $key, string $op, mixed $value, Predicat
         $where->between($key, $value[0], $value[1]);
     }
 
-    private function parseHint(mixed $key, mixed $value, Select $select): void
+    private function parseHint(string $key, mixed $value, Select $select): void
     {
         if ($key === BuilderInterface::HINT_SORT) {
             if (! is_array($value)) {