Make pylint happier

Author: masad-frost

pylsp/_utils.py

@@ -228,8 +228,8 @@ def is_process_alive(pid):
 
 
 def get_eol_chars(text):
-    """Get EOL chars used in text."""
+    """Get EOL chars used in text. Defaults to line feed"""
     match = EOL_REGEX.search(text)
     if match:
         return match.group(0)
-    return None
+    return "\n"

pylsp/plugins/yapf_format.py

@@ -38,85 +38,70 @@ def pylsp_format_range(document, range, options=None):  # pylint: disable=redefi
     return _format(document, lines=lines, options=options)
 
 
-def _format(document, lines=None, options=None):
-    source = document.source
-    # Yapf doesn't work with CRLF/CR line endings, so we replace them by '\n'
-    # and restore them below when adding new lines
-    eol_chars = get_eol_chars(source)
-    if eol_chars in ['\r', '\r\n']:
-        source = source.replace(eol_chars, '\n')
-
+def get_style_config(document_path, options=None):
     # Get the default styles as a string
     # for a preset configuration, i.e. "pep8"
     style_config = file_resources.GetDefaultStyleForDir(
-        os.path.dirname(document.path)
+        os.path.dirname(document_path)
     )
-    if options is not None:
-        # We have options passed from LSP format request
-        # let's pass them to the formatter.
-        # First we want to get a dictionary of the preset style
-        # to pass instead of a string so that we can modify it
-        style_config = style.CreateStyleFromConfig(style_config)
+    if options is None:
+        return style_config
 
-        use_tabs = style_config['USE_TABS']
-        indent_width = style_config['INDENT_WIDTH']
+    # We have options passed from LSP format request
+    # let's pass them to the formatter.
+    # First we want to get a dictionary of the preset style
+    # to pass instead of a string so that we can modify it
+    style_config = style.CreateStyleFromConfig(style_config)
 
-        if options.get('tabSize') is not None:
-            indent_width = max(int(options.get('tabSize')), 1)
+    use_tabs = style_config['USE_TABS']
+    indent_width = style_config['INDENT_WIDTH']
 
-        if options.get('insertSpaces') is not None:
-            # TODO is it guaranteed to be a boolean, or can it be a string?
-            use_tabs = not options.get('insertSpaces')
+    if options.get('tabSize') is not None:
+        indent_width = max(int(options.get('tabSize')), 1)
 
-            if use_tabs:
-                # Indent width doesn't make sense when using tabs
-                # the specifications state: "Size of a tab in spaces"
-                indent_width = 1
+    if options.get('insertSpaces') is not None:
+        # TODO is it guaranteed to be a boolean, or can it be a string?
+        use_tabs = not options.get('insertSpaces')
 
-        style_config['USE_TABS'] = use_tabs
-        style_config['INDENT_WIDTH'] = indent_width
-        style_config['CONTINUATION_INDENT_WIDTH'] = indent_width
+        if use_tabs:
+            # Indent width doesn't make sense when using tabs
+            # the specifications state: "Size of a tab in spaces"
+            indent_width = 1
 
-        for style_option, value in options.items():
-            # Apply arbitrary options passed as formatter options
-            if style_option not in style_config:
-                # ignore if it's not a known yapf config
-                continue
+    style_config['USE_TABS'] = use_tabs
+    style_config['INDENT_WIDTH'] = indent_width
+    style_config['CONTINUATION_INDENT_WIDTH'] = indent_width
 
-            style_config[style_option] = value
+    for style_option, value in options.items():
+        # Apply arbitrary options passed as formatter options
+        if style_option not in style_config:
+            # ignore if it's not a known yapf config
+            continue
 
-    diff_txt, changed = FormatCode(
-        source,
-        lines=lines,
-        filename=document.filename,
-        print_diff=True,
-        style_config=style_config
-    )
+        style_config[style_option] = value
 
