ModelPrinter::getResolvedPartials() - Code Metrics - Inspection of "typed class printers allow use of method templates" - spider-mane/leonidas - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 3491f1...e1ceb1 )

by Chris

created 2022-06-29 23:57 UTC

ModelPrinter::getResolvedPartials() A

↳ Parent: ModelPrinter

Complexity

Conditions	4
Paths	6

Size

Total Lines	20
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	20

Importance

Changes

Metric	Value
cc	4
eloc	13
c	0
b	0
f	0
nc	6
nop	0
dl	0
loc	20
ccs	0
cts	14
cp	0
crap	20
rs	9.8333

<?php

namespace Leonidas\Console\Library\Printer\Model;

use Leonidas\Console\Library\Printer\Model\Abstracts\AbstractTypedClassPrinter;
use Leonidas\Contracts\System\Model\CommentableInterface;
use Leonidas\Contracts\System\Model\FilterableInterface;
use Leonidas\Contracts\System\Model\HierarchicalInterface;
use Leonidas\Contracts\System\Model\MimeInterface;
use Leonidas\Contracts\System\Model\MutableAuthoredInterface;
use Leonidas\Contracts\System\Model\MutableContentInterface;
use Leonidas\Contracts\System\Model\MutableDatableInterface;
use Leonidas\Contracts\System\Model\MutablePostModelInterface;
use Leonidas\Contracts\System\Model\MutableTermModelInterface;
use Leonidas\Contracts\System\Model\MutableUserModelInterface;
use Leonidas\Contracts\System\Model\PingableInterface;
use Leonidas\Contracts\System\Model\RestrictableInterface;
use Leonidas\Contracts\Util\AutoInvokerInterface;
use Leonidas\Library\System\Model\Abstracts\AllAccessGrantedTrait;
use Leonidas\Library\System\Model\Abstracts\LazyLoadableRelationshipsTrait;
use Leonidas\Library\System\Model\Abstracts\Post\FilterablePostModelTrait;
use Leonidas\Library\System\Model\Abstracts\Post\HierarchicalPostModelTrait;
use Leonidas\Library\System\Model\Abstracts\Post\MimePostModelTrait;
use Leonidas\Library\System\Model\Abstracts\Post\MutableAuthoredPostModelTrait;
use Leonidas\Library\System\Model\Abstracts\Post\MutableCommentablePostModelTrait;
use Leonidas\Library\System\Model\Abstracts\Post\MutableContentPostModelTrait;
use Leonidas\Library\System\Model\Abstracts\Post\MutableDatablePostModelTrait;
use Leonidas\Library\System\Model\Abstracts\Post\MutablePingablePostModelTrait;
use Leonidas\Library\System\Model\Abstracts\Post\MutablePostModelTrait;
use Leonidas\Library\System\Model\Abstracts\Post\RestrictablePostModelTrait;
use Leonidas\Library\System\Model\Abstracts\Post\ValidatesPostTypeTrait;
use Leonidas\Library\System\Model\Abstracts\Term\HierarchicalTermTrait;
use Leonidas\Library\System\Model\Abstracts\Term\MutableTermModelTrait;
use Leonidas\Library\System\Model\Abstracts\Term\ValidatesTaxonomyTrait;
use Leonidas\Library\System\Model\Abstracts\User\MutableUserModelTrait;
use Leonidas\Library\System\Model\Abstracts\User\ValidatesRoleTrait;
use Nette\PhpGenerator\PhpNamespace;
use WP_Comment;
filter:
    dependency_paths: ["lib/*"]
use WP_Post;
use WP_Term;
filter:
    dependency_paths: ["lib/*"]
use WP_User;
filter:
    dependency_paths: ["lib/*"]

class ModelPrinter extends AbstractTypedClassPrinter
{
    public const TEMPLATES = [
        'post' => WP_Post::class,
        'post:h' => WP_Post::class,
        'attachment' => WP_Post::class,
        'term' => WP_Term::class,
        'term:h' => WP_Term::class,
        'user' => WP_User::class,
        // 'comment' => WP_Comment::class,
    ];

    public const CORES = [
        'post' => 'post',
        'post:h' => 'post',
        'attachment' => 'post',
        'term' => 'term',
        'term:h' => 'term',
        'user' => 'user',
        // 'comment' => 'comment',
    ];

    public const VALIDATORS = [
        'post' => ValidatesPostTypeTrait::class,
        'post:h' => ValidatesPostTypeTrait::class,
        'attachment' => ValidatesPostTypeTrait::class,
        'term' => ValidatesTaxonomyTrait::class,
        'user' => ValidatesRoleTrait::class,
    ];

