]> 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:

projects / etc / vim.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Fixed malformed link to pathlib
[etc/vim.git] / black.py
diff --git a/black.py b/black.py
index 24c57ca4aee1d54ae862e8e879a4d27f9577f029..d48fddbe6526d6dc2753a71c482e53afe8c2f9ee 100644 (file)
--- a/black.py
+++ b/black.py
@@ -20,7 +20,7 @@ from blib2to3 import pygram, pytree
 from blib2to3.pgen2 import driver, token
 from blib2to3.pgen2.parse import ParseError
 
 from blib2to3.pgen2 import driver, token
 from blib2to3.pgen2.parse import ParseError
 
-__version__ = "18.3a0"
+__version__ = "18.3a1"
 DEFAULT_LINE_LENGTH = 88
 # types
 syms = pygram.python_symbols
 DEFAULT_LINE_LENGTH = 88
 # types
 syms = pygram.python_symbols
@@ -358,7 +358,7 @@ class BracketTracker:
         """Returns True if there is an yet unmatched open bracket on the line."""
         return bool(self.bracket_match)
 
         """Returns True if there is an yet unmatched open bracket on the line."""
         return bool(self.bracket_match)
 
-    def max_priority(self, exclude: Iterable[LeafID] = ()) -> int:
+    def max_priority(self, exclude: Iterable[LeafID] =()) -> int:
         """Returns the highest priority of a delimiter found on the line.
 
         Values are consistent with what `is_delimiter()` returns.
         """Returns the highest priority of a delimiter found on the line.
 
         Values are consistent with what `is_delimiter()` returns.
@@ -765,6 +765,7 @@ def whitespace(leaf: Leaf) -> str:
     DOUBLESPACE = '  '
     t = leaf.type
     p = leaf.parent
     DOUBLESPACE = '  '
     t = leaf.type
     p = leaf.parent
+    v = leaf.value
     if t == token.COLON:
         return NO
 
     if t == token.COLON:
         return NO
 
@@ -780,13 +781,51 @@ def whitespace(leaf: Leaf) -> str:
     if t == STANDALONE_COMMENT:
         return NO
 
     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}"
     assert p is not None, f"INTERNAL ERROR: hand-made leaf without parent: {leaf!r}"
+    prev = leaf.prev_sibling
+    if not prev:
+        prevp = preceding_leaf(p)
+        if not prevp or prevp.type in OPENING_BRACKETS:
+            return NO
+
+        if prevp.type == token.EQUAL:
+            if prevp.parent and prevp.parent.type in {
+                syms.typedargslist,
+                syms.varargslist,
+                syms.parameters,
+                syms.arglist,
+                syms.argument,
+            }:
+                return NO
+
+        elif prevp.type == token.DOUBLESTAR:
+            if prevp.parent and prevp.parent.type in {
+                syms.typedargslist,
+                syms.varargslist,
+                syms.parameters,
+                syms.arglist,
+                syms.dictsetmaker,
+            }:
+                return NO
+
+        elif prevp.type == token.COLON:
+            if prevp.parent and prevp.parent.type == syms.subscript:
+                return NO
+
+        elif prevp.parent and prevp.parent.type == syms.factor:
+            return NO
+
+    elif prev.type in OPENING_BRACKETS:
+        return NO
+
     if p.type in {syms.parameters, syms.arglist}:
         # untyped function signatures or calls
         if t == token.RPAR:
             return NO
 
     if p.type in {syms.parameters, syms.arglist}:
         # untyped function signatures or calls
         if t == token.RPAR:
             return NO
 
-        prev = leaf.prev_sibling
         if not prev or prev.type != token.COMMA:
             return NO
 
         if not prev or prev.type != token.COMMA:
             return NO
 
@@ -795,13 +834,11 @@ def whitespace(leaf: Leaf) -> str:
         if t == token.RPAR:
             return NO
 
         if t == token.RPAR:
             return NO
 
-        prev = leaf.prev_sibling
         if prev and prev.type != token.COMMA:
             return NO
 
     elif p.type == syms.typedargslist:
         # typed function signatures
         if prev and prev.type != token.COMMA:
             return NO
 
     elif p.type == syms.typedargslist:
         # typed function signatures
-        prev = leaf.prev_sibling
         if not prev:
             return NO
 
         if not prev:
             return NO
 
@@ -819,7 +856,6 @@ def whitespace(leaf: Leaf) -> str:
 
     elif p.type == syms.tname:
         # type names
 
     elif p.type == syms.tname:
         # type names
-        prev = leaf.prev_sibling
         if not prev:
             prevp = preceding_leaf(p)
             if not prevp or prevp.type != token.COMMA:
         if not prev:
             prevp = preceding_leaf(p)
             if not prevp or prevp.type != token.COMMA:
@@ -830,7 +866,6 @@ def whitespace(leaf: Leaf) -> str:
         if t == token.LPAR or t == token.RPAR:
             return NO
 
         if t == token.LPAR or t == token.RPAR:
             return NO
 
-        prev = leaf.prev_sibling
         if not prev:
             if t == token.DOT:
                 prevp = preceding_leaf(p)
         if not prev:
             if t == token.DOT:
                 prevp = preceding_leaf(p)
@@ -848,7 +883,6 @@ def whitespace(leaf: Leaf) -> str:
         if t == token.EQUAL:
             return NO
 
         if t == token.EQUAL:
             return NO
 
