phpcs calisthenics rules Download - phpcs calisthenics rules Código Fonte Download

Regras de calistenia do objeto para php_codesniffer

Despregado: Php_codesniffer é ótimo para lidar com espaços e posições de char. No entanto, essas regras são sobre arquitetura e estrutura de código. Em 2020, há uma ferramenta que se adapta a isso perfeitamente - Phpstan .

Dizendo isso, a Calistenia do Objeto foi implementada como regras do Phpstan em um pacote symplify/phpstan-rules . Em vez disso?

 includes:
    - vendor/symplify/phpstan-rules/packages/object-calisthenics/config/object-calisthenics-rules.neon
    - vendor/symplify/phpstan-rules/packages/object-calisthenics/config/object-calisthenics-services.neon

A calistenia do objeto é um conjunto de regras no código orientado a objetos, que focos de manutenção, legibilidade, testabilidade e compreensibilidade . Somos pragmáticos primeiro - eles são fáceis de usar juntos ou um por um.

Por que você deve usar isso em seu projeto?

Leia o post de William Durand ou verifique a apresentação de Guilherme Blanco .

Instalar

composer require object-calisthenics/phpcs-calisthenics-rules --dev

Uso

Se você sabe o que deseja, pule diretamente para a regra específica:

1. Somente x nível de indentação por método
2. Não use palavras -chave "else"
5. Use apenas um operador de objeto (->) por instrução
6. Não abreviem
7. Mantenha suas aulas pequenas
9. Não use getters e setters

Como verificar rapidamente 1 regra?

Em php_codesniffer

vendor/bin/phpcs src tests -sp 
--standard=vendor/object-calisthenics/phpcs-calisthenics-rules/src/ObjectCalisthenics/ruleset.xml 
--sniffs=ObjectCalisthenics.Classes.ForbiddenPublicProperty

Em Easycodingstandard

 # ecs.yaml
services :
    ObjectCalisthenicsSniffsClassesForbiddenPublicPropertySniff : ~

então

vendor/bin/ecs check src

Implementou Sniffs de regra

1. Somente `X` nível de indentação por método

 foreach ( $ sniffGroups as $ sniffGroup ) {
    foreach ( $ sniffGroup as $ sniffKey => $ sniffClass ) {
        if (! $ sniffClass instanceof Sniff) {
            throw new InvalidClassTypeException ;
        }
    }
}

 foreach ( $ sniffGroups as $ sniffGroup ) {
    $ this -> ensureIsAllInstanceOf ( $ sniffGroup , Sniff::class);
}

// ...
private function ensureIsAllInstanceOf ( array $ objects , string $ type )
{
    // ...
}

Usar apenas esta regra?

Em php_codesniffer:

vendor/bin/phpcs ... --sniffs=ObjectCalisthenics.Metrics.MaxNestingLevel

Em ECS:

 # ecs.yaml
services :
    ObjectCalisthenicsSniffsMetricsMaxNestingLevelSniff : ~

? Configurável

Em php_codesniffer:

<? xml version = " 1.0 " ?>
< ruleset name = " my-project " >
    < rule ref = " ObjectCalisthenics.Metrics.MaxNestingLevel " >
        < properties >
            < property name = " maxNestingLevel " value = " 2 " />
        </ properties >
    </ rule >
</ ruleset >

Em ECS:

 services :
    ObjectCalisthenicsSniffsMetricsMaxNestingLevelSniff :
        maxNestingLevel : 2

2. Não use palavras -chave "else"

 if ( $ status === self :: DONE ) {
    $ this -> finish ();
} else {
    $ this -> advance ();
}

 if ( $ status === self :: DONE ) {
    $ this -> finish ();
    return ;
}

$ this -> advance ();

Usar apenas esta regra?

Em php_codesniffer:

vendor/bin/phpcs ... --sniffs=ObjectCalisthenics.ControlStructures.NoElse

Em ECS:

 # ecs.yaml
services :
    ObjectCalisthenicsSniffsControlStructuresNoElseSniff : ~