    public const ASSERTIONS = [
        'post' => "\$this->assertPostType($%s, '%s');",
        'post:h' => "\$this->assertPostType($%s, '%s');",
        'attachment' => "\$this->assertPostType($%s, '%s');",
        'term' => "\$this->assertTaxonomy($%s, '%s');",
        'term:h' => "\$this->assertTaxonomy($%s, '%s');",
        'user' => "\$this->assertRole($%s, '%s');",
    ];

    public const PARTIALS = [
        'post' => [
            FilterableInterface::class => FilterablePostModelTrait::class,
            MutableAuthoredInterface::class => MutableAuthoredPostModelTrait::class,
            MutableContentInterface::class => MutableContentPostModelTrait::class,
            MutablePostModelInterface::class => MutablePostModelTrait::class,
            PingableInterface::class => MutablePingablePostModelTrait::class,
            CommentableInterface::class => MutableCommentablePostModelTrait::class,
            RestrictableInterface::class => RestrictablePostModelTrait::class,
            MimeInterface::class => MimePostModelTrait::class,
            MutableDatableInterface::class => MutableDatablePostModelTrait::class,
        ],
        'post:h' => [
            '@post',
            HierarchicalInterface::class => HierarchicalPostModelTrait::class,
        ],
        'attachment' => [
            '@post',
        ],
        'term' => [
            MutableTermModelInterface::class => MutableTermModelTrait::class,
        ],
        'term:h' => [
            '@term',
            HierarchicalInterface::class => HierarchicalTermTrait::class,
        ],
        'user' => [
            MutableUserModelInterface::class => MutableUserModelTrait::class,
        ],
        // 'comment' => [],
    ];

    protected string $entity;

    protected string $template;

    public function __construct(
        string $namespace,
        string $class,
        string $type,
        string $entity,
        string $template = 'post'
    ) {
        parent::__construct($namespace, $class, $type);

        $this->entity = $entity;
        $this->template = $template;
    }

    protected function setupClass(PhpNamespace $namespace): object
    {
        $accessTrait = AllAccessGrantedTrait::class;
        $lazyLoadTrait = LazyLoadableRelationshipsTrait::class;
        $invoker = AutoInvokerInterface::class;
        $template = static::TEMPLATES[$this->template];
        $core = static::CORES[$this->template];
        $validator = static::VALIDATORS[$this->template];
        $assertion = static::ASSERTIONS[$this->template];

        $class = $namespace
            ->addUse($this->type)
            ->addUse($accessTrait)
            ->addUse($lazyLoadTrait)
            ->addUse($validator)
            ->addUse($invoker)
            ->addUse($template)
            ->addClass($this->class);

        $class->addImplement($this->type);
        $class->addTrait($accessTrait);
        $class->addTrait($lazyLoadTrait);
        $class->addTrait($validator);

        foreach ($this->getResolvedPartials() as $partial) {
            $namespace->addUse($partial);
            $class->addTrait($partial);
        }

        $constructor = $class->addMethod('__construct')->setPublic();
        $constraint = $this->template === 'attachment' ? 'attachment' : $this->entity;

        $constructor->addParameter($core)->setType($template);
        $constructor->addParameter('autoInvoker')->setType($invoker);

        $constructor->addBody(sprintf($assertion, $core, $constraint) . "\n");
        $constructor->addBody(sprintf('$this->%s = $%s;', $core, $core));
        $constructor->addBody('$this->autoInvoker = $autoInvoker;' . "\n");

        $getAccessTemplate = $this->isPostTemplate()
            ? '$this->getAccessProvider = new %sTagAccessProvider($this, $%s);'
            : '$this->getAccessProvider = new %sGetAccessProvider($this);';

        $constructor->addBody(sprintf($getAccessTemplate, $this->class, $core));
        $constructor->addBody(sprintf(
            '$this->setAccessProvider = new %sSetAccessProvider($this);',
            $this->class
        ));

        return $class;
    }

    protected function isPostTemplate(): bool
    {
        return in_array($this->template, ['post', 'post:h', 'attachment']);
    }

    protected function getResolvedPartials(): array
    {
        $partials = [];
        $map = [];

        foreach (static::PARTIALS[$this->template] as $contract => $partial) {
            if (str_starts_with($partial, '@')) {
                $inherit = static::PARTIALS[substr($partial, 1)];

                $partials = [...array_values($inherit), ...$partials];
                $map = $map + array_flip($inherit);
            } else {
                $partials[] = $partial;
                $map[$partial] = $contract;
            }
        }

        return $this->isDoingTypeMatch()
            ? $this->matchTraitsToType($partials, $map)
            : $partials;
    }
}


1			<?php
2
3			namespace Leonidas\Console\Library\Printer\Model;
4
5			use Leonidas\Console\Library\Printer\Model\Abstracts\AbstractTypedClassPrinter;
6			use Leonidas\Contracts\System\Model\CommentableInterface;
7			use Leonidas\Contracts\System\Model\FilterableInterface;
8			use Leonidas\Contracts\System\Model\HierarchicalInterface;
9			use Leonidas\Contracts\System\Model\MimeInterface;
10			use Leonidas\Contracts\System\Model\MutableAuthoredInterface;
11			use Leonidas\Contracts\System\Model\MutableContentInterface;
12			use Leonidas\Contracts\System\Model\MutableDatableInterface;
13			use Leonidas\Contracts\System\Model\MutablePostModelInterface;
14			use Leonidas\Contracts\System\Model\MutableTermModelInterface;
15			use Leonidas\Contracts\System\Model\MutableUserModelInterface;
16			use Leonidas\Contracts\System\Model\PingableInterface;
17			use Leonidas\Contracts\System\Model\RestrictableInterface;
18			use Leonidas\Contracts\Util\AutoInvokerInterface;
19			use Leonidas\Library\System\Model\Abstracts\AllAccessGrantedTrait;
20			use Leonidas\Library\System\Model\Abstracts\LazyLoadableRelationshipsTrait;
21			use Leonidas\Library\System\Model\Abstracts\Post\FilterablePostModelTrait;
22			use Leonidas\Library\System\Model\Abstracts\Post\HierarchicalPostModelTrait;
23			use Leonidas\Library\System\Model\Abstracts\Post\MimePostModelTrait;
24			use Leonidas\Library\System\Model\Abstracts\Post\MutableAuthoredPostModelTrait;
25			use Leonidas\Library\System\Model\Abstracts\Post\MutableCommentablePostModelTrait;
26			use Leonidas\Library\System\Model\Abstracts\Post\MutableContentPostModelTrait;
27			use Leonidas\Library\System\Model\Abstracts\Post\MutableDatablePostModelTrait;
28			use Leonidas\Library\System\Model\Abstracts\Post\MutablePingablePostModelTrait;
29			use Leonidas\Library\System\Model\Abstracts\Post\MutablePostModelTrait;
30			use Leonidas\Library\System\Model\Abstracts\Post\RestrictablePostModelTrait;
31			use Leonidas\Library\System\Model\Abstracts\Post\ValidatesPostTypeTrait;
32			use Leonidas\Library\System\Model\Abstracts\Term\HierarchicalTermTrait;
33			use Leonidas\Library\System\Model\Abstracts\Term\MutableTermModelTrait;
34			use Leonidas\Library\System\Model\Abstracts\Term\ValidatesTaxonomyTrait;
35			use Leonidas\Library\System\Model\Abstracts\User\MutableUserModelTrait;
36			use Leonidas\Library\System\Model\Abstracts\User\ValidatesRoleTrait;
37			use Nette\PhpGenerator\PhpNamespace;
38			use WP_Comment;
			0 ignored issues – show Bug introduced 2022-06-22 04:32 UTC by Report Bug Copy Issue Report The type `WP_Comment` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
39			use WP_Post;
40			use WP_Term;
			0 ignored issues – show Bug introduced 2022-06-22 04:32 UTC by Report Bug Copy Issue Report The type `WP_Term` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
41			use WP_User;
			0 ignored issues – show Bug introduced 2022-06-22 04:32 UTC by Report Bug Copy Issue Report The type `WP_User` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
