formatter: line break after opening "if ("

[cweiske]

Which formatter rule is responsible for making adding a line break after the opening ( in an if condition?

-            if (auth()->check()
+            if (
+                auth()->check()
                 && !str_starts_with($request->getPathInfo(), '/nova')
                 && auth()->user()->dynamics_contact_id !== null
             ) {

[Samielakkad]

There is no dedicated ?break after if (? rule for this case. It is the formatter's automatic wrapping triggered by print-width (120 by default). When the complete condition does not fit, the condition's parenthesis group breaks, which puts the first expression on the next line as shown.

You can allow a longer line in mago.toml, for example:

[formatter]
print-width = 140

That will only keep it inline when the whole formatted condition fits within the new width. I do not see a separate setting for the exact style ?keep the first operand beside if ( but break only the later && operands.? preserve-breaking-condition-expression is different: it preserves an existing multiline condition layout rather than choosing that partial-inline style.

[cweiske]

Thank you.

[cweiske]

It turns out I already have preserve-breaking-condition-expression = true in mago.toml set, with a print-width of 100. mago 1.43.0

Details

#:schema https://mago.carthage.software/1.43.0/schema.json
# Welcome to Mago!
# For full documentation, see https://mago.carthage.software/1.43.0/en/tools/overview/
version = "1"
php-version = "8.4.0"

[source]
workspace = "."
paths = ["app/", "database/factories/", "database/seeders/", "tests/"]
includes = ["vendor"]
excludes = []

[source.glob]
literal-separator = true

[formatter]
preset = "psr-12"
print-width = 100

align-assignment-like = true
preserve-breaking-argument-list = true
preserve-breaking-array-like = true
preserve-breaking-attribute-list = true
preserve-breaking-binary-expression = true
preserve-breaking-conditional-expression = true
preserve-breaking-condition-expression = true
preserve-breaking-member-access-chain = true
preserve-breaking-member-access-chain-first-method-on-same-line = true
preserve-breaking-parameter-list = true
preserve-redundant-logical-binary-expression-parentheses = true
space-within-grouping-parenthesis = false
trailing-comma = true

[linter]
integrations = ["symfony", "laravel", "phpunit"]

[linter.rules]
ambiguous-function-call = { enabled = false }
literal-named-argument = { enabled = false }
halstead = { effort-threshold = 7000 }
no-else-clause = { enabled = false }
no-empty = { enabled = false }
no-isset = { enabled = false }
too-many-methods = { enabled = false }
too-many-properties = { enabled = false }

strict-types = { enabled = false }

[analyzer]
plugins = []
find-unused-definitions = true
find-unused-expressions = true
analyze-dead-code = true
memoize-properties = true
allow-possibly-undefined-array-keys = true
check-throws = false
unchecked-exceptions = ["Error", "LogicException"]
unchecked-exception-classes = []
check-missing-override = true
find-unused-parameters = true
strict-list-index-checks = false
strict-array-index-existence = false
allow-array-truthy-operand = false
no-boolean-literal-comparison = false
check-missing-type-hints = true
register-super-globals = true
</details>

[cweiske]

@Samielakkad if the config option is already there, is this a bug?

[Kenneth-Sills]

Seems to be working as-intended, but there's a misalignment of expectations from the name kinda-sorta overpromising.

Mago is still a parse-and-reprint formatter and preserve-breaking-condition-expression only promises that, "when enabled [and existing breaks are detected], each boolean operator goes on its own line." It does not preserve the exact whitespace you use, just that there is some whitespace - of which Mago is opinionated about (see below).

The way this works, is that it checks if you want to preserve breaks. If you do, it checks if there's already a line break between the left paren and the beginning of your conditional expression (in your source). If there is, when it creates the document group, it demands the group contains hard breaks for each group element (L paren, condition, R paren).

Otherwise, the group will automatically detect if a break is needed based on the contents. If it is, the whole group will be broken as well.

So, with your settings, it:

 // Preserves
 if ($foo && $bar)

 // Preserves - even though it should unwrap
 if (
     $foo
     && $bar
 )

 // Does NOT preserve - the wrapping condition expression forces the whole group to hard break.
-if ($foo
+if (
+    $foo
     && $realyLongVariablesThatCause
     && $thisExpressionToExceedLineLimits
 )

 // Does NOT preserve - because `preserve-breaking-binary-expressions` forces the whole group to hard break.
-if ($foo
+if(
+    $foo
     && $bar
 )

Mago's opinionated-ness here comes from PSR-121 itself:

Expressions in parentheses MAY be split across multiple lines, where each subsequent line is indented at least once. When doing so, the first condition MUST be on the next line. The closing parenthesis and opening brace MUST be placed together on their own line with one space between them. Boolean operators between conditions MUST always be at the beginning or at the end of the line, not a mix of both.

So, changing this implementation would make Mago non-compliant with all of its supported presets.

Footnotes

1. Or PER-CS 3.0, if you hadn't specified otherwise. ↩

[cweiske]

thanks!