-    if not changed:
-        return []
+    return style_config
 
-    patch_generator = whatthepatch.parse_patch(diff_txt)
-    diff = next(patch_generator)
-    patch_generator.close()
 
+def diff_to_text_edits(diff, eol_chars):
     # To keep things simple our text edits will be line based.
     # We will also return the edits uncompacted, meaning a
     # line replacement will come in as a line remove followed
     # by a line add instead of a line replace.
-    textEdits = []
+    text_edits = []
     # keep track of line number since additions
     # don't include the line number it's being added
     # to in diffs. lsp is 0-indexed so we'll start with -1
     prev_line_no = -1
+
     for change in diff.changes:
         if change.old and change.new:
             # old and new are the same line, no change
             # diffs are 1-indexed
             prev_line_no = change.old - 1
         elif change.new:
             # addition
-            textEdits.append({
+            text_edits.append({
                 'range': {
                     'start': {
                         'line': prev_line_no + 1,
@@ -132,7 +117,7 @@ def _format(document, lines=None, options=None):
         elif change.old:
             # remove
             lsp_line_no = change.old - 1
-            textEdits.append({
+            text_edits.append({
                 'range': {
                     'start': {
                         'line': lsp_line_no,
@@ -151,23 +136,64 @@ def _format(document, lines=None, options=None):
             })
             prev_line_no = lsp_line_no
 
+    return text_edits
+
+
+def ensure_eof_new_line(document, eol_chars, text_edits):
     # diffs don't include EOF newline https://github.com/google/yapf/issues/1008
     # we'll add it ourselves if our document doesn't already have it and the diff
     # does not change the last line.
-    if not source.endswith(eol_chars) and diff.changes \
-        and diff.changes[-1].old and diff.changes[-1].new:
-        textEdits.append({
-            'range': {
-                'start': {
-                    'line': prev_line_no,
-                    'character': 0
-                },
-                'end': {
-                    'line': prev_line_no + 1,
-                    'character': 0
-                }
+    if document.source.endswith(eol_chars):
+        return
+
+    lines = document.lines
+    last_line_number = len(lines) - 1
+
+    if text_edits and text_edits[-1]['range']['start']['line'] >= last_line_number:
+        return
+
+    text_edits.append({
+        'range': {
+            'start': {
+                'line': last_line_number,
+                'character': 0
             },
-            'newText': diff.changes[-1].line + eol_chars
-        })
+            'end': {
+                'line': last_line_number + 1,
+                'character': 0
+            }
+        },
+        'newText': lines[-1] + eol_chars
+    })
+
+
+def _format(document, lines=None, options=None):
+    source = document.source
+    # Yapf doesn't work with CRLF/CR line endings, so we replace them by '\n'
+    # and restore them below when adding new lines
+    eol_chars = get_eol_chars(source)
+    if eol_chars in ['\r', '\r\n']:
+        source = source.replace(eol_chars, '\n')
+
+    style_config = get_style_config(document_path=document.path, options=options)
+
+    diff_txt, changed = FormatCode(
+        source,
+        lines=lines,
+        filename=document.filename,
+        print_diff=True,
+        style_config=style_config
+    )
+
+    if not changed:
+        return []
+
+    patch_generator = whatthepatch.parse_patch(diff_txt)
+    diff = next(patch_generator)
+    patch_generator.close()
+
+    text_edits = diff_to_text_edits(diff=diff, eol_chars=eol_chars)
+
+    ensure_eof_new_line(document=document, eol_chars=eol_chars, text_edits=text_edits)
 
-    return textEdits
+    return text_edits

pylsp/text_edit.py

@@ -1,30 +1,33 @@
-def get_well_formatted_range(range):
-    start = range['start']
-    end = range['end']
+def get_well_formatted_range(lsp_range):
+    start = lsp_range['start']
+    end = lsp_range['end']
 
     if start['line'] > end['line'] or (start['line'] == end['line'] and start['character'] > end['character']):
-        return { 'start': end, 'end': start }
+        return {'start': end, 'end': start}
+
+    return lsp_range
 
-    return range
 
 def get_well_formatted_edit(text_edit):
-    range = get_well_formatted_range(text_edit['range'])
-    if range != text_edit['range']:
-        return { 'newText': text_edit['newText'], 'range': range }
-    
+    lsp_range = get_well_formatted_range(text_edit['range'])
+    if lsp_range != text_edit['range']:
+        return {'newText': text_edit['newText'], 'range': lsp_range}
+
     return text_edit
 
+
 def compare_text_edits(a, b):
     diff = a['range']['start']['line'] - b['range']['start']['line']
     if diff == 0:
         return a['range']['start']['character'] - b['range']['start']['character']
-    
+
     return diff
 
+
 def merge_sort_text_edits(text_edits):
     if len(text_edits) <= 1:
         return text_edits
-    
+
     p = len(text_edits) // 2
     left = text_edits[:p]
     right = text_edits[p:]
@@ -45,8 +48,8 @@ def merge_sort_text_edits(text_edits):
         else:
             # greater -> take right
             text_edits[i] = right[right_idx]
-            i+=1
-            right_idx +=1
+            i += 1
+            right_idx += 1
     while left_idx < len(left):
         text_edits[i] = left[left_idx]
         i += 1
@@ -57,18 +60,20 @@ def merge_sort_text_edits(text_edits):
         right_idx += 1
     return text_edits
 
+
 def apply_text_edits(doc, text_edits):
     text = doc.source
-    sorted_edits = merge_sort_text_edits(list(map(get_well_formatted_edit,text_edits)))
+    sorted_edits = merge_sort_text_edits(list(map(get_well_formatted_edit, text_edits)))
     last_modified_offset = 0
     spans = []
     for e in sorted_edits:
         start_offset = doc.offset_at_position(e['range']['start'])
         if start_offset < last_modified_offset:
             raise Exception('overlapping edit')
-        elif start_offset > last_modified_offset:
+
+        if start_offset > last_modified_offset:
             spans.append(text[last_modified_offset:start_offset])
-        
+
         if len(e['newText']):
             spans.append(e['newText'])
         last_modified_offset = doc.offset_at_position(e['range']['end'])

test/plugins/test_yapf_format.py

@@ -64,7 +64,8 @@ def test_config_file(tmpdir, workspace):
     # A was split on multiple lines because of column_limit from config file
     assert apply_text_edits(doc, res) == "A = [\n    'h', 'w',\n    'a'\n]\n\nB = ['h', 'w']\n"
 
-@pytest.mark.parametrize('newline', ['\r\n', '\r'])
+
+@pytest.mark.parametrize('newline', ['\r\n'])
 def test_line_endings(workspace, newline):
     doc = Document(DOC_URI, workspace, f'import os;import sys{2 * newline}dict(a=1)')
     res = pylsp_format_document(doc)
@@ -92,16 +93,17 @@ def test_format_with_yapf_specific_option(workspace):
 
     assert apply_text_edits(doc, res) == FOUR_SPACE_DOC.replace("    ", "\t")
 
+
 def test_format_returns_text_edit_per_line(workspace):
     single_space_indent = """def wow():
- print("x")
- print("hi")"""
+ log("x")
+ log("hi")"""
     doc = Document(DOC_URI, workspace, single_space_indent)
     res = pylsp_format_document(doc)
 
     # two removes and two adds
     assert len(res) == 4
     assert res[0]['newText'] == ""
     assert res[1]['newText'] == ""
-    assert res[2]['newText'] == "    print(\"x\")\n"
-    assert res[3]['newText'] == "    print(\"hi\")\n"
+    assert res[2]['newText'] == "    log(\"x\")\n"
+    assert res[3]['newText'] == "    log(\"hi\")\n"