Hi!

I'm trying out v0.8.x-dev, but I'm unable to run any test. Do I need to include my vendor folder or autoload file somewhere as well?

When I run: vendor/bin/phpat phpat.yaml

I get:

In IdentifierNotFound.php line 30:
                                                                                                                                           
  PHPStan\BetterReflection\Reflection\ReflectionClass "Symfony\Component\HttpFoundation\Request" could not be found in the located source  

phpat.yaml

src:
  path: src/
composer:
  app:
    json: composer.json
    lock: composer.lock
tests:
  path: tests/Architecture/

composer.json

{
    "require": {
        "php": ">=8.0",
    },
    "autoload": {
        "files": [
            "src/Domain/Shared/Translation/functions.php"
        ],
        "psr-4": {
            "Application\\": "src/Application",
            "Domain\\": "src/Domain",
            "Infrastructure\\": "src/Infrastructure",
            "UserInterface\\": "src/UserInterface"
        }
    },
    "autoload-dev": {
        "psr-4": {
            "Tests\\": "tests/"
        }
    }
}

DomainTest.php

<?php

namespace Tests\Architecture;

use PhpAT\Rule\Rule;
use PhpAT\Selector\Selector;
use PhpAT\Test\ArchitectureTest;

class DomainTest extends ArchitectureTest
{
    public function testDomainDoesNotDependOnOtherLayers(): Rule
    {
        return $this->newRule
            ->classesThat(Selector::haveClassName('Domain\*'))
            ->canOnlyDependOn()
            ->classesThat(Selector::havePath('Domain/*'))
            ->build();
    }
}

Inspecting code like following:

namespace Shared\Domain;

interface EventSourcedAggregateRoot extends AggregateRoot
{
    /**
     * @param iterable<DomainEvent> $history
     *
     * @return static
     *
     * @psalm-pure
     */
    public static function reconstituteFromHistory(iterable $history) : self;
    // ... snip ...
}

Current tooling detects self and static as class names, while they should probably be resolved as self in the context of dependency tracking:

X Shared\Domain\EventSourcedAggregateRoot depends on Shared\Domain\static
X Shared\Domain\EventSourcedAggregateRoot depends on Shared\Domain\self

Bug Description

The test output seems to get shown before the actual test was run.

We would expect the output with the green/red marker to get shown right below the test where the errors originate from (at the bottom green/red marker).

Additional context

We run phpat using Docker, with the basic config yaml from the README

$ docker run --rm -v ${PWD}:/project -w /project jakzal/phpqa phpat

Enhancement description It would be great to provide a phar version of the tool to avoid dependency collisions with other projects.

Suggested approach or solution Investigate and create a script to generate updated versions every time a new release is published.

This list is based on https://github.com/phpactor/phpactor/issues/1135

Package Support

Ensuring that all packages support 8.0 and phpat can be composer-installed in a PHP 8.0 environment ✅

Language Support

Constructor promotion ✅

class CustomerDTO
{
    public function __construct(
        public Email $email, 
        public DateTimeImmutable $birth_date,
    ) {}
}

Named Parameters ✅

$data = new CustomerData(
    email: new Email('[email protected]')
);

Union Types ✅

Currently supported in docblocks

class Example {
    private int|float $foo;
    public function squareAndAdd(float|int $bar): int|float {
        return $bar ** 2 + $foo;
    }
}

$class is instanceof Foo|Bar

Attributes ✅ :warning:

TODO:

• Attribute arguments might use types
• Currently only class and method attributes are catched

Match and Throw Expression ✅

match ($class) {
    $class instanceof Foo => 'one',
    $class instanceof Bar => 'bar',
    default => throw new Exception('error');
}

Enhancement description In a Mono-Repo setup it is common that each module has it's own composer.json file that defines the dependencies. However it is easy to depend on a dependency from another module. Also dependencies between modules in the same mono-repo should also be defined inside each modules composer.json.

It would be great if we don't have to replicate the whole information from the composer.json, but rather use the composer.json as a source for our architecture testing.

**Suggested approach or solution ** Didn't look at the source yet, however phparch has a similar feature: https://github.com/j6s/phparch#shorthand-for-monorepos-addcomposerbasedcomponent

The phparch solution misses one important thing, as it expects a composer.lock file inside each module, in a mono-repo setup especially for development purposes you mostly just have one lock file in the mono-repo root containing the dependencies of all modules. https://github.com/symfony/symfony being a good example of such setup

Enhancement description At the moment, every assertion requires specifying another selector for a relation. There are no assertions which can assert a certain characteristic of the selected classes. For example, one could want to assert that every class matching a selector is final.

