Local build: rely only on docker (#58)

Slamdunk · web-flow · commit e485ec42d76f · 2024-06-11T12:06:12.000+02:00
diff --git a/.gitattributes b/.gitattributes
@@ -3,6 +3,8 @@
 /.gitattributes                 export-ignore
 /.gitignore                     export-ignore
 /.php-cs-fixer.php              export-ignore
+/Dockerfile                     export-ignore
+/docker-compose.yml             export-ignore
 /Makefile                       export-ignore
 /composer-require-checker.json  export-ignore
 /phpstan.neon                   export-ignore
diff --git a/.gitignore b/.gitignore
@@ -2,6 +2,7 @@
 /.phpunit.cache/
 /vendor/
 /coverage/
+/.env
 /.php-cs-fixer.cache
 /.phpunit.result.cache
 /composer.lock
diff --git a/Dockerfile b/Dockerfile
@@ -0,0 +1,13 @@
+FROM php:8.3
+
+ADD --chmod=0755 https://github.com/mlocati/docker-php-extension-installer/releases/latest/download/install-php-extensions /usr/local/bin/
+
+RUN install-php-extensions @composer pcov
+
+ARG USER_ID
+ARG GROUP_ID
+
+RUN groupadd --gid ${GROUP_ID} code \
+    && useradd --create-home --shell /bin/bash --uid ${USER_ID} --gid code code
+
+USER code
diff --git a/Makefile b/Makefile
@@ -1,23 +1,30 @@
-CSFIX_PHP_BIN=PHP_CS_FIXER_IGNORE_ENV=1 php8.2
-PHP_BIN=php8.2 -d zend.assertions=1
-COMPOSER_BIN=$(shell command -v composer)
+DOCKER_PHP_EXEC := docker compose run php
+PHP_BIN=php -d zend.assertions=1
 
 all: csfix static-analysis test
 	@echo "Done."
 
-vendor: composer.json
-	$(PHP_BIN) $(COMPOSER_BIN) update
-	$(PHP_BIN) $(COMPOSER_BIN) bump
-	touch vendor
+.env: /etc/passwd /etc/group Makefile
+	printf "USER_ID=%s\nGROUP_ID=%s\n" `id --user "${USER}"` `id --group "${USER}"` > .env
+
+vendor: .env docker-compose.yml Dockerfile composer.json
+	docker compose build --pull
+	$(DOCKER_PHP_EXEC) composer update
+	$(DOCKER_PHP_EXEC) composer bump
+	touch --no-create $@
 
 .PHONY: csfix
 csfix: vendor
-	$(CSFIX_PHP_BIN) vendor/bin/php-cs-fixer fix -v $(arg)
+	$(DOCKER_PHP_EXEC) vendor/bin/php-cs-fixer fix -v $(arg)
 
 .PHONY: static-analysis
 static-analysis: vendor
-	$(PHP_BIN) vendor/bin/phpstan analyse $(PHPSTAN_ARGS)
+	$(DOCKER_PHP_EXEC) $(PHP_BIN) vendor/bin/phpstan analyse --memory-limit=512M $(PHPSTAN_ARGS)
 
 .PHONY: test
 test: vendor
-	$(PHP_BIN) vendor/bin/phpunit $(PHPUNIT_ARGS)
+	$(DOCKER_PHP_EXEC) $(PHP_BIN) vendor/bin/phpunit $(PHPUNIT_ARGS)
+
+.PHONY: clean
+clean:
+	git clean -dfX
diff --git a/composer.json b/composer.json
@@ -12,14 +12,14 @@
     ],
     "require": {
         "php": "~8.2.0 || ~8.3.0",
-        "nikic/php-parser": "^4.18.0 || ^5.0.0",
-        "phpstan/phpstan": "^1.10.59"
+        "nikic/php-parser": "^4.19.1 || ^5.0.2",
+        "phpstan/phpstan": "^1.11.4"
     },
     "require-dev": {
-        "nette/di": "^3.2.1",
+        "nette/di": "^3.2.2",
         "nette/neon": "^3.4.1",
-        "phpstan/phpstan-phpunit": "^1.3.16",
-        "phpunit/phpunit": "^11.0.4",
+        "phpstan/phpstan-phpunit": "^1.4.0",
+        "phpunit/phpunit": "^11.2.1",
         "slam/php-cs-fixer-extensions": "^3.10.0"
     },
     "autoload": {
diff --git a/docker-compose.yml b/docker-compose.yml
@@ -0,0 +1,10 @@
+services:
+  php:
+    build:
+      context: .
+      args:
+        USER_ID: ${USER_ID}
+        GROUP_ID: ${GROUP_ID}
+    volumes:
+      - .:${PWD}
+    working_dir: ${PWD}
diff --git a/lib/AccessGlobalVariableWithinContextRule.php b/lib/AccessGlobalVariableWithinContextRule.php
@@ -9,6 +9,8 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\Broker\Broker;
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleError;
+use PHPStan\Rules\RuleErrorBuilder;
 
 /**
  * @implements Rule<Variable>
@@ -42,7 +44,7 @@ public function getNodeType(): string
         return Variable::class;
     }
 
-    /** @return string[] */
+    /** @return list<RuleError> */
     public function processNode(Node $node, Scope $scope): array
     {
         if (! \is_string($node->name)) {
@@ -64,12 +66,12 @@ public function processNode(Node $node, Scope $scope): array
 
         $modelBaseClassOrInterface = $this->broker->getClass($this->contextBaseClassOrInterface);
 
-        return [\sprintf(
+        return [RuleErrorBuilder::message(\sprintf(
             'Class %s %s %s and uses $%s: accessing globals in this context is considered an anti-pattern',
             $classReflection->getDisplayName(),
             $modelBaseClassOrInterface->isInterface() ? 'implements' : 'extends',
             $this->contextBaseClassOrInterface,
             $node->name
-        )];
+        ))->identifier('globalAccess.outOfContext')->build()];
     }
 }
diff --git a/lib/AccessStaticPropertyWithinModelContextRule.php b/lib/AccessStaticPropertyWithinModelContextRule.php
@@ -9,6 +9,8 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\Broker\Broker;
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleError;
+use PHPStan\Rules\RuleErrorBuilder;
 
 /**
  * @implements Rule<StaticPropertyFetch>
@@ -31,7 +33,7 @@ public function getNodeType(): string
         return StaticPropertyFetch::class;
     }
 
-    /** @return string[] */
+    /** @return list<RuleError> */
     public function processNode(Node $node, Scope $scope): array
     {
         if (! $node->class instanceof Node\Name || ! $node->name instanceof Node\VarLikeIdentifier) {
@@ -59,13 +61,13 @@ public function processNode(Node $node, Scope $scope): array
 
         $modelBaseClassOrInterface = $this->broker->getClass($this->modelBaseClassOrInterface);
 
-        return [\sprintf(
+        return [RuleErrorBuilder::message(\sprintf(
             'Class %s %s %s and uses %s::$%s: accessing a singleton in this context is considered an anti-pattern',
             $classReflection->getDisplayName(),
             $modelBaseClassOrInterface->isInterface() ? 'implements' : 'extends',
             $this->modelBaseClassOrInterface,
             $this->singletonAccessor,
             (string) $node->name
-        )];
+        ))->identifier('singletonAccess.outOfContext')->build()];
     }
 }
diff --git a/lib/ClassNotationRule.php b/lib/ClassNotationRule.php
@@ -12,6 +12,8 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\Broker\Broker;
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleError;
+use PHPStan\Rules\RuleErrorBuilder;
 
 /**
  * @implements Rule<ClassLike>
@@ -30,23 +32,23 @@ public function getNodeType(): string
         return ClassLike::class;
     }
 
-    /** @return string[] */
+    /** @return list<RuleError> */
     public function processNode(Node $node, Scope $scope): array
     {
-        $messages       = [];
         $nodeIdentifier = $node->name;
         if (null === $nodeIdentifier) {
-            return $messages;
+            return [];
         }
         $name = $nodeIdentifier->name;
         if (\str_starts_with($name, 'AnonymousClass')) {
-            return $messages;
+            return [];
         }
         if (null === $node->namespacedName) {
-            return $messages;
+            return [];
         }
 
-        $fqcn = $node->namespacedName->toString();
+        $messages = [];
+        $fqcn     = $node->namespacedName->toString();
         if ($node instanceof Interface_) {
             if (! \preg_match('/Interface$/', $name)) {
                 $messages[] = \sprintf('Interface %s should end with "Interface" suffix.', $fqcn);
@@ -75,6 +77,8 @@ public function processNode(Node $node, Scope $scope): array
             }
         }
 
-        return $messages;
+        return \array_map(static function (string $message): RuleError {
+            return RuleErrorBuilder::message($message)->identifier('classNotation')->build();
+        }, $messages);
     }
 }