42
43			class ModelPrinter extends AbstractTypedClassPrinter
44			{
45			public const TEMPLATES = [
46			'post' => WP_Post::class,
47			'post:h' => WP_Post::class,
48			'attachment' => WP_Post::class,
49			'term' => WP_Term::class,
50			'term:h' => WP_Term::class,
51			'user' => WP_User::class,
52			// 'comment' => WP_Comment::class,
53			];
54
55			public const CORES = [
56			'post' => 'post',
57			'post:h' => 'post',
58			'attachment' => 'post',
59			'term' => 'term',
60			'term:h' => 'term',
61			'user' => 'user',
62			// 'comment' => 'comment',
63			];
64
65			public const VALIDATORS = [
66			'post' => ValidatesPostTypeTrait::class,
67			'post:h' => ValidatesPostTypeTrait::class,
68			'attachment' => ValidatesPostTypeTrait::class,
69			'term' => ValidatesTaxonomyTrait::class,
70			'user' => ValidatesRoleTrait::class,
71			];
72
73			public const ASSERTIONS = [
74			'post' => "\$this->assertPostType($%s, '%s');",
75			'post:h' => "\$this->assertPostType($%s, '%s');",
76			'attachment' => "\$this->assertPostType($%s, '%s');",
77			'term' => "\$this->assertTaxonomy($%s, '%s');",
78			'term:h' => "\$this->assertTaxonomy($%s, '%s');",
79			'user' => "\$this->assertRole($%s, '%s');",
80			];
81
82			public const PARTIALS = [
83			'post' => [
84			FilterableInterface::class => FilterablePostModelTrait::class,
85			MutableAuthoredInterface::class => MutableAuthoredPostModelTrait::class,
86			MutableContentInterface::class => MutableContentPostModelTrait::class,
87			MutablePostModelInterface::class => MutablePostModelTrait::class,
88			PingableInterface::class => MutablePingablePostModelTrait::class,
89			CommentableInterface::class => MutableCommentablePostModelTrait::class,
90			RestrictableInterface::class => RestrictablePostModelTrait::class,
91			MimeInterface::class => MimePostModelTrait::class,
92			MutableDatableInterface::class => MutableDatablePostModelTrait::class,
93			],
94			'post:h' => [
95			'@post',
96			HierarchicalInterface::class => HierarchicalPostModelTrait::class,
97			],
98			'attachment' => [
99			'@post',
100			],
101			'term' => [
102			MutableTermModelInterface::class => MutableTermModelTrait::class,
103			],
104			'term:h' => [
105			'@term',
106			HierarchicalInterface::class => HierarchicalTermTrait::class,
107			],
108			'user' => [
109			MutableUserModelInterface::class => MutableUserModelTrait::class,
110			],
111			// 'comment' => [],
112			];
113
114			protected string $entity;
115
116			protected string $template;
117
118			public function __construct(
119			string $namespace,
120			string $class,
121			string $type,
122			string $entity,
123			string $template = 'post'
124			) {
125			parent::__construct($namespace, $class, $type);
126
127			$this->entity = $entity;
128			$this->template = $template;
129			}
130
131			protected function setupClass(PhpNamespace $namespace): object
132			{
133			$accessTrait = AllAccessGrantedTrait::class;
134			$lazyLoadTrait = LazyLoadableRelationshipsTrait::class;
135			$invoker = AutoInvokerInterface::class;
136			$template = static::TEMPLATES[$this->template];
137			$core = static::CORES[$this->template];
138			$validator = static::VALIDATORS[$this->template];
139			$assertion = static::ASSERTIONS[$this->template];
140
141			$class = $namespace
142			->addUse($this->type)
143			->addUse($accessTrait)
144			->addUse($lazyLoadTrait)
145			->addUse($validator)
146			->addUse($invoker)
147			->addUse($template)
148			->addClass($this->class);
149
150			$class->addImplement($this->type);
151			$class->addTrait($accessTrait);
152			$class->addTrait($lazyLoadTrait);
153			$class->addTrait($validator);
154
155			foreach ($this->getResolvedPartials() as $partial) {
156			$namespace->addUse($partial);
157			$class->addTrait($partial);
158			}
159
160			$constructor = $class->addMethod('__construct')->setPublic();
161			$constraint = $this->template === 'attachment' ? 'attachment' : $this->entity;
162
163			$constructor->addParameter($core)->setType($template);
164			$constructor->addParameter('autoInvoker')->setType($invoker);
165
166			$constructor->addBody(sprintf($assertion, $core, $constraint) . "\n");
167			$constructor->addBody(sprintf('$this->%s = $%s;', $core, $core));
168			$constructor->addBody('$this->autoInvoker = $autoInvoker;' . "\n");
169
170			$getAccessTemplate = $this->isPostTemplate()
171			? '$this->getAccessProvider = new %sTagAccessProvider($this, $%s);'
172			: '$this->getAccessProvider = new %sGetAccessProvider($this);';
173
174			$constructor->addBody(sprintf($getAccessTemplate, $this->class, $core));
175			$constructor->addBody(sprintf(
176			'$this->setAccessProvider = new %sSetAccessProvider($this);',
177			$this->class
178			));
179
180			return $class;
181			}
182
183			protected function isPostTemplate(): bool
184			{
185			return in_array($this->template, ['post', 'post:h', 'attachment']);
186			}
187
188			protected function getResolvedPartials(): array
189			{
190			$partials = [];
191			$map = [];
192
193			foreach (static::PARTIALS[$this->template] as $contract => $partial) {
194			if (str_starts_with($partial, '@')) {
195			$inherit = static::PARTIALS[substr($partial, 1)];
196
197			$partials = [...array_values($inherit), ...$partials];
198			$map = $map + array_flip($inherit);
199			} else {
200			$partials[] = $partial;
201			$map[$partial] = $contract;
202			}
203			}
204
205			return $this->isDoingTypeMatch()
206			? $this->matchTraitsToType($partials, $map)
207			: $partials;
208			}
209			}
210

spider-mane / leonidas

Push — master ( 3491f1...e1ceb1 )

ModelPrinter::getResolvedPartials() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like