Fix spacing of general (non-specific) tokens + tests

src/client/formatters/lineFormatter.ts

@@ -5,14 +5,15 @@
 import Char from 'typescript-char';
 import { BraceCounter } from '../language/braceCounter';
 import { TextBuilder } from '../language/textBuilder';
+import { TextRangeCollection } from '../language/textRangeCollection';
 import { Tokenizer } from '../language/tokenizer';
 import { ITextRangeCollection, IToken, TokenType } from '../language/types';
 
 export class LineFormatter {
-    private builder: TextBuilder;
-    private tokens: ITextRangeCollection<IToken>;
-    private braceCounter: BraceCounter;
-    private text: string;
+    private builder = new TextBuilder();
+    private tokens: ITextRangeCollection<IToken> = new TextRangeCollection<IToken>([]);
+    private braceCounter = new BraceCounter();
+    private text = '';
 
     // tslint:disable-next-line:cyclomatic-complexity
     public formatLine(text: string): string {
@@ -72,7 +73,7 @@ export class LineFormatter {
                     break;
 
                 default:
-                    this.handleOther(t);
+                    this.handleOther(t, i);
                     break;
             }
         }
@@ -108,24 +109,54 @@ export class LineFormatter {
         if (this.braceCounter.isOpened(TokenType.OpenBrace)) {
             // Check if this is = in function arguments. If so, do not
             // add spaces around it.
-            const prev = this.tokens.getItemAt(index - 1);
-            const prevPrev = this.tokens.getItemAt(index - 2);
-            if (prev.type === TokenType.Identifier &&
-                (prevPrev.type === TokenType.Comma || prevPrev.type === TokenType.OpenBrace)) {
+            if (this.isEqualsInsideArguments(index)) {
                 this.builder.append('=');
                 return true;
             }
         }
         return false;
     }
 
-    private handleOther(t: IToken): void {
+    private handleOther(t: IToken, index: number): void {
         if (this.isBraceType(t.type)) {
             this.braceCounter.countBrace(t);
+            this.builder.append(this.text.substring(t.start, t.end));
+            return;
+        }
+
+        if (this.isEqualsInsideArguments(index - 1)) {
+            // Don't add space around = inside function arguments
+            this.builder.append(this.text.substring(t.start, t.end));
+            return;
+        }
+
+        if (index > 0) {
+            const prev = this.tokens.getItemAt(index - 1);
+            if (this.isOpenBraceType(prev.type)) {
+                // Don't insert space after (, [ or {
+                this.builder.append(this.text.substring(t.start, t.end));
+                return;
+            }
         }
+
+        // In general, keep tokes separated
+        this.builder.softAppendSpace();
         this.builder.append(this.text.substring(t.start, t.end));
     }
 
+    private isEqualsInsideArguments(index: number): boolean {
+        if (index < 2) {
+            return false;
+        }
+        const prev = this.tokens.getItemAt(index - 1);
+        const prevPrev = this.tokens.getItemAt(index - 2);
+        if (prev.type === TokenType.Identifier &&
+            (prevPrev.type === TokenType.Comma || prevPrev.type === TokenType.OpenBrace)) {
+            return true;
+        }
+        return false;
+    }
+
     private isOpenBraceType(type: TokenType): boolean {
         return type === TokenType.OpenBrace || type === TokenType.OpenBracket || type === TokenType.OpenCurly;
     }

src/test/format/extension.onEnterFormat.test.ts

@@ -59,8 +59,23 @@ suite('Formatting - OnEnter provider', () => {
         assert.equal(text, 'x.y', 'Line ending with period was reformatted');
     });
 
-    test('Formatting line ending in string', async () => {
+    test('Formatting line with unknown neighboring tokens', async () => {
         const text = await formatAtPosition(9, 0);
+        assert.equal(text, 'if x <= 1:', 'Line with unknown neighboring tokens was not formatted');
+    });
+
+    test('Formatting method definition with arguments', async () => {
+        const text = await formatAtPosition(10, 0);
+        assert.equal(text, 'def __init__(self, age=23)', 'Method definition with arguments was not formatted');
+    });
+
+    test('Formatting space after open brace', async () => {
+        const text = await formatAtPosition(11, 0);
+        assert.equal(text, 'while(1)', 'Method definition with arguments was not formatted');
+    });
+
+    test('Formatting line ending in string', async () => {
+        const text = await formatAtPosition(12, 0);
         assert.equal(text, 'x + """', 'Line ending in multiline string was not formatted');
     });
 

src/test/pythonFiles/formatting/fileToFormatOnEnter.py

@@ -6,4 +6,7 @@
 x+1 # 
 @x
 x.y
+if x<=1:
+def __init__(self, age = 23)
+while(1)  
 x+"""