braces-position
***************

.[perex]
Otevírací složená závorka stojí u tříd a funkcí na vlastním řádku a u řídicích struktur, closures a anonymních tříd na řádku hlavičky; tělo začíná na novém řádku a zavírací závorka má řádek pro sebe.

Opravuje · v presetech `dresscode/per`, `dresscode/psr12`, `dresscode/nette` · pokrývá `Nette/braces_position`, `braces_position`, `PSR2.Classes.ClassDeclaration`, `Squiz.Functions.MultiLineFunctionDeclaration` .[rule-info]


Co pravidlo hlídá
=================

Kam patří `{`, je nejviditelnější rozhodnutí každého stylu a zároveň to, na kterém se styly nejčastěji rozcházejí. Pravidlo má pro každý druh konstrukce volbu: třídy, rozhraní, traity a výčty (`classes`), anonymní třídy, anonymní funkce a řídicí struktury. Výchozí hodnoty jsou ty z PSR-12 a PER: deklarace mají závorku na dalším řádku, všechno ostatní na témže. Pro funkci s parametry na několika řádcích rozhoduje `multiLineParameters`, protože tam PER a některé domácí styly říkají každý něco jiného.

Vedle otevírací závorky pravidlo hlídá, že za ní tělo začíná na novém řádku a že zavírací závorka stojí na řádku sama. Výjimky jsou tři a každá má volbu: closure napsaná celá na jednom řádku (`allowSingleLineAnonymousFunctions`), prázdná anonymní třída jako `{}` (`emptyAnonymousClasses`) a prázdné tělo třídy nebo funkce jako `{}` (`emptyBodies`). Property hooky mají závorku na řádku vlastnosti a zkrácený zápis `{ get; set; }` zůstává; rozepsané hooky mají každý svůj řádek.

Pravidlo přesouvá jen závorky. Kde pak řádek stojí, tedy jeho odsazení, je věc pravidla `indentation`.


Příklad
=======

```php .[before]
class Cart {  // A line break before the opening brace
	public function add(Item $item): void {  // A line break before the opening brace
		if ($item->isFree())
		{  // No line break before the opening brace
			return;
		}
		$this->items[] = $item;
	}
}
```

```php .[after]
class Cart
{
	public function add(Item $item): void
	{
		if ($item->isFree()) {
			return;
		}
		$this->items[] = $item;
	}
}
```


Volby
=====


multiLineParameters .[option]
-----------------------------

`sameLine`, `nextLine` nebo `nextLineAfterReturnType`, výchozí `sameLine`. Kam jde závorka funkce, jejíž parametry zabírají několik řádků: hned za zavírací kulatou závorku (PER), na další řádek, nebo na další řádek jen tehdy, když má funkce návratový typ. Poslední hodnotu používá preset `dresscode/nette`: bez návratového typu by závorka na vlastním řádku vypadala jako `) {` bez důvodu, s ním by `): void {` schovala typ na konec řádku.

```neon
rules:
	dresscode/braces-position:
		multiLineParameters: nextLineAfterReturnType
```

```php .[before]
function send(
	string $to,
	string $subject,
): void {  // A line break before the opening brace
	mail($to, $subject);
}

function log(
	string $message,
)
{  // No line break before the opening brace
	echo $message;
}
```

```php .[after]
function send(
	string $to,
	string $subject,
): void
{
	mail($to, $subject);
}

function log(
	string $message,
) {
	echo $message;
}
```


classes .[option]
-----------------

`sameLine` nebo `nextLine`, výchozí `nextLine`. Třídy, rozhraní, traity a výčty.

```neon
rules:
	dresscode/braces-position:
		classes: sameLine
```

```php .[before]
class Cart
{  // No line break before the opening brace
	private array $items = [];
}
```

```php .[after]
class Cart {
	private array $items = [];
}
```


anonymousClasses .[option]
--------------------------