5. Use apenas um operador de objeto ( `->` ) por instrução

 $ this -> container -> getBuilder ()-> addDefinition (SniffRunner::class);

 $ containerBuilder = $ this -> getContainerBuilder ();
$ containerBuilder -> addDefinition (SniffRunner::class);

Usar apenas esta regra?

Em php_codesniffer:

vendor/bin/phpcs ... --sniffs=ObjectCalisthenics.CodeAnalysis.OneObjectOperatorPerLine

Em ECS:

 # ecs.yaml
services :
    ObjectCalisthenicsSniffsCodeAnalysisOneObjectOperatorPerLineSniff : ~

? Configurável

Em php_codesniffer:

<? xml version = " 1.0 " ?>
< ruleset name = " my-project " >
    < rule ref = " ObjectCalisthenics.CodeAnalysis.OneObjectOperatorPerLine " >
        < properties >
            < property name = " variablesHoldingAFluentInterface " type = " array " value = " $queryBuilder,$containerBuilder " />
            < property name = " methodsStartingAFluentInterface " type = " array " value = " createQueryBuilder " />
            < property name = " methodsEndingAFluentInterface " type = " array " value = " execute,getQuery " />
        </ properties >
    </ rule >
</ ruleset >

Em ECS:

 services :
    ObjectCalisthenicsSniffsCodeAnalysisOneObjectOperatorPerLineSniff :
        variablesHoldingAFluentInterface : ["$queryBuilder", "$containerBuilder"]
        methodsStartingAFluentInterface : ["createQueryBuilder"]
        methodsEndingAFluentInterface : ["execute", "getQuery"]

6. Não abreviem

Isso está relacionado a nomes de classe, característica, interface, constante, função e variável.

 class EM
{
    // ...
}

 class EntityMailer
{
    // ...
}

Usar apenas esta regra?

Em php_codesniffer:

vendor/bin/phpcs ... --sniffs=ObjectCalisthenics.NamingConventions.ElementNameMinimalLength

Em ECS:

 # ecs.yaml
services :
    ObjectCalisthenicsSniffsNamingConventionsElementNameMinimalLengthSniff : ~

? Configurável

Em php_codesniffer:

<? xml version = " 1.0 " ?>
< ruleset name = " my-project " >
    < rule ref = " ObjectCalisthenics.NamingConventions.ElementNameMinimalLength " >
        < properties >
            < property name = " minLength " value = " 3 " />
            < property name = " allowedShortNames " type = " array " value = " i,id,to,up " />
        </ properties >
    </ rule >
</ ruleset >

Em ECS:

 # ecs.yaml
services :
    ObjectCalisthenicsSniffsNamingConventionsElementNameMinimalLengthSniff :
        minLength : 3
        allowedShortNames : ["i", "id", "to", "up"]

7. Mantenha suas aulas pequenas

 class SimpleStartupController
{
    // 300 lines of code
}

 class SimpleStartupController
{
    // 50 lines of code
}

 class SomeClass
{
    public function simpleLogic ()
    {
        // 30 lines of code
    }
}

 class SomeClass
{
    public function simpleLogic ()
    {
        // 10 lines of code
    }
}

 class SomeClass
{
    // 20 properties
}

 class SomeClass
{
    // 5 properties
}

 class SomeClass
{
    // 20 methods
}

 class SomeClass
{
    // 5 methods
}

Usar apenas esta regra?

Em php_codesniffer:

vendor/bin/phpcs ... --sniffs=ObjectCalisthenics.Files.ClassTraitAndInterfaceLength,ObjectCalisthenics.Files.FunctionLength,ObjectCalisthenics.Metrics.MethodPerClassLimit,ObjectCalisthenics.Metrics.PropertyPerClassLimit

Em ECS:

 # ecs.yaml
services :
    ObjectCalisthenicsSniffsFilesClassTraitAndInterfaceLengthSniff : ~
    ObjectCalisthenicsSniffsFilesFunctionLengthSniff : ~
    ObjectCalisthenicsSniffsMetricsMethodPerClassLimitSniff : ~
    ObjectCalisthenicsSniffsMetricsPropertyPerClassLimitSniff : ~

? Configurável

