]>
git.madduck.net Git - etc/vim.git/blobdiff - black.py
madduck's git repository
Every one of the projects in this repository is available at the canonical
URL git://git.madduck.net/madduck/pub/<projectpath> — see
each project's metadata for the exact URL.
All patches and comments are welcome. Please squash your changes to logical
commits before using git-format-patch and git-send-email to
patches@ git. madduck. net .
If you'd read over the Git project's submission guidelines and adhered to them,
I'd be especially grateful.
SSH access, as well as push access can be individually
arranged .
If you use my repositories frequently, consider adding the following
snippet to ~/.gitconfig and using the third clone URL listed for each
project:
[url "git://git.madduck.net/madduck/"]
insteadOf = madduck:
if leaf.type in CLOSING_BRACKETS:
self.depth -= 1
opening_bracket = self.bracket_match.pop((self.depth, leaf.type))
if leaf.type in CLOSING_BRACKETS:
self.depth -= 1
opening_bracket = self.bracket_match.pop((self.depth, leaf.type))
- leaf.opening_bracket = opening_bracket # type: ignore
- leaf.bracket_depth = self.depth # type: ignore
+ leaf.opening_bracket = opening_bracket
+ leaf.bracket_depth = self.depth
if self.depth == 0:
delim = is_delimiter(leaf)
if delim:
if self.depth == 0:
delim = is_delimiter(leaf)
if delim:
# For parens let's check if it's safe to remove the comma. If the
# trailing one is the only one, we might mistakenly change a tuple
# into a different type by removing the comma.
# For parens let's check if it's safe to remove the comma. If the
# trailing one is the only one, we might mistakenly change a tuple
# into a different type by removing the comma.
- depth = closing.bracket_depth + 1 # type: ignore
+ depth = closing.bracket_depth + 1
- opening = closing.opening_bracket # type: ignore
+ opening = closing.opening_bracket
for _opening_index, leaf in enumerate(self.leaves):
if leaf is opening:
break
for _opening_index, leaf in enumerate(self.leaves):
if leaf is opening:
break
if leaf is closing:
break
if leaf is closing:
break
- bracket_depth = leaf.bracket_depth # type: ignore
+ bracket_depth = leaf.bracket_depth
if bracket_depth == depth and leaf.type == token.COMMA:
commas += 1
if commas > 1:
if bracket_depth == depth and leaf.type == token.COMMA:
commas += 1
if commas > 1:
OPENING_BRACKETS = set(BRACKET.keys())
CLOSING_BRACKETS = set(BRACKET.values())
BRACKETS = OPENING_BRACKETS | CLOSING_BRACKETS
OPENING_BRACKETS = set(BRACKET.keys())
CLOSING_BRACKETS = set(BRACKET.values())
BRACKETS = OPENING_BRACKETS | CLOSING_BRACKETS
+ALWAYS_NO_SPACE = CLOSING_BRACKETS | {token.COMMA, token.COLON, STANDALONE_COMMENT}
def whitespace(leaf: Leaf) -> str:
def whitespace(leaf: Leaf) -> str:
t = leaf.type
p = leaf.parent
v = leaf.value
t = leaf.type
p = leaf.parent
v = leaf.value
- if t == token.COLON:
- return NO
-
- if t == token.COMMA:
- return NO
-
- if t == token.RPAR:
+ if t in ALWAYS_NO_SPACE:
return NO
if t == token.COMMENT:
return DOUBLESPACE
return NO
if t == token.COMMENT:
return DOUBLESPACE
- if t == STANDALONE_COMMENT:
- return NO
-
- if t in CLOSING_BRACKETS:
- return NO
-
assert p is not None, f"INTERNAL ERROR: hand-made leaf without parent: {leaf!r}"
prev = leaf.prev_sibling
if not prev:
assert p is not None, f"INTERNAL ERROR: hand-made leaf without parent: {leaf!r}"
prev = leaf.prev_sibling
if not prev:
if prevp.parent and prevp.parent.type == syms.subscript:
return NO
if prevp.parent and prevp.parent.type == syms.subscript:
return NO
- elif prevp.parent and prevp.parent.type == syms.factor :
+ elif prevp.parent and prevp.parent.type in {syms.factor, syms.star_expr} :
return NO
elif prev.type in OPENING_BRACKETS:
return NO
elif prev.type in OPENING_BRACKETS:
elif p.type == syms.subscript:
# indexing
elif p.type == syms.subscript:
# indexing
- if not prev or prev.type == token.COLON:
+ if not prev:
+ assert p.parent is not None, "subscripts are always parented"
+ if p.parent.type == syms.subscriptlist:
+ return SPACE
+
+ return NO
+
+ elif prev.type == token.COLON:
return NO
elif p.type == syms.atom:
return NO
elif p.type == syms.atom:
if prev.type == token.DOUBLESTAR:
return NO
if prev.type == token.DOUBLESTAR:
return NO
- elif p.type == syms.factor or p.type == syms.star_expr :
+ elif p.type in {syms.factor, syms.star_expr} :
# unary ops
if not prev:
prevp = preceding_leaf(p)
# unary ops
if not prev:
prevp = preceding_leaf(p)
if (
current_leaves is body_leaves and
leaf.type in CLOSING_BRACKETS and
if (
current_leaves is body_leaves and
leaf.type in CLOSING_BRACKETS and
- leaf.opening_bracket is matching_bracket # type: ignore
+ leaf.opening_bracket is matching_bracket
):
current_leaves = tail_leaves
current_leaves.append(leaf)
):
current_leaves = tail_leaves
current_leaves.append(leaf)
current_leaves.append(leaf)
if current_leaves is tail_leaves:
if leaf.type in CLOSING_BRACKETS:
current_leaves.append(leaf)
if current_leaves is tail_leaves:
if leaf.type in CLOSING_BRACKETS:
- opening_bracket = leaf.opening_bracket # type: ignore
+ opening_bracket = leaf.opening_bracket
current_leaves = body_leaves
tail_leaves.reverse()
body_leaves.reverse()
current_leaves = body_leaves
tail_leaves.reverse()
body_leaves.reverse()
current_line.append(comment_after, preformatted=True)
lowest_depth = min(lowest_depth, leaf.bracket_depth)
if (
current_line.append(comment_after, preformatted=True)
lowest_depth = min(lowest_depth, leaf.bracket_depth)
if (
- leaf.bracket_depth == lowest_depth and # type: ignore
+ leaf.bracket_depth == lowest_depth and
leaf.type == token.STAR or
leaf.type == token.DOUBLESTAR
):
leaf.type == token.STAR or
leaf.type == token.DOUBLESTAR
):
"""
for n in node.pre_order():
if n.type == token.STRING:
"""
for n in node.pre_order():
if n.type == token.STRING:
- assert isinstance(n, Leaf)
- if n.value[:2] in {'f"', 'F"', "f'", "F'", 'rf', 'fr', 'RF', 'FR'}:
+ value_head = n.value[:2] # type: ignore
+ if value_head in {'f"', 'F"', "f'", "F'", 'rf', 'fr', 'RF', 'FR'}: