802 commits

Author	SHA1	Message	Date
Micha Reiser	30bec3fcfa	Only omit optinal parens if the expression ends or starts with a parenthesized expression ... <!-- Thank you for contributing to Ruff! To help us out with reviewing, please consider the following: - Does this pull request include a summary of the change? (See below.) - Does this pull request include a descriptive title? - Does this pull request include references to any relevant issues? --> ## Summary This PR matches Black' behavior where it only omits the optional parentheses if the expression starts or ends with a parenthesized expression: ```python a + [aaa, bbb, cccc] * c # Don't omit [aaa, bbb, cccc] + a * c # Split a + c * [aaa, bbb, ccc] # Split ``` <!-- What's the purpose of the change? What does it do, and why? --> ## Test Plan This improves the Jaccard index from 0.945 to 0.946	2023-07-11 17:05:25 +02:00
Micha Reiser	8b9193ab1f	Improve comprehension line break beheavior ... <!-- Thank you for contributing to Ruff! To help us out with reviewing, please consider the following: - Does this pull request include a summary of the change? (See below.) - Does this pull request include a descriptive title? - Does this pull request include references to any relevant issues? --> ## Summary This PR improves the Black compatibility when it comes to breaking comprehensions. We want to avoid line breaks before the target and `in` whenever possible. Furthermore, `if X is not None` should be grouped together, similar to other binary like expressions <!-- What's the purpose of the change? What does it do, and why? --> ## Test Plan `cargo test` <!-- How was it tested? -->	2023-07-11 16:51:24 +02:00
konsti	62a24e1028	Format ModExpression (#5689) ... ## Summary We don't use `ModExpression` anywhere but it's part of the AST, removes one `not_implemented_yet` and is a trivial 2-liner, so i implemented formatting for `ModExpression`. ## Test Plan None, this kind of node does not occur in file input. Otherwise all the tests for expressions	2023-07-11 16:41:10 +02:00
Micha Reiser	f1d367655b	Format target: annotation = value? expressions (#5661)	2023-07-11 16:40:28 +02:00
konsti	0c8ec80d7b	Change lambda dummy to NOT_YET_IMPLEMENTED_lambda (#5687) ... This only changes the dummy to be easier to identify.	2023-07-11 13:16:18 +00:00
Micha Reiser	8665a1a19d	Pass FormatContext to NeedsParentheses ... <!-- Thank you for contributing to Ruff! To help us out with reviewing, please consider the following: - Does this pull request include a summary of the change? (See below.) - Does this pull request include a descriptive title? - Does this pull request include references to any relevant issues? --> ## Summary I started working on this because I assumed that I would need access to options inside of `NeedsParantheses` but it then turned out that I won't. Anyway, it kind of felt nice to pass fewer arguments. So I'm gonna put this out here to get your feedback if you prefer this over passing individual fiels. Oh, I sneeked in another change. I renamed `context.contents` to `source`. `contents` is too generic and doesn't tell you anything. <!-- What's the purpose of the change? What does it do, and why? --> ## Test Plan It compiles	2023-07-11 14:28:50 +02:00
Micha Reiser	715250a179	Prefer expanding parenthesized expressions before operands ... <!-- Thank you for contributing to Ruff! To help us out with reviewing, please consider the following: - Does this pull request include a summary of the change? (See below.) - Does this pull request include a descriptive title? - Does this pull request include references to any relevant issues? --> ## Summary This PR implements Black's behavior where it first splits off parenthesized expressions before splitting before operands to avoid unnecessary parentheses: ```python # We want if a + [ b, c ]: pass # Rather than if ( a + [b, c] ): pass ``` This is implemented by using the new IR elements introduced in #5596. * We give the group wrapping the optional parentheses an ID (`parentheses_id`) * We use `conditional_group` for the lower priority groups (all non-parenthesized expressions) with the condition that the `parentheses_id` group breaks (we want to split before operands only if the parentheses are necessary) * We use `fits_expanded` to wrap all other parenthesized expressions (lists, dicts, sets), to prevent that expanding e.g. a list expands the `parentheses_id` group. We gate the `fits_expand` to only apply if the `parentheses_id` group fits (because we prefer `a\n+[b, c]` over expanding `[b, c]` if the whole expression gets parenthesized). We limit using `fits_expanded` and `conditional_group` only to expressions that themselves are not in parentheses (checking the conditions isn't free) ## Test Plan It increases the Jaccard index for Django from 0.915 to 0.917 ## Incompatibilites There are two incompatibilities left that I'm aware of (there may be more, I didn't go through all snapshot differences). ### Long string literals I commented on the regression. The issue is that a very long string (or any content without a split point) may not fit when only breaking the right side. The formatter than inserts the optional parentheses. But this is kind of useless because the overlong string will still not fit, because there are no new split points. I think we should ignore this incompatibility for now ### Expressions on statement level I don't fully understand the logic behind this yet, but black doesn't break before the operators for the following example even though the expression exceeds the configured line width ```python aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa < bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb > ccccccccccccccccccccccccccccc == ddddddddddddddddddddd ``` But it would if the expression is used inside of a condition. What I understand so far is that Black doesn't insert optional parentheses on the expression statement level (and a few other places) and, therefore, only breaks after opening parentheses. I propose to keep this deviation for now to avoid overlong-lines and use the compatibility report to make a decision if we should implement the same behavior.	2023-07-11 14:07:39 +02:00
Micha Reiser	d30e9125eb	Extend formatter IR to support Black's expression formatting (#5596)	2023-07-11 11:20:04 +00:00
konsti	212fd86bf0	Switch from jaccard index to similarity index (#5679) ... ## Summary The similarity index, the fraction of unchanged lines, is easier to understand than the jaccard index, the fraction between intersection and union. ## Test Plan I ran this on django and git a 0.945 index, meaning 5.5% of lines are currently reformatted when compared to black	2023-07-11 13:03:44 +02:00
David Szotten	4b58a9c092	formatter: tidy: list_comp is an expression, not a statement (#5677)	2023-07-11 08:00:10 +00:00
konsti	b7794f855b	Format StmtAugAssign (#5655) ... ## Summary Format statements such as `tree_depth += 1`. This is a statement that does not allow any line breaks, the only thing to be mindful of is to parenthesize the assigned expression Jaccard index on django: 0.915 -> 0.918 ## Test Plan black tests, and two new tests, a basic one and one that ensures that the child gets parentheses. I ran the django stability check.	2023-07-11 09:06:23 +02:00
Chris Pryer	15c7b6bcf7	Format delete statement (#5169)	2023-07-11 08:36:26 +02:00
David Szotten	1782fb8c30	format ExprListComp (#5600) ... Co-authored-by: Micha Reiser <micha@reiser.io>	2023-07-11 06:35:51 +00:00
Micha Reiser	987111f5fb	Format ExpressionStarred nodes (#5654)	2023-07-11 06:08:08 +00:00
Charlie Marsh	4dee49d6fa	Run nightly Clippy over the Ruff repo (#5670) ... ## Summary This is the result of running `cargo +nightly clippy --workspace --all-targets --all-features -- -D warnings` and fixing all violations. Just wanted to see if there were any interesting new checks on nightly 👀	2023-07-10 23:44:38 -04:00
Louis Dispa	e7e2f44440	Format raise statement (#5595) ... ## Summary This PR implements the formatting of `raise` statements. I haven't looked at the black implementation, this is inspired from from the `return` statements formatting. ## Test Plan The black differences with insta. I also compared manually some edge cases with very long string and call chaining and it seems to do the same formatting as black. There is one issue: ```python # input raise OsError( "aksjdhflsakhdflkjsadlfajkslhfdkjsaldajlahflashdfljahlfksajlhfajfjfsaahflakjslhdfkjalhdskjfa" ) from a.aaaaa(aksjdhflsakhdflkjsadlfajkslhfdkjsaldajlahflashdfljahlfksajlhfajfjfsaahflakjslhdfkjalhdskjfa).a(aaaa) # black raise OsError( "aksjdhflsakhdflkjsadlfajkslhfdkjsaldajlahflashdfljahlfksajlhfajfjfsaahflakjslhdfkjalhdskjfa" ) from a.aaaaa( aksjdhflsakhdflkjsadlfajkslhfdkjsaldajlahflashdfljahlfksajlhfajfjfsaahflakjslhdfkjalhdskjfa ).a( aaaa ) # ruff raise OsError( "aksjdhflsakhdflkjsadlfajkslhfdkjsaldajlahflashdfljahlfksajlhfajfjfsaahflakjslhdfkjalhdskjfa" ) from a.aaaaa( aksjdhflsakhdflkjsadlfajkslhfdkjsaldajlahflashdfljahlfksajlhfajfjfsaahflakjslhdfkjalhdskjfa ).a(aaaa) ``` But I'm not sure this diff is the raise formatting implementation. --------- Co-authored-by: Louis Dispa <ldispa@deezer.com>	2023-07-10 21:23:49 +02:00
konsti	cab3a507bc	Fix find_only_token_in_range with expression parentheses (#5645) ... ## Summary Fix an oversight in `find_only_token_in_range` where the following code would panic due do the closing and opening parentheses being in the range we scan: ```python d1 = [ ("a") if # 1 ("b") else # 2 ("c") ] ``` Closing and opening parentheses respectively are now correctly skipped. ## Test Plan I added a regression test	2023-07-10 15:55:19 +02:00
Micha Reiser	089a671adb	Fix Black compatible snapshot deletion (#5646)	2023-07-10 15:00:18 +02:00
konsti	bd8f65814c	Format named expressions (walrus operator) (#5642) ... ## Summary Format named expressions (walrus operator) such a `value := f()`. Unlike tuples, named expression parentheses are not part of the range even when mandatory, so mapping optional parentheses to always gives us decent formatting without implementing all [PEP 572](https://peps.python.org/pep-0572/) rules on when we need parentheses where other expressions wouldn't. We might want to revisit this decision later and implement special cases, but for now this gives us what we need. ## Test Plan black fixtures, i added some fixtures and checked django and cpython for stability. Closes #5613	2023-07-10 12:32:15 +00:00
David Szotten	1e894f328c	formatter: multi char tokens in SimpleTokenizer (#5610)	2023-07-10 09:00:59 +01:00
Dimitri Papadopoulos Orfanos	efe7c393d1	Fix typos found by codespell (#5607) ... <!-- Thank you for contributing to Ruff! To help us out with reviewing, please consider the following: - Does this pull request include a summary of the change? (See below.) - Does this pull request include a descriptive title? - Does this pull request include references to any relevant issues? --> ## Summary Fix typos found by [codespell](https://github.com/codespell-project/codespell). I have left out `memoize` for now (see #5606). <!-- What's the purpose of the change? What does it do, and why? --> ## Test Plan CI tests. <!-- How was it tested? -->	2023-07-08 12:33:18 +02:00
konsti	0b9af031fb	Format ExprIfExp (ternary operator) (#5597) ... ## Summary Format `ExprIfExp`, also known as the ternary operator or inline `if`. It can look like ```python a1 = 1 if True else 2 ``` but also ```python b1 = ( # We return "a" ... "a" # that's our True value # ... if this condition matches ... if True # that's our test # ... otherwise we return "b§ else "b" # that's our False value ) ``` This also fixes a visitor order bug. The jaccard index on django goes from 0.911 to 0.915. ## Test Plan I added fixtures without and with comments in strange places.	2023-07-07 19:11:52 +00:00
konsti	0f9d7283e7	Add format-dev contributor docs (#5594) ... ## Summary This adds markdown-level docs for #5492 ## Test Plan n/a --------- Co-authored-by: Micha Reiser <micha@reiser.io>	2023-07-07 16:52:13 +00:00
konsti	b22e6c3d38	Extend ruff_dev formatter script to compute statistics and format a project (#5492) ... ## Summary This extends the `ruff_dev` formatter script util. Instead of only doing stability checks, you can now choose different compatible options on the CLI and get statistics. * It adds an option the formats all files that ruff would check to allow looking at an entire black-formatted repository with `git diff` * It computes the [Jaccard index](https://en.wikipedia.org/wiki/Jaccard_index) as a measure of deviation between input and output, which is useful as single number metric for assessing our current deviations from black. * It adds progress bars to both the single projects as well as the multi-project mode. * It adds an option to write the multi-project output to a file Sample usage: ``` $ cargo run --bin ruff_dev -- format-dev --stability-check crates/ruff/resources/test/cpython $ cargo run --bin ruff_dev -- format-dev --stability-check /home/konsti/projects/django Syntax error in /home/konsti/projects/django/tests/test_runner_apps/tagged/tests_syntax_error.py: source contains syntax errors (parser error): BaseError { error: UnrecognizedToken(Name { name: "syntax_error" }, None), offset: 131, source_path: "<filename>" } Found 0 stability errors in 2755 files (jaccard index 0.911) in 9.75s $ cargo run --bin ruff_dev -- format-dev --write /home/konsti/projects/django ``` Options: ``` Several utils related to the formatter which can be run on one or more repositories. The selected set of files in a repository is the same as for `ruff check`. * Check formatter stability: Format a repository twice and ensure that it looks that the first and second formatting look the same. * Format: Format the files in a repository to be able to check them with `git diff` * Statistics: The subcommand the Jaccard index between the (assumed to be black formatted) input and the ruff formatted output Usage: ruff_dev format-dev [OPTIONS] [FILES]... Arguments: [FILES]... Like `ruff check`'s files. See `--multi-project` if you want to format an ecosystem checkout Options: --stability-check Check stability We want to ensure that once formatted content stays the same when formatted again, which is known as formatter stability or formatter idempotency, and that the formatter prints syntactically valid code. As our test cases cover only a limited amount of code, this allows checking entire repositories. --write Format the files. Without this flag, the python files are not modified --format <FORMAT> Control the verbosity of the output [default: default] Possible values: - minimal: Filenames only - default: Filenames and reduced diff - full: Full diff and invalid code -x, --exit-first-error Print only the first error and exit, `-x` is same as pytest --multi-project Checks each project inside a directory, useful e.g. if you want to check all of the ecosystem checkouts --error-file <ERROR_FILE> Write all errors to this file in addition to stdout. Only used in multi-project mode ``` ## Test Plan I ran this on django (2755 files, jaccard index 0.911) and discovered a magic trailing comma problem and that we really needed to implement import formatting. I ran the script on cpython to identify https://github.com/astral-sh/ruff/pull/5558.	2023-07-07 11:30:12 +00:00
Micha Reiser	40ddc1604c	Introduce parenthesized helper (#5565)	2023-07-07 11:28:25 +02:00
konsti	5e5a96ca28	Fix formatter StmtTry test (#5568) ... For some reason this didn't turn up on CI before CC @michareiser this is the fix for the error you had	2023-07-06 18:23:53 +00:00
konsti	8184235f93	Try statements have a body: Fix formatter instability (#5558) ... ## Summary The following code was previously leading to unstable formatting: ```python try: try: pass finally: print(1) # issue7208 except A: pass ``` The comment would be formatted as a trailing comment of `try` which is unstable as an end-of-line comment gets two extra whitespaces. This was originally found in 99b00efd5e/Lib/getpass.py (L68-L91) ## Test Plan I added a regression test	2023-07-06 16:07:47 +02:00
konsti	787e2fd49d	Format import statements (#5493) ... ## Summary Format import statements in all their variants. Specifically, this implemented formatting `StmtImport`, `StmtImportFrom` and `Alias`. ## Test Plan I added some custom snapshots, even though this has been covered well by black's tests.	2023-07-04 07:07:20 +00:00
konsti	a647f31600	Don't add a magic trailing comma for a single entry (#5463) ... ## Summary If a comma separated list has only one entry, black will respect the magic trailing comma, but it will not add a new one. The following code will remain as is: ```python b1 = [ aksjdhflsakhdflkjsadlfajkslhfdkjsaldajlahflashdfljahlfksajlhfajfjfsaahflakjslhdfkjalhdskjfa ] b2 = [ aksjdhflsakhdflkjsadlfajkslhfdkjsaldajlahflashdfljahlfksajlhfajfjfsaahflakjslhdfkjalhdskjfa, ] b3 = [ aksjdhflsakhdflkjsadlfajkslhfdkjsaldajlahflashdfljahlfksajlhfajfjfsaahflakjslhdfkjalhdskjfa, aksjdhflsakhdflkjsadlfajkslhfdkjsaldajlahflashdfljahlfksajlhfajfjfsaahflakjslhdfkjalhdskjfa ] ``` ## Test Plan This was first discovered in 7eeadc82c2/django/contrib/admin/checks.py (L674-L681), which i've minimized into a call test. I've added tests for the three cases (one entry + no comma, one entry + comma, more than one entry) to the list tests. The diffs from the black tests get smaller.	2023-07-03 21:48:44 +02:00
Louis Dispa	dc072537e5	Fix python_formatter generate.py with rust path (#5475) ... ## Summary This PR fix an issue with the `generate.py` file of the python formatter. Since https://github.com/astral-sh/ruff/pull/5369 the [node.rs file](f51dc20497/crates/ruff_python_ast/src/node.rs) used to generate the types now has `ast::` in the enum. ```rust pub enum AnyNode { ModModule(ModModule), ModInteractive(ModInteractive), ModExpression(ModExpression), ModFunctionType(ModFunctionType), ... ``` And now: ```rust pub enum AnyNode { ModModule(ast::ModModule), ModInteractive(ast::ModInteractive), ModExpression(ast::ModExpression), ModFunctionType(ast::ModFunctionType), ... ``` The python script was not parsing rust paths. This PR adds the possibility to have it. ## Test Plan This was tested locally. ### Script output Before ``` ['ast::ModModule),', 'ast::ModInteractive),', 'ast::ModExpression),', 'ast::ModFunctionType),', 'ast::StmtFunctionDef),', 'ast::StmtAsyncFunctionDef),', 'ast::StmtClassDef),', 'ast::StmtReturn),', 'ast::StmtDelete),', 'ast::StmtAssign),', 'ast::StmtAugAssign),', 'ast::StmtAnnAssign),', 'ast::StmtFor),', 'ast::StmtAsyncFor),', 'ast::StmtWhile),', 'ast::StmtIf),', 'ast::StmtWith),', 'ast::StmtAsyncWith),', 'ast::StmtMatch),', 'ast::StmtRaise),', 'ast::StmtTry),', 'ast::StmtTryStar),', 'ast::StmtAssert),', 'ast::StmtImport),', 'ast::StmtImportFrom),', 'ast::StmtGlobal),', 'ast::StmtNonlocal),', 'ast::StmtExpr),', 'ast::StmtPass),', 'ast::StmtBreak),', 'ast::StmtContinue),', 'ast::ExprBoolOp),', 'ast::ExprNamedExpr),', 'ast::ExprBinOp),', 'ast::ExprUnaryOp),', 'ast::ExprLambda),', 'ast::ExprIfExp),', 'ast::ExprDict),', 'ast::ExprSet),', 'ast::ExprListComp),', 'ast::ExprSetComp),', 'ast::ExprDictComp),', 'ast::ExprGeneratorExp),', 'ast::ExprAwait),', 'ast::ExprYield),', 'ast::ExprYieldFrom),', 'ast::ExprCompare),', 'ast::ExprCall),', 'ast::ExprFormattedValue),', 'ast::ExprJoinedStr),', 'ast::ExprConstant),', 'ast::ExprAttribute),', 'ast::ExprSubscript),', 'ast::ExprStarred),', 'ast::ExprName),', 'ast::ExprList),', 'ast::ExprTuple),', 'ast::ExprSlice),', 'ast::ExceptHandlerExceptHandler),', 'ast::PatternMatchValue),', 'ast::PatternMatchSingleton),', 'ast::PatternMatchSequence),', 'ast::PatternMatchMapping),', 'ast::PatternMatchClass),', 'ast::PatternMatchStar),', 'ast::PatternMatchAs),', 'ast::PatternMatchOr),', 'ast::TypeIgnoreTypeIgnore),', 'Comprehension),', 'Arguments),', 'Arg),', 'ArgWithDefault),', 'Keyword),', 'Alias),', 'WithItem),', 'MatchCase),', 'Decorator),'] error: unexpected closing delimiter: `)` --> <stdin>:3:55 | 2 | use ruff_formatter::{write, Buffer, FormatResult}; | - this opening brace... - ...matches this closing brace 3 | use rustpython_parser::ast::ast::ModModule),; | ^ unexpected closing delimiter Traceback (most recent call last): File "/Users/ldispa/Documents/perso/ruff/crates/ruff_python_formatter/generate.py", line 100, in <module> node_path.write_text(rustfmt(code)) ^^^^^^^^^^^^^ File "/Users/ldispa/Documents/perso/ruff/crates/ruff_python_formatter/generate.py", line 12, in rustfmt return check_output(["rustfmt", "--emit=stdout"], input=code, text=True) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/opt/homebrew/Cellar/python@3.11/3.11.4_1/Frameworks/Python.framework/Versions/3.11/lib/python3.11/subprocess.py", line 466, in check_output return run(*popenargs, stdout=PIPE, timeout=timeout, check=True, ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/opt/homebrew/Cellar/python@3.11/3.11.4_1/Frameworks/Python.framework/Versions/3.11/lib/python3.11/subprocess.py", line 571, in run raise CalledProcessError(retcode, process.args, subprocess.CalledProcessError: Command '['rustfmt', '--emit=stdout']' returned non-zero exit status 1. ``` After: ``` ['ModModule', 'ModInteractive', 'ModExpression', 'ModFunctionType', 'StmtFunctionDef', 'StmtAsyncFunctionDef', 'StmtClassDef', 'StmtReturn', 'StmtDelete', 'StmtAssign', 'StmtAugAssign', 'StmtAnnAssign', 'StmtFor', 'StmtAsyncFor', 'StmtWhile', 'StmtIf', 'StmtWith', 'StmtAsyncWith', 'StmtMatch', 'StmtRaise', 'StmtTry', 'StmtTryStar', 'StmtAssert', 'StmtImport', 'StmtImportFrom', 'StmtGlobal', 'StmtNonlocal', 'StmtExpr', 'StmtPass', 'StmtBreak', 'StmtContinue', 'ExprBoolOp', 'ExprNamedExpr', 'ExprBinOp', 'ExprUnaryOp', 'ExprLambda', 'ExprIfExp', 'ExprDict', 'ExprSet', 'ExprListComp', 'ExprSetComp', 'ExprDictComp', 'ExprGeneratorExp', 'ExprAwait', 'ExprYield', 'ExprYieldFrom', 'ExprCompare', 'ExprCall', 'ExprFormattedValue', 'ExprJoinedStr', 'ExprConstant', 'ExprAttribute', 'ExprSubscript', 'ExprStarred', 'ExprName', 'ExprList', 'ExprTuple', 'ExprSlice', 'ExceptHandlerExceptHandler', 'PatternMatchValue', 'PatternMatchSingleton', 'PatternMatchSequence', 'PatternMatchMapping', 'PatternMatchClass', 'PatternMatchStar', 'PatternMatchAs', 'PatternMatchOr', 'TypeIgnoreTypeIgnore', 'Comprehension', 'Arguments', 'Arg', 'ArgWithDefault', 'Keyword', 'Alias', 'WithItem', 'MatchCase', 'Decorator'] ```	2023-07-03 16:07:57 +02:00
konsti	7ac9e0252e	Document Checking formatter stability and panics (#5415) ... This adds the documentation, but ideally we should add the CI first	2023-07-03 11:22:19 +02:00
konsti	ca6ff72404	Change generator formatting dummy to include NOT_YET_IMPLEMENTED (#5464) ... ## Summary Change generator formatting dummy to include `NOT_YET_IMPLEMENTED`. This makes it easier to correctly identify them as dummies ## Test Plan This is a dummy change	2023-07-03 09:11:14 +02:00
Anders Kaseorg	df13e69c3c	Format let-else with rustfmt nightly (#5461) ... Support for `let…else` formatting was just merged to nightly (rust-lang/rust#113225). Rerun `cargo fmt` with Rust nightly 2023-07-02 to pick this up. Followup to #939. Signed-off-by: Anders Kaseorg <andersk@mit.edu>	2023-07-03 02:13:35 +00:00
Micha Reiser	f9129e435a	Normalize '\r' in string literals to '\n' ... <!-- Thank you for contributing to Ruff! To help us out with reviewing, please consider the following: - Does this pull request include a summary of the change? (See below.) - Does this pull request include a descriptive title? - Does this pull request include references to any relevant issues? --> ## Summary This PR normalizes line endings inside of strings to `\n` as required by the printer. <!-- What's the purpose of the change? What does it do, and why? --> ## Test Plan I added a new test using `\r\n` and ran the ecosystem check. There are no remaining end of line panics. https://gist.github.com/MichaReiser/8f36b1391ca7b48475b3a4f592d74ff4 <!-- How was it tested? -->	2023-06-30 10:13:23 +02:00
Micha Reiser	9c2a75284b	Preserve parentheses around left side of binary expression ... <!-- Thank you for contributing to Ruff! To help us out with reviewing, please consider the following: - Does this pull request include a summary of the change? (See below.) - Does this pull request include a descriptive title? - Does this pull request include references to any relevant issues? --> ## Summary This PR fixes an issue where the binary expression formatting removed parentheses around the left hand side of an expression. <!-- What's the purpose of the change? What does it do, and why? --> ## Test Plan I added a new regression test and re-ran the ecosystem check. It brings down the `check-formatter-stability` output from a 3.4MB file down to 900KB. <!-- How was it tested? -->	2023-06-30 09:52:14 +02:00
Micha Reiser	ae25638b0b	Update Black tests (#5438)	2023-06-30 06:32:50 +00:00
Micha Reiser	955e9ef821	Fix invalid syntax for binary expression in unary op (#5370)	2023-06-29 08:09:26 +02:00
Micha Reiser	38189ed913	Fix invalid printer IR error (#5422)	2023-06-29 08:09:13 +02:00
David Szotten	ca5e10b5ea	format StmtTryStar (#5418)	2023-06-29 08:07:33 +02:00
David Szotten	c7adb9117f	format StmtAsyncWith (#5376) ... Co-authored-by: Micha Reiser <micha@reiser.io>	2023-06-28 10:21:44 +00:00
David Szotten	1979103ec0	Format StmtTry (#5222) ... Co-authored-by: Micha Reiser <micha@reiser.io>	2023-06-28 10:02:15 +00:00
konstin	7f6cb9dfb5	Format call expressions (without call chaining) (#5341) ... ## Summary This formats call expressions with magic trailing comma and parentheses behaviour but without call chaining ## Test Plan Lots of new test fixtures, including some that don't work yet	2023-06-27 09:29:40 +00:00
David Szotten	50a7769d69	magic trailing comma for ExprList (#5365)	2023-06-26 21:59:01 +02:00
Charlie Marsh	fa1b85b3da	Remove prelude from ruff_python_ast (#5369) ... ## Summary Per @MichaReiser, this is causing more confusion than it is helpful.	2023-06-26 11:43:49 -04:00
David Szotten	d00559e42a	format StmtWith (#5350)	2023-06-26 15:09:06 +01:00
Micha Reiser	49cabca3e7	Format implicit string continuation (#5328)	2023-06-26 12:41:47 +00:00
Micha Reiser	313711aaf9	Prefer the configured quote style ... <!-- Thank you for contributing to Ruff! To help us out with reviewing, please consider the following: - Does this pull request include a summary of the change? (See below.) - Does this pull request include a descriptive title? - Does this pull request include references to any relevant issues? --> ## Summary This PR extends the string formatting to respect the configured quote style. <!-- What's the purpose of the change? What does it do, and why? --> ## Test Plan Extended the string test with new cases and set it up to run twice: Once with the `quote_style: Doube`, and once with `quote_style: Single` single and double quotes. <!-- How was it tested? -->	2023-06-26 14:24:25 +02:00
Micha Reiser	f18a1f70de	Add tests for skip magic trailing comma ... <!-- Thank you for contributing to Ruff! To help us out with reviewing, please consider the following: - Does this pull request include a summary of the change? (See below.) - Does this pull request include a descriptive title? - Does this pull request include references to any relevant issues? --> ## Summary This PR adds tests that verify that the magic trailing comma is not respected if disabled in the formatter options. Our test setup now allows to create a `<fixture-name>.options.json` file that contains an array of configurations that should be tested. <!-- What's the purpose of the change? What does it do, and why? --> ## Test Plan It's all about tests :) <!-- How was it tested? -->	2023-06-26 14:15:55 +02:00
Micha Reiser	dd0d1afb66	Create PyFormatOptions ... <!-- Thank you for contributing to Ruff! To help us out with reviewing, please consider the following: - Does this pull request include a summary of the change? (See below.) - Does this pull request include a descriptive title? - Does this pull request include references to any relevant issues? --> ## Summary This PR adds a new `PyFormatOptions` struct that stores the python formatter options. The new options aren't used yet, with the exception of magical trailing commas and the options passed to the printer. I'll follow up with more PRs that use the new options (e.g. `QuoteStyle`). <!-- What's the purpose of the change? What does it do, and why? --> ## Test Plan `cargo test` I'll follow up with a new PR that adds support for overriding the options in our fixture tests.	2023-06-26 14:02:17 +02:00
konstin	a52cd47c7f	Fix attribute chain own line comments (#5340) ... ## Motation Previously, ```python x = ( a1 .a2 # a . # b # c a3 ) ``` got formatted as ```python x = a1.a2 # a . # b # c a3 ``` which is invalid syntax. This fixes that. ## Summary This implements a basic form of attribute chaining (<https://black.readthedocs.io/en/stable/the_black_code_style/current_style.html#call-chains>) by checking if any inner attribute access contains an own line comment, and if this is the case, adds parentheses around the outermost attribute access while disabling parentheses for all inner attribute expressions. We want to replace this with an implementation that uses recursion or a stack while formatting instead of in `needs_parentheses` and also includes calls rather sooner than later, but i'm fixing this now because i'm uncomfortable with having known invalid syntax generation in the formatter. ## Test Plan I added new fixtures.	2023-06-26 09:13:07 +00:00