Em php_codesniffer:

<? xml version = " 1.0 " ?>
< ruleset name = " my-project " >
    < rule ref = " ObjectCalisthenics.Files.ClassTraitAndInterfaceLength " >
        < properties >
            < property name = " maxLength " value = " 200 " />
        </ properties >
    </ rule >
    < rule ref = " ObjectCalisthenics.Files.FunctionLength " >
        < properties >
            < property name = " maxLength " value = " 20 " />
        </ properties >
    </ rule >
    < rule ref = " ObjectCalisthenics.Metrics.PropertyPerClassLimit " >
        < properties >
            < property name = " maxCount " value = " 10 " />
        </ properties >
    </ rule >
    < rule ref = " ObjectCalisthenics.Metrics.MethodPerClassLimit " >
        < properties >
            < property name = " maxCount " value = " 10 " />
        </ properties >
    </ rule >
</ ruleset >

Em ECS:

 # ecs.yaml
services :
    ObjectCalisthenicsSniffsFilesClassTraitAndInterfaceLengthSniff :
        maxLength : 200
    ObjectCalisthenicsSniffsFilesFunctionLengthSniff :
        maxLength : 20
    ObjectCalisthenicsSniffsMetricsPropertyPerClassLimitSniff :
        maxCount : 10
    ObjectCalisthenicsSniffsMetricsMethodPerClassLimitSniff :
        maxCount : 10

9. Não use getters e setters

Essas regras estão parcialmente relacionadas ao design orientado ao domínio.

As aulas não devem conter propriedades públicas.
O método deve representar o comportamento, não definir valores.

 class ImmutableBankAccount
{
    public $ currency = ' USD ' ;

    private $ amount ;

    public function setAmount ( int $ amount )
    {
        $ this -> amount = $ amount ;
    }
}

 class ImmutableBankAccount
{
    private $ currency = ' USD ' ;

    private $ amount ;

    public function withdrawAmount ( int $ withdrawnAmount )
    {
        $ this -> amount -= $ withdrawnAmount ;
    }
}

Usar apenas esta regra?

Em php_codesniffer:

vendor/bin/phpcs ... --sniffs=ObjectCalisthenics.Classes.ForbiddenPublicProperty,ObjectCalisthenics.NamingConventions.NoSetter

Em ECS:

 # ecs.yaml
services :
    ObjectCalisthenicsSniffsClassesForbiddenPublicPropertySniff : ~
    ObjectCalisthenicsSniffsNamingConventionsNoSetterSniff : ~

? Configurável

Em php_codesniffer:

<? xml version = " 1.0 " ?>
< ruleset name = " my-project " >
    < rule ref = " ObjectCalisthenics.NamingConventions.NoSetter " >
        < properties >
            < property name = " allowedClasses " type = " array " value = " *DataObject " />
        </ properties >
    </ rule >
</ ruleset >

Em ECS:

 # ecs.yaml
services :
    ObjectCalisthenicsSniffsNamingConventionsNoSetterSniff :
        allowedClasses : 
            - ' *DataObject '

Regras não implementadas - muito rigoroso, vago ou irritante

Ao usar na prática, descobrimos que essas regra são muito rigorosas, vagas ou até irritantes, em vez de ajudar a escrever um código mais limpo e pragmático. Eles também estão intimamente relacionados ao design orientado a domínio.

3. Tipos e strings primitivas de envoltório - Como o PHP 7, você pode usar define(strict_types=1) e dicas do tipo escalar. Para outros casos, por exemplo, você pode lidar com isso em seu domínio por meio de objetos de valor.

4. Use coleções de primeira classe - essa regra faz sentido, mas é rigoroso demais para ser útil na prática. Mesmo nosso código não passou.

8. Não use classes com mais de duas variáveis de instância - isso depende do domínio individual de cada projeto. Não faz sentido fazer uma regra para isso.

3 regras para contribuir

1 recurso por PR
Cada novo recurso deve ser coberto por testes
Todos os testes e verificações de estilo devem passar
```
composer complete-check
```

Teremos o maior prazer em mesclar seu recurso então.

Expandir