From f62d92972256e98045f106a3883ed46443331fc0 Mon Sep 17 00:00:00 2001 From: Xiao Wang Date: Thu, 18 Aug 2022 10:40:01 +0200 Subject: [PATCH 1/9] features to align assignment operators and dictionary colons --- yapf/pytree/comment_splicer.py | 1 - yapf/pytree/subtype_assigner.py | 16 +- yapf/yapflib/format_decision_state.py | 1 + yapf/yapflib/format_token.py | 89 +++++ yapf/yapflib/reformatter.py | 508 ++++++++++++++++++++++++++ yapf/yapflib/style.py | 24 ++ yapf/yapflib/subtypes.py | 1 + yapftests/format_token_test.py | 34 +- yapftests/reformatter_basic_test.py | 368 ++++++++++++++++++- yapftests/subtype_assigner_test.py | 109 +++++- yapftests/yapf_test.py | 2 +- 11 files changed, 1138 insertions(+), 15 deletions(-) diff --git a/yapf/pytree/comment_splicer.py b/yapf/pytree/comment_splicer.py index ae5ffe66f..9e8f02c48 100644 --- a/yapf/pytree/comment_splicer.py +++ b/yapf/pytree/comment_splicer.py @@ -42,7 +42,6 @@ def SpliceComments(tree): # This is a list because Python 2.x doesn't have 'nonlocal' :) prev_leaf = [None] _AnnotateIndents(tree) - def _VisitNodeRec(node): """Recursively visit each node to splice comments into the AST.""" # This loop may insert into node.children, so we'll iterate over a copy. diff --git a/yapf/pytree/subtype_assigner.py b/yapf/pytree/subtype_assigner.py index dd3ea3d1e..03d7efe1a 100644 --- a/yapf/pytree/subtype_assigner.py +++ b/yapf/pytree/subtype_assigner.py @@ -240,6 +240,7 @@ def Visit_argument(self, node): # pylint: disable=invalid-name # argument ::= # test [comp_for] | test '=' test self._ProcessArgLists(node) + #TODO add a subtype to each argument? def Visit_arglist(self, node): # pylint: disable=invalid-name # arglist ::= @@ -300,6 +301,7 @@ def Visit_typedargslist(self, node): # pylint: disable=invalid-name for i in range(1, len(node.children)): prev_child = node.children[i - 1] child = node.children[i] + if prev_child.type == grammar_token.COMMA: _AppendFirstLeafTokenSubtype(child, subtypes.PARAMETER_START) elif child.type == grammar_token.COMMA: @@ -309,6 +311,10 @@ def Visit_typedargslist(self, node): # pylint: disable=invalid-name tname = True _SetArgListSubtype(child, subtypes.TYPED_NAME, subtypes.TYPED_NAME_ARG_LIST) + # NOTE Every element of the tynamme argument list + # should have this list type + _AppendSubtypeRec(child, subtypes.TYPED_NAME_ARG_LIST) + elif child.type == grammar_token.COMMA: tname = False elif child.type == grammar_token.EQUAL and tname: @@ -383,21 +389,25 @@ def HasSubtype(node): for child in node.children: node_name = pytree_utils.NodeName(child) + #TODO exclude it if the first leaf is a comment in appendfirstleaftokensubtype if node_name not in {'atom', 'COMMA'}: _AppendFirstLeafTokenSubtype(child, list_subtype) + def _AppendTokenSubtype(node, subtype): """Append the token's subtype only if it's not already set.""" pytree_utils.AppendNodeAnnotation(node, pytree_utils.Annotation.SUBTYPE, subtype) - +#TODO should exclude comment child to all Appendsubtypes functions def _AppendFirstLeafTokenSubtype(node, subtype): """Append the first leaf token's subtypes.""" + #TODO exclude the comment leaf if isinstance(node, pytree.Leaf): - _AppendTokenSubtype(node, subtype) - return + _AppendTokenSubtype(node, subtype) + return + _AppendFirstLeafTokenSubtype(node.children[0], subtype) diff --git a/yapf/yapflib/format_decision_state.py b/yapf/yapflib/format_decision_state.py index c299d1c85..efcef0ba4 100644 --- a/yapf/yapflib/format_decision_state.py +++ b/yapf/yapflib/format_decision_state.py @@ -978,6 +978,7 @@ def _GetNewlineColumn(self): not self.param_list_stack[-1].SplitBeforeClosingBracket( top_of_stack.indent) and top_of_stack.indent == ((self.line.depth + 1) * style.Get('INDENT_WIDTH'))): + # NOTE: comment inside argument list is not excluded in subtype assigner if (subtypes.PARAMETER_START in current.subtypes or (previous.is_comment and subtypes.PARAMETER_START in previous.subtypes)): diff --git a/yapf/yapflib/format_token.py b/yapf/yapflib/format_token.py index 6eea05473..f8658f772 100644 --- a/yapf/yapflib/format_token.py +++ b/yapf/yapflib/format_token.py @@ -14,6 +14,7 @@ """Enhanced token information for formatting.""" import keyword +from operator import sub import re from lib2to3.pgen2 import token @@ -124,6 +125,7 @@ def __init__(self, node, name): self.subtypes = {subtypes.NONE} if not stypes else stypes self.is_pseudo = hasattr(node, 'is_pseudo') and node.is_pseudo + @property def formatted_whitespace_prefix(self): if style.Get('INDENT_BLANK_LINES'): @@ -322,3 +324,90 @@ def is_pytype_comment(self): def is_copybara_comment(self): return self.is_comment and re.match( r'#.*\bcopybara:\s*(strip|insert|replace)', self.value) + + + @property + def is_assign(self): + return subtypes.ASSIGN_OPERATOR in self.subtypes + + @property + def is_dict_colon(self): + # if the token is dictionary colon and + # the dictionary has no comp_for + return self.value == ':' and self.previous_token.is_dict_key + + @property + def is_dict_key(self): + # if the token is dictionary key which is not preceded by doubel stars and + # the dictionary has no comp_for + return subtypes.DICTIONARY_KEY_PART in self.subtypes + + @property + def is_dict_key_start(self): + # if the token is dictionary key start + return subtypes.DICTIONARY_KEY in self.subtypes + + @property + def is_dict_value(self): + return subtypes.DICTIONARY_VALUE in self.subtypes + + @property + def is_augassign(self): + augassigns = {'+=', '-=' , '*=' , '@=' , '/=' , '%=' , '&=' , '|=' , '^=' , + '<<=' , '>>=' , '**=' , '//='} + return self.value in augassigns + + @property + def is_argassign(self): + return (subtypes.DEFAULT_OR_NAMED_ASSIGN in self.subtypes + or subtypes.VARARGS_LIST in self.subtypes) + + @property + def is_argname(self): + # it's the argument part before argument assignment operator, + # including tnames and data type + # not the assign operator, + # not the value after the assign operator + + # argument without assignment is also included + # the token is arg part before '=' but not after '=' + if self.is_argname_start: + return True + + # exclude comment inside argument list + if not self.is_comment: + # the token is any element in typed arglist + if subtypes.TYPED_NAME_ARG_LIST in self.subtypes: + return True + + return False + + + @property + def is_argname_start(self): + # return true if it's the start of every argument entry + if self.previous_token: + previous_subtypes = self.previous_token.subtypes + + return ( + (not self.is_comment + and subtypes.DEFAULT_OR_NAMED_ASSIGN not in self.subtypes + and subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST in self.subtypes + and subtypes.DEFAULT_OR_NAMED_ASSIGN not in previous_subtypes + and (not subtypes.PARAMETER_STOP in self.subtypes + or subtypes.PARAMETER_START in self.subtypes) + ) + or # if there is comment, the arg after it is the argname start + (not self.is_comment and self.previous_token and self.previous_token.is_comment + and + (subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST in previous_subtypes + or subtypes.TYPED_NAME_ARG_LIST in self.subtypes + or subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST in self.subtypes)) + ) + + + + + + + diff --git a/yapf/yapflib/reformatter.py b/yapf/yapflib/reformatter.py index 14e0bde70..92aaa950e 100644 --- a/yapf/yapflib/reformatter.py +++ b/yapf/yapflib/reformatter.py @@ -22,6 +22,7 @@ from __future__ import unicode_literals import collections +from distutils.errors import LinkError import heapq import re @@ -102,6 +103,15 @@ def Reformat(llines, verify=False, lines=None): final_lines.append(lline) prev_line = lline + + if style.Get('ALIGN_ASSIGNMENT'): + _AlignAssignment(final_lines) + if (style.Get('EACH_DICT_ENTRY_ON_SEPARATE_LINE') + and style.Get('ALIGN_DICT_COLON')): + _AlignDictColon(final_lines) + if style.Get('ALIGN_ARGUMENT_ASSIGNMENT'): + _AlignArgAssign(final_lines) + _AlignTrailingComments(final_lines) return _FormatFinalLines(final_lines, verify) @@ -394,6 +404,504 @@ def _AlignTrailingComments(final_lines): final_lines_index += 1 +def _AlignAssignment(final_lines): + """Align assignment operators and augmented assignment operators to the same column""" + + final_lines_index = 0 + while final_lines_index < len(final_lines): + line = final_lines[final_lines_index] + + assert line.tokens + process_content = False + + for tok in line.tokens: + if tok.is_assign or tok.is_augassign: + # all pre assignment variable lengths in one block of lines + all_pa_variables_lengths = [] + max_variables_length = 0 + + while True: + # EOF + if final_lines_index + len(all_pa_variables_lengths) == len(final_lines): + break + + this_line_index = final_lines_index + len(all_pa_variables_lengths) + this_line = final_lines[this_line_index] + + next_line = None + if this_line_index < len(final_lines) - 1: + next_line = final_lines[final_lines_index + len(all_pa_variables_lengths) + 1 ] + + assert this_line.tokens, next_line.tokens + + # align them differently when there is a blank line in between + if (all_pa_variables_lengths and + this_line.tokens[0].formatted_whitespace_prefix.startswith('\n\n') + ): + break + + # if there is a standalone comment or keyword statement line + # or other lines without assignment in between, break + elif (all_pa_variables_lengths and + True not in [tok.is_assign or tok.is_augassign for tok in this_line.tokens]): + if this_line.tokens[0].is_comment: + if style.Get('NEW_ALIGNMENT_AFTER_COMMENTLINE'): + break + else: break + + if this_line.disable: + all_pa_variables_lengths.append([]) + continue + + variables_content = '' + pa_variables_lengths = [] + contain_object = False + line_tokens = this_line.tokens + # only one assignment expression is on each line + for index in range(len(line_tokens)): + line_tok = line_tokens[index] + + prefix = line_tok.formatted_whitespace_prefix + newline_index = prefix.rfind('\n') + if newline_index != -1: + variables_content = '' + prefix = prefix[newline_index + 1:] + + if line_tok.is_assign or line_tok.is_augassign: + next_toks = [line_tokens[i] for i in range(index+1, len(line_tokens))] + # if there is object(list/tuple/dict) with newline entries, break, + # update the alignment so far and start to calulate new alignment + for tok in next_toks: + if tok.value in ['(', '[', '{'] and tok.next_token: + if (tok.next_token.formatted_whitespace_prefix.startswith('\n') + or (tok.next_token.is_comment and tok.next_token.next_token.formatted_whitespace_prefix.startswith('\n'))): + pa_variables_lengths.append(len(variables_content)) + contain_object = True + break + if not contain_object: + if line_tok.is_assign: + pa_variables_lengths.append(len(variables_content)) + # if augassign, add the extra augmented part to the max length caculation + elif line_tok.is_augassign: + pa_variables_lengths.append(len(variables_content) + len(line_tok.value) - 1 ) + # don't add the tokens + # after the assignment operator + break + else: + variables_content += '{}{}'.format(prefix, line_tok.value) + + if pa_variables_lengths: + max_variables_length = max(max_variables_length, max(pa_variables_lengths)) + + all_pa_variables_lengths.append(pa_variables_lengths) + + # after saving this line's max variable length, + # we check if next line has the same depth as this line, + # if not, we don't want to calculate their max variable length together + # so we break the while loop, update alignment so far, and + # then go to next line that has '=' + if next_line: + if this_line.depth != next_line.depth: + break + # if this line contains objects with newline entries, + # start new block alignment + if contain_object: + break + + # if no update of max_length, just go to the next block + if max_variables_length == 0: continue + + max_variables_length += 2 + + # Update the assignment token values based on the max variable length + for all_pa_variables_lengths_index, pa_variables_lengths in enumerate( + all_pa_variables_lengths): + if not pa_variables_lengths: + continue + this_line = final_lines[final_lines_index + all_pa_variables_lengths_index] + + # only the first assignment operator on each line + pa_variables_lengths_index = 0 + for line_tok in this_line.tokens: + if line_tok.is_assign or line_tok.is_augassign: + assert pa_variables_lengths[0] < max_variables_length + + if pa_variables_lengths_index < len(pa_variables_lengths): + whitespace = ' ' * ( + max_variables_length - pa_variables_lengths[0] - 1) + + assign_content = '{}{}'.format(whitespace, line_tok.value.strip()) + + existing_whitespace_prefix = \ + line_tok.formatted_whitespace_prefix.lstrip('\n') + + # in case the existing spaces are larger than padded spaces + if (len(whitespace) == 1 or len(whitespace) > 1 and + len(existing_whitespace_prefix)>len(whitespace)): + line_tok.whitespace_prefix = '' + elif assign_content.startswith(existing_whitespace_prefix): + assign_content = assign_content[len(existing_whitespace_prefix):] + + # update the assignment operator value + line_tok.value = assign_content + + pa_variables_lengths_index += 1 + + final_lines_index += len(all_pa_variables_lengths) + + process_content = True + break + + if not process_content: + final_lines_index += 1 + + +def _AlignArgAssign(final_lines): + """Align the assign operators in a argument list to the same column""" + """NOTE One argument list of one function is on one logical line! + But funtion calls/argument lists can be in argument list. + """ + final_lines_index = 0 + while final_lines_index < len(final_lines): + line = final_lines[final_lines_index] + if line.disable: + final_lines_index += 1 + continue + + assert line.tokens + process_content = False + + for tok in line.tokens: + if tok.is_argassign: + + this_line = line + line_tokens = this_line.tokens + + for open_index in range(len(line_tokens)): + line_tok = line_tokens[open_index] + + if (line_tok.value == '(' and not line_tok.is_pseudo + and line_tok.next_token.formatted_whitespace_prefix.startswith('\n')): + index = open_index + # skip the comments in the beginning + index += 1 + line_tok = line_tokens[index] + while not line_tok.is_argname_start and index < len(line_tokens)-1: + index += 1 + line_tok = line_tokens[index] + + # check if the argstart is on newline + if line_tok.is_argname_start and line_tok.formatted_whitespace_prefix.startswith('\n'): + first_arg_index = index + first_arg_column = len(line_tok.formatted_whitespace_prefix.lstrip('\n')) + + closing = False + all_arg_name_lengths = [] + arg_name_lengths = [] + name_content = '' + arg_column = first_arg_column + + # start with the first argument + # that has nextline prefix + while not closing: + # if there is a comment in between, save, reset and continue to calulate new alignment + if (style.Get('NEW_ALIGNMENT_AFTER_COMMENTLINE') + and arg_name_lengths and line_tok.is_comment + and line_tok.formatted_whitespace_prefix.startswith('\n')): + all_arg_name_lengths.append(arg_name_lengths) + arg_name_lengths = [] + index += 1 + line_tok = line_tokens[index] + continue + + prefix = line_tok.formatted_whitespace_prefix + newline_index = prefix.rfind('\n') + + if newline_index != -1: + if line_tok.is_argname_start: + name_content = '' + prefix = prefix[newline_index + 1:] + arg_column = len(prefix) + # if a typed arg name is so long + # that there are newlines inside + # only calulate the last line arg_name that has the assignment + elif line_tok.is_argname: + name_content = '' + prefix = prefix[newline_index + 1:] + # if any argument not on newline + elif line_tok.is_argname_start: + name_content = '' + arg_column = line_tok.column + # in case they are formatted into one line in final_line + # but are put in separated lines in original codes + if arg_column == first_arg_column: + arg_column = line_tok.formatted_whitespace_prefix + # on the same argument level + if (line_tok.is_argname_start and arg_name_lengths + and arg_column==first_arg_column): + argname_end = line_tok + while argname_end.is_argname: + argname_end = argname_end.next_token + # argument without assignment in between + if not argname_end.is_argassign: + all_arg_name_lengths.append(arg_name_lengths) + arg_name_lengths = [] + index += 1 + line_tok = line_tokens[index] + continue + + if line_tok.is_argassign and arg_column == first_arg_column: + arg_name_lengths.append(len(name_content)) + elif line_tok.is_argname and arg_column == first_arg_column: + name_content += '{}{}'.format(prefix, line_tok.value) + # add up all token values before the arg assign operator + + index += 1 + if index < len(line_tokens): + line_tok = line_tokens[index] + # when the matching closing bracket never found + # due to edge cases where the closing bracket + # is not indented or dedented + else: + all_arg_name_lengths.append(arg_name_lengths) + break + + # if there is a new object(list/tuple/dict) with its entries on newlines, + # save, reset and continue to calulate new alignment + if (line_tok.value in ['(', '[','{'] and line_tok.next_token + and line_tok.next_token.formatted_whitespace_prefix.startswith('\n')): + if arg_name_lengths: + all_arg_name_lengths.append(arg_name_lengths) + arg_name_lengths = [] + index += 1 + line_tok = line_tokens[index] + continue + + if line_tok.value == ')'and not line_tok.is_pseudo: + if line_tok.formatted_whitespace_prefix.startswith('\n'): + close_column = len(line_tok.formatted_whitespace_prefix.lstrip('\n')) + else: close_column = line_tok.column + if close_column < first_arg_column: + if arg_name_lengths: + all_arg_name_lengths.append(arg_name_lengths) + closing = True + + # update the alignment once one full arg list is processed + if all_arg_name_lengths: + # if argument list with only the first argument on newline + if len(all_arg_name_lengths) == 1 and len(all_arg_name_lengths[0]) == 1: + continue + max_name_length = 0 + all_arg_name_lengths_index = 0 + arg_name_lengths = all_arg_name_lengths[all_arg_name_lengths_index] + max_name_length = max(arg_name_lengths or [0]) + 2 + arg_lengths_index = 0 + for token in line_tokens[first_arg_index:index]: + if token.is_argassign: + name_token = token.previous_token + while name_token.is_argname and not name_token.is_argname_start: + name_token = name_token.previous_token + name_column = len(name_token.formatted_whitespace_prefix.lstrip('\n')) + if name_column == first_arg_column: + if all_arg_name_lengths_index < len(all_arg_name_lengths): + if arg_lengths_index == len(arg_name_lengths): + all_arg_name_lengths_index += 1 + arg_name_lengths = all_arg_name_lengths[all_arg_name_lengths_index] + max_name_length = max(arg_name_lengths or [0]) + 2 + arg_lengths_index = 0 + + if arg_lengths_index < len(arg_name_lengths): + + assert arg_name_lengths[arg_lengths_index] < max_name_length + + padded_spaces = ' ' * ( + max_name_length - arg_name_lengths[arg_lengths_index] - 1) + arg_lengths_index += 1 + + assign_content = '{}{}'.format(padded_spaces, token.value.strip()) + existing_whitespace_prefix = \ + token.formatted_whitespace_prefix.lstrip('\n') + + # in case the existing spaces are larger than padded spaces + if (len(padded_spaces)==1 or len(padded_spaces)>1 and + len(existing_whitespace_prefix)>len(padded_spaces)): + token.whitespace_prefix = '' + elif assign_content.startswith(existing_whitespace_prefix): + assign_content = assign_content[len(existing_whitespace_prefix):] + + token.value = assign_content + + final_lines_index += 1 + process_content = True + break + + if not process_content: + final_lines_index += 1 + + +def _AlignDictColon(final_lines): + """Align colons in a dict to the same column""" + """NOTE One (nested) dict/list is one logical line!""" + final_lines_index = 0 + while final_lines_index < len(final_lines): + line = final_lines[final_lines_index] + if line.disable: + final_lines_index += 1 + continue + + assert line.tokens + process_content = False + + for tok in line.tokens: + # make sure each dict entry on separate lines and + # the dict has more than one entry + if (tok.is_dict_key and tok.formatted_whitespace_prefix.startswith('\n') and + not tok.is_comment): + + this_line = line + + line_tokens = this_line.tokens + for open_index in range(len(line_tokens)): + line_tok = line_tokens[open_index] + + # check each time if the detected dict is the dict we aim for + if line_tok.value == '{' and line_tok.next_token.formatted_whitespace_prefix.startswith('\n'): + index = open_index + # skip the comments in the beginning + index += 1 + line_tok = line_tokens[index] + while not line_tok.is_dict_key and index < len(line_tokens)-1: + index += 1 + line_tok = line_tokens[index] + # in case empty dict, check if dict key again + if line_tok.is_dict_key and line_tok.formatted_whitespace_prefix.startswith('\n'): + closing = False # the closing bracket in dict '}'. + keys_content = '' + all_dict_keys_lengths = [] + dict_keys_lengths = [] + + # record the column number of the first key + first_key_column = len(line_tok.formatted_whitespace_prefix.lstrip('\n')) + key_column = first_key_column + + # while not closing: + while not closing: + prefix = line_tok.formatted_whitespace_prefix + newline = prefix.startswith('\n') + if newline: + # if comments inbetween, save, reset and continue to caluclate new alignment + if (style.Get('NEW_ALIGNMENT_AFTER_COMMENTLINE') + and dict_keys_lengths and line_tok.is_comment): + all_dict_keys_lengths.append(dict_keys_lengths) + dict_keys_lengths =[] + index += 1 + line_tok = line_tokens[index] + continue + if line_tok.is_dict_key_start: + keys_content = '' + prefix = prefix.lstrip('\n') + key_column = len(prefix) + # if the dict key is so long that it has multi-lines + # only caculate the last line that has the colon + elif line_tok.is_dict_key: + keys_content = '' + prefix = prefix.lstrip('\n') + elif line_tok.is_dict_key_start: + key_column = line_tok.column + + if line_tok.is_dict_colon and key_column == first_key_column: + dict_keys_lengths.append(len(keys_content)) + elif line_tok.is_dict_key and key_column == first_key_column: + keys_content += '{}{}'.format(prefix, line_tok.value) + + index += 1 + if index < len(line_tokens): + line_tok = line_tokens[index] + # when the matching closing bracket never found + # due to edge cases where the closing bracket + # is not indented or dedented, e.g. ']}', with another bracket before + else: + all_dict_keys_lengths.append(dict_keys_lengths) + break + + # if there is new objects(list/tuple/dict) with its entries on newlines, + # or a function call with any of its arguments on newlines, + # save, reset and continue to calulate new alignment + if (line_tok.value in ['(', '[', '{'] and not line_tok.is_pseudo and line_tok.next_token + and line_tok.next_token.formatted_whitespace_prefix.startswith('\n')): + if dict_keys_lengths: + all_dict_keys_lengths.append(dict_keys_lengths) + dict_keys_lengths = [] + index += 1 + line_tok = line_tokens[index] + continue + # the matching closing bracket is either same indented or dedented + # accordingly to previous level's indentation + # the first found, immediately break the while loop + if line_tok.value == '}': + if line_tok.formatted_whitespace_prefix.startswith('\n'): + close_column = len(line_tok.formatted_whitespace_prefix.lstrip('\n')) + else: close_column = line_tok.column + if close_column < first_key_column: + if dict_keys_lengths: + all_dict_keys_lengths.append(dict_keys_lengths) + closing = True + + # update the alignment once one dict is processed + if all_dict_keys_lengths: + max_keys_length = 0 + all_dict_keys_lengths_index = 0 + dict_keys_lengths = all_dict_keys_lengths[all_dict_keys_lengths_index] + max_keys_length = max(dict_keys_lengths or [0]) + 2 + keys_lengths_index = 0 + for token in line_tokens[open_index+1:index]: + if token.is_dict_colon: + # check if the key has multiple tokens and + # get the first key token in this key + key_token = token.previous_token + while key_token.previous_token.is_dict_key: + key_token = key_token.previous_token + key_column = len(key_token.formatted_whitespace_prefix.lstrip('\n')) + + if key_column == first_key_column: + + if keys_lengths_index == len(dict_keys_lengths): + all_dict_keys_lengths_index += 1 + dict_keys_lengths = all_dict_keys_lengths[all_dict_keys_lengths_index] + max_keys_length = max(dict_keys_lengths or [0]) + 2 + keys_lengths_index = 0 + + if keys_lengths_index < len(dict_keys_lengths): + assert dict_keys_lengths[keys_lengths_index] < max_keys_length + + padded_spaces = ' ' * ( + max_keys_length - dict_keys_lengths[keys_lengths_index] - 1) + keys_lengths_index += 1 + #NOTE if the existing whitespaces are larger than padded spaces + existing_whitespace_prefix = \ + token.formatted_whitespace_prefix.lstrip('\n') + colon_content = '{}{}'.format(padded_spaces, token.value.strip()) + + # in case the existing spaces are larger than the paddes spaces + if (len(padded_spaces) == 1 or len(padded_spaces) > 1 + and len(existing_whitespace_prefix) >= len(padded_spaces)): + # remove the existing spaces + token.whitespace_prefix = '' + elif colon_content.startswith(existing_whitespace_prefix): + colon_content = colon_content[len(existing_whitespace_prefix):] + + token.value = colon_content + + final_lines_index += 1 + + process_content = True + break + + if not process_content: + final_lines_index += 1 + + + def _FormatFinalLines(final_lines, verify): """Compose the final output from the finalized lines.""" formatted_code = [] diff --git a/yapf/yapflib/style.py b/yapf/yapflib/style.py index 233a64e6b..a4c54b5f8 100644 --- a/yapf/yapflib/style.py +++ b/yapf/yapflib/style.py @@ -54,6 +54,22 @@ def SetGlobalStyle(style): _STYLE_HELP = dict( ALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENT=textwrap.dedent("""\ Align closing bracket with visual indentation."""), + ALIGN_ASSIGNMENT=textwrap.dedent("""\ + Align assignment or augmented assignment operators. + If there is a blank line or newline comment or objects with newline entries in between, + it will start new block alignment."""), + ALIGN_ARGUMENT_ASSIGNMENT=textwrap.dedent("""\ + Align assignment operators in the argument list if they are all split on newlines. + Arguments without assignment are ignored. + Arguments without assignment in between will initiate new block alignment calulation. + Newline comments or objects with newline entries will also start new block alignment."""), + ALIGN_DICT_COLON=textwrap.dedent("""\ + Align the colons in the dictionary + if all entries in dictionay are split on newlines. + and 'EACH_DICT_ENTRY_ON_SEPERATE_LINE' set True. + """), + NEW_ALIGNMENT_AFTER_COMMENTLINE=textwrap.dedent("""\ + Start new assignment or colon alignment when there is a newline comment in between."""), ALLOW_MULTILINE_LAMBDAS=textwrap.dedent("""\ Allow lambdas to be formatted on more than one line."""), ALLOW_MULTILINE_DICTIONARY_KEYS=textwrap.dedent("""\ @@ -419,6 +435,10 @@ def CreatePEP8Style(): """Create the PEP8 formatting style.""" return dict( ALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENT=True, + ALIGN_ASSIGNMENT=False, + ALIGN_ARGUMENT_ASSIGNMENT=False, + ALIGN_DICT_COLON=False, + NEW_ALIGNMENT_AFTER_COMMENTLINE=False, ALLOW_MULTILINE_LAMBDAS=False, ALLOW_MULTILINE_DICTIONARY_KEYS=False, ALLOW_SPLIT_BEFORE_DEFAULT_OR_NAMED_ASSIGNS=True, @@ -607,6 +627,10 @@ def _IntOrIntListConverter(s): # Note: this dict has to map all the supported style options. _STYLE_OPTION_VALUE_CONVERTER = dict( ALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENT=_BoolConverter, + ALIGN_ASSIGNMENT=_BoolConverter, + ALIGN_DICT_COLON=_BoolConverter, + NEW_ALIGNMENT_AFTER_COMMENTLINE=_BoolConverter, + ALIGN_ARGUMENT_ASSIGNMENT=_BoolConverter, ALLOW_MULTILINE_LAMBDAS=_BoolConverter, ALLOW_MULTILINE_DICTIONARY_KEYS=_BoolConverter, ALLOW_SPLIT_BEFORE_DEFAULT_OR_NAMED_ASSIGNS=_BoolConverter, diff --git a/yapf/yapflib/subtypes.py b/yapf/yapflib/subtypes.py index b4b7efe75..21ca213ad 100644 --- a/yapf/yapflib/subtypes.py +++ b/yapf/yapflib/subtypes.py @@ -38,3 +38,4 @@ SIMPLE_EXPRESSION = 22 PARAMETER_START = 23 PARAMETER_STOP = 24 + diff --git a/yapftests/format_token_test.py b/yapftests/format_token_test.py index 6ea24af63..3bb1ce9f5 100644 --- a/yapftests/format_token_test.py +++ b/yapftests/format_token_test.py @@ -15,10 +15,11 @@ import unittest -from lib2to3 import pytree +from lib2to3 import pytree, pygram from lib2to3.pgen2 import token from yapf.yapflib import format_token +from yapf.pytree import subtype_assigner class TabbedContinuationAlignPaddingTest(unittest.TestCase): @@ -89,6 +90,37 @@ def testIsMultilineString(self): pytree.Leaf(token.STRING, 'r"""hello"""'), 'STRING') self.assertTrue(tok.is_multiline_string) + #------------test argument names------------ + # fun( + # a='hello world', + # # comment, + # b='') + child1 = pytree.Leaf(token.NAME, 'a') + child2 = pytree.Leaf(token.EQUAL, '=') + child3 = pytree.Leaf(token.STRING, "'hello world'") + child4 = pytree.Leaf(token.COMMA, ',') + child5 = pytree.Leaf(token.COMMENT,'# comment') + child6 = pytree.Leaf(token.COMMA, ',') + child7 = pytree.Leaf(token.NAME, 'b') + child8 = pytree.Leaf(token.EQUAL, '=') + child9 = pytree.Leaf(token.STRING, "''") + node_type = pygram.python_grammar.symbol2number['arglist'] + node = pytree.Node(node_type, [child1, child2, child3, child4, child5, + child6, child7, child8,child9]) + subtype_assigner.AssignSubtypes(node) + + def testIsArgName(self, node=node): + tok = format_token.FormatToken(node.children[0],'NAME') + self.assertTrue(tok.is_argname) + + def testIsArgAssign(self, node=node): + tok = format_token.FormatToken(node.children[1], 'EQUAL') + self.assertTrue(tok.is_argassign) + + # test if comment inside is not argname + def testCommentNotIsArgName(self, node=node): + tok = format_token.FormatToken(node.children[4], 'COMMENT') + self.assertFalse(tok.is_argname) if __name__ == '__main__': unittest.main() diff --git a/yapftests/reformatter_basic_test.py b/yapftests/reformatter_basic_test.py index 657d1e246..0c68c8525 100644 --- a/yapftests/reformatter_basic_test.py +++ b/yapftests/reformatter_basic_test.py @@ -1583,18 +1583,20 @@ def testNoSplittingWithinSubscriptList(self): llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) + def testExcessCharacters(self): code = textwrap.dedent("""\ - class foo: + class foo: - def bar(self): - self.write(s=[ - '%s%s %s' % ('many of really', 'long strings', '+ just makes up 81') - ]) - """) # noqa + def bar(self): + self.write(s=[ + '%s%s %s' % ('many of really', 'long strings', '+ just makes up 81') + ]) + """) # noqa llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) + unformatted_code = textwrap.dedent("""\ def _(): if True: @@ -2863,6 +2865,8 @@ def function(first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None) -> None def function(first_argument_xxxxxxxxxxxxxxxxxxxxxxx=(0,), second_argument=None) -> None: pass """) # noqa + # if dedent closing brackets and Align argAssign are true, there will be + # spaces before the argassign expected_formatted_code = textwrap.dedent("""\ def function( first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None @@ -2879,7 +2883,8 @@ def function( try: style.SetGlobalStyle( style.CreateStyleFromConfig('{based_on_style: yapf,' - ' dedent_closing_brackets: True}')) + ' dedent_closing_brackets: True,' + ' align_argument_assignment: False}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, @@ -3165,6 +3170,355 @@ def testWalrus(self): llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected, reformatter.Reformat(llines)) + #------tests for alignment functions-------- + def testAlignAssignBlankLineInbetween(self): + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig('{align_assignment: true}')) + unformatted_code = textwrap.dedent("""\ + val_first = 1 + val_second += 2 + + val_third = 3 + """) + expected_formatted_code = textwrap.dedent("""\ + val_first = 1 + val_second += 2 + + val_third = 3 + """) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testAlignAssignCommentLineInbetween(self): + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig('{align_assignment: true,' + 'new_alignment_after_commentline = true}')) + unformatted_code = textwrap.dedent("""\ + val_first = 1 + val_second += 2 + # comment + val_third = 3 + """) + expected_formatted_code = textwrap.dedent("""\ + val_first = 1 + val_second += 2 + # comment + val_third = 3 + """) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testAlignAssignDefLineInbetween(self): + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig('{align_assignment: true}')) + unformatted_code = textwrap.dedent("""\ + val_first = 1 + val_second += 2 + def fun(): + a = 'example' + abc = '' + val_third = 3 + """) + expected_formatted_code = textwrap.dedent("""\ + val_first = 1 + val_second += 2 + + + def fun(): + a = 'example' + abc = '' + + + val_third = 3 + """) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testAlignAssignObjectWithNewLineInbetween(self): + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig('{align_assignment: true}')) + unformatted_code = textwrap.dedent("""\ + val_first = 1 + val_second += 2 + object = { + entry1:1, + entry2:2, + entry3:3, + } + val_third = 3 + """) + expected_formatted_code = textwrap.dedent("""\ + val_first = 1 + val_second += 2 + object = { + entry1: 1, + entry2: 2, + entry3: 3, + } + val_third = 3 + """) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testAlignAssignWithOnlyOneAssignmentLine(self): + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig('{align_assignment: true}')) + unformatted_code = textwrap.dedent("""\ + val_first = 1 + """) + expected_formatted_code = unformatted_code + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + ########## for Align_ArgAssign()########### + def testAlignArgAssignTypedName(self): + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig('{align_argument_assignment: true,' + 'dedent_closing_brackets: true}')) + unformatted_code = textwrap.dedent("""\ +def f1( + self, + *, + app_name:str="", + server=None, + main_app=None, + db: Optional[NemDB]=None, + root: Optional[str]="", + conf: Optional[dict]={1, 2}, + ini_section: str="" +): pass +""") + expected_formatted_code = textwrap.dedent("""\ +def f1( + self, + *, + app_name: str = "", + server =None, + main_app =None, + db: Optional[NemDB] = None, + root: Optional[str] = "", + conf: Optional[dict] = {1, 2}, + ini_section: str = "" +): + pass +""") + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + # test both object/nested argument list with newlines and + # argument without assignment in between + def testAlignArgAssignNestedArglistInBetween(self): + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig('{align_argument_assignment: true,' + 'dedent_closing_brackets: true}')) + unformatted_code = textwrap.dedent("""\ +arglist = test( + first_argument='', + second_argument=fun( + self, role=3, username_id, client_id=1, very_long_long_long_long_long='' + ), + third_argument=3, + fourth_argument=4 +) +""") + expected_formatted_code = textwrap.dedent("""\ +arglist = test( + first_argument ='', + second_argument =fun( + self, + role =3, + username_id, + client_id =1, + very_long_long_long_long_long ='' + ), + third_argument =3, + fourth_argument =4 +) +""") + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + # start new alignment after comment line in between + def testAlignArgAssignCommentLineInBetween(self): + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig('{align_argument_assignment: true,' + 'dedent_closing_brackets: true,' + 'new_alignment_after_commentline:true}')) + unformatted_code = textwrap.dedent("""\ +arglist = test( + client_id=0, + username_id=1, + # comment + user_name='xxxxxxxxxxxxxxxxxxxxx' +) +""") + expected_formatted_code = textwrap.dedent("""\ +arglist = test( + client_id =0, + username_id =1, + # comment + user_name ='xxxxxxxxxxxxxxxxxxxxx' +) +""") + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testAlignArgAssignWithOnlyFirstArgOnNewline(self): + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig('{align_argument_assignment: true,' + 'dedent_closing_brackets: true}')) + unformatted_code = textwrap.dedent("""\ +arglist = self.get_data_from_excelsheet( + client_id=0, username_id=1, user_name='xxxxxxxxxxxxxxxxxxxx' +) +""") + expected_formatted_code = unformatted_code + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testAlignArgAssignArgumentsCanFitInOneLine(self): + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig('{align_argument_assignment: true,' + 'dedent_closing_brackets: true}')) + unformatted_code = textwrap.dedent("""\ +def function( + first_argument_xxxxxx =(0,), + second_argument =None +) -> None: + pass +""") + expected_formatted_code = textwrap.dedent("""\ +def function(first_argument_xxxxxx=(0,), second_argument=None) -> None: + pass +""") + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + ########for align dictionary colons######### + def testAlignDictColonNestedDictInBetween(self): + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig('{align_dict_colon: true,' + 'dedent_closing_brackets: true}')) + unformatted_code = textwrap.dedent("""\ +fields = [{"type": "text","required": True,"html": {"attr": 'style="width: 250px;" maxlength="30"',"page": 0,}, + "list" : [1, 2, 3, 4]}] +""") + expected_formatted_code = textwrap.dedent("""\ +fields = [ + { + "type" : "text", + "required" : True, + "html" : { + "attr" : 'style="width: 250px;" maxlength="30"', + "page" : 0, + }, + "list" : [1, 2, 3, 4] + } +] +""") + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testAlignDictColonCommentLineInBetween(self): + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig('{align_dict_colon: true,' + 'dedent_closing_brackets: true,' + 'new_alignment_after_commentline: true}')) + unformatted_code = textwrap.dedent("""\ +fields = [{ + "type": "text", + "required": True, + # comment + "list": [1, 2, 3, 4]}] +""") + expected_formatted_code = textwrap.dedent("""\ +fields = [{ + "type" : "text", + "required" : True, + # comment + "list" : [1, 2, 3, 4] +}] +""") + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testAlignDictColonLargerExistingSpacesBefore(self): + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig('{align_dict_colon: true,' + 'dedent_closing_brackets: true}')) + unformatted_code = textwrap.dedent("""\ +fields = [{ + "type" : "text", + "required" : True, + "list" : [1, 2, 3, 4], +}] +""") + expected_formatted_code = textwrap.dedent("""\ +fields = [{ + "type" : "text", + "required" : True, + "list" : [1, 2, 3, 4], +}] +""") + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + + + + if __name__ == '__main__': unittest.main() diff --git a/yapftests/subtype_assigner_test.py b/yapftests/subtype_assigner_test.py index 8616169c9..c69d13e4e 100644 --- a/yapftests/subtype_assigner_test.py +++ b/yapftests/subtype_assigner_test.py @@ -123,12 +123,117 @@ def testFuncCallWithDefaultAssign(self): subtypes.NONE, subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, }), - ('=', {subtypes.DEFAULT_OR_NAMED_ASSIGN}), - ("'hello world'", {subtypes.NONE}), + ('=', { + subtypes.DEFAULT_OR_NAMED_ASSIGN + }), + ("'hello world'", { + subtypes.NONE + }), + (')', {subtypes.NONE}), + ], + ]) + + #----test comment subtype inside the argument list---- + def testCommentSubtypesInsideArglist(self): + code = textwrap.dedent("""\ + foo( + # comment + x, + a='hello world') + """) + llines = yapf_test_helper.ParseAndUnwrap(code) + self._CheckFormatTokenSubtypes(llines, [ + [ + ('foo', {subtypes.NONE}), + ('(', {subtypes.NONE}), + ('# comment', {subtypes.NONE, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST}), + ('x', { + subtypes.NONE, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, + }), + (',', {subtypes.NONE}), + ('a', { + subtypes.NONE, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, + }), + ('=', { + subtypes.DEFAULT_OR_NAMED_ASSIGN + }), + ("'hello world'", { + subtypes.NONE + }), + (')', {subtypes.NONE}), + ], + ]) + + # ----test typed arguments subtypes------ + def testTypedArgumentsInsideArglist(self): + code = textwrap.dedent("""\ +def foo( + self, + preprocess: Callable[[str], str] = identity + ): pass +""") + llines = yapf_test_helper.ParseAndUnwrap(code) + self._CheckFormatTokenSubtypes(llines, [ + [ + ('def', {subtypes.NONE}), + ('foo', {subtypes.FUNC_DEF}), + ('(', {subtypes.NONE}), + ('self', {subtypes.NONE, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, + subtypes.PARAMETER_START, + subtypes.PARAMETER_STOP + }), + (',', {subtypes.NONE}), + ('preprocess', { + subtypes.NONE, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, + subtypes.PARAMETER_START, + subtypes.TYPED_NAME_ARG_LIST + }), + (':', { + subtypes.TYPED_NAME, + subtypes.TYPED_NAME_ARG_LIST, + }), + ('Callable', {subtypes.TYPED_NAME_ARG_LIST + }), + ('[', { + subtypes.SUBSCRIPT_BRACKET, + subtypes.TYPED_NAME_ARG_LIST + }), + ('[', {subtypes.TYPED_NAME_ARG_LIST + }), + ('str', {subtypes.TYPED_NAME_ARG_LIST + }), + (']', {subtypes.TYPED_NAME_ARG_LIST + }), + (',', {subtypes.TYPED_NAME_ARG_LIST + }), + ('str', {subtypes.TYPED_NAME_ARG_LIST + }), + (']', { + subtypes.SUBSCRIPT_BRACKET, + subtypes.TYPED_NAME_ARG_LIST + }), + ('=', { + subtypes.DEFAULT_OR_NAMED_ASSIGN, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, + subtypes.TYPED_NAME + }), + ('identity', { + subtypes.NONE, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, + subtypes.PARAMETER_STOP + }), (')', {subtypes.NONE}), + (':', {subtypes.NONE})], + [('pass', {subtypes.NONE}), ], ]) + def testSetComprehension(self): code = textwrap.dedent("""\ def foo(strs): diff --git a/yapftests/yapf_test.py b/yapftests/yapf_test.py index 2330f4e18..4ddaf5c8a 100644 --- a/yapftests/yapf_test.py +++ b/yapftests/yapf_test.py @@ -26,7 +26,7 @@ from lib2to3.pgen2 import tokenize -from yapf.yapflib import errors +from yapf.yapflib import errors, reformatter from yapf.yapflib import py3compat from yapf.yapflib import style from yapf.yapflib import yapf_api From 7a7de673b6fb23ef7097e320f030f213c6d85fac Mon Sep 17 00:00:00 2001 From: Xiao Wang Date: Tue, 30 Aug 2022 11:59:59 +0200 Subject: [PATCH 2/9] update the changelog and readme --- CHANGELOG | 4 ++ CONTRIBUTORS | 1 + README.rst | 51 ++++++++++++++++++++++++ yapf/pytree/comment_splicer.py | 1 + yapf/pytree/subtype_assigner.py | 9 +---- yapf/yapflib/format_token.py | 11 ----- yapf/yapflib/reformatter.py | 1 - yapf/yapflib/style.py | 2 +- yapf/yapflib/subtypes.py | 3 +- yapftests/reformatter_basic_test.py | 19 ++++----- yapftests/subtype_assigner_test.py | 62 +++++++++-------------------- yapftests/yapf_test.py | 2 +- 12 files changed, 88 insertions(+), 78 deletions(-) diff --git a/CHANGELOG b/CHANGELOG index 5ac3e6329..9004d6da0 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -2,6 +2,10 @@ # All notable changes to this project will be documented in this file. # This project adheres to [Semantic Versioning](http://semver.org/). +## [0.41.1] 2022-08-30 +### Added +- Add 4 new knobs to align assignment operators and dictionary colons. They are align_assignment, align_argument_assignment, align_dict_colon and new_alignment_after_commentline. + ## [0.40.0] UNRELEASED ### Added - Add a new Python parser to generate logical lines. diff --git a/CONTRIBUTORS b/CONTRIBUTORS index 054ef2652..1852a9133 100644 --- a/CONTRIBUTORS +++ b/CONTRIBUTORS @@ -15,3 +15,4 @@ Sam Clegg Łukasz Langa Oleg Butuzov Mauricio Herrera Cuadra +Xiao Wang \ No newline at end of file diff --git a/README.rst b/README.rst index 5734a5d76..39b368c7d 100644 --- a/README.rst +++ b/README.rst @@ -390,6 +390,57 @@ Options:: Knobs ===== +``ALIGN_ASSIGNMENT`` + Align assignment or augmented assignment operators. + If there is a blank line or a newline comment or a multiline object + (e.g. a dictionary, a list, a function call) in between, + it will start new block alignment. Lines in the same block have the same + indentation level. + + .. code-block:: python + a = 1 + abc = 2 + if condition == None: + var += '' + var_long -= 4 + b = 3 + bc = 4 + +``ALIGN_ARGUMENT_ASSIGNMENT`` + Align assignment operators in the argument list if they are all split on newlines. + Arguments without assignment in between will initiate new block alignment calulation; + for example, a comment line. + Multiline objects in between will also initiate a new alignment block. + + .. code-block:: python + rglist = test( + var_first = 0, + var_second = '', + var_dict = { + "key_1" : '', + "key_2" : 2, + "key_3" : True, + }, + var_third = 1, + var_very_long = None ) + +``ALIGN_DICT_COLON`` + Align the colons in the dictionary if all entries in dictionay are split on newlines + or 'EACH_DICT_ENTRY_ON_SEPERATE_LINE' is set True. + A commentline or multi-line object in between will start new alignment block. + .. code-block:: python + fields = + { + "field" : "ediid", + "type" : "text", + # key: value + "required" : True, + } + +``NEW_ALIGNMENT_AFTER_COMMENTLINE`` + Make it optional to whether start a new alignmetn block for assignment + alignment and colon alignment after a comment line. + ``ALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENT`` Align closing bracket with visual indentation. diff --git a/yapf/pytree/comment_splicer.py b/yapf/pytree/comment_splicer.py index 9e8f02c48..ae5ffe66f 100644 --- a/yapf/pytree/comment_splicer.py +++ b/yapf/pytree/comment_splicer.py @@ -42,6 +42,7 @@ def SpliceComments(tree): # This is a list because Python 2.x doesn't have 'nonlocal' :) prev_leaf = [None] _AnnotateIndents(tree) + def _VisitNodeRec(node): """Recursively visit each node to splice comments into the AST.""" # This loop may insert into node.children, so we'll iterate over a copy. diff --git a/yapf/pytree/subtype_assigner.py b/yapf/pytree/subtype_assigner.py index 03d7efe1a..5ebefc704 100644 --- a/yapf/pytree/subtype_assigner.py +++ b/yapf/pytree/subtype_assigner.py @@ -301,7 +301,6 @@ def Visit_typedargslist(self, node): # pylint: disable=invalid-name for i in range(1, len(node.children)): prev_child = node.children[i - 1] child = node.children[i] - if prev_child.type == grammar_token.COMMA: _AppendFirstLeafTokenSubtype(child, subtypes.PARAMETER_START) elif child.type == grammar_token.COMMA: @@ -311,7 +310,7 @@ def Visit_typedargslist(self, node): # pylint: disable=invalid-name tname = True _SetArgListSubtype(child, subtypes.TYPED_NAME, subtypes.TYPED_NAME_ARG_LIST) - # NOTE Every element of the tynamme argument list + # NOTE Every element of the tynamme argument # should have this list type _AppendSubtypeRec(child, subtypes.TYPED_NAME_ARG_LIST) @@ -389,25 +388,21 @@ def HasSubtype(node): for child in node.children: node_name = pytree_utils.NodeName(child) - #TODO exclude it if the first leaf is a comment in appendfirstleaftokensubtype if node_name not in {'atom', 'COMMA'}: _AppendFirstLeafTokenSubtype(child, list_subtype) - def _AppendTokenSubtype(node, subtype): """Append the token's subtype only if it's not already set.""" pytree_utils.AppendNodeAnnotation(node, pytree_utils.Annotation.SUBTYPE, subtype) -#TODO should exclude comment child to all Appendsubtypes functions + def _AppendFirstLeafTokenSubtype(node, subtype): """Append the first leaf token's subtypes.""" - #TODO exclude the comment leaf if isinstance(node, pytree.Leaf): _AppendTokenSubtype(node, subtype) return - _AppendFirstLeafTokenSubtype(node.children[0], subtype) diff --git a/yapf/yapflib/format_token.py b/yapf/yapflib/format_token.py index f8658f772..1618b35af 100644 --- a/yapf/yapflib/format_token.py +++ b/yapf/yapflib/format_token.py @@ -14,7 +14,6 @@ """Enhanced token information for formatting.""" import keyword -from operator import sub import re from lib2to3.pgen2 import token @@ -125,7 +124,6 @@ def __init__(self, node, name): self.subtypes = {subtypes.NONE} if not stypes else stypes self.is_pseudo = hasattr(node, 'is_pseudo') and node.is_pseudo - @property def formatted_whitespace_prefix(self): if style.Get('INDENT_BLANK_LINES'): @@ -325,7 +323,6 @@ def is_copybara_comment(self): return self.is_comment and re.match( r'#.*\bcopybara:\s*(strip|insert|replace)', self.value) - @property def is_assign(self): return subtypes.ASSIGN_OPERATOR in self.subtypes @@ -382,7 +379,6 @@ def is_argname(self): return False - @property def is_argname_start(self): # return true if it's the start of every argument entry @@ -404,10 +400,3 @@ def is_argname_start(self): or subtypes.TYPED_NAME_ARG_LIST in self.subtypes or subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST in self.subtypes)) ) - - - - - - - diff --git a/yapf/yapflib/reformatter.py b/yapf/yapflib/reformatter.py index 92aaa950e..4cdaf165c 100644 --- a/yapf/yapflib/reformatter.py +++ b/yapf/yapflib/reformatter.py @@ -103,7 +103,6 @@ def Reformat(llines, verify=False, lines=None): final_lines.append(lline) prev_line = lline - if style.Get('ALIGN_ASSIGNMENT'): _AlignAssignment(final_lines) if (style.Get('EACH_DICT_ENTRY_ON_SEPARATE_LINE') diff --git a/yapf/yapflib/style.py b/yapf/yapflib/style.py index a4c54b5f8..d9e9e5e9e 100644 --- a/yapf/yapflib/style.py +++ b/yapf/yapflib/style.py @@ -66,7 +66,7 @@ def SetGlobalStyle(style): ALIGN_DICT_COLON=textwrap.dedent("""\ Align the colons in the dictionary if all entries in dictionay are split on newlines. - and 'EACH_DICT_ENTRY_ON_SEPERATE_LINE' set True. + or 'EACH_DICT_ENTRY_ON_SEPERATE_LINE' is set True. """), NEW_ALIGNMENT_AFTER_COMMENTLINE=textwrap.dedent("""\ Start new assignment or colon alignment when there is a newline comment in between."""), diff --git a/yapf/yapflib/subtypes.py b/yapf/yapflib/subtypes.py index 21ca213ad..2c0431853 100644 --- a/yapf/yapflib/subtypes.py +++ b/yapf/yapflib/subtypes.py @@ -37,5 +37,4 @@ TYPED_NAME_ARG_LIST = 21 SIMPLE_EXPRESSION = 22 PARAMETER_START = 23 -PARAMETER_STOP = 24 - +PARAMETER_STOP = 24 \ No newline at end of file diff --git a/yapftests/reformatter_basic_test.py b/yapftests/reformatter_basic_test.py index 0c68c8525..3371ac339 100644 --- a/yapftests/reformatter_basic_test.py +++ b/yapftests/reformatter_basic_test.py @@ -1583,20 +1583,18 @@ def testNoSplittingWithinSubscriptList(self): llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testExcessCharacters(self): code = textwrap.dedent("""\ - class foo: + class foo: - def bar(self): - self.write(s=[ - '%s%s %s' % ('many of really', 'long strings', '+ just makes up 81') - ]) - """) # noqa + def bar(self): + self.write(s=[ + '%s%s %s' % ('many of really', 'long strings', '+ just makes up 81') + ]) + """) # noqa llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent("""\ def _(): if True: @@ -2865,8 +2863,6 @@ def function(first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None) -> None def function(first_argument_xxxxxxxxxxxxxxxxxxxxxxx=(0,), second_argument=None) -> None: pass """) # noqa - # if dedent closing brackets and Align argAssign are true, there will be - # spaces before the argassign expected_formatted_code = textwrap.dedent("""\ def function( first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None @@ -2883,8 +2879,7 @@ def function( try: style.SetGlobalStyle( style.CreateStyleFromConfig('{based_on_style: yapf,' - ' dedent_closing_brackets: True,' - ' align_argument_assignment: False}')) + ' dedent_closing_brackets: True}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, diff --git a/yapftests/subtype_assigner_test.py b/yapftests/subtype_assigner_test.py index c69d13e4e..97f9cd3ac 100644 --- a/yapftests/subtype_assigner_test.py +++ b/yapftests/subtype_assigner_test.py @@ -123,12 +123,8 @@ def testFuncCallWithDefaultAssign(self): subtypes.NONE, subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, }), - ('=', { - subtypes.DEFAULT_OR_NAMED_ASSIGN - }), - ("'hello world'", { - subtypes.NONE - }), + ('=', {subtypes.DEFAULT_OR_NAMED_ASSIGN}), + ("'hello world'", {subtypes.NONE}), (')', {subtypes.NONE}), ], ]) @@ -150,19 +146,13 @@ def testCommentSubtypesInsideArglist(self): subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST}), ('x', { subtypes.NONE, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, - }), + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST}), (',', {subtypes.NONE}), ('a', { subtypes.NONE, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, - }), - ('=', { - subtypes.DEFAULT_OR_NAMED_ASSIGN - }), - ("'hello world'", { - subtypes.NONE - }), + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST}), + ('=', {subtypes.DEFAULT_OR_NAMED_ASSIGN}), + ("'hello world'", {subtypes.NONE}), (')', {subtypes.NONE}), ], ]) @@ -184,56 +174,42 @@ def foo( ('self', {subtypes.NONE, subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, subtypes.PARAMETER_START, - subtypes.PARAMETER_STOP - }), + subtypes.PARAMETER_STOP}), (',', {subtypes.NONE}), ('preprocess', { subtypes.NONE, subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, subtypes.PARAMETER_START, - subtypes.TYPED_NAME_ARG_LIST - }), + subtypes.TYPED_NAME_ARG_LIST}), (':', { subtypes.TYPED_NAME, - subtypes.TYPED_NAME_ARG_LIST, - }), - ('Callable', {subtypes.TYPED_NAME_ARG_LIST - }), + subtypes.TYPED_NAME_ARG_LIST}), + ('Callable', {subtypes.TYPED_NAME_ARG_LIST}), ('[', { subtypes.SUBSCRIPT_BRACKET, - subtypes.TYPED_NAME_ARG_LIST - }), - ('[', {subtypes.TYPED_NAME_ARG_LIST - }), - ('str', {subtypes.TYPED_NAME_ARG_LIST - }), - (']', {subtypes.TYPED_NAME_ARG_LIST - }), - (',', {subtypes.TYPED_NAME_ARG_LIST - }), - ('str', {subtypes.TYPED_NAME_ARG_LIST - }), + subtypes.TYPED_NAME_ARG_LIST}), + ('[', {subtypes.TYPED_NAME_ARG_LIST}), + ('str', {subtypes.TYPED_NAME_ARG_LIST}), + (']', {subtypes.TYPED_NAME_ARG_LIST}), + (',', {subtypes.TYPED_NAME_ARG_LIST}), + ('str', {subtypes.TYPED_NAME_ARG_LIST}), (']', { subtypes.SUBSCRIPT_BRACKET, - subtypes.TYPED_NAME_ARG_LIST - }), + subtypes.TYPED_NAME_ARG_LIST}), ('=', { subtypes.DEFAULT_OR_NAMED_ASSIGN, subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, - subtypes.TYPED_NAME - }), + subtypes.TYPED_NAME}), ('identity', { subtypes.NONE, subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, - subtypes.PARAMETER_STOP - }), + subtypes.PARAMETER_STOP}), (')', {subtypes.NONE}), (':', {subtypes.NONE})], [('pass', {subtypes.NONE}), ], ]) - def testSetComprehension(self): code = textwrap.dedent("""\ def foo(strs): diff --git a/yapftests/yapf_test.py b/yapftests/yapf_test.py index 4ddaf5c8a..2330f4e18 100644 --- a/yapftests/yapf_test.py +++ b/yapftests/yapf_test.py @@ -26,7 +26,7 @@ from lib2to3.pgen2 import tokenize -from yapf.yapflib import errors, reformatter +from yapf.yapflib import errors from yapf.yapflib import py3compat from yapf.yapflib import style from yapf.yapflib import yapf_api From 94cca9bb5e10bd92999367681cfabf0d8f5d71e3 Mon Sep 17 00:00:00 2001 From: Xiao Wang Date: Tue, 30 Aug 2022 12:08:43 +0200 Subject: [PATCH 3/9] small fixes --- README.rst | 2 +- yapf/pytree/subtype_assigner.py | 4 ++-- yapf/yapflib/subtypes.py | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/README.rst b/README.rst index 39b368c7d..845ea441d 100644 --- a/README.rst +++ b/README.rst @@ -438,7 +438,7 @@ Knobs } ``NEW_ALIGNMENT_AFTER_COMMENTLINE`` - Make it optional to whether start a new alignmetn block for assignment + Make it optional to start a new alignmetn block for assignment alignment and colon alignment after a comment line. ``ALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENT`` diff --git a/yapf/pytree/subtype_assigner.py b/yapf/pytree/subtype_assigner.py index 5ebefc704..0ee247a82 100644 --- a/yapf/pytree/subtype_assigner.py +++ b/yapf/pytree/subtype_assigner.py @@ -401,8 +401,8 @@ def _AppendTokenSubtype(node, subtype): def _AppendFirstLeafTokenSubtype(node, subtype): """Append the first leaf token's subtypes.""" if isinstance(node, pytree.Leaf): - _AppendTokenSubtype(node, subtype) - return + _AppendTokenSubtype(node, subtype) + return _AppendFirstLeafTokenSubtype(node.children[0], subtype) diff --git a/yapf/yapflib/subtypes.py b/yapf/yapflib/subtypes.py index 2c0431853..b4b7efe75 100644 --- a/yapf/yapflib/subtypes.py +++ b/yapf/yapflib/subtypes.py @@ -37,4 +37,4 @@ TYPED_NAME_ARG_LIST = 21 SIMPLE_EXPRESSION = 22 PARAMETER_START = 23 -PARAMETER_STOP = 24 \ No newline at end of file +PARAMETER_STOP = 24 From 2ecde17df8c6d400d8bb46c16c3217422c7916b6 Mon Sep 17 00:00:00 2001 From: lizawang <56673986+lizawang@users.noreply.github.com> Date: Tue, 30 Aug 2022 13:32:06 +0200 Subject: [PATCH 4/9] Update README.rst --- README.rst | 24 ++++++++++++++---------- 1 file changed, 14 insertions(+), 10 deletions(-) diff --git a/README.rst b/README.rst index 845ea441d..71e4497be 100644 --- a/README.rst +++ b/README.rst @@ -398,6 +398,7 @@ Knobs indentation level. .. code-block:: python + a = 1 abc = 2 if condition == None: @@ -413,22 +414,25 @@ Knobs Multiline objects in between will also initiate a new alignment block. .. code-block:: python - rglist = test( - var_first = 0, - var_second = '', - var_dict = { - "key_1" : '', - "key_2" : 2, - "key_3" : True, - }, - var_third = 1, - var_very_long = None ) + + rglist = test( + var_first = 0, + var_second = '', + var_dict = { + "key_1" : '', + "key_2" : 2, + "key_3" : True, + }, + var_third = 1, + var_very_long = None ) ``ALIGN_DICT_COLON`` Align the colons in the dictionary if all entries in dictionay are split on newlines or 'EACH_DICT_ENTRY_ON_SEPERATE_LINE' is set True. A commentline or multi-line object in between will start new alignment block. + .. code-block:: python + fields = { "field" : "ediid", From e2181d87c945a88c9314c1cf2cf5dc8b498828d9 Mon Sep 17 00:00:00 2001 From: Xiao Wang Date: Tue, 30 Aug 2022 13:57:19 +0200 Subject: [PATCH 5/9] fix readme --- README.rst | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/README.rst b/README.rst index 845ea441d..c54801650 100644 --- a/README.rst +++ b/README.rst @@ -398,6 +398,7 @@ Knobs indentation level. .. code-block:: python + a = 1 abc = 2 if condition == None: @@ -413,6 +414,7 @@ Knobs Multiline objects in between will also initiate a new alignment block. .. code-block:: python + rglist = test( var_first = 0, var_second = '', @@ -428,7 +430,9 @@ Knobs Align the colons in the dictionary if all entries in dictionay are split on newlines or 'EACH_DICT_ENTRY_ON_SEPERATE_LINE' is set True. A commentline or multi-line object in between will start new alignment block. + .. code-block:: python + fields = { "field" : "ediid", From 82f1326b8ff973bc1a91cc5ac7f40679b8b355e1 Mon Sep 17 00:00:00 2001 From: Xiao Wang Date: Tue, 13 Sep 2022 18:12:28 +0200 Subject: [PATCH 6/9] fix align_dict_colon --- yapf/yapflib/format_token.py | 1 + yapf/yapflib/reformatter.py | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/yapf/yapflib/format_token.py b/yapf/yapflib/format_token.py index 1618b35af..070987851 100644 --- a/yapf/yapflib/format_token.py +++ b/yapf/yapflib/format_token.py @@ -382,6 +382,7 @@ def is_argname(self): @property def is_argname_start(self): # return true if it's the start of every argument entry + previous_subtypes = {0} if self.previous_token: previous_subtypes = self.previous_token.subtypes diff --git a/yapf/yapflib/reformatter.py b/yapf/yapflib/reformatter.py index 4cdaf165c..e63917134 100644 --- a/yapf/yapflib/reformatter.py +++ b/yapf/yapflib/reformatter.py @@ -858,7 +858,7 @@ def _AlignDictColon(final_lines): # check if the key has multiple tokens and # get the first key token in this key key_token = token.previous_token - while key_token.previous_token.is_dict_key: + while key_token.is_dict_key and not key_token.is_dict_key_start: key_token = key_token.previous_token key_column = len(key_token.formatted_whitespace_prefix.lstrip('\n')) From 6c273dc210d2514089fa53e1fd526979cd2d599e Mon Sep 17 00:00:00 2001 From: Xiao Wang Date: Thu, 15 Sep 2022 10:46:49 +0200 Subject: [PATCH 7/9] add test for the case when the dict starts with a comment --- yapf/yapflib/reformatter.py | 4 +- yapftests/reformatter_basic_test.py | 87 ++++++++++++++++------------- 2 files changed, 50 insertions(+), 41 deletions(-) diff --git a/yapf/yapflib/reformatter.py b/yapf/yapflib/reformatter.py index e63917134..8f8a103f8 100644 --- a/yapf/yapflib/reformatter.py +++ b/yapf/yapflib/reformatter.py @@ -658,7 +658,7 @@ def _AlignArgAssign(final_lines): index += 1 if index < len(line_tokens): line_tok = line_tokens[index] - # when the matching closing bracket never found + # when the matching closing bracket is never found # due to edge cases where the closing bracket # is not indented or dedented else: @@ -816,7 +816,7 @@ def _AlignDictColon(final_lines): index += 1 if index < len(line_tokens): line_tok = line_tokens[index] - # when the matching closing bracket never found + # when the matching closing bracket is never found # due to edge cases where the closing bracket # is not indented or dedented, e.g. ']}', with another bracket before else: diff --git a/yapftests/reformatter_basic_test.py b/yapftests/reformatter_basic_test.py index 3371ac339..0eeeefdce 100644 --- a/yapftests/reformatter_basic_test.py +++ b/yapftests/reformatter_basic_test.py @@ -3285,12 +3285,12 @@ def testAlignAssignWithOnlyOneAssignmentLine(self): finally: style.SetGlobalStyle(style.CreateYapfStyle()) - ########## for Align_ArgAssign()########### + ########## for Align_ArgAssign()########### def testAlignArgAssignTypedName(self): try: style.SetGlobalStyle( style.CreateStyleFromConfig('{align_argument_assignment: true,' - 'dedent_closing_brackets: true}')) + 'split_before_first_argument: true}')) unformatted_code = textwrap.dedent("""\ def f1( self, @@ -3314,8 +3314,7 @@ def f1( db: Optional[NemDB] = None, root: Optional[str] = "", conf: Optional[dict] = {1, 2}, - ini_section: str = "" -): + ini_section: str = ""): pass """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) @@ -3329,13 +3328,12 @@ def f1( def testAlignArgAssignNestedArglistInBetween(self): try: style.SetGlobalStyle( - style.CreateStyleFromConfig('{align_argument_assignment: true,' - 'dedent_closing_brackets: true}')) + style.CreateStyleFromConfig('{align_argument_assignment: true}')) unformatted_code = textwrap.dedent("""\ arglist = test( first_argument='', second_argument=fun( - self, role=3, username_id, client_id=1, very_long_long_long_long_long='' + self, role=None, client_name='', client_id=1, very_long_long_long_long_long='' ), third_argument=3, fourth_argument=4 @@ -3346,14 +3344,12 @@ def testAlignArgAssignNestedArglistInBetween(self): first_argument ='', second_argument =fun( self, - role =3, - username_id, + role =None, + client_name ='', client_id =1, - very_long_long_long_long_long ='' - ), + very_long_long_long_long_long =''), third_argument =3, - fourth_argument =4 -) + fourth_argument =4) """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, @@ -3366,7 +3362,6 @@ def testAlignArgAssignCommentLineInBetween(self): try: style.SetGlobalStyle( style.CreateStyleFromConfig('{align_argument_assignment: true,' - 'dedent_closing_brackets: true,' 'new_alignment_after_commentline:true}')) unformatted_code = textwrap.dedent("""\ arglist = test( @@ -3381,8 +3376,7 @@ def testAlignArgAssignCommentLineInBetween(self): client_id =0, username_id =1, # comment - user_name ='xxxxxxxxxxxxxxxxxxxxx' -) + user_name ='xxxxxxxxxxxxxxxxxxxxx') """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, @@ -3393,12 +3387,10 @@ def testAlignArgAssignCommentLineInBetween(self): def testAlignArgAssignWithOnlyFirstArgOnNewline(self): try: style.SetGlobalStyle( - style.CreateStyleFromConfig('{align_argument_assignment: true,' - 'dedent_closing_brackets: true}')) + style.CreateStyleFromConfig('{align_argument_assignment: true}')) unformatted_code = textwrap.dedent("""\ arglist = self.get_data_from_excelsheet( - client_id=0, username_id=1, user_name='xxxxxxxxxxxxxxxxxxxx' -) + client_id=0, username_id=1, user_name='xxxxxxxxxxxxxxxxxxxx') """) expected_formatted_code = unformatted_code llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) @@ -3410,8 +3402,7 @@ def testAlignArgAssignWithOnlyFirstArgOnNewline(self): def testAlignArgAssignArgumentsCanFitInOneLine(self): try: style.SetGlobalStyle( - style.CreateStyleFromConfig('{align_argument_assignment: true,' - 'dedent_closing_brackets: true}')) + style.CreateStyleFromConfig('{align_argument_assignment: true}')) unformatted_code = textwrap.dedent("""\ def function( first_argument_xxxxxx =(0,), @@ -3433,24 +3424,21 @@ def function(first_argument_xxxxxx=(0,), second_argument=None) -> None: def testAlignDictColonNestedDictInBetween(self): try: style.SetGlobalStyle( - style.CreateStyleFromConfig('{align_dict_colon: true,' - 'dedent_closing_brackets: true}')) + style.CreateStyleFromConfig('{align_dict_colon: true}')) unformatted_code = textwrap.dedent("""\ fields = [{"type": "text","required": True,"html": {"attr": 'style="width: 250px;" maxlength="30"',"page": 0,}, "list" : [1, 2, 3, 4]}] """) expected_formatted_code = textwrap.dedent("""\ -fields = [ - { - "type" : "text", - "required" : True, - "html" : { - "attr" : 'style="width: 250px;" maxlength="30"', - "page" : 0, - }, - "list" : [1, 2, 3, 4] - } -] +fields = [{ + "type" : "text", + "required" : True, + "html" : { + "attr" : 'style="width: 250px;" maxlength="30"', + "page" : 0, + }, + "list" : [1, 2, 3, 4] +}] """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, @@ -3462,7 +3450,6 @@ def testAlignDictColonCommentLineInBetween(self): try: style.SetGlobalStyle( style.CreateStyleFromConfig('{align_dict_colon: true,' - 'dedent_closing_brackets: true,' 'new_alignment_after_commentline: true}')) unformatted_code = textwrap.dedent("""\ fields = [{ @@ -3488,8 +3475,7 @@ def testAlignDictColonCommentLineInBetween(self): def testAlignDictColonLargerExistingSpacesBefore(self): try: style.SetGlobalStyle( - style.CreateStyleFromConfig('{align_dict_colon: true,' - 'dedent_closing_brackets: true}')) + style.CreateStyleFromConfig('{align_dict_colon: true}')) unformatted_code = textwrap.dedent("""\ fields = [{ "type" : "text", @@ -3510,7 +3496,30 @@ def testAlignDictColonLargerExistingSpacesBefore(self): finally: style.SetGlobalStyle(style.CreateYapfStyle()) - + def testAlignDictColonCommentAfterOpenBracket(self): + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig('{align_dict_colon: true}')) + unformatted_code = textwrap.dedent("""\ +fields = [{ + # comment + "type": "text", + "required": True, + "list": [1, 2, 3, 4]}] +""") + expected_formatted_code = textwrap.dedent("""\ +fields = [{ + # comment + "type" : "text", + "required" : True, + "list" : [1, 2, 3, 4] +}] +""") + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) From 506612e587c9883a36d9c5bfd3ea8215500878c7 Mon Sep 17 00:00:00 2001 From: Xiao Wang Date: Mon, 3 Oct 2022 15:57:08 +0200 Subject: [PATCH 8/9] ran alignment over yapf codes --- yapf/__init__.py | 184 ++-- yapf/pyparser/pyparser.py | 32 +- yapf/pyparser/pyparser_utils.py | 8 +- yapf/pyparser/split_penalty_visitor.py | 49 +- yapf/pytree/blank_line_calculator.py | 60 +- yapf/pytree/comment_splicer.py | 56 +- yapf/pytree/continuation_splicer.py | 6 +- yapf/pytree/pytree_unwrapper.py | 42 +- yapf/pytree/pytree_utils.py | 54 +- yapf/pytree/pytree_visitor.py | 2 +- yapf/pytree/split_penalty.py | 87 +- yapf/pytree/subtype_assigner.py | 49 +- yapf/third_party/yapf_diff/yapf_diff.py | 43 +- yapf/yapflib/errors.py | 4 +- yapf/yapflib/file_resources.py | 26 +- yapf/yapflib/format_decision_state.py | 183 ++-- yapf/yapflib/format_token.py | 147 +-- yapf/yapflib/logical_line.py | 34 +- yapf/yapflib/object_state.py | 69 +- yapf/yapflib/py3compat.py | 14 +- yapf/yapflib/reformatter.py | 596 ++++++----- yapf/yapflib/split_penalty.py | 16 +- yapf/yapflib/style.py | 534 +++++----- yapf/yapflib/subtypes.py | 48 +- yapf/yapflib/verifier.py | 2 +- yapf/yapflib/yapf_api.py | 83 +- yapftests/blank_line_calculator_test.py | 69 +- yapftests/comment_splicer_test.py | 62 +- yapftests/file_resources_test.py | 147 ++- yapftests/format_decision_state_test.py | 8 +- yapftests/format_token_test.py | 26 +- yapftests/line_joiner_test.py | 18 +- yapftests/logical_line_test.py | 22 +- yapftests/main_test.py | 11 +- yapftests/pytree_unwrapper_test.py | 273 ++--- yapftests/pytree_utils_test.py | 62 +- yapftests/pytree_visitor_test.py | 10 +- yapftests/reformatter_basic_test.py | 1098 ++++++++++++-------- yapftests/reformatter_buganizer_test.py | 541 ++++++---- yapftests/reformatter_facebook_test.py | 95 +- yapftests/reformatter_pep8_test.py | 274 +++-- yapftests/reformatter_python3_test.py | 109 +- yapftests/reformatter_style_config_test.py | 54 +- yapftests/reformatter_verify_test.py | 26 +- yapftests/split_penalty_test.py | 272 ++--- yapftests/style_test.py | 63 +- yapftests/subtype_assigner_test.py | 555 +++++----- yapftests/utils.py | 44 +- yapftests/yapf_test.py | 520 +++++---- yapftests/yapf_test_helper.py | 8 +- 50 files changed, 3887 insertions(+), 2908 deletions(-) diff --git a/yapf/__init__.py b/yapf/__init__.py index 94e445b59..703c9141e 100644 --- a/yapf/__init__.py +++ b/yapf/__init__.py @@ -55,8 +55,8 @@ def main(argv): Raises: YapfError: if none of the supplied files were Python files. """ - parser = _BuildParser() - args = parser.parse_args(argv[1:]) + parser = _BuildParser() + args = parser.parse_args(argv[1:]) style_config = args.style if args.style_help: @@ -70,8 +70,9 @@ def main(argv): if not args.files: # No arguments specified. Read code from stdin. if args.in_place or args.diff: - parser.error('cannot use --in-place or --diff flags when reading ' - 'from stdin') + parser.error( + 'cannot use --in-place or --diff flags when reading ' + 'from stdin') original_source = [] while True: @@ -93,16 +94,16 @@ def main(argv): if style_config is None and not args.no_local_style: style_config = file_resources.GetDefaultStyleForDir(os.getcwd()) - source = [line.rstrip() for line in original_source] + source = [line.rstrip() for line in original_source] source[0] = py3compat.removeBOM(source[0]) try: reformatted_source, _ = yapf_api.FormatCode( py3compat.unicode('\n'.join(source) + '\n'), - filename='', - style_config=style_config, - lines=lines, - verify=args.verify) + filename ='', + style_config =style_config, + lines =lines, + verify =args.verify) except errors.YapfError: raise except Exception as e: @@ -115,23 +116,23 @@ def main(argv): exclude_patterns_from_ignore_file = file_resources.GetExcludePatternsForDir( os.getcwd()) - files = file_resources.GetCommandLineFiles(args.files, args.recursive, - (args.exclude or []) + - exclude_patterns_from_ignore_file) + files = file_resources.GetCommandLineFiles( + args.files, args.recursive, + (args.exclude or []) + exclude_patterns_from_ignore_file) if not files: raise errors.YapfError('input filenames did not match any python files') changed = FormatFiles( files, lines, - style_config=args.style, - no_local_style=args.no_local_style, - in_place=args.in_place, - print_diff=args.diff, - verify=args.verify, - parallel=args.parallel, - quiet=args.quiet, - verbose=args.verbose) + style_config =args.style, + no_local_style =args.no_local_style, + in_place =args.in_place, + print_diff =args.diff, + verify =args.verify, + parallel =args.parallel, + quiet =args.quiet, + verbose =args.verbose) return 1 if changed and (args.diff or args.quiet) else 0 @@ -152,16 +153,17 @@ def _PrintHelp(args): print() -def FormatFiles(filenames, - lines, - style_config=None, - no_local_style=False, - in_place=False, - print_diff=False, - verify=False, - parallel=False, - quiet=False, - verbose=False): +def FormatFiles( + filenames, + lines, + style_config =None, + no_local_style =False, + in_place =False, + print_diff =False, + verify =False, + parallel =False, + quiet =False, + verbose =False): """Format a list of files. Arguments: @@ -191,28 +193,31 @@ def FormatFiles(filenames, workers = min(multiprocessing.cpu_count(), len(filenames)) with concurrent.futures.ProcessPoolExecutor(workers) as executor: future_formats = [ - executor.submit(_FormatFile, filename, lines, style_config, - no_local_style, in_place, print_diff, verify, quiet, - verbose) for filename in filenames + executor.submit( + _FormatFile, filename, lines, style_config, no_local_style, + in_place, print_diff, verify, quiet, verbose) + for filename in filenames ] for future in concurrent.futures.as_completed(future_formats): changed |= future.result() else: for filename in filenames: - changed |= _FormatFile(filename, lines, style_config, no_local_style, - in_place, print_diff, verify, quiet, verbose) + changed |= _FormatFile( + filename, lines, style_config, no_local_style, in_place, print_diff, + verify, quiet, verbose) return changed -def _FormatFile(filename, - lines, - style_config=None, - no_local_style=False, - in_place=False, - print_diff=False, - verify=False, - quiet=False, - verbose=False): +def _FormatFile( + filename, + lines, + style_config =None, + no_local_style =False, + in_place =False, + print_diff =False, + verify =False, + quiet =False, + verbose =False): """Format an individual file.""" if verbose and not quiet: print('Reformatting %s' % filename) @@ -224,20 +229,20 @@ def _FormatFile(filename, try: reformatted_code, encoding, has_change = yapf_api.FormatFile( filename, - in_place=in_place, - style_config=style_config, - lines=lines, - print_diff=print_diff, - verify=verify, - logger=logging.warning) + in_place =in_place, + style_config =style_config, + lines =lines, + print_diff =print_diff, + verify =verify, + logger =logging.warning) except errors.YapfError: raise except Exception as e: raise errors.YapfError(errors.FormatErrorMsg(e)) if not in_place and not quiet and reformatted_code: - file_resources.WriteReformattedCode(filename, reformatted_code, encoding, - in_place) + file_resources.WriteReformattedCode( + filename, reformatted_code, encoding, in_place) return has_change @@ -277,78 +282,81 @@ def _BuildParser(): parser.add_argument( '-v', '--version', - action='version', - version='%(prog)s {}'.format(__version__)) + action ='version', + version ='%(prog)s {}'.format(__version__)) diff_inplace_quiet_group = parser.add_mutually_exclusive_group() diff_inplace_quiet_group.add_argument( '-d', '--diff', - action='store_true', - help='print the diff for the fixed source') + action ='store_true', + help ='print the diff for the fixed source') diff_inplace_quiet_group.add_argument( '-i', '--in-place', - action='store_true', - help='make changes to files in place') + action ='store_true', + help ='make changes to files in place') diff_inplace_quiet_group.add_argument( '-q', '--quiet', - action='store_true', - help='output nothing and set return value') + action ='store_true', + help ='output nothing and set return value') lines_recursive_group = parser.add_mutually_exclusive_group() lines_recursive_group.add_argument( '-r', '--recursive', - action='store_true', - help='run recursively over directories') + action ='store_true', + help ='run recursively over directories') lines_recursive_group.add_argument( '-l', '--lines', - metavar='START-END', - action='append', - default=None, - help='range of lines to reformat, one-based') + metavar ='START-END', + action ='append', + default =None, + help ='range of lines to reformat, one-based') parser.add_argument( '-e', '--exclude', - metavar='PATTERN', - action='append', - default=None, - help='patterns for files to exclude from formatting') + metavar ='PATTERN', + action ='append', + default =None, + help ='patterns for files to exclude from formatting') parser.add_argument( '--style', - action='store', - help=('specify formatting style: either a style name (for example "pep8" ' - 'or "google"), or the name of a file with style settings. The ' - 'default is pep8 unless a %s or %s or %s file located in the same ' - 'directory as the source or one of its parent directories ' - '(for stdin, the current directory is used).' % - (style.LOCAL_STYLE, style.SETUP_CONFIG, style.PYPROJECT_TOML))) + action ='store', + help =( + 'specify formatting style: either a style name (for example "pep8" ' + 'or "google"), or the name of a file with style settings. The ' + 'default is pep8 unless a %s or %s or %s file located in the same ' + 'directory as the source or one of its parent directories ' + '(for stdin, the current directory is used).' % + (style.LOCAL_STYLE, style.SETUP_CONFIG, style.PYPROJECT_TOML))) parser.add_argument( '--style-help', - action='store_true', - help=('show style settings and exit; this output can be ' - 'saved to .style.yapf to make your settings ' - 'permanent')) + action ='store_true', + help =( + 'show style settings and exit; this output can be ' + 'saved to .style.yapf to make your settings ' + 'permanent')) parser.add_argument( '--no-local-style', - action='store_true', - help="don't search for local style definition") + action ='store_true', + help ="don't search for local style definition") parser.add_argument('--verify', action='store_true', help=argparse.SUPPRESS) parser.add_argument( '-p', '--parallel', - action='store_true', - help=('run YAPF in parallel when formatting multiple files. Requires ' - 'concurrent.futures in Python 2.X')) + action ='store_true', + help =( + 'run YAPF in parallel when formatting multiple files. Requires ' + 'concurrent.futures in Python 2.X')) parser.add_argument( '-vv', '--verbose', - action='store_true', - help='print out file names while processing') + action ='store_true', + help ='print out file names while processing') parser.add_argument( 'files', nargs='*', help='reads from stdin when no files are specified.') diff --git a/yapf/pyparser/pyparser.py b/yapf/pyparser/pyparser.py index a8a28ebc8..7b2ce0dea 100644 --- a/yapf/pyparser/pyparser.py +++ b/yapf/pyparser/pyparser.py @@ -68,7 +68,7 @@ def ParseCode(unformatted_source, filename=''): ast_tree = ast.parse(unformatted_source, filename) ast.fix_missing_locations(ast_tree) readline = py3compat.StringIO(unformatted_source).readline - tokens = tokenize.generate_tokens(readline) + tokens = tokenize.generate_tokens(readline) except Exception: raise @@ -89,10 +89,10 @@ def _CreateLogicalLines(tokens): Returns: A list of LogicalLines. """ - logical_lines = [] + logical_lines = [] cur_logical_line = [] - prev_tok = None - depth = 0 + prev_tok = None + depth = 0 for tok in tokens: tok = py3compat.TokenInfo(*tok) @@ -100,7 +100,7 @@ def _CreateLogicalLines(tokens): # End of a logical line. logical_lines.append(logical_line.LogicalLine(depth, cur_logical_line)) cur_logical_line = [] - prev_tok = None + prev_tok = None elif tok.type == tokenize.INDENT: depth += 1 elif tok.type == tokenize.DEDENT: @@ -110,36 +110,36 @@ def _CreateLogicalLines(tokens): prev_tok.start[0] < tok.start[0]): # Insert a token for a line continuation. ctok = py3compat.TokenInfo( - type=CONTINUATION, - string='\\', - start=(prev_tok.start[0], prev_tok.start[1] + 1), - end=(prev_tok.end[0], prev_tok.end[0] + 2), - line=prev_tok.line) + type =CONTINUATION, + string ='\\', + start =(prev_tok.start[0], prev_tok.start[1] + 1), + end =(prev_tok.end[0], prev_tok.end[0] + 2), + line =prev_tok.line) ctok.lineno = ctok.start[0] ctok.column = ctok.start[1] - ctok.value = '\\' + ctok.value = '\\' cur_logical_line.append(format_token.FormatToken(ctok, 'CONTINUATION')) tok.lineno = tok.start[0] tok.column = tok.start[1] - tok.value = tok.string + tok.value = tok.string cur_logical_line.append( format_token.FormatToken(tok, token.tok_name[tok.type])) prev_tok = tok # Link the FormatTokens in each line together to for a doubly linked list. for line in logical_lines: - previous = line.first + previous = line.first bracket_stack = [previous] if previous.OpensScope() else [] for tok in line.tokens[1:]: - tok.previous_token = previous + tok.previous_token = previous previous.next_token = tok - previous = tok + previous = tok # Set up the "matching_bracket" attribute. if tok.OpensScope(): bracket_stack.append(tok) elif tok.ClosesScope(): bracket_stack[-1].matching_bracket = tok - tok.matching_bracket = bracket_stack.pop() + tok.matching_bracket = bracket_stack.pop() return logical_lines diff --git a/yapf/pyparser/pyparser_utils.py b/yapf/pyparser/pyparser_utils.py index 3f17b15a4..149e0a280 100644 --- a/yapf/pyparser/pyparser_utils.py +++ b/yapf/pyparser/pyparser_utils.py @@ -31,8 +31,8 @@ def GetTokens(logical_lines, node): """Get a list of tokens within the node's range from the logical lines.""" - start = TokenStart(node) - end = TokenEnd(node) + start = TokenStart(node) + end = TokenEnd(node) tokens = [] for line in logical_lines: @@ -46,8 +46,8 @@ def GetTokens(logical_lines, node): def GetTokensInSubRange(tokens, node): """Get a subset of tokens representing the node.""" - start = TokenStart(node) - end = TokenEnd(node) + start = TokenStart(node) + end = TokenEnd(node) tokens_in_range = [] for tok in tokens: diff --git a/yapf/pyparser/split_penalty_visitor.py b/yapf/pyparser/split_penalty_visitor.py index 047b48a3d..946bd949f 100644 --- a/yapf/pyparser/split_penalty_visitor.py +++ b/yapf/pyparser/split_penalty_visitor.py @@ -67,13 +67,14 @@ def visit_FunctionDef(self, node): _SetPenalty(token, split_penalty.UNBREAKABLE) if node.returns: - start_index = pyutils.GetTokenIndex(tokens, - pyutils.TokenStart(node.returns)) - _IncreasePenalty(tokens[start_index - 1:start_index + 1], - split_penalty.VERY_STRONGLY_CONNECTED) + start_index = pyutils.GetTokenIndex( + tokens, pyutils.TokenStart(node.returns)) + _IncreasePenalty( + tokens[start_index - 1:start_index + 1], + split_penalty.VERY_STRONGLY_CONNECTED) end_index = pyutils.GetTokenIndex(tokens, pyutils.TokenEnd(node.returns)) - _IncreasePenalty(tokens[start_index + 1:end_index], - split_penalty.STRONGLY_CONNECTED) + _IncreasePenalty( + tokens[start_index + 1:end_index], split_penalty.STRONGLY_CONNECTED) return self.generic_visit(node) @@ -103,7 +104,7 @@ def visit_ClassDef(self, node): for decorator in node.decorator_list: # Don't split after the '@'. - decorator_range = self._GetTokens(decorator) + decorator_range = self._GetTokens(decorator) decorator_range[0].split_penalty = split_penalty.UNBREAKABLE return self.generic_visit(node) @@ -263,7 +264,7 @@ def visit_BoolOp(self, node): # Lower the split penalty to allow splitting before or after the logical # operator. split_before_operator = style.Get('SPLIT_BEFORE_LOGICAL_OPERATOR') - operator_indices = [ + operator_indices = [ pyutils.GetNextTokenIndex(tokens, pyutils.TokenEnd(value)) for value in node.values[:-1] ] @@ -292,8 +293,8 @@ def visit_BinOp(self, node): # Lower the split penalty to allow splitting before or after the arithmetic # operator. - operator_index = pyutils.GetNextTokenIndex(tokens, - pyutils.TokenEnd(node.left)) + operator_index = pyutils.GetNextTokenIndex( + tokens, pyutils.TokenEnd(node.left)) if not style.Get('SPLIT_BEFORE_ARITHMETIC_OPERATOR'): operator_index += 1 @@ -370,7 +371,7 @@ def visit_ListComp(self, node): # is_async=0), # ... # ]) - tokens = self._GetTokens(node) + tokens = self._GetTokens(node) element = pyutils.GetTokensInSubRange(tokens, node.elt) _IncreasePenalty(element[1:], split_penalty.EXPR) @@ -394,7 +395,7 @@ def visit_SetComp(self, node): # is_async=0), # ... # ]) - tokens = self._GetTokens(node) + tokens = self._GetTokens(node) element = pyutils.GetTokensInSubRange(tokens, node.elt) _IncreasePenalty(element[1:], split_penalty.EXPR) @@ -420,7 +421,7 @@ def visit_DictComp(self, node): # ... # ]) tokens = self._GetTokens(node) - key = pyutils.GetTokensInSubRange(tokens, node.key) + key = pyutils.GetTokensInSubRange(tokens, node.key) _IncreasePenalty(key[1:], split_penalty.EXPR) value = pyutils.GetTokensInSubRange(tokens, node.value) @@ -446,7 +447,7 @@ def visit_GeneratorExp(self, node): # is_async=0), # ... # ]) - tokens = self._GetTokens(node) + tokens = self._GetTokens(node) element = pyutils.GetTokensInSubRange(tokens, node.elt) _IncreasePenalty(element[1:], split_penalty.EXPR) @@ -541,10 +542,10 @@ def visit_Constant(self, node): def visit_Attribute(self, node): # Attribute(value=Expr, # attr=Identifier) - tokens = self._GetTokens(node) + tokens = self._GetTokens(node) split_before = style.Get('SPLIT_BEFORE_DOT') - dot_indices = pyutils.GetNextTokenIndex(tokens, - pyutils.TokenEnd(node.value)) + dot_indices = pyutils.GetNextTokenIndex( + tokens, pyutils.TokenEnd(node.value)) if not split_before: dot_indices += 1 @@ -558,8 +559,8 @@ def visit_Subscript(self, node): tokens = self._GetTokens(node) # Don't split before the opening bracket of a subscript. - bracket_index = pyutils.GetNextTokenIndex(tokens, - pyutils.TokenEnd(node.value)) + bracket_index = pyutils.GetNextTokenIndex( + tokens, pyutils.TokenEnd(node.value)) _IncreasePenalty(tokens[bracket_index], split_penalty.UNBREAKABLE) return self.generic_visit(node) @@ -609,16 +610,16 @@ def visit_Slice(self, node): _DecreasePenalty(subrange[0], split_penalty.EXPR // 2) if hasattr(node, 'upper') and node.upper: - colon_index = pyutils.GetPrevTokenIndex(tokens, - pyutils.TokenStart(node.upper)) + colon_index = pyutils.GetPrevTokenIndex( + tokens, pyutils.TokenStart(node.upper)) _IncreasePenalty(tokens[colon_index], split_penalty.UNBREAKABLE) subrange = pyutils.GetTokensInSubRange(tokens, node.upper) _IncreasePenalty(subrange, split_penalty.EXPR) _DecreasePenalty(subrange[0], split_penalty.EXPR // 2) if hasattr(node, 'step') and node.step: - colon_index = pyutils.GetPrevTokenIndex(tokens, - pyutils.TokenStart(node.step)) + colon_index = pyutils.GetPrevTokenIndex( + tokens, pyutils.TokenStart(node.step)) _IncreasePenalty(tokens[colon_index], split_penalty.UNBREAKABLE) subrange = pyutils.GetTokensInSubRange(tokens, node.step) _IncreasePenalty(subrange, split_penalty.EXPR) @@ -864,7 +865,7 @@ def visit_arg(self, node): # Process any annotations. if hasattr(node, 'annotation') and node.annotation: annotation = node.annotation - subrange = pyutils.GetTokensInSubRange(tokens, annotation) + subrange = pyutils.GetTokensInSubRange(tokens, annotation) _IncreasePenalty(subrange, split_penalty.ANNOTATION) return self.generic_visit(node) diff --git a/yapf/pytree/blank_line_calculator.py b/yapf/pytree/blank_line_calculator.py index 9d218bf97..8aa20ec0a 100644 --- a/yapf/pytree/blank_line_calculator.py +++ b/yapf/pytree/blank_line_calculator.py @@ -29,17 +29,18 @@ from yapf.yapflib import py3compat from yapf.yapflib import style -_NO_BLANK_LINES = 1 -_ONE_BLANK_LINE = 2 +_NO_BLANK_LINES = 1 +_ONE_BLANK_LINE = 2 _TWO_BLANK_LINES = 3 -_PYTHON_STATEMENTS = frozenset({ - 'small_stmt', 'expr_stmt', 'print_stmt', 'del_stmt', 'pass_stmt', - 'break_stmt', 'continue_stmt', 'return_stmt', 'raise_stmt', 'yield_stmt', - 'import_stmt', 'global_stmt', 'exec_stmt', 'assert_stmt', 'if_stmt', - 'while_stmt', 'for_stmt', 'try_stmt', 'with_stmt', 'nonlocal_stmt', - 'async_stmt', 'simple_stmt' -}) +_PYTHON_STATEMENTS = frozenset( + { + 'small_stmt', 'expr_stmt', 'print_stmt', 'del_stmt', 'pass_stmt', + 'break_stmt', 'continue_stmt', 'return_stmt', 'raise_stmt', + 'yield_stmt', 'import_stmt', 'global_stmt', 'exec_stmt', 'assert_stmt', + 'if_stmt', 'while_stmt', 'for_stmt', 'try_stmt', 'with_stmt', + 'nonlocal_stmt', 'async_stmt', 'simple_stmt' + }) def CalculateBlankLines(tree): @@ -58,10 +59,10 @@ class _BlankLineCalculator(pytree_visitor.PyTreeVisitor): """_BlankLineCalculator - see file-level docstring for a description.""" def __init__(self): - self.class_level = 0 - self.function_level = 0 - self.last_comment_lineno = 0 - self.last_was_decorator = False + self.class_level = 0 + self.function_level = 0 + self.last_comment_lineno = 0 + self.last_was_decorator = False self.last_was_class_or_function = False def Visit_simple_stmt(self, node): # pylint: disable=invalid-name @@ -81,17 +82,17 @@ def Visit_decorator(self, node): # pylint: disable=invalid-name def Visit_classdef(self, node): # pylint: disable=invalid-name self.last_was_class_or_function = False - index = self._SetBlankLinesBetweenCommentAndClassFunc(node) - self.last_was_decorator = False - self.class_level += 1 + index = self._SetBlankLinesBetweenCommentAndClassFunc(node) + self.last_was_decorator = False + self.class_level += 1 for child in node.children[index:]: self.Visit(child) - self.class_level -= 1 + self.class_level -= 1 self.last_was_class_or_function = True def Visit_funcdef(self, node): # pylint: disable=invalid-name self.last_was_class_or_function = False - index = self._SetBlankLinesBetweenCommentAndClassFunc(node) + index = self._SetBlankLinesBetweenCommentAndClassFunc(node) if _AsyncFunction(node): index = self._SetBlankLinesBetweenCommentAndClassFunc( node.prev_sibling.parent) @@ -99,10 +100,10 @@ def Visit_funcdef(self, node): # pylint: disable=invalid-name else: index = self._SetBlankLinesBetweenCommentAndClassFunc(node) self.last_was_decorator = False - self.function_level += 1 + self.function_level += 1 for child in node.children[index:]: self.Visit(child) - self.function_level -= 1 + self.function_level -= 1 self.last_was_class_or_function = True def DefaultNodeVisit(self, node): @@ -160,20 +161,23 @@ def _GetNumNewlines(self, node): return _ONE_BLANK_LINE def _IsTopLevel(self, node): - return (not (self.class_level or self.function_level) and - _StartsInZerothColumn(node)) + return ( + not (self.class_level or self.function_level) and + _StartsInZerothColumn(node)) def _SetNumNewlines(node, num_newlines): - pytree_utils.SetNodeAnnotation(node, pytree_utils.Annotation.NEWLINES, - num_newlines) + pytree_utils.SetNodeAnnotation( + node, pytree_utils.Annotation.NEWLINES, num_newlines) def _StartsInZerothColumn(node): - return (pytree_utils.FirstLeafNode(node).column == 0 or - (_AsyncFunction(node) and node.prev_sibling.column == 0)) + return ( + pytree_utils.FirstLeafNode(node).column == 0 or + (_AsyncFunction(node) and node.prev_sibling.column == 0)) def _AsyncFunction(node): - return (py3compat.PY3 and node.prev_sibling and - node.prev_sibling.type == grammar_token.ASYNC) + return ( + py3compat.PY3 and node.prev_sibling and + node.prev_sibling.type == grammar_token.ASYNC) diff --git a/yapf/pytree/comment_splicer.py b/yapf/pytree/comment_splicer.py index ae5ffe66f..f5406e968 100644 --- a/yapf/pytree/comment_splicer.py +++ b/yapf/pytree/comment_splicer.py @@ -60,7 +60,7 @@ def _VisitNodeRec(node): # Remember the leading indentation of this prefix and clear it. # Mopping up the prefix is important because we may go over this same # child in the next iteration... - child_prefix = child.prefix.lstrip('\n') + child_prefix = child.prefix.lstrip('\n') prefix_indent = child_prefix[:child_prefix.find('#')] if '\n' in prefix_indent: prefix_indent = prefix_indent[prefix_indent.rfind('\n') + 1:] @@ -171,22 +171,23 @@ def _VisitNodeRec(node): else: if comment_lineno == prev_leaf[0].lineno: comment_lines = comment_prefix.splitlines() - value = comment_lines[0].lstrip() + value = comment_lines[0].lstrip() if value.rstrip('\n'): - comment_column = prev_leaf[0].column + comment_column = prev_leaf[0].column comment_column += len(prev_leaf[0].value) - comment_column += ( + comment_column += ( len(comment_lines[0]) - len(comment_lines[0].lstrip())) comment_leaf = pytree.Leaf( - type=token.COMMENT, - value=value.rstrip('\n'), - context=('', (comment_lineno, comment_column))) + type =token.COMMENT, + value =value.rstrip('\n'), + context =('', (comment_lineno, comment_column))) pytree_utils.InsertNodesAfter([comment_leaf], prev_leaf[0]) - comment_prefix = '\n'.join(comment_lines[1:]) + comment_prefix = '\n'.join(comment_lines[1:]) comment_lineno += 1 - rindex = (0 if '\n' not in comment_prefix.rstrip() else - comment_prefix.rstrip().rindex('\n') + 1) + rindex = ( + 0 if '\n' not in comment_prefix.rstrip() else + comment_prefix.rstrip().rindex('\n') + 1) comment_column = ( len(comment_prefix[rindex:]) - len(comment_prefix[rindex:].lstrip())) @@ -203,10 +204,8 @@ def _VisitNodeRec(node): _VisitNodeRec(tree) -def _CreateCommentsFromPrefix(comment_prefix, - comment_lineno, - comment_column, - standalone=False): +def _CreateCommentsFromPrefix( + comment_prefix, comment_lineno, comment_column, standalone=False): """Create pytree nodes to represent the given comment prefix. Args: @@ -234,13 +233,13 @@ def _CreateCommentsFromPrefix(comment_prefix, index += 1 if comment_block: - new_lineno = comment_lineno + index - 1 - comment_block[0] = comment_block[0].strip() + new_lineno = comment_lineno + index - 1 + comment_block[0] = comment_block[0].strip() comment_block[-1] = comment_block[-1].strip() - comment_leaf = pytree.Leaf( - type=token.COMMENT, - value='\n'.join(comment_block), - context=('', (new_lineno, comment_column))) + comment_leaf = pytree.Leaf( + type =token.COMMENT, + value ='\n'.join(comment_block), + context =('', (new_lineno, comment_column))) comment_node = comment_leaf if not standalone else pytree.Node( pygram.python_symbols.simple_stmt, [comment_leaf]) comments.append(comment_node) @@ -262,10 +261,11 @@ def _CreateCommentsFromPrefix(comment_prefix, # line, not on the same line with other code), it's important to insert it into # an appropriate parent of the node it's attached to. An appropriate parent # is the first "standalone line node" in the parent chain of a node. -_STANDALONE_LINE_NODES = frozenset([ - 'suite', 'if_stmt', 'while_stmt', 'for_stmt', 'try_stmt', 'with_stmt', - 'funcdef', 'classdef', 'decorated', 'file_input' -]) +_STANDALONE_LINE_NODES = frozenset( + [ + 'suite', 'if_stmt', 'while_stmt', 'for_stmt', 'try_stmt', 'with_stmt', + 'funcdef', 'classdef', 'decorated', 'file_input' + ]) def _FindNodeWithStandaloneLineParent(node): @@ -352,14 +352,14 @@ def _AnnotateIndents(tree): """ # Annotate the root of the tree with zero indent. if tree.parent is None: - pytree_utils.SetNodeAnnotation(tree, pytree_utils.Annotation.CHILD_INDENT, - '') + pytree_utils.SetNodeAnnotation( + tree, pytree_utils.Annotation.CHILD_INDENT, '') for child in tree.children: if child.type == token.INDENT: child_indent = pytree_utils.GetNodeAnnotation( tree, pytree_utils.Annotation.CHILD_INDENT) if child_indent is not None and child_indent != child.value: raise RuntimeError('inconsistent indentation for child', (tree, child)) - pytree_utils.SetNodeAnnotation(tree, pytree_utils.Annotation.CHILD_INDENT, - child.value) + pytree_utils.SetNodeAnnotation( + tree, pytree_utils.Annotation.CHILD_INDENT, child.value) _AnnotateIndents(child) diff --git a/yapf/pytree/continuation_splicer.py b/yapf/pytree/continuation_splicer.py index b86188cb5..2648da033 100644 --- a/yapf/pytree/continuation_splicer.py +++ b/yapf/pytree/continuation_splicer.py @@ -38,9 +38,9 @@ def RecSplicer(node): if node.prefix.lstrip().startswith('\\\n'): new_lineno = node.lineno - node.prefix.count('\n') return pytree.Leaf( - type=format_token.CONTINUATION, - value=node.prefix, - context=('', (new_lineno, 0))) + type =format_token.CONTINUATION, + value =node.prefix, + context =('', (new_lineno, 0))) return None num_inserted = 0 for index, child in enumerate(node.children[:]): diff --git a/yapf/pytree/pytree_unwrapper.py b/yapf/pytree/pytree_unwrapper.py index 3fe4ade08..835ca60a1 100644 --- a/yapf/pytree/pytree_unwrapper.py +++ b/yapf/pytree/pytree_unwrapper.py @@ -61,10 +61,11 @@ def UnwrapPyTree(tree): # Grammar tokens considered as whitespace for the purpose of unwrapping. -_WHITESPACE_TOKENS = frozenset([ - grammar_token.NEWLINE, grammar_token.DEDENT, grammar_token.INDENT, - grammar_token.ENDMARKER -]) +_WHITESPACE_TOKENS = frozenset( + [ + grammar_token.NEWLINE, grammar_token.DEDENT, grammar_token.INDENT, + grammar_token.ENDMARKER + ]) class PyTreeUnwrapper(pytree_visitor.PyTreeVisitor): @@ -118,16 +119,17 @@ def _StartNewLine(self): _AdjustSplitPenalty(self._cur_logical_line) self._cur_logical_line = logical_line.LogicalLine(self._cur_depth) - _STMT_TYPES = frozenset({ - 'if_stmt', - 'while_stmt', - 'for_stmt', - 'try_stmt', - 'expect_clause', - 'with_stmt', - 'funcdef', - 'classdef', - }) + _STMT_TYPES = frozenset( + { + 'if_stmt', + 'while_stmt', + 'for_stmt', + 'try_stmt', + 'expect_clause', + 'with_stmt', + 'funcdef', + 'classdef', + }) # pylint: disable=invalid-name,missing-docstring def Visit_simple_stmt(self, node): @@ -320,7 +322,7 @@ def _MatchBrackets(line): bracket_stack.append(token) elif token.value in _CLOSING_BRACKETS: bracket_stack[-1].matching_bracket = token - token.matching_bracket = bracket_stack[-1] + token.matching_bracket = bracket_stack[-1] bracket_stack.pop() for bracket in bracket_stack: @@ -338,7 +340,7 @@ def _IdentifyParameterLists(line): Arguments: line: (LogicalLine) A logical line. """ - func_stack = [] + func_stack = [] param_stack = [] for tok in line.tokens: # Identify parameter list objects. @@ -374,9 +376,9 @@ def _AdjustSplitPenalty(line): bracket_level = 0 for index, token in enumerate(line.tokens): if index and not bracket_level: - pytree_utils.SetNodeAnnotation(token.node, - pytree_utils.Annotation.SPLIT_PENALTY, - split_penalty.UNBREAKABLE) + pytree_utils.SetNodeAnnotation( + token.node, pytree_utils.Annotation.SPLIT_PENALTY, + split_penalty.UNBREAKABLE) if token.value in _OPENING_BRACKETS: bracket_level += 1 elif token.value in _CLOSING_BRACKETS: @@ -396,7 +398,7 @@ def _DetermineMustSplitAnnotation(node): node.children[-1].value != ','): return num_children = len(node.children) - index = 0 + index = 0 _SetMustSplitOnFirstLeaf(node.children[0]) while index < num_children - 1: child = node.children[index] diff --git a/yapf/pytree/pytree_utils.py b/yapf/pytree/pytree_utils.py index 66a54e617..b54a0c043 100644 --- a/yapf/pytree/pytree_utils.py +++ b/yapf/pytree/pytree_utils.py @@ -42,11 +42,11 @@ class Annotation(object): """Annotation names associated with pytrees.""" - CHILD_INDENT = 'child_indent' - NEWLINES = 'newlines' - MUST_SPLIT = 'must_split' + CHILD_INDENT = 'child_indent' + NEWLINES = 'newlines' + MUST_SPLIT = 'must_split' SPLIT_PENALTY = 'split_penalty' - SUBTYPE = 'subtype' + SUBTYPE = 'subtype' def NodeName(node): @@ -113,13 +113,13 @@ def ParseCodeToTree(code): # Try to parse using a Python 3 grammar, which is more permissive (print and # exec are not keywords). parser_driver = driver.Driver(_GRAMMAR_FOR_PY3, convert=pytree.convert) - tree = parser_driver.parse_string(code, debug=False) + tree = parser_driver.parse_string(code, debug=False) except parse.ParseError: # Now try to parse using a Python 2 grammar; If this fails, then # there's something else wrong with the code. try: parser_driver = driver.Driver(_GRAMMAR_FOR_PY2, convert=pytree.convert) - tree = parser_driver.parse_string(code, debug=False) + tree = parser_driver.parse_string(code, debug=False) except parse.ParseError: # Raise a syntax error if the code is invalid python syntax. try: @@ -195,8 +195,9 @@ def _InsertNodeAt(new_node, target, after=False): # Protect against attempts to insert nodes which already belong to some tree. if new_node.parent is not None: - raise RuntimeError('inserting node which already has a parent', - (new_node, new_node.parent)) + raise RuntimeError( + 'inserting node which already has a parent', + (new_node, new_node.parent)) # The code here is based on pytree.Base.next_sibling parent_of_target = target.parent @@ -209,8 +210,8 @@ def _InsertNodeAt(new_node, target, after=False): parent_of_target.insert_child(insertion_index, new_node) return - raise RuntimeError('unable to find insertion point for target node', - (target,)) + raise RuntimeError( + 'unable to find insertion point for target node', (target,)) # The following constant and functions implement a simple custom annotation @@ -316,32 +317,35 @@ def DumpNodeToString(node): The string representation. """ if isinstance(node, pytree.Leaf): - fmt = ('{name}({value}) [lineno={lineno}, column={column}, ' - 'prefix={prefix}, penalty={penalty}]') + fmt = ( + '{name}({value}) [lineno={lineno}, column={column}, ' + 'prefix={prefix}, penalty={penalty}]') return fmt.format( - name=NodeName(node), - value=_PytreeNodeRepr(node), - lineno=node.lineno, - column=node.column, - prefix=repr(node.prefix), - penalty=GetNodeAnnotation(node, Annotation.SPLIT_PENALTY, None)) + name =NodeName(node), + value =_PytreeNodeRepr(node), + lineno =node.lineno, + column =node.column, + prefix =repr(node.prefix), + penalty =GetNodeAnnotation(node, Annotation.SPLIT_PENALTY, None)) else: fmt = '{node} [{len} children] [child_indent="{indent}"]' return fmt.format( - node=NodeName(node), - len=len(node.children), - indent=GetNodeAnnotation(node, Annotation.CHILD_INDENT)) + node =NodeName(node), + len =len(node.children), + indent =GetNodeAnnotation(node, Annotation.CHILD_INDENT)) def _PytreeNodeRepr(node): """Like pytree.Node.__repr__, but names instead of numbers for tokens.""" if isinstance(node, pytree.Node): - return '%s(%s, %r)' % (node.__class__.__name__, NodeName(node), - [_PytreeNodeRepr(c) for c in node.children]) + return '%s(%s, %r)' % ( + node.__class__.__name__, NodeName(node), + [_PytreeNodeRepr(c) for c in node.children]) if isinstance(node, pytree.Leaf): return '%s(%s, %r)' % (node.__class__.__name__, NodeName(node), node.value) def IsCommentStatement(node): - return (NodeName(node) == 'simple_stmt' and - node.children[0].type == token.COMMENT) + return ( + NodeName(node) == 'simple_stmt' and + node.children[0].type == token.COMMENT) diff --git a/yapf/pytree/pytree_visitor.py b/yapf/pytree/pytree_visitor.py index 314431e84..1cc2819f6 100644 --- a/yapf/pytree/pytree_visitor.py +++ b/yapf/pytree/pytree_visitor.py @@ -117,7 +117,7 @@ def __init__(self, target_stream=sys.stdout): target_stream: the stream to dump the tree to. A file-like object. By default will dump into stdout. """ - self._target_stream = target_stream + self._target_stream = target_stream self._current_indent = 0 def _DumpString(self, s): diff --git a/yapf/pytree/split_penalty.py b/yapf/pytree/split_penalty.py index b53ffbf85..08e1a5dbd 100644 --- a/yapf/pytree/split_penalty.py +++ b/yapf/pytree/split_penalty.py @@ -26,30 +26,30 @@ # TODO(morbo): Document the annotations in a centralized place. E.g., the # README file. -UNBREAKABLE = 1000 * 1000 -NAMED_ASSIGN = 15000 -DOTTED_NAME = 4000 +UNBREAKABLE = 1000 * 1000 +NAMED_ASSIGN = 15000 +DOTTED_NAME = 4000 VERY_STRONGLY_CONNECTED = 3500 -STRONGLY_CONNECTED = 3000 -CONNECTED = 500 -TOGETHER = 100 - -OR_TEST = 1000 -AND_TEST = 1100 -NOT_TEST = 1200 -COMPARISON = 1300 -STAR_EXPR = 1300 -EXPR = 1400 -XOR_EXPR = 1500 -AND_EXPR = 1700 -SHIFT_EXPR = 1800 -ARITH_EXPR = 1900 -TERM = 2000 -FACTOR = 2100 -POWER = 2200 -ATOM = 2300 +STRONGLY_CONNECTED = 3000 +CONNECTED = 500 +TOGETHER = 100 + +OR_TEST = 1000 +AND_TEST = 1100 +NOT_TEST = 1200 +COMPARISON = 1300 +STAR_EXPR = 1300 +EXPR = 1400 +XOR_EXPR = 1500 +AND_EXPR = 1700 +SHIFT_EXPR = 1800 +ARITH_EXPR = 1900 +TERM = 2000 +FACTOR = 2100 +POWER = 2200 +ATOM = 2300 ONE_ELEMENT_ARGUMENT = 500 -SUBSCRIPT = 6000 +SUBSCRIPT = 6000 def ComputeSplitPenalties(tree): @@ -210,10 +210,10 @@ def Visit_trailer(self, node): # pylint: disable=invalid-name # trailer ::= '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME if node.children[0].value == '.': before = style.Get('SPLIT_BEFORE_DOT') - _SetSplitPenalty(node.children[0], - VERY_STRONGLY_CONNECTED if before else DOTTED_NAME) - _SetSplitPenalty(node.children[1], - DOTTED_NAME if before else VERY_STRONGLY_CONNECTED) + _SetSplitPenalty( + node.children[0], VERY_STRONGLY_CONNECTED if before else DOTTED_NAME) + _SetSplitPenalty( + node.children[1], DOTTED_NAME if before else VERY_STRONGLY_CONNECTED) elif len(node.children) == 2: # Don't split an empty argument list if at all possible. _SetSplitPenalty(node.children[1], VERY_STRONGLY_CONNECTED) @@ -237,10 +237,12 @@ def Visit_trailer(self, node): # pylint: disable=invalid-name _SetStronglyConnected(node.children[1].children[2]) # Still allow splitting around the operator. - split_before = ((name.endswith('_test') and - style.Get('SPLIT_BEFORE_LOGICAL_OPERATOR')) or - (name.endswith('_expr') and - style.Get('SPLIT_BEFORE_BITWISE_OPERATOR'))) + split_before = ( + ( + name.endswith('_test') and + style.Get('SPLIT_BEFORE_LOGICAL_OPERATOR')) or ( + name.endswith('_expr') and + style.Get('SPLIT_BEFORE_BITWISE_OPERATOR'))) if split_before: _SetSplitPenalty( pytree_utils.LastLeafNode(node.children[1].children[1]), 0) @@ -249,12 +251,11 @@ def Visit_trailer(self, node): # pylint: disable=invalid-name pytree_utils.FirstLeafNode(node.children[1].children[2]), 0) # Don't split the ending bracket of a subscript list. - _RecAnnotate(node.children[-1], pytree_utils.Annotation.SPLIT_PENALTY, - VERY_STRONGLY_CONNECTED) - elif name not in { - 'arglist', 'argument', 'term', 'or_test', 'and_test', 'comparison', - 'atom', 'power' - }: + _RecAnnotate( + node.children[-1], pytree_utils.Annotation.SPLIT_PENALTY, + VERY_STRONGLY_CONNECTED) + elif name not in {'arglist', 'argument', 'term', 'or_test', 'and_test', + 'comparison', 'atom', 'power'}: # Don't split an argument list with one element if at all possible. stypes = pytree_utils.GetNodeAnnotation( pytree_utils.FirstLeafNode(node), pytree_utils.Annotation.SUBTYPE) @@ -295,7 +296,7 @@ def Visit_power(self, node): # pylint: disable=invalid-name,missing-docstring prev_trailer_idx = 1 while prev_trailer_idx < len(node.children) - 1: cur_trailer_idx = prev_trailer_idx + 1 - cur_trailer = node.children[cur_trailer_idx] + cur_trailer = node.children[cur_trailer_idx] if pytree_utils.NodeName(cur_trailer) != 'trailer': break @@ -369,8 +370,8 @@ def Visit_old_comp_for(self, node): # pylint: disable=invalid-name def Visit_comp_if(self, node): # pylint: disable=invalid-name # comp_if ::= 'if' old_test [comp_iter] - _SetSplitPenalty(node.children[0], - style.Get('SPLIT_PENALTY_BEFORE_IF_EXPR')) + _SetSplitPenalty( + node.children[0], style.Get('SPLIT_PENALTY_BEFORE_IF_EXPR')) _SetStronglyConnected(*node.children[1:]) self.DefaultNodeVisit(node) @@ -514,8 +515,8 @@ def _SetUnbreakable(node): def _SetStronglyConnected(*nodes): """Set a STRONGLY_CONNECTED penalty annotation for the given nodes.""" for node in nodes: - _RecAnnotate(node, pytree_utils.Annotation.SPLIT_PENALTY, - STRONGLY_CONNECTED) + _RecAnnotate( + node, pytree_utils.Annotation.SPLIT_PENALTY, STRONGLY_CONNECTED) def _SetExpressionPenalty(node, penalty): @@ -629,5 +630,5 @@ def _DecrementSplitPenalty(node, amt): def _SetSplitPenalty(node, penalty): - pytree_utils.SetNodeAnnotation(node, pytree_utils.Annotation.SPLIT_PENALTY, - penalty) + pytree_utils.SetNodeAnnotation( + node, pytree_utils.Annotation.SPLIT_PENALTY, penalty) diff --git a/yapf/pytree/subtype_assigner.py b/yapf/pytree/subtype_assigner.py index 0ee247a82..310b2134f 100644 --- a/yapf/pytree/subtype_assigner.py +++ b/yapf/pytree/subtype_assigner.py @@ -46,10 +46,10 @@ def AssignSubtypes(tree): # Map tokens in argument lists to their respective subtype. _ARGLIST_TOKEN_TO_SUBTYPE = { - '=': subtypes.DEFAULT_OR_NAMED_ASSIGN, - ':': subtypes.TYPED_NAME, - '*': subtypes.VARARGS_STAR, - '**': subtypes.KWARGS_STAR_STAR, + '=' : subtypes.DEFAULT_OR_NAMED_ASSIGN, + ':' : subtypes.TYPED_NAME, + '*' : subtypes.VARARGS_STAR, + '**' : subtypes.KWARGS_STAR_STAR, } @@ -66,7 +66,7 @@ def Visit_dictsetmaker(self, node): # pylint: disable=invalid-name for child in node.children: self.Visit(child) - comp_for = False + comp_for = False dict_maker = False for child in node.children: @@ -78,7 +78,7 @@ def Visit_dictsetmaker(self, node): # pylint: disable=invalid-name if not comp_for and dict_maker: last_was_colon = False - unpacking = False + unpacking = False for child in node.children: if child.type == grammar_token.DOUBLESTAR: _AppendFirstLeafTokenSubtype(child, subtypes.KWARGS_STAR_STAR) @@ -248,13 +248,15 @@ def Visit_arglist(self, node): # pylint: disable=invalid-name # | '*' test (',' argument)* [',' '**' test] # | '**' test) self._ProcessArgLists(node) - _SetArgListSubtype(node, subtypes.DEFAULT_OR_NAMED_ASSIGN, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST) + _SetArgListSubtype( + node, subtypes.DEFAULT_OR_NAMED_ASSIGN, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST) def Visit_tname(self, node): # pylint: disable=invalid-name self._ProcessArgLists(node) - _SetArgListSubtype(node, subtypes.DEFAULT_OR_NAMED_ASSIGN, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST) + _SetArgListSubtype( + node, subtypes.DEFAULT_OR_NAMED_ASSIGN, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST) def Visit_decorator(self, node): # pylint: disable=invalid-name # decorator ::= @@ -288,8 +290,9 @@ def Visit_typedargslist(self, node): # pylint: disable=invalid-name # | '**' tname) # | tfpdef ['=' test] (',' tfpdef ['=' test])* [',']) self._ProcessArgLists(node) - _SetArgListSubtype(node, subtypes.DEFAULT_OR_NAMED_ASSIGN, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST) + _SetArgListSubtype( + node, subtypes.DEFAULT_OR_NAMED_ASSIGN, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST) tname = False if not node.children: return @@ -300,7 +303,7 @@ def Visit_typedargslist(self, node): # pylint: disable=invalid-name tname = pytree_utils.NodeName(node.children[0]) == 'tname' for i in range(1, len(node.children)): prev_child = node.children[i - 1] - child = node.children[i] + child = node.children[i] if prev_child.type == grammar_token.COMMA: _AppendFirstLeafTokenSubtype(child, subtypes.PARAMETER_START) elif child.type == grammar_token.COMMA: @@ -308,8 +311,8 @@ def Visit_typedargslist(self, node): # pylint: disable=invalid-name if pytree_utils.NodeName(child) == 'tname': tname = True - _SetArgListSubtype(child, subtypes.TYPED_NAME, - subtypes.TYPED_NAME_ARG_LIST) + _SetArgListSubtype( + child, subtypes.TYPED_NAME, subtypes.TYPED_NAME_ARG_LIST) # NOTE Every element of the tynamme argument # should have this list type _AppendSubtypeRec(child, subtypes.TYPED_NAME_ARG_LIST) @@ -337,8 +340,8 @@ def Visit_comp_for(self, node): # pylint: disable=invalid-name _AppendSubtypeRec(node, subtypes.COMP_FOR) # Mark the previous node as COMP_EXPR unless this is a nested comprehension # as these will have the outer comprehension as their previous node. - attr = pytree_utils.GetNodeAnnotation(node.parent, - pytree_utils.Annotation.SUBTYPE) + attr = pytree_utils.GetNodeAnnotation( + node.parent, pytree_utils.Annotation.SUBTYPE) if not attr or subtypes.COMP_FOR not in attr: _AppendSubtypeRec(node.parent.children[0], subtypes.COMP_EXPR) self.DefaultNodeVisit(node) @@ -394,8 +397,8 @@ def HasSubtype(node): def _AppendTokenSubtype(node, subtype): """Append the token's subtype only if it's not already set.""" - pytree_utils.AppendNodeAnnotation(node, pytree_utils.Annotation.SUBTYPE, - subtype) + pytree_utils.AppendNodeAnnotation( + node, pytree_utils.Annotation.SUBTYPE, subtype) def _AppendFirstLeafTokenSubtype(node, subtype): @@ -432,14 +435,14 @@ def _InsertPseudoParentheses(node): node.children[-1].remove() first = pytree_utils.FirstLeafNode(node) - last = pytree_utils.LastLeafNode(node) + last = pytree_utils.LastLeafNode(node) if first == last and first.type == grammar_token.COMMENT: # A comment was inserted before the value, which is a pytree.Leaf. # Encompass the dictionary's value into an ATOM node. - last = first.next_sibling + last = first.next_sibling last_clone = last.clone() - new_node = pytree.Node(syms.atom, [first.clone(), last_clone]) + new_node = pytree.Node(syms.atom, [first.clone(), last_clone]) for orig_leaf, clone_leaf in zip(last.leaves(), last_clone.leaves()): pytree_utils.CopyYapfAnnotations(orig_leaf, clone_leaf) if hasattr(orig_leaf, 'is_pseudo'): @@ -450,7 +453,7 @@ def _InsertPseudoParentheses(node): last.remove() first = pytree_utils.FirstLeafNode(node) - last = pytree_utils.LastLeafNode(node) + last = pytree_utils.LastLeafNode(node) lparen = pytree.Leaf( grammar_token.LPAR, diff --git a/yapf/third_party/yapf_diff/yapf_diff.py b/yapf/third_party/yapf_diff/yapf_diff.py index 810a6a2d4..48551ba96 100644 --- a/yapf/third_party/yapf_diff/yapf_diff.py +++ b/yapf/third_party/yapf_diff/yapf_diff.py @@ -44,32 +44,32 @@ def main(): parser.add_argument( '-i', '--in-place', - action='store_true', - default=False, - help='apply edits to files instead of displaying a diff') + action ='store_true', + default =False, + help ='apply edits to files instead of displaying a diff') parser.add_argument( '-p', '--prefix', - metavar='NUM', - default=1, - help='strip the smallest prefix containing P slashes') + metavar ='NUM', + default =1, + help ='strip the smallest prefix containing P slashes') parser.add_argument( '--regex', - metavar='PATTERN', - default=None, - help='custom pattern selecting file paths to reformat ' + metavar ='PATTERN', + default =None, + help ='custom pattern selecting file paths to reformat ' '(case sensitive, overrides -iregex)') parser.add_argument( '--iregex', - metavar='PATTERN', - default=r'.*\.(py)', - help='custom pattern selecting file paths to reformat ' + metavar ='PATTERN', + default =r'.*\.(py)', + help ='custom pattern selecting file paths to reformat ' '(case insensitive, overridden by -regex)') parser.add_argument( '-v', '--verbose', - action='store_true', - help='be more verbose, ineffective without -i') + action ='store_true', + help ='be more verbose, ineffective without -i') parser.add_argument( '--style', help='specify formatting style: either a style name (for ' @@ -83,7 +83,7 @@ def main(): args = parser.parse_args() # Extract changed lines for each file. - filename = None + filename = None lines_by_file = {} for line in sys.stdin: match = re.search(r'^\+\+\+\ (.*?/){%s}(\S*)' % args.prefix, line) @@ -122,10 +122,10 @@ def main(): command.extend(['--style', args.style]) p = subprocess.Popen( command, - stdout=subprocess.PIPE, - stderr=None, - stdin=subprocess.PIPE, - universal_newlines=True) + stdout =subprocess.PIPE, + stderr =None, + stdin =subprocess.PIPE, + universal_newlines =True) stdout, stderr = p.communicate() if p.returncode != 0: sys.exit(p.returncode) @@ -134,8 +134,9 @@ def main(): with open(filename) as f: code = f.readlines() formatted_code = StringIO(stdout).readlines() - diff = difflib.unified_diff(code, formatted_code, filename, filename, - '(before formatting)', '(after formatting)') + diff = difflib.unified_diff( + code, formatted_code, filename, filename, '(before formatting)', + '(after formatting)') diff_string = ''.join(diff) if len(diff_string) > 0: sys.stdout.write(diff_string) diff --git a/yapf/yapflib/errors.py b/yapf/yapflib/errors.py index 99e88d9c0..cb8694d2c 100644 --- a/yapf/yapflib/errors.py +++ b/yapf/yapflib/errors.py @@ -32,8 +32,8 @@ def FormatErrorMsg(e): if isinstance(e, SyntaxError): return '{}:{}:{}: {}'.format(e.filename, e.lineno, e.offset, e.msg) if isinstance(e, tokenize.TokenError): - return '{}:{}:{}: {}'.format(e.filename, e.args[1][0], e.args[1][1], - e.args[0]) + return '{}:{}:{}: {}'.format( + e.filename, e.args[1][0], e.args[1][1], e.args[0]) return '{}:{}:{}: {}'.format(e.args[1][0], e.args[1][1], e.args[1][2], e.msg) diff --git a/yapf/yapflib/file_resources.py b/yapf/yapflib/file_resources.py index b5e2612bd..9c071db3d 100644 --- a/yapf/yapflib/file_resources.py +++ b/yapf/yapflib/file_resources.py @@ -25,8 +25,8 @@ from yapf.yapflib import py3compat from yapf.yapflib import style -CR = '\r' -LF = '\n' +CR = '\r' +LF = '\n' CRLF = '\r\n' @@ -56,7 +56,7 @@ def _GetExcludePatternsFromPyprojectToml(filename): "configuration file") if os.path.isfile(filename) and os.access(filename, os.R_OK): - pyproject_toml = toml.load(filename) + pyproject_toml = toml.load(filename) ignore_patterns = pyproject_toml.get('tool', {}).get('yapfignore', {}).get('ignore_patterns', []) @@ -140,7 +140,7 @@ def GetDefaultStyleForDir(dirname, default_style=style.DEFAULT_STYLE): "configuration file") pyproject_toml = toml.load(config_file) - style_dict = pyproject_toml.get('tool', {}).get('yapf', None) + style_dict = pyproject_toml.get('tool', {}).get('yapf', None) if style_dict is not None: return config_file @@ -161,10 +161,8 @@ def GetCommandLineFiles(command_line_file_list, recursive, exclude): return _FindPythonFiles(command_line_file_list, recursive, exclude) -def WriteReformattedCode(filename, - reformatted_code, - encoding='', - in_place=False): +def WriteReformattedCode( + filename, reformatted_code, encoding='', in_place=False): """Emit the reformatted code. Write the reformatted code into the file, if in_place is True. Otherwise, @@ -177,8 +175,8 @@ def WriteReformattedCode(filename, in_place: (bool) If True, then write the reformatted code to the file. """ if in_place: - with py3compat.open_with_encoding( - filename, mode='w', encoding=encoding, newline='') as fd: + with py3compat.open_with_encoding(filename, mode='w', encoding=encoding, + newline='') as fd: fd.write(reformatted_code) else: py3compat.EncodeAndWriteToStdout(reformatted_code) @@ -265,8 +263,8 @@ def IsPythonFile(filename): encoding = py3compat.detect_encoding(fd.readline)[0] # Check for correctness of encoding. - with py3compat.open_with_encoding( - filename, mode='r', encoding=encoding) as fd: + with py3compat.open_with_encoding(filename, mode='r', + encoding=encoding) as fd: fd.read() except UnicodeDecodeError: encoding = 'latin-1' @@ -277,8 +275,8 @@ def IsPythonFile(filename): return False try: - with py3compat.open_with_encoding( - filename, mode='r', encoding=encoding) as fd: + with py3compat.open_with_encoding(filename, mode='r', + encoding=encoding) as fd: first_line = fd.readline(256) except IOError: return False diff --git a/yapf/yapflib/format_decision_state.py b/yapf/yapflib/format_decision_state.py index efcef0ba4..40bf5e25b 100644 --- a/yapf/yapflib/format_decision_state.py +++ b/yapf/yapflib/format_decision_state.py @@ -66,59 +66,62 @@ def __init__(self, line, first_indent): line: (LogicalLine) The logical line we're currently processing. first_indent: (int) The indent of the first token. """ - self.next_token = line.first - self.column = first_indent - self.line = line - self.paren_level = 0 - self.lowest_level_on_line = 0 + self.next_token = line.first + self.column = first_indent + self.line = line + self.paren_level = 0 + self.lowest_level_on_line = 0 self.ignore_stack_for_comparison = False - self.stack = [_ParenState(first_indent, first_indent)] - self.comp_stack = [] - self.param_list_stack = [] - self.first_indent = first_indent - self.column_limit = style.Get('COLUMN_LIMIT') + self.stack = [_ParenState(first_indent, first_indent)] + self.comp_stack = [] + self.param_list_stack = [] + self.first_indent = first_indent + self.column_limit = style.Get('COLUMN_LIMIT') def Clone(self): """Clones a FormatDecisionState object.""" - new = FormatDecisionState(self.line, self.first_indent) - new.next_token = self.next_token - new.column = self.column - new.line = self.line - new.paren_level = self.paren_level - new.line.depth = self.line.depth - new.lowest_level_on_line = self.lowest_level_on_line + new = FormatDecisionState(self.line, self.first_indent) + new.next_token = self.next_token + new.column = self.column + new.line = self.line + new.paren_level = self.paren_level + new.line.depth = self.line.depth + new.lowest_level_on_line = self.lowest_level_on_line new.ignore_stack_for_comparison = self.ignore_stack_for_comparison - new.first_indent = self.first_indent - new.stack = [state.Clone() for state in self.stack] - new.comp_stack = [state.Clone() for state in self.comp_stack] - new.param_list_stack = [state.Clone() for state in self.param_list_stack] + new.first_indent = self.first_indent + new.stack = [state.Clone() for state in self.stack] + new.comp_stack = [state.Clone() for state in self.comp_stack] + new.param_list_stack = [state.Clone() for state in self.param_list_stack] return new def __eq__(self, other): # Note: 'first_indent' is implicit in the stack. Also, we ignore 'previous', # because it shouldn't have a bearing on this comparison. (I.e., it will # report equal if 'next_token' does.) - return (self.next_token == other.next_token and - self.column == other.column and - self.paren_level == other.paren_level and - self.line.depth == other.line.depth and - self.lowest_level_on_line == other.lowest_level_on_line and - (self.ignore_stack_for_comparison or - other.ignore_stack_for_comparison or self.stack == other.stack and - self.comp_stack == other.comp_stack and - self.param_list_stack == other.param_list_stack)) + return ( + self.next_token == other.next_token and self.column == other.column and + self.paren_level == other.paren_level and + self.line.depth == other.line.depth and + self.lowest_level_on_line == other.lowest_level_on_line and ( + self.ignore_stack_for_comparison or + other.ignore_stack_for_comparison or self.stack == other.stack and + self.comp_stack == other.comp_stack and + self.param_list_stack == other.param_list_stack)) def __ne__(self, other): return not self == other def __hash__(self): - return hash((self.next_token, self.column, self.paren_level, - self.line.depth, self.lowest_level_on_line)) + return hash( + ( + self.next_token, self.column, self.paren_level, self.line.depth, + self.lowest_level_on_line)) def __repr__(self): - return ('column::%d, next_token::%s, paren_level::%d, stack::[\n\t%s' % - (self.column, repr(self.next_token), self.paren_level, - '\n\t'.join(repr(s) for s in self.stack) + ']')) + return ( + 'column::%d, next_token::%s, paren_level::%d, stack::[\n\t%s' % ( + self.column, repr(self.next_token), self.paren_level, + '\n\t'.join(repr(s) for s in self.stack) + ']')) def CanSplit(self, must_split): """Determine if we can split before the next token. @@ -129,7 +132,7 @@ def CanSplit(self, must_split): Returns: True if the line can be split before the next token. """ - current = self.next_token + current = self.next_token previous = current.previous_token if current.is_pseudo: @@ -166,7 +169,7 @@ def CanSplit(self, must_split): def MustSplit(self): """Returns True if the line must split before the next token.""" - current = self.next_token + current = self.next_token previous = current.previous_token if current.is_pseudo: @@ -289,7 +292,7 @@ def SurroundedByParens(token): # # or when a string formatting syntax. func_call_or_string_format = False - tok = current.next_token + tok = current.next_token if current.is_name: while tok and (tok.is_name or tok.value == '.'): tok = tok.next_token @@ -421,7 +424,7 @@ def SurroundedByParens(token): (opening.previous_token.is_name or opening.previous_token.value in {'*', '**'})): is_func_call = False - opening = current + opening = current while opening: if opening.value == '(': is_func_call = True @@ -452,7 +455,7 @@ def SurroundedByParens(token): # default=False) if (current.value == '{' and previous.value == '(' and pprevious and pprevious.is_name): - dict_end = current.matching_bracket + dict_end = current.matching_bracket next_token = dict_end.next_token if next_token.value == ',' and not self._FitsOnLine(current, dict_end): return True @@ -483,7 +486,7 @@ def SurroundedByParens(token): (opening.previous_token.is_name or opening.previous_token.value in {'*', '**'})): is_func_call = False - opening = current + opening = current while opening: if opening.value == '(': is_func_call = True @@ -522,7 +525,7 @@ def SurroundedByParens(token): return False elements = previous.container_elements + [previous.matching_bracket] - i = 1 + i = 1 while i < len(elements): if (not elements[i - 1].OpensScope() and not self._FitsOnLine(elements[i - 1], elements[i])): @@ -594,7 +597,7 @@ def _AddTokenOnCurrentLine(self, dry_run): Arguments: dry_run: (bool) Commit whitespace changes to the FormatToken if True. """ - current = self.next_token + current = self.next_token previous = current.previous_token spaces = current.spaces_required_before @@ -637,14 +640,14 @@ def _AddTokenOnNewline(self, dry_run, must_split): Returns: The split penalty for splitting after the current state. """ - current = self.next_token + current = self.next_token previous = current.previous_token self.column = self._GetNewlineColumn() if not dry_run: indent_level = self.line.depth - spaces = self.column + spaces = self.column if spaces: spaces -= indent_level * style.Get('INDENT_WIDTH') current.AddWhitespacePrefix( @@ -657,7 +660,7 @@ def _AddTokenOnNewline(self, dry_run, must_split): if (previous.OpensScope() or (previous.is_comment and previous.previous_token is not None and previous.previous_token.OpensScope())): - dedent = (style.Get('CONTINUATION_INDENT_WIDTH'), + dedent = (style.Get('CONTINUATION_INDENT_WIDTH'), 0)[style.Get('INDENT_CLOSING_BRACKETS')] self.stack[-1].closing_scope_indent = ( max(0, self.stack[-1].indent - dedent)) @@ -677,9 +680,9 @@ def _AddTokenOnNewline(self, dry_run, must_split): # Add a penalty for each increasing newline we add, but don't penalize for # splitting before an if-expression or list comprehension. if current.value not in {'if', 'for'}: - last = self.stack[-1] + last = self.stack[-1] last.num_line_splits += 1 - penalty += ( + penalty += ( style.Get('SPLIT_PENALTY_FOR_ADDED_LINE_SPLIT') * last.num_line_splits) @@ -704,13 +707,13 @@ def MoveStateToNextToken(self): """ current = self.next_token if not current.OpensScope() and not current.ClosesScope(): - self.lowest_level_on_line = min(self.lowest_level_on_line, - self.paren_level) + self.lowest_level_on_line = min( + self.lowest_level_on_line, self.paren_level) # If we encounter an opening bracket, we add a level to our stack to prepare # for the subsequent tokens. if current.OpensScope(): - last = self.stack[-1] + last = self.stack[-1] new_indent = style.Get('CONTINUATION_INDENT_WIDTH') + last.last_space self.stack.append(_ParenState(new_indent, self.stack[-1].last_space)) @@ -740,7 +743,7 @@ def MoveStateToNextToken(self): if (not current.is_pylint_comment and not current.is_pytype_comment and not current.is_copybara_comment and self.column > self.column_limit): excess_characters = self.column - self.column_limit - penalty += style.Get('SPLIT_PENALTY_EXCESS_CHARACTER') * excess_characters + penalty += style.Get('SPLIT_PENALTY_EXCESS_CHARACTER') * excess_characters if is_multiline_string: # If this is a multiline string, the column is actually the @@ -759,10 +762,10 @@ def _CalculateComprehensionState(self, newline): The penalty for the token-newline combination given the current comprehension state. """ - current = self.next_token - previous = current.previous_token + current = self.next_token + previous = current.previous_token top_of_stack = self.comp_stack[-1] if self.comp_stack else None - penalty = 0 + penalty = 0 if top_of_stack is not None: # Check if the token terminates the current comprehension. @@ -798,7 +801,7 @@ def _CalculateComprehensionState(self, newline): not top_of_stack.HasTrivialExpr())): penalty += split_penalty.UNBREAKABLE else: - top_of_stack.for_token = current + top_of_stack.for_token = current top_of_stack.has_split_at_for = newline # Try to keep trivial expressions on the same line as the comp_for. @@ -823,14 +826,14 @@ def _PushParameterListState(self, newline): Args: newline: Whether the current token is to be added on a newline. """ - current = self.next_token + current = self.next_token previous = current.previous_token if _IsFunctionDefinition(previous): first_param_column = previous.total_length + self.stack[-2].indent self.param_list_stack.append( - object_state.ParameterListState(previous, newline, - first_param_column)) + object_state.ParameterListState( + previous, newline, first_param_column)) def _CalculateParameterListState(self, newline): """Makes required changes to parameter list state. @@ -842,18 +845,18 @@ def _CalculateParameterListState(self, newline): The penalty for the token-newline combination given the current parameter state. """ - current = self.next_token + current = self.next_token previous = current.previous_token - penalty = 0 + penalty = 0 if _IsFunctionDefinition(previous): first_param_column = previous.total_length + self.stack[-2].indent if not newline: param_list = self.param_list_stack[-1] if param_list.parameters and param_list.has_typed_return: - last_param = param_list.parameters[-1].first_token - last_token = _LastTokenInLine(previous.matching_bracket) - total_length = last_token.total_length + last_param = param_list.parameters[-1].first_token + last_token = _LastTokenInLine(previous.matching_bracket) + total_length = last_token.total_length total_length -= last_param.total_length - len(last_param.value) if total_length + self.column > self.column_limit: # If we need to split before the trailing code of a function @@ -921,8 +924,9 @@ def _IndentWithContinuationAlignStyle(self, column): return column align_style = style.Get('CONTINUATION_ALIGN_STYLE') if align_style == 'FIXED': - return ((self.line.depth * style.Get('INDENT_WIDTH')) + - style.Get('CONTINUATION_INDENT_WIDTH')) + return ( + (self.line.depth * style.Get('INDENT_WIDTH')) + + style.Get('CONTINUATION_INDENT_WIDTH')) if align_style == 'VALIGN-RIGHT': indent_width = style.Get('INDENT_WIDTH') return indent_width * int((column + indent_width - 1) / indent_width) @@ -930,8 +934,8 @@ def _IndentWithContinuationAlignStyle(self, column): def _GetNewlineColumn(self): """Return the new column on the newline.""" - current = self.next_token - previous = current.previous_token + current = self.next_token + previous = current.previous_token top_of_stack = self.stack[-1] if isinstance(current.spaces_required_before, list): @@ -951,8 +955,8 @@ def _GetNewlineColumn(self): if (previous.OpensScope() or (previous.is_comment and previous.previous_token is not None and previous.previous_token.OpensScope())): - return max(0, - top_of_stack.indent - style.Get('CONTINUATION_INDENT_WIDTH')) + return max( + 0, top_of_stack.indent - style.Get('CONTINUATION_INDENT_WIDTH')) return top_of_stack.closing_scope_indent if (previous and previous.is_string and current.is_string and @@ -1008,7 +1012,7 @@ def ImplicitStringConcatenation(tok): tok = tok.next_token while tok.is_string: num_strings += 1 - tok = tok.next_token + tok = tok.next_token return num_strings > 1 def DictValueIsContainer(opening, closing): @@ -1027,9 +1031,9 @@ def DictValueIsContainer(opening, closing): return False return subtypes.DICTIONARY_KEY_PART in key.subtypes - closing = opening.matching_bracket + closing = opening.matching_bracket entry_start = opening.next_token - current = opening.next_token.next_token + current = opening.next_token.next_token while current and current != closing: if subtypes.DICTIONARY_KEY in current.subtypes: @@ -1037,7 +1041,7 @@ def DictValueIsContainer(opening, closing): if prev.value == ',': prev = PreviousNonCommentToken(prev.previous_token) if not DictValueIsContainer(prev.matching_bracket, prev): - length = prev.total_length - entry_start.total_length + length = prev.total_length - entry_start.total_length length += len(entry_start.value) if length + self.stack[-2].indent >= self.column_limit: return False @@ -1069,7 +1073,7 @@ def DictValueIsContainer(opening, closing): # At this point, current is the closing bracket. Go back one to get the end # of the dictionary entry. current = PreviousNonCommentToken(current) - length = current.total_length - entry_start.total_length + length = current.total_length - entry_start.total_length length += len(entry_start.value) return length + self.stack[-2].indent <= self.column_limit @@ -1089,8 +1093,9 @@ def _ArgumentListHasDictionaryEntry(self, token): def _ContainerFitsOnStartLine(self, opening): """Check if the container can fit on its starting line.""" - return (opening.matching_bracket.total_length - opening.total_length + - self.stack[-1].indent) <= self.column_limit + return ( + opening.matching_bracket.total_length - opening.total_length + + self.stack[-1].indent) <= self.column_limit _COMPOUND_STMTS = frozenset( @@ -1166,8 +1171,8 @@ def _IsLastScopeInLine(current): def _IsSingleElementTuple(token): """Check if it's a single-element tuple.""" - close = token.matching_bracket - token = token.next_token + close = token.matching_bracket + token = token.next_token num_commas = 0 while token != close: if token.value == ',': @@ -1208,17 +1213,17 @@ class _ParenState(object): # TODO(morbo): This doesn't track "bin packing." def __init__(self, indent, last_space): - self.indent = indent - self.last_space = last_space - self.closing_scope_indent = 0 + self.indent = indent + self.last_space = last_space + self.closing_scope_indent = 0 self.split_before_closing_bracket = False - self.num_line_splits = 0 + self.num_line_splits = 0 def Clone(self): - state = _ParenState(self.indent, self.last_space) - state.closing_scope_indent = self.closing_scope_indent + state = _ParenState(self.indent, self.last_space) + state.closing_scope_indent = self.closing_scope_indent state.split_before_closing_bracket = self.split_before_closing_bracket - state.num_line_splits = self.num_line_splits + state.num_line_splits = self.num_line_splits return state def __repr__(self): @@ -1232,5 +1237,7 @@ def __ne__(self, other): return not self == other def __hash__(self, *args, **kwargs): - return hash((self.indent, self.last_space, self.closing_scope_indent, - self.split_before_closing_bracket, self.num_line_splits)) + return hash( + ( + self.indent, self.last_space, self.closing_scope_indent, + self.split_before_closing_bracket, self.num_line_splits)) diff --git a/yapf/yapflib/format_token.py b/yapf/yapflib/format_token.py index 070987851..36c4b3ed2 100644 --- a/yapf/yapflib/format_token.py +++ b/yapf/yapflib/format_token.py @@ -90,27 +90,27 @@ def __init__(self, node, name): node: (pytree.Leaf) The node that's being wrapped. name: (string) The name of the node. """ - self.node = node - self.name = name - self.type = node.type + self.node = node + self.name = name + self.type = node.type self.column = node.column self.lineno = node.lineno - self.value = node.value + self.value = node.value if self.is_continuation: self.value = node.value.rstrip() - self.next_token = None - self.previous_token = None - self.matching_bracket = None - self.parameters = [] - self.container_opening = None + self.next_token = None + self.previous_token = None + self.matching_bracket = None + self.parameters = [] + self.container_opening = None self.container_elements = [] - self.whitespace_prefix = '' - self.total_length = 0 - self.split_penalty = 0 - self.can_break_before = False - self.must_break_before = pytree_utils.GetNodeAnnotation( + self.whitespace_prefix = '' + self.total_length = 0 + self.split_penalty = 0 + self.can_break_before = False + self.must_break_before = pytree_utils.GetNodeAnnotation( node, pytree_utils.Annotation.MUST_SPLIT, default=False) self.newlines = pytree_utils.GetNodeAnnotation( node, pytree_utils.Annotation.NEWLINES) @@ -119,16 +119,16 @@ def __init__(self, node, name): if self.is_comment: self.spaces_required_before = style.Get('SPACES_BEFORE_COMMENT') - stypes = pytree_utils.GetNodeAnnotation(node, - pytree_utils.Annotation.SUBTYPE) - self.subtypes = {subtypes.NONE} if not stypes else stypes + stypes = pytree_utils.GetNodeAnnotation( + node, pytree_utils.Annotation.SUBTYPE) + self.subtypes = {subtypes.NONE} if not stypes else stypes self.is_pseudo = hasattr(node, 'is_pseudo') and node.is_pseudo @property def formatted_whitespace_prefix(self): if style.Get('INDENT_BLANK_LINES'): without_newlines = self.whitespace_prefix.lstrip('\n') - height = len(self.whitespace_prefix) - len(without_newlines) + height = len(self.whitespace_prefix) - len(without_newlines) if height: return ('\n' + without_newlines) * height return self.whitespace_prefix @@ -151,26 +151,26 @@ def AddWhitespacePrefix(self, newlines_before, spaces=0, indent_level=0): else: indent_before = '\t' * indent_level + ' ' * spaces else: - indent_before = (' ' * indent_level * style.Get('INDENT_WIDTH') + - ' ' * spaces) + indent_before = ( + ' ' * indent_level * style.Get('INDENT_WIDTH') + ' ' * spaces) if self.is_comment: comment_lines = [s.lstrip() for s in self.value.splitlines()] - self.value = ('\n' + indent_before).join(comment_lines) + self.value = ('\n' + indent_before).join(comment_lines) # Update our own value since we are changing node value self.value = self.value if not self.whitespace_prefix: - self.whitespace_prefix = ('\n' * (self.newlines or newlines_before) + - indent_before) + self.whitespace_prefix = ( + '\n' * (self.newlines or newlines_before) + indent_before) else: self.whitespace_prefix += indent_before def AdjustNewlinesBefore(self, newlines_before): """Change the number of newlines before this token.""" - self.whitespace_prefix = ('\n' * newlines_before + - self.whitespace_prefix.lstrip('\n')) + self.whitespace_prefix = ( + '\n' * newlines_before + self.whitespace_prefix.lstrip('\n')) def RetainHorizontalSpacing(self, first_column, depth): """Retains a token's horizontal spacing.""" @@ -183,7 +183,7 @@ def RetainHorizontalSpacing(self, first_column, depth): if not previous: return - cur_lineno = self.lineno + cur_lineno = self.lineno prev_lineno = previous.lineno if previous.is_multiline_string: prev_lineno += previous.value.count('\n') @@ -195,13 +195,13 @@ def RetainHorizontalSpacing(self, first_column, depth): self.column - first_column + depth * style.Get('INDENT_WIDTH')) return - cur_column = self.column + cur_column = self.column prev_column = previous.column - prev_len = len(previous.value) + prev_len = len(previous.value) if previous.is_pseudo and previous.value == ')': prev_column -= 1 - prev_len = 0 + prev_len = 0 if previous.is_multiline_string: prev_len = len(previous.value.split('\n')[-1]) @@ -220,10 +220,11 @@ def AddSubtype(self, subtype): self.subtypes.add(subtype) def __repr__(self): - msg = ('FormatToken(name={0}, value={1}, column={2}, lineno={3}, ' - 'splitpenalty={4}'.format( - 'DOCSTRING' if self.is_docstring else self.name, self.value, - self.column, self.lineno, self.split_penalty)) + msg = ( + 'FormatToken(name={0}, value={1}, column={2}, lineno={3}, ' + 'splitpenalty={4}'.format( + 'DOCSTRING' if self.is_docstring else self.name, self.value, + self.column, self.lineno, self.split_penalty)) msg += ', pseudo)' if self.is_pseudo else ')' return msg @@ -242,21 +243,22 @@ def is_binary_op(self): @py3compat.lru_cache() def is_arithmetic_op(self): """Token is an arithmetic operator.""" - return self.value in frozenset({ - '+', # Add - '-', # Subtract - '*', # Multiply - '@', # Matrix Multiply - '/', # Divide - '//', # Floor Divide - '%', # Modulo - '<<', # Left Shift - '>>', # Right Shift - '|', # Bitwise Or - '&', # Bitwise Add - '^', # Bitwise Xor - '**', # Power - }) + return self.value in frozenset( + { + '+', # Add + '-', # Subtract + '*', # Multiply + '@', # Matrix Multiply + '/', # Divide + '//', # Floor Divide + '%', # Modulo + '<<', # Left Shift + '>>', # Right Shift + '|', # Bitwise Or + '&', # Bitwise Add + '^', # Bitwise Xor + '**', # Power + }) @property def is_simple_expr(self): @@ -310,13 +312,13 @@ def is_docstring(self): @property def is_pylint_comment(self): - return self.is_comment and re.match(r'#.*\bpylint:\s*(disable|enable)=', - self.value) + return self.is_comment and re.match( + r'#.*\bpylint:\s*(disable|enable)=', self.value) @property def is_pytype_comment(self): - return self.is_comment and re.match(r'#.*\bpytype:\s*(disable|enable)=', - self.value) + return self.is_comment and re.match( + r'#.*\bpytype:\s*(disable|enable)=', self.value) @property def is_copybara_comment(self): @@ -350,14 +352,17 @@ def is_dict_value(self): @property def is_augassign(self): - augassigns = {'+=', '-=' , '*=' , '@=' , '/=' , '%=' , '&=' , '|=' , '^=' , - '<<=' , '>>=' , '**=' , '//='} + augassigns = { + '+=', '-=', '*=', '@=', '/=', '%=', '&=', '|=', '^=', '<<=', '>>=', + '**=', '//=' + } return self.value in augassigns @property def is_argassign(self): - return (subtypes.DEFAULT_OR_NAMED_ASSIGN in self.subtypes - or subtypes.VARARGS_LIST in self.subtypes) + return ( + subtypes.DEFAULT_OR_NAMED_ASSIGN in self.subtypes or + subtypes.VARARGS_LIST in self.subtypes) @property def is_argname(self): @@ -369,7 +374,7 @@ def is_argname(self): # argument without assignment is also included # the token is arg part before '=' but not after '=' if self.is_argname_start: - return True + return True # exclude comment inside argument list if not self.is_comment: @@ -387,17 +392,17 @@ def is_argname_start(self): previous_subtypes = self.previous_token.subtypes return ( - (not self.is_comment - and subtypes.DEFAULT_OR_NAMED_ASSIGN not in self.subtypes - and subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST in self.subtypes - and subtypes.DEFAULT_OR_NAMED_ASSIGN not in previous_subtypes - and (not subtypes.PARAMETER_STOP in self.subtypes - or subtypes.PARAMETER_START in self.subtypes) - ) - or # if there is comment, the arg after it is the argname start - (not self.is_comment and self.previous_token and self.previous_token.is_comment - and - (subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST in previous_subtypes - or subtypes.TYPED_NAME_ARG_LIST in self.subtypes - or subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST in self.subtypes)) - ) + ( + not self.is_comment and + subtypes.DEFAULT_OR_NAMED_ASSIGN not in self.subtypes and + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST in self.subtypes and + subtypes.DEFAULT_OR_NAMED_ASSIGN not in previous_subtypes and ( + not subtypes.PARAMETER_STOP in self.subtypes or + subtypes.PARAMETER_START in self.subtypes)) + or # if there is comment, the arg after it is the argname start + ( + not self.is_comment and self.previous_token and + self.previous_token.is_comment and ( + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST in previous_subtypes + or subtypes.TYPED_NAME_ARG_LIST in self.subtypes or + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST in self.subtypes))) diff --git a/yapf/yapflib/logical_line.py b/yapf/yapflib/logical_line.py index 8c84b7ba8..477d4d625 100644 --- a/yapf/yapflib/logical_line.py +++ b/yapf/yapflib/logical_line.py @@ -49,7 +49,7 @@ def __init__(self, depth, tokens=None): depth: indentation depth of this line tokens: initial list of tokens """ - self.depth = depth + self.depth = depth self._tokens = tokens or [] self.disable = False @@ -57,7 +57,7 @@ def __init__(self, depth, tokens=None): # Set up a doubly linked list. for index, tok in enumerate(self._tokens[1:]): # Note, 'index' is the index to the previous token. - tok.previous_token = self._tokens[index] + tok.previous_token = self._tokens[index] self._tokens[index].next_token = tok def CalculateFormattingInformation(self): @@ -66,9 +66,9 @@ def CalculateFormattingInformation(self): # means only that if this logical line is joined with a predecessor line, # then there will be a space between them. self.first.spaces_required_before = 1 - self.first.total_length = len(self.first.value) + self.first.total_length = len(self.first.value) - prev_token = self.first + prev_token = self.first prev_length = self.first.total_length for token in self._tokens[1:]: if (token.spaces_required_before == 0 and @@ -93,13 +93,13 @@ def CalculateFormattingInformation(self): # The split penalty has to be computed before {must|can}_break_before, # because these may use it for their decision. - token.split_penalty += _SplitPenalty(prev_token, token) + token.split_penalty += _SplitPenalty(prev_token, token) token.must_break_before = _MustBreakBefore(prev_token, token) - token.can_break_before = ( + token.can_break_before = ( token.must_break_before or _CanBreakBefore(prev_token, token)) prev_length = token.total_length - prev_token = token + prev_token = token def Split(self): """Split the line at semicolons.""" @@ -107,7 +107,7 @@ def Split(self): return [self] llines = [] - lline = LogicalLine(self.depth) + lline = LogicalLine(self.depth) for tok in self._tokens: if tok.value == ';': llines.append(lline) @@ -120,7 +120,7 @@ def Split(self): for lline in llines: lline.first.previous_token = None - lline.last.next_token = None + lline.last.next_token = None return llines @@ -164,7 +164,7 @@ def AsCode(self, indent_per_depth=2): Returns: A string representing the line as code. """ - indent = ' ' * indent_per_depth * self.depth + indent = ' ' * indent_per_depth * self.depth tokens_str = ' '.join(tok.value for tok in self._tokens) return indent + tokens_str @@ -544,10 +544,10 @@ def _CanBreakBefore(prev_token, cur_token): def IsSurroundedByBrackets(tok): """Return True if the token is surrounded by brackets.""" - paren_count = 0 - brace_count = 0 + paren_count = 0 + brace_count = 0 sq_bracket_count = 0 - previous_token = tok.previous_token + previous_token = tok.previous_token while previous_token: if previous_token.value == ')': paren_count -= 1 @@ -580,10 +580,10 @@ def _IsDictListTupleDelimiterTok(tok, is_opening): return False if is_opening: - open_tok = tok + open_tok = tok close_tok = tok.matching_bracket else: - open_tok = tok.matching_bracket + open_tok = tok.matching_bracket close_tok = tok # There must be something in between the tokens @@ -600,8 +600,8 @@ def _IsDictListTupleDelimiterTok(tok, is_opening): ] -_LOGICAL_OPERATORS = frozenset({'and', 'or'}) -_BITWISE_OPERATORS = frozenset({'&', '|', '^'}) +_LOGICAL_OPERATORS = frozenset({'and', 'or'}) +_BITWISE_OPERATORS = frozenset({'&', '|', '^'}) _ARITHMETIC_OPERATORS = frozenset({'+', '-', '*', '/', '%', '//', '@'}) diff --git a/yapf/yapflib/object_state.py b/yapf/yapflib/object_state.py index ec259e682..0afdb6041 100644 --- a/yapf/yapflib/object_state.py +++ b/yapf/yapflib/object_state.py @@ -45,9 +45,9 @@ class ComprehensionState(object): """ def __init__(self, expr_token): - self.expr_token = expr_token - self.for_token = None - self.has_split_at_for = False + self.expr_token = expr_token + self.for_token = None + self.has_split_at_for = False self.has_interior_split = False def HasTrivialExpr(self): @@ -63,17 +63,18 @@ def closing_bracket(self): return self.opening_bracket.matching_bracket def Clone(self): - clone = ComprehensionState(self.expr_token) - clone.for_token = self.for_token - clone.has_split_at_for = self.has_split_at_for + clone = ComprehensionState(self.expr_token) + clone.for_token = self.for_token + clone.has_split_at_for = self.has_split_at_for clone.has_interior_split = self.has_interior_split return clone def __repr__(self): - return ('[opening_bracket::%s, for_token::%s, has_split_at_for::%s,' - ' has_interior_split::%s, has_trivial_expr::%s]' % - (self.opening_bracket, self.for_token, self.has_split_at_for, - self.has_interior_split, self.HasTrivialExpr())) + return ( + '[opening_bracket::%s, for_token::%s, has_split_at_for::%s,' + ' has_interior_split::%s, has_trivial_expr::%s]' % ( + self.opening_bracket, self.for_token, self.has_split_at_for, + self.has_interior_split, self.HasTrivialExpr())) def __eq__(self, other): return hash(self) == hash(other) @@ -82,8 +83,10 @@ def __ne__(self, other): return not self == other def __hash__(self, *args, **kwargs): - return hash((self.expr_token, self.for_token, self.has_split_at_for, - self.has_interior_split)) + return hash( + ( + self.expr_token, self.for_token, self.has_split_at_for, + self.has_interior_split)) class ParameterListState(object): @@ -105,10 +108,10 @@ class ParameterListState(object): """ def __init__(self, opening_bracket, newline, opening_column): - self.opening_bracket = opening_bracket + self.opening_bracket = opening_bracket self.has_split_before_first_param = newline - self.opening_column = opening_column - self.parameters = opening_bracket.parameters + self.opening_column = opening_column + self.parameters = opening_bracket.parameters self.split_before_closing_bracket = False @property @@ -146,8 +149,8 @@ def LastParamFitsOnLine(self, indent): return False if not self.parameters: return True - total_length = self.last_token.total_length - last_param = self.parameters[-1].first_token + total_length = self.last_token.total_length + last_param = self.parameters[-1].first_token total_length -= last_param.total_length - len(last_param.value) return total_length + indent <= style.Get('COLUMN_LIMIT') @@ -160,24 +163,25 @@ def SplitBeforeClosingBracket(self, indent): return True if not self.parameters: return False - total_length = self.last_token.total_length - last_param = self.parameters[-1].first_token + total_length = self.last_token.total_length + last_param = self.parameters[-1].first_token total_length -= last_param.total_length - len(last_param.value) return total_length + indent > style.Get('COLUMN_LIMIT') def Clone(self): - clone = ParameterListState(self.opening_bracket, - self.has_split_before_first_param, - self.opening_column) + clone = ParameterListState( + self.opening_bracket, self.has_split_before_first_param, + self.opening_column) clone.split_before_closing_bracket = self.split_before_closing_bracket - clone.parameters = [param.Clone() for param in self.parameters] + clone.parameters = [param.Clone() for param in self.parameters] return clone def __repr__(self): - return ('[opening_bracket::%s, has_split_before_first_param::%s, ' - 'opening_column::%d]' % - (self.opening_bracket, self.has_split_before_first_param, - self.opening_column)) + return ( + '[opening_bracket::%s, has_split_before_first_param::%s, ' + 'opening_column::%d]' % ( + self.opening_bracket, self.has_split_before_first_param, + self.opening_column)) def __eq__(self, other): return hash(self) == hash(other) @@ -187,8 +191,9 @@ def __ne__(self, other): def __hash__(self, *args, **kwargs): return hash( - (self.opening_bracket, self.has_split_before_first_param, - self.opening_column, (hash(param) for param in self.parameters))) + ( + self.opening_bracket, self.has_split_before_first_param, + self.opening_column, (hash(param) for param in self.parameters))) class Parameter(object): @@ -202,7 +207,7 @@ class Parameter(object): def __init__(self, first_token, last_token): self.first_token = first_token - self.last_token = last_token + self.last_token = last_token @property @py3compat.lru_cache() @@ -219,8 +224,8 @@ def Clone(self): return Parameter(self.first_token, self.last_token) def __repr__(self): - return '[first_token::%s, last_token:%s]' % (self.first_token, - self.last_token) + return '[first_token::%s, last_token:%s]' % ( + self.first_token, self.last_token) def __eq__(self, other): return hash(self) == hash(other) diff --git a/yapf/yapflib/py3compat.py b/yapf/yapflib/py3compat.py index e4cb9788f..2ea5910d1 100644 --- a/yapf/yapflib/py3compat.py +++ b/yapf/yapflib/py3compat.py @@ -18,14 +18,14 @@ import os import sys -PY3 = sys.version_info[0] >= 3 +PY3 = sys.version_info[0] >= 3 PY36 = sys.version_info[0] >= 3 and sys.version_info[1] >= 6 PY37 = sys.version_info[0] >= 3 and sys.version_info[1] >= 7 PY38 = sys.version_info[0] >= 3 and sys.version_info[1] >= 8 if PY3: StringIO = io.StringIO - BytesIO = io.BytesIO + BytesIO = io.BytesIO import codecs # noqa: F811 @@ -35,7 +35,7 @@ def open_with_encoding(filename, mode, encoding, newline=''): # pylint: disable import functools lru_cache = functools.lru_cache - range = range + range = range ifilter = filter def raw_input(): @@ -50,7 +50,7 @@ def raw_input(): import tokenize detect_encoding = tokenize.detect_encoding - TokenInfo = tokenize.TokenInfo + TokenInfo = tokenize.TokenInfo else: import __builtin__ import cStringIO @@ -80,8 +80,8 @@ def fake_wrapper(user_function): import collections - class TokenInfo( - collections.namedtuple('TokenInfo', 'type string start end line')): + class TokenInfo(collections.namedtuple('TokenInfo', + 'type string start end line')): pass @@ -116,7 +116,7 @@ def EncodeAndWriteToStdout(s, encoding='utf-8'): if PY3: basestring = str - unicode = str # pylint: disable=redefined-builtin,invalid-name + unicode = str # pylint: disable=redefined-builtin,invalid-name else: basestring = basestring diff --git a/yapf/yapflib/reformatter.py b/yapf/yapflib/reformatter.py index 8f8a103f8..564d1355f 100644 --- a/yapf/yapflib/reformatter.py +++ b/yapf/yapflib/reformatter.py @@ -49,8 +49,8 @@ def Reformat(llines, verify=False, lines=None): Returns: A string representing the reformatted code. """ - final_lines = [] - prev_line = None # The previous line. + final_lines = [] + prev_line = None # The previous line. indent_width = style.Get('INDENT_WIDTH') for lline in _SingleOrMergedLines(llines): @@ -58,7 +58,7 @@ def Reformat(llines, verify=False, lines=None): _FormatFirstToken(first_token, lline.depth, prev_line, final_lines) indent_amt = indent_width * lline.depth - state = format_decision_state.FormatDecisionState(lline, indent_amt) + state = format_decision_state.FormatDecisionState(lline, indent_amt) state.MoveStateToNextToken() if not lline.disable: @@ -69,8 +69,8 @@ def Reformat(llines, verify=False, lines=None): if prev_line and prev_line.disable: # Keep the vertical spacing between a disabled and enabled formatting # region. - _RetainRequiredVerticalSpacingBetweenTokens(lline.first, prev_line.last, - lines) + _RetainRequiredVerticalSpacingBetweenTokens( + lline.first, prev_line.last, lines) if any(tok.is_comment for tok in lline.tokens): _RetainVerticalSpacingBeforeComments(lline) @@ -105,8 +105,8 @@ def Reformat(llines, verify=False, lines=None): if style.Get('ALIGN_ASSIGNMENT'): _AlignAssignment(final_lines) - if (style.Get('EACH_DICT_ENTRY_ON_SEPARATE_LINE') - and style.Get('ALIGN_DICT_COLON')): + if (style.Get('EACH_DICT_ENTRY_ON_SEPARATE_LINE') and + style.Get('ALIGN_DICT_COLON')): _AlignDictColon(final_lines) if style.Get('ALIGN_ARGUMENT_ASSIGNMENT'): _AlignArgAssign(final_lines) @@ -165,11 +165,11 @@ def _RetainRequiredVerticalSpacingBetweenTokens(cur_tok, prev_tok, lines): # Don't adjust between a comment and non-comment. pass elif lines and lines.intersection(range(prev_lineno, cur_lineno + 1)): - desired_newlines = cur_tok.whitespace_prefix.count('\n') - whitespace_lines = range(prev_lineno + 1, cur_lineno) - deletable_lines = len(lines.intersection(whitespace_lines)) - required_newlines = max(required_newlines - deletable_lines, - desired_newlines) + desired_newlines = cur_tok.whitespace_prefix.count('\n') + whitespace_lines = range(prev_lineno + 1, cur_lineno) + deletable_lines = len(lines.intersection(whitespace_lines)) + required_newlines = max( + required_newlines - deletable_lines, desired_newlines) cur_tok.AdjustNewlinesBefore(required_newlines) @@ -198,7 +198,7 @@ def _EmitLineUnformatted(state): state. """ while state.next_token: - previous_token = state.next_token.previous_token + previous_token = state.next_token.previous_token previous_lineno = previous_token.lineno if previous_token.is_multiline_string or previous_token.is_string: @@ -262,16 +262,17 @@ def _CanPlaceOnSingleLine(line): if (style.Get('FORCE_MULTILINE_DICT') and 'LBRACE' in token_names): return False indent_amt = style.Get('INDENT_WIDTH') * line.depth - last = line.last + last = line.last last_index = -1 if (last.is_pylint_comment or last.is_pytype_comment or last.is_copybara_comment): - last = last.previous_token + last = last.previous_token last_index = -2 if last is None: return True - return (last.total_length + indent_amt <= style.Get('COLUMN_LIMIT') and - not any(tok.is_comment for tok in line.tokens[:last_index])) + return ( + last.total_length + indent_amt <= style.Get('COLUMN_LIMIT') and + not any(tok.is_comment for tok in line.tokens[:last_index])) def _AlignTrailingComments(final_lines): @@ -293,7 +294,7 @@ def _AlignTrailingComments(final_lines): # first col value greater than that value and create the necessary for # each line accordingly. all_pc_line_lengths = [] # All pre-comment line lengths - max_line_length = 0 + max_line_length = 0 while True: # EOF @@ -315,7 +316,7 @@ def _AlignTrailingComments(final_lines): continue # Calculate the length of each line in this logical line. - line_content = '' + line_content = '' pc_line_lengths = [] for line_tok in this_line.tokens: @@ -324,7 +325,7 @@ def _AlignTrailingComments(final_lines): newline_index = whitespace_prefix.rfind('\n') if newline_index != -1: max_line_length = max(max_line_length, len(line_content)) - line_content = '' + line_content = '' whitespace_prefix = whitespace_prefix[newline_index + 1:] @@ -374,8 +375,8 @@ def _AlignTrailingComments(final_lines): for comment_line_index, comment_line in enumerate( line_tok.value.split('\n')): - line_content.append('{}{}'.format(whitespace, - comment_line.strip())) + line_content.append( + '{}{}'.format(whitespace, comment_line.strip())) if comment_line_index == 0: whitespace = ' ' * (aligned_col - 1) @@ -417,63 +418,71 @@ def _AlignAssignment(final_lines): if tok.is_assign or tok.is_augassign: # all pre assignment variable lengths in one block of lines all_pa_variables_lengths = [] - max_variables_length = 0 + max_variables_length = 0 while True: - # EOF - if final_lines_index + len(all_pa_variables_lengths) == len(final_lines): + # EOF + if final_lines_index + len(all_pa_variables_lengths) == len( + final_lines): break this_line_index = final_lines_index + len(all_pa_variables_lengths) - this_line = final_lines[this_line_index] + this_line = final_lines[this_line_index] next_line = None if this_line_index < len(final_lines) - 1: - next_line = final_lines[final_lines_index + len(all_pa_variables_lengths) + 1 ] + next_line = final_lines[final_lines_index + + len(all_pa_variables_lengths) + 1] assert this_line.tokens, next_line.tokens # align them differently when there is a blank line in between if (all_pa_variables_lengths and - this_line.tokens[0].formatted_whitespace_prefix.startswith('\n\n') - ): - break + this_line.tokens[0].formatted_whitespace_prefix.startswith('\n\n') + ): + break # if there is a standalone comment or keyword statement line # or other lines without assignment in between, break elif (all_pa_variables_lengths and - True not in [tok.is_assign or tok.is_augassign for tok in this_line.tokens]): + True not in [tok.is_assign or tok.is_augassign + for tok in this_line.tokens]): if this_line.tokens[0].is_comment: if style.Get('NEW_ALIGNMENT_AFTER_COMMENTLINE'): break - else: break + else: + break if this_line.disable: all_pa_variables_lengths.append([]) continue - variables_content = '' + variables_content = '' pa_variables_lengths = [] - contain_object = False - line_tokens = this_line.tokens + contain_object = False + line_tokens = this_line.tokens # only one assignment expression is on each line for index in range(len(line_tokens)): line_tok = line_tokens[index] - prefix = line_tok.formatted_whitespace_prefix + prefix = line_tok.formatted_whitespace_prefix newline_index = prefix.rfind('\n') if newline_index != -1: variables_content = '' - prefix = prefix[newline_index + 1:] + prefix = prefix[newline_index + 1:] if line_tok.is_assign or line_tok.is_augassign: - next_toks = [line_tokens[i] for i in range(index+1, len(line_tokens))] + next_toks = [ + line_tokens[i] for i in range(index + 1, len(line_tokens)) + ] # if there is object(list/tuple/dict) with newline entries, break, # update the alignment so far and start to calulate new alignment for tok in next_toks: if tok.value in ['(', '[', '{'] and tok.next_token: - if (tok.next_token.formatted_whitespace_prefix.startswith('\n') - or (tok.next_token.is_comment and tok.next_token.next_token.formatted_whitespace_prefix.startswith('\n'))): + if (tok.next_token.formatted_whitespace_prefix.startswith( + '\n') or + (tok.next_token.is_comment and tok.next_token.next_token + .formatted_whitespace_prefix.startswith('\n'))): pa_variables_lengths.append(len(variables_content)) contain_object = True break @@ -482,7 +491,8 @@ def _AlignAssignment(final_lines): pa_variables_lengths.append(len(variables_content)) # if augassign, add the extra augmented part to the max length caculation elif line_tok.is_augassign: - pa_variables_lengths.append(len(variables_content) + len(line_tok.value) - 1 ) + pa_variables_lengths.append( + len(variables_content) + len(line_tok.value) - 1) # don't add the tokens # after the assignment operator break @@ -490,7 +500,8 @@ def _AlignAssignment(final_lines): variables_content += '{}{}'.format(prefix, line_tok.value) if pa_variables_lengths: - max_variables_length = max(max_variables_length, max(pa_variables_lengths)) + max_variables_length = max( + max_variables_length, max(pa_variables_lengths)) all_pa_variables_lengths.append(pa_variables_lengths) @@ -508,43 +519,47 @@ def _AlignAssignment(final_lines): break # if no update of max_length, just go to the next block - if max_variables_length == 0: continue + if max_variables_length == 0: + continue max_variables_length += 2 # Update the assignment token values based on the max variable length for all_pa_variables_lengths_index, pa_variables_lengths in enumerate( - all_pa_variables_lengths): - if not pa_variables_lengths: - continue - this_line = final_lines[final_lines_index + all_pa_variables_lengths_index] + all_pa_variables_lengths): + if not pa_variables_lengths: + continue + this_line = final_lines[final_lines_index + + all_pa_variables_lengths_index] - # only the first assignment operator on each line - pa_variables_lengths_index = 0 - for line_tok in this_line.tokens: - if line_tok.is_assign or line_tok.is_augassign: - assert pa_variables_lengths[0] < max_variables_length + # only the first assignment operator on each line + pa_variables_lengths_index = 0 + for line_tok in this_line.tokens: + if line_tok.is_assign or line_tok.is_augassign: + assert pa_variables_lengths[0] < max_variables_length - if pa_variables_lengths_index < len(pa_variables_lengths): - whitespace = ' ' * ( - max_variables_length - pa_variables_lengths[0] - 1) + if pa_variables_lengths_index < len(pa_variables_lengths): + whitespace = ' ' * ( + max_variables_length - pa_variables_lengths[0] - 1) - assign_content = '{}{}'.format(whitespace, line_tok.value.strip()) + assign_content = '{}{}'.format( + whitespace, line_tok.value.strip()) - existing_whitespace_prefix = \ - line_tok.formatted_whitespace_prefix.lstrip('\n') + existing_whitespace_prefix = \ + line_tok.formatted_whitespace_prefix.lstrip('\n') - # in case the existing spaces are larger than padded spaces - if (len(whitespace) == 1 or len(whitespace) > 1 and - len(existing_whitespace_prefix)>len(whitespace)): - line_tok.whitespace_prefix = '' - elif assign_content.startswith(existing_whitespace_prefix): - assign_content = assign_content[len(existing_whitespace_prefix):] + # in case the existing spaces are larger than padded spaces + if (len(whitespace) == 1 or len(whitespace) > 1 and + len(existing_whitespace_prefix) > len(whitespace)): + line_tok.whitespace_prefix = '' + elif assign_content.startswith(existing_whitespace_prefix): + assign_content = assign_content[ + len(existing_whitespace_prefix):] - # update the assignment operator value - line_tok.value = assign_content + # update the assignment operator value + line_tok.value = assign_content - pa_variables_lengths_index += 1 + pa_variables_lengths_index += 1 final_lines_index += len(all_pa_variables_lengths) @@ -552,7 +567,7 @@ def _AlignAssignment(final_lines): break if not process_content: - final_lines_index += 1 + final_lines_index += 1 def _AlignArgAssign(final_lines): @@ -573,71 +588,74 @@ def _AlignArgAssign(final_lines): for tok in line.tokens: if tok.is_argassign: - this_line = line + this_line = line line_tokens = this_line.tokens for open_index in range(len(line_tokens)): line_tok = line_tokens[open_index] - if (line_tok.value == '(' and not line_tok.is_pseudo - and line_tok.next_token.formatted_whitespace_prefix.startswith('\n')): + if (line_tok.value == '(' and not line_tok.is_pseudo and + line_tok.next_token.formatted_whitespace_prefix.startswith('\n')): index = open_index # skip the comments in the beginning - index += 1 + index += 1 line_tok = line_tokens[index] - while not line_tok.is_argname_start and index < len(line_tokens)-1: - index += 1 + while not line_tok.is_argname_start and index < len( + line_tokens) - 1: + index += 1 line_tok = line_tokens[index] # check if the argstart is on newline - if line_tok.is_argname_start and line_tok.formatted_whitespace_prefix.startswith('\n'): - first_arg_index = index - first_arg_column = len(line_tok.formatted_whitespace_prefix.lstrip('\n')) + if line_tok.is_argname_start and line_tok.formatted_whitespace_prefix.startswith( + '\n'): + first_arg_index = index + first_arg_column = len( + line_tok.formatted_whitespace_prefix.lstrip('\n')) - closing = False + closing = False all_arg_name_lengths = [] - arg_name_lengths = [] - name_content = '' - arg_column = first_arg_column + arg_name_lengths = [] + name_content = '' + arg_column = first_arg_column # start with the first argument # that has nextline prefix while not closing: # if there is a comment in between, save, reset and continue to calulate new alignment - if (style.Get('NEW_ALIGNMENT_AFTER_COMMENTLINE') - and arg_name_lengths and line_tok.is_comment - and line_tok.formatted_whitespace_prefix.startswith('\n')): + if (style.Get('NEW_ALIGNMENT_AFTER_COMMENTLINE') and + arg_name_lengths and line_tok.is_comment and + line_tok.formatted_whitespace_prefix.startswith('\n')): all_arg_name_lengths.append(arg_name_lengths) arg_name_lengths = [] - index += 1 - line_tok = line_tokens[index] + index += 1 + line_tok = line_tokens[index] continue - prefix = line_tok.formatted_whitespace_prefix + prefix = line_tok.formatted_whitespace_prefix newline_index = prefix.rfind('\n') if newline_index != -1: if line_tok.is_argname_start: name_content = '' - prefix = prefix[newline_index + 1:] - arg_column = len(prefix) + prefix = prefix[newline_index + 1:] + arg_column = len(prefix) # if a typed arg name is so long # that there are newlines inside # only calulate the last line arg_name that has the assignment elif line_tok.is_argname: name_content = '' - prefix = prefix[newline_index + 1:] + prefix = prefix[newline_index + 1:] # if any argument not on newline elif line_tok.is_argname_start: name_content = '' - arg_column = line_tok.column + arg_column = line_tok.column # in case they are formatted into one line in final_line # but are put in separated lines in original codes if arg_column == first_arg_column: arg_column = line_tok.formatted_whitespace_prefix # on the same argument level - if (line_tok.is_argname_start and arg_name_lengths - and arg_column==first_arg_column): + if (line_tok.is_argname_start and arg_name_lengths and + arg_column == first_arg_column): argname_end = line_tok while argname_end.is_argname: argname_end = argname_end.next_token @@ -645,8 +663,8 @@ def _AlignArgAssign(final_lines): if not argname_end.is_argassign: all_arg_name_lengths.append(arg_name_lengths) arg_name_lengths = [] - index += 1 - line_tok = line_tokens[index] + index += 1 + line_tok = line_tokens[index] continue if line_tok.is_argassign and arg_column == first_arg_column: @@ -667,19 +685,23 @@ def _AlignArgAssign(final_lines): # if there is a new object(list/tuple/dict) with its entries on newlines, # save, reset and continue to calulate new alignment - if (line_tok.value in ['(', '[','{'] and line_tok.next_token - and line_tok.next_token.formatted_whitespace_prefix.startswith('\n')): + if (line_tok.value in ['(', '[', '{'] and + line_tok.next_token and + line_tok.next_token.formatted_whitespace_prefix.startswith( + '\n')): if arg_name_lengths: all_arg_name_lengths.append(arg_name_lengths) arg_name_lengths = [] - index += 1 - line_tok = line_tokens[index] + index += 1 + line_tok = line_tokens[index] continue - if line_tok.value == ')'and not line_tok.is_pseudo: + if line_tok.value == ')' and not line_tok.is_pseudo: if line_tok.formatted_whitespace_prefix.startswith('\n'): - close_column = len(line_tok.formatted_whitespace_prefix.lstrip('\n')) - else: close_column = line_tok.column + close_column = len( + line_tok.formatted_whitespace_prefix.lstrip('\n')) + else: + close_column = line_tok.column if close_column < first_arg_column: if arg_name_lengths: all_arg_name_lengths.append(arg_name_lengths) @@ -688,50 +710,61 @@ def _AlignArgAssign(final_lines): # update the alignment once one full arg list is processed if all_arg_name_lengths: # if argument list with only the first argument on newline - if len(all_arg_name_lengths) == 1 and len(all_arg_name_lengths[0]) == 1: + if len(all_arg_name_lengths) == 1 and len( + all_arg_name_lengths[0]) == 1: continue - max_name_length = 0 + max_name_length = 0 all_arg_name_lengths_index = 0 - arg_name_lengths = all_arg_name_lengths[all_arg_name_lengths_index] - max_name_length = max(arg_name_lengths or [0]) + 2 + arg_name_lengths = all_arg_name_lengths[ + all_arg_name_lengths_index] + max_name_length = max(arg_name_lengths or [0]) + 2 arg_lengths_index = 0 for token in line_tokens[first_arg_index:index]: if token.is_argassign: name_token = token.previous_token while name_token.is_argname and not name_token.is_argname_start: name_token = name_token.previous_token - name_column = len(name_token.formatted_whitespace_prefix.lstrip('\n')) + name_column = len( + name_token.formatted_whitespace_prefix.lstrip('\n')) if name_column == first_arg_column: if all_arg_name_lengths_index < len(all_arg_name_lengths): if arg_lengths_index == len(arg_name_lengths): all_arg_name_lengths_index += 1 - arg_name_lengths = all_arg_name_lengths[all_arg_name_lengths_index] - max_name_length = max(arg_name_lengths or [0]) + 2 + arg_name_lengths = all_arg_name_lengths[ + all_arg_name_lengths_index] + max_name_length = max(arg_name_lengths or [0]) + 2 arg_lengths_index = 0 if arg_lengths_index < len(arg_name_lengths): - assert arg_name_lengths[arg_lengths_index] < max_name_length + assert arg_name_lengths[ + arg_lengths_index] < max_name_length padded_spaces = ' ' * ( - max_name_length - arg_name_lengths[arg_lengths_index] - 1) + max_name_length - + arg_name_lengths[arg_lengths_index] - 1) arg_lengths_index += 1 - assign_content = '{}{}'.format(padded_spaces, token.value.strip()) + assign_content = '{}{}'.format( + padded_spaces, token.value.strip()) existing_whitespace_prefix = \ token.formatted_whitespace_prefix.lstrip('\n') # in case the existing spaces are larger than padded spaces - if (len(padded_spaces)==1 or len(padded_spaces)>1 and - len(existing_whitespace_prefix)>len(padded_spaces)): + if (len(padded_spaces) == 1 or + len(padded_spaces) > 1 and + len(existing_whitespace_prefix) + > len(padded_spaces)): token.whitespace_prefix = '' - elif assign_content.startswith(existing_whitespace_prefix): - assign_content = assign_content[len(existing_whitespace_prefix):] + elif assign_content.startswith( + existing_whitespace_prefix): + assign_content = assign_content[ + len(existing_whitespace_prefix):] token.value = assign_content final_lines_index += 1 - process_content = True + process_content = True break if not process_content: @@ -754,153 +787,170 @@ def _AlignDictColon(final_lines): for tok in line.tokens: # make sure each dict entry on separate lines and # the dict has more than one entry - if (tok.is_dict_key and tok.formatted_whitespace_prefix.startswith('\n') and - not tok.is_comment): + if (tok.is_dict_key and + tok.formatted_whitespace_prefix.startswith('\n') and + not tok.is_comment): - this_line = line + this_line = line - line_tokens = this_line.tokens - for open_index in range(len(line_tokens)): - line_tok = line_tokens[open_index] + line_tokens = this_line.tokens + for open_index in range(len(line_tokens)): + line_tok = line_tokens[open_index] + + # check each time if the detected dict is the dict we aim for + if line_tok.value == '{' and line_tok.next_token.formatted_whitespace_prefix.startswith( + '\n'): + index = open_index + # skip the comments in the beginning + index += 1 + line_tok = line_tokens[index] + while not line_tok.is_dict_key and index < len(line_tokens) - 1: + index += 1 + line_tok = line_tokens[index] + # in case empty dict, check if dict key again + if line_tok.is_dict_key and line_tok.formatted_whitespace_prefix.startswith( + '\n'): + closing = False # the closing bracket in dict '}'. + keys_content = '' + all_dict_keys_lengths = [] + dict_keys_lengths = [] + + # record the column number of the first key + first_key_column = len( + line_tok.formatted_whitespace_prefix.lstrip('\n')) + key_column = first_key_column + + # while not closing: + while not closing: + prefix = line_tok.formatted_whitespace_prefix + newline = prefix.startswith('\n') + if newline: + # if comments inbetween, save, reset and continue to caluclate new alignment + if (style.Get('NEW_ALIGNMENT_AFTER_COMMENTLINE') and + dict_keys_lengths and line_tok.is_comment): + all_dict_keys_lengths.append(dict_keys_lengths) + dict_keys_lengths = [] + index += 1 + line_tok = line_tokens[index] + continue + if line_tok.is_dict_key_start: + keys_content = '' + prefix = prefix.lstrip('\n') + key_column = len(prefix) + # if the dict key is so long that it has multi-lines + # only caculate the last line that has the colon + elif line_tok.is_dict_key: + keys_content = '' + prefix = prefix.lstrip('\n') + elif line_tok.is_dict_key_start: + key_column = line_tok.column + + if line_tok.is_dict_colon and key_column == first_key_column: + dict_keys_lengths.append(len(keys_content)) + elif line_tok.is_dict_key and key_column == first_key_column: + keys_content += '{}{}'.format(prefix, line_tok.value) - # check each time if the detected dict is the dict we aim for - if line_tok.value == '{' and line_tok.next_token.formatted_whitespace_prefix.startswith('\n'): - index = open_index - # skip the comments in the beginning index += 1 - line_tok = line_tokens[index] - while not line_tok.is_dict_key and index < len(line_tokens)-1: - index += 1 + if index < len(line_tokens): line_tok = line_tokens[index] - # in case empty dict, check if dict key again - if line_tok.is_dict_key and line_tok.formatted_whitespace_prefix.startswith('\n'): - closing = False # the closing bracket in dict '}'. - keys_content = '' - all_dict_keys_lengths = [] - dict_keys_lengths = [] + # when the matching closing bracket is never found + # due to edge cases where the closing bracket + # is not indented or dedented, e.g. ']}', with another bracket before + else: + all_dict_keys_lengths.append(dict_keys_lengths) + break - # record the column number of the first key - first_key_column = len(line_tok.formatted_whitespace_prefix.lstrip('\n')) - key_column = first_key_column - - # while not closing: - while not closing: - prefix = line_tok.formatted_whitespace_prefix - newline = prefix.startswith('\n') - if newline: - # if comments inbetween, save, reset and continue to caluclate new alignment - if (style.Get('NEW_ALIGNMENT_AFTER_COMMENTLINE') - and dict_keys_lengths and line_tok.is_comment): - all_dict_keys_lengths.append(dict_keys_lengths) - dict_keys_lengths =[] - index += 1 - line_tok = line_tokens[index] - continue - if line_tok.is_dict_key_start: - keys_content = '' - prefix = prefix.lstrip('\n') - key_column = len(prefix) - # if the dict key is so long that it has multi-lines - # only caculate the last line that has the colon - elif line_tok.is_dict_key: - keys_content = '' - prefix = prefix.lstrip('\n') - elif line_tok.is_dict_key_start: - key_column = line_tok.column - - if line_tok.is_dict_colon and key_column == first_key_column: - dict_keys_lengths.append(len(keys_content)) - elif line_tok.is_dict_key and key_column == first_key_column: - keys_content += '{}{}'.format(prefix, line_tok.value) - - index += 1 - if index < len(line_tokens): - line_tok = line_tokens[index] - # when the matching closing bracket is never found - # due to edge cases where the closing bracket - # is not indented or dedented, e.g. ']}', with another bracket before - else: + # if there is new objects(list/tuple/dict) with its entries on newlines, + # or a function call with any of its arguments on newlines, + # save, reset and continue to calulate new alignment + if (line_tok.value in ['(', '[', '{'] and + not line_tok.is_pseudo and line_tok.next_token and + line_tok.next_token.formatted_whitespace_prefix.startswith( + '\n')): + if dict_keys_lengths: + all_dict_keys_lengths.append(dict_keys_lengths) + dict_keys_lengths = [] + index += 1 + line_tok = line_tokens[index] + continue + # the matching closing bracket is either same indented or dedented + # accordingly to previous level's indentation + # the first found, immediately break the while loop + if line_tok.value == '}': + if line_tok.formatted_whitespace_prefix.startswith('\n'): + close_column = len( + line_tok.formatted_whitespace_prefix.lstrip('\n')) + else: + close_column = line_tok.column + if close_column < first_key_column: + if dict_keys_lengths: all_dict_keys_lengths.append(dict_keys_lengths) - break - - # if there is new objects(list/tuple/dict) with its entries on newlines, - # or a function call with any of its arguments on newlines, - # save, reset and continue to calulate new alignment - if (line_tok.value in ['(', '[', '{'] and not line_tok.is_pseudo and line_tok.next_token - and line_tok.next_token.formatted_whitespace_prefix.startswith('\n')): - if dict_keys_lengths: - all_dict_keys_lengths.append(dict_keys_lengths) - dict_keys_lengths = [] - index += 1 - line_tok = line_tokens[index] - continue - # the matching closing bracket is either same indented or dedented - # accordingly to previous level's indentation - # the first found, immediately break the while loop - if line_tok.value == '}': - if line_tok.formatted_whitespace_prefix.startswith('\n'): - close_column = len(line_tok.formatted_whitespace_prefix.lstrip('\n')) - else: close_column = line_tok.column - if close_column < first_key_column: - if dict_keys_lengths: - all_dict_keys_lengths.append(dict_keys_lengths) - closing = True - - # update the alignment once one dict is processed - if all_dict_keys_lengths: - max_keys_length = 0 - all_dict_keys_lengths_index = 0 - dict_keys_lengths = all_dict_keys_lengths[all_dict_keys_lengths_index] - max_keys_length = max(dict_keys_lengths or [0]) + 2 - keys_lengths_index = 0 - for token in line_tokens[open_index+1:index]: - if token.is_dict_colon: - # check if the key has multiple tokens and - # get the first key token in this key - key_token = token.previous_token - while key_token.is_dict_key and not key_token.is_dict_key_start: - key_token = key_token.previous_token - key_column = len(key_token.formatted_whitespace_prefix.lstrip('\n')) - - if key_column == first_key_column: - - if keys_lengths_index == len(dict_keys_lengths): - all_dict_keys_lengths_index += 1 - dict_keys_lengths = all_dict_keys_lengths[all_dict_keys_lengths_index] - max_keys_length = max(dict_keys_lengths or [0]) + 2 - keys_lengths_index = 0 - - if keys_lengths_index < len(dict_keys_lengths): - assert dict_keys_lengths[keys_lengths_index] < max_keys_length - - padded_spaces = ' ' * ( - max_keys_length - dict_keys_lengths[keys_lengths_index] - 1) - keys_lengths_index += 1 - #NOTE if the existing whitespaces are larger than padded spaces - existing_whitespace_prefix = \ - token.formatted_whitespace_prefix.lstrip('\n') - colon_content = '{}{}'.format(padded_spaces, token.value.strip()) - - # in case the existing spaces are larger than the paddes spaces - if (len(padded_spaces) == 1 or len(padded_spaces) > 1 - and len(existing_whitespace_prefix) >= len(padded_spaces)): - # remove the existing spaces - token.whitespace_prefix = '' - elif colon_content.startswith(existing_whitespace_prefix): - colon_content = colon_content[len(existing_whitespace_prefix):] - - token.value = colon_content - - final_lines_index += 1 - - process_content = True - break + closing = True + + # update the alignment once one dict is processed + if all_dict_keys_lengths: + max_keys_length = 0 + all_dict_keys_lengths_index = 0 + dict_keys_lengths = all_dict_keys_lengths[ + all_dict_keys_lengths_index] + max_keys_length = max(dict_keys_lengths or [0]) + 2 + keys_lengths_index = 0 + for token in line_tokens[open_index + 1:index]: + if token.is_dict_colon: + # check if the key has multiple tokens and + # get the first key token in this key + key_token = token.previous_token + while key_token.is_dict_key and not key_token.is_dict_key_start: + key_token = key_token.previous_token + key_column = len( + key_token.formatted_whitespace_prefix.lstrip('\n')) + + if key_column == first_key_column: + + if keys_lengths_index == len(dict_keys_lengths): + all_dict_keys_lengths_index += 1 + dict_keys_lengths = all_dict_keys_lengths[ + all_dict_keys_lengths_index] + max_keys_length = max(dict_keys_lengths or [0]) + 2 + keys_lengths_index = 0 + + if keys_lengths_index < len(dict_keys_lengths): + assert dict_keys_lengths[ + keys_lengths_index] < max_keys_length + + padded_spaces = ' ' * ( + max_keys_length - + dict_keys_lengths[keys_lengths_index] - 1) + keys_lengths_index += 1 + #NOTE if the existing whitespaces are larger than padded spaces + existing_whitespace_prefix = \ + token.formatted_whitespace_prefix.lstrip('\n') + colon_content = '{}{}'.format( + padded_spaces, token.value.strip()) + + # in case the existing spaces are larger than the paddes spaces + if (len(padded_spaces) == 1 or + len(padded_spaces) > 1 and + len(existing_whitespace_prefix) + >= len(padded_spaces)): + # remove the existing spaces + token.whitespace_prefix = '' + elif colon_content.startswith( + existing_whitespace_prefix): + colon_content = colon_content[ + len(existing_whitespace_prefix):] + + token.value = colon_content + + final_lines_index += 1 + + process_content = True + break if not process_content: final_lines_index += 1 - def _FormatFinalLines(final_lines, verify): """Compose the final output from the finalized lines.""" formatted_code = [] @@ -937,8 +987,8 @@ class _StateNode(object): # TODO(morbo): Add a '__cmp__' method. def __init__(self, state, newline, previous): - self.state = state.Clone() - self.newline = newline + self.state = state.Clone() + self.newline = newline self.previous = previous def __repr__(self): # pragma: no cover @@ -954,8 +1004,8 @@ def __repr__(self): # pragma: no cover # An item in the prioritized BFS search queue. The 'StateNode's 'state' has # the given '_OrderedPenalty'. -_QueueItem = collections.namedtuple('QueueItem', - ['ordered_penalty', 'state_node']) +_QueueItem = collections.namedtuple( + 'QueueItem', ['ordered_penalty', 'state_node']) def _AnalyzeSolutionSpace(initial_state): @@ -973,8 +1023,8 @@ def _AnalyzeSolutionSpace(initial_state): Returns: True if a formatting solution was found. False otherwise. """ - count = 0 - seen = set() + count = 0 + seen = set() p_queue = [] # Insert start element. @@ -983,9 +1033,9 @@ def _AnalyzeSolutionSpace(initial_state): count += 1 while p_queue: - item = p_queue[0] + item = p_queue[0] penalty = item.ordered_penalty.penalty - node = item.state_node + node = item.state_node if not node.state.next_token: break heapq.heappop(p_queue) @@ -1039,7 +1089,7 @@ def _AddNextStateToQueue(penalty, previous_node, newline, count, p_queue): # Don't add a token we must split but where we aren't splitting. return count - node = _StateNode(previous_node.state, newline, previous_node) + node = _StateNode(previous_node.state, newline, previous_node) penalty += node.state.AddTokenToState( newline=newline, dry_run=True, must_split=must_split) heapq.heappush(p_queue, _QueueItem(_OrderedPenalty(penalty, count), node)) @@ -1095,25 +1145,25 @@ def _FormatFirstToken(first_token, indent_depth, prev_line, final_lines): NESTED_DEPTH.append(indent_depth) first_token.AddWhitespacePrefix( - _CalculateNumberOfNewlines(first_token, indent_depth, prev_line, - final_lines, first_nested), + _CalculateNumberOfNewlines( + first_token, indent_depth, prev_line, final_lines, first_nested), indent_level=indent_depth) -NO_BLANK_LINES = 1 -ONE_BLANK_LINE = 2 +NO_BLANK_LINES = 1 +ONE_BLANK_LINE = 2 TWO_BLANK_LINES = 3 def _IsClassOrDef(tok): if tok.value in {'class', 'def', '@'}: return True - return (tok.next_token and tok.value == 'async' and - tok.next_token.value == 'def') + return ( + tok.next_token and tok.value == 'async' and tok.next_token.value == 'def') -def _CalculateNumberOfNewlines(first_token, indent_depth, prev_line, - final_lines, first_nested): +def _CalculateNumberOfNewlines( + first_token, indent_depth, prev_line, final_lines, first_nested): """Calculate the number of newlines we need to add. Arguments: @@ -1233,11 +1283,11 @@ def _SingleOrMergedLines(lines): Either a single line, if the current line cannot be merged with the succeeding line, or the next two lines merged into one line. """ - index = 0 + index = 0 last_was_merged = False while index < len(lines): if lines[index].disable: - line = lines[index] + line = lines[index] index += 1 while index < len(lines): column = line.last.column + 2 @@ -1263,11 +1313,11 @@ def _SingleOrMergedLines(lines): # formatting. Otherwise, it could mess up the shell script's syntax. lines[index].disable = True yield lines[index] - index += 2 + index += 2 last_was_merged = True else: yield lines[index] - index += 1 + index += 1 last_was_merged = False diff --git a/yapf/yapflib/split_penalty.py b/yapf/yapflib/split_penalty.py index 79b68edcd..8f93d3ade 100644 --- a/yapf/yapflib/split_penalty.py +++ b/yapf/yapflib/split_penalty.py @@ -15,9 +15,9 @@ from yapf.yapflib import style # Generic split penalties -UNBREAKABLE = 1000**5 +UNBREAKABLE = 1000**5 VERY_STRONGLY_CONNECTED = 5000 -STRONGLY_CONNECTED = 2500 +STRONGLY_CONNECTED = 2500 ############################################################################# # Grammar-specific penalties - should be <= 1000 # @@ -25,15 +25,15 @@ # Lambdas shouldn't be split unless absolutely necessary or if # ALLOW_MULTILINE_LAMBDAS is True. -LAMBDA = 1000 +LAMBDA = 1000 MULTILINE_LAMBDA = 500 ANNOTATION = 100 -ARGUMENT = 25 +ARGUMENT = 25 # TODO: Assign real values. -RETURN_TYPE = 1 -DOTTED_NAME = 40 -EXPR = 10 -DICT_KEY_EXPR = 20 +RETURN_TYPE = 1 +DOTTED_NAME = 40 +EXPR = 10 +DICT_KEY_EXPR = 20 DICT_VALUE_EXPR = 11 diff --git a/yapf/yapflib/style.py b/yapf/yapflib/style.py index d9e9e5e9e..20414f717 100644 --- a/yapf/yapflib/style.py +++ b/yapf/yapflib/style.py @@ -52,27 +52,36 @@ def SetGlobalStyle(style): _STYLE_HELP = dict( - ALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENT=textwrap.dedent("""\ + ALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENT =textwrap.dedent( + """\ Align closing bracket with visual indentation."""), - ALIGN_ASSIGNMENT=textwrap.dedent("""\ + ALIGN_ASSIGNMENT =textwrap.dedent( + """\ Align assignment or augmented assignment operators. If there is a blank line or newline comment or objects with newline entries in between, it will start new block alignment."""), - ALIGN_ARGUMENT_ASSIGNMENT=textwrap.dedent("""\ + ALIGN_ARGUMENT_ASSIGNMENT =textwrap.dedent( + """\ Align assignment operators in the argument list if they are all split on newlines. Arguments without assignment are ignored. Arguments without assignment in between will initiate new block alignment calulation. - Newline comments or objects with newline entries will also start new block alignment."""), - ALIGN_DICT_COLON=textwrap.dedent("""\ + Newline comments or objects with newline entries will also start new block alignment.""" + ), + ALIGN_DICT_COLON =textwrap.dedent( + """\ Align the colons in the dictionary if all entries in dictionay are split on newlines. or 'EACH_DICT_ENTRY_ON_SEPERATE_LINE' is set True. """), - NEW_ALIGNMENT_AFTER_COMMENTLINE=textwrap.dedent("""\ - Start new assignment or colon alignment when there is a newline comment in between."""), - ALLOW_MULTILINE_LAMBDAS=textwrap.dedent("""\ + NEW_ALIGNMENT_AFTER_COMMENTLINE =textwrap.dedent( + """\ + Start new assignment or colon alignment when there is a newline comment in between.""" + ), + ALLOW_MULTILINE_LAMBDAS =textwrap.dedent( + """\ Allow lambdas to be formatted on more than one line."""), - ALLOW_MULTILINE_DICTIONARY_KEYS=textwrap.dedent("""\ + ALLOW_MULTILINE_DICTIONARY_KEYS =textwrap.dedent( + """\ Allow dictionary keys to exist on multiple lines. For example: x = { @@ -80,12 +89,15 @@ def SetGlobalStyle(style): 'this is the second element of a tuple'): value, }"""), - ALLOW_SPLIT_BEFORE_DEFAULT_OR_NAMED_ASSIGNS=textwrap.dedent("""\ + ALLOW_SPLIT_BEFORE_DEFAULT_OR_NAMED_ASSIGNS =textwrap.dedent( + """\ Allow splitting before a default / named assignment in an argument list. """), - ALLOW_SPLIT_BEFORE_DICT_VALUE=textwrap.dedent("""\ + ALLOW_SPLIT_BEFORE_DICT_VALUE =textwrap.dedent( + """\ Allow splits before the dictionary value."""), - ARITHMETIC_PRECEDENCE_INDICATION=textwrap.dedent("""\ + ARITHMETIC_PRECEDENCE_INDICATION =textwrap.dedent( + """\ Let spacing indicate operator precedence. For example: a = 1 * 2 + 3 / 4 @@ -105,7 +117,8 @@ def SetGlobalStyle(style): f = 1 + 2 + 3 + 4 """), - BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF=textwrap.dedent("""\ + BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF =textwrap.dedent( + """\ Insert a blank line before a 'def' or 'class' immediately nested within another 'def' or 'class'. For example: @@ -113,17 +126,22 @@ class Foo: # <------ this blank line def method(): ..."""), - BLANK_LINE_BEFORE_CLASS_DOCSTRING=textwrap.dedent("""\ + BLANK_LINE_BEFORE_CLASS_DOCSTRING =textwrap.dedent( + """\ Insert a blank line before a class-level docstring."""), - BLANK_LINE_BEFORE_MODULE_DOCSTRING=textwrap.dedent("""\ + BLANK_LINE_BEFORE_MODULE_DOCSTRING =textwrap.dedent( + """\ Insert a blank line before a module docstring."""), - BLANK_LINES_AROUND_TOP_LEVEL_DEFINITION=textwrap.dedent("""\ + BLANK_LINES_AROUND_TOP_LEVEL_DEFINITION =textwrap.dedent( + """\ Number of blank lines surrounding top-level function and class definitions."""), - BLANK_LINES_BETWEEN_TOP_LEVEL_IMPORTS_AND_VARIABLES=textwrap.dedent("""\ + BLANK_LINES_BETWEEN_TOP_LEVEL_IMPORTS_AND_VARIABLES =textwrap.dedent( + """\ Number of blank lines between top-level imports and variable definitions."""), - COALESCE_BRACKETS=textwrap.dedent("""\ + COALESCE_BRACKETS =textwrap.dedent( + """\ Do not split consecutive brackets. Only relevant when dedent_closing_brackets is set. For example: @@ -140,9 +158,10 @@ def method(): 'key1': 'value1', 'key2': 'value2', })"""), - COLUMN_LIMIT=textwrap.dedent("""\ + COLUMN_LIMIT =textwrap.dedent("""\ The column limit."""), - CONTINUATION_ALIGN_STYLE=textwrap.dedent("""\ + CONTINUATION_ALIGN_STYLE =textwrap.dedent( + """\ The style for continuation alignment. Possible values are: - SPACE: Use spaces for continuation alignment. This is default behavior. @@ -152,9 +171,11 @@ def method(): - VALIGN-RIGHT: Vertically align continuation lines to multiple of INDENT_WIDTH columns. Slightly right (one tab or a few spaces) if cannot vertically align continuation lines with indent characters."""), - CONTINUATION_INDENT_WIDTH=textwrap.dedent("""\ + CONTINUATION_INDENT_WIDTH =textwrap.dedent( + """\ Indent width used for line continuations."""), - DEDENT_CLOSING_BRACKETS=textwrap.dedent("""\ + DEDENT_CLOSING_BRACKETS =textwrap.dedent( + """\ Put closing brackets on a separate line, dedented, if the bracketed expression can't fit in a single line. Applies to all kinds of brackets, including function definitions and calls. For example: @@ -172,27 +193,33 @@ def method(): end_ts=now(), ) # <--- this bracket is dedented and on a separate line """), - DISABLE_ENDING_COMMA_HEURISTIC=textwrap.dedent("""\ + DISABLE_ENDING_COMMA_HEURISTIC =textwrap.dedent( + """\ Disable the heuristic which places each list element on a separate line if the list is comma-terminated."""), - EACH_DICT_ENTRY_ON_SEPARATE_LINE=textwrap.dedent("""\ + EACH_DICT_ENTRY_ON_SEPARATE_LINE =textwrap.dedent( + """\ Place each dictionary entry onto its own line."""), - FORCE_MULTILINE_DICT=textwrap.dedent("""\ + FORCE_MULTILINE_DICT =textwrap.dedent( + """\ Require multiline dictionary even if it would normally fit on one line. For example: config = { 'key1': 'value1' }"""), - I18N_COMMENT=textwrap.dedent("""\ + I18N_COMMENT =textwrap.dedent( + """\ The regex for an i18n comment. The presence of this comment stops reformatting of that line, because the comments are required to be next to the string they translate."""), - I18N_FUNCTION_CALL=textwrap.dedent("""\ + I18N_FUNCTION_CALL =textwrap.dedent( + """\ The i18n function call names. The presence of this function stops reformattting on that line, because the string it has cannot be moved away from the i18n comment."""), - INDENT_CLOSING_BRACKETS=textwrap.dedent("""\ + INDENT_CLOSING_BRACKETS =textwrap.dedent( + """\ Put closing brackets on a separate line, indented, if the bracketed expression can't fit in a single line. Applies to all kinds of brackets, including function definitions and calls. For example: @@ -210,7 +237,8 @@ def method(): end_ts=now(), ) # <--- this bracket is indented and on a separate line """), - INDENT_DICTIONARY_VALUE=textwrap.dedent("""\ + INDENT_DICTIONARY_VALUE =textwrap.dedent( + """\ Indent the dictionary value if it cannot fit on the same line as the dictionary key. For example: @@ -221,13 +249,16 @@ def method(): value2, } """), - INDENT_WIDTH=textwrap.dedent("""\ + INDENT_WIDTH =textwrap.dedent( + """\ The number of columns to use for indentation."""), - INDENT_BLANK_LINES=textwrap.dedent("""\ + INDENT_BLANK_LINES =textwrap.dedent("""\ Indent blank lines."""), - JOIN_MULTIPLE_LINES=textwrap.dedent("""\ + JOIN_MULTIPLE_LINES =textwrap.dedent( + """\ Join short lines into one line. E.g., single line 'if' statements."""), - NO_SPACES_AROUND_SELECTED_BINARY_OPERATORS=textwrap.dedent("""\ + NO_SPACES_AROUND_SELECTED_BINARY_OPERATORS =textwrap.dedent( + """\ Do not include spaces around selected binary operators. For example: 1 + 2 * 3 - 4 / 5 @@ -236,21 +267,26 @@ def method(): 1 + 2*3 - 4/5 """), - SPACE_BETWEEN_ENDING_COMMA_AND_CLOSING_BRACKET=textwrap.dedent("""\ + SPACE_BETWEEN_ENDING_COMMA_AND_CLOSING_BRACKET =textwrap.dedent( + """\ Insert a space between the ending comma and closing bracket of a list, etc."""), - SPACE_INSIDE_BRACKETS=textwrap.dedent("""\ + SPACE_INSIDE_BRACKETS =textwrap.dedent( + """\ Use spaces inside brackets, braces, and parentheses. For example: method_call( 1 ) my_dict[ 3 ][ 1 ][ get_index( *args, **kwargs ) ] my_set = { 1, 2, 3 } """), - SPACES_AROUND_POWER_OPERATOR=textwrap.dedent("""\ + SPACES_AROUND_POWER_OPERATOR =textwrap.dedent( + """\ Use spaces around the power operator."""), - SPACES_AROUND_DEFAULT_OR_NAMED_ASSIGN=textwrap.dedent("""\ + SPACES_AROUND_DEFAULT_OR_NAMED_ASSIGN =textwrap.dedent( + """\ Use spaces around default or named assigns."""), - SPACES_AROUND_DICT_DELIMITERS=textwrap.dedent("""\ + SPACES_AROUND_DICT_DELIMITERS =textwrap.dedent( + """\ Adds a space after the opening '{' and before the ending '}' dict delimiters. @@ -260,7 +296,8 @@ def method(): { 1: 2 } """), - SPACES_AROUND_LIST_DELIMITERS=textwrap.dedent("""\ + SPACES_AROUND_LIST_DELIMITERS =textwrap.dedent( + """\ Adds a space after the opening '[' and before the ending ']' list delimiters. @@ -270,12 +307,14 @@ def method(): [ 1, 2 ] """), - SPACES_AROUND_SUBSCRIPT_COLON=textwrap.dedent("""\ + SPACES_AROUND_SUBSCRIPT_COLON =textwrap.dedent( + """\ Use spaces around the subscript / slice operator. For example: my_list[1 : 10 : 2] """), - SPACES_AROUND_TUPLE_DELIMITERS=textwrap.dedent("""\ + SPACES_AROUND_TUPLE_DELIMITERS =textwrap.dedent( + """\ Adds a space after the opening '(' and before the ending ')' tuple delimiters. @@ -285,7 +324,8 @@ def method(): ( 1, 2, 3 ) """), - SPACES_BEFORE_COMMENT=textwrap.dedent("""\ + SPACES_BEFORE_COMMENT =textwrap.dedent( + """\ The number of spaces required before a trailing comment. This can be a single value (representing the number of spaces before each trailing comment) or list of values (representing @@ -327,24 +367,31 @@ def method(): short # This is a shorter statement """), # noqa - SPLIT_ARGUMENTS_WHEN_COMMA_TERMINATED=textwrap.dedent("""\ + SPLIT_ARGUMENTS_WHEN_COMMA_TERMINATED =textwrap.dedent( + """\ Split before arguments if the argument list is terminated by a comma."""), - SPLIT_ALL_COMMA_SEPARATED_VALUES=textwrap.dedent("""\ + SPLIT_ALL_COMMA_SEPARATED_VALUES =textwrap.dedent( + """\ Split before arguments"""), - SPLIT_ALL_TOP_LEVEL_COMMA_SEPARATED_VALUES=textwrap.dedent("""\ + SPLIT_ALL_TOP_LEVEL_COMMA_SEPARATED_VALUES =textwrap.dedent( + """\ Split before arguments, but do not split all subexpressions recursively (unless needed)."""), - SPLIT_BEFORE_ARITHMETIC_OPERATOR=textwrap.dedent("""\ + SPLIT_BEFORE_ARITHMETIC_OPERATOR =textwrap.dedent( + """\ Set to True to prefer splitting before '+', '-', '*', '/', '//', or '@' rather than after."""), - SPLIT_BEFORE_BITWISE_OPERATOR=textwrap.dedent("""\ + SPLIT_BEFORE_BITWISE_OPERATOR =textwrap.dedent( + """\ Set to True to prefer splitting before '&', '|' or '^' rather than after."""), - SPLIT_BEFORE_CLOSING_BRACKET=textwrap.dedent("""\ + SPLIT_BEFORE_CLOSING_BRACKET =textwrap.dedent( + """\ Split before the closing bracket if a list or dict literal doesn't fit on a single line."""), - SPLIT_BEFORE_DICT_SET_GENERATOR=textwrap.dedent("""\ + SPLIT_BEFORE_DICT_SET_GENERATOR =textwrap.dedent( + """\ Split before a dictionary or set generator (comp_for). For example, note the split before the 'for': @@ -352,7 +399,8 @@ def method(): variable: 'Hello world, have a nice day!' for variable in bar if variable != 42 }"""), - SPLIT_BEFORE_DOT=textwrap.dedent("""\ + SPLIT_BEFORE_DOT =textwrap.dedent( + """\ Split before the '.' if we need to split a longer expression: foo = ('This is a really long string: {}, {}, {}, {}'.format(a, b, c, d)) @@ -362,19 +410,24 @@ def method(): foo = ('This is a really long string: {}, {}, {}, {}' .format(a, b, c, d)) """), # noqa - SPLIT_BEFORE_EXPRESSION_AFTER_OPENING_PAREN=textwrap.dedent("""\ + SPLIT_BEFORE_EXPRESSION_AFTER_OPENING_PAREN =textwrap.dedent( + """\ Split after the opening paren which surrounds an expression if it doesn't fit on a single line. """), - SPLIT_BEFORE_FIRST_ARGUMENT=textwrap.dedent("""\ + SPLIT_BEFORE_FIRST_ARGUMENT =textwrap.dedent( + """\ If an argument / parameter list is going to be split, then split before the first argument."""), - SPLIT_BEFORE_LOGICAL_OPERATOR=textwrap.dedent("""\ + SPLIT_BEFORE_LOGICAL_OPERATOR =textwrap.dedent( + """\ Set to True to prefer splitting before 'and' or 'or' rather than after."""), - SPLIT_BEFORE_NAMED_ASSIGNS=textwrap.dedent("""\ + SPLIT_BEFORE_NAMED_ASSIGNS =textwrap.dedent( + """\ Split named assignments onto individual lines."""), - SPLIT_COMPLEX_COMPREHENSION=textwrap.dedent("""\ + SPLIT_COMPLEX_COMPREHENSION =textwrap.dedent( + """\ Set to True to split list comprehensions and generators that have non-trivial expressions and multiple clauses before each of these clauses. For example: @@ -390,27 +443,36 @@ def method(): for a_long_var in xrange(1000) if a_long_var % 10] """), - SPLIT_PENALTY_AFTER_OPENING_BRACKET=textwrap.dedent("""\ + SPLIT_PENALTY_AFTER_OPENING_BRACKET =textwrap.dedent( + """\ The penalty for splitting right after the opening bracket."""), - SPLIT_PENALTY_AFTER_UNARY_OPERATOR=textwrap.dedent("""\ + SPLIT_PENALTY_AFTER_UNARY_OPERATOR =textwrap.dedent( + """\ The penalty for splitting the line after a unary operator."""), - SPLIT_PENALTY_ARITHMETIC_OPERATOR=textwrap.dedent("""\ + SPLIT_PENALTY_ARITHMETIC_OPERATOR =textwrap.dedent( + """\ The penalty of splitting the line around the '+', '-', '*', '/', '//', ``%``, and '@' operators."""), - SPLIT_PENALTY_BEFORE_IF_EXPR=textwrap.dedent("""\ + SPLIT_PENALTY_BEFORE_IF_EXPR =textwrap.dedent( + """\ The penalty for splitting right before an if expression."""), - SPLIT_PENALTY_BITWISE_OPERATOR=textwrap.dedent("""\ + SPLIT_PENALTY_BITWISE_OPERATOR =textwrap.dedent( + """\ The penalty of splitting the line around the '&', '|', and '^' operators."""), - SPLIT_PENALTY_COMPREHENSION=textwrap.dedent("""\ + SPLIT_PENALTY_COMPREHENSION =textwrap.dedent( + """\ The penalty for splitting a list comprehension or generator expression."""), - SPLIT_PENALTY_EXCESS_CHARACTER=textwrap.dedent("""\ + SPLIT_PENALTY_EXCESS_CHARACTER =textwrap.dedent( + """\ The penalty for characters over the column limit."""), - SPLIT_PENALTY_FOR_ADDED_LINE_SPLIT=textwrap.dedent("""\ + SPLIT_PENALTY_FOR_ADDED_LINE_SPLIT =textwrap.dedent( + """\ The penalty incurred by adding a line split to the logical line. The more line splits added the higher the penalty."""), - SPLIT_PENALTY_IMPORT_NAMES=textwrap.dedent("""\ + SPLIT_PENALTY_IMPORT_NAMES =textwrap.dedent( + """\ The penalty of splitting a list of "import as" names. For example: from a_very_long_or_indented_module_name_yada_yad import (long_argument_1, @@ -422,10 +484,12 @@ def method(): from a_very_long_or_indented_module_name_yada_yad import ( long_argument_1, long_argument_2, long_argument_3) """), # noqa - SPLIT_PENALTY_LOGICAL_OPERATOR=textwrap.dedent("""\ + SPLIT_PENALTY_LOGICAL_OPERATOR =textwrap.dedent( + """\ The penalty of splitting the line around the 'and' and 'or' operators."""), - USE_TABS=textwrap.dedent("""\ + USE_TABS =textwrap.dedent( + """\ Use the Tab character for indentation."""), # BASED_ON_STYLE='Which predefined style this style is based on', ) @@ -434,128 +498,128 @@ def method(): def CreatePEP8Style(): """Create the PEP8 formatting style.""" return dict( - ALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENT=True, - ALIGN_ASSIGNMENT=False, - ALIGN_ARGUMENT_ASSIGNMENT=False, - ALIGN_DICT_COLON=False, - NEW_ALIGNMENT_AFTER_COMMENTLINE=False, - ALLOW_MULTILINE_LAMBDAS=False, - ALLOW_MULTILINE_DICTIONARY_KEYS=False, - ALLOW_SPLIT_BEFORE_DEFAULT_OR_NAMED_ASSIGNS=True, - ALLOW_SPLIT_BEFORE_DICT_VALUE=True, - ARITHMETIC_PRECEDENCE_INDICATION=False, - BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF=True, - BLANK_LINE_BEFORE_CLASS_DOCSTRING=False, - BLANK_LINE_BEFORE_MODULE_DOCSTRING=False, - BLANK_LINES_AROUND_TOP_LEVEL_DEFINITION=2, - BLANK_LINES_BETWEEN_TOP_LEVEL_IMPORTS_AND_VARIABLES=1, - COALESCE_BRACKETS=False, - COLUMN_LIMIT=79, - CONTINUATION_ALIGN_STYLE='SPACE', - CONTINUATION_INDENT_WIDTH=4, - DEDENT_CLOSING_BRACKETS=False, - INDENT_CLOSING_BRACKETS=False, - DISABLE_ENDING_COMMA_HEURISTIC=False, - EACH_DICT_ENTRY_ON_SEPARATE_LINE=True, - FORCE_MULTILINE_DICT=False, - I18N_COMMENT='', - I18N_FUNCTION_CALL='', - INDENT_DICTIONARY_VALUE=False, - INDENT_WIDTH=4, - INDENT_BLANK_LINES=False, - JOIN_MULTIPLE_LINES=True, - NO_SPACES_AROUND_SELECTED_BINARY_OPERATORS=set(), - SPACE_BETWEEN_ENDING_COMMA_AND_CLOSING_BRACKET=True, - SPACE_INSIDE_BRACKETS=False, - SPACES_AROUND_POWER_OPERATOR=False, - SPACES_AROUND_DEFAULT_OR_NAMED_ASSIGN=False, - SPACES_AROUND_DICT_DELIMITERS=False, - SPACES_AROUND_LIST_DELIMITERS=False, - SPACES_AROUND_SUBSCRIPT_COLON=False, - SPACES_AROUND_TUPLE_DELIMITERS=False, - SPACES_BEFORE_COMMENT=2, - SPLIT_ARGUMENTS_WHEN_COMMA_TERMINATED=False, - SPLIT_ALL_COMMA_SEPARATED_VALUES=False, - SPLIT_ALL_TOP_LEVEL_COMMA_SEPARATED_VALUES=False, - SPLIT_BEFORE_ARITHMETIC_OPERATOR=False, - SPLIT_BEFORE_BITWISE_OPERATOR=True, - SPLIT_BEFORE_CLOSING_BRACKET=True, - SPLIT_BEFORE_DICT_SET_GENERATOR=True, - SPLIT_BEFORE_DOT=False, - SPLIT_BEFORE_EXPRESSION_AFTER_OPENING_PAREN=False, - SPLIT_BEFORE_FIRST_ARGUMENT=False, - SPLIT_BEFORE_LOGICAL_OPERATOR=True, - SPLIT_BEFORE_NAMED_ASSIGNS=True, - SPLIT_COMPLEX_COMPREHENSION=False, - SPLIT_PENALTY_AFTER_OPENING_BRACKET=300, - SPLIT_PENALTY_AFTER_UNARY_OPERATOR=10000, - SPLIT_PENALTY_ARITHMETIC_OPERATOR=300, - SPLIT_PENALTY_BEFORE_IF_EXPR=0, - SPLIT_PENALTY_BITWISE_OPERATOR=300, - SPLIT_PENALTY_COMPREHENSION=80, - SPLIT_PENALTY_EXCESS_CHARACTER=7000, - SPLIT_PENALTY_FOR_ADDED_LINE_SPLIT=30, - SPLIT_PENALTY_IMPORT_NAMES=0, - SPLIT_PENALTY_LOGICAL_OPERATOR=300, - USE_TABS=False, + ALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENT =True, + ALIGN_ASSIGNMENT =False, + ALIGN_ARGUMENT_ASSIGNMENT =False, + ALIGN_DICT_COLON =False, + NEW_ALIGNMENT_AFTER_COMMENTLINE =False, + ALLOW_MULTILINE_LAMBDAS =False, + ALLOW_MULTILINE_DICTIONARY_KEYS =False, + ALLOW_SPLIT_BEFORE_DEFAULT_OR_NAMED_ASSIGNS =True, + ALLOW_SPLIT_BEFORE_DICT_VALUE =True, + ARITHMETIC_PRECEDENCE_INDICATION =False, + BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF =True, + BLANK_LINE_BEFORE_CLASS_DOCSTRING =False, + BLANK_LINE_BEFORE_MODULE_DOCSTRING =False, + BLANK_LINES_AROUND_TOP_LEVEL_DEFINITION =2, + BLANK_LINES_BETWEEN_TOP_LEVEL_IMPORTS_AND_VARIABLES =1, + COALESCE_BRACKETS =False, + COLUMN_LIMIT =79, + CONTINUATION_ALIGN_STYLE ='SPACE', + CONTINUATION_INDENT_WIDTH =4, + DEDENT_CLOSING_BRACKETS =False, + INDENT_CLOSING_BRACKETS =False, + DISABLE_ENDING_COMMA_HEURISTIC =False, + EACH_DICT_ENTRY_ON_SEPARATE_LINE =True, + FORCE_MULTILINE_DICT =False, + I18N_COMMENT ='', + I18N_FUNCTION_CALL ='', + INDENT_DICTIONARY_VALUE =False, + INDENT_WIDTH =4, + INDENT_BLANK_LINES =False, + JOIN_MULTIPLE_LINES =True, + NO_SPACES_AROUND_SELECTED_BINARY_OPERATORS =set(), + SPACE_BETWEEN_ENDING_COMMA_AND_CLOSING_BRACKET =True, + SPACE_INSIDE_BRACKETS =False, + SPACES_AROUND_POWER_OPERATOR =False, + SPACES_AROUND_DEFAULT_OR_NAMED_ASSIGN =False, + SPACES_AROUND_DICT_DELIMITERS =False, + SPACES_AROUND_LIST_DELIMITERS =False, + SPACES_AROUND_SUBSCRIPT_COLON =False, + SPACES_AROUND_TUPLE_DELIMITERS =False, + SPACES_BEFORE_COMMENT =2, + SPLIT_ARGUMENTS_WHEN_COMMA_TERMINATED =False, + SPLIT_ALL_COMMA_SEPARATED_VALUES =False, + SPLIT_ALL_TOP_LEVEL_COMMA_SEPARATED_VALUES =False, + SPLIT_BEFORE_ARITHMETIC_OPERATOR =False, + SPLIT_BEFORE_BITWISE_OPERATOR =True, + SPLIT_BEFORE_CLOSING_BRACKET =True, + SPLIT_BEFORE_DICT_SET_GENERATOR =True, + SPLIT_BEFORE_DOT =False, + SPLIT_BEFORE_EXPRESSION_AFTER_OPENING_PAREN =False, + SPLIT_BEFORE_FIRST_ARGUMENT =False, + SPLIT_BEFORE_LOGICAL_OPERATOR =True, + SPLIT_BEFORE_NAMED_ASSIGNS =True, + SPLIT_COMPLEX_COMPREHENSION =False, + SPLIT_PENALTY_AFTER_OPENING_BRACKET =300, + SPLIT_PENALTY_AFTER_UNARY_OPERATOR =10000, + SPLIT_PENALTY_ARITHMETIC_OPERATOR =300, + SPLIT_PENALTY_BEFORE_IF_EXPR =0, + SPLIT_PENALTY_BITWISE_OPERATOR =300, + SPLIT_PENALTY_COMPREHENSION =80, + SPLIT_PENALTY_EXCESS_CHARACTER =7000, + SPLIT_PENALTY_FOR_ADDED_LINE_SPLIT =30, + SPLIT_PENALTY_IMPORT_NAMES =0, + SPLIT_PENALTY_LOGICAL_OPERATOR =300, + USE_TABS =False, ) def CreateGoogleStyle(): """Create the Google formatting style.""" - style = CreatePEP8Style() - style['ALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENT'] = False - style['COLUMN_LIMIT'] = 80 - style['INDENT_DICTIONARY_VALUE'] = True - style['INDENT_WIDTH'] = 4 - style['I18N_COMMENT'] = r'#\..*' - style['I18N_FUNCTION_CALL'] = ['N_', '_'] - style['JOIN_MULTIPLE_LINES'] = False + style = CreatePEP8Style() + style['ALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENT'] = False + style['COLUMN_LIMIT'] = 80 + style['INDENT_DICTIONARY_VALUE'] = True + style['INDENT_WIDTH'] = 4 + style['I18N_COMMENT'] = r'#\..*' + style['I18N_FUNCTION_CALL'] = ['N_', '_'] + style['JOIN_MULTIPLE_LINES'] = False style['SPACE_BETWEEN_ENDING_COMMA_AND_CLOSING_BRACKET'] = False - style['SPLIT_BEFORE_BITWISE_OPERATOR'] = False - style['SPLIT_BEFORE_DICT_SET_GENERATOR'] = False - style['SPLIT_BEFORE_LOGICAL_OPERATOR'] = False - style['SPLIT_COMPLEX_COMPREHENSION'] = True - style['SPLIT_PENALTY_COMPREHENSION'] = 2100 + style['SPLIT_BEFORE_BITWISE_OPERATOR'] = False + style['SPLIT_BEFORE_DICT_SET_GENERATOR'] = False + style['SPLIT_BEFORE_LOGICAL_OPERATOR'] = False + style['SPLIT_COMPLEX_COMPREHENSION'] = True + style['SPLIT_PENALTY_COMPREHENSION'] = 2100 return style def CreateYapfStyle(): """Create the YAPF formatting style.""" - style = CreateGoogleStyle() - style['ALLOW_MULTILINE_DICTIONARY_KEYS'] = True + style = CreateGoogleStyle() + style['ALLOW_MULTILINE_DICTIONARY_KEYS'] = True style['ALLOW_SPLIT_BEFORE_DEFAULT_OR_NAMED_ASSIGNS'] = False - style['INDENT_WIDTH'] = 2 - style['SPLIT_BEFORE_BITWISE_OPERATOR'] = True - style['SPLIT_BEFORE_DOT'] = True + style['INDENT_WIDTH'] = 2 + style['SPLIT_BEFORE_BITWISE_OPERATOR'] = True + style['SPLIT_BEFORE_DOT'] = True style['SPLIT_BEFORE_EXPRESSION_AFTER_OPENING_PAREN'] = True return style def CreateFacebookStyle(): """Create the Facebook formatting style.""" - style = CreatePEP8Style() + style = CreatePEP8Style() style['ALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENT'] = False - style['BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF'] = False - style['COLUMN_LIMIT'] = 80 - style['DEDENT_CLOSING_BRACKETS'] = True - style['INDENT_CLOSING_BRACKETS'] = False - style['INDENT_DICTIONARY_VALUE'] = True - style['JOIN_MULTIPLE_LINES'] = False - style['SPACES_BEFORE_COMMENT'] = 2 - style['SPLIT_PENALTY_AFTER_OPENING_BRACKET'] = 0 - style['SPLIT_PENALTY_BEFORE_IF_EXPR'] = 30 - style['SPLIT_PENALTY_FOR_ADDED_LINE_SPLIT'] = 30 - style['SPLIT_BEFORE_LOGICAL_OPERATOR'] = False - style['SPLIT_BEFORE_BITWISE_OPERATOR'] = False + style['BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF'] = False + style['COLUMN_LIMIT'] = 80 + style['DEDENT_CLOSING_BRACKETS'] = True + style['INDENT_CLOSING_BRACKETS'] = False + style['INDENT_DICTIONARY_VALUE'] = True + style['JOIN_MULTIPLE_LINES'] = False + style['SPACES_BEFORE_COMMENT'] = 2 + style['SPLIT_PENALTY_AFTER_OPENING_BRACKET'] = 0 + style['SPLIT_PENALTY_BEFORE_IF_EXPR'] = 30 + style['SPLIT_PENALTY_FOR_ADDED_LINE_SPLIT'] = 30 + style['SPLIT_BEFORE_LOGICAL_OPERATOR'] = False + style['SPLIT_BEFORE_BITWISE_OPERATOR'] = False return style _STYLE_NAME_TO_FACTORY = dict( - pep8=CreatePEP8Style, - google=CreateGoogleStyle, - facebook=CreateFacebookStyle, - yapf=CreateYapfStyle, + pep8 =CreatePEP8Style, + google =CreateGoogleStyle, + facebook =CreateFacebookStyle, + yapf =CreateYapfStyle, ) _DEFAULT_STYLE_TO_FACTORY = [ @@ -626,70 +690,70 @@ def _IntOrIntListConverter(s): # # Note: this dict has to map all the supported style options. _STYLE_OPTION_VALUE_CONVERTER = dict( - ALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENT=_BoolConverter, - ALIGN_ASSIGNMENT=_BoolConverter, - ALIGN_DICT_COLON=_BoolConverter, - NEW_ALIGNMENT_AFTER_COMMENTLINE=_BoolConverter, - ALIGN_ARGUMENT_ASSIGNMENT=_BoolConverter, - ALLOW_MULTILINE_LAMBDAS=_BoolConverter, - ALLOW_MULTILINE_DICTIONARY_KEYS=_BoolConverter, - ALLOW_SPLIT_BEFORE_DEFAULT_OR_NAMED_ASSIGNS=_BoolConverter, - ALLOW_SPLIT_BEFORE_DICT_VALUE=_BoolConverter, - ARITHMETIC_PRECEDENCE_INDICATION=_BoolConverter, - BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF=_BoolConverter, - BLANK_LINE_BEFORE_CLASS_DOCSTRING=_BoolConverter, - BLANK_LINE_BEFORE_MODULE_DOCSTRING=_BoolConverter, - BLANK_LINES_AROUND_TOP_LEVEL_DEFINITION=int, - BLANK_LINES_BETWEEN_TOP_LEVEL_IMPORTS_AND_VARIABLES=int, - COALESCE_BRACKETS=_BoolConverter, - COLUMN_LIMIT=int, - CONTINUATION_ALIGN_STYLE=_ContinuationAlignStyleStringConverter, - CONTINUATION_INDENT_WIDTH=int, - DEDENT_CLOSING_BRACKETS=_BoolConverter, - INDENT_CLOSING_BRACKETS=_BoolConverter, - DISABLE_ENDING_COMMA_HEURISTIC=_BoolConverter, - EACH_DICT_ENTRY_ON_SEPARATE_LINE=_BoolConverter, - FORCE_MULTILINE_DICT=_BoolConverter, - I18N_COMMENT=str, - I18N_FUNCTION_CALL=_StringListConverter, - INDENT_DICTIONARY_VALUE=_BoolConverter, - INDENT_WIDTH=int, - INDENT_BLANK_LINES=_BoolConverter, - JOIN_MULTIPLE_LINES=_BoolConverter, - NO_SPACES_AROUND_SELECTED_BINARY_OPERATORS=_StringSetConverter, - SPACE_BETWEEN_ENDING_COMMA_AND_CLOSING_BRACKET=_BoolConverter, - SPACE_INSIDE_BRACKETS=_BoolConverter, - SPACES_AROUND_POWER_OPERATOR=_BoolConverter, - SPACES_AROUND_DEFAULT_OR_NAMED_ASSIGN=_BoolConverter, - SPACES_AROUND_DICT_DELIMITERS=_BoolConverter, - SPACES_AROUND_LIST_DELIMITERS=_BoolConverter, - SPACES_AROUND_SUBSCRIPT_COLON=_BoolConverter, - SPACES_AROUND_TUPLE_DELIMITERS=_BoolConverter, - SPACES_BEFORE_COMMENT=_IntOrIntListConverter, - SPLIT_ARGUMENTS_WHEN_COMMA_TERMINATED=_BoolConverter, - SPLIT_ALL_COMMA_SEPARATED_VALUES=_BoolConverter, - SPLIT_ALL_TOP_LEVEL_COMMA_SEPARATED_VALUES=_BoolConverter, - SPLIT_BEFORE_ARITHMETIC_OPERATOR=_BoolConverter, - SPLIT_BEFORE_BITWISE_OPERATOR=_BoolConverter, - SPLIT_BEFORE_CLOSING_BRACKET=_BoolConverter, - SPLIT_BEFORE_DICT_SET_GENERATOR=_BoolConverter, - SPLIT_BEFORE_DOT=_BoolConverter, - SPLIT_BEFORE_EXPRESSION_AFTER_OPENING_PAREN=_BoolConverter, - SPLIT_BEFORE_FIRST_ARGUMENT=_BoolConverter, - SPLIT_BEFORE_LOGICAL_OPERATOR=_BoolConverter, - SPLIT_BEFORE_NAMED_ASSIGNS=_BoolConverter, - SPLIT_COMPLEX_COMPREHENSION=_BoolConverter, - SPLIT_PENALTY_AFTER_OPENING_BRACKET=int, - SPLIT_PENALTY_AFTER_UNARY_OPERATOR=int, - SPLIT_PENALTY_ARITHMETIC_OPERATOR=int, - SPLIT_PENALTY_BEFORE_IF_EXPR=int, - SPLIT_PENALTY_BITWISE_OPERATOR=int, - SPLIT_PENALTY_COMPREHENSION=int, - SPLIT_PENALTY_EXCESS_CHARACTER=int, - SPLIT_PENALTY_FOR_ADDED_LINE_SPLIT=int, - SPLIT_PENALTY_IMPORT_NAMES=int, - SPLIT_PENALTY_LOGICAL_OPERATOR=int, - USE_TABS=_BoolConverter, + ALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENT =_BoolConverter, + ALIGN_ASSIGNMENT =_BoolConverter, + ALIGN_DICT_COLON =_BoolConverter, + NEW_ALIGNMENT_AFTER_COMMENTLINE =_BoolConverter, + ALIGN_ARGUMENT_ASSIGNMENT =_BoolConverter, + ALLOW_MULTILINE_LAMBDAS =_BoolConverter, + ALLOW_MULTILINE_DICTIONARY_KEYS =_BoolConverter, + ALLOW_SPLIT_BEFORE_DEFAULT_OR_NAMED_ASSIGNS =_BoolConverter, + ALLOW_SPLIT_BEFORE_DICT_VALUE =_BoolConverter, + ARITHMETIC_PRECEDENCE_INDICATION =_BoolConverter, + BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF =_BoolConverter, + BLANK_LINE_BEFORE_CLASS_DOCSTRING =_BoolConverter, + BLANK_LINE_BEFORE_MODULE_DOCSTRING =_BoolConverter, + BLANK_LINES_AROUND_TOP_LEVEL_DEFINITION =int, + BLANK_LINES_BETWEEN_TOP_LEVEL_IMPORTS_AND_VARIABLES =int, + COALESCE_BRACKETS =_BoolConverter, + COLUMN_LIMIT =int, + CONTINUATION_ALIGN_STYLE =_ContinuationAlignStyleStringConverter, + CONTINUATION_INDENT_WIDTH =int, + DEDENT_CLOSING_BRACKETS =_BoolConverter, + INDENT_CLOSING_BRACKETS =_BoolConverter, + DISABLE_ENDING_COMMA_HEURISTIC =_BoolConverter, + EACH_DICT_ENTRY_ON_SEPARATE_LINE =_BoolConverter, + FORCE_MULTILINE_DICT =_BoolConverter, + I18N_COMMENT =str, + I18N_FUNCTION_CALL =_StringListConverter, + INDENT_DICTIONARY_VALUE =_BoolConverter, + INDENT_WIDTH =int, + INDENT_BLANK_LINES =_BoolConverter, + JOIN_MULTIPLE_LINES =_BoolConverter, + NO_SPACES_AROUND_SELECTED_BINARY_OPERATORS =_StringSetConverter, + SPACE_BETWEEN_ENDING_COMMA_AND_CLOSING_BRACKET =_BoolConverter, + SPACE_INSIDE_BRACKETS =_BoolConverter, + SPACES_AROUND_POWER_OPERATOR =_BoolConverter, + SPACES_AROUND_DEFAULT_OR_NAMED_ASSIGN =_BoolConverter, + SPACES_AROUND_DICT_DELIMITERS =_BoolConverter, + SPACES_AROUND_LIST_DELIMITERS =_BoolConverter, + SPACES_AROUND_SUBSCRIPT_COLON =_BoolConverter, + SPACES_AROUND_TUPLE_DELIMITERS =_BoolConverter, + SPACES_BEFORE_COMMENT =_IntOrIntListConverter, + SPLIT_ARGUMENTS_WHEN_COMMA_TERMINATED =_BoolConverter, + SPLIT_ALL_COMMA_SEPARATED_VALUES =_BoolConverter, + SPLIT_ALL_TOP_LEVEL_COMMA_SEPARATED_VALUES =_BoolConverter, + SPLIT_BEFORE_ARITHMETIC_OPERATOR =_BoolConverter, + SPLIT_BEFORE_BITWISE_OPERATOR =_BoolConverter, + SPLIT_BEFORE_CLOSING_BRACKET =_BoolConverter, + SPLIT_BEFORE_DICT_SET_GENERATOR =_BoolConverter, + SPLIT_BEFORE_DOT =_BoolConverter, + SPLIT_BEFORE_EXPRESSION_AFTER_OPENING_PAREN =_BoolConverter, + SPLIT_BEFORE_FIRST_ARGUMENT =_BoolConverter, + SPLIT_BEFORE_LOGICAL_OPERATOR =_BoolConverter, + SPLIT_BEFORE_NAMED_ASSIGNS =_BoolConverter, + SPLIT_COMPLEX_COMPREHENSION =_BoolConverter, + SPLIT_PENALTY_AFTER_OPENING_BRACKET =int, + SPLIT_PENALTY_AFTER_UNARY_OPERATOR =int, + SPLIT_PENALTY_ARITHMETIC_OPERATOR =int, + SPLIT_PENALTY_BEFORE_IF_EXPR =int, + SPLIT_PENALTY_BITWISE_OPERATOR =int, + SPLIT_PENALTY_COMPREHENSION =int, + SPLIT_PENALTY_EXCESS_CHARACTER =int, + SPLIT_PENALTY_FOR_ADDED_LINE_SPLIT =int, + SPLIT_PENALTY_IMPORT_NAMES =int, + SPLIT_PENALTY_LOGICAL_OPERATOR =int, + USE_TABS =_BoolConverter, ) @@ -781,7 +845,7 @@ def _CreateConfigParserFromConfigFile(config_filename): "configuration file") pyproject_toml = toml.load(style_file) - style_dict = pyproject_toml.get("tool", {}).get("yapf", None) + style_dict = pyproject_toml.get("tool", {}).get("yapf", None) if style_dict is None: raise StyleConfigError( 'Unable to find section [tool.yapf] in {0}'.format(config_filename)) @@ -824,10 +888,10 @@ def _CreateStyleFromConfigParser(config): # Initialize the base style. section = 'yapf' if config.has_section('yapf') else 'style' if config.has_option('style', 'based_on_style'): - based_on = config.get('style', 'based_on_style').lower() + based_on = config.get('style', 'based_on_style').lower() base_style = _STYLE_NAME_TO_FACTORY[based_on]() elif config.has_option('yapf', 'based_on_style'): - based_on = config.get('yapf', 'based_on_style').lower() + based_on = config.get('yapf', 'based_on_style').lower() base_style = _STYLE_NAME_TO_FACTORY[based_on]() else: base_style = _GLOBAL_STYLE_FACTORY() @@ -844,14 +908,14 @@ def _CreateStyleFromConfigParser(config): try: base_style[option] = _STYLE_OPTION_VALUE_CONVERTER[option](value) except ValueError: - raise StyleConfigError("'{}' is not a valid setting for {}.".format( - value, option)) + raise StyleConfigError( + "'{}' is not a valid setting for {}.".format(value, option)) return base_style # The default style - used if yapf is not invoked without specifically # requesting a formatting style. -DEFAULT_STYLE = 'pep8' +DEFAULT_STYLE = 'pep8' DEFAULT_STYLE_FACTORY = CreatePEP8Style _GLOBAL_STYLE_FACTORY = CreatePEP8Style diff --git a/yapf/yapflib/subtypes.py b/yapf/yapflib/subtypes.py index b4b7efe75..e675c41c1 100644 --- a/yapf/yapflib/subtypes.py +++ b/yapf/yapflib/subtypes.py @@ -13,28 +13,28 @@ # limitations under the License. """Token subtypes used to improve formatting.""" -NONE = 0 -UNARY_OPERATOR = 1 -BINARY_OPERATOR = 2 -SUBSCRIPT_COLON = 3 -SUBSCRIPT_BRACKET = 4 -DEFAULT_OR_NAMED_ASSIGN = 5 +NONE = 0 +UNARY_OPERATOR = 1 +BINARY_OPERATOR = 2 +SUBSCRIPT_COLON = 3 +SUBSCRIPT_BRACKET = 4 +DEFAULT_OR_NAMED_ASSIGN = 5 DEFAULT_OR_NAMED_ASSIGN_ARG_LIST = 6 -VARARGS_LIST = 7 -VARARGS_STAR = 8 -KWARGS_STAR_STAR = 9 -ASSIGN_OPERATOR = 10 -DICTIONARY_KEY = 11 -DICTIONARY_KEY_PART = 12 -DICTIONARY_VALUE = 13 -DICT_SET_GENERATOR = 14 -COMP_EXPR = 15 -COMP_FOR = 16 -COMP_IF = 17 -FUNC_DEF = 18 -DECORATOR = 19 -TYPED_NAME = 20 -TYPED_NAME_ARG_LIST = 21 -SIMPLE_EXPRESSION = 22 -PARAMETER_START = 23 -PARAMETER_STOP = 24 +VARARGS_LIST = 7 +VARARGS_STAR = 8 +KWARGS_STAR_STAR = 9 +ASSIGN_OPERATOR = 10 +DICTIONARY_KEY = 11 +DICTIONARY_KEY_PART = 12 +DICTIONARY_VALUE = 13 +DICT_SET_GENERATOR = 14 +COMP_EXPR = 15 +COMP_FOR = 16 +COMP_IF = 17 +FUNC_DEF = 18 +DECORATOR = 19 +TYPED_NAME = 20 +TYPED_NAME_ARG_LIST = 21 +SIMPLE_EXPRESSION = 22 +PARAMETER_START = 23 +PARAMETER_STOP = 24 diff --git a/yapf/yapflib/verifier.py b/yapf/yapflib/verifier.py index bcbe6fb6b..01dccc0b0 100644 --- a/yapf/yapflib/verifier.py +++ b/yapf/yapflib/verifier.py @@ -59,7 +59,7 @@ def _NormalizeCode(code): # Split the code to lines and get rid of all leading full-comment lines as # they can mess up the normalization attempt. lines = code.split('\n') - i = 0 + i = 0 for i, line in enumerate(lines): line = line.strip() if line and not line.startswith('#'): diff --git a/yapf/yapflib/yapf_api.py b/yapf/yapflib/yapf_api.py index c17451434..dd75e9fe6 100644 --- a/yapf/yapflib/yapf_api.py +++ b/yapf/yapflib/yapf_api.py @@ -51,13 +51,14 @@ from yapf.yapflib import style -def FormatFile(filename, - style_config=None, - lines=None, - print_diff=False, - verify=False, - in_place=False, - logger=None): +def FormatFile( + filename, + style_config =None, + lines =None, + print_diff =False, + verify =False, + in_place =False, + logger =None): """Format a single Python file and return the formatted code. Arguments: @@ -90,20 +91,20 @@ def FormatFile(filename, raise ValueError('Cannot pass both in_place and print_diff.') original_source, newline, encoding = ReadFile(filename, logger) - reformatted_source, changed = FormatCode( + reformatted_source, changed = FormatCode( original_source, - style_config=style_config, - filename=filename, - lines=lines, - print_diff=print_diff, - verify=verify) + style_config =style_config, + filename =filename, + lines =lines, + print_diff =print_diff, + verify =verify) if reformatted_source.rstrip('\n'): - lines = reformatted_source.rstrip('\n').split('\n') + lines = reformatted_source.rstrip('\n').split('\n') reformatted_source = newline.join(iter(lines)) + newline if in_place: if original_source and original_source != reformatted_source: - file_resources.WriteReformattedCode(filename, reformatted_source, - encoding, in_place) + file_resources.WriteReformattedCode( + filename, reformatted_source, encoding, in_place) return None, encoding, changed return reformatted_source, encoding, changed @@ -148,12 +149,13 @@ def FormatTree(tree, style_config=None, lines=None, verify=False): return reformatter.Reformat(_SplitSemicolons(llines), verify, lines) -def FormatCode(unformatted_source, - filename='', - style_config=None, - lines=None, - print_diff=False, - verify=False): +def FormatCode( + unformatted_source, + filename ='', + style_config =None, + lines =None, + print_diff =False, + verify =False): """Format a string of Python code. This provides an alternative entry point to YAPF. @@ -228,12 +230,12 @@ def ReadFile(filename, logger=None): encoding = file_resources.FileEncoding(filename) # Preserves line endings. - with py3compat.open_with_encoding( - filename, mode='r', encoding=encoding, newline='') as fd: + with py3compat.open_with_encoding(filename, mode='r', encoding=encoding, + newline='') as fd: lines = fd.readlines() line_ending = file_resources.LineEnding(lines) - source = '\n'.join(line.rstrip('\r\n') for line in lines) + '\n' + source = '\n'.join(line.rstrip('\r\n') for line in lines) + '\n' return source, line_ending, encoding except IOError as e: # pragma: no cover if logger: @@ -242,8 +244,9 @@ def ReadFile(filename, logger=None): raise except UnicodeDecodeError as e: # pragma: no cover if logger: - logger('Could not parse %s! Consider excluding this file with --exclude.', - filename) + logger( + 'Could not parse %s! Consider excluding this file with --exclude.', + filename) logger(e) e.args = (e.args[0], (filename, e.args[1][1], e.args[1][2], e.args[1][3])) raise @@ -257,7 +260,7 @@ def _SplitSemicolons(lines): DISABLE_PATTERN = r'^#.*\byapf:\s*disable\b' -ENABLE_PATTERN = r'^#.*\byapf:\s*enable\b' +ENABLE_PATTERN = r'^#.*\byapf:\s*enable\b' def _LineRangesToSet(line_ranges): @@ -290,29 +293,31 @@ def _MarkLinesToFormat(llines, lines): index += 1 while index < len(llines): uwline = llines[index] - line = uwline.first.value.strip() + line = uwline.first.value.strip() if uwline.is_comment and _EnableYAPF(line): if not _DisableYAPF(line): break uwline.disable = True - index += 1 + index += 1 elif re.search(DISABLE_PATTERN, uwline.last.value.strip(), re.IGNORECASE): uwline.disable = True index += 1 def _DisableYAPF(line): - return (re.search(DISABLE_PATTERN, - line.split('\n')[0].strip(), re.IGNORECASE) or - re.search(DISABLE_PATTERN, - line.split('\n')[-1].strip(), re.IGNORECASE)) + return ( + re.search(DISABLE_PATTERN, + line.split('\n')[0].strip(), re.IGNORECASE) or + re.search(DISABLE_PATTERN, + line.split('\n')[-1].strip(), re.IGNORECASE)) def _EnableYAPF(line): - return (re.search(ENABLE_PATTERN, - line.split('\n')[0].strip(), re.IGNORECASE) or - re.search(ENABLE_PATTERN, - line.split('\n')[-1].strip(), re.IGNORECASE)) + return ( + re.search(ENABLE_PATTERN, + line.split('\n')[0].strip(), re.IGNORECASE) or + re.search(ENABLE_PATTERN, + line.split('\n')[-1].strip(), re.IGNORECASE)) def _GetUnifiedDiff(before, after, filename='code'): @@ -327,7 +332,7 @@ def _GetUnifiedDiff(before, after, filename='code'): The unified diff text. """ before = before.splitlines() - after = after.splitlines() + after = after.splitlines() return '\n'.join( difflib.unified_diff( before, diff --git a/yapftests/blank_line_calculator_test.py b/yapftests/blank_line_calculator_test.py index 18fa83e0b..d5d97d794 100644 --- a/yapftests/blank_line_calculator_test.py +++ b/yapftests/blank_line_calculator_test.py @@ -30,13 +30,15 @@ def setUpClass(cls): style.SetGlobalStyle(style.CreateYapfStyle()) def testDecorators(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ @bork() def foo(): pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ @bork() def foo(): pass @@ -45,7 +47,8 @@ def foo(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testComplexDecorators(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ import sys @bork() @@ -60,7 +63,8 @@ class moo(object): def method(self): pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ import sys @@ -81,7 +85,8 @@ def method(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testCodeAfterFunctionsAndClasses(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def foo(): pass top_level_code = True @@ -97,7 +102,8 @@ def method_2(self): except Error as error: pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def foo(): pass @@ -126,7 +132,8 @@ def method_2(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testCommentSpacing(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ # This is the first comment # And it's multiline @@ -155,7 +162,8 @@ def foo(self): # comment pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ # This is the first comment # And it's multiline @@ -192,7 +200,8 @@ def foo(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testCommentBeforeMethod(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ class foo(object): # pylint: disable=invalid-name @@ -203,7 +212,8 @@ def f(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testCommentsBeforeClassDefs(self): - code = textwrap.dedent('''\ + code = textwrap.dedent( + '''\ """Test.""" # Comment @@ -216,7 +226,8 @@ class Foo(object): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testCommentsBeforeDecorator(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ # The @foo operator adds bork to a(). @foo() def a(): @@ -225,7 +236,8 @@ def a(): llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ # Hello world @@ -237,7 +249,8 @@ def a(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testCommentsAfterDecorator(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ class _(): def _(): @@ -254,7 +267,8 @@ def test_unicode_filename_in_sdist(self, sdist_unicode, tmpdir, monkeypatch): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testInnerClasses(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ class DeployAPIClient(object): class Error(Exception): pass @@ -262,7 +276,8 @@ class TaskValidationError(Error): pass class DeployAPIHTTPError(Error): pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ class DeployAPIClient(object): class Error(Exception): @@ -278,7 +293,8 @@ class DeployAPIHTTPError(Error): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testLinesOnRangeBoundary(self): - unformatted_code = textwrap.dedent(u"""\ + unformatted_code = textwrap.dedent( + u"""\ def A(): pass @@ -292,7 +308,8 @@ def D(): # 9 def E(): pass """) - expected_formatted_code = textwrap.dedent(u"""\ + expected_formatted_code = textwrap.dedent( + u"""\ def A(): pass @@ -315,7 +332,8 @@ def E(): self.assertTrue(changed) def testLinesRangeBoundaryNotOutside(self): - unformatted_code = textwrap.dedent(u"""\ + unformatted_code = textwrap.dedent( + u"""\ def A(): pass @@ -329,7 +347,8 @@ def B(): # 6 def C(): pass """) - expected_formatted_code = textwrap.dedent(u"""\ + expected_formatted_code = textwrap.dedent( + u"""\ def A(): pass @@ -348,7 +367,8 @@ def C(): self.assertFalse(changed) def testLinesRangeRemove(self): - unformatted_code = textwrap.dedent(u"""\ + unformatted_code = textwrap.dedent( + u"""\ def A(): pass @@ -363,7 +383,8 @@ def B(): # 6 def C(): pass """) - expected_formatted_code = textwrap.dedent(u"""\ + expected_formatted_code = textwrap.dedent( + u"""\ def A(): pass @@ -382,7 +403,8 @@ def C(): self.assertTrue(changed) def testLinesRangeRemoveSome(self): - unformatted_code = textwrap.dedent(u"""\ + unformatted_code = textwrap.dedent( + u"""\ def A(): pass @@ -398,7 +420,8 @@ def B(): # 7 def C(): pass """) - expected_formatted_code = textwrap.dedent(u"""\ + expected_formatted_code = textwrap.dedent( + u"""\ def A(): pass diff --git a/yapftests/comment_splicer_test.py b/yapftests/comment_splicer_test.py index 2e0141bd4..985ea88b7 100644 --- a/yapftests/comment_splicer_test.py +++ b/yapftests/comment_splicer_test.py @@ -38,9 +38,8 @@ def _AssertNodeIsComment(self, node, text_in_comment=None): self.assertIn(text_in_comment, node_value) def _FindNthChildNamed(self, node, name, n=1): - for i, child in enumerate( - py3compat.ifilter(lambda c: pytree_utils.NodeName(c) == name, - node.pre_order())): + for i, child in enumerate(py3compat.ifilter( + lambda c: pytree_utils.NodeName(c) == name, node.pre_order())): if i == n - 1: return child raise RuntimeError('No Nth child for n={0}'.format(n)) @@ -59,7 +58,8 @@ def testSimpleInline(self): self._AssertNodeIsComment(comment_node, '# and a comment') def testSimpleSeparateLine(self): - code = textwrap.dedent(r''' + code = textwrap.dedent( + r''' foo = 1 # first comment bar = 2 @@ -74,7 +74,8 @@ def testSimpleSeparateLine(self): self._AssertNodeIsComment(comment_node) def testTwoLineComment(self): - code = textwrap.dedent(r''' + code = textwrap.dedent( + r''' foo = 1 # first comment # second comment @@ -88,7 +89,8 @@ def testTwoLineComment(self): self._AssertNodeIsComment(tree.children[1]) def testCommentIsFirstChildInCompound(self): - code = textwrap.dedent(r''' + code = textwrap.dedent( + r''' if x: # a comment foo = 1 @@ -104,7 +106,8 @@ def testCommentIsFirstChildInCompound(self): self._AssertNodeIsComment(if_suite.children[1]) def testCommentIsLastChildInCompound(self): - code = textwrap.dedent(r''' + code = textwrap.dedent( + r''' if x: foo = 1 # a comment @@ -120,7 +123,8 @@ def testCommentIsLastChildInCompound(self): self._AssertNodeIsComment(if_suite.children[-2]) def testInlineAfterSeparateLine(self): - code = textwrap.dedent(r''' + code = textwrap.dedent( + r''' bar = 1 # line comment foo = 1 # inline comment @@ -133,12 +137,13 @@ def testInlineAfterSeparateLine(self): sep_comment_node = tree.children[1] self._AssertNodeIsComment(sep_comment_node, '# line comment') - expr = tree.children[2].children[0] + expr = tree.children[2].children[0] inline_comment_node = expr.children[-1] self._AssertNodeIsComment(inline_comment_node, '# inline comment') def testSeparateLineAfterInline(self): - code = textwrap.dedent(r''' + code = textwrap.dedent( + r''' bar = 1 foo = 1 # inline comment # line comment @@ -151,12 +156,13 @@ def testSeparateLineAfterInline(self): sep_comment_node = tree.children[-2] self._AssertNodeIsComment(sep_comment_node, '# line comment') - expr = tree.children[1].children[0] + expr = tree.children[1].children[0] inline_comment_node = expr.children[-1] self._AssertNodeIsComment(inline_comment_node, '# inline comment') def testCommentBeforeDedent(self): - code = textwrap.dedent(r''' + code = textwrap.dedent( + r''' if bar: z = 1 # a comment @@ -171,7 +177,8 @@ def testCommentBeforeDedent(self): self._AssertNodeType('DEDENT', if_suite.children[-1]) def testCommentBeforeDedentTwoLevel(self): - code = textwrap.dedent(r''' + code = textwrap.dedent( + r''' if foo: if bar: z = 1 @@ -188,7 +195,8 @@ def testCommentBeforeDedentTwoLevel(self): self._AssertNodeType('DEDENT', if_suite.children[-1]) def testCommentBeforeDedentTwoLevelImproperlyIndented(self): - code = textwrap.dedent(r''' + code = textwrap.dedent( + r''' if foo: if bar: z = 1 @@ -208,7 +216,8 @@ def testCommentBeforeDedentTwoLevelImproperlyIndented(self): self._AssertNodeType('DEDENT', if_suite.children[-1]) def testCommentBeforeDedentThreeLevel(self): - code = textwrap.dedent(r''' + code = textwrap.dedent( + r''' if foo: if bar: z = 1 @@ -235,7 +244,8 @@ def testCommentBeforeDedentThreeLevel(self): self._AssertNodeType('DEDENT', if_suite_2.children[-1]) def testCommentsInClass(self): - code = textwrap.dedent(r''' + code = textwrap.dedent( + r''' class Foo: """docstring abc...""" # top-level comment @@ -246,18 +256,19 @@ def foo(): pass tree = pytree_utils.ParseCodeToTree(code) comment_splicer.SpliceComments(tree) - class_suite = tree.children[0].children[3] + class_suite = tree.children[0].children[3] another_comment = class_suite.children[-2] self._AssertNodeIsComment(another_comment, '# another') # It's OK for the comment to be a child of funcdef, as long as it's # the first child and thus comes before the 'def'. - funcdef = class_suite.children[3] + funcdef = class_suite.children[3] toplevel_comment = funcdef.children[0] self._AssertNodeIsComment(toplevel_comment, '# top-level') def testMultipleBlockComments(self): - code = textwrap.dedent(r''' + code = textwrap.dedent( + r''' # Block comment number 1 # Block comment number 2 @@ -268,7 +279,7 @@ def f(): tree = pytree_utils.ParseCodeToTree(code) comment_splicer.SpliceComments(tree) - funcdef = tree.children[0] + funcdef = tree.children[0] block_comment_1 = funcdef.children[0] self._AssertNodeIsComment(block_comment_1, '# Block comment number 1') @@ -276,7 +287,8 @@ def f(): self._AssertNodeIsComment(block_comment_2, '# Block comment number 2') def testCommentsOnDedents(self): - code = textwrap.dedent(r''' + code = textwrap.dedent( + r''' class Foo(object): # A comment for qux. def qux(self): @@ -291,7 +303,7 @@ def mux(self): tree = pytree_utils.ParseCodeToTree(code) comment_splicer.SpliceComments(tree) - classdef = tree.children[0] + classdef = tree.children[0] class_suite = classdef.children[6] qux_comment = class_suite.children[1] self._AssertNodeIsComment(qux_comment, '# A comment for qux.') @@ -300,7 +312,8 @@ def mux(self): self._AssertNodeIsComment(interim_comment, '# Interim comment.') def testExprComments(self): - code = textwrap.dedent(r''' + code = textwrap.dedent( + r''' foo( # Request fractions of an hour. 948.0/3600, 20) ''') @@ -312,7 +325,8 @@ def testExprComments(self): self._AssertNodeIsComment(comment, '# Request fractions of an hour.') def testMultipleCommentsInOneExpr(self): - code = textwrap.dedent(r''' + code = textwrap.dedent( + r''' foo( # com 1 948.0/3600, # com 2 20 + 12 # com 3 diff --git a/yapftests/file_resources_test.py b/yapftests/file_resources_test.py index 31184c4a3..eb9a3cd3b 100644 --- a/yapftests/file_resources_test.py +++ b/yapftests/file_resources_test.py @@ -56,7 +56,7 @@ def tearDown(self): # pylint: disable=g-missing-super-call def test_get_exclude_file_patterns_from_yapfignore(self): local_ignore_file = os.path.join(self.test_tmpdir, '.yapfignore') - ignore_patterns = ['temp/**/*.py', 'temp2/*.py'] + ignore_patterns = ['temp/**/*.py', 'temp2/*.py'] with open(local_ignore_file, 'w') as f: f.writelines('\n'.join(ignore_patterns)) @@ -66,7 +66,7 @@ def test_get_exclude_file_patterns_from_yapfignore(self): def test_get_exclude_file_patterns_from_yapfignore_with_wrong_syntax(self): local_ignore_file = os.path.join(self.test_tmpdir, '.yapfignore') - ignore_patterns = ['temp/**/*.py', './wrong/syntax/*.py'] + ignore_patterns = ['temp/**/*.py', './wrong/syntax/*.py'] with open(local_ignore_file, 'w') as f: f.writelines('\n'.join(ignore_patterns)) @@ -79,7 +79,7 @@ def test_get_exclude_file_patterns_from_pyproject(self): except ImportError: return local_ignore_file = os.path.join(self.test_tmpdir, 'pyproject.toml') - ignore_patterns = ['temp/**/*.py', 'temp2/*.py'] + ignore_patterns = ['temp/**/*.py', 'temp2/*.py'] with open(local_ignore_file, 'w') as f: f.write('[tool.yapfignore]\n') f.write('ignore_patterns=[') @@ -97,7 +97,7 @@ def test_get_exclude_file_patterns_from_pyproject_with_wrong_syntax(self): except ImportError: return local_ignore_file = os.path.join(self.test_tmpdir, 'pyproject.toml') - ignore_patterns = ['temp/**/*.py', './wrong/syntax/*.py'] + ignore_patterns = ['temp/**/*.py', './wrong/syntax/*.py'] with open(local_ignore_file, 'w') as f: f.write('[tool.yapfignore]\n') f.write('ignore_patterns=[') @@ -113,7 +113,7 @@ def test_get_exclude_file_patterns_from_pyproject_no_ignore_section(self): except ImportError: return local_ignore_file = os.path.join(self.test_tmpdir, 'pyproject.toml') - ignore_patterns = [] + ignore_patterns = [] open(local_ignore_file, 'w').close() self.assertEqual( @@ -126,7 +126,7 @@ def test_get_exclude_file_patterns_from_pyproject_ignore_section_empty(self): except ImportError: return local_ignore_file = os.path.join(self.test_tmpdir, 'pyproject.toml') - ignore_patterns = [] + ignore_patterns = [] with open(local_ignore_file, 'w') as f: f.write('[tool.yapfignore]\n') @@ -151,12 +151,12 @@ def tearDown(self): # pylint: disable=g-missing-super-call shutil.rmtree(self.test_tmpdir) def test_no_local_style(self): - test_file = os.path.join(self.test_tmpdir, 'file.py') + test_file = os.path.join(self.test_tmpdir, 'file.py') style_name = file_resources.GetDefaultStyleForDir(test_file) self.assertEqual(style_name, 'pep8') def test_no_local_style_custom_default(self): - test_file = os.path.join(self.test_tmpdir, 'file.py') + test_file = os.path.join(self.test_tmpdir, 'file.py') style_name = file_resources.GetDefaultStyleForDir( test_file, default_style='custom-default') self.assertEqual(style_name, 'custom-default') @@ -167,27 +167,27 @@ def test_with_local_style(self): open(style_file, 'w').close() test_filename = os.path.join(self.test_tmpdir, 'file.py') - self.assertEqual(style_file, - file_resources.GetDefaultStyleForDir(test_filename)) + self.assertEqual( + style_file, file_resources.GetDefaultStyleForDir(test_filename)) test_filename = os.path.join(self.test_tmpdir, 'dir1', 'file.py') - self.assertEqual(style_file, - file_resources.GetDefaultStyleForDir(test_filename)) + self.assertEqual( + style_file, file_resources.GetDefaultStyleForDir(test_filename)) def test_setup_config(self): # An empty setup.cfg file should not be used setup_config = os.path.join(self.test_tmpdir, 'setup.cfg') open(setup_config, 'w').close() - test_dir = os.path.join(self.test_tmpdir, 'dir1') + test_dir = os.path.join(self.test_tmpdir, 'dir1') style_name = file_resources.GetDefaultStyleForDir(test_dir) self.assertEqual(style_name, 'pep8') # One with a '[yapf]' section should be used with open(setup_config, 'w') as f: f.write('[yapf]\n') - self.assertEqual(setup_config, - file_resources.GetDefaultStyleForDir(test_dir)) + self.assertEqual( + setup_config, file_resources.GetDefaultStyleForDir(test_dir)) def test_pyproject_toml(self): # An empty pyproject.toml file should not be used @@ -199,20 +199,20 @@ def test_pyproject_toml(self): pyproject_toml = os.path.join(self.test_tmpdir, 'pyproject.toml') open(pyproject_toml, 'w').close() - test_dir = os.path.join(self.test_tmpdir, 'dir1') + test_dir = os.path.join(self.test_tmpdir, 'dir1') style_name = file_resources.GetDefaultStyleForDir(test_dir) self.assertEqual(style_name, 'pep8') # One with a '[tool.yapf]' section should be used with open(pyproject_toml, 'w') as f: f.write('[tool.yapf]\n') - self.assertEqual(pyproject_toml, - file_resources.GetDefaultStyleForDir(test_dir)) + self.assertEqual( + pyproject_toml, file_resources.GetDefaultStyleForDir(test_dir)) def test_local_style_at_root(self): # Test behavior of files located on the root, and under root. - rootdir = os.path.abspath(os.path.sep) - test_dir_at_root = os.path.join(rootdir, 'dir1') + rootdir = os.path.abspath(os.path.sep) + test_dir_at_root = os.path.join(rootdir, 'dir1') test_dir_under_root = os.path.join(rootdir, 'dir1', 'dir2') # Fake placing only a style file at the root by mocking `os.path.exists`. @@ -241,7 +241,7 @@ class GetCommandLineFilesTest(unittest.TestCase): def setUp(self): # pylint: disable=g-missing-super-call self.test_tmpdir = tempfile.mkdtemp() - self.old_dir = os.getcwd() + self.old_dir = os.getcwd() def tearDown(self): # pylint: disable=g-missing-super-call os.chdir(self.old_dir) @@ -260,13 +260,11 @@ def test_find_files_not_dirs(self): _touch_files([file1, file2]) self.assertEqual( - file_resources.GetCommandLineFiles([file1, file2], - recursive=False, - exclude=None), [file1, file2]) + file_resources.GetCommandLineFiles( + [file1, file2], recursive=False, exclude=None), [file1, file2]) self.assertEqual( - file_resources.GetCommandLineFiles([file1, file2], - recursive=True, - exclude=None), [file1, file2]) + file_resources.GetCommandLineFiles( + [file1, file2], recursive=True, exclude=None), [file1, file2]) def test_nonrecursive_find_in_dir(self): tdir1 = self._make_test_dir('test1') @@ -278,9 +276,9 @@ def test_nonrecursive_find_in_dir(self): self.assertRaises( errors.YapfError, file_resources.GetCommandLineFiles, - command_line_file_list=[tdir1], - recursive=False, - exclude=None) + command_line_file_list =[tdir1], + recursive =False, + exclude =None) def test_recursive_find_in_dir(self): tdir1 = self._make_test_dir('test1') @@ -295,9 +293,9 @@ def test_recursive_find_in_dir(self): self.assertEqual( sorted( - file_resources.GetCommandLineFiles([self.test_tmpdir], - recursive=True, - exclude=None)), sorted(files)) + file_resources.GetCommandLineFiles( + [self.test_tmpdir], recursive=True, exclude=None)), + sorted(files)) def test_recursive_find_in_dir_with_exclude(self): tdir1 = self._make_test_dir('test1') @@ -312,13 +310,13 @@ def test_recursive_find_in_dir_with_exclude(self): self.assertEqual( sorted( - file_resources.GetCommandLineFiles([self.test_tmpdir], - recursive=True, - exclude=['*test*3.py'])), - sorted([ - os.path.join(tdir1, 'testfile1.py'), - os.path.join(tdir2, 'testfile2.py'), - ])) + file_resources.GetCommandLineFiles( + [self.test_tmpdir], recursive=True, exclude=['*test*3.py'])), + sorted( + [ + os.path.join(tdir1, 'testfile1.py'), + os.path.join(tdir2, 'testfile2.py'), + ])) def test_find_with_excluded_hidden_dirs(self): tdir1 = self._make_test_dir('.test1') @@ -331,16 +329,16 @@ def test_find_with_excluded_hidden_dirs(self): ] _touch_files(files) - actual = file_resources.GetCommandLineFiles([self.test_tmpdir], - recursive=True, - exclude=['*.test1*']) + actual = file_resources.GetCommandLineFiles( + [self.test_tmpdir], recursive=True, exclude=['*.test1*']) self.assertEqual( sorted(actual), - sorted([ - os.path.join(tdir2, 'testfile2.py'), - os.path.join(tdir3, 'testfile3.py'), - ])) + sorted( + [ + os.path.join(tdir2, 'testfile2.py'), + os.path.join(tdir3, 'testfile3.py'), + ])) def test_find_with_excluded_hidden_dirs_relative(self): """Test find with excluded hidden dirs. @@ -370,19 +368,20 @@ def test_find_with_excluded_hidden_dirs_relative(self): os.chdir(self.test_tmpdir) actual = file_resources.GetCommandLineFiles( [os.path.relpath(self.test_tmpdir)], - recursive=True, - exclude=['*.test1*']) + recursive =True, + exclude =['*.test1*']) self.assertEqual( sorted(actual), - sorted([ - os.path.join( - os.path.relpath(self.test_tmpdir), os.path.basename(tdir2), - 'testfile2.py'), - os.path.join( - os.path.relpath(self.test_tmpdir), os.path.basename(tdir3), - 'testfile3.py'), - ])) + sorted( + [ + os.path.join( + os.path.relpath(self.test_tmpdir), + os.path.basename(tdir2), 'testfile2.py'), + os.path.join( + os.path.relpath(self.test_tmpdir), + os.path.basename(tdir3), 'testfile3.py'), + ])) def test_find_with_excluded_dirs(self): tdir1 = self._make_test_dir('test1') @@ -398,23 +397,23 @@ def test_find_with_excluded_dirs(self): os.chdir(self.test_tmpdir) found = sorted( - file_resources.GetCommandLineFiles(['test1', 'test2', 'test3'], - recursive=True, - exclude=[ - 'test1', - 'test2/testinner/', - ])) + file_resources.GetCommandLineFiles( + ['test1', 'test2', 'test3'], + recursive =True, + exclude =[ + 'test1', + 'test2/testinner/', + ])) self.assertEqual( found, ['test3/foo/bar/bas/xxx/testfile3.py'.replace("/", os.path.sep)]) found = sorted( - file_resources.GetCommandLineFiles(['.'], - recursive=True, - exclude=[ - 'test1', - 'test3', - ])) + file_resources.GetCommandLineFiles( + ['.'], recursive=True, exclude=[ + 'test1', + 'test3', + ])) self.assertEqual( found, ['./test2/testinner/testfile2.py'.replace("/", os.path.sep)]) @@ -517,7 +516,7 @@ def test_write_to_file(self): self.assertEqual(f2.read(), s) def test_write_to_stdout(self): - s = u'foobar' + s = u'foobar' stream = BufferedByteStream() if py3compat.PY3 else py3compat.StringIO() with utils.stdout_redirector(stream): file_resources.WriteReformattedCode( @@ -525,7 +524,7 @@ def test_write_to_stdout(self): self.assertEqual(stream.getvalue(), s) def test_write_encoded_to_stdout(self): - s = '\ufeff# -*- coding: utf-8 -*-\nresult = "passed"\n' # pylint: disable=anomalous-unicode-escape-in-string # noqa + s = '\ufeff# -*- coding: utf-8 -*-\nresult = "passed"\n' # pylint: disable=anomalous-unicode-escape-in-string # noqa stream = BufferedByteStream() if py3compat.PY3 else py3compat.StringIO() with utils.stdout_redirector(stream): file_resources.WriteReformattedCode( @@ -536,17 +535,17 @@ def test_write_encoded_to_stdout(self): class LineEndingTest(unittest.TestCase): def test_line_ending_linefeed(self): - lines = ['spam\n', 'spam\n'] + lines = ['spam\n', 'spam\n'] actual = file_resources.LineEnding(lines) self.assertEqual(actual, '\n') def test_line_ending_carriage_return(self): - lines = ['spam\r', 'spam\r'] + lines = ['spam\r', 'spam\r'] actual = file_resources.LineEnding(lines) self.assertEqual(actual, '\r') def test_line_ending_combo(self): - lines = ['spam\r\n', 'spam\r\n'] + lines = ['spam\r\n', 'spam\r\n'] actual = file_resources.LineEnding(lines) self.assertEqual(actual, '\r\n') diff --git a/yapftests/format_decision_state_test.py b/yapftests/format_decision_state_test.py index 63961f332..d9cdefe8c 100644 --- a/yapftests/format_decision_state_test.py +++ b/yapftests/format_decision_state_test.py @@ -32,12 +32,12 @@ def setUpClass(cls): style.SetGlobalStyle(style.CreateYapfStyle()) def testSimpleFunctionDefWithNoSplitting(self): - code = textwrap.dedent(r""" + code = textwrap.dedent(r""" def f(a, b): pass """) llines = yapf_test_helper.ParseAndUnwrap(code) - lline = logical_line.LogicalLine(0, _FilterLine(llines[0])) + lline = logical_line.LogicalLine(0, _FilterLine(llines[0])) lline.CalculateFormattingInformation() # Add: 'f' @@ -86,12 +86,12 @@ def f(a, b): self.assertEqual(repr(state), repr(clone)) def testSimpleFunctionDefWithSplitting(self): - code = textwrap.dedent(r""" + code = textwrap.dedent(r""" def f(a, b): pass """) llines = yapf_test_helper.ParseAndUnwrap(code) - lline = logical_line.LogicalLine(0, _FilterLine(llines[0])) + lline = logical_line.LogicalLine(0, _FilterLine(llines[0])) lline.CalculateFormattingInformation() # Add: 'f' diff --git a/yapftests/format_token_test.py b/yapftests/format_token_test.py index 3bb1ce9f5..4ec46f69f 100644 --- a/yapftests/format_token_test.py +++ b/yapftests/format_token_test.py @@ -95,22 +95,23 @@ def testIsMultilineString(self): # a='hello world', # # comment, # b='') - child1 = pytree.Leaf(token.NAME, 'a') - child2 = pytree.Leaf(token.EQUAL, '=') - child3 = pytree.Leaf(token.STRING, "'hello world'") - child4 = pytree.Leaf(token.COMMA, ',') - child5 = pytree.Leaf(token.COMMENT,'# comment') - child6 = pytree.Leaf(token.COMMA, ',') - child7 = pytree.Leaf(token.NAME, 'b') - child8 = pytree.Leaf(token.EQUAL, '=') - child9 = pytree.Leaf(token.STRING, "''") + child1 = pytree.Leaf(token.NAME, 'a') + child2 = pytree.Leaf(token.EQUAL, '=') + child3 = pytree.Leaf(token.STRING, "'hello world'") + child4 = pytree.Leaf(token.COMMA, ',') + child5 = pytree.Leaf(token.COMMENT, '# comment') + child6 = pytree.Leaf(token.COMMA, ',') + child7 = pytree.Leaf(token.NAME, 'b') + child8 = pytree.Leaf(token.EQUAL, '=') + child9 = pytree.Leaf(token.STRING, "''") node_type = pygram.python_grammar.symbol2number['arglist'] - node = pytree.Node(node_type, [child1, child2, child3, child4, child5, - child6, child7, child8,child9]) + node = pytree.Node( + node_type, + [child1, child2, child3, child4, child5, child6, child7, child8, child9]) subtype_assigner.AssignSubtypes(node) def testIsArgName(self, node=node): - tok = format_token.FormatToken(node.children[0],'NAME') + tok = format_token.FormatToken(node.children[0], 'NAME') self.assertTrue(tok.is_argname) def testIsArgAssign(self, node=node): @@ -122,5 +123,6 @@ def testCommentNotIsArgName(self, node=node): tok = format_token.FormatToken(node.children[4], 'COMMENT') self.assertFalse(tok.is_argname) + if __name__ == '__main__': unittest.main() diff --git a/yapftests/line_joiner_test.py b/yapftests/line_joiner_test.py index 2eaf16478..ea6186693 100644 --- a/yapftests/line_joiner_test.py +++ b/yapftests/line_joiner_test.py @@ -39,20 +39,23 @@ def _CheckLineJoining(self, code, join_lines): self.assertCodeEqual(line_joiner.CanMergeMultipleLines(llines), join_lines) def testSimpleSingleLineStatement(self): - code = textwrap.dedent(u"""\ + code = textwrap.dedent( + u"""\ if isinstance(a, int): continue """) self._CheckLineJoining(code, join_lines=True) def testSimpleMultipleLineStatement(self): - code = textwrap.dedent(u"""\ + code = textwrap.dedent( + u"""\ if isinstance(b, int): continue """) self._CheckLineJoining(code, join_lines=False) def testSimpleMultipleLineComplexStatement(self): - code = textwrap.dedent(u"""\ + code = textwrap.dedent( + u"""\ if isinstance(c, int): while True: continue @@ -60,19 +63,22 @@ def testSimpleMultipleLineComplexStatement(self): self._CheckLineJoining(code, join_lines=False) def testSimpleMultipleLineStatementWithComment(self): - code = textwrap.dedent(u"""\ + code = textwrap.dedent( + u"""\ if isinstance(d, int): continue # We're pleased that d's an int. """) self._CheckLineJoining(code, join_lines=True) def testSimpleMultipleLineStatementWithLargeIndent(self): - code = textwrap.dedent(u"""\ + code = textwrap.dedent( + u"""\ if isinstance(e, int): continue """) self._CheckLineJoining(code, join_lines=True) def testOverColumnLimit(self): - code = textwrap.dedent(u"""\ + code = textwrap.dedent( + u"""\ if instance(bbbbbbbbbbbbbbbbbbbbbbbbb, int): cccccccccccccccccccccccccc = ddddddddddddddddddddd """) # noqa self._CheckLineJoining(code, join_lines=False) diff --git a/yapftests/logical_line_test.py b/yapftests/logical_line_test.py index d18262a7c..695f88bd5 100644 --- a/yapftests/logical_line_test.py +++ b/yapftests/logical_line_test.py @@ -29,25 +29,29 @@ class LogicalLineBasicTest(unittest.TestCase): def testConstruction(self): - toks = _MakeFormatTokenList([(token.DOT, '.', 'DOT'), - (token.VBAR, '|', 'VBAR')]) + toks = _MakeFormatTokenList( + [(token.DOT, '.', 'DOT'), (token.VBAR, '|', 'VBAR')]) lline = logical_line.LogicalLine(20, toks) self.assertEqual(20, lline.depth) self.assertEqual(['DOT', 'VBAR'], [tok.name for tok in lline.tokens]) def testFirstLast(self): - toks = _MakeFormatTokenList([(token.DOT, '.', 'DOT'), - (token.LPAR, '(', 'LPAR'), - (token.VBAR, '|', 'VBAR')]) + toks = _MakeFormatTokenList( + [ + (token.DOT, '.', 'DOT'), (token.LPAR, '(', 'LPAR'), + (token.VBAR, '|', 'VBAR') + ]) lline = logical_line.LogicalLine(20, toks) self.assertEqual(20, lline.depth) self.assertEqual('DOT', lline.first.name) self.assertEqual('VBAR', lline.last.name) def testAsCode(self): - toks = _MakeFormatTokenList([(token.DOT, '.', 'DOT'), - (token.LPAR, '(', 'LPAR'), - (token.VBAR, '|', 'VBAR')]) + toks = _MakeFormatTokenList( + [ + (token.DOT, '.', 'DOT'), (token.LPAR, '(', 'LPAR'), + (token.VBAR, '|', 'VBAR') + ]) lline = logical_line.LogicalLine(2, toks) self.assertEqual(' . ( |', lline.AsCode()) @@ -61,7 +65,7 @@ def testAppendToken(self): class LogicalLineFormattingInformationTest(yapf_test_helper.YAPFTest): def testFuncDef(self): - code = textwrap.dedent(r""" + code = textwrap.dedent(r""" def f(a, b): pass """) diff --git a/yapftests/main_test.py b/yapftests/main_test.py index c83b8b66a..ea6892f5a 100644 --- a/yapftests/main_test.py +++ b/yapftests/main_test.py @@ -78,7 +78,7 @@ def patch_raw_input(lines=lines()): return next(lines) try: - orig_raw_import = yapf.py3compat.raw_input + orig_raw_import = yapf.py3compat.raw_input yapf.py3compat.raw_input = patch_raw_input yield finally: @@ -90,7 +90,7 @@ class RunMainTest(yapf_test_helper.YAPFTest): def testShouldHandleYapfError(self): """run_main should handle YapfError and sys.exit(1).""" expected_message = 'yapf: input filenames did not match any python files\n' - sys.argv = ['yapf', 'foo.c'] + sys.argv = ['yapf', 'foo.c'] with captured_output() as (out, err): with self.assertRaises(SystemExit): yapf.run_main() @@ -114,7 +114,7 @@ def testEchoInput(self): self.assertEqual(out.getvalue(), code) def testEchoInputWithStyle(self): - code = 'def f(a = 1\n\n):\n return 2*a\n' + code = 'def f(a = 1\n\n):\n return 2*a\n' yapf_code = 'def f(a=1):\n return 2 * a\n' with patched_input(code): with captured_output() as (out, _): @@ -135,5 +135,6 @@ def testHelp(self): self.assertEqual(ret, 0) help_message = out.getvalue() self.assertIn('indent_width=4', help_message) - self.assertIn('The number of spaces required before a trailing comment.', - help_message) + self.assertIn( + 'The number of spaces required before a trailing comment.', + help_message) diff --git a/yapftests/pytree_unwrapper_test.py b/yapftests/pytree_unwrapper_test.py index 525278def..cd67e0de1 100644 --- a/yapftests/pytree_unwrapper_test.py +++ b/yapftests/pytree_unwrapper_test.py @@ -43,69 +43,79 @@ def _CheckLogicalLines(self, llines, list_of_expected): self.assertEqual(list_of_expected, actual) def testSimpleFileScope(self): - code = textwrap.dedent(r""" + code = textwrap.dedent( + r""" x = 1 # a comment y = 2 """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckLogicalLines(llines, [ - (0, ['x', '=', '1']), - (0, ['# a comment']), - (0, ['y', '=', '2']), - ]) + self._CheckLogicalLines( + llines, [ + (0, ['x', '=', '1']), + (0, ['# a comment']), + (0, ['y', '=', '2']), + ]) def testSimpleMultilineStatement(self): - code = textwrap.dedent(r""" + code = textwrap.dedent(r""" y = (1 + x) """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckLogicalLines(llines, [ - (0, ['y', '=', '(', '1', '+', 'x', ')']), - ]) + self._CheckLogicalLines( + llines, [ + (0, ['y', '=', '(', '1', '+', 'x', ')']), + ]) def testFileScopeWithInlineComment(self): - code = textwrap.dedent(r""" + code = textwrap.dedent( + r""" x = 1 # a comment y = 2 """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckLogicalLines(llines, [ - (0, ['x', '=', '1', '# a comment']), - (0, ['y', '=', '2']), - ]) + self._CheckLogicalLines( + llines, [ + (0, ['x', '=', '1', '# a comment']), + (0, ['y', '=', '2']), + ]) def testSimpleIf(self): - code = textwrap.dedent(r""" + code = textwrap.dedent( + r""" if foo: x = 1 y = 2 """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckLogicalLines(llines, [ - (0, ['if', 'foo', ':']), - (1, ['x', '=', '1']), - (1, ['y', '=', '2']), - ]) + self._CheckLogicalLines( + llines, [ + (0, ['if', 'foo', ':']), + (1, ['x', '=', '1']), + (1, ['y', '=', '2']), + ]) def testSimpleIfWithComments(self): - code = textwrap.dedent(r""" + code = textwrap.dedent( + r""" # c1 if foo: # c2 x = 1 y = 2 """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckLogicalLines(llines, [ - (0, ['# c1']), - (0, ['if', 'foo', ':', '# c2']), - (1, ['x', '=', '1']), - (1, ['y', '=', '2']), - ]) + self._CheckLogicalLines( + llines, [ + (0, ['# c1']), + (0, ['if', 'foo', ':', '# c2']), + (1, ['x', '=', '1']), + (1, ['y', '=', '2']), + ]) def testIfWithCommentsInside(self): - code = textwrap.dedent(r""" + code = textwrap.dedent( + r""" if foo: # c1 x = 1 # c2 @@ -113,16 +123,18 @@ def testIfWithCommentsInside(self): y = 2 """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckLogicalLines(llines, [ - (0, ['if', 'foo', ':']), - (1, ['# c1']), - (1, ['x', '=', '1', '# c2']), - (1, ['# c3']), - (1, ['y', '=', '2']), - ]) + self._CheckLogicalLines( + llines, [ + (0, ['if', 'foo', ':']), + (1, ['# c1']), + (1, ['x', '=', '1', '# c2']), + (1, ['# c3']), + (1, ['y', '=', '2']), + ]) def testIfElifElse(self): - code = textwrap.dedent(r""" + code = textwrap.dedent( + r""" if x: x = 1 # c1 elif y: # c2 @@ -132,18 +144,20 @@ def testIfElifElse(self): z = 1 """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckLogicalLines(llines, [ - (0, ['if', 'x', ':']), - (1, ['x', '=', '1', '# c1']), - (0, ['elif', 'y', ':', '# c2']), - (1, ['y', '=', '1']), - (0, ['else', ':']), - (1, ['# c3']), - (1, ['z', '=', '1']), - ]) + self._CheckLogicalLines( + llines, [ + (0, ['if', 'x', ':']), + (1, ['x', '=', '1', '# c1']), + (0, ['elif', 'y', ':', '# c2']), + (1, ['y', '=', '1']), + (0, ['else', ':']), + (1, ['# c3']), + (1, ['z', '=', '1']), + ]) def testNestedCompoundTwoLevel(self): - code = textwrap.dedent(r""" + code = textwrap.dedent( + r""" if x: x = 1 # c1 while t: @@ -152,30 +166,34 @@ def testNestedCompoundTwoLevel(self): k = 1 """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckLogicalLines(llines, [ - (0, ['if', 'x', ':']), - (1, ['x', '=', '1', '# c1']), - (1, ['while', 't', ':']), - (2, ['# c2']), - (2, ['j', '=', '1']), - (1, ['k', '=', '1']), - ]) + self._CheckLogicalLines( + llines, [ + (0, ['if', 'x', ':']), + (1, ['x', '=', '1', '# c1']), + (1, ['while', 't', ':']), + (2, ['# c2']), + (2, ['j', '=', '1']), + (1, ['k', '=', '1']), + ]) def testSimpleWhile(self): - code = textwrap.dedent(r""" + code = textwrap.dedent( + r""" while x > 1: # c1 # c2 x = 1 """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckLogicalLines(llines, [ - (0, ['while', 'x', '>', '1', ':', '# c1']), - (1, ['# c2']), - (1, ['x', '=', '1']), - ]) + self._CheckLogicalLines( + llines, [ + (0, ['while', 'x', '>', '1', ':', '# c1']), + (1, ['# c2']), + (1, ['x', '=', '1']), + ]) def testSimpleTry(self): - code = textwrap.dedent(r""" + code = textwrap.dedent( + r""" try: pass except: @@ -188,34 +206,38 @@ def testSimpleTry(self): pass """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckLogicalLines(llines, [ - (0, ['try', ':']), - (1, ['pass']), - (0, ['except', ':']), - (1, ['pass']), - (0, ['except', ':']), - (1, ['pass']), - (0, ['else', ':']), - (1, ['pass']), - (0, ['finally', ':']), - (1, ['pass']), - ]) + self._CheckLogicalLines( + llines, [ + (0, ['try', ':']), + (1, ['pass']), + (0, ['except', ':']), + (1, ['pass']), + (0, ['except', ':']), + (1, ['pass']), + (0, ['else', ':']), + (1, ['pass']), + (0, ['finally', ':']), + (1, ['pass']), + ]) def testSimpleFuncdef(self): - code = textwrap.dedent(r""" + code = textwrap.dedent( + r""" def foo(x): # c1 # c2 return x """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckLogicalLines(llines, [ - (0, ['def', 'foo', '(', 'x', ')', ':', '# c1']), - (1, ['# c2']), - (1, ['return', 'x']), - ]) + self._CheckLogicalLines( + llines, [ + (0, ['def', 'foo', '(', 'x', ')', ':', '# c1']), + (1, ['# c2']), + (1, ['return', 'x']), + ]) def testTwoFuncDefs(self): - code = textwrap.dedent(r""" + code = textwrap.dedent( + r""" def foo(x): # c1 # c2 return x @@ -225,40 +247,45 @@ def bar(): # c3 return x """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckLogicalLines(llines, [ - (0, ['def', 'foo', '(', 'x', ')', ':', '# c1']), - (1, ['# c2']), - (1, ['return', 'x']), - (0, ['def', 'bar', '(', ')', ':', '# c3']), - (1, ['# c4']), - (1, ['return', 'x']), - ]) + self._CheckLogicalLines( + llines, [ + (0, ['def', 'foo', '(', 'x', ')', ':', '# c1']), + (1, ['# c2']), + (1, ['return', 'x']), + (0, ['def', 'bar', '(', ')', ':', '# c3']), + (1, ['# c4']), + (1, ['return', 'x']), + ]) def testSimpleClassDef(self): - code = textwrap.dedent(r""" + code = textwrap.dedent( + r""" class Klass: # c1 # c2 p = 1 """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckLogicalLines(llines, [ - (0, ['class', 'Klass', ':', '# c1']), - (1, ['# c2']), - (1, ['p', '=', '1']), - ]) + self._CheckLogicalLines( + llines, [ + (0, ['class', 'Klass', ':', '# c1']), + (1, ['# c2']), + (1, ['p', '=', '1']), + ]) def testSingleLineStmtInFunc(self): - code = textwrap.dedent(r""" + code = textwrap.dedent(r""" def f(): return 37 """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckLogicalLines(llines, [ - (0, ['def', 'f', '(', ')', ':']), - (1, ['return', '37']), - ]) + self._CheckLogicalLines( + llines, [ + (0, ['def', 'f', '(', ')', ':']), + (1, ['return', '37']), + ]) def testMultipleComments(self): - code = textwrap.dedent(r""" + code = textwrap.dedent( + r""" # Comment #1 # Comment #2 @@ -266,15 +293,17 @@ def f(): pass """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckLogicalLines(llines, [ - (0, ['# Comment #1']), - (0, ['# Comment #2']), - (0, ['def', 'f', '(', ')', ':']), - (1, ['pass']), - ]) + self._CheckLogicalLines( + llines, [ + (0, ['# Comment #1']), + (0, ['# Comment #2']), + (0, ['def', 'f', '(', ')', ':']), + (1, ['pass']), + ]) def testSplitListWithComment(self): - code = textwrap.dedent(r""" + code = textwrap.dedent( + r""" a = [ 'a', 'b', @@ -282,9 +311,14 @@ def testSplitListWithComment(self): ] """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckLogicalLines(llines, [(0, [ - 'a', '=', '[', "'a'", ',', "'b'", ',', "'c'", ',', '# hello world', ']' - ])]) + self._CheckLogicalLines( + llines, [ + ( + 0, [ + 'a', '=', '[', "'a'", ',', "'b'", ',', "'c'", ',', + '# hello world', ']' + ]) + ]) class MatchBracketsTest(yapf_test_helper.YAPFTest): @@ -300,9 +334,11 @@ def _CheckMatchingBrackets(self, llines, list_of_expected): """ actual = [] for lline in llines: - filtered_values = [(ft, ft.matching_bracket) - for ft in lline.tokens - if ft.name not in pytree_utils.NONSEMANTIC_TOKENS] + filtered_values = [ + (ft, ft.matching_bracket) + for ft in lline.tokens + if ft.name not in pytree_utils.NONSEMANTIC_TOKENS + ] if filtered_values: actual.append(filtered_values) @@ -317,7 +353,8 @@ def _CheckMatchingBrackets(self, llines, list_of_expected): self.assertEqual(lline[close_bracket][0], lline[open_bracket][1]) def testFunctionDef(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ def foo(a, b=['w','d'], c=[42, 37]): pass """) @@ -328,7 +365,8 @@ def foo(a, b=['w','d'], c=[42, 37]): ]) def testDecorator(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ @bar() def foo(a, b, c): pass @@ -341,7 +379,8 @@ def foo(a, b, c): ]) def testClassDef(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ class A(B, C, D): pass """) diff --git a/yapftests/pytree_utils_test.py b/yapftests/pytree_utils_test.py index c175f833e..ec61f75d2 100644 --- a/yapftests/pytree_utils_test.py +++ b/yapftests/pytree_utils_test.py @@ -25,7 +25,7 @@ # module. _GRAMMAR_SYMBOL2NUMBER = pygram.python_grammar.symbol2number -_FOO = 'foo' +_FOO = 'foo' _FOO1 = 'foo1' _FOO2 = 'foo2' _FOO3 = 'foo3' @@ -87,12 +87,12 @@ def _BuildSimpleTree(self): # simple_stmt: # NAME('foo') # - lpar1 = pytree.Leaf(token.LPAR, '(') - lpar2 = pytree.Leaf(token.LPAR, '(') - simple_stmt = pytree.Node(_GRAMMAR_SYMBOL2NUMBER['simple_stmt'], - [pytree.Leaf(token.NAME, 'foo')]) - return pytree.Node(_GRAMMAR_SYMBOL2NUMBER['suite'], - [lpar1, lpar2, simple_stmt]) + lpar1 = pytree.Leaf(token.LPAR, '(') + lpar2 = pytree.Leaf(token.LPAR, '(') + simple_stmt = pytree.Node( + _GRAMMAR_SYMBOL2NUMBER['simple_stmt'], [pytree.Leaf(token.NAME, 'foo')]) + return pytree.Node( + _GRAMMAR_SYMBOL2NUMBER['suite'], [lpar1, lpar2, simple_stmt]) def _MakeNewNodeRPAR(self): return pytree.Leaf(token.RPAR, ')') @@ -102,18 +102,18 @@ def setUp(self): def testInsertNodesBefore(self): # Insert before simple_stmt and make sure it went to the right place - pytree_utils.InsertNodesBefore([self._MakeNewNodeRPAR()], - self._simple_tree.children[2]) + pytree_utils.InsertNodesBefore( + [self._MakeNewNodeRPAR()], self._simple_tree.children[2]) self.assertEqual(4, len(self._simple_tree.children)) - self.assertEqual('RPAR', - pytree_utils.NodeName(self._simple_tree.children[2])) - self.assertEqual('simple_stmt', - pytree_utils.NodeName(self._simple_tree.children[3])) + self.assertEqual( + 'RPAR', pytree_utils.NodeName(self._simple_tree.children[2])) + self.assertEqual( + 'simple_stmt', pytree_utils.NodeName(self._simple_tree.children[3])) def testInsertNodesBeforeFirstChild(self): # Insert before the first child of its parent simple_stmt = self._simple_tree.children[2] - foo_child = simple_stmt.children[0] + foo_child = simple_stmt.children[0] pytree_utils.InsertNodesBefore([self._MakeNewNodeRPAR()], foo_child) self.assertEqual(3, len(self._simple_tree.children)) self.assertEqual(2, len(simple_stmt.children)) @@ -122,18 +122,18 @@ def testInsertNodesBeforeFirstChild(self): def testInsertNodesAfter(self): # Insert after and make sure it went to the right place - pytree_utils.InsertNodesAfter([self._MakeNewNodeRPAR()], - self._simple_tree.children[2]) + pytree_utils.InsertNodesAfter( + [self._MakeNewNodeRPAR()], self._simple_tree.children[2]) self.assertEqual(4, len(self._simple_tree.children)) - self.assertEqual('simple_stmt', - pytree_utils.NodeName(self._simple_tree.children[2])) - self.assertEqual('RPAR', - pytree_utils.NodeName(self._simple_tree.children[3])) + self.assertEqual( + 'simple_stmt', pytree_utils.NodeName(self._simple_tree.children[2])) + self.assertEqual( + 'RPAR', pytree_utils.NodeName(self._simple_tree.children[3])) def testInsertNodesAfterLastChild(self): # Insert after the last child of its parent simple_stmt = self._simple_tree.children[2] - foo_child = simple_stmt.children[0] + foo_child = simple_stmt.children[0] pytree_utils.InsertNodesAfter([self._MakeNewNodeRPAR()], foo_child) self.assertEqual(3, len(self._simple_tree.children)) self.assertEqual(2, len(simple_stmt.children)) @@ -143,16 +143,16 @@ def testInsertNodesAfterLastChild(self): def testInsertNodesWhichHasParent(self): # Try to insert an existing tree node into another place and fail. with self.assertRaises(RuntimeError): - pytree_utils.InsertNodesAfter([self._simple_tree.children[1]], - self._simple_tree.children[0]) + pytree_utils.InsertNodesAfter( + [self._simple_tree.children[1]], self._simple_tree.children[0]) class AnnotationsTest(unittest.TestCase): def setUp(self): self._leaf = pytree.Leaf(token.LPAR, '(') - self._node = pytree.Node(_GRAMMAR_SYMBOL2NUMBER['simple_stmt'], - [pytree.Leaf(token.NAME, 'foo')]) + self._node = pytree.Node( + _GRAMMAR_SYMBOL2NUMBER['simple_stmt'], [pytree.Leaf(token.NAME, 'foo')]) def testGetWhenNone(self): self.assertIsNone(pytree_utils.GetNodeAnnotation(self._leaf, _FOO)) @@ -183,18 +183,18 @@ def testMultiple(self): self.assertEqual(pytree_utils.GetNodeAnnotation(self._leaf, _FOO5), 5) def testSubtype(self): - pytree_utils.AppendNodeAnnotation(self._leaf, - pytree_utils.Annotation.SUBTYPE, _FOO) + pytree_utils.AppendNodeAnnotation( + self._leaf, pytree_utils.Annotation.SUBTYPE, _FOO) self.assertSetEqual( - pytree_utils.GetNodeAnnotation(self._leaf, - pytree_utils.Annotation.SUBTYPE), {_FOO}) + pytree_utils.GetNodeAnnotation( + self._leaf, pytree_utils.Annotation.SUBTYPE), {_FOO}) pytree_utils.RemoveSubtypeAnnotation(self._leaf, _FOO) self.assertSetEqual( - pytree_utils.GetNodeAnnotation(self._leaf, - pytree_utils.Annotation.SUBTYPE), set()) + pytree_utils.GetNodeAnnotation( + self._leaf, pytree_utils.Annotation.SUBTYPE), set()) def testSetOnNode(self): pytree_utils.SetNodeAnnotation(self._node, _FOO, 20) diff --git a/yapftests/pytree_visitor_test.py b/yapftests/pytree_visitor_test.py index 45a83b113..231183030 100644 --- a/yapftests/pytree_visitor_test.py +++ b/yapftests/pytree_visitor_test.py @@ -31,7 +31,7 @@ class _NodeNameCollector(pytree_visitor.PyTreeVisitor): """ def __init__(self): - self.all_node_names = [] + self.all_node_names = [] self.name_node_values = [] def DefaultNodeVisit(self, node): @@ -61,7 +61,7 @@ def Visit_NAME(self, leaf): class PytreeVisitorTest(unittest.TestCase): def testCollectAllNodeNamesSimpleCode(self): - tree = pytree_utils.ParseCodeToTree(_VISITOR_TEST_SIMPLE_CODE) + tree = pytree_utils.ParseCodeToTree(_VISITOR_TEST_SIMPLE_CODE) collector = _NodeNameCollector() collector.Visit(tree) expected_names = [ @@ -76,7 +76,7 @@ def testCollectAllNodeNamesSimpleCode(self): self.assertEqual(expected_name_node_values, collector.name_node_values) def testCollectAllNodeNamesNestedCode(self): - tree = pytree_utils.ParseCodeToTree(_VISITOR_TEST_NESTED_CODE) + tree = pytree_utils.ParseCodeToTree(_VISITOR_TEST_NESTED_CODE) collector = _NodeNameCollector() collector.Visit(tree) expected_names = [ @@ -95,7 +95,7 @@ def testCollectAllNodeNamesNestedCode(self): def testDumper(self): # PyTreeDumper is mainly a debugging utility, so only do basic sanity # checking. - tree = pytree_utils.ParseCodeToTree(_VISITOR_TEST_SIMPLE_CODE) + tree = pytree_utils.ParseCodeToTree(_VISITOR_TEST_SIMPLE_CODE) stream = py3compat.StringIO() pytree_visitor.PyTreeDumper(target_stream=stream).Visit(tree) @@ -106,7 +106,7 @@ def testDumper(self): def testDumpPyTree(self): # Similar sanity checking for the convenience wrapper DumpPyTree - tree = pytree_utils.ParseCodeToTree(_VISITOR_TEST_SIMPLE_CODE) + tree = pytree_utils.ParseCodeToTree(_VISITOR_TEST_SIMPLE_CODE) stream = py3compat.StringIO() pytree_visitor.DumpPyTree(tree, target_stream=stream) diff --git a/yapftests/reformatter_basic_test.py b/yapftests/reformatter_basic_test.py index 0eeeefdce..77ef859cb 100644 --- a/yapftests/reformatter_basic_test.py +++ b/yapftests/reformatter_basic_test.py @@ -33,10 +33,12 @@ def testSplittingAllArgs(self): style.SetGlobalStyle( style.CreateStyleFromConfig( '{split_all_comma_separated_values: true, column_limit: 40}')) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ responseDict = {"timestamp": timestamp, "someValue": value, "whatever": 120} """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ responseDict = { "timestamp": timestamp, "someValue": value, @@ -46,10 +48,12 @@ def testSplittingAllArgs(self): llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ yes = { 'yes': 'no', 'no': 'yes', } """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ yes = { 'yes': 'no', 'no': 'yes', @@ -57,11 +61,13 @@ def testSplittingAllArgs(self): """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def foo(long_arg, really_long_arg, really_really_long_arg, cant_keep_all_these_args): pass """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def foo(long_arg, really_long_arg, really_really_long_arg, @@ -70,10 +76,12 @@ def foo(long_arg, """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ foo_tuple = [long_arg, really_long_arg, really_really_long_arg, cant_keep_all_these_args] """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ foo_tuple = [ long_arg, really_long_arg, @@ -83,21 +91,25 @@ def foo(long_arg, """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ foo_tuple = [short, arg] """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ foo_tuple = [short, arg] """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) # There is a test for split_all_top_level_comma_separated_values, with # different expected value - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ someLongFunction(this_is_a_very_long_parameter, abc=(a, this_will_just_fit_xxxxxxx)) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ someLongFunction( this_is_a_very_long_parameter, abc=(a, @@ -112,10 +124,12 @@ def testSplittingTopLevelAllArgs(self): '{split_all_top_level_comma_separated_values: true, ' 'column_limit: 40}')) # Works the same way as split_all_comma_separated_values - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ responseDict = {"timestamp": timestamp, "someValue": value, "whatever": 120} """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ responseDict = { "timestamp": timestamp, "someValue": value, @@ -125,11 +139,13 @@ def testSplittingTopLevelAllArgs(self): llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) # Works the same way as split_all_comma_separated_values - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def foo(long_arg, really_long_arg, really_really_long_arg, cant_keep_all_these_args): pass """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def foo(long_arg, really_long_arg, really_really_long_arg, @@ -139,10 +155,12 @@ def foo(long_arg, llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) # Works the same way as split_all_comma_separated_values - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ foo_tuple = [long_arg, really_long_arg, really_really_long_arg, cant_keep_all_these_args] """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ foo_tuple = [ long_arg, really_long_arg, @@ -153,35 +171,41 @@ def foo(long_arg, llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) # Works the same way as split_all_comma_separated_values - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ foo_tuple = [short, arg] """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ foo_tuple = [short, arg] """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) # There is a test for split_all_comma_separated_values, with different # expected value - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ someLongFunction(this_is_a_very_long_parameter, abc=(a, this_will_just_fit_xxxxxxx)) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ someLongFunction( this_is_a_very_long_parameter, abc=(a, this_will_just_fit_xxxxxxx)) """) - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) actual_formatted_code = reformatter.Reformat(llines) self.assertEqual(40, len(actual_formatted_code.splitlines()[-1])) self.assertCodeEqual(expected_formatted_code, actual_formatted_code) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ someLongFunction(this_is_a_very_long_parameter, abc=(a, this_will_not_fit_xxxxxxxxx)) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ someLongFunction( this_is_a_very_long_parameter, abc=(a, @@ -191,11 +215,13 @@ def foo(long_arg, self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) # Exercise the case where there's no opening bracket (for a, b) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ a, b = f( a_very_long_parameter, yet_another_one, and_another) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ a, b = f( a_very_long_parameter, yet_another_one, and_another) """) @@ -203,7 +229,8 @@ def foo(long_arg, self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) # Don't require splitting before comments. - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ KO = { 'ABC': Abc, # abc 'DEF': Def, # def @@ -212,7 +239,8 @@ def foo(long_arg, 'JKL': Jkl, } """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ KO = { 'ABC': Abc, # abc 'DEF': Def, # def @@ -225,7 +253,8 @@ def foo(long_arg, self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testSimpleFunctionsWithTrailingComments(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def g(): # Trailing comment if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): @@ -237,7 +266,8 @@ def f( # Intermediate comment xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def g(): # Trailing comment if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): @@ -254,11 +284,13 @@ def f( # Intermediate comment self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testBlankLinesBetweenTopLevelImportsAndVariables(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ import foo as bar VAR = 'baz' """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ import foo as bar VAR = 'baz' @@ -266,12 +298,14 @@ def testBlankLinesBetweenTopLevelImportsAndVariables(self): llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ import foo as bar VAR = 'baz' """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ import foo as bar @@ -283,28 +317,32 @@ def testBlankLinesBetweenTopLevelImportsAndVariables(self): '{based_on_style: yapf, ' 'blank_lines_between_top_level_imports_and_variables: 2}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ import foo as bar # Some comment """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ import foo as bar # Some comment """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ import foo as bar class Baz(): pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ import foo as bar @@ -314,12 +352,14 @@ class Baz(): llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ import foo as bar def foobar(): pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ import foo as bar @@ -329,12 +369,14 @@ def foobar(): llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def foobar(): from foo import Bar Bar.baz() """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def foobar(): from foo import Bar Bar.baz() @@ -343,34 +385,39 @@ def foobar(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testBlankLinesAtEndOfFile(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def foobar(): # foo pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def foobar(): # foo pass """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ x = { 'a':37,'b':42, 'c':927} """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ x = {'a': 37, 'b': 42, 'c': 927} """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testIndentBlankLines(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ class foo(object): def foobar(self): @@ -398,18 +445,19 @@ class foo(object):\n \n def foobar(self):\n \n pass\n \n def barfoo(se '{based_on_style: yapf, indent_blank_lines: true}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) - unformatted_code, expected_formatted_code = (expected_formatted_code, - unformatted_code) + unformatted_code, expected_formatted_code = ( + expected_formatted_code, unformatted_code) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testMultipleUgliness(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ x = { 'a':37,'b':42, 'c':927} @@ -425,7 +473,8 @@ def g(self, x,y=42): def f ( a ) : return 37+-+a[42-x : y**3] """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ x = {'a': 37, 'b': 42, 'c': 927} y = 'hello ' 'world' @@ -449,7 +498,8 @@ def f(a): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testComments(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ class Foo(object): pass @@ -471,7 +521,8 @@ class Baz(object): class Qux(object): pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ class Foo(object): pass @@ -502,16 +553,18 @@ class Qux(object): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testSingleComment(self): - code = textwrap.dedent("""\ + code = textwrap.dedent("""\ # Thing 1 """) llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) def testCommentsWithTrailingSpaces(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ # Thing 1 \n# Thing 2 \n""") - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ # Thing 1 # Thing 2 """) @@ -519,7 +572,8 @@ def testCommentsWithTrailingSpaces(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testCommentsInDataLiteral(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ def f(): return collections.OrderedDict({ # First comment. @@ -536,7 +590,8 @@ def f(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testEndingWhitespaceAfterSimpleStatement(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ import foo as bar # Thing 1 # Thing 2 @@ -545,7 +600,8 @@ def testEndingWhitespaceAfterSimpleStatement(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testDocstrings(self): - unformatted_code = textwrap.dedent('''\ + unformatted_code = textwrap.dedent( + '''\ u"""Module-level docstring.""" import os class Foo(object): @@ -562,7 +618,8 @@ def qux(self): print('hello {}'.format('world')) return 42 ''') - expected_formatted_code = textwrap.dedent('''\ + expected_formatted_code = textwrap.dedent( + '''\ u"""Module-level docstring.""" import os @@ -583,7 +640,8 @@ def qux(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testDocstringAndMultilineComment(self): - unformatted_code = textwrap.dedent('''\ + unformatted_code = textwrap.dedent( + '''\ """Hello world""" # A multiline # comment @@ -597,7 +655,8 @@ def foo(self): # comment pass ''') - expected_formatted_code = textwrap.dedent('''\ + expected_formatted_code = textwrap.dedent( + '''\ """Hello world""" @@ -618,7 +677,8 @@ def foo(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testMultilineDocstringAndMultilineComment(self): - unformatted_code = textwrap.dedent('''\ + unformatted_code = textwrap.dedent( + '''\ """Hello world RIP Dennis Richie. @@ -641,7 +701,8 @@ def foo(self): # comment pass ''') - expected_formatted_code = textwrap.dedent('''\ + expected_formatted_code = textwrap.dedent( + '''\ """Hello world RIP Dennis Richie. @@ -671,24 +732,26 @@ def foo(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testTupleCommaBeforeLastParen(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent("""\ a = ( 1, ) """) expected_formatted_code = textwrap.dedent("""\ a = (1,) """) - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testNoBreakOutsideOfBracket(self): # FIXME(morbo): How this is formatted is not correct. But it's syntactically # correct. - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def f(): assert port >= minimum, \ 'Unexpected port %d when minimum was %d.' % (port, minimum) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def f(): assert port >= minimum, 'Unexpected port %d when minimum was %d.' % (port, minimum) @@ -697,7 +760,8 @@ def f(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testBlankLinesBeforeDecorators(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ @foo() class A(object): @bar() @@ -705,7 +769,8 @@ class A(object): def x(self): pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ @foo() class A(object): @@ -718,14 +783,16 @@ def x(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testCommentBetweenDecorators(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ @foo() # frob @bar def x (self): pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ @foo() # frob @bar @@ -736,12 +803,14 @@ def x(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testListComprehension(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def given(y): [k for k in () if k in y] """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def given(y): [k for k in () if k in y] """) @@ -749,14 +818,16 @@ def given(y): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testListComprehensionPreferOneLine(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def given(y): long_variable_name = [ long_var_name + 1 for long_var_name in () if long_var_name == 2] """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def given(y): long_variable_name = [ long_var_name + 1 for long_var_name in () if long_var_name == 2 @@ -766,12 +837,14 @@ def given(y): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testListComprehensionPreferOneLineOverArithmeticSplit(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def given(used_identifiers): return (sum(len(identifier) for identifier in used_identifiers) / len(used_identifiers)) """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def given(used_identifiers): return (sum(len(identifier) for identifier in used_identifiers) / len(used_identifiers)) @@ -780,14 +853,16 @@ def given(used_identifiers): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testListComprehensionPreferThreeLinesForLineWrap(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def given(y): long_variable_name = [ long_var_name + 1 for long_var_name, number_two in () if long_var_name == 2 and number_two == 3] """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def given(y): long_variable_name = [ long_var_name + 1 @@ -799,14 +874,16 @@ def given(y): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testListComprehensionPreferNoBreakForTrivialExpression(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def given(y): long_variable_name = [ long_var_name for long_var_name, number_two in () if long_var_name == 2 and number_two == 3] """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def given(y): long_variable_name = [ long_var_name for long_var_name, number_two in () @@ -817,7 +894,7 @@ def given(y): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testOpeningAndClosingBrackets(self): - unformatted_code = """\ + unformatted_code = """\ foo( (1, ) ) foo( ( 1, 2, 3 ) ) foo( ( 1, 2, 3, ) ) @@ -831,14 +908,16 @@ def testOpeningAndClosingBrackets(self): 3, )) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testSingleLineFunctions(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def foo(): return 42 """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def foo(): return 42 """) @@ -849,21 +928,23 @@ def testNoQueueSeletionInMiddleOfLine(self): # If the queue isn't properly constructed, then a token in the middle of the # line may be selected as the one with least penalty. The tokens after that # one are then splatted at the end of the line with no formatting. - unformatted_code = """\ + unformatted_code = """\ find_symbol(node.type) + "< " + " ".join(find_pattern(n) for n in node.child) + " >" """ # noqa expected_formatted_code = """\ find_symbol(node.type) + "< " + " ".join( find_pattern(n) for n in node.child) + " >" """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testNoSpacesBetweenSubscriptsAndCalls(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ aaaaaaaaaa = bbbbbbbb.ccccccccc() [42] (a, 2) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ aaaaaaaaaa = bbbbbbbb.ccccccccc()[42](a, 2) """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) @@ -871,21 +952,25 @@ def testNoSpacesBetweenSubscriptsAndCalls(self): def testNoSpacesBetweenOpeningBracketAndStartingOperator(self): # Unary operator. - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ aaaaaaaaaa = bbbbbbbb.ccccccccc[ -1 ]( -42 ) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ aaaaaaaaaa = bbbbbbbb.ccccccccc[-1](-42) """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) # Varargs and kwargs. - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ aaaaaaaaaa = bbbbbbbb.ccccccccc( *varargs ) aaaaaaaaaa = bbbbbbbb.ccccccccc( **kwargs ) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ aaaaaaaaaa = bbbbbbbb.ccccccccc(*varargs) aaaaaaaaaa = bbbbbbbb.ccccccccc(**kwargs) """) @@ -893,13 +978,15 @@ def testNoSpacesBetweenOpeningBracketAndStartingOperator(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testMultilineCommentReformatted(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ if True: # This is a multiline # comment. pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ if True: # This is a multiline # comment. @@ -909,7 +996,8 @@ def testMultilineCommentReformatted(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testDictionaryMakerFormatting(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ _PYTHON_STATEMENTS = frozenset({ lambda x, y: 'simple_stmt': 'small_stmt', 'expr_stmt': 'print_stmt', 'del_stmt': 'pass_stmt', lambda: 'break_stmt': 'continue_stmt', 'return_stmt': 'raise_stmt', @@ -917,7 +1005,8 @@ def testDictionaryMakerFormatting(self): 'if_stmt', 'while_stmt': 'for_stmt', }) """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ _PYTHON_STATEMENTS = frozenset({ lambda x, y: 'simple_stmt': 'small_stmt', 'expr_stmt': 'print_stmt', @@ -934,14 +1023,16 @@ def testDictionaryMakerFormatting(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testSimpleMultilineCode(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ if True: aaaaaaaaaaaaaa.bbbbbbbbbbbbbb.ccccccc(zzzzzzzzzzzz, \ xxxxxxxxxxx, yyyyyyyyyyyy, vvvvvvvvv) aaaaaaaaaaaaaa.bbbbbbbbbbbbbb.ccccccc(zzzzzzzzzzzz, \ xxxxxxxxxxx, yyyyyyyyyyyy, vvvvvvvvv) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ if True: aaaaaaaaaaaaaa.bbbbbbbbbbbbbb.ccccccc(zzzzzzzzzzzz, xxxxxxxxxxx, yyyyyyyyyyyy, vvvvvvvvv) @@ -952,7 +1043,8 @@ def testSimpleMultilineCode(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testMultilineComment(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ if Foo: # Hello world # Yo man. @@ -965,14 +1057,15 @@ def testMultilineComment(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testSpaceBetweenStringAndParentheses(self): - code = textwrap.dedent("""\ + code = textwrap.dedent("""\ b = '0' ('hello') """) llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) def testMultilineString(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ code = textwrap.dedent('''\ if Foo: # Hello world @@ -986,7 +1079,8 @@ def testMultilineString(self): llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent('''\ + unformatted_code = textwrap.dedent( + '''\ def f(): email_text += """This is a really long docstring that goes over the column limit and is multi-line.

Czar: """+despot["Nicholas"]+"""
@@ -995,7 +1089,8 @@ def f(): """ ''') # noqa - expected_formatted_code = textwrap.dedent('''\ + expected_formatted_code = textwrap.dedent( + '''\ def f(): email_text += """This is a really long docstring that goes over the column limit and is multi-line.

Czar: """ + despot["Nicholas"] + """
@@ -1008,7 +1103,8 @@ def f(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testSimpleMultilineWithComments(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ if ( # This is the first comment a and # This is the second comment # This is the third comment @@ -1020,12 +1116,14 @@ def testSimpleMultilineWithComments(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testMatchingParenSplittingMatching(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def f(): raise RuntimeError('unable to find insertion point for target node', (target,)) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def f(): raise RuntimeError('unable to find insertion point for target node', (target,)) @@ -1034,7 +1132,8 @@ def f(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testContinuationIndent(self): - unformatted_code = textwrap.dedent('''\ + unformatted_code = textwrap.dedent( + '''\ class F: def _ProcessArgLists(self, node): """Common method for processing argument lists.""" @@ -1044,7 +1143,8 @@ def _ProcessArgLists(self, node): child, subtype=_ARGLIST_TOKEN_TO_SUBTYPE.get( child.value, format_token.Subtype.NONE)) ''') - expected_formatted_code = textwrap.dedent('''\ + expected_formatted_code = textwrap.dedent( + '''\ class F: def _ProcessArgLists(self, node): @@ -1060,12 +1160,14 @@ def _ProcessArgLists(self, node): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testTrailingCommaAndBracket(self): - unformatted_code = textwrap.dedent('''\ + unformatted_code = textwrap.dedent( + '''\ a = { 42, } b = ( 42, ) c = [ 42, ] ''') - expected_formatted_code = textwrap.dedent('''\ + expected_formatted_code = textwrap.dedent( + '''\ a = { 42, } @@ -1078,20 +1180,23 @@ def testTrailingCommaAndBracket(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testI18n(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ N_('Some years ago - never mind how long precisely - having little or no money in my purse, and nothing particular to interest me on shore, I thought I would sail about a little and see the watery part of the world.') # A comment is here. """) # noqa llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ foo('Fake function call') #. Some years ago - never mind how long precisely - having little or no money in my purse, and nothing particular to interest me on shore, I thought I would sail about a little and see the watery part of the world. """) # noqa llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) def testI18nCommentsInDataLiteral(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ def f(): return collections.OrderedDict({ #. First i18n comment. @@ -1105,7 +1210,8 @@ def f(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testClosingBracketIndent(self): - code = textwrap.dedent('''\ + code = textwrap.dedent( + '''\ def f(): def g(): @@ -1118,7 +1224,8 @@ def g(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testClosingBracketsInlinedInCall(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ class Foo(object): def bar(self): @@ -1132,7 +1239,8 @@ def bar(self): "porkporkpork": 5, }) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ class Foo(object): def bar(self): @@ -1150,7 +1258,8 @@ def bar(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testLineWrapInForExpression(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ class A: def x(self, node, name, n=1): @@ -1163,7 +1272,7 @@ def x(self, node, name, n=1): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testFunctionCallContinuationLine(self): - code = """\ + code = """\ class foo: def bar(self, node, name, n=1): @@ -1177,7 +1286,8 @@ def bar(self, node, name, n=1): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testI18nNonFormatting(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ class F(object): def __init__(self, fieldname, @@ -1189,7 +1299,8 @@ def __init__(self, fieldname, self.assertCodeEqual(code, reformatter.Reformat(llines)) def testNoSpaceBetweenUnaryOpAndOpeningParen(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ if ~(a or b): pass """) @@ -1197,7 +1308,8 @@ def testNoSpaceBetweenUnaryOpAndOpeningParen(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testCommentBeforeFuncDef(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ class Foo(object): a = 42 @@ -1215,7 +1327,8 @@ def __init__(self, self.assertCodeEqual(code, reformatter.Reformat(llines)) def testExcessLineCountWithDefaultKeywords(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ class Fnord(object): def Moo(self): aaaaaaaaaaaaaaaa = self._bbbbbbbbbbbbbbbbbbbbbbb( @@ -1223,7 +1336,8 @@ def Moo(self): fffff=fffff, ggggggg=ggggggg, hhhhhhhhhhhhh=hhhhhhhhhhhhh, iiiiiii=iiiiiiiiiiiiii) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ class Fnord(object): def Moo(self): @@ -1240,7 +1354,8 @@ def Moo(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testSpaceAfterNotOperator(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ if not (this and that): pass """) @@ -1248,7 +1363,8 @@ def testSpaceAfterNotOperator(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testNoPenaltySplitting(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ def f(): if True: if True: @@ -1261,7 +1377,8 @@ def f(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testExpressionPenalties(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ def f(): if ((left.value == '(' and right.value == ')') or (left.value == '[' and right.value == ']') or @@ -1272,14 +1389,16 @@ def f(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testLineDepthOfSingleLineStatement(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ while True: continue for x in range(3): continue try: a = 42 except: b = 42 with open(a) as fd: a = fd.read() """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ while True: continue for x in range(3): @@ -1295,11 +1414,13 @@ def testLineDepthOfSingleLineStatement(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testSplitListWithTerminatingComma(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ FOO = ['bar', 'baz', 'mux', 'qux', 'quux', 'quuux', 'quuuux', 'quuuuux', 'quuuuuux', 'quuuuuuux', lambda a, b: 37,] """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ FOO = [ 'bar', 'baz', @@ -1318,7 +1439,8 @@ def testSplitListWithTerminatingComma(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testSplitListWithInterspersedComments(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ FOO = [ 'bar', # bar 'baz', # baz @@ -1337,7 +1459,7 @@ def testSplitListWithInterspersedComments(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testRelativeImportStatements(self): - code = textwrap.dedent("""\ + code = textwrap.dedent("""\ from ... import bork """) llines = yapf_test_helper.ParseAndUnwrap(code) @@ -1345,13 +1467,15 @@ def testRelativeImportStatements(self): def testSingleLineList(self): # A list on a single line should prefer to remain contiguous. - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = aaaaaaaaaaa( ("...", "."), "..", ".............................................." ) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = aaaaaaaaaaa( ("...", "."), "..", "..............................................") """) # noqa @@ -1359,7 +1483,8 @@ def testSingleLineList(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testBlankLinesBeforeFunctionsNotInColumnZero(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ import signal @@ -1374,7 +1499,8 @@ def timeout(seconds=1): except: pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ import signal try: @@ -1393,7 +1519,8 @@ def timeout(seconds=1): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testNoKeywordArgumentBreakage(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ class A(object): def b(self): @@ -1405,7 +1532,7 @@ def b(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testTrailerOnSingleLine(self): - code = """\ + code = """\ urlpatterns = patterns('', url(r'^$', 'homepage_view'), url(r'^/login/$', 'login_view'), url(r'^/login/$', 'logout_view'), @@ -1415,7 +1542,8 @@ def testTrailerOnSingleLine(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testIfConditionalParens(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ class Foo: def bar(): @@ -1428,7 +1556,8 @@ def bar(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testContinuationMarkers(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. "\\ "Sed sit amet ipsum mauris. Maecenas congue ligula ac quam viverra nec consectetur "\\ "ante hendrerit. Donec et mollis dolor. Praesent et diam eget libero egestas mattis "\\ @@ -1438,14 +1567,16 @@ def testContinuationMarkers(self): llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ from __future__ import nested_scopes, generators, division, absolute_import, with_statement, \\ print_function, unicode_literals """) # noqa llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ if aaaaaaaaa == 42 and bbbbbbbbbbbbbb == 42 and \\ cccccccc == 42: pass @@ -1454,7 +1585,8 @@ def testContinuationMarkers(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testCommentsWithContinuationMarkers(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ def fn(arg): v = fn2(key1=True, #c1 @@ -1465,7 +1597,8 @@ def fn(arg): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testMultipleContinuationMarkers(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ xyz = \\ \\ some_thing() @@ -1474,7 +1607,7 @@ def testMultipleContinuationMarkers(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testContinuationMarkerAfterStringWithContinuation(self): - code = """\ + code = """\ s = 'foo \\ bar' \\ .format() @@ -1483,7 +1616,8 @@ def testContinuationMarkerAfterStringWithContinuation(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testEmptyContainers(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ flags.DEFINE_list( 'output_dirs', [], 'Lorem ipsum dolor sit amet, consetetur adipiscing elit. Donec a diam lectus. ' @@ -1493,10 +1627,12 @@ def testEmptyContainers(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testSplitStringsIfSurroundedByParens(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ a = foo.bar({'xxxxxxxxxxxxxxxxxxxxxxx' 'yyyyyyyyyyyyyyyyyyyyyyyyyy': baz[42]} + 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' 'bbbbbbbbbbbbbbbbbbbbbbbbbb' 'cccccccccccccccccccccccccccccccc' 'ddddddddddddddddddddddddddddd') """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ a = foo.bar({'xxxxxxxxxxxxxxxxxxxxxxx' 'yyyyyyyyyyyyyyyyyyyyyyyyyy': baz[42]} + 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' @@ -1507,7 +1643,8 @@ def testSplitStringsIfSurroundedByParens(self): llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ a = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' \ 'bbbbbbbbbbbbbbbbbbbbbbbbbb' 'cccccccccccccccccccccccccccccccc' \ 'ddddddddddddddddddddddddddddd' @@ -1516,7 +1653,8 @@ def testSplitStringsIfSurroundedByParens(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testMultilineShebang(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ #!/bin/sh if "true" : '''\' then @@ -1536,7 +1674,8 @@ def testMultilineShebang(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testNoSplittingAroundTermOperators(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ a_very_long_function_call_yada_yada_etc_etc_etc(long_arg1, long_arg2 / long_arg3) """) @@ -1544,7 +1683,8 @@ def testNoSplittingAroundTermOperators(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testNoSplittingAroundCompOperators(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ c = (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa is not bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) c = (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa in bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) c = (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not in bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) @@ -1552,7 +1692,8 @@ def testNoSplittingAroundCompOperators(self): c = (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa is bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) c = (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <= bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) """) # noqa - expected_code = textwrap.dedent("""\ + expected_code = textwrap.dedent( + """\ c = ( aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa is not bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) @@ -1574,7 +1715,8 @@ def testNoSplittingAroundCompOperators(self): self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) def testNoSplittingWithinSubscriptList(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ somequitelongvariablename.somemember[(a, b)] = { 'somelongkey': 1, 'someotherlongkey': 2 @@ -1584,7 +1726,8 @@ def testNoSplittingWithinSubscriptList(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testExcessCharacters(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ class foo: def bar(self): @@ -1595,14 +1738,16 @@ def bar(self): llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def _(): if True: if True: if contract == allow_contract and attr_dict.get(if_attribute) == has_value: return True """) # noqa - expected_code = textwrap.dedent("""\ + expected_code = textwrap.dedent( + """\ def _(): if True: if True: @@ -1614,7 +1759,8 @@ def _(): self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) def testDictSetGenerator(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ foo = { variable: 'hello world. How are you today?' for variable in fnord @@ -1625,7 +1771,8 @@ def testDictSetGenerator(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testUnaryOpInDictionaryValue(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ beta = "123" test = {'alpha': beta[-1]} @@ -1636,7 +1783,8 @@ def testUnaryOpInDictionaryValue(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testUnaryNotOperator(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ if True: if True: if True: @@ -1648,7 +1796,7 @@ def testUnaryNotOperator(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testRelaxArraySubscriptAffinity(self): - code = """\ + code = """\ class A(object): def f(self, aaaaaaaaa, bbbbbbbbbbbbb, row): @@ -1664,17 +1812,18 @@ def f(self, aaaaaaaaa, bbbbbbbbbbbbb, row): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testFunctionCallInDict(self): - code = "a = {'a': b(c=d, **e)}\n" + code = "a = {'a': b(c=d, **e)}\n" llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) def testFunctionCallInNestedDict(self): - code = "a = {'a': {'a': {'a': b(c=d, **e)}}}\n" + code = "a = {'a': {'a': {'a': b(c=d, **e)}}}\n" llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) def testUnbreakableNot(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ def test(): if not "Foooooooooooooooooooooooooooooo" or "Foooooooooooooooooooooooooooooo" == "Foooooooooooooooooooooooooooooo": pass @@ -1683,7 +1832,8 @@ def test(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testSplitListWithComment(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ a = [ 'a', 'b', @@ -1694,7 +1844,8 @@ def testSplitListWithComment(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testOverColumnLimit(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ class Test: def testSomething(self): @@ -1704,7 +1855,8 @@ def testSomething(self): ('aaaaaaaaaaaaa', 'bbbb'): 'ccccccccccccccccccccccccccccccccccccccccccc', } """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ class Test: def testSomething(self): @@ -1721,7 +1873,8 @@ def testSomething(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testEndingComment(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ a = f( a="something", b="something requiring comment which is quite long", # comment about b (pushes line over 79) @@ -1731,7 +1884,8 @@ def testEndingComment(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testContinuationSpaceRetention(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ def fn(): return module \\ .method(Object(data, @@ -1742,7 +1896,8 @@ def fn(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testIfExpressionWithFunctionCall(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ if x or z.y( a, c, @@ -1754,7 +1909,8 @@ def testIfExpressionWithFunctionCall(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testUnformattedAfterMultilineString(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ def foo(): com_text = \\ ''' @@ -1765,7 +1921,8 @@ def foo(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testNoSpacesAroundKeywordDefaultValues(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ sources = { 'json': request.get_json(silent=True) or {}, 'json2': request.get_json(silent=True), @@ -1776,12 +1933,14 @@ def testNoSpacesAroundKeywordDefaultValues(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testNoSplittingBeforeEndingSubscriptBracket(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ if True: if True: status = cf.describe_stacks(StackName=stackname)[u'Stacks'][0][u'StackStatus'] """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ if True: if True: status = cf.describe_stacks( @@ -1791,7 +1950,8 @@ def testNoSplittingBeforeEndingSubscriptBracket(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testNoSplittingOnSingleArgument(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ xxxxxxxxxxxxxx = (re.search(r'(\\d+\\.\\d+\\.\\d+\\.)\\d+', aaaaaaa.bbbbbbbbbbbb).group(1) + re.search(r'\\d+\\.\\d+\\.\\d+\\.(\\d+)', @@ -1801,7 +1961,8 @@ def testNoSplittingOnSingleArgument(self): re.search(r'\\d+\\.\\d+\\.\\d+\\.(\\d+)', ccccccc).group(c.d)) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ xxxxxxxxxxxxxx = ( re.search(r'(\\d+\\.\\d+\\.\\d+\\.)\\d+', aaaaaaa.bbbbbbbbbbbb).group(1) + re.search(r'\\d+\\.\\d+\\.\\d+\\.(\\d+)', ccccccc).group(1)) @@ -1813,13 +1974,15 @@ def testNoSplittingOnSingleArgument(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testSplittingArraysSensibly(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ while True: while True: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = list['bbbbbbbbbbbbbbbbbbbbbbbbb'].split(',') aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = list('bbbbbbbbbbbbbbbbbbbbbbbbb').split(',') """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ while True: while True: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = list[ @@ -1831,13 +1994,15 @@ def testSplittingArraysSensibly(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testComprehensionForAndIf(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ class f: def __repr__(self): tokens_repr = ','.join(['{0}({1!r})'.format(tok.name, tok.value) for tok in self._tokens]) """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ class f: def __repr__(self): @@ -1848,7 +2013,8 @@ def __repr__(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testFunctionCallArguments(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def f(): if True: pytree_utils.InsertNodesBefore(_CreateCommentsFromPrefix( @@ -1858,7 +2024,8 @@ def f(): comment_prefix, comment_lineno, comment_column, standalone=True)) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def f(): if True: pytree_utils.InsertNodesBefore( @@ -1873,18 +2040,21 @@ def f(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testBinaryOperators(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ a = b ** 37 c = (20 ** -3) / (_GRID_ROWS ** (code_length - 10)) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ a = b**37 c = (20**-3) / (_GRID_ROWS**(code_length - 10)) """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ def f(): if True: if (self.stack[-1].split_before_closing_bracket and @@ -1897,7 +2067,8 @@ def f(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testContiguousList(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ [retval1, retval2] = a_very_long_function(argument_1, argument2, argument_3, argument_4) """) # noqa @@ -1905,7 +2076,8 @@ def testContiguousList(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testArgsAndKwargsFormatting(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ a(a=aaaaaaaaaaaaaaaaaaaaa, b=aaaaaaaaaaaaaaaaaaaaaaaa, c=aaaaaaaaaaaaaaaaaa, @@ -1915,7 +2087,8 @@ def testArgsAndKwargsFormatting(self): llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ def foo(): return [ Bar(xxx='some string', @@ -1927,7 +2100,8 @@ def foo(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testCommentColumnLimitOverflow(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ def f(): if True: TaskManager.get_tags = MagicMock( @@ -1940,7 +2114,8 @@ def f(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testMultilineLambdas(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ class SomeClass(object): do_something = True @@ -1951,7 +2126,8 @@ def succeeded(self, dddddddddddddd): d.addCallback(lambda _: self.aaaaaa.bbbbbbbbbbbbbbbb.cccccccccccccccccccccccccccccccc(dddddddddddddd)) return d """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ class SomeClass(object): do_something = True @@ -1969,13 +2145,14 @@ def succeeded(self, dddddddddddddd): style.CreateStyleFromConfig( '{based_on_style: yapf, allow_multiline_lambdas: true}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testMultilineDictionaryKeys(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ MAP_WITH_LONG_KEYS = { ('lorem ipsum', 'dolor sit amet'): 1, @@ -1985,7 +2162,8 @@ def testMultilineDictionaryKeys(self): 3 } """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ MAP_WITH_LONG_KEYS = { ('lorem ipsum', 'dolor sit amet'): 1, @@ -1999,16 +2177,18 @@ def testMultilineDictionaryKeys(self): try: style.SetGlobalStyle( - style.CreateStyleFromConfig('{based_on_style: yapf, ' - 'allow_multiline_dictionary_keys: true}')) + style.CreateStyleFromConfig( + '{based_on_style: yapf, ' + 'allow_multiline_dictionary_keys: true}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testStableDictionaryFormatting(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ class A(object): def method(self): @@ -2025,15 +2205,16 @@ def method(self): try: style.SetGlobalStyle( - style.CreateStyleFromConfig('{based_on_style: pep8, indent_width: 2, ' - 'continuation_indent_width: 4, ' - 'indent_dictionary_value: True}')) + style.CreateStyleFromConfig( + '{based_on_style: pep8, indent_width: 2, ' + 'continuation_indent_width: 4, ' + 'indent_dictionary_value: True}')) - llines = yapf_test_helper.ParseAndUnwrap(code) + llines = yapf_test_helper.ParseAndUnwrap(code) reformatted_code = reformatter.Reformat(llines) self.assertCodeEqual(code, reformatted_code) - llines = yapf_test_helper.ParseAndUnwrap(reformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(reformatted_code) reformatted_code = reformatter.Reformat(llines) self.assertCodeEqual(code, reformatted_code) finally: @@ -2042,12 +2223,14 @@ def method(self): def testStableInlinedDictionaryFormatting(self): try: style.SetGlobalStyle(style.CreatePEP8Style()) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def _(): url = "http://{0}/axis-cgi/admin/param.cgi?{1}".format( value, urllib.urlencode({'action': 'update', 'parameter': value})) """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def _(): url = "http://{0}/axis-cgi/admin/param.cgi?{1}".format( value, urllib.urlencode({ @@ -2056,23 +2239,25 @@ def _(): })) """) - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) reformatted_code = reformatter.Reformat(llines) self.assertCodeEqual(expected_formatted_code, reformatted_code) - llines = yapf_test_helper.ParseAndUnwrap(reformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(reformatted_code) reformatted_code = reformatter.Reformat(llines) self.assertCodeEqual(expected_formatted_code, reformatted_code) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testDontSplitKeywordValueArguments(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def mark_game_scored(gid): _connect.execute(_games.update().where(_games.c.gid == gid).values( scored=True)) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def mark_game_scored(gid): _connect.execute( _games.update().where(_games.c.gid == gid).values(scored=True)) @@ -2081,7 +2266,8 @@ def mark_game_scored(gid): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testDontAddBlankLineAfterMultilineString(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ query = '''SELECT id FROM table WHERE day in {}''' @@ -2091,7 +2277,8 @@ def testDontAddBlankLineAfterMultilineString(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testFormattingListComprehensions(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ def a(): if True: if True: @@ -2105,7 +2292,8 @@ def a(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testNoSplittingWhenBinPacking(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ a_very_long_function_name( long_argument_name_1=1, long_argument_name_2=2, @@ -2127,23 +2315,25 @@ def testNoSplittingWhenBinPacking(self): 'dedent_closing_brackets: True, ' 'split_before_named_assigns: False}')) - llines = yapf_test_helper.ParseAndUnwrap(code) + llines = yapf_test_helper.ParseAndUnwrap(code) reformatted_code = reformatter.Reformat(llines) self.assertCodeEqual(code, reformatted_code) - llines = yapf_test_helper.ParseAndUnwrap(reformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(reformatted_code) reformatted_code = reformatter.Reformat(llines) self.assertCodeEqual(code, reformatted_code) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testNotSplittingAfterSubscript(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ if not aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.b(c == d[ 'eeeeee']).ffffff(): pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ if not aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.b( c == d['eeeeee']).ffffff(): pass @@ -2152,7 +2342,8 @@ def testNotSplittingAfterSubscript(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testSplittingOneArgumentList(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def _(): if True: if True: @@ -2161,7 +2352,8 @@ def _(): if True: boxes[id_] = np.concatenate((points.min(axis=0), qoints.max(axis=0))) """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def _(): if True: if True: @@ -2175,7 +2367,8 @@ def _(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testSplittingBeforeFirstElementListArgument(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ class _(): @classmethod def _pack_results_for_constraint_or(cls, combination, constraints): @@ -2188,7 +2381,8 @@ def _pack_results_for_constraint_or(cls, combination, constraints): ), constraints, InvestigationResult.OR ) """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ class _(): @classmethod @@ -2204,7 +2398,8 @@ def _pack_results_for_constraint_or(cls, combination, constraints): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testSplittingArgumentsTerminatedByComma(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ function_name(argument_name_1=1, argument_name_2=2, argument_name_3=3) function_name(argument_name_1=1, argument_name_2=2, argument_name_3=3,) @@ -2215,7 +2410,8 @@ def testSplittingArgumentsTerminatedByComma(self): r =f0 (1, 2,3,) """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ function_name(argument_name_1=1, argument_name_2=2, argument_name_3=3) function_name( @@ -2250,18 +2446,19 @@ def testSplittingArgumentsTerminatedByComma(self): '{based_on_style: yapf, ' 'split_arguments_when_comma_terminated: True}')) - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) reformatted_code = reformatter.Reformat(llines) self.assertCodeEqual(expected_formatted_code, reformatted_code) - llines = yapf_test_helper.ParseAndUnwrap(reformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(reformatted_code) reformatted_code = reformatter.Reformat(llines) self.assertCodeEqual(expected_formatted_code, reformatted_code) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testImportAsList(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ from toto import titi, tata, tutu # noqa from toto import titi, tata, tutu from toto import (titi, tata, tutu) @@ -2270,7 +2467,8 @@ def testImportAsList(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testDictionaryValuesOnOwnLines(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ a = { 'aaaaaaaaaaaaaaaaaaaaaaaa': Check('ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ', '=', True), @@ -2294,7 +2492,8 @@ def testDictionaryValuesOnOwnLines(self): Check('QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ', '=', False), } """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ a = { 'aaaaaaaaaaaaaaaaaaaaaaaa': Check('ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ', '=', True), @@ -2322,27 +2521,31 @@ def testDictionaryValuesOnOwnLines(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testDictionaryOnOwnLine(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ doc = test_utils.CreateTestDocumentViaController( content={ 'a': 'b' }, branch_key=branch.key, collection_key=collection.key) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ doc = test_utils.CreateTestDocumentViaController( content={'a': 'b'}, branch_key=branch.key, collection_key=collection.key) """) # noqa llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ doc = test_utils.CreateTestDocumentViaController( content={ 'a': 'b' }, branch_key=branch.key, collection_key=collection.key, collection_key2=collection.key2) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ doc = test_utils.CreateTestDocumentViaController( content={'a': 'b'}, branch_key=branch.key, @@ -2353,7 +2556,8 @@ def testDictionaryOnOwnLine(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testNestedListsInDictionary(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ _A = { 'cccccccccc': ('^^1',), 'rrrrrrrrrrrrrrrrrrrrrrrrr': ('^7913', # AAAAAAAAAAAAAA. @@ -2382,7 +2586,8 @@ def testNestedListsInDictionary(self): ), } """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ _A = { 'cccccccccc': ('^^1',), 'rrrrrrrrrrrrrrrrrrrrrrrrr': ( @@ -2420,7 +2625,8 @@ def testNestedListsInDictionary(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testNestedDictionary(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ class _(): def _(): breadcrumbs = [{'name': 'Admin', @@ -2430,7 +2636,8 @@ def _(): 'url': url_for(".home")}, {'title': title}] """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ class _(): def _(): breadcrumbs = [ @@ -2448,7 +2655,8 @@ def _(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testDictionaryElementsOnOneLine(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ class _(): @mock.patch.dict( @@ -2468,10 +2676,12 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testNotInParams(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ list("a long line to break the line. a long line to break the brk a long lin", not True) """) # noqa - expected_code = textwrap.dedent("""\ + expected_code = textwrap.dedent( + """\ list("a long line to break the line. a long line to break the brk a long lin", not True) """) # noqa @@ -2479,14 +2689,16 @@ def testNotInParams(self): self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) def testNamedAssignNotAtEndOfLine(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def _(): if True: with py3compat.open_with_encoding(filename, mode='w', encoding=encoding) as fd: pass """) - expected_code = textwrap.dedent("""\ + expected_code = textwrap.dedent( + """\ def _(): if True: with py3compat.open_with_encoding( @@ -2497,7 +2709,8 @@ def _(): self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) def testBlankLineBeforeClassDocstring(self): - unformatted_code = textwrap.dedent('''\ + unformatted_code = textwrap.dedent( + '''\ class A: """Does something. @@ -2508,7 +2721,8 @@ class A: def __init__(self): pass ''') - expected_code = textwrap.dedent('''\ + expected_code = textwrap.dedent( + '''\ class A: """Does something. @@ -2521,7 +2735,8 @@ def __init__(self): llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent('''\ + unformatted_code = textwrap.dedent( + '''\ class A: """Does something. @@ -2532,7 +2747,8 @@ class A: def __init__(self): pass ''') - expected_formatted_code = textwrap.dedent('''\ + expected_formatted_code = textwrap.dedent( + '''\ class A: """Does something. @@ -2551,13 +2767,14 @@ def __init__(self): 'blank_line_before_class_docstring: True}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testBlankLineBeforeModuleDocstring(self): - unformatted_code = textwrap.dedent('''\ + unformatted_code = textwrap.dedent( + '''\ #!/usr/bin/env python # -*- coding: utf-8 name> -*- @@ -2567,7 +2784,8 @@ def testBlankLineBeforeModuleDocstring(self): def foobar(): pass ''') - expected_code = textwrap.dedent('''\ + expected_code = textwrap.dedent( + '''\ #!/usr/bin/env python # -*- coding: utf-8 name> -*- """Some module docstring.""" @@ -2579,7 +2797,8 @@ def foobar(): llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent('''\ + unformatted_code = textwrap.dedent( + '''\ #!/usr/bin/env python # -*- coding: utf-8 name> -*- """Some module docstring.""" @@ -2588,7 +2807,8 @@ def foobar(): def foobar(): pass ''') - expected_formatted_code = textwrap.dedent('''\ + expected_formatted_code = textwrap.dedent( + '''\ #!/usr/bin/env python # -*- coding: utf-8 name> -*- @@ -2606,18 +2826,20 @@ def foobar(): 'blank_line_before_module_docstring: True}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testTupleCohesion(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def f(): this_is_a_very_long_function_name(an_extremely_long_variable_name, ( 'a string that may be too long %s' % 'M15')) """) - expected_code = textwrap.dedent("""\ + expected_code = textwrap.dedent( + """\ def f(): this_is_a_very_long_function_name( an_extremely_long_variable_name, @@ -2627,14 +2849,15 @@ def f(): self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) def testSubscriptExpression(self): - code = textwrap.dedent("""\ + code = textwrap.dedent("""\ foo = d[not a] """) llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) def testListWithFunctionCalls(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def foo(): return [ Bar( @@ -2646,7 +2869,8 @@ def foo(): zzz='a third long string') ] """) - expected_code = textwrap.dedent("""\ + expected_code = textwrap.dedent( + """\ def foo(): return [ Bar(xxx='some string', @@ -2661,11 +2885,13 @@ def foo(): self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) def testEllipses(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ X=... Y = X if ... else X """) - expected_code = textwrap.dedent("""\ + expected_code = textwrap.dedent( + """\ X = ... Y = X if ... else X """) @@ -2679,7 +2905,7 @@ def testPseudoParens(self): {'nested_key': 1, }, } """ - expected_code = """\ + expected_code = """\ my_dict = { 'key': # Some comment about the key { @@ -2687,16 +2913,18 @@ def testPseudoParens(self): }, } """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) def testSplittingBeforeFirstArgumentOnFunctionCall(self): """Tests split_before_first_argument on a function call.""" - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ a_very_long_function_name("long string with formatting {0:s}".format( "mystring")) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ a_very_long_function_name( "long string with formatting {0:s}".format("mystring")) """) @@ -2707,19 +2935,21 @@ def testSplittingBeforeFirstArgumentOnFunctionCall(self): '{based_on_style: yapf, split_before_first_argument: True}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testSplittingBeforeFirstArgumentOnFunctionDefinition(self): """Tests split_before_first_argument on a function definition.""" - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def _GetNumberOfSecondsFromElements(year, month, day, hours, minutes, seconds, microseconds): return """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def _GetNumberOfSecondsFromElements( year, month, day, hours, minutes, seconds, microseconds): return @@ -2731,21 +2961,23 @@ def _GetNumberOfSecondsFromElements( '{based_on_style: yapf, split_before_first_argument: True}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testSplittingBeforeFirstArgumentOnCompoundStatement(self): """Tests split_before_first_argument on a compound statement.""" - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ if (long_argument_name_1 == 1 or long_argument_name_2 == 2 or long_argument_name_3 == 3 or long_argument_name_4 == 4): pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ if (long_argument_name_1 == 1 or long_argument_name_2 == 2 or long_argument_name_3 == 3 or long_argument_name_4 == 4): pass @@ -2757,14 +2989,15 @@ def testSplittingBeforeFirstArgumentOnCompoundStatement(self): '{based_on_style: yapf, split_before_first_argument: True}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testCoalesceBracketsOnDict(self): """Tests coalesce_brackets on a dictionary.""" - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ date_time_values = ( { u'year': year, @@ -2776,7 +3009,8 @@ def testCoalesceBracketsOnDict(self): } ) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ date_time_values = ({ u'year': year, u'month': month, @@ -2793,13 +3027,14 @@ def testCoalesceBracketsOnDict(self): '{based_on_style: yapf, coalesce_brackets: True}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testSplitAfterComment(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ if __name__ == "__main__": with another_resource: account = { @@ -2824,7 +3059,8 @@ def testAsyncAsNonKeyword(self): style.SetGlobalStyle(style.CreatePEP8Style()) # In Python 2, async may be used as a non-keyword identifier. - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ from util import async @@ -2846,8 +3082,9 @@ def testDisableEndingCommaHeuristic(self): try: style.SetGlobalStyle( - style.CreateStyleFromConfig('{based_on_style: yapf,' - ' disable_ending_comma_heuristic: True}')) + style.CreateStyleFromConfig( + '{based_on_style: yapf,' + ' disable_ending_comma_heuristic: True}')) llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) @@ -2855,7 +3092,8 @@ def testDisableEndingCommaHeuristic(self): style.SetGlobalStyle(style.CreateYapfStyle()) def testDedentClosingBracketsWithTypeAnnotationExceedingLineLength(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def function(first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None) -> None: pass @@ -2863,7 +3101,8 @@ def function(first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None) -> None def function(first_argument_xxxxxxxxxxxxxxxxxxxxxxx=(0,), second_argument=None) -> None: pass """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def function( first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None ) -> None: @@ -2878,17 +3117,19 @@ def function( try: style.SetGlobalStyle( - style.CreateStyleFromConfig('{based_on_style: yapf,' - ' dedent_closing_brackets: True}')) + style.CreateStyleFromConfig( + '{based_on_style: yapf,' + ' dedent_closing_brackets: True}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testIndentClosingBracketsWithTypeAnnotationExceedingLineLength(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def function(first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None) -> None: pass @@ -2896,7 +3137,8 @@ def function(first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None) -> None def function(first_argument_xxxxxxxxxxxxxxxxxxxxxxx=(0,), second_argument=None) -> None: pass """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def function( first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None ) -> None: @@ -2911,17 +3153,19 @@ def function( try: style.SetGlobalStyle( - style.CreateStyleFromConfig('{based_on_style: yapf,' - ' indent_closing_brackets: True}')) + style.CreateStyleFromConfig( + '{based_on_style: yapf,' + ' indent_closing_brackets: True}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testIndentClosingBracketsInFunctionCall(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def function(first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None, third_and_final_argument=True): pass @@ -2929,7 +3173,8 @@ def function(first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None, third_a def function(first_argument_xxxxxxxxxxxxxxxxxxxxxxx=(0,), second_and_last_argument=None): pass """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def function( first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None, @@ -2946,17 +3191,19 @@ def function( try: style.SetGlobalStyle( - style.CreateStyleFromConfig('{based_on_style: yapf,' - ' indent_closing_brackets: True}')) + style.CreateStyleFromConfig( + '{based_on_style: yapf,' + ' indent_closing_brackets: True}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testIndentClosingBracketsInTuple(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def function(): some_var = ('a long element', 'another long element', 'short element', 'really really long element') return True @@ -2965,7 +3212,8 @@ def function(): some_var = ('a couple', 'small', 'elemens') return False """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def function(): some_var = ( 'a long element', 'another long element', 'short element', @@ -2981,17 +3229,19 @@ def function(): try: style.SetGlobalStyle( - style.CreateStyleFromConfig('{based_on_style: yapf,' - ' indent_closing_brackets: True}')) + style.CreateStyleFromConfig( + '{based_on_style: yapf,' + ' indent_closing_brackets: True}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testIndentClosingBracketsInList(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def function(): some_var = ['a long element', 'another long element', 'short element', 'really really long element'] return True @@ -3000,7 +3250,8 @@ def function(): some_var = ['a couple', 'small', 'elemens'] return False """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def function(): some_var = [ 'a long element', 'another long element', 'short element', @@ -3016,17 +3267,19 @@ def function(): try: style.SetGlobalStyle( - style.CreateStyleFromConfig('{based_on_style: yapf,' - ' indent_closing_brackets: True}')) + style.CreateStyleFromConfig( + '{based_on_style: yapf,' + ' indent_closing_brackets: True}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testIndentClosingBracketsInDict(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def function(): some_var = {1: ('a long element', 'and another really really long element that is really really amazingly long'), 2: 'another long element', 3: 'short element', 4: 'really really long element'} return True @@ -3035,7 +3288,8 @@ def function(): some_var = {1: 'a couple', 2: 'small', 3: 'elemens'} return False """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def function(): some_var = { 1: @@ -3057,17 +3311,19 @@ def function(): try: style.SetGlobalStyle( - style.CreateStyleFromConfig('{based_on_style: yapf,' - ' indent_closing_brackets: True}')) + style.CreateStyleFromConfig( + '{based_on_style: yapf,' + ' indent_closing_brackets: True}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testMultipleDictionariesInList(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ class A: def b(): d = { @@ -3093,7 +3349,8 @@ def b(): ] } """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ class A: def b(): @@ -3125,9 +3382,10 @@ def testForceMultilineDict_True(self): style.CreateStyleFromConfig('{force_multiline_dict: true}')) unformatted_code = textwrap.dedent( "responseDict = {'childDict': {'spam': 'eggs'}}\n") - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - actual = reformatter.Reformat(llines) - expected = textwrap.dedent("""\ + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + actual = reformatter.Reformat(llines) + expected = textwrap.dedent( + """\ responseDict = { 'childDict': { 'spam': 'eggs' @@ -3142,23 +3400,26 @@ def testForceMultilineDict_False(self): try: style.SetGlobalStyle( style.CreateStyleFromConfig('{force_multiline_dict: false}')) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ responseDict = {'childDict': {'spam': 'eggs'}} """) expected_formatted_code = unformatted_code - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) @unittest.skipUnless(py3compat.PY38, 'Requires Python 3.8') def testWalrus(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ if (x := len([1]*1000)>100): print(f'{x} is pretty big' ) """) - expected = textwrap.dedent("""\ + expected = textwrap.dedent( + """\ if (x := len([1] * 1000) > 100): print(f'{x} is pretty big') """) @@ -3170,44 +3431,49 @@ def testAlignAssignBlankLineInbetween(self): try: style.SetGlobalStyle( style.CreateStyleFromConfig('{align_assignment: true}')) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ val_first = 1 val_second += 2 val_third = 3 """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ val_first = 1 val_second += 2 val_third = 3 """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testAlignAssignCommentLineInbetween(self): try: style.SetGlobalStyle( - style.CreateStyleFromConfig('{align_assignment: true,' - 'new_alignment_after_commentline = true}')) - unformatted_code = textwrap.dedent("""\ + style.CreateStyleFromConfig( + '{align_assignment: true,' + 'new_alignment_after_commentline = true}')) + unformatted_code = textwrap.dedent( + """\ val_first = 1 val_second += 2 # comment val_third = 3 """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ val_first = 1 val_second += 2 # comment val_third = 3 """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) @@ -3215,7 +3481,8 @@ def testAlignAssignDefLineInbetween(self): try: style.SetGlobalStyle( style.CreateStyleFromConfig('{align_assignment: true}')) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ val_first = 1 val_second += 2 def fun(): @@ -3223,7 +3490,8 @@ def fun(): abc = '' val_third = 3 """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ val_first = 1 val_second += 2 @@ -3236,8 +3504,8 @@ def fun(): val_third = 3 """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) @@ -3245,7 +3513,8 @@ def testAlignAssignObjectWithNewLineInbetween(self): try: style.SetGlobalStyle( style.CreateStyleFromConfig('{align_assignment: true}')) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ val_first = 1 val_second += 2 object = { @@ -3255,7 +3524,8 @@ def testAlignAssignObjectWithNewLineInbetween(self): } val_third = 3 """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ val_first = 1 val_second += 2 object = { @@ -3266,8 +3536,8 @@ def testAlignAssignObjectWithNewLineInbetween(self): val_third = 3 """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) @@ -3275,23 +3545,26 @@ def testAlignAssignWithOnlyOneAssignmentLine(self): try: style.SetGlobalStyle( style.CreateStyleFromConfig('{align_assignment: true}')) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent("""\ val_first = 1 """) expected_formatted_code = unformatted_code - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) - ########## for Align_ArgAssign()########### +########## for Align_ArgAssign()########### + def testAlignArgAssignTypedName(self): try: style.SetGlobalStyle( - style.CreateStyleFromConfig('{align_argument_assignment: true,' - 'split_before_first_argument: true}')) - unformatted_code = textwrap.dedent("""\ + style.CreateStyleFromConfig( + '{align_argument_assignment: true,' + 'split_before_first_argument: true}')) + unformatted_code = textwrap.dedent( + """\ def f1( self, *, @@ -3304,7 +3577,8 @@ def f1( ini_section: str="" ): pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def f1( self, *, @@ -3318,8 +3592,8 @@ def f1( pass """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) @@ -3329,7 +3603,8 @@ def testAlignArgAssignNestedArglistInBetween(self): try: style.SetGlobalStyle( style.CreateStyleFromConfig('{align_argument_assignment: true}')) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ arglist = test( first_argument='', second_argument=fun( @@ -3339,7 +3614,8 @@ def testAlignArgAssignNestedArglistInBetween(self): fourth_argument=4 ) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ arglist = test( first_argument ='', second_argument =fun( @@ -3352,8 +3628,8 @@ def testAlignArgAssignNestedArglistInBetween(self): fourth_argument =4) """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) @@ -3361,9 +3637,11 @@ def testAlignArgAssignNestedArglistInBetween(self): def testAlignArgAssignCommentLineInBetween(self): try: style.SetGlobalStyle( - style.CreateStyleFromConfig('{align_argument_assignment: true,' - 'new_alignment_after_commentline:true}')) - unformatted_code = textwrap.dedent("""\ + style.CreateStyleFromConfig( + '{align_argument_assignment: true,' + 'new_alignment_after_commentline:true}')) + unformatted_code = textwrap.dedent( + """\ arglist = test( client_id=0, username_id=1, @@ -3371,7 +3649,8 @@ def testAlignArgAssignCommentLineInBetween(self): user_name='xxxxxxxxxxxxxxxxxxxxx' ) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ arglist = test( client_id =0, username_id =1, @@ -3379,8 +3658,8 @@ def testAlignArgAssignCommentLineInBetween(self): user_name ='xxxxxxxxxxxxxxxxxxxxx') """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) @@ -3388,14 +3667,15 @@ def testAlignArgAssignWithOnlyFirstArgOnNewline(self): try: style.SetGlobalStyle( style.CreateStyleFromConfig('{align_argument_assignment: true}')) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ arglist = self.get_data_from_excelsheet( client_id=0, username_id=1, user_name='xxxxxxxxxxxxxxxxxxxx') """) expected_formatted_code = unformatted_code - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) @@ -3403,20 +3683,22 @@ def testAlignArgAssignArgumentsCanFitInOneLine(self): try: style.SetGlobalStyle( style.CreateStyleFromConfig('{align_argument_assignment: true}')) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def function( first_argument_xxxxxx =(0,), second_argument =None ) -> None: pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def function(first_argument_xxxxxx=(0,), second_argument=None) -> None: pass """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) @@ -3425,11 +3707,13 @@ def testAlignDictColonNestedDictInBetween(self): try: style.SetGlobalStyle( style.CreateStyleFromConfig('{align_dict_colon: true}')) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ fields = [{"type": "text","required": True,"html": {"attr": 'style="width: 250px;" maxlength="30"',"page": 0,}, "list" : [1, 2, 3, 4]}] """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ fields = [{ "type" : "text", "required" : True, @@ -3441,24 +3725,27 @@ def testAlignDictColonNestedDictInBetween(self): }] """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testAlignDictColonCommentLineInBetween(self): try: style.SetGlobalStyle( - style.CreateStyleFromConfig('{align_dict_colon: true,' - 'new_alignment_after_commentline: true}')) - unformatted_code = textwrap.dedent("""\ + style.CreateStyleFromConfig( + '{align_dict_colon: true,' + 'new_alignment_after_commentline: true}')) + unformatted_code = textwrap.dedent( + """\ fields = [{ "type": "text", "required": True, # comment "list": [1, 2, 3, 4]}] """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ fields = [{ "type" : "text", "required" : True, @@ -3467,8 +3754,8 @@ def testAlignDictColonCommentLineInBetween(self): }] """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) @@ -3476,14 +3763,16 @@ def testAlignDictColonLargerExistingSpacesBefore(self): try: style.SetGlobalStyle( style.CreateStyleFromConfig('{align_dict_colon: true}')) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ fields = [{ "type" : "text", "required" : True, "list" : [1, 2, 3, 4], }] """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ fields = [{ "type" : "text", "required" : True, @@ -3491,8 +3780,8 @@ def testAlignDictColonLargerExistingSpacesBefore(self): }] """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) @@ -3500,14 +3789,16 @@ def testAlignDictColonCommentAfterOpenBracket(self): try: style.SetGlobalStyle( style.CreateStyleFromConfig('{align_dict_colon: true}')) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ fields = [{ # comment "type": "text", "required": True, "list": [1, 2, 3, 4]}] """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ fields = [{ # comment "type" : "text", @@ -3516,13 +3807,10 @@ def testAlignDictColonCommentAfterOpenBracket(self): }] """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) - - - if __name__ == '__main__': unittest.main() diff --git a/yapftests/reformatter_buganizer_test.py b/yapftests/reformatter_buganizer_test.py index 54a62b588..d8beb04cb 100644 --- a/yapftests/reformatter_buganizer_test.py +++ b/yapftests/reformatter_buganizer_test.py @@ -29,7 +29,7 @@ def setUpClass(cls): style.SetGlobalStyle(style.CreateYapfStyle()) def testB137580392(self): - code = """\ + code = """\ def _create_testing_simulator_and_sink( ) -> Tuple[_batch_simulator:_batch_simulator.BatchSimulator, _batch_simulator.SimulationSink]: @@ -39,7 +39,7 @@ def _create_testing_simulator_and_sink( self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB73279849(self): - unformatted_code = """\ + unformatted_code = """\ class A: def _(a): return 'hello' [ a ] @@ -49,11 +49,11 @@ class A: def _(a): return 'hello'[a] """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB122455211(self): - unformatted_code = """\ + unformatted_code = """\ _zzzzzzzzzzzzzzzzzzzz = Union[sssssssssssssssssssss.pppppppppppppppp, sssssssssssssssssssss.pppppppppppppppppppppppppppp] """ @@ -62,11 +62,11 @@ def testB122455211(self): sssssssssssssssssssss.pppppppppppppppp, sssssssssssssssssssss.pppppppppppppppppppppppppppp] """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB119300344(self): - code = """\ + code = """\ def _GenerateStatsEntries( process_id: Text, timestamp: Optional[rdfvalue.RDFDatetime] = None @@ -77,7 +77,7 @@ def _GenerateStatsEntries( self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB132886019(self): - code = """\ + code = """\ X = { 'some_dict_key': frozenset([ @@ -90,7 +90,7 @@ def testB132886019(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB26521719(self): - code = """\ + code = """\ class _(): def _(self): @@ -101,7 +101,7 @@ def _(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB122541552(self): - code = """\ + code = """\ # pylint: disable=g-explicit-bool-comparison,singleton-comparison _QUERY = account.Account.query(account.Account.enabled == True) # pylint: enable=g-explicit-bool-comparison,singleton-comparison @@ -114,7 +114,7 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB124415889(self): - code = """\ + code = """\ class _(): def run_queue_scanners(): @@ -137,7 +137,7 @@ def modules_to_install(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB73166511(self): - code = """\ + code = """\ def _(): if min_std is not None: groundtruth_age_variances = tf.maximum(groundtruth_age_variances, @@ -147,7 +147,7 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB118624921(self): - code = """\ + code = """\ def _(): function_call( alert_name='xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx', @@ -160,7 +160,7 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB35417079(self): - code = """\ + code = """\ class _(): def _(): @@ -175,7 +175,7 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB120047670(self): - unformatted_code = """\ + unformatted_code = """\ X = { 'NO_PING_COMPONENTS': [ 79775, # Releases / FOO API @@ -195,11 +195,11 @@ def testB120047670(self): 'PING_BLOCKED_BUGS': False, } """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB120245013(self): - unformatted_code = """\ + unformatted_code = """\ class Foo(object): def testNoAlertForShortPeriod(self, rutabaga): self.targets[:][streamz_path,self._fillInOtherFields(streamz_path, {streamz_field_of_interest:True})] = series.Counter('1s', '+ 500x10000') @@ -213,11 +213,11 @@ def testNoAlertForShortPeriod(self, rutabaga): self._fillInOtherFields(streamz_path, {streamz_field_of_interest: True} )] = series.Counter('1s', '+ 500x10000') """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB117841880(self): - code = """\ + code = """\ def xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( aaaaaaaaaaaaaaaaaaa: AnyStr, bbbbbbbbbbbb: Optional[Sequence[AnyStr]] = None, @@ -234,7 +234,7 @@ def xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB111764402(self): - unformatted_code = """\ + unformatted_code = """\ x = self.stubs.stub(video_classification_map, 'read_video_classifications', (lambda external_ids, **unused_kwargs: {external_id: self._get_serving_classification('video') for external_id in external_ids})) """ # noqa expected_formatted_code = """\ @@ -244,11 +244,11 @@ def testB111764402(self): for external_id in external_ids })) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB116825060(self): - code = """\ + code = """\ result_df = pd.DataFrame({LEARNED_CTR_COLUMN: learned_ctr}, index=df_metrics.index) """ @@ -256,7 +256,7 @@ def testB116825060(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB112711217(self): - code = """\ + code = """\ def _(): stats['moderated'] = ~stats.moderation_reason.isin( approved_moderation_reasons) @@ -265,7 +265,7 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB112867548(self): - unformatted_code = """\ + unformatted_code = """\ def _(): return flask.make_response( 'Records: {}, Problems: {}, More: {}'.format( @@ -283,11 +283,11 @@ def _(): httplib.ACCEPTED if process_result.has_more else httplib.OK, {'content-type': _TEXT_CONTEXT_TYPE}) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB112651423(self): - unformatted_code = """\ + unformatted_code = """\ def potato(feeditems, browse_use_case=None): for item in turnip: if kumquat: @@ -302,11 +302,11 @@ def potato(feeditems, browse_use_case=None): 'FEEDS_LOAD_PLAYLIST_VIDEOS_FOR_ALL_ITEMS'] and item.video: continue """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB80484938(self): - code = """\ + code = """\ for sssssss, aaaaaaaaaa in [ ('ssssssssssssssssssss', 'sssssssssssssssssssssssss'), ('nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn', @@ -349,7 +349,7 @@ def testB80484938(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB120771563(self): - code = """\ + code = """\ class A: def b(): @@ -376,7 +376,7 @@ def b(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB79462249(self): - code = """\ + code = """\ foo.bar(baz, [ quux(thud=42), norf, @@ -398,7 +398,7 @@ def testB79462249(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB113210278(self): - unformatted_code = """\ + unformatted_code = """\ def _(): aaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb.cccccccccccccccccccccccccccc(\ eeeeeeeeeeeeeeeeeeeeeeeeee.fffffffffffffffffffffffffffffffffffffff.\ @@ -410,11 +410,11 @@ def _(): eeeeeeeeeeeeeeeeeeeeeeeeee.fffffffffffffffffffffffffffffffffffffff .ggggggggggggggggggggggggggggggggg.hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh()) """ # noqa - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB77923341(self): - code = """\ + code = """\ def f(): if (aaaaaaaaaaaaaa.bbbbbbbbbbbb.ccccc <= 0 and # pytype: disable=attribute-error ddddddddddd.eeeeeeeee == constants.FFFFFFFFFFFFFF): @@ -424,7 +424,7 @@ def f(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB77329955(self): - code = """\ + code = """\ class _(): @parameterized.named_parameters( @@ -442,7 +442,7 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB65197969(self): - unformatted_code = """\ + unformatted_code = """\ class _(): def _(): @@ -457,11 +457,11 @@ def _(): seconds=max(float(time_scale), small_interval) * 1.41**min(num_attempts, 9)) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB65546221(self): - unformatted_code = """\ + unformatted_code = """\ SUPPORTED_PLATFORMS = ( "centos-6", "centos-7", @@ -484,11 +484,11 @@ def testB65546221(self): "debian-9-stretch", ) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB30500455(self): - unformatted_code = """\ + unformatted_code = """\ INITIAL_SYMTAB = dict([(name, 'exception#' + name) for name in INITIAL_EXCEPTIONS ] * [(name, 'type#' + name) for name in INITIAL_TYPES] + [ (name, 'function#' + name) for name in INITIAL_FUNCTIONS @@ -501,11 +501,11 @@ def testB30500455(self): [(name, 'function#' + name) for name in INITIAL_FUNCTIONS] + [(name, 'const#' + name) for name in INITIAL_CONSTS]) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB38343525(self): - code = """\ + code = """\ # This does foo. @arg.String('some_path_to_a_file', required=True) # This does bar. @@ -517,7 +517,7 @@ def f(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB37099651(self): - unformatted_code = """\ + unformatted_code = """\ _MEMCACHE = lazy.MakeLazy( # pylint: disable=g-long-lambda lambda: function.call.mem.clients(FLAGS.some_flag_thingy, default_namespace=_LAZY_MEM_NAMESPACE, allow_pickle=True) @@ -534,11 +534,11 @@ def testB37099651(self): # pylint: enable=g-long-lambda ) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB33228502(self): - unformatted_code = """\ + unformatted_code = """\ def _(): success_rate_stream_table = module.Precompute( query_function=module.DefineQueryFunction( @@ -572,11 +572,11 @@ def _(): | m.Join('successes', 'total') | m.Point(m.VAL['successes'] / m.VAL['total'])))) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB30394228(self): - code = """\ + code = """\ class _(): def _(self): @@ -589,7 +589,7 @@ def _(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB65246454(self): - unformatted_code = """\ + unformatted_code = """\ class _(): def _(self): @@ -605,11 +605,11 @@ def _(self): self.assertEqual({i.id for i in successful_instances}, {i.id for i in self._statuses.successful_instances}) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB67935450(self): - unformatted_code = """\ + unformatted_code = """\ def _(): return ( (Gauge( @@ -646,11 +646,11 @@ def _(): m.Cond(m.VAL['start'] != 0, m.VAL['start'], m.TimestampMicros() / 1000000L))) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB66011084(self): - unformatted_code = """\ + unformatted_code = """\ X = { "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa": # Comment 1. ([] if True else [ # Comment 2. @@ -678,22 +678,22 @@ def testB66011084(self): ]), } """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB67455376(self): - unformatted_code = """\ + unformatted_code = """\ sponge_ids.extend(invocation.id() for invocation in self._client.GetInvocationsByLabels(labels)) """ # noqa expected_formatted_code = """\ sponge_ids.extend(invocation.id() for invocation in self._client.GetInvocationsByLabels(labels)) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB35210351(self): - unformatted_code = """\ + unformatted_code = """\ def _(): config.AnotherRuleThing( 'the_title_to_the_thing_here', @@ -719,11 +719,11 @@ def _(): GetTheAlertToIt('the_title_to_the_thing_here'), GetNotificationTemplate('your_email_here'))) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB34774905(self): - unformatted_code = """\ + unformatted_code = """\ x=[VarExprType(ir_name=IrName( value='x', expr_type=UnresolvedAttrExprType( atom=UnknownExprType(), attr_name=IrName( value='x', expr_type=UnknownExprType(), usage='UNKNOWN', fqn=None, @@ -748,18 +748,18 @@ def testB34774905(self): astn=None)) ] """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB65176185(self): - code = """\ + code = """\ xx = zip(*[(a, b) for (a, b, c) in yy]) """ llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB35210166(self): - unformatted_code = """\ + unformatted_code = """\ def _(): query = ( m.Fetch(n.Raw('monarch.BorgTask', '/proc/container/memory/usage'), { 'borg_user': borguser, 'borg_job': jobname }) @@ -776,11 +776,11 @@ def _(): | o.Window(m.Align('5m')) | p.GroupBy(['borg_user', 'borg_job', 'borg_cell'], q.Mean())) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB32167774(self): - unformatted_code = """\ + unformatted_code = """\ X = ( 'is_official', 'is_cover', @@ -803,11 +803,11 @@ def testB32167774(self): 'is_compilation', ) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB66912275(self): - unformatted_code = """\ + unformatted_code = """\ def _(): with self.assertRaisesRegexp(errors.HttpError, 'Invalid'): patch_op = api_client.forwardingRules().patch( @@ -827,11 +827,11 @@ def _(): 'fingerprint': base64.urlsafe_b64encode('invalid_fingerprint') }).execute() """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB67312284(self): - code = """\ + code = """\ def _(): self.assertEqual( [u'to be published 2', u'to be published 1', u'to be published 0'], @@ -841,7 +841,7 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB65241516(self): - unformatted_code = """\ + unformatted_code = """\ checkpoint_files = gfile.Glob(os.path.join(TrainTraceDir(unit_key, "*", "*"), embedding_model.CHECKPOINT_FILENAME + "-*")) """ # noqa expected_formatted_code = """\ @@ -850,11 +850,12 @@ def testB65241516(self): TrainTraceDir(unit_key, "*", "*"), embedding_model.CHECKPOINT_FILENAME + "-*")) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB37460004(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ assert all(s not in (_SENTINEL, None) for s in nested_schemas ), 'Nested schemas should never contain None/_SENTINEL' """) @@ -862,7 +863,7 @@ def testB37460004(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB36806207(self): - code = """\ + code = """\ def _(): linearity_data = [[row] for row in [ "%.1f mm" % (np.mean(linearity_values["pos_error"]) * 1000.0), @@ -881,7 +882,8 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB36215507(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ class X(): def _(): @@ -895,7 +897,8 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB35212469(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def _(): X = { 'retain': { @@ -904,7 +907,8 @@ def _(): } } """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def _(): X = { 'retain': { @@ -917,12 +921,14 @@ def _(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB31063453(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def _(): while ((not mpede_proc) or ((time_time() - last_modified) < FLAGS_boot_idle_timeout)): pass """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def _(): while ((not mpede_proc) or ((time_time() - last_modified) < FLAGS_boot_idle_timeout)): @@ -932,7 +938,8 @@ def _(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB35021894(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def _(): labelacl = Env(qa={ 'read': 'name/some-type-of-very-long-name-for-reading-perms', @@ -943,7 +950,8 @@ def _(): 'modify': 'name/some-other-type-of-very-long-name-for-modifying' }) """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def _(): labelacl = Env( qa={ @@ -959,10 +967,12 @@ def _(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB34682902(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ logging.info("Mean angular velocity norm: %.3f", np.linalg.norm(np.mean(ang_vel_arr, axis=0))) """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ logging.info("Mean angular velocity norm: %.3f", np.linalg.norm(np.mean(ang_vel_arr, axis=0))) """) @@ -970,13 +980,15 @@ def testB34682902(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB33842726(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ class _(): def _(): hints.append(('hg tag -f -l -r %s %s # %s' % (short(ctx.node( )), candidatetag, firstline))[:78]) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ class _(): def _(): hints.append(('hg tag -f -l -r %s %s # %s' % @@ -986,7 +998,8 @@ def _(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB32931780(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ environments = { 'prod': { # this is a comment before the first entry. @@ -1017,7 +1030,8 @@ def testB32931780(self): } } """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ environments = { 'prod': { # this is a comment before the first entry. @@ -1048,7 +1062,8 @@ def testB32931780(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB33047408(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ def _(): for sort in (sorts or []): request['sorts'].append({ @@ -1062,7 +1077,8 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB32714745(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ class _(): def _BlankDefinition(): @@ -1092,14 +1108,16 @@ def _BlankDefinition(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB32737279(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ here_is_a_dict = { 'key': # Comment. 'value' } """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ here_is_a_dict = { 'key': # Comment. 'value' @@ -1109,7 +1127,8 @@ def testB32737279(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB32570937(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ def _(): if (job_message.ball not in ('*', ball) or job_message.call not in ('*', call) or @@ -1120,7 +1139,8 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB31937033(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ class _(): def __init__(self, metric, fields_cb=None): @@ -1130,7 +1150,7 @@ def __init__(self, metric, fields_cb=None): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB31911533(self): - code = """\ + code = """\ class _(): @parameterized.NamedParameters( @@ -1146,7 +1166,8 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB31847238(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ class _(): def aaaaa(self, bbbbb, cccccccccccccc=None): # TODO(who): pylint: disable=unused-argument @@ -1155,7 +1176,8 @@ def aaaaa(self, bbbbb, cccccccccccccc=None): # TODO(who): pylint: disable=unuse def xxxxx(self, yyyyy, zzzzzzzzzzzzzz=None): # A normal comment that runs over the column limit. return 1 """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ class _(): def aaaaa(self, bbbbb, cccccccccccccc=None): # TODO(who): pylint: disable=unused-argument @@ -1171,11 +1193,13 @@ def xxxxx( self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB30760569(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ {'1234567890123456789012345678901234567890123456789012345678901234567890': '1234567890123456789012345678901234567890'} """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ { '1234567890123456789012345678901234567890123456789012345678901234567890': '1234567890123456789012345678901234567890' @@ -1185,13 +1209,15 @@ def testB30760569(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB26034238(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ class Thing: def Function(self): thing.Scrape('/aaaaaaaaa/bbbbbbbbbb/ccccc/dddd/eeeeeeeeeeeeee/ffffffffffffff').AndReturn(42) """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ class Thing: def Function(self): @@ -1203,7 +1229,8 @@ def Function(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB30536435(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def main(unused_argv): if True: if True: @@ -1212,7 +1239,8 @@ def main(unused_argv): ccccccccc.within, imports.ddddddddddddddddddd(name_item.ffffffffffffffff))) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def main(unused_argv): if True: if True: @@ -1224,12 +1252,14 @@ def main(unused_argv): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB30442148(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def lulz(): return (some_long_module_name.SomeLongClassName. some_long_attribute_name.some_long_method_name()) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def lulz(): return (some_long_module_name.SomeLongClassName.some_long_attribute_name .some_long_method_name()) @@ -1238,7 +1268,8 @@ def lulz(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB26868213(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def _(): xxxxxxxxxxxxxxxxxxx = { 'ssssss': {'ddddd': 'qqqqq', @@ -1253,7 +1284,8 @@ def _(): } } """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def _(): xxxxxxxxxxxxxxxxxxx = { 'ssssss': { @@ -1274,7 +1306,8 @@ def _(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB30173198(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ class _(): def _(): @@ -1285,7 +1318,8 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB29908765(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ class _(): def __repr__(self): @@ -1296,7 +1330,8 @@ def __repr__(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB30087362(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ def _(): for s in sorted(env['foo']): bar() @@ -1309,7 +1344,8 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB30087363(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ if False: bar() # This is a comment @@ -1321,12 +1357,14 @@ def testB30087363(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB29093579(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def _(): _xxxxxxxxxxxxxxx(aaaaaaaa, bbbbbbbbbbbbbb.cccccccccc[ dddddddddddddddddddddddddddd.eeeeeeeeeeeeeeeeeeeeee.fffffffffffffffffffff]) """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def _(): _xxxxxxxxxxxxxxx( aaaaaaaa, @@ -1337,7 +1375,8 @@ def _(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB26382315(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ @hello_world # This is a first comment @@ -1349,7 +1388,8 @@ def foo(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB27616132(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ if True: query.fetch_page.assert_has_calls([ mock.call(100, @@ -1360,7 +1400,8 @@ def testB27616132(self): start_cursor=cursor_2), ]) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ if True: query.fetch_page.assert_has_calls([ mock.call(100, start_cursor=None), @@ -1372,7 +1413,8 @@ def testB27616132(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB27590179(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ if True: if True: self.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = ( @@ -1382,7 +1424,8 @@ def testB27590179(self): self.bbb.cccccccccc(ddddddddddddddddddddddd.eeeeeeeeeeeeeeeeeeeeee) }) """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ if True: if True: self.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = ({ @@ -1396,11 +1439,13 @@ def testB27590179(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB27266946(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def _(): aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = (self.bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb.cccccccccccccccccccccccccccccccccccc) """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def _(): aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = ( self.bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb @@ -1410,7 +1455,8 @@ def _(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB25505359(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ _EXAMPLE = { 'aaaaaaaaaaaaaa': [{ 'bbbb': 'cccccccccccccccccccccc', @@ -1425,7 +1471,8 @@ def testB25505359(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB25324261(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ aaaaaaaaa = set(bbbb.cccc for ddd in eeeeee.fffffffffff.gggggggggggggggg for cccc in ddd.specification) @@ -1434,7 +1481,8 @@ def testB25324261(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB25136704(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ class f: def test(self): @@ -1446,7 +1494,8 @@ def test(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB25165602(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ def f(): ids = {u: i for u, i in zip(self.aaaaa, xrange(42, 42 + len(self.aaaaaa)))} """) # noqa @@ -1454,7 +1503,8 @@ def f(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB25157123(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ def ListArgs(): FairlyLongMethodName([relatively_long_identifier_for_a_list], another_argument_with_a_long_identifier) @@ -1463,7 +1513,8 @@ def ListArgs(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB25136820(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def foo(): return collections.OrderedDict({ # Preceding comment. @@ -1471,7 +1522,8 @@ def foo(): '$bbbbbbbbbbbbbbbbbbbbbbbb', }) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def foo(): return collections.OrderedDict({ # Preceding comment. @@ -1483,13 +1535,15 @@ def foo(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB25131481(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ APPARENT_ACTIONS = ('command_type', { 'materialize': lambda x: some_type_of_function('materialize ' + x.command_def), '#': lambda x: x # do nothing }) """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ APPARENT_ACTIONS = ( 'command_type', { @@ -1503,7 +1557,8 @@ def testB25131481(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB23445244(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def foo(): if True: return xxxxxxxxxxxxxxxx( @@ -1514,7 +1569,8 @@ def foo(): FLAGS.aaaaaaaaaaaaaa + FLAGS.bbbbbbbbbbbbbbbbbbb, }) """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def foo(): if True: return xxxxxxxxxxxxxxxx( @@ -1530,7 +1586,8 @@ def foo(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB20559654(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ class A(object): def foo(self): @@ -1538,7 +1595,8 @@ def foo(self): ['AA BBBB CCC DDD EEEEEEEE X YY ZZZZ FFF EEE AAAAAAAA'], aaaaaaaaaaa=True, bbbbbbbb=None) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ class A(object): def foo(self): @@ -1551,7 +1609,8 @@ def foo(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB23943842(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ class F(): def f(): self.assertDictEqual( @@ -1565,7 +1624,8 @@ def f(): 'lines': 'l8'} }) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ class F(): def f(): @@ -1589,12 +1649,14 @@ def f(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB20551180(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def foo(): if True: return (struct.pack('aaaa', bbbbbbbbbb, ccccccccccccccc, dddddddd) + eeeeeee) """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def foo(): if True: return (struct.pack('aaaa', bbbbbbbbbb, ccccccccccccccc, dddddddd) + @@ -1604,12 +1666,14 @@ def foo(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB23944849(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ class A(object): def xxxxxxxxx(self, aaaaaaa, bbbbbbb=ccccccccccc, dddddd=300, eeeeeeeeeeeeee=None, fffffffffffffff=0): pass """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ class A(object): def xxxxxxxxx(self, @@ -1624,12 +1688,14 @@ def xxxxxxxxx(self, self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB23935890(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ class F(): def functioni(self, aaaaaaa, bbbbbbb, cccccc, dddddddddddddd, eeeeeeeeeeeeeee): pass """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ class F(): def functioni(self, aaaaaaa, bbbbbbb, cccccc, dddddddddddddd, @@ -1640,7 +1706,8 @@ def functioni(self, aaaaaaa, bbbbbbb, cccccc, dddddddddddddd, self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB28414371(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ def _(): return ((m.fffff( m.rrr('mmmmmmmmmmmmmmmm', 'ssssssssssssssssssssssssss'), ffffffffffffffff) @@ -1665,7 +1732,8 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB20127686(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ def f(): if True: return ((m.fffff( @@ -1683,11 +1751,13 @@ def f(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB20016122(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ from a_very_long_or_indented_module_name_yada_yada import (long_argument_1, long_argument_2) """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ from a_very_long_or_indented_module_name_yada_yada import ( long_argument_1, long_argument_2) """) @@ -1698,12 +1768,13 @@ def testB20016122(self): '{based_on_style: pep8, split_penalty_import_names: 350}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreatePEP8Style()) - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ class foo(): def __eq__(self, other): @@ -1723,8 +1794,9 @@ def __eq__(self, other): try: style.SetGlobalStyle( - style.CreateStyleFromConfig('{based_on_style: yapf, ' - 'split_before_logical_operator: True}')) + style.CreateStyleFromConfig( + '{based_on_style: yapf, ' + 'split_before_logical_operator: True}')) llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) @@ -1732,12 +1804,14 @@ def __eq__(self, other): style.SetGlobalStyle(style.CreateYapfStyle()) def testB22527411(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def f(): if True: aaaaaa.bbbbbbbbbbbbbbbbbbbb[-1].cccccccccccccc.ddd().eeeeeeee(ffffffffffffff) """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def f(): if True: aaaaaa.bbbbbbbbbbbbbbbbbbbb[-1].cccccccccccccc.ddd().eeeeeeee( @@ -1747,7 +1821,8 @@ def f(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB20849933(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def main(unused_argv): if True: aaaaaaaa = { @@ -1755,7 +1830,8 @@ def main(unused_argv): (eeeeee.FFFFFFFFFFFFFFFFFF), } """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def main(unused_argv): if True: aaaaaaaa = { @@ -1767,7 +1843,8 @@ def main(unused_argv): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB20813997(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ def myfunc_1(): myarray = numpy.zeros((2, 2, 2)) print(myarray[:, 1, :]) @@ -1776,7 +1853,8 @@ def myfunc_1(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB20605036(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ foo = { 'aaaa': { # A comment for no particular reason. @@ -1790,7 +1868,8 @@ def testB20605036(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB20562732(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ foo = [ # Comment about first list item 'First item', @@ -1802,7 +1881,8 @@ def testB20562732(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB20128830(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ a = { 'xxxxxxxxxxxxxxxxxxxx': { 'aaaa': @@ -1822,7 +1902,8 @@ def testB20128830(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB20073838(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ class DummyModel(object): def do_nothing(self, class_1_count): @@ -1839,7 +1920,8 @@ def do_nothing(self, class_1_count): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB19626808(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ if True: aaaaaaaaaaaaaaaaaaaaaaa.bbbbbbbbb( 'ccccccccccc', ddddddddd='eeeee').fffffffff([ggggggggggggggggggggg]) @@ -1848,7 +1930,8 @@ def testB19626808(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB19547210(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ while True: if True: if True: @@ -1862,7 +1945,8 @@ def testB19547210(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB19377034(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ def f(): if (aaaaaaaaaaaaaaa.start >= aaaaaaaaaaaaaaa.end or bbbbbbbbbbbbbbb.start >= bbbbbbbbbbbbbbb.end): @@ -1872,7 +1956,8 @@ def f(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB19372573(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ def f(): if a: return 42 while True: @@ -1890,7 +1975,8 @@ def f(): style.SetGlobalStyle(style.CreateYapfStyle()) def testB19353268(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ a = {1, 2, 3}[x] b = {'foo': 42, 'bar': 37}['foo'] """) @@ -1898,7 +1984,8 @@ def testB19353268(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB19287512(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ class Foo(object): def bar(self): @@ -1908,7 +1995,8 @@ def bar(self): .Mmmmmmmmmmmmmmmmmm(-1, 'permission error'))): self.assertRaises(nnnnnnnnnnnnnnnn.ooooo, ppppp.qqqqqqqqqqqqqqqqq) """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ class Foo(object): def bar(self): @@ -1923,7 +2011,8 @@ def bar(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB19194420(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ method.Set( 'long argument goes here that causes the line to break', lambda arg2=0.5: arg2) @@ -1932,7 +2021,7 @@ def testB19194420(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB19073499(self): - code = """\ + code = """\ instance = ( aaaaaaa.bbbbbbb().ccccccccccccccccc().ddddddddddd({ 'aa': 'context!' @@ -1944,7 +2033,8 @@ def testB19073499(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB18257115(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ if True: if True: self._Test(aaaa, bbbbbbb.cccccccccc, dddddddd, eeeeeeeeeee, @@ -1954,7 +2044,8 @@ def testB18257115(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB18256666(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ class Foo(object): def Bar(self): @@ -1972,7 +2063,8 @@ def Bar(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB18256826(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ if True: pass # A multiline comment. @@ -1991,7 +2083,8 @@ def testB18256826(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB18255697(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ AAAAAAAAAAAAAAA = { 'XXXXXXXXXXXXXX': 4242, # Inline comment # Next comment @@ -2002,12 +2095,14 @@ def testB18255697(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB17534869(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ if True: self.assertLess(abs(time.time()-aaaa.bbbbbbbbbbb( datetime.datetime.now())), 1) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ if True: self.assertLess( abs(time.time() - aaaa.bbbbbbbbbbb(datetime.datetime.now())), 1) @@ -2016,14 +2111,16 @@ def testB17534869(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB17489866(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def f(): if True: if True: return aaaa.bbbbbbbbb(ccccccc=dddddddddddddd({('eeee', \ 'ffffffff'): str(j)})) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def f(): if True: if True: @@ -2034,7 +2131,8 @@ def f(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB17133019(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ class aaaaaaaaaaaaaa(object): def bbbbbbbbbb(self): @@ -2045,7 +2143,8 @@ def bbbbbbbbbb(self): ), "rb") as gggggggggggggggggggg: print(gggggggggggggggggggg) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ class aaaaaaaaaaaaaa(object): def bbbbbbbbbb(self): @@ -2059,7 +2158,8 @@ def bbbbbbbbbb(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB17011869(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ '''blah......''' class SomeClass(object): @@ -2070,7 +2170,8 @@ class SomeClass(object): 'DDDDDDDD': 0.4811 } """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ '''blah......''' @@ -2086,14 +2187,16 @@ class SomeClass(object): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB16783631(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ if True: with aaaaaaaaaaaaaa.bbbbbbbbbbbbb.ccccccc(ddddddddddddd, eeeeeeeee=self.fffffffffffff )as gggg: pass """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ if True: with aaaaaaaaaaaaaa.bbbbbbbbbbbbb.ccccccc( ddddddddddddd, eeeeeeeee=self.fffffffffffff) as gggg: @@ -2103,12 +2206,14 @@ def testB16783631(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB16572361(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def foo(self): def bar(my_dict_name): self.my_dict_name['foo-bar-baz-biz-boo-baa-baa'].IncrementBy.assert_called_once_with('foo_bar_baz_boo') """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def foo(self): def bar(my_dict_name): @@ -2120,13 +2225,15 @@ def bar(my_dict_name): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB15884241(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ if 1: if 1: for row in AAAA: self.create(aaaaaaaa="/aaa/bbbb/cccc/dddddd/eeeeeeeeeeeeeeeeeeeeeeeeee/%s" % row [0].replace(".foo", ".bar"), aaaaa=bbb[1], ccccc=bbb[2], dddd=bbb[3], eeeeeeeeeee=[s.strip() for s in bbb[4].split(",")], ffffffff=[s.strip() for s in bbb[5].split(",")], gggggg=bbb[6]) """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ if 1: if 1: for row in AAAA: @@ -2144,7 +2251,8 @@ def testB15884241(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB15697268(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def main(unused_argv): ARBITRARY_CONSTANT_A = 10 an_array_with_an_exceedingly_long_name = range(ARBITRARY_CONSTANT_A + 1) @@ -2153,7 +2261,8 @@ def main(unused_argv): a_long_name_slicing = an_array_with_an_exceedingly_long_name[:ARBITRARY_CONSTANT_A] bad_slice = ("I am a crazy, no good, string what's too long, etc." + " no really ")[:ARBITRARY_CONSTANT_A] """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def main(unused_argv): ARBITRARY_CONSTANT_A = 10 an_array_with_an_exceedingly_long_name = range(ARBITRARY_CONSTANT_A + 1) @@ -2169,7 +2278,7 @@ def main(unused_argv): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB15597568(self): - unformatted_code = """\ + unformatted_code = """\ if True: if True: if True: @@ -2183,14 +2292,16 @@ def testB15597568(self): (", and the process timed out." if did_time_out else ".")) % errorcode) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB15542157(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ aaaaaaaaaaaa = bbbb.ccccccccccccccc(dddddd.eeeeeeeeeeeeee, ffffffffffffffffff, gggggg.hhhhhhhhhhhhhhhhh) """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ aaaaaaaaaaaa = bbbb.ccccccccccccccc(dddddd.eeeeeeeeeeeeee, ffffffffffffffffff, gggggg.hhhhhhhhhhhhhhhhh) """) # noqa @@ -2198,7 +2309,8 @@ def testB15542157(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB15438132(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ if aaaaaaa.bbbbbbbbbb: cccccc.dddddddddd(eeeeeeeeeee=fffffffffffff.gggggggggggggggggg) if hhhhhh.iiiii.jjjjjjjjjjjjj: @@ -2214,7 +2326,8 @@ def testB15438132(self): lllll.mm), nnnnnnnnnn=ooooooo.pppppppppp) """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ if aaaaaaa.bbbbbbbbbb: cccccc.dddddddddd(eeeeeeeeeee=fffffffffffff.gggggggggggggggggg) if hhhhhh.iiiii.jjjjjjjjjjjjj: @@ -2233,7 +2346,7 @@ def testB15438132(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB14468247(self): - unformatted_code = """\ + unformatted_code = """\ call(a=1, b=2, ) @@ -2244,15 +2357,17 @@ def testB14468247(self): b=2, ) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB14406499(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def foo1(parameter_1, parameter_2, parameter_3, parameter_4, \ parameter_5, parameter_6): pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def foo1(parameter_1, parameter_2, parameter_3, parameter_4, parameter_5, parameter_6): pass @@ -2261,18 +2376,21 @@ def foo1(parameter_1, parameter_2, parameter_3, parameter_4, parameter_5, self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB13900309(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ self.aaaaaaaaaaa( # A comment in the middle of it all. 948.0/3600, self.bbb.ccccccccccccccccccccc(dddddddddddddddd.eeee, True)) """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ self.aaaaaaaaaaa( # A comment in the middle of it all. 948.0 / 3600, self.bbb.ccccccccccccccccccccc(dddddddddddddddd.eeee, True)) """) # noqa llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ aaaaaaaaaa.bbbbbbbbbbbbbbbbbbbbbbbb.cccccccccccccccccccccccccccccc( DC_1, (CL - 50, CL), AAAAAAAA, BBBBBBBBBBBBBBBB, 98.0, CCCCCCC).ddddddddd( # Look! A comment is here. @@ -2281,41 +2399,49 @@ def testB13900309(self): llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ aaaaaaaaaaaaaaaaaaaaaaaa.bbbbbbbbbbbbb.ccccccccccccccccccccccccc().dddddddddddddddddddddddddd(1, 2, 3, 4) """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ aaaaaaaaaaaaaaaaaaaaaaaa.bbbbbbbbbbbbb.ccccccccccccccccccccccccc( ).dddddddddddddddddddddddddd(1, 2, 3, 4) """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ aaaaaaaaaaaaaaaaaaaaaaaa.bbbbbbbbbbbbb.ccccccccccccccccccccccccc(x).dddddddddddddddddddddddddd(1, 2, 3, 4) """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ aaaaaaaaaaaaaaaaaaaaaaaa.bbbbbbbbbbbbb.ccccccccccccccccccccccccc( x).dddddddddddddddddddddddddd(1, 2, 3, 4) """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ aaaaaaaaaaaaaaaaaaaaaaaa(xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx).dddddddddddddddddddddddddd(1, 2, 3, 4) """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ aaaaaaaaaaaaaaaaaaaaaaaa( xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx).dddddddddddddddddddddddddd(1, 2, 3, 4) """) # noqa llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ aaaaaaaaaaaaaaaaaaaaaaaa().bbbbbbbbbbbbbbbbbbbbbbbb().ccccccccccccccccccc().\ dddddddddddddddddd().eeeeeeeeeeeeeeeeeeeee().fffffffffffffffff().gggggggggggggggggg() """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ aaaaaaaaaaaaaaaaaaaaaaaa().bbbbbbbbbbbbbbbbbbbbbbbb().ccccccccccccccccccc( ).dddddddddddddddddd().eeeeeeeeeeeeeeeeeeeee().fffffffffffffffff( ).gggggggggggggggggg() @@ -2324,7 +2450,8 @@ def testB13900309(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB67935687(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ Fetch( Raw('monarch.BorgTask', '/union/row_operator_action_delay'), {'borg_user': self.borg_user}) @@ -2332,13 +2459,15 @@ def testB67935687(self): llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ shelf_renderer.expand_text = text.translate_to_unicode( expand_text % { 'creator': creator }) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ shelf_renderer.expand_text = text.translate_to_unicode(expand_text % {'creator': creator}) """) # noqa diff --git a/yapftests/reformatter_facebook_test.py b/yapftests/reformatter_facebook_test.py index c61f32bf5..14b07d06b 100644 --- a/yapftests/reformatter_facebook_test.py +++ b/yapftests/reformatter_facebook_test.py @@ -29,12 +29,14 @@ def setUpClass(cls): style.SetGlobalStyle(style.CreateFacebookStyle()) def testNoNeedForLineBreaks(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def overly_long_function_name( just_one_arg, **kwargs): pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def overly_long_function_name(just_one_arg, **kwargs): pass """) @@ -42,13 +44,15 @@ def overly_long_function_name(just_one_arg, **kwargs): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testDedentClosingBracket(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def overly_long_function_name( first_argument_on_the_same_line, second_argument_makes_the_line_too_long): pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def overly_long_function_name( first_argument_on_the_same_line, second_argument_makes_the_line_too_long ): @@ -58,12 +62,14 @@ def overly_long_function_name( self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testBreakAfterOpeningBracketIfContentsTooBig(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def overly_long_function_name(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z): pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def overly_long_function_name( a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, \ v, w, x, y, z @@ -74,7 +80,8 @@ def overly_long_function_name( self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testDedentClosingBracketWithComments(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def overly_long_function_name( # comment about the first argument first_argument_with_a_very_long_name_or_so, @@ -82,7 +89,8 @@ def overly_long_function_name( second_argument_makes_the_line_too_long): pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def overly_long_function_name( # comment about the first argument first_argument_with_a_very_long_name_or_so, @@ -95,7 +103,8 @@ def overly_long_function_name( self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testDedentImportAsNames(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ from module import ( internal_function as function, SOME_CONSTANT_NUMBER1, @@ -107,7 +116,8 @@ def testDedentImportAsNames(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testDedentTestListGexp(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ try: pass except ( @@ -122,7 +132,8 @@ def testDedentTestListGexp(self): ) as exception: pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ try: pass except ( @@ -146,13 +157,15 @@ def testDedentTestListGexp(self): def testBrokenIdempotency(self): # TODO(ambv): The following behaviour should be fixed. - pass0_code = textwrap.dedent("""\ + pass0_code = textwrap.dedent( + """\ try: pass except (IOError, OSError, LookupError, RuntimeError, OverflowError) as exception: pass """) # noqa - pass1_code = textwrap.dedent("""\ + pass1_code = textwrap.dedent( + """\ try: pass except ( @@ -163,7 +176,8 @@ def testBrokenIdempotency(self): llines = yapf_test_helper.ParseAndUnwrap(pass0_code) self.assertCodeEqual(pass1_code, reformatter.Reformat(llines)) - pass2_code = textwrap.dedent("""\ + pass2_code = textwrap.dedent( + """\ try: pass except ( @@ -175,7 +189,8 @@ def testBrokenIdempotency(self): self.assertCodeEqual(pass2_code, reformatter.Reformat(llines)) def testIfExprHangingIndent(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ if True: if True: if True: @@ -184,7 +199,8 @@ def testIfExprHangingIndent(self): self.foobars.counters['db.marshmellow_skins'] != 1): pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ if True: if True: if True: @@ -198,11 +214,13 @@ def testIfExprHangingIndent(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testSimpleDedenting(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ if True: self.assertEqual(result.reason_not_added, "current preflight is still running") """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ if True: self.assertEqual( result.reason_not_added, "current preflight is still running" @@ -212,7 +230,8 @@ def testSimpleDedenting(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testDedentingWithSubscripts(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ class Foo: class Bar: @classmethod @@ -221,7 +240,8 @@ def baz(cls, clues_list, effect, constraints, constraint_manager): return cls.single_constraint_not(clues_lists, effect, constraints[0], constraint_manager) """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ class Foo: class Bar: @classmethod @@ -235,7 +255,8 @@ def baz(cls, clues_list, effect, constraints, constraint_manager): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testDedentingCallsWithInnerLists(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ class _(): def _(): cls.effect_clues = { @@ -246,7 +267,8 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testDedentingListComprehension(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ class Foo(): def _pack_results_for_constraint_or(): self.param_groups = dict( @@ -284,7 +306,8 @@ def _pack_results_for_constraint_or(): ('localhost', os.path.join(path, 'node_2.log'), super_parser) ] """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ class Foo(): def _pack_results_for_constraint_or(): self.param_groups = dict( @@ -324,7 +347,8 @@ def _pack_results_for_constraint_or(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testMustSplitDedenting(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ class _(): def _(): effect_line = FrontInput( @@ -336,7 +360,8 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testDedentIfConditional(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ class _(): def _(): if True: @@ -350,7 +375,8 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testDedentSet(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ class _(): def _(): assert set(self.constraint_links.get_links()) == set( @@ -366,7 +392,8 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testDedentingInnerScope(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ class Foo(): @classmethod def _pack_results_for_constraint_or(cls, combination, constraints): @@ -375,16 +402,17 @@ def _pack_results_for_constraint_or(cls, combination, constraints): constraints, InvestigationResult.OR ) """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(code) + llines = yapf_test_helper.ParseAndUnwrap(code) reformatted_code = reformatter.Reformat(llines) self.assertCodeEqual(code, reformatted_code) - llines = yapf_test_helper.ParseAndUnwrap(reformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(reformatted_code) reformatted_code = reformatter.Reformat(llines) self.assertCodeEqual(code, reformatted_code) def testCommentWithNewlinesInPrefix(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def foo(): if 0: return False @@ -397,7 +425,8 @@ def foo(): print(foo()) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def foo(): if 0: return False @@ -413,7 +442,7 @@ def foo(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testIfStmtClosingBracket(self): - unformatted_code = """\ + unformatted_code = """\ if (isinstance(value , (StopIteration , StopAsyncIteration )) and exc.__cause__ is value_asdfasdfasdfasdfsafsafsafdasfasdfs): return False """ # noqa @@ -424,7 +453,7 @@ def testIfStmtClosingBracket(self): ): return False """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) diff --git a/yapftests/reformatter_pep8_test.py b/yapftests/reformatter_pep8_test.py index acc218d24..19c294d18 100644 --- a/yapftests/reformatter_pep8_test.py +++ b/yapftests/reformatter_pep8_test.py @@ -30,11 +30,13 @@ def setUpClass(cls): # pylint: disable=g-missing-super-call style.SetGlobalStyle(style.CreatePEP8Style()) def testIndent4(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ if a+b: pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ if a + b: pass """) @@ -42,7 +44,8 @@ def testIndent4(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testSingleLineIfStatements(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ if True: a = 42 elif False: b = 42 else: c = 42 @@ -51,12 +54,14 @@ def testSingleLineIfStatements(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testBlankBetweenClassAndDef(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ class Foo: def joe(): pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ class Foo: def joe(): @@ -66,7 +71,8 @@ def joe(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testBlankBetweenDefsInClass(self): - unformatted_code = textwrap.dedent('''\ + unformatted_code = textwrap.dedent( + '''\ class TestClass: def __init__(self): self.running = False @@ -75,7 +81,8 @@ def run(self): def is_running(self): return self.running ''') - expected_formatted_code = textwrap.dedent('''\ + expected_formatted_code = textwrap.dedent( + '''\ class TestClass: def __init__(self): @@ -91,11 +98,13 @@ def is_running(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testSingleWhiteBeforeTrailingComment(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ if a+b: # comment pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ if a + b: # comment pass """) @@ -103,19 +112,22 @@ def testSingleWhiteBeforeTrailingComment(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testSpaceBetweenEndingCommandAndClosingBracket(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ a = ( 1, ) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ a = (1, ) """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testContinuedNonOutdentedLine(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ class eld(d): if str(geom.geom_type).upper( ) != self.geom_type and not self.geom_type == 'GEOMETRY': @@ -125,7 +137,8 @@ class eld(d): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testWrappingPercentExpressions(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def f(): if True: zzzzz = '%s-%s' % (xxxxxxxxxxxxxxxxxxxxxxxxxx + 1, xxxxxxxxxxxxxxxxx.yyy + 1) @@ -133,7 +146,8 @@ def f(): zzzzz = '%s-%s' % (xxxxxxxxxxxxxxxxxxxxxxx + 1, xxxxxxxxxxxxxxxxxxxxx + 1) zzzzz = '%s-%s'.ww(xxxxxxxxxxxxxxxxxxxxxxx + 1, xxxxxxxxxxxxxxxxxxxxx + 1) """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def f(): if True: zzzzz = '%s-%s' % (xxxxxxxxxxxxxxxxxxxxxxxxxx + 1, @@ -149,12 +163,14 @@ def f(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testAlignClosingBracketWithVisualIndentation(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ TEST_LIST = ('foo', 'bar', # first comment 'baz' # second comment ) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ TEST_LIST = ( 'foo', 'bar', # first comment @@ -164,7 +180,8 @@ def testAlignClosingBracketWithVisualIndentation(self): llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def f(): def g(): @@ -173,7 +190,8 @@ def g(): ): pass """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def f(): def g(): @@ -186,11 +204,13 @@ def g(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testIndentSizeChanging(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ if True: runtime_mins = (program_end_time - program_start_time).total_seconds() / 60.0 """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ if True: runtime_mins = (program_end_time - program_start_time).total_seconds() / 60.0 @@ -199,7 +219,8 @@ def testIndentSizeChanging(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testHangingIndentCollision(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ if (aaaaaaaaaaaaaa + bbbbbbbbbbbbbbbb == ccccccccccccccccc and xxxxxxxxxxxxx or yyyyyyyyyyyyyyyyy): pass elif (xxxxxxxxxxxxxxx(aaaaaaaaaaa, bbbbbbbbbbbbbb, cccccccccccc, dddddddddd=None)): @@ -213,7 +234,8 @@ def h(): for connection in itertools.chain(branch.contact, branch.address, morestuff.andmore.andmore.andmore.andmore.andmore.andmore.andmore): dosomething(connection) """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ if (aaaaaaaaaaaaaa + bbbbbbbbbbbbbbbb == ccccccccccccccccc and xxxxxxxxxxxxx or yyyyyyyyyyyyyyyyy): pass @@ -242,7 +264,8 @@ def testSplittingBeforeLogicalOperator(self): style.SetGlobalStyle( style.CreateStyleFromConfig( '{based_on_style: pep8, split_before_logical_operator: True}')) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def foo(): return bool(update.message.new_chat_member or update.message.left_chat_member or update.message.new_chat_title or update.message.new_chat_photo or @@ -251,7 +274,8 @@ def foo(): or update.message.migrate_to_chat_id or update.message.migrate_from_chat_id or update.message.pinned_message) """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def foo(): return bool( update.message.new_chat_member or update.message.left_chat_member @@ -265,18 +289,20 @@ def foo(): or update.message.pinned_message) """) # noqa llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreatePEP8Style()) def testContiguousListEndingWithComment(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ if True: if True: keys.append(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) # may be unassigned. """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ if True: if True: keys.append( @@ -290,11 +316,13 @@ def testSplittingBeforeFirstArgument(self): style.SetGlobalStyle( style.CreateStyleFromConfig( '{based_on_style: pep8, split_before_first_argument: True}')) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ a_very_long_function_name(long_argument_name_1=1, long_argument_name_2=2, long_argument_name_3=3, long_argument_name_4=4) """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ a_very_long_function_name( long_argument_name_1=1, long_argument_name_2=2, @@ -302,17 +330,19 @@ def testSplittingBeforeFirstArgument(self): long_argument_name_4=4) """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreatePEP8Style()) def testSplittingExpressionsInsideSubscripts(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def foo(): df = df[(df['campaign_status'] == 'LIVE') & (df['action_status'] == 'LIVE')] """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def foo(): df = df[(df['campaign_status'] == 'LIVE') & (df['action_status'] == 'LIVE')] @@ -321,13 +351,15 @@ def foo(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testSplitListsAndDictSetMakersIfCommaTerminated(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ DJANGO_TEMPLATES_OPTIONS = {"context_processors": []} DJANGO_TEMPLATES_OPTIONS = {"context_processors": [],} x = ["context_processors"] x = ["context_processors",] """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ DJANGO_TEMPLATES_OPTIONS = {"context_processors": []} DJANGO_TEMPLATES_OPTIONS = { "context_processors": [], @@ -341,13 +373,15 @@ def testSplitListsAndDictSetMakersIfCommaTerminated(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testSplitAroundNamedAssigns(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ class a(): def a(): return a( aaaaaaaaaa=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ class a(): def a(): @@ -359,13 +393,15 @@ def a(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testUnaryOperator(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ if not -3 < x < 3: pass if -3 < x < 3: pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ if not -3 < x < 3: pass if -3 < x < 3: @@ -377,21 +413,24 @@ def testUnaryOperator(self): def testNoSplitBeforeDictValue(self): try: style.SetGlobalStyle( - style.CreateStyleFromConfig('{based_on_style: pep8, ' - 'allow_split_before_dict_value: false, ' - 'coalesce_brackets: true, ' - 'dedent_closing_brackets: true, ' - 'each_dict_entry_on_separate_line: true, ' - 'split_before_logical_operator: true}')) - - unformatted_code = textwrap.dedent("""\ + style.CreateStyleFromConfig( + '{based_on_style: pep8, ' + 'allow_split_before_dict_value: false, ' + 'coalesce_brackets: true, ' + 'dedent_closing_brackets: true, ' + 'each_dict_entry_on_separate_line: true, ' + 'split_before_logical_operator: true}')) + + unformatted_code = textwrap.dedent( + """\ some_dict = { 'title': _("I am example data"), 'description': _("Lorem ipsum dolor met sit amet elit, si vis pacem para bellum " "elites nihi very long string."), } """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ some_dict = { 'title': _("I am example data"), 'description': _( @@ -401,13 +440,15 @@ def testNoSplitBeforeDictValue(self): } """) # noqa llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ X = {'a': 1, 'b': 2, 'key': this_is_a_function_call_that_goes_over_the_column_limit_im_pretty_sure()} """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ X = { 'a': 1, 'b': 2, @@ -415,16 +456,18 @@ def testNoSplitBeforeDictValue(self): } """) # noqa llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ attrs = { 'category': category, 'role': forms.ModelChoiceField(label=_("Role"), required=False, queryset=category_roles, initial=selected_role, empty_label=_("No access"),), } """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ attrs = { 'category': category, 'role': forms.ModelChoiceField( @@ -437,17 +480,19 @@ def testNoSplitBeforeDictValue(self): } """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ css_class = forms.CharField( label=_("CSS class"), required=False, help_text=_("Optional CSS class used to customize this category appearance from templates."), ) """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ css_class = forms.CharField( label=_("CSS class"), required=False, @@ -457,8 +502,8 @@ def testNoSplitBeforeDictValue(self): ) """) # noqa llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreatePEP8Style()) @@ -473,7 +518,7 @@ def _(): cdffile['Latitude'][:] >= select_lat - radius) & ( cdffile['Latitude'][:] <= select_lat + radius)) """ - expected_code = """\ + expected_code = """\ def _(): include_values = np.where( (cdffile['Quality_Flag'][:] >= 5) & (cdffile['Day_Night_Flag'][:] == 1) @@ -482,7 +527,7 @@ def _(): & (cdffile['Latitude'][:] >= select_lat - radius) & (cdffile['Latitude'][:] <= select_lat + radius)) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertEqual(expected_code, reformatter.Reformat(llines)) def testNoBlankLinesOnlyForFirstNestedObject(self): @@ -500,7 +545,7 @@ def bar(self): bar docs """ ''' - expected_code = '''\ + expected_code = '''\ class Demo: """ Demo docs @@ -516,7 +561,7 @@ def bar(self): bar docs """ ''' - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertEqual(expected_code, reformatter.Reformat(llines)) def testSplitBeforeArithmeticOperators(self): @@ -525,7 +570,7 @@ def testSplitBeforeArithmeticOperators(self): style.CreateStyleFromConfig( '{based_on_style: pep8, split_before_arithmetic_operator: true}')) - unformatted_code = """\ + unformatted_code = """\ def _(): raise ValueError('This is a long message that ends with an argument: ' + str(42)) """ # noqa @@ -534,9 +579,9 @@ def _(): raise ValueError('This is a long message that ends with an argument: ' + str(42)) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreatePEP8Style()) @@ -546,12 +591,12 @@ def testListSplitting(self): (1,1), (1,1), (1,1), (1,1), (1,1), (1,1), (1,1), (1,10), (1,11), (1, 10), (1,11), (10,11)]) """ - expected_code = """\ + expected_code = """\ foo([(1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 10), (1, 11), (1, 10), (1, 11), (10, 11)]) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) def testNoBlankLineBeforeNestedFuncOrClass(self): @@ -561,7 +606,7 @@ def testNoBlankLineBeforeNestedFuncOrClass(self): '{based_on_style: pep8, ' 'blank_line_before_nested_class_or_def: false}')) - unformatted_code = '''\ + unformatted_code = '''\ def normal_function(): """Return the nested function.""" @@ -589,14 +634,15 @@ class nested_class(): return nested_function ''' - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreatePEP8Style()) def testParamListIndentationCollision1(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ class _(): def __init__(self, title: Optional[str], diffs: Collection[BinaryDiff] = (), charset: Union[Type[AsciiCharset], Type[LineCharset]] = AsciiCharset, preprocess: Callable[[str], str] = identity, @@ -605,7 +651,8 @@ def __init__(self, title: Optional[str], diffs: Collection[BinaryDiff] = (), cha self._cs = charset self._preprocess = preprocess """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ class _(): def __init__( @@ -624,7 +671,8 @@ def __init__( self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testParamListIndentationCollision2(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ def simple_pass_function_with_an_extremely_long_name_and_some_arguments( argument0, argument1): pass @@ -633,7 +681,8 @@ def simple_pass_function_with_an_extremely_long_name_and_some_arguments( self.assertCodeEqual(code, reformatter.Reformat(llines)) def testParamListIndentationCollision3(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ def func1( arg1, arg2, @@ -651,11 +700,13 @@ def func2( self.assertCodeEqual(code, reformatter.Reformat(llines)) def testTwoWordComparisonOperators(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ _ = (klsdfjdklsfjksdlfjdklsfjdslkfjsdkl is not ksldfjsdklfjdklsfjdklsfjdklsfjdsklfjdklsfj) _ = (klsdfjdklsfjksdlfjdklsfjdslkfjsdkl not in {ksldfjsdklfjdklsfjdklsfjdklsfjdsklfjdklsfj}) """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ _ = (klsdfjdklsfjksdlfjdklsfjdslkfjsdkl is not ksldfjsdklfjdklsfjdklsfjdklsfjdsklfjdklsfj) _ = (klsdfjdklsfjksdlfjdklsfjdslkfjsdkl @@ -667,7 +718,8 @@ def testTwoWordComparisonOperators(self): @unittest.skipUnless(not py3compat.PY3, 'Requires Python 2.7') def testAsyncAsNonKeyword(self): # In Python 2, async may be used as a non-keyword identifier. - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ from util import async @@ -683,12 +735,14 @@ def bar(self): self.assertCodeEqual(code, reformatter.Reformat(llines, verify=False)) def testStableInlinedDictionaryFormatting(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def _(): url = "http://{0}/axis-cgi/admin/param.cgi?{1}".format( value, urllib.urlencode({'action': 'update', 'parameter': value})) """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def _(): url = "http://{0}/axis-cgi/admin/param.cgi?{1}".format( value, urllib.urlencode({ @@ -697,18 +751,19 @@ def _(): })) """) - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) reformatted_code = reformatter.Reformat(llines) self.assertCodeEqual(expected_formatted_code, reformatted_code) - llines = yapf_test_helper.ParseAndUnwrap(reformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(reformatted_code) reformatted_code = reformatter.Reformat(llines) self.assertCodeEqual(expected_formatted_code, reformatted_code) @unittest.skipUnless(py3compat.PY36, 'Requires Python 3.6') def testSpaceBetweenColonAndElipses(self): style.SetGlobalStyle(style.CreatePEP8Style()) - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ class MyClass(ABC): place: ... @@ -719,10 +774,11 @@ class MyClass(ABC): @unittest.skipUnless(py3compat.PY36, 'Requires Python 3.6') def testSpaceBetweenDictColonAndElipses(self): style.SetGlobalStyle(style.CreatePEP8Style()) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent("""\ {0:"...", 1:...} """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ {0: "...", 1: ...} """) @@ -732,7 +788,8 @@ def testSpaceBetweenDictColonAndElipses(self): class TestsForSpacesInsideBrackets(yapf_test_helper.YAPFTest): """Test the SPACE_INSIDE_BRACKETS style option.""" - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ foo() foo(1) foo(1,2) @@ -765,7 +822,8 @@ def testEnabled(self): style.SetGlobalStyle( style.CreateStyleFromConfig('{space_inside_brackets: True}')) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ foo() foo( 1 ) foo( 1, 2 ) @@ -803,7 +861,8 @@ def testEnabled(self): def testDefault(self): style.SetGlobalStyle(style.CreatePEP8Style()) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ foo() foo(1) foo(1, 2) @@ -842,7 +901,8 @@ def testDefault(self): def testAwait(self): style.SetGlobalStyle( style.CreateStyleFromConfig('{space_inside_brackets: True}')) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ import asyncio import time @@ -855,7 +915,8 @@ async def main(): if (await get_html()): pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ import asyncio import time @@ -876,7 +937,8 @@ async def main(): class TestsForSpacesAroundSubscriptColon(yapf_test_helper.YAPFTest): """Test the SPACES_AROUND_SUBSCRIPT_COLON style option.""" - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ a = list1[ : ] b = list2[ slice_start: ] c = list3[ slice_start:slice_end ] @@ -892,7 +954,8 @@ class TestsForSpacesAroundSubscriptColon(yapf_test_helper.YAPFTest): def testEnabled(self): style.SetGlobalStyle( style.CreateStyleFromConfig('{spaces_around_subscript_colon: True}')) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ a = list1[:] b = list2[slice_start :] c = list3[slice_start : slice_end] @@ -909,11 +972,13 @@ def testEnabled(self): def testWithSpaceInsideBrackets(self): style.SetGlobalStyle( - style.CreateStyleFromConfig('{' - 'spaces_around_subscript_colon: true, ' - 'space_inside_brackets: true,' - '}')) - expected_formatted_code = textwrap.dedent("""\ + style.CreateStyleFromConfig( + '{' + 'spaces_around_subscript_colon: true, ' + 'space_inside_brackets: true,' + '}')) + expected_formatted_code = textwrap.dedent( + """\ a = list1[ : ] b = list2[ slice_start : ] c = list3[ slice_start : slice_end ] @@ -930,7 +995,8 @@ def testWithSpaceInsideBrackets(self): def testDefault(self): style.SetGlobalStyle(style.CreatePEP8Style()) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ a = list1[:] b = list2[slice_start:] c = list3[slice_start:slice_end] diff --git a/yapftests/reformatter_python3_test.py b/yapftests/reformatter_python3_test.py index b5d68e86f..88dd9d7bd 100644 --- a/yapftests/reformatter_python3_test.py +++ b/yapftests/reformatter_python3_test.py @@ -33,11 +33,13 @@ def setUpClass(cls): # pylint: disable=g-missing-super-call style.SetGlobalStyle(style.CreatePEP8Style()) def testTypedNames(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def x(aaaaaaaaaaaaaaa:int,bbbbbbbbbbbbbbbb:str,ccccccccccccccc:dict,eeeeeeeeeeeeee:set={1, 2, 3})->bool: pass """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def x(aaaaaaaaaaaaaaa: int, bbbbbbbbbbbbbbbb: str, ccccccccccccccc: dict, @@ -48,11 +50,13 @@ def x(aaaaaaaaaaaaaaa: int, self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testTypedNameWithLongNamedArg(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def func(arg=long_function_call_that_pushes_the_line_over_eighty_characters()) -> ReturnType: pass """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def func(arg=long_function_call_that_pushes_the_line_over_eighty_characters() ) -> ReturnType: pass @@ -61,11 +65,13 @@ def func(arg=long_function_call_that_pushes_the_line_over_eighty_characters() self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testKeywordOnlyArgSpecifier(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def foo(a, *, kw): return a+kw """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def foo(a, *, kw): return a + kw """) @@ -74,13 +80,15 @@ def foo(a, *, kw): @unittest.skipUnless(py3compat.PY36, 'Requires Python 3.6') def testPEP448ParameterExpansion(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ { ** x } { **{} } { **{ **x }, **x } {'a': 1, **kw , 'b':3, **kw2 } """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ {**x} {**{}} {**{**x}, **x} @@ -90,11 +98,13 @@ def testPEP448ParameterExpansion(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testAnnotations(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def foo(a: list, b: "bar") -> dict: return a+b """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def foo(a: list, b: "bar") -> dict: return a + b """) @@ -102,15 +112,16 @@ def foo(a: list, b: "bar") -> dict: self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testExecAsNonKeyword(self): - unformatted_code = 'methods.exec( sys.modules[name])\n' + unformatted_code = 'methods.exec( sys.modules[name])\n' expected_formatted_code = 'methods.exec(sys.modules[name])\n' - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testAsyncFunctions(self): if sys.version_info[1] < 5: return - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ import asyncio import time @@ -130,7 +141,7 @@ async def main(): self.assertCodeEqual(code, reformatter.Reformat(llines, verify=False)) def testNoSpacesAroundPowerOperator(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent("""\ a**b """) expected_formatted_code = textwrap.dedent("""\ @@ -143,13 +154,13 @@ def testNoSpacesAroundPowerOperator(self): '{based_on_style: pep8, SPACES_AROUND_POWER_OPERATOR: True}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreatePEP8Style()) def testSpacesAroundDefaultOrNamedAssign(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent("""\ f(a=5) """) expected_formatted_code = textwrap.dedent("""\ @@ -163,13 +174,14 @@ def testSpacesAroundDefaultOrNamedAssign(self): 'SPACES_AROUND_DEFAULT_OR_NAMED_ASSIGN: True}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreatePEP8Style()) def testTypeHint(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def foo(x: int=42): pass @@ -177,7 +189,8 @@ def foo(x: int=42): def foo2(x: 'int' =42): pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def foo(x: int = 42): pass @@ -189,17 +202,18 @@ def foo2(x: 'int' = 42): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testMatrixMultiplication(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent("""\ a=b@c """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ a = b @ c """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testNoneKeyword(self): - code = """\ + code = """\ None.__ne__() """ llines = yapf_test_helper.ParseAndUnwrap(code) @@ -208,7 +222,8 @@ def testNoneKeyword(self): def testAsyncWithPrecedingComment(self): if sys.version_info[1] < 5: return - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ import asyncio # Comment @@ -218,7 +233,8 @@ async def bar(): async def foo(): pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ import asyncio @@ -236,7 +252,8 @@ async def foo(): def testAsyncFunctionsNested(self): if sys.version_info[1] < 5: return - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ async def outer(): async def inner(): @@ -248,13 +265,15 @@ async def inner(): def testKeepTypesIntact(self): if sys.version_info[1] < 5: return - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def _ReduceAbstractContainers( self, *args: Optional[automation_converter.PyiCollectionAbc]) -> List[ automation_converter.PyiCollectionAbc]: pass """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def _ReduceAbstractContainers( self, *args: Optional[automation_converter.PyiCollectionAbc] ) -> List[automation_converter.PyiCollectionAbc]: @@ -266,13 +285,15 @@ def _ReduceAbstractContainers( def testContinuationIndentWithAsync(self): if sys.version_info[1] < 5: return - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ async def start_websocket(): async with session.ws_connect( r"ws://a_really_long_long_long_long_long_long_url") as ws: pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ async def start_websocket(): async with session.ws_connect( r"ws://a_really_long_long_long_long_long_long_url") as ws: @@ -285,7 +306,7 @@ def testSplittingArguments(self): if sys.version_info[1] < 5: return - unformatted_code = """\ + unformatted_code = """\ async def open_file(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None): pass @@ -346,15 +367,15 @@ def run_sync_in_worker_thread(sync_fn, *args, cancellable=False, limiter=None): 'split_before_first_argument: true}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreatePEP8Style()) def testDictUnpacking(self): if sys.version_info[1] < 5: return - unformatted_code = """\ + unformatted_code = """\ class Foo: def foo(self): foofoofoofoofoofoofoofoo('foofoofoofoofoo', { @@ -373,7 +394,7 @@ def foo(self): **foofoofoo }) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testMultilineFormatString(self): @@ -401,7 +422,7 @@ def dirichlet(x12345678901234567890123456789012345678901234567890=...) -> None: self.assertCodeEqual(code, reformatter.Reformat(llines)) def testFunctionTypedReturnNextLine(self): - code = """\ + code = """\ def _GenerateStatsEntries( process_id: Text, timestamp: Optional[ffffffff.FFFFFFFFFFF] = None @@ -412,7 +433,7 @@ def _GenerateStatsEntries( self.assertCodeEqual(code, reformatter.Reformat(llines)) def testFunctionTypedReturnSameLine(self): - code = """\ + code = """\ def rrrrrrrrrrrrrrrrrrrrrr( ccccccccccccccccccccccc: Tuple[Text, Text]) -> List[Tuple[Text, Text]]: pass @@ -423,7 +444,8 @@ def rrrrrrrrrrrrrrrrrrrrrr( def testAsyncForElseNotIndentedInsideBody(self): if sys.version_info[1] < 5: return - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ async def fn(): async for message in websocket: for i in range(10): @@ -439,7 +461,8 @@ async def fn(): def testForElseInAsyncNotMixedWithAsyncFor(self): if sys.version_info[1] < 5: return - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ async def fn(): for i in range(10): pass @@ -450,12 +473,14 @@ async def fn(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testParameterListIndentationConflicts(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def raw_message( # pylint: disable=too-many-arguments self, text, user_id=1000, chat_type='private', forward_date=None, forward_from=None): pass """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def raw_message( # pylint: disable=too-many-arguments self, text, diff --git a/yapftests/reformatter_style_config_test.py b/yapftests/reformatter_style_config_test.py index c5726cb30..6746ba0ed 100644 --- a/yapftests/reformatter_style_config_test.py +++ b/yapftests/reformatter_style_config_test.py @@ -30,26 +30,30 @@ def setUp(self): def testSetGlobalStyle(self): try: style.SetGlobalStyle(style.CreateYapfStyle()) - unformatted_code = textwrap.dedent(u"""\ + unformatted_code = textwrap.dedent( + u"""\ for i in range(5): print('bar') """) - expected_formatted_code = textwrap.dedent(u"""\ + expected_formatted_code = textwrap.dedent( + u"""\ for i in range(5): print('bar') """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreatePEP8Style()) style.DEFAULT_STYLE = self.current_style - unformatted_code = textwrap.dedent(u"""\ + unformatted_code = textwrap.dedent( + u"""\ for i in range(5): print('bar') """) - expected_formatted_code = textwrap.dedent(u"""\ + expected_formatted_code = textwrap.dedent( + u"""\ for i in range(5): print('bar') """) @@ -58,32 +62,35 @@ def testSetGlobalStyle(self): def testOperatorNoSpaceStyle(self): try: - sympy_style = style.CreatePEP8Style() + sympy_style = style.CreatePEP8Style() sympy_style['NO_SPACES_AROUND_SELECTED_BINARY_OPERATORS'] = \ style._StringSetConverter('*,/') style.SetGlobalStyle(sympy_style) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ a = 1+2 * 3 - 4 / 5 b = '0' * 1 """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ a = 1 + 2*3 - 4/5 b = '0'*1 """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreatePEP8Style()) style.DEFAULT_STYLE = self.current_style def testOperatorPrecedenceStyle(self): try: - pep8_with_precedence = style.CreatePEP8Style() + pep8_with_precedence = style.CreatePEP8Style() pep8_with_precedence['ARITHMETIC_PRECEDENCE_INDICATION'] = True style.SetGlobalStyle(pep8_with_precedence) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ 1+2 (1 + 2) * (3 - (4 / 5)) a = 1 * 2 + 3 / 4 @@ -98,7 +105,8 @@ def testOperatorPrecedenceStyle(self): j = (1 * 2 - 3) + 4 k = (1 * 2 * 3) + (4 * 5 * 6 * 7 * 8) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ 1 + 2 (1+2) * (3 - (4/5)) a = 1*2 + 3/4 @@ -115,19 +123,20 @@ def testOperatorPrecedenceStyle(self): """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreatePEP8Style()) style.DEFAULT_STYLE = self.current_style def testNoSplitBeforeFirstArgumentStyle1(self): try: - pep8_no_split_before_first = style.CreatePEP8Style() + pep8_no_split_before_first = style.CreatePEP8Style() pep8_no_split_before_first['SPLIT_BEFORE_FIRST_ARGUMENT'] = False - pep8_no_split_before_first['SPLIT_BEFORE_NAMED_ASSIGNS'] = False + pep8_no_split_before_first['SPLIT_BEFORE_NAMED_ASSIGNS'] = False style.SetGlobalStyle(pep8_no_split_before_first) - formatted_code = textwrap.dedent("""\ + formatted_code = textwrap.dedent( + """\ # Example from in-code MustSplit comments foo = outer_function_call(fitting_inner_function_call(inner_arg1, inner_arg2), outer_arg1, outer_arg2) @@ -164,11 +173,12 @@ def testNoSplitBeforeFirstArgumentStyle1(self): def testNoSplitBeforeFirstArgumentStyle2(self): try: - pep8_no_split_before_first = style.CreatePEP8Style() + pep8_no_split_before_first = style.CreatePEP8Style() pep8_no_split_before_first['SPLIT_BEFORE_FIRST_ARGUMENT'] = False - pep8_no_split_before_first['SPLIT_BEFORE_NAMED_ASSIGNS'] = True + pep8_no_split_before_first['SPLIT_BEFORE_NAMED_ASSIGNS'] = True style.SetGlobalStyle(pep8_no_split_before_first) - formatted_code = textwrap.dedent("""\ + formatted_code = textwrap.dedent( + """\ # Examples Issue#556 i_take_a_lot_of_params(arg1, param1=very_long_expression1(), diff --git a/yapftests/reformatter_verify_test.py b/yapftests/reformatter_verify_test.py index 33ba3a614..2abbd19ff 100644 --- a/yapftests/reformatter_verify_test.py +++ b/yapftests/reformatter_verify_test.py @@ -32,7 +32,8 @@ def setUpClass(cls): style.SetGlobalStyle(style.CreatePEP8Style()) def testVerifyException(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ class ABC(metaclass=type): pass """) @@ -42,20 +43,23 @@ class ABC(metaclass=type): reformatter.Reformat(llines) # verify should be False by default. def testNoVerify(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ class ABC(metaclass=type): pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ class ABC(metaclass=type): pass """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines, verify=False)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines, verify=False)) def testVerifyFutureImport(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ from __future__ import print_function def call_my_function(the_function): @@ -68,7 +72,8 @@ def call_my_function(the_function): with self.assertRaises(verifier.InternalError): reformatter.Reformat(llines, verify=True) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ from __future__ import print_function @@ -80,11 +85,12 @@ def call_my_function(the_function): call_my_function(print) """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines, verify=False)) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines, verify=False)) def testContinuationLineShouldBeDistinguished(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ class Foo(object): def bar(self): diff --git a/yapftests/split_penalty_test.py b/yapftests/split_penalty_test.py index f7474a398..24226cbac 100644 --- a/yapftests/split_penalty_test.py +++ b/yapftests/split_penalty_test.py @@ -26,10 +26,10 @@ from yapftests import yapf_test_helper -UNBREAKABLE = split_penalty.UNBREAKABLE +UNBREAKABLE = split_penalty.UNBREAKABLE VERY_STRONGLY_CONNECTED = split_penalty.VERY_STRONGLY_CONNECTED -DOTTED_NAME = split_penalty.DOTTED_NAME -STRONGLY_CONNECTED = split_penalty.STRONGLY_CONNECTED +DOTTED_NAME = split_penalty.DOTTED_NAME +STRONGLY_CONNECTED = split_penalty.STRONGLY_CONNECTED class SplitPenaltyTest(yapf_test_helper.YAPFTest): @@ -68,9 +68,12 @@ def FlattenRec(tree): if pytree_utils.NodeName(tree) in pytree_utils.NONSEMANTIC_TOKENS: return [] if isinstance(tree, pytree.Leaf): - return [(tree.value, - pytree_utils.GetNodeAnnotation( - tree, pytree_utils.Annotation.SPLIT_PENALTY))] + return [ + ( + tree.value, + pytree_utils.GetNodeAnnotation( + tree, pytree_utils.Annotation.SPLIT_PENALTY)) + ] nodes = [] for node in tree.children: nodes += FlattenRec(node) @@ -85,181 +88,194 @@ def foo(x): pass """) tree = self._ParseAndComputePenalties(code) - self._CheckPenalties(tree, [ - ('def', None), - ('foo', UNBREAKABLE), - ('(', UNBREAKABLE), - ('x', None), - (')', STRONGLY_CONNECTED), - (':', UNBREAKABLE), - ('pass', None), - ]) + self._CheckPenalties( + tree, [ + ('def', None), + ('foo', UNBREAKABLE), + ('(', UNBREAKABLE), + ('x', None), + (')', STRONGLY_CONNECTED), + (':', UNBREAKABLE), + ('pass', None), + ]) # Test function definition with trailing comment. - code = textwrap.dedent(r""" + code = textwrap.dedent( + r""" def foo(x): # trailing comment pass """) tree = self._ParseAndComputePenalties(code) - self._CheckPenalties(tree, [ - ('def', None), - ('foo', UNBREAKABLE), - ('(', UNBREAKABLE), - ('x', None), - (')', STRONGLY_CONNECTED), - (':', UNBREAKABLE), - ('pass', None), - ]) + self._CheckPenalties( + tree, [ + ('def', None), + ('foo', UNBREAKABLE), + ('(', UNBREAKABLE), + ('x', None), + (')', STRONGLY_CONNECTED), + (':', UNBREAKABLE), + ('pass', None), + ]) # Test class definitions. - code = textwrap.dedent(r""" + code = textwrap.dedent( + r""" class A: pass class B(A): pass """) tree = self._ParseAndComputePenalties(code) - self._CheckPenalties(tree, [ - ('class', None), - ('A', UNBREAKABLE), - (':', UNBREAKABLE), - ('pass', None), - ('class', None), - ('B', UNBREAKABLE), - ('(', UNBREAKABLE), - ('A', None), - (')', None), - (':', UNBREAKABLE), - ('pass', None), - ]) + self._CheckPenalties( + tree, [ + ('class', None), + ('A', UNBREAKABLE), + (':', UNBREAKABLE), + ('pass', None), + ('class', None), + ('B', UNBREAKABLE), + ('(', UNBREAKABLE), + ('A', None), + (')', None), + (':', UNBREAKABLE), + ('pass', None), + ]) # Test lambda definitions. code = textwrap.dedent(r""" lambda a, b: None """) tree = self._ParseAndComputePenalties(code) - self._CheckPenalties(tree, [ - ('lambda', None), - ('a', VERY_STRONGLY_CONNECTED), - (',', VERY_STRONGLY_CONNECTED), - ('b', VERY_STRONGLY_CONNECTED), - (':', VERY_STRONGLY_CONNECTED), - ('None', VERY_STRONGLY_CONNECTED), - ]) + self._CheckPenalties( + tree, [ + ('lambda', None), + ('a', VERY_STRONGLY_CONNECTED), + (',', VERY_STRONGLY_CONNECTED), + ('b', VERY_STRONGLY_CONNECTED), + (':', VERY_STRONGLY_CONNECTED), + ('None', VERY_STRONGLY_CONNECTED), + ]) # Test dotted names. code = textwrap.dedent(r""" import a.b.c """) tree = self._ParseAndComputePenalties(code) - self._CheckPenalties(tree, [ - ('import', None), - ('a', None), - ('.', UNBREAKABLE), - ('b', UNBREAKABLE), - ('.', UNBREAKABLE), - ('c', UNBREAKABLE), - ]) + self._CheckPenalties( + tree, [ + ('import', None), + ('a', None), + ('.', UNBREAKABLE), + ('b', UNBREAKABLE), + ('.', UNBREAKABLE), + ('c', UNBREAKABLE), + ]) def testStronglyConnected(self): # Test dictionary keys. - code = textwrap.dedent(r""" + code = textwrap.dedent( + r""" a = { 'x': 42, y(lambda a: 23): 37, } """) tree = self._ParseAndComputePenalties(code) - self._CheckPenalties(tree, [ - ('a', None), - ('=', None), - ('{', None), - ("'x'", None), - (':', STRONGLY_CONNECTED), - ('42', None), - (',', None), - ('y', None), - ('(', UNBREAKABLE), - ('lambda', STRONGLY_CONNECTED), - ('a', VERY_STRONGLY_CONNECTED), - (':', VERY_STRONGLY_CONNECTED), - ('23', VERY_STRONGLY_CONNECTED), - (')', VERY_STRONGLY_CONNECTED), - (':', STRONGLY_CONNECTED), - ('37', None), - (',', None), - ('}', None), - ]) + self._CheckPenalties( + tree, [ + ('a', None), + ('=', None), + ('{', None), + ("'x'", None), + (':', STRONGLY_CONNECTED), + ('42', None), + (',', None), + ('y', None), + ('(', UNBREAKABLE), + ('lambda', STRONGLY_CONNECTED), + ('a', VERY_STRONGLY_CONNECTED), + (':', VERY_STRONGLY_CONNECTED), + ('23', VERY_STRONGLY_CONNECTED), + (')', VERY_STRONGLY_CONNECTED), + (':', STRONGLY_CONNECTED), + ('37', None), + (',', None), + ('}', None), + ]) # Test list comprehension. code = textwrap.dedent(r""" [a for a in foo if a.x == 37] """) tree = self._ParseAndComputePenalties(code) - self._CheckPenalties(tree, [ - ('[', None), - ('a', None), - ('for', 0), - ('a', STRONGLY_CONNECTED), - ('in', STRONGLY_CONNECTED), - ('foo', STRONGLY_CONNECTED), - ('if', 0), - ('a', STRONGLY_CONNECTED), - ('.', VERY_STRONGLY_CONNECTED), - ('x', DOTTED_NAME), - ('==', STRONGLY_CONNECTED), - ('37', STRONGLY_CONNECTED), - (']', None), - ]) + self._CheckPenalties( + tree, [ + ('[', None), + ('a', None), + ('for', 0), + ('a', STRONGLY_CONNECTED), + ('in', STRONGLY_CONNECTED), + ('foo', STRONGLY_CONNECTED), + ('if', 0), + ('a', STRONGLY_CONNECTED), + ('.', VERY_STRONGLY_CONNECTED), + ('x', DOTTED_NAME), + ('==', STRONGLY_CONNECTED), + ('37', STRONGLY_CONNECTED), + (']', None), + ]) def testFuncCalls(self): code = 'foo(1, 2, 3)\n' tree = self._ParseAndComputePenalties(code) - self._CheckPenalties(tree, [ - ('foo', None), - ('(', UNBREAKABLE), - ('1', None), - (',', UNBREAKABLE), - ('2', None), - (',', UNBREAKABLE), - ('3', None), - (')', VERY_STRONGLY_CONNECTED), - ]) + self._CheckPenalties( + tree, [ + ('foo', None), + ('(', UNBREAKABLE), + ('1', None), + (',', UNBREAKABLE), + ('2', None), + (',', UNBREAKABLE), + ('3', None), + (')', VERY_STRONGLY_CONNECTED), + ]) # Now a method call, which has more than one trailer code = 'foo.bar.baz(1, 2, 3)\n' tree = self._ParseAndComputePenalties(code) - self._CheckPenalties(tree, [ - ('foo', None), - ('.', VERY_STRONGLY_CONNECTED), - ('bar', DOTTED_NAME), - ('.', VERY_STRONGLY_CONNECTED), - ('baz', DOTTED_NAME), - ('(', STRONGLY_CONNECTED), - ('1', None), - (',', UNBREAKABLE), - ('2', None), - (',', UNBREAKABLE), - ('3', None), - (')', VERY_STRONGLY_CONNECTED), - ]) + self._CheckPenalties( + tree, [ + ('foo', None), + ('.', VERY_STRONGLY_CONNECTED), + ('bar', DOTTED_NAME), + ('.', VERY_STRONGLY_CONNECTED), + ('baz', DOTTED_NAME), + ('(', STRONGLY_CONNECTED), + ('1', None), + (',', UNBREAKABLE), + ('2', None), + (',', UNBREAKABLE), + ('3', None), + (')', VERY_STRONGLY_CONNECTED), + ]) # Test single generator argument. code = 'max(i for i in xrange(10))\n' tree = self._ParseAndComputePenalties(code) - self._CheckPenalties(tree, [ - ('max', None), - ('(', UNBREAKABLE), - ('i', 0), - ('for', 0), - ('i', STRONGLY_CONNECTED), - ('in', STRONGLY_CONNECTED), - ('xrange', STRONGLY_CONNECTED), - ('(', UNBREAKABLE), - ('10', STRONGLY_CONNECTED), - (')', VERY_STRONGLY_CONNECTED), - (')', VERY_STRONGLY_CONNECTED), - ]) + self._CheckPenalties( + tree, [ + ('max', None), + ('(', UNBREAKABLE), + ('i', 0), + ('for', 0), + ('i', STRONGLY_CONNECTED), + ('in', STRONGLY_CONNECTED), + ('xrange', STRONGLY_CONNECTED), + ('(', UNBREAKABLE), + ('10', STRONGLY_CONNECTED), + (')', VERY_STRONGLY_CONNECTED), + (')', VERY_STRONGLY_CONNECTED), + ]) if __name__ == '__main__': diff --git a/yapftests/style_test.py b/yapftests/style_test.py index 8a37f9535..bbd9f567f 100644 --- a/yapftests/style_test.py +++ b/yapftests/style_test.py @@ -50,8 +50,8 @@ def testContinuationAlignStyleStringConverter(self): 'VALIGN-RIGHT') with self.assertRaises(ValueError) as ctx: style._ContinuationAlignStyleStringConverter('blahblah') - self.assertIn("unknown continuation align style: 'blahblah'", - str(ctx.exception)) + self.assertIn( + "unknown continuation align style: 'blahblah'", str(ctx.exception)) def testStringListConverter(self): self.assertEqual(style._StringListConverter('foo, bar'), ['foo', 'bar']) @@ -136,7 +136,8 @@ def tearDownClass(cls): # pylint: disable=g-missing-super-call shutil.rmtree(cls.test_tmpdir) def testDefaultBasedOnStyle(self): - cfg = textwrap.dedent(u'''\ + cfg = textwrap.dedent( + u'''\ [style] continuation_indent_width = 20 ''') @@ -146,7 +147,8 @@ def testDefaultBasedOnStyle(self): self.assertEqual(cfg['CONTINUATION_INDENT_WIDTH'], 20) def testDefaultBasedOnPEP8Style(self): - cfg = textwrap.dedent(u'''\ + cfg = textwrap.dedent( + u'''\ [style] based_on_style = pep8 continuation_indent_width = 40 @@ -157,7 +159,8 @@ def testDefaultBasedOnPEP8Style(self): self.assertEqual(cfg['CONTINUATION_INDENT_WIDTH'], 40) def testDefaultBasedOnGoogleStyle(self): - cfg = textwrap.dedent(u'''\ + cfg = textwrap.dedent( + u'''\ [style] based_on_style = google continuation_indent_width = 20 @@ -168,7 +171,8 @@ def testDefaultBasedOnGoogleStyle(self): self.assertEqual(cfg['CONTINUATION_INDENT_WIDTH'], 20) def testDefaultBasedOnFacebookStyle(self): - cfg = textwrap.dedent(u'''\ + cfg = textwrap.dedent( + u'''\ [style] based_on_style = facebook continuation_indent_width = 20 @@ -179,7 +183,8 @@ def testDefaultBasedOnFacebookStyle(self): self.assertEqual(cfg['CONTINUATION_INDENT_WIDTH'], 20) def testBoolOptionValue(self): - cfg = textwrap.dedent(u'''\ + cfg = textwrap.dedent( + u'''\ [style] based_on_style = pep8 SPLIT_BEFORE_NAMED_ASSIGNS=False @@ -192,7 +197,8 @@ def testBoolOptionValue(self): self.assertEqual(cfg['SPLIT_BEFORE_LOGICAL_OPERATOR'], True) def testStringListOptionValue(self): - cfg = textwrap.dedent(u'''\ + cfg = textwrap.dedent( + u'''\ [style] based_on_style = pep8 I18N_FUNCTION_CALL = N_, V_, T_ @@ -218,7 +224,8 @@ def testErrorNoStyleSection(self): style.CreateStyleFromConfig(filepath) def testErrorUnknownStyleOption(self): - cfg = textwrap.dedent(u'''\ + cfg = textwrap.dedent( + u'''\ [style] indent_width=2 hummus=2 @@ -235,7 +242,7 @@ def testPyprojectTomlNoYapfSection(self): return filepath = os.path.join(self.test_tmpdir, 'pyproject.toml') - _ = open(filepath, 'w') + _ = open(filepath, 'w') with self.assertRaisesRegex(style.StyleConfigError, 'Unable to find section'): style.CreateStyleFromConfig(filepath) @@ -246,7 +253,8 @@ def testPyprojectTomlParseYapfSection(self): except ImportError: return - cfg = textwrap.dedent(u'''\ + cfg = textwrap.dedent( + u'''\ [tool.yapf] based_on_style = "pep8" continuation_indent_width = 40 @@ -267,21 +275,21 @@ def setUpClass(cls): # pylint: disable=g-missing-super-call def testDefaultBasedOnStyle(self): config_dict = { - 'based_on_style': 'pep8', - 'indent_width': 2, - 'blank_line_before_nested_class_or_def': True + 'based_on_style' : 'pep8', + 'indent_width' : 2, + 'blank_line_before_nested_class_or_def' : True } cfg = style.CreateStyleFromConfig(config_dict) self.assertTrue(_LooksLikePEP8Style(cfg)) self.assertEqual(cfg['INDENT_WIDTH'], 2) def testDefaultBasedOnStyleBadDict(self): - self.assertRaisesRegex(style.StyleConfigError, 'Unknown style option', - style.CreateStyleFromConfig, - {'based_on_styl': 'pep8'}) - self.assertRaisesRegex(style.StyleConfigError, 'not a valid', - style.CreateStyleFromConfig, - {'INDENT_WIDTH': 'FOUR'}) + self.assertRaisesRegex( + style.StyleConfigError, 'Unknown style option', + style.CreateStyleFromConfig, {'based_on_styl': 'pep8'}) + self.assertRaisesRegex( + style.StyleConfigError, 'not a valid', style.CreateStyleFromConfig, + {'INDENT_WIDTH': 'FOUR'}) class StyleFromCommandLine(yapf_test_helper.YAPFTest): @@ -315,12 +323,15 @@ def testDefaultBasedOnDetaultTypeString(self): self.assertIsInstance(cfg, dict) def testDefaultBasedOnStyleBadString(self): - self.assertRaisesRegex(style.StyleConfigError, 'Unknown style option', - style.CreateStyleFromConfig, '{based_on_styl: pep8}') - self.assertRaisesRegex(style.StyleConfigError, 'not a valid', - style.CreateStyleFromConfig, '{INDENT_WIDTH: FOUR}') - self.assertRaisesRegex(style.StyleConfigError, 'Invalid style dict', - style.CreateStyleFromConfig, '{based_on_style: pep8') + self.assertRaisesRegex( + style.StyleConfigError, 'Unknown style option', + style.CreateStyleFromConfig, '{based_on_styl: pep8}') + self.assertRaisesRegex( + style.StyleConfigError, 'not a valid', style.CreateStyleFromConfig, + '{INDENT_WIDTH: FOUR}') + self.assertRaisesRegex( + style.StyleConfigError, 'Invalid style dict', + style.CreateStyleFromConfig, '{based_on_style: pep8') class StyleHelp(yapf_test_helper.YAPFTest): diff --git a/yapftests/subtype_assigner_test.py b/yapftests/subtype_assigner_test.py index 97f9cd3ac..75efb00df 100644 --- a/yapftests/subtype_assigner_test.py +++ b/yapftests/subtype_assigner_test.py @@ -35,9 +35,11 @@ def _CheckFormatTokenSubtypes(self, llines, list_of_expected): """ actual = [] for lline in llines: - filtered_values = [(ft.value, ft.subtypes) - for ft in lline.tokens - if ft.name not in pytree_utils.NONSEMANTIC_TOKENS] + filtered_values = [ + (ft.value, ft.subtypes) + for ft in lline.tokens + if ft.name not in pytree_utils.NONSEMANTIC_TOKENS + ] if filtered_values: actual.append(filtered_values) @@ -45,323 +47,352 @@ def _CheckFormatTokenSubtypes(self, llines, list_of_expected): def testFuncDefDefaultAssign(self): self.maxDiff = None # pylint: disable=invalid-name - code = textwrap.dedent(r""" + code = textwrap.dedent( + r""" def foo(a=37, *b, **c): return -x[:42] """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckFormatTokenSubtypes(llines, [ - [ - ('def', {subtypes.NONE}), - ('foo', {subtypes.FUNC_DEF}), - ('(', {subtypes.NONE}), - ('a', { - subtypes.NONE, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, - subtypes.PARAMETER_START, - }), - ('=', { - subtypes.DEFAULT_OR_NAMED_ASSIGN, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, - }), - ('37', { - subtypes.NONE, - subtypes.PARAMETER_STOP, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, - }), - (',', {subtypes.NONE}), - ('*', { - subtypes.PARAMETER_START, - subtypes.VARARGS_STAR, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, - }), - ('b', { - subtypes.NONE, - subtypes.PARAMETER_STOP, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, - }), - (',', {subtypes.NONE}), - ('**', { - subtypes.PARAMETER_START, - subtypes.KWARGS_STAR_STAR, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, - }), - ('c', { - subtypes.NONE, - subtypes.PARAMETER_STOP, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, - }), - (')', {subtypes.NONE}), - (':', {subtypes.NONE}), - ], - [ - ('return', {subtypes.NONE}), - ('-', {subtypes.UNARY_OPERATOR}), - ('x', {subtypes.NONE}), - ('[', {subtypes.SUBSCRIPT_BRACKET}), - (':', {subtypes.SUBSCRIPT_COLON}), - ('42', {subtypes.NONE}), - (']', {subtypes.SUBSCRIPT_BRACKET}), - ], - ]) + self._CheckFormatTokenSubtypes( + llines, [ + [ + ('def', {subtypes.NONE}), + ('foo', {subtypes.FUNC_DEF}), + ('(', {subtypes.NONE}), + ( + 'a', { + subtypes.NONE, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, + subtypes.PARAMETER_START, + }), + ( + '=', { + subtypes.DEFAULT_OR_NAMED_ASSIGN, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, + }), + ( + '37', { + subtypes.NONE, + subtypes.PARAMETER_STOP, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, + }), + (',', {subtypes.NONE}), + ( + '*', { + subtypes.PARAMETER_START, + subtypes.VARARGS_STAR, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, + }), + ( + 'b', { + subtypes.NONE, + subtypes.PARAMETER_STOP, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, + }), + (',', {subtypes.NONE}), + ( + '**', { + subtypes.PARAMETER_START, + subtypes.KWARGS_STAR_STAR, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, + }), + ( + 'c', { + subtypes.NONE, + subtypes.PARAMETER_STOP, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, + }), + (')', {subtypes.NONE}), + (':', {subtypes.NONE}), + ], + [ + ('return', {subtypes.NONE}), + ('-', {subtypes.UNARY_OPERATOR}), + ('x', {subtypes.NONE}), + ('[', {subtypes.SUBSCRIPT_BRACKET}), + (':', {subtypes.SUBSCRIPT_COLON}), + ('42', {subtypes.NONE}), + (']', {subtypes.SUBSCRIPT_BRACKET}), + ], + ]) def testFuncCallWithDefaultAssign(self): - code = textwrap.dedent(r""" + code = textwrap.dedent(r""" foo(x, a='hello world') """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckFormatTokenSubtypes(llines, [ - [ - ('foo', {subtypes.NONE}), - ('(', {subtypes.NONE}), - ('x', { - subtypes.NONE, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, - }), - (',', {subtypes.NONE}), - ('a', { - subtypes.NONE, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, - }), - ('=', {subtypes.DEFAULT_OR_NAMED_ASSIGN}), - ("'hello world'", {subtypes.NONE}), - (')', {subtypes.NONE}), - ], - ]) + self._CheckFormatTokenSubtypes( + llines, [ + [ + ('foo', {subtypes.NONE}), + ('(', {subtypes.NONE}), + ( + 'x', { + subtypes.NONE, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, + }), + (',', {subtypes.NONE}), + ( + 'a', { + subtypes.NONE, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, + }), + ('=', {subtypes.DEFAULT_OR_NAMED_ASSIGN}), + ("'hello world'", {subtypes.NONE}), + (')', {subtypes.NONE}), + ], + ]) #----test comment subtype inside the argument list---- def testCommentSubtypesInsideArglist(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ foo( # comment x, a='hello world') """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckFormatTokenSubtypes(llines, [ - [ - ('foo', {subtypes.NONE}), - ('(', {subtypes.NONE}), - ('# comment', {subtypes.NONE, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST}), - ('x', { - subtypes.NONE, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST}), - (',', {subtypes.NONE}), - ('a', { - subtypes.NONE, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST}), - ('=', {subtypes.DEFAULT_OR_NAMED_ASSIGN}), - ("'hello world'", {subtypes.NONE}), - (')', {subtypes.NONE}), - ], - ]) + self._CheckFormatTokenSubtypes( + llines, [ + [ + ('foo', {subtypes.NONE}), + ('(', {subtypes.NONE}), + ( + '# comment', + {subtypes.NONE, subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST}), + ( + 'x', + {subtypes.NONE, subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST}), + (',', {subtypes.NONE}), + ( + 'a', + {subtypes.NONE, subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST}), + ('=', {subtypes.DEFAULT_OR_NAMED_ASSIGN}), + ("'hello world'", {subtypes.NONE}), + (')', {subtypes.NONE}), + ], + ]) # ----test typed arguments subtypes------ def testTypedArgumentsInsideArglist(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ def foo( self, preprocess: Callable[[str], str] = identity ): pass """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckFormatTokenSubtypes(llines, [ - [ - ('def', {subtypes.NONE}), - ('foo', {subtypes.FUNC_DEF}), - ('(', {subtypes.NONE}), - ('self', {subtypes.NONE, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, - subtypes.PARAMETER_START, - subtypes.PARAMETER_STOP}), - (',', {subtypes.NONE}), - ('preprocess', { - subtypes.NONE, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, - subtypes.PARAMETER_START, - subtypes.TYPED_NAME_ARG_LIST}), - (':', { - subtypes.TYPED_NAME, - subtypes.TYPED_NAME_ARG_LIST}), - ('Callable', {subtypes.TYPED_NAME_ARG_LIST}), - ('[', { - subtypes.SUBSCRIPT_BRACKET, - subtypes.TYPED_NAME_ARG_LIST}), - ('[', {subtypes.TYPED_NAME_ARG_LIST}), - ('str', {subtypes.TYPED_NAME_ARG_LIST}), - (']', {subtypes.TYPED_NAME_ARG_LIST}), - (',', {subtypes.TYPED_NAME_ARG_LIST}), - ('str', {subtypes.TYPED_NAME_ARG_LIST}), - (']', { - subtypes.SUBSCRIPT_BRACKET, - subtypes.TYPED_NAME_ARG_LIST}), - ('=', { - subtypes.DEFAULT_OR_NAMED_ASSIGN, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, - subtypes.TYPED_NAME}), - ('identity', { - subtypes.NONE, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, - subtypes.PARAMETER_STOP}), - (')', {subtypes.NONE}), - (':', {subtypes.NONE})], - [('pass', {subtypes.NONE}), - ], - ]) + self._CheckFormatTokenSubtypes( + llines, [ + [ + ('def', {subtypes.NONE}), ('foo', {subtypes.FUNC_DEF}), + ('(', {subtypes.NONE}), + ( + 'self', { + subtypes.NONE, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, + subtypes.PARAMETER_START, subtypes.PARAMETER_STOP + }), (',', {subtypes.NONE}), + ( + 'preprocess', { + subtypes.NONE, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, + subtypes.PARAMETER_START, subtypes.TYPED_NAME_ARG_LIST + }), + (':', {subtypes.TYPED_NAME, subtypes.TYPED_NAME_ARG_LIST}), + ('Callable', {subtypes.TYPED_NAME_ARG_LIST}), + ( + '[', + {subtypes.SUBSCRIPT_BRACKET, subtypes.TYPED_NAME_ARG_LIST}), + ('[', {subtypes.TYPED_NAME_ARG_LIST}), + ('str', {subtypes.TYPED_NAME_ARG_LIST}), + (']', {subtypes.TYPED_NAME_ARG_LIST}), + (',', {subtypes.TYPED_NAME_ARG_LIST}), + ('str', {subtypes.TYPED_NAME_ARG_LIST}), + ( + ']', + {subtypes.SUBSCRIPT_BRACKET, subtypes.TYPED_NAME_ARG_LIST}), + ( + '=', { + subtypes.DEFAULT_OR_NAMED_ASSIGN, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, + subtypes.TYPED_NAME + }), + ( + 'identity', { + subtypes.NONE, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, + subtypes.PARAMETER_STOP + }), (')', {subtypes.NONE}), (':', {subtypes.NONE}) + ], + [ + ('pass', {subtypes.NONE}), + ], + ]) def testSetComprehension(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ def foo(strs): return {s.lower() for s in strs} """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckFormatTokenSubtypes(llines, [ - [ - ('def', {subtypes.NONE}), - ('foo', {subtypes.FUNC_DEF}), - ('(', {subtypes.NONE}), - ('strs', { - subtypes.NONE, - subtypes.PARAMETER_START, - subtypes.PARAMETER_STOP, - }), - (')', {subtypes.NONE}), - (':', {subtypes.NONE}), - ], - [ - ('return', {subtypes.NONE}), - ('{', {subtypes.NONE}), - ('s', {subtypes.COMP_EXPR}), - ('.', {subtypes.COMP_EXPR}), - ('lower', {subtypes.COMP_EXPR}), - ('(', {subtypes.COMP_EXPR}), - (')', {subtypes.COMP_EXPR}), - ('for', { - subtypes.DICT_SET_GENERATOR, - subtypes.COMP_FOR, - }), - ('s', {subtypes.COMP_FOR}), - ('in', {subtypes.COMP_FOR}), - ('strs', {subtypes.COMP_FOR}), - ('}', {subtypes.NONE}), - ], - ]) + self._CheckFormatTokenSubtypes( + llines, [ + [ + ('def', {subtypes.NONE}), + ('foo', {subtypes.FUNC_DEF}), + ('(', {subtypes.NONE}), + ( + 'strs', { + subtypes.NONE, + subtypes.PARAMETER_START, + subtypes.PARAMETER_STOP, + }), + (')', {subtypes.NONE}), + (':', {subtypes.NONE}), + ], + [ + ('return', {subtypes.NONE}), + ('{', {subtypes.NONE}), + ('s', {subtypes.COMP_EXPR}), + ('.', {subtypes.COMP_EXPR}), + ('lower', {subtypes.COMP_EXPR}), + ('(', {subtypes.COMP_EXPR}), + (')', {subtypes.COMP_EXPR}), + ('for', { + subtypes.DICT_SET_GENERATOR, + subtypes.COMP_FOR, + }), + ('s', {subtypes.COMP_FOR}), + ('in', {subtypes.COMP_FOR}), + ('strs', {subtypes.COMP_FOR}), + ('}', {subtypes.NONE}), + ], + ]) def testUnaryNotOperator(self): - code = textwrap.dedent("""\ + code = textwrap.dedent("""\ not a """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckFormatTokenSubtypes(llines, [[('not', {subtypes.UNARY_OPERATOR}), - ('a', {subtypes.NONE})]]) + self._CheckFormatTokenSubtypes( + llines, [[('not', {subtypes.UNARY_OPERATOR}), ('a', {subtypes.NONE})]]) def testBitwiseOperators(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ x = ((a | (b ^ 3) & c) << 3) >> 1 """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckFormatTokenSubtypes(llines, [ - [ - ('x', {subtypes.NONE}), - ('=', {subtypes.ASSIGN_OPERATOR}), - ('(', {subtypes.NONE}), - ('(', {subtypes.NONE}), - ('a', {subtypes.NONE}), - ('|', {subtypes.BINARY_OPERATOR}), - ('(', {subtypes.NONE}), - ('b', {subtypes.NONE}), - ('^', {subtypes.BINARY_OPERATOR}), - ('3', {subtypes.NONE}), - (')', {subtypes.NONE}), - ('&', {subtypes.BINARY_OPERATOR}), - ('c', {subtypes.NONE}), - (')', {subtypes.NONE}), - ('<<', {subtypes.BINARY_OPERATOR}), - ('3', {subtypes.NONE}), - (')', {subtypes.NONE}), - ('>>', {subtypes.BINARY_OPERATOR}), - ('1', {subtypes.NONE}), - ], - ]) + self._CheckFormatTokenSubtypes( + llines, [ + [ + ('x', {subtypes.NONE}), + ('=', {subtypes.ASSIGN_OPERATOR}), + ('(', {subtypes.NONE}), + ('(', {subtypes.NONE}), + ('a', {subtypes.NONE}), + ('|', {subtypes.BINARY_OPERATOR}), + ('(', {subtypes.NONE}), + ('b', {subtypes.NONE}), + ('^', {subtypes.BINARY_OPERATOR}), + ('3', {subtypes.NONE}), + (')', {subtypes.NONE}), + ('&', {subtypes.BINARY_OPERATOR}), + ('c', {subtypes.NONE}), + (')', {subtypes.NONE}), + ('<<', {subtypes.BINARY_OPERATOR}), + ('3', {subtypes.NONE}), + (')', {subtypes.NONE}), + ('>>', {subtypes.BINARY_OPERATOR}), + ('1', {subtypes.NONE}), + ], + ]) def testArithmeticOperators(self): - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ x = ((a + (b - 3) * (1 % c) @ d) / 3) // 1 """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckFormatTokenSubtypes(llines, [ - [ - ('x', {subtypes.NONE}), - ('=', {subtypes.ASSIGN_OPERATOR}), - ('(', {subtypes.NONE}), - ('(', {subtypes.NONE}), - ('a', {subtypes.NONE}), - ('+', {subtypes.BINARY_OPERATOR}), - ('(', {subtypes.NONE}), - ('b', {subtypes.NONE}), - ('-', { - subtypes.BINARY_OPERATOR, - subtypes.SIMPLE_EXPRESSION, - }), - ('3', {subtypes.NONE}), - (')', {subtypes.NONE}), - ('*', {subtypes.BINARY_OPERATOR}), - ('(', {subtypes.NONE}), - ('1', {subtypes.NONE}), - ('%', { - subtypes.BINARY_OPERATOR, - subtypes.SIMPLE_EXPRESSION, - }), - ('c', {subtypes.NONE}), - (')', {subtypes.NONE}), - ('@', {subtypes.BINARY_OPERATOR}), - ('d', {subtypes.NONE}), - (')', {subtypes.NONE}), - ('/', {subtypes.BINARY_OPERATOR}), - ('3', {subtypes.NONE}), - (')', {subtypes.NONE}), - ('//', {subtypes.BINARY_OPERATOR}), - ('1', {subtypes.NONE}), - ], - ]) + self._CheckFormatTokenSubtypes( + llines, [ + [ + ('x', {subtypes.NONE}), + ('=', {subtypes.ASSIGN_OPERATOR}), + ('(', {subtypes.NONE}), + ('(', {subtypes.NONE}), + ('a', {subtypes.NONE}), + ('+', {subtypes.BINARY_OPERATOR}), + ('(', {subtypes.NONE}), + ('b', {subtypes.NONE}), + ('-', { + subtypes.BINARY_OPERATOR, + subtypes.SIMPLE_EXPRESSION, + }), + ('3', {subtypes.NONE}), + (')', {subtypes.NONE}), + ('*', {subtypes.BINARY_OPERATOR}), + ('(', {subtypes.NONE}), + ('1', {subtypes.NONE}), + ('%', { + subtypes.BINARY_OPERATOR, + subtypes.SIMPLE_EXPRESSION, + }), + ('c', {subtypes.NONE}), + (')', {subtypes.NONE}), + ('@', {subtypes.BINARY_OPERATOR}), + ('d', {subtypes.NONE}), + (')', {subtypes.NONE}), + ('/', {subtypes.BINARY_OPERATOR}), + ('3', {subtypes.NONE}), + (')', {subtypes.NONE}), + ('//', {subtypes.BINARY_OPERATOR}), + ('1', {subtypes.NONE}), + ], + ]) def testSubscriptColon(self): - code = textwrap.dedent("""\ + code = textwrap.dedent("""\ x[0:42:1] """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckFormatTokenSubtypes(llines, [ - [ - ('x', {subtypes.NONE}), - ('[', {subtypes.SUBSCRIPT_BRACKET}), - ('0', {subtypes.NONE}), - (':', {subtypes.SUBSCRIPT_COLON}), - ('42', {subtypes.NONE}), - (':', {subtypes.SUBSCRIPT_COLON}), - ('1', {subtypes.NONE}), - (']', {subtypes.SUBSCRIPT_BRACKET}), - ], - ]) + self._CheckFormatTokenSubtypes( + llines, [ + [ + ('x', {subtypes.NONE}), + ('[', {subtypes.SUBSCRIPT_BRACKET}), + ('0', {subtypes.NONE}), + (':', {subtypes.SUBSCRIPT_COLON}), + ('42', {subtypes.NONE}), + (':', {subtypes.SUBSCRIPT_COLON}), + ('1', {subtypes.NONE}), + (']', {subtypes.SUBSCRIPT_BRACKET}), + ], + ]) def testFunctionCallWithStarExpression(self): - code = textwrap.dedent("""\ + code = textwrap.dedent("""\ [a, *b] """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckFormatTokenSubtypes(llines, [ - [ - ('[', {subtypes.NONE}), - ('a', {subtypes.NONE}), - (',', {subtypes.NONE}), - ('*', { - subtypes.UNARY_OPERATOR, - subtypes.VARARGS_STAR, - }), - ('b', {subtypes.NONE}), - (']', {subtypes.NONE}), - ], - ]) + self._CheckFormatTokenSubtypes( + llines, [ + [ + ('[', {subtypes.NONE}), + ('a', {subtypes.NONE}), + (',', {subtypes.NONE}), + ('*', { + subtypes.UNARY_OPERATOR, + subtypes.VARARGS_STAR, + }), + ('b', {subtypes.NONE}), + (']', {subtypes.NONE}), + ], + ]) if __name__ == '__main__': diff --git a/yapftests/utils.py b/yapftests/utils.py index 268b8c43a..cfcc51010 100644 --- a/yapftests/utils.py +++ b/yapftests/utils.py @@ -42,15 +42,16 @@ def stdout_redirector(stream): # pylint: disable=invalid-name # Note: `buffering` is set to -1 despite documentation of NamedTemporaryFile # says None. This is probably a problem with the python documentation. @contextlib.contextmanager -def NamedTempFile(mode='w+b', - buffering=-1, - encoding=None, - errors=None, - newline=None, - suffix=None, - prefix=None, - dirname=None, - text=False): +def NamedTempFile( + mode ='w+b', + buffering =-1, + encoding =None, + errors =None, + newline =None, + suffix =None, + prefix =None, + dirname =None, + text =False): """Context manager creating a new temporary file in text mode.""" if sys.version_info < (3, 5): # covers also python 2 if suffix is None: @@ -61,29 +62,22 @@ def NamedTempFile(mode='w+b', suffix=suffix, prefix=prefix, dir=dirname, text=text) f = io.open( fd, - mode=mode, - buffering=buffering, - encoding=encoding, - errors=errors, - newline=newline) + mode =mode, + buffering =buffering, + encoding =encoding, + errors =errors, + newline =newline) yield f, fname f.close() os.remove(fname) @contextlib.contextmanager -def TempFileContents(dirname, - contents, - encoding='utf-8', - newline='', - suffix=None): +def TempFileContents( + dirname, contents, encoding='utf-8', newline='', suffix=None): # Note: NamedTempFile properly handles unicode encoding when using mode='w' - with NamedTempFile( - dirname=dirname, - mode='w', - encoding=encoding, - newline=newline, - suffix=suffix) as (f, fname): + with NamedTempFile(dirname=dirname, mode='w', encoding=encoding, + newline=newline, suffix=suffix) as (f, fname): f.write(contents) f.flush() yield fname diff --git a/yapftests/yapf_test.py b/yapftests/yapf_test.py index 2330f4e18..9eee1a9f0 100644 --- a/yapftests/yapf_test.py +++ b/yapftests/yapf_test.py @@ -54,10 +54,11 @@ def testSimple(self): self._Check(unformatted_code, unformatted_code) def testNoEndingNewline(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent("""\ if True: pass""") - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ if True: pass """) @@ -65,7 +66,7 @@ def testNoEndingNewline(self): @unittest.skipUnless(py3compat.PY36, 'Requires Python 3.6') def testPrintAfterPeriod(self): - unformatted_code = textwrap.dedent("""a.print\n""") + unformatted_code = textwrap.dedent("""a.print\n""") expected_formatted_code = textwrap.dedent("""a.print\n""") self._Check(unformatted_code, expected_formatted_code) @@ -80,7 +81,7 @@ def tearDown(self): # pylint: disable=g-missing-super-call def assertCodeEqual(self, expected_code, code): if code != expected_code: - msg = 'Code format mismatch:\n' + msg = 'Code format mismatch:\n' msg += 'Expected:\n >' msg += '\n > '.join(expected_code.splitlines()) msg += '\nActual:\n >' @@ -89,15 +90,18 @@ def assertCodeEqual(self, expected_code, code): self.fail(msg) def testFormatFile(self): - unformatted_code = textwrap.dedent(u"""\ + unformatted_code = textwrap.dedent( + u"""\ if True: pass """) - expected_formatted_code_pep8 = textwrap.dedent(u"""\ + expected_formatted_code_pep8 = textwrap.dedent( + u"""\ if True: pass """) - expected_formatted_code_yapf = textwrap.dedent(u"""\ + expected_formatted_code_yapf = textwrap.dedent( + u"""\ if True: pass """) @@ -109,7 +113,8 @@ def testFormatFile(self): self.assertCodeEqual(expected_formatted_code_yapf, formatted_code) def testDisableLinesPattern(self): - unformatted_code = textwrap.dedent(u"""\ + unformatted_code = textwrap.dedent( + u"""\ if a: b # yapf: disable @@ -117,7 +122,8 @@ def testDisableLinesPattern(self): if h: i """) - expected_formatted_code = textwrap.dedent(u"""\ + expected_formatted_code = textwrap.dedent( + u"""\ if a: b # yapf: disable @@ -130,7 +136,8 @@ def testDisableLinesPattern(self): self.assertCodeEqual(expected_formatted_code, formatted_code) def testDisableAndReenableLinesPattern(self): - unformatted_code = textwrap.dedent(u"""\ + unformatted_code = textwrap.dedent( + u"""\ if a: b # yapf: disable @@ -139,7 +146,8 @@ def testDisableAndReenableLinesPattern(self): if h: i """) - expected_formatted_code = textwrap.dedent(u"""\ + expected_formatted_code = textwrap.dedent( + u"""\ if a: b # yapf: disable @@ -153,7 +161,8 @@ def testDisableAndReenableLinesPattern(self): self.assertCodeEqual(expected_formatted_code, formatted_code) def testDisablePartOfMultilineComment(self): - unformatted_code = textwrap.dedent(u"""\ + unformatted_code = textwrap.dedent( + u"""\ if a: b # This is a multiline comment that disables YAPF. @@ -165,7 +174,8 @@ def testDisablePartOfMultilineComment(self): if h: i """) - expected_formatted_code = textwrap.dedent(u"""\ + expected_formatted_code = textwrap.dedent( + u"""\ if a: b # This is a multiline comment that disables YAPF. @@ -180,7 +190,8 @@ def testDisablePartOfMultilineComment(self): formatted_code, _, _ = yapf_api.FormatFile(filepath, style_config='pep8') self.assertCodeEqual(expected_formatted_code, formatted_code) - code = textwrap.dedent(u"""\ + code = textwrap.dedent( + u"""\ def foo_function(): # some comment # yapf: disable @@ -197,7 +208,8 @@ def foo_function(): self.assertCodeEqual(code, formatted_code) def testEnabledDisabledSameComment(self): - code = textwrap.dedent(u"""\ + code = textwrap.dedent( + u"""\ # yapf: disable a(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb, ccccccccccccccccccccccccccccccc, ddddddddddddddddddddddd, eeeeeeeeeeeeeeeeeeeeeeeeeee) # yapf: enable @@ -210,21 +222,24 @@ def testEnabledDisabledSameComment(self): self.assertCodeEqual(code, formatted_code) def testFormatFileLinesSelection(self): - unformatted_code = textwrap.dedent(u"""\ + unformatted_code = textwrap.dedent( + u"""\ if a: b if f: g if h: i """) - expected_formatted_code_lines1and2 = textwrap.dedent(u"""\ + expected_formatted_code_lines1and2 = textwrap.dedent( + u"""\ if a: b if f: g if h: i """) - expected_formatted_code_lines3 = textwrap.dedent(u"""\ + expected_formatted_code_lines3 = textwrap.dedent( + u"""\ if a: b if f: g @@ -240,7 +255,8 @@ def testFormatFileLinesSelection(self): self.assertCodeEqual(expected_formatted_code_lines3, formatted_code) def testFormatFileDiff(self): - unformatted_code = textwrap.dedent(u"""\ + unformatted_code = textwrap.dedent( + u"""\ if True: pass """) @@ -250,7 +266,7 @@ def testFormatFileDiff(self): def testFormatFileInPlace(self): unformatted_code = u'True==False\n' - formatted_code = u'True == False\n' + formatted_code = u'True == False\n' with utils.TempFileContents(self.test_tmpdir, unformatted_code) as filepath: result, _, _ = yapf_api.FormatFile(filepath, in_place=True) self.assertEqual(result, None) @@ -264,21 +280,23 @@ def testFormatFileInPlace(self): ValueError, yapf_api.FormatFile, filepath, - in_place=True, - print_diff=True) + in_place =True, + print_diff =True) def testNoFile(self): - stream = py3compat.StringIO() + stream = py3compat.StringIO() handler = logging.StreamHandler(stream) - logger = logging.getLogger('mylogger') + logger = logging.getLogger('mylogger') logger.addHandler(handler) self.assertRaises( IOError, yapf_api.FormatFile, 'not_a_file.py', logger=logger.error) - self.assertEqual(stream.getvalue(), - "[Errno 2] No such file or directory: 'not_a_file.py'\n") + self.assertEqual( + stream.getvalue(), + "[Errno 2] No such file or directory: 'not_a_file.py'\n") def testCommentsUnformatted(self): - code = textwrap.dedent(u"""\ + code = textwrap.dedent( + u"""\ foo = [# A list of things # bork 'one', @@ -290,7 +308,8 @@ def testCommentsUnformatted(self): self.assertCodeEqual(code, formatted_code) def testDisabledHorizontalFormattingOnNewLine(self): - code = textwrap.dedent(u"""\ + code = textwrap.dedent( + u"""\ # yapf: disable a = [ 1] @@ -301,12 +320,14 @@ def testDisabledHorizontalFormattingOnNewLine(self): self.assertCodeEqual(code, formatted_code) def testSplittingSemicolonStatements(self): - unformatted_code = textwrap.dedent(u"""\ + unformatted_code = textwrap.dedent( + u"""\ def f(): x = y + 42 ; z = n * 42 if True: a += 1 ; b += 1; c += 1 """) - expected_formatted_code = textwrap.dedent(u"""\ + expected_formatted_code = textwrap.dedent( + u"""\ def f(): x = y + 42 z = n * 42 @@ -320,12 +341,14 @@ def f(): self.assertCodeEqual(expected_formatted_code, formatted_code) def testSemicolonStatementsDisabled(self): - unformatted_code = textwrap.dedent(u"""\ + unformatted_code = textwrap.dedent( + u"""\ def f(): x = y + 42 ; z = n * 42 # yapf: disable if True: a += 1 ; b += 1; c += 1 """) - expected_formatted_code = textwrap.dedent(u"""\ + expected_formatted_code = textwrap.dedent( + u"""\ def f(): x = y + 42 ; z = n * 42 # yapf: disable if True: @@ -338,7 +361,8 @@ def f(): self.assertCodeEqual(expected_formatted_code, formatted_code) def testDisabledSemiColonSeparatedStatements(self): - code = textwrap.dedent(u"""\ + code = textwrap.dedent( + u"""\ # yapf: disable if True: a ; b """) @@ -347,7 +371,8 @@ def testDisabledSemiColonSeparatedStatements(self): self.assertCodeEqual(code, formatted_code) def testDisabledMultilineStringInDictionary(self): - code = textwrap.dedent(u"""\ + code = textwrap.dedent( + u"""\ # yapf: disable A = [ @@ -366,7 +391,8 @@ def testDisabledMultilineStringInDictionary(self): self.assertCodeEqual(code, formatted_code) def testDisabledWithPrecedingText(self): - code = textwrap.dedent(u"""\ + code = textwrap.dedent( + u"""\ # TODO(fix formatting): yapf: disable A = [ @@ -402,11 +428,8 @@ def setUpClass(cls): # pylint: disable=g-missing-super-call def tearDownClass(cls): # pylint: disable=g-missing-super-call shutil.rmtree(cls.test_tmpdir) - def assertYapfReformats(self, - unformatted, - expected, - extra_options=None, - env=None): + def assertYapfReformats( + self, unformatted, expected, extra_options=None, env=None): """Check that yapf reformats the given code as expected. Invokes yapf in a subprocess, piping the unformatted code into its stdin. @@ -419,12 +442,12 @@ def assertYapfReformats(self, env: dict of environment variables. """ cmdline = YAPF_BINARY + (extra_options or []) - p = subprocess.Popen( + p = subprocess.Popen( cmdline, - stdout=subprocess.PIPE, - stdin=subprocess.PIPE, - stderr=subprocess.PIPE, - env=env) + stdout =subprocess.PIPE, + stdin =subprocess.PIPE, + stderr =subprocess.PIPE, + env =env) reformatted_code, stderrdata = p.communicate( unformatted.encode('utf-8-sig')) self.assertEqual(stderrdata, b'') @@ -432,27 +455,30 @@ def assertYapfReformats(self, @unittest.skipUnless(py3compat.PY36, 'Requires Python 3.6') def testUnicodeEncodingPipedToFile(self): - unformatted_code = textwrap.dedent(u"""\ + unformatted_code = textwrap.dedent( + u"""\ def foo(): print('⇒') """) - with utils.NamedTempFile( - dirname=self.test_tmpdir, suffix='.py') as (out, _): - with utils.TempFileContents( - self.test_tmpdir, unformatted_code, suffix='.py') as filepath: + with utils.NamedTempFile(dirname=self.test_tmpdir, + suffix='.py') as (out, _): + with utils.TempFileContents(self.test_tmpdir, unformatted_code, + suffix='.py') as filepath: subprocess.check_call(YAPF_BINARY + ['--diff', filepath], stdout=out) def testInPlaceReformatting(self): - unformatted_code = textwrap.dedent(u"""\ + unformatted_code = textwrap.dedent( + u"""\ def foo(): x = 37 """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def foo(): x = 37 """) - with utils.TempFileContents( - self.test_tmpdir, unformatted_code, suffix='.py') as filepath: + with utils.TempFileContents(self.test_tmpdir, unformatted_code, + suffix='.py') as filepath: p = subprocess.Popen(YAPF_BINARY + ['--in-place', filepath]) p.wait() with io.open(filepath, mode='r', newline='') as fd: @@ -460,10 +486,10 @@ def foo(): self.assertEqual(reformatted_code, expected_formatted_code) def testInPlaceReformattingBlank(self): - unformatted_code = u'\n\n' + unformatted_code = u'\n\n' expected_formatted_code = u'\n' - with utils.TempFileContents( - self.test_tmpdir, unformatted_code, suffix='.py') as filepath: + with utils.TempFileContents(self.test_tmpdir, unformatted_code, + suffix='.py') as filepath: p = subprocess.Popen(YAPF_BINARY + ['--in-place', filepath]) p.wait() with io.open(filepath, mode='r', encoding='utf-8', newline='') as fd: @@ -471,10 +497,10 @@ def testInPlaceReformattingBlank(self): self.assertEqual(reformatted_code, expected_formatted_code) def testInPlaceReformattingEmpty(self): - unformatted_code = u'' + unformatted_code = u'' expected_formatted_code = u'' - with utils.TempFileContents( - self.test_tmpdir, unformatted_code, suffix='.py') as filepath: + with utils.TempFileContents(self.test_tmpdir, unformatted_code, + suffix='.py') as filepath: p = subprocess.Popen(YAPF_BINARY + ['--in-place', filepath]) p.wait() with io.open(filepath, mode='r', encoding='utf-8', newline='') as fd: @@ -482,31 +508,37 @@ def testInPlaceReformattingEmpty(self): self.assertEqual(reformatted_code, expected_formatted_code) def testReadFromStdin(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def foo(): x = 37 """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def foo(): x = 37 """) self.assertYapfReformats(unformatted_code, expected_formatted_code) def testReadFromStdinWithEscapedStrings(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ s = "foo\\nbar" """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ s = "foo\\nbar" """) self.assertYapfReformats(unformatted_code, expected_formatted_code) def testSetYapfStyle(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def foo(): # trail x = 37 """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def foo(): # trail x = 37 """) @@ -516,15 +548,18 @@ def foo(): # trail extra_options=['--style=yapf']) def testSetCustomStyleBasedOnYapf(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def foo(): # trail x = 37 """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def foo(): # trail x = 37 """) - style_file = textwrap.dedent(u'''\ + style_file = textwrap.dedent( + u'''\ [style] based_on_style = yapf spaces_before_comment = 4 @@ -536,15 +571,18 @@ def foo(): # trail extra_options=['--style={0}'.format(stylepath)]) def testSetCustomStyleSpacesBeforeComment(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ a_very_long_statement_that_extends_way_beyond # Comment short # This is a shorter statement """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ a_very_long_statement_that_extends_way_beyond # Comment short # This is a shorter statement """) # noqa - style_file = textwrap.dedent(u'''\ + style_file = textwrap.dedent( + u'''\ [style] spaces_before_comment = 15, 20 ''') @@ -555,26 +593,28 @@ def testSetCustomStyleSpacesBeforeComment(self): extra_options=['--style={0}'.format(stylepath)]) def testReadSingleLineCodeFromStdin(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent("""\ if True: pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ if True: pass """) self.assertYapfReformats(unformatted_code, expected_formatted_code) def testEncodingVerification(self): - unformatted_code = textwrap.dedent(u"""\ + unformatted_code = textwrap.dedent( + u"""\ '''The module docstring.''' # -*- coding: utf-8 -*- def f(): x = 37 """) - with utils.NamedTempFile( - suffix='.py', dirname=self.test_tmpdir) as (out, _): - with utils.TempFileContents( - self.test_tmpdir, unformatted_code, suffix='.py') as filepath: + with utils.NamedTempFile(suffix='.py', + dirname=self.test_tmpdir) as (out, _): + with utils.TempFileContents(self.test_tmpdir, unformatted_code, + suffix='.py') as filepath: try: subprocess.check_call(YAPF_BINARY + ['--diff', filepath], stdout=out) except subprocess.CalledProcessError as e: @@ -582,7 +622,8 @@ def f(): self.assertEqual(e.returncode, 1) # pylint: disable=g-assert-in-except # noqa def testReformattingSpecificLines(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass @@ -592,7 +633,8 @@ def g(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): @@ -612,14 +654,16 @@ def g(): extra_options=['--lines', '1-2']) def testOmitFormattingLinesBeforeDisabledFunctionComment(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ import sys # Comment def some_func(x): x = ["badly" , "formatted","line" ] """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ import sys # Comment @@ -632,7 +676,8 @@ def some_func(x): extra_options=['--lines', '5-5']) def testReformattingSkippingLines(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass @@ -643,7 +688,8 @@ def g(): pass # yapf: enable """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): @@ -659,7 +705,8 @@ def g(): self.assertYapfReformats(unformatted_code, expected_formatted_code) def testReformattingSkippingToEndOfFile(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass @@ -676,7 +723,8 @@ def e(): 'bbbbbbb'): pass """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): @@ -698,7 +746,8 @@ def e(): self.assertYapfReformats(unformatted_code, expected_formatted_code) def testReformattingSkippingSingleLine(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass @@ -707,7 +756,8 @@ def g(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): # yapf: disable pass """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): @@ -721,13 +771,15 @@ def g(): self.assertYapfReformats(unformatted_code, expected_formatted_code) def testDisableWholeDataStructure(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ A = set([ 'hello', 'world', ]) # yapf: disable """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ A = set([ 'hello', 'world', @@ -736,14 +788,16 @@ def testDisableWholeDataStructure(self): self.assertYapfReformats(unformatted_code, expected_formatted_code) def testDisableButAdjustIndentations(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ class SplitPenaltyTest(unittest.TestCase): def testUnbreakable(self): self._CheckPenalties(tree, [ ]) # yapf: disable """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ class SplitPenaltyTest(unittest.TestCase): def testUnbreakable(self): @@ -753,7 +807,8 @@ def testUnbreakable(self): self.assertYapfReformats(unformatted_code, expected_formatted_code) def testRetainingHorizontalWhitespace(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass @@ -762,7 +817,8 @@ def g(): if (xxxxxxxxxxxx.yyyyyyyy (zzzzzzzzzzzzz [0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): # yapf: disable pass """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): @@ -776,7 +832,8 @@ def g(): self.assertYapfReformats(unformatted_code, expected_formatted_code) def testRetainingVerticalWhitespace(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass @@ -788,7 +845,8 @@ def g(): pass """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): @@ -806,7 +864,8 @@ def g(): expected_formatted_code, extra_options=['--lines', '1-2']) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ if a: b @@ -823,7 +882,8 @@ def g(): # trailing whitespace """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ if a: b @@ -843,7 +903,8 @@ def g(): expected_formatted_code, extra_options=['--lines', '3-3', '--lines', '13-13']) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ ''' docstring @@ -856,7 +917,7 @@ def g(): unformatted_code, unformatted_code, extra_options=['--lines', '2-2']) def testVerticalSpacingWithCommentWithContinuationMarkers(self): - unformatted_code = """\ + unformatted_code = """\ # \\ # \\ # \\ @@ -878,13 +939,15 @@ def testVerticalSpacingWithCommentWithContinuationMarkers(self): extra_options=['--lines', '1-1']) def testRetainingSemicolonsWhenSpecifyingLines(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ a = line_to_format def f(): x = y + 42; z = n * 42 if True: a += 1 ; b += 1 ; c += 1 """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ a = line_to_format def f(): x = y + 42; z = n * 42 @@ -896,7 +959,8 @@ def f(): extra_options=['--lines', '1-1']) def testDisabledMultilineStrings(self): - unformatted_code = textwrap.dedent('''\ + unformatted_code = textwrap.dedent( + '''\ foo=42 def f(): email_text += """This is a really long docstring that goes over the column limit and is multi-line.

@@ -906,7 +970,8 @@ def f(): """ ''') # noqa - expected_formatted_code = textwrap.dedent('''\ + expected_formatted_code = textwrap.dedent( + '''\ foo = 42 def f(): email_text += """This is a really long docstring that goes over the column limit and is multi-line.

@@ -922,7 +987,8 @@ def f(): extra_options=['--lines', '1-1']) def testDisableWhenSpecifyingLines(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ # yapf: disable A = set([ 'hello', @@ -934,7 +1000,8 @@ def testDisableWhenSpecifyingLines(self): 'world', ]) # yapf: disable """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ # yapf: disable A = set([ 'hello', @@ -952,7 +1019,8 @@ def testDisableWhenSpecifyingLines(self): extra_options=['--lines', '1-10']) def testDisableFormattingInDataLiteral(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def horrible(): oh_god() why_would_you() @@ -971,7 +1039,8 @@ def still_horrible(): 'that' ] """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def horrible(): oh_god() why_would_you() @@ -992,7 +1061,8 @@ def still_horrible(): extra_options=['--lines', '14-15']) def testRetainVerticalFormattingBetweenDisabledAndEnabledLines(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ class A(object): def aaaaaaaaaaaaa(self): c = bbbbbbbbb.ccccccccc('challenge', 0, 1, 10) @@ -1003,7 +1073,8 @@ def aaaaaaaaaaaaa(self): gggggggggggg.hhhhhhhhh(c, c.ffffffffffff)) iiiii = jjjjjjjjjjjjjj.iiiii """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ class A(object): def aaaaaaaaaaaaa(self): c = bbbbbbbbb.ccccccccc('challenge', 0, 1, 10) @@ -1018,7 +1089,8 @@ def aaaaaaaaaaaaa(self): extra_options=['--lines', '4-7']) def testRetainVerticalFormattingBetweenDisabledLines(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ class A(object): def aaaaaaaaaaaaa(self): pass @@ -1027,7 +1099,8 @@ def aaaaaaaaaaaaa(self): def bbbbbbbbbbbbb(self): # 5 pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ class A(object): def aaaaaaaaaaaaa(self): pass @@ -1042,7 +1115,8 @@ def bbbbbbbbbbbbb(self): # 5 extra_options=['--lines', '4-4']) def testFormatLinesSpecifiedInMiddleOfExpression(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ class A(object): def aaaaaaaaaaaaa(self): c = bbbbbbbbb.ccccccccc('challenge', 0, 1, 10) @@ -1053,7 +1127,8 @@ def aaaaaaaaaaaaa(self): gggggggggggg.hhhhhhhhh(c, c.ffffffffffff)) iiiii = jjjjjjjjjjjjjj.iiiii """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ class A(object): def aaaaaaaaaaaaa(self): c = bbbbbbbbb.ccccccccc('challenge', 0, 1, 10) @@ -1068,7 +1143,8 @@ def aaaaaaaaaaaaa(self): extra_options=['--lines', '5-6']) def testCommentFollowingMultilineString(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def foo(): '''First line. Second line. @@ -1076,7 +1152,8 @@ def foo(): x = '''hello world''' # second comment return 42 # another comment """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def foo(): '''First line. Second line. @@ -1091,12 +1168,14 @@ def foo(): def testDedentClosingBracket(self): # no line-break on the first argument, not dedenting closing brackets - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def overly_long_function_name(first_argument_on_the_same_line, second_argument_makes_the_line_too_long): pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def overly_long_function_name(first_argument_on_the_same_line, second_argument_makes_the_line_too_long): pass @@ -1114,7 +1193,8 @@ def overly_long_function_name(first_argument_on_the_same_line, # extra_options=['--style=facebook']) # line-break before the first argument, dedenting closing brackets if set - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def overly_long_function_name( first_argument_on_the_same_line, second_argument_makes_the_line_too_long): @@ -1126,7 +1206,8 @@ def overly_long_function_name( # second_argument_makes_the_line_too_long): # pass # """) - expected_formatted_fb_code = textwrap.dedent("""\ + expected_formatted_fb_code = textwrap.dedent( + """\ def overly_long_function_name( first_argument_on_the_same_line, second_argument_makes_the_line_too_long ): @@ -1144,14 +1225,16 @@ def overly_long_function_name( # extra_options=['--style=pep8']) def testCoalesceBrackets(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ some_long_function_name_foo( { 'first_argument_of_the_thing': id, 'second_argument_of_the_thing': "some thing" } )""") - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ some_long_function_name_foo({ 'first_argument_of_the_thing': id, 'second_argument_of_the_thing': "some thing" @@ -1159,7 +1242,8 @@ def testCoalesceBrackets(self): """) with utils.NamedTempFile(dirname=self.test_tmpdir, mode='w') as (f, name): f.write( - textwrap.dedent(u'''\ + textwrap.dedent( + u'''\ [style] column_limit=82 coalesce_brackets = True @@ -1171,12 +1255,14 @@ def testCoalesceBrackets(self): extra_options=['--style={0}'.format(name)]) def testPseudoParenSpaces(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def foo(): def bar(): return {msg_id: author for author, msg_id in reader} """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def foo(): def bar(): return {msg_id: author for author, msg_id in reader} @@ -1187,7 +1273,8 @@ def bar(): extra_options=['--lines', '1-1', '--style', 'yapf']) def testMultilineCommentFormattingDisabled(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ # This is a comment FOO = { aaaaaaaa.ZZZ: [ @@ -1201,7 +1288,8 @@ def testMultilineCommentFormattingDisabled(self): '#': lambda x: x # do nothing } """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ # This is a comment FOO = { aaaaaaaa.ZZZ: [ @@ -1221,14 +1309,16 @@ def testMultilineCommentFormattingDisabled(self): extra_options=['--lines', '1-1', '--style', 'yapf']) def testTrailingCommentsWithDisabledFormatting(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ import os SCOPES = [ 'hello world' # This is a comment. ] """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ import os SCOPES = [ @@ -1241,7 +1331,7 @@ def testTrailingCommentsWithDisabledFormatting(self): extra_options=['--lines', '1-1', '--style', 'yapf']) def testUseTabs(self): - unformatted_code = """\ + unformatted_code = """\ def foo_function(): if True: pass @@ -1251,7 +1341,7 @@ def foo_function(): if True: pass """ # noqa: W191,E101 - style_contents = u"""\ + style_contents = u"""\ [style] based_on_style = yapf USE_TABS = true @@ -1264,7 +1354,7 @@ def foo_function(): extra_options=['--style={0}'.format(stylepath)]) def testUseTabsWith(self): - unformatted_code = """\ + unformatted_code = """\ def f(): return ['hello', 'world',] """ @@ -1275,7 +1365,7 @@ def f(): 'world', ] """ # noqa: W191,E101 - style_contents = u"""\ + style_contents = u"""\ [style] based_on_style = yapf USE_TABS = true @@ -1288,7 +1378,7 @@ def f(): extra_options=['--style={0}'.format(stylepath)]) def testUseTabsContinuationAlignStyleFixed(self): - unformatted_code = """\ + unformatted_code = """\ def foo_function(arg1, arg2, arg3): return ['hello', 'world',] """ @@ -1300,7 +1390,7 @@ def foo_function( 'world', ] """ # noqa: W191,E101 - style_contents = u"""\ + style_contents = u"""\ [style] based_on_style = yapf USE_TABS = true @@ -1316,7 +1406,7 @@ def foo_function( extra_options=['--style={0}'.format(stylepath)]) def testUseTabsContinuationAlignStyleVAlignRight(self): - unformatted_code = """\ + unformatted_code = """\ def foo_function(arg1, arg2, arg3): return ['hello', 'world',] """ @@ -1328,7 +1418,7 @@ def foo_function(arg1, arg2, 'world', ] """ # noqa: W191,E101 - style_contents = u"""\ + style_contents = u"""\ [style] based_on_style = yapf USE_TABS = true @@ -1344,7 +1434,7 @@ def foo_function(arg1, arg2, extra_options=['--style={0}'.format(stylepath)]) def testUseSpacesContinuationAlignStyleFixed(self): - unformatted_code = """\ + unformatted_code = """\ def foo_function(arg1, arg2, arg3): return ['hello', 'world',] """ @@ -1356,7 +1446,7 @@ def foo_function( 'world', ] """ - style_contents = u"""\ + style_contents = u"""\ [style] based_on_style = yapf COLUMN_LIMIT=32 @@ -1371,7 +1461,7 @@ def foo_function( extra_options=['--style={0}'.format(stylepath)]) def testUseSpacesContinuationAlignStyleVAlignRight(self): - unformatted_code = """\ + unformatted_code = """\ def foo_function(arg1, arg2, arg3): return ['hello', 'world',] """ @@ -1383,7 +1473,7 @@ def foo_function(arg1, arg2, 'world', ] """ - style_contents = u"""\ + style_contents = u"""\ [style] based_on_style = yapf COLUMN_LIMIT=32 @@ -1398,11 +1488,13 @@ def foo_function(arg1, arg2, extra_options=['--style={0}'.format(stylepath)]) def testStyleOutputRoundTrip(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def foo_function(): pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def foo_function(): pass """) @@ -1411,9 +1503,9 @@ def foo_function(): stylepath): p = subprocess.Popen( YAPF_BINARY + ['--style-help'], - stdout=stylefile, - stdin=subprocess.PIPE, - stderr=subprocess.PIPE) + stdout =stylefile, + stdin =subprocess.PIPE, + stderr =subprocess.PIPE) _, stderrdata = p.communicate() self.assertEqual(stderrdata, b'') self.assertYapfReformats( @@ -1422,7 +1514,8 @@ def foo_function(): extra_options=['--style={0}'.format(stylepath)]) def testSpacingBeforeComments(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ A = 42 @@ -1432,7 +1525,8 @@ def x(): def _(): pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ A = 42 @@ -1448,7 +1542,8 @@ def _(): extra_options=['--lines', '1-2']) def testSpacingBeforeCommentsInDicts(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ A=42 X = { @@ -1463,7 +1558,8 @@ def testSpacingBeforeCommentsInDicts(self): 'BROKEN' } """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ A = 42 X = { @@ -1484,7 +1580,8 @@ def testSpacingBeforeCommentsInDicts(self): extra_options=['--style', 'yapf', '--lines', '1-1']) def testDisableWithLinesOption(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ # yapf_lines_bug.py # yapf: disable def outer_func(): @@ -1493,7 +1590,8 @@ def inner_func(): return # yapf: enable """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ # yapf_lines_bug.py # yapf: disable def outer_func(): @@ -1509,7 +1607,7 @@ def inner_func(): @unittest.skipUnless(py3compat.PY36, 'Requires Python 3.6') def testNoSpacesAroundBinaryOperators(self): - unformatted_code = """\ + unformatted_code = """\ a = 4-b/c@d**37 """ expected_formatted_code = """\ @@ -1518,7 +1616,7 @@ def testNoSpacesAroundBinaryOperators(self): self.assertYapfReformats( unformatted_code, expected_formatted_code, - extra_options=[ + extra_options =[ '--style', '{based_on_style: pep8, ' 'no_spaces_around_selected_binary_operators: "@,**,-"}', @@ -1526,7 +1624,7 @@ def testNoSpacesAroundBinaryOperators(self): @unittest.skipUnless(py3compat.PY36, 'Requires Python 3.6') def testCP936Encoding(self): - unformatted_code = 'print("中文")\n' + unformatted_code = 'print("中文")\n' expected_formatted_code = 'print("中文")\n' self.assertYapfReformats( unformatted_code, @@ -1534,7 +1632,7 @@ def testCP936Encoding(self): env={'PYTHONIOENCODING': 'cp936'}) def testDisableWithLineRanges(self): - unformatted_code = """\ + unformatted_code = """\ # yapf: disable a = [ 1, @@ -1574,8 +1672,8 @@ class DiffIndentTest(unittest.TestCase): @staticmethod def _OwnStyle(): - my_style = style.CreatePEP8Style() - my_style['INDENT_WIDTH'] = 3 + my_style = style.CreatePEP8Style() + my_style['INDENT_WIDTH'] = 3 my_style['CONTINUATION_INDENT_WIDTH'] = 3 return my_style @@ -1585,11 +1683,13 @@ def _Check(self, unformatted_code, expected_formatted_code): self.assertEqual(expected_formatted_code, formatted_code) def testSimple(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ for i in range(5): print('bar') """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ for i in range(5): print('bar') """) @@ -1600,7 +1700,7 @@ class HorizontallyAlignedTrailingCommentsTest(yapf_test_helper.YAPFTest): @staticmethod def _OwnStyle(): - my_style = style.CreatePEP8Style() + my_style = style.CreatePEP8Style() my_style['SPACES_BEFORE_COMMENT'] = [ 15, 25, @@ -1614,7 +1714,8 @@ def _Check(self, unformatted_code, expected_formatted_code): self.assertCodeEqual(expected_formatted_code, formatted_code) def testSimple(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ foo = '1' # Aligned at first list value foo = '2__<15>' # Aligned at second list value @@ -1623,7 +1724,8 @@ def testSimple(self): foo = '4______________________<35>' # Aligned beyond list values """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ foo = '1' # Aligned at first list value foo = '2__<15>' # Aligned at second list value @@ -1635,7 +1737,8 @@ def testSimple(self): self._Check(unformatted_code, expected_formatted_code) def testBlock(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ func(1) # Line 1 func(2) # Line 2 # Line 3 @@ -1643,7 +1746,8 @@ def testBlock(self): # Line 5 # Line 6 """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ func(1) # Line 1 func(2) # Line 2 # Line 3 @@ -1654,7 +1758,8 @@ def testBlock(self): self._Check(unformatted_code, expected_formatted_code) def testBlockWithLongLine(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ func(1) # Line 1 func___________________(2) # Line 2 # Line 3 @@ -1662,7 +1767,8 @@ def testBlockWithLongLine(self): # Line 5 # Line 6 """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ func(1) # Line 1 func___________________(2) # Line 2 # Line 3 @@ -1673,7 +1779,8 @@ def testBlockWithLongLine(self): self._Check(unformatted_code, expected_formatted_code) def testBlockFuncSuffix(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ func(1) # Line 1 func(2) # Line 2 # Line 3 @@ -1684,7 +1791,8 @@ def testBlockFuncSuffix(self): def Func(): pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ func(1) # Line 1 func(2) # Line 2 # Line 3 @@ -1699,7 +1807,8 @@ def Func(): self._Check(unformatted_code, expected_formatted_code) def testBlockCommentSuffix(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ func(1) # Line 1 func(2) # Line 2 # Line 3 @@ -1709,7 +1818,8 @@ def testBlockCommentSuffix(self): # Aligned with prev comment block """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ func(1) # Line 1 func(2) # Line 2 # Line 3 @@ -1722,7 +1832,8 @@ def testBlockCommentSuffix(self): self._Check(unformatted_code, expected_formatted_code) def testBlockIndentedFuncSuffix(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ if True: func(1) # Line 1 func(2) # Line 2 @@ -1736,7 +1847,8 @@ def testBlockIndentedFuncSuffix(self): def Func(): pass """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ if True: func(1) # Line 1 func(2) # Line 2 @@ -1755,7 +1867,8 @@ def Func(): self._Check(unformatted_code, expected_formatted_code) def testBlockIndentedCommentSuffix(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ if True: func(1) # Line 1 func(2) # Line 2 @@ -1766,7 +1879,8 @@ def testBlockIndentedCommentSuffix(self): # Not aligned """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ if True: func(1) # Line 1 func(2) # Line 2 @@ -1780,7 +1894,8 @@ def testBlockIndentedCommentSuffix(self): self._Check(unformatted_code, expected_formatted_code) def testBlockMultiIndented(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ if True: if True: if True: @@ -1793,7 +1908,8 @@ def testBlockMultiIndented(self): # Not aligned """) # noqa - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ if True: if True: if True: @@ -1809,7 +1925,8 @@ def testBlockMultiIndented(self): self._Check(unformatted_code, expected_formatted_code) def testArgs(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ def MyFunc( arg1, # Desc 1 arg2, # Desc 2 @@ -1820,7 +1937,8 @@ def MyFunc( ): pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def MyFunc( arg1, # Desc 1 arg2, # Desc 2 @@ -1834,7 +1952,8 @@ def MyFunc( self._Check(unformatted_code, expected_formatted_code) def testDisableBlock(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ a() # comment 1 b() # comment 2 @@ -1846,7 +1965,8 @@ def testDisableBlock(self): e() # comment 5 f() # comment 6 """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ a() # comment 1 b() # comment 2 @@ -1861,13 +1981,15 @@ def testDisableBlock(self): self._Check(unformatted_code, expected_formatted_code) def testDisabledLine(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ short # comment 1 do_not_touch1 # yapf: disable do_not_touch2 # yapf: disable a_longer_statement # comment 2 """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ short # comment 1 do_not_touch1 # yapf: disable do_not_touch2 # yapf: disable @@ -1880,9 +2002,9 @@ class _SpacesAroundDictListTupleTestImpl(unittest.TestCase): @staticmethod def _OwnStyle(): - my_style = style.CreatePEP8Style() - my_style['DISABLE_ENDING_COMMA_HEURISTIC'] = True - my_style['SPLIT_ALL_COMMA_SEPARATED_VALUES'] = False + my_style = style.CreatePEP8Style() + my_style['DISABLE_ENDING_COMMA_HEURISTIC'] = True + my_style['SPLIT_ALL_COMMA_SEPARATED_VALUES'] = False my_style['SPLIT_ARGUMENTS_WHEN_COMMA_TERMINATED'] = False return my_style @@ -1899,13 +2021,14 @@ class SpacesAroundDictTest(_SpacesAroundDictListTupleTestImpl): @classmethod def _OwnStyle(cls): - style = super(SpacesAroundDictTest, cls)._OwnStyle() + style = super(SpacesAroundDictTest, cls)._OwnStyle() style['SPACES_AROUND_DICT_DELIMITERS'] = True return style def testStandard(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ {1 : 2} {k:v for k, v in other.items()} {k for k in [1, 2, 3]} @@ -1922,7 +2045,8 @@ def testStandard(self): [1, 2] (3, 4) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ { 1: 2 } { k: v for k, v in other.items() } { k for k in [1, 2, 3] } @@ -1947,13 +2071,14 @@ class SpacesAroundListTest(_SpacesAroundDictListTupleTestImpl): @classmethod def _OwnStyle(cls): - style = super(SpacesAroundListTest, cls)._OwnStyle() + style = super(SpacesAroundListTest, cls)._OwnStyle() style['SPACES_AROUND_LIST_DELIMITERS'] = True return style def testStandard(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ [a,b,c] [4,5,] [6, [7, 8], 9] @@ -1974,7 +2099,8 @@ def testStandard(self): {a: b} (1, 2) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ [ a, b, c ] [ 4, 5, ] [ 6, [ 7, 8 ], 9 ] @@ -2003,13 +2129,14 @@ class SpacesAroundTupleTest(_SpacesAroundDictListTupleTestImpl): @classmethod def _OwnStyle(cls): - style = super(SpacesAroundTupleTest, cls)._OwnStyle() + style = super(SpacesAroundTupleTest, cls)._OwnStyle() style['SPACES_AROUND_TUPLE_DELIMITERS'] = True return style def testStandard(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent( + """\ (0, 1) (2, 3) (4, 5, 6,) @@ -2032,7 +2159,8 @@ def testStandard(self): {a: b} [3, 4] """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ ( 0, 1 ) ( 2, 3 ) ( 4, 5, 6, ) diff --git a/yapftests/yapf_test_helper.py b/yapftests/yapf_test_helper.py index cb56ec865..b70b193f4 100644 --- a/yapftests/yapf_test_helper.py +++ b/yapftests/yapf_test_helper.py @@ -39,7 +39,7 @@ def __init__(self, *args): def assertCodeEqual(self, expected_code, code): if code != expected_code: - msg = ['Code format mismatch:', 'Expected:'] + msg = ['Code format mismatch:', 'Expected:'] linelen = style.Get('COLUMN_LIMIT') for line in expected_code.splitlines(): if len(line) > linelen: @@ -57,9 +57,9 @@ def assertCodeEqual(self, expected_code, code): difflib.unified_diff( code.splitlines(), expected_code.splitlines(), - fromfile='actual', - tofile='expected', - lineterm='')) + fromfile ='actual', + tofile ='expected', + lineterm ='')) self.fail('\n'.join(msg)) From 9dc84e67174c11e4f10f44aa233f3da883a840ca Mon Sep 17 00:00:00 2001 From: Xiao Wang Date: Tue, 3 Jan 2023 11:19:56 +0100 Subject: [PATCH 9/9] Revert "ran alignment over yapf codes" This reverts commit 506612e587c9883a36d9c5bfd3ea8215500878c7. change formatting back to original. --- yapf/__init__.py | 184 ++-- yapf/pyparser/pyparser.py | 32 +- yapf/pyparser/pyparser_utils.py | 8 +- yapf/pyparser/split_penalty_visitor.py | 49 +- yapf/pytree/blank_line_calculator.py | 60 +- yapf/pytree/comment_splicer.py | 56 +- yapf/pytree/continuation_splicer.py | 6 +- yapf/pytree/pytree_unwrapper.py | 42 +- yapf/pytree/pytree_utils.py | 54 +- yapf/pytree/pytree_visitor.py | 2 +- yapf/pytree/split_penalty.py | 87 +- yapf/pytree/subtype_assigner.py | 49 +- yapf/third_party/yapf_diff/yapf_diff.py | 43 +- yapf/yapflib/errors.py | 4 +- yapf/yapflib/file_resources.py | 26 +- yapf/yapflib/format_decision_state.py | 183 ++-- yapf/yapflib/format_token.py | 147 ++- yapf/yapflib/logical_line.py | 34 +- yapf/yapflib/object_state.py | 69 +- yapf/yapflib/py3compat.py | 14 +- yapf/yapflib/reformatter.py | 596 +++++------ yapf/yapflib/split_penalty.py | 16 +- yapf/yapflib/style.py | 534 +++++----- yapf/yapflib/subtypes.py | 48 +- yapf/yapflib/verifier.py | 2 +- yapf/yapflib/yapf_api.py | 83 +- yapftests/blank_line_calculator_test.py | 69 +- yapftests/comment_splicer_test.py | 62 +- yapftests/file_resources_test.py | 147 +-- yapftests/format_decision_state_test.py | 8 +- yapftests/format_token_test.py | 26 +- yapftests/line_joiner_test.py | 18 +- yapftests/logical_line_test.py | 22 +- yapftests/main_test.py | 11 +- yapftests/pytree_unwrapper_test.py | 273 +++-- yapftests/pytree_utils_test.py | 62 +- yapftests/pytree_visitor_test.py | 10 +- yapftests/reformatter_basic_test.py | 1098 ++++++++------------ yapftests/reformatter_buganizer_test.py | 541 ++++------ yapftests/reformatter_facebook_test.py | 95 +- yapftests/reformatter_pep8_test.py | 274 ++--- yapftests/reformatter_python3_test.py | 109 +- yapftests/reformatter_style_config_test.py | 54 +- yapftests/reformatter_verify_test.py | 26 +- yapftests/split_penalty_test.py | 272 +++-- yapftests/style_test.py | 63 +- yapftests/subtype_assigner_test.py | 555 +++++----- yapftests/utils.py | 44 +- yapftests/yapf_test.py | 520 ++++----- yapftests/yapf_test_helper.py | 8 +- 50 files changed, 2908 insertions(+), 3887 deletions(-) diff --git a/yapf/__init__.py b/yapf/__init__.py index 703c9141e..94e445b59 100644 --- a/yapf/__init__.py +++ b/yapf/__init__.py @@ -55,8 +55,8 @@ def main(argv): Raises: YapfError: if none of the supplied files were Python files. """ - parser = _BuildParser() - args = parser.parse_args(argv[1:]) + parser = _BuildParser() + args = parser.parse_args(argv[1:]) style_config = args.style if args.style_help: @@ -70,9 +70,8 @@ def main(argv): if not args.files: # No arguments specified. Read code from stdin. if args.in_place or args.diff: - parser.error( - 'cannot use --in-place or --diff flags when reading ' - 'from stdin') + parser.error('cannot use --in-place or --diff flags when reading ' + 'from stdin') original_source = [] while True: @@ -94,16 +93,16 @@ def main(argv): if style_config is None and not args.no_local_style: style_config = file_resources.GetDefaultStyleForDir(os.getcwd()) - source = [line.rstrip() for line in original_source] + source = [line.rstrip() for line in original_source] source[0] = py3compat.removeBOM(source[0]) try: reformatted_source, _ = yapf_api.FormatCode( py3compat.unicode('\n'.join(source) + '\n'), - filename ='', - style_config =style_config, - lines =lines, - verify =args.verify) + filename='', + style_config=style_config, + lines=lines, + verify=args.verify) except errors.YapfError: raise except Exception as e: @@ -116,23 +115,23 @@ def main(argv): exclude_patterns_from_ignore_file = file_resources.GetExcludePatternsForDir( os.getcwd()) - files = file_resources.GetCommandLineFiles( - args.files, args.recursive, - (args.exclude or []) + exclude_patterns_from_ignore_file) + files = file_resources.GetCommandLineFiles(args.files, args.recursive, + (args.exclude or []) + + exclude_patterns_from_ignore_file) if not files: raise errors.YapfError('input filenames did not match any python files') changed = FormatFiles( files, lines, - style_config =args.style, - no_local_style =args.no_local_style, - in_place =args.in_place, - print_diff =args.diff, - verify =args.verify, - parallel =args.parallel, - quiet =args.quiet, - verbose =args.verbose) + style_config=args.style, + no_local_style=args.no_local_style, + in_place=args.in_place, + print_diff=args.diff, + verify=args.verify, + parallel=args.parallel, + quiet=args.quiet, + verbose=args.verbose) return 1 if changed and (args.diff or args.quiet) else 0 @@ -153,17 +152,16 @@ def _PrintHelp(args): print() -def FormatFiles( - filenames, - lines, - style_config =None, - no_local_style =False, - in_place =False, - print_diff =False, - verify =False, - parallel =False, - quiet =False, - verbose =False): +def FormatFiles(filenames, + lines, + style_config=None, + no_local_style=False, + in_place=False, + print_diff=False, + verify=False, + parallel=False, + quiet=False, + verbose=False): """Format a list of files. Arguments: @@ -193,31 +191,28 @@ def FormatFiles( workers = min(multiprocessing.cpu_count(), len(filenames)) with concurrent.futures.ProcessPoolExecutor(workers) as executor: future_formats = [ - executor.submit( - _FormatFile, filename, lines, style_config, no_local_style, - in_place, print_diff, verify, quiet, verbose) - for filename in filenames + executor.submit(_FormatFile, filename, lines, style_config, + no_local_style, in_place, print_diff, verify, quiet, + verbose) for filename in filenames ] for future in concurrent.futures.as_completed(future_formats): changed |= future.result() else: for filename in filenames: - changed |= _FormatFile( - filename, lines, style_config, no_local_style, in_place, print_diff, - verify, quiet, verbose) + changed |= _FormatFile(filename, lines, style_config, no_local_style, + in_place, print_diff, verify, quiet, verbose) return changed -def _FormatFile( - filename, - lines, - style_config =None, - no_local_style =False, - in_place =False, - print_diff =False, - verify =False, - quiet =False, - verbose =False): +def _FormatFile(filename, + lines, + style_config=None, + no_local_style=False, + in_place=False, + print_diff=False, + verify=False, + quiet=False, + verbose=False): """Format an individual file.""" if verbose and not quiet: print('Reformatting %s' % filename) @@ -229,20 +224,20 @@ def _FormatFile( try: reformatted_code, encoding, has_change = yapf_api.FormatFile( filename, - in_place =in_place, - style_config =style_config, - lines =lines, - print_diff =print_diff, - verify =verify, - logger =logging.warning) + in_place=in_place, + style_config=style_config, + lines=lines, + print_diff=print_diff, + verify=verify, + logger=logging.warning) except errors.YapfError: raise except Exception as e: raise errors.YapfError(errors.FormatErrorMsg(e)) if not in_place and not quiet and reformatted_code: - file_resources.WriteReformattedCode( - filename, reformatted_code, encoding, in_place) + file_resources.WriteReformattedCode(filename, reformatted_code, encoding, + in_place) return has_change @@ -282,81 +277,78 @@ def _BuildParser(): parser.add_argument( '-v', '--version', - action ='version', - version ='%(prog)s {}'.format(__version__)) + action='version', + version='%(prog)s {}'.format(__version__)) diff_inplace_quiet_group = parser.add_mutually_exclusive_group() diff_inplace_quiet_group.add_argument( '-d', '--diff', - action ='store_true', - help ='print the diff for the fixed source') + action='store_true', + help='print the diff for the fixed source') diff_inplace_quiet_group.add_argument( '-i', '--in-place', - action ='store_true', - help ='make changes to files in place') + action='store_true', + help='make changes to files in place') diff_inplace_quiet_group.add_argument( '-q', '--quiet', - action ='store_true', - help ='output nothing and set return value') + action='store_true', + help='output nothing and set return value') lines_recursive_group = parser.add_mutually_exclusive_group() lines_recursive_group.add_argument( '-r', '--recursive', - action ='store_true', - help ='run recursively over directories') + action='store_true', + help='run recursively over directories') lines_recursive_group.add_argument( '-l', '--lines', - metavar ='START-END', - action ='append', - default =None, - help ='range of lines to reformat, one-based') + metavar='START-END', + action='append', + default=None, + help='range of lines to reformat, one-based') parser.add_argument( '-e', '--exclude', - metavar ='PATTERN', - action ='append', - default =None, - help ='patterns for files to exclude from formatting') + metavar='PATTERN', + action='append', + default=None, + help='patterns for files to exclude from formatting') parser.add_argument( '--style', - action ='store', - help =( - 'specify formatting style: either a style name (for example "pep8" ' - 'or "google"), or the name of a file with style settings. The ' - 'default is pep8 unless a %s or %s or %s file located in the same ' - 'directory as the source or one of its parent directories ' - '(for stdin, the current directory is used).' % - (style.LOCAL_STYLE, style.SETUP_CONFIG, style.PYPROJECT_TOML))) + action='store', + help=('specify formatting style: either a style name (for example "pep8" ' + 'or "google"), or the name of a file with style settings. The ' + 'default is pep8 unless a %s or %s or %s file located in the same ' + 'directory as the source or one of its parent directories ' + '(for stdin, the current directory is used).' % + (style.LOCAL_STYLE, style.SETUP_CONFIG, style.PYPROJECT_TOML))) parser.add_argument( '--style-help', - action ='store_true', - help =( - 'show style settings and exit; this output can be ' - 'saved to .style.yapf to make your settings ' - 'permanent')) + action='store_true', + help=('show style settings and exit; this output can be ' + 'saved to .style.yapf to make your settings ' + 'permanent')) parser.add_argument( '--no-local-style', - action ='store_true', - help ="don't search for local style definition") + action='store_true', + help="don't search for local style definition") parser.add_argument('--verify', action='store_true', help=argparse.SUPPRESS) parser.add_argument( '-p', '--parallel', - action ='store_true', - help =( - 'run YAPF in parallel when formatting multiple files. Requires ' - 'concurrent.futures in Python 2.X')) + action='store_true', + help=('run YAPF in parallel when formatting multiple files. Requires ' + 'concurrent.futures in Python 2.X')) parser.add_argument( '-vv', '--verbose', - action ='store_true', - help ='print out file names while processing') + action='store_true', + help='print out file names while processing') parser.add_argument( 'files', nargs='*', help='reads from stdin when no files are specified.') diff --git a/yapf/pyparser/pyparser.py b/yapf/pyparser/pyparser.py index 7b2ce0dea..a8a28ebc8 100644 --- a/yapf/pyparser/pyparser.py +++ b/yapf/pyparser/pyparser.py @@ -68,7 +68,7 @@ def ParseCode(unformatted_source, filename=''): ast_tree = ast.parse(unformatted_source, filename) ast.fix_missing_locations(ast_tree) readline = py3compat.StringIO(unformatted_source).readline - tokens = tokenize.generate_tokens(readline) + tokens = tokenize.generate_tokens(readline) except Exception: raise @@ -89,10 +89,10 @@ def _CreateLogicalLines(tokens): Returns: A list of LogicalLines. """ - logical_lines = [] + logical_lines = [] cur_logical_line = [] - prev_tok = None - depth = 0 + prev_tok = None + depth = 0 for tok in tokens: tok = py3compat.TokenInfo(*tok) @@ -100,7 +100,7 @@ def _CreateLogicalLines(tokens): # End of a logical line. logical_lines.append(logical_line.LogicalLine(depth, cur_logical_line)) cur_logical_line = [] - prev_tok = None + prev_tok = None elif tok.type == tokenize.INDENT: depth += 1 elif tok.type == tokenize.DEDENT: @@ -110,36 +110,36 @@ def _CreateLogicalLines(tokens): prev_tok.start[0] < tok.start[0]): # Insert a token for a line continuation. ctok = py3compat.TokenInfo( - type =CONTINUATION, - string ='\\', - start =(prev_tok.start[0], prev_tok.start[1] + 1), - end =(prev_tok.end[0], prev_tok.end[0] + 2), - line =prev_tok.line) + type=CONTINUATION, + string='\\', + start=(prev_tok.start[0], prev_tok.start[1] + 1), + end=(prev_tok.end[0], prev_tok.end[0] + 2), + line=prev_tok.line) ctok.lineno = ctok.start[0] ctok.column = ctok.start[1] - ctok.value = '\\' + ctok.value = '\\' cur_logical_line.append(format_token.FormatToken(ctok, 'CONTINUATION')) tok.lineno = tok.start[0] tok.column = tok.start[1] - tok.value = tok.string + tok.value = tok.string cur_logical_line.append( format_token.FormatToken(tok, token.tok_name[tok.type])) prev_tok = tok # Link the FormatTokens in each line together to for a doubly linked list. for line in logical_lines: - previous = line.first + previous = line.first bracket_stack = [previous] if previous.OpensScope() else [] for tok in line.tokens[1:]: - tok.previous_token = previous + tok.previous_token = previous previous.next_token = tok - previous = tok + previous = tok # Set up the "matching_bracket" attribute. if tok.OpensScope(): bracket_stack.append(tok) elif tok.ClosesScope(): bracket_stack[-1].matching_bracket = tok - tok.matching_bracket = bracket_stack.pop() + tok.matching_bracket = bracket_stack.pop() return logical_lines diff --git a/yapf/pyparser/pyparser_utils.py b/yapf/pyparser/pyparser_utils.py index 149e0a280..3f17b15a4 100644 --- a/yapf/pyparser/pyparser_utils.py +++ b/yapf/pyparser/pyparser_utils.py @@ -31,8 +31,8 @@ def GetTokens(logical_lines, node): """Get a list of tokens within the node's range from the logical lines.""" - start = TokenStart(node) - end = TokenEnd(node) + start = TokenStart(node) + end = TokenEnd(node) tokens = [] for line in logical_lines: @@ -46,8 +46,8 @@ def GetTokens(logical_lines, node): def GetTokensInSubRange(tokens, node): """Get a subset of tokens representing the node.""" - start = TokenStart(node) - end = TokenEnd(node) + start = TokenStart(node) + end = TokenEnd(node) tokens_in_range = [] for tok in tokens: diff --git a/yapf/pyparser/split_penalty_visitor.py b/yapf/pyparser/split_penalty_visitor.py index 946bd949f..047b48a3d 100644 --- a/yapf/pyparser/split_penalty_visitor.py +++ b/yapf/pyparser/split_penalty_visitor.py @@ -67,14 +67,13 @@ def visit_FunctionDef(self, node): _SetPenalty(token, split_penalty.UNBREAKABLE) if node.returns: - start_index = pyutils.GetTokenIndex( - tokens, pyutils.TokenStart(node.returns)) - _IncreasePenalty( - tokens[start_index - 1:start_index + 1], - split_penalty.VERY_STRONGLY_CONNECTED) + start_index = pyutils.GetTokenIndex(tokens, + pyutils.TokenStart(node.returns)) + _IncreasePenalty(tokens[start_index - 1:start_index + 1], + split_penalty.VERY_STRONGLY_CONNECTED) end_index = pyutils.GetTokenIndex(tokens, pyutils.TokenEnd(node.returns)) - _IncreasePenalty( - tokens[start_index + 1:end_index], split_penalty.STRONGLY_CONNECTED) + _IncreasePenalty(tokens[start_index + 1:end_index], + split_penalty.STRONGLY_CONNECTED) return self.generic_visit(node) @@ -104,7 +103,7 @@ def visit_ClassDef(self, node): for decorator in node.decorator_list: # Don't split after the '@'. - decorator_range = self._GetTokens(decorator) + decorator_range = self._GetTokens(decorator) decorator_range[0].split_penalty = split_penalty.UNBREAKABLE return self.generic_visit(node) @@ -264,7 +263,7 @@ def visit_BoolOp(self, node): # Lower the split penalty to allow splitting before or after the logical # operator. split_before_operator = style.Get('SPLIT_BEFORE_LOGICAL_OPERATOR') - operator_indices = [ + operator_indices = [ pyutils.GetNextTokenIndex(tokens, pyutils.TokenEnd(value)) for value in node.values[:-1] ] @@ -293,8 +292,8 @@ def visit_BinOp(self, node): # Lower the split penalty to allow splitting before or after the arithmetic # operator. - operator_index = pyutils.GetNextTokenIndex( - tokens, pyutils.TokenEnd(node.left)) + operator_index = pyutils.GetNextTokenIndex(tokens, + pyutils.TokenEnd(node.left)) if not style.Get('SPLIT_BEFORE_ARITHMETIC_OPERATOR'): operator_index += 1 @@ -371,7 +370,7 @@ def visit_ListComp(self, node): # is_async=0), # ... # ]) - tokens = self._GetTokens(node) + tokens = self._GetTokens(node) element = pyutils.GetTokensInSubRange(tokens, node.elt) _IncreasePenalty(element[1:], split_penalty.EXPR) @@ -395,7 +394,7 @@ def visit_SetComp(self, node): # is_async=0), # ... # ]) - tokens = self._GetTokens(node) + tokens = self._GetTokens(node) element = pyutils.GetTokensInSubRange(tokens, node.elt) _IncreasePenalty(element[1:], split_penalty.EXPR) @@ -421,7 +420,7 @@ def visit_DictComp(self, node): # ... # ]) tokens = self._GetTokens(node) - key = pyutils.GetTokensInSubRange(tokens, node.key) + key = pyutils.GetTokensInSubRange(tokens, node.key) _IncreasePenalty(key[1:], split_penalty.EXPR) value = pyutils.GetTokensInSubRange(tokens, node.value) @@ -447,7 +446,7 @@ def visit_GeneratorExp(self, node): # is_async=0), # ... # ]) - tokens = self._GetTokens(node) + tokens = self._GetTokens(node) element = pyutils.GetTokensInSubRange(tokens, node.elt) _IncreasePenalty(element[1:], split_penalty.EXPR) @@ -542,10 +541,10 @@ def visit_Constant(self, node): def visit_Attribute(self, node): # Attribute(value=Expr, # attr=Identifier) - tokens = self._GetTokens(node) + tokens = self._GetTokens(node) split_before = style.Get('SPLIT_BEFORE_DOT') - dot_indices = pyutils.GetNextTokenIndex( - tokens, pyutils.TokenEnd(node.value)) + dot_indices = pyutils.GetNextTokenIndex(tokens, + pyutils.TokenEnd(node.value)) if not split_before: dot_indices += 1 @@ -559,8 +558,8 @@ def visit_Subscript(self, node): tokens = self._GetTokens(node) # Don't split before the opening bracket of a subscript. - bracket_index = pyutils.GetNextTokenIndex( - tokens, pyutils.TokenEnd(node.value)) + bracket_index = pyutils.GetNextTokenIndex(tokens, + pyutils.TokenEnd(node.value)) _IncreasePenalty(tokens[bracket_index], split_penalty.UNBREAKABLE) return self.generic_visit(node) @@ -610,16 +609,16 @@ def visit_Slice(self, node): _DecreasePenalty(subrange[0], split_penalty.EXPR // 2) if hasattr(node, 'upper') and node.upper: - colon_index = pyutils.GetPrevTokenIndex( - tokens, pyutils.TokenStart(node.upper)) + colon_index = pyutils.GetPrevTokenIndex(tokens, + pyutils.TokenStart(node.upper)) _IncreasePenalty(tokens[colon_index], split_penalty.UNBREAKABLE) subrange = pyutils.GetTokensInSubRange(tokens, node.upper) _IncreasePenalty(subrange, split_penalty.EXPR) _DecreasePenalty(subrange[0], split_penalty.EXPR // 2) if hasattr(node, 'step') and node.step: - colon_index = pyutils.GetPrevTokenIndex( - tokens, pyutils.TokenStart(node.step)) + colon_index = pyutils.GetPrevTokenIndex(tokens, + pyutils.TokenStart(node.step)) _IncreasePenalty(tokens[colon_index], split_penalty.UNBREAKABLE) subrange = pyutils.GetTokensInSubRange(tokens, node.step) _IncreasePenalty(subrange, split_penalty.EXPR) @@ -865,7 +864,7 @@ def visit_arg(self, node): # Process any annotations. if hasattr(node, 'annotation') and node.annotation: annotation = node.annotation - subrange = pyutils.GetTokensInSubRange(tokens, annotation) + subrange = pyutils.GetTokensInSubRange(tokens, annotation) _IncreasePenalty(subrange, split_penalty.ANNOTATION) return self.generic_visit(node) diff --git a/yapf/pytree/blank_line_calculator.py b/yapf/pytree/blank_line_calculator.py index 8aa20ec0a..9d218bf97 100644 --- a/yapf/pytree/blank_line_calculator.py +++ b/yapf/pytree/blank_line_calculator.py @@ -29,18 +29,17 @@ from yapf.yapflib import py3compat from yapf.yapflib import style -_NO_BLANK_LINES = 1 -_ONE_BLANK_LINE = 2 +_NO_BLANK_LINES = 1 +_ONE_BLANK_LINE = 2 _TWO_BLANK_LINES = 3 -_PYTHON_STATEMENTS = frozenset( - { - 'small_stmt', 'expr_stmt', 'print_stmt', 'del_stmt', 'pass_stmt', - 'break_stmt', 'continue_stmt', 'return_stmt', 'raise_stmt', - 'yield_stmt', 'import_stmt', 'global_stmt', 'exec_stmt', 'assert_stmt', - 'if_stmt', 'while_stmt', 'for_stmt', 'try_stmt', 'with_stmt', - 'nonlocal_stmt', 'async_stmt', 'simple_stmt' - }) +_PYTHON_STATEMENTS = frozenset({ + 'small_stmt', 'expr_stmt', 'print_stmt', 'del_stmt', 'pass_stmt', + 'break_stmt', 'continue_stmt', 'return_stmt', 'raise_stmt', 'yield_stmt', + 'import_stmt', 'global_stmt', 'exec_stmt', 'assert_stmt', 'if_stmt', + 'while_stmt', 'for_stmt', 'try_stmt', 'with_stmt', 'nonlocal_stmt', + 'async_stmt', 'simple_stmt' +}) def CalculateBlankLines(tree): @@ -59,10 +58,10 @@ class _BlankLineCalculator(pytree_visitor.PyTreeVisitor): """_BlankLineCalculator - see file-level docstring for a description.""" def __init__(self): - self.class_level = 0 - self.function_level = 0 - self.last_comment_lineno = 0 - self.last_was_decorator = False + self.class_level = 0 + self.function_level = 0 + self.last_comment_lineno = 0 + self.last_was_decorator = False self.last_was_class_or_function = False def Visit_simple_stmt(self, node): # pylint: disable=invalid-name @@ -82,17 +81,17 @@ def Visit_decorator(self, node): # pylint: disable=invalid-name def Visit_classdef(self, node): # pylint: disable=invalid-name self.last_was_class_or_function = False - index = self._SetBlankLinesBetweenCommentAndClassFunc(node) - self.last_was_decorator = False - self.class_level += 1 + index = self._SetBlankLinesBetweenCommentAndClassFunc(node) + self.last_was_decorator = False + self.class_level += 1 for child in node.children[index:]: self.Visit(child) - self.class_level -= 1 + self.class_level -= 1 self.last_was_class_or_function = True def Visit_funcdef(self, node): # pylint: disable=invalid-name self.last_was_class_or_function = False - index = self._SetBlankLinesBetweenCommentAndClassFunc(node) + index = self._SetBlankLinesBetweenCommentAndClassFunc(node) if _AsyncFunction(node): index = self._SetBlankLinesBetweenCommentAndClassFunc( node.prev_sibling.parent) @@ -100,10 +99,10 @@ def Visit_funcdef(self, node): # pylint: disable=invalid-name else: index = self._SetBlankLinesBetweenCommentAndClassFunc(node) self.last_was_decorator = False - self.function_level += 1 + self.function_level += 1 for child in node.children[index:]: self.Visit(child) - self.function_level -= 1 + self.function_level -= 1 self.last_was_class_or_function = True def DefaultNodeVisit(self, node): @@ -161,23 +160,20 @@ def _GetNumNewlines(self, node): return _ONE_BLANK_LINE def _IsTopLevel(self, node): - return ( - not (self.class_level or self.function_level) and - _StartsInZerothColumn(node)) + return (not (self.class_level or self.function_level) and + _StartsInZerothColumn(node)) def _SetNumNewlines(node, num_newlines): - pytree_utils.SetNodeAnnotation( - node, pytree_utils.Annotation.NEWLINES, num_newlines) + pytree_utils.SetNodeAnnotation(node, pytree_utils.Annotation.NEWLINES, + num_newlines) def _StartsInZerothColumn(node): - return ( - pytree_utils.FirstLeafNode(node).column == 0 or - (_AsyncFunction(node) and node.prev_sibling.column == 0)) + return (pytree_utils.FirstLeafNode(node).column == 0 or + (_AsyncFunction(node) and node.prev_sibling.column == 0)) def _AsyncFunction(node): - return ( - py3compat.PY3 and node.prev_sibling and - node.prev_sibling.type == grammar_token.ASYNC) + return (py3compat.PY3 and node.prev_sibling and + node.prev_sibling.type == grammar_token.ASYNC) diff --git a/yapf/pytree/comment_splicer.py b/yapf/pytree/comment_splicer.py index f5406e968..ae5ffe66f 100644 --- a/yapf/pytree/comment_splicer.py +++ b/yapf/pytree/comment_splicer.py @@ -60,7 +60,7 @@ def _VisitNodeRec(node): # Remember the leading indentation of this prefix and clear it. # Mopping up the prefix is important because we may go over this same # child in the next iteration... - child_prefix = child.prefix.lstrip('\n') + child_prefix = child.prefix.lstrip('\n') prefix_indent = child_prefix[:child_prefix.find('#')] if '\n' in prefix_indent: prefix_indent = prefix_indent[prefix_indent.rfind('\n') + 1:] @@ -171,23 +171,22 @@ def _VisitNodeRec(node): else: if comment_lineno == prev_leaf[0].lineno: comment_lines = comment_prefix.splitlines() - value = comment_lines[0].lstrip() + value = comment_lines[0].lstrip() if value.rstrip('\n'): - comment_column = prev_leaf[0].column + comment_column = prev_leaf[0].column comment_column += len(prev_leaf[0].value) - comment_column += ( + comment_column += ( len(comment_lines[0]) - len(comment_lines[0].lstrip())) comment_leaf = pytree.Leaf( - type =token.COMMENT, - value =value.rstrip('\n'), - context =('', (comment_lineno, comment_column))) + type=token.COMMENT, + value=value.rstrip('\n'), + context=('', (comment_lineno, comment_column))) pytree_utils.InsertNodesAfter([comment_leaf], prev_leaf[0]) - comment_prefix = '\n'.join(comment_lines[1:]) + comment_prefix = '\n'.join(comment_lines[1:]) comment_lineno += 1 - rindex = ( - 0 if '\n' not in comment_prefix.rstrip() else - comment_prefix.rstrip().rindex('\n') + 1) + rindex = (0 if '\n' not in comment_prefix.rstrip() else + comment_prefix.rstrip().rindex('\n') + 1) comment_column = ( len(comment_prefix[rindex:]) - len(comment_prefix[rindex:].lstrip())) @@ -204,8 +203,10 @@ def _VisitNodeRec(node): _VisitNodeRec(tree) -def _CreateCommentsFromPrefix( - comment_prefix, comment_lineno, comment_column, standalone=False): +def _CreateCommentsFromPrefix(comment_prefix, + comment_lineno, + comment_column, + standalone=False): """Create pytree nodes to represent the given comment prefix. Args: @@ -233,13 +234,13 @@ def _CreateCommentsFromPrefix( index += 1 if comment_block: - new_lineno = comment_lineno + index - 1 - comment_block[0] = comment_block[0].strip() + new_lineno = comment_lineno + index - 1 + comment_block[0] = comment_block[0].strip() comment_block[-1] = comment_block[-1].strip() - comment_leaf = pytree.Leaf( - type =token.COMMENT, - value ='\n'.join(comment_block), - context =('', (new_lineno, comment_column))) + comment_leaf = pytree.Leaf( + type=token.COMMENT, + value='\n'.join(comment_block), + context=('', (new_lineno, comment_column))) comment_node = comment_leaf if not standalone else pytree.Node( pygram.python_symbols.simple_stmt, [comment_leaf]) comments.append(comment_node) @@ -261,11 +262,10 @@ def _CreateCommentsFromPrefix( # line, not on the same line with other code), it's important to insert it into # an appropriate parent of the node it's attached to. An appropriate parent # is the first "standalone line node" in the parent chain of a node. -_STANDALONE_LINE_NODES = frozenset( - [ - 'suite', 'if_stmt', 'while_stmt', 'for_stmt', 'try_stmt', 'with_stmt', - 'funcdef', 'classdef', 'decorated', 'file_input' - ]) +_STANDALONE_LINE_NODES = frozenset([ + 'suite', 'if_stmt', 'while_stmt', 'for_stmt', 'try_stmt', 'with_stmt', + 'funcdef', 'classdef', 'decorated', 'file_input' +]) def _FindNodeWithStandaloneLineParent(node): @@ -352,14 +352,14 @@ def _AnnotateIndents(tree): """ # Annotate the root of the tree with zero indent. if tree.parent is None: - pytree_utils.SetNodeAnnotation( - tree, pytree_utils.Annotation.CHILD_INDENT, '') + pytree_utils.SetNodeAnnotation(tree, pytree_utils.Annotation.CHILD_INDENT, + '') for child in tree.children: if child.type == token.INDENT: child_indent = pytree_utils.GetNodeAnnotation( tree, pytree_utils.Annotation.CHILD_INDENT) if child_indent is not None and child_indent != child.value: raise RuntimeError('inconsistent indentation for child', (tree, child)) - pytree_utils.SetNodeAnnotation( - tree, pytree_utils.Annotation.CHILD_INDENT, child.value) + pytree_utils.SetNodeAnnotation(tree, pytree_utils.Annotation.CHILD_INDENT, + child.value) _AnnotateIndents(child) diff --git a/yapf/pytree/continuation_splicer.py b/yapf/pytree/continuation_splicer.py index 2648da033..b86188cb5 100644 --- a/yapf/pytree/continuation_splicer.py +++ b/yapf/pytree/continuation_splicer.py @@ -38,9 +38,9 @@ def RecSplicer(node): if node.prefix.lstrip().startswith('\\\n'): new_lineno = node.lineno - node.prefix.count('\n') return pytree.Leaf( - type =format_token.CONTINUATION, - value =node.prefix, - context =('', (new_lineno, 0))) + type=format_token.CONTINUATION, + value=node.prefix, + context=('', (new_lineno, 0))) return None num_inserted = 0 for index, child in enumerate(node.children[:]): diff --git a/yapf/pytree/pytree_unwrapper.py b/yapf/pytree/pytree_unwrapper.py index 835ca60a1..3fe4ade08 100644 --- a/yapf/pytree/pytree_unwrapper.py +++ b/yapf/pytree/pytree_unwrapper.py @@ -61,11 +61,10 @@ def UnwrapPyTree(tree): # Grammar tokens considered as whitespace for the purpose of unwrapping. -_WHITESPACE_TOKENS = frozenset( - [ - grammar_token.NEWLINE, grammar_token.DEDENT, grammar_token.INDENT, - grammar_token.ENDMARKER - ]) +_WHITESPACE_TOKENS = frozenset([ + grammar_token.NEWLINE, grammar_token.DEDENT, grammar_token.INDENT, + grammar_token.ENDMARKER +]) class PyTreeUnwrapper(pytree_visitor.PyTreeVisitor): @@ -119,17 +118,16 @@ def _StartNewLine(self): _AdjustSplitPenalty(self._cur_logical_line) self._cur_logical_line = logical_line.LogicalLine(self._cur_depth) - _STMT_TYPES = frozenset( - { - 'if_stmt', - 'while_stmt', - 'for_stmt', - 'try_stmt', - 'expect_clause', - 'with_stmt', - 'funcdef', - 'classdef', - }) + _STMT_TYPES = frozenset({ + 'if_stmt', + 'while_stmt', + 'for_stmt', + 'try_stmt', + 'expect_clause', + 'with_stmt', + 'funcdef', + 'classdef', + }) # pylint: disable=invalid-name,missing-docstring def Visit_simple_stmt(self, node): @@ -322,7 +320,7 @@ def _MatchBrackets(line): bracket_stack.append(token) elif token.value in _CLOSING_BRACKETS: bracket_stack[-1].matching_bracket = token - token.matching_bracket = bracket_stack[-1] + token.matching_bracket = bracket_stack[-1] bracket_stack.pop() for bracket in bracket_stack: @@ -340,7 +338,7 @@ def _IdentifyParameterLists(line): Arguments: line: (LogicalLine) A logical line. """ - func_stack = [] + func_stack = [] param_stack = [] for tok in line.tokens: # Identify parameter list objects. @@ -376,9 +374,9 @@ def _AdjustSplitPenalty(line): bracket_level = 0 for index, token in enumerate(line.tokens): if index and not bracket_level: - pytree_utils.SetNodeAnnotation( - token.node, pytree_utils.Annotation.SPLIT_PENALTY, - split_penalty.UNBREAKABLE) + pytree_utils.SetNodeAnnotation(token.node, + pytree_utils.Annotation.SPLIT_PENALTY, + split_penalty.UNBREAKABLE) if token.value in _OPENING_BRACKETS: bracket_level += 1 elif token.value in _CLOSING_BRACKETS: @@ -398,7 +396,7 @@ def _DetermineMustSplitAnnotation(node): node.children[-1].value != ','): return num_children = len(node.children) - index = 0 + index = 0 _SetMustSplitOnFirstLeaf(node.children[0]) while index < num_children - 1: child = node.children[index] diff --git a/yapf/pytree/pytree_utils.py b/yapf/pytree/pytree_utils.py index b54a0c043..66a54e617 100644 --- a/yapf/pytree/pytree_utils.py +++ b/yapf/pytree/pytree_utils.py @@ -42,11 +42,11 @@ class Annotation(object): """Annotation names associated with pytrees.""" - CHILD_INDENT = 'child_indent' - NEWLINES = 'newlines' - MUST_SPLIT = 'must_split' + CHILD_INDENT = 'child_indent' + NEWLINES = 'newlines' + MUST_SPLIT = 'must_split' SPLIT_PENALTY = 'split_penalty' - SUBTYPE = 'subtype' + SUBTYPE = 'subtype' def NodeName(node): @@ -113,13 +113,13 @@ def ParseCodeToTree(code): # Try to parse using a Python 3 grammar, which is more permissive (print and # exec are not keywords). parser_driver = driver.Driver(_GRAMMAR_FOR_PY3, convert=pytree.convert) - tree = parser_driver.parse_string(code, debug=False) + tree = parser_driver.parse_string(code, debug=False) except parse.ParseError: # Now try to parse using a Python 2 grammar; If this fails, then # there's something else wrong with the code. try: parser_driver = driver.Driver(_GRAMMAR_FOR_PY2, convert=pytree.convert) - tree = parser_driver.parse_string(code, debug=False) + tree = parser_driver.parse_string(code, debug=False) except parse.ParseError: # Raise a syntax error if the code is invalid python syntax. try: @@ -195,9 +195,8 @@ def _InsertNodeAt(new_node, target, after=False): # Protect against attempts to insert nodes which already belong to some tree. if new_node.parent is not None: - raise RuntimeError( - 'inserting node which already has a parent', - (new_node, new_node.parent)) + raise RuntimeError('inserting node which already has a parent', + (new_node, new_node.parent)) # The code here is based on pytree.Base.next_sibling parent_of_target = target.parent @@ -210,8 +209,8 @@ def _InsertNodeAt(new_node, target, after=False): parent_of_target.insert_child(insertion_index, new_node) return - raise RuntimeError( - 'unable to find insertion point for target node', (target,)) + raise RuntimeError('unable to find insertion point for target node', + (target,)) # The following constant and functions implement a simple custom annotation @@ -317,35 +316,32 @@ def DumpNodeToString(node): The string representation. """ if isinstance(node, pytree.Leaf): - fmt = ( - '{name}({value}) [lineno={lineno}, column={column}, ' - 'prefix={prefix}, penalty={penalty}]') + fmt = ('{name}({value}) [lineno={lineno}, column={column}, ' + 'prefix={prefix}, penalty={penalty}]') return fmt.format( - name =NodeName(node), - value =_PytreeNodeRepr(node), - lineno =node.lineno, - column =node.column, - prefix =repr(node.prefix), - penalty =GetNodeAnnotation(node, Annotation.SPLIT_PENALTY, None)) + name=NodeName(node), + value=_PytreeNodeRepr(node), + lineno=node.lineno, + column=node.column, + prefix=repr(node.prefix), + penalty=GetNodeAnnotation(node, Annotation.SPLIT_PENALTY, None)) else: fmt = '{node} [{len} children] [child_indent="{indent}"]' return fmt.format( - node =NodeName(node), - len =len(node.children), - indent =GetNodeAnnotation(node, Annotation.CHILD_INDENT)) + node=NodeName(node), + len=len(node.children), + indent=GetNodeAnnotation(node, Annotation.CHILD_INDENT)) def _PytreeNodeRepr(node): """Like pytree.Node.__repr__, but names instead of numbers for tokens.""" if isinstance(node, pytree.Node): - return '%s(%s, %r)' % ( - node.__class__.__name__, NodeName(node), - [_PytreeNodeRepr(c) for c in node.children]) + return '%s(%s, %r)' % (node.__class__.__name__, NodeName(node), + [_PytreeNodeRepr(c) for c in node.children]) if isinstance(node, pytree.Leaf): return '%s(%s, %r)' % (node.__class__.__name__, NodeName(node), node.value) def IsCommentStatement(node): - return ( - NodeName(node) == 'simple_stmt' and - node.children[0].type == token.COMMENT) + return (NodeName(node) == 'simple_stmt' and + node.children[0].type == token.COMMENT) diff --git a/yapf/pytree/pytree_visitor.py b/yapf/pytree/pytree_visitor.py index 1cc2819f6..314431e84 100644 --- a/yapf/pytree/pytree_visitor.py +++ b/yapf/pytree/pytree_visitor.py @@ -117,7 +117,7 @@ def __init__(self, target_stream=sys.stdout): target_stream: the stream to dump the tree to. A file-like object. By default will dump into stdout. """ - self._target_stream = target_stream + self._target_stream = target_stream self._current_indent = 0 def _DumpString(self, s): diff --git a/yapf/pytree/split_penalty.py b/yapf/pytree/split_penalty.py index 08e1a5dbd..b53ffbf85 100644 --- a/yapf/pytree/split_penalty.py +++ b/yapf/pytree/split_penalty.py @@ -26,30 +26,30 @@ # TODO(morbo): Document the annotations in a centralized place. E.g., the # README file. -UNBREAKABLE = 1000 * 1000 -NAMED_ASSIGN = 15000 -DOTTED_NAME = 4000 +UNBREAKABLE = 1000 * 1000 +NAMED_ASSIGN = 15000 +DOTTED_NAME = 4000 VERY_STRONGLY_CONNECTED = 3500 -STRONGLY_CONNECTED = 3000 -CONNECTED = 500 -TOGETHER = 100 - -OR_TEST = 1000 -AND_TEST = 1100 -NOT_TEST = 1200 -COMPARISON = 1300 -STAR_EXPR = 1300 -EXPR = 1400 -XOR_EXPR = 1500 -AND_EXPR = 1700 -SHIFT_EXPR = 1800 -ARITH_EXPR = 1900 -TERM = 2000 -FACTOR = 2100 -POWER = 2200 -ATOM = 2300 +STRONGLY_CONNECTED = 3000 +CONNECTED = 500 +TOGETHER = 100 + +OR_TEST = 1000 +AND_TEST = 1100 +NOT_TEST = 1200 +COMPARISON = 1300 +STAR_EXPR = 1300 +EXPR = 1400 +XOR_EXPR = 1500 +AND_EXPR = 1700 +SHIFT_EXPR = 1800 +ARITH_EXPR = 1900 +TERM = 2000 +FACTOR = 2100 +POWER = 2200 +ATOM = 2300 ONE_ELEMENT_ARGUMENT = 500 -SUBSCRIPT = 6000 +SUBSCRIPT = 6000 def ComputeSplitPenalties(tree): @@ -210,10 +210,10 @@ def Visit_trailer(self, node): # pylint: disable=invalid-name # trailer ::= '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME if node.children[0].value == '.': before = style.Get('SPLIT_BEFORE_DOT') - _SetSplitPenalty( - node.children[0], VERY_STRONGLY_CONNECTED if before else DOTTED_NAME) - _SetSplitPenalty( - node.children[1], DOTTED_NAME if before else VERY_STRONGLY_CONNECTED) + _SetSplitPenalty(node.children[0], + VERY_STRONGLY_CONNECTED if before else DOTTED_NAME) + _SetSplitPenalty(node.children[1], + DOTTED_NAME if before else VERY_STRONGLY_CONNECTED) elif len(node.children) == 2: # Don't split an empty argument list if at all possible. _SetSplitPenalty(node.children[1], VERY_STRONGLY_CONNECTED) @@ -237,12 +237,10 @@ def Visit_trailer(self, node): # pylint: disable=invalid-name _SetStronglyConnected(node.children[1].children[2]) # Still allow splitting around the operator. - split_before = ( - ( - name.endswith('_test') and - style.Get('SPLIT_BEFORE_LOGICAL_OPERATOR')) or ( - name.endswith('_expr') and - style.Get('SPLIT_BEFORE_BITWISE_OPERATOR'))) + split_before = ((name.endswith('_test') and + style.Get('SPLIT_BEFORE_LOGICAL_OPERATOR')) or + (name.endswith('_expr') and + style.Get('SPLIT_BEFORE_BITWISE_OPERATOR'))) if split_before: _SetSplitPenalty( pytree_utils.LastLeafNode(node.children[1].children[1]), 0) @@ -251,11 +249,12 @@ def Visit_trailer(self, node): # pylint: disable=invalid-name pytree_utils.FirstLeafNode(node.children[1].children[2]), 0) # Don't split the ending bracket of a subscript list. - _RecAnnotate( - node.children[-1], pytree_utils.Annotation.SPLIT_PENALTY, - VERY_STRONGLY_CONNECTED) - elif name not in {'arglist', 'argument', 'term', 'or_test', 'and_test', - 'comparison', 'atom', 'power'}: + _RecAnnotate(node.children[-1], pytree_utils.Annotation.SPLIT_PENALTY, + VERY_STRONGLY_CONNECTED) + elif name not in { + 'arglist', 'argument', 'term', 'or_test', 'and_test', 'comparison', + 'atom', 'power' + }: # Don't split an argument list with one element if at all possible. stypes = pytree_utils.GetNodeAnnotation( pytree_utils.FirstLeafNode(node), pytree_utils.Annotation.SUBTYPE) @@ -296,7 +295,7 @@ def Visit_power(self, node): # pylint: disable=invalid-name,missing-docstring prev_trailer_idx = 1 while prev_trailer_idx < len(node.children) - 1: cur_trailer_idx = prev_trailer_idx + 1 - cur_trailer = node.children[cur_trailer_idx] + cur_trailer = node.children[cur_trailer_idx] if pytree_utils.NodeName(cur_trailer) != 'trailer': break @@ -370,8 +369,8 @@ def Visit_old_comp_for(self, node): # pylint: disable=invalid-name def Visit_comp_if(self, node): # pylint: disable=invalid-name # comp_if ::= 'if' old_test [comp_iter] - _SetSplitPenalty( - node.children[0], style.Get('SPLIT_PENALTY_BEFORE_IF_EXPR')) + _SetSplitPenalty(node.children[0], + style.Get('SPLIT_PENALTY_BEFORE_IF_EXPR')) _SetStronglyConnected(*node.children[1:]) self.DefaultNodeVisit(node) @@ -515,8 +514,8 @@ def _SetUnbreakable(node): def _SetStronglyConnected(*nodes): """Set a STRONGLY_CONNECTED penalty annotation for the given nodes.""" for node in nodes: - _RecAnnotate( - node, pytree_utils.Annotation.SPLIT_PENALTY, STRONGLY_CONNECTED) + _RecAnnotate(node, pytree_utils.Annotation.SPLIT_PENALTY, + STRONGLY_CONNECTED) def _SetExpressionPenalty(node, penalty): @@ -630,5 +629,5 @@ def _DecrementSplitPenalty(node, amt): def _SetSplitPenalty(node, penalty): - pytree_utils.SetNodeAnnotation( - node, pytree_utils.Annotation.SPLIT_PENALTY, penalty) + pytree_utils.SetNodeAnnotation(node, pytree_utils.Annotation.SPLIT_PENALTY, + penalty) diff --git a/yapf/pytree/subtype_assigner.py b/yapf/pytree/subtype_assigner.py index 310b2134f..0ee247a82 100644 --- a/yapf/pytree/subtype_assigner.py +++ b/yapf/pytree/subtype_assigner.py @@ -46,10 +46,10 @@ def AssignSubtypes(tree): # Map tokens in argument lists to their respective subtype. _ARGLIST_TOKEN_TO_SUBTYPE = { - '=' : subtypes.DEFAULT_OR_NAMED_ASSIGN, - ':' : subtypes.TYPED_NAME, - '*' : subtypes.VARARGS_STAR, - '**' : subtypes.KWARGS_STAR_STAR, + '=': subtypes.DEFAULT_OR_NAMED_ASSIGN, + ':': subtypes.TYPED_NAME, + '*': subtypes.VARARGS_STAR, + '**': subtypes.KWARGS_STAR_STAR, } @@ -66,7 +66,7 @@ def Visit_dictsetmaker(self, node): # pylint: disable=invalid-name for child in node.children: self.Visit(child) - comp_for = False + comp_for = False dict_maker = False for child in node.children: @@ -78,7 +78,7 @@ def Visit_dictsetmaker(self, node): # pylint: disable=invalid-name if not comp_for and dict_maker: last_was_colon = False - unpacking = False + unpacking = False for child in node.children: if child.type == grammar_token.DOUBLESTAR: _AppendFirstLeafTokenSubtype(child, subtypes.KWARGS_STAR_STAR) @@ -248,15 +248,13 @@ def Visit_arglist(self, node): # pylint: disable=invalid-name # | '*' test (',' argument)* [',' '**' test] # | '**' test) self._ProcessArgLists(node) - _SetArgListSubtype( - node, subtypes.DEFAULT_OR_NAMED_ASSIGN, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST) + _SetArgListSubtype(node, subtypes.DEFAULT_OR_NAMED_ASSIGN, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST) def Visit_tname(self, node): # pylint: disable=invalid-name self._ProcessArgLists(node) - _SetArgListSubtype( - node, subtypes.DEFAULT_OR_NAMED_ASSIGN, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST) + _SetArgListSubtype(node, subtypes.DEFAULT_OR_NAMED_ASSIGN, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST) def Visit_decorator(self, node): # pylint: disable=invalid-name # decorator ::= @@ -290,9 +288,8 @@ def Visit_typedargslist(self, node): # pylint: disable=invalid-name # | '**' tname) # | tfpdef ['=' test] (',' tfpdef ['=' test])* [',']) self._ProcessArgLists(node) - _SetArgListSubtype( - node, subtypes.DEFAULT_OR_NAMED_ASSIGN, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST) + _SetArgListSubtype(node, subtypes.DEFAULT_OR_NAMED_ASSIGN, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST) tname = False if not node.children: return @@ -303,7 +300,7 @@ def Visit_typedargslist(self, node): # pylint: disable=invalid-name tname = pytree_utils.NodeName(node.children[0]) == 'tname' for i in range(1, len(node.children)): prev_child = node.children[i - 1] - child = node.children[i] + child = node.children[i] if prev_child.type == grammar_token.COMMA: _AppendFirstLeafTokenSubtype(child, subtypes.PARAMETER_START) elif child.type == grammar_token.COMMA: @@ -311,8 +308,8 @@ def Visit_typedargslist(self, node): # pylint: disable=invalid-name if pytree_utils.NodeName(child) == 'tname': tname = True - _SetArgListSubtype( - child, subtypes.TYPED_NAME, subtypes.TYPED_NAME_ARG_LIST) + _SetArgListSubtype(child, subtypes.TYPED_NAME, + subtypes.TYPED_NAME_ARG_LIST) # NOTE Every element of the tynamme argument # should have this list type _AppendSubtypeRec(child, subtypes.TYPED_NAME_ARG_LIST) @@ -340,8 +337,8 @@ def Visit_comp_for(self, node): # pylint: disable=invalid-name _AppendSubtypeRec(node, subtypes.COMP_FOR) # Mark the previous node as COMP_EXPR unless this is a nested comprehension # as these will have the outer comprehension as their previous node. - attr = pytree_utils.GetNodeAnnotation( - node.parent, pytree_utils.Annotation.SUBTYPE) + attr = pytree_utils.GetNodeAnnotation(node.parent, + pytree_utils.Annotation.SUBTYPE) if not attr or subtypes.COMP_FOR not in attr: _AppendSubtypeRec(node.parent.children[0], subtypes.COMP_EXPR) self.DefaultNodeVisit(node) @@ -397,8 +394,8 @@ def HasSubtype(node): def _AppendTokenSubtype(node, subtype): """Append the token's subtype only if it's not already set.""" - pytree_utils.AppendNodeAnnotation( - node, pytree_utils.Annotation.SUBTYPE, subtype) + pytree_utils.AppendNodeAnnotation(node, pytree_utils.Annotation.SUBTYPE, + subtype) def _AppendFirstLeafTokenSubtype(node, subtype): @@ -435,14 +432,14 @@ def _InsertPseudoParentheses(node): node.children[-1].remove() first = pytree_utils.FirstLeafNode(node) - last = pytree_utils.LastLeafNode(node) + last = pytree_utils.LastLeafNode(node) if first == last and first.type == grammar_token.COMMENT: # A comment was inserted before the value, which is a pytree.Leaf. # Encompass the dictionary's value into an ATOM node. - last = first.next_sibling + last = first.next_sibling last_clone = last.clone() - new_node = pytree.Node(syms.atom, [first.clone(), last_clone]) + new_node = pytree.Node(syms.atom, [first.clone(), last_clone]) for orig_leaf, clone_leaf in zip(last.leaves(), last_clone.leaves()): pytree_utils.CopyYapfAnnotations(orig_leaf, clone_leaf) if hasattr(orig_leaf, 'is_pseudo'): @@ -453,7 +450,7 @@ def _InsertPseudoParentheses(node): last.remove() first = pytree_utils.FirstLeafNode(node) - last = pytree_utils.LastLeafNode(node) + last = pytree_utils.LastLeafNode(node) lparen = pytree.Leaf( grammar_token.LPAR, diff --git a/yapf/third_party/yapf_diff/yapf_diff.py b/yapf/third_party/yapf_diff/yapf_diff.py index 48551ba96..810a6a2d4 100644 --- a/yapf/third_party/yapf_diff/yapf_diff.py +++ b/yapf/third_party/yapf_diff/yapf_diff.py @@ -44,32 +44,32 @@ def main(): parser.add_argument( '-i', '--in-place', - action ='store_true', - default =False, - help ='apply edits to files instead of displaying a diff') + action='store_true', + default=False, + help='apply edits to files instead of displaying a diff') parser.add_argument( '-p', '--prefix', - metavar ='NUM', - default =1, - help ='strip the smallest prefix containing P slashes') + metavar='NUM', + default=1, + help='strip the smallest prefix containing P slashes') parser.add_argument( '--regex', - metavar ='PATTERN', - default =None, - help ='custom pattern selecting file paths to reformat ' + metavar='PATTERN', + default=None, + help='custom pattern selecting file paths to reformat ' '(case sensitive, overrides -iregex)') parser.add_argument( '--iregex', - metavar ='PATTERN', - default =r'.*\.(py)', - help ='custom pattern selecting file paths to reformat ' + metavar='PATTERN', + default=r'.*\.(py)', + help='custom pattern selecting file paths to reformat ' '(case insensitive, overridden by -regex)') parser.add_argument( '-v', '--verbose', - action ='store_true', - help ='be more verbose, ineffective without -i') + action='store_true', + help='be more verbose, ineffective without -i') parser.add_argument( '--style', help='specify formatting style: either a style name (for ' @@ -83,7 +83,7 @@ def main(): args = parser.parse_args() # Extract changed lines for each file. - filename = None + filename = None lines_by_file = {} for line in sys.stdin: match = re.search(r'^\+\+\+\ (.*?/){%s}(\S*)' % args.prefix, line) @@ -122,10 +122,10 @@ def main(): command.extend(['--style', args.style]) p = subprocess.Popen( command, - stdout =subprocess.PIPE, - stderr =None, - stdin =subprocess.PIPE, - universal_newlines =True) + stdout=subprocess.PIPE, + stderr=None, + stdin=subprocess.PIPE, + universal_newlines=True) stdout, stderr = p.communicate() if p.returncode != 0: sys.exit(p.returncode) @@ -134,9 +134,8 @@ def main(): with open(filename) as f: code = f.readlines() formatted_code = StringIO(stdout).readlines() - diff = difflib.unified_diff( - code, formatted_code, filename, filename, '(before formatting)', - '(after formatting)') + diff = difflib.unified_diff(code, formatted_code, filename, filename, + '(before formatting)', '(after formatting)') diff_string = ''.join(diff) if len(diff_string) > 0: sys.stdout.write(diff_string) diff --git a/yapf/yapflib/errors.py b/yapf/yapflib/errors.py index cb8694d2c..99e88d9c0 100644 --- a/yapf/yapflib/errors.py +++ b/yapf/yapflib/errors.py @@ -32,8 +32,8 @@ def FormatErrorMsg(e): if isinstance(e, SyntaxError): return '{}:{}:{}: {}'.format(e.filename, e.lineno, e.offset, e.msg) if isinstance(e, tokenize.TokenError): - return '{}:{}:{}: {}'.format( - e.filename, e.args[1][0], e.args[1][1], e.args[0]) + return '{}:{}:{}: {}'.format(e.filename, e.args[1][0], e.args[1][1], + e.args[0]) return '{}:{}:{}: {}'.format(e.args[1][0], e.args[1][1], e.args[1][2], e.msg) diff --git a/yapf/yapflib/file_resources.py b/yapf/yapflib/file_resources.py index 9c071db3d..b5e2612bd 100644 --- a/yapf/yapflib/file_resources.py +++ b/yapf/yapflib/file_resources.py @@ -25,8 +25,8 @@ from yapf.yapflib import py3compat from yapf.yapflib import style -CR = '\r' -LF = '\n' +CR = '\r' +LF = '\n' CRLF = '\r\n' @@ -56,7 +56,7 @@ def _GetExcludePatternsFromPyprojectToml(filename): "configuration file") if os.path.isfile(filename) and os.access(filename, os.R_OK): - pyproject_toml = toml.load(filename) + pyproject_toml = toml.load(filename) ignore_patterns = pyproject_toml.get('tool', {}).get('yapfignore', {}).get('ignore_patterns', []) @@ -140,7 +140,7 @@ def GetDefaultStyleForDir(dirname, default_style=style.DEFAULT_STYLE): "configuration file") pyproject_toml = toml.load(config_file) - style_dict = pyproject_toml.get('tool', {}).get('yapf', None) + style_dict = pyproject_toml.get('tool', {}).get('yapf', None) if style_dict is not None: return config_file @@ -161,8 +161,10 @@ def GetCommandLineFiles(command_line_file_list, recursive, exclude): return _FindPythonFiles(command_line_file_list, recursive, exclude) -def WriteReformattedCode( - filename, reformatted_code, encoding='', in_place=False): +def WriteReformattedCode(filename, + reformatted_code, + encoding='', + in_place=False): """Emit the reformatted code. Write the reformatted code into the file, if in_place is True. Otherwise, @@ -175,8 +177,8 @@ def WriteReformattedCode( in_place: (bool) If True, then write the reformatted code to the file. """ if in_place: - with py3compat.open_with_encoding(filename, mode='w', encoding=encoding, - newline='') as fd: + with py3compat.open_with_encoding( + filename, mode='w', encoding=encoding, newline='') as fd: fd.write(reformatted_code) else: py3compat.EncodeAndWriteToStdout(reformatted_code) @@ -263,8 +265,8 @@ def IsPythonFile(filename): encoding = py3compat.detect_encoding(fd.readline)[0] # Check for correctness of encoding. - with py3compat.open_with_encoding(filename, mode='r', - encoding=encoding) as fd: + with py3compat.open_with_encoding( + filename, mode='r', encoding=encoding) as fd: fd.read() except UnicodeDecodeError: encoding = 'latin-1' @@ -275,8 +277,8 @@ def IsPythonFile(filename): return False try: - with py3compat.open_with_encoding(filename, mode='r', - encoding=encoding) as fd: + with py3compat.open_with_encoding( + filename, mode='r', encoding=encoding) as fd: first_line = fd.readline(256) except IOError: return False diff --git a/yapf/yapflib/format_decision_state.py b/yapf/yapflib/format_decision_state.py index 40bf5e25b..efcef0ba4 100644 --- a/yapf/yapflib/format_decision_state.py +++ b/yapf/yapflib/format_decision_state.py @@ -66,62 +66,59 @@ def __init__(self, line, first_indent): line: (LogicalLine) The logical line we're currently processing. first_indent: (int) The indent of the first token. """ - self.next_token = line.first - self.column = first_indent - self.line = line - self.paren_level = 0 - self.lowest_level_on_line = 0 + self.next_token = line.first + self.column = first_indent + self.line = line + self.paren_level = 0 + self.lowest_level_on_line = 0 self.ignore_stack_for_comparison = False - self.stack = [_ParenState(first_indent, first_indent)] - self.comp_stack = [] - self.param_list_stack = [] - self.first_indent = first_indent - self.column_limit = style.Get('COLUMN_LIMIT') + self.stack = [_ParenState(first_indent, first_indent)] + self.comp_stack = [] + self.param_list_stack = [] + self.first_indent = first_indent + self.column_limit = style.Get('COLUMN_LIMIT') def Clone(self): """Clones a FormatDecisionState object.""" - new = FormatDecisionState(self.line, self.first_indent) - new.next_token = self.next_token - new.column = self.column - new.line = self.line - new.paren_level = self.paren_level - new.line.depth = self.line.depth - new.lowest_level_on_line = self.lowest_level_on_line + new = FormatDecisionState(self.line, self.first_indent) + new.next_token = self.next_token + new.column = self.column + new.line = self.line + new.paren_level = self.paren_level + new.line.depth = self.line.depth + new.lowest_level_on_line = self.lowest_level_on_line new.ignore_stack_for_comparison = self.ignore_stack_for_comparison - new.first_indent = self.first_indent - new.stack = [state.Clone() for state in self.stack] - new.comp_stack = [state.Clone() for state in self.comp_stack] - new.param_list_stack = [state.Clone() for state in self.param_list_stack] + new.first_indent = self.first_indent + new.stack = [state.Clone() for state in self.stack] + new.comp_stack = [state.Clone() for state in self.comp_stack] + new.param_list_stack = [state.Clone() for state in self.param_list_stack] return new def __eq__(self, other): # Note: 'first_indent' is implicit in the stack. Also, we ignore 'previous', # because it shouldn't have a bearing on this comparison. (I.e., it will # report equal if 'next_token' does.) - return ( - self.next_token == other.next_token and self.column == other.column and - self.paren_level == other.paren_level and - self.line.depth == other.line.depth and - self.lowest_level_on_line == other.lowest_level_on_line and ( - self.ignore_stack_for_comparison or - other.ignore_stack_for_comparison or self.stack == other.stack and - self.comp_stack == other.comp_stack and - self.param_list_stack == other.param_list_stack)) + return (self.next_token == other.next_token and + self.column == other.column and + self.paren_level == other.paren_level and + self.line.depth == other.line.depth and + self.lowest_level_on_line == other.lowest_level_on_line and + (self.ignore_stack_for_comparison or + other.ignore_stack_for_comparison or self.stack == other.stack and + self.comp_stack == other.comp_stack and + self.param_list_stack == other.param_list_stack)) def __ne__(self, other): return not self == other def __hash__(self): - return hash( - ( - self.next_token, self.column, self.paren_level, self.line.depth, - self.lowest_level_on_line)) + return hash((self.next_token, self.column, self.paren_level, + self.line.depth, self.lowest_level_on_line)) def __repr__(self): - return ( - 'column::%d, next_token::%s, paren_level::%d, stack::[\n\t%s' % ( - self.column, repr(self.next_token), self.paren_level, - '\n\t'.join(repr(s) for s in self.stack) + ']')) + return ('column::%d, next_token::%s, paren_level::%d, stack::[\n\t%s' % + (self.column, repr(self.next_token), self.paren_level, + '\n\t'.join(repr(s) for s in self.stack) + ']')) def CanSplit(self, must_split): """Determine if we can split before the next token. @@ -132,7 +129,7 @@ def CanSplit(self, must_split): Returns: True if the line can be split before the next token. """ - current = self.next_token + current = self.next_token previous = current.previous_token if current.is_pseudo: @@ -169,7 +166,7 @@ def CanSplit(self, must_split): def MustSplit(self): """Returns True if the line must split before the next token.""" - current = self.next_token + current = self.next_token previous = current.previous_token if current.is_pseudo: @@ -292,7 +289,7 @@ def SurroundedByParens(token): # # or when a string formatting syntax. func_call_or_string_format = False - tok = current.next_token + tok = current.next_token if current.is_name: while tok and (tok.is_name or tok.value == '.'): tok = tok.next_token @@ -424,7 +421,7 @@ def SurroundedByParens(token): (opening.previous_token.is_name or opening.previous_token.value in {'*', '**'})): is_func_call = False - opening = current + opening = current while opening: if opening.value == '(': is_func_call = True @@ -455,7 +452,7 @@ def SurroundedByParens(token): # default=False) if (current.value == '{' and previous.value == '(' and pprevious and pprevious.is_name): - dict_end = current.matching_bracket + dict_end = current.matching_bracket next_token = dict_end.next_token if next_token.value == ',' and not self._FitsOnLine(current, dict_end): return True @@ -486,7 +483,7 @@ def SurroundedByParens(token): (opening.previous_token.is_name or opening.previous_token.value in {'*', '**'})): is_func_call = False - opening = current + opening = current while opening: if opening.value == '(': is_func_call = True @@ -525,7 +522,7 @@ def SurroundedByParens(token): return False elements = previous.container_elements + [previous.matching_bracket] - i = 1 + i = 1 while i < len(elements): if (not elements[i - 1].OpensScope() and not self._FitsOnLine(elements[i - 1], elements[i])): @@ -597,7 +594,7 @@ def _AddTokenOnCurrentLine(self, dry_run): Arguments: dry_run: (bool) Commit whitespace changes to the FormatToken if True. """ - current = self.next_token + current = self.next_token previous = current.previous_token spaces = current.spaces_required_before @@ -640,14 +637,14 @@ def _AddTokenOnNewline(self, dry_run, must_split): Returns: The split penalty for splitting after the current state. """ - current = self.next_token + current = self.next_token previous = current.previous_token self.column = self._GetNewlineColumn() if not dry_run: indent_level = self.line.depth - spaces = self.column + spaces = self.column if spaces: spaces -= indent_level * style.Get('INDENT_WIDTH') current.AddWhitespacePrefix( @@ -660,7 +657,7 @@ def _AddTokenOnNewline(self, dry_run, must_split): if (previous.OpensScope() or (previous.is_comment and previous.previous_token is not None and previous.previous_token.OpensScope())): - dedent = (style.Get('CONTINUATION_INDENT_WIDTH'), + dedent = (style.Get('CONTINUATION_INDENT_WIDTH'), 0)[style.Get('INDENT_CLOSING_BRACKETS')] self.stack[-1].closing_scope_indent = ( max(0, self.stack[-1].indent - dedent)) @@ -680,9 +677,9 @@ def _AddTokenOnNewline(self, dry_run, must_split): # Add a penalty for each increasing newline we add, but don't penalize for # splitting before an if-expression or list comprehension. if current.value not in {'if', 'for'}: - last = self.stack[-1] + last = self.stack[-1] last.num_line_splits += 1 - penalty += ( + penalty += ( style.Get('SPLIT_PENALTY_FOR_ADDED_LINE_SPLIT') * last.num_line_splits) @@ -707,13 +704,13 @@ def MoveStateToNextToken(self): """ current = self.next_token if not current.OpensScope() and not current.ClosesScope(): - self.lowest_level_on_line = min( - self.lowest_level_on_line, self.paren_level) + self.lowest_level_on_line = min(self.lowest_level_on_line, + self.paren_level) # If we encounter an opening bracket, we add a level to our stack to prepare # for the subsequent tokens. if current.OpensScope(): - last = self.stack[-1] + last = self.stack[-1] new_indent = style.Get('CONTINUATION_INDENT_WIDTH') + last.last_space self.stack.append(_ParenState(new_indent, self.stack[-1].last_space)) @@ -743,7 +740,7 @@ def MoveStateToNextToken(self): if (not current.is_pylint_comment and not current.is_pytype_comment and not current.is_copybara_comment and self.column > self.column_limit): excess_characters = self.column - self.column_limit - penalty += style.Get('SPLIT_PENALTY_EXCESS_CHARACTER') * excess_characters + penalty += style.Get('SPLIT_PENALTY_EXCESS_CHARACTER') * excess_characters if is_multiline_string: # If this is a multiline string, the column is actually the @@ -762,10 +759,10 @@ def _CalculateComprehensionState(self, newline): The penalty for the token-newline combination given the current comprehension state. """ - current = self.next_token - previous = current.previous_token + current = self.next_token + previous = current.previous_token top_of_stack = self.comp_stack[-1] if self.comp_stack else None - penalty = 0 + penalty = 0 if top_of_stack is not None: # Check if the token terminates the current comprehension. @@ -801,7 +798,7 @@ def _CalculateComprehensionState(self, newline): not top_of_stack.HasTrivialExpr())): penalty += split_penalty.UNBREAKABLE else: - top_of_stack.for_token = current + top_of_stack.for_token = current top_of_stack.has_split_at_for = newline # Try to keep trivial expressions on the same line as the comp_for. @@ -826,14 +823,14 @@ def _PushParameterListState(self, newline): Args: newline: Whether the current token is to be added on a newline. """ - current = self.next_token + current = self.next_token previous = current.previous_token if _IsFunctionDefinition(previous): first_param_column = previous.total_length + self.stack[-2].indent self.param_list_stack.append( - object_state.ParameterListState( - previous, newline, first_param_column)) + object_state.ParameterListState(previous, newline, + first_param_column)) def _CalculateParameterListState(self, newline): """Makes required changes to parameter list state. @@ -845,18 +842,18 @@ def _CalculateParameterListState(self, newline): The penalty for the token-newline combination given the current parameter state. """ - current = self.next_token + current = self.next_token previous = current.previous_token - penalty = 0 + penalty = 0 if _IsFunctionDefinition(previous): first_param_column = previous.total_length + self.stack[-2].indent if not newline: param_list = self.param_list_stack[-1] if param_list.parameters and param_list.has_typed_return: - last_param = param_list.parameters[-1].first_token - last_token = _LastTokenInLine(previous.matching_bracket) - total_length = last_token.total_length + last_param = param_list.parameters[-1].first_token + last_token = _LastTokenInLine(previous.matching_bracket) + total_length = last_token.total_length total_length -= last_param.total_length - len(last_param.value) if total_length + self.column > self.column_limit: # If we need to split before the trailing code of a function @@ -924,9 +921,8 @@ def _IndentWithContinuationAlignStyle(self, column): return column align_style = style.Get('CONTINUATION_ALIGN_STYLE') if align_style == 'FIXED': - return ( - (self.line.depth * style.Get('INDENT_WIDTH')) + - style.Get('CONTINUATION_INDENT_WIDTH')) + return ((self.line.depth * style.Get('INDENT_WIDTH')) + + style.Get('CONTINUATION_INDENT_WIDTH')) if align_style == 'VALIGN-RIGHT': indent_width = style.Get('INDENT_WIDTH') return indent_width * int((column + indent_width - 1) / indent_width) @@ -934,8 +930,8 @@ def _IndentWithContinuationAlignStyle(self, column): def _GetNewlineColumn(self): """Return the new column on the newline.""" - current = self.next_token - previous = current.previous_token + current = self.next_token + previous = current.previous_token top_of_stack = self.stack[-1] if isinstance(current.spaces_required_before, list): @@ -955,8 +951,8 @@ def _GetNewlineColumn(self): if (previous.OpensScope() or (previous.is_comment and previous.previous_token is not None and previous.previous_token.OpensScope())): - return max( - 0, top_of_stack.indent - style.Get('CONTINUATION_INDENT_WIDTH')) + return max(0, + top_of_stack.indent - style.Get('CONTINUATION_INDENT_WIDTH')) return top_of_stack.closing_scope_indent if (previous and previous.is_string and current.is_string and @@ -1012,7 +1008,7 @@ def ImplicitStringConcatenation(tok): tok = tok.next_token while tok.is_string: num_strings += 1 - tok = tok.next_token + tok = tok.next_token return num_strings > 1 def DictValueIsContainer(opening, closing): @@ -1031,9 +1027,9 @@ def DictValueIsContainer(opening, closing): return False return subtypes.DICTIONARY_KEY_PART in key.subtypes - closing = opening.matching_bracket + closing = opening.matching_bracket entry_start = opening.next_token - current = opening.next_token.next_token + current = opening.next_token.next_token while current and current != closing: if subtypes.DICTIONARY_KEY in current.subtypes: @@ -1041,7 +1037,7 @@ def DictValueIsContainer(opening, closing): if prev.value == ',': prev = PreviousNonCommentToken(prev.previous_token) if not DictValueIsContainer(prev.matching_bracket, prev): - length = prev.total_length - entry_start.total_length + length = prev.total_length - entry_start.total_length length += len(entry_start.value) if length + self.stack[-2].indent >= self.column_limit: return False @@ -1073,7 +1069,7 @@ def DictValueIsContainer(opening, closing): # At this point, current is the closing bracket. Go back one to get the end # of the dictionary entry. current = PreviousNonCommentToken(current) - length = current.total_length - entry_start.total_length + length = current.total_length - entry_start.total_length length += len(entry_start.value) return length + self.stack[-2].indent <= self.column_limit @@ -1093,9 +1089,8 @@ def _ArgumentListHasDictionaryEntry(self, token): def _ContainerFitsOnStartLine(self, opening): """Check if the container can fit on its starting line.""" - return ( - opening.matching_bracket.total_length - opening.total_length + - self.stack[-1].indent) <= self.column_limit + return (opening.matching_bracket.total_length - opening.total_length + + self.stack[-1].indent) <= self.column_limit _COMPOUND_STMTS = frozenset( @@ -1171,8 +1166,8 @@ def _IsLastScopeInLine(current): def _IsSingleElementTuple(token): """Check if it's a single-element tuple.""" - close = token.matching_bracket - token = token.next_token + close = token.matching_bracket + token = token.next_token num_commas = 0 while token != close: if token.value == ',': @@ -1213,17 +1208,17 @@ class _ParenState(object): # TODO(morbo): This doesn't track "bin packing." def __init__(self, indent, last_space): - self.indent = indent - self.last_space = last_space - self.closing_scope_indent = 0 + self.indent = indent + self.last_space = last_space + self.closing_scope_indent = 0 self.split_before_closing_bracket = False - self.num_line_splits = 0 + self.num_line_splits = 0 def Clone(self): - state = _ParenState(self.indent, self.last_space) - state.closing_scope_indent = self.closing_scope_indent + state = _ParenState(self.indent, self.last_space) + state.closing_scope_indent = self.closing_scope_indent state.split_before_closing_bracket = self.split_before_closing_bracket - state.num_line_splits = self.num_line_splits + state.num_line_splits = self.num_line_splits return state def __repr__(self): @@ -1237,7 +1232,5 @@ def __ne__(self, other): return not self == other def __hash__(self, *args, **kwargs): - return hash( - ( - self.indent, self.last_space, self.closing_scope_indent, - self.split_before_closing_bracket, self.num_line_splits)) + return hash((self.indent, self.last_space, self.closing_scope_indent, + self.split_before_closing_bracket, self.num_line_splits)) diff --git a/yapf/yapflib/format_token.py b/yapf/yapflib/format_token.py index 36c4b3ed2..070987851 100644 --- a/yapf/yapflib/format_token.py +++ b/yapf/yapflib/format_token.py @@ -90,27 +90,27 @@ def __init__(self, node, name): node: (pytree.Leaf) The node that's being wrapped. name: (string) The name of the node. """ - self.node = node - self.name = name - self.type = node.type + self.node = node + self.name = name + self.type = node.type self.column = node.column self.lineno = node.lineno - self.value = node.value + self.value = node.value if self.is_continuation: self.value = node.value.rstrip() - self.next_token = None - self.previous_token = None - self.matching_bracket = None - self.parameters = [] - self.container_opening = None + self.next_token = None + self.previous_token = None + self.matching_bracket = None + self.parameters = [] + self.container_opening = None self.container_elements = [] - self.whitespace_prefix = '' - self.total_length = 0 - self.split_penalty = 0 - self.can_break_before = False - self.must_break_before = pytree_utils.GetNodeAnnotation( + self.whitespace_prefix = '' + self.total_length = 0 + self.split_penalty = 0 + self.can_break_before = False + self.must_break_before = pytree_utils.GetNodeAnnotation( node, pytree_utils.Annotation.MUST_SPLIT, default=False) self.newlines = pytree_utils.GetNodeAnnotation( node, pytree_utils.Annotation.NEWLINES) @@ -119,16 +119,16 @@ def __init__(self, node, name): if self.is_comment: self.spaces_required_before = style.Get('SPACES_BEFORE_COMMENT') - stypes = pytree_utils.GetNodeAnnotation( - node, pytree_utils.Annotation.SUBTYPE) - self.subtypes = {subtypes.NONE} if not stypes else stypes + stypes = pytree_utils.GetNodeAnnotation(node, + pytree_utils.Annotation.SUBTYPE) + self.subtypes = {subtypes.NONE} if not stypes else stypes self.is_pseudo = hasattr(node, 'is_pseudo') and node.is_pseudo @property def formatted_whitespace_prefix(self): if style.Get('INDENT_BLANK_LINES'): without_newlines = self.whitespace_prefix.lstrip('\n') - height = len(self.whitespace_prefix) - len(without_newlines) + height = len(self.whitespace_prefix) - len(without_newlines) if height: return ('\n' + without_newlines) * height return self.whitespace_prefix @@ -151,26 +151,26 @@ def AddWhitespacePrefix(self, newlines_before, spaces=0, indent_level=0): else: indent_before = '\t' * indent_level + ' ' * spaces else: - indent_before = ( - ' ' * indent_level * style.Get('INDENT_WIDTH') + ' ' * spaces) + indent_before = (' ' * indent_level * style.Get('INDENT_WIDTH') + + ' ' * spaces) if self.is_comment: comment_lines = [s.lstrip() for s in self.value.splitlines()] - self.value = ('\n' + indent_before).join(comment_lines) + self.value = ('\n' + indent_before).join(comment_lines) # Update our own value since we are changing node value self.value = self.value if not self.whitespace_prefix: - self.whitespace_prefix = ( - '\n' * (self.newlines or newlines_before) + indent_before) + self.whitespace_prefix = ('\n' * (self.newlines or newlines_before) + + indent_before) else: self.whitespace_prefix += indent_before def AdjustNewlinesBefore(self, newlines_before): """Change the number of newlines before this token.""" - self.whitespace_prefix = ( - '\n' * newlines_before + self.whitespace_prefix.lstrip('\n')) + self.whitespace_prefix = ('\n' * newlines_before + + self.whitespace_prefix.lstrip('\n')) def RetainHorizontalSpacing(self, first_column, depth): """Retains a token's horizontal spacing.""" @@ -183,7 +183,7 @@ def RetainHorizontalSpacing(self, first_column, depth): if not previous: return - cur_lineno = self.lineno + cur_lineno = self.lineno prev_lineno = previous.lineno if previous.is_multiline_string: prev_lineno += previous.value.count('\n') @@ -195,13 +195,13 @@ def RetainHorizontalSpacing(self, first_column, depth): self.column - first_column + depth * style.Get('INDENT_WIDTH')) return - cur_column = self.column + cur_column = self.column prev_column = previous.column - prev_len = len(previous.value) + prev_len = len(previous.value) if previous.is_pseudo and previous.value == ')': prev_column -= 1 - prev_len = 0 + prev_len = 0 if previous.is_multiline_string: prev_len = len(previous.value.split('\n')[-1]) @@ -220,11 +220,10 @@ def AddSubtype(self, subtype): self.subtypes.add(subtype) def __repr__(self): - msg = ( - 'FormatToken(name={0}, value={1}, column={2}, lineno={3}, ' - 'splitpenalty={4}'.format( - 'DOCSTRING' if self.is_docstring else self.name, self.value, - self.column, self.lineno, self.split_penalty)) + msg = ('FormatToken(name={0}, value={1}, column={2}, lineno={3}, ' + 'splitpenalty={4}'.format( + 'DOCSTRING' if self.is_docstring else self.name, self.value, + self.column, self.lineno, self.split_penalty)) msg += ', pseudo)' if self.is_pseudo else ')' return msg @@ -243,22 +242,21 @@ def is_binary_op(self): @py3compat.lru_cache() def is_arithmetic_op(self): """Token is an arithmetic operator.""" - return self.value in frozenset( - { - '+', # Add - '-', # Subtract - '*', # Multiply - '@', # Matrix Multiply - '/', # Divide - '//', # Floor Divide - '%', # Modulo - '<<', # Left Shift - '>>', # Right Shift - '|', # Bitwise Or - '&', # Bitwise Add - '^', # Bitwise Xor - '**', # Power - }) + return self.value in frozenset({ + '+', # Add + '-', # Subtract + '*', # Multiply + '@', # Matrix Multiply + '/', # Divide + '//', # Floor Divide + '%', # Modulo + '<<', # Left Shift + '>>', # Right Shift + '|', # Bitwise Or + '&', # Bitwise Add + '^', # Bitwise Xor + '**', # Power + }) @property def is_simple_expr(self): @@ -312,13 +310,13 @@ def is_docstring(self): @property def is_pylint_comment(self): - return self.is_comment and re.match( - r'#.*\bpylint:\s*(disable|enable)=', self.value) + return self.is_comment and re.match(r'#.*\bpylint:\s*(disable|enable)=', + self.value) @property def is_pytype_comment(self): - return self.is_comment and re.match( - r'#.*\bpytype:\s*(disable|enable)=', self.value) + return self.is_comment and re.match(r'#.*\bpytype:\s*(disable|enable)=', + self.value) @property def is_copybara_comment(self): @@ -352,17 +350,14 @@ def is_dict_value(self): @property def is_augassign(self): - augassigns = { - '+=', '-=', '*=', '@=', '/=', '%=', '&=', '|=', '^=', '<<=', '>>=', - '**=', '//=' - } + augassigns = {'+=', '-=' , '*=' , '@=' , '/=' , '%=' , '&=' , '|=' , '^=' , + '<<=' , '>>=' , '**=' , '//='} return self.value in augassigns @property def is_argassign(self): - return ( - subtypes.DEFAULT_OR_NAMED_ASSIGN in self.subtypes or - subtypes.VARARGS_LIST in self.subtypes) + return (subtypes.DEFAULT_OR_NAMED_ASSIGN in self.subtypes + or subtypes.VARARGS_LIST in self.subtypes) @property def is_argname(self): @@ -374,7 +369,7 @@ def is_argname(self): # argument without assignment is also included # the token is arg part before '=' but not after '=' if self.is_argname_start: - return True + return True # exclude comment inside argument list if not self.is_comment: @@ -392,17 +387,17 @@ def is_argname_start(self): previous_subtypes = self.previous_token.subtypes return ( - ( - not self.is_comment and - subtypes.DEFAULT_OR_NAMED_ASSIGN not in self.subtypes and - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST in self.subtypes and - subtypes.DEFAULT_OR_NAMED_ASSIGN not in previous_subtypes and ( - not subtypes.PARAMETER_STOP in self.subtypes or - subtypes.PARAMETER_START in self.subtypes)) - or # if there is comment, the arg after it is the argname start - ( - not self.is_comment and self.previous_token and - self.previous_token.is_comment and ( - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST in previous_subtypes - or subtypes.TYPED_NAME_ARG_LIST in self.subtypes or - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST in self.subtypes))) + (not self.is_comment + and subtypes.DEFAULT_OR_NAMED_ASSIGN not in self.subtypes + and subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST in self.subtypes + and subtypes.DEFAULT_OR_NAMED_ASSIGN not in previous_subtypes + and (not subtypes.PARAMETER_STOP in self.subtypes + or subtypes.PARAMETER_START in self.subtypes) + ) + or # if there is comment, the arg after it is the argname start + (not self.is_comment and self.previous_token and self.previous_token.is_comment + and + (subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST in previous_subtypes + or subtypes.TYPED_NAME_ARG_LIST in self.subtypes + or subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST in self.subtypes)) + ) diff --git a/yapf/yapflib/logical_line.py b/yapf/yapflib/logical_line.py index 477d4d625..8c84b7ba8 100644 --- a/yapf/yapflib/logical_line.py +++ b/yapf/yapflib/logical_line.py @@ -49,7 +49,7 @@ def __init__(self, depth, tokens=None): depth: indentation depth of this line tokens: initial list of tokens """ - self.depth = depth + self.depth = depth self._tokens = tokens or [] self.disable = False @@ -57,7 +57,7 @@ def __init__(self, depth, tokens=None): # Set up a doubly linked list. for index, tok in enumerate(self._tokens[1:]): # Note, 'index' is the index to the previous token. - tok.previous_token = self._tokens[index] + tok.previous_token = self._tokens[index] self._tokens[index].next_token = tok def CalculateFormattingInformation(self): @@ -66,9 +66,9 @@ def CalculateFormattingInformation(self): # means only that if this logical line is joined with a predecessor line, # then there will be a space between them. self.first.spaces_required_before = 1 - self.first.total_length = len(self.first.value) + self.first.total_length = len(self.first.value) - prev_token = self.first + prev_token = self.first prev_length = self.first.total_length for token in self._tokens[1:]: if (token.spaces_required_before == 0 and @@ -93,13 +93,13 @@ def CalculateFormattingInformation(self): # The split penalty has to be computed before {must|can}_break_before, # because these may use it for their decision. - token.split_penalty += _SplitPenalty(prev_token, token) + token.split_penalty += _SplitPenalty(prev_token, token) token.must_break_before = _MustBreakBefore(prev_token, token) - token.can_break_before = ( + token.can_break_before = ( token.must_break_before or _CanBreakBefore(prev_token, token)) prev_length = token.total_length - prev_token = token + prev_token = token def Split(self): """Split the line at semicolons.""" @@ -107,7 +107,7 @@ def Split(self): return [self] llines = [] - lline = LogicalLine(self.depth) + lline = LogicalLine(self.depth) for tok in self._tokens: if tok.value == ';': llines.append(lline) @@ -120,7 +120,7 @@ def Split(self): for lline in llines: lline.first.previous_token = None - lline.last.next_token = None + lline.last.next_token = None return llines @@ -164,7 +164,7 @@ def AsCode(self, indent_per_depth=2): Returns: A string representing the line as code. """ - indent = ' ' * indent_per_depth * self.depth + indent = ' ' * indent_per_depth * self.depth tokens_str = ' '.join(tok.value for tok in self._tokens) return indent + tokens_str @@ -544,10 +544,10 @@ def _CanBreakBefore(prev_token, cur_token): def IsSurroundedByBrackets(tok): """Return True if the token is surrounded by brackets.""" - paren_count = 0 - brace_count = 0 + paren_count = 0 + brace_count = 0 sq_bracket_count = 0 - previous_token = tok.previous_token + previous_token = tok.previous_token while previous_token: if previous_token.value == ')': paren_count -= 1 @@ -580,10 +580,10 @@ def _IsDictListTupleDelimiterTok(tok, is_opening): return False if is_opening: - open_tok = tok + open_tok = tok close_tok = tok.matching_bracket else: - open_tok = tok.matching_bracket + open_tok = tok.matching_bracket close_tok = tok # There must be something in between the tokens @@ -600,8 +600,8 @@ def _IsDictListTupleDelimiterTok(tok, is_opening): ] -_LOGICAL_OPERATORS = frozenset({'and', 'or'}) -_BITWISE_OPERATORS = frozenset({'&', '|', '^'}) +_LOGICAL_OPERATORS = frozenset({'and', 'or'}) +_BITWISE_OPERATORS = frozenset({'&', '|', '^'}) _ARITHMETIC_OPERATORS = frozenset({'+', '-', '*', '/', '%', '//', '@'}) diff --git a/yapf/yapflib/object_state.py b/yapf/yapflib/object_state.py index 0afdb6041..ec259e682 100644 --- a/yapf/yapflib/object_state.py +++ b/yapf/yapflib/object_state.py @@ -45,9 +45,9 @@ class ComprehensionState(object): """ def __init__(self, expr_token): - self.expr_token = expr_token - self.for_token = None - self.has_split_at_for = False + self.expr_token = expr_token + self.for_token = None + self.has_split_at_for = False self.has_interior_split = False def HasTrivialExpr(self): @@ -63,18 +63,17 @@ def closing_bracket(self): return self.opening_bracket.matching_bracket def Clone(self): - clone = ComprehensionState(self.expr_token) - clone.for_token = self.for_token - clone.has_split_at_for = self.has_split_at_for + clone = ComprehensionState(self.expr_token) + clone.for_token = self.for_token + clone.has_split_at_for = self.has_split_at_for clone.has_interior_split = self.has_interior_split return clone def __repr__(self): - return ( - '[opening_bracket::%s, for_token::%s, has_split_at_for::%s,' - ' has_interior_split::%s, has_trivial_expr::%s]' % ( - self.opening_bracket, self.for_token, self.has_split_at_for, - self.has_interior_split, self.HasTrivialExpr())) + return ('[opening_bracket::%s, for_token::%s, has_split_at_for::%s,' + ' has_interior_split::%s, has_trivial_expr::%s]' % + (self.opening_bracket, self.for_token, self.has_split_at_for, + self.has_interior_split, self.HasTrivialExpr())) def __eq__(self, other): return hash(self) == hash(other) @@ -83,10 +82,8 @@ def __ne__(self, other): return not self == other def __hash__(self, *args, **kwargs): - return hash( - ( - self.expr_token, self.for_token, self.has_split_at_for, - self.has_interior_split)) + return hash((self.expr_token, self.for_token, self.has_split_at_for, + self.has_interior_split)) class ParameterListState(object): @@ -108,10 +105,10 @@ class ParameterListState(object): """ def __init__(self, opening_bracket, newline, opening_column): - self.opening_bracket = opening_bracket + self.opening_bracket = opening_bracket self.has_split_before_first_param = newline - self.opening_column = opening_column - self.parameters = opening_bracket.parameters + self.opening_column = opening_column + self.parameters = opening_bracket.parameters self.split_before_closing_bracket = False @property @@ -149,8 +146,8 @@ def LastParamFitsOnLine(self, indent): return False if not self.parameters: return True - total_length = self.last_token.total_length - last_param = self.parameters[-1].first_token + total_length = self.last_token.total_length + last_param = self.parameters[-1].first_token total_length -= last_param.total_length - len(last_param.value) return total_length + indent <= style.Get('COLUMN_LIMIT') @@ -163,25 +160,24 @@ def SplitBeforeClosingBracket(self, indent): return True if not self.parameters: return False - total_length = self.last_token.total_length - last_param = self.parameters[-1].first_token + total_length = self.last_token.total_length + last_param = self.parameters[-1].first_token total_length -= last_param.total_length - len(last_param.value) return total_length + indent > style.Get('COLUMN_LIMIT') def Clone(self): - clone = ParameterListState( - self.opening_bracket, self.has_split_before_first_param, - self.opening_column) + clone = ParameterListState(self.opening_bracket, + self.has_split_before_first_param, + self.opening_column) clone.split_before_closing_bracket = self.split_before_closing_bracket - clone.parameters = [param.Clone() for param in self.parameters] + clone.parameters = [param.Clone() for param in self.parameters] return clone def __repr__(self): - return ( - '[opening_bracket::%s, has_split_before_first_param::%s, ' - 'opening_column::%d]' % ( - self.opening_bracket, self.has_split_before_first_param, - self.opening_column)) + return ('[opening_bracket::%s, has_split_before_first_param::%s, ' + 'opening_column::%d]' % + (self.opening_bracket, self.has_split_before_first_param, + self.opening_column)) def __eq__(self, other): return hash(self) == hash(other) @@ -191,9 +187,8 @@ def __ne__(self, other): def __hash__(self, *args, **kwargs): return hash( - ( - self.opening_bracket, self.has_split_before_first_param, - self.opening_column, (hash(param) for param in self.parameters))) + (self.opening_bracket, self.has_split_before_first_param, + self.opening_column, (hash(param) for param in self.parameters))) class Parameter(object): @@ -207,7 +202,7 @@ class Parameter(object): def __init__(self, first_token, last_token): self.first_token = first_token - self.last_token = last_token + self.last_token = last_token @property @py3compat.lru_cache() @@ -224,8 +219,8 @@ def Clone(self): return Parameter(self.first_token, self.last_token) def __repr__(self): - return '[first_token::%s, last_token:%s]' % ( - self.first_token, self.last_token) + return '[first_token::%s, last_token:%s]' % (self.first_token, + self.last_token) def __eq__(self, other): return hash(self) == hash(other) diff --git a/yapf/yapflib/py3compat.py b/yapf/yapflib/py3compat.py index 2ea5910d1..e4cb9788f 100644 --- a/yapf/yapflib/py3compat.py +++ b/yapf/yapflib/py3compat.py @@ -18,14 +18,14 @@ import os import sys -PY3 = sys.version_info[0] >= 3 +PY3 = sys.version_info[0] >= 3 PY36 = sys.version_info[0] >= 3 and sys.version_info[1] >= 6 PY37 = sys.version_info[0] >= 3 and sys.version_info[1] >= 7 PY38 = sys.version_info[0] >= 3 and sys.version_info[1] >= 8 if PY3: StringIO = io.StringIO - BytesIO = io.BytesIO + BytesIO = io.BytesIO import codecs # noqa: F811 @@ -35,7 +35,7 @@ def open_with_encoding(filename, mode, encoding, newline=''): # pylint: disable import functools lru_cache = functools.lru_cache - range = range + range = range ifilter = filter def raw_input(): @@ -50,7 +50,7 @@ def raw_input(): import tokenize detect_encoding = tokenize.detect_encoding - TokenInfo = tokenize.TokenInfo + TokenInfo = tokenize.TokenInfo else: import __builtin__ import cStringIO @@ -80,8 +80,8 @@ def fake_wrapper(user_function): import collections - class TokenInfo(collections.namedtuple('TokenInfo', - 'type string start end line')): + class TokenInfo( + collections.namedtuple('TokenInfo', 'type string start end line')): pass @@ -116,7 +116,7 @@ def EncodeAndWriteToStdout(s, encoding='utf-8'): if PY3: basestring = str - unicode = str # pylint: disable=redefined-builtin,invalid-name + unicode = str # pylint: disable=redefined-builtin,invalid-name else: basestring = basestring diff --git a/yapf/yapflib/reformatter.py b/yapf/yapflib/reformatter.py index 564d1355f..8f8a103f8 100644 --- a/yapf/yapflib/reformatter.py +++ b/yapf/yapflib/reformatter.py @@ -49,8 +49,8 @@ def Reformat(llines, verify=False, lines=None): Returns: A string representing the reformatted code. """ - final_lines = [] - prev_line = None # The previous line. + final_lines = [] + prev_line = None # The previous line. indent_width = style.Get('INDENT_WIDTH') for lline in _SingleOrMergedLines(llines): @@ -58,7 +58,7 @@ def Reformat(llines, verify=False, lines=None): _FormatFirstToken(first_token, lline.depth, prev_line, final_lines) indent_amt = indent_width * lline.depth - state = format_decision_state.FormatDecisionState(lline, indent_amt) + state = format_decision_state.FormatDecisionState(lline, indent_amt) state.MoveStateToNextToken() if not lline.disable: @@ -69,8 +69,8 @@ def Reformat(llines, verify=False, lines=None): if prev_line and prev_line.disable: # Keep the vertical spacing between a disabled and enabled formatting # region. - _RetainRequiredVerticalSpacingBetweenTokens( - lline.first, prev_line.last, lines) + _RetainRequiredVerticalSpacingBetweenTokens(lline.first, prev_line.last, + lines) if any(tok.is_comment for tok in lline.tokens): _RetainVerticalSpacingBeforeComments(lline) @@ -105,8 +105,8 @@ def Reformat(llines, verify=False, lines=None): if style.Get('ALIGN_ASSIGNMENT'): _AlignAssignment(final_lines) - if (style.Get('EACH_DICT_ENTRY_ON_SEPARATE_LINE') and - style.Get('ALIGN_DICT_COLON')): + if (style.Get('EACH_DICT_ENTRY_ON_SEPARATE_LINE') + and style.Get('ALIGN_DICT_COLON')): _AlignDictColon(final_lines) if style.Get('ALIGN_ARGUMENT_ASSIGNMENT'): _AlignArgAssign(final_lines) @@ -165,11 +165,11 @@ def _RetainRequiredVerticalSpacingBetweenTokens(cur_tok, prev_tok, lines): # Don't adjust between a comment and non-comment. pass elif lines and lines.intersection(range(prev_lineno, cur_lineno + 1)): - desired_newlines = cur_tok.whitespace_prefix.count('\n') - whitespace_lines = range(prev_lineno + 1, cur_lineno) - deletable_lines = len(lines.intersection(whitespace_lines)) - required_newlines = max( - required_newlines - deletable_lines, desired_newlines) + desired_newlines = cur_tok.whitespace_prefix.count('\n') + whitespace_lines = range(prev_lineno + 1, cur_lineno) + deletable_lines = len(lines.intersection(whitespace_lines)) + required_newlines = max(required_newlines - deletable_lines, + desired_newlines) cur_tok.AdjustNewlinesBefore(required_newlines) @@ -198,7 +198,7 @@ def _EmitLineUnformatted(state): state. """ while state.next_token: - previous_token = state.next_token.previous_token + previous_token = state.next_token.previous_token previous_lineno = previous_token.lineno if previous_token.is_multiline_string or previous_token.is_string: @@ -262,17 +262,16 @@ def _CanPlaceOnSingleLine(line): if (style.Get('FORCE_MULTILINE_DICT') and 'LBRACE' in token_names): return False indent_amt = style.Get('INDENT_WIDTH') * line.depth - last = line.last + last = line.last last_index = -1 if (last.is_pylint_comment or last.is_pytype_comment or last.is_copybara_comment): - last = last.previous_token + last = last.previous_token last_index = -2 if last is None: return True - return ( - last.total_length + indent_amt <= style.Get('COLUMN_LIMIT') and - not any(tok.is_comment for tok in line.tokens[:last_index])) + return (last.total_length + indent_amt <= style.Get('COLUMN_LIMIT') and + not any(tok.is_comment for tok in line.tokens[:last_index])) def _AlignTrailingComments(final_lines): @@ -294,7 +293,7 @@ def _AlignTrailingComments(final_lines): # first col value greater than that value and create the necessary for # each line accordingly. all_pc_line_lengths = [] # All pre-comment line lengths - max_line_length = 0 + max_line_length = 0 while True: # EOF @@ -316,7 +315,7 @@ def _AlignTrailingComments(final_lines): continue # Calculate the length of each line in this logical line. - line_content = '' + line_content = '' pc_line_lengths = [] for line_tok in this_line.tokens: @@ -325,7 +324,7 @@ def _AlignTrailingComments(final_lines): newline_index = whitespace_prefix.rfind('\n') if newline_index != -1: max_line_length = max(max_line_length, len(line_content)) - line_content = '' + line_content = '' whitespace_prefix = whitespace_prefix[newline_index + 1:] @@ -375,8 +374,8 @@ def _AlignTrailingComments(final_lines): for comment_line_index, comment_line in enumerate( line_tok.value.split('\n')): - line_content.append( - '{}{}'.format(whitespace, comment_line.strip())) + line_content.append('{}{}'.format(whitespace, + comment_line.strip())) if comment_line_index == 0: whitespace = ' ' * (aligned_col - 1) @@ -418,71 +417,63 @@ def _AlignAssignment(final_lines): if tok.is_assign or tok.is_augassign: # all pre assignment variable lengths in one block of lines all_pa_variables_lengths = [] - max_variables_length = 0 + max_variables_length = 0 while True: - # EOF - if final_lines_index + len(all_pa_variables_lengths) == len( - final_lines): + # EOF + if final_lines_index + len(all_pa_variables_lengths) == len(final_lines): break this_line_index = final_lines_index + len(all_pa_variables_lengths) - this_line = final_lines[this_line_index] + this_line = final_lines[this_line_index] next_line = None if this_line_index < len(final_lines) - 1: - next_line = final_lines[final_lines_index + - len(all_pa_variables_lengths) + 1] + next_line = final_lines[final_lines_index + len(all_pa_variables_lengths) + 1 ] assert this_line.tokens, next_line.tokens # align them differently when there is a blank line in between if (all_pa_variables_lengths and - this_line.tokens[0].formatted_whitespace_prefix.startswith('\n\n') - ): - break + this_line.tokens[0].formatted_whitespace_prefix.startswith('\n\n') + ): + break # if there is a standalone comment or keyword statement line # or other lines without assignment in between, break elif (all_pa_variables_lengths and - True not in [tok.is_assign or tok.is_augassign - for tok in this_line.tokens]): + True not in [tok.is_assign or tok.is_augassign for tok in this_line.tokens]): if this_line.tokens[0].is_comment: if style.Get('NEW_ALIGNMENT_AFTER_COMMENTLINE'): break - else: - break + else: break if this_line.disable: all_pa_variables_lengths.append([]) continue - variables_content = '' + variables_content = '' pa_variables_lengths = [] - contain_object = False - line_tokens = this_line.tokens + contain_object = False + line_tokens = this_line.tokens # only one assignment expression is on each line for index in range(len(line_tokens)): line_tok = line_tokens[index] - prefix = line_tok.formatted_whitespace_prefix + prefix = line_tok.formatted_whitespace_prefix newline_index = prefix.rfind('\n') if newline_index != -1: variables_content = '' - prefix = prefix[newline_index + 1:] + prefix = prefix[newline_index + 1:] if line_tok.is_assign or line_tok.is_augassign: - next_toks = [ - line_tokens[i] for i in range(index + 1, len(line_tokens)) - ] + next_toks = [line_tokens[i] for i in range(index+1, len(line_tokens))] # if there is object(list/tuple/dict) with newline entries, break, # update the alignment so far and start to calulate new alignment for tok in next_toks: if tok.value in ['(', '[', '{'] and tok.next_token: - if (tok.next_token.formatted_whitespace_prefix.startswith( - '\n') or - (tok.next_token.is_comment and tok.next_token.next_token - .formatted_whitespace_prefix.startswith('\n'))): + if (tok.next_token.formatted_whitespace_prefix.startswith('\n') + or (tok.next_token.is_comment and tok.next_token.next_token.formatted_whitespace_prefix.startswith('\n'))): pa_variables_lengths.append(len(variables_content)) contain_object = True break @@ -491,8 +482,7 @@ def _AlignAssignment(final_lines): pa_variables_lengths.append(len(variables_content)) # if augassign, add the extra augmented part to the max length caculation elif line_tok.is_augassign: - pa_variables_lengths.append( - len(variables_content) + len(line_tok.value) - 1) + pa_variables_lengths.append(len(variables_content) + len(line_tok.value) - 1 ) # don't add the tokens # after the assignment operator break @@ -500,8 +490,7 @@ def _AlignAssignment(final_lines): variables_content += '{}{}'.format(prefix, line_tok.value) if pa_variables_lengths: - max_variables_length = max( - max_variables_length, max(pa_variables_lengths)) + max_variables_length = max(max_variables_length, max(pa_variables_lengths)) all_pa_variables_lengths.append(pa_variables_lengths) @@ -519,47 +508,43 @@ def _AlignAssignment(final_lines): break # if no update of max_length, just go to the next block - if max_variables_length == 0: - continue + if max_variables_length == 0: continue max_variables_length += 2 # Update the assignment token values based on the max variable length for all_pa_variables_lengths_index, pa_variables_lengths in enumerate( - all_pa_variables_lengths): - if not pa_variables_lengths: - continue - this_line = final_lines[final_lines_index + - all_pa_variables_lengths_index] + all_pa_variables_lengths): + if not pa_variables_lengths: + continue + this_line = final_lines[final_lines_index + all_pa_variables_lengths_index] - # only the first assignment operator on each line - pa_variables_lengths_index = 0 - for line_tok in this_line.tokens: - if line_tok.is_assign or line_tok.is_augassign: - assert pa_variables_lengths[0] < max_variables_length + # only the first assignment operator on each line + pa_variables_lengths_index = 0 + for line_tok in this_line.tokens: + if line_tok.is_assign or line_tok.is_augassign: + assert pa_variables_lengths[0] < max_variables_length - if pa_variables_lengths_index < len(pa_variables_lengths): - whitespace = ' ' * ( - max_variables_length - pa_variables_lengths[0] - 1) + if pa_variables_lengths_index < len(pa_variables_lengths): + whitespace = ' ' * ( + max_variables_length - pa_variables_lengths[0] - 1) - assign_content = '{}{}'.format( - whitespace, line_tok.value.strip()) + assign_content = '{}{}'.format(whitespace, line_tok.value.strip()) - existing_whitespace_prefix = \ - line_tok.formatted_whitespace_prefix.lstrip('\n') + existing_whitespace_prefix = \ + line_tok.formatted_whitespace_prefix.lstrip('\n') - # in case the existing spaces are larger than padded spaces - if (len(whitespace) == 1 or len(whitespace) > 1 and - len(existing_whitespace_prefix) > len(whitespace)): - line_tok.whitespace_prefix = '' - elif assign_content.startswith(existing_whitespace_prefix): - assign_content = assign_content[ - len(existing_whitespace_prefix):] + # in case the existing spaces are larger than padded spaces + if (len(whitespace) == 1 or len(whitespace) > 1 and + len(existing_whitespace_prefix)>len(whitespace)): + line_tok.whitespace_prefix = '' + elif assign_content.startswith(existing_whitespace_prefix): + assign_content = assign_content[len(existing_whitespace_prefix):] - # update the assignment operator value - line_tok.value = assign_content + # update the assignment operator value + line_tok.value = assign_content - pa_variables_lengths_index += 1 + pa_variables_lengths_index += 1 final_lines_index += len(all_pa_variables_lengths) @@ -567,7 +552,7 @@ def _AlignAssignment(final_lines): break if not process_content: - final_lines_index += 1 + final_lines_index += 1 def _AlignArgAssign(final_lines): @@ -588,74 +573,71 @@ def _AlignArgAssign(final_lines): for tok in line.tokens: if tok.is_argassign: - this_line = line + this_line = line line_tokens = this_line.tokens for open_index in range(len(line_tokens)): line_tok = line_tokens[open_index] - if (line_tok.value == '(' and not line_tok.is_pseudo and - line_tok.next_token.formatted_whitespace_prefix.startswith('\n')): + if (line_tok.value == '(' and not line_tok.is_pseudo + and line_tok.next_token.formatted_whitespace_prefix.startswith('\n')): index = open_index # skip the comments in the beginning - index += 1 + index += 1 line_tok = line_tokens[index] - while not line_tok.is_argname_start and index < len( - line_tokens) - 1: - index += 1 + while not line_tok.is_argname_start and index < len(line_tokens)-1: + index += 1 line_tok = line_tokens[index] # check if the argstart is on newline - if line_tok.is_argname_start and line_tok.formatted_whitespace_prefix.startswith( - '\n'): - first_arg_index = index - first_arg_column = len( - line_tok.formatted_whitespace_prefix.lstrip('\n')) + if line_tok.is_argname_start and line_tok.formatted_whitespace_prefix.startswith('\n'): + first_arg_index = index + first_arg_column = len(line_tok.formatted_whitespace_prefix.lstrip('\n')) - closing = False + closing = False all_arg_name_lengths = [] - arg_name_lengths = [] - name_content = '' - arg_column = first_arg_column + arg_name_lengths = [] + name_content = '' + arg_column = first_arg_column # start with the first argument # that has nextline prefix while not closing: # if there is a comment in between, save, reset and continue to calulate new alignment - if (style.Get('NEW_ALIGNMENT_AFTER_COMMENTLINE') and - arg_name_lengths and line_tok.is_comment and - line_tok.formatted_whitespace_prefix.startswith('\n')): + if (style.Get('NEW_ALIGNMENT_AFTER_COMMENTLINE') + and arg_name_lengths and line_tok.is_comment + and line_tok.formatted_whitespace_prefix.startswith('\n')): all_arg_name_lengths.append(arg_name_lengths) arg_name_lengths = [] - index += 1 - line_tok = line_tokens[index] + index += 1 + line_tok = line_tokens[index] continue - prefix = line_tok.formatted_whitespace_prefix + prefix = line_tok.formatted_whitespace_prefix newline_index = prefix.rfind('\n') if newline_index != -1: if line_tok.is_argname_start: name_content = '' - prefix = prefix[newline_index + 1:] - arg_column = len(prefix) + prefix = prefix[newline_index + 1:] + arg_column = len(prefix) # if a typed arg name is so long # that there are newlines inside # only calulate the last line arg_name that has the assignment elif line_tok.is_argname: name_content = '' - prefix = prefix[newline_index + 1:] + prefix = prefix[newline_index + 1:] # if any argument not on newline elif line_tok.is_argname_start: name_content = '' - arg_column = line_tok.column + arg_column = line_tok.column # in case they are formatted into one line in final_line # but are put in separated lines in original codes if arg_column == first_arg_column: arg_column = line_tok.formatted_whitespace_prefix # on the same argument level - if (line_tok.is_argname_start and arg_name_lengths and - arg_column == first_arg_column): + if (line_tok.is_argname_start and arg_name_lengths + and arg_column==first_arg_column): argname_end = line_tok while argname_end.is_argname: argname_end = argname_end.next_token @@ -663,8 +645,8 @@ def _AlignArgAssign(final_lines): if not argname_end.is_argassign: all_arg_name_lengths.append(arg_name_lengths) arg_name_lengths = [] - index += 1 - line_tok = line_tokens[index] + index += 1 + line_tok = line_tokens[index] continue if line_tok.is_argassign and arg_column == first_arg_column: @@ -685,23 +667,19 @@ def _AlignArgAssign(final_lines): # if there is a new object(list/tuple/dict) with its entries on newlines, # save, reset and continue to calulate new alignment - if (line_tok.value in ['(', '[', '{'] and - line_tok.next_token and - line_tok.next_token.formatted_whitespace_prefix.startswith( - '\n')): + if (line_tok.value in ['(', '[','{'] and line_tok.next_token + and line_tok.next_token.formatted_whitespace_prefix.startswith('\n')): if arg_name_lengths: all_arg_name_lengths.append(arg_name_lengths) arg_name_lengths = [] - index += 1 - line_tok = line_tokens[index] + index += 1 + line_tok = line_tokens[index] continue - if line_tok.value == ')' and not line_tok.is_pseudo: + if line_tok.value == ')'and not line_tok.is_pseudo: if line_tok.formatted_whitespace_prefix.startswith('\n'): - close_column = len( - line_tok.formatted_whitespace_prefix.lstrip('\n')) - else: - close_column = line_tok.column + close_column = len(line_tok.formatted_whitespace_prefix.lstrip('\n')) + else: close_column = line_tok.column if close_column < first_arg_column: if arg_name_lengths: all_arg_name_lengths.append(arg_name_lengths) @@ -710,61 +688,50 @@ def _AlignArgAssign(final_lines): # update the alignment once one full arg list is processed if all_arg_name_lengths: # if argument list with only the first argument on newline - if len(all_arg_name_lengths) == 1 and len( - all_arg_name_lengths[0]) == 1: + if len(all_arg_name_lengths) == 1 and len(all_arg_name_lengths[0]) == 1: continue - max_name_length = 0 + max_name_length = 0 all_arg_name_lengths_index = 0 - arg_name_lengths = all_arg_name_lengths[ - all_arg_name_lengths_index] - max_name_length = max(arg_name_lengths or [0]) + 2 + arg_name_lengths = all_arg_name_lengths[all_arg_name_lengths_index] + max_name_length = max(arg_name_lengths or [0]) + 2 arg_lengths_index = 0 for token in line_tokens[first_arg_index:index]: if token.is_argassign: name_token = token.previous_token while name_token.is_argname and not name_token.is_argname_start: name_token = name_token.previous_token - name_column = len( - name_token.formatted_whitespace_prefix.lstrip('\n')) + name_column = len(name_token.formatted_whitespace_prefix.lstrip('\n')) if name_column == first_arg_column: if all_arg_name_lengths_index < len(all_arg_name_lengths): if arg_lengths_index == len(arg_name_lengths): all_arg_name_lengths_index += 1 - arg_name_lengths = all_arg_name_lengths[ - all_arg_name_lengths_index] - max_name_length = max(arg_name_lengths or [0]) + 2 + arg_name_lengths = all_arg_name_lengths[all_arg_name_lengths_index] + max_name_length = max(arg_name_lengths or [0]) + 2 arg_lengths_index = 0 if arg_lengths_index < len(arg_name_lengths): - assert arg_name_lengths[ - arg_lengths_index] < max_name_length + assert arg_name_lengths[arg_lengths_index] < max_name_length padded_spaces = ' ' * ( - max_name_length - - arg_name_lengths[arg_lengths_index] - 1) + max_name_length - arg_name_lengths[arg_lengths_index] - 1) arg_lengths_index += 1 - assign_content = '{}{}'.format( - padded_spaces, token.value.strip()) + assign_content = '{}{}'.format(padded_spaces, token.value.strip()) existing_whitespace_prefix = \ token.formatted_whitespace_prefix.lstrip('\n') # in case the existing spaces are larger than padded spaces - if (len(padded_spaces) == 1 or - len(padded_spaces) > 1 and - len(existing_whitespace_prefix) - > len(padded_spaces)): + if (len(padded_spaces)==1 or len(padded_spaces)>1 and + len(existing_whitespace_prefix)>len(padded_spaces)): token.whitespace_prefix = '' - elif assign_content.startswith( - existing_whitespace_prefix): - assign_content = assign_content[ - len(existing_whitespace_prefix):] + elif assign_content.startswith(existing_whitespace_prefix): + assign_content = assign_content[len(existing_whitespace_prefix):] token.value = assign_content final_lines_index += 1 - process_content = True + process_content = True break if not process_content: @@ -787,170 +754,153 @@ def _AlignDictColon(final_lines): for tok in line.tokens: # make sure each dict entry on separate lines and # the dict has more than one entry - if (tok.is_dict_key and - tok.formatted_whitespace_prefix.startswith('\n') and - not tok.is_comment): + if (tok.is_dict_key and tok.formatted_whitespace_prefix.startswith('\n') and + not tok.is_comment): - this_line = line + this_line = line - line_tokens = this_line.tokens - for open_index in range(len(line_tokens)): - line_tok = line_tokens[open_index] - - # check each time if the detected dict is the dict we aim for - if line_tok.value == '{' and line_tok.next_token.formatted_whitespace_prefix.startswith( - '\n'): - index = open_index - # skip the comments in the beginning - index += 1 - line_tok = line_tokens[index] - while not line_tok.is_dict_key and index < len(line_tokens) - 1: - index += 1 - line_tok = line_tokens[index] - # in case empty dict, check if dict key again - if line_tok.is_dict_key and line_tok.formatted_whitespace_prefix.startswith( - '\n'): - closing = False # the closing bracket in dict '}'. - keys_content = '' - all_dict_keys_lengths = [] - dict_keys_lengths = [] - - # record the column number of the first key - first_key_column = len( - line_tok.formatted_whitespace_prefix.lstrip('\n')) - key_column = first_key_column - - # while not closing: - while not closing: - prefix = line_tok.formatted_whitespace_prefix - newline = prefix.startswith('\n') - if newline: - # if comments inbetween, save, reset and continue to caluclate new alignment - if (style.Get('NEW_ALIGNMENT_AFTER_COMMENTLINE') and - dict_keys_lengths and line_tok.is_comment): - all_dict_keys_lengths.append(dict_keys_lengths) - dict_keys_lengths = [] - index += 1 - line_tok = line_tokens[index] - continue - if line_tok.is_dict_key_start: - keys_content = '' - prefix = prefix.lstrip('\n') - key_column = len(prefix) - # if the dict key is so long that it has multi-lines - # only caculate the last line that has the colon - elif line_tok.is_dict_key: - keys_content = '' - prefix = prefix.lstrip('\n') - elif line_tok.is_dict_key_start: - key_column = line_tok.column - - if line_tok.is_dict_colon and key_column == first_key_column: - dict_keys_lengths.append(len(keys_content)) - elif line_tok.is_dict_key and key_column == first_key_column: - keys_content += '{}{}'.format(prefix, line_tok.value) + line_tokens = this_line.tokens + for open_index in range(len(line_tokens)): + line_tok = line_tokens[open_index] + # check each time if the detected dict is the dict we aim for + if line_tok.value == '{' and line_tok.next_token.formatted_whitespace_prefix.startswith('\n'): + index = open_index + # skip the comments in the beginning index += 1 - if index < len(line_tokens): + line_tok = line_tokens[index] + while not line_tok.is_dict_key and index < len(line_tokens)-1: + index += 1 line_tok = line_tokens[index] - # when the matching closing bracket is never found - # due to edge cases where the closing bracket - # is not indented or dedented, e.g. ']}', with another bracket before - else: - all_dict_keys_lengths.append(dict_keys_lengths) - break - - # if there is new objects(list/tuple/dict) with its entries on newlines, - # or a function call with any of its arguments on newlines, - # save, reset and continue to calulate new alignment - if (line_tok.value in ['(', '[', '{'] and - not line_tok.is_pseudo and line_tok.next_token and - line_tok.next_token.formatted_whitespace_prefix.startswith( - '\n')): - if dict_keys_lengths: - all_dict_keys_lengths.append(dict_keys_lengths) + # in case empty dict, check if dict key again + if line_tok.is_dict_key and line_tok.formatted_whitespace_prefix.startswith('\n'): + closing = False # the closing bracket in dict '}'. + keys_content = '' + all_dict_keys_lengths = [] dict_keys_lengths = [] - index += 1 - line_tok = line_tokens[index] - continue - # the matching closing bracket is either same indented or dedented - # accordingly to previous level's indentation - # the first found, immediately break the while loop - if line_tok.value == '}': - if line_tok.formatted_whitespace_prefix.startswith('\n'): - close_column = len( - line_tok.formatted_whitespace_prefix.lstrip('\n')) - else: - close_column = line_tok.column - if close_column < first_key_column: - if dict_keys_lengths: - all_dict_keys_lengths.append(dict_keys_lengths) - closing = True - - # update the alignment once one dict is processed - if all_dict_keys_lengths: - max_keys_length = 0 - all_dict_keys_lengths_index = 0 - dict_keys_lengths = all_dict_keys_lengths[ - all_dict_keys_lengths_index] - max_keys_length = max(dict_keys_lengths or [0]) + 2 - keys_lengths_index = 0 - for token in line_tokens[open_index + 1:index]: - if token.is_dict_colon: - # check if the key has multiple tokens and - # get the first key token in this key - key_token = token.previous_token - while key_token.is_dict_key and not key_token.is_dict_key_start: - key_token = key_token.previous_token - key_column = len( - key_token.formatted_whitespace_prefix.lstrip('\n')) - - if key_column == first_key_column: - - if keys_lengths_index == len(dict_keys_lengths): - all_dict_keys_lengths_index += 1 - dict_keys_lengths = all_dict_keys_lengths[ - all_dict_keys_lengths_index] - max_keys_length = max(dict_keys_lengths or [0]) + 2 - keys_lengths_index = 0 - - if keys_lengths_index < len(dict_keys_lengths): - assert dict_keys_lengths[ - keys_lengths_index] < max_keys_length - - padded_spaces = ' ' * ( - max_keys_length - - dict_keys_lengths[keys_lengths_index] - 1) - keys_lengths_index += 1 - #NOTE if the existing whitespaces are larger than padded spaces - existing_whitespace_prefix = \ - token.formatted_whitespace_prefix.lstrip('\n') - colon_content = '{}{}'.format( - padded_spaces, token.value.strip()) - - # in case the existing spaces are larger than the paddes spaces - if (len(padded_spaces) == 1 or - len(padded_spaces) > 1 and - len(existing_whitespace_prefix) - >= len(padded_spaces)): - # remove the existing spaces - token.whitespace_prefix = '' - elif colon_content.startswith( - existing_whitespace_prefix): - colon_content = colon_content[ - len(existing_whitespace_prefix):] - - token.value = colon_content - final_lines_index += 1 - - process_content = True - break + # record the column number of the first key + first_key_column = len(line_tok.formatted_whitespace_prefix.lstrip('\n')) + key_column = first_key_column + + # while not closing: + while not closing: + prefix = line_tok.formatted_whitespace_prefix + newline = prefix.startswith('\n') + if newline: + # if comments inbetween, save, reset and continue to caluclate new alignment + if (style.Get('NEW_ALIGNMENT_AFTER_COMMENTLINE') + and dict_keys_lengths and line_tok.is_comment): + all_dict_keys_lengths.append(dict_keys_lengths) + dict_keys_lengths =[] + index += 1 + line_tok = line_tokens[index] + continue + if line_tok.is_dict_key_start: + keys_content = '' + prefix = prefix.lstrip('\n') + key_column = len(prefix) + # if the dict key is so long that it has multi-lines + # only caculate the last line that has the colon + elif line_tok.is_dict_key: + keys_content = '' + prefix = prefix.lstrip('\n') + elif line_tok.is_dict_key_start: + key_column = line_tok.column + + if line_tok.is_dict_colon and key_column == first_key_column: + dict_keys_lengths.append(len(keys_content)) + elif line_tok.is_dict_key and key_column == first_key_column: + keys_content += '{}{}'.format(prefix, line_tok.value) + + index += 1 + if index < len(line_tokens): + line_tok = line_tokens[index] + # when the matching closing bracket is never found + # due to edge cases where the closing bracket + # is not indented or dedented, e.g. ']}', with another bracket before + else: + all_dict_keys_lengths.append(dict_keys_lengths) + break + + # if there is new objects(list/tuple/dict) with its entries on newlines, + # or a function call with any of its arguments on newlines, + # save, reset and continue to calulate new alignment + if (line_tok.value in ['(', '[', '{'] and not line_tok.is_pseudo and line_tok.next_token + and line_tok.next_token.formatted_whitespace_prefix.startswith('\n')): + if dict_keys_lengths: + all_dict_keys_lengths.append(dict_keys_lengths) + dict_keys_lengths = [] + index += 1 + line_tok = line_tokens[index] + continue + # the matching closing bracket is either same indented or dedented + # accordingly to previous level's indentation + # the first found, immediately break the while loop + if line_tok.value == '}': + if line_tok.formatted_whitespace_prefix.startswith('\n'): + close_column = len(line_tok.formatted_whitespace_prefix.lstrip('\n')) + else: close_column = line_tok.column + if close_column < first_key_column: + if dict_keys_lengths: + all_dict_keys_lengths.append(dict_keys_lengths) + closing = True + + # update the alignment once one dict is processed + if all_dict_keys_lengths: + max_keys_length = 0 + all_dict_keys_lengths_index = 0 + dict_keys_lengths = all_dict_keys_lengths[all_dict_keys_lengths_index] + max_keys_length = max(dict_keys_lengths or [0]) + 2 + keys_lengths_index = 0 + for token in line_tokens[open_index+1:index]: + if token.is_dict_colon: + # check if the key has multiple tokens and + # get the first key token in this key + key_token = token.previous_token + while key_token.is_dict_key and not key_token.is_dict_key_start: + key_token = key_token.previous_token + key_column = len(key_token.formatted_whitespace_prefix.lstrip('\n')) + + if key_column == first_key_column: + + if keys_lengths_index == len(dict_keys_lengths): + all_dict_keys_lengths_index += 1 + dict_keys_lengths = all_dict_keys_lengths[all_dict_keys_lengths_index] + max_keys_length = max(dict_keys_lengths or [0]) + 2 + keys_lengths_index = 0 + + if keys_lengths_index < len(dict_keys_lengths): + assert dict_keys_lengths[keys_lengths_index] < max_keys_length + + padded_spaces = ' ' * ( + max_keys_length - dict_keys_lengths[keys_lengths_index] - 1) + keys_lengths_index += 1 + #NOTE if the existing whitespaces are larger than padded spaces + existing_whitespace_prefix = \ + token.formatted_whitespace_prefix.lstrip('\n') + colon_content = '{}{}'.format(padded_spaces, token.value.strip()) + + # in case the existing spaces are larger than the paddes spaces + if (len(padded_spaces) == 1 or len(padded_spaces) > 1 + and len(existing_whitespace_prefix) >= len(padded_spaces)): + # remove the existing spaces + token.whitespace_prefix = '' + elif colon_content.startswith(existing_whitespace_prefix): + colon_content = colon_content[len(existing_whitespace_prefix):] + + token.value = colon_content + + final_lines_index += 1 + + process_content = True + break if not process_content: final_lines_index += 1 + def _FormatFinalLines(final_lines, verify): """Compose the final output from the finalized lines.""" formatted_code = [] @@ -987,8 +937,8 @@ class _StateNode(object): # TODO(morbo): Add a '__cmp__' method. def __init__(self, state, newline, previous): - self.state = state.Clone() - self.newline = newline + self.state = state.Clone() + self.newline = newline self.previous = previous def __repr__(self): # pragma: no cover @@ -1004,8 +954,8 @@ def __repr__(self): # pragma: no cover # An item in the prioritized BFS search queue. The 'StateNode's 'state' has # the given '_OrderedPenalty'. -_QueueItem = collections.namedtuple( - 'QueueItem', ['ordered_penalty', 'state_node']) +_QueueItem = collections.namedtuple('QueueItem', + ['ordered_penalty', 'state_node']) def _AnalyzeSolutionSpace(initial_state): @@ -1023,8 +973,8 @@ def _AnalyzeSolutionSpace(initial_state): Returns: True if a formatting solution was found. False otherwise. """ - count = 0 - seen = set() + count = 0 + seen = set() p_queue = [] # Insert start element. @@ -1033,9 +983,9 @@ def _AnalyzeSolutionSpace(initial_state): count += 1 while p_queue: - item = p_queue[0] + item = p_queue[0] penalty = item.ordered_penalty.penalty - node = item.state_node + node = item.state_node if not node.state.next_token: break heapq.heappop(p_queue) @@ -1089,7 +1039,7 @@ def _AddNextStateToQueue(penalty, previous_node, newline, count, p_queue): # Don't add a token we must split but where we aren't splitting. return count - node = _StateNode(previous_node.state, newline, previous_node) + node = _StateNode(previous_node.state, newline, previous_node) penalty += node.state.AddTokenToState( newline=newline, dry_run=True, must_split=must_split) heapq.heappush(p_queue, _QueueItem(_OrderedPenalty(penalty, count), node)) @@ -1145,25 +1095,25 @@ def _FormatFirstToken(first_token, indent_depth, prev_line, final_lines): NESTED_DEPTH.append(indent_depth) first_token.AddWhitespacePrefix( - _CalculateNumberOfNewlines( - first_token, indent_depth, prev_line, final_lines, first_nested), + _CalculateNumberOfNewlines(first_token, indent_depth, prev_line, + final_lines, first_nested), indent_level=indent_depth) -NO_BLANK_LINES = 1 -ONE_BLANK_LINE = 2 +NO_BLANK_LINES = 1 +ONE_BLANK_LINE = 2 TWO_BLANK_LINES = 3 def _IsClassOrDef(tok): if tok.value in {'class', 'def', '@'}: return True - return ( - tok.next_token and tok.value == 'async' and tok.next_token.value == 'def') + return (tok.next_token and tok.value == 'async' and + tok.next_token.value == 'def') -def _CalculateNumberOfNewlines( - first_token, indent_depth, prev_line, final_lines, first_nested): +def _CalculateNumberOfNewlines(first_token, indent_depth, prev_line, + final_lines, first_nested): """Calculate the number of newlines we need to add. Arguments: @@ -1283,11 +1233,11 @@ def _SingleOrMergedLines(lines): Either a single line, if the current line cannot be merged with the succeeding line, or the next two lines merged into one line. """ - index = 0 + index = 0 last_was_merged = False while index < len(lines): if lines[index].disable: - line = lines[index] + line = lines[index] index += 1 while index < len(lines): column = line.last.column + 2 @@ -1313,11 +1263,11 @@ def _SingleOrMergedLines(lines): # formatting. Otherwise, it could mess up the shell script's syntax. lines[index].disable = True yield lines[index] - index += 2 + index += 2 last_was_merged = True else: yield lines[index] - index += 1 + index += 1 last_was_merged = False diff --git a/yapf/yapflib/split_penalty.py b/yapf/yapflib/split_penalty.py index 8f93d3ade..79b68edcd 100644 --- a/yapf/yapflib/split_penalty.py +++ b/yapf/yapflib/split_penalty.py @@ -15,9 +15,9 @@ from yapf.yapflib import style # Generic split penalties -UNBREAKABLE = 1000**5 +UNBREAKABLE = 1000**5 VERY_STRONGLY_CONNECTED = 5000 -STRONGLY_CONNECTED = 2500 +STRONGLY_CONNECTED = 2500 ############################################################################# # Grammar-specific penalties - should be <= 1000 # @@ -25,15 +25,15 @@ # Lambdas shouldn't be split unless absolutely necessary or if # ALLOW_MULTILINE_LAMBDAS is True. -LAMBDA = 1000 +LAMBDA = 1000 MULTILINE_LAMBDA = 500 ANNOTATION = 100 -ARGUMENT = 25 +ARGUMENT = 25 # TODO: Assign real values. -RETURN_TYPE = 1 -DOTTED_NAME = 40 -EXPR = 10 -DICT_KEY_EXPR = 20 +RETURN_TYPE = 1 +DOTTED_NAME = 40 +EXPR = 10 +DICT_KEY_EXPR = 20 DICT_VALUE_EXPR = 11 diff --git a/yapf/yapflib/style.py b/yapf/yapflib/style.py index 20414f717..d9e9e5e9e 100644 --- a/yapf/yapflib/style.py +++ b/yapf/yapflib/style.py @@ -52,36 +52,27 @@ def SetGlobalStyle(style): _STYLE_HELP = dict( - ALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENT =textwrap.dedent( - """\ + ALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENT=textwrap.dedent("""\ Align closing bracket with visual indentation."""), - ALIGN_ASSIGNMENT =textwrap.dedent( - """\ + ALIGN_ASSIGNMENT=textwrap.dedent("""\ Align assignment or augmented assignment operators. If there is a blank line or newline comment or objects with newline entries in between, it will start new block alignment."""), - ALIGN_ARGUMENT_ASSIGNMENT =textwrap.dedent( - """\ + ALIGN_ARGUMENT_ASSIGNMENT=textwrap.dedent("""\ Align assignment operators in the argument list if they are all split on newlines. Arguments without assignment are ignored. Arguments without assignment in between will initiate new block alignment calulation. - Newline comments or objects with newline entries will also start new block alignment.""" - ), - ALIGN_DICT_COLON =textwrap.dedent( - """\ + Newline comments or objects with newline entries will also start new block alignment."""), + ALIGN_DICT_COLON=textwrap.dedent("""\ Align the colons in the dictionary if all entries in dictionay are split on newlines. or 'EACH_DICT_ENTRY_ON_SEPERATE_LINE' is set True. """), - NEW_ALIGNMENT_AFTER_COMMENTLINE =textwrap.dedent( - """\ - Start new assignment or colon alignment when there is a newline comment in between.""" - ), - ALLOW_MULTILINE_LAMBDAS =textwrap.dedent( - """\ + NEW_ALIGNMENT_AFTER_COMMENTLINE=textwrap.dedent("""\ + Start new assignment or colon alignment when there is a newline comment in between."""), + ALLOW_MULTILINE_LAMBDAS=textwrap.dedent("""\ Allow lambdas to be formatted on more than one line."""), - ALLOW_MULTILINE_DICTIONARY_KEYS =textwrap.dedent( - """\ + ALLOW_MULTILINE_DICTIONARY_KEYS=textwrap.dedent("""\ Allow dictionary keys to exist on multiple lines. For example: x = { @@ -89,15 +80,12 @@ def SetGlobalStyle(style): 'this is the second element of a tuple'): value, }"""), - ALLOW_SPLIT_BEFORE_DEFAULT_OR_NAMED_ASSIGNS =textwrap.dedent( - """\ + ALLOW_SPLIT_BEFORE_DEFAULT_OR_NAMED_ASSIGNS=textwrap.dedent("""\ Allow splitting before a default / named assignment in an argument list. """), - ALLOW_SPLIT_BEFORE_DICT_VALUE =textwrap.dedent( - """\ + ALLOW_SPLIT_BEFORE_DICT_VALUE=textwrap.dedent("""\ Allow splits before the dictionary value."""), - ARITHMETIC_PRECEDENCE_INDICATION =textwrap.dedent( - """\ + ARITHMETIC_PRECEDENCE_INDICATION=textwrap.dedent("""\ Let spacing indicate operator precedence. For example: a = 1 * 2 + 3 / 4 @@ -117,8 +105,7 @@ def SetGlobalStyle(style): f = 1 + 2 + 3 + 4 """), - BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF =textwrap.dedent( - """\ + BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF=textwrap.dedent("""\ Insert a blank line before a 'def' or 'class' immediately nested within another 'def' or 'class'. For example: @@ -126,22 +113,17 @@ class Foo: # <------ this blank line def method(): ..."""), - BLANK_LINE_BEFORE_CLASS_DOCSTRING =textwrap.dedent( - """\ + BLANK_LINE_BEFORE_CLASS_DOCSTRING=textwrap.dedent("""\ Insert a blank line before a class-level docstring."""), - BLANK_LINE_BEFORE_MODULE_DOCSTRING =textwrap.dedent( - """\ + BLANK_LINE_BEFORE_MODULE_DOCSTRING=textwrap.dedent("""\ Insert a blank line before a module docstring."""), - BLANK_LINES_AROUND_TOP_LEVEL_DEFINITION =textwrap.dedent( - """\ + BLANK_LINES_AROUND_TOP_LEVEL_DEFINITION=textwrap.dedent("""\ Number of blank lines surrounding top-level function and class definitions."""), - BLANK_LINES_BETWEEN_TOP_LEVEL_IMPORTS_AND_VARIABLES =textwrap.dedent( - """\ + BLANK_LINES_BETWEEN_TOP_LEVEL_IMPORTS_AND_VARIABLES=textwrap.dedent("""\ Number of blank lines between top-level imports and variable definitions."""), - COALESCE_BRACKETS =textwrap.dedent( - """\ + COALESCE_BRACKETS=textwrap.dedent("""\ Do not split consecutive brackets. Only relevant when dedent_closing_brackets is set. For example: @@ -158,10 +140,9 @@ def method(): 'key1': 'value1', 'key2': 'value2', })"""), - COLUMN_LIMIT =textwrap.dedent("""\ + COLUMN_LIMIT=textwrap.dedent("""\ The column limit."""), - CONTINUATION_ALIGN_STYLE =textwrap.dedent( - """\ + CONTINUATION_ALIGN_STYLE=textwrap.dedent("""\ The style for continuation alignment. Possible values are: - SPACE: Use spaces for continuation alignment. This is default behavior. @@ -171,11 +152,9 @@ def method(): - VALIGN-RIGHT: Vertically align continuation lines to multiple of INDENT_WIDTH columns. Slightly right (one tab or a few spaces) if cannot vertically align continuation lines with indent characters."""), - CONTINUATION_INDENT_WIDTH =textwrap.dedent( - """\ + CONTINUATION_INDENT_WIDTH=textwrap.dedent("""\ Indent width used for line continuations."""), - DEDENT_CLOSING_BRACKETS =textwrap.dedent( - """\ + DEDENT_CLOSING_BRACKETS=textwrap.dedent("""\ Put closing brackets on a separate line, dedented, if the bracketed expression can't fit in a single line. Applies to all kinds of brackets, including function definitions and calls. For example: @@ -193,33 +172,27 @@ def method(): end_ts=now(), ) # <--- this bracket is dedented and on a separate line """), - DISABLE_ENDING_COMMA_HEURISTIC =textwrap.dedent( - """\ + DISABLE_ENDING_COMMA_HEURISTIC=textwrap.dedent("""\ Disable the heuristic which places each list element on a separate line if the list is comma-terminated."""), - EACH_DICT_ENTRY_ON_SEPARATE_LINE =textwrap.dedent( - """\ + EACH_DICT_ENTRY_ON_SEPARATE_LINE=textwrap.dedent("""\ Place each dictionary entry onto its own line."""), - FORCE_MULTILINE_DICT =textwrap.dedent( - """\ + FORCE_MULTILINE_DICT=textwrap.dedent("""\ Require multiline dictionary even if it would normally fit on one line. For example: config = { 'key1': 'value1' }"""), - I18N_COMMENT =textwrap.dedent( - """\ + I18N_COMMENT=textwrap.dedent("""\ The regex for an i18n comment. The presence of this comment stops reformatting of that line, because the comments are required to be next to the string they translate."""), - I18N_FUNCTION_CALL =textwrap.dedent( - """\ + I18N_FUNCTION_CALL=textwrap.dedent("""\ The i18n function call names. The presence of this function stops reformattting on that line, because the string it has cannot be moved away from the i18n comment."""), - INDENT_CLOSING_BRACKETS =textwrap.dedent( - """\ + INDENT_CLOSING_BRACKETS=textwrap.dedent("""\ Put closing brackets on a separate line, indented, if the bracketed expression can't fit in a single line. Applies to all kinds of brackets, including function definitions and calls. For example: @@ -237,8 +210,7 @@ def method(): end_ts=now(), ) # <--- this bracket is indented and on a separate line """), - INDENT_DICTIONARY_VALUE =textwrap.dedent( - """\ + INDENT_DICTIONARY_VALUE=textwrap.dedent("""\ Indent the dictionary value if it cannot fit on the same line as the dictionary key. For example: @@ -249,16 +221,13 @@ def method(): value2, } """), - INDENT_WIDTH =textwrap.dedent( - """\ + INDENT_WIDTH=textwrap.dedent("""\ The number of columns to use for indentation."""), - INDENT_BLANK_LINES =textwrap.dedent("""\ + INDENT_BLANK_LINES=textwrap.dedent("""\ Indent blank lines."""), - JOIN_MULTIPLE_LINES =textwrap.dedent( - """\ + JOIN_MULTIPLE_LINES=textwrap.dedent("""\ Join short lines into one line. E.g., single line 'if' statements."""), - NO_SPACES_AROUND_SELECTED_BINARY_OPERATORS =textwrap.dedent( - """\ + NO_SPACES_AROUND_SELECTED_BINARY_OPERATORS=textwrap.dedent("""\ Do not include spaces around selected binary operators. For example: 1 + 2 * 3 - 4 / 5 @@ -267,26 +236,21 @@ def method(): 1 + 2*3 - 4/5 """), - SPACE_BETWEEN_ENDING_COMMA_AND_CLOSING_BRACKET =textwrap.dedent( - """\ + SPACE_BETWEEN_ENDING_COMMA_AND_CLOSING_BRACKET=textwrap.dedent("""\ Insert a space between the ending comma and closing bracket of a list, etc."""), - SPACE_INSIDE_BRACKETS =textwrap.dedent( - """\ + SPACE_INSIDE_BRACKETS=textwrap.dedent("""\ Use spaces inside brackets, braces, and parentheses. For example: method_call( 1 ) my_dict[ 3 ][ 1 ][ get_index( *args, **kwargs ) ] my_set = { 1, 2, 3 } """), - SPACES_AROUND_POWER_OPERATOR =textwrap.dedent( - """\ + SPACES_AROUND_POWER_OPERATOR=textwrap.dedent("""\ Use spaces around the power operator."""), - SPACES_AROUND_DEFAULT_OR_NAMED_ASSIGN =textwrap.dedent( - """\ + SPACES_AROUND_DEFAULT_OR_NAMED_ASSIGN=textwrap.dedent("""\ Use spaces around default or named assigns."""), - SPACES_AROUND_DICT_DELIMITERS =textwrap.dedent( - """\ + SPACES_AROUND_DICT_DELIMITERS=textwrap.dedent("""\ Adds a space after the opening '{' and before the ending '}' dict delimiters. @@ -296,8 +260,7 @@ def method(): { 1: 2 } """), - SPACES_AROUND_LIST_DELIMITERS =textwrap.dedent( - """\ + SPACES_AROUND_LIST_DELIMITERS=textwrap.dedent("""\ Adds a space after the opening '[' and before the ending ']' list delimiters. @@ -307,14 +270,12 @@ def method(): [ 1, 2 ] """), - SPACES_AROUND_SUBSCRIPT_COLON =textwrap.dedent( - """\ + SPACES_AROUND_SUBSCRIPT_COLON=textwrap.dedent("""\ Use spaces around the subscript / slice operator. For example: my_list[1 : 10 : 2] """), - SPACES_AROUND_TUPLE_DELIMITERS =textwrap.dedent( - """\ + SPACES_AROUND_TUPLE_DELIMITERS=textwrap.dedent("""\ Adds a space after the opening '(' and before the ending ')' tuple delimiters. @@ -324,8 +285,7 @@ def method(): ( 1, 2, 3 ) """), - SPACES_BEFORE_COMMENT =textwrap.dedent( - """\ + SPACES_BEFORE_COMMENT=textwrap.dedent("""\ The number of spaces required before a trailing comment. This can be a single value (representing the number of spaces before each trailing comment) or list of values (representing @@ -367,31 +327,24 @@ def method(): short # This is a shorter statement """), # noqa - SPLIT_ARGUMENTS_WHEN_COMMA_TERMINATED =textwrap.dedent( - """\ + SPLIT_ARGUMENTS_WHEN_COMMA_TERMINATED=textwrap.dedent("""\ Split before arguments if the argument list is terminated by a comma."""), - SPLIT_ALL_COMMA_SEPARATED_VALUES =textwrap.dedent( - """\ + SPLIT_ALL_COMMA_SEPARATED_VALUES=textwrap.dedent("""\ Split before arguments"""), - SPLIT_ALL_TOP_LEVEL_COMMA_SEPARATED_VALUES =textwrap.dedent( - """\ + SPLIT_ALL_TOP_LEVEL_COMMA_SEPARATED_VALUES=textwrap.dedent("""\ Split before arguments, but do not split all subexpressions recursively (unless needed)."""), - SPLIT_BEFORE_ARITHMETIC_OPERATOR =textwrap.dedent( - """\ + SPLIT_BEFORE_ARITHMETIC_OPERATOR=textwrap.dedent("""\ Set to True to prefer splitting before '+', '-', '*', '/', '//', or '@' rather than after."""), - SPLIT_BEFORE_BITWISE_OPERATOR =textwrap.dedent( - """\ + SPLIT_BEFORE_BITWISE_OPERATOR=textwrap.dedent("""\ Set to True to prefer splitting before '&', '|' or '^' rather than after."""), - SPLIT_BEFORE_CLOSING_BRACKET =textwrap.dedent( - """\ + SPLIT_BEFORE_CLOSING_BRACKET=textwrap.dedent("""\ Split before the closing bracket if a list or dict literal doesn't fit on a single line."""), - SPLIT_BEFORE_DICT_SET_GENERATOR =textwrap.dedent( - """\ + SPLIT_BEFORE_DICT_SET_GENERATOR=textwrap.dedent("""\ Split before a dictionary or set generator (comp_for). For example, note the split before the 'for': @@ -399,8 +352,7 @@ def method(): variable: 'Hello world, have a nice day!' for variable in bar if variable != 42 }"""), - SPLIT_BEFORE_DOT =textwrap.dedent( - """\ + SPLIT_BEFORE_DOT=textwrap.dedent("""\ Split before the '.' if we need to split a longer expression: foo = ('This is a really long string: {}, {}, {}, {}'.format(a, b, c, d)) @@ -410,24 +362,19 @@ def method(): foo = ('This is a really long string: {}, {}, {}, {}' .format(a, b, c, d)) """), # noqa - SPLIT_BEFORE_EXPRESSION_AFTER_OPENING_PAREN =textwrap.dedent( - """\ + SPLIT_BEFORE_EXPRESSION_AFTER_OPENING_PAREN=textwrap.dedent("""\ Split after the opening paren which surrounds an expression if it doesn't fit on a single line. """), - SPLIT_BEFORE_FIRST_ARGUMENT =textwrap.dedent( - """\ + SPLIT_BEFORE_FIRST_ARGUMENT=textwrap.dedent("""\ If an argument / parameter list is going to be split, then split before the first argument."""), - SPLIT_BEFORE_LOGICAL_OPERATOR =textwrap.dedent( - """\ + SPLIT_BEFORE_LOGICAL_OPERATOR=textwrap.dedent("""\ Set to True to prefer splitting before 'and' or 'or' rather than after."""), - SPLIT_BEFORE_NAMED_ASSIGNS =textwrap.dedent( - """\ + SPLIT_BEFORE_NAMED_ASSIGNS=textwrap.dedent("""\ Split named assignments onto individual lines."""), - SPLIT_COMPLEX_COMPREHENSION =textwrap.dedent( - """\ + SPLIT_COMPLEX_COMPREHENSION=textwrap.dedent("""\ Set to True to split list comprehensions and generators that have non-trivial expressions and multiple clauses before each of these clauses. For example: @@ -443,36 +390,27 @@ def method(): for a_long_var in xrange(1000) if a_long_var % 10] """), - SPLIT_PENALTY_AFTER_OPENING_BRACKET =textwrap.dedent( - """\ + SPLIT_PENALTY_AFTER_OPENING_BRACKET=textwrap.dedent("""\ The penalty for splitting right after the opening bracket."""), - SPLIT_PENALTY_AFTER_UNARY_OPERATOR =textwrap.dedent( - """\ + SPLIT_PENALTY_AFTER_UNARY_OPERATOR=textwrap.dedent("""\ The penalty for splitting the line after a unary operator."""), - SPLIT_PENALTY_ARITHMETIC_OPERATOR =textwrap.dedent( - """\ + SPLIT_PENALTY_ARITHMETIC_OPERATOR=textwrap.dedent("""\ The penalty of splitting the line around the '+', '-', '*', '/', '//', ``%``, and '@' operators."""), - SPLIT_PENALTY_BEFORE_IF_EXPR =textwrap.dedent( - """\ + SPLIT_PENALTY_BEFORE_IF_EXPR=textwrap.dedent("""\ The penalty for splitting right before an if expression."""), - SPLIT_PENALTY_BITWISE_OPERATOR =textwrap.dedent( - """\ + SPLIT_PENALTY_BITWISE_OPERATOR=textwrap.dedent("""\ The penalty of splitting the line around the '&', '|', and '^' operators."""), - SPLIT_PENALTY_COMPREHENSION =textwrap.dedent( - """\ + SPLIT_PENALTY_COMPREHENSION=textwrap.dedent("""\ The penalty for splitting a list comprehension or generator expression."""), - SPLIT_PENALTY_EXCESS_CHARACTER =textwrap.dedent( - """\ + SPLIT_PENALTY_EXCESS_CHARACTER=textwrap.dedent("""\ The penalty for characters over the column limit."""), - SPLIT_PENALTY_FOR_ADDED_LINE_SPLIT =textwrap.dedent( - """\ + SPLIT_PENALTY_FOR_ADDED_LINE_SPLIT=textwrap.dedent("""\ The penalty incurred by adding a line split to the logical line. The more line splits added the higher the penalty."""), - SPLIT_PENALTY_IMPORT_NAMES =textwrap.dedent( - """\ + SPLIT_PENALTY_IMPORT_NAMES=textwrap.dedent("""\ The penalty of splitting a list of "import as" names. For example: from a_very_long_or_indented_module_name_yada_yad import (long_argument_1, @@ -484,12 +422,10 @@ def method(): from a_very_long_or_indented_module_name_yada_yad import ( long_argument_1, long_argument_2, long_argument_3) """), # noqa - SPLIT_PENALTY_LOGICAL_OPERATOR =textwrap.dedent( - """\ + SPLIT_PENALTY_LOGICAL_OPERATOR=textwrap.dedent("""\ The penalty of splitting the line around the 'and' and 'or' operators."""), - USE_TABS =textwrap.dedent( - """\ + USE_TABS=textwrap.dedent("""\ Use the Tab character for indentation."""), # BASED_ON_STYLE='Which predefined style this style is based on', ) @@ -498,128 +434,128 @@ def method(): def CreatePEP8Style(): """Create the PEP8 formatting style.""" return dict( - ALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENT =True, - ALIGN_ASSIGNMENT =False, - ALIGN_ARGUMENT_ASSIGNMENT =False, - ALIGN_DICT_COLON =False, - NEW_ALIGNMENT_AFTER_COMMENTLINE =False, - ALLOW_MULTILINE_LAMBDAS =False, - ALLOW_MULTILINE_DICTIONARY_KEYS =False, - ALLOW_SPLIT_BEFORE_DEFAULT_OR_NAMED_ASSIGNS =True, - ALLOW_SPLIT_BEFORE_DICT_VALUE =True, - ARITHMETIC_PRECEDENCE_INDICATION =False, - BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF =True, - BLANK_LINE_BEFORE_CLASS_DOCSTRING =False, - BLANK_LINE_BEFORE_MODULE_DOCSTRING =False, - BLANK_LINES_AROUND_TOP_LEVEL_DEFINITION =2, - BLANK_LINES_BETWEEN_TOP_LEVEL_IMPORTS_AND_VARIABLES =1, - COALESCE_BRACKETS =False, - COLUMN_LIMIT =79, - CONTINUATION_ALIGN_STYLE ='SPACE', - CONTINUATION_INDENT_WIDTH =4, - DEDENT_CLOSING_BRACKETS =False, - INDENT_CLOSING_BRACKETS =False, - DISABLE_ENDING_COMMA_HEURISTIC =False, - EACH_DICT_ENTRY_ON_SEPARATE_LINE =True, - FORCE_MULTILINE_DICT =False, - I18N_COMMENT ='', - I18N_FUNCTION_CALL ='', - INDENT_DICTIONARY_VALUE =False, - INDENT_WIDTH =4, - INDENT_BLANK_LINES =False, - JOIN_MULTIPLE_LINES =True, - NO_SPACES_AROUND_SELECTED_BINARY_OPERATORS =set(), - SPACE_BETWEEN_ENDING_COMMA_AND_CLOSING_BRACKET =True, - SPACE_INSIDE_BRACKETS =False, - SPACES_AROUND_POWER_OPERATOR =False, - SPACES_AROUND_DEFAULT_OR_NAMED_ASSIGN =False, - SPACES_AROUND_DICT_DELIMITERS =False, - SPACES_AROUND_LIST_DELIMITERS =False, - SPACES_AROUND_SUBSCRIPT_COLON =False, - SPACES_AROUND_TUPLE_DELIMITERS =False, - SPACES_BEFORE_COMMENT =2, - SPLIT_ARGUMENTS_WHEN_COMMA_TERMINATED =False, - SPLIT_ALL_COMMA_SEPARATED_VALUES =False, - SPLIT_ALL_TOP_LEVEL_COMMA_SEPARATED_VALUES =False, - SPLIT_BEFORE_ARITHMETIC_OPERATOR =False, - SPLIT_BEFORE_BITWISE_OPERATOR =True, - SPLIT_BEFORE_CLOSING_BRACKET =True, - SPLIT_BEFORE_DICT_SET_GENERATOR =True, - SPLIT_BEFORE_DOT =False, - SPLIT_BEFORE_EXPRESSION_AFTER_OPENING_PAREN =False, - SPLIT_BEFORE_FIRST_ARGUMENT =False, - SPLIT_BEFORE_LOGICAL_OPERATOR =True, - SPLIT_BEFORE_NAMED_ASSIGNS =True, - SPLIT_COMPLEX_COMPREHENSION =False, - SPLIT_PENALTY_AFTER_OPENING_BRACKET =300, - SPLIT_PENALTY_AFTER_UNARY_OPERATOR =10000, - SPLIT_PENALTY_ARITHMETIC_OPERATOR =300, - SPLIT_PENALTY_BEFORE_IF_EXPR =0, - SPLIT_PENALTY_BITWISE_OPERATOR =300, - SPLIT_PENALTY_COMPREHENSION =80, - SPLIT_PENALTY_EXCESS_CHARACTER =7000, - SPLIT_PENALTY_FOR_ADDED_LINE_SPLIT =30, - SPLIT_PENALTY_IMPORT_NAMES =0, - SPLIT_PENALTY_LOGICAL_OPERATOR =300, - USE_TABS =False, + ALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENT=True, + ALIGN_ASSIGNMENT=False, + ALIGN_ARGUMENT_ASSIGNMENT=False, + ALIGN_DICT_COLON=False, + NEW_ALIGNMENT_AFTER_COMMENTLINE=False, + ALLOW_MULTILINE_LAMBDAS=False, + ALLOW_MULTILINE_DICTIONARY_KEYS=False, + ALLOW_SPLIT_BEFORE_DEFAULT_OR_NAMED_ASSIGNS=True, + ALLOW_SPLIT_BEFORE_DICT_VALUE=True, + ARITHMETIC_PRECEDENCE_INDICATION=False, + BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF=True, + BLANK_LINE_BEFORE_CLASS_DOCSTRING=False, + BLANK_LINE_BEFORE_MODULE_DOCSTRING=False, + BLANK_LINES_AROUND_TOP_LEVEL_DEFINITION=2, + BLANK_LINES_BETWEEN_TOP_LEVEL_IMPORTS_AND_VARIABLES=1, + COALESCE_BRACKETS=False, + COLUMN_LIMIT=79, + CONTINUATION_ALIGN_STYLE='SPACE', + CONTINUATION_INDENT_WIDTH=4, + DEDENT_CLOSING_BRACKETS=False, + INDENT_CLOSING_BRACKETS=False, + DISABLE_ENDING_COMMA_HEURISTIC=False, + EACH_DICT_ENTRY_ON_SEPARATE_LINE=True, + FORCE_MULTILINE_DICT=False, + I18N_COMMENT='', + I18N_FUNCTION_CALL='', + INDENT_DICTIONARY_VALUE=False, + INDENT_WIDTH=4, + INDENT_BLANK_LINES=False, + JOIN_MULTIPLE_LINES=True, + NO_SPACES_AROUND_SELECTED_BINARY_OPERATORS=set(), + SPACE_BETWEEN_ENDING_COMMA_AND_CLOSING_BRACKET=True, + SPACE_INSIDE_BRACKETS=False, + SPACES_AROUND_POWER_OPERATOR=False, + SPACES_AROUND_DEFAULT_OR_NAMED_ASSIGN=False, + SPACES_AROUND_DICT_DELIMITERS=False, + SPACES_AROUND_LIST_DELIMITERS=False, + SPACES_AROUND_SUBSCRIPT_COLON=False, + SPACES_AROUND_TUPLE_DELIMITERS=False, + SPACES_BEFORE_COMMENT=2, + SPLIT_ARGUMENTS_WHEN_COMMA_TERMINATED=False, + SPLIT_ALL_COMMA_SEPARATED_VALUES=False, + SPLIT_ALL_TOP_LEVEL_COMMA_SEPARATED_VALUES=False, + SPLIT_BEFORE_ARITHMETIC_OPERATOR=False, + SPLIT_BEFORE_BITWISE_OPERATOR=True, + SPLIT_BEFORE_CLOSING_BRACKET=True, + SPLIT_BEFORE_DICT_SET_GENERATOR=True, + SPLIT_BEFORE_DOT=False, + SPLIT_BEFORE_EXPRESSION_AFTER_OPENING_PAREN=False, + SPLIT_BEFORE_FIRST_ARGUMENT=False, + SPLIT_BEFORE_LOGICAL_OPERATOR=True, + SPLIT_BEFORE_NAMED_ASSIGNS=True, + SPLIT_COMPLEX_COMPREHENSION=False, + SPLIT_PENALTY_AFTER_OPENING_BRACKET=300, + SPLIT_PENALTY_AFTER_UNARY_OPERATOR=10000, + SPLIT_PENALTY_ARITHMETIC_OPERATOR=300, + SPLIT_PENALTY_BEFORE_IF_EXPR=0, + SPLIT_PENALTY_BITWISE_OPERATOR=300, + SPLIT_PENALTY_COMPREHENSION=80, + SPLIT_PENALTY_EXCESS_CHARACTER=7000, + SPLIT_PENALTY_FOR_ADDED_LINE_SPLIT=30, + SPLIT_PENALTY_IMPORT_NAMES=0, + SPLIT_PENALTY_LOGICAL_OPERATOR=300, + USE_TABS=False, ) def CreateGoogleStyle(): """Create the Google formatting style.""" - style = CreatePEP8Style() - style['ALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENT'] = False - style['COLUMN_LIMIT'] = 80 - style['INDENT_DICTIONARY_VALUE'] = True - style['INDENT_WIDTH'] = 4 - style['I18N_COMMENT'] = r'#\..*' - style['I18N_FUNCTION_CALL'] = ['N_', '_'] - style['JOIN_MULTIPLE_LINES'] = False + style = CreatePEP8Style() + style['ALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENT'] = False + style['COLUMN_LIMIT'] = 80 + style['INDENT_DICTIONARY_VALUE'] = True + style['INDENT_WIDTH'] = 4 + style['I18N_COMMENT'] = r'#\..*' + style['I18N_FUNCTION_CALL'] = ['N_', '_'] + style['JOIN_MULTIPLE_LINES'] = False style['SPACE_BETWEEN_ENDING_COMMA_AND_CLOSING_BRACKET'] = False - style['SPLIT_BEFORE_BITWISE_OPERATOR'] = False - style['SPLIT_BEFORE_DICT_SET_GENERATOR'] = False - style['SPLIT_BEFORE_LOGICAL_OPERATOR'] = False - style['SPLIT_COMPLEX_COMPREHENSION'] = True - style['SPLIT_PENALTY_COMPREHENSION'] = 2100 + style['SPLIT_BEFORE_BITWISE_OPERATOR'] = False + style['SPLIT_BEFORE_DICT_SET_GENERATOR'] = False + style['SPLIT_BEFORE_LOGICAL_OPERATOR'] = False + style['SPLIT_COMPLEX_COMPREHENSION'] = True + style['SPLIT_PENALTY_COMPREHENSION'] = 2100 return style def CreateYapfStyle(): """Create the YAPF formatting style.""" - style = CreateGoogleStyle() - style['ALLOW_MULTILINE_DICTIONARY_KEYS'] = True + style = CreateGoogleStyle() + style['ALLOW_MULTILINE_DICTIONARY_KEYS'] = True style['ALLOW_SPLIT_BEFORE_DEFAULT_OR_NAMED_ASSIGNS'] = False - style['INDENT_WIDTH'] = 2 - style['SPLIT_BEFORE_BITWISE_OPERATOR'] = True - style['SPLIT_BEFORE_DOT'] = True + style['INDENT_WIDTH'] = 2 + style['SPLIT_BEFORE_BITWISE_OPERATOR'] = True + style['SPLIT_BEFORE_DOT'] = True style['SPLIT_BEFORE_EXPRESSION_AFTER_OPENING_PAREN'] = True return style def CreateFacebookStyle(): """Create the Facebook formatting style.""" - style = CreatePEP8Style() + style = CreatePEP8Style() style['ALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENT'] = False - style['BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF'] = False - style['COLUMN_LIMIT'] = 80 - style['DEDENT_CLOSING_BRACKETS'] = True - style['INDENT_CLOSING_BRACKETS'] = False - style['INDENT_DICTIONARY_VALUE'] = True - style['JOIN_MULTIPLE_LINES'] = False - style['SPACES_BEFORE_COMMENT'] = 2 - style['SPLIT_PENALTY_AFTER_OPENING_BRACKET'] = 0 - style['SPLIT_PENALTY_BEFORE_IF_EXPR'] = 30 - style['SPLIT_PENALTY_FOR_ADDED_LINE_SPLIT'] = 30 - style['SPLIT_BEFORE_LOGICAL_OPERATOR'] = False - style['SPLIT_BEFORE_BITWISE_OPERATOR'] = False + style['BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF'] = False + style['COLUMN_LIMIT'] = 80 + style['DEDENT_CLOSING_BRACKETS'] = True + style['INDENT_CLOSING_BRACKETS'] = False + style['INDENT_DICTIONARY_VALUE'] = True + style['JOIN_MULTIPLE_LINES'] = False + style['SPACES_BEFORE_COMMENT'] = 2 + style['SPLIT_PENALTY_AFTER_OPENING_BRACKET'] = 0 + style['SPLIT_PENALTY_BEFORE_IF_EXPR'] = 30 + style['SPLIT_PENALTY_FOR_ADDED_LINE_SPLIT'] = 30 + style['SPLIT_BEFORE_LOGICAL_OPERATOR'] = False + style['SPLIT_BEFORE_BITWISE_OPERATOR'] = False return style _STYLE_NAME_TO_FACTORY = dict( - pep8 =CreatePEP8Style, - google =CreateGoogleStyle, - facebook =CreateFacebookStyle, - yapf =CreateYapfStyle, + pep8=CreatePEP8Style, + google=CreateGoogleStyle, + facebook=CreateFacebookStyle, + yapf=CreateYapfStyle, ) _DEFAULT_STYLE_TO_FACTORY = [ @@ -690,70 +626,70 @@ def _IntOrIntListConverter(s): # # Note: this dict has to map all the supported style options. _STYLE_OPTION_VALUE_CONVERTER = dict( - ALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENT =_BoolConverter, - ALIGN_ASSIGNMENT =_BoolConverter, - ALIGN_DICT_COLON =_BoolConverter, - NEW_ALIGNMENT_AFTER_COMMENTLINE =_BoolConverter, - ALIGN_ARGUMENT_ASSIGNMENT =_BoolConverter, - ALLOW_MULTILINE_LAMBDAS =_BoolConverter, - ALLOW_MULTILINE_DICTIONARY_KEYS =_BoolConverter, - ALLOW_SPLIT_BEFORE_DEFAULT_OR_NAMED_ASSIGNS =_BoolConverter, - ALLOW_SPLIT_BEFORE_DICT_VALUE =_BoolConverter, - ARITHMETIC_PRECEDENCE_INDICATION =_BoolConverter, - BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF =_BoolConverter, - BLANK_LINE_BEFORE_CLASS_DOCSTRING =_BoolConverter, - BLANK_LINE_BEFORE_MODULE_DOCSTRING =_BoolConverter, - BLANK_LINES_AROUND_TOP_LEVEL_DEFINITION =int, - BLANK_LINES_BETWEEN_TOP_LEVEL_IMPORTS_AND_VARIABLES =int, - COALESCE_BRACKETS =_BoolConverter, - COLUMN_LIMIT =int, - CONTINUATION_ALIGN_STYLE =_ContinuationAlignStyleStringConverter, - CONTINUATION_INDENT_WIDTH =int, - DEDENT_CLOSING_BRACKETS =_BoolConverter, - INDENT_CLOSING_BRACKETS =_BoolConverter, - DISABLE_ENDING_COMMA_HEURISTIC =_BoolConverter, - EACH_DICT_ENTRY_ON_SEPARATE_LINE =_BoolConverter, - FORCE_MULTILINE_DICT =_BoolConverter, - I18N_COMMENT =str, - I18N_FUNCTION_CALL =_StringListConverter, - INDENT_DICTIONARY_VALUE =_BoolConverter, - INDENT_WIDTH =int, - INDENT_BLANK_LINES =_BoolConverter, - JOIN_MULTIPLE_LINES =_BoolConverter, - NO_SPACES_AROUND_SELECTED_BINARY_OPERATORS =_StringSetConverter, - SPACE_BETWEEN_ENDING_COMMA_AND_CLOSING_BRACKET =_BoolConverter, - SPACE_INSIDE_BRACKETS =_BoolConverter, - SPACES_AROUND_POWER_OPERATOR =_BoolConverter, - SPACES_AROUND_DEFAULT_OR_NAMED_ASSIGN =_BoolConverter, - SPACES_AROUND_DICT_DELIMITERS =_BoolConverter, - SPACES_AROUND_LIST_DELIMITERS =_BoolConverter, - SPACES_AROUND_SUBSCRIPT_COLON =_BoolConverter, - SPACES_AROUND_TUPLE_DELIMITERS =_BoolConverter, - SPACES_BEFORE_COMMENT =_IntOrIntListConverter, - SPLIT_ARGUMENTS_WHEN_COMMA_TERMINATED =_BoolConverter, - SPLIT_ALL_COMMA_SEPARATED_VALUES =_BoolConverter, - SPLIT_ALL_TOP_LEVEL_COMMA_SEPARATED_VALUES =_BoolConverter, - SPLIT_BEFORE_ARITHMETIC_OPERATOR =_BoolConverter, - SPLIT_BEFORE_BITWISE_OPERATOR =_BoolConverter, - SPLIT_BEFORE_CLOSING_BRACKET =_BoolConverter, - SPLIT_BEFORE_DICT_SET_GENERATOR =_BoolConverter, - SPLIT_BEFORE_DOT =_BoolConverter, - SPLIT_BEFORE_EXPRESSION_AFTER_OPENING_PAREN =_BoolConverter, - SPLIT_BEFORE_FIRST_ARGUMENT =_BoolConverter, - SPLIT_BEFORE_LOGICAL_OPERATOR =_BoolConverter, - SPLIT_BEFORE_NAMED_ASSIGNS =_BoolConverter, - SPLIT_COMPLEX_COMPREHENSION =_BoolConverter, - SPLIT_PENALTY_AFTER_OPENING_BRACKET =int, - SPLIT_PENALTY_AFTER_UNARY_OPERATOR =int, - SPLIT_PENALTY_ARITHMETIC_OPERATOR =int, - SPLIT_PENALTY_BEFORE_IF_EXPR =int, - SPLIT_PENALTY_BITWISE_OPERATOR =int, - SPLIT_PENALTY_COMPREHENSION =int, - SPLIT_PENALTY_EXCESS_CHARACTER =int, - SPLIT_PENALTY_FOR_ADDED_LINE_SPLIT =int, - SPLIT_PENALTY_IMPORT_NAMES =int, - SPLIT_PENALTY_LOGICAL_OPERATOR =int, - USE_TABS =_BoolConverter, + ALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENT=_BoolConverter, + ALIGN_ASSIGNMENT=_BoolConverter, + ALIGN_DICT_COLON=_BoolConverter, + NEW_ALIGNMENT_AFTER_COMMENTLINE=_BoolConverter, + ALIGN_ARGUMENT_ASSIGNMENT=_BoolConverter, + ALLOW_MULTILINE_LAMBDAS=_BoolConverter, + ALLOW_MULTILINE_DICTIONARY_KEYS=_BoolConverter, + ALLOW_SPLIT_BEFORE_DEFAULT_OR_NAMED_ASSIGNS=_BoolConverter, + ALLOW_SPLIT_BEFORE_DICT_VALUE=_BoolConverter, + ARITHMETIC_PRECEDENCE_INDICATION=_BoolConverter, + BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF=_BoolConverter, + BLANK_LINE_BEFORE_CLASS_DOCSTRING=_BoolConverter, + BLANK_LINE_BEFORE_MODULE_DOCSTRING=_BoolConverter, + BLANK_LINES_AROUND_TOP_LEVEL_DEFINITION=int, + BLANK_LINES_BETWEEN_TOP_LEVEL_IMPORTS_AND_VARIABLES=int, + COALESCE_BRACKETS=_BoolConverter, + COLUMN_LIMIT=int, + CONTINUATION_ALIGN_STYLE=_ContinuationAlignStyleStringConverter, + CONTINUATION_INDENT_WIDTH=int, + DEDENT_CLOSING_BRACKETS=_BoolConverter, + INDENT_CLOSING_BRACKETS=_BoolConverter, + DISABLE_ENDING_COMMA_HEURISTIC=_BoolConverter, + EACH_DICT_ENTRY_ON_SEPARATE_LINE=_BoolConverter, + FORCE_MULTILINE_DICT=_BoolConverter, + I18N_COMMENT=str, + I18N_FUNCTION_CALL=_StringListConverter, + INDENT_DICTIONARY_VALUE=_BoolConverter, + INDENT_WIDTH=int, + INDENT_BLANK_LINES=_BoolConverter, + JOIN_MULTIPLE_LINES=_BoolConverter, + NO_SPACES_AROUND_SELECTED_BINARY_OPERATORS=_StringSetConverter, + SPACE_BETWEEN_ENDING_COMMA_AND_CLOSING_BRACKET=_BoolConverter, + SPACE_INSIDE_BRACKETS=_BoolConverter, + SPACES_AROUND_POWER_OPERATOR=_BoolConverter, + SPACES_AROUND_DEFAULT_OR_NAMED_ASSIGN=_BoolConverter, + SPACES_AROUND_DICT_DELIMITERS=_BoolConverter, + SPACES_AROUND_LIST_DELIMITERS=_BoolConverter, + SPACES_AROUND_SUBSCRIPT_COLON=_BoolConverter, + SPACES_AROUND_TUPLE_DELIMITERS=_BoolConverter, + SPACES_BEFORE_COMMENT=_IntOrIntListConverter, + SPLIT_ARGUMENTS_WHEN_COMMA_TERMINATED=_BoolConverter, + SPLIT_ALL_COMMA_SEPARATED_VALUES=_BoolConverter, + SPLIT_ALL_TOP_LEVEL_COMMA_SEPARATED_VALUES=_BoolConverter, + SPLIT_BEFORE_ARITHMETIC_OPERATOR=_BoolConverter, + SPLIT_BEFORE_BITWISE_OPERATOR=_BoolConverter, + SPLIT_BEFORE_CLOSING_BRACKET=_BoolConverter, + SPLIT_BEFORE_DICT_SET_GENERATOR=_BoolConverter, + SPLIT_BEFORE_DOT=_BoolConverter, + SPLIT_BEFORE_EXPRESSION_AFTER_OPENING_PAREN=_BoolConverter, + SPLIT_BEFORE_FIRST_ARGUMENT=_BoolConverter, + SPLIT_BEFORE_LOGICAL_OPERATOR=_BoolConverter, + SPLIT_BEFORE_NAMED_ASSIGNS=_BoolConverter, + SPLIT_COMPLEX_COMPREHENSION=_BoolConverter, + SPLIT_PENALTY_AFTER_OPENING_BRACKET=int, + SPLIT_PENALTY_AFTER_UNARY_OPERATOR=int, + SPLIT_PENALTY_ARITHMETIC_OPERATOR=int, + SPLIT_PENALTY_BEFORE_IF_EXPR=int, + SPLIT_PENALTY_BITWISE_OPERATOR=int, + SPLIT_PENALTY_COMPREHENSION=int, + SPLIT_PENALTY_EXCESS_CHARACTER=int, + SPLIT_PENALTY_FOR_ADDED_LINE_SPLIT=int, + SPLIT_PENALTY_IMPORT_NAMES=int, + SPLIT_PENALTY_LOGICAL_OPERATOR=int, + USE_TABS=_BoolConverter, ) @@ -845,7 +781,7 @@ def _CreateConfigParserFromConfigFile(config_filename): "configuration file") pyproject_toml = toml.load(style_file) - style_dict = pyproject_toml.get("tool", {}).get("yapf", None) + style_dict = pyproject_toml.get("tool", {}).get("yapf", None) if style_dict is None: raise StyleConfigError( 'Unable to find section [tool.yapf] in {0}'.format(config_filename)) @@ -888,10 +824,10 @@ def _CreateStyleFromConfigParser(config): # Initialize the base style. section = 'yapf' if config.has_section('yapf') else 'style' if config.has_option('style', 'based_on_style'): - based_on = config.get('style', 'based_on_style').lower() + based_on = config.get('style', 'based_on_style').lower() base_style = _STYLE_NAME_TO_FACTORY[based_on]() elif config.has_option('yapf', 'based_on_style'): - based_on = config.get('yapf', 'based_on_style').lower() + based_on = config.get('yapf', 'based_on_style').lower() base_style = _STYLE_NAME_TO_FACTORY[based_on]() else: base_style = _GLOBAL_STYLE_FACTORY() @@ -908,14 +844,14 @@ def _CreateStyleFromConfigParser(config): try: base_style[option] = _STYLE_OPTION_VALUE_CONVERTER[option](value) except ValueError: - raise StyleConfigError( - "'{}' is not a valid setting for {}.".format(value, option)) + raise StyleConfigError("'{}' is not a valid setting for {}.".format( + value, option)) return base_style # The default style - used if yapf is not invoked without specifically # requesting a formatting style. -DEFAULT_STYLE = 'pep8' +DEFAULT_STYLE = 'pep8' DEFAULT_STYLE_FACTORY = CreatePEP8Style _GLOBAL_STYLE_FACTORY = CreatePEP8Style diff --git a/yapf/yapflib/subtypes.py b/yapf/yapflib/subtypes.py index e675c41c1..b4b7efe75 100644 --- a/yapf/yapflib/subtypes.py +++ b/yapf/yapflib/subtypes.py @@ -13,28 +13,28 @@ # limitations under the License. """Token subtypes used to improve formatting.""" -NONE = 0 -UNARY_OPERATOR = 1 -BINARY_OPERATOR = 2 -SUBSCRIPT_COLON = 3 -SUBSCRIPT_BRACKET = 4 -DEFAULT_OR_NAMED_ASSIGN = 5 +NONE = 0 +UNARY_OPERATOR = 1 +BINARY_OPERATOR = 2 +SUBSCRIPT_COLON = 3 +SUBSCRIPT_BRACKET = 4 +DEFAULT_OR_NAMED_ASSIGN = 5 DEFAULT_OR_NAMED_ASSIGN_ARG_LIST = 6 -VARARGS_LIST = 7 -VARARGS_STAR = 8 -KWARGS_STAR_STAR = 9 -ASSIGN_OPERATOR = 10 -DICTIONARY_KEY = 11 -DICTIONARY_KEY_PART = 12 -DICTIONARY_VALUE = 13 -DICT_SET_GENERATOR = 14 -COMP_EXPR = 15 -COMP_FOR = 16 -COMP_IF = 17 -FUNC_DEF = 18 -DECORATOR = 19 -TYPED_NAME = 20 -TYPED_NAME_ARG_LIST = 21 -SIMPLE_EXPRESSION = 22 -PARAMETER_START = 23 -PARAMETER_STOP = 24 +VARARGS_LIST = 7 +VARARGS_STAR = 8 +KWARGS_STAR_STAR = 9 +ASSIGN_OPERATOR = 10 +DICTIONARY_KEY = 11 +DICTIONARY_KEY_PART = 12 +DICTIONARY_VALUE = 13 +DICT_SET_GENERATOR = 14 +COMP_EXPR = 15 +COMP_FOR = 16 +COMP_IF = 17 +FUNC_DEF = 18 +DECORATOR = 19 +TYPED_NAME = 20 +TYPED_NAME_ARG_LIST = 21 +SIMPLE_EXPRESSION = 22 +PARAMETER_START = 23 +PARAMETER_STOP = 24 diff --git a/yapf/yapflib/verifier.py b/yapf/yapflib/verifier.py index 01dccc0b0..bcbe6fb6b 100644 --- a/yapf/yapflib/verifier.py +++ b/yapf/yapflib/verifier.py @@ -59,7 +59,7 @@ def _NormalizeCode(code): # Split the code to lines and get rid of all leading full-comment lines as # they can mess up the normalization attempt. lines = code.split('\n') - i = 0 + i = 0 for i, line in enumerate(lines): line = line.strip() if line and not line.startswith('#'): diff --git a/yapf/yapflib/yapf_api.py b/yapf/yapflib/yapf_api.py index dd75e9fe6..c17451434 100644 --- a/yapf/yapflib/yapf_api.py +++ b/yapf/yapflib/yapf_api.py @@ -51,14 +51,13 @@ from yapf.yapflib import style -def FormatFile( - filename, - style_config =None, - lines =None, - print_diff =False, - verify =False, - in_place =False, - logger =None): +def FormatFile(filename, + style_config=None, + lines=None, + print_diff=False, + verify=False, + in_place=False, + logger=None): """Format a single Python file and return the formatted code. Arguments: @@ -91,20 +90,20 @@ def FormatFile( raise ValueError('Cannot pass both in_place and print_diff.') original_source, newline, encoding = ReadFile(filename, logger) - reformatted_source, changed = FormatCode( + reformatted_source, changed = FormatCode( original_source, - style_config =style_config, - filename =filename, - lines =lines, - print_diff =print_diff, - verify =verify) + style_config=style_config, + filename=filename, + lines=lines, + print_diff=print_diff, + verify=verify) if reformatted_source.rstrip('\n'): - lines = reformatted_source.rstrip('\n').split('\n') + lines = reformatted_source.rstrip('\n').split('\n') reformatted_source = newline.join(iter(lines)) + newline if in_place: if original_source and original_source != reformatted_source: - file_resources.WriteReformattedCode( - filename, reformatted_source, encoding, in_place) + file_resources.WriteReformattedCode(filename, reformatted_source, + encoding, in_place) return None, encoding, changed return reformatted_source, encoding, changed @@ -149,13 +148,12 @@ def FormatTree(tree, style_config=None, lines=None, verify=False): return reformatter.Reformat(_SplitSemicolons(llines), verify, lines) -def FormatCode( - unformatted_source, - filename ='', - style_config =None, - lines =None, - print_diff =False, - verify =False): +def FormatCode(unformatted_source, + filename='', + style_config=None, + lines=None, + print_diff=False, + verify=False): """Format a string of Python code. This provides an alternative entry point to YAPF. @@ -230,12 +228,12 @@ def ReadFile(filename, logger=None): encoding = file_resources.FileEncoding(filename) # Preserves line endings. - with py3compat.open_with_encoding(filename, mode='r', encoding=encoding, - newline='') as fd: + with py3compat.open_with_encoding( + filename, mode='r', encoding=encoding, newline='') as fd: lines = fd.readlines() line_ending = file_resources.LineEnding(lines) - source = '\n'.join(line.rstrip('\r\n') for line in lines) + '\n' + source = '\n'.join(line.rstrip('\r\n') for line in lines) + '\n' return source, line_ending, encoding except IOError as e: # pragma: no cover if logger: @@ -244,9 +242,8 @@ def ReadFile(filename, logger=None): raise except UnicodeDecodeError as e: # pragma: no cover if logger: - logger( - 'Could not parse %s! Consider excluding this file with --exclude.', - filename) + logger('Could not parse %s! Consider excluding this file with --exclude.', + filename) logger(e) e.args = (e.args[0], (filename, e.args[1][1], e.args[1][2], e.args[1][3])) raise @@ -260,7 +257,7 @@ def _SplitSemicolons(lines): DISABLE_PATTERN = r'^#.*\byapf:\s*disable\b' -ENABLE_PATTERN = r'^#.*\byapf:\s*enable\b' +ENABLE_PATTERN = r'^#.*\byapf:\s*enable\b' def _LineRangesToSet(line_ranges): @@ -293,31 +290,29 @@ def _MarkLinesToFormat(llines, lines): index += 1 while index < len(llines): uwline = llines[index] - line = uwline.first.value.strip() + line = uwline.first.value.strip() if uwline.is_comment and _EnableYAPF(line): if not _DisableYAPF(line): break uwline.disable = True - index += 1 + index += 1 elif re.search(DISABLE_PATTERN, uwline.last.value.strip(), re.IGNORECASE): uwline.disable = True index += 1 def _DisableYAPF(line): - return ( - re.search(DISABLE_PATTERN, - line.split('\n')[0].strip(), re.IGNORECASE) or - re.search(DISABLE_PATTERN, - line.split('\n')[-1].strip(), re.IGNORECASE)) + return (re.search(DISABLE_PATTERN, + line.split('\n')[0].strip(), re.IGNORECASE) or + re.search(DISABLE_PATTERN, + line.split('\n')[-1].strip(), re.IGNORECASE)) def _EnableYAPF(line): - return ( - re.search(ENABLE_PATTERN, - line.split('\n')[0].strip(), re.IGNORECASE) or - re.search(ENABLE_PATTERN, - line.split('\n')[-1].strip(), re.IGNORECASE)) + return (re.search(ENABLE_PATTERN, + line.split('\n')[0].strip(), re.IGNORECASE) or + re.search(ENABLE_PATTERN, + line.split('\n')[-1].strip(), re.IGNORECASE)) def _GetUnifiedDiff(before, after, filename='code'): @@ -332,7 +327,7 @@ def _GetUnifiedDiff(before, after, filename='code'): The unified diff text. """ before = before.splitlines() - after = after.splitlines() + after = after.splitlines() return '\n'.join( difflib.unified_diff( before, diff --git a/yapftests/blank_line_calculator_test.py b/yapftests/blank_line_calculator_test.py index d5d97d794..18fa83e0b 100644 --- a/yapftests/blank_line_calculator_test.py +++ b/yapftests/blank_line_calculator_test.py @@ -30,15 +30,13 @@ def setUpClass(cls): style.SetGlobalStyle(style.CreateYapfStyle()) def testDecorators(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ @bork() def foo(): pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ @bork() def foo(): pass @@ -47,8 +45,7 @@ def foo(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testComplexDecorators(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ import sys @bork() @@ -63,8 +60,7 @@ class moo(object): def method(self): pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ import sys @@ -85,8 +81,7 @@ def method(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testCodeAfterFunctionsAndClasses(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def foo(): pass top_level_code = True @@ -102,8 +97,7 @@ def method_2(self): except Error as error: pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def foo(): pass @@ -132,8 +126,7 @@ def method_2(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testCommentSpacing(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ # This is the first comment # And it's multiline @@ -162,8 +155,7 @@ def foo(self): # comment pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ # This is the first comment # And it's multiline @@ -200,8 +192,7 @@ def foo(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testCommentBeforeMethod(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ class foo(object): # pylint: disable=invalid-name @@ -212,8 +203,7 @@ def f(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testCommentsBeforeClassDefs(self): - code = textwrap.dedent( - '''\ + code = textwrap.dedent('''\ """Test.""" # Comment @@ -226,8 +216,7 @@ class Foo(object): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testCommentsBeforeDecorator(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ # The @foo operator adds bork to a(). @foo() def a(): @@ -236,8 +225,7 @@ def a(): llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ # Hello world @@ -249,8 +237,7 @@ def a(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testCommentsAfterDecorator(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ class _(): def _(): @@ -267,8 +254,7 @@ def test_unicode_filename_in_sdist(self, sdist_unicode, tmpdir, monkeypatch): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testInnerClasses(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ class DeployAPIClient(object): class Error(Exception): pass @@ -276,8 +262,7 @@ class TaskValidationError(Error): pass class DeployAPIHTTPError(Error): pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ class DeployAPIClient(object): class Error(Exception): @@ -293,8 +278,7 @@ class DeployAPIHTTPError(Error): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testLinesOnRangeBoundary(self): - unformatted_code = textwrap.dedent( - u"""\ + unformatted_code = textwrap.dedent(u"""\ def A(): pass @@ -308,8 +292,7 @@ def D(): # 9 def E(): pass """) - expected_formatted_code = textwrap.dedent( - u"""\ + expected_formatted_code = textwrap.dedent(u"""\ def A(): pass @@ -332,8 +315,7 @@ def E(): self.assertTrue(changed) def testLinesRangeBoundaryNotOutside(self): - unformatted_code = textwrap.dedent( - u"""\ + unformatted_code = textwrap.dedent(u"""\ def A(): pass @@ -347,8 +329,7 @@ def B(): # 6 def C(): pass """) - expected_formatted_code = textwrap.dedent( - u"""\ + expected_formatted_code = textwrap.dedent(u"""\ def A(): pass @@ -367,8 +348,7 @@ def C(): self.assertFalse(changed) def testLinesRangeRemove(self): - unformatted_code = textwrap.dedent( - u"""\ + unformatted_code = textwrap.dedent(u"""\ def A(): pass @@ -383,8 +363,7 @@ def B(): # 6 def C(): pass """) - expected_formatted_code = textwrap.dedent( - u"""\ + expected_formatted_code = textwrap.dedent(u"""\ def A(): pass @@ -403,8 +382,7 @@ def C(): self.assertTrue(changed) def testLinesRangeRemoveSome(self): - unformatted_code = textwrap.dedent( - u"""\ + unformatted_code = textwrap.dedent(u"""\ def A(): pass @@ -420,8 +398,7 @@ def B(): # 7 def C(): pass """) - expected_formatted_code = textwrap.dedent( - u"""\ + expected_formatted_code = textwrap.dedent(u"""\ def A(): pass diff --git a/yapftests/comment_splicer_test.py b/yapftests/comment_splicer_test.py index 985ea88b7..2e0141bd4 100644 --- a/yapftests/comment_splicer_test.py +++ b/yapftests/comment_splicer_test.py @@ -38,8 +38,9 @@ def _AssertNodeIsComment(self, node, text_in_comment=None): self.assertIn(text_in_comment, node_value) def _FindNthChildNamed(self, node, name, n=1): - for i, child in enumerate(py3compat.ifilter( - lambda c: pytree_utils.NodeName(c) == name, node.pre_order())): + for i, child in enumerate( + py3compat.ifilter(lambda c: pytree_utils.NodeName(c) == name, + node.pre_order())): if i == n - 1: return child raise RuntimeError('No Nth child for n={0}'.format(n)) @@ -58,8 +59,7 @@ def testSimpleInline(self): self._AssertNodeIsComment(comment_node, '# and a comment') def testSimpleSeparateLine(self): - code = textwrap.dedent( - r''' + code = textwrap.dedent(r''' foo = 1 # first comment bar = 2 @@ -74,8 +74,7 @@ def testSimpleSeparateLine(self): self._AssertNodeIsComment(comment_node) def testTwoLineComment(self): - code = textwrap.dedent( - r''' + code = textwrap.dedent(r''' foo = 1 # first comment # second comment @@ -89,8 +88,7 @@ def testTwoLineComment(self): self._AssertNodeIsComment(tree.children[1]) def testCommentIsFirstChildInCompound(self): - code = textwrap.dedent( - r''' + code = textwrap.dedent(r''' if x: # a comment foo = 1 @@ -106,8 +104,7 @@ def testCommentIsFirstChildInCompound(self): self._AssertNodeIsComment(if_suite.children[1]) def testCommentIsLastChildInCompound(self): - code = textwrap.dedent( - r''' + code = textwrap.dedent(r''' if x: foo = 1 # a comment @@ -123,8 +120,7 @@ def testCommentIsLastChildInCompound(self): self._AssertNodeIsComment(if_suite.children[-2]) def testInlineAfterSeparateLine(self): - code = textwrap.dedent( - r''' + code = textwrap.dedent(r''' bar = 1 # line comment foo = 1 # inline comment @@ -137,13 +133,12 @@ def testInlineAfterSeparateLine(self): sep_comment_node = tree.children[1] self._AssertNodeIsComment(sep_comment_node, '# line comment') - expr = tree.children[2].children[0] + expr = tree.children[2].children[0] inline_comment_node = expr.children[-1] self._AssertNodeIsComment(inline_comment_node, '# inline comment') def testSeparateLineAfterInline(self): - code = textwrap.dedent( - r''' + code = textwrap.dedent(r''' bar = 1 foo = 1 # inline comment # line comment @@ -156,13 +151,12 @@ def testSeparateLineAfterInline(self): sep_comment_node = tree.children[-2] self._AssertNodeIsComment(sep_comment_node, '# line comment') - expr = tree.children[1].children[0] + expr = tree.children[1].children[0] inline_comment_node = expr.children[-1] self._AssertNodeIsComment(inline_comment_node, '# inline comment') def testCommentBeforeDedent(self): - code = textwrap.dedent( - r''' + code = textwrap.dedent(r''' if bar: z = 1 # a comment @@ -177,8 +171,7 @@ def testCommentBeforeDedent(self): self._AssertNodeType('DEDENT', if_suite.children[-1]) def testCommentBeforeDedentTwoLevel(self): - code = textwrap.dedent( - r''' + code = textwrap.dedent(r''' if foo: if bar: z = 1 @@ -195,8 +188,7 @@ def testCommentBeforeDedentTwoLevel(self): self._AssertNodeType('DEDENT', if_suite.children[-1]) def testCommentBeforeDedentTwoLevelImproperlyIndented(self): - code = textwrap.dedent( - r''' + code = textwrap.dedent(r''' if foo: if bar: z = 1 @@ -216,8 +208,7 @@ def testCommentBeforeDedentTwoLevelImproperlyIndented(self): self._AssertNodeType('DEDENT', if_suite.children[-1]) def testCommentBeforeDedentThreeLevel(self): - code = textwrap.dedent( - r''' + code = textwrap.dedent(r''' if foo: if bar: z = 1 @@ -244,8 +235,7 @@ def testCommentBeforeDedentThreeLevel(self): self._AssertNodeType('DEDENT', if_suite_2.children[-1]) def testCommentsInClass(self): - code = textwrap.dedent( - r''' + code = textwrap.dedent(r''' class Foo: """docstring abc...""" # top-level comment @@ -256,19 +246,18 @@ def foo(): pass tree = pytree_utils.ParseCodeToTree(code) comment_splicer.SpliceComments(tree) - class_suite = tree.children[0].children[3] + class_suite = tree.children[0].children[3] another_comment = class_suite.children[-2] self._AssertNodeIsComment(another_comment, '# another') # It's OK for the comment to be a child of funcdef, as long as it's # the first child and thus comes before the 'def'. - funcdef = class_suite.children[3] + funcdef = class_suite.children[3] toplevel_comment = funcdef.children[0] self._AssertNodeIsComment(toplevel_comment, '# top-level') def testMultipleBlockComments(self): - code = textwrap.dedent( - r''' + code = textwrap.dedent(r''' # Block comment number 1 # Block comment number 2 @@ -279,7 +268,7 @@ def f(): tree = pytree_utils.ParseCodeToTree(code) comment_splicer.SpliceComments(tree) - funcdef = tree.children[0] + funcdef = tree.children[0] block_comment_1 = funcdef.children[0] self._AssertNodeIsComment(block_comment_1, '# Block comment number 1') @@ -287,8 +276,7 @@ def f(): self._AssertNodeIsComment(block_comment_2, '# Block comment number 2') def testCommentsOnDedents(self): - code = textwrap.dedent( - r''' + code = textwrap.dedent(r''' class Foo(object): # A comment for qux. def qux(self): @@ -303,7 +291,7 @@ def mux(self): tree = pytree_utils.ParseCodeToTree(code) comment_splicer.SpliceComments(tree) - classdef = tree.children[0] + classdef = tree.children[0] class_suite = classdef.children[6] qux_comment = class_suite.children[1] self._AssertNodeIsComment(qux_comment, '# A comment for qux.') @@ -312,8 +300,7 @@ def mux(self): self._AssertNodeIsComment(interim_comment, '# Interim comment.') def testExprComments(self): - code = textwrap.dedent( - r''' + code = textwrap.dedent(r''' foo( # Request fractions of an hour. 948.0/3600, 20) ''') @@ -325,8 +312,7 @@ def testExprComments(self): self._AssertNodeIsComment(comment, '# Request fractions of an hour.') def testMultipleCommentsInOneExpr(self): - code = textwrap.dedent( - r''' + code = textwrap.dedent(r''' foo( # com 1 948.0/3600, # com 2 20 + 12 # com 3 diff --git a/yapftests/file_resources_test.py b/yapftests/file_resources_test.py index eb9a3cd3b..31184c4a3 100644 --- a/yapftests/file_resources_test.py +++ b/yapftests/file_resources_test.py @@ -56,7 +56,7 @@ def tearDown(self): # pylint: disable=g-missing-super-call def test_get_exclude_file_patterns_from_yapfignore(self): local_ignore_file = os.path.join(self.test_tmpdir, '.yapfignore') - ignore_patterns = ['temp/**/*.py', 'temp2/*.py'] + ignore_patterns = ['temp/**/*.py', 'temp2/*.py'] with open(local_ignore_file, 'w') as f: f.writelines('\n'.join(ignore_patterns)) @@ -66,7 +66,7 @@ def test_get_exclude_file_patterns_from_yapfignore(self): def test_get_exclude_file_patterns_from_yapfignore_with_wrong_syntax(self): local_ignore_file = os.path.join(self.test_tmpdir, '.yapfignore') - ignore_patterns = ['temp/**/*.py', './wrong/syntax/*.py'] + ignore_patterns = ['temp/**/*.py', './wrong/syntax/*.py'] with open(local_ignore_file, 'w') as f: f.writelines('\n'.join(ignore_patterns)) @@ -79,7 +79,7 @@ def test_get_exclude_file_patterns_from_pyproject(self): except ImportError: return local_ignore_file = os.path.join(self.test_tmpdir, 'pyproject.toml') - ignore_patterns = ['temp/**/*.py', 'temp2/*.py'] + ignore_patterns = ['temp/**/*.py', 'temp2/*.py'] with open(local_ignore_file, 'w') as f: f.write('[tool.yapfignore]\n') f.write('ignore_patterns=[') @@ -97,7 +97,7 @@ def test_get_exclude_file_patterns_from_pyproject_with_wrong_syntax(self): except ImportError: return local_ignore_file = os.path.join(self.test_tmpdir, 'pyproject.toml') - ignore_patterns = ['temp/**/*.py', './wrong/syntax/*.py'] + ignore_patterns = ['temp/**/*.py', './wrong/syntax/*.py'] with open(local_ignore_file, 'w') as f: f.write('[tool.yapfignore]\n') f.write('ignore_patterns=[') @@ -113,7 +113,7 @@ def test_get_exclude_file_patterns_from_pyproject_no_ignore_section(self): except ImportError: return local_ignore_file = os.path.join(self.test_tmpdir, 'pyproject.toml') - ignore_patterns = [] + ignore_patterns = [] open(local_ignore_file, 'w').close() self.assertEqual( @@ -126,7 +126,7 @@ def test_get_exclude_file_patterns_from_pyproject_ignore_section_empty(self): except ImportError: return local_ignore_file = os.path.join(self.test_tmpdir, 'pyproject.toml') - ignore_patterns = [] + ignore_patterns = [] with open(local_ignore_file, 'w') as f: f.write('[tool.yapfignore]\n') @@ -151,12 +151,12 @@ def tearDown(self): # pylint: disable=g-missing-super-call shutil.rmtree(self.test_tmpdir) def test_no_local_style(self): - test_file = os.path.join(self.test_tmpdir, 'file.py') + test_file = os.path.join(self.test_tmpdir, 'file.py') style_name = file_resources.GetDefaultStyleForDir(test_file) self.assertEqual(style_name, 'pep8') def test_no_local_style_custom_default(self): - test_file = os.path.join(self.test_tmpdir, 'file.py') + test_file = os.path.join(self.test_tmpdir, 'file.py') style_name = file_resources.GetDefaultStyleForDir( test_file, default_style='custom-default') self.assertEqual(style_name, 'custom-default') @@ -167,27 +167,27 @@ def test_with_local_style(self): open(style_file, 'w').close() test_filename = os.path.join(self.test_tmpdir, 'file.py') - self.assertEqual( - style_file, file_resources.GetDefaultStyleForDir(test_filename)) + self.assertEqual(style_file, + file_resources.GetDefaultStyleForDir(test_filename)) test_filename = os.path.join(self.test_tmpdir, 'dir1', 'file.py') - self.assertEqual( - style_file, file_resources.GetDefaultStyleForDir(test_filename)) + self.assertEqual(style_file, + file_resources.GetDefaultStyleForDir(test_filename)) def test_setup_config(self): # An empty setup.cfg file should not be used setup_config = os.path.join(self.test_tmpdir, 'setup.cfg') open(setup_config, 'w').close() - test_dir = os.path.join(self.test_tmpdir, 'dir1') + test_dir = os.path.join(self.test_tmpdir, 'dir1') style_name = file_resources.GetDefaultStyleForDir(test_dir) self.assertEqual(style_name, 'pep8') # One with a '[yapf]' section should be used with open(setup_config, 'w') as f: f.write('[yapf]\n') - self.assertEqual( - setup_config, file_resources.GetDefaultStyleForDir(test_dir)) + self.assertEqual(setup_config, + file_resources.GetDefaultStyleForDir(test_dir)) def test_pyproject_toml(self): # An empty pyproject.toml file should not be used @@ -199,20 +199,20 @@ def test_pyproject_toml(self): pyproject_toml = os.path.join(self.test_tmpdir, 'pyproject.toml') open(pyproject_toml, 'w').close() - test_dir = os.path.join(self.test_tmpdir, 'dir1') + test_dir = os.path.join(self.test_tmpdir, 'dir1') style_name = file_resources.GetDefaultStyleForDir(test_dir) self.assertEqual(style_name, 'pep8') # One with a '[tool.yapf]' section should be used with open(pyproject_toml, 'w') as f: f.write('[tool.yapf]\n') - self.assertEqual( - pyproject_toml, file_resources.GetDefaultStyleForDir(test_dir)) + self.assertEqual(pyproject_toml, + file_resources.GetDefaultStyleForDir(test_dir)) def test_local_style_at_root(self): # Test behavior of files located on the root, and under root. - rootdir = os.path.abspath(os.path.sep) - test_dir_at_root = os.path.join(rootdir, 'dir1') + rootdir = os.path.abspath(os.path.sep) + test_dir_at_root = os.path.join(rootdir, 'dir1') test_dir_under_root = os.path.join(rootdir, 'dir1', 'dir2') # Fake placing only a style file at the root by mocking `os.path.exists`. @@ -241,7 +241,7 @@ class GetCommandLineFilesTest(unittest.TestCase): def setUp(self): # pylint: disable=g-missing-super-call self.test_tmpdir = tempfile.mkdtemp() - self.old_dir = os.getcwd() + self.old_dir = os.getcwd() def tearDown(self): # pylint: disable=g-missing-super-call os.chdir(self.old_dir) @@ -260,11 +260,13 @@ def test_find_files_not_dirs(self): _touch_files([file1, file2]) self.assertEqual( - file_resources.GetCommandLineFiles( - [file1, file2], recursive=False, exclude=None), [file1, file2]) + file_resources.GetCommandLineFiles([file1, file2], + recursive=False, + exclude=None), [file1, file2]) self.assertEqual( - file_resources.GetCommandLineFiles( - [file1, file2], recursive=True, exclude=None), [file1, file2]) + file_resources.GetCommandLineFiles([file1, file2], + recursive=True, + exclude=None), [file1, file2]) def test_nonrecursive_find_in_dir(self): tdir1 = self._make_test_dir('test1') @@ -276,9 +278,9 @@ def test_nonrecursive_find_in_dir(self): self.assertRaises( errors.YapfError, file_resources.GetCommandLineFiles, - command_line_file_list =[tdir1], - recursive =False, - exclude =None) + command_line_file_list=[tdir1], + recursive=False, + exclude=None) def test_recursive_find_in_dir(self): tdir1 = self._make_test_dir('test1') @@ -293,9 +295,9 @@ def test_recursive_find_in_dir(self): self.assertEqual( sorted( - file_resources.GetCommandLineFiles( - [self.test_tmpdir], recursive=True, exclude=None)), - sorted(files)) + file_resources.GetCommandLineFiles([self.test_tmpdir], + recursive=True, + exclude=None)), sorted(files)) def test_recursive_find_in_dir_with_exclude(self): tdir1 = self._make_test_dir('test1') @@ -310,13 +312,13 @@ def test_recursive_find_in_dir_with_exclude(self): self.assertEqual( sorted( - file_resources.GetCommandLineFiles( - [self.test_tmpdir], recursive=True, exclude=['*test*3.py'])), - sorted( - [ - os.path.join(tdir1, 'testfile1.py'), - os.path.join(tdir2, 'testfile2.py'), - ])) + file_resources.GetCommandLineFiles([self.test_tmpdir], + recursive=True, + exclude=['*test*3.py'])), + sorted([ + os.path.join(tdir1, 'testfile1.py'), + os.path.join(tdir2, 'testfile2.py'), + ])) def test_find_with_excluded_hidden_dirs(self): tdir1 = self._make_test_dir('.test1') @@ -329,16 +331,16 @@ def test_find_with_excluded_hidden_dirs(self): ] _touch_files(files) - actual = file_resources.GetCommandLineFiles( - [self.test_tmpdir], recursive=True, exclude=['*.test1*']) + actual = file_resources.GetCommandLineFiles([self.test_tmpdir], + recursive=True, + exclude=['*.test1*']) self.assertEqual( sorted(actual), - sorted( - [ - os.path.join(tdir2, 'testfile2.py'), - os.path.join(tdir3, 'testfile3.py'), - ])) + sorted([ + os.path.join(tdir2, 'testfile2.py'), + os.path.join(tdir3, 'testfile3.py'), + ])) def test_find_with_excluded_hidden_dirs_relative(self): """Test find with excluded hidden dirs. @@ -368,20 +370,19 @@ def test_find_with_excluded_hidden_dirs_relative(self): os.chdir(self.test_tmpdir) actual = file_resources.GetCommandLineFiles( [os.path.relpath(self.test_tmpdir)], - recursive =True, - exclude =['*.test1*']) + recursive=True, + exclude=['*.test1*']) self.assertEqual( sorted(actual), - sorted( - [ - os.path.join( - os.path.relpath(self.test_tmpdir), - os.path.basename(tdir2), 'testfile2.py'), - os.path.join( - os.path.relpath(self.test_tmpdir), - os.path.basename(tdir3), 'testfile3.py'), - ])) + sorted([ + os.path.join( + os.path.relpath(self.test_tmpdir), os.path.basename(tdir2), + 'testfile2.py'), + os.path.join( + os.path.relpath(self.test_tmpdir), os.path.basename(tdir3), + 'testfile3.py'), + ])) def test_find_with_excluded_dirs(self): tdir1 = self._make_test_dir('test1') @@ -397,23 +398,23 @@ def test_find_with_excluded_dirs(self): os.chdir(self.test_tmpdir) found = sorted( - file_resources.GetCommandLineFiles( - ['test1', 'test2', 'test3'], - recursive =True, - exclude =[ - 'test1', - 'test2/testinner/', - ])) + file_resources.GetCommandLineFiles(['test1', 'test2', 'test3'], + recursive=True, + exclude=[ + 'test1', + 'test2/testinner/', + ])) self.assertEqual( found, ['test3/foo/bar/bas/xxx/testfile3.py'.replace("/", os.path.sep)]) found = sorted( - file_resources.GetCommandLineFiles( - ['.'], recursive=True, exclude=[ - 'test1', - 'test3', - ])) + file_resources.GetCommandLineFiles(['.'], + recursive=True, + exclude=[ + 'test1', + 'test3', + ])) self.assertEqual( found, ['./test2/testinner/testfile2.py'.replace("/", os.path.sep)]) @@ -516,7 +517,7 @@ def test_write_to_file(self): self.assertEqual(f2.read(), s) def test_write_to_stdout(self): - s = u'foobar' + s = u'foobar' stream = BufferedByteStream() if py3compat.PY3 else py3compat.StringIO() with utils.stdout_redirector(stream): file_resources.WriteReformattedCode( @@ -524,7 +525,7 @@ def test_write_to_stdout(self): self.assertEqual(stream.getvalue(), s) def test_write_encoded_to_stdout(self): - s = '\ufeff# -*- coding: utf-8 -*-\nresult = "passed"\n' # pylint: disable=anomalous-unicode-escape-in-string # noqa + s = '\ufeff# -*- coding: utf-8 -*-\nresult = "passed"\n' # pylint: disable=anomalous-unicode-escape-in-string # noqa stream = BufferedByteStream() if py3compat.PY3 else py3compat.StringIO() with utils.stdout_redirector(stream): file_resources.WriteReformattedCode( @@ -535,17 +536,17 @@ def test_write_encoded_to_stdout(self): class LineEndingTest(unittest.TestCase): def test_line_ending_linefeed(self): - lines = ['spam\n', 'spam\n'] + lines = ['spam\n', 'spam\n'] actual = file_resources.LineEnding(lines) self.assertEqual(actual, '\n') def test_line_ending_carriage_return(self): - lines = ['spam\r', 'spam\r'] + lines = ['spam\r', 'spam\r'] actual = file_resources.LineEnding(lines) self.assertEqual(actual, '\r') def test_line_ending_combo(self): - lines = ['spam\r\n', 'spam\r\n'] + lines = ['spam\r\n', 'spam\r\n'] actual = file_resources.LineEnding(lines) self.assertEqual(actual, '\r\n') diff --git a/yapftests/format_decision_state_test.py b/yapftests/format_decision_state_test.py index d9cdefe8c..63961f332 100644 --- a/yapftests/format_decision_state_test.py +++ b/yapftests/format_decision_state_test.py @@ -32,12 +32,12 @@ def setUpClass(cls): style.SetGlobalStyle(style.CreateYapfStyle()) def testSimpleFunctionDefWithNoSplitting(self): - code = textwrap.dedent(r""" + code = textwrap.dedent(r""" def f(a, b): pass """) llines = yapf_test_helper.ParseAndUnwrap(code) - lline = logical_line.LogicalLine(0, _FilterLine(llines[0])) + lline = logical_line.LogicalLine(0, _FilterLine(llines[0])) lline.CalculateFormattingInformation() # Add: 'f' @@ -86,12 +86,12 @@ def f(a, b): self.assertEqual(repr(state), repr(clone)) def testSimpleFunctionDefWithSplitting(self): - code = textwrap.dedent(r""" + code = textwrap.dedent(r""" def f(a, b): pass """) llines = yapf_test_helper.ParseAndUnwrap(code) - lline = logical_line.LogicalLine(0, _FilterLine(llines[0])) + lline = logical_line.LogicalLine(0, _FilterLine(llines[0])) lline.CalculateFormattingInformation() # Add: 'f' diff --git a/yapftests/format_token_test.py b/yapftests/format_token_test.py index 4ec46f69f..3bb1ce9f5 100644 --- a/yapftests/format_token_test.py +++ b/yapftests/format_token_test.py @@ -95,23 +95,22 @@ def testIsMultilineString(self): # a='hello world', # # comment, # b='') - child1 = pytree.Leaf(token.NAME, 'a') - child2 = pytree.Leaf(token.EQUAL, '=') - child3 = pytree.Leaf(token.STRING, "'hello world'") - child4 = pytree.Leaf(token.COMMA, ',') - child5 = pytree.Leaf(token.COMMENT, '# comment') - child6 = pytree.Leaf(token.COMMA, ',') - child7 = pytree.Leaf(token.NAME, 'b') - child8 = pytree.Leaf(token.EQUAL, '=') - child9 = pytree.Leaf(token.STRING, "''") + child1 = pytree.Leaf(token.NAME, 'a') + child2 = pytree.Leaf(token.EQUAL, '=') + child3 = pytree.Leaf(token.STRING, "'hello world'") + child4 = pytree.Leaf(token.COMMA, ',') + child5 = pytree.Leaf(token.COMMENT,'# comment') + child6 = pytree.Leaf(token.COMMA, ',') + child7 = pytree.Leaf(token.NAME, 'b') + child8 = pytree.Leaf(token.EQUAL, '=') + child9 = pytree.Leaf(token.STRING, "''") node_type = pygram.python_grammar.symbol2number['arglist'] - node = pytree.Node( - node_type, - [child1, child2, child3, child4, child5, child6, child7, child8, child9]) + node = pytree.Node(node_type, [child1, child2, child3, child4, child5, + child6, child7, child8,child9]) subtype_assigner.AssignSubtypes(node) def testIsArgName(self, node=node): - tok = format_token.FormatToken(node.children[0], 'NAME') + tok = format_token.FormatToken(node.children[0],'NAME') self.assertTrue(tok.is_argname) def testIsArgAssign(self, node=node): @@ -123,6 +122,5 @@ def testCommentNotIsArgName(self, node=node): tok = format_token.FormatToken(node.children[4], 'COMMENT') self.assertFalse(tok.is_argname) - if __name__ == '__main__': unittest.main() diff --git a/yapftests/line_joiner_test.py b/yapftests/line_joiner_test.py index ea6186693..2eaf16478 100644 --- a/yapftests/line_joiner_test.py +++ b/yapftests/line_joiner_test.py @@ -39,23 +39,20 @@ def _CheckLineJoining(self, code, join_lines): self.assertCodeEqual(line_joiner.CanMergeMultipleLines(llines), join_lines) def testSimpleSingleLineStatement(self): - code = textwrap.dedent( - u"""\ + code = textwrap.dedent(u"""\ if isinstance(a, int): continue """) self._CheckLineJoining(code, join_lines=True) def testSimpleMultipleLineStatement(self): - code = textwrap.dedent( - u"""\ + code = textwrap.dedent(u"""\ if isinstance(b, int): continue """) self._CheckLineJoining(code, join_lines=False) def testSimpleMultipleLineComplexStatement(self): - code = textwrap.dedent( - u"""\ + code = textwrap.dedent(u"""\ if isinstance(c, int): while True: continue @@ -63,22 +60,19 @@ def testSimpleMultipleLineComplexStatement(self): self._CheckLineJoining(code, join_lines=False) def testSimpleMultipleLineStatementWithComment(self): - code = textwrap.dedent( - u"""\ + code = textwrap.dedent(u"""\ if isinstance(d, int): continue # We're pleased that d's an int. """) self._CheckLineJoining(code, join_lines=True) def testSimpleMultipleLineStatementWithLargeIndent(self): - code = textwrap.dedent( - u"""\ + code = textwrap.dedent(u"""\ if isinstance(e, int): continue """) self._CheckLineJoining(code, join_lines=True) def testOverColumnLimit(self): - code = textwrap.dedent( - u"""\ + code = textwrap.dedent(u"""\ if instance(bbbbbbbbbbbbbbbbbbbbbbbbb, int): cccccccccccccccccccccccccc = ddddddddddddddddddddd """) # noqa self._CheckLineJoining(code, join_lines=False) diff --git a/yapftests/logical_line_test.py b/yapftests/logical_line_test.py index 695f88bd5..d18262a7c 100644 --- a/yapftests/logical_line_test.py +++ b/yapftests/logical_line_test.py @@ -29,29 +29,25 @@ class LogicalLineBasicTest(unittest.TestCase): def testConstruction(self): - toks = _MakeFormatTokenList( - [(token.DOT, '.', 'DOT'), (token.VBAR, '|', 'VBAR')]) + toks = _MakeFormatTokenList([(token.DOT, '.', 'DOT'), + (token.VBAR, '|', 'VBAR')]) lline = logical_line.LogicalLine(20, toks) self.assertEqual(20, lline.depth) self.assertEqual(['DOT', 'VBAR'], [tok.name for tok in lline.tokens]) def testFirstLast(self): - toks = _MakeFormatTokenList( - [ - (token.DOT, '.', 'DOT'), (token.LPAR, '(', 'LPAR'), - (token.VBAR, '|', 'VBAR') - ]) + toks = _MakeFormatTokenList([(token.DOT, '.', 'DOT'), + (token.LPAR, '(', 'LPAR'), + (token.VBAR, '|', 'VBAR')]) lline = logical_line.LogicalLine(20, toks) self.assertEqual(20, lline.depth) self.assertEqual('DOT', lline.first.name) self.assertEqual('VBAR', lline.last.name) def testAsCode(self): - toks = _MakeFormatTokenList( - [ - (token.DOT, '.', 'DOT'), (token.LPAR, '(', 'LPAR'), - (token.VBAR, '|', 'VBAR') - ]) + toks = _MakeFormatTokenList([(token.DOT, '.', 'DOT'), + (token.LPAR, '(', 'LPAR'), + (token.VBAR, '|', 'VBAR')]) lline = logical_line.LogicalLine(2, toks) self.assertEqual(' . ( |', lline.AsCode()) @@ -65,7 +61,7 @@ def testAppendToken(self): class LogicalLineFormattingInformationTest(yapf_test_helper.YAPFTest): def testFuncDef(self): - code = textwrap.dedent(r""" + code = textwrap.dedent(r""" def f(a, b): pass """) diff --git a/yapftests/main_test.py b/yapftests/main_test.py index ea6892f5a..c83b8b66a 100644 --- a/yapftests/main_test.py +++ b/yapftests/main_test.py @@ -78,7 +78,7 @@ def patch_raw_input(lines=lines()): return next(lines) try: - orig_raw_import = yapf.py3compat.raw_input + orig_raw_import = yapf.py3compat.raw_input yapf.py3compat.raw_input = patch_raw_input yield finally: @@ -90,7 +90,7 @@ class RunMainTest(yapf_test_helper.YAPFTest): def testShouldHandleYapfError(self): """run_main should handle YapfError and sys.exit(1).""" expected_message = 'yapf: input filenames did not match any python files\n' - sys.argv = ['yapf', 'foo.c'] + sys.argv = ['yapf', 'foo.c'] with captured_output() as (out, err): with self.assertRaises(SystemExit): yapf.run_main() @@ -114,7 +114,7 @@ def testEchoInput(self): self.assertEqual(out.getvalue(), code) def testEchoInputWithStyle(self): - code = 'def f(a = 1\n\n):\n return 2*a\n' + code = 'def f(a = 1\n\n):\n return 2*a\n' yapf_code = 'def f(a=1):\n return 2 * a\n' with patched_input(code): with captured_output() as (out, _): @@ -135,6 +135,5 @@ def testHelp(self): self.assertEqual(ret, 0) help_message = out.getvalue() self.assertIn('indent_width=4', help_message) - self.assertIn( - 'The number of spaces required before a trailing comment.', - help_message) + self.assertIn('The number of spaces required before a trailing comment.', + help_message) diff --git a/yapftests/pytree_unwrapper_test.py b/yapftests/pytree_unwrapper_test.py index cd67e0de1..525278def 100644 --- a/yapftests/pytree_unwrapper_test.py +++ b/yapftests/pytree_unwrapper_test.py @@ -43,79 +43,69 @@ def _CheckLogicalLines(self, llines, list_of_expected): self.assertEqual(list_of_expected, actual) def testSimpleFileScope(self): - code = textwrap.dedent( - r""" + code = textwrap.dedent(r""" x = 1 # a comment y = 2 """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckLogicalLines( - llines, [ - (0, ['x', '=', '1']), - (0, ['# a comment']), - (0, ['y', '=', '2']), - ]) + self._CheckLogicalLines(llines, [ + (0, ['x', '=', '1']), + (0, ['# a comment']), + (0, ['y', '=', '2']), + ]) def testSimpleMultilineStatement(self): - code = textwrap.dedent(r""" + code = textwrap.dedent(r""" y = (1 + x) """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckLogicalLines( - llines, [ - (0, ['y', '=', '(', '1', '+', 'x', ')']), - ]) + self._CheckLogicalLines(llines, [ + (0, ['y', '=', '(', '1', '+', 'x', ')']), + ]) def testFileScopeWithInlineComment(self): - code = textwrap.dedent( - r""" + code = textwrap.dedent(r""" x = 1 # a comment y = 2 """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckLogicalLines( - llines, [ - (0, ['x', '=', '1', '# a comment']), - (0, ['y', '=', '2']), - ]) + self._CheckLogicalLines(llines, [ + (0, ['x', '=', '1', '# a comment']), + (0, ['y', '=', '2']), + ]) def testSimpleIf(self): - code = textwrap.dedent( - r""" + code = textwrap.dedent(r""" if foo: x = 1 y = 2 """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckLogicalLines( - llines, [ - (0, ['if', 'foo', ':']), - (1, ['x', '=', '1']), - (1, ['y', '=', '2']), - ]) + self._CheckLogicalLines(llines, [ + (0, ['if', 'foo', ':']), + (1, ['x', '=', '1']), + (1, ['y', '=', '2']), + ]) def testSimpleIfWithComments(self): - code = textwrap.dedent( - r""" + code = textwrap.dedent(r""" # c1 if foo: # c2 x = 1 y = 2 """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckLogicalLines( - llines, [ - (0, ['# c1']), - (0, ['if', 'foo', ':', '# c2']), - (1, ['x', '=', '1']), - (1, ['y', '=', '2']), - ]) + self._CheckLogicalLines(llines, [ + (0, ['# c1']), + (0, ['if', 'foo', ':', '# c2']), + (1, ['x', '=', '1']), + (1, ['y', '=', '2']), + ]) def testIfWithCommentsInside(self): - code = textwrap.dedent( - r""" + code = textwrap.dedent(r""" if foo: # c1 x = 1 # c2 @@ -123,18 +113,16 @@ def testIfWithCommentsInside(self): y = 2 """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckLogicalLines( - llines, [ - (0, ['if', 'foo', ':']), - (1, ['# c1']), - (1, ['x', '=', '1', '# c2']), - (1, ['# c3']), - (1, ['y', '=', '2']), - ]) + self._CheckLogicalLines(llines, [ + (0, ['if', 'foo', ':']), + (1, ['# c1']), + (1, ['x', '=', '1', '# c2']), + (1, ['# c3']), + (1, ['y', '=', '2']), + ]) def testIfElifElse(self): - code = textwrap.dedent( - r""" + code = textwrap.dedent(r""" if x: x = 1 # c1 elif y: # c2 @@ -144,20 +132,18 @@ def testIfElifElse(self): z = 1 """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckLogicalLines( - llines, [ - (0, ['if', 'x', ':']), - (1, ['x', '=', '1', '# c1']), - (0, ['elif', 'y', ':', '# c2']), - (1, ['y', '=', '1']), - (0, ['else', ':']), - (1, ['# c3']), - (1, ['z', '=', '1']), - ]) + self._CheckLogicalLines(llines, [ + (0, ['if', 'x', ':']), + (1, ['x', '=', '1', '# c1']), + (0, ['elif', 'y', ':', '# c2']), + (1, ['y', '=', '1']), + (0, ['else', ':']), + (1, ['# c3']), + (1, ['z', '=', '1']), + ]) def testNestedCompoundTwoLevel(self): - code = textwrap.dedent( - r""" + code = textwrap.dedent(r""" if x: x = 1 # c1 while t: @@ -166,34 +152,30 @@ def testNestedCompoundTwoLevel(self): k = 1 """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckLogicalLines( - llines, [ - (0, ['if', 'x', ':']), - (1, ['x', '=', '1', '# c1']), - (1, ['while', 't', ':']), - (2, ['# c2']), - (2, ['j', '=', '1']), - (1, ['k', '=', '1']), - ]) + self._CheckLogicalLines(llines, [ + (0, ['if', 'x', ':']), + (1, ['x', '=', '1', '# c1']), + (1, ['while', 't', ':']), + (2, ['# c2']), + (2, ['j', '=', '1']), + (1, ['k', '=', '1']), + ]) def testSimpleWhile(self): - code = textwrap.dedent( - r""" + code = textwrap.dedent(r""" while x > 1: # c1 # c2 x = 1 """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckLogicalLines( - llines, [ - (0, ['while', 'x', '>', '1', ':', '# c1']), - (1, ['# c2']), - (1, ['x', '=', '1']), - ]) + self._CheckLogicalLines(llines, [ + (0, ['while', 'x', '>', '1', ':', '# c1']), + (1, ['# c2']), + (1, ['x', '=', '1']), + ]) def testSimpleTry(self): - code = textwrap.dedent( - r""" + code = textwrap.dedent(r""" try: pass except: @@ -206,38 +188,34 @@ def testSimpleTry(self): pass """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckLogicalLines( - llines, [ - (0, ['try', ':']), - (1, ['pass']), - (0, ['except', ':']), - (1, ['pass']), - (0, ['except', ':']), - (1, ['pass']), - (0, ['else', ':']), - (1, ['pass']), - (0, ['finally', ':']), - (1, ['pass']), - ]) + self._CheckLogicalLines(llines, [ + (0, ['try', ':']), + (1, ['pass']), + (0, ['except', ':']), + (1, ['pass']), + (0, ['except', ':']), + (1, ['pass']), + (0, ['else', ':']), + (1, ['pass']), + (0, ['finally', ':']), + (1, ['pass']), + ]) def testSimpleFuncdef(self): - code = textwrap.dedent( - r""" + code = textwrap.dedent(r""" def foo(x): # c1 # c2 return x """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckLogicalLines( - llines, [ - (0, ['def', 'foo', '(', 'x', ')', ':', '# c1']), - (1, ['# c2']), - (1, ['return', 'x']), - ]) + self._CheckLogicalLines(llines, [ + (0, ['def', 'foo', '(', 'x', ')', ':', '# c1']), + (1, ['# c2']), + (1, ['return', 'x']), + ]) def testTwoFuncDefs(self): - code = textwrap.dedent( - r""" + code = textwrap.dedent(r""" def foo(x): # c1 # c2 return x @@ -247,45 +225,40 @@ def bar(): # c3 return x """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckLogicalLines( - llines, [ - (0, ['def', 'foo', '(', 'x', ')', ':', '# c1']), - (1, ['# c2']), - (1, ['return', 'x']), - (0, ['def', 'bar', '(', ')', ':', '# c3']), - (1, ['# c4']), - (1, ['return', 'x']), - ]) + self._CheckLogicalLines(llines, [ + (0, ['def', 'foo', '(', 'x', ')', ':', '# c1']), + (1, ['# c2']), + (1, ['return', 'x']), + (0, ['def', 'bar', '(', ')', ':', '# c3']), + (1, ['# c4']), + (1, ['return', 'x']), + ]) def testSimpleClassDef(self): - code = textwrap.dedent( - r""" + code = textwrap.dedent(r""" class Klass: # c1 # c2 p = 1 """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckLogicalLines( - llines, [ - (0, ['class', 'Klass', ':', '# c1']), - (1, ['# c2']), - (1, ['p', '=', '1']), - ]) + self._CheckLogicalLines(llines, [ + (0, ['class', 'Klass', ':', '# c1']), + (1, ['# c2']), + (1, ['p', '=', '1']), + ]) def testSingleLineStmtInFunc(self): - code = textwrap.dedent(r""" + code = textwrap.dedent(r""" def f(): return 37 """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckLogicalLines( - llines, [ - (0, ['def', 'f', '(', ')', ':']), - (1, ['return', '37']), - ]) + self._CheckLogicalLines(llines, [ + (0, ['def', 'f', '(', ')', ':']), + (1, ['return', '37']), + ]) def testMultipleComments(self): - code = textwrap.dedent( - r""" + code = textwrap.dedent(r""" # Comment #1 # Comment #2 @@ -293,17 +266,15 @@ def f(): pass """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckLogicalLines( - llines, [ - (0, ['# Comment #1']), - (0, ['# Comment #2']), - (0, ['def', 'f', '(', ')', ':']), - (1, ['pass']), - ]) + self._CheckLogicalLines(llines, [ + (0, ['# Comment #1']), + (0, ['# Comment #2']), + (0, ['def', 'f', '(', ')', ':']), + (1, ['pass']), + ]) def testSplitListWithComment(self): - code = textwrap.dedent( - r""" + code = textwrap.dedent(r""" a = [ 'a', 'b', @@ -311,14 +282,9 @@ def testSplitListWithComment(self): ] """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckLogicalLines( - llines, [ - ( - 0, [ - 'a', '=', '[', "'a'", ',', "'b'", ',', "'c'", ',', - '# hello world', ']' - ]) - ]) + self._CheckLogicalLines(llines, [(0, [ + 'a', '=', '[', "'a'", ',', "'b'", ',', "'c'", ',', '# hello world', ']' + ])]) class MatchBracketsTest(yapf_test_helper.YAPFTest): @@ -334,11 +300,9 @@ def _CheckMatchingBrackets(self, llines, list_of_expected): """ actual = [] for lline in llines: - filtered_values = [ - (ft, ft.matching_bracket) - for ft in lline.tokens - if ft.name not in pytree_utils.NONSEMANTIC_TOKENS - ] + filtered_values = [(ft, ft.matching_bracket) + for ft in lline.tokens + if ft.name not in pytree_utils.NONSEMANTIC_TOKENS] if filtered_values: actual.append(filtered_values) @@ -353,8 +317,7 @@ def _CheckMatchingBrackets(self, llines, list_of_expected): self.assertEqual(lline[close_bracket][0], lline[open_bracket][1]) def testFunctionDef(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ def foo(a, b=['w','d'], c=[42, 37]): pass """) @@ -365,8 +328,7 @@ def foo(a, b=['w','d'], c=[42, 37]): ]) def testDecorator(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ @bar() def foo(a, b, c): pass @@ -379,8 +341,7 @@ def foo(a, b, c): ]) def testClassDef(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ class A(B, C, D): pass """) diff --git a/yapftests/pytree_utils_test.py b/yapftests/pytree_utils_test.py index ec61f75d2..c175f833e 100644 --- a/yapftests/pytree_utils_test.py +++ b/yapftests/pytree_utils_test.py @@ -25,7 +25,7 @@ # module. _GRAMMAR_SYMBOL2NUMBER = pygram.python_grammar.symbol2number -_FOO = 'foo' +_FOO = 'foo' _FOO1 = 'foo1' _FOO2 = 'foo2' _FOO3 = 'foo3' @@ -87,12 +87,12 @@ def _BuildSimpleTree(self): # simple_stmt: # NAME('foo') # - lpar1 = pytree.Leaf(token.LPAR, '(') - lpar2 = pytree.Leaf(token.LPAR, '(') - simple_stmt = pytree.Node( - _GRAMMAR_SYMBOL2NUMBER['simple_stmt'], [pytree.Leaf(token.NAME, 'foo')]) - return pytree.Node( - _GRAMMAR_SYMBOL2NUMBER['suite'], [lpar1, lpar2, simple_stmt]) + lpar1 = pytree.Leaf(token.LPAR, '(') + lpar2 = pytree.Leaf(token.LPAR, '(') + simple_stmt = pytree.Node(_GRAMMAR_SYMBOL2NUMBER['simple_stmt'], + [pytree.Leaf(token.NAME, 'foo')]) + return pytree.Node(_GRAMMAR_SYMBOL2NUMBER['suite'], + [lpar1, lpar2, simple_stmt]) def _MakeNewNodeRPAR(self): return pytree.Leaf(token.RPAR, ')') @@ -102,18 +102,18 @@ def setUp(self): def testInsertNodesBefore(self): # Insert before simple_stmt and make sure it went to the right place - pytree_utils.InsertNodesBefore( - [self._MakeNewNodeRPAR()], self._simple_tree.children[2]) + pytree_utils.InsertNodesBefore([self._MakeNewNodeRPAR()], + self._simple_tree.children[2]) self.assertEqual(4, len(self._simple_tree.children)) - self.assertEqual( - 'RPAR', pytree_utils.NodeName(self._simple_tree.children[2])) - self.assertEqual( - 'simple_stmt', pytree_utils.NodeName(self._simple_tree.children[3])) + self.assertEqual('RPAR', + pytree_utils.NodeName(self._simple_tree.children[2])) + self.assertEqual('simple_stmt', + pytree_utils.NodeName(self._simple_tree.children[3])) def testInsertNodesBeforeFirstChild(self): # Insert before the first child of its parent simple_stmt = self._simple_tree.children[2] - foo_child = simple_stmt.children[0] + foo_child = simple_stmt.children[0] pytree_utils.InsertNodesBefore([self._MakeNewNodeRPAR()], foo_child) self.assertEqual(3, len(self._simple_tree.children)) self.assertEqual(2, len(simple_stmt.children)) @@ -122,18 +122,18 @@ def testInsertNodesBeforeFirstChild(self): def testInsertNodesAfter(self): # Insert after and make sure it went to the right place - pytree_utils.InsertNodesAfter( - [self._MakeNewNodeRPAR()], self._simple_tree.children[2]) + pytree_utils.InsertNodesAfter([self._MakeNewNodeRPAR()], + self._simple_tree.children[2]) self.assertEqual(4, len(self._simple_tree.children)) - self.assertEqual( - 'simple_stmt', pytree_utils.NodeName(self._simple_tree.children[2])) - self.assertEqual( - 'RPAR', pytree_utils.NodeName(self._simple_tree.children[3])) + self.assertEqual('simple_stmt', + pytree_utils.NodeName(self._simple_tree.children[2])) + self.assertEqual('RPAR', + pytree_utils.NodeName(self._simple_tree.children[3])) def testInsertNodesAfterLastChild(self): # Insert after the last child of its parent simple_stmt = self._simple_tree.children[2] - foo_child = simple_stmt.children[0] + foo_child = simple_stmt.children[0] pytree_utils.InsertNodesAfter([self._MakeNewNodeRPAR()], foo_child) self.assertEqual(3, len(self._simple_tree.children)) self.assertEqual(2, len(simple_stmt.children)) @@ -143,16 +143,16 @@ def testInsertNodesAfterLastChild(self): def testInsertNodesWhichHasParent(self): # Try to insert an existing tree node into another place and fail. with self.assertRaises(RuntimeError): - pytree_utils.InsertNodesAfter( - [self._simple_tree.children[1]], self._simple_tree.children[0]) + pytree_utils.InsertNodesAfter([self._simple_tree.children[1]], + self._simple_tree.children[0]) class AnnotationsTest(unittest.TestCase): def setUp(self): self._leaf = pytree.Leaf(token.LPAR, '(') - self._node = pytree.Node( - _GRAMMAR_SYMBOL2NUMBER['simple_stmt'], [pytree.Leaf(token.NAME, 'foo')]) + self._node = pytree.Node(_GRAMMAR_SYMBOL2NUMBER['simple_stmt'], + [pytree.Leaf(token.NAME, 'foo')]) def testGetWhenNone(self): self.assertIsNone(pytree_utils.GetNodeAnnotation(self._leaf, _FOO)) @@ -183,18 +183,18 @@ def testMultiple(self): self.assertEqual(pytree_utils.GetNodeAnnotation(self._leaf, _FOO5), 5) def testSubtype(self): - pytree_utils.AppendNodeAnnotation( - self._leaf, pytree_utils.Annotation.SUBTYPE, _FOO) + pytree_utils.AppendNodeAnnotation(self._leaf, + pytree_utils.Annotation.SUBTYPE, _FOO) self.assertSetEqual( - pytree_utils.GetNodeAnnotation( - self._leaf, pytree_utils.Annotation.SUBTYPE), {_FOO}) + pytree_utils.GetNodeAnnotation(self._leaf, + pytree_utils.Annotation.SUBTYPE), {_FOO}) pytree_utils.RemoveSubtypeAnnotation(self._leaf, _FOO) self.assertSetEqual( - pytree_utils.GetNodeAnnotation( - self._leaf, pytree_utils.Annotation.SUBTYPE), set()) + pytree_utils.GetNodeAnnotation(self._leaf, + pytree_utils.Annotation.SUBTYPE), set()) def testSetOnNode(self): pytree_utils.SetNodeAnnotation(self._node, _FOO, 20) diff --git a/yapftests/pytree_visitor_test.py b/yapftests/pytree_visitor_test.py index 231183030..45a83b113 100644 --- a/yapftests/pytree_visitor_test.py +++ b/yapftests/pytree_visitor_test.py @@ -31,7 +31,7 @@ class _NodeNameCollector(pytree_visitor.PyTreeVisitor): """ def __init__(self): - self.all_node_names = [] + self.all_node_names = [] self.name_node_values = [] def DefaultNodeVisit(self, node): @@ -61,7 +61,7 @@ def Visit_NAME(self, leaf): class PytreeVisitorTest(unittest.TestCase): def testCollectAllNodeNamesSimpleCode(self): - tree = pytree_utils.ParseCodeToTree(_VISITOR_TEST_SIMPLE_CODE) + tree = pytree_utils.ParseCodeToTree(_VISITOR_TEST_SIMPLE_CODE) collector = _NodeNameCollector() collector.Visit(tree) expected_names = [ @@ -76,7 +76,7 @@ def testCollectAllNodeNamesSimpleCode(self): self.assertEqual(expected_name_node_values, collector.name_node_values) def testCollectAllNodeNamesNestedCode(self): - tree = pytree_utils.ParseCodeToTree(_VISITOR_TEST_NESTED_CODE) + tree = pytree_utils.ParseCodeToTree(_VISITOR_TEST_NESTED_CODE) collector = _NodeNameCollector() collector.Visit(tree) expected_names = [ @@ -95,7 +95,7 @@ def testCollectAllNodeNamesNestedCode(self): def testDumper(self): # PyTreeDumper is mainly a debugging utility, so only do basic sanity # checking. - tree = pytree_utils.ParseCodeToTree(_VISITOR_TEST_SIMPLE_CODE) + tree = pytree_utils.ParseCodeToTree(_VISITOR_TEST_SIMPLE_CODE) stream = py3compat.StringIO() pytree_visitor.PyTreeDumper(target_stream=stream).Visit(tree) @@ -106,7 +106,7 @@ def testDumper(self): def testDumpPyTree(self): # Similar sanity checking for the convenience wrapper DumpPyTree - tree = pytree_utils.ParseCodeToTree(_VISITOR_TEST_SIMPLE_CODE) + tree = pytree_utils.ParseCodeToTree(_VISITOR_TEST_SIMPLE_CODE) stream = py3compat.StringIO() pytree_visitor.DumpPyTree(tree, target_stream=stream) diff --git a/yapftests/reformatter_basic_test.py b/yapftests/reformatter_basic_test.py index 77ef859cb..0eeeefdce 100644 --- a/yapftests/reformatter_basic_test.py +++ b/yapftests/reformatter_basic_test.py @@ -33,12 +33,10 @@ def testSplittingAllArgs(self): style.SetGlobalStyle( style.CreateStyleFromConfig( '{split_all_comma_separated_values: true, column_limit: 40}')) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ responseDict = {"timestamp": timestamp, "someValue": value, "whatever": 120} """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ responseDict = { "timestamp": timestamp, "someValue": value, @@ -48,12 +46,10 @@ def testSplittingAllArgs(self): llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ yes = { 'yes': 'no', 'no': 'yes', } """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ yes = { 'yes': 'no', 'no': 'yes', @@ -61,13 +57,11 @@ def testSplittingAllArgs(self): """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def foo(long_arg, really_long_arg, really_really_long_arg, cant_keep_all_these_args): pass """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def foo(long_arg, really_long_arg, really_really_long_arg, @@ -76,12 +70,10 @@ def foo(long_arg, """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ foo_tuple = [long_arg, really_long_arg, really_really_long_arg, cant_keep_all_these_args] """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ foo_tuple = [ long_arg, really_long_arg, @@ -91,25 +83,21 @@ def foo(long_arg, """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ foo_tuple = [short, arg] """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ foo_tuple = [short, arg] """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) # There is a test for split_all_top_level_comma_separated_values, with # different expected value - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ someLongFunction(this_is_a_very_long_parameter, abc=(a, this_will_just_fit_xxxxxxx)) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ someLongFunction( this_is_a_very_long_parameter, abc=(a, @@ -124,12 +112,10 @@ def testSplittingTopLevelAllArgs(self): '{split_all_top_level_comma_separated_values: true, ' 'column_limit: 40}')) # Works the same way as split_all_comma_separated_values - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ responseDict = {"timestamp": timestamp, "someValue": value, "whatever": 120} """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ responseDict = { "timestamp": timestamp, "someValue": value, @@ -139,13 +125,11 @@ def testSplittingTopLevelAllArgs(self): llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) # Works the same way as split_all_comma_separated_values - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def foo(long_arg, really_long_arg, really_really_long_arg, cant_keep_all_these_args): pass """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def foo(long_arg, really_long_arg, really_really_long_arg, @@ -155,12 +139,10 @@ def foo(long_arg, llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) # Works the same way as split_all_comma_separated_values - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ foo_tuple = [long_arg, really_long_arg, really_really_long_arg, cant_keep_all_these_args] """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ foo_tuple = [ long_arg, really_long_arg, @@ -171,41 +153,35 @@ def foo(long_arg, llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) # Works the same way as split_all_comma_separated_values - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ foo_tuple = [short, arg] """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ foo_tuple = [short, arg] """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) # There is a test for split_all_comma_separated_values, with different # expected value - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ someLongFunction(this_is_a_very_long_parameter, abc=(a, this_will_just_fit_xxxxxxx)) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ someLongFunction( this_is_a_very_long_parameter, abc=(a, this_will_just_fit_xxxxxxx)) """) - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) actual_formatted_code = reformatter.Reformat(llines) self.assertEqual(40, len(actual_formatted_code.splitlines()[-1])) self.assertCodeEqual(expected_formatted_code, actual_formatted_code) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ someLongFunction(this_is_a_very_long_parameter, abc=(a, this_will_not_fit_xxxxxxxxx)) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ someLongFunction( this_is_a_very_long_parameter, abc=(a, @@ -215,13 +191,11 @@ def foo(long_arg, self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) # Exercise the case where there's no opening bracket (for a, b) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ a, b = f( a_very_long_parameter, yet_another_one, and_another) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ a, b = f( a_very_long_parameter, yet_another_one, and_another) """) @@ -229,8 +203,7 @@ def foo(long_arg, self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) # Don't require splitting before comments. - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ KO = { 'ABC': Abc, # abc 'DEF': Def, # def @@ -239,8 +212,7 @@ def foo(long_arg, 'JKL': Jkl, } """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ KO = { 'ABC': Abc, # abc 'DEF': Def, # def @@ -253,8 +225,7 @@ def foo(long_arg, self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testSimpleFunctionsWithTrailingComments(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def g(): # Trailing comment if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): @@ -266,8 +237,7 @@ def f( # Intermediate comment xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def g(): # Trailing comment if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): @@ -284,13 +254,11 @@ def f( # Intermediate comment self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testBlankLinesBetweenTopLevelImportsAndVariables(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ import foo as bar VAR = 'baz' """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ import foo as bar VAR = 'baz' @@ -298,14 +266,12 @@ def testBlankLinesBetweenTopLevelImportsAndVariables(self): llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ import foo as bar VAR = 'baz' """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ import foo as bar @@ -317,32 +283,28 @@ def testBlankLinesBetweenTopLevelImportsAndVariables(self): '{based_on_style: yapf, ' 'blank_lines_between_top_level_imports_and_variables: 2}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ import foo as bar # Some comment """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ import foo as bar # Some comment """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ import foo as bar class Baz(): pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ import foo as bar @@ -352,14 +314,12 @@ class Baz(): llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ import foo as bar def foobar(): pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ import foo as bar @@ -369,14 +329,12 @@ def foobar(): llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def foobar(): from foo import Bar Bar.baz() """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def foobar(): from foo import Bar Bar.baz() @@ -385,39 +343,34 @@ def foobar(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testBlankLinesAtEndOfFile(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def foobar(): # foo pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def foobar(): # foo pass """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ x = { 'a':37,'b':42, 'c':927} """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ x = {'a': 37, 'b': 42, 'c': 927} """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testIndentBlankLines(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ class foo(object): def foobar(self): @@ -445,19 +398,18 @@ class foo(object):\n \n def foobar(self):\n \n pass\n \n def barfoo(se '{based_on_style: yapf, indent_blank_lines: true}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) - unformatted_code, expected_formatted_code = ( - expected_formatted_code, unformatted_code) + unformatted_code, expected_formatted_code = (expected_formatted_code, + unformatted_code) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testMultipleUgliness(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ x = { 'a':37,'b':42, 'c':927} @@ -473,8 +425,7 @@ def g(self, x,y=42): def f ( a ) : return 37+-+a[42-x : y**3] """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ x = {'a': 37, 'b': 42, 'c': 927} y = 'hello ' 'world' @@ -498,8 +449,7 @@ def f(a): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testComments(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ class Foo(object): pass @@ -521,8 +471,7 @@ class Baz(object): class Qux(object): pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ class Foo(object): pass @@ -553,18 +502,16 @@ class Qux(object): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testSingleComment(self): - code = textwrap.dedent("""\ + code = textwrap.dedent("""\ # Thing 1 """) llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) def testCommentsWithTrailingSpaces(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ # Thing 1 \n# Thing 2 \n""") - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ # Thing 1 # Thing 2 """) @@ -572,8 +519,7 @@ def testCommentsWithTrailingSpaces(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testCommentsInDataLiteral(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ def f(): return collections.OrderedDict({ # First comment. @@ -590,8 +536,7 @@ def f(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testEndingWhitespaceAfterSimpleStatement(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ import foo as bar # Thing 1 # Thing 2 @@ -600,8 +545,7 @@ def testEndingWhitespaceAfterSimpleStatement(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testDocstrings(self): - unformatted_code = textwrap.dedent( - '''\ + unformatted_code = textwrap.dedent('''\ u"""Module-level docstring.""" import os class Foo(object): @@ -618,8 +562,7 @@ def qux(self): print('hello {}'.format('world')) return 42 ''') - expected_formatted_code = textwrap.dedent( - '''\ + expected_formatted_code = textwrap.dedent('''\ u"""Module-level docstring.""" import os @@ -640,8 +583,7 @@ def qux(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testDocstringAndMultilineComment(self): - unformatted_code = textwrap.dedent( - '''\ + unformatted_code = textwrap.dedent('''\ """Hello world""" # A multiline # comment @@ -655,8 +597,7 @@ def foo(self): # comment pass ''') - expected_formatted_code = textwrap.dedent( - '''\ + expected_formatted_code = textwrap.dedent('''\ """Hello world""" @@ -677,8 +618,7 @@ def foo(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testMultilineDocstringAndMultilineComment(self): - unformatted_code = textwrap.dedent( - '''\ + unformatted_code = textwrap.dedent('''\ """Hello world RIP Dennis Richie. @@ -701,8 +641,7 @@ def foo(self): # comment pass ''') - expected_formatted_code = textwrap.dedent( - '''\ + expected_formatted_code = textwrap.dedent('''\ """Hello world RIP Dennis Richie. @@ -732,26 +671,24 @@ def foo(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testTupleCommaBeforeLastParen(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent("""\ a = ( 1, ) """) expected_formatted_code = textwrap.dedent("""\ a = (1,) """) - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testNoBreakOutsideOfBracket(self): # FIXME(morbo): How this is formatted is not correct. But it's syntactically # correct. - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def f(): assert port >= minimum, \ 'Unexpected port %d when minimum was %d.' % (port, minimum) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def f(): assert port >= minimum, 'Unexpected port %d when minimum was %d.' % (port, minimum) @@ -760,8 +697,7 @@ def f(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testBlankLinesBeforeDecorators(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ @foo() class A(object): @bar() @@ -769,8 +705,7 @@ class A(object): def x(self): pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ @foo() class A(object): @@ -783,16 +718,14 @@ def x(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testCommentBetweenDecorators(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ @foo() # frob @bar def x (self): pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ @foo() # frob @bar @@ -803,14 +736,12 @@ def x(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testListComprehension(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def given(y): [k for k in () if k in y] """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def given(y): [k for k in () if k in y] """) @@ -818,16 +749,14 @@ def given(y): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testListComprehensionPreferOneLine(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def given(y): long_variable_name = [ long_var_name + 1 for long_var_name in () if long_var_name == 2] """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def given(y): long_variable_name = [ long_var_name + 1 for long_var_name in () if long_var_name == 2 @@ -837,14 +766,12 @@ def given(y): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testListComprehensionPreferOneLineOverArithmeticSplit(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def given(used_identifiers): return (sum(len(identifier) for identifier in used_identifiers) / len(used_identifiers)) """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def given(used_identifiers): return (sum(len(identifier) for identifier in used_identifiers) / len(used_identifiers)) @@ -853,16 +780,14 @@ def given(used_identifiers): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testListComprehensionPreferThreeLinesForLineWrap(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def given(y): long_variable_name = [ long_var_name + 1 for long_var_name, number_two in () if long_var_name == 2 and number_two == 3] """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def given(y): long_variable_name = [ long_var_name + 1 @@ -874,16 +799,14 @@ def given(y): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testListComprehensionPreferNoBreakForTrivialExpression(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def given(y): long_variable_name = [ long_var_name for long_var_name, number_two in () if long_var_name == 2 and number_two == 3] """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def given(y): long_variable_name = [ long_var_name for long_var_name, number_two in () @@ -894,7 +817,7 @@ def given(y): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testOpeningAndClosingBrackets(self): - unformatted_code = """\ + unformatted_code = """\ foo( (1, ) ) foo( ( 1, 2, 3 ) ) foo( ( 1, 2, 3, ) ) @@ -908,16 +831,14 @@ def testOpeningAndClosingBrackets(self): 3, )) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testSingleLineFunctions(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def foo(): return 42 """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def foo(): return 42 """) @@ -928,23 +849,21 @@ def testNoQueueSeletionInMiddleOfLine(self): # If the queue isn't properly constructed, then a token in the middle of the # line may be selected as the one with least penalty. The tokens after that # one are then splatted at the end of the line with no formatting. - unformatted_code = """\ + unformatted_code = """\ find_symbol(node.type) + "< " + " ".join(find_pattern(n) for n in node.child) + " >" """ # noqa expected_formatted_code = """\ find_symbol(node.type) + "< " + " ".join( find_pattern(n) for n in node.child) + " >" """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testNoSpacesBetweenSubscriptsAndCalls(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ aaaaaaaaaa = bbbbbbbb.ccccccccc() [42] (a, 2) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ aaaaaaaaaa = bbbbbbbb.ccccccccc()[42](a, 2) """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) @@ -952,25 +871,21 @@ def testNoSpacesBetweenSubscriptsAndCalls(self): def testNoSpacesBetweenOpeningBracketAndStartingOperator(self): # Unary operator. - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ aaaaaaaaaa = bbbbbbbb.ccccccccc[ -1 ]( -42 ) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ aaaaaaaaaa = bbbbbbbb.ccccccccc[-1](-42) """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) # Varargs and kwargs. - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ aaaaaaaaaa = bbbbbbbb.ccccccccc( *varargs ) aaaaaaaaaa = bbbbbbbb.ccccccccc( **kwargs ) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ aaaaaaaaaa = bbbbbbbb.ccccccccc(*varargs) aaaaaaaaaa = bbbbbbbb.ccccccccc(**kwargs) """) @@ -978,15 +893,13 @@ def testNoSpacesBetweenOpeningBracketAndStartingOperator(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testMultilineCommentReformatted(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ if True: # This is a multiline # comment. pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ if True: # This is a multiline # comment. @@ -996,8 +909,7 @@ def testMultilineCommentReformatted(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testDictionaryMakerFormatting(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ _PYTHON_STATEMENTS = frozenset({ lambda x, y: 'simple_stmt': 'small_stmt', 'expr_stmt': 'print_stmt', 'del_stmt': 'pass_stmt', lambda: 'break_stmt': 'continue_stmt', 'return_stmt': 'raise_stmt', @@ -1005,8 +917,7 @@ def testDictionaryMakerFormatting(self): 'if_stmt', 'while_stmt': 'for_stmt', }) """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ _PYTHON_STATEMENTS = frozenset({ lambda x, y: 'simple_stmt': 'small_stmt', 'expr_stmt': 'print_stmt', @@ -1023,16 +934,14 @@ def testDictionaryMakerFormatting(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testSimpleMultilineCode(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ if True: aaaaaaaaaaaaaa.bbbbbbbbbbbbbb.ccccccc(zzzzzzzzzzzz, \ xxxxxxxxxxx, yyyyyyyyyyyy, vvvvvvvvv) aaaaaaaaaaaaaa.bbbbbbbbbbbbbb.ccccccc(zzzzzzzzzzzz, \ xxxxxxxxxxx, yyyyyyyyyyyy, vvvvvvvvv) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ if True: aaaaaaaaaaaaaa.bbbbbbbbbbbbbb.ccccccc(zzzzzzzzzzzz, xxxxxxxxxxx, yyyyyyyyyyyy, vvvvvvvvv) @@ -1043,8 +952,7 @@ def testSimpleMultilineCode(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testMultilineComment(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ if Foo: # Hello world # Yo man. @@ -1057,15 +965,14 @@ def testMultilineComment(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testSpaceBetweenStringAndParentheses(self): - code = textwrap.dedent("""\ + code = textwrap.dedent("""\ b = '0' ('hello') """) llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) def testMultilineString(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ code = textwrap.dedent('''\ if Foo: # Hello world @@ -1079,8 +986,7 @@ def testMultilineString(self): llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent( - '''\ + unformatted_code = textwrap.dedent('''\ def f(): email_text += """This is a really long docstring that goes over the column limit and is multi-line.

Czar: """+despot["Nicholas"]+"""
@@ -1089,8 +995,7 @@ def f(): """ ''') # noqa - expected_formatted_code = textwrap.dedent( - '''\ + expected_formatted_code = textwrap.dedent('''\ def f(): email_text += """This is a really long docstring that goes over the column limit and is multi-line.

Czar: """ + despot["Nicholas"] + """
@@ -1103,8 +1008,7 @@ def f(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testSimpleMultilineWithComments(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ if ( # This is the first comment a and # This is the second comment # This is the third comment @@ -1116,14 +1020,12 @@ def testSimpleMultilineWithComments(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testMatchingParenSplittingMatching(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def f(): raise RuntimeError('unable to find insertion point for target node', (target,)) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def f(): raise RuntimeError('unable to find insertion point for target node', (target,)) @@ -1132,8 +1034,7 @@ def f(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testContinuationIndent(self): - unformatted_code = textwrap.dedent( - '''\ + unformatted_code = textwrap.dedent('''\ class F: def _ProcessArgLists(self, node): """Common method for processing argument lists.""" @@ -1143,8 +1044,7 @@ def _ProcessArgLists(self, node): child, subtype=_ARGLIST_TOKEN_TO_SUBTYPE.get( child.value, format_token.Subtype.NONE)) ''') - expected_formatted_code = textwrap.dedent( - '''\ + expected_formatted_code = textwrap.dedent('''\ class F: def _ProcessArgLists(self, node): @@ -1160,14 +1060,12 @@ def _ProcessArgLists(self, node): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testTrailingCommaAndBracket(self): - unformatted_code = textwrap.dedent( - '''\ + unformatted_code = textwrap.dedent('''\ a = { 42, } b = ( 42, ) c = [ 42, ] ''') - expected_formatted_code = textwrap.dedent( - '''\ + expected_formatted_code = textwrap.dedent('''\ a = { 42, } @@ -1180,23 +1078,20 @@ def testTrailingCommaAndBracket(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testI18n(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ N_('Some years ago - never mind how long precisely - having little or no money in my purse, and nothing particular to interest me on shore, I thought I would sail about a little and see the watery part of the world.') # A comment is here. """) # noqa llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ foo('Fake function call') #. Some years ago - never mind how long precisely - having little or no money in my purse, and nothing particular to interest me on shore, I thought I would sail about a little and see the watery part of the world. """) # noqa llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) def testI18nCommentsInDataLiteral(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ def f(): return collections.OrderedDict({ #. First i18n comment. @@ -1210,8 +1105,7 @@ def f(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testClosingBracketIndent(self): - code = textwrap.dedent( - '''\ + code = textwrap.dedent('''\ def f(): def g(): @@ -1224,8 +1118,7 @@ def g(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testClosingBracketsInlinedInCall(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ class Foo(object): def bar(self): @@ -1239,8 +1132,7 @@ def bar(self): "porkporkpork": 5, }) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ class Foo(object): def bar(self): @@ -1258,8 +1150,7 @@ def bar(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testLineWrapInForExpression(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ class A: def x(self, node, name, n=1): @@ -1272,7 +1163,7 @@ def x(self, node, name, n=1): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testFunctionCallContinuationLine(self): - code = """\ + code = """\ class foo: def bar(self, node, name, n=1): @@ -1286,8 +1177,7 @@ def bar(self, node, name, n=1): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testI18nNonFormatting(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ class F(object): def __init__(self, fieldname, @@ -1299,8 +1189,7 @@ def __init__(self, fieldname, self.assertCodeEqual(code, reformatter.Reformat(llines)) def testNoSpaceBetweenUnaryOpAndOpeningParen(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ if ~(a or b): pass """) @@ -1308,8 +1197,7 @@ def testNoSpaceBetweenUnaryOpAndOpeningParen(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testCommentBeforeFuncDef(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ class Foo(object): a = 42 @@ -1327,8 +1215,7 @@ def __init__(self, self.assertCodeEqual(code, reformatter.Reformat(llines)) def testExcessLineCountWithDefaultKeywords(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ class Fnord(object): def Moo(self): aaaaaaaaaaaaaaaa = self._bbbbbbbbbbbbbbbbbbbbbbb( @@ -1336,8 +1223,7 @@ def Moo(self): fffff=fffff, ggggggg=ggggggg, hhhhhhhhhhhhh=hhhhhhhhhhhhh, iiiiiii=iiiiiiiiiiiiii) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ class Fnord(object): def Moo(self): @@ -1354,8 +1240,7 @@ def Moo(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testSpaceAfterNotOperator(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ if not (this and that): pass """) @@ -1363,8 +1248,7 @@ def testSpaceAfterNotOperator(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testNoPenaltySplitting(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ def f(): if True: if True: @@ -1377,8 +1261,7 @@ def f(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testExpressionPenalties(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ def f(): if ((left.value == '(' and right.value == ')') or (left.value == '[' and right.value == ']') or @@ -1389,16 +1272,14 @@ def f(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testLineDepthOfSingleLineStatement(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ while True: continue for x in range(3): continue try: a = 42 except: b = 42 with open(a) as fd: a = fd.read() """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ while True: continue for x in range(3): @@ -1414,13 +1295,11 @@ def testLineDepthOfSingleLineStatement(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testSplitListWithTerminatingComma(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ FOO = ['bar', 'baz', 'mux', 'qux', 'quux', 'quuux', 'quuuux', 'quuuuux', 'quuuuuux', 'quuuuuuux', lambda a, b: 37,] """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ FOO = [ 'bar', 'baz', @@ -1439,8 +1318,7 @@ def testSplitListWithTerminatingComma(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testSplitListWithInterspersedComments(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ FOO = [ 'bar', # bar 'baz', # baz @@ -1459,7 +1337,7 @@ def testSplitListWithInterspersedComments(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testRelativeImportStatements(self): - code = textwrap.dedent("""\ + code = textwrap.dedent("""\ from ... import bork """) llines = yapf_test_helper.ParseAndUnwrap(code) @@ -1467,15 +1345,13 @@ def testRelativeImportStatements(self): def testSingleLineList(self): # A list on a single line should prefer to remain contiguous. - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = aaaaaaaaaaa( ("...", "."), "..", ".............................................." ) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = aaaaaaaaaaa( ("...", "."), "..", "..............................................") """) # noqa @@ -1483,8 +1359,7 @@ def testSingleLineList(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testBlankLinesBeforeFunctionsNotInColumnZero(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ import signal @@ -1499,8 +1374,7 @@ def timeout(seconds=1): except: pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ import signal try: @@ -1519,8 +1393,7 @@ def timeout(seconds=1): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testNoKeywordArgumentBreakage(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ class A(object): def b(self): @@ -1532,7 +1405,7 @@ def b(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testTrailerOnSingleLine(self): - code = """\ + code = """\ urlpatterns = patterns('', url(r'^$', 'homepage_view'), url(r'^/login/$', 'login_view'), url(r'^/login/$', 'logout_view'), @@ -1542,8 +1415,7 @@ def testTrailerOnSingleLine(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testIfConditionalParens(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ class Foo: def bar(): @@ -1556,8 +1428,7 @@ def bar(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testContinuationMarkers(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. "\\ "Sed sit amet ipsum mauris. Maecenas congue ligula ac quam viverra nec consectetur "\\ "ante hendrerit. Donec et mollis dolor. Praesent et diam eget libero egestas mattis "\\ @@ -1567,16 +1438,14 @@ def testContinuationMarkers(self): llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ from __future__ import nested_scopes, generators, division, absolute_import, with_statement, \\ print_function, unicode_literals """) # noqa llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ if aaaaaaaaa == 42 and bbbbbbbbbbbbbb == 42 and \\ cccccccc == 42: pass @@ -1585,8 +1454,7 @@ def testContinuationMarkers(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testCommentsWithContinuationMarkers(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ def fn(arg): v = fn2(key1=True, #c1 @@ -1597,8 +1465,7 @@ def fn(arg): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testMultipleContinuationMarkers(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ xyz = \\ \\ some_thing() @@ -1607,7 +1474,7 @@ def testMultipleContinuationMarkers(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testContinuationMarkerAfterStringWithContinuation(self): - code = """\ + code = """\ s = 'foo \\ bar' \\ .format() @@ -1616,8 +1483,7 @@ def testContinuationMarkerAfterStringWithContinuation(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testEmptyContainers(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ flags.DEFINE_list( 'output_dirs', [], 'Lorem ipsum dolor sit amet, consetetur adipiscing elit. Donec a diam lectus. ' @@ -1627,12 +1493,10 @@ def testEmptyContainers(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testSplitStringsIfSurroundedByParens(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ a = foo.bar({'xxxxxxxxxxxxxxxxxxxxxxx' 'yyyyyyyyyyyyyyyyyyyyyyyyyy': baz[42]} + 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' 'bbbbbbbbbbbbbbbbbbbbbbbbbb' 'cccccccccccccccccccccccccccccccc' 'ddddddddddddddddddddddddddddd') """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ a = foo.bar({'xxxxxxxxxxxxxxxxxxxxxxx' 'yyyyyyyyyyyyyyyyyyyyyyyyyy': baz[42]} + 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' @@ -1643,8 +1507,7 @@ def testSplitStringsIfSurroundedByParens(self): llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ a = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' \ 'bbbbbbbbbbbbbbbbbbbbbbbbbb' 'cccccccccccccccccccccccccccccccc' \ 'ddddddddddddddddddddddddddddd' @@ -1653,8 +1516,7 @@ def testSplitStringsIfSurroundedByParens(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testMultilineShebang(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ #!/bin/sh if "true" : '''\' then @@ -1674,8 +1536,7 @@ def testMultilineShebang(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testNoSplittingAroundTermOperators(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ a_very_long_function_call_yada_yada_etc_etc_etc(long_arg1, long_arg2 / long_arg3) """) @@ -1683,8 +1544,7 @@ def testNoSplittingAroundTermOperators(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testNoSplittingAroundCompOperators(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ c = (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa is not bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) c = (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa in bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) c = (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not in bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) @@ -1692,8 +1552,7 @@ def testNoSplittingAroundCompOperators(self): c = (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa is bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) c = (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <= bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) """) # noqa - expected_code = textwrap.dedent( - """\ + expected_code = textwrap.dedent("""\ c = ( aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa is not bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) @@ -1715,8 +1574,7 @@ def testNoSplittingAroundCompOperators(self): self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) def testNoSplittingWithinSubscriptList(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ somequitelongvariablename.somemember[(a, b)] = { 'somelongkey': 1, 'someotherlongkey': 2 @@ -1726,8 +1584,7 @@ def testNoSplittingWithinSubscriptList(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testExcessCharacters(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ class foo: def bar(self): @@ -1738,16 +1595,14 @@ def bar(self): llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def _(): if True: if True: if contract == allow_contract and attr_dict.get(if_attribute) == has_value: return True """) # noqa - expected_code = textwrap.dedent( - """\ + expected_code = textwrap.dedent("""\ def _(): if True: if True: @@ -1759,8 +1614,7 @@ def _(): self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) def testDictSetGenerator(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ foo = { variable: 'hello world. How are you today?' for variable in fnord @@ -1771,8 +1625,7 @@ def testDictSetGenerator(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testUnaryOpInDictionaryValue(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ beta = "123" test = {'alpha': beta[-1]} @@ -1783,8 +1636,7 @@ def testUnaryOpInDictionaryValue(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testUnaryNotOperator(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ if True: if True: if True: @@ -1796,7 +1648,7 @@ def testUnaryNotOperator(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testRelaxArraySubscriptAffinity(self): - code = """\ + code = """\ class A(object): def f(self, aaaaaaaaa, bbbbbbbbbbbbb, row): @@ -1812,18 +1664,17 @@ def f(self, aaaaaaaaa, bbbbbbbbbbbbb, row): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testFunctionCallInDict(self): - code = "a = {'a': b(c=d, **e)}\n" + code = "a = {'a': b(c=d, **e)}\n" llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) def testFunctionCallInNestedDict(self): - code = "a = {'a': {'a': {'a': b(c=d, **e)}}}\n" + code = "a = {'a': {'a': {'a': b(c=d, **e)}}}\n" llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) def testUnbreakableNot(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ def test(): if not "Foooooooooooooooooooooooooooooo" or "Foooooooooooooooooooooooooooooo" == "Foooooooooooooooooooooooooooooo": pass @@ -1832,8 +1683,7 @@ def test(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testSplitListWithComment(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ a = [ 'a', 'b', @@ -1844,8 +1694,7 @@ def testSplitListWithComment(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testOverColumnLimit(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ class Test: def testSomething(self): @@ -1855,8 +1704,7 @@ def testSomething(self): ('aaaaaaaaaaaaa', 'bbbb'): 'ccccccccccccccccccccccccccccccccccccccccccc', } """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ class Test: def testSomething(self): @@ -1873,8 +1721,7 @@ def testSomething(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testEndingComment(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ a = f( a="something", b="something requiring comment which is quite long", # comment about b (pushes line over 79) @@ -1884,8 +1731,7 @@ def testEndingComment(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testContinuationSpaceRetention(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ def fn(): return module \\ .method(Object(data, @@ -1896,8 +1742,7 @@ def fn(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testIfExpressionWithFunctionCall(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ if x or z.y( a, c, @@ -1909,8 +1754,7 @@ def testIfExpressionWithFunctionCall(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testUnformattedAfterMultilineString(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ def foo(): com_text = \\ ''' @@ -1921,8 +1765,7 @@ def foo(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testNoSpacesAroundKeywordDefaultValues(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ sources = { 'json': request.get_json(silent=True) or {}, 'json2': request.get_json(silent=True), @@ -1933,14 +1776,12 @@ def testNoSpacesAroundKeywordDefaultValues(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testNoSplittingBeforeEndingSubscriptBracket(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ if True: if True: status = cf.describe_stacks(StackName=stackname)[u'Stacks'][0][u'StackStatus'] """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ if True: if True: status = cf.describe_stacks( @@ -1950,8 +1791,7 @@ def testNoSplittingBeforeEndingSubscriptBracket(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testNoSplittingOnSingleArgument(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ xxxxxxxxxxxxxx = (re.search(r'(\\d+\\.\\d+\\.\\d+\\.)\\d+', aaaaaaa.bbbbbbbbbbbb).group(1) + re.search(r'\\d+\\.\\d+\\.\\d+\\.(\\d+)', @@ -1961,8 +1801,7 @@ def testNoSplittingOnSingleArgument(self): re.search(r'\\d+\\.\\d+\\.\\d+\\.(\\d+)', ccccccc).group(c.d)) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ xxxxxxxxxxxxxx = ( re.search(r'(\\d+\\.\\d+\\.\\d+\\.)\\d+', aaaaaaa.bbbbbbbbbbbb).group(1) + re.search(r'\\d+\\.\\d+\\.\\d+\\.(\\d+)', ccccccc).group(1)) @@ -1974,15 +1813,13 @@ def testNoSplittingOnSingleArgument(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testSplittingArraysSensibly(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ while True: while True: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = list['bbbbbbbbbbbbbbbbbbbbbbbbb'].split(',') aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = list('bbbbbbbbbbbbbbbbbbbbbbbbb').split(',') """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ while True: while True: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = list[ @@ -1994,15 +1831,13 @@ def testSplittingArraysSensibly(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testComprehensionForAndIf(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ class f: def __repr__(self): tokens_repr = ','.join(['{0}({1!r})'.format(tok.name, tok.value) for tok in self._tokens]) """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ class f: def __repr__(self): @@ -2013,8 +1848,7 @@ def __repr__(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testFunctionCallArguments(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def f(): if True: pytree_utils.InsertNodesBefore(_CreateCommentsFromPrefix( @@ -2024,8 +1858,7 @@ def f(): comment_prefix, comment_lineno, comment_column, standalone=True)) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def f(): if True: pytree_utils.InsertNodesBefore( @@ -2040,21 +1873,18 @@ def f(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testBinaryOperators(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ a = b ** 37 c = (20 ** -3) / (_GRID_ROWS ** (code_length - 10)) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ a = b**37 c = (20**-3) / (_GRID_ROWS**(code_length - 10)) """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ def f(): if True: if (self.stack[-1].split_before_closing_bracket and @@ -2067,8 +1897,7 @@ def f(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testContiguousList(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ [retval1, retval2] = a_very_long_function(argument_1, argument2, argument_3, argument_4) """) # noqa @@ -2076,8 +1905,7 @@ def testContiguousList(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testArgsAndKwargsFormatting(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ a(a=aaaaaaaaaaaaaaaaaaaaa, b=aaaaaaaaaaaaaaaaaaaaaaaa, c=aaaaaaaaaaaaaaaaaa, @@ -2087,8 +1915,7 @@ def testArgsAndKwargsFormatting(self): llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ def foo(): return [ Bar(xxx='some string', @@ -2100,8 +1927,7 @@ def foo(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testCommentColumnLimitOverflow(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ def f(): if True: TaskManager.get_tags = MagicMock( @@ -2114,8 +1940,7 @@ def f(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testMultilineLambdas(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ class SomeClass(object): do_something = True @@ -2126,8 +1951,7 @@ def succeeded(self, dddddddddddddd): d.addCallback(lambda _: self.aaaaaa.bbbbbbbbbbbbbbbb.cccccccccccccccccccccccccccccccc(dddddddddddddd)) return d """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ class SomeClass(object): do_something = True @@ -2145,14 +1969,13 @@ def succeeded(self, dddddddddddddd): style.CreateStyleFromConfig( '{based_on_style: yapf, allow_multiline_lambdas: true}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testMultilineDictionaryKeys(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ MAP_WITH_LONG_KEYS = { ('lorem ipsum', 'dolor sit amet'): 1, @@ -2162,8 +1985,7 @@ def testMultilineDictionaryKeys(self): 3 } """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ MAP_WITH_LONG_KEYS = { ('lorem ipsum', 'dolor sit amet'): 1, @@ -2177,18 +1999,16 @@ def testMultilineDictionaryKeys(self): try: style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{based_on_style: yapf, ' - 'allow_multiline_dictionary_keys: true}')) + style.CreateStyleFromConfig('{based_on_style: yapf, ' + 'allow_multiline_dictionary_keys: true}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testStableDictionaryFormatting(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ class A(object): def method(self): @@ -2205,16 +2025,15 @@ def method(self): try: style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{based_on_style: pep8, indent_width: 2, ' - 'continuation_indent_width: 4, ' - 'indent_dictionary_value: True}')) + style.CreateStyleFromConfig('{based_on_style: pep8, indent_width: 2, ' + 'continuation_indent_width: 4, ' + 'indent_dictionary_value: True}')) - llines = yapf_test_helper.ParseAndUnwrap(code) + llines = yapf_test_helper.ParseAndUnwrap(code) reformatted_code = reformatter.Reformat(llines) self.assertCodeEqual(code, reformatted_code) - llines = yapf_test_helper.ParseAndUnwrap(reformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(reformatted_code) reformatted_code = reformatter.Reformat(llines) self.assertCodeEqual(code, reformatted_code) finally: @@ -2223,14 +2042,12 @@ def method(self): def testStableInlinedDictionaryFormatting(self): try: style.SetGlobalStyle(style.CreatePEP8Style()) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def _(): url = "http://{0}/axis-cgi/admin/param.cgi?{1}".format( value, urllib.urlencode({'action': 'update', 'parameter': value})) """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def _(): url = "http://{0}/axis-cgi/admin/param.cgi?{1}".format( value, urllib.urlencode({ @@ -2239,25 +2056,23 @@ def _(): })) """) - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) reformatted_code = reformatter.Reformat(llines) self.assertCodeEqual(expected_formatted_code, reformatted_code) - llines = yapf_test_helper.ParseAndUnwrap(reformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(reformatted_code) reformatted_code = reformatter.Reformat(llines) self.assertCodeEqual(expected_formatted_code, reformatted_code) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testDontSplitKeywordValueArguments(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def mark_game_scored(gid): _connect.execute(_games.update().where(_games.c.gid == gid).values( scored=True)) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def mark_game_scored(gid): _connect.execute( _games.update().where(_games.c.gid == gid).values(scored=True)) @@ -2266,8 +2081,7 @@ def mark_game_scored(gid): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testDontAddBlankLineAfterMultilineString(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ query = '''SELECT id FROM table WHERE day in {}''' @@ -2277,8 +2091,7 @@ def testDontAddBlankLineAfterMultilineString(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testFormattingListComprehensions(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ def a(): if True: if True: @@ -2292,8 +2105,7 @@ def a(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testNoSplittingWhenBinPacking(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ a_very_long_function_name( long_argument_name_1=1, long_argument_name_2=2, @@ -2315,25 +2127,23 @@ def testNoSplittingWhenBinPacking(self): 'dedent_closing_brackets: True, ' 'split_before_named_assigns: False}')) - llines = yapf_test_helper.ParseAndUnwrap(code) + llines = yapf_test_helper.ParseAndUnwrap(code) reformatted_code = reformatter.Reformat(llines) self.assertCodeEqual(code, reformatted_code) - llines = yapf_test_helper.ParseAndUnwrap(reformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(reformatted_code) reformatted_code = reformatter.Reformat(llines) self.assertCodeEqual(code, reformatted_code) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testNotSplittingAfterSubscript(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ if not aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.b(c == d[ 'eeeeee']).ffffff(): pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ if not aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.b( c == d['eeeeee']).ffffff(): pass @@ -2342,8 +2152,7 @@ def testNotSplittingAfterSubscript(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testSplittingOneArgumentList(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def _(): if True: if True: @@ -2352,8 +2161,7 @@ def _(): if True: boxes[id_] = np.concatenate((points.min(axis=0), qoints.max(axis=0))) """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def _(): if True: if True: @@ -2367,8 +2175,7 @@ def _(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testSplittingBeforeFirstElementListArgument(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ class _(): @classmethod def _pack_results_for_constraint_or(cls, combination, constraints): @@ -2381,8 +2188,7 @@ def _pack_results_for_constraint_or(cls, combination, constraints): ), constraints, InvestigationResult.OR ) """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ class _(): @classmethod @@ -2398,8 +2204,7 @@ def _pack_results_for_constraint_or(cls, combination, constraints): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testSplittingArgumentsTerminatedByComma(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ function_name(argument_name_1=1, argument_name_2=2, argument_name_3=3) function_name(argument_name_1=1, argument_name_2=2, argument_name_3=3,) @@ -2410,8 +2215,7 @@ def testSplittingArgumentsTerminatedByComma(self): r =f0 (1, 2,3,) """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ function_name(argument_name_1=1, argument_name_2=2, argument_name_3=3) function_name( @@ -2446,19 +2250,18 @@ def testSplittingArgumentsTerminatedByComma(self): '{based_on_style: yapf, ' 'split_arguments_when_comma_terminated: True}')) - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) reformatted_code = reformatter.Reformat(llines) self.assertCodeEqual(expected_formatted_code, reformatted_code) - llines = yapf_test_helper.ParseAndUnwrap(reformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(reformatted_code) reformatted_code = reformatter.Reformat(llines) self.assertCodeEqual(expected_formatted_code, reformatted_code) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testImportAsList(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ from toto import titi, tata, tutu # noqa from toto import titi, tata, tutu from toto import (titi, tata, tutu) @@ -2467,8 +2270,7 @@ def testImportAsList(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testDictionaryValuesOnOwnLines(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ a = { 'aaaaaaaaaaaaaaaaaaaaaaaa': Check('ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ', '=', True), @@ -2492,8 +2294,7 @@ def testDictionaryValuesOnOwnLines(self): Check('QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ', '=', False), } """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ a = { 'aaaaaaaaaaaaaaaaaaaaaaaa': Check('ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ', '=', True), @@ -2521,31 +2322,27 @@ def testDictionaryValuesOnOwnLines(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testDictionaryOnOwnLine(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ doc = test_utils.CreateTestDocumentViaController( content={ 'a': 'b' }, branch_key=branch.key, collection_key=collection.key) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ doc = test_utils.CreateTestDocumentViaController( content={'a': 'b'}, branch_key=branch.key, collection_key=collection.key) """) # noqa llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ doc = test_utils.CreateTestDocumentViaController( content={ 'a': 'b' }, branch_key=branch.key, collection_key=collection.key, collection_key2=collection.key2) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ doc = test_utils.CreateTestDocumentViaController( content={'a': 'b'}, branch_key=branch.key, @@ -2556,8 +2353,7 @@ def testDictionaryOnOwnLine(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testNestedListsInDictionary(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ _A = { 'cccccccccc': ('^^1',), 'rrrrrrrrrrrrrrrrrrrrrrrrr': ('^7913', # AAAAAAAAAAAAAA. @@ -2586,8 +2382,7 @@ def testNestedListsInDictionary(self): ), } """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ _A = { 'cccccccccc': ('^^1',), 'rrrrrrrrrrrrrrrrrrrrrrrrr': ( @@ -2625,8 +2420,7 @@ def testNestedListsInDictionary(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testNestedDictionary(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ class _(): def _(): breadcrumbs = [{'name': 'Admin', @@ -2636,8 +2430,7 @@ def _(): 'url': url_for(".home")}, {'title': title}] """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ class _(): def _(): breadcrumbs = [ @@ -2655,8 +2448,7 @@ def _(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testDictionaryElementsOnOneLine(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ class _(): @mock.patch.dict( @@ -2676,12 +2468,10 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testNotInParams(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ list("a long line to break the line. a long line to break the brk a long lin", not True) """) # noqa - expected_code = textwrap.dedent( - """\ + expected_code = textwrap.dedent("""\ list("a long line to break the line. a long line to break the brk a long lin", not True) """) # noqa @@ -2689,16 +2479,14 @@ def testNotInParams(self): self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) def testNamedAssignNotAtEndOfLine(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def _(): if True: with py3compat.open_with_encoding(filename, mode='w', encoding=encoding) as fd: pass """) - expected_code = textwrap.dedent( - """\ + expected_code = textwrap.dedent("""\ def _(): if True: with py3compat.open_with_encoding( @@ -2709,8 +2497,7 @@ def _(): self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) def testBlankLineBeforeClassDocstring(self): - unformatted_code = textwrap.dedent( - '''\ + unformatted_code = textwrap.dedent('''\ class A: """Does something. @@ -2721,8 +2508,7 @@ class A: def __init__(self): pass ''') - expected_code = textwrap.dedent( - '''\ + expected_code = textwrap.dedent('''\ class A: """Does something. @@ -2735,8 +2521,7 @@ def __init__(self): llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent( - '''\ + unformatted_code = textwrap.dedent('''\ class A: """Does something. @@ -2747,8 +2532,7 @@ class A: def __init__(self): pass ''') - expected_formatted_code = textwrap.dedent( - '''\ + expected_formatted_code = textwrap.dedent('''\ class A: """Does something. @@ -2767,14 +2551,13 @@ def __init__(self): 'blank_line_before_class_docstring: True}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testBlankLineBeforeModuleDocstring(self): - unformatted_code = textwrap.dedent( - '''\ + unformatted_code = textwrap.dedent('''\ #!/usr/bin/env python # -*- coding: utf-8 name> -*- @@ -2784,8 +2567,7 @@ def testBlankLineBeforeModuleDocstring(self): def foobar(): pass ''') - expected_code = textwrap.dedent( - '''\ + expected_code = textwrap.dedent('''\ #!/usr/bin/env python # -*- coding: utf-8 name> -*- """Some module docstring.""" @@ -2797,8 +2579,7 @@ def foobar(): llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent( - '''\ + unformatted_code = textwrap.dedent('''\ #!/usr/bin/env python # -*- coding: utf-8 name> -*- """Some module docstring.""" @@ -2807,8 +2588,7 @@ def foobar(): def foobar(): pass ''') - expected_formatted_code = textwrap.dedent( - '''\ + expected_formatted_code = textwrap.dedent('''\ #!/usr/bin/env python # -*- coding: utf-8 name> -*- @@ -2826,20 +2606,18 @@ def foobar(): 'blank_line_before_module_docstring: True}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testTupleCohesion(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def f(): this_is_a_very_long_function_name(an_extremely_long_variable_name, ( 'a string that may be too long %s' % 'M15')) """) - expected_code = textwrap.dedent( - """\ + expected_code = textwrap.dedent("""\ def f(): this_is_a_very_long_function_name( an_extremely_long_variable_name, @@ -2849,15 +2627,14 @@ def f(): self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) def testSubscriptExpression(self): - code = textwrap.dedent("""\ + code = textwrap.dedent("""\ foo = d[not a] """) llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) def testListWithFunctionCalls(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def foo(): return [ Bar( @@ -2869,8 +2646,7 @@ def foo(): zzz='a third long string') ] """) - expected_code = textwrap.dedent( - """\ + expected_code = textwrap.dedent("""\ def foo(): return [ Bar(xxx='some string', @@ -2885,13 +2661,11 @@ def foo(): self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) def testEllipses(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ X=... Y = X if ... else X """) - expected_code = textwrap.dedent( - """\ + expected_code = textwrap.dedent("""\ X = ... Y = X if ... else X """) @@ -2905,7 +2679,7 @@ def testPseudoParens(self): {'nested_key': 1, }, } """ - expected_code = """\ + expected_code = """\ my_dict = { 'key': # Some comment about the key { @@ -2913,18 +2687,16 @@ def testPseudoParens(self): }, } """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) def testSplittingBeforeFirstArgumentOnFunctionCall(self): """Tests split_before_first_argument on a function call.""" - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ a_very_long_function_name("long string with formatting {0:s}".format( "mystring")) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ a_very_long_function_name( "long string with formatting {0:s}".format("mystring")) """) @@ -2935,21 +2707,19 @@ def testSplittingBeforeFirstArgumentOnFunctionCall(self): '{based_on_style: yapf, split_before_first_argument: True}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testSplittingBeforeFirstArgumentOnFunctionDefinition(self): """Tests split_before_first_argument on a function definition.""" - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def _GetNumberOfSecondsFromElements(year, month, day, hours, minutes, seconds, microseconds): return """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def _GetNumberOfSecondsFromElements( year, month, day, hours, minutes, seconds, microseconds): return @@ -2961,23 +2731,21 @@ def _GetNumberOfSecondsFromElements( '{based_on_style: yapf, split_before_first_argument: True}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testSplittingBeforeFirstArgumentOnCompoundStatement(self): """Tests split_before_first_argument on a compound statement.""" - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ if (long_argument_name_1 == 1 or long_argument_name_2 == 2 or long_argument_name_3 == 3 or long_argument_name_4 == 4): pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ if (long_argument_name_1 == 1 or long_argument_name_2 == 2 or long_argument_name_3 == 3 or long_argument_name_4 == 4): pass @@ -2989,15 +2757,14 @@ def testSplittingBeforeFirstArgumentOnCompoundStatement(self): '{based_on_style: yapf, split_before_first_argument: True}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testCoalesceBracketsOnDict(self): """Tests coalesce_brackets on a dictionary.""" - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ date_time_values = ( { u'year': year, @@ -3009,8 +2776,7 @@ def testCoalesceBracketsOnDict(self): } ) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ date_time_values = ({ u'year': year, u'month': month, @@ -3027,14 +2793,13 @@ def testCoalesceBracketsOnDict(self): '{based_on_style: yapf, coalesce_brackets: True}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testSplitAfterComment(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ if __name__ == "__main__": with another_resource: account = { @@ -3059,8 +2824,7 @@ def testAsyncAsNonKeyword(self): style.SetGlobalStyle(style.CreatePEP8Style()) # In Python 2, async may be used as a non-keyword identifier. - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ from util import async @@ -3082,9 +2846,8 @@ def testDisableEndingCommaHeuristic(self): try: style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{based_on_style: yapf,' - ' disable_ending_comma_heuristic: True}')) + style.CreateStyleFromConfig('{based_on_style: yapf,' + ' disable_ending_comma_heuristic: True}')) llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) @@ -3092,8 +2855,7 @@ def testDisableEndingCommaHeuristic(self): style.SetGlobalStyle(style.CreateYapfStyle()) def testDedentClosingBracketsWithTypeAnnotationExceedingLineLength(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def function(first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None) -> None: pass @@ -3101,8 +2863,7 @@ def function(first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None) -> None def function(first_argument_xxxxxxxxxxxxxxxxxxxxxxx=(0,), second_argument=None) -> None: pass """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def function( first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None ) -> None: @@ -3117,19 +2878,17 @@ def function( try: style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{based_on_style: yapf,' - ' dedent_closing_brackets: True}')) + style.CreateStyleFromConfig('{based_on_style: yapf,' + ' dedent_closing_brackets: True}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testIndentClosingBracketsWithTypeAnnotationExceedingLineLength(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def function(first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None) -> None: pass @@ -3137,8 +2896,7 @@ def function(first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None) -> None def function(first_argument_xxxxxxxxxxxxxxxxxxxxxxx=(0,), second_argument=None) -> None: pass """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def function( first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None ) -> None: @@ -3153,19 +2911,17 @@ def function( try: style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{based_on_style: yapf,' - ' indent_closing_brackets: True}')) + style.CreateStyleFromConfig('{based_on_style: yapf,' + ' indent_closing_brackets: True}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testIndentClosingBracketsInFunctionCall(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def function(first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None, third_and_final_argument=True): pass @@ -3173,8 +2929,7 @@ def function(first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None, third_a def function(first_argument_xxxxxxxxxxxxxxxxxxxxxxx=(0,), second_and_last_argument=None): pass """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def function( first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None, @@ -3191,19 +2946,17 @@ def function( try: style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{based_on_style: yapf,' - ' indent_closing_brackets: True}')) + style.CreateStyleFromConfig('{based_on_style: yapf,' + ' indent_closing_brackets: True}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testIndentClosingBracketsInTuple(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def function(): some_var = ('a long element', 'another long element', 'short element', 'really really long element') return True @@ -3212,8 +2965,7 @@ def function(): some_var = ('a couple', 'small', 'elemens') return False """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def function(): some_var = ( 'a long element', 'another long element', 'short element', @@ -3229,19 +2981,17 @@ def function(): try: style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{based_on_style: yapf,' - ' indent_closing_brackets: True}')) + style.CreateStyleFromConfig('{based_on_style: yapf,' + ' indent_closing_brackets: True}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testIndentClosingBracketsInList(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def function(): some_var = ['a long element', 'another long element', 'short element', 'really really long element'] return True @@ -3250,8 +3000,7 @@ def function(): some_var = ['a couple', 'small', 'elemens'] return False """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def function(): some_var = [ 'a long element', 'another long element', 'short element', @@ -3267,19 +3016,17 @@ def function(): try: style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{based_on_style: yapf,' - ' indent_closing_brackets: True}')) + style.CreateStyleFromConfig('{based_on_style: yapf,' + ' indent_closing_brackets: True}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testIndentClosingBracketsInDict(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def function(): some_var = {1: ('a long element', 'and another really really long element that is really really amazingly long'), 2: 'another long element', 3: 'short element', 4: 'really really long element'} return True @@ -3288,8 +3035,7 @@ def function(): some_var = {1: 'a couple', 2: 'small', 3: 'elemens'} return False """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def function(): some_var = { 1: @@ -3311,19 +3057,17 @@ def function(): try: style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{based_on_style: yapf,' - ' indent_closing_brackets: True}')) + style.CreateStyleFromConfig('{based_on_style: yapf,' + ' indent_closing_brackets: True}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testMultipleDictionariesInList(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ class A: def b(): d = { @@ -3349,8 +3093,7 @@ def b(): ] } """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ class A: def b(): @@ -3382,10 +3125,9 @@ def testForceMultilineDict_True(self): style.CreateStyleFromConfig('{force_multiline_dict: true}')) unformatted_code = textwrap.dedent( "responseDict = {'childDict': {'spam': 'eggs'}}\n") - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - actual = reformatter.Reformat(llines) - expected = textwrap.dedent( - """\ + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + actual = reformatter.Reformat(llines) + expected = textwrap.dedent("""\ responseDict = { 'childDict': { 'spam': 'eggs' @@ -3400,26 +3142,23 @@ def testForceMultilineDict_False(self): try: style.SetGlobalStyle( style.CreateStyleFromConfig('{force_multiline_dict: false}')) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ responseDict = {'childDict': {'spam': 'eggs'}} """) expected_formatted_code = unformatted_code - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) @unittest.skipUnless(py3compat.PY38, 'Requires Python 3.8') def testWalrus(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ if (x := len([1]*1000)>100): print(f'{x} is pretty big' ) """) - expected = textwrap.dedent( - """\ + expected = textwrap.dedent("""\ if (x := len([1] * 1000) > 100): print(f'{x} is pretty big') """) @@ -3431,49 +3170,44 @@ def testAlignAssignBlankLineInbetween(self): try: style.SetGlobalStyle( style.CreateStyleFromConfig('{align_assignment: true}')) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ val_first = 1 val_second += 2 val_third = 3 """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ val_first = 1 val_second += 2 val_third = 3 """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testAlignAssignCommentLineInbetween(self): try: style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{align_assignment: true,' - 'new_alignment_after_commentline = true}')) - unformatted_code = textwrap.dedent( - """\ + style.CreateStyleFromConfig('{align_assignment: true,' + 'new_alignment_after_commentline = true}')) + unformatted_code = textwrap.dedent("""\ val_first = 1 val_second += 2 # comment val_third = 3 """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ val_first = 1 val_second += 2 # comment val_third = 3 """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) @@ -3481,8 +3215,7 @@ def testAlignAssignDefLineInbetween(self): try: style.SetGlobalStyle( style.CreateStyleFromConfig('{align_assignment: true}')) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ val_first = 1 val_second += 2 def fun(): @@ -3490,8 +3223,7 @@ def fun(): abc = '' val_third = 3 """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ val_first = 1 val_second += 2 @@ -3504,8 +3236,8 @@ def fun(): val_third = 3 """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) @@ -3513,8 +3245,7 @@ def testAlignAssignObjectWithNewLineInbetween(self): try: style.SetGlobalStyle( style.CreateStyleFromConfig('{align_assignment: true}')) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ val_first = 1 val_second += 2 object = { @@ -3524,8 +3255,7 @@ def testAlignAssignObjectWithNewLineInbetween(self): } val_third = 3 """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ val_first = 1 val_second += 2 object = { @@ -3536,8 +3266,8 @@ def testAlignAssignObjectWithNewLineInbetween(self): val_third = 3 """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) @@ -3545,26 +3275,23 @@ def testAlignAssignWithOnlyOneAssignmentLine(self): try: style.SetGlobalStyle( style.CreateStyleFromConfig('{align_assignment: true}')) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent("""\ val_first = 1 """) expected_formatted_code = unformatted_code - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) -########## for Align_ArgAssign()########### - + ########## for Align_ArgAssign()########### def testAlignArgAssignTypedName(self): try: style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{align_argument_assignment: true,' - 'split_before_first_argument: true}')) - unformatted_code = textwrap.dedent( - """\ + style.CreateStyleFromConfig('{align_argument_assignment: true,' + 'split_before_first_argument: true}')) + unformatted_code = textwrap.dedent("""\ def f1( self, *, @@ -3577,8 +3304,7 @@ def f1( ini_section: str="" ): pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def f1( self, *, @@ -3592,8 +3318,8 @@ def f1( pass """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) @@ -3603,8 +3329,7 @@ def testAlignArgAssignNestedArglistInBetween(self): try: style.SetGlobalStyle( style.CreateStyleFromConfig('{align_argument_assignment: true}')) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ arglist = test( first_argument='', second_argument=fun( @@ -3614,8 +3339,7 @@ def testAlignArgAssignNestedArglistInBetween(self): fourth_argument=4 ) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ arglist = test( first_argument ='', second_argument =fun( @@ -3628,8 +3352,8 @@ def testAlignArgAssignNestedArglistInBetween(self): fourth_argument =4) """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) @@ -3637,11 +3361,9 @@ def testAlignArgAssignNestedArglistInBetween(self): def testAlignArgAssignCommentLineInBetween(self): try: style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{align_argument_assignment: true,' - 'new_alignment_after_commentline:true}')) - unformatted_code = textwrap.dedent( - """\ + style.CreateStyleFromConfig('{align_argument_assignment: true,' + 'new_alignment_after_commentline:true}')) + unformatted_code = textwrap.dedent("""\ arglist = test( client_id=0, username_id=1, @@ -3649,8 +3371,7 @@ def testAlignArgAssignCommentLineInBetween(self): user_name='xxxxxxxxxxxxxxxxxxxxx' ) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ arglist = test( client_id =0, username_id =1, @@ -3658,8 +3379,8 @@ def testAlignArgAssignCommentLineInBetween(self): user_name ='xxxxxxxxxxxxxxxxxxxxx') """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) @@ -3667,15 +3388,14 @@ def testAlignArgAssignWithOnlyFirstArgOnNewline(self): try: style.SetGlobalStyle( style.CreateStyleFromConfig('{align_argument_assignment: true}')) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ arglist = self.get_data_from_excelsheet( client_id=0, username_id=1, user_name='xxxxxxxxxxxxxxxxxxxx') """) expected_formatted_code = unformatted_code - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) @@ -3683,22 +3403,20 @@ def testAlignArgAssignArgumentsCanFitInOneLine(self): try: style.SetGlobalStyle( style.CreateStyleFromConfig('{align_argument_assignment: true}')) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def function( first_argument_xxxxxx =(0,), second_argument =None ) -> None: pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def function(first_argument_xxxxxx=(0,), second_argument=None) -> None: pass """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) @@ -3707,13 +3425,11 @@ def testAlignDictColonNestedDictInBetween(self): try: style.SetGlobalStyle( style.CreateStyleFromConfig('{align_dict_colon: true}')) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ fields = [{"type": "text","required": True,"html": {"attr": 'style="width: 250px;" maxlength="30"',"page": 0,}, "list" : [1, 2, 3, 4]}] """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ fields = [{ "type" : "text", "required" : True, @@ -3725,27 +3441,24 @@ def testAlignDictColonNestedDictInBetween(self): }] """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) def testAlignDictColonCommentLineInBetween(self): try: style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{align_dict_colon: true,' - 'new_alignment_after_commentline: true}')) - unformatted_code = textwrap.dedent( - """\ + style.CreateStyleFromConfig('{align_dict_colon: true,' + 'new_alignment_after_commentline: true}')) + unformatted_code = textwrap.dedent("""\ fields = [{ "type": "text", "required": True, # comment "list": [1, 2, 3, 4]}] """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ fields = [{ "type" : "text", "required" : True, @@ -3754,8 +3467,8 @@ def testAlignDictColonCommentLineInBetween(self): }] """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) @@ -3763,16 +3476,14 @@ def testAlignDictColonLargerExistingSpacesBefore(self): try: style.SetGlobalStyle( style.CreateStyleFromConfig('{align_dict_colon: true}')) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ fields = [{ "type" : "text", "required" : True, "list" : [1, 2, 3, 4], }] """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ fields = [{ "type" : "text", "required" : True, @@ -3780,8 +3491,8 @@ def testAlignDictColonLargerExistingSpacesBefore(self): }] """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) @@ -3789,16 +3500,14 @@ def testAlignDictColonCommentAfterOpenBracket(self): try: style.SetGlobalStyle( style.CreateStyleFromConfig('{align_dict_colon: true}')) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ fields = [{ # comment "type": "text", "required": True, "list": [1, 2, 3, 4]}] """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ fields = [{ # comment "type" : "text", @@ -3807,10 +3516,13 @@ def testAlignDictColonCommentAfterOpenBracket(self): }] """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) + + + if __name__ == '__main__': unittest.main() diff --git a/yapftests/reformatter_buganizer_test.py b/yapftests/reformatter_buganizer_test.py index d8beb04cb..54a62b588 100644 --- a/yapftests/reformatter_buganizer_test.py +++ b/yapftests/reformatter_buganizer_test.py @@ -29,7 +29,7 @@ def setUpClass(cls): style.SetGlobalStyle(style.CreateYapfStyle()) def testB137580392(self): - code = """\ + code = """\ def _create_testing_simulator_and_sink( ) -> Tuple[_batch_simulator:_batch_simulator.BatchSimulator, _batch_simulator.SimulationSink]: @@ -39,7 +39,7 @@ def _create_testing_simulator_and_sink( self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB73279849(self): - unformatted_code = """\ + unformatted_code = """\ class A: def _(a): return 'hello' [ a ] @@ -49,11 +49,11 @@ class A: def _(a): return 'hello'[a] """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB122455211(self): - unformatted_code = """\ + unformatted_code = """\ _zzzzzzzzzzzzzzzzzzzz = Union[sssssssssssssssssssss.pppppppppppppppp, sssssssssssssssssssss.pppppppppppppppppppppppppppp] """ @@ -62,11 +62,11 @@ def testB122455211(self): sssssssssssssssssssss.pppppppppppppppp, sssssssssssssssssssss.pppppppppppppppppppppppppppp] """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB119300344(self): - code = """\ + code = """\ def _GenerateStatsEntries( process_id: Text, timestamp: Optional[rdfvalue.RDFDatetime] = None @@ -77,7 +77,7 @@ def _GenerateStatsEntries( self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB132886019(self): - code = """\ + code = """\ X = { 'some_dict_key': frozenset([ @@ -90,7 +90,7 @@ def testB132886019(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB26521719(self): - code = """\ + code = """\ class _(): def _(self): @@ -101,7 +101,7 @@ def _(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB122541552(self): - code = """\ + code = """\ # pylint: disable=g-explicit-bool-comparison,singleton-comparison _QUERY = account.Account.query(account.Account.enabled == True) # pylint: enable=g-explicit-bool-comparison,singleton-comparison @@ -114,7 +114,7 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB124415889(self): - code = """\ + code = """\ class _(): def run_queue_scanners(): @@ -137,7 +137,7 @@ def modules_to_install(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB73166511(self): - code = """\ + code = """\ def _(): if min_std is not None: groundtruth_age_variances = tf.maximum(groundtruth_age_variances, @@ -147,7 +147,7 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB118624921(self): - code = """\ + code = """\ def _(): function_call( alert_name='xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx', @@ -160,7 +160,7 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB35417079(self): - code = """\ + code = """\ class _(): def _(): @@ -175,7 +175,7 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB120047670(self): - unformatted_code = """\ + unformatted_code = """\ X = { 'NO_PING_COMPONENTS': [ 79775, # Releases / FOO API @@ -195,11 +195,11 @@ def testB120047670(self): 'PING_BLOCKED_BUGS': False, } """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB120245013(self): - unformatted_code = """\ + unformatted_code = """\ class Foo(object): def testNoAlertForShortPeriod(self, rutabaga): self.targets[:][streamz_path,self._fillInOtherFields(streamz_path, {streamz_field_of_interest:True})] = series.Counter('1s', '+ 500x10000') @@ -213,11 +213,11 @@ def testNoAlertForShortPeriod(self, rutabaga): self._fillInOtherFields(streamz_path, {streamz_field_of_interest: True} )] = series.Counter('1s', '+ 500x10000') """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB117841880(self): - code = """\ + code = """\ def xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( aaaaaaaaaaaaaaaaaaa: AnyStr, bbbbbbbbbbbb: Optional[Sequence[AnyStr]] = None, @@ -234,7 +234,7 @@ def xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB111764402(self): - unformatted_code = """\ + unformatted_code = """\ x = self.stubs.stub(video_classification_map, 'read_video_classifications', (lambda external_ids, **unused_kwargs: {external_id: self._get_serving_classification('video') for external_id in external_ids})) """ # noqa expected_formatted_code = """\ @@ -244,11 +244,11 @@ def testB111764402(self): for external_id in external_ids })) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB116825060(self): - code = """\ + code = """\ result_df = pd.DataFrame({LEARNED_CTR_COLUMN: learned_ctr}, index=df_metrics.index) """ @@ -256,7 +256,7 @@ def testB116825060(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB112711217(self): - code = """\ + code = """\ def _(): stats['moderated'] = ~stats.moderation_reason.isin( approved_moderation_reasons) @@ -265,7 +265,7 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB112867548(self): - unformatted_code = """\ + unformatted_code = """\ def _(): return flask.make_response( 'Records: {}, Problems: {}, More: {}'.format( @@ -283,11 +283,11 @@ def _(): httplib.ACCEPTED if process_result.has_more else httplib.OK, {'content-type': _TEXT_CONTEXT_TYPE}) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB112651423(self): - unformatted_code = """\ + unformatted_code = """\ def potato(feeditems, browse_use_case=None): for item in turnip: if kumquat: @@ -302,11 +302,11 @@ def potato(feeditems, browse_use_case=None): 'FEEDS_LOAD_PLAYLIST_VIDEOS_FOR_ALL_ITEMS'] and item.video: continue """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB80484938(self): - code = """\ + code = """\ for sssssss, aaaaaaaaaa in [ ('ssssssssssssssssssss', 'sssssssssssssssssssssssss'), ('nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn', @@ -349,7 +349,7 @@ def testB80484938(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB120771563(self): - code = """\ + code = """\ class A: def b(): @@ -376,7 +376,7 @@ def b(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB79462249(self): - code = """\ + code = """\ foo.bar(baz, [ quux(thud=42), norf, @@ -398,7 +398,7 @@ def testB79462249(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB113210278(self): - unformatted_code = """\ + unformatted_code = """\ def _(): aaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb.cccccccccccccccccccccccccccc(\ eeeeeeeeeeeeeeeeeeeeeeeeee.fffffffffffffffffffffffffffffffffffffff.\ @@ -410,11 +410,11 @@ def _(): eeeeeeeeeeeeeeeeeeeeeeeeee.fffffffffffffffffffffffffffffffffffffff .ggggggggggggggggggggggggggggggggg.hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh()) """ # noqa - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB77923341(self): - code = """\ + code = """\ def f(): if (aaaaaaaaaaaaaa.bbbbbbbbbbbb.ccccc <= 0 and # pytype: disable=attribute-error ddddddddddd.eeeeeeeee == constants.FFFFFFFFFFFFFF): @@ -424,7 +424,7 @@ def f(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB77329955(self): - code = """\ + code = """\ class _(): @parameterized.named_parameters( @@ -442,7 +442,7 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB65197969(self): - unformatted_code = """\ + unformatted_code = """\ class _(): def _(): @@ -457,11 +457,11 @@ def _(): seconds=max(float(time_scale), small_interval) * 1.41**min(num_attempts, 9)) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB65546221(self): - unformatted_code = """\ + unformatted_code = """\ SUPPORTED_PLATFORMS = ( "centos-6", "centos-7", @@ -484,11 +484,11 @@ def testB65546221(self): "debian-9-stretch", ) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB30500455(self): - unformatted_code = """\ + unformatted_code = """\ INITIAL_SYMTAB = dict([(name, 'exception#' + name) for name in INITIAL_EXCEPTIONS ] * [(name, 'type#' + name) for name in INITIAL_TYPES] + [ (name, 'function#' + name) for name in INITIAL_FUNCTIONS @@ -501,11 +501,11 @@ def testB30500455(self): [(name, 'function#' + name) for name in INITIAL_FUNCTIONS] + [(name, 'const#' + name) for name in INITIAL_CONSTS]) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB38343525(self): - code = """\ + code = """\ # This does foo. @arg.String('some_path_to_a_file', required=True) # This does bar. @@ -517,7 +517,7 @@ def f(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB37099651(self): - unformatted_code = """\ + unformatted_code = """\ _MEMCACHE = lazy.MakeLazy( # pylint: disable=g-long-lambda lambda: function.call.mem.clients(FLAGS.some_flag_thingy, default_namespace=_LAZY_MEM_NAMESPACE, allow_pickle=True) @@ -534,11 +534,11 @@ def testB37099651(self): # pylint: enable=g-long-lambda ) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB33228502(self): - unformatted_code = """\ + unformatted_code = """\ def _(): success_rate_stream_table = module.Precompute( query_function=module.DefineQueryFunction( @@ -572,11 +572,11 @@ def _(): | m.Join('successes', 'total') | m.Point(m.VAL['successes'] / m.VAL['total'])))) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB30394228(self): - code = """\ + code = """\ class _(): def _(self): @@ -589,7 +589,7 @@ def _(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB65246454(self): - unformatted_code = """\ + unformatted_code = """\ class _(): def _(self): @@ -605,11 +605,11 @@ def _(self): self.assertEqual({i.id for i in successful_instances}, {i.id for i in self._statuses.successful_instances}) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB67935450(self): - unformatted_code = """\ + unformatted_code = """\ def _(): return ( (Gauge( @@ -646,11 +646,11 @@ def _(): m.Cond(m.VAL['start'] != 0, m.VAL['start'], m.TimestampMicros() / 1000000L))) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB66011084(self): - unformatted_code = """\ + unformatted_code = """\ X = { "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa": # Comment 1. ([] if True else [ # Comment 2. @@ -678,22 +678,22 @@ def testB66011084(self): ]), } """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB67455376(self): - unformatted_code = """\ + unformatted_code = """\ sponge_ids.extend(invocation.id() for invocation in self._client.GetInvocationsByLabels(labels)) """ # noqa expected_formatted_code = """\ sponge_ids.extend(invocation.id() for invocation in self._client.GetInvocationsByLabels(labels)) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB35210351(self): - unformatted_code = """\ + unformatted_code = """\ def _(): config.AnotherRuleThing( 'the_title_to_the_thing_here', @@ -719,11 +719,11 @@ def _(): GetTheAlertToIt('the_title_to_the_thing_here'), GetNotificationTemplate('your_email_here'))) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB34774905(self): - unformatted_code = """\ + unformatted_code = """\ x=[VarExprType(ir_name=IrName( value='x', expr_type=UnresolvedAttrExprType( atom=UnknownExprType(), attr_name=IrName( value='x', expr_type=UnknownExprType(), usage='UNKNOWN', fqn=None, @@ -748,18 +748,18 @@ def testB34774905(self): astn=None)) ] """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB65176185(self): - code = """\ + code = """\ xx = zip(*[(a, b) for (a, b, c) in yy]) """ llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB35210166(self): - unformatted_code = """\ + unformatted_code = """\ def _(): query = ( m.Fetch(n.Raw('monarch.BorgTask', '/proc/container/memory/usage'), { 'borg_user': borguser, 'borg_job': jobname }) @@ -776,11 +776,11 @@ def _(): | o.Window(m.Align('5m')) | p.GroupBy(['borg_user', 'borg_job', 'borg_cell'], q.Mean())) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB32167774(self): - unformatted_code = """\ + unformatted_code = """\ X = ( 'is_official', 'is_cover', @@ -803,11 +803,11 @@ def testB32167774(self): 'is_compilation', ) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB66912275(self): - unformatted_code = """\ + unformatted_code = """\ def _(): with self.assertRaisesRegexp(errors.HttpError, 'Invalid'): patch_op = api_client.forwardingRules().patch( @@ -827,11 +827,11 @@ def _(): 'fingerprint': base64.urlsafe_b64encode('invalid_fingerprint') }).execute() """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB67312284(self): - code = """\ + code = """\ def _(): self.assertEqual( [u'to be published 2', u'to be published 1', u'to be published 0'], @@ -841,7 +841,7 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB65241516(self): - unformatted_code = """\ + unformatted_code = """\ checkpoint_files = gfile.Glob(os.path.join(TrainTraceDir(unit_key, "*", "*"), embedding_model.CHECKPOINT_FILENAME + "-*")) """ # noqa expected_formatted_code = """\ @@ -850,12 +850,11 @@ def testB65241516(self): TrainTraceDir(unit_key, "*", "*"), embedding_model.CHECKPOINT_FILENAME + "-*")) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB37460004(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ assert all(s not in (_SENTINEL, None) for s in nested_schemas ), 'Nested schemas should never contain None/_SENTINEL' """) @@ -863,7 +862,7 @@ def testB37460004(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB36806207(self): - code = """\ + code = """\ def _(): linearity_data = [[row] for row in [ "%.1f mm" % (np.mean(linearity_values["pos_error"]) * 1000.0), @@ -882,8 +881,7 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB36215507(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ class X(): def _(): @@ -897,8 +895,7 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB35212469(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def _(): X = { 'retain': { @@ -907,8 +904,7 @@ def _(): } } """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def _(): X = { 'retain': { @@ -921,14 +917,12 @@ def _(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB31063453(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def _(): while ((not mpede_proc) or ((time_time() - last_modified) < FLAGS_boot_idle_timeout)): pass """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def _(): while ((not mpede_proc) or ((time_time() - last_modified) < FLAGS_boot_idle_timeout)): @@ -938,8 +932,7 @@ def _(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB35021894(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def _(): labelacl = Env(qa={ 'read': 'name/some-type-of-very-long-name-for-reading-perms', @@ -950,8 +943,7 @@ def _(): 'modify': 'name/some-other-type-of-very-long-name-for-modifying' }) """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def _(): labelacl = Env( qa={ @@ -967,12 +959,10 @@ def _(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB34682902(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ logging.info("Mean angular velocity norm: %.3f", np.linalg.norm(np.mean(ang_vel_arr, axis=0))) """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ logging.info("Mean angular velocity norm: %.3f", np.linalg.norm(np.mean(ang_vel_arr, axis=0))) """) @@ -980,15 +970,13 @@ def testB34682902(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB33842726(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ class _(): def _(): hints.append(('hg tag -f -l -r %s %s # %s' % (short(ctx.node( )), candidatetag, firstline))[:78]) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ class _(): def _(): hints.append(('hg tag -f -l -r %s %s # %s' % @@ -998,8 +986,7 @@ def _(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB32931780(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ environments = { 'prod': { # this is a comment before the first entry. @@ -1030,8 +1017,7 @@ def testB32931780(self): } } """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ environments = { 'prod': { # this is a comment before the first entry. @@ -1062,8 +1048,7 @@ def testB32931780(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB33047408(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ def _(): for sort in (sorts or []): request['sorts'].append({ @@ -1077,8 +1062,7 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB32714745(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ class _(): def _BlankDefinition(): @@ -1108,16 +1092,14 @@ def _BlankDefinition(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB32737279(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ here_is_a_dict = { 'key': # Comment. 'value' } """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ here_is_a_dict = { 'key': # Comment. 'value' @@ -1127,8 +1109,7 @@ def testB32737279(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB32570937(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ def _(): if (job_message.ball not in ('*', ball) or job_message.call not in ('*', call) or @@ -1139,8 +1120,7 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB31937033(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ class _(): def __init__(self, metric, fields_cb=None): @@ -1150,7 +1130,7 @@ def __init__(self, metric, fields_cb=None): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB31911533(self): - code = """\ + code = """\ class _(): @parameterized.NamedParameters( @@ -1166,8 +1146,7 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB31847238(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ class _(): def aaaaa(self, bbbbb, cccccccccccccc=None): # TODO(who): pylint: disable=unused-argument @@ -1176,8 +1155,7 @@ def aaaaa(self, bbbbb, cccccccccccccc=None): # TODO(who): pylint: disable=unuse def xxxxx(self, yyyyy, zzzzzzzzzzzzzz=None): # A normal comment that runs over the column limit. return 1 """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ class _(): def aaaaa(self, bbbbb, cccccccccccccc=None): # TODO(who): pylint: disable=unused-argument @@ -1193,13 +1171,11 @@ def xxxxx( self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB30760569(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ {'1234567890123456789012345678901234567890123456789012345678901234567890': '1234567890123456789012345678901234567890'} """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ { '1234567890123456789012345678901234567890123456789012345678901234567890': '1234567890123456789012345678901234567890' @@ -1209,15 +1185,13 @@ def testB30760569(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB26034238(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ class Thing: def Function(self): thing.Scrape('/aaaaaaaaa/bbbbbbbbbb/ccccc/dddd/eeeeeeeeeeeeee/ffffffffffffff').AndReturn(42) """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ class Thing: def Function(self): @@ -1229,8 +1203,7 @@ def Function(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB30536435(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def main(unused_argv): if True: if True: @@ -1239,8 +1212,7 @@ def main(unused_argv): ccccccccc.within, imports.ddddddddddddddddddd(name_item.ffffffffffffffff))) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def main(unused_argv): if True: if True: @@ -1252,14 +1224,12 @@ def main(unused_argv): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB30442148(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def lulz(): return (some_long_module_name.SomeLongClassName. some_long_attribute_name.some_long_method_name()) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def lulz(): return (some_long_module_name.SomeLongClassName.some_long_attribute_name .some_long_method_name()) @@ -1268,8 +1238,7 @@ def lulz(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB26868213(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def _(): xxxxxxxxxxxxxxxxxxx = { 'ssssss': {'ddddd': 'qqqqq', @@ -1284,8 +1253,7 @@ def _(): } } """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def _(): xxxxxxxxxxxxxxxxxxx = { 'ssssss': { @@ -1306,8 +1274,7 @@ def _(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB30173198(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ class _(): def _(): @@ -1318,8 +1285,7 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB29908765(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ class _(): def __repr__(self): @@ -1330,8 +1296,7 @@ def __repr__(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB30087362(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ def _(): for s in sorted(env['foo']): bar() @@ -1344,8 +1309,7 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB30087363(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ if False: bar() # This is a comment @@ -1357,14 +1321,12 @@ def testB30087363(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB29093579(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def _(): _xxxxxxxxxxxxxxx(aaaaaaaa, bbbbbbbbbbbbbb.cccccccccc[ dddddddddddddddddddddddddddd.eeeeeeeeeeeeeeeeeeeeee.fffffffffffffffffffff]) """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def _(): _xxxxxxxxxxxxxxx( aaaaaaaa, @@ -1375,8 +1337,7 @@ def _(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB26382315(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ @hello_world # This is a first comment @@ -1388,8 +1349,7 @@ def foo(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB27616132(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ if True: query.fetch_page.assert_has_calls([ mock.call(100, @@ -1400,8 +1360,7 @@ def testB27616132(self): start_cursor=cursor_2), ]) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ if True: query.fetch_page.assert_has_calls([ mock.call(100, start_cursor=None), @@ -1413,8 +1372,7 @@ def testB27616132(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB27590179(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ if True: if True: self.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = ( @@ -1424,8 +1382,7 @@ def testB27590179(self): self.bbb.cccccccccc(ddddddddddddddddddddddd.eeeeeeeeeeeeeeeeeeeeee) }) """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ if True: if True: self.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = ({ @@ -1439,13 +1396,11 @@ def testB27590179(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB27266946(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def _(): aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = (self.bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb.cccccccccccccccccccccccccccccccccccc) """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def _(): aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = ( self.bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb @@ -1455,8 +1410,7 @@ def _(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB25505359(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ _EXAMPLE = { 'aaaaaaaaaaaaaa': [{ 'bbbb': 'cccccccccccccccccccccc', @@ -1471,8 +1425,7 @@ def testB25505359(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB25324261(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ aaaaaaaaa = set(bbbb.cccc for ddd in eeeeee.fffffffffff.gggggggggggggggg for cccc in ddd.specification) @@ -1481,8 +1434,7 @@ def testB25324261(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB25136704(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ class f: def test(self): @@ -1494,8 +1446,7 @@ def test(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB25165602(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ def f(): ids = {u: i for u, i in zip(self.aaaaa, xrange(42, 42 + len(self.aaaaaa)))} """) # noqa @@ -1503,8 +1454,7 @@ def f(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB25157123(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ def ListArgs(): FairlyLongMethodName([relatively_long_identifier_for_a_list], another_argument_with_a_long_identifier) @@ -1513,8 +1463,7 @@ def ListArgs(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB25136820(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def foo(): return collections.OrderedDict({ # Preceding comment. @@ -1522,8 +1471,7 @@ def foo(): '$bbbbbbbbbbbbbbbbbbbbbbbb', }) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def foo(): return collections.OrderedDict({ # Preceding comment. @@ -1535,15 +1483,13 @@ def foo(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB25131481(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ APPARENT_ACTIONS = ('command_type', { 'materialize': lambda x: some_type_of_function('materialize ' + x.command_def), '#': lambda x: x # do nothing }) """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ APPARENT_ACTIONS = ( 'command_type', { @@ -1557,8 +1503,7 @@ def testB25131481(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB23445244(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def foo(): if True: return xxxxxxxxxxxxxxxx( @@ -1569,8 +1514,7 @@ def foo(): FLAGS.aaaaaaaaaaaaaa + FLAGS.bbbbbbbbbbbbbbbbbbb, }) """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def foo(): if True: return xxxxxxxxxxxxxxxx( @@ -1586,8 +1530,7 @@ def foo(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB20559654(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ class A(object): def foo(self): @@ -1595,8 +1538,7 @@ def foo(self): ['AA BBBB CCC DDD EEEEEEEE X YY ZZZZ FFF EEE AAAAAAAA'], aaaaaaaaaaa=True, bbbbbbbb=None) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ class A(object): def foo(self): @@ -1609,8 +1551,7 @@ def foo(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB23943842(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ class F(): def f(): self.assertDictEqual( @@ -1624,8 +1565,7 @@ def f(): 'lines': 'l8'} }) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ class F(): def f(): @@ -1649,14 +1589,12 @@ def f(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB20551180(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def foo(): if True: return (struct.pack('aaaa', bbbbbbbbbb, ccccccccccccccc, dddddddd) + eeeeeee) """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def foo(): if True: return (struct.pack('aaaa', bbbbbbbbbb, ccccccccccccccc, dddddddd) + @@ -1666,14 +1604,12 @@ def foo(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB23944849(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ class A(object): def xxxxxxxxx(self, aaaaaaa, bbbbbbb=ccccccccccc, dddddd=300, eeeeeeeeeeeeee=None, fffffffffffffff=0): pass """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ class A(object): def xxxxxxxxx(self, @@ -1688,14 +1624,12 @@ def xxxxxxxxx(self, self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB23935890(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ class F(): def functioni(self, aaaaaaa, bbbbbbb, cccccc, dddddddddddddd, eeeeeeeeeeeeeee): pass """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ class F(): def functioni(self, aaaaaaa, bbbbbbb, cccccc, dddddddddddddd, @@ -1706,8 +1640,7 @@ def functioni(self, aaaaaaa, bbbbbbb, cccccc, dddddddddddddd, self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB28414371(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ def _(): return ((m.fffff( m.rrr('mmmmmmmmmmmmmmmm', 'ssssssssssssssssssssssssss'), ffffffffffffffff) @@ -1732,8 +1665,7 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB20127686(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ def f(): if True: return ((m.fffff( @@ -1751,13 +1683,11 @@ def f(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB20016122(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ from a_very_long_or_indented_module_name_yada_yada import (long_argument_1, long_argument_2) """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ from a_very_long_or_indented_module_name_yada_yada import ( long_argument_1, long_argument_2) """) @@ -1768,13 +1698,12 @@ def testB20016122(self): '{based_on_style: pep8, split_penalty_import_names: 350}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreatePEP8Style()) - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ class foo(): def __eq__(self, other): @@ -1794,9 +1723,8 @@ def __eq__(self, other): try: style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{based_on_style: yapf, ' - 'split_before_logical_operator: True}')) + style.CreateStyleFromConfig('{based_on_style: yapf, ' + 'split_before_logical_operator: True}')) llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) @@ -1804,14 +1732,12 @@ def __eq__(self, other): style.SetGlobalStyle(style.CreateYapfStyle()) def testB22527411(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def f(): if True: aaaaaa.bbbbbbbbbbbbbbbbbbbb[-1].cccccccccccccc.ddd().eeeeeeee(ffffffffffffff) """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def f(): if True: aaaaaa.bbbbbbbbbbbbbbbbbbbb[-1].cccccccccccccc.ddd().eeeeeeee( @@ -1821,8 +1747,7 @@ def f(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB20849933(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def main(unused_argv): if True: aaaaaaaa = { @@ -1830,8 +1755,7 @@ def main(unused_argv): (eeeeee.FFFFFFFFFFFFFFFFFF), } """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def main(unused_argv): if True: aaaaaaaa = { @@ -1843,8 +1767,7 @@ def main(unused_argv): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB20813997(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ def myfunc_1(): myarray = numpy.zeros((2, 2, 2)) print(myarray[:, 1, :]) @@ -1853,8 +1776,7 @@ def myfunc_1(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB20605036(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ foo = { 'aaaa': { # A comment for no particular reason. @@ -1868,8 +1790,7 @@ def testB20605036(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB20562732(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ foo = [ # Comment about first list item 'First item', @@ -1881,8 +1802,7 @@ def testB20562732(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB20128830(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ a = { 'xxxxxxxxxxxxxxxxxxxx': { 'aaaa': @@ -1902,8 +1822,7 @@ def testB20128830(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB20073838(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ class DummyModel(object): def do_nothing(self, class_1_count): @@ -1920,8 +1839,7 @@ def do_nothing(self, class_1_count): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB19626808(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ if True: aaaaaaaaaaaaaaaaaaaaaaa.bbbbbbbbb( 'ccccccccccc', ddddddddd='eeeee').fffffffff([ggggggggggggggggggggg]) @@ -1930,8 +1848,7 @@ def testB19626808(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB19547210(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ while True: if True: if True: @@ -1945,8 +1862,7 @@ def testB19547210(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB19377034(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ def f(): if (aaaaaaaaaaaaaaa.start >= aaaaaaaaaaaaaaa.end or bbbbbbbbbbbbbbb.start >= bbbbbbbbbbbbbbb.end): @@ -1956,8 +1872,7 @@ def f(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB19372573(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ def f(): if a: return 42 while True: @@ -1975,8 +1890,7 @@ def f(): style.SetGlobalStyle(style.CreateYapfStyle()) def testB19353268(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ a = {1, 2, 3}[x] b = {'foo': 42, 'bar': 37}['foo'] """) @@ -1984,8 +1898,7 @@ def testB19353268(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB19287512(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ class Foo(object): def bar(self): @@ -1995,8 +1908,7 @@ def bar(self): .Mmmmmmmmmmmmmmmmmm(-1, 'permission error'))): self.assertRaises(nnnnnnnnnnnnnnnn.ooooo, ppppp.qqqqqqqqqqqqqqqqq) """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ class Foo(object): def bar(self): @@ -2011,8 +1923,7 @@ def bar(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB19194420(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ method.Set( 'long argument goes here that causes the line to break', lambda arg2=0.5: arg2) @@ -2021,7 +1932,7 @@ def testB19194420(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB19073499(self): - code = """\ + code = """\ instance = ( aaaaaaa.bbbbbbb().ccccccccccccccccc().ddddddddddd({ 'aa': 'context!' @@ -2033,8 +1944,7 @@ def testB19073499(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB18257115(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ if True: if True: self._Test(aaaa, bbbbbbb.cccccccccc, dddddddd, eeeeeeeeeee, @@ -2044,8 +1954,7 @@ def testB18257115(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB18256666(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ class Foo(object): def Bar(self): @@ -2063,8 +1972,7 @@ def Bar(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB18256826(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ if True: pass # A multiline comment. @@ -2083,8 +1991,7 @@ def testB18256826(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB18255697(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ AAAAAAAAAAAAAAA = { 'XXXXXXXXXXXXXX': 4242, # Inline comment # Next comment @@ -2095,14 +2002,12 @@ def testB18255697(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testB17534869(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ if True: self.assertLess(abs(time.time()-aaaa.bbbbbbbbbbb( datetime.datetime.now())), 1) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ if True: self.assertLess( abs(time.time() - aaaa.bbbbbbbbbbb(datetime.datetime.now())), 1) @@ -2111,16 +2016,14 @@ def testB17534869(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB17489866(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def f(): if True: if True: return aaaa.bbbbbbbbb(ccccccc=dddddddddddddd({('eeee', \ 'ffffffff'): str(j)})) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def f(): if True: if True: @@ -2131,8 +2034,7 @@ def f(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB17133019(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ class aaaaaaaaaaaaaa(object): def bbbbbbbbbb(self): @@ -2143,8 +2045,7 @@ def bbbbbbbbbb(self): ), "rb") as gggggggggggggggggggg: print(gggggggggggggggggggg) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ class aaaaaaaaaaaaaa(object): def bbbbbbbbbb(self): @@ -2158,8 +2059,7 @@ def bbbbbbbbbb(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB17011869(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ '''blah......''' class SomeClass(object): @@ -2170,8 +2070,7 @@ class SomeClass(object): 'DDDDDDDD': 0.4811 } """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ '''blah......''' @@ -2187,16 +2086,14 @@ class SomeClass(object): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB16783631(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ if True: with aaaaaaaaaaaaaa.bbbbbbbbbbbbb.ccccccc(ddddddddddddd, eeeeeeeee=self.fffffffffffff )as gggg: pass """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ if True: with aaaaaaaaaaaaaa.bbbbbbbbbbbbb.ccccccc( ddddddddddddd, eeeeeeeee=self.fffffffffffff) as gggg: @@ -2206,14 +2103,12 @@ def testB16783631(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB16572361(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def foo(self): def bar(my_dict_name): self.my_dict_name['foo-bar-baz-biz-boo-baa-baa'].IncrementBy.assert_called_once_with('foo_bar_baz_boo') """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def foo(self): def bar(my_dict_name): @@ -2225,15 +2120,13 @@ def bar(my_dict_name): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB15884241(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ if 1: if 1: for row in AAAA: self.create(aaaaaaaa="/aaa/bbbb/cccc/dddddd/eeeeeeeeeeeeeeeeeeeeeeeeee/%s" % row [0].replace(".foo", ".bar"), aaaaa=bbb[1], ccccc=bbb[2], dddd=bbb[3], eeeeeeeeeee=[s.strip() for s in bbb[4].split(",")], ffffffff=[s.strip() for s in bbb[5].split(",")], gggggg=bbb[6]) """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ if 1: if 1: for row in AAAA: @@ -2251,8 +2144,7 @@ def testB15884241(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB15697268(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def main(unused_argv): ARBITRARY_CONSTANT_A = 10 an_array_with_an_exceedingly_long_name = range(ARBITRARY_CONSTANT_A + 1) @@ -2261,8 +2153,7 @@ def main(unused_argv): a_long_name_slicing = an_array_with_an_exceedingly_long_name[:ARBITRARY_CONSTANT_A] bad_slice = ("I am a crazy, no good, string what's too long, etc." + " no really ")[:ARBITRARY_CONSTANT_A] """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def main(unused_argv): ARBITRARY_CONSTANT_A = 10 an_array_with_an_exceedingly_long_name = range(ARBITRARY_CONSTANT_A + 1) @@ -2278,7 +2169,7 @@ def main(unused_argv): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB15597568(self): - unformatted_code = """\ + unformatted_code = """\ if True: if True: if True: @@ -2292,16 +2183,14 @@ def testB15597568(self): (", and the process timed out." if did_time_out else ".")) % errorcode) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB15542157(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ aaaaaaaaaaaa = bbbb.ccccccccccccccc(dddddd.eeeeeeeeeeeeee, ffffffffffffffffff, gggggg.hhhhhhhhhhhhhhhhh) """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ aaaaaaaaaaaa = bbbb.ccccccccccccccc(dddddd.eeeeeeeeeeeeee, ffffffffffffffffff, gggggg.hhhhhhhhhhhhhhhhh) """) # noqa @@ -2309,8 +2198,7 @@ def testB15542157(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB15438132(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ if aaaaaaa.bbbbbbbbbb: cccccc.dddddddddd(eeeeeeeeeee=fffffffffffff.gggggggggggggggggg) if hhhhhh.iiiii.jjjjjjjjjjjjj: @@ -2326,8 +2214,7 @@ def testB15438132(self): lllll.mm), nnnnnnnnnn=ooooooo.pppppppppp) """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ if aaaaaaa.bbbbbbbbbb: cccccc.dddddddddd(eeeeeeeeeee=fffffffffffff.gggggggggggggggggg) if hhhhhh.iiiii.jjjjjjjjjjjjj: @@ -2346,7 +2233,7 @@ def testB15438132(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB14468247(self): - unformatted_code = """\ + unformatted_code = """\ call(a=1, b=2, ) @@ -2357,17 +2244,15 @@ def testB14468247(self): b=2, ) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB14406499(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def foo1(parameter_1, parameter_2, parameter_3, parameter_4, \ parameter_5, parameter_6): pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def foo1(parameter_1, parameter_2, parameter_3, parameter_4, parameter_5, parameter_6): pass @@ -2376,21 +2261,18 @@ def foo1(parameter_1, parameter_2, parameter_3, parameter_4, parameter_5, self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB13900309(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ self.aaaaaaaaaaa( # A comment in the middle of it all. 948.0/3600, self.bbb.ccccccccccccccccccccc(dddddddddddddddd.eeee, True)) """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ self.aaaaaaaaaaa( # A comment in the middle of it all. 948.0 / 3600, self.bbb.ccccccccccccccccccccc(dddddddddddddddd.eeee, True)) """) # noqa llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ aaaaaaaaaa.bbbbbbbbbbbbbbbbbbbbbbbb.cccccccccccccccccccccccccccccc( DC_1, (CL - 50, CL), AAAAAAAA, BBBBBBBBBBBBBBBB, 98.0, CCCCCCC).ddddddddd( # Look! A comment is here. @@ -2399,49 +2281,41 @@ def testB13900309(self): llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ aaaaaaaaaaaaaaaaaaaaaaaa.bbbbbbbbbbbbb.ccccccccccccccccccccccccc().dddddddddddddddddddddddddd(1, 2, 3, 4) """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ aaaaaaaaaaaaaaaaaaaaaaaa.bbbbbbbbbbbbb.ccccccccccccccccccccccccc( ).dddddddddddddddddddddddddd(1, 2, 3, 4) """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ aaaaaaaaaaaaaaaaaaaaaaaa.bbbbbbbbbbbbb.ccccccccccccccccccccccccc(x).dddddddddddddddddddddddddd(1, 2, 3, 4) """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ aaaaaaaaaaaaaaaaaaaaaaaa.bbbbbbbbbbbbb.ccccccccccccccccccccccccc( x).dddddddddddddddddddddddddd(1, 2, 3, 4) """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ aaaaaaaaaaaaaaaaaaaaaaaa(xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx).dddddddddddddddddddddddddd(1, 2, 3, 4) """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ aaaaaaaaaaaaaaaaaaaaaaaa( xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx).dddddddddddddddddddddddddd(1, 2, 3, 4) """) # noqa llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ aaaaaaaaaaaaaaaaaaaaaaaa().bbbbbbbbbbbbbbbbbbbbbbbb().ccccccccccccccccccc().\ dddddddddddddddddd().eeeeeeeeeeeeeeeeeeeee().fffffffffffffffff().gggggggggggggggggg() """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ aaaaaaaaaaaaaaaaaaaaaaaa().bbbbbbbbbbbbbbbbbbbbbbbb().ccccccccccccccccccc( ).dddddddddddddddddd().eeeeeeeeeeeeeeeeeeeee().fffffffffffffffff( ).gggggggggggggggggg() @@ -2450,8 +2324,7 @@ def testB13900309(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testB67935687(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ Fetch( Raw('monarch.BorgTask', '/union/row_operator_action_delay'), {'borg_user': self.borg_user}) @@ -2459,15 +2332,13 @@ def testB67935687(self): llines = yapf_test_helper.ParseAndUnwrap(code) self.assertCodeEqual(code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ shelf_renderer.expand_text = text.translate_to_unicode( expand_text % { 'creator': creator }) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ shelf_renderer.expand_text = text.translate_to_unicode(expand_text % {'creator': creator}) """) # noqa diff --git a/yapftests/reformatter_facebook_test.py b/yapftests/reformatter_facebook_test.py index 14b07d06b..c61f32bf5 100644 --- a/yapftests/reformatter_facebook_test.py +++ b/yapftests/reformatter_facebook_test.py @@ -29,14 +29,12 @@ def setUpClass(cls): style.SetGlobalStyle(style.CreateFacebookStyle()) def testNoNeedForLineBreaks(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def overly_long_function_name( just_one_arg, **kwargs): pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def overly_long_function_name(just_one_arg, **kwargs): pass """) @@ -44,15 +42,13 @@ def overly_long_function_name(just_one_arg, **kwargs): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testDedentClosingBracket(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def overly_long_function_name( first_argument_on_the_same_line, second_argument_makes_the_line_too_long): pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def overly_long_function_name( first_argument_on_the_same_line, second_argument_makes_the_line_too_long ): @@ -62,14 +58,12 @@ def overly_long_function_name( self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testBreakAfterOpeningBracketIfContentsTooBig(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def overly_long_function_name(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z): pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def overly_long_function_name( a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, \ v, w, x, y, z @@ -80,8 +74,7 @@ def overly_long_function_name( self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testDedentClosingBracketWithComments(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def overly_long_function_name( # comment about the first argument first_argument_with_a_very_long_name_or_so, @@ -89,8 +82,7 @@ def overly_long_function_name( second_argument_makes_the_line_too_long): pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def overly_long_function_name( # comment about the first argument first_argument_with_a_very_long_name_or_so, @@ -103,8 +95,7 @@ def overly_long_function_name( self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testDedentImportAsNames(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ from module import ( internal_function as function, SOME_CONSTANT_NUMBER1, @@ -116,8 +107,7 @@ def testDedentImportAsNames(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testDedentTestListGexp(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ try: pass except ( @@ -132,8 +122,7 @@ def testDedentTestListGexp(self): ) as exception: pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ try: pass except ( @@ -157,15 +146,13 @@ def testDedentTestListGexp(self): def testBrokenIdempotency(self): # TODO(ambv): The following behaviour should be fixed. - pass0_code = textwrap.dedent( - """\ + pass0_code = textwrap.dedent("""\ try: pass except (IOError, OSError, LookupError, RuntimeError, OverflowError) as exception: pass """) # noqa - pass1_code = textwrap.dedent( - """\ + pass1_code = textwrap.dedent("""\ try: pass except ( @@ -176,8 +163,7 @@ def testBrokenIdempotency(self): llines = yapf_test_helper.ParseAndUnwrap(pass0_code) self.assertCodeEqual(pass1_code, reformatter.Reformat(llines)) - pass2_code = textwrap.dedent( - """\ + pass2_code = textwrap.dedent("""\ try: pass except ( @@ -189,8 +175,7 @@ def testBrokenIdempotency(self): self.assertCodeEqual(pass2_code, reformatter.Reformat(llines)) def testIfExprHangingIndent(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ if True: if True: if True: @@ -199,8 +184,7 @@ def testIfExprHangingIndent(self): self.foobars.counters['db.marshmellow_skins'] != 1): pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ if True: if True: if True: @@ -214,13 +198,11 @@ def testIfExprHangingIndent(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testSimpleDedenting(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ if True: self.assertEqual(result.reason_not_added, "current preflight is still running") """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ if True: self.assertEqual( result.reason_not_added, "current preflight is still running" @@ -230,8 +212,7 @@ def testSimpleDedenting(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testDedentingWithSubscripts(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ class Foo: class Bar: @classmethod @@ -240,8 +221,7 @@ def baz(cls, clues_list, effect, constraints, constraint_manager): return cls.single_constraint_not(clues_lists, effect, constraints[0], constraint_manager) """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ class Foo: class Bar: @classmethod @@ -255,8 +235,7 @@ def baz(cls, clues_list, effect, constraints, constraint_manager): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testDedentingCallsWithInnerLists(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ class _(): def _(): cls.effect_clues = { @@ -267,8 +246,7 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testDedentingListComprehension(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ class Foo(): def _pack_results_for_constraint_or(): self.param_groups = dict( @@ -306,8 +284,7 @@ def _pack_results_for_constraint_or(): ('localhost', os.path.join(path, 'node_2.log'), super_parser) ] """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ class Foo(): def _pack_results_for_constraint_or(): self.param_groups = dict( @@ -347,8 +324,7 @@ def _pack_results_for_constraint_or(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testMustSplitDedenting(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ class _(): def _(): effect_line = FrontInput( @@ -360,8 +336,7 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testDedentIfConditional(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ class _(): def _(): if True: @@ -375,8 +350,7 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testDedentSet(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ class _(): def _(): assert set(self.constraint_links.get_links()) == set( @@ -392,8 +366,7 @@ def _(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testDedentingInnerScope(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ class Foo(): @classmethod def _pack_results_for_constraint_or(cls, combination, constraints): @@ -402,17 +375,16 @@ def _pack_results_for_constraint_or(cls, combination, constraints): constraints, InvestigationResult.OR ) """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(code) + llines = yapf_test_helper.ParseAndUnwrap(code) reformatted_code = reformatter.Reformat(llines) self.assertCodeEqual(code, reformatted_code) - llines = yapf_test_helper.ParseAndUnwrap(reformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(reformatted_code) reformatted_code = reformatter.Reformat(llines) self.assertCodeEqual(code, reformatted_code) def testCommentWithNewlinesInPrefix(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def foo(): if 0: return False @@ -425,8 +397,7 @@ def foo(): print(foo()) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def foo(): if 0: return False @@ -442,7 +413,7 @@ def foo(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testIfStmtClosingBracket(self): - unformatted_code = """\ + unformatted_code = """\ if (isinstance(value , (StopIteration , StopAsyncIteration )) and exc.__cause__ is value_asdfasdfasdfasdfsafsafsafdasfasdfs): return False """ # noqa @@ -453,7 +424,7 @@ def testIfStmtClosingBracket(self): ): return False """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) diff --git a/yapftests/reformatter_pep8_test.py b/yapftests/reformatter_pep8_test.py index 19c294d18..acc218d24 100644 --- a/yapftests/reformatter_pep8_test.py +++ b/yapftests/reformatter_pep8_test.py @@ -30,13 +30,11 @@ def setUpClass(cls): # pylint: disable=g-missing-super-call style.SetGlobalStyle(style.CreatePEP8Style()) def testIndent4(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ if a+b: pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ if a + b: pass """) @@ -44,8 +42,7 @@ def testIndent4(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testSingleLineIfStatements(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ if True: a = 42 elif False: b = 42 else: c = 42 @@ -54,14 +51,12 @@ def testSingleLineIfStatements(self): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testBlankBetweenClassAndDef(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ class Foo: def joe(): pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ class Foo: def joe(): @@ -71,8 +66,7 @@ def joe(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testBlankBetweenDefsInClass(self): - unformatted_code = textwrap.dedent( - '''\ + unformatted_code = textwrap.dedent('''\ class TestClass: def __init__(self): self.running = False @@ -81,8 +75,7 @@ def run(self): def is_running(self): return self.running ''') - expected_formatted_code = textwrap.dedent( - '''\ + expected_formatted_code = textwrap.dedent('''\ class TestClass: def __init__(self): @@ -98,13 +91,11 @@ def is_running(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testSingleWhiteBeforeTrailingComment(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ if a+b: # comment pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ if a + b: # comment pass """) @@ -112,22 +103,19 @@ def testSingleWhiteBeforeTrailingComment(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testSpaceBetweenEndingCommandAndClosingBracket(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ a = ( 1, ) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ a = (1, ) """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testContinuedNonOutdentedLine(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ class eld(d): if str(geom.geom_type).upper( ) != self.geom_type and not self.geom_type == 'GEOMETRY': @@ -137,8 +125,7 @@ class eld(d): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testWrappingPercentExpressions(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def f(): if True: zzzzz = '%s-%s' % (xxxxxxxxxxxxxxxxxxxxxxxxxx + 1, xxxxxxxxxxxxxxxxx.yyy + 1) @@ -146,8 +133,7 @@ def f(): zzzzz = '%s-%s' % (xxxxxxxxxxxxxxxxxxxxxxx + 1, xxxxxxxxxxxxxxxxxxxxx + 1) zzzzz = '%s-%s'.ww(xxxxxxxxxxxxxxxxxxxxxxx + 1, xxxxxxxxxxxxxxxxxxxxx + 1) """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def f(): if True: zzzzz = '%s-%s' % (xxxxxxxxxxxxxxxxxxxxxxxxxx + 1, @@ -163,14 +149,12 @@ def f(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testAlignClosingBracketWithVisualIndentation(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ TEST_LIST = ('foo', 'bar', # first comment 'baz' # second comment ) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ TEST_LIST = ( 'foo', 'bar', # first comment @@ -180,8 +164,7 @@ def testAlignClosingBracketWithVisualIndentation(self): llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def f(): def g(): @@ -190,8 +173,7 @@ def g(): ): pass """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def f(): def g(): @@ -204,13 +186,11 @@ def g(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testIndentSizeChanging(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ if True: runtime_mins = (program_end_time - program_start_time).total_seconds() / 60.0 """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ if True: runtime_mins = (program_end_time - program_start_time).total_seconds() / 60.0 @@ -219,8 +199,7 @@ def testIndentSizeChanging(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testHangingIndentCollision(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ if (aaaaaaaaaaaaaa + bbbbbbbbbbbbbbbb == ccccccccccccccccc and xxxxxxxxxxxxx or yyyyyyyyyyyyyyyyy): pass elif (xxxxxxxxxxxxxxx(aaaaaaaaaaa, bbbbbbbbbbbbbb, cccccccccccc, dddddddddd=None)): @@ -234,8 +213,7 @@ def h(): for connection in itertools.chain(branch.contact, branch.address, morestuff.andmore.andmore.andmore.andmore.andmore.andmore.andmore): dosomething(connection) """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ if (aaaaaaaaaaaaaa + bbbbbbbbbbbbbbbb == ccccccccccccccccc and xxxxxxxxxxxxx or yyyyyyyyyyyyyyyyy): pass @@ -264,8 +242,7 @@ def testSplittingBeforeLogicalOperator(self): style.SetGlobalStyle( style.CreateStyleFromConfig( '{based_on_style: pep8, split_before_logical_operator: True}')) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def foo(): return bool(update.message.new_chat_member or update.message.left_chat_member or update.message.new_chat_title or update.message.new_chat_photo or @@ -274,8 +251,7 @@ def foo(): or update.message.migrate_to_chat_id or update.message.migrate_from_chat_id or update.message.pinned_message) """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def foo(): return bool( update.message.new_chat_member or update.message.left_chat_member @@ -289,20 +265,18 @@ def foo(): or update.message.pinned_message) """) # noqa llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreatePEP8Style()) def testContiguousListEndingWithComment(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ if True: if True: keys.append(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) # may be unassigned. """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ if True: if True: keys.append( @@ -316,13 +290,11 @@ def testSplittingBeforeFirstArgument(self): style.SetGlobalStyle( style.CreateStyleFromConfig( '{based_on_style: pep8, split_before_first_argument: True}')) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ a_very_long_function_name(long_argument_name_1=1, long_argument_name_2=2, long_argument_name_3=3, long_argument_name_4=4) """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ a_very_long_function_name( long_argument_name_1=1, long_argument_name_2=2, @@ -330,19 +302,17 @@ def testSplittingBeforeFirstArgument(self): long_argument_name_4=4) """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreatePEP8Style()) def testSplittingExpressionsInsideSubscripts(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def foo(): df = df[(df['campaign_status'] == 'LIVE') & (df['action_status'] == 'LIVE')] """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def foo(): df = df[(df['campaign_status'] == 'LIVE') & (df['action_status'] == 'LIVE')] @@ -351,15 +321,13 @@ def foo(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testSplitListsAndDictSetMakersIfCommaTerminated(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ DJANGO_TEMPLATES_OPTIONS = {"context_processors": []} DJANGO_TEMPLATES_OPTIONS = {"context_processors": [],} x = ["context_processors"] x = ["context_processors",] """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ DJANGO_TEMPLATES_OPTIONS = {"context_processors": []} DJANGO_TEMPLATES_OPTIONS = { "context_processors": [], @@ -373,15 +341,13 @@ def testSplitListsAndDictSetMakersIfCommaTerminated(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testSplitAroundNamedAssigns(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ class a(): def a(): return a( aaaaaaaaaa=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ class a(): def a(): @@ -393,15 +359,13 @@ def a(): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testUnaryOperator(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ if not -3 < x < 3: pass if -3 < x < 3: pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ if not -3 < x < 3: pass if -3 < x < 3: @@ -413,24 +377,21 @@ def testUnaryOperator(self): def testNoSplitBeforeDictValue(self): try: style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{based_on_style: pep8, ' - 'allow_split_before_dict_value: false, ' - 'coalesce_brackets: true, ' - 'dedent_closing_brackets: true, ' - 'each_dict_entry_on_separate_line: true, ' - 'split_before_logical_operator: true}')) - - unformatted_code = textwrap.dedent( - """\ + style.CreateStyleFromConfig('{based_on_style: pep8, ' + 'allow_split_before_dict_value: false, ' + 'coalesce_brackets: true, ' + 'dedent_closing_brackets: true, ' + 'each_dict_entry_on_separate_line: true, ' + 'split_before_logical_operator: true}')) + + unformatted_code = textwrap.dedent("""\ some_dict = { 'title': _("I am example data"), 'description': _("Lorem ipsum dolor met sit amet elit, si vis pacem para bellum " "elites nihi very long string."), } """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ some_dict = { 'title': _("I am example data"), 'description': _( @@ -440,15 +401,13 @@ def testNoSplitBeforeDictValue(self): } """) # noqa llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ X = {'a': 1, 'b': 2, 'key': this_is_a_function_call_that_goes_over_the_column_limit_im_pretty_sure()} """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ X = { 'a': 1, 'b': 2, @@ -456,18 +415,16 @@ def testNoSplitBeforeDictValue(self): } """) # noqa llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ attrs = { 'category': category, 'role': forms.ModelChoiceField(label=_("Role"), required=False, queryset=category_roles, initial=selected_role, empty_label=_("No access"),), } """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ attrs = { 'category': category, 'role': forms.ModelChoiceField( @@ -480,19 +437,17 @@ def testNoSplitBeforeDictValue(self): } """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ css_class = forms.CharField( label=_("CSS class"), required=False, help_text=_("Optional CSS class used to customize this category appearance from templates."), ) """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ css_class = forms.CharField( label=_("CSS class"), required=False, @@ -502,8 +457,8 @@ def testNoSplitBeforeDictValue(self): ) """) # noqa llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreatePEP8Style()) @@ -518,7 +473,7 @@ def _(): cdffile['Latitude'][:] >= select_lat - radius) & ( cdffile['Latitude'][:] <= select_lat + radius)) """ - expected_code = """\ + expected_code = """\ def _(): include_values = np.where( (cdffile['Quality_Flag'][:] >= 5) & (cdffile['Day_Night_Flag'][:] == 1) @@ -527,7 +482,7 @@ def _(): & (cdffile['Latitude'][:] >= select_lat - radius) & (cdffile['Latitude'][:] <= select_lat + radius)) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertEqual(expected_code, reformatter.Reformat(llines)) def testNoBlankLinesOnlyForFirstNestedObject(self): @@ -545,7 +500,7 @@ def bar(self): bar docs """ ''' - expected_code = '''\ + expected_code = '''\ class Demo: """ Demo docs @@ -561,7 +516,7 @@ def bar(self): bar docs """ ''' - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertEqual(expected_code, reformatter.Reformat(llines)) def testSplitBeforeArithmeticOperators(self): @@ -570,7 +525,7 @@ def testSplitBeforeArithmeticOperators(self): style.CreateStyleFromConfig( '{based_on_style: pep8, split_before_arithmetic_operator: true}')) - unformatted_code = """\ + unformatted_code = """\ def _(): raise ValueError('This is a long message that ends with an argument: ' + str(42)) """ # noqa @@ -579,9 +534,9 @@ def _(): raise ValueError('This is a long message that ends with an argument: ' + str(42)) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreatePEP8Style()) @@ -591,12 +546,12 @@ def testListSplitting(self): (1,1), (1,1), (1,1), (1,1), (1,1), (1,1), (1,1), (1,10), (1,11), (1, 10), (1,11), (10,11)]) """ - expected_code = """\ + expected_code = """\ foo([(1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 10), (1, 11), (1, 10), (1, 11), (10, 11)]) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) def testNoBlankLineBeforeNestedFuncOrClass(self): @@ -606,7 +561,7 @@ def testNoBlankLineBeforeNestedFuncOrClass(self): '{based_on_style: pep8, ' 'blank_line_before_nested_class_or_def: false}')) - unformatted_code = '''\ + unformatted_code = '''\ def normal_function(): """Return the nested function.""" @@ -634,15 +589,14 @@ class nested_class(): return nested_function ''' - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreatePEP8Style()) def testParamListIndentationCollision1(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ class _(): def __init__(self, title: Optional[str], diffs: Collection[BinaryDiff] = (), charset: Union[Type[AsciiCharset], Type[LineCharset]] = AsciiCharset, preprocess: Callable[[str], str] = identity, @@ -651,8 +605,7 @@ def __init__(self, title: Optional[str], diffs: Collection[BinaryDiff] = (), cha self._cs = charset self._preprocess = preprocess """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ class _(): def __init__( @@ -671,8 +624,7 @@ def __init__( self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testParamListIndentationCollision2(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ def simple_pass_function_with_an_extremely_long_name_and_some_arguments( argument0, argument1): pass @@ -681,8 +633,7 @@ def simple_pass_function_with_an_extremely_long_name_and_some_arguments( self.assertCodeEqual(code, reformatter.Reformat(llines)) def testParamListIndentationCollision3(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ def func1( arg1, arg2, @@ -700,13 +651,11 @@ def func2( self.assertCodeEqual(code, reformatter.Reformat(llines)) def testTwoWordComparisonOperators(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ _ = (klsdfjdklsfjksdlfjdklsfjdslkfjsdkl is not ksldfjsdklfjdklsfjdklsfjdklsfjdsklfjdklsfj) _ = (klsdfjdklsfjksdlfjdklsfjdslkfjsdkl not in {ksldfjsdklfjdklsfjdklsfjdklsfjdsklfjdklsfj}) """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ _ = (klsdfjdklsfjksdlfjdklsfjdslkfjsdkl is not ksldfjsdklfjdklsfjdklsfjdklsfjdsklfjdklsfj) _ = (klsdfjdklsfjksdlfjdklsfjdslkfjsdkl @@ -718,8 +667,7 @@ def testTwoWordComparisonOperators(self): @unittest.skipUnless(not py3compat.PY3, 'Requires Python 2.7') def testAsyncAsNonKeyword(self): # In Python 2, async may be used as a non-keyword identifier. - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ from util import async @@ -735,14 +683,12 @@ def bar(self): self.assertCodeEqual(code, reformatter.Reformat(llines, verify=False)) def testStableInlinedDictionaryFormatting(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def _(): url = "http://{0}/axis-cgi/admin/param.cgi?{1}".format( value, urllib.urlencode({'action': 'update', 'parameter': value})) """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def _(): url = "http://{0}/axis-cgi/admin/param.cgi?{1}".format( value, urllib.urlencode({ @@ -751,19 +697,18 @@ def _(): })) """) - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) reformatted_code = reformatter.Reformat(llines) self.assertCodeEqual(expected_formatted_code, reformatted_code) - llines = yapf_test_helper.ParseAndUnwrap(reformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(reformatted_code) reformatted_code = reformatter.Reformat(llines) self.assertCodeEqual(expected_formatted_code, reformatted_code) @unittest.skipUnless(py3compat.PY36, 'Requires Python 3.6') def testSpaceBetweenColonAndElipses(self): style.SetGlobalStyle(style.CreatePEP8Style()) - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ class MyClass(ABC): place: ... @@ -774,11 +719,10 @@ class MyClass(ABC): @unittest.skipUnless(py3compat.PY36, 'Requires Python 3.6') def testSpaceBetweenDictColonAndElipses(self): style.SetGlobalStyle(style.CreatePEP8Style()) - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent("""\ {0:"...", 1:...} """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ {0: "...", 1: ...} """) @@ -788,8 +732,7 @@ def testSpaceBetweenDictColonAndElipses(self): class TestsForSpacesInsideBrackets(yapf_test_helper.YAPFTest): """Test the SPACE_INSIDE_BRACKETS style option.""" - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ foo() foo(1) foo(1,2) @@ -822,8 +765,7 @@ def testEnabled(self): style.SetGlobalStyle( style.CreateStyleFromConfig('{space_inside_brackets: True}')) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ foo() foo( 1 ) foo( 1, 2 ) @@ -861,8 +803,7 @@ def testEnabled(self): def testDefault(self): style.SetGlobalStyle(style.CreatePEP8Style()) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ foo() foo(1) foo(1, 2) @@ -901,8 +842,7 @@ def testDefault(self): def testAwait(self): style.SetGlobalStyle( style.CreateStyleFromConfig('{space_inside_brackets: True}')) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ import asyncio import time @@ -915,8 +855,7 @@ async def main(): if (await get_html()): pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ import asyncio import time @@ -937,8 +876,7 @@ async def main(): class TestsForSpacesAroundSubscriptColon(yapf_test_helper.YAPFTest): """Test the SPACES_AROUND_SUBSCRIPT_COLON style option.""" - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ a = list1[ : ] b = list2[ slice_start: ] c = list3[ slice_start:slice_end ] @@ -954,8 +892,7 @@ class TestsForSpacesAroundSubscriptColon(yapf_test_helper.YAPFTest): def testEnabled(self): style.SetGlobalStyle( style.CreateStyleFromConfig('{spaces_around_subscript_colon: True}')) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ a = list1[:] b = list2[slice_start :] c = list3[slice_start : slice_end] @@ -972,13 +909,11 @@ def testEnabled(self): def testWithSpaceInsideBrackets(self): style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{' - 'spaces_around_subscript_colon: true, ' - 'space_inside_brackets: true,' - '}')) - expected_formatted_code = textwrap.dedent( - """\ + style.CreateStyleFromConfig('{' + 'spaces_around_subscript_colon: true, ' + 'space_inside_brackets: true,' + '}')) + expected_formatted_code = textwrap.dedent("""\ a = list1[ : ] b = list2[ slice_start : ] c = list3[ slice_start : slice_end ] @@ -995,8 +930,7 @@ def testWithSpaceInsideBrackets(self): def testDefault(self): style.SetGlobalStyle(style.CreatePEP8Style()) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ a = list1[:] b = list2[slice_start:] c = list3[slice_start:slice_end] diff --git a/yapftests/reformatter_python3_test.py b/yapftests/reformatter_python3_test.py index 88dd9d7bd..b5d68e86f 100644 --- a/yapftests/reformatter_python3_test.py +++ b/yapftests/reformatter_python3_test.py @@ -33,13 +33,11 @@ def setUpClass(cls): # pylint: disable=g-missing-super-call style.SetGlobalStyle(style.CreatePEP8Style()) def testTypedNames(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def x(aaaaaaaaaaaaaaa:int,bbbbbbbbbbbbbbbb:str,ccccccccccccccc:dict,eeeeeeeeeeeeee:set={1, 2, 3})->bool: pass """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def x(aaaaaaaaaaaaaaa: int, bbbbbbbbbbbbbbbb: str, ccccccccccccccc: dict, @@ -50,13 +48,11 @@ def x(aaaaaaaaaaaaaaa: int, self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testTypedNameWithLongNamedArg(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def func(arg=long_function_call_that_pushes_the_line_over_eighty_characters()) -> ReturnType: pass """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def func(arg=long_function_call_that_pushes_the_line_over_eighty_characters() ) -> ReturnType: pass @@ -65,13 +61,11 @@ def func(arg=long_function_call_that_pushes_the_line_over_eighty_characters() self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testKeywordOnlyArgSpecifier(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def foo(a, *, kw): return a+kw """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def foo(a, *, kw): return a + kw """) @@ -80,15 +74,13 @@ def foo(a, *, kw): @unittest.skipUnless(py3compat.PY36, 'Requires Python 3.6') def testPEP448ParameterExpansion(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ { ** x } { **{} } { **{ **x }, **x } {'a': 1, **kw , 'b':3, **kw2 } """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ {**x} {**{}} {**{**x}, **x} @@ -98,13 +90,11 @@ def testPEP448ParameterExpansion(self): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testAnnotations(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def foo(a: list, b: "bar") -> dict: return a+b """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def foo(a: list, b: "bar") -> dict: return a + b """) @@ -112,16 +102,15 @@ def foo(a: list, b: "bar") -> dict: self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testExecAsNonKeyword(self): - unformatted_code = 'methods.exec( sys.modules[name])\n' + unformatted_code = 'methods.exec( sys.modules[name])\n' expected_formatted_code = 'methods.exec(sys.modules[name])\n' - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testAsyncFunctions(self): if sys.version_info[1] < 5: return - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ import asyncio import time @@ -141,7 +130,7 @@ async def main(): self.assertCodeEqual(code, reformatter.Reformat(llines, verify=False)) def testNoSpacesAroundPowerOperator(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent("""\ a**b """) expected_formatted_code = textwrap.dedent("""\ @@ -154,13 +143,13 @@ def testNoSpacesAroundPowerOperator(self): '{based_on_style: pep8, SPACES_AROUND_POWER_OPERATOR: True}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreatePEP8Style()) def testSpacesAroundDefaultOrNamedAssign(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent("""\ f(a=5) """) expected_formatted_code = textwrap.dedent("""\ @@ -174,14 +163,13 @@ def testSpacesAroundDefaultOrNamedAssign(self): 'SPACES_AROUND_DEFAULT_OR_NAMED_ASSIGN: True}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreatePEP8Style()) def testTypeHint(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def foo(x: int=42): pass @@ -189,8 +177,7 @@ def foo(x: int=42): def foo2(x: 'int' =42): pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def foo(x: int = 42): pass @@ -202,18 +189,17 @@ def foo2(x: 'int' = 42): self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testMatrixMultiplication(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent("""\ a=b@c """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ a = b @ c """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testNoneKeyword(self): - code = """\ + code = """\ None.__ne__() """ llines = yapf_test_helper.ParseAndUnwrap(code) @@ -222,8 +208,7 @@ def testNoneKeyword(self): def testAsyncWithPrecedingComment(self): if sys.version_info[1] < 5: return - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ import asyncio # Comment @@ -233,8 +218,7 @@ async def bar(): async def foo(): pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ import asyncio @@ -252,8 +236,7 @@ async def foo(): def testAsyncFunctionsNested(self): if sys.version_info[1] < 5: return - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ async def outer(): async def inner(): @@ -265,15 +248,13 @@ async def inner(): def testKeepTypesIntact(self): if sys.version_info[1] < 5: return - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def _ReduceAbstractContainers( self, *args: Optional[automation_converter.PyiCollectionAbc]) -> List[ automation_converter.PyiCollectionAbc]: pass """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def _ReduceAbstractContainers( self, *args: Optional[automation_converter.PyiCollectionAbc] ) -> List[automation_converter.PyiCollectionAbc]: @@ -285,15 +266,13 @@ def _ReduceAbstractContainers( def testContinuationIndentWithAsync(self): if sys.version_info[1] < 5: return - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ async def start_websocket(): async with session.ws_connect( r"ws://a_really_long_long_long_long_long_long_url") as ws: pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ async def start_websocket(): async with session.ws_connect( r"ws://a_really_long_long_long_long_long_long_url") as ws: @@ -306,7 +285,7 @@ def testSplittingArguments(self): if sys.version_info[1] < 5: return - unformatted_code = """\ + unformatted_code = """\ async def open_file(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None): pass @@ -367,15 +346,15 @@ def run_sync_in_worker_thread(sync_fn, *args, cancellable=False, limiter=None): 'split_before_first_argument: true}')) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreatePEP8Style()) def testDictUnpacking(self): if sys.version_info[1] < 5: return - unformatted_code = """\ + unformatted_code = """\ class Foo: def foo(self): foofoofoofoofoofoofoofoo('foofoofoofoofoo', { @@ -394,7 +373,7 @@ def foo(self): **foofoofoo }) """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) def testMultilineFormatString(self): @@ -422,7 +401,7 @@ def dirichlet(x12345678901234567890123456789012345678901234567890=...) -> None: self.assertCodeEqual(code, reformatter.Reformat(llines)) def testFunctionTypedReturnNextLine(self): - code = """\ + code = """\ def _GenerateStatsEntries( process_id: Text, timestamp: Optional[ffffffff.FFFFFFFFFFF] = None @@ -433,7 +412,7 @@ def _GenerateStatsEntries( self.assertCodeEqual(code, reformatter.Reformat(llines)) def testFunctionTypedReturnSameLine(self): - code = """\ + code = """\ def rrrrrrrrrrrrrrrrrrrrrr( ccccccccccccccccccccccc: Tuple[Text, Text]) -> List[Tuple[Text, Text]]: pass @@ -444,8 +423,7 @@ def rrrrrrrrrrrrrrrrrrrrrr( def testAsyncForElseNotIndentedInsideBody(self): if sys.version_info[1] < 5: return - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ async def fn(): async for message in websocket: for i in range(10): @@ -461,8 +439,7 @@ async def fn(): def testForElseInAsyncNotMixedWithAsyncFor(self): if sys.version_info[1] < 5: return - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ async def fn(): for i in range(10): pass @@ -473,14 +450,12 @@ async def fn(): self.assertCodeEqual(code, reformatter.Reformat(llines)) def testParameterListIndentationConflicts(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def raw_message( # pylint: disable=too-many-arguments self, text, user_id=1000, chat_type='private', forward_date=None, forward_from=None): pass """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def raw_message( # pylint: disable=too-many-arguments self, text, diff --git a/yapftests/reformatter_style_config_test.py b/yapftests/reformatter_style_config_test.py index 6746ba0ed..c5726cb30 100644 --- a/yapftests/reformatter_style_config_test.py +++ b/yapftests/reformatter_style_config_test.py @@ -30,30 +30,26 @@ def setUp(self): def testSetGlobalStyle(self): try: style.SetGlobalStyle(style.CreateYapfStyle()) - unformatted_code = textwrap.dedent( - u"""\ + unformatted_code = textwrap.dedent(u"""\ for i in range(5): print('bar') """) - expected_formatted_code = textwrap.dedent( - u"""\ + expected_formatted_code = textwrap.dedent(u"""\ for i in range(5): print('bar') """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreatePEP8Style()) style.DEFAULT_STYLE = self.current_style - unformatted_code = textwrap.dedent( - u"""\ + unformatted_code = textwrap.dedent(u"""\ for i in range(5): print('bar') """) - expected_formatted_code = textwrap.dedent( - u"""\ + expected_formatted_code = textwrap.dedent(u"""\ for i in range(5): print('bar') """) @@ -62,35 +58,32 @@ def testSetGlobalStyle(self): def testOperatorNoSpaceStyle(self): try: - sympy_style = style.CreatePEP8Style() + sympy_style = style.CreatePEP8Style() sympy_style['NO_SPACES_AROUND_SELECTED_BINARY_OPERATORS'] = \ style._StringSetConverter('*,/') style.SetGlobalStyle(sympy_style) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ a = 1+2 * 3 - 4 / 5 b = '0' * 1 """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ a = 1 + 2*3 - 4/5 b = '0'*1 """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreatePEP8Style()) style.DEFAULT_STYLE = self.current_style def testOperatorPrecedenceStyle(self): try: - pep8_with_precedence = style.CreatePEP8Style() + pep8_with_precedence = style.CreatePEP8Style() pep8_with_precedence['ARITHMETIC_PRECEDENCE_INDICATION'] = True style.SetGlobalStyle(pep8_with_precedence) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ 1+2 (1 + 2) * (3 - (4 / 5)) a = 1 * 2 + 3 / 4 @@ -105,8 +98,7 @@ def testOperatorPrecedenceStyle(self): j = (1 * 2 - 3) + 4 k = (1 * 2 * 3) + (4 * 5 * 6 * 7 * 8) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ 1 + 2 (1+2) * (3 - (4/5)) a = 1*2 + 3/4 @@ -123,20 +115,19 @@ def testOperatorPrecedenceStyle(self): """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreatePEP8Style()) style.DEFAULT_STYLE = self.current_style def testNoSplitBeforeFirstArgumentStyle1(self): try: - pep8_no_split_before_first = style.CreatePEP8Style() + pep8_no_split_before_first = style.CreatePEP8Style() pep8_no_split_before_first['SPLIT_BEFORE_FIRST_ARGUMENT'] = False - pep8_no_split_before_first['SPLIT_BEFORE_NAMED_ASSIGNS'] = False + pep8_no_split_before_first['SPLIT_BEFORE_NAMED_ASSIGNS'] = False style.SetGlobalStyle(pep8_no_split_before_first) - formatted_code = textwrap.dedent( - """\ + formatted_code = textwrap.dedent("""\ # Example from in-code MustSplit comments foo = outer_function_call(fitting_inner_function_call(inner_arg1, inner_arg2), outer_arg1, outer_arg2) @@ -173,12 +164,11 @@ def testNoSplitBeforeFirstArgumentStyle1(self): def testNoSplitBeforeFirstArgumentStyle2(self): try: - pep8_no_split_before_first = style.CreatePEP8Style() + pep8_no_split_before_first = style.CreatePEP8Style() pep8_no_split_before_first['SPLIT_BEFORE_FIRST_ARGUMENT'] = False - pep8_no_split_before_first['SPLIT_BEFORE_NAMED_ASSIGNS'] = True + pep8_no_split_before_first['SPLIT_BEFORE_NAMED_ASSIGNS'] = True style.SetGlobalStyle(pep8_no_split_before_first) - formatted_code = textwrap.dedent( - """\ + formatted_code = textwrap.dedent("""\ # Examples Issue#556 i_take_a_lot_of_params(arg1, param1=very_long_expression1(), diff --git a/yapftests/reformatter_verify_test.py b/yapftests/reformatter_verify_test.py index 2abbd19ff..33ba3a614 100644 --- a/yapftests/reformatter_verify_test.py +++ b/yapftests/reformatter_verify_test.py @@ -32,8 +32,7 @@ def setUpClass(cls): style.SetGlobalStyle(style.CreatePEP8Style()) def testVerifyException(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ class ABC(metaclass=type): pass """) @@ -43,23 +42,20 @@ class ABC(metaclass=type): reformatter.Reformat(llines) # verify should be False by default. def testNoVerify(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ class ABC(metaclass=type): pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ class ABC(metaclass=type): pass """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines, verify=False)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines, verify=False)) def testVerifyFutureImport(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ from __future__ import print_function def call_my_function(the_function): @@ -72,8 +68,7 @@ def call_my_function(the_function): with self.assertRaises(verifier.InternalError): reformatter.Reformat(llines, verify=True) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ from __future__ import print_function @@ -85,12 +80,11 @@ def call_my_function(the_function): call_my_function(print) """) llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual( - expected_formatted_code, reformatter.Reformat(llines, verify=False)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines, verify=False)) def testContinuationLineShouldBeDistinguished(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ class Foo(object): def bar(self): diff --git a/yapftests/split_penalty_test.py b/yapftests/split_penalty_test.py index 24226cbac..f7474a398 100644 --- a/yapftests/split_penalty_test.py +++ b/yapftests/split_penalty_test.py @@ -26,10 +26,10 @@ from yapftests import yapf_test_helper -UNBREAKABLE = split_penalty.UNBREAKABLE +UNBREAKABLE = split_penalty.UNBREAKABLE VERY_STRONGLY_CONNECTED = split_penalty.VERY_STRONGLY_CONNECTED -DOTTED_NAME = split_penalty.DOTTED_NAME -STRONGLY_CONNECTED = split_penalty.STRONGLY_CONNECTED +DOTTED_NAME = split_penalty.DOTTED_NAME +STRONGLY_CONNECTED = split_penalty.STRONGLY_CONNECTED class SplitPenaltyTest(yapf_test_helper.YAPFTest): @@ -68,12 +68,9 @@ def FlattenRec(tree): if pytree_utils.NodeName(tree) in pytree_utils.NONSEMANTIC_TOKENS: return [] if isinstance(tree, pytree.Leaf): - return [ - ( - tree.value, - pytree_utils.GetNodeAnnotation( - tree, pytree_utils.Annotation.SPLIT_PENALTY)) - ] + return [(tree.value, + pytree_utils.GetNodeAnnotation( + tree, pytree_utils.Annotation.SPLIT_PENALTY))] nodes = [] for node in tree.children: nodes += FlattenRec(node) @@ -88,194 +85,181 @@ def foo(x): pass """) tree = self._ParseAndComputePenalties(code) - self._CheckPenalties( - tree, [ - ('def', None), - ('foo', UNBREAKABLE), - ('(', UNBREAKABLE), - ('x', None), - (')', STRONGLY_CONNECTED), - (':', UNBREAKABLE), - ('pass', None), - ]) + self._CheckPenalties(tree, [ + ('def', None), + ('foo', UNBREAKABLE), + ('(', UNBREAKABLE), + ('x', None), + (')', STRONGLY_CONNECTED), + (':', UNBREAKABLE), + ('pass', None), + ]) # Test function definition with trailing comment. - code = textwrap.dedent( - r""" + code = textwrap.dedent(r""" def foo(x): # trailing comment pass """) tree = self._ParseAndComputePenalties(code) - self._CheckPenalties( - tree, [ - ('def', None), - ('foo', UNBREAKABLE), - ('(', UNBREAKABLE), - ('x', None), - (')', STRONGLY_CONNECTED), - (':', UNBREAKABLE), - ('pass', None), - ]) + self._CheckPenalties(tree, [ + ('def', None), + ('foo', UNBREAKABLE), + ('(', UNBREAKABLE), + ('x', None), + (')', STRONGLY_CONNECTED), + (':', UNBREAKABLE), + ('pass', None), + ]) # Test class definitions. - code = textwrap.dedent( - r""" + code = textwrap.dedent(r""" class A: pass class B(A): pass """) tree = self._ParseAndComputePenalties(code) - self._CheckPenalties( - tree, [ - ('class', None), - ('A', UNBREAKABLE), - (':', UNBREAKABLE), - ('pass', None), - ('class', None), - ('B', UNBREAKABLE), - ('(', UNBREAKABLE), - ('A', None), - (')', None), - (':', UNBREAKABLE), - ('pass', None), - ]) + self._CheckPenalties(tree, [ + ('class', None), + ('A', UNBREAKABLE), + (':', UNBREAKABLE), + ('pass', None), + ('class', None), + ('B', UNBREAKABLE), + ('(', UNBREAKABLE), + ('A', None), + (')', None), + (':', UNBREAKABLE), + ('pass', None), + ]) # Test lambda definitions. code = textwrap.dedent(r""" lambda a, b: None """) tree = self._ParseAndComputePenalties(code) - self._CheckPenalties( - tree, [ - ('lambda', None), - ('a', VERY_STRONGLY_CONNECTED), - (',', VERY_STRONGLY_CONNECTED), - ('b', VERY_STRONGLY_CONNECTED), - (':', VERY_STRONGLY_CONNECTED), - ('None', VERY_STRONGLY_CONNECTED), - ]) + self._CheckPenalties(tree, [ + ('lambda', None), + ('a', VERY_STRONGLY_CONNECTED), + (',', VERY_STRONGLY_CONNECTED), + ('b', VERY_STRONGLY_CONNECTED), + (':', VERY_STRONGLY_CONNECTED), + ('None', VERY_STRONGLY_CONNECTED), + ]) # Test dotted names. code = textwrap.dedent(r""" import a.b.c """) tree = self._ParseAndComputePenalties(code) - self._CheckPenalties( - tree, [ - ('import', None), - ('a', None), - ('.', UNBREAKABLE), - ('b', UNBREAKABLE), - ('.', UNBREAKABLE), - ('c', UNBREAKABLE), - ]) + self._CheckPenalties(tree, [ + ('import', None), + ('a', None), + ('.', UNBREAKABLE), + ('b', UNBREAKABLE), + ('.', UNBREAKABLE), + ('c', UNBREAKABLE), + ]) def testStronglyConnected(self): # Test dictionary keys. - code = textwrap.dedent( - r""" + code = textwrap.dedent(r""" a = { 'x': 42, y(lambda a: 23): 37, } """) tree = self._ParseAndComputePenalties(code) - self._CheckPenalties( - tree, [ - ('a', None), - ('=', None), - ('{', None), - ("'x'", None), - (':', STRONGLY_CONNECTED), - ('42', None), - (',', None), - ('y', None), - ('(', UNBREAKABLE), - ('lambda', STRONGLY_CONNECTED), - ('a', VERY_STRONGLY_CONNECTED), - (':', VERY_STRONGLY_CONNECTED), - ('23', VERY_STRONGLY_CONNECTED), - (')', VERY_STRONGLY_CONNECTED), - (':', STRONGLY_CONNECTED), - ('37', None), - (',', None), - ('}', None), - ]) + self._CheckPenalties(tree, [ + ('a', None), + ('=', None), + ('{', None), + ("'x'", None), + (':', STRONGLY_CONNECTED), + ('42', None), + (',', None), + ('y', None), + ('(', UNBREAKABLE), + ('lambda', STRONGLY_CONNECTED), + ('a', VERY_STRONGLY_CONNECTED), + (':', VERY_STRONGLY_CONNECTED), + ('23', VERY_STRONGLY_CONNECTED), + (')', VERY_STRONGLY_CONNECTED), + (':', STRONGLY_CONNECTED), + ('37', None), + (',', None), + ('}', None), + ]) # Test list comprehension. code = textwrap.dedent(r""" [a for a in foo if a.x == 37] """) tree = self._ParseAndComputePenalties(code) - self._CheckPenalties( - tree, [ - ('[', None), - ('a', None), - ('for', 0), - ('a', STRONGLY_CONNECTED), - ('in', STRONGLY_CONNECTED), - ('foo', STRONGLY_CONNECTED), - ('if', 0), - ('a', STRONGLY_CONNECTED), - ('.', VERY_STRONGLY_CONNECTED), - ('x', DOTTED_NAME), - ('==', STRONGLY_CONNECTED), - ('37', STRONGLY_CONNECTED), - (']', None), - ]) + self._CheckPenalties(tree, [ + ('[', None), + ('a', None), + ('for', 0), + ('a', STRONGLY_CONNECTED), + ('in', STRONGLY_CONNECTED), + ('foo', STRONGLY_CONNECTED), + ('if', 0), + ('a', STRONGLY_CONNECTED), + ('.', VERY_STRONGLY_CONNECTED), + ('x', DOTTED_NAME), + ('==', STRONGLY_CONNECTED), + ('37', STRONGLY_CONNECTED), + (']', None), + ]) def testFuncCalls(self): code = 'foo(1, 2, 3)\n' tree = self._ParseAndComputePenalties(code) - self._CheckPenalties( - tree, [ - ('foo', None), - ('(', UNBREAKABLE), - ('1', None), - (',', UNBREAKABLE), - ('2', None), - (',', UNBREAKABLE), - ('3', None), - (')', VERY_STRONGLY_CONNECTED), - ]) + self._CheckPenalties(tree, [ + ('foo', None), + ('(', UNBREAKABLE), + ('1', None), + (',', UNBREAKABLE), + ('2', None), + (',', UNBREAKABLE), + ('3', None), + (')', VERY_STRONGLY_CONNECTED), + ]) # Now a method call, which has more than one trailer code = 'foo.bar.baz(1, 2, 3)\n' tree = self._ParseAndComputePenalties(code) - self._CheckPenalties( - tree, [ - ('foo', None), - ('.', VERY_STRONGLY_CONNECTED), - ('bar', DOTTED_NAME), - ('.', VERY_STRONGLY_CONNECTED), - ('baz', DOTTED_NAME), - ('(', STRONGLY_CONNECTED), - ('1', None), - (',', UNBREAKABLE), - ('2', None), - (',', UNBREAKABLE), - ('3', None), - (')', VERY_STRONGLY_CONNECTED), - ]) + self._CheckPenalties(tree, [ + ('foo', None), + ('.', VERY_STRONGLY_CONNECTED), + ('bar', DOTTED_NAME), + ('.', VERY_STRONGLY_CONNECTED), + ('baz', DOTTED_NAME), + ('(', STRONGLY_CONNECTED), + ('1', None), + (',', UNBREAKABLE), + ('2', None), + (',', UNBREAKABLE), + ('3', None), + (')', VERY_STRONGLY_CONNECTED), + ]) # Test single generator argument. code = 'max(i for i in xrange(10))\n' tree = self._ParseAndComputePenalties(code) - self._CheckPenalties( - tree, [ - ('max', None), - ('(', UNBREAKABLE), - ('i', 0), - ('for', 0), - ('i', STRONGLY_CONNECTED), - ('in', STRONGLY_CONNECTED), - ('xrange', STRONGLY_CONNECTED), - ('(', UNBREAKABLE), - ('10', STRONGLY_CONNECTED), - (')', VERY_STRONGLY_CONNECTED), - (')', VERY_STRONGLY_CONNECTED), - ]) + self._CheckPenalties(tree, [ + ('max', None), + ('(', UNBREAKABLE), + ('i', 0), + ('for', 0), + ('i', STRONGLY_CONNECTED), + ('in', STRONGLY_CONNECTED), + ('xrange', STRONGLY_CONNECTED), + ('(', UNBREAKABLE), + ('10', STRONGLY_CONNECTED), + (')', VERY_STRONGLY_CONNECTED), + (')', VERY_STRONGLY_CONNECTED), + ]) if __name__ == '__main__': diff --git a/yapftests/style_test.py b/yapftests/style_test.py index bbd9f567f..8a37f9535 100644 --- a/yapftests/style_test.py +++ b/yapftests/style_test.py @@ -50,8 +50,8 @@ def testContinuationAlignStyleStringConverter(self): 'VALIGN-RIGHT') with self.assertRaises(ValueError) as ctx: style._ContinuationAlignStyleStringConverter('blahblah') - self.assertIn( - "unknown continuation align style: 'blahblah'", str(ctx.exception)) + self.assertIn("unknown continuation align style: 'blahblah'", + str(ctx.exception)) def testStringListConverter(self): self.assertEqual(style._StringListConverter('foo, bar'), ['foo', 'bar']) @@ -136,8 +136,7 @@ def tearDownClass(cls): # pylint: disable=g-missing-super-call shutil.rmtree(cls.test_tmpdir) def testDefaultBasedOnStyle(self): - cfg = textwrap.dedent( - u'''\ + cfg = textwrap.dedent(u'''\ [style] continuation_indent_width = 20 ''') @@ -147,8 +146,7 @@ def testDefaultBasedOnStyle(self): self.assertEqual(cfg['CONTINUATION_INDENT_WIDTH'], 20) def testDefaultBasedOnPEP8Style(self): - cfg = textwrap.dedent( - u'''\ + cfg = textwrap.dedent(u'''\ [style] based_on_style = pep8 continuation_indent_width = 40 @@ -159,8 +157,7 @@ def testDefaultBasedOnPEP8Style(self): self.assertEqual(cfg['CONTINUATION_INDENT_WIDTH'], 40) def testDefaultBasedOnGoogleStyle(self): - cfg = textwrap.dedent( - u'''\ + cfg = textwrap.dedent(u'''\ [style] based_on_style = google continuation_indent_width = 20 @@ -171,8 +168,7 @@ def testDefaultBasedOnGoogleStyle(self): self.assertEqual(cfg['CONTINUATION_INDENT_WIDTH'], 20) def testDefaultBasedOnFacebookStyle(self): - cfg = textwrap.dedent( - u'''\ + cfg = textwrap.dedent(u'''\ [style] based_on_style = facebook continuation_indent_width = 20 @@ -183,8 +179,7 @@ def testDefaultBasedOnFacebookStyle(self): self.assertEqual(cfg['CONTINUATION_INDENT_WIDTH'], 20) def testBoolOptionValue(self): - cfg = textwrap.dedent( - u'''\ + cfg = textwrap.dedent(u'''\ [style] based_on_style = pep8 SPLIT_BEFORE_NAMED_ASSIGNS=False @@ -197,8 +192,7 @@ def testBoolOptionValue(self): self.assertEqual(cfg['SPLIT_BEFORE_LOGICAL_OPERATOR'], True) def testStringListOptionValue(self): - cfg = textwrap.dedent( - u'''\ + cfg = textwrap.dedent(u'''\ [style] based_on_style = pep8 I18N_FUNCTION_CALL = N_, V_, T_ @@ -224,8 +218,7 @@ def testErrorNoStyleSection(self): style.CreateStyleFromConfig(filepath) def testErrorUnknownStyleOption(self): - cfg = textwrap.dedent( - u'''\ + cfg = textwrap.dedent(u'''\ [style] indent_width=2 hummus=2 @@ -242,7 +235,7 @@ def testPyprojectTomlNoYapfSection(self): return filepath = os.path.join(self.test_tmpdir, 'pyproject.toml') - _ = open(filepath, 'w') + _ = open(filepath, 'w') with self.assertRaisesRegex(style.StyleConfigError, 'Unable to find section'): style.CreateStyleFromConfig(filepath) @@ -253,8 +246,7 @@ def testPyprojectTomlParseYapfSection(self): except ImportError: return - cfg = textwrap.dedent( - u'''\ + cfg = textwrap.dedent(u'''\ [tool.yapf] based_on_style = "pep8" continuation_indent_width = 40 @@ -275,21 +267,21 @@ def setUpClass(cls): # pylint: disable=g-missing-super-call def testDefaultBasedOnStyle(self): config_dict = { - 'based_on_style' : 'pep8', - 'indent_width' : 2, - 'blank_line_before_nested_class_or_def' : True + 'based_on_style': 'pep8', + 'indent_width': 2, + 'blank_line_before_nested_class_or_def': True } cfg = style.CreateStyleFromConfig(config_dict) self.assertTrue(_LooksLikePEP8Style(cfg)) self.assertEqual(cfg['INDENT_WIDTH'], 2) def testDefaultBasedOnStyleBadDict(self): - self.assertRaisesRegex( - style.StyleConfigError, 'Unknown style option', - style.CreateStyleFromConfig, {'based_on_styl': 'pep8'}) - self.assertRaisesRegex( - style.StyleConfigError, 'not a valid', style.CreateStyleFromConfig, - {'INDENT_WIDTH': 'FOUR'}) + self.assertRaisesRegex(style.StyleConfigError, 'Unknown style option', + style.CreateStyleFromConfig, + {'based_on_styl': 'pep8'}) + self.assertRaisesRegex(style.StyleConfigError, 'not a valid', + style.CreateStyleFromConfig, + {'INDENT_WIDTH': 'FOUR'}) class StyleFromCommandLine(yapf_test_helper.YAPFTest): @@ -323,15 +315,12 @@ def testDefaultBasedOnDetaultTypeString(self): self.assertIsInstance(cfg, dict) def testDefaultBasedOnStyleBadString(self): - self.assertRaisesRegex( - style.StyleConfigError, 'Unknown style option', - style.CreateStyleFromConfig, '{based_on_styl: pep8}') - self.assertRaisesRegex( - style.StyleConfigError, 'not a valid', style.CreateStyleFromConfig, - '{INDENT_WIDTH: FOUR}') - self.assertRaisesRegex( - style.StyleConfigError, 'Invalid style dict', - style.CreateStyleFromConfig, '{based_on_style: pep8') + self.assertRaisesRegex(style.StyleConfigError, 'Unknown style option', + style.CreateStyleFromConfig, '{based_on_styl: pep8}') + self.assertRaisesRegex(style.StyleConfigError, 'not a valid', + style.CreateStyleFromConfig, '{INDENT_WIDTH: FOUR}') + self.assertRaisesRegex(style.StyleConfigError, 'Invalid style dict', + style.CreateStyleFromConfig, '{based_on_style: pep8') class StyleHelp(yapf_test_helper.YAPFTest): diff --git a/yapftests/subtype_assigner_test.py b/yapftests/subtype_assigner_test.py index 75efb00df..97f9cd3ac 100644 --- a/yapftests/subtype_assigner_test.py +++ b/yapftests/subtype_assigner_test.py @@ -35,11 +35,9 @@ def _CheckFormatTokenSubtypes(self, llines, list_of_expected): """ actual = [] for lline in llines: - filtered_values = [ - (ft.value, ft.subtypes) - for ft in lline.tokens - if ft.name not in pytree_utils.NONSEMANTIC_TOKENS - ] + filtered_values = [(ft.value, ft.subtypes) + for ft in lline.tokens + if ft.name not in pytree_utils.NONSEMANTIC_TOKENS] if filtered_values: actual.append(filtered_values) @@ -47,352 +45,323 @@ def _CheckFormatTokenSubtypes(self, llines, list_of_expected): def testFuncDefDefaultAssign(self): self.maxDiff = None # pylint: disable=invalid-name - code = textwrap.dedent( - r""" + code = textwrap.dedent(r""" def foo(a=37, *b, **c): return -x[:42] """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckFormatTokenSubtypes( - llines, [ - [ - ('def', {subtypes.NONE}), - ('foo', {subtypes.FUNC_DEF}), - ('(', {subtypes.NONE}), - ( - 'a', { - subtypes.NONE, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, - subtypes.PARAMETER_START, - }), - ( - '=', { - subtypes.DEFAULT_OR_NAMED_ASSIGN, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, - }), - ( - '37', { - subtypes.NONE, - subtypes.PARAMETER_STOP, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, - }), - (',', {subtypes.NONE}), - ( - '*', { - subtypes.PARAMETER_START, - subtypes.VARARGS_STAR, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, - }), - ( - 'b', { - subtypes.NONE, - subtypes.PARAMETER_STOP, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, - }), - (',', {subtypes.NONE}), - ( - '**', { - subtypes.PARAMETER_START, - subtypes.KWARGS_STAR_STAR, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, - }), - ( - 'c', { - subtypes.NONE, - subtypes.PARAMETER_STOP, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, - }), - (')', {subtypes.NONE}), - (':', {subtypes.NONE}), - ], - [ - ('return', {subtypes.NONE}), - ('-', {subtypes.UNARY_OPERATOR}), - ('x', {subtypes.NONE}), - ('[', {subtypes.SUBSCRIPT_BRACKET}), - (':', {subtypes.SUBSCRIPT_COLON}), - ('42', {subtypes.NONE}), - (']', {subtypes.SUBSCRIPT_BRACKET}), - ], - ]) + self._CheckFormatTokenSubtypes(llines, [ + [ + ('def', {subtypes.NONE}), + ('foo', {subtypes.FUNC_DEF}), + ('(', {subtypes.NONE}), + ('a', { + subtypes.NONE, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, + subtypes.PARAMETER_START, + }), + ('=', { + subtypes.DEFAULT_OR_NAMED_ASSIGN, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, + }), + ('37', { + subtypes.NONE, + subtypes.PARAMETER_STOP, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, + }), + (',', {subtypes.NONE}), + ('*', { + subtypes.PARAMETER_START, + subtypes.VARARGS_STAR, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, + }), + ('b', { + subtypes.NONE, + subtypes.PARAMETER_STOP, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, + }), + (',', {subtypes.NONE}), + ('**', { + subtypes.PARAMETER_START, + subtypes.KWARGS_STAR_STAR, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, + }), + ('c', { + subtypes.NONE, + subtypes.PARAMETER_STOP, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, + }), + (')', {subtypes.NONE}), + (':', {subtypes.NONE}), + ], + [ + ('return', {subtypes.NONE}), + ('-', {subtypes.UNARY_OPERATOR}), + ('x', {subtypes.NONE}), + ('[', {subtypes.SUBSCRIPT_BRACKET}), + (':', {subtypes.SUBSCRIPT_COLON}), + ('42', {subtypes.NONE}), + (']', {subtypes.SUBSCRIPT_BRACKET}), + ], + ]) def testFuncCallWithDefaultAssign(self): - code = textwrap.dedent(r""" + code = textwrap.dedent(r""" foo(x, a='hello world') """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckFormatTokenSubtypes( - llines, [ - [ - ('foo', {subtypes.NONE}), - ('(', {subtypes.NONE}), - ( - 'x', { - subtypes.NONE, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, - }), - (',', {subtypes.NONE}), - ( - 'a', { - subtypes.NONE, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, - }), - ('=', {subtypes.DEFAULT_OR_NAMED_ASSIGN}), - ("'hello world'", {subtypes.NONE}), - (')', {subtypes.NONE}), - ], - ]) + self._CheckFormatTokenSubtypes(llines, [ + [ + ('foo', {subtypes.NONE}), + ('(', {subtypes.NONE}), + ('x', { + subtypes.NONE, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, + }), + (',', {subtypes.NONE}), + ('a', { + subtypes.NONE, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, + }), + ('=', {subtypes.DEFAULT_OR_NAMED_ASSIGN}), + ("'hello world'", {subtypes.NONE}), + (')', {subtypes.NONE}), + ], + ]) #----test comment subtype inside the argument list---- def testCommentSubtypesInsideArglist(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ foo( # comment x, a='hello world') """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckFormatTokenSubtypes( - llines, [ - [ - ('foo', {subtypes.NONE}), - ('(', {subtypes.NONE}), - ( - '# comment', - {subtypes.NONE, subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST}), - ( - 'x', - {subtypes.NONE, subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST}), - (',', {subtypes.NONE}), - ( - 'a', - {subtypes.NONE, subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST}), - ('=', {subtypes.DEFAULT_OR_NAMED_ASSIGN}), - ("'hello world'", {subtypes.NONE}), - (')', {subtypes.NONE}), - ], - ]) + self._CheckFormatTokenSubtypes(llines, [ + [ + ('foo', {subtypes.NONE}), + ('(', {subtypes.NONE}), + ('# comment', {subtypes.NONE, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST}), + ('x', { + subtypes.NONE, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST}), + (',', {subtypes.NONE}), + ('a', { + subtypes.NONE, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST}), + ('=', {subtypes.DEFAULT_OR_NAMED_ASSIGN}), + ("'hello world'", {subtypes.NONE}), + (')', {subtypes.NONE}), + ], + ]) # ----test typed arguments subtypes------ def testTypedArgumentsInsideArglist(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ def foo( self, preprocess: Callable[[str], str] = identity ): pass """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckFormatTokenSubtypes( - llines, [ - [ - ('def', {subtypes.NONE}), ('foo', {subtypes.FUNC_DEF}), - ('(', {subtypes.NONE}), - ( - 'self', { - subtypes.NONE, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, - subtypes.PARAMETER_START, subtypes.PARAMETER_STOP - }), (',', {subtypes.NONE}), - ( - 'preprocess', { - subtypes.NONE, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, - subtypes.PARAMETER_START, subtypes.TYPED_NAME_ARG_LIST - }), - (':', {subtypes.TYPED_NAME, subtypes.TYPED_NAME_ARG_LIST}), - ('Callable', {subtypes.TYPED_NAME_ARG_LIST}), - ( - '[', - {subtypes.SUBSCRIPT_BRACKET, subtypes.TYPED_NAME_ARG_LIST}), - ('[', {subtypes.TYPED_NAME_ARG_LIST}), - ('str', {subtypes.TYPED_NAME_ARG_LIST}), - (']', {subtypes.TYPED_NAME_ARG_LIST}), - (',', {subtypes.TYPED_NAME_ARG_LIST}), - ('str', {subtypes.TYPED_NAME_ARG_LIST}), - ( - ']', - {subtypes.SUBSCRIPT_BRACKET, subtypes.TYPED_NAME_ARG_LIST}), - ( - '=', { - subtypes.DEFAULT_OR_NAMED_ASSIGN, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, - subtypes.TYPED_NAME - }), - ( - 'identity', { - subtypes.NONE, - subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, - subtypes.PARAMETER_STOP - }), (')', {subtypes.NONE}), (':', {subtypes.NONE}) - ], - [ - ('pass', {subtypes.NONE}), - ], - ]) + self._CheckFormatTokenSubtypes(llines, [ + [ + ('def', {subtypes.NONE}), + ('foo', {subtypes.FUNC_DEF}), + ('(', {subtypes.NONE}), + ('self', {subtypes.NONE, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, + subtypes.PARAMETER_START, + subtypes.PARAMETER_STOP}), + (',', {subtypes.NONE}), + ('preprocess', { + subtypes.NONE, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, + subtypes.PARAMETER_START, + subtypes.TYPED_NAME_ARG_LIST}), + (':', { + subtypes.TYPED_NAME, + subtypes.TYPED_NAME_ARG_LIST}), + ('Callable', {subtypes.TYPED_NAME_ARG_LIST}), + ('[', { + subtypes.SUBSCRIPT_BRACKET, + subtypes.TYPED_NAME_ARG_LIST}), + ('[', {subtypes.TYPED_NAME_ARG_LIST}), + ('str', {subtypes.TYPED_NAME_ARG_LIST}), + (']', {subtypes.TYPED_NAME_ARG_LIST}), + (',', {subtypes.TYPED_NAME_ARG_LIST}), + ('str', {subtypes.TYPED_NAME_ARG_LIST}), + (']', { + subtypes.SUBSCRIPT_BRACKET, + subtypes.TYPED_NAME_ARG_LIST}), + ('=', { + subtypes.DEFAULT_OR_NAMED_ASSIGN, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, + subtypes.TYPED_NAME}), + ('identity', { + subtypes.NONE, + subtypes.DEFAULT_OR_NAMED_ASSIGN_ARG_LIST, + subtypes.PARAMETER_STOP}), + (')', {subtypes.NONE}), + (':', {subtypes.NONE})], + [('pass', {subtypes.NONE}), + ], + ]) def testSetComprehension(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ def foo(strs): return {s.lower() for s in strs} """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckFormatTokenSubtypes( - llines, [ - [ - ('def', {subtypes.NONE}), - ('foo', {subtypes.FUNC_DEF}), - ('(', {subtypes.NONE}), - ( - 'strs', { - subtypes.NONE, - subtypes.PARAMETER_START, - subtypes.PARAMETER_STOP, - }), - (')', {subtypes.NONE}), - (':', {subtypes.NONE}), - ], - [ - ('return', {subtypes.NONE}), - ('{', {subtypes.NONE}), - ('s', {subtypes.COMP_EXPR}), - ('.', {subtypes.COMP_EXPR}), - ('lower', {subtypes.COMP_EXPR}), - ('(', {subtypes.COMP_EXPR}), - (')', {subtypes.COMP_EXPR}), - ('for', { - subtypes.DICT_SET_GENERATOR, - subtypes.COMP_FOR, - }), - ('s', {subtypes.COMP_FOR}), - ('in', {subtypes.COMP_FOR}), - ('strs', {subtypes.COMP_FOR}), - ('}', {subtypes.NONE}), - ], - ]) + self._CheckFormatTokenSubtypes(llines, [ + [ + ('def', {subtypes.NONE}), + ('foo', {subtypes.FUNC_DEF}), + ('(', {subtypes.NONE}), + ('strs', { + subtypes.NONE, + subtypes.PARAMETER_START, + subtypes.PARAMETER_STOP, + }), + (')', {subtypes.NONE}), + (':', {subtypes.NONE}), + ], + [ + ('return', {subtypes.NONE}), + ('{', {subtypes.NONE}), + ('s', {subtypes.COMP_EXPR}), + ('.', {subtypes.COMP_EXPR}), + ('lower', {subtypes.COMP_EXPR}), + ('(', {subtypes.COMP_EXPR}), + (')', {subtypes.COMP_EXPR}), + ('for', { + subtypes.DICT_SET_GENERATOR, + subtypes.COMP_FOR, + }), + ('s', {subtypes.COMP_FOR}), + ('in', {subtypes.COMP_FOR}), + ('strs', {subtypes.COMP_FOR}), + ('}', {subtypes.NONE}), + ], + ]) def testUnaryNotOperator(self): - code = textwrap.dedent("""\ + code = textwrap.dedent("""\ not a """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckFormatTokenSubtypes( - llines, [[('not', {subtypes.UNARY_OPERATOR}), ('a', {subtypes.NONE})]]) + self._CheckFormatTokenSubtypes(llines, [[('not', {subtypes.UNARY_OPERATOR}), + ('a', {subtypes.NONE})]]) def testBitwiseOperators(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ x = ((a | (b ^ 3) & c) << 3) >> 1 """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckFormatTokenSubtypes( - llines, [ - [ - ('x', {subtypes.NONE}), - ('=', {subtypes.ASSIGN_OPERATOR}), - ('(', {subtypes.NONE}), - ('(', {subtypes.NONE}), - ('a', {subtypes.NONE}), - ('|', {subtypes.BINARY_OPERATOR}), - ('(', {subtypes.NONE}), - ('b', {subtypes.NONE}), - ('^', {subtypes.BINARY_OPERATOR}), - ('3', {subtypes.NONE}), - (')', {subtypes.NONE}), - ('&', {subtypes.BINARY_OPERATOR}), - ('c', {subtypes.NONE}), - (')', {subtypes.NONE}), - ('<<', {subtypes.BINARY_OPERATOR}), - ('3', {subtypes.NONE}), - (')', {subtypes.NONE}), - ('>>', {subtypes.BINARY_OPERATOR}), - ('1', {subtypes.NONE}), - ], - ]) + self._CheckFormatTokenSubtypes(llines, [ + [ + ('x', {subtypes.NONE}), + ('=', {subtypes.ASSIGN_OPERATOR}), + ('(', {subtypes.NONE}), + ('(', {subtypes.NONE}), + ('a', {subtypes.NONE}), + ('|', {subtypes.BINARY_OPERATOR}), + ('(', {subtypes.NONE}), + ('b', {subtypes.NONE}), + ('^', {subtypes.BINARY_OPERATOR}), + ('3', {subtypes.NONE}), + (')', {subtypes.NONE}), + ('&', {subtypes.BINARY_OPERATOR}), + ('c', {subtypes.NONE}), + (')', {subtypes.NONE}), + ('<<', {subtypes.BINARY_OPERATOR}), + ('3', {subtypes.NONE}), + (')', {subtypes.NONE}), + ('>>', {subtypes.BINARY_OPERATOR}), + ('1', {subtypes.NONE}), + ], + ]) def testArithmeticOperators(self): - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ x = ((a + (b - 3) * (1 % c) @ d) / 3) // 1 """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckFormatTokenSubtypes( - llines, [ - [ - ('x', {subtypes.NONE}), - ('=', {subtypes.ASSIGN_OPERATOR}), - ('(', {subtypes.NONE}), - ('(', {subtypes.NONE}), - ('a', {subtypes.NONE}), - ('+', {subtypes.BINARY_OPERATOR}), - ('(', {subtypes.NONE}), - ('b', {subtypes.NONE}), - ('-', { - subtypes.BINARY_OPERATOR, - subtypes.SIMPLE_EXPRESSION, - }), - ('3', {subtypes.NONE}), - (')', {subtypes.NONE}), - ('*', {subtypes.BINARY_OPERATOR}), - ('(', {subtypes.NONE}), - ('1', {subtypes.NONE}), - ('%', { - subtypes.BINARY_OPERATOR, - subtypes.SIMPLE_EXPRESSION, - }), - ('c', {subtypes.NONE}), - (')', {subtypes.NONE}), - ('@', {subtypes.BINARY_OPERATOR}), - ('d', {subtypes.NONE}), - (')', {subtypes.NONE}), - ('/', {subtypes.BINARY_OPERATOR}), - ('3', {subtypes.NONE}), - (')', {subtypes.NONE}), - ('//', {subtypes.BINARY_OPERATOR}), - ('1', {subtypes.NONE}), - ], - ]) + self._CheckFormatTokenSubtypes(llines, [ + [ + ('x', {subtypes.NONE}), + ('=', {subtypes.ASSIGN_OPERATOR}), + ('(', {subtypes.NONE}), + ('(', {subtypes.NONE}), + ('a', {subtypes.NONE}), + ('+', {subtypes.BINARY_OPERATOR}), + ('(', {subtypes.NONE}), + ('b', {subtypes.NONE}), + ('-', { + subtypes.BINARY_OPERATOR, + subtypes.SIMPLE_EXPRESSION, + }), + ('3', {subtypes.NONE}), + (')', {subtypes.NONE}), + ('*', {subtypes.BINARY_OPERATOR}), + ('(', {subtypes.NONE}), + ('1', {subtypes.NONE}), + ('%', { + subtypes.BINARY_OPERATOR, + subtypes.SIMPLE_EXPRESSION, + }), + ('c', {subtypes.NONE}), + (')', {subtypes.NONE}), + ('@', {subtypes.BINARY_OPERATOR}), + ('d', {subtypes.NONE}), + (')', {subtypes.NONE}), + ('/', {subtypes.BINARY_OPERATOR}), + ('3', {subtypes.NONE}), + (')', {subtypes.NONE}), + ('//', {subtypes.BINARY_OPERATOR}), + ('1', {subtypes.NONE}), + ], + ]) def testSubscriptColon(self): - code = textwrap.dedent("""\ + code = textwrap.dedent("""\ x[0:42:1] """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckFormatTokenSubtypes( - llines, [ - [ - ('x', {subtypes.NONE}), - ('[', {subtypes.SUBSCRIPT_BRACKET}), - ('0', {subtypes.NONE}), - (':', {subtypes.SUBSCRIPT_COLON}), - ('42', {subtypes.NONE}), - (':', {subtypes.SUBSCRIPT_COLON}), - ('1', {subtypes.NONE}), - (']', {subtypes.SUBSCRIPT_BRACKET}), - ], - ]) + self._CheckFormatTokenSubtypes(llines, [ + [ + ('x', {subtypes.NONE}), + ('[', {subtypes.SUBSCRIPT_BRACKET}), + ('0', {subtypes.NONE}), + (':', {subtypes.SUBSCRIPT_COLON}), + ('42', {subtypes.NONE}), + (':', {subtypes.SUBSCRIPT_COLON}), + ('1', {subtypes.NONE}), + (']', {subtypes.SUBSCRIPT_BRACKET}), + ], + ]) def testFunctionCallWithStarExpression(self): - code = textwrap.dedent("""\ + code = textwrap.dedent("""\ [a, *b] """) llines = yapf_test_helper.ParseAndUnwrap(code) - self._CheckFormatTokenSubtypes( - llines, [ - [ - ('[', {subtypes.NONE}), - ('a', {subtypes.NONE}), - (',', {subtypes.NONE}), - ('*', { - subtypes.UNARY_OPERATOR, - subtypes.VARARGS_STAR, - }), - ('b', {subtypes.NONE}), - (']', {subtypes.NONE}), - ], - ]) + self._CheckFormatTokenSubtypes(llines, [ + [ + ('[', {subtypes.NONE}), + ('a', {subtypes.NONE}), + (',', {subtypes.NONE}), + ('*', { + subtypes.UNARY_OPERATOR, + subtypes.VARARGS_STAR, + }), + ('b', {subtypes.NONE}), + (']', {subtypes.NONE}), + ], + ]) if __name__ == '__main__': diff --git a/yapftests/utils.py b/yapftests/utils.py index cfcc51010..268b8c43a 100644 --- a/yapftests/utils.py +++ b/yapftests/utils.py @@ -42,16 +42,15 @@ def stdout_redirector(stream): # pylint: disable=invalid-name # Note: `buffering` is set to -1 despite documentation of NamedTemporaryFile # says None. This is probably a problem with the python documentation. @contextlib.contextmanager -def NamedTempFile( - mode ='w+b', - buffering =-1, - encoding =None, - errors =None, - newline =None, - suffix =None, - prefix =None, - dirname =None, - text =False): +def NamedTempFile(mode='w+b', + buffering=-1, + encoding=None, + errors=None, + newline=None, + suffix=None, + prefix=None, + dirname=None, + text=False): """Context manager creating a new temporary file in text mode.""" if sys.version_info < (3, 5): # covers also python 2 if suffix is None: @@ -62,22 +61,29 @@ def NamedTempFile( suffix=suffix, prefix=prefix, dir=dirname, text=text) f = io.open( fd, - mode =mode, - buffering =buffering, - encoding =encoding, - errors =errors, - newline =newline) + mode=mode, + buffering=buffering, + encoding=encoding, + errors=errors, + newline=newline) yield f, fname f.close() os.remove(fname) @contextlib.contextmanager -def TempFileContents( - dirname, contents, encoding='utf-8', newline='', suffix=None): +def TempFileContents(dirname, + contents, + encoding='utf-8', + newline='', + suffix=None): # Note: NamedTempFile properly handles unicode encoding when using mode='w' - with NamedTempFile(dirname=dirname, mode='w', encoding=encoding, - newline=newline, suffix=suffix) as (f, fname): + with NamedTempFile( + dirname=dirname, + mode='w', + encoding=encoding, + newline=newline, + suffix=suffix) as (f, fname): f.write(contents) f.flush() yield fname diff --git a/yapftests/yapf_test.py b/yapftests/yapf_test.py index 9eee1a9f0..2330f4e18 100644 --- a/yapftests/yapf_test.py +++ b/yapftests/yapf_test.py @@ -54,11 +54,10 @@ def testSimple(self): self._Check(unformatted_code, unformatted_code) def testNoEndingNewline(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent("""\ if True: pass""") - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ if True: pass """) @@ -66,7 +65,7 @@ def testNoEndingNewline(self): @unittest.skipUnless(py3compat.PY36, 'Requires Python 3.6') def testPrintAfterPeriod(self): - unformatted_code = textwrap.dedent("""a.print\n""") + unformatted_code = textwrap.dedent("""a.print\n""") expected_formatted_code = textwrap.dedent("""a.print\n""") self._Check(unformatted_code, expected_formatted_code) @@ -81,7 +80,7 @@ def tearDown(self): # pylint: disable=g-missing-super-call def assertCodeEqual(self, expected_code, code): if code != expected_code: - msg = 'Code format mismatch:\n' + msg = 'Code format mismatch:\n' msg += 'Expected:\n >' msg += '\n > '.join(expected_code.splitlines()) msg += '\nActual:\n >' @@ -90,18 +89,15 @@ def assertCodeEqual(self, expected_code, code): self.fail(msg) def testFormatFile(self): - unformatted_code = textwrap.dedent( - u"""\ + unformatted_code = textwrap.dedent(u"""\ if True: pass """) - expected_formatted_code_pep8 = textwrap.dedent( - u"""\ + expected_formatted_code_pep8 = textwrap.dedent(u"""\ if True: pass """) - expected_formatted_code_yapf = textwrap.dedent( - u"""\ + expected_formatted_code_yapf = textwrap.dedent(u"""\ if True: pass """) @@ -113,8 +109,7 @@ def testFormatFile(self): self.assertCodeEqual(expected_formatted_code_yapf, formatted_code) def testDisableLinesPattern(self): - unformatted_code = textwrap.dedent( - u"""\ + unformatted_code = textwrap.dedent(u"""\ if a: b # yapf: disable @@ -122,8 +117,7 @@ def testDisableLinesPattern(self): if h: i """) - expected_formatted_code = textwrap.dedent( - u"""\ + expected_formatted_code = textwrap.dedent(u"""\ if a: b # yapf: disable @@ -136,8 +130,7 @@ def testDisableLinesPattern(self): self.assertCodeEqual(expected_formatted_code, formatted_code) def testDisableAndReenableLinesPattern(self): - unformatted_code = textwrap.dedent( - u"""\ + unformatted_code = textwrap.dedent(u"""\ if a: b # yapf: disable @@ -146,8 +139,7 @@ def testDisableAndReenableLinesPattern(self): if h: i """) - expected_formatted_code = textwrap.dedent( - u"""\ + expected_formatted_code = textwrap.dedent(u"""\ if a: b # yapf: disable @@ -161,8 +153,7 @@ def testDisableAndReenableLinesPattern(self): self.assertCodeEqual(expected_formatted_code, formatted_code) def testDisablePartOfMultilineComment(self): - unformatted_code = textwrap.dedent( - u"""\ + unformatted_code = textwrap.dedent(u"""\ if a: b # This is a multiline comment that disables YAPF. @@ -174,8 +165,7 @@ def testDisablePartOfMultilineComment(self): if h: i """) - expected_formatted_code = textwrap.dedent( - u"""\ + expected_formatted_code = textwrap.dedent(u"""\ if a: b # This is a multiline comment that disables YAPF. @@ -190,8 +180,7 @@ def testDisablePartOfMultilineComment(self): formatted_code, _, _ = yapf_api.FormatFile(filepath, style_config='pep8') self.assertCodeEqual(expected_formatted_code, formatted_code) - code = textwrap.dedent( - u"""\ + code = textwrap.dedent(u"""\ def foo_function(): # some comment # yapf: disable @@ -208,8 +197,7 @@ def foo_function(): self.assertCodeEqual(code, formatted_code) def testEnabledDisabledSameComment(self): - code = textwrap.dedent( - u"""\ + code = textwrap.dedent(u"""\ # yapf: disable a(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb, ccccccccccccccccccccccccccccccc, ddddddddddddddddddddddd, eeeeeeeeeeeeeeeeeeeeeeeeeee) # yapf: enable @@ -222,24 +210,21 @@ def testEnabledDisabledSameComment(self): self.assertCodeEqual(code, formatted_code) def testFormatFileLinesSelection(self): - unformatted_code = textwrap.dedent( - u"""\ + unformatted_code = textwrap.dedent(u"""\ if a: b if f: g if h: i """) - expected_formatted_code_lines1and2 = textwrap.dedent( - u"""\ + expected_formatted_code_lines1and2 = textwrap.dedent(u"""\ if a: b if f: g if h: i """) - expected_formatted_code_lines3 = textwrap.dedent( - u"""\ + expected_formatted_code_lines3 = textwrap.dedent(u"""\ if a: b if f: g @@ -255,8 +240,7 @@ def testFormatFileLinesSelection(self): self.assertCodeEqual(expected_formatted_code_lines3, formatted_code) def testFormatFileDiff(self): - unformatted_code = textwrap.dedent( - u"""\ + unformatted_code = textwrap.dedent(u"""\ if True: pass """) @@ -266,7 +250,7 @@ def testFormatFileDiff(self): def testFormatFileInPlace(self): unformatted_code = u'True==False\n' - formatted_code = u'True == False\n' + formatted_code = u'True == False\n' with utils.TempFileContents(self.test_tmpdir, unformatted_code) as filepath: result, _, _ = yapf_api.FormatFile(filepath, in_place=True) self.assertEqual(result, None) @@ -280,23 +264,21 @@ def testFormatFileInPlace(self): ValueError, yapf_api.FormatFile, filepath, - in_place =True, - print_diff =True) + in_place=True, + print_diff=True) def testNoFile(self): - stream = py3compat.StringIO() + stream = py3compat.StringIO() handler = logging.StreamHandler(stream) - logger = logging.getLogger('mylogger') + logger = logging.getLogger('mylogger') logger.addHandler(handler) self.assertRaises( IOError, yapf_api.FormatFile, 'not_a_file.py', logger=logger.error) - self.assertEqual( - stream.getvalue(), - "[Errno 2] No such file or directory: 'not_a_file.py'\n") + self.assertEqual(stream.getvalue(), + "[Errno 2] No such file or directory: 'not_a_file.py'\n") def testCommentsUnformatted(self): - code = textwrap.dedent( - u"""\ + code = textwrap.dedent(u"""\ foo = [# A list of things # bork 'one', @@ -308,8 +290,7 @@ def testCommentsUnformatted(self): self.assertCodeEqual(code, formatted_code) def testDisabledHorizontalFormattingOnNewLine(self): - code = textwrap.dedent( - u"""\ + code = textwrap.dedent(u"""\ # yapf: disable a = [ 1] @@ -320,14 +301,12 @@ def testDisabledHorizontalFormattingOnNewLine(self): self.assertCodeEqual(code, formatted_code) def testSplittingSemicolonStatements(self): - unformatted_code = textwrap.dedent( - u"""\ + unformatted_code = textwrap.dedent(u"""\ def f(): x = y + 42 ; z = n * 42 if True: a += 1 ; b += 1; c += 1 """) - expected_formatted_code = textwrap.dedent( - u"""\ + expected_formatted_code = textwrap.dedent(u"""\ def f(): x = y + 42 z = n * 42 @@ -341,14 +320,12 @@ def f(): self.assertCodeEqual(expected_formatted_code, formatted_code) def testSemicolonStatementsDisabled(self): - unformatted_code = textwrap.dedent( - u"""\ + unformatted_code = textwrap.dedent(u"""\ def f(): x = y + 42 ; z = n * 42 # yapf: disable if True: a += 1 ; b += 1; c += 1 """) - expected_formatted_code = textwrap.dedent( - u"""\ + expected_formatted_code = textwrap.dedent(u"""\ def f(): x = y + 42 ; z = n * 42 # yapf: disable if True: @@ -361,8 +338,7 @@ def f(): self.assertCodeEqual(expected_formatted_code, formatted_code) def testDisabledSemiColonSeparatedStatements(self): - code = textwrap.dedent( - u"""\ + code = textwrap.dedent(u"""\ # yapf: disable if True: a ; b """) @@ -371,8 +347,7 @@ def testDisabledSemiColonSeparatedStatements(self): self.assertCodeEqual(code, formatted_code) def testDisabledMultilineStringInDictionary(self): - code = textwrap.dedent( - u"""\ + code = textwrap.dedent(u"""\ # yapf: disable A = [ @@ -391,8 +366,7 @@ def testDisabledMultilineStringInDictionary(self): self.assertCodeEqual(code, formatted_code) def testDisabledWithPrecedingText(self): - code = textwrap.dedent( - u"""\ + code = textwrap.dedent(u"""\ # TODO(fix formatting): yapf: disable A = [ @@ -428,8 +402,11 @@ def setUpClass(cls): # pylint: disable=g-missing-super-call def tearDownClass(cls): # pylint: disable=g-missing-super-call shutil.rmtree(cls.test_tmpdir) - def assertYapfReformats( - self, unformatted, expected, extra_options=None, env=None): + def assertYapfReformats(self, + unformatted, + expected, + extra_options=None, + env=None): """Check that yapf reformats the given code as expected. Invokes yapf in a subprocess, piping the unformatted code into its stdin. @@ -442,12 +419,12 @@ def assertYapfReformats( env: dict of environment variables. """ cmdline = YAPF_BINARY + (extra_options or []) - p = subprocess.Popen( + p = subprocess.Popen( cmdline, - stdout =subprocess.PIPE, - stdin =subprocess.PIPE, - stderr =subprocess.PIPE, - env =env) + stdout=subprocess.PIPE, + stdin=subprocess.PIPE, + stderr=subprocess.PIPE, + env=env) reformatted_code, stderrdata = p.communicate( unformatted.encode('utf-8-sig')) self.assertEqual(stderrdata, b'') @@ -455,30 +432,27 @@ def assertYapfReformats( @unittest.skipUnless(py3compat.PY36, 'Requires Python 3.6') def testUnicodeEncodingPipedToFile(self): - unformatted_code = textwrap.dedent( - u"""\ + unformatted_code = textwrap.dedent(u"""\ def foo(): print('⇒') """) - with utils.NamedTempFile(dirname=self.test_tmpdir, - suffix='.py') as (out, _): - with utils.TempFileContents(self.test_tmpdir, unformatted_code, - suffix='.py') as filepath: + with utils.NamedTempFile( + dirname=self.test_tmpdir, suffix='.py') as (out, _): + with utils.TempFileContents( + self.test_tmpdir, unformatted_code, suffix='.py') as filepath: subprocess.check_call(YAPF_BINARY + ['--diff', filepath], stdout=out) def testInPlaceReformatting(self): - unformatted_code = textwrap.dedent( - u"""\ + unformatted_code = textwrap.dedent(u"""\ def foo(): x = 37 """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def foo(): x = 37 """) - with utils.TempFileContents(self.test_tmpdir, unformatted_code, - suffix='.py') as filepath: + with utils.TempFileContents( + self.test_tmpdir, unformatted_code, suffix='.py') as filepath: p = subprocess.Popen(YAPF_BINARY + ['--in-place', filepath]) p.wait() with io.open(filepath, mode='r', newline='') as fd: @@ -486,10 +460,10 @@ def foo(): self.assertEqual(reformatted_code, expected_formatted_code) def testInPlaceReformattingBlank(self): - unformatted_code = u'\n\n' + unformatted_code = u'\n\n' expected_formatted_code = u'\n' - with utils.TempFileContents(self.test_tmpdir, unformatted_code, - suffix='.py') as filepath: + with utils.TempFileContents( + self.test_tmpdir, unformatted_code, suffix='.py') as filepath: p = subprocess.Popen(YAPF_BINARY + ['--in-place', filepath]) p.wait() with io.open(filepath, mode='r', encoding='utf-8', newline='') as fd: @@ -497,10 +471,10 @@ def testInPlaceReformattingBlank(self): self.assertEqual(reformatted_code, expected_formatted_code) def testInPlaceReformattingEmpty(self): - unformatted_code = u'' + unformatted_code = u'' expected_formatted_code = u'' - with utils.TempFileContents(self.test_tmpdir, unformatted_code, - suffix='.py') as filepath: + with utils.TempFileContents( + self.test_tmpdir, unformatted_code, suffix='.py') as filepath: p = subprocess.Popen(YAPF_BINARY + ['--in-place', filepath]) p.wait() with io.open(filepath, mode='r', encoding='utf-8', newline='') as fd: @@ -508,37 +482,31 @@ def testInPlaceReformattingEmpty(self): self.assertEqual(reformatted_code, expected_formatted_code) def testReadFromStdin(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def foo(): x = 37 """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def foo(): x = 37 """) self.assertYapfReformats(unformatted_code, expected_formatted_code) def testReadFromStdinWithEscapedStrings(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ s = "foo\\nbar" """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ s = "foo\\nbar" """) self.assertYapfReformats(unformatted_code, expected_formatted_code) def testSetYapfStyle(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def foo(): # trail x = 37 """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def foo(): # trail x = 37 """) @@ -548,18 +516,15 @@ def foo(): # trail extra_options=['--style=yapf']) def testSetCustomStyleBasedOnYapf(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def foo(): # trail x = 37 """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def foo(): # trail x = 37 """) - style_file = textwrap.dedent( - u'''\ + style_file = textwrap.dedent(u'''\ [style] based_on_style = yapf spaces_before_comment = 4 @@ -571,18 +536,15 @@ def foo(): # trail extra_options=['--style={0}'.format(stylepath)]) def testSetCustomStyleSpacesBeforeComment(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ a_very_long_statement_that_extends_way_beyond # Comment short # This is a shorter statement """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ a_very_long_statement_that_extends_way_beyond # Comment short # This is a shorter statement """) # noqa - style_file = textwrap.dedent( - u'''\ + style_file = textwrap.dedent(u'''\ [style] spaces_before_comment = 15, 20 ''') @@ -593,28 +555,26 @@ def testSetCustomStyleSpacesBeforeComment(self): extra_options=['--style={0}'.format(stylepath)]) def testReadSingleLineCodeFromStdin(self): - unformatted_code = textwrap.dedent("""\ + unformatted_code = textwrap.dedent("""\ if True: pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ if True: pass """) self.assertYapfReformats(unformatted_code, expected_formatted_code) def testEncodingVerification(self): - unformatted_code = textwrap.dedent( - u"""\ + unformatted_code = textwrap.dedent(u"""\ '''The module docstring.''' # -*- coding: utf-8 -*- def f(): x = 37 """) - with utils.NamedTempFile(suffix='.py', - dirname=self.test_tmpdir) as (out, _): - with utils.TempFileContents(self.test_tmpdir, unformatted_code, - suffix='.py') as filepath: + with utils.NamedTempFile( + suffix='.py', dirname=self.test_tmpdir) as (out, _): + with utils.TempFileContents( + self.test_tmpdir, unformatted_code, suffix='.py') as filepath: try: subprocess.check_call(YAPF_BINARY + ['--diff', filepath], stdout=out) except subprocess.CalledProcessError as e: @@ -622,8 +582,7 @@ def f(): self.assertEqual(e.returncode, 1) # pylint: disable=g-assert-in-except # noqa def testReformattingSpecificLines(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass @@ -633,8 +592,7 @@ def g(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): @@ -654,16 +612,14 @@ def g(): extra_options=['--lines', '1-2']) def testOmitFormattingLinesBeforeDisabledFunctionComment(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ import sys # Comment def some_func(x): x = ["badly" , "formatted","line" ] """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ import sys # Comment @@ -676,8 +632,7 @@ def some_func(x): extra_options=['--lines', '5-5']) def testReformattingSkippingLines(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass @@ -688,8 +643,7 @@ def g(): pass # yapf: enable """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): @@ -705,8 +659,7 @@ def g(): self.assertYapfReformats(unformatted_code, expected_formatted_code) def testReformattingSkippingToEndOfFile(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass @@ -723,8 +676,7 @@ def e(): 'bbbbbbb'): pass """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): @@ -746,8 +698,7 @@ def e(): self.assertYapfReformats(unformatted_code, expected_formatted_code) def testReformattingSkippingSingleLine(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass @@ -756,8 +707,7 @@ def g(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): # yapf: disable pass """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): @@ -771,15 +721,13 @@ def g(): self.assertYapfReformats(unformatted_code, expected_formatted_code) def testDisableWholeDataStructure(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ A = set([ 'hello', 'world', ]) # yapf: disable """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ A = set([ 'hello', 'world', @@ -788,16 +736,14 @@ def testDisableWholeDataStructure(self): self.assertYapfReformats(unformatted_code, expected_formatted_code) def testDisableButAdjustIndentations(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ class SplitPenaltyTest(unittest.TestCase): def testUnbreakable(self): self._CheckPenalties(tree, [ ]) # yapf: disable """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ class SplitPenaltyTest(unittest.TestCase): def testUnbreakable(self): @@ -807,8 +753,7 @@ def testUnbreakable(self): self.assertYapfReformats(unformatted_code, expected_formatted_code) def testRetainingHorizontalWhitespace(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass @@ -817,8 +762,7 @@ def g(): if (xxxxxxxxxxxx.yyyyyyyy (zzzzzzzzzzzzz [0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): # yapf: disable pass """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): @@ -832,8 +776,7 @@ def g(): self.assertYapfReformats(unformatted_code, expected_formatted_code) def testRetainingVerticalWhitespace(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass @@ -845,8 +788,7 @@ def g(): pass """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def h(): if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): @@ -864,8 +806,7 @@ def g(): expected_formatted_code, extra_options=['--lines', '1-2']) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ if a: b @@ -882,8 +823,7 @@ def g(): # trailing whitespace """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ if a: b @@ -903,8 +843,7 @@ def g(): expected_formatted_code, extra_options=['--lines', '3-3', '--lines', '13-13']) - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ ''' docstring @@ -917,7 +856,7 @@ def g(): unformatted_code, unformatted_code, extra_options=['--lines', '2-2']) def testVerticalSpacingWithCommentWithContinuationMarkers(self): - unformatted_code = """\ + unformatted_code = """\ # \\ # \\ # \\ @@ -939,15 +878,13 @@ def testVerticalSpacingWithCommentWithContinuationMarkers(self): extra_options=['--lines', '1-1']) def testRetainingSemicolonsWhenSpecifyingLines(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ a = line_to_format def f(): x = y + 42; z = n * 42 if True: a += 1 ; b += 1 ; c += 1 """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ a = line_to_format def f(): x = y + 42; z = n * 42 @@ -959,8 +896,7 @@ def f(): extra_options=['--lines', '1-1']) def testDisabledMultilineStrings(self): - unformatted_code = textwrap.dedent( - '''\ + unformatted_code = textwrap.dedent('''\ foo=42 def f(): email_text += """This is a really long docstring that goes over the column limit and is multi-line.

@@ -970,8 +906,7 @@ def f(): """ ''') # noqa - expected_formatted_code = textwrap.dedent( - '''\ + expected_formatted_code = textwrap.dedent('''\ foo = 42 def f(): email_text += """This is a really long docstring that goes over the column limit and is multi-line.

@@ -987,8 +922,7 @@ def f(): extra_options=['--lines', '1-1']) def testDisableWhenSpecifyingLines(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ # yapf: disable A = set([ 'hello', @@ -1000,8 +934,7 @@ def testDisableWhenSpecifyingLines(self): 'world', ]) # yapf: disable """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ # yapf: disable A = set([ 'hello', @@ -1019,8 +952,7 @@ def testDisableWhenSpecifyingLines(self): extra_options=['--lines', '1-10']) def testDisableFormattingInDataLiteral(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def horrible(): oh_god() why_would_you() @@ -1039,8 +971,7 @@ def still_horrible(): 'that' ] """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def horrible(): oh_god() why_would_you() @@ -1061,8 +992,7 @@ def still_horrible(): extra_options=['--lines', '14-15']) def testRetainVerticalFormattingBetweenDisabledAndEnabledLines(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ class A(object): def aaaaaaaaaaaaa(self): c = bbbbbbbbb.ccccccccc('challenge', 0, 1, 10) @@ -1073,8 +1003,7 @@ def aaaaaaaaaaaaa(self): gggggggggggg.hhhhhhhhh(c, c.ffffffffffff)) iiiii = jjjjjjjjjjjjjj.iiiii """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ class A(object): def aaaaaaaaaaaaa(self): c = bbbbbbbbb.ccccccccc('challenge', 0, 1, 10) @@ -1089,8 +1018,7 @@ def aaaaaaaaaaaaa(self): extra_options=['--lines', '4-7']) def testRetainVerticalFormattingBetweenDisabledLines(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ class A(object): def aaaaaaaaaaaaa(self): pass @@ -1099,8 +1027,7 @@ def aaaaaaaaaaaaa(self): def bbbbbbbbbbbbb(self): # 5 pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ class A(object): def aaaaaaaaaaaaa(self): pass @@ -1115,8 +1042,7 @@ def bbbbbbbbbbbbb(self): # 5 extra_options=['--lines', '4-4']) def testFormatLinesSpecifiedInMiddleOfExpression(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ class A(object): def aaaaaaaaaaaaa(self): c = bbbbbbbbb.ccccccccc('challenge', 0, 1, 10) @@ -1127,8 +1053,7 @@ def aaaaaaaaaaaaa(self): gggggggggggg.hhhhhhhhh(c, c.ffffffffffff)) iiiii = jjjjjjjjjjjjjj.iiiii """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ class A(object): def aaaaaaaaaaaaa(self): c = bbbbbbbbb.ccccccccc('challenge', 0, 1, 10) @@ -1143,8 +1068,7 @@ def aaaaaaaaaaaaa(self): extra_options=['--lines', '5-6']) def testCommentFollowingMultilineString(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def foo(): '''First line. Second line. @@ -1152,8 +1076,7 @@ def foo(): x = '''hello world''' # second comment return 42 # another comment """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def foo(): '''First line. Second line. @@ -1168,14 +1091,12 @@ def foo(): def testDedentClosingBracket(self): # no line-break on the first argument, not dedenting closing brackets - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def overly_long_function_name(first_argument_on_the_same_line, second_argument_makes_the_line_too_long): pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def overly_long_function_name(first_argument_on_the_same_line, second_argument_makes_the_line_too_long): pass @@ -1193,8 +1114,7 @@ def overly_long_function_name(first_argument_on_the_same_line, # extra_options=['--style=facebook']) # line-break before the first argument, dedenting closing brackets if set - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def overly_long_function_name( first_argument_on_the_same_line, second_argument_makes_the_line_too_long): @@ -1206,8 +1126,7 @@ def overly_long_function_name( # second_argument_makes_the_line_too_long): # pass # """) - expected_formatted_fb_code = textwrap.dedent( - """\ + expected_formatted_fb_code = textwrap.dedent("""\ def overly_long_function_name( first_argument_on_the_same_line, second_argument_makes_the_line_too_long ): @@ -1225,16 +1144,14 @@ def overly_long_function_name( # extra_options=['--style=pep8']) def testCoalesceBrackets(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ some_long_function_name_foo( { 'first_argument_of_the_thing': id, 'second_argument_of_the_thing': "some thing" } )""") - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ some_long_function_name_foo({ 'first_argument_of_the_thing': id, 'second_argument_of_the_thing': "some thing" @@ -1242,8 +1159,7 @@ def testCoalesceBrackets(self): """) with utils.NamedTempFile(dirname=self.test_tmpdir, mode='w') as (f, name): f.write( - textwrap.dedent( - u'''\ + textwrap.dedent(u'''\ [style] column_limit=82 coalesce_brackets = True @@ -1255,14 +1171,12 @@ def testCoalesceBrackets(self): extra_options=['--style={0}'.format(name)]) def testPseudoParenSpaces(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def foo(): def bar(): return {msg_id: author for author, msg_id in reader} """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def foo(): def bar(): return {msg_id: author for author, msg_id in reader} @@ -1273,8 +1187,7 @@ def bar(): extra_options=['--lines', '1-1', '--style', 'yapf']) def testMultilineCommentFormattingDisabled(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ # This is a comment FOO = { aaaaaaaa.ZZZ: [ @@ -1288,8 +1201,7 @@ def testMultilineCommentFormattingDisabled(self): '#': lambda x: x # do nothing } """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ # This is a comment FOO = { aaaaaaaa.ZZZ: [ @@ -1309,16 +1221,14 @@ def testMultilineCommentFormattingDisabled(self): extra_options=['--lines', '1-1', '--style', 'yapf']) def testTrailingCommentsWithDisabledFormatting(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ import os SCOPES = [ 'hello world' # This is a comment. ] """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ import os SCOPES = [ @@ -1331,7 +1241,7 @@ def testTrailingCommentsWithDisabledFormatting(self): extra_options=['--lines', '1-1', '--style', 'yapf']) def testUseTabs(self): - unformatted_code = """\ + unformatted_code = """\ def foo_function(): if True: pass @@ -1341,7 +1251,7 @@ def foo_function(): if True: pass """ # noqa: W191,E101 - style_contents = u"""\ + style_contents = u"""\ [style] based_on_style = yapf USE_TABS = true @@ -1354,7 +1264,7 @@ def foo_function(): extra_options=['--style={0}'.format(stylepath)]) def testUseTabsWith(self): - unformatted_code = """\ + unformatted_code = """\ def f(): return ['hello', 'world',] """ @@ -1365,7 +1275,7 @@ def f(): 'world', ] """ # noqa: W191,E101 - style_contents = u"""\ + style_contents = u"""\ [style] based_on_style = yapf USE_TABS = true @@ -1378,7 +1288,7 @@ def f(): extra_options=['--style={0}'.format(stylepath)]) def testUseTabsContinuationAlignStyleFixed(self): - unformatted_code = """\ + unformatted_code = """\ def foo_function(arg1, arg2, arg3): return ['hello', 'world',] """ @@ -1390,7 +1300,7 @@ def foo_function( 'world', ] """ # noqa: W191,E101 - style_contents = u"""\ + style_contents = u"""\ [style] based_on_style = yapf USE_TABS = true @@ -1406,7 +1316,7 @@ def foo_function( extra_options=['--style={0}'.format(stylepath)]) def testUseTabsContinuationAlignStyleVAlignRight(self): - unformatted_code = """\ + unformatted_code = """\ def foo_function(arg1, arg2, arg3): return ['hello', 'world',] """ @@ -1418,7 +1328,7 @@ def foo_function(arg1, arg2, 'world', ] """ # noqa: W191,E101 - style_contents = u"""\ + style_contents = u"""\ [style] based_on_style = yapf USE_TABS = true @@ -1434,7 +1344,7 @@ def foo_function(arg1, arg2, extra_options=['--style={0}'.format(stylepath)]) def testUseSpacesContinuationAlignStyleFixed(self): - unformatted_code = """\ + unformatted_code = """\ def foo_function(arg1, arg2, arg3): return ['hello', 'world',] """ @@ -1446,7 +1356,7 @@ def foo_function( 'world', ] """ - style_contents = u"""\ + style_contents = u"""\ [style] based_on_style = yapf COLUMN_LIMIT=32 @@ -1461,7 +1371,7 @@ def foo_function( extra_options=['--style={0}'.format(stylepath)]) def testUseSpacesContinuationAlignStyleVAlignRight(self): - unformatted_code = """\ + unformatted_code = """\ def foo_function(arg1, arg2, arg3): return ['hello', 'world',] """ @@ -1473,7 +1383,7 @@ def foo_function(arg1, arg2, 'world', ] """ - style_contents = u"""\ + style_contents = u"""\ [style] based_on_style = yapf COLUMN_LIMIT=32 @@ -1488,13 +1398,11 @@ def foo_function(arg1, arg2, extra_options=['--style={0}'.format(stylepath)]) def testStyleOutputRoundTrip(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def foo_function(): pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def foo_function(): pass """) @@ -1503,9 +1411,9 @@ def foo_function(): stylepath): p = subprocess.Popen( YAPF_BINARY + ['--style-help'], - stdout =stylefile, - stdin =subprocess.PIPE, - stderr =subprocess.PIPE) + stdout=stylefile, + stdin=subprocess.PIPE, + stderr=subprocess.PIPE) _, stderrdata = p.communicate() self.assertEqual(stderrdata, b'') self.assertYapfReformats( @@ -1514,8 +1422,7 @@ def foo_function(): extra_options=['--style={0}'.format(stylepath)]) def testSpacingBeforeComments(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ A = 42 @@ -1525,8 +1432,7 @@ def x(): def _(): pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ A = 42 @@ -1542,8 +1448,7 @@ def _(): extra_options=['--lines', '1-2']) def testSpacingBeforeCommentsInDicts(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ A=42 X = { @@ -1558,8 +1463,7 @@ def testSpacingBeforeCommentsInDicts(self): 'BROKEN' } """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ A = 42 X = { @@ -1580,8 +1484,7 @@ def testSpacingBeforeCommentsInDicts(self): extra_options=['--style', 'yapf', '--lines', '1-1']) def testDisableWithLinesOption(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ # yapf_lines_bug.py # yapf: disable def outer_func(): @@ -1590,8 +1493,7 @@ def inner_func(): return # yapf: enable """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ # yapf_lines_bug.py # yapf: disable def outer_func(): @@ -1607,7 +1509,7 @@ def inner_func(): @unittest.skipUnless(py3compat.PY36, 'Requires Python 3.6') def testNoSpacesAroundBinaryOperators(self): - unformatted_code = """\ + unformatted_code = """\ a = 4-b/c@d**37 """ expected_formatted_code = """\ @@ -1616,7 +1518,7 @@ def testNoSpacesAroundBinaryOperators(self): self.assertYapfReformats( unformatted_code, expected_formatted_code, - extra_options =[ + extra_options=[ '--style', '{based_on_style: pep8, ' 'no_spaces_around_selected_binary_operators: "@,**,-"}', @@ -1624,7 +1526,7 @@ def testNoSpacesAroundBinaryOperators(self): @unittest.skipUnless(py3compat.PY36, 'Requires Python 3.6') def testCP936Encoding(self): - unformatted_code = 'print("中文")\n' + unformatted_code = 'print("中文")\n' expected_formatted_code = 'print("中文")\n' self.assertYapfReformats( unformatted_code, @@ -1632,7 +1534,7 @@ def testCP936Encoding(self): env={'PYTHONIOENCODING': 'cp936'}) def testDisableWithLineRanges(self): - unformatted_code = """\ + unformatted_code = """\ # yapf: disable a = [ 1, @@ -1672,8 +1574,8 @@ class DiffIndentTest(unittest.TestCase): @staticmethod def _OwnStyle(): - my_style = style.CreatePEP8Style() - my_style['INDENT_WIDTH'] = 3 + my_style = style.CreatePEP8Style() + my_style['INDENT_WIDTH'] = 3 my_style['CONTINUATION_INDENT_WIDTH'] = 3 return my_style @@ -1683,13 +1585,11 @@ def _Check(self, unformatted_code, expected_formatted_code): self.assertEqual(expected_formatted_code, formatted_code) def testSimple(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ for i in range(5): print('bar') """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ for i in range(5): print('bar') """) @@ -1700,7 +1600,7 @@ class HorizontallyAlignedTrailingCommentsTest(yapf_test_helper.YAPFTest): @staticmethod def _OwnStyle(): - my_style = style.CreatePEP8Style() + my_style = style.CreatePEP8Style() my_style['SPACES_BEFORE_COMMENT'] = [ 15, 25, @@ -1714,8 +1614,7 @@ def _Check(self, unformatted_code, expected_formatted_code): self.assertCodeEqual(expected_formatted_code, formatted_code) def testSimple(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ foo = '1' # Aligned at first list value foo = '2__<15>' # Aligned at second list value @@ -1724,8 +1623,7 @@ def testSimple(self): foo = '4______________________<35>' # Aligned beyond list values """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ foo = '1' # Aligned at first list value foo = '2__<15>' # Aligned at second list value @@ -1737,8 +1635,7 @@ def testSimple(self): self._Check(unformatted_code, expected_formatted_code) def testBlock(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ func(1) # Line 1 func(2) # Line 2 # Line 3 @@ -1746,8 +1643,7 @@ def testBlock(self): # Line 5 # Line 6 """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ func(1) # Line 1 func(2) # Line 2 # Line 3 @@ -1758,8 +1654,7 @@ def testBlock(self): self._Check(unformatted_code, expected_formatted_code) def testBlockWithLongLine(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ func(1) # Line 1 func___________________(2) # Line 2 # Line 3 @@ -1767,8 +1662,7 @@ def testBlockWithLongLine(self): # Line 5 # Line 6 """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ func(1) # Line 1 func___________________(2) # Line 2 # Line 3 @@ -1779,8 +1673,7 @@ def testBlockWithLongLine(self): self._Check(unformatted_code, expected_formatted_code) def testBlockFuncSuffix(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ func(1) # Line 1 func(2) # Line 2 # Line 3 @@ -1791,8 +1684,7 @@ def testBlockFuncSuffix(self): def Func(): pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ func(1) # Line 1 func(2) # Line 2 # Line 3 @@ -1807,8 +1699,7 @@ def Func(): self._Check(unformatted_code, expected_formatted_code) def testBlockCommentSuffix(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ func(1) # Line 1 func(2) # Line 2 # Line 3 @@ -1818,8 +1709,7 @@ def testBlockCommentSuffix(self): # Aligned with prev comment block """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ func(1) # Line 1 func(2) # Line 2 # Line 3 @@ -1832,8 +1722,7 @@ def testBlockCommentSuffix(self): self._Check(unformatted_code, expected_formatted_code) def testBlockIndentedFuncSuffix(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ if True: func(1) # Line 1 func(2) # Line 2 @@ -1847,8 +1736,7 @@ def testBlockIndentedFuncSuffix(self): def Func(): pass """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ if True: func(1) # Line 1 func(2) # Line 2 @@ -1867,8 +1755,7 @@ def Func(): self._Check(unformatted_code, expected_formatted_code) def testBlockIndentedCommentSuffix(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ if True: func(1) # Line 1 func(2) # Line 2 @@ -1879,8 +1766,7 @@ def testBlockIndentedCommentSuffix(self): # Not aligned """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ if True: func(1) # Line 1 func(2) # Line 2 @@ -1894,8 +1780,7 @@ def testBlockIndentedCommentSuffix(self): self._Check(unformatted_code, expected_formatted_code) def testBlockMultiIndented(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ if True: if True: if True: @@ -1908,8 +1793,7 @@ def testBlockMultiIndented(self): # Not aligned """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ if True: if True: if True: @@ -1925,8 +1809,7 @@ def testBlockMultiIndented(self): self._Check(unformatted_code, expected_formatted_code) def testArgs(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ def MyFunc( arg1, # Desc 1 arg2, # Desc 2 @@ -1937,8 +1820,7 @@ def MyFunc( ): pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def MyFunc( arg1, # Desc 1 arg2, # Desc 2 @@ -1952,8 +1834,7 @@ def MyFunc( self._Check(unformatted_code, expected_formatted_code) def testDisableBlock(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ a() # comment 1 b() # comment 2 @@ -1965,8 +1846,7 @@ def testDisableBlock(self): e() # comment 5 f() # comment 6 """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ a() # comment 1 b() # comment 2 @@ -1981,15 +1861,13 @@ def testDisableBlock(self): self._Check(unformatted_code, expected_formatted_code) def testDisabledLine(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ short # comment 1 do_not_touch1 # yapf: disable do_not_touch2 # yapf: disable a_longer_statement # comment 2 """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ short # comment 1 do_not_touch1 # yapf: disable do_not_touch2 # yapf: disable @@ -2002,9 +1880,9 @@ class _SpacesAroundDictListTupleTestImpl(unittest.TestCase): @staticmethod def _OwnStyle(): - my_style = style.CreatePEP8Style() - my_style['DISABLE_ENDING_COMMA_HEURISTIC'] = True - my_style['SPLIT_ALL_COMMA_SEPARATED_VALUES'] = False + my_style = style.CreatePEP8Style() + my_style['DISABLE_ENDING_COMMA_HEURISTIC'] = True + my_style['SPLIT_ALL_COMMA_SEPARATED_VALUES'] = False my_style['SPLIT_ARGUMENTS_WHEN_COMMA_TERMINATED'] = False return my_style @@ -2021,14 +1899,13 @@ class SpacesAroundDictTest(_SpacesAroundDictListTupleTestImpl): @classmethod def _OwnStyle(cls): - style = super(SpacesAroundDictTest, cls)._OwnStyle() + style = super(SpacesAroundDictTest, cls)._OwnStyle() style['SPACES_AROUND_DICT_DELIMITERS'] = True return style def testStandard(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ {1 : 2} {k:v for k, v in other.items()} {k for k in [1, 2, 3]} @@ -2045,8 +1922,7 @@ def testStandard(self): [1, 2] (3, 4) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ { 1: 2 } { k: v for k, v in other.items() } { k for k in [1, 2, 3] } @@ -2071,14 +1947,13 @@ class SpacesAroundListTest(_SpacesAroundDictListTupleTestImpl): @classmethod def _OwnStyle(cls): - style = super(SpacesAroundListTest, cls)._OwnStyle() + style = super(SpacesAroundListTest, cls)._OwnStyle() style['SPACES_AROUND_LIST_DELIMITERS'] = True return style def testStandard(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ [a,b,c] [4,5,] [6, [7, 8], 9] @@ -2099,8 +1974,7 @@ def testStandard(self): {a: b} (1, 2) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ [ a, b, c ] [ 4, 5, ] [ 6, [ 7, 8 ], 9 ] @@ -2129,14 +2003,13 @@ class SpacesAroundTupleTest(_SpacesAroundDictListTupleTestImpl): @classmethod def _OwnStyle(cls): - style = super(SpacesAroundTupleTest, cls)._OwnStyle() + style = super(SpacesAroundTupleTest, cls)._OwnStyle() style['SPACES_AROUND_TUPLE_DELIMITERS'] = True return style def testStandard(self): - unformatted_code = textwrap.dedent( - """\ + unformatted_code = textwrap.dedent("""\ (0, 1) (2, 3) (4, 5, 6,) @@ -2159,8 +2032,7 @@ def testStandard(self): {a: b} [3, 4] """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ ( 0, 1 ) ( 2, 3 ) ( 4, 5, 6, ) diff --git a/yapftests/yapf_test_helper.py b/yapftests/yapf_test_helper.py index b70b193f4..cb56ec865 100644 --- a/yapftests/yapf_test_helper.py +++ b/yapftests/yapf_test_helper.py @@ -39,7 +39,7 @@ def __init__(self, *args): def assertCodeEqual(self, expected_code, code): if code != expected_code: - msg = ['Code format mismatch:', 'Expected:'] + msg = ['Code format mismatch:', 'Expected:'] linelen = style.Get('COLUMN_LIMIT') for line in expected_code.splitlines(): if len(line) > linelen: @@ -57,9 +57,9 @@ def assertCodeEqual(self, expected_code, code): difflib.unified_diff( code.splitlines(), expected_code.splitlines(), - fromfile ='actual', - tofile ='expected', - lineterm ='')) + fromfile='actual', + tofile='expected', + lineterm='')) self.fail('\n'.join(msg))