class NothingChanged(UserWarning):
- """Raised by `format_file()` when the reformatted code is the same as source."""
+ """Raised by :func:`format_file` when reformatted code is the same as source."""
class CannotSplit(Exception):
"""A readable split that fits the allotted line length is impossible.
- Raised by `left_hand_split()`, `right_hand_split()`, and `delimiter_split()`.
+ Raised by :func:`left_hand_split`, :func:`right_hand_split`, and
+ :func:`delimiter_split`.
"""
}
await asyncio.wait(tasks.values())
cancelled = []
- report = Report()
+ report = Report(check=not write_back)
for src, task in tasks.items():
if not task.done():
report.failed(src, 'timed out, cancelling')
def format_file_contents(
src_contents: str, line_length: int, fast: bool
) -> FileContent:
- """Reformats a file and returns its contents and encoding.
+ """Reformat contents a file and return new contents.
If `fast` is False, additionally confirm that the reformatted code is
valid by calling :func:`assert_equivalent` and :func:`assert_stable` on it.
def format_str(src_contents: str, line_length: int) -> FileContent:
- """Reformats a string and returns new contents.
+ """Reformat a string and return new contents.
`line_length` determines how many characters per line are allowed.
"""
@classmethod
def show(cls, code: str) -> None:
- """Pretty-prints a given string of `code`.
+ """Pretty-print the lib2to3 AST of a given string of `code`.
Convenience method for debugging.
"""
previous: Optional[Leaf] = None
def mark(self, leaf: Leaf) -> None:
- """Marks `leaf` with bracket-related metadata. Keeps track of delimiters.
+ """Mark `leaf` with bracket-related metadata. Keep track of delimiters.
All leaves receive an int `bracket_depth` field that stores how deep
within brackets a given leaf is. 0 means there are no enclosing brackets
self.previous = leaf
def any_open_brackets(self) -> bool:
- """Returns True if there is an yet unmatched open bracket on the line."""
+ """Return True if there is an yet unmatched open bracket on the line."""
return bool(self.bracket_match)
def max_delimiter_priority(self, exclude: Iterable[LeafID] = ()) -> int:
- """Returns the highest priority of a delimiter found on the line.
+ """Return the highest priority of a delimiter found on the line.
Values are consistent with what `is_delimiter()` returns.
"""
@property
def is_class(self) -> bool:
- """Is this a class definition?"""
+ """Is this line a class definition?"""
return (
bool(self)
and self.leaves[0].type == token.NAME
@property
def is_flow_control(self) -> bool:
- """Is this a flow control statement?
+ """Is this line a flow control statement?
Those are `return`, `raise`, `break`, and `continue`.
"""
@property
def is_yield(self) -> bool:
- """Is this a yield statement?"""
+ """Is this line a yield statement?"""
return (
bool(self)
and self.leaves[0].type == token.NAME
def maybe_increment_for_loop_variable(self, leaf: Leaf) -> bool:
"""In a for loop, or comprehension, the variables are often unpacks.
- To avoid splitting on the comma in this situation, we will increase
- the depth of tokens between `for` and `in`.
+ To avoid splitting on the comma in this situation, increase the depth of
+ tokens between `for` and `in`.
"""
if leaf.type == token.NAME and leaf.value == 'for':
self.has_for = True
return True
def last_non_delimiter(self) -> Leaf:
- """Returns the last non-delimiter on the line. Raises LookupError otherwise."""
+ """Return the last non-delimiter on the line. Raise LookupError otherwise."""
for i in range(len(self.leaves)):
last = self.leaves[-i - 1]
if not is_delimiter(last):
return res + '\n'
def __bool__(self) -> bool:
- """Returns True if the line has leaves or comments."""
+ """Return True if the line has leaves or comments."""
return bool(self.leaves or self.comments)
elif leaf.type == token.DEDENT:
self.depth -= 1
+ def __str__(self) -> str:
+ """Render unformatted lines from leaves which were added with `append()`.
+
+ `depth` is not used for indentation in this case.
+ """
+ if not self:
+ return '\n'
+
+ res = ''
+ for leaf in self.leaves:
+ res += str(leaf)
+ return res
+
def append_comment(self, comment: Leaf) -> bool:
- """Not implemented in this class."""
+ """Not implemented in this class. Raises `NotImplementedError`."""
raise NotImplementedError("Unformatted lines don't store comments separately.")
def maybe_remove_trailing_comma(self, closing: Leaf) -> bool:
"""Does nothing and returns False."""
return False
- def __str__(self) -> str:
- """Renders unformatted lines from leaves which were added with `append()`.
-
- `depth` is not used for indentation in this case.
- """
- if not self:
- return '\n'
-
- res = ''
- for leaf in self.leaves:
- res += str(leaf)
- return res
-
@dataclass
class EmptyLineTracker:
previous_defs: List[int] = Factory(list)
def maybe_empty_lines(self, current_line: Line) -> Tuple[int, int]:
- """Returns the number of extra empty lines before and after the `current_line`.
+ """Return the number of extra empty lines before and after the `current_line`.
- This is for separating `def`, `async def` and `class` with extra empty lines
- (two on module-level), as well as providing an extra empty line after flow
- control keywords to make them more prominent.
+ This is for separating `def`, `async def` and `class` with extra empty
+ lines (two on module-level), as well as providing an extra empty line
+ after flow control keywords to make them more prominent.
"""
if isinstance(current_line, UnformattedLines):
return 0, 0
yield complete_line
def visit(self, node: LN) -> Iterator[Line]:
- """Main method to start the visit process. Yields :class:`Line` objects."""
+ """Main method to visit `node` and its children.
+
+ Yields :class:`Line` objects.
+ """
if isinstance(self.current_line, UnformattedLines):
# File contained `# fmt: off`
yield from self.visit_unformatted(node)
yield from super().visit_default(node)
def visit_INDENT(self, node: Node) -> Iterator[Line]:
- """Increases indentation level, maybe yields a line."""
+ """Increase indentation level, maybe yield a line."""
# In blib2to3 INDENT never holds comments.
yield from self.line(+1)
yield from self.visit_default(node)
def visit_DEDENT(self, node: Node) -> Iterator[Line]:
- """Decreases indentation level, maybe yields a line."""
+ """Decrease indentation level, maybe yield a line."""
# DEDENT has no value. Additionally, in blib2to3 it never holds comments.
yield from self.line(-1)
def visit_stmt(self, node: Node, keywords: Set[str]) -> Iterator[Line]:
- """Visits a statement.
+ """Visit a statement.
This implementation is shared for `if`, `while`, `for`, `try`, `except`,
`def`, `with`, and `class`.
yield from self.visit(child)
def visit_simple_stmt(self, node: Node) -> Iterator[Line]:
- """Visits a statement without nested statements."""
+ """Visit a statement without nested statements."""
is_suite_like = node.parent and node.parent.type in STATEMENT
if is_suite_like:
yield from self.line(+1)
yield from self.visit_default(node)
def visit_async_stmt(self, node: Node) -> Iterator[Line]:
- """Visits `async def`, `async for`, `async with`."""
+ """Visit `async def`, `async for`, `async with`."""
yield from self.line()
children = iter(node.children)
yield from self.visit(child)
def visit_decorators(self, node: Node) -> Iterator[Line]:
- """Visits decorators."""
+ """Visit decorators."""
for child in node.children:
yield from self.line()
yield from self.visit(child)
def visit_SEMI(self, leaf: Leaf) -> Iterator[Line]:
- """Semicolons are always removed.
-
- Statements between them are put on separate lines.
- """
+ """Remove a semicolon and put the other statement on a separate line."""
yield from self.line()
def visit_ENDMARKER(self, leaf: Leaf) -> Iterator[Line]:
- """End of file.
-
- Process outstanding comments and end with a newline.
- """
+ """End of file. Process outstanding comments and end with a newline."""
yield from self.visit_default(leaf)
yield from self.line()
def preceding_leaf(node: Optional[LN]) -> Optional[Leaf]:
- """Returns the first leaf that precedes `node`, if any."""
+ """Return the first leaf that precedes `node`, if any."""
while node:
res = node.prev_sibling
if res:
def is_delimiter(leaf: Leaf) -> int:
- """Returns the priority of the `leaf` delimiter. Returns 0 if not delimiter.
+ """Return the priority of the `leaf` delimiter. Return 0 if not delimiter.
Higher numbers are higher priority.
"""
def generate_comments(leaf: Leaf) -> Iterator[Leaf]:
- """Cleans the prefix of the `leaf` and generates comments from it, if any.
+ """Clean the prefix of the `leaf` and generate comments from it, if any.
Comments in lib2to3 are shoved into the whitespace prefix. This happens
in `pgen2/driver.py:Driver.parse_tokens()`. This was a brilliant implementation
def make_comment(content: str) -> str:
- """Returns a consistently formatted comment from the given `content` string.
+ """Return a consistently formatted comment from the given `content` string.
All comments (except for "##", "#!", "#:") should have a single space between
the hash sign and the content.
def split_line(
line: Line, line_length: int, inner: bool = False, py36: bool = False
) -> Iterator[Line]:
- """Splits a `line` into potentially many lines.
+ """Split a `line` into potentially many lines.
They should fit in the allotted `line_length` but might not be able to.
`inner` signifies that there were a pair of brackets somewhere around the
def left_hand_split(line: Line, py36: bool = False) -> Iterator[Line]:
- """Splits line into many lines, starting with the first matching bracket pair.
+ """Split line into many lines, starting with the first matching bracket pair.
Note: this usually looks weird, only use this for function definitions.
Prefer RHS otherwise.
def right_hand_split(line: Line, py36: bool = False) -> Iterator[Line]:
- """Splits line into many lines, starting with the last matching bracket pair."""
+ """Split line into many lines, starting with the last matching bracket pair."""
head = Line(depth=line.depth)
body = Line(depth=line.depth + 1, inside_brackets=True)
tail = Line(depth=line.depth)
def delimiter_split(line: Line, py36: bool = False) -> Iterator[Line]:
- """Splits according to delimiters of the highest priority.
+ """Split according to delimiters of the highest priority.
This kind of split doesn't increase indentation.
If `py36` is True, the split will add trailing commas also in function
def is_import(leaf: Leaf) -> bool:
- """Returns True if the given leaf starts an import statement."""
+ """Return True if the given leaf starts an import statement."""
p = leaf.parent
t = leaf.type
v = leaf.value
def normalize_prefix(leaf: Leaf, *, inside_brackets: bool) -> None:
- """Leaves existing extra newlines if not `inside_brackets`.
+ """Leave existing extra newlines if not `inside_brackets`. Remove everything
+ else.
- Removes everything else. Note: don't use backslashes for formatting or
- you'll lose your voting rights.
+ Note: don't use backslashes for formatting or you'll lose your voting rights.
"""
if not inside_brackets:
spl = leaf.prefix.split('#')
def is_python36(node: Node) -> bool:
- """Returns True if the current file is using Python 3.6+ features.
+ """Return True if the current file is using Python 3.6+ features.
Currently looking for:
- f-strings; and
def gen_python_files_in_dir(path: Path) -> Iterator[Path]:
- """Generates all files under `path` which aren't under BLACKLISTED_DIRECTORIES
+ """Generate all files under `path` which aren't under BLACKLISTED_DIRECTORIES
and have one of the PYTHON_EXTENSIONS.
"""
for child in path.iterdir():
@property
def return_code(self) -> int:
- """Which return code should the app use considering the current state."""
+ """Return the exit code that the app should use.
+
+ This considers the current state of changed files and failures:
+ - if there were any failures, return 123;
+ - if any files were changed and --check is being used, return 1;
+ - otherwise return 0.
+ """
# According to http://tldp.org/LDP/abs/html/exitcodes.html starting with
# 126 we have special returncodes reserved by the shell.
if self.failure_count:
return 0
def __str__(self) -> str:
- """A color report of the current state.
+ """Render a color report of the current state.
Use `click.unstyle` to remove colors.
"""
def assert_equivalent(src: str, dst: str) -> None:
- """Raises AssertionError if `src` and `dst` aren't equivalent.
-
- This is a temporary sanity check until Black becomes stable.
- """
+ """Raise AssertionError if `src` and `dst` aren't equivalent."""
import ast
import traceback
def assert_stable(src: str, dst: str, line_length: int) -> None:
- """Raises AssertionError if `dst` reformats differently the second time.
-
- This is a temporary sanity check until Black becomes stable.
- """
+ """Raise AssertionError if `dst` reformats differently the second time."""
newdst = format_str(dst, line_length=line_length)
if dst != newdst:
log = dump_to_file(
def dump_to_file(*output: str) -> str:
- """Dumps `output` to a temporary file. Returns path to the file."""
+ """Dump `output` to a temporary file. Return path to the file."""
import tempfile
with tempfile.NamedTemporaryFile(
def diff(a: str, b: str, a_name: str, b_name: str) -> str:
- """Returns a udiff string between strings `a` and `b`."""
+ """Return a unified diff string between strings `a` and `b`."""
import difflib
a_lines = [line + '\n' for line in a.split('\n')]
projects / etc / vim.git / blobdiff