Example usage:

 <?php

use PhpAT\Rule\Rule;
use PhpAT\Selector\Selector;
use PhpAT\Test\ArchitectureTest;

class ExampleTest extends ArchitectureTest
{
    public function testEntitesAreFinal(): Rule
    {
        return $this->newRule
            ->classesThat(Selector::haveClassName('App\Entity\*'))
            ->mustBeFinal()
            ->build();
    }
}

Would such assertions be accepted as pull requests? Do you think phpat is the best tool for that (vs rector, php-cs-fixer and tests)?

Suggested approach or solution

Creating a new collection of assertions which look only at the AST of the matched classes and not depend on its relations. Perhaps for these assertions a simple AST processing would be needed.

This adds 2 more selectors:

• One for source files declared in composer.json
• One for dependencies declared in composer.json

The functionality is pretty much a 1:1 copy from phparch with some additional tweaks. Example usage can be found in tests/architecture/ComposerTest

I am not happy with the naming since areComposerSource does not really communicate the intent of the selector very well.

Enhancement description It would be great to have the option of checking if a class has some dependency/inheritance/mixin/composition not only by itself but coming from a parent.

Suggested approach or solution The feature should be enabled by default, but with the ability to disable it with ignore-indirect-behaviour. This check should be performed by the parser.

i have a legacy Symfony 1 Application and want to enforce some rules within the legacy code. starting with SfContext (which i replaced and aliased with a new implementation), so i configured my phpstan like this:

  paths:
    - lib
    - src
    - tests

  bootstrapFiles:
    - .phpstan/aliases.php

# aliases.php
<?php

    class_alias(\SymfonyOne\SfContext::class, \sfContext::class );

with a simple test enforcing this:

<?php namespace Tests\Architecture;

    use SymfonyOne\SfContext;
    use PHPat\Selector\Selector;
    use PHPat\Test\PHPat;
    use PHPat\Test\Builder\Rule;

    class ExampleTest {
        public function test_no_dependency_on_sfContext(): Rule
        {
            return PHPat::rule()
                ->classes(Selector::all())
                ->shouldNotDependOn()
                ->classes(
                    Selector::classname(SfContext::class),
                    Selector::classname(\sfContext::class),
                );
        }
    }

which works fine for the test itself, i get errors which i would expect:

 ------ --------------------------------------------------------------------------------------------------------
  Line   tests/Architecture/ExampleTest.php
 ------ --------------------------------------------------------------------------------------------------------
  15     \Tests\Architecture\ExampleTest should not depend on \SymfonyOne\SfContext
  16     \Tests\Architecture\ExampleTest should not depend on sfContext
 ------ --------------------------------------------------------------------------------------------------------

but i do not get any errors from classes without namespace living in the lib folder which is scanned by phpstan :thinking:

is that a limitation of phpat?

This pull requests fixes 3 issues:

• The path to the binary was incorrect, so the file in phar project was empty
• As the phpat binary is put at the top level the path to vendor/autload.php was incorrect
• After fixing the above I was still getting autoload errors about missing PHPUnit files failed to open stream: phar error: "vendor/phpunit/phpunit/src/Framework/Assert/Functions.php" is not a file in phar "/home/lefty/Workspace/phpat/dist/phpat.phar" in phar:///.../phpat/dist/phpat.phar/vendor/composer/autoload_real.php on line 55 As those files are not necessary for the library to work and increase the size of the phar archive I instructed workflow not to install dev dependencies

Hi!

I have a class in the Domain namespace, which has Doctrine's attributes for ORM mapping. My classes have the following imports:

<?php

declare(strict_types=1);

namespace Domain\MyDomain;

use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\DBAL\Types\Types;
use Doctrine\ORM\Mapping as ORM;

With the test below:

public function testDomainLayerOnlyDependsOnDomainLayer(): Rule
{
    return PHPat::rule()
        ->classes(
            Selector::namespace('/^Domain.*/', true),
        )
        ->shouldNotDependOn()
        ->classes(
            Selector::NOT(Selector::namespace('/^Domain.*/', true)),
        )
    ;
}

I get:

 ------ ------------------------------------------------------------------------------------------------- 
  Line   src/Domain/MyDomain\MyClass.php                                                           
 ------ ------------------------------------------------------------------------------------------------- 
  43     Domain\MyDomain\MyClass should not depend on Doctrine\DBAL\Types\Types                    
  48     Domain\MyDomain\MyClass should not depend on Doctrine\DBAL\Types\Types                    
  51     Domain\MyDomain\MyClass should not depend on Doctrine\DBAL\Types\Types                    
  54     Domain\MyDomain\MyClass should not depend on Doctrine\DBAL\Types\Types                    
  57     Domain\MyDomain\MyClass should not depend on Doctrine\DBAL\Types\Types                    
  60     Domain\MyDomain\MyClass should not depend on Doctrine\DBAL\Types\Types                    
  63     Domain\MyDomain\MyClass should not depend on Doctrine\DBAL\Types\Types                    
  69     Domain\MyDomain\MyClass should not depend on Doctrine\Common\Collections\Collection       
  75     Domain\MyDomain\MyClass should not depend on Doctrine\Common\Collections\Collection       
  95     Domain\MyDomain\MyClass should not depend on Doctrine\Common\Collections\ArrayCollection  
  102    Domain\MyDomain\MyClass should not depend on Doctrine\Common\Collections\ArrayCollection  
 ------ ------------------------------------------------------------------------------------------------- 

There is no mention of the import:

use Doctrine\ORM\Mapping as ORM;

Using a direct import also is not reported:

use Doctrine\ORM\Mapping\Column;

Hi,

I'm trying to define the rule:

• Classes from the Application namespace, can only depend on classes in the Application namespace, and the Domain namespace.

In PHPat's language:

• Classes with namespace Application, should not depend on classes that NOT have namespace Application AND should not depend on classes that NOT have namespace Domain.

With the test below:

    public function testApplicationLayerOnlyDependsOnDomainAndApplicationLayer(): Rule
    {
        return PHPat::rule()
            ->classes(
                Selector::namespace('/^Application.*/', true),
            )
            ->shouldNotDependOn()
            ->classes(
                Selector::NOT(Selector::namespace('/^Application.*/', true)),
                Selector::NOT(Selector::namespace('/^Domain.*/', true)),
            )
        ;
    }

Both classes from Domain and Application namespace are reported.

Below works, but feels counterintuitive?

    public function testApplicationLayerOnlyDependsOnDomainAndApplicationLayer(): Rule
    {
        return PHPat::rule()
            ->classes(
                Selector::namespace('/^Application.*/', true),
            )
            ->shouldNotDependOn()
            ->classes(Selector::all())
            ->excluding(
                Selector::namespace('/^Application.*/', true),
                Selector::namespace('/^Domain.*/', true),
            )
        ;
    }

Hi,

I'm trying to define the rule:

• Classes in the Domain namespace, can only depend on classes in the Domain namespace, and classes from php's global namespace.

In PHPat's language:

• Classes with namespace Domain, should not depend on classes that NOT have namespace Domain, excluding classes from the global php namespace.

How can I define the "global namespace" part? I tried an empty string, or a regex where the namespace stars with a backslash, but without result.

public function testDomainLayerOnlyDependsOnDomainLayer(): Rule
    {
        return PHPat::rule()
            ->classes(
                Selector::namespace('/^Domain.*/', true),
            )
            ->shouldNotDependOn()
            ->classes(
                Selector::NOT(Selector::namespace('/^Domain.*/', true)),
            )
            ->excluding(
                Selector::classname('/^\\*./', true), <-- how to do this?
            )
        ;
    }
``

Hi!

Great job on 0.10!

Most of my tests included the canOnlyDependOn assertion, which I guess is removed in 0.10. Was this done on purpose and do you maybe have an alternative way of writing these rules? :)

Edit:

Ah. I guess I can nest it like this?

return PHPat::rule()
    ->classes(Selector::haveClassName('...'))
    ->shouldNotDependOn()
    ->classes(
        Selector::NOT(
            Selector::classname('...')
        )
    )

Enhancement description While defining my rules, I need to define some fine grained rules such as:

• If class implements interface X, I want it to use trait A or B or C
• if class uses trait A, I want its class to implement interface A and one of ( B or C )

Currently, all rules are combining as an and operator. Those operators may be useful:

• all of (and operator)
• any of (or operator)
• none of (not operator)
• one of (xor operator)
• at least X of
• at most X of

Suggested approach or solution By creating new selectors, I can now define more precise rules

$this->newRule
    ->classesThat(Selector::implementInterface('EventSauce\EventSourcing\AggregateRoot'))
    ->mustInclude()
    ->classesThat(
        Selector::oneOf(
            Selector::haveClassName('EventSauce\EventSourcing\AggregateRootWithAggregates'),
            Selector::haveClassName('EventSauce\EventSourcing\AggregateRootBehaviour'),
            Selector::haveClassName('EventSauce\EventSourcing\AggregateAlwaysAppliesEvents'),
        )
    )
    ->build();