Bump symfony/http-kernel from 4.4.7 to 4.4.13

DataGrid/Expression/ComparisonExpression.php

@@ -30,17 +30,11 @@ class ComparisonExpression implements Visitable
      */
     protected $operator;
 
-    /**
-     * @return string
-     */
     public function getField(): string
     {
         return $this->field;
     }
 
-    /**
-     * @return string
-     */
     public function getOperator(): string
     {
         return $this->operator;
@@ -62,8 +56,6 @@ public function getValue()
     /**
      * ComparisonExpression constructor.
      *
-     * @param string $field
-     * @param string $operator
      * @param $value
      */
     public function __construct(string $field, string $operator, $value)
@@ -74,8 +66,6 @@ public function __construct(string $field, string $operator, $value)
     }
 
     /**
-     * @param AbstractExpressionVisitor $visitor
-     *
      * @return mixed
      */
     public function visit(AbstractExpressionVisitor $visitor)

DataGrid/Expression/CompositeExpression.php

@@ -46,8 +46,6 @@ public function getExpressions(): array
     }
 
     /**
-     * @param Visitable $expression
-     *
      * @return $this
      */
     public function addExpression(Visitable $expression)
@@ -57,9 +55,6 @@ public function addExpression(Visitable $expression)
         return $this;
     }
 