diff --git a/lib/GotoRule.php b/lib/GotoRule.php
@@ -8,6 +8,8 @@
 use PhpParser\Node\Stmt\Goto_;
 use PHPStan\Analyser\Scope;
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleError;
+use PHPStan\Rules\RuleErrorBuilder;
 
 /**
  * @implements Rule<Goto_>
@@ -19,9 +21,9 @@ public function getNodeType(): string
         return Goto_::class;
     }
 
-    /** @return string[] */
+    /** @return list<RuleError> */
     public function processNode(Node $node, Scope $scope): array
     {
-        return ['No goto, cmon!'];
+        return [RuleErrorBuilder::message('No goto, cmon!')->identifier('goto.forbidden')->build()];
     }
 }
diff --git a/lib/MissingClosureParameterTypehintRule.php b/lib/MissingClosureParameterTypehintRule.php
@@ -8,6 +8,8 @@
 use PhpParser\Node\Expr\Closure;
 use PHPStan\Analyser\Scope;
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleError;
+use PHPStan\Rules\RuleErrorBuilder;
 
 /**
  * @implements Rule<Closure>
@@ -19,7 +21,7 @@ public function getNodeType(): string
         return Closure::class;
     }
 
-    /** @return string[] */
+    /** @return list<RuleError> */
     public function processNode(Node $node, Scope $scope): array
     {
         $messages = [];
@@ -29,7 +31,11 @@ public function processNode(Node $node, Scope $scope): array
                 continue;
             }
 
-            $messages[] = \sprintf('Parameter #%d $%s of anonymous function has no typehint.', 1 + $index, $param->var->name);
+            $messages[] = RuleErrorBuilder::message(\sprintf(
+                'Parameter #%d $%s of anonymous function has no typehint.',
+                1 + $index,
+                $param->var->name,
+            ))->identifier('typehintMissing.anonymousFunction')->build();
         }
 
         return $messages;
diff --git a/lib/NotNow/NoDateWithoutSecondArgumentRule.php b/lib/NotNow/NoDateWithoutSecondArgumentRule.php
@@ -9,6 +9,8 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\Reflection\ReflectionProvider;
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleError;
+use PHPStan\Rules\RuleErrorBuilder;
 
 /**
  * @implements Rule<FuncCall>
@@ -27,7 +29,7 @@ public function getNodeType(): string
         return FuncCall::class;
     }
 
-    /** @return string[] */
+    /** @return list<RuleError> */
     public function processNode(Node $node, Scope $scope): array
     {
         if (! $node->name instanceof Node\Name) {
@@ -42,6 +44,8 @@ public function processNode(Node $node, Scope $scope): array
             return [];
         }
 
-        return ['Calling date() without the second parameter is forbidden, rely on a clock abstraction like lcobucci/clock'];
+        return [RuleErrorBuilder::message(
+            'Calling date() without the second parameter is forbidden, rely on a clock abstraction like lcobucci/clock',
+        )->identifier('datecall.implicitTime.forbidden')->build()];
     }
 }