-        prev = leaf.prev_sibling
         if not prev:
             prevp = preceding_leaf(p)
             if not prevp or prevp.type == token.LPAR:
         if not prev:
             prevp = preceding_leaf(p)
             if not prevp or prevp.type == token.LPAR:
@@ -862,88 +896,27 @@ def whitespace(leaf: Leaf) -> str:
         return NO
 
     elif p.type == syms.dotted_name:
         return NO
 
     elif p.type == syms.dotted_name:
-        prev = leaf.prev_sibling
         if prev:
             return NO
 
         prevp = preceding_leaf(p)
         if prev:
             return NO
 
         prevp = preceding_leaf(p)
-        if not prevp or prevp.type == token.AT:
+        if not prevp or prevp.type == token.AT or prevp.type == token.DOT:
             return NO
 
     elif p.type == syms.classdef:
         if t == token.LPAR:
             return NO
 
             return NO
 
     elif p.type == syms.classdef:
         if t == token.LPAR:
             return NO
 
-        prev = leaf.prev_sibling
         if prev and prev.type == token.LPAR:
             return NO
 
     elif p.type == syms.subscript:
         # indexing
         if prev and prev.type == token.LPAR:
             return NO
 
     elif p.type == syms.subscript:
         # indexing
-        if t == token.COLON:
-            return NO
-
-        prev = leaf.prev_sibling
         if not prev or prev.type == token.COLON:
             return NO
 
         if not prev or prev.type == token.COLON:
             return NO
 
-    elif p.type in {
-        syms.test,
-        syms.not_test,
-        syms.xor_expr,
-        syms.or_test,
-        syms.and_test,
-        syms.arith_expr,
-        syms.shift_expr,
-        syms.yield_expr,
-        syms.term,
-        syms.power,
-        syms.comparison,
-    }:
-        # various arithmetic and logic expressions
-        prev = leaf.prev_sibling
-        if not prev:
-            prevp = preceding_leaf(p)
-            if not prevp or prevp.type in OPENING_BRACKETS:
-                return NO
-
-            if prevp.type == token.EQUAL:
-                if prevp.parent and prevp.parent.type in {
-                    syms.varargslist, syms.parameters, syms.arglist, syms.argument
-                }:
-                    return NO
-
-        return SPACE
-
     elif p.type == syms.atom:
     elif p.type == syms.atom:
-        if t in CLOSING_BRACKETS:
-            return NO
-
-        prev = leaf.prev_sibling
-        if not prev:
-            prevp = preceding_leaf(p)
-            if not prevp:
-                return NO
-
-            if prevp.type in OPENING_BRACKETS:
-                return NO
-
-            if prevp.type == token.EQUAL:
-                if prevp.parent and prevp.parent.type in {
-                    syms.varargslist, syms.parameters, syms.arglist, syms.argument
-                }:
-                    return NO
-
-            if prevp.type == token.DOUBLESTAR:
-                if prevp.parent and prevp.parent.type in {
-                    syms.varargslist, syms.parameters, syms.arglist, syms.dictsetmaker
-                }:
-                    return NO
-
-        elif prev.type in OPENING_BRACKETS:
-            return NO
-
-        elif t == token.DOT:
+        if prev and t == token.DOT:
             # dots, but not the first one.
             return NO
 
             # dots, but not the first one.
             return NO
 
@@ -953,13 +926,11 @@ def whitespace(leaf: Leaf) -> str:
         p.type == syms.subscriptlist
     ):
         # list interior, including unpacking
         p.type == syms.subscriptlist
     ):
         # list interior, including unpacking
-        prev = leaf.prev_sibling
         if not prev:
             return NO
 
     elif p.type == syms.dictsetmaker:
         # dict and set interior, including unpacking
         if not prev:
             return NO
 
     elif p.type == syms.dictsetmaker:
         # dict and set interior, including unpacking
-        prev = leaf.prev_sibling
         if not prev:
             return NO
 
         if not prev:
             return NO
 
@@ -968,7 +939,6 @@ def whitespace(leaf: Leaf) -> str:
 
     elif p.type == syms.factor or p.type == syms.star_expr:
         # unary ops
 
     elif p.type == syms.factor or p.type == syms.star_expr:
         # unary ops
-        prev = leaf.prev_sibling
         if not prev:
             prevp = preceding_leaf(p)
             if not prevp or prevp.type in OPENING_BRACKETS:
         if not prev:
             prevp = preceding_leaf(p)
             if not prevp or prevp.type in OPENING_BRACKETS:
@@ -987,10 +957,17 @@ def whitespace(leaf: Leaf) -> str:
         elif t == token.NAME or t == token.NUMBER:
             return NO
 
         elif t == token.NAME or t == token.NUMBER:
             return NO
 
-    elif p.type == syms.import_from and t == token.NAME:
-        prev = leaf.prev_sibling
-        if prev and prev.type == token.DOT:
-            return NO
+    elif p.type == syms.import_from:
+        if t == token.DOT:
+            if prev and prev.type == token.DOT:
+                return NO
+
+        elif t == token.NAME:
+            if v == 'import':
+                return SPACE
+
+            if prev and prev.type == token.DOT:
+                return NO
 
     elif p.type == syms.sliceop:
         return NO
 
     elif p.type == syms.sliceop:
         return NO
vim configuration

Legalese

All content available in this repository is copyright © martin f. krafft, unless otherwise noted.

All files and their content are released under the terms of the Artistic Licence 2.0, unless otherwise noted.

The operator of this repository shall not be held liable for offending content in pages linking to or linked from these page, nor does he endorse their content unless stated otherwise.