`sameLine` nebo `nextLine`, výchozí `sameLine`.

```neon
rules:
	dresscode/braces-position:
		anonymousClasses: nextLine
```

```php .[before]
$logger = new class implements Logger {  // A line break before the opening brace
	public function log(string $message): void
	{
		echo $message;
	}
};
```

```php .[after]
$logger = new class implements Logger
{
	public function log(string $message): void
	{
		echo $message;
	}
};
```


anonymousFunctions .[option]
----------------------------

`sameLine` nebo `nextLine`, výchozí `sameLine`.

```neon
rules:
	dresscode/braces-position:
		anonymousFunctions: nextLine
```

```php .[before]
$double = function (int $x) {  // A line break before the opening brace
	return $x * 2;
};
```

```php .[after]
$double = function (int $x)
{
	return $x * 2;
};
```


controlStructures .[option]
---------------------------

`sameLine` nebo `nextLine`, výchozí `sameLine`. Podmínky, cykly, `switch`, `match`, `try` a jejich pokračování.

```neon
rules:
	dresscode/braces-position:
		controlStructures: nextLine
```

```php .[before]
if ($ready) {  // A line break before the opening brace
	start();
}
```

```php .[after]
if ($ready)
{
	start();
}
```


allowSingleLineAnonymousFunctions .[option]
-------------------------------------------

`bool`, výchozí `true`. Closure napsaná celá na jednom řádku smí tak zůstat. Presety `dresscode/psr12` a `dresscode/per` to zakazují, protože PSR-12 chce tělo každé closure na vlastních řádcích.

```neon
rules:
	dresscode/braces-position:
		allowSingleLineAnonymousFunctions: false
```

```php .[before]
$ids = array_map(function ($row) { return $row->id; }, $rows);  // A line break after the opening brace // A line break before the closing brace
```

```php .[after]
$ids = array_map(function ($row) {
	return $row->id;
}, $rows);
```


emptyAnonymousClasses .[option]
-------------------------------

`sameLine` nebo `ownLine`, výchozí `sameLine`. Prázdná anonymní třída se zapíše jako `{}` na řádku `new`, ať `emptyBodies` říká cokoli; `ownLine` dá zavírací závorku na vlastní řádek.

```neon
rules:
	dresscode/braces-position:
		emptyAnonymousClasses: ownLine
```

```php .[before]
$marker = new class {};  // A line break after the opening brace
```

```php .[after]
$marker = new class {
};
```


emptyBodies .[option]
---------------------

`sameLine` nebo `ownLine`, výchozí `ownLine`. Prázdné tělo třídy, funkce, metody nebo closure: buď `{}` na řádku hlavičky, nebo otevírací a zavírací závorka každá na svém řádku. Komentář uvnitř dělá z těla neprázdné. Preset `dresscode/per` nastavuje `sameLine`, protože PER 2.0 prázdná těla zkracuje.

```neon
rules:
	dresscode/braces-position:
		emptyBodies: sameLine
```

```php .[before]
class NotFound extends Exception
{  // No line break before the opening brace
}  // No line break before the closing brace

class Point
{
	public function __construct(private int $x, private int $y)
	{  // No line break before the opening brace
	}  // No line break before the closing brace
}
```

```php .[after]
class NotFound extends Exception {}

class Point
{
	public function __construct(private int $x, private int $y) {}
}
```


Související pravidla
====================

- `indentation` odsadí řádky, které tohle pravidlo otevřelo
- `control-structure-braces` doplní závorky kolem těla řídicí struktury, které je nemá
- `continuation-position` umístí `else`, `catch` a `finally` k zavírací závorce


Zdroj
=====

Třída "BracesPositionRule":https://github.com/dg/dresscode/blob/master/src/DressCode/Rules/Whitespace/BracesPositionRule.php, fixtury "braces-position":https://github.com/dg/dresscode/tree/master/tests/DressCode/Rules/fixtures/braces-position.