diff --git a/lib/NotNow/NoRelativeDateTimeInterfaceRule.php b/lib/NotNow/NoRelativeDateTimeInterfaceRule.php
@@ -9,6 +9,8 @@
 use PhpParser\Node\Expr\New_;
 use PHPStan\Analyser\Scope;
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleError;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\ConstantScalarType;
 use PHPStan\Type\TypeWithClassName;
 
@@ -22,7 +24,7 @@ public function getNodeType(): string
         return New_::class;
     }
 
-    /** @return string[] */
+    /** @return list<RuleError> */
     public function processNode(Node $node, Scope $scope): array
     {
         $type = $scope->getType($node);
@@ -37,12 +39,10 @@ public function processNode(Node $node, Scope $scope): array
         $args = $node->getArgs();
 
         if (0 === \count($args)) {
-            return [
-                \sprintf(
-                    'Instantiating %s without the first argument is forbidden, rely on a clock abstraction like lcobucci/clock',
-                    DateTimeInterface::class
-                ),
-            ];
+            return [RuleErrorBuilder::message(\sprintf(
+                'Instantiating %s without the first argument is forbidden, rely on a clock abstraction like lcobucci/clock',
+                DateTimeInterface::class,
+            ))->identifier('newdate.implicitTime.forbidden')->build()];
         }
 
         $argType = $scope->getType($args[0]->value);
@@ -55,12 +55,10 @@ public function processNode(Node $node, Scope $scope): array
             return [];
         }
 
-        return [
-            \sprintf(
-                'Instantiating %s with relative datetime "%s" is forbidden, rely on a clock abstraction like lcobucci/clock',
-                DateTimeInterface::class,
-                $value
-            ),
-        ];
+        return [RuleErrorBuilder::message(\sprintf(
+            'Instantiating %s with relative datetime "%s" is forbidden, rely on a clock abstraction like lcobucci/clock',
+            DateTimeInterface::class,
+            $value,
+        ))->identifier('newdate.relativeTime.forbidden')->build()];
     }
 }
diff --git a/lib/NotNow/NoRelativeStrtotimeRule.php b/lib/NotNow/NoRelativeStrtotimeRule.php
@@ -9,6 +9,8 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\Reflection\ReflectionProvider;
 use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleError;
+use PHPStan\Rules\RuleErrorBuilder;
 use PHPStan\Type\ConstantScalarType;
 
 /**
@@ -28,7 +30,7 @@ public function getNodeType(): string
         return FuncCall::class;
     }
 
-    /** @return string[] */
+    /** @return list<RuleError> */
     public function processNode(Node $node, Scope $scope): array
     {
         if (! $node->name instanceof Node\Name) {
@@ -55,11 +57,9 @@ public function processNode(Node $node, Scope $scope): array
             return [];
         }
 
-        return [
-            \sprintf(
-                'Calling strtotime() with relative datetime "%s" without the second argument is forbidden, rely on a clock abstraction like lcobucci/clock',
-                $value
-            ),
-        ];
+        return [RuleErrorBuilder::message(\sprintf(
+            'Calling strtotime() with relative datetime "%s" without the second argument is forbidden, rely on a clock abstraction like lcobucci/clock',
+            $value,
+        ))->identifier('strtotimecall.implicitTime.forbidden')->build()];
     }
 }
