Disable string splitting/merging by default (#1609)
* put experimental string stuff behind a flag * update tests * don't need an output section if it's the same as the input * Primer: Expect no formatting changes in attrs, hypothesis and poetry with --experimental-string-processing off Co-authored-by: Hugo van Kemenade <hugovk@users.noreply.github.com>
This commit is contained in:
Jelle Zijlstra
GitHub
parent
e1027e2bee
commit
e5bb92f53c
@ -240,6 +240,7 @@ class Mode:
|
||||
target_versions: Set[TargetVersion] = field(default_factory=set)
|
||||
line_length: int = DEFAULT_LINE_LENGTH
|
||||
string_normalization: bool = True
|
||||
experimental_string_processing: bool = False
|
||||
is_pyi: bool = False
|
||||
|
||||
def get_cache_key(self) -> str:
|
||||
@ -376,6 +377,15 @@ def target_version_option_callback(
|
||||
is_flag=True,
|
||||
help="Don't normalize string quotes or prefixes.",
|
||||
)
|
||||
@click.option(
|
||||
"--experimental-string-processing",
|
||||
is_flag=True,
|
||||
hidden=True,
|
||||
help=(
|
||||
"Experimental option that performs more normalization on string literals."
|
||||
" Currently disabled because it leads to some crashes."
|
||||
),
|
||||
)
|
||||
@click.option(
|
||||
"--check",
|
||||
is_flag=True,
|
||||
@ -485,6 +495,7 @@ def main(
|
||||
fast: bool,
|
||||
pyi: bool,
|
||||
skip_string_normalization: bool,
|
||||
experimental_string_processing: bool,
|
||||
quiet: bool,
|
||||
verbose: bool,
|
||||
include: str,
|
||||
@ -505,6 +516,7 @@ def main(
|
||||
line_length=line_length,
|
||||
is_pyi=pyi,
|
||||
string_normalization=not skip_string_normalization,
|
||||
experimental_string_processing=experimental_string_processing,
|
||||
)
|
||||
if config and verbose:
|
||||
out(f"Using configuration from {config}.", bold=False, fg="blue")
|
||||
@ -984,10 +996,7 @@ def f(
|
||||
before, after = elt.maybe_empty_lines(current_line)
|
||||
dst_contents.append(str(empty_line) * before)
|
||||
for line in transform_line(
|
||||
current_line,
|
||||
line_length=mode.line_length,
|
||||
normalize_strings=mode.string_normalization,
|
||||
features=split_line_features,
|
||||
current_line, mode=mode, features=split_line_features
|
||||
):
|
||||
dst_contents.append(str(line))
|
||||
return "".join(dst_contents)
|
||||
@ -2649,10 +2658,7 @@ def make_comment(content: str) -> str:
|
||||
|
||||
|
||||
def transform_line(
|
||||
line: Line,
|
||||
line_length: int,
|
||||
normalize_strings: bool,
|
||||
features: Collection[Feature] = (),
|
||||
line: Line, mode: Mode, features: Collection[Feature] = ()
|
||||
) -> Iterator[Line]:
|
||||
"""Transform a `line`, potentially splitting it into many lines.
|
||||
|
||||
@ -2668,7 +2674,7 @@ def transform_line(
|
||||
|
||||
def init_st(ST: Type[StringTransformer]) -> StringTransformer:
|
||||
"""Initialize StringTransformer"""
|
||||
return ST(line_length, normalize_strings)
|
||||
return ST(mode.line_length, mode.string_normalization)
|
||||
|
||||
string_merge = init_st(StringMerger)
|
||||
string_paren_strip = init_st(StringParenStripper)
|
||||
@ -2681,21 +2687,26 @@ def init_st(ST: Type[StringTransformer]) -> StringTransformer:
|
||||
and not line.should_explode
|
||||
and not line.is_collection_with_optional_trailing_comma
|
||||
and (
|
||||
is_line_short_enough(line, line_length=line_length, line_str=line_str)
|
||||
is_line_short_enough(line, line_length=mode.line_length, line_str=line_str)
|
||||
or line.contains_unsplittable_type_ignore()
|
||||
)
|
||||
and not (line.contains_standalone_comments() and line.inside_brackets)
|
||||
):
|
||||
# Only apply basic string preprocessing, since lines shouldn't be split here.
|
||||
transformers = [string_merge, string_paren_strip]
|
||||
if mode.experimental_string_processing:
|
||||
transformers = [string_merge, string_paren_strip]
|
||||
else:
|
||||
transformers = []
|
||||
elif line.is_def:
|
||||
transformers = [left_hand_split]
|
||||
else:
|
||||
|
||||
def rhs(line: Line, features: Collection[Feature]) -> Iterator[Line]:
|
||||
for omit in generate_trailers_to_omit(line, line_length):
|
||||
lines = list(right_hand_split(line, line_length, features, omit=omit))
|
||||
if is_line_short_enough(lines[0], line_length=line_length):
|
||||
for omit in generate_trailers_to_omit(line, mode.line_length):
|
||||
lines = list(
|
||||
right_hand_split(line, mode.line_length, features, omit=omit)
|
||||
)
|
||||
if is_line_short_enough(lines[0], line_length=mode.line_length):
|
||||
yield from lines
|
||||
return
|
||||
|
||||
@ -2706,24 +2717,30 @@ def rhs(line: Line, features: Collection[Feature]) -> Iterator[Line]:
|
||||
# See #762 and #781 for the full story.
|
||||
yield from right_hand_split(line, line_length=1, features=features)
|
||||
|
||||
if line.inside_brackets:
|
||||
transformers = [
|
||||
string_merge,
|
||||
string_paren_strip,
|
||||
delimiter_split,
|
||||
standalone_comment_split,
|
||||
string_split,
|
||||
string_paren_wrap,
|
||||
rhs,
|
||||
]
|
||||
if mode.experimental_string_processing:
|
||||
if line.inside_brackets:
|
||||
transformers = [
|
||||
string_merge,
|
||||
string_paren_strip,
|
||||
delimiter_split,
|
||||
standalone_comment_split,
|
||||
string_split,
|
||||
string_paren_wrap,
|
||||
rhs,
|
||||
]
|
||||
else:
|
||||
transformers = [
|
||||
string_merge,
|
||||
string_paren_strip,
|
||||
string_split,
|
||||
string_paren_wrap,
|
||||
rhs,
|
||||
]
|
||||
else:
|
||||
transformers = [
|
||||
string_merge,
|
||||
string_paren_strip,
|
||||
string_split,
|
||||
string_paren_wrap,
|
||||
rhs,
|
||||
]
|
||||
if line.inside_brackets:
|
||||
transformers = [delimiter_split, standalone_comment_split, rhs]
|
||||
else:
|
||||
transformers = [rhs]
|
||||
|
||||
for transform in transformers:
|
||||
# We are accumulating lines in `result` because we might want to abort
|
||||
@ -2738,12 +2755,7 @@ def rhs(line: Line, features: Collection[Feature]) -> Iterator[Line]:
|
||||
)
|
||||
|
||||
result.extend(
|
||||
transform_line(
|
||||
transformed_line,
|
||||
line_length=line_length,
|
||||
normalize_strings=normalize_strings,
|
||||
features=features,
|
||||
)
|
||||
transform_line(transformed_line, mode=mode, features=features)
|
||||
)
|
||||
except CannotTransform:
|
||||
continue
|
||||
|
||||
@ -10,7 +10,7 @@
|
||||
},
|
||||
"attrs": {
|
||||
"cli_arguments": [],
|
||||
"expect_formatting_changes": true,
|
||||
"expect_formatting_changes": false,
|
||||
"git_clone_url": "https://github.com/python-attrs/attrs.git",
|
||||
"long_checkout": false,
|
||||
"py_versions": ["all"]
|
||||
@ -47,7 +47,7 @@
|
||||
},
|
||||
"hypothesis": {
|
||||
"cli_arguments": [],
|
||||
"expect_formatting_changes": true,
|
||||
"expect_formatting_changes": false,
|
||||
"git_clone_url": "https://github.com/HypothesisWorks/hypothesis.git",
|
||||
"long_checkout": false,
|
||||
"py_versions": ["all"]
|
||||
@ -63,7 +63,7 @@
|
||||
},
|
||||
"poetry": {
|
||||
"cli_arguments": [],
|
||||
"expect_formatting_changes": true,
|
||||
"expect_formatting_changes": false,
|
||||
"git_clone_url": "https://github.com/python-poetry/poetry.git",
|
||||
"long_checkout": false,
|
||||
"py_versions": ["all"]
|
||||
|
||||
278
tests/data/long_strings_flag_disabled.py
Normal file
278
tests/data/long_strings_flag_disabled.py
Normal file
@ -0,0 +1,278 @@
|
||||
x = "This is a really long string that can't possibly be expected to fit all together on one line. In fact it may even take up three or more lines... like four or five... but probably just three."
|
||||
|
||||
x += "This is a really long string that can't possibly be expected to fit all together on one line. In fact it may even take up three or more lines... like four or five... but probably just three."
|
||||
|
||||
y = "Short string"
|
||||
|
||||
print(
|
||||
"This is a really long string inside of a print statement with extra arguments attached at the end of it.",
|
||||
x,
|
||||
y,
|
||||
z,
|
||||
)
|
||||
|
||||
print(
|
||||
"This is a really long string inside of a print statement with no extra arguments attached at the end of it."
|
||||
)
|
||||
|
||||
D1 = {
|
||||
"The First": "This is a really long string that can't possibly be expected to fit all together on one line. Also it is inside a dictionary, so formatting is more difficult.",
|
||||
"The Second": "This is another really really (not really) long string that also can't be expected to fit on one line and is, like the other string, inside a dictionary.",
|
||||
}
|
||||
|
||||
D2 = {
|
||||
1.0: "This is a really long string that can't possibly be expected to fit all together on one line. Also it is inside a dictionary, so formatting is more difficult.",
|
||||
2.0: "This is another really really (not really) long string that also can't be expected to fit on one line and is, like the other string, inside a dictionary.",
|
||||
}
|
||||
|
||||
D3 = {
|
||||
x: "This is a really long string that can't possibly be expected to fit all together on one line. Also it is inside a dictionary, so formatting is more difficult.",
|
||||
y: "This is another really really (not really) long string that also can't be expected to fit on one line and is, like the other string, inside a dictionary.",
|
||||
}
|
||||
|
||||
D4 = {
|
||||
"A long and ridiculous {}".format(
|
||||
string_key
|
||||
): "This is a really really really long string that has to go i,side of a dictionary. It is soooo bad.",
|
||||
some_func(
|
||||
"calling", "some", "stuff"
|
||||
): "This is a really really really long string that has to go inside of a dictionary. It is {soooo} bad (#{x}).".format(
|
||||
sooo="soooo", x=2
|
||||
),
|
||||
"A %s %s"
|
||||
% (
|
||||
"formatted",
|
||||
"string",
|
||||
): "This is a really really really long string that has to go inside of a dictionary. It is %s bad (#%d)."
|
||||
% ("soooo", 2),
|
||||
}
|
||||
|
||||
func_with_keywords(
|
||||
my_arg,
|
||||
my_kwarg="Long keyword strings also need to be wrapped, but they will probably need to be handled a little bit differently.",
|
||||
)
|
||||
|
||||
bad_split1 = (
|
||||
"But what should happen when code has already been formatted but in the wrong way? Like"
|
||||
" with a space at the end instead of the beginning. Or what about when it is split too soon?"
|
||||
)
|
||||
|
||||
bad_split2 = (
|
||||
"But what should happen when code has already "
|
||||
"been formatted but in the wrong way? Like "
|
||||
"with a space at the end instead of the "
|
||||
"beginning. Or what about when it is split too "
|
||||
"soon? In the case of a split that is too "
|
||||
"short, black will try to honer the custom "
|
||||
"split."
|
||||
)
|
||||
|
||||
bad_split3 = (
|
||||
"What if we have inline comments on " # First Comment
|
||||
"each line of a bad split? In that " # Second Comment
|
||||
"case, we should just leave it alone." # Third Comment
|
||||
)
|
||||
|
||||
bad_split_func1(
|
||||
"But what should happen when code has already "
|
||||
"been formatted but in the wrong way? Like "
|
||||
"with a space at the end instead of the "
|
||||
"beginning. Or what about when it is split too "
|
||||
"soon? In the case of a split that is too "
|
||||
"short, black will try to honer the custom "
|
||||
"split.",
|
||||
xxx,
|
||||
yyy,
|
||||
zzz,
|
||||
)
|
||||
|
||||
bad_split_func2(
|
||||
xxx,
|
||||
yyy,
|
||||
zzz,
|
||||
long_string_kwarg="But what should happen when code has already been formatted but in the wrong way? Like "
|
||||
"with a space at the end instead of the beginning. Or what about when it is split too "
|
||||
"soon?",
|
||||
)
|
||||
|
||||
bad_split_func3(
|
||||
(
|
||||
"But what should happen when code has already "
|
||||
r"been formatted but in the wrong way? Like "
|
||||
"with a space at the end instead of the "
|
||||
r"beginning. Or what about when it is split too "
|
||||
r"soon? In the case of a split that is too "
|
||||
"short, black will try to honer the custom "
|
||||
"split."
|
||||
),
|
||||
xxx,
|
||||
yyy,
|
||||
zzz,
|
||||
)
|
||||
|
||||
raw_string = r"This is a long raw string. When re-formatting this string, black needs to make sure it prepends the 'r' onto the new string."
|
||||
|
||||
fmt_string1 = "We also need to be sure to preserve any and all {} which may or may not be attached to the string in question.".format(
|
||||
"method calls"
|
||||
)
|
||||
|
||||
fmt_string2 = "But what about when the string is {} but {}".format(
|
||||
"short",
|
||||
"the method call is really really really really really really really really long?",
|
||||
)
|
||||
|
||||
old_fmt_string1 = (
|
||||
"While we are on the topic of %s, we should also note that old-style formatting must also be preserved, since some %s still uses it."
|
||||
% ("formatting", "code")
|
||||
)
|
||||
|
||||
old_fmt_string2 = "This is a %s %s %s %s" % (
|
||||
"really really really really really",
|
||||
"old",
|
||||
"way to format strings!",
|
||||
"Use f-strings instead!",
|
||||
)
|
||||
|
||||
old_fmt_string3 = (
|
||||
"Whereas only the strings after the percent sign were long in the last example, this example uses a long initial string as well. This is another %s %s %s %s"
|
||||
% (
|
||||
"really really really really really",
|
||||
"old",
|
||||
"way to format strings!",
|
||||
"Use f-strings instead!",
|
||||
)
|
||||
)
|
||||
|
||||
fstring = f"f-strings definitely make things more {difficult} than they need to be for {{black}}. But boy they sure are handy. The problem is that some lines will need to have the 'f' whereas others do not. This {line}, for example, needs one."
|
||||
|
||||
fstring_with_no_fexprs = f"Some regular string that needs to get split certainly but is NOT an fstring by any means whatsoever."
|
||||
|
||||
comment_string = "Long lines with inline comments should have their comments appended to the reformatted string's enclosing right parentheses." # This comment gets thrown to the top.
|
||||
|
||||
arg_comment_string = print(
|
||||
"Long lines with inline comments which are apart of (and not the only member of) an argument list should have their comments appended to the reformatted string's enclosing left parentheses.", # This comment stays on the bottom.
|
||||
"Arg #2",
|
||||
"Arg #3",
|
||||
"Arg #4",
|
||||
"Arg #5",
|
||||
)
|
||||
|
||||
pragma_comment_string1 = "Lines which end with an inline pragma comment of the form `# <pragma>: <...>` should be left alone." # noqa: E501
|
||||
|
||||
pragma_comment_string2 = "Lines which end with an inline pragma comment of the form `# <pragma>: <...>` should be left alone." # noqa
|
||||
|
||||
"""This is a really really really long triple quote string and it should not be touched."""
|
||||
|
||||
triple_quote_string = """This is a really really really long triple quote string assignment and it should not be touched."""
|
||||
|
||||
assert (
|
||||
some_type_of_boolean_expression
|
||||
), "Followed by a really really really long string that is used to provide context to the AssertionError exception."
|
||||
|
||||
assert (
|
||||
some_type_of_boolean_expression
|
||||
), "Followed by a really really really long string that is used to provide context to the AssertionError exception, which uses dynamic string {}.".format(
|
||||
"formatting"
|
||||
)
|
||||
|
||||
assert some_type_of_boolean_expression, (
|
||||
"Followed by a really really really long string that is used to provide context to the AssertionError exception, which uses dynamic string %s."
|
||||
% "formatting"
|
||||
)
|
||||
|
||||
assert some_type_of_boolean_expression, (
|
||||
"Followed by a really really really long string that is used to provide context to the AssertionError exception, which uses dynamic %s %s."
|
||||
% ("string", "formatting")
|
||||
)
|
||||
|
||||
some_function_call(
|
||||
"With a reallly generic name and with a really really long string that is, at some point down the line, "
|
||||
+ added
|
||||
+ " to a variable and then added to another string."
|
||||
)
|
||||
|
||||
some_function_call(
|
||||
"With a reallly generic name and with a really really long string that is, at some point down the line, "
|
||||
+ added
|
||||
+ " to a variable and then added to another string. But then what happens when the final string is also supppppperrrrr long?! Well then that second (realllllllly long) string should be split too.",
|
||||
"and a second argument",
|
||||
and_a_third,
|
||||
)
|
||||
|
||||
return "A really really really really really really really really really really really really really long {} {}".format(
|
||||
"return", "value"
|
||||
)
|
||||
|
||||
func_with_bad_comma(
|
||||
"This is a really long string argument to a function that has a trailing comma which should NOT be there.",
|
||||
)
|
||||
|
||||
func_with_bad_comma(
|
||||
"This is a really long string argument to a function that has a trailing comma which should NOT be there.", # comment after comma
|
||||
)
|
||||
|
||||
func_with_bad_comma(
|
||||
(
|
||||
"This is a really long string argument to a function that has a trailing comma"
|
||||
" which should NOT be there."
|
||||
),
|
||||
)
|
||||
|
||||
func_with_bad_comma(
|
||||
(
|
||||
"This is a really long string argument to a function that has a trailing comma"
|
||||
" which should NOT be there."
|
||||
), # comment after comma
|
||||
)
|
||||
|
||||
func_with_bad_parens(
|
||||
("short string that should have parens stripped"), x, y, z,
|
||||
)
|
||||
|
||||
func_with_bad_parens(
|
||||
x, y, ("short string that should have parens stripped"), z,
|
||||
)
|
||||
|
||||
annotated_variable: Final = (
|
||||
"This is a large "
|
||||
+ STRING
|
||||
+ " that has been "
|
||||
+ CONCATENATED
|
||||
+ "using the '+' operator."
|
||||
)
|
||||
annotated_variable: Final = "This is a large string that has a type annotation attached to it. A type annotation should NOT stop a long string from being wrapped."
|
||||
annotated_variable: Literal[
|
||||
"fakse_literal"
|
||||
] = "This is a large string that has a type annotation attached to it. A type annotation should NOT stop a long string from being wrapped."
|
||||
|
||||
backslashes = "This is a really long string with \"embedded\" double quotes and 'single' quotes that also handles checking for an even number of backslashes \\"
|
||||
backslashes = "This is a really long string with \"embedded\" double quotes and 'single' quotes that also handles checking for an even number of backslashes \\\\"
|
||||
backslashes = "This is a really 'long' string with \"embedded double quotes\" and 'single' quotes that also handles checking for an odd number of backslashes \\\", like this...\\\\\\"
|
||||
|
||||
short_string = "Hi" " there."
|
||||
|
||||
func_call(short_string=("Hi" " there."))
|
||||
|
||||
raw_strings = r"Don't" " get" r" merged" " unless they are all raw."
|
||||
|
||||
|
||||
def foo():
|
||||
yield "This is a really long string that can't possibly be expected to fit all together on one line. In fact it may even take up three or more lines... like four or five... but probably just three."
|
||||
|
||||
|
||||
x = f"This is a {{really}} long string that needs to be split without a doubt (i.e. most definitely). In short, this {string} that can't possibly be {{expected}} to fit all together on one line. In {fact} it may even take up three or more lines... like four or five... but probably just four."
|
||||
|
||||
long_unmergable_string_with_pragma = (
|
||||
"This is a really long string that can't be merged because it has a likely pragma at the end" # type: ignore
|
||||
" of it."
|
||||
)
|
||||
|
||||
long_unmergable_string_with_pragma = (
|
||||
"This is a really long string that can't be merged because it has a likely pragma at the end" # noqa
|
||||
" of it."
|
||||
)
|
||||
|
||||
long_unmergable_string_with_pragma = (
|
||||
"This is a really long string that can't be merged because it has a likely pragma at the end" # pylint: disable=some-pylint-check
|
||||
" of it."
|
||||
)
|
||||
@ -3,6 +3,7 @@
|
||||
import logging
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
from contextlib import contextmanager
|
||||
from dataclasses import replace
|
||||
from functools import partial
|
||||
from io import BytesIO, TextIOWrapper
|
||||
import os
|
||||
@ -36,8 +37,9 @@
|
||||
from .test_primer import PrimerCLITests # noqa: F401
|
||||
|
||||
|
||||
ff = partial(black.format_file_in_place, mode=black.FileMode(), fast=True)
|
||||
fs = partial(black.format_str, mode=black.FileMode())
|
||||
DEFAULT_MODE = black.FileMode(experimental_string_processing=True)
|
||||
ff = partial(black.format_file_in_place, mode=DEFAULT_MODE, fast=True)
|
||||
fs = partial(black.format_str, mode=DEFAULT_MODE)
|
||||
THIS_FILE = Path(__file__)
|
||||
THIS_DIR = THIS_FILE.parent
|
||||
PROJECT_ROOT = THIS_DIR.parent
|
||||
@ -190,13 +192,13 @@ def invokeBlack(
|
||||
)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def checkSourceFile(self, name: str) -> None:
|
||||
def checkSourceFile(self, name: str, mode: black.FileMode = DEFAULT_MODE) -> None:
|
||||
path = THIS_DIR.parent / name
|
||||
source, expected = read_data(str(path), data=False)
|
||||
actual = fs(source)
|
||||
actual = fs(source, mode=mode)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, mode)
|
||||
self.assertFalse(ff(path))
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
@ -205,7 +207,7 @@ def test_empty(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
def test_empty_ff(self) -> None:
|
||||
expected = ""
|
||||
@ -267,7 +269,7 @@ def test_piping(self) -> None:
|
||||
self.assertEqual(result.exit_code, 0)
|
||||
self.assertFormatEqual(expected, result.output)
|
||||
black.assert_equivalent(source, result.output)
|
||||
black.assert_stable(source, result.output, black.FileMode())
|
||||
black.assert_stable(source, result.output, DEFAULT_MODE)
|
||||
|
||||
def test_piping_diff(self) -> None:
|
||||
diff_header = re.compile(
|
||||
@ -320,7 +322,7 @@ def test_function(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_function2(self) -> None:
|
||||
@ -328,7 +330,7 @@ def test_function2(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_function_trailing_comma(self) -> None:
|
||||
@ -336,7 +338,7 @@ def test_function_trailing_comma(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_expression(self) -> None:
|
||||
@ -344,14 +346,14 @@ def test_expression(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_pep_572(self) -> None:
|
||||
source, expected = read_data("pep_572")
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
if sys.version_info >= (3, 8):
|
||||
black.assert_equivalent(source, actual)
|
||||
|
||||
@ -375,7 +377,7 @@ def test_expression_ff(self) -> None:
|
||||
self.assertFormatEqual(expected, actual)
|
||||
with patch("black.dump_to_file", dump_to_stderr):
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
def test_expression_diff(self) -> None:
|
||||
source, _ = read_data("expression.py")
|
||||
@ -427,14 +429,14 @@ def test_fstring(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_pep_570(self) -> None:
|
||||
source, expected = read_data("pep_570")
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
if sys.version_info >= (3, 8):
|
||||
black.assert_equivalent(source, actual)
|
||||
|
||||
@ -452,8 +454,8 @@ def test_string_quotes(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
mode = black.FileMode(string_normalization=False)
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
mode = replace(DEFAULT_MODE, string_normalization=False)
|
||||
not_normalized = fs(source, mode=mode)
|
||||
self.assertFormatEqual(source.replace("\\\n", ""), not_normalized)
|
||||
black.assert_equivalent(source, not_normalized)
|
||||
@ -465,7 +467,7 @@ def test_docstring(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
def test_long_strings(self) -> None:
|
||||
"""Tests for splitting long strings."""
|
||||
@ -473,7 +475,15 @@ def test_long_strings(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
def test_long_strings_flag_disabled(self) -> None:
|
||||
"""Tests for turning off the string processing logic."""
|
||||
source, expected = read_data("long_strings_flag_disabled")
|
||||
mode = replace(DEFAULT_MODE, experimental_string_processing=False)
|
||||
actual = fs(source, mode=mode)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_stable(expected, actual, mode)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_long_strings__edge_case(self) -> None:
|
||||
@ -482,7 +492,7 @@ def test_long_strings__edge_case(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_long_strings__regression(self) -> None:
|
||||
@ -491,7 +501,7 @@ def test_long_strings__regression(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_slices(self) -> None:
|
||||
@ -499,7 +509,7 @@ def test_slices(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_percent_precedence(self) -> None:
|
||||
@ -507,7 +517,7 @@ def test_percent_precedence(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_comments(self) -> None:
|
||||
@ -515,7 +525,7 @@ def test_comments(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_comments2(self) -> None:
|
||||
@ -523,7 +533,7 @@ def test_comments2(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_comments3(self) -> None:
|
||||
@ -531,7 +541,7 @@ def test_comments3(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_comments4(self) -> None:
|
||||
@ -539,7 +549,7 @@ def test_comments4(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_comments5(self) -> None:
|
||||
@ -547,7 +557,7 @@ def test_comments5(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_comments6(self) -> None:
|
||||
@ -555,7 +565,7 @@ def test_comments6(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_comments7(self) -> None:
|
||||
@ -563,7 +573,7 @@ def test_comments7(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_comment_after_escaped_newline(self) -> None:
|
||||
@ -571,7 +581,7 @@ def test_comment_after_escaped_newline(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_cantfit(self) -> None:
|
||||
@ -579,7 +589,7 @@ def test_cantfit(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_import_spacing(self) -> None:
|
||||
@ -587,7 +597,7 @@ def test_import_spacing(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_composition(self) -> None:
|
||||
@ -595,7 +605,7 @@ def test_composition(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_empty_lines(self) -> None:
|
||||
@ -603,7 +613,7 @@ def test_empty_lines(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_remove_parens(self) -> None:
|
||||
@ -611,7 +621,7 @@ def test_remove_parens(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_string_prefixes(self) -> None:
|
||||
@ -619,12 +629,12 @@ def test_string_prefixes(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_numeric_literals(self) -> None:
|
||||
source, expected = read_data("numeric_literals")
|
||||
mode = black.FileMode(target_versions=black.PY36_VERSIONS)
|
||||
mode = replace(DEFAULT_MODE, target_versions=black.PY36_VERSIONS)
|
||||
actual = fs(source, mode=mode)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
@ -633,7 +643,7 @@ def test_numeric_literals(self) -> None:
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_numeric_literals_ignoring_underscores(self) -> None:
|
||||
source, expected = read_data("numeric_literals_skip_underscores")
|
||||
mode = black.FileMode(target_versions=black.PY36_VERSIONS)
|
||||
mode = replace(DEFAULT_MODE, target_versions=black.PY36_VERSIONS)
|
||||
actual = fs(source, mode=mode)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
@ -644,7 +654,7 @@ def test_numeric_literals_py2(self) -> None:
|
||||
source, expected = read_data("numeric_literals_py2")
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_python2(self) -> None:
|
||||
@ -652,12 +662,12 @@ def test_python2(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_python2_print_function(self) -> None:
|
||||
source, expected = read_data("python2_print_function")
|
||||
mode = black.FileMode(target_versions={TargetVersion.PY27})
|
||||
mode = replace(DEFAULT_MODE, target_versions={TargetVersion.PY27})
|
||||
actual = fs(source, mode=mode)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
@ -669,11 +679,11 @@ def test_python2_unicode_literals(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_stub(self) -> None:
|
||||
mode = black.FileMode(is_pyi=True)
|
||||
mode = replace(DEFAULT_MODE, is_pyi=True)
|
||||
source, expected = read_data("stub.pyi")
|
||||
actual = fs(source, mode=mode)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
@ -688,7 +698,7 @@ def test_async_as_identifier(self) -> None:
|
||||
major, minor = sys.version_info[:2]
|
||||
if major < 3 or (major <= 3 and minor < 7):
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
# ensure black can parse this when the target is 3.6
|
||||
self.invokeBlack([str(source_path), "--target-version", "py36"])
|
||||
# but not on 3.7, because async/await is no longer an identifier
|
||||
@ -703,7 +713,7 @@ def test_python37(self) -> None:
|
||||
major, minor = sys.version_info[:2]
|
||||
if major > 3 or (major == 3 and minor >= 7):
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
# ensure black can parse this when the target is 3.7
|
||||
self.invokeBlack([str(source_path), "--target-version", "py37"])
|
||||
# but not on 3.6, because we use async as a reserved keyword
|
||||
@ -717,7 +727,7 @@ def test_python38(self) -> None:
|
||||
major, minor = sys.version_info[:2]
|
||||
if major > 3 or (major == 3 and minor >= 8):
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_fmtonoff(self) -> None:
|
||||
@ -725,7 +735,7 @@ def test_fmtonoff(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_fmtonoff2(self) -> None:
|
||||
@ -733,7 +743,7 @@ def test_fmtonoff2(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_fmtonoff3(self) -> None:
|
||||
@ -741,7 +751,7 @@ def test_fmtonoff3(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_fmtonoff4(self) -> None:
|
||||
@ -749,7 +759,7 @@ def test_fmtonoff4(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_remove_empty_parentheses_after_class(self) -> None:
|
||||
@ -757,7 +767,7 @@ def test_remove_empty_parentheses_after_class(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_new_line_between_class_and_code(self) -> None:
|
||||
@ -765,7 +775,7 @@ def test_new_line_between_class_and_code(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_bracket_match(self) -> None:
|
||||
@ -773,7 +783,7 @@ def test_bracket_match(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_tuple_assign(self) -> None:
|
||||
@ -781,7 +791,7 @@ def test_tuple_assign(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
@patch("black.dump_to_file", dump_to_stderr)
|
||||
def test_beginning_backslash(self) -> None:
|
||||
@ -789,7 +799,7 @@ def test_beginning_backslash(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
def test_tab_comment_indentation(self) -> None:
|
||||
contents_tab = "if 1:\n\tif 2:\n\t\tpass\n\t# comment\n\tpass\n"
|
||||
@ -1218,7 +1228,7 @@ def err(msg: str, **kwargs: Any) -> None:
|
||||
|
||||
def test_format_file_contents(self) -> None:
|
||||
empty = ""
|
||||
mode = black.FileMode()
|
||||
mode = DEFAULT_MODE
|
||||
with self.assertRaises(black.NothingChanged):
|
||||
black.format_file_contents(empty, mode=mode, fast=False)
|
||||
just_nl = "\n"
|
||||
@ -1263,7 +1273,7 @@ def err(msg: str, **kwargs: Any) -> None:
|
||||
self.assertEqual("".join(err_lines), "")
|
||||
|
||||
def test_cache_broken_file(self) -> None:
|
||||
mode = black.FileMode()
|
||||
mode = DEFAULT_MODE
|
||||
with cache_dir() as workspace:
|
||||
cache_file = black.get_cache_file(mode)
|
||||
with cache_file.open("w") as fobj:
|
||||
@ -1277,7 +1287,7 @@ def test_cache_broken_file(self) -> None:
|
||||
self.assertIn(src, cache)
|
||||
|
||||
def test_cache_single_file_already_cached(self) -> None:
|
||||
mode = black.FileMode()
|
||||
mode = DEFAULT_MODE
|
||||
with cache_dir() as workspace:
|
||||
src = (workspace / "test.py").resolve()
|
||||
with src.open("w") as fobj:
|
||||
@ -1289,7 +1299,7 @@ def test_cache_single_file_already_cached(self) -> None:
|
||||
|
||||
@event_loop()
|
||||
def test_cache_multiple_files(self) -> None:
|
||||
mode = black.FileMode()
|
||||
mode = DEFAULT_MODE
|
||||
with cache_dir() as workspace, patch(
|
||||
"black.ProcessPoolExecutor", new=ThreadPoolExecutor
|
||||
):
|
||||
@ -1310,7 +1320,7 @@ def test_cache_multiple_files(self) -> None:
|
||||
self.assertIn(two, cache)
|
||||
|
||||
def test_no_cache_when_writeback_diff(self) -> None:
|
||||
mode = black.FileMode()
|
||||
mode = DEFAULT_MODE
|
||||
with cache_dir() as workspace:
|
||||
src = (workspace / "test.py").resolve()
|
||||
with src.open("w") as fobj:
|
||||
@ -1320,7 +1330,7 @@ def test_no_cache_when_writeback_diff(self) -> None:
|
||||
self.assertFalse(cache_file.exists())
|
||||
|
||||
def test_no_cache_when_stdin(self) -> None:
|
||||
mode = black.FileMode()
|
||||
mode = DEFAULT_MODE
|
||||
with cache_dir():
|
||||
result = CliRunner().invoke(
|
||||
black.main, ["-"], input=BytesIO(b"print('hello')")
|
||||
@ -1330,12 +1340,12 @@ def test_no_cache_when_stdin(self) -> None:
|
||||
self.assertFalse(cache_file.exists())
|
||||
|
||||
def test_read_cache_no_cachefile(self) -> None:
|
||||
mode = black.FileMode()
|
||||
mode = DEFAULT_MODE
|
||||
with cache_dir():
|
||||
self.assertEqual(black.read_cache(mode), {})
|
||||
|
||||
def test_write_cache_read_cache(self) -> None:
|
||||
mode = black.FileMode()
|
||||
mode = DEFAULT_MODE
|
||||
with cache_dir() as workspace:
|
||||
src = (workspace / "test.py").resolve()
|
||||
src.touch()
|
||||
@ -1361,7 +1371,7 @@ def test_filter_cached(self) -> None:
|
||||
self.assertEqual(done, {cached})
|
||||
|
||||
def test_write_cache_creates_directory_if_needed(self) -> None:
|
||||
mode = black.FileMode()
|
||||
mode = DEFAULT_MODE
|
||||
with cache_dir(exists=False) as workspace:
|
||||
self.assertFalse(workspace.exists())
|
||||
black.write_cache({}, [], mode)
|
||||
@ -1369,7 +1379,7 @@ def test_write_cache_creates_directory_if_needed(self) -> None:
|
||||
|
||||
@event_loop()
|
||||
def test_failed_formatting_does_not_get_cached(self) -> None:
|
||||
mode = black.FileMode()
|
||||
mode = DEFAULT_MODE
|
||||
with cache_dir() as workspace, patch(
|
||||
"black.ProcessPoolExecutor", new=ThreadPoolExecutor
|
||||
):
|
||||
@ -1385,7 +1395,7 @@ def test_failed_formatting_does_not_get_cached(self) -> None:
|
||||
self.assertIn(clean, cache)
|
||||
|
||||
def test_write_cache_write_fail(self) -> None:
|
||||
mode = black.FileMode()
|
||||
mode = DEFAULT_MODE
|
||||
with cache_dir(), patch.object(Path, "open") as mock:
|
||||
mock.side_effect = OSError
|
||||
black.write_cache({}, [], mode)
|
||||
@ -1428,8 +1438,8 @@ def test_broken_symlink(self) -> None:
|
||||
self.invokeBlack([str(workspace.resolve())])
|
||||
|
||||
def test_read_cache_line_lengths(self) -> None:
|
||||
mode = black.FileMode()
|
||||
short_mode = black.FileMode(line_length=1)
|
||||
mode = DEFAULT_MODE
|
||||
short_mode = replace(DEFAULT_MODE, line_length=1)
|
||||
with cache_dir() as workspace:
|
||||
path = (workspace / "file.py").resolve()
|
||||
path.touch()
|
||||
@ -1444,11 +1454,11 @@ def test_tricky_unicode_symbols(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
def test_single_file_force_pyi(self) -> None:
|
||||
reg_mode = black.FileMode()
|
||||
pyi_mode = black.FileMode(is_pyi=True)
|
||||
reg_mode = DEFAULT_MODE
|
||||
pyi_mode = replace(DEFAULT_MODE, is_pyi=True)
|
||||
contents, expected = read_data("force_pyi")
|
||||
with cache_dir() as workspace:
|
||||
path = (workspace / "file.py").resolve()
|
||||
@ -1466,8 +1476,8 @@ def test_single_file_force_pyi(self) -> None:
|
||||
|
||||
@event_loop()
|
||||
def test_multi_file_force_pyi(self) -> None:
|
||||
reg_mode = black.FileMode()
|
||||
pyi_mode = black.FileMode(is_pyi=True)
|
||||
reg_mode = DEFAULT_MODE
|
||||
pyi_mode = replace(DEFAULT_MODE, is_pyi=True)
|
||||
contents, expected = read_data("force_pyi")
|
||||
with cache_dir() as workspace:
|
||||
paths = [
|
||||
@ -1499,8 +1509,8 @@ def test_pipe_force_pyi(self) -> None:
|
||||
self.assertFormatEqual(actual, expected)
|
||||
|
||||
def test_single_file_force_py36(self) -> None:
|
||||
reg_mode = black.FileMode()
|
||||
py36_mode = black.FileMode(target_versions=black.PY36_VERSIONS)
|
||||
reg_mode = DEFAULT_MODE
|
||||
py36_mode = replace(DEFAULT_MODE, target_versions=black.PY36_VERSIONS)
|
||||
source, expected = read_data("force_py36")
|
||||
with cache_dir() as workspace:
|
||||
path = (workspace / "file.py").resolve()
|
||||
@ -1518,8 +1528,8 @@ def test_single_file_force_py36(self) -> None:
|
||||
|
||||
@event_loop()
|
||||
def test_multi_file_force_py36(self) -> None:
|
||||
reg_mode = black.FileMode()
|
||||
py36_mode = black.FileMode(target_versions=black.PY36_VERSIONS)
|
||||
reg_mode = DEFAULT_MODE
|
||||
py36_mode = replace(DEFAULT_MODE, target_versions=black.PY36_VERSIONS)
|
||||
source, expected = read_data("force_py36")
|
||||
with cache_dir() as workspace:
|
||||
paths = [
|
||||
@ -1546,7 +1556,7 @@ def test_collections(self) -> None:
|
||||
actual = fs(source)
|
||||
self.assertFormatEqual(expected, actual)
|
||||
black.assert_equivalent(source, actual)
|
||||
black.assert_stable(source, actual, black.FileMode())
|
||||
black.assert_stable(source, actual, DEFAULT_MODE)
|
||||
|
||||
def test_pipe_force_py36(self) -> None:
|
||||
source, expected = read_data("force_py36")
|
||||
@ -1827,9 +1837,7 @@ def test_parse_pyproject_toml(self) -> None:
|
||||
def test_read_pyproject_toml(self) -> None:
|
||||
test_toml_file = THIS_DIR / "test.toml"
|
||||
fake_ctx = FakeContext()
|
||||
black.read_pyproject_toml(
|
||||
fake_ctx, FakeParameter(), str(test_toml_file),
|
||||
)
|
||||
black.read_pyproject_toml(fake_ctx, FakeParameter(), str(test_toml_file))
|
||||
config = fake_ctx.default_map
|
||||
self.assertEqual(config["verbose"], "1")
|
||||
self.assertEqual(config["check"], "no")
|
||||
|
||||
Loading…
Reference in New Issue
Block a user