-    /**
-     * @return string
-     */
     public function getType(): string
     {
         return $this->type;

DataGrid/Expression/EmptyExpression.php

@@ -10,8 +10,6 @@
 class EmptyExpression implements Visitable
 {
     /**
-     * @param AbstractExpressionVisitor $visitor
-     *
      * @return mixed
      */
     public function visit(AbstractExpressionVisitor $visitor)

DataGrid/Expression/Visitable.php

@@ -10,8 +10,6 @@
 interface Visitable
 {
     /**
-     * @param AbstractExpressionVisitor $visitor
-     *
      * @return mixed
      */
     public function visit(AbstractExpressionVisitor $visitor);

DataGrid/ExpressionVisitor/AbstractExpressionVisitor.php

@@ -12,23 +12,18 @@
 abstract class AbstractExpressionVisitor
 {
     /**
-     * @param ComparisonExpression $comparison
-     *
      * @return mixed
      */
     abstract public function visitComparison(ComparisonExpression $comparison);
 
     /**
      * @param $type
-     * @param array $expressions
      *
      * @return mixed
      */
     abstract public function visitProcessedCompositeExpression(string $type, array $expressions);
 
     /**
-     * @param CompositeExpression $compositeExpression
-     *
      * @return mixed
      */
     public function visitCompositeExpression(CompositeExpression $compositeExpression)
@@ -37,7 +32,7 @@ public function visitCompositeExpression(CompositeExpression $compositeExpressio
             return $expr->visit($this);
         });
         $expressions = \Functional\filter($expressions, function ($expr) {
-            return $expr !== null;
+            return null !== $expr;
         });
 
         return $this->visitProcessedCompositeExpression($compositeExpression->getType(), $expressions);

DataGrid/ExpressionVisitor/DoctrineExpressionVisitor.php

@@ -53,8 +53,6 @@ class DoctrineExpressionVisitor extends AbstractExpressionVisitor
 
     /**
      * DoctrineExpressionVisitor constructor.
-     *
-     * @param DoctrineQueryHandler $queryHandler
      */
     public function __construct(DoctrineQueryHandler $queryHandler)
     {
@@ -75,8 +73,6 @@ protected function convertOperator($operator)
     }
 
     /**
-     * @param ComparisonExpression $comparison
-     *
      * @return mixed|string
      */
     protected function visitValue(ComparisonExpression $comparison)
@@ -88,26 +84,21 @@ protected function visitValue(ComparisonExpression $comparison)
         ) {
             return $date->setTimezone(new \DateTimezone(date_default_timezone_get()));
         } else {
-            $value = $comparison->getValue() !== null ? $this->queryHandler->transformValueCase($comparison->getValue()) : null;
-            if ($comparison->getOperator() === ComparisonExpression::CONTAINS || $comparison->getOperator(
-                ) === ComparisonExpression::NOTCONTAINS
+            $value = null !== $comparison->getValue() ? $this->queryHandler->transformValueCase($comparison->getValue()) : null;
+            if (ComparisonExpression::CONTAINS === $comparison->getOperator() || ComparisonExpression::NOTCONTAINS === $comparison->getOperator(
+                )
             ) {
                 return '%'.$value.'%';
-            } elseif ($comparison->getOperator() === ComparisonExpression::STARTSWITH) {
+            } elseif (ComparisonExpression::STARTSWITH === $comparison->getOperator()) {
                 return $value.'%';
-            } elseif ($comparison->getOperator() === ComparisonExpression::ENDSWITH) {
+            } elseif (ComparisonExpression::ENDSWITH === $comparison->getOperator()) {
                 return '%'.$value;
             } else {
                 return $value;
             }
         }
     }
 
-    /**
-     * @param ComparisonExpression $comparisonExpression
-     *
-     * @return string
-     */
     protected function visitField(ComparisonExpression $comparisonExpression, $visitedValue): string
     {
         $field = $comparisonExpression->getField();
@@ -119,9 +110,7 @@ protected function visitField(ComparisonExpression $comparisonExpression, $visit
     }
 
     /**
-     * @param ComparisonExpression $comparison
-     * @param string               $fieldName
-     * @param mixed                $value
+     * @param mixed $value
      *
      * @return DoctrineComparison
      */
@@ -156,9 +145,6 @@ protected function visitComparisonWithNotNullValue(ComparisonExpression $compari
     }
 
     /**
-     * @param ComparisonExpression $comparison
-     * @param string               $fieldName
-     *
      * @return string
      */
     protected function visitComparisonWithNullValue(ComparisonExpression $comparison, string $fieldName)
@@ -174,26 +160,21 @@ protected function visitComparisonWithNullValue(ComparisonExpression $comparison
     }
 
     /**
-     * @param ComparisonExpression $comparison
-     *
      * @return DoctrineComparison
      */
     public function visitComparison(ComparisonExpression $comparison)
     {
         $value = $this->visitValue($comparison);
         $fieldName = $this->visitField($comparison, $value);
 
-        if ($value !== null) {
+        if (null !== $value) {
             return $this->visitComparisonWithNotNullValue($comparison, $fieldName, $value);
         } else {
             return $this->visitComparisonWithNullValue($comparison, $fieldName);
         }
     }
 
     /**
-     * @param string $type
-     * @param array  $expressions
-     *
      * @return Andx|Orx|Func
      */
     public function visitProcessedCompositeExpression(string $type, array $expressions)
@@ -204,7 +185,7 @@ public function visitProcessedCompositeExpression(string $type, array $expressio
             case CompositeExpression::TYPE_OR:
                 return new Orx($expressions);
             case CompositeExpression::TYPE_NOT:
-                return new Func("not", $expressions);
+                return new Func('not', $expressions);
             default:
                 throw new UnknownCompositeException($type);
         }

DataGrid/Parser/SearchQueryParser.php

@@ -28,19 +28,11 @@ public function __construct()
         $this->builder = new SearchQueryBuilder();
     }
 
-    /**
-     * @return SearchQueryBuilder
-     */
     public function getBuilder(): SearchQueryBuilder
     {
         return $this->builder;
     }
 
-    /**
-     * @param \stdClass $data
-     *
-     * @return SearchQuery
-     */
     public function parse(\stdClass $data): SearchQuery
     {
         if (isset($data->take)) {
@@ -60,8 +52,6 @@ public function parse(\stdClass $data): SearchQuery
     }
 
     /**
-     * @param \stdClass $data
-     *
      * @throws NotNumericException
      */
     public function parseStartIndex(\stdClass $data)
@@ -74,8 +64,6 @@ public function parseStartIndex(\stdClass $data)
     }
 
     /**
-     * @param \stdClass $data
-     *
      * @throws NotNumericException
      */
     public function parseMaxResults(\stdClass $data)
@@ -88,8 +76,6 @@ public function parseMaxResults(\stdClass $data)
     }
 
     /**
-     * @param \stdClass $data
-     *
      * @throws NotArrayException
      */
     public function parseSort(\stdClass $data)
@@ -106,28 +92,18 @@ function (\stdClass $sort) {
         }
     }
 
-    /**
-     * @param array $filter
-     *
-     * @return ComparisonExpression
-     */
     public function parseComparison(array $filter): ComparisonExpression
     {
         return new ComparisonExpression($filter[0], $filter[1], $filter[2]);
     }
 
     /**
-     * @param array                    $filter
-     * @param CompositeExpression|null $parent
-     *
-     * @return Visitable
-     *
      * @throws \Exception
      */
     public function parseDisjunction(array $filter, CompositeExpression $parent = null): Visitable
     {
-        if (count($filter) == 1) {
-            if ($parent === null) {
+        if (1 == count($filter)) {
+            if (null === $parent) {
                 return $this->parseComparison(array_shift($filter));
             } else {
                 $parent->addExpression($this->parseDisjunction(array_shift($filter)));
@@ -137,14 +113,14 @@ public function parseDisjunction(array $filter, CompositeExpression $parent = nu
         } elseif (count($filter) >= 3) {
             $first = array_shift($filter);
             $second = array_shift($filter);
-            if ($second === 'and' || $second === 'or') {
-                if ($second === 'and') {
+            if ('and' === $second || 'or' === $second) {
+                if ('and' === $second) {
                     $newComposite = new CompositeExpression(CompositeExpression::TYPE_AND, []);
                 } else {
                     $newComposite = new CompositeExpression(CompositeExpression::TYPE_OR, []);
                 }
-                if ($parent !== null) {
-                    if (count($filter[0]) > 1 && count($parent->getExpressions()) === 0) {
+                if (null !== $parent) {
+                    if (count($filter[0]) > 1 && 0 === count($parent->getExpressions())) {
                         $newComposite->addExpression($this->parseDisjunction($first, $newComposite));
 
                         return $this->parseDisjunction($filter, $newComposite);
@@ -161,11 +137,11 @@ public function parseDisjunction(array $filter, CompositeExpression $parent = nu
             } else {
                 return $this->parseComparison([$first, $second, $filter[0]]);
             }
-        } else if (count($filter) == 2) {
+        } elseif (2 == count($filter)) {
             $first = array_shift($filter);
             $second = array_shift($filter);
 
-            if($first === '!') {
+            if ('!' === $first) {
                 $newComposite = new CompositeExpression(CompositeExpression::TYPE_NOT, []);
 
                 $newComposite->addExpression($this->parseDisjunction($second, $newComposite));
@@ -178,8 +154,6 @@ public function parseDisjunction(array $filter, CompositeExpression $parent = nu
     }
 
     /**
-     * @param \stdClass $data
-     *
      * @throws NotArrayException
      */
     public function parseFilter(\stdClass $data)

DataGrid/QueryHandler/DoctrineQueryConfig.php

@@ -27,9 +27,7 @@ class DoctrineQueryConfig
     /**
      * DoctrineQueryConfig constructor.
      *
-     * @param array $fieldMapping
-     * @param array $defaultFilters
-     * @param bool  $caseSensitive
+     * @param bool $caseSensitive
      */
     public function __construct(array $fieldMapping = [], array $defaultFilters = [], $caseSensitive = false)
     {
@@ -46,33 +44,22 @@ public function getDefaultFilters(): array
         return $this->defaultFilters;
     }
 
-    /**
-     * @param array $defaultFilters
-     */
     public function setDefaultFilters(array $defaultFilters)
     {
         $this->defaultFilters = $defaultFilters;
     }
 
-    /**
-     * @return array
-     */
     public function getFieldMapping(): array
     {
         return $this->fieldMapping;
     }
 
-    /**
-     * @param array $fieldMapping
-     */
     public function setFieldMapping(array $fieldMapping)
     {
         $this->fieldMapping = $fieldMapping;
     }
 
     /**
-     * @param string $field
-     *
      * @return string
      */
     public function mapField(string $field)
@@ -84,17 +71,11 @@ public function mapField(string $field)
         return $field;
     }
 
-    /**
-     * @return bool
-     */
     public function isCaseSensitive(): bool
     {
         return $this->caseSensitive;
     }
 
-    /**
-     * @param bool $caseSensitive
-     */
     public function setCaseSensitive(bool $caseSensitive)
     {
         $this->caseSensitive = $caseSensitive;