diff --git a/lib/NotNow/NoTimeRule.php b/lib/NotNow/NoTimeRule.php
diff --git a/lib/StringToClassRule.php b/lib/StringToClassRule.php
diff --git a/lib/SymfonyFilesystemRule.php b/lib/SymfonyFilesystemRule.php
diff --git a/lib/SymfonyProcessRule.php b/lib/SymfonyProcessRule.php
diff --git a/phpstan-baseline.neon b/phpstan-baseline.neon
diff --git a/tests/UnusedVariableRuleTest.php b/tests/UnusedVariableRuleTest.php

Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,8 @@`
`12`	`12`	`use PHPStan\Analyser\Scope;`
`13`	`13`	`use PHPStan\Broker\Broker;`
`14`	`14`	`use PHPStan\Rules\Rule;`
	`15`	`+use PHPStan\Rules\RuleError;`
	`16`	`+use PHPStan\Rules\RuleErrorBuilder;`
`15`	`17`
`16`	`18`	`/**`
`17`	`19`	`* @implements Rule<ClassLike>`
`@@ -30,23 +32,23 @@ public function getNodeType(): string`
`30`	`32`	`return ClassLike::class;`
`31`	`33`	`}`
`32`	`34`
`33`		`- /** @return string[] */`
	`35`	`+ /** @return list<RuleError> */`
`34`	`36`	`public function processNode(Node $node, Scope $scope): array`
`35`	`37`	`{`
`36`		`- $messages = [];`
`37`	`38`	`$nodeIdentifier = $node->name;`
`38`	`39`	`if (null === $nodeIdentifier) {`
`39`		`- return $messages;`
	`40`	`+ return [];`
`40`	`41`	`}`
`41`	`42`	`$name = $nodeIdentifier->name;`
`42`	`43`	`if (\str_starts_with($name, 'AnonymousClass')) {`
`43`		`- return $messages;`
	`44`	`+ return [];`
`44`	`45`	`}`
`45`	`46`	`if (null === $node->namespacedName) {`
`46`		`- return $messages;`
	`47`	`+ return [];`
`47`	`48`	`}`
`48`	`49`
`49`		`- $fqcn = $node->namespacedName->toString();`
	`50`	`+ $messages = [];`
	`51`	`+ $fqcn = $node->namespacedName->toString();`
`50`	`52`	`if ($node instanceof Interface_) {`
`51`	`53`	`if (! \preg_match('/Interface$/', $name)) {`
`52`	`54`	`$messages[] = \sprintf('Interface %s should end with "Interface" suffix.', $fqcn);`
`@@ -75,6 +77,8 @@ public function processNode(Node $node, Scope $scope): array`
`75`	`77`	`}`
`76`	`78`	`}`
`77`	`79`
`78`		`- return $messages;`
	`80`	`+ return \array_map(static function (string $message): RuleError {`
	`81`	`+ return RuleErrorBuilder::message($message)->identifier('classNotation')->build();`
	`82`	`+ }, $messages);`
`79`	`83`	`}`
`80`	`84`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,8 @@`
`8`	`8`	`use PhpParser\Node\Stmt\Goto_;`
`9`	`9`	`use PHPStan\Analyser\Scope;`
`10`	`10`	`use PHPStan\Rules\Rule;`
	`11`	`+use PHPStan\Rules\RuleError;`
	`12`	`+use PHPStan\Rules\RuleErrorBuilder;`
`11`	`13`
`12`	`14`	`/**`
`13`	`15`	`* @implements Rule<Goto_>`
`@@ -19,9 +21,9 @@ public function getNodeType(): string`
`19`	`21`	`return Goto_::class;`
`20`	`22`	`}`
`21`	`23`
`22`		`- /** @return string[] */`
	`24`	`+ /** @return list<RuleError> */`
`23`	`25`	`public function processNode(Node $node, Scope $scope): array`
`24`	`26`	`{`
`25`		`- return ['No goto, cmon!'];`
	`27`	`+ return [RuleErrorBuilder::message('No goto, cmon!')->identifier('goto.forbidden')->build()];`
`26`	`28`	`}`
`27`	`29`	`}`