MontealegreLuis / phuml

src/Parser/Code/ExternalDefinitionsResolver.php

Spacing +7 added lines, -7 removed lines

@@ -25,7 +25,7 @@ 
     {
         /** @var ClassDefinition|InterfaceDefinition|TraitDefinition $definition */
         foreach ($codebase->definitions() as $definition) {
-            match (true) {
+            match(true) {
                 $definition instanceof ClassDefinition => $this->resolveForClass($definition, $codebase),
                 $definition instanceof InterfaceDefinition => $this->resolveInterfaces($definition->parents(), $codebase),
                 default => $this->resolveTraits($definition->traits(), $codebase),
@@ -46,8 +46,8 @@ 
     /** @param Name[] $interfaces */
     private function resolveInterfaces(array $interfaces, Codebase $codebase): void
     {
-        array_map(static function (Name $interface) use ($codebase): void {
-            if (! $codebase->has($interface)) {
+        array_map(static function(Name $interface) use ($codebase): void {
+            if (!$codebase->has($interface)) {
                 $codebase->add(new InterfaceDefinition($interface));
             }
         }, $interfaces);
@@ -56,8 +56,8 @@ 
     /** @param Name[] $traits */
     private function resolveTraits(array $traits, Codebase $codebase): void
     {
-        array_map(static function (Name $trait) use ($codebase): void {
-            if (! $codebase->has($trait)) {
+        array_map(static function(Name $trait) use ($codebase): void {
+            if (!$codebase->has($trait)) {
                 $codebase->add(new TraitDefinition($trait));
             }
         }, $traits);
@@ -65,11 +65,11 @@ 
 
     private function resolveExternalParentClass(ClassDefinition $definition, Codebase $codebase): void
     {
-        if (! $definition->hasParent()) {
+        if (!$definition->hasParent()) {
             return;
         }
         $parent = $definition->parent();
-        if (! $codebase->has($parent)) {
+        if (!$codebase->has($parent)) {
             $codebase->add(new ClassDefinition($parent));
         }
     }

src/Parser/Code/Builders/TagType.php

Spacing +3 added lines, -3 removed lines

@@ -36,7 +36,7 @@ 
 
     public function resolve(UseStatements $useStatements): TypeDeclaration
     {
-        return match (true) {
+        return match(true) {
             $this->isNullable => TypeDeclaration::fromNullable($useStatements->fullyQualifiedNameFor($this->types()[0])),
             count($this->types) === 1 => TypeDeclaration::from($useStatements->fullyQualifiedNameFor($this->types()[0])),
             default => $this->resolveUnionTypes($useStatements),
@@ -46,7 +46,7 @@ 
     private function resolveUnionTypes(UseStatements $useStatements): TypeDeclaration
     {
         $withFullyQualifiedNames = array_map(
-            static fn (Name $type) => $useStatements->fullyQualifiedNameFor($type),
+            static fn(Name $type) => $useStatements->fullyQualifiedNameFor($type),
             $this->types(),
         );
         return TypeDeclaration::fromUnionType($withFullyQualifiedNames);
@@ -55,6 +55,6 @@ 
     /** @return Name[] */
     private function types(): array
     {
-        return array_map(static fn (string $type) => new Name(ltrim($type, characters: '\\')), $this->types);
+        return array_map(static fn(string $type) => new Name(ltrim($type, characters: '\\')), $this->types);
     }
 }

src/Parser/Code/Builders/MembersBuilder.php

Spacing +2 added lines, -2 removed lines

@@ -44,7 +44,7 @@ 
     public function constants(array $members): array
     {
         /** @var ClassConst[] $constants */
-        $constants = array_filter($members, static fn ($attribute): bool => $attribute instanceof ClassConst);
+        $constants = array_filter($members, static fn($attribute): bool => $attribute instanceof ClassConst);
 
         /** @var ClassConst[] $filteredConstants */
         $filteredConstants = $this->filters->apply($constants);
@@ -64,7 +64,7 @@ 
         }
 
         /** @var Property[] $properties */
-        $properties = array_filter($members, static fn ($attribute): bool => $attribute instanceof Property);
+        $properties = array_filter($members, static fn($attribute): bool => $attribute instanceof Property);
 
         /** @var Property[] $filteredAttributes */
         $filteredAttributes = $this->filters->apply($properties);

src/Parser/Code/Builders/Members/ParsedConstantsBuilder.php

Spacing +3 added lines, -3 removed lines

@@ -35,8 +35,8 @@ 
      */
     public function build(array $classConstants): array
     {
-        return array_map(fn (ClassConst $constant): Constant => new Constant(
-            (string) $constant->consts[0]->name,
+        return array_map(fn(ClassConst $constant): Constant => new Constant(
+            (string)$constant->consts[0]->name,
             TypeDeclaration::from($this->determineType($constant->consts[0])),
             $this->visibilityBuilder->build($constant)
         ), $classConstants);
@@ -47,7 +47,7 @@ 
         if (property_exists($constant->value, 'value')) {
             return self::TYPES[\gettype($constant->value->value)];
         }
-        if (! $constant->value instanceof ConstFetch) {
+        if (!$constant->value instanceof ConstFetch) {
             return null;
         }
         return 'bool';

src/Parser/Code/Builders/Members/ParsedAttributesBuilder.php

Spacing +3 added lines, -3 removed lines

@@ -37,7 +37,7 @@ 
      */
     public function build(array $parsedAttributes, UseStatements $useStatements): array
     {
-        return array_map(function (Property $attribute) use ($useStatements): Attribute {
+        return array_map(function(Property $attribute) use ($useStatements): Attribute {
             $variable = new Variable(
                 "\${$attribute->props[0]->name}",
                 $this->typeBuilder->fromAttributeType($attribute->type, $attribute->getDocComment(), $useStatements)
@@ -56,10 +56,10 @@ 
     {
         $promotedProperties = array_filter(
             $constructorParameters,
-            static fn (Node\Param $param) => $param->flags !== 0
+            static fn(Node\Param $param) => $param->flags !== 0
         );
 
-        return array_map(function (Node\Param $param) use ($useStatements): Attribute {
+        return array_map(function(Node\Param $param) use ($useStatements): Attribute {
             /** @var Node\Expr\Variable $var */
             $var = $param->var;
 

src/Parser/Code/Builders/Members/TypeBuilder.php

Spacing +14 added lines, -14 removed lines

@@ -23,18 +23,18 @@ 
     }
 
     public function fromMethodParameter(
-        Identifier|Name|NullableType|UnionType|null $type,
+        Identifier | Name | NullableType | UnionType | null $type,
         ?Doc $docBlock,
         string $name,
         UseStatements $useStatements
     ): TypeDeclaration {
-        $methodComment = $docBlock?->getText();
+        $methodComment = $docBlock ? ->getText();
         if ($type === null) {
             return $this->typeResolver->resolveForParameter($methodComment, $name, $useStatements);
         }
 
         $typeDeclaration = $this->fromParsedType($type);
-        if (! $typeDeclaration->isBuiltInArray()) {
+        if (!$typeDeclaration->isBuiltInArray()) {
             return $typeDeclaration;
         }
 
@@ -44,17 +44,17 @@ 
     }
 
     public function fromMethodReturnType(
-        Identifier|Name|NullableType|UnionType|null $type,
+        Identifier | Name | NullableType | UnionType | null $type,
         ?Doc $docBlock,
         UseStatements $useStatements
     ): TypeDeclaration {
-        $methodComment = $docBlock?->getText();
+        $methodComment = $docBlock ? ->getText();
         if ($type === null) {
             return $this->typeResolver->resolveForReturn($methodComment, $useStatements);
         }
 
         $typeDeclaration = $this->fromParsedType($type);
-        if (! $typeDeclaration->isBuiltInArray()) {
+        if (!$typeDeclaration->isBuiltInArray()) {
             return $typeDeclaration;
         }
 
@@ -64,17 +64,17 @@ 
     }
 
     public function fromAttributeType(
-        Identifier|Name|NullableType|UnionType|null $type,
+        Identifier | Name | NullableType | UnionType | null $type,
         ?Doc $docBlock,
         UseStatements $useStatements
     ): TypeDeclaration {
-        $attributeComment = $docBlock?->getText();
+        $attributeComment = $docBlock ? ->getText();
         if ($type === null) {
             return $this->typeResolver->resolveForAttribute($attributeComment, $useStatements);
         }
 
         $typeDeclaration = $this->fromParsedType($type);
-        if (! $typeDeclaration->isBuiltInArray()) {
+        if (!$typeDeclaration->isBuiltInArray()) {
             return $typeDeclaration;
         }
 
@@ -83,11 +83,11 @@ 
         return $typeFromDocBlock->isPresent() ? $typeFromDocBlock : $typeDeclaration;
     }
 
-    private function fromParsedType(Identifier|Name|NullableType|UnionType|null $type): TypeDeclaration
+    private function fromParsedType(Identifier | Name | NullableType | UnionType | null $type): TypeDeclaration
     {
-        return match (true) {
-            $type instanceof NullableType => TypeDeclaration::fromNullable((string) $type->type),
-            $type instanceof Name, $type instanceof Identifier => TypeDeclaration::from((string) $type),
+        return match(true) {
+            $type instanceof NullableType => TypeDeclaration::fromNullable((string)$type->type),
+            $type instanceof Name, $type instanceof Identifier => TypeDeclaration::from((string)$type),
             $type === null => TypeDeclaration::absent(),
             default => TypeDeclaration::fromUnionType($this->fromUnionType($type)),
         };
@@ -97,7 +97,7 @@ 
     private function fromUnionType(UnionType $type): array
     {
         return array_map(
-            static fn (Identifier|Name $name): string => (string) $name,
+            static fn(Identifier | Name $name): string => (string)$name,
             $type->types
         );
     }

src/Parser/Code/Builders/Members/VisibilityFilters.php

Spacing +1 added lines, -1 removed lines

@@ -43,7 +43,7 @@
     {
         $members = $definitionMembers;
         foreach ($this->filters as $filter) {
-            $members = array_filter($members, static fn (Stmt $member): bool => $filter->accept($member));
+            $members = array_filter($members, static fn(Stmt $member): bool => $filter->accept($member));
         }
         return $members;
     }

src/Parser/Code/Builders/Members/ParsedMethodsBuilder.php

Spacing +2 added lines, -2 removed lines

@@ -36,7 +36,7 @@ 
     public function build(array $methods, UseStatements $useStatements): array
     {
         return array_map(
-            fn (ClassMethod $method): Method => $this->buildMethod($method, $useStatements),
+            fn(ClassMethod $method): Method => $this->buildMethod($method, $useStatements),
             $methods
         );
     }
@@ -48,7 +48,7 @@ 
         $docBlock = $method->getDocComment();
         $returnType = $this->typeBuilder->fromMethodReturnType($method->returnType, $docBlock, $useStatements);
         $parameters = $this->parametersBuilder->build($method->params, $docBlock, $useStatements);
-        return match (true) {
+        return match(true) {
             $method->isAbstract() => new Method($name, $visibility, $returnType, $parameters, isAbstract: true),
             $method->isStatic() => new Method($name, $visibility, $returnType, $parameters, isStatic: true),
             default => new Method($name, $visibility, $returnType, $parameters),

src/Parser/Code/Builders/UseStatementsBuilder.php

Spacing +8 added lines, -8 removed lines

@@ -20,18 +20,18 @@ 
 
 final class UseStatementsBuilder
 {
-    public function build(Class_|Interface_|Trait_ $definition): UseStatements
+    public function build(Class_ | Interface_ | Trait_ $definition): UseStatements
     {
         $uses = [];
 
         $previous = $definition->getAttribute('previous');
         while ($previous instanceof Use_ || $previous instanceof GroupUse) {
             if ($previous instanceof Use_) {
-                $uses[] = array_map(fn (UseUse $use): UseStatement => $this->fromUseStatement($use), $previous->uses);
+                $uses[] = array_map(fn(UseUse $use): UseStatement => $this->fromUseStatement($use), $previous->uses);
             } else {
-                $prefix = (string) $previous->prefix;
+                $prefix = (string)$previous->prefix;
                 $uses[] = array_map(
-                    fn (UseUse $use): UseStatement => $this->fromGroupedUse($use, $prefix),
+                    fn(UseUse $use): UseStatement => $this->fromGroupedUse($use, $prefix),
                     $previous->uses
                 );
             }
@@ -45,17 +45,17 @@ 
     {
         $alias = null;
         if ($use->alias !== null) {
-            $alias = new Name((string) $use->alias);
+            $alias = new Name((string)$use->alias);
         }
-        return new UseStatement(new Name((string) $use->name), $alias);
+        return new UseStatement(new Name((string)$use->name), $alias);
     }
 
     private function fromGroupedUse(UseUse $use, string $prefix): UseStatement
     {
         $alias = null;
         if ($use->alias !== null) {
-            $alias = new Name((string) $use->alias);
+            $alias = new Name((string)$use->alias);
         }
-        return new UseStatement(new Name((string) ParsedName::concat($prefix, $use->name)), $alias);
+        return new UseStatement(new Name((string)ParsedName::concat($prefix, $use->name)), $alias);
     }
 }