From f62d92972256e98045f106a3883ed46443331fc0 Mon Sep 17 00:00:00 2001 From: Xiao Wang Date: Thu, 18 Aug 2022 10:40:01 +0200 Subject: [PATCH 01/11] 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 02/11] 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 03/11] 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 04/11] 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 05/11] 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 06/11] 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 07/11] 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 4246e8567fb34aed72c8ae55e531ffb6909bb850 Mon Sep 17 00:00:00 2001 From: Xiao Wang Date: Mon, 3 Oct 2022 15:22:51 +0200 Subject: [PATCH 08/11] new branch for argument assignment alignment --- yapf/yapflib/format_token.py | 583 +++--- yapf/yapflib/reformatter.py | 1676 +++++++--------- yapf/yapflib/style.py | 873 +++++---- yapftests/reformatter_basic_test.py | 2801 ++++++++++++++------------- 4 files changed, 2844 insertions(+), 3089 deletions(-) diff --git a/yapf/yapflib/format_token.py b/yapf/yapflib/format_token.py index 070987851..eb053e3e9 100644 --- a/yapf/yapflib/format_token.py +++ b/yapf/yapflib/format_token.py @@ -30,7 +30,7 @@ def _TabbedContinuationAlignPadding(spaces, align_style, tab_width): - """Build padding string for continuation alignment in tabbed indentation. + """Build padding string for continuation alignment in tabbed indentation. Arguments: spaces: (int) The number of spaces to place before the token for alignment. @@ -40,15 +40,15 @@ def _TabbedContinuationAlignPadding(spaces, align_style, tab_width): Returns: A padding string for alignment with style specified by align_style option. """ - if align_style in ('FIXED', 'VALIGN-RIGHT'): - if spaces > 0: - return '\t' * int((spaces + tab_width - 1) / tab_width) - return '' - return ' ' * spaces + if align_style in ('FIXED', 'VALIGN-RIGHT'): + if spaces > 0: + return '\t' * int((spaces + tab_width - 1) / tab_width) + return '' + return ' ' * spaces class FormatToken(object): - """Enhanced token information for formatting. + """Enhanced token information for formatting. This represents the token plus additional information useful for reformatting the code. @@ -83,58 +83,57 @@ class FormatToken(object): newlines: The number of newlines needed before this token. """ - def __init__(self, node, name): - """Constructor. + def __init__(self, node, name): + """Constructor. Arguments: 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.column = node.column - self.lineno = node.lineno - 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.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( - node, pytree_utils.Annotation.MUST_SPLIT, default=False) - self.newlines = pytree_utils.GetNodeAnnotation( - node, pytree_utils.Annotation.NEWLINES) - self.spaces_required_before = 0 - - 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 - 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) - if height: - return ('\n' + without_newlines) * height - return self.whitespace_prefix - - def AddWhitespacePrefix(self, newlines_before, spaces=0, indent_level=0): - """Register a token's whitespace prefix. + self.node = node + self.name = name + self.type = node.type + self.column = node.column + self.lineno = node.lineno + 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.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( + node, pytree_utils.Annotation.MUST_SPLIT, default=False) + self.newlines = pytree_utils.GetNodeAnnotation( + node, pytree_utils.Annotation.NEWLINES) + self.spaces_required_before = 0 + + 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 + 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) + if height: + return ('\n' + without_newlines) * height + return self.whitespace_prefix + + def AddWhitespacePrefix(self, newlines_before, spaces=0, indent_level=0): + """Register a token's whitespace prefix. This is the whitespace that will be output before a token's string. @@ -143,261 +142,233 @@ def AddWhitespacePrefix(self, newlines_before, spaces=0, indent_level=0): spaces: (int) The number of spaces to place before the token. indent_level: (int) The indentation level. """ - if style.Get('USE_TABS'): - if newlines_before > 0: - indent_before = '\t' * indent_level + _TabbedContinuationAlignPadding( - spaces, style.Get('CONTINUATION_ALIGN_STYLE'), - style.Get('INDENT_WIDTH')) - else: - indent_before = '\t' * indent_level + ' ' * spaces - else: - 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) - - # 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) - 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')) - - def RetainHorizontalSpacing(self, first_column, depth): - """Retains a token's horizontal spacing.""" - previous = self.previous_token - if not previous: - return - - if previous.is_pseudo: - previous = previous.previous_token - if not previous: - return - - cur_lineno = self.lineno - prev_lineno = previous.lineno - if previous.is_multiline_string: - prev_lineno += previous.value.count('\n') - - if (cur_lineno != prev_lineno or - (previous.is_pseudo and previous.value != ')' and - cur_lineno != previous.previous_token.lineno)): - self.spaces_required_before = ( - self.column - first_column + depth * style.Get('INDENT_WIDTH')) - return - - cur_column = self.column - prev_column = previous.column - prev_len = len(previous.value) - - if previous.is_pseudo and previous.value == ')': - prev_column -= 1 - prev_len = 0 - - if previous.is_multiline_string: - prev_len = len(previous.value.split('\n')[-1]) - if '\n' in previous.value: - prev_column = 0 # Last line starts in column 0. - - self.spaces_required_before = cur_column - (prev_column + prev_len) - - def OpensScope(self): - return self.value in _OPENING_BRACKETS - - def ClosesScope(self): - return self.value in _CLOSING_BRACKETS - - 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 += ', pseudo)' if self.is_pseudo else ')' - return msg - - @property - def node_split_penalty(self): - """Split penalty attached to the pytree node of this token.""" - return pytree_utils.GetNodeAnnotation( - self.node, pytree_utils.Annotation.SPLIT_PENALTY, default=0) - - @property - def is_binary_op(self): - """Token is a binary operator.""" - return subtypes.BINARY_OPERATOR in self.subtypes - - @property - @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 - }) - - @property - def is_simple_expr(self): - """Token is an operator in a simple expression.""" - return subtypes.SIMPLE_EXPRESSION in self.subtypes - - @property - def is_subscript_colon(self): - """Token is a subscript colon.""" - return subtypes.SUBSCRIPT_COLON in self.subtypes - - @property - def is_comment(self): - return self.type == token.COMMENT - - @property - def is_continuation(self): - return self.type == CONTINUATION - - @property - @py3compat.lru_cache() - def is_keyword(self): - return keyword.iskeyword(self.value) - - @property - def is_name(self): - return self.type == token.NAME and not self.is_keyword - - @property - def is_number(self): - return self.type == token.NUMBER - - @property - def is_string(self): - return self.type == token.STRING - - @property - def is_multiline_string(self): - """Test if this string is a multiline string. + if style.Get('USE_TABS'): + if newlines_before > 0: + indent_before = '\t' * indent_level + _TabbedContinuationAlignPadding( + spaces, style.Get('CONTINUATION_ALIGN_STYLE'), + style.Get('INDENT_WIDTH')) + else: + indent_before = '\t' * indent_level + ' ' * spaces + else: + 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) + + # 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) + 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')) + + def RetainHorizontalSpacing(self, first_column, depth): + """Retains a token's horizontal spacing.""" + previous = self.previous_token + if not previous: + return + + if previous.is_pseudo: + previous = previous.previous_token + if not previous: + return + + cur_lineno = self.lineno + prev_lineno = previous.lineno + if previous.is_multiline_string: + prev_lineno += previous.value.count('\n') + + if (cur_lineno != prev_lineno or + (previous.is_pseudo and previous.value != ')' and + cur_lineno != previous.previous_token.lineno)): + self.spaces_required_before = ( + self.column - first_column + depth * style.Get('INDENT_WIDTH')) + return + + cur_column = self.column + prev_column = previous.column + prev_len = len(previous.value) + + if previous.is_pseudo and previous.value == ')': + prev_column -= 1 + prev_len = 0 + + if previous.is_multiline_string: + prev_len = len(previous.value.split('\n')[-1]) + if '\n' in previous.value: + prev_column = 0 # Last line starts in column 0. + + self.spaces_required_before = cur_column - (prev_column + prev_len) + + def OpensScope(self): + return self.value in _OPENING_BRACKETS + + def ClosesScope(self): + return self.value in _CLOSING_BRACKETS + + 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 += ', pseudo)' if self.is_pseudo else ')' + return msg + + @property + def node_split_penalty(self): + """Split penalty attached to the pytree node of this token.""" + return pytree_utils.GetNodeAnnotation( + self.node, pytree_utils.Annotation.SPLIT_PENALTY, default=0) + + @property + def is_binary_op(self): + """Token is a binary operator.""" + return subtypes.BINARY_OPERATOR in self.subtypes + + @property + @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 + }) + + @property + def is_simple_expr(self): + """Token is an operator in a simple expression.""" + return subtypes.SIMPLE_EXPRESSION in self.subtypes + + @property + def is_subscript_colon(self): + """Token is a subscript colon.""" + return subtypes.SUBSCRIPT_COLON in self.subtypes + + @property + def is_comment(self): + return self.type == token.COMMENT + + @property + def is_continuation(self): + return self.type == CONTINUATION + + @property + @py3compat.lru_cache() + def is_keyword(self): + return keyword.iskeyword(self.value) + + @property + def is_name(self): + return self.type == token.NAME and not self.is_keyword + + @property + def is_number(self): + return self.type == token.NUMBER + + @property + def is_string(self): + return self.type == token.STRING + + @property + def is_multiline_string(self): + """Test if this string is a multiline string. Returns: A multiline string always ends with triple quotes, so if it is a string token, inspect the last 3 characters and return True if it is a triple double or triple single quote mark. """ - return self.is_string and self.value.endswith(('"""', "'''")) - - @property - def is_docstring(self): - return self.is_string and self.previous_token is None - - @property - def is_pylint_comment(self): - 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) - - @property - 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 - previous_subtypes = {0} - 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)) - ) + return self.is_string and self.value.endswith(('"""', "'''")) + + @property + def is_docstring(self): + return self.is_string and self.previous_token is None + + @property + def is_pylint_comment(self): + 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) + + @property + def is_copybara_comment(self): + return self.is_comment and re.match( + r'#.*\bcopybara:\s*(strip|insert|replace)', self.value) + + @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 + previous_subtypes = {0} + 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 8f8a103f8..c7992d290 100644 --- a/yapf/yapflib/reformatter.py +++ b/yapf/yapflib/reformatter.py @@ -38,7 +38,7 @@ def Reformat(llines, verify=False, lines=None): - """Reformat the logical lines. + """Reformat the logical lines. Arguments: llines: (list of logical_line.LogicalLine) Lines we want to format. @@ -49,144 +49,137 @@ def Reformat(llines, verify=False, lines=None): Returns: A string representing the reformatted code. """ - final_lines = [] - prev_line = None # The previous line. - indent_width = style.Get('INDENT_WIDTH') - - for lline in _SingleOrMergedLines(llines): - first_token = lline.first - _FormatFirstToken(first_token, lline.depth, prev_line, final_lines) - - indent_amt = indent_width * lline.depth - state = format_decision_state.FormatDecisionState(lline, indent_amt) - state.MoveStateToNextToken() - - if not lline.disable: - if lline.first.is_comment: - lline.first.value = lline.first.value.rstrip() - elif lline.last.is_comment: - lline.last.value = lline.last.value.rstrip() - 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) - if any(tok.is_comment for tok in lline.tokens): - _RetainVerticalSpacingBeforeComments(lline) - - if lline.disable or _LineHasContinuationMarkers(lline): - _RetainHorizontalSpacing(lline) - _RetainRequiredVerticalSpacing(lline, prev_line, lines) - _EmitLineUnformatted(state) - - elif (_LineContainsPylintDisableLineTooLong(lline) or - _LineContainsI18n(lline)): - # Don't modify vertical spacing, but fix any horizontal spacing issues. - _RetainRequiredVerticalSpacing(lline, prev_line, lines) - _EmitLineUnformatted(state) - - elif _CanPlaceOnSingleLine(lline) and not any(tok.must_break_before - for tok in lline.tokens): - # The logical line fits on one line. - while state.next_token: - state.AddTokenToState(newline=False, dry_run=False) - - elif not _AnalyzeSolutionSpace(state): - # Failsafe mode. If there isn't a solution to the line, then just emit - # it as is. - state = format_decision_state.FormatDecisionState(lline, indent_amt) - state.MoveStateToNextToken() - _RetainHorizontalSpacing(lline) - _RetainRequiredVerticalSpacing(lline, prev_line, None) - _EmitLineUnformatted(state) - - 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) + final_lines = [] + prev_line = None # The previous line. + indent_width = style.Get('INDENT_WIDTH') + + for lline in _SingleOrMergedLines(llines): + first_token = lline.first + _FormatFirstToken(first_token, lline.depth, prev_line, final_lines) + + indent_amt = indent_width * lline.depth + state = format_decision_state.FormatDecisionState(lline, indent_amt) + state.MoveStateToNextToken() + + if not lline.disable: + if lline.first.is_comment: + lline.first.value = lline.first.value.rstrip() + elif lline.last.is_comment: + lline.last.value = lline.last.value.rstrip() + 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) + if any(tok.is_comment for tok in lline.tokens): + _RetainVerticalSpacingBeforeComments(lline) + + if lline.disable or _LineHasContinuationMarkers(lline): + _RetainHorizontalSpacing(lline) + _RetainRequiredVerticalSpacing(lline, prev_line, lines) + _EmitLineUnformatted(state) + + elif (_LineContainsPylintDisableLineTooLong(lline) or _LineContainsI18n(lline)): + # Don't modify vertical spacing, but fix any horizontal spacing issues. + _RetainRequiredVerticalSpacing(lline, prev_line, lines) + _EmitLineUnformatted(state) + + elif _CanPlaceOnSingleLine(lline) and not any(tok.must_break_before + for tok in lline.tokens): + # The logical line fits on one line. + while state.next_token: + state.AddTokenToState(newline=False, dry_run=False) + + elif not _AnalyzeSolutionSpace(state): + # Failsafe mode. If there isn't a solution to the line, then just emit + # it as is. + state = format_decision_state.FormatDecisionState(lline, indent_amt) + state.MoveStateToNextToken() + _RetainHorizontalSpacing(lline) + _RetainRequiredVerticalSpacing(lline, prev_line, None) + _EmitLineUnformatted(state) + + final_lines.append(lline) + prev_line = lline + + if style.Get('ALIGN_ARGUMENT_ASSIGNMENT'): + _AlignArgAssign(final_lines) + + _AlignTrailingComments(final_lines) + return _FormatFinalLines(final_lines, verify) def _RetainHorizontalSpacing(line): - """Retain all horizontal spacing between tokens.""" - for tok in line.tokens: - tok.RetainHorizontalSpacing(line.first.column, line.depth) + """Retain all horizontal spacing between tokens.""" + for tok in line.tokens: + tok.RetainHorizontalSpacing(line.first.column, line.depth) def _RetainRequiredVerticalSpacing(cur_line, prev_line, lines): - """Retain all vertical spacing between lines.""" - prev_tok = None - if prev_line is not None: - prev_tok = prev_line.last + """Retain all vertical spacing between lines.""" + prev_tok = None + if prev_line is not None: + prev_tok = prev_line.last - if cur_line.disable: - # After the first token we are acting on a single line. So if it is - # disabled we must not reformat. - lines = set() + if cur_line.disable: + # After the first token we are acting on a single line. So if it is + # disabled we must not reformat. + lines = set() - for cur_tok in cur_line.tokens: - _RetainRequiredVerticalSpacingBetweenTokens(cur_tok, prev_tok, lines) - prev_tok = cur_tok + for cur_tok in cur_line.tokens: + _RetainRequiredVerticalSpacingBetweenTokens(cur_tok, prev_tok, lines) + prev_tok = cur_tok def _RetainRequiredVerticalSpacingBetweenTokens(cur_tok, prev_tok, lines): - """Retain vertical spacing between two tokens if not in editable range.""" - if prev_tok is None: - return - - if prev_tok.is_string: - prev_lineno = prev_tok.lineno + prev_tok.value.count('\n') - elif prev_tok.is_pseudo: - if not prev_tok.previous_token.is_multiline_string: - prev_lineno = prev_tok.previous_token.lineno + """Retain vertical spacing between two tokens if not in editable range.""" + if prev_tok is None: + return + + if prev_tok.is_string: + prev_lineno = prev_tok.lineno + prev_tok.value.count('\n') + elif prev_tok.is_pseudo: + if not prev_tok.previous_token.is_multiline_string: + prev_lineno = prev_tok.previous_token.lineno + else: + prev_lineno = prev_tok.lineno else: - prev_lineno = prev_tok.lineno - else: - prev_lineno = prev_tok.lineno + prev_lineno = prev_tok.lineno - if cur_tok.is_comment: - cur_lineno = cur_tok.lineno - cur_tok.value.count('\n') - else: - cur_lineno = cur_tok.lineno + if cur_tok.is_comment: + cur_lineno = cur_tok.lineno - cur_tok.value.count('\n') + else: + cur_lineno = cur_tok.lineno - if not prev_tok.is_comment and prev_tok.value.endswith('\\'): - prev_lineno += prev_tok.value.count('\n') + if not prev_tok.is_comment and prev_tok.value.endswith('\\'): + prev_lineno += prev_tok.value.count('\n') - required_newlines = cur_lineno - prev_lineno - if cur_tok.is_comment and not prev_tok.is_comment: - # 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) + required_newlines = cur_lineno - prev_lineno + if cur_tok.is_comment and not prev_tok.is_comment: + # 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) - cur_tok.AdjustNewlinesBefore(required_newlines) + cur_tok.AdjustNewlinesBefore(required_newlines) def _RetainVerticalSpacingBeforeComments(line): - """Retain vertical spacing before comments.""" - prev_token = None - for tok in line.tokens: - if tok.is_comment and prev_token: - if tok.lineno - tok.value.count('\n') - prev_token.lineno > 1: - tok.AdjustNewlinesBefore(ONE_BLANK_LINE) + """Retain vertical spacing before comments.""" + prev_token = None + for tok in line.tokens: + if tok.is_comment and prev_token: + if tok.lineno - tok.value.count('\n') - prev_token.lineno > 1: + tok.AdjustNewlinesBefore(ONE_BLANK_LINE) - prev_token = tok + prev_token = tok def _EmitLineUnformatted(state): - """Emit the line without formatting. + """Emit the line without formatting. The line contains code that if reformatted would break a non-syntactic convention. E.g., i18n comments and function calls are tightly bound by @@ -197,23 +190,23 @@ def _EmitLineUnformatted(state): state: (format_decision_state.FormatDecisionState) The format decision state. """ - while state.next_token: - previous_token = state.next_token.previous_token - previous_lineno = previous_token.lineno + while state.next_token: + previous_token = state.next_token.previous_token + previous_lineno = previous_token.lineno - if previous_token.is_multiline_string or previous_token.is_string: - previous_lineno += previous_token.value.count('\n') + if previous_token.is_multiline_string or previous_token.is_string: + previous_lineno += previous_token.value.count('\n') - if previous_token.is_continuation: - newline = False - else: - newline = state.next_token.lineno > previous_lineno + if previous_token.is_continuation: + newline = False + else: + newline = state.next_token.lineno > previous_lineno - state.AddTokenToState(newline=newline, dry_run=False) + state.AddTokenToState(newline=newline, dry_run=False) def _LineContainsI18n(line): - """Return true if there are i18n comments or function calls in the line. + """Return true if there are i18n comments or function calls in the line. I18n comments and pseudo-function calls are closely related. They cannot be moved apart without breaking i18n. @@ -224,33 +217,33 @@ def _LineContainsI18n(line): Returns: True if the line contains i18n comments or function calls. False otherwise. """ - if style.Get('I18N_COMMENT'): - for tok in line.tokens: - if tok.is_comment and re.match(style.Get('I18N_COMMENT'), tok.value): - # Contains an i18n comment. - return True - - if style.Get('I18N_FUNCTION_CALL'): - length = len(line.tokens) - for index in range(length - 1): - if (line.tokens[index + 1].value == '(' and - line.tokens[index].value in style.Get('I18N_FUNCTION_CALL')): - return True - return False + if style.Get('I18N_COMMENT'): + for tok in line.tokens: + if tok.is_comment and re.match(style.Get('I18N_COMMENT'), tok.value): + # Contains an i18n comment. + return True + + if style.Get('I18N_FUNCTION_CALL'): + length = len(line.tokens) + for index in range(length - 1): + if (line.tokens[index + 1].value == '(' and + line.tokens[index].value in style.Get('I18N_FUNCTION_CALL')): + return True + return False def _LineContainsPylintDisableLineTooLong(line): - """Return true if there is a "pylint: disable=line-too-long" comment.""" - return re.search(r'\bpylint:\s+disable=line-too-long\b', line.last.value) + """Return true if there is a "pylint: disable=line-too-long" comment.""" + return re.search(r'\bpylint:\s+disable=line-too-long\b', line.last.value) def _LineHasContinuationMarkers(line): - """Return true if the line has continuation markers in it.""" - return any(tok.is_continuation for tok in line.tokens) + """Return true if the line has continuation markers in it.""" + return any(tok.is_continuation for tok in line.tokens) def _CanPlaceOnSingleLine(line): - """Determine if the logical line can go on a single line. + """Determine if the logical line can go on a single line. Arguments: line: (logical_line.LogicalLine) The line currently being formatted. @@ -258,673 +251,395 @@ def _CanPlaceOnSingleLine(line): Returns: True if the line can or should be added to a single line. False otherwise. """ - token_names = [x.name for x in line.tokens] - 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_index = -1 - if (last.is_pylint_comment or last.is_pytype_comment or - last.is_copybara_comment): - 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])) + token_names = [x.name for x in line.tokens] + 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_index = -1 + if (last.is_pylint_comment or last.is_pytype_comment or last.is_copybara_comment): + 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])) def _AlignTrailingComments(final_lines): - """Align trailing comments to the same column.""" - final_lines_index = 0 - while final_lines_index < len(final_lines): - line = final_lines[final_lines_index] - assert line.tokens - - processed_content = False - - for tok in line.tokens: - if (tok.is_comment and isinstance(tok.spaces_required_before, list) and - tok.value.startswith('#')): - # All trailing comments and comments that appear on a line by themselves - # in this block should be indented at the same level. The block is - # terminated by an empty line or EOF. Enumerate through each line in - # the block and calculate the max line length. Once complete, use the - # 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 - - while True: - # EOF - if final_lines_index + len(all_pc_line_lengths) == len(final_lines): - break - - this_line = final_lines[final_lines_index + len(all_pc_line_lengths)] - - # Blank line - note that content is preformatted so we don't need to - # worry about spaces/tabs; a blank line will always be '\n\n'. - assert this_line.tokens - if (all_pc_line_lengths and - this_line.tokens[0].formatted_whitespace_prefix.startswith('\n\n') - ): - break - - if this_line.disable: - all_pc_line_lengths.append([]) - continue - - # Calculate the length of each line in this logical line. - line_content = '' - pc_line_lengths = [] - - for line_tok in this_line.tokens: - whitespace_prefix = line_tok.formatted_whitespace_prefix - - newline_index = whitespace_prefix.rfind('\n') - if newline_index != -1: - max_line_length = max(max_line_length, len(line_content)) - line_content = '' - - whitespace_prefix = whitespace_prefix[newline_index + 1:] - - if line_tok.is_comment: - pc_line_lengths.append(len(line_content)) - else: - line_content += '{}{}'.format(whitespace_prefix, line_tok.value) - - if pc_line_lengths: - max_line_length = max(max_line_length, max(pc_line_lengths)) - - all_pc_line_lengths.append(pc_line_lengths) - - # Calculate the aligned column value - max_line_length += 2 - - aligned_col = None - for potential_col in tok.spaces_required_before: - if potential_col > max_line_length: - aligned_col = potential_col - break - - if aligned_col is None: - aligned_col = max_line_length - - # Update the comment token values based on the aligned values - for all_pc_line_lengths_index, pc_line_lengths in enumerate( - all_pc_line_lengths): - if not pc_line_lengths: - continue + """Align trailing comments to the same column.""" + final_lines_index = 0 + while final_lines_index < len(final_lines): + line = final_lines[final_lines_index] + assert line.tokens + + processed_content = False + + for tok in line.tokens: + if (tok.is_comment and isinstance(tok.spaces_required_before, list) and + tok.value.startswith('#')): + # All trailing comments and comments that appear on a line by themselves + # in this block should be indented at the same level. The block is + # terminated by an empty line or EOF. Enumerate through each line in + # the block and calculate the max line length. Once complete, use the + # 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 + + while True: + # EOF + if final_lines_index + len(all_pc_line_lengths) == len(final_lines): + break + + this_line = final_lines[final_lines_index + + len(all_pc_line_lengths)] + + # Blank line - note that content is preformatted so we don't need to + # worry about spaces/tabs; a blank line will always be '\n\n'. + assert this_line.tokens + if (all_pc_line_lengths and + this_line.tokens[0].formatted_whitespace_prefix.startswith( + '\n\n')): + break + + if this_line.disable: + all_pc_line_lengths.append([]) + continue - this_line = final_lines[final_lines_index + all_pc_line_lengths_index] + # Calculate the length of each line in this logical line. + line_content = '' + pc_line_lengths = [] - pc_line_length_index = 0 - for line_tok in this_line.tokens: - if line_tok.is_comment: - assert pc_line_length_index < len(pc_line_lengths) - assert pc_line_lengths[pc_line_length_index] < aligned_col + for line_tok in this_line.tokens: + whitespace_prefix = line_tok.formatted_whitespace_prefix - # Note that there may be newlines embedded in the comments, so - # we need to apply a whitespace prefix to each line. - whitespace = ' ' * ( - aligned_col - pc_line_lengths[pc_line_length_index] - 1) - pc_line_length_index += 1 + 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:] - for comment_line_index, comment_line in enumerate( - line_tok.value.split('\n')): - line_content.append('{}{}'.format(whitespace, - comment_line.strip())) + if line_tok.is_comment: + pc_line_lengths.append(len(line_content)) + else: + line_content += '{}{}'.format( + whitespace_prefix, line_tok.value) - if comment_line_index == 0: - whitespace = ' ' * (aligned_col - 1) + if pc_line_lengths: + max_line_length = max(max_line_length, max(pc_line_lengths)) - line_content = '\n'.join(line_content) + all_pc_line_lengths.append(pc_line_lengths) - # Account for initial whitespace already slated for the - # beginning of the line. - existing_whitespace_prefix = \ - line_tok.formatted_whitespace_prefix.lstrip('\n') + # Calculate the aligned column value + max_line_length += 2 - if line_content.startswith(existing_whitespace_prefix): - line_content = line_content[len(existing_whitespace_prefix):] + aligned_col = None + for potential_col in tok.spaces_required_before: + if potential_col > max_line_length: + aligned_col = potential_col + break - line_tok.value = line_content + if aligned_col is None: + aligned_col = max_line_length - assert pc_line_length_index == len(pc_line_lengths) + # Update the comment token values based on the aligned values + for all_pc_line_lengths_index, pc_line_lengths in enumerate( + all_pc_line_lengths): + if not pc_line_lengths: + continue - final_lines_index += len(all_pc_line_lengths) + this_line = final_lines[final_lines_index + + all_pc_line_lengths_index] - processed_content = True - break + pc_line_length_index = 0 + for line_tok in this_line.tokens: + if line_tok.is_comment: + assert pc_line_length_index < len(pc_line_lengths) + assert pc_line_lengths[pc_line_length_index] < aligned_col - if not processed_content: - final_lines_index += 1 + # Note that there may be newlines embedded in the comments, so + # we need to apply a whitespace prefix to each line. + whitespace = ' ' * ( + aligned_col - pc_line_lengths[pc_line_length_index] - 1) + pc_line_length_index += 1 + line_content = [] -def _AlignAssignment(final_lines): - """Align assignment operators and augmented assignment operators to the same column""" + for comment_line_index, comment_line in enumerate( + line_tok.value.split('\n')): + line_content.append( + '{}{}'.format(whitespace, comment_line.strip())) - final_lines_index = 0 - while final_lines_index < len(final_lines): - line = final_lines[final_lines_index] + if comment_line_index == 0: + whitespace = ' ' * (aligned_col - 1) - assert line.tokens - process_content = False + line_content = '\n'.join(line_content) - 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 + # Account for initial whitespace already slated for the + # beginning of the line. + existing_whitespace_prefix = \ + line_tok.formatted_whitespace_prefix.lstrip('\n') - this_line_index = final_lines_index + len(all_pa_variables_lengths) - this_line = final_lines[this_line_index] + if line_content.startswith(existing_whitespace_prefix): + line_content = line_content[ + len(existing_whitespace_prefix):] - next_line = None - if this_line_index < len(final_lines) - 1: - next_line = final_lines[final_lines_index + len(all_pa_variables_lengths) + 1 ] + line_tok.value = line_content - assert this_line.tokens, next_line.tokens + assert pc_line_length_index == len(pc_line_lengths) - # 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 + final_lines_index += len(all_pc_line_lengths) - # 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'): + processed_content = True 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 + if not processed_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! + """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] + 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 - 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 + assert line.tokens + process_content = False - 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 - 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: + if tok.is_argassign: - 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 + this_line = line + line_tokens = this_line.tokens - line_tokens = this_line.tokens - for open_index in range(len(line_tokens)): - line_tok = line_tokens[open_index] + 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 =[] + 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] - 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 + 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 is 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 - 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 = [] - for line in final_lines: - formatted_line = [] - for tok in line.tokens: - if not tok.is_pseudo: - formatted_line.append(tok.formatted_whitespace_prefix) - formatted_line.append(tok.value) - elif (not tok.next_token.whitespace_prefix.startswith('\n') and - not tok.next_token.whitespace_prefix.startswith(' ')): - if (tok.previous_token.value == ':' or - tok.next_token.value not in ',}])'): - formatted_line.append(' ') - - formatted_code.append(''.join(formatted_line)) - if verify: - verifier.VerifyCode(formatted_code[-1]) - - return ''.join(formatted_code) + '\n' + """Compose the final output from the finalized lines.""" + formatted_code = [] + for line in final_lines: + formatted_line = [] + for tok in line.tokens: + if not tok.is_pseudo: + formatted_line.append(tok.formatted_whitespace_prefix) + formatted_line.append(tok.value) + elif (not tok.next_token.whitespace_prefix.startswith('\n') and + not tok.next_token.whitespace_prefix.startswith(' ')): + if (tok.previous_token.value == ':' or + tok.next_token.value not in ',}])'): + formatted_line.append(' ') + + formatted_code.append(''.join(formatted_line)) + if verify: + verifier.VerifyCode(formatted_code[-1]) + + return ''.join(formatted_code) + '\n' class _StateNode(object): - """An edge in the solution space from 'previous.state' to 'state'. + """An edge in the solution space from 'previous.state' to 'state'. Attributes: state: (format_decision_state.FormatDecisionState) The format decision state @@ -934,16 +649,16 @@ class _StateNode(object): previous: (_StateNode) The previous state node in the graph. """ - # TODO(morbo): Add a '__cmp__' method. + # TODO(morbo): Add a '__cmp__' method. - def __init__(self, state, newline, previous): - self.state = state.Clone() - self.newline = newline - self.previous = previous + def __init__(self, state, newline, previous): + self.state = state.Clone() + self.newline = newline + self.previous = previous - def __repr__(self): # pragma: no cover - return 'StateNode(state=[\n{0}\n], newline={1})'.format( - self.state, self.newline) + def __repr__(self): # pragma: no cover + return 'StateNode(state=[\n{0}\n], newline={1})'.format( + self.state, self.newline) # A tuple of (penalty, count) that is used to prioritize the BFS. In case of @@ -954,12 +669,11 @@ 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): - """Analyze the entire solution space starting from initial_state. + """Analyze the entire solution space starting from initial_state. This implements a variant of Dijkstra's algorithm on the graph that spans the solution space (LineStates are the nodes). The algorithm tries to find @@ -973,49 +687,49 @@ def _AnalyzeSolutionSpace(initial_state): Returns: True if a formatting solution was found. False otherwise. """ - count = 0 - seen = set() - p_queue = [] - - # Insert start element. - node = _StateNode(initial_state, False, None) - heapq.heappush(p_queue, _QueueItem(_OrderedPenalty(0, count), node)) - - count += 1 - while p_queue: - item = p_queue[0] - penalty = item.ordered_penalty.penalty - node = item.state_node - if not node.state.next_token: - break - heapq.heappop(p_queue) - - if count > 10000: - node.state.ignore_stack_for_comparison = True - - # Unconditionally add the state and check if it was present to avoid having - # to hash it twice in the common case (state hashing is expensive). - before_seen_count = len(seen) - seen.add(node.state) - # If seen didn't change size, the state was already present. - if before_seen_count == len(seen): - continue - - # FIXME(morbo): Add a 'decision' element? - - count = _AddNextStateToQueue(penalty, node, False, count, p_queue) - count = _AddNextStateToQueue(penalty, node, True, count, p_queue) - - if not p_queue: - # We weren't able to find a solution. Do nothing. - return False + count = 0 + seen = set() + p_queue = [] + + # Insert start element. + node = _StateNode(initial_state, False, None) + heapq.heappush(p_queue, _QueueItem(_OrderedPenalty(0, count), node)) + + count += 1 + while p_queue: + item = p_queue[0] + penalty = item.ordered_penalty.penalty + node = item.state_node + if not node.state.next_token: + break + heapq.heappop(p_queue) + + if count > 10000: + node.state.ignore_stack_for_comparison = True + + # Unconditionally add the state and check if it was present to avoid having + # to hash it twice in the common case (state hashing is expensive). + before_seen_count = len(seen) + seen.add(node.state) + # If seen didn't change size, the state was already present. + if before_seen_count == len(seen): + continue + + # FIXME(morbo): Add a 'decision' element? + + count = _AddNextStateToQueue(penalty, node, False, count, p_queue) + count = _AddNextStateToQueue(penalty, node, True, count, p_queue) - _ReconstructPath(initial_state, heapq.heappop(p_queue).state_node) - return True + if not p_queue: + # We weren't able to find a solution. Do nothing. + return False + + _ReconstructPath(initial_state, heapq.heappop(p_queue).state_node) + return True def _AddNextStateToQueue(penalty, previous_node, newline, count, p_queue): - """Add the following state to the analysis queue. + """Add the following state to the analysis queue. Assume the current state is 'previous_node' and has been reached with a penalty of 'penalty'. Insert a line break if 'newline' is True. @@ -1031,23 +745,23 @@ def _AddNextStateToQueue(penalty, previous_node, newline, count, p_queue): Returns: The updated number of elements in the queue. """ - must_split = previous_node.state.MustSplit() - if newline and not previous_node.state.CanSplit(must_split): - # Don't add a newline if the token cannot be split. - return count - if not newline and must_split: - # Don't add a token we must split but where we aren't splitting. - return count + must_split = previous_node.state.MustSplit() + if newline and not previous_node.state.CanSplit(must_split): + # Don't add a newline if the token cannot be split. + return count + if not newline and must_split: + # Don't add a token we must split but where we aren't splitting. + return count - 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)) - return count + 1 + 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)) + return count + 1 def _ReconstructPath(initial_state, current): - """Reconstruct the path through the queue with lowest penalty. + """Reconstruct the path through the queue with lowest penalty. Arguments: initial_state: (format_decision_state.FormatDecisionState) The initial state @@ -1055,21 +769,21 @@ def _ReconstructPath(initial_state, current): current: (_StateNode) The node in the decision graph that is the end point of the path with the least penalty. """ - path = collections.deque() + path = collections.deque() - while current.previous: - path.appendleft(current) - current = current.previous + while current.previous: + path.appendleft(current) + current = current.previous - for node in path: - initial_state.AddTokenToState(newline=node.newline, dry_run=False) + for node in path: + initial_state.AddTokenToState(newline=node.newline, dry_run=False) NESTED_DEPTH = [] def _FormatFirstToken(first_token, indent_depth, prev_line, final_lines): - """Format the first token in the logical line. + """Format the first token in the logical line. Add a newline and the required indent before the first token of the logical line. @@ -1082,22 +796,22 @@ def _FormatFirstToken(first_token, indent_depth, prev_line, final_lines): final_lines: (list of logical_line.LogicalLine) The logical lines that have already been processed. """ - global NESTED_DEPTH - while NESTED_DEPTH and NESTED_DEPTH[-1] > indent_depth: - NESTED_DEPTH.pop() + global NESTED_DEPTH + while NESTED_DEPTH and NESTED_DEPTH[-1] > indent_depth: + NESTED_DEPTH.pop() - first_nested = False - if _IsClassOrDef(first_token): - if not NESTED_DEPTH: - NESTED_DEPTH = [indent_depth] - elif NESTED_DEPTH[-1] < indent_depth: - first_nested = True - NESTED_DEPTH.append(indent_depth) + first_nested = False + if _IsClassOrDef(first_token): + if not NESTED_DEPTH: + NESTED_DEPTH = [indent_depth] + elif NESTED_DEPTH[-1] < indent_depth: + first_nested = True + NESTED_DEPTH.append(indent_depth) - first_token.AddWhitespacePrefix( - _CalculateNumberOfNewlines(first_token, indent_depth, prev_line, - final_lines, first_nested), - indent_level=indent_depth) + first_token.AddWhitespacePrefix( + _CalculateNumberOfNewlines( + first_token, indent_depth, prev_line, final_lines, first_nested), + indent_level=indent_depth) NO_BLANK_LINES = 1 @@ -1106,15 +820,14 @@ def _FormatFirstToken(first_token, indent_depth, prev_line, final_lines): 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') + if tok.value in {'class', 'def', '@'}: + return True + 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): - """Calculate the number of newlines we need to add. +def _CalculateNumberOfNewlines( + first_token, indent_depth, prev_line, final_lines, first_nested): + """Calculate the number of newlines we need to add. Arguments: first_token: (format_token.FormatToken) The first token in the logical @@ -1129,102 +842,99 @@ def _CalculateNumberOfNewlines(first_token, indent_depth, prev_line, Returns: The number of newlines needed before the first token. """ - # TODO(morbo): Special handling for imports. - # TODO(morbo): Create a knob that can tune these. - if prev_line is None: - # The first line in the file. Don't add blank lines. - # FIXME(morbo): Is this correct? - if first_token.newlines is not None: - first_token.newlines = None - return 0 - - if first_token.is_docstring: - if (prev_line.first.value == 'class' and - style.Get('BLANK_LINE_BEFORE_CLASS_DOCSTRING')): - # Enforce a blank line before a class's docstring. - return ONE_BLANK_LINE - elif (prev_line.first.value.startswith('#') and - style.Get('BLANK_LINE_BEFORE_MODULE_DOCSTRING')): - # Enforce a blank line before a module's docstring. - return ONE_BLANK_LINE - # The docstring shouldn't have a newline before it. - return NO_BLANK_LINES - - if first_token.is_name and not indent_depth: - if prev_line.first.value in {'from', 'import'}: - # Support custom number of blank lines between top-level imports and - # variable definitions. - return 1 + style.Get( - 'BLANK_LINES_BETWEEN_TOP_LEVEL_IMPORTS_AND_VARIABLES') - - prev_last_token = prev_line.last - if prev_last_token.is_docstring: - if (not indent_depth and first_token.value in {'class', 'def', 'async'}): - # Separate a class or function from the module-level docstring with - # appropriate number of blank lines. - return 1 + style.Get('BLANK_LINES_AROUND_TOP_LEVEL_DEFINITION') - if (first_nested and - not style.Get('BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF') and - _IsClassOrDef(first_token)): - first_token.newlines = None - return NO_BLANK_LINES - if _NoBlankLinesBeforeCurrentToken(prev_last_token.value, first_token, - prev_last_token): - return NO_BLANK_LINES - else: - return ONE_BLANK_LINE - - if _IsClassOrDef(first_token): - # TODO(morbo): This can go once the blank line calculator is more - # sophisticated. - if not indent_depth: - # This is a top-level class or function. - is_inline_comment = prev_last_token.whitespace_prefix.count('\n') == 0 - if (not prev_line.disable and prev_last_token.is_comment and - not is_inline_comment): - # This token follows a non-inline comment. - if _NoBlankLinesBeforeCurrentToken(prev_last_token.value, first_token, - prev_last_token): - # Assume that the comment is "attached" to the current line. - # Therefore, we want two blank lines before the comment. - index = len(final_lines) - 1 - while index > 0: - if not final_lines[index - 1].is_comment: - break - index -= 1 - if final_lines[index - 1].first.value == '@': - final_lines[index].first.AdjustNewlinesBefore(NO_BLANK_LINES) - else: - prev_last_token.AdjustNewlinesBefore( - 1 + style.Get('BLANK_LINES_AROUND_TOP_LEVEL_DEFINITION')) - if first_token.newlines is not None: + # TODO(morbo): Special handling for imports. + # TODO(morbo): Create a knob that can tune these. + if prev_line is None: + # The first line in the file. Don't add blank lines. + # FIXME(morbo): Is this correct? + if first_token.newlines is not None: first_token.newlines = None - return NO_BLANK_LINES - elif _IsClassOrDef(prev_line.first): - if first_nested and not style.Get( - 'BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF'): - first_token.newlines = None + return 0 + + if first_token.is_docstring: + if (prev_line.first.value == 'class' and + style.Get('BLANK_LINE_BEFORE_CLASS_DOCSTRING')): + # Enforce a blank line before a class's docstring. + return ONE_BLANK_LINE + elif (prev_line.first.value.startswith('#') and + style.Get('BLANK_LINE_BEFORE_MODULE_DOCSTRING')): + # Enforce a blank line before a module's docstring. + return ONE_BLANK_LINE + # The docstring shouldn't have a newline before it. return NO_BLANK_LINES - # Calculate how many newlines were between the original lines. We want to - # retain that formatting if it doesn't violate one of the style guide rules. - if first_token.is_comment: - first_token_lineno = first_token.lineno - first_token.value.count('\n') - else: - first_token_lineno = first_token.lineno + if first_token.is_name and not indent_depth: + if prev_line.first.value in {'from', 'import'}: + # Support custom number of blank lines between top-level imports and + # variable definitions. + return 1 + style.Get('BLANK_LINES_BETWEEN_TOP_LEVEL_IMPORTS_AND_VARIABLES') + + prev_last_token = prev_line.last + if prev_last_token.is_docstring: + if (not indent_depth and first_token.value in {'class', 'def', 'async'}): + # Separate a class or function from the module-level docstring with + # appropriate number of blank lines. + return 1 + style.Get('BLANK_LINES_AROUND_TOP_LEVEL_DEFINITION') + if (first_nested and not style.Get('BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF') and + _IsClassOrDef(first_token)): + first_token.newlines = None + return NO_BLANK_LINES + if _NoBlankLinesBeforeCurrentToken(prev_last_token.value, first_token, + prev_last_token): + return NO_BLANK_LINES + else: + return ONE_BLANK_LINE + + if _IsClassOrDef(first_token): + # TODO(morbo): This can go once the blank line calculator is more + # sophisticated. + if not indent_depth: + # This is a top-level class or function. + is_inline_comment = prev_last_token.whitespace_prefix.count('\n') == 0 + if (not prev_line.disable and prev_last_token.is_comment and + not is_inline_comment): + # This token follows a non-inline comment. + if _NoBlankLinesBeforeCurrentToken(prev_last_token.value, first_token, + prev_last_token): + # Assume that the comment is "attached" to the current line. + # Therefore, we want two blank lines before the comment. + index = len(final_lines) - 1 + while index > 0: + if not final_lines[index - 1].is_comment: + break + index -= 1 + if final_lines[index - 1].first.value == '@': + final_lines[index].first.AdjustNewlinesBefore(NO_BLANK_LINES) + else: + prev_last_token.AdjustNewlinesBefore( + 1 + style.Get('BLANK_LINES_AROUND_TOP_LEVEL_DEFINITION')) + if first_token.newlines is not None: + first_token.newlines = None + return NO_BLANK_LINES + elif _IsClassOrDef(prev_line.first): + if first_nested and not style.Get('BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF'): + first_token.newlines = None + return NO_BLANK_LINES + + # Calculate how many newlines were between the original lines. We want to + # retain that formatting if it doesn't violate one of the style guide rules. + if first_token.is_comment: + first_token_lineno = first_token.lineno - first_token.value.count('\n') + else: + first_token_lineno = first_token.lineno - prev_last_token_lineno = prev_last_token.lineno - if prev_last_token.is_multiline_string: - prev_last_token_lineno += prev_last_token.value.count('\n') + prev_last_token_lineno = prev_last_token.lineno + if prev_last_token.is_multiline_string: + prev_last_token_lineno += prev_last_token.value.count('\n') - if first_token_lineno - prev_last_token_lineno > 1: - return ONE_BLANK_LINE + if first_token_lineno - prev_last_token_lineno > 1: + return ONE_BLANK_LINE - return NO_BLANK_LINES + return NO_BLANK_LINES def _SingleOrMergedLines(lines): - """Generate the lines we want to format. + """Generate the lines we want to format. Arguments: lines: (list of logical_line.LogicalLine) Lines we want to format. @@ -1233,46 +943,46 @@ 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 - last_was_merged = False - while index < len(lines): - if lines[index].disable: - line = lines[index] - index += 1 - while index < len(lines): - column = line.last.column + 2 - if lines[index].lineno != line.lineno: - break - if line.last.value != ':': - leaf = pytree.Leaf( - type=token.SEMI, value=';', context=('', (line.lineno, column))) - line.AppendToken( - format_token.FormatToken(leaf, pytree_utils.NodeName(leaf))) - for tok in lines[index].tokens: - line.AppendToken(tok) - index += 1 - yield line - elif line_joiner.CanMergeMultipleLines(lines[index:], last_was_merged): - # TODO(morbo): This splice is potentially very slow. Come up with a more - # performance-friendly way of determining if two lines can be merged. - next_line = lines[index + 1] - for tok in next_line.tokens: - lines[index].AppendToken(tok) - if (len(next_line.tokens) == 1 and next_line.first.is_multiline_string): - # This may be a multiline shebang. In that case, we want to retain the - # formatting. Otherwise, it could mess up the shell script's syntax. - lines[index].disable = True - yield lines[index] - index += 2 - last_was_merged = True - else: - yield lines[index] - index += 1 - last_was_merged = False + index = 0 + last_was_merged = False + while index < len(lines): + if lines[index].disable: + line = lines[index] + index += 1 + while index < len(lines): + column = line.last.column + 2 + if lines[index].lineno != line.lineno: + break + if line.last.value != ':': + leaf = pytree.Leaf( + type=token.SEMI, value=';', context=('', (line.lineno, column))) + line.AppendToken( + format_token.FormatToken(leaf, pytree_utils.NodeName(leaf))) + for tok in lines[index].tokens: + line.AppendToken(tok) + index += 1 + yield line + elif line_joiner.CanMergeMultipleLines(lines[index:], last_was_merged): + # TODO(morbo): This splice is potentially very slow. Come up with a more + # performance-friendly way of determining if two lines can be merged. + next_line = lines[index + 1] + for tok in next_line.tokens: + lines[index].AppendToken(tok) + if (len(next_line.tokens) == 1 and next_line.first.is_multiline_string): + # This may be a multiline shebang. In that case, we want to retain the + # formatting. Otherwise, it could mess up the shell script's syntax. + lines[index].disable = True + yield lines[index] + index += 2 + last_was_merged = True + else: + yield lines[index] + index += 1 + last_was_merged = False def _NoBlankLinesBeforeCurrentToken(text, cur_token, prev_token): - """Determine if there are no blank lines before the current token. + """Determine if there are no blank lines before the current token. The previous token is a docstring or comment. The prev_token_lineno is the start of the text of that token. Counting the number of newlines in its text @@ -1290,8 +1000,8 @@ def _NoBlankLinesBeforeCurrentToken(text, cur_token, prev_token): Returns: True if there is no blank line before the current token. """ - cur_token_lineno = cur_token.lineno - if cur_token.is_comment: - cur_token_lineno -= cur_token.value.count('\n') - num_newlines = text.count('\n') if not prev_token.is_comment else 0 - return prev_token.lineno + num_newlines == cur_token_lineno - 1 + cur_token_lineno = cur_token.lineno + if cur_token.is_comment: + cur_token_lineno -= cur_token.value.count('\n') + num_newlines = text.count('\n') if not prev_token.is_comment else 0 + return prev_token.lineno + num_newlines == cur_token_lineno - 1 diff --git a/yapf/yapflib/style.py b/yapf/yapflib/style.py index d9e9e5e9e..e1939e289 100644 --- a/yapf/yapflib/style.py +++ b/yapf/yapflib/style.py @@ -22,57 +22,55 @@ class StyleConfigError(errors.YapfError): - """Raised when there's a problem reading the style configuration.""" - pass + """Raised when there's a problem reading the style configuration.""" + pass def Get(setting_name): - """Get a style setting.""" - return _style[setting_name] + """Get a style setting.""" + return _style[setting_name] def GetOrDefault(setting_name, default_value): - """Get a style setting or default value if the setting does not exist.""" - return _style.get(setting_name, default_value) + """Get a style setting or default value if the setting does not exist.""" + return _style.get(setting_name, default_value) def Help(): - """Return dict mapping style names to help strings.""" - return _STYLE_HELP + """Return dict mapping style names to help strings.""" + return _STYLE_HELP def SetGlobalStyle(style): - """Set a style dict.""" - global _style - global _GLOBAL_STYLE_FACTORY - factory = _GetStyleFactory(style) - if factory: - _GLOBAL_STYLE_FACTORY = factory - _style = style + """Set a style dict.""" + global _style + global _GLOBAL_STYLE_FACTORY + factory = _GetStyleFactory(style) + if factory: + _GLOBAL_STYLE_FACTORY = factory + _style = 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 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("""\ - 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("""\ + Newline comments or objects with newline entries will also start new block alignment.""" + ), + 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 +78,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 +106,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 +115,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 +147,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 +160,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 +182,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 +226,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 +238,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 +256,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 +285,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 +296,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 +313,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 @@ -326,25 +355,32 @@ def method(): a_very_long_statement_that_extends_beyond_the_final_column # Comment <-- the end of line comments are aligned based on the line length short # This is a shorter statement - """), # noqa - SPLIT_ARGUMENTS_WHEN_COMMA_TERMINATED=textwrap.dedent("""\ + """), # noqa + 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 +388,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)) @@ -361,20 +398,25 @@ def method(): foo = ('This is a really long string: {}, {}, {}, {}' .format(a, b, c, d)) - """), # noqa - SPLIT_BEFORE_EXPRESSION_AFTER_OPENING_PAREN=textwrap.dedent("""\ + """), # noqa + 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 +432,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, @@ -421,141 +472,140 @@ 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("""\ + """), # noqa + 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', + # BASED_ON_STYLE='Which predefined style this style is based on', ) 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, - ) + """Create the PEP8 formatting style.""" + return dict( + ALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENT =True, + ALIGN_ARGUMENT_ASSIGNMENT =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['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 - return style + """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['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 + return style def CreateYapfStyle(): - """Create the YAPF formatting style.""" - 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['SPLIT_BEFORE_EXPRESSION_AFTER_OPENING_PAREN'] = True - return style + """Create the YAPF formatting style.""" + 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['SPLIT_BEFORE_EXPRESSION_AFTER_OPENING_PAREN'] = True + return style def CreateFacebookStyle(): - """Create the Facebook formatting style.""" - 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 - return style + """Create the Facebook formatting style.""" + 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 + 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 = [ @@ -567,55 +617,55 @@ def CreateFacebookStyle(): def _GetStyleFactory(style): - for def_style, factory in _DEFAULT_STYLE_TO_FACTORY: - if style == def_style: - return factory - return None + for def_style, factory in _DEFAULT_STYLE_TO_FACTORY: + if style == def_style: + return factory + return None def _ContinuationAlignStyleStringConverter(s): - """Option value converter for a continuation align style string.""" - accepted_styles = ('SPACE', 'FIXED', 'VALIGN-RIGHT') - if s: - r = s.strip('"\'').replace('_', '-').upper() - if r not in accepted_styles: - raise ValueError('unknown continuation align style: %r' % (s,)) - else: - r = accepted_styles[0] - return r + """Option value converter for a continuation align style string.""" + accepted_styles = ('SPACE', 'FIXED', 'VALIGN-RIGHT') + if s: + r = s.strip('"\'').replace('_', '-').upper() + if r not in accepted_styles: + raise ValueError('unknown continuation align style: %r' % (s,)) + else: + r = accepted_styles[0] + return r def _StringListConverter(s): - """Option value converter for a comma-separated list of strings.""" - return [part.strip() for part in s.split(',')] + """Option value converter for a comma-separated list of strings.""" + return [part.strip() for part in s.split(',')] def _StringSetConverter(s): - """Option value converter for a comma-separated set of strings.""" - if len(s) > 2 and s[0] in '"\'': - s = s[1:-1] - return {part.strip() for part in s.split(',')} + """Option value converter for a comma-separated set of strings.""" + if len(s) > 2 and s[0] in '"\'': + s = s[1:-1] + return {part.strip() for part in s.split(',')} def _BoolConverter(s): - """Option value converter for a boolean.""" - return py3compat.CONFIGPARSER_BOOLEAN_STATES[s.lower()] + """Option value converter for a boolean.""" + return py3compat.CONFIGPARSER_BOOLEAN_STATES[s.lower()] def _IntListConverter(s): - """Option value converter for a comma-separated list of integers.""" - s = s.strip() - if s.startswith('[') and s.endswith(']'): - s = s[1:-1] + """Option value converter for a comma-separated list of integers.""" + s = s.strip() + if s.startswith('[') and s.endswith(']'): + s = s[1:-1] - return [int(part.strip()) for part in s.split(',') if part.strip()] + return [int(part.strip()) for part in s.split(',') if part.strip()] def _IntOrIntListConverter(s): - """Option value converter for an integer or list of integers.""" - if len(s) > 2 and s[0] in '"\'': - s = s[1:-1] - return _IntListConverter(s) if ',' in s else int(s) + """Option value converter for an integer or list of integers.""" + if len(s) > 2 and s[0] in '"\'': + s = s[1:-1] + return _IntListConverter(s) if ',' in s else int(s) # Different style options need to have their values interpreted differently when @@ -626,75 +676,73 @@ 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, + 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, ) def CreateStyleFromConfig(style_config): - """Create a style dict from the given config. + """Create a style dict from the given config. Arguments: style_config: either a style name or a file name. The file is expected to @@ -710,107 +758,106 @@ def CreateStyleFromConfig(style_config): StyleConfigError: if an unknown style option was encountered. """ - def GlobalStyles(): - for style, _ in _DEFAULT_STYLE_TO_FACTORY: - yield style - - def_style = False - if style_config is None: - for style in GlobalStyles(): - if _style == style: - def_style = True - break - if not def_style: - return _style - return _GLOBAL_STYLE_FACTORY() - - if isinstance(style_config, dict): - config = _CreateConfigParserFromConfigDict(style_config) - elif isinstance(style_config, py3compat.basestring): - style_factory = _STYLE_NAME_TO_FACTORY.get(style_config.lower()) - if style_factory is not None: - return style_factory() - if style_config.startswith('{'): - # Most likely a style specification from the command line. - config = _CreateConfigParserFromConfigString(style_config) - else: - # Unknown config name: assume it's a file name then. - config = _CreateConfigParserFromConfigFile(style_config) - return _CreateStyleFromConfigParser(config) + def GlobalStyles(): + for style, _ in _DEFAULT_STYLE_TO_FACTORY: + yield style + + def_style = False + if style_config is None: + for style in GlobalStyles(): + if _style == style: + def_style = True + break + if not def_style: + return _style + return _GLOBAL_STYLE_FACTORY() + + if isinstance(style_config, dict): + config = _CreateConfigParserFromConfigDict(style_config) + elif isinstance(style_config, py3compat.basestring): + style_factory = _STYLE_NAME_TO_FACTORY.get(style_config.lower()) + if style_factory is not None: + return style_factory() + if style_config.startswith('{'): + # Most likely a style specification from the command line. + config = _CreateConfigParserFromConfigString(style_config) + else: + # Unknown config name: assume it's a file name then. + config = _CreateConfigParserFromConfigFile(style_config) + return _CreateStyleFromConfigParser(config) def _CreateConfigParserFromConfigDict(config_dict): - config = py3compat.ConfigParser() - config.add_section('style') - for key, value in config_dict.items(): - config.set('style', key, str(value)) - return config + config = py3compat.ConfigParser() + config.add_section('style') + for key, value in config_dict.items(): + config.set('style', key, str(value)) + return config def _CreateConfigParserFromConfigString(config_string): - """Given a config string from the command line, return a config parser.""" - if config_string[0] != '{' or config_string[-1] != '}': - raise StyleConfigError( - "Invalid style dict syntax: '{}'.".format(config_string)) - config = py3compat.ConfigParser() - config.add_section('style') - for key, value, _ in re.findall( - r'([a-zA-Z0-9_]+)\s*[:=]\s*' - r'(?:' - r'((?P[\'"]).*?(?P=quote)|' - r'[a-zA-Z0-9_]+)' - r')', config_string): # yapf: disable - config.set('style', key, value) - return config + """Given a config string from the command line, return a config parser.""" + if config_string[0] != '{' or config_string[-1] != '}': + raise StyleConfigError("Invalid style dict syntax: '{}'.".format(config_string)) + config = py3compat.ConfigParser() + config.add_section('style') + for key, value, _ in re.findall( + r'([a-zA-Z0-9_]+)\s*[:=]\s*' + r'(?:' + r'((?P[\'"]).*?(?P=quote)|' + r'[a-zA-Z0-9_]+)' + r')', config_string): # yapf: disable + config.set('style', key, value) + return config def _CreateConfigParserFromConfigFile(config_filename): - """Read the file and return a ConfigParser object.""" - if not os.path.exists(config_filename): - # Provide a more meaningful error here. - raise StyleConfigError( - '"{0}" is not a valid style or file path'.format(config_filename)) - with open(config_filename) as style_file: - config = py3compat.ConfigParser() - if config_filename.endswith(PYPROJECT_TOML): - try: - import toml - except ImportError: - raise errors.YapfError( - "toml package is needed for using pyproject.toml as a " - "configuration file") - - pyproject_toml = toml.load(style_file) - 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)) - config.add_section('style') - for k, v in style_dict.items(): - config.set('style', k, str(v)) - return config - - config.read_file(style_file) - if config_filename.endswith(SETUP_CONFIG): - if not config.has_section('yapf'): + """Read the file and return a ConfigParser object.""" + if not os.path.exists(config_filename): + # Provide a more meaningful error here. raise StyleConfigError( - 'Unable to find section [yapf] in {0}'.format(config_filename)) - return config - - if config_filename.endswith(LOCAL_STYLE): - if not config.has_section('style'): - raise StyleConfigError( - 'Unable to find section [style] in {0}'.format(config_filename)) - return config - - if not config.has_section('style'): - raise StyleConfigError( - 'Unable to find section [style] in {0}'.format(config_filename)) - return config + '"{0}" is not a valid style or file path'.format(config_filename)) + with open(config_filename) as style_file: + config = py3compat.ConfigParser() + if config_filename.endswith(PYPROJECT_TOML): + try: + import toml + except ImportError: + raise errors.YapfError( + "toml package is needed for using pyproject.toml as a " + "configuration file") + + pyproject_toml = toml.load(style_file) + 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)) + config.add_section('style') + for k, v in style_dict.items(): + config.set('style', k, str(v)) + return config + + config.read_file(style_file) + if config_filename.endswith(SETUP_CONFIG): + if not config.has_section('yapf'): + raise StyleConfigError( + 'Unable to find section [yapf] in {0}'.format(config_filename)) + return config + + if config_filename.endswith(LOCAL_STYLE): + if not config.has_section('style'): + raise StyleConfigError( + 'Unable to find section [style] in {0}'.format(config_filename)) + return config + + if not config.has_section('style'): + raise StyleConfigError( + 'Unable to find section [style] in {0}'.format(config_filename)) + return config def _CreateStyleFromConfigParser(config): - """Create a style dict from a configuration file. + """Create a style dict from a configuration file. Arguments: config: a ConfigParser object. @@ -821,32 +868,32 @@ def _CreateStyleFromConfigParser(config): Raises: StyleConfigError: if an unknown style option was encountered. """ - # 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() - 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() - base_style = _STYLE_NAME_TO_FACTORY[based_on]() - else: - base_style = _GLOBAL_STYLE_FACTORY() - - # Read all options specified in the file and update the style. - for option, value in config.items(section): - if option.lower() == 'based_on_style': - # Now skip this one - we've already handled it and it's not one of the - # recognized style options. - continue - option = option.upper() - if option not in _STYLE_OPTION_VALUE_CONVERTER: - raise StyleConfigError('Unknown style option "{0}"'.format(option)) - try: - base_style[option] = _STYLE_OPTION_VALUE_CONVERTER[option](value) - except ValueError: - raise StyleConfigError("'{}' is not a valid setting for {}.".format( - value, option)) - return base_style + # 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() + 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() + base_style = _STYLE_NAME_TO_FACTORY[based_on]() + else: + base_style = _GLOBAL_STYLE_FACTORY() + + # Read all options specified in the file and update the style. + for option, value in config.items(section): + if option.lower() == 'based_on_style': + # Now skip this one - we've already handled it and it's not one of the + # recognized style options. + continue + option = option.upper() + if option not in _STYLE_OPTION_VALUE_CONVERTER: + raise StyleConfigError('Unknown style option "{0}"'.format(option)) + try: + base_style[option] = _STYLE_OPTION_VALUE_CONVERTER[option](value) + except ValueError: + 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 diff --git a/yapftests/reformatter_basic_test.py b/yapftests/reformatter_basic_test.py index 0eeeefdce..3e242dd6e 100644 --- a/yapftests/reformatter_basic_test.py +++ b/yapftests/reformatter_basic_test.py @@ -25,55 +25,63 @@ class BasicReformatterTest(yapf_test_helper.YAPFTest): - @classmethod - def setUpClass(cls): - style.SetGlobalStyle(style.CreateYapfStyle()) - - def testSplittingAllArgs(self): - style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{split_all_comma_separated_values: true, column_limit: 40}')) - unformatted_code = textwrap.dedent("""\ + @classmethod + def setUpClass(cls): + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testSplittingAllArgs(self): + style.SetGlobalStyle( + style.CreateStyleFromConfig( + '{split_all_comma_separated_values: true, column_limit: 40}')) + unformatted_code = textwrap.dedent( + """\ responseDict = {"timestamp": timestamp, "someValue": value, "whatever": 120} - """) # noqa - expected_formatted_code = textwrap.dedent("""\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ responseDict = { "timestamp": timestamp, "someValue": value, "whatever": 120 } """) - 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)) - 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', } """) - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent("""\ + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + 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("""\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ def foo(long_arg, really_long_arg, really_really_long_arg, cant_keep_all_these_args): pass """) - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent("""\ + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + 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("""\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ foo_tuple = [ long_arg, really_long_arg, @@ -81,68 +89,78 @@ def foo(long_arg, cant_keep_all_these_args ] """) - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent("""\ + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + 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("""\ + 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( + """\ 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) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - - def testSplittingTopLevelAllArgs(self): - style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{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("""\ + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + + def testSplittingTopLevelAllArgs(self): + style.SetGlobalStyle( + style.CreateStyleFromConfig( + '{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( + """\ responseDict = {"timestamp": timestamp, "someValue": value, "whatever": 120} - """) # noqa - expected_formatted_code = textwrap.dedent("""\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ responseDict = { "timestamp": timestamp, "someValue": value, "whatever": 120 } """) - 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("""\ + 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( + """\ def foo(long_arg, really_long_arg, really_really_long_arg, cant_keep_all_these_args): pass - """) # noqa - expected_formatted_code = textwrap.dedent("""\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ def foo(long_arg, really_long_arg, really_really_long_arg, cant_keep_all_these_args): pass """) - 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("""\ + 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( + """\ foo_tuple = [long_arg, really_long_arg, really_really_long_arg, cant_keep_all_these_args] - """) # noqa - expected_formatted_code = textwrap.dedent("""\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ foo_tuple = [ long_arg, really_long_arg, @@ -150,60 +168,69 @@ def foo(long_arg, cant_keep_all_these_args ] """) - 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("""\ + 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( + """\ 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("""\ + 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( + """\ 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) - actual_formatted_code = reformatter.Reformat(llines) - self.assertEqual(40, len(actual_formatted_code.splitlines()[-1])) - self.assertCodeEqual(expected_formatted_code, actual_formatted_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, this_will_not_fit_xxxxxxxxx)) """) - 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)) - # Exercise the case where there's no opening bracket (for a, b) - unformatted_code = textwrap.dedent("""\ + # Exercise the case where there's no opening bracket (for a, b) + 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) """) - 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)) - # Don't require splitting before comments. - unformatted_code = textwrap.dedent("""\ + # Don't require splitting before comments. + 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 @@ -221,11 +249,12 @@ def foo(long_arg, 'JKL': Jkl, } """) - 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)) - def testSimpleFunctionsWithTrailingComments(self): - unformatted_code = textwrap.dedent("""\ + def testSimpleFunctionsWithTrailingComments(self): + 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'): @@ -250,127 +280,143 @@ def f( # Intermediate comment xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass """) - 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)) - def testBlankLinesBetweenTopLevelImportsAndVariables(self): - unformatted_code = textwrap.dedent("""\ + def testBlankLinesBetweenTopLevelImportsAndVariables(self): + 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' """) - 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)) - 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' """) - try: - style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{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)) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) - - unformatted_code = textwrap.dedent("""\ + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig( + '{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)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + 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)) + 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 class Baz(): pass """) - 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)) - 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 def foobar(): pass """) - 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)) - 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() """) - 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)) - def testBlankLinesAtEndOfFile(self): - unformatted_code = textwrap.dedent("""\ + def testBlankLinesAtEndOfFile(self): + 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)) + 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)) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - def testIndentBlankLines(self): - unformatted_code = textwrap.dedent("""\ + def testIndentBlankLines(self): + unformatted_code = textwrap.dedent( + """\ class foo(object): def foobar(self): @@ -388,28 +434,28 @@ def bar(): return 0 """) - expected_formatted_code = """\ + expected_formatted_code = """\ class foo(object):\n \n def foobar(self):\n \n pass\n \n def barfoo(self, x, y): # bar\n \n if x:\n \n return y\n\n\ndef bar():\n \n return 0 """ # noqa - try: - style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{based_on_style: yapf, indent_blank_lines: true}')) - - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) - - 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("""\ + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig( + '{based_on_style: yapf, indent_blank_lines: true}')) + + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + 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( + """\ x = { 'a':37,'b':42, 'c':927} @@ -425,7 +471,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' @@ -445,11 +492,12 @@ def g(self, x, y=42): def f(a): return 37 + -+a[42 - x:y**3] """) - 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)) - def testComments(self): - unformatted_code = textwrap.dedent("""\ + def testComments(self): + unformatted_code = textwrap.dedent( + """\ class Foo(object): pass @@ -471,7 +519,8 @@ class Baz(object): class Qux(object): pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ class Foo(object): pass @@ -498,28 +547,31 @@ class Baz(object): class Qux(object): pass """) - 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)) - def testSingleComment(self): - code = textwrap.dedent("""\ + def testSingleComment(self): + code = textwrap.dedent("""\ # Thing 1 """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testCommentsWithTrailingSpaces(self): - unformatted_code = textwrap.dedent("""\ + def testCommentsWithTrailingSpaces(self): + unformatted_code = textwrap.dedent( + """\ # Thing 1 \n# Thing 2 \n""") - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ # Thing 1 # Thing 2 """) - 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)) - def testCommentsInDataLiteral(self): - code = textwrap.dedent("""\ + def testCommentsInDataLiteral(self): + code = textwrap.dedent( + """\ def f(): return collections.OrderedDict({ # First comment. @@ -532,20 +584,22 @@ def f(): # Ending comment. }) """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testEndingWhitespaceAfterSimpleStatement(self): - code = textwrap.dedent("""\ + def testEndingWhitespaceAfterSimpleStatement(self): + code = textwrap.dedent( + """\ import foo as bar # Thing 1 # Thing 2 """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testDocstrings(self): - unformatted_code = textwrap.dedent('''\ + def testDocstrings(self): + unformatted_code = textwrap.dedent( + '''\ u"""Module-level docstring.""" import os class Foo(object): @@ -562,7 +616,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 @@ -579,11 +634,12 @@ def qux(self): print('hello {}'.format('world')) return 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)) - def testDocstringAndMultilineComment(self): - unformatted_code = textwrap.dedent('''\ + def testDocstringAndMultilineComment(self): + unformatted_code = textwrap.dedent( + '''\ """Hello world""" # A multiline # comment @@ -597,7 +653,8 @@ def foo(self): # comment pass ''') - expected_formatted_code = textwrap.dedent('''\ + expected_formatted_code = textwrap.dedent( + '''\ """Hello world""" @@ -614,11 +671,12 @@ def foo(self): # comment pass ''') - 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)) - def testMultilineDocstringAndMultilineComment(self): - unformatted_code = textwrap.dedent('''\ + def testMultilineDocstringAndMultilineComment(self): + unformatted_code = textwrap.dedent( + '''\ """Hello world RIP Dennis Richie. @@ -641,7 +699,8 @@ def foo(self): # comment pass ''') - expected_formatted_code = textwrap.dedent('''\ + expected_formatted_code = textwrap.dedent( + '''\ """Hello world RIP Dennis Richie. @@ -667,37 +726,40 @@ def foo(self): # comment pass ''') - 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)) - def testTupleCommaBeforeLastParen(self): - unformatted_code = textwrap.dedent("""\ + def testTupleCommaBeforeLastParen(self): + 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)) + 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("""\ + def testNoBreakOutsideOfBracket(self): + # FIXME(morbo): How this is formatted is not correct. But it's syntactically + # correct. + 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) - """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - def testBlankLinesBeforeDecorators(self): - unformatted_code = textwrap.dedent("""\ + def testBlankLinesBeforeDecorators(self): + unformatted_code = textwrap.dedent( + """\ @foo() class A(object): @bar() @@ -705,7 +767,8 @@ class A(object): def x(self): pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ @foo() class A(object): @@ -714,80 +777,90 @@ class A(object): def x(self): pass """) - 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)) - def testCommentBetweenDecorators(self): - unformatted_code = textwrap.dedent("""\ + def testCommentBetweenDecorators(self): + unformatted_code = textwrap.dedent( + """\ @foo() # frob @bar def x (self): pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ @foo() # frob @bar def x(self): pass """) - 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)) - def testListComprehension(self): - unformatted_code = textwrap.dedent("""\ + def testListComprehension(self): + 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] """) - 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)) - def testListComprehensionPreferOneLine(self): - unformatted_code = textwrap.dedent("""\ + def testListComprehensionPreferOneLine(self): + 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 ] """) - 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)) - def testListComprehensionPreferOneLineOverArithmeticSplit(self): - unformatted_code = textwrap.dedent("""\ + def testListComprehensionPreferOneLineOverArithmeticSplit(self): + 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("""\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ def given(used_identifiers): return (sum(len(identifier) for identifier in used_identifiers) / len(used_identifiers)) """) - 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)) - def testListComprehensionPreferThreeLinesForLineWrap(self): - unformatted_code = textwrap.dedent("""\ + def testListComprehensionPreferThreeLinesForLineWrap(self): + 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 @@ -795,34 +868,36 @@ def given(y): if long_var_name == 2 and number_two == 3 ] """) - 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)) - def testListComprehensionPreferNoBreakForTrivialExpression(self): - unformatted_code = textwrap.dedent("""\ + def testListComprehensionPreferNoBreakForTrivialExpression(self): + 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 () if long_var_name == 2 and number_two == 3 ] """) - 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)) - def testOpeningAndClosingBrackets(self): - unformatted_code = """\ + def testOpeningAndClosingBrackets(self): + unformatted_code = """\ foo( (1, ) ) foo( ( 1, 2, 3 ) ) foo( ( 1, 2, 3, ) ) """ - expected_formatted_code = """\ + expected_formatted_code = """\ foo((1,)) foo((1, 2, 3)) foo(( @@ -831,93 +906,105 @@ def testOpeningAndClosingBrackets(self): 3, )) """ - 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)) - def testSingleLineFunctions(self): - unformatted_code = textwrap.dedent("""\ + def testSingleLineFunctions(self): + unformatted_code = textwrap.dedent( + """\ def foo(): return 42 """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def foo(): return 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)) - 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 = """\ + 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 = """\ find_symbol(node.type) + "< " + " ".join(find_pattern(n) for n in node.child) + " >" """ # noqa - expected_formatted_code = """\ + expected_formatted_code = """\ find_symbol(node.type) + "< " + " ".join( find_pattern(n) for n in node.child) + " >" """ - 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)) - def testNoSpacesBetweenSubscriptsAndCalls(self): - unformatted_code = textwrap.dedent("""\ + def testNoSpacesBetweenSubscriptsAndCalls(self): + 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) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - def testNoSpacesBetweenOpeningBracketAndStartingOperator(self): - # Unary operator. - unformatted_code = textwrap.dedent("""\ + def testNoSpacesBetweenOpeningBracketAndStartingOperator(self): + # Unary operator. + 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)) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - # Varargs and kwargs. - unformatted_code = textwrap.dedent("""\ + # Varargs and kwargs. + 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) """) - 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)) - def testMultilineCommentReformatted(self): - unformatted_code = textwrap.dedent("""\ + def testMultilineCommentReformatted(self): + 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. pass """) - 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)) - def testDictionaryMakerFormatting(self): - unformatted_code = textwrap.dedent("""\ + def testDictionaryMakerFormatting(self): + 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', 'yield_stmt': 'import_stmt', lambda: 'global_stmt': 'exec_stmt', 'assert_stmt': 'if_stmt', 'while_stmt': 'for_stmt', }) - """) # noqa - expected_formatted_code = textwrap.dedent("""\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ _PYTHON_STATEMENTS = frozenset({ lambda x, y: 'simple_stmt': 'small_stmt', 'expr_stmt': 'print_stmt', @@ -930,29 +1017,32 @@ def testDictionaryMakerFormatting(self): 'while_stmt': 'for_stmt', }) """) - 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)) - def testSimpleMultilineCode(self): - unformatted_code = textwrap.dedent("""\ + def testSimpleMultilineCode(self): + 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) aaaaaaaaaaaaaa.bbbbbbbbbbbbbb.ccccccc(zzzzzzzzzzzz, xxxxxxxxxxx, yyyyyyyyyyyy, vvvvvvvvv) - """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - def testMultilineComment(self): - code = textwrap.dedent("""\ + def testMultilineComment(self): + code = textwrap.dedent( + """\ if Foo: # Hello world # Yo man. @@ -961,18 +1051,19 @@ def testMultilineComment(self): # Yo man. a = 42 """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testSpaceBetweenStringAndParentheses(self): - code = textwrap.dedent("""\ + def testSpaceBetweenStringAndParentheses(self): + code = textwrap.dedent("""\ b = '0' ('hello') """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testMultilineString(self): - code = textwrap.dedent("""\ + def testMultilineString(self): + code = textwrap.dedent( + """\ code = textwrap.dedent('''\ if Foo: # Hello world @@ -983,10 +1074,11 @@ def testMultilineString(self): a = 42 ''') """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + 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"]+"""
@@ -994,8 +1086,9 @@ def f(): Residence: """+palace["Winter"]+"""
""" - ''') # noqa - expected_formatted_code = textwrap.dedent('''\ + ''') # noqa + 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"] + """
@@ -1003,12 +1096,13 @@ def f(): Residence: """ + palace["Winter"] + """
""" - ''') # noqa - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + ''') # noqa + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - def testSimpleMultilineWithComments(self): - code = textwrap.dedent("""\ + def testSimpleMultilineWithComments(self): + code = textwrap.dedent( + """\ if ( # This is the first comment a and # This is the second comment # This is the third comment @@ -1016,25 +1110,28 @@ def testSimpleMultilineWithComments(self): # Whoa! A normal comment!! pass # Another trailing comment """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testMatchingParenSplittingMatching(self): - unformatted_code = textwrap.dedent("""\ + def testMatchingParenSplittingMatching(self): + 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,)) """) - 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)) - def testContinuationIndent(self): - unformatted_code = textwrap.dedent('''\ + def testContinuationIndent(self): + unformatted_code = textwrap.dedent( + '''\ class F: def _ProcessArgLists(self, node): """Common method for processing argument lists.""" @@ -1044,7 +1141,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): @@ -1055,17 +1153,19 @@ def _ProcessArgLists(self, node): child, subtype=_ARGLIST_TOKEN_TO_SUBTYPE.get(child.value, format_token.Subtype.NONE)) - ''') # noqa - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + ''') # noqa + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - def testTrailingCommaAndBracket(self): - unformatted_code = textwrap.dedent('''\ + def testTrailingCommaAndBracket(self): + unformatted_code = textwrap.dedent( + '''\ a = { 42, } b = ( 42, ) c = [ 42, ] ''') - expected_formatted_code = textwrap.dedent('''\ + expected_formatted_code = textwrap.dedent( + '''\ a = { 42, } @@ -1074,24 +1174,27 @@ def testTrailingCommaAndBracket(self): 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)) - def testI18n(self): - code = textwrap.dedent("""\ + def testI18n(self): + 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)) + """) # 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)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testI18nCommentsInDataLiteral(self): - code = textwrap.dedent("""\ + def testI18nCommentsInDataLiteral(self): + code = textwrap.dedent( + """\ def f(): return collections.OrderedDict({ #. First i18n comment. @@ -1101,11 +1204,12 @@ def f(): 'snork': 'bar#.*=\\\\0', }) """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testClosingBracketIndent(self): - code = textwrap.dedent('''\ + def testClosingBracketIndent(self): + code = textwrap.dedent( + '''\ def f(): def g(): @@ -1113,12 +1217,13 @@ def g(): xxxxxxxxxxxxxxxxxxxxx( yyyyyyyyyyyyy[zzzzz].aaaaaaaa[0]) == 'bbbbbbb'): pass - ''') # noqa - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + ''') # noqa + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testClosingBracketsInlinedInCall(self): - unformatted_code = textwrap.dedent("""\ + def testClosingBracketsInlinedInCall(self): + unformatted_code = textwrap.dedent( + """\ class Foo(object): def bar(self): @@ -1132,7 +1237,8 @@ def bar(self): "porkporkpork": 5, }) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ class Foo(object): def bar(self): @@ -1146,11 +1252,12 @@ def bar(self): "porkporkpork": 5, }) """) - 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)) - def testLineWrapInForExpression(self): - code = textwrap.dedent("""\ + def testLineWrapInForExpression(self): + code = textwrap.dedent( + """\ class A: def x(self, node, name, n=1): @@ -1159,11 +1266,11 @@ def x(self, node, name, n=1): node.pre_order())): pass """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testFunctionCallContinuationLine(self): - code = """\ + def testFunctionCallContinuationLine(self): + code = """\ class foo: def bar(self, node, name, n=1): @@ -1173,31 +1280,33 @@ def bar(self, node, name, n=1): bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb( cccc, ddddddddddddddddddddddddddddddddddddd))] """ - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testI18nNonFormatting(self): - code = textwrap.dedent("""\ + def testI18nNonFormatting(self): + code = textwrap.dedent( + """\ class F(object): def __init__(self, fieldname, #. Error message indicating an invalid e-mail address. message=N_('Please check your email address.'), **kwargs): pass - """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testNoSpaceBetweenUnaryOpAndOpeningParen(self): - code = textwrap.dedent("""\ + def testNoSpaceBetweenUnaryOpAndOpeningParen(self): + code = textwrap.dedent("""\ if ~(a or b): pass """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testCommentBeforeFuncDef(self): - code = textwrap.dedent("""\ + def testCommentBeforeFuncDef(self): + code = textwrap.dedent( + """\ class Foo(object): a = 42 @@ -1211,11 +1320,12 @@ def __init__(self, bbbbbbbbbbbbbbb=False): pass """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testExcessLineCountWithDefaultKeywords(self): - unformatted_code = textwrap.dedent("""\ + def testExcessLineCountWithDefaultKeywords(self): + unformatted_code = textwrap.dedent( + """\ class Fnord(object): def Moo(self): aaaaaaaaaaaaaaaa = self._bbbbbbbbbbbbbbbbbbbbbbb( @@ -1223,7 +1333,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): @@ -1236,19 +1347,21 @@ def Moo(self): hhhhhhhhhhhhh=hhhhhhhhhhhhh, iiiiiii=iiiiiiiiiiiiii) """) - 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)) - def testSpaceAfterNotOperator(self): - code = textwrap.dedent("""\ + def testSpaceAfterNotOperator(self): + code = textwrap.dedent( + """\ if not (this and that): pass """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testNoPenaltySplitting(self): - code = textwrap.dedent("""\ + def testNoPenaltySplitting(self): + code = textwrap.dedent( + """\ def f(): if True: if True: @@ -1257,29 +1370,32 @@ def f(): for f in os.listdir(filename) if IsPythonFile(os.path.join(filename, f))) """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testExpressionPenalties(self): - code = textwrap.dedent("""\ + def testExpressionPenalties(self): + code = textwrap.dedent( + """\ def f(): if ((left.value == '(' and right.value == ')') or (left.value == '[' and right.value == ']') or (left.value == '{' and right.value == '}')): return False """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testLineDepthOfSingleLineStatement(self): - unformatted_code = textwrap.dedent("""\ + def testLineDepthOfSingleLineStatement(self): + 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): @@ -1291,15 +1407,17 @@ def testLineDepthOfSingleLineStatement(self): with open(a) as fd: a = fd.read() """) - 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)) - def testSplitListWithTerminatingComma(self): - unformatted_code = textwrap.dedent("""\ + def testSplitListWithTerminatingComma(self): + 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', @@ -1314,11 +1432,12 @@ def testSplitListWithTerminatingComma(self): lambda a, b: 37, ] """) - 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)) - def testSplitListWithInterspersedComments(self): - code = textwrap.dedent("""\ + def testSplitListWithInterspersedComments(self): + code = textwrap.dedent( + """\ FOO = [ 'bar', # bar 'baz', # baz @@ -1333,33 +1452,36 @@ def testSplitListWithInterspersedComments(self): lambda a, b: 37 # lambda ] """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testRelativeImportStatements(self): - code = textwrap.dedent("""\ + def testRelativeImportStatements(self): + code = textwrap.dedent("""\ from ... import bork """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testSingleLineList(self): - # A list on a single line should prefer to remain contiguous. - unformatted_code = textwrap.dedent("""\ + def testSingleLineList(self): + # A list on a single line should prefer to remain contiguous. + unformatted_code = textwrap.dedent( + """\ bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = aaaaaaaaaaa( ("...", "."), "..", ".............................................." ) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = aaaaaaaaaaa( ("...", "."), "..", "..............................................") - """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - def testBlankLinesBeforeFunctionsNotInColumnZero(self): - unformatted_code = textwrap.dedent("""\ + def testBlankLinesBeforeFunctionsNotInColumnZero(self): + unformatted_code = textwrap.dedent( + """\ import signal @@ -1374,7 +1496,8 @@ def timeout(seconds=1): except: pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ import signal try: @@ -1388,12 +1511,13 @@ def timeout(seconds=1): pass except: pass - """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - def testNoKeywordArgumentBreakage(self): - code = textwrap.dedent("""\ + def testNoKeywordArgumentBreakage(self): + code = textwrap.dedent( + """\ class A(object): def b(self): @@ -1401,21 +1525,22 @@ def b(self): cccccccccccccccccccc=True): pass """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testTrailerOnSingleLine(self): - code = """\ + def testTrailerOnSingleLine(self): + code = """\ urlpatterns = patterns('', url(r'^$', 'homepage_view'), url(r'^/login/$', 'login_view'), url(r'^/login/$', 'logout_view'), url(r'^/user/(?P\\w+)/$', 'profile_view')) """ - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testIfConditionalParens(self): - code = textwrap.dedent("""\ + def testIfConditionalParens(self): + code = textwrap.dedent( + """\ class Foo: def bar(): @@ -1424,79 +1549,87 @@ def bar(): child.value in substatement_names): pass """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testContinuationMarkers(self): - code = textwrap.dedent("""\ + def testContinuationMarkers(self): + 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 "\\ "sit amet vitae augue. Nam tincidunt congue enim, ut porta lorem lacinia consectetur. "\\ "Donec ut libero sed arcu vehicula ultricies a non tortor. Lorem ipsum dolor sit amet" - """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + """) # noqa + 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)) + """) # 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 """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testCommentsWithContinuationMarkers(self): - code = textwrap.dedent("""\ + def testCommentsWithContinuationMarkers(self): + code = textwrap.dedent( + """\ def fn(arg): v = fn2(key1=True, #c1 key2=arg)\\ .fn3() """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testMultipleContinuationMarkers(self): - code = textwrap.dedent("""\ + def testMultipleContinuationMarkers(self): + code = textwrap.dedent( + """\ xyz = \\ \\ some_thing() """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testContinuationMarkerAfterStringWithContinuation(self): - code = """\ + def testContinuationMarkerAfterStringWithContinuation(self): + code = """\ s = 'foo \\ bar' \\ .format() """ - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testEmptyContainers(self): - code = textwrap.dedent("""\ + def testEmptyContainers(self): + code = textwrap.dedent( + """\ flags.DEFINE_list( 'output_dirs', [], 'Lorem ipsum dolor sit amet, consetetur adipiscing elit. Donec a diam lectus. ' 'Sed sit amet ipsum mauris. Maecenas congue.') - """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testSplitStringsIfSurroundedByParens(self): - unformatted_code = textwrap.dedent("""\ + def testSplitStringsIfSurroundedByParens(self): + unformatted_code = textwrap.dedent( + """\ a = foo.bar({'xxxxxxxxxxxxxxxxxxxxxxx' 'yyyyyyyyyyyyyyyyyyyyyyyyyy': baz[42]} + 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' 'bbbbbbbbbbbbbbbbbbbbbbbbbb' 'cccccccccccccccccccccccccccccccc' 'ddddddddddddddddddddddddddddd') - """) # noqa - expected_formatted_code = textwrap.dedent("""\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ a = foo.bar({'xxxxxxxxxxxxxxxxxxxxxxx' 'yyyyyyyyyyyyyyyyyyyyyyyyyy': baz[42]} + 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' @@ -1504,19 +1637,21 @@ def testSplitStringsIfSurroundedByParens(self): 'cccccccccccccccccccccccccccccccc' 'ddddddddddddddddddddddddddddd') """) - 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)) - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ a = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' \ 'bbbbbbbbbbbbbbbbbbbbbbbbbb' 'cccccccccccccccccccccccccccccccc' \ 'ddddddddddddddddddddddddddddd' """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testMultilineShebang(self): - code = textwrap.dedent("""\ + def testMultilineShebang(self): + code = textwrap.dedent( + """\ #!/bin/sh if "true" : '''\' then @@ -1532,27 +1667,30 @@ def testMultilineShebang(self): assert os.environ['FOO'] == '123' """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testNoSplittingAroundTermOperators(self): - code = textwrap.dedent("""\ + def testNoSplittingAroundTermOperators(self): + code = textwrap.dedent( + """\ a_very_long_function_call_yada_yada_etc_etc_etc(long_arg1, long_arg2 / long_arg3) """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testNoSplittingAroundCompOperators(self): - code = textwrap.dedent("""\ + def testNoSplittingAroundCompOperators(self): + code = textwrap.dedent( + """\ c = (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa is not bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) c = (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa in bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) c = (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not in bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) c = (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa is bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) c = (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <= bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) - """) # noqa - expected_code = textwrap.dedent("""\ + """) # noqa + expected_code = textwrap.dedent( + """\ c = ( aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa is not bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) @@ -1570,39 +1708,43 @@ def testNoSplittingAroundCompOperators(self): aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <= bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) - def testNoSplittingWithinSubscriptList(self): - code = textwrap.dedent("""\ + def testNoSplittingWithinSubscriptList(self): + code = textwrap.dedent( + """\ somequitelongvariablename.somemember[(a, b)] = { 'somelongkey': 1, 'someotherlongkey': 2 } """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testExcessCharacters(self): - code = textwrap.dedent("""\ + def testExcessCharacters(self): + code = textwrap.dedent( + """\ class foo: 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)) + """) # noqa + 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("""\ + """) # noqa + expected_code = textwrap.dedent( + """\ def _(): if True: if True: @@ -1610,45 +1752,48 @@ def _(): if_attribute) == has_value: return True """) - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) - def testDictSetGenerator(self): - code = textwrap.dedent("""\ + def testDictSetGenerator(self): + code = textwrap.dedent( + """\ foo = { variable: 'hello world. How are you today?' for variable in fnord if variable != 37 } """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testUnaryOpInDictionaryValue(self): - code = textwrap.dedent("""\ + def testUnaryOpInDictionaryValue(self): + code = textwrap.dedent( + """\ beta = "123" test = {'alpha': beta[-1]} print(beta[-1]) """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testUnaryNotOperator(self): - code = textwrap.dedent("""\ + def testUnaryNotOperator(self): + code = textwrap.dedent( + """\ if True: if True: if True: if True: remote_checksum = self.get_checksum(conn, tmp, dest, inject, not directory_prepended, source) - """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testRelaxArraySubscriptAffinity(self): - code = """\ + def testRelaxArraySubscriptAffinity(self): + code = """\ class A(object): def f(self, aaaaaaaaa, bbbbbbbbbbbbb, row): @@ -1660,41 +1805,44 @@ def f(self, aaaaaaaaa, bbbbbbbbbbbbb, row): bbbbbbbbbbbbb[ '..............'] = row[5] if row[5] is not None else 5 """ - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) - - def testFunctionCallInDict(self): - 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" - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) - - def testUnbreakableNot(self): - code = textwrap.dedent("""\ + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) + + def testFunctionCallInDict(self): + 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" + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) + + def testUnbreakableNot(self): + code = textwrap.dedent( + """\ def test(): if not "Foooooooooooooooooooooooooooooo" or "Foooooooooooooooooooooooooooooo" == "Foooooooooooooooooooooooooooooo": pass - """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testSplitListWithComment(self): - code = textwrap.dedent("""\ + def testSplitListWithComment(self): + code = textwrap.dedent( + """\ a = [ 'a', 'b', 'c' # hello world ] """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testOverColumnLimit(self): - unformatted_code = textwrap.dedent("""\ + def testOverColumnLimit(self): + unformatted_code = textwrap.dedent( + """\ class Test: def testSomething(self): @@ -1703,8 +1851,9 @@ def testSomething(self): ('aaaaaaaaaaaaa', 'bbbb'): 'ccccccccccccccccccccccccccccccccccccccccccc', ('aaaaaaaaaaaaa', 'bbbb'): 'ccccccccccccccccccccccccccccccccccccccccccc', } - """) # noqa - expected_formatted_code = textwrap.dedent("""\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ class Test: def testSomething(self): @@ -1717,32 +1866,35 @@ def testSomething(self): 'ccccccccccccccccccccccccccccccccccccccccccc', } """) - 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)) - def testEndingComment(self): - code = textwrap.dedent("""\ + def testEndingComment(self): + code = textwrap.dedent( + """\ a = f( a="something", b="something requiring comment which is quite long", # comment about b (pushes line over 79) c="something else, about which comment doesn't make sense") - """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testContinuationSpaceRetention(self): - code = textwrap.dedent("""\ + def testContinuationSpaceRetention(self): + code = textwrap.dedent( + """\ def fn(): return module \\ .method(Object(data, fn2(arg) )) """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testIfExpressionWithFunctionCall(self): - code = textwrap.dedent("""\ + def testIfExpressionWithFunctionCall(self): + code = textwrap.dedent( + """\ if x or z.y( a, c, @@ -1750,48 +1902,53 @@ def testIfExpressionWithFunctionCall(self): bbbbbbbbbbbbbbbbbbbbb=bbbbbbbbbbbbbbbbbb): pass """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testUnformattedAfterMultilineString(self): - code = textwrap.dedent("""\ + def testUnformattedAfterMultilineString(self): + code = textwrap.dedent( + """\ def foo(): com_text = \\ ''' TEST ''' % (input_fname, output_fname) """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testNoSpacesAroundKeywordDefaultValues(self): - code = textwrap.dedent("""\ + def testNoSpacesAroundKeywordDefaultValues(self): + code = textwrap.dedent( + """\ sources = { 'json': request.get_json(silent=True) or {}, 'json2': request.get_json(silent=True), } json = request.get_json(silent=True) or {} """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testNoSplittingBeforeEndingSubscriptBracket(self): - unformatted_code = textwrap.dedent("""\ + def testNoSplittingBeforeEndingSubscriptBracket(self): + 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("""\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ if True: if True: status = cf.describe_stacks( StackName=stackname)[u'Stacks'][0][u'StackStatus'] """) - 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)) - def testNoSplittingOnSingleArgument(self): - unformatted_code = textwrap.dedent("""\ + def testNoSplittingOnSingleArgument(self): + unformatted_code = textwrap.dedent( + """\ xxxxxxxxxxxxxx = (re.search(r'(\\d+\\.\\d+\\.\\d+\\.)\\d+', aaaaaaa.bbbbbbbbbbbb).group(1) + re.search(r'\\d+\\.\\d+\\.\\d+\\.(\\d+)', @@ -1801,25 +1958,28 @@ 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)) xxxxxxxxxxxxxx = ( re.search(r'(\\d+\\.\\d+\\.\\d+\\.)\\d+', aaaaaaa.bbbbbbbbbbbb).group(a.b) + re.search(r'\\d+\\.\\d+\\.\\d+\\.(\\d+)', ccccccc).group(c.d)) - """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - def testSplittingArraysSensibly(self): - unformatted_code = textwrap.dedent("""\ + def testSplittingArraysSensibly(self): + unformatted_code = textwrap.dedent( + """\ while True: while True: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = list['bbbbbbbbbbbbbbbbbbbbbbbbb'].split(',') aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = list('bbbbbbbbbbbbbbbbbbbbbbbbb').split(',') - """) # noqa - expected_formatted_code = textwrap.dedent("""\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ while True: while True: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = list[ @@ -1827,28 +1987,31 @@ def testSplittingArraysSensibly(self): aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = list( 'bbbbbbbbbbbbbbbbbbbbbbbbb').split(',') """) - 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)) - def testComprehensionForAndIf(self): - unformatted_code = textwrap.dedent("""\ + def testComprehensionForAndIf(self): + 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("""\ + """) # noqa + expected_formatted_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 - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - def testFunctionCallArguments(self): - unformatted_code = textwrap.dedent("""\ + def testFunctionCallArguments(self): + unformatted_code = textwrap.dedent( + """\ def f(): if True: pytree_utils.InsertNodesBefore(_CreateCommentsFromPrefix( @@ -1858,7 +2021,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( @@ -1868,23 +2032,26 @@ def f(): pytree_utils.InsertNodesBefore( _CreateCommentsFromPrefix( comment_prefix, comment_lineno, comment_column, standalone=True)) - """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - def testBinaryOperators(self): - unformatted_code = textwrap.dedent("""\ + def testBinaryOperators(self): + 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)) + 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 @@ -1893,29 +2060,32 @@ def f(): current.value in ']}'): pass """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testContiguousList(self): - code = textwrap.dedent("""\ + def testContiguousList(self): + code = textwrap.dedent( + """\ [retval1, retval2] = a_very_long_function(argument_1, argument2, argument_3, argument_4) - """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testArgsAndKwargsFormatting(self): - code = textwrap.dedent("""\ + def testArgsAndKwargsFormatting(self): + code = textwrap.dedent( + """\ a(a=aaaaaaaaaaaaaaaaaaaaa, b=aaaaaaaaaaaaaaaaaaaaaaaa, c=aaaaaaaaaaaaaaaaaa, *d, **e) """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + 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', @@ -1923,11 +2093,12 @@ def foo(): zzz='a third long string') ] """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testCommentColumnLimitOverflow(self): - code = textwrap.dedent("""\ + def testCommentColumnLimitOverflow(self): + code = textwrap.dedent( + """\ def f(): if True: TaskManager.get_tags = MagicMock( @@ -1936,11 +2107,12 @@ def f(): # side_effect=[(157031694470475), (157031694470475),], ) """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testMultilineLambdas(self): - unformatted_code = textwrap.dedent("""\ + def testMultilineLambdas(self): + unformatted_code = textwrap.dedent( + """\ class SomeClass(object): do_something = True @@ -1950,8 +2122,9 @@ def succeeded(self, dddddddddddddd): if self.do_something: d.addCallback(lambda _: self.aaaaaa.bbbbbbbbbbbbbbbb.cccccccccccccccccccccccccccccccc(dddddddddddddd)) return d - """) # noqa - expected_formatted_code = textwrap.dedent("""\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ class SomeClass(object): do_something = True @@ -1964,18 +2137,18 @@ def succeeded(self, dddddddddddddd): return d """) - try: - style.SetGlobalStyle( - 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)) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) - - def testMultilineDictionaryKeys(self): - unformatted_code = textwrap.dedent("""\ + try: + style.SetGlobalStyle( + 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)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testMultilineDictionaryKeys(self): + unformatted_code = textwrap.dedent( + """\ MAP_WITH_LONG_KEYS = { ('lorem ipsum', 'dolor sit amet'): 1, @@ -1984,8 +2157,9 @@ def testMultilineDictionaryKeys(self): ('vehicula convallis nulla. Vestibulum dictum nisl in malesuada finibus.',): 3 } - """) # noqa - expected_formatted_code = textwrap.dedent("""\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ MAP_WITH_LONG_KEYS = { ('lorem ipsum', 'dolor sit amet'): 1, @@ -1995,20 +2169,21 @@ def testMultilineDictionaryKeys(self): ('vehicula convallis nulla. Vestibulum dictum nisl in malesuada finibus.',): 3 } - """) # noqa - - try: - style.SetGlobalStyle( - 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)) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) - - def testStableDictionaryFormatting(self): - code = textwrap.dedent("""\ + """) # noqa + + try: + style.SetGlobalStyle( + 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)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testStableDictionaryFormatting(self): + code = textwrap.dedent( + """\ class A(object): def method(self): @@ -2021,33 +2196,36 @@ def method(self): } }] } - """) # noqa - - try: - style.SetGlobalStyle( - style.CreateStyleFromConfig('{based_on_style: pep8, indent_width: 2, ' - 'continuation_indent_width: 4, ' - 'indent_dictionary_value: True}')) - - llines = yapf_test_helper.ParseAndUnwrap(code) - reformatted_code = reformatter.Reformat(llines) - self.assertCodeEqual(code, 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 testStableInlinedDictionaryFormatting(self): - try: - style.SetGlobalStyle(style.CreatePEP8Style()) - unformatted_code = textwrap.dedent("""\ + """) # noqa + + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig( + '{based_on_style: pep8, indent_width: 2, ' + 'continuation_indent_width: 4, ' + 'indent_dictionary_value: True}')) + + llines = yapf_test_helper.ParseAndUnwrap(code) + reformatted_code = reformatter.Reformat(llines) + self.assertCodeEqual(code, 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 testStableInlinedDictionaryFormatting(self): + try: + style.SetGlobalStyle(style.CreatePEP8Style()) + 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("""\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ def _(): url = "http://{0}/axis-cgi/admin/param.cgi?{1}".format( value, urllib.urlencode({ @@ -2056,42 +2234,46 @@ def _(): })) """) - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - reformatted_code = reformatter.Reformat(llines) - self.assertCodeEqual(expected_formatted_code, reformatted_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) - reformatted_code = reformatter.Reformat(llines) - self.assertCodeEqual(expected_formatted_code, reformatted_code) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) + 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("""\ + def testDontSplitKeywordValueArguments(self): + 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)) """) - 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)) - def testDontAddBlankLineAfterMultilineString(self): - code = textwrap.dedent("""\ + def testDontAddBlankLineAfterMultilineString(self): + code = textwrap.dedent( + """\ query = '''SELECT id FROM table WHERE day in {}''' days = ",".join(days) """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testFormattingListComprehensions(self): - code = textwrap.dedent("""\ + def testFormattingListComprehensions(self): + code = textwrap.dedent( + """\ def a(): if True: if True: @@ -2100,12 +2282,13 @@ def a(): x for x, y in self._heap_this_is_very_long if x.route[0] == choice ] self._heap = [x for x in self._heap if x.route and x.route[0] == choice] - """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testNoSplittingWhenBinPacking(self): - code = textwrap.dedent("""\ + def testNoSplittingWhenBinPacking(self): + code = textwrap.dedent( + """\ a_very_long_function_name( long_argument_name_1=1, long_argument_name_2=2, @@ -2117,42 +2300,45 @@ def testNoSplittingWhenBinPacking(self): long_argument_name_1=1, long_argument_name_2=2, long_argument_name_3=3, long_argument_name_4=4 ) - """) # noqa - - try: - style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{based_on_style: pep8, indent_width: 2, ' - 'continuation_indent_width: 4, indent_dictionary_value: True, ' - 'dedent_closing_brackets: True, ' - 'split_before_named_assigns: False}')) - - llines = yapf_test_helper.ParseAndUnwrap(code) - reformatted_code = reformatter.Reformat(llines) - self.assertCodeEqual(code, 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("""\ + """) # noqa + + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig( + '{based_on_style: pep8, indent_width: 2, ' + 'continuation_indent_width: 4, indent_dictionary_value: True, ' + 'dedent_closing_brackets: True, ' + 'split_before_named_assigns: False}')) + + llines = yapf_test_helper.ParseAndUnwrap(code) + reformatted_code = reformatter.Reformat(llines) + self.assertCodeEqual(code, 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( + """\ 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 """) - 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)) - def testSplittingOneArgumentList(self): - unformatted_code = textwrap.dedent("""\ + def testSplittingOneArgumentList(self): + unformatted_code = textwrap.dedent( + """\ def _(): if True: if True: @@ -2160,8 +2346,9 @@ def _(): if True: if True: boxes[id_] = np.concatenate((points.min(axis=0), qoints.max(axis=0))) - """) # noqa - expected_formatted_code = textwrap.dedent("""\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ def _(): if True: if True: @@ -2171,11 +2358,12 @@ def _(): boxes[id_] = np.concatenate( (points.min(axis=0), qoints.max(axis=0))) """) - 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)) - def testSplittingBeforeFirstElementListArgument(self): - unformatted_code = textwrap.dedent("""\ + def testSplittingBeforeFirstElementListArgument(self): + unformatted_code = textwrap.dedent( + """\ class _(): @classmethod def _pack_results_for_constraint_or(cls, combination, constraints): @@ -2187,8 +2375,9 @@ def _pack_results_for_constraint_or(cls, combination, constraints): clue for clue in combination if not clue == Verifier.UNMATCHED ), constraints, InvestigationResult.OR ) - """) # noqa - expected_formatted_code = textwrap.dedent("""\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ class _(): @classmethod @@ -2199,12 +2388,13 @@ def _pack_results_for_constraint_or(cls, combination, constraints): return cls._create_investigation_result( (clue for clue in combination if not clue == Verifier.UNMATCHED), constraints, InvestigationResult.OR) - """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - def testSplittingArgumentsTerminatedByComma(self): - unformatted_code = textwrap.dedent("""\ + def testSplittingArgumentsTerminatedByComma(self): + 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,) @@ -2214,8 +2404,9 @@ def testSplittingArgumentsTerminatedByComma(self): a_very_long_function_name(long_argument_name_1, long_argument_name_2, long_argument_name_3, long_argument_name_4,) r =f0 (1, 2,3,) - """) # noqa - expected_formatted_code = textwrap.dedent("""\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ function_name(argument_name_1=1, argument_name_2=2, argument_name_3=3) function_name( @@ -2244,33 +2435,35 @@ def testSplittingArgumentsTerminatedByComma(self): ) """) - try: - style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{based_on_style: yapf, ' - 'split_arguments_when_comma_terminated: True}')) - - 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) - reformatted_code = reformatter.Reformat(llines) - self.assertCodeEqual(expected_formatted_code, reformatted_code) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) - - def testImportAsList(self): - code = textwrap.dedent("""\ + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig( + '{based_on_style: yapf, ' + 'split_arguments_when_comma_terminated: True}')) + + 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) + reformatted_code = reformatter.Reformat(llines) + self.assertCodeEqual(expected_formatted_code, reformatted_code) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testImportAsList(self): + code = textwrap.dedent( + """\ from toto import titi, tata, tutu # noqa from toto import titi, tata, tutu from toto import (titi, tata, tutu) """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testDictionaryValuesOnOwnLines(self): - unformatted_code = textwrap.dedent("""\ + def testDictionaryValuesOnOwnLines(self): + unformatted_code = textwrap.dedent( + """\ a = { 'aaaaaaaaaaaaaaaaaaaaaaaa': Check('ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ', '=', True), @@ -2294,7 +2487,8 @@ def testDictionaryValuesOnOwnLines(self): Check('QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ', '=', False), } """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ a = { 'aaaaaaaaaaaaaaaaaaaaaaaa': Check('ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ', '=', True), @@ -2317,43 +2511,48 @@ def testDictionaryValuesOnOwnLines(self): 'jjjjjjjjjjjjjjjjjjjjjjjjjj': Check('QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ', '=', False), } - """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - def testDictionaryOnOwnLine(self): - unformatted_code = textwrap.dedent("""\ + def testDictionaryOnOwnLine(self): + 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)) + """) # 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, collection_key=collection.key, collection_key2=collection.key2) """) - 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)) - def testNestedListsInDictionary(self): - unformatted_code = textwrap.dedent("""\ + def testNestedListsInDictionary(self): + unformatted_code = textwrap.dedent( + """\ _A = { 'cccccccccc': ('^^1',), 'rrrrrrrrrrrrrrrrrrrrrrrrr': ('^7913', # AAAAAAAAAAAAAA. @@ -2381,8 +2580,9 @@ def testNestedListsInDictionary(self): 'cccccccccc': ('^21109', # PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP. ), } - """) # noqa - expected_formatted_code = textwrap.dedent("""\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ _A = { 'cccccccccc': ('^^1',), 'rrrrrrrrrrrrrrrrrrrrrrrrr': ( @@ -2416,11 +2616,12 @@ def testNestedListsInDictionary(self): ), } """) - 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)) - def testNestedDictionary(self): - unformatted_code = textwrap.dedent("""\ + def testNestedDictionary(self): + unformatted_code = textwrap.dedent( + """\ class _(): def _(): breadcrumbs = [{'name': 'Admin', @@ -2430,7 +2631,8 @@ def _(): 'url': url_for(".home")}, {'title': title}] """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ class _(): def _(): breadcrumbs = [ @@ -2443,12 +2645,13 @@ def _(): }, ] breadcrumbs = [{'name': 'Admin', 'url': url_for(".home")}, {'title': title}] - """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - def testDictionaryElementsOnOneLine(self): - code = textwrap.dedent("""\ + def testDictionaryElementsOnOneLine(self): + code = textwrap.dedent( + """\ class _(): @mock.patch.dict( @@ -2463,41 +2666,46 @@ def _(): Environment.YYYYYYY: 'some text more text even more text yet ag', Environment.ZZZZZZZZZZZ: 'some text more text even more text yet again tex', } - """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testNotInParams(self): - unformatted_code = textwrap.dedent("""\ + def testNotInParams(self): + 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("""\ + """) # noqa + 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 - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) - def testNamedAssignNotAtEndOfLine(self): - unformatted_code = textwrap.dedent("""\ + def testNamedAssignNotAtEndOfLine(self): + 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( filename, mode='w', encoding=encoding) as fd: pass """) - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) - def testBlankLineBeforeClassDocstring(self): - unformatted_code = textwrap.dedent('''\ + def testBlankLineBeforeClassDocstring(self): + unformatted_code = textwrap.dedent( + '''\ class A: """Does something. @@ -2508,7 +2716,8 @@ class A: def __init__(self): pass ''') - expected_code = textwrap.dedent('''\ + expected_code = textwrap.dedent( + '''\ class A: """Does something. @@ -2518,10 +2727,11 @@ class A: def __init__(self): pass ''') - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) + 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 +2742,8 @@ class A: def __init__(self): pass ''') - expected_formatted_code = textwrap.dedent('''\ + expected_formatted_code = textwrap.dedent( + '''\ class A: """Does something. @@ -2544,20 +2755,20 @@ def __init__(self): pass ''') - try: - style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{based_on_style: yapf, ' - 'blank_line_before_class_docstring: True}')) - - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) - - def testBlankLineBeforeModuleDocstring(self): - unformatted_code = textwrap.dedent('''\ + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig( + '{based_on_style: yapf, ' + 'blank_line_before_class_docstring: True}')) + + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testBlankLineBeforeModuleDocstring(self): + unformatted_code = textwrap.dedent( + '''\ #!/usr/bin/env python # -*- coding: utf-8 name> -*- @@ -2567,7 +2778,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.""" @@ -2576,10 +2788,11 @@ def foobar(): def foobar(): pass ''') - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) + 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 +2801,8 @@ def foobar(): def foobar(): pass ''') - expected_formatted_code = textwrap.dedent('''\ + expected_formatted_code = textwrap.dedent( + '''\ #!/usr/bin/env python # -*- coding: utf-8 name> -*- @@ -2599,42 +2813,44 @@ def foobar(): pass ''') - try: - style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{based_on_style: pep8, ' - 'blank_line_before_module_docstring: True}')) - - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) - - def testTupleCohesion(self): - unformatted_code = textwrap.dedent("""\ + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig( + '{based_on_style: pep8, ' + 'blank_line_before_module_docstring: True}')) + + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testTupleCohesion(self): + 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, ('a string that may be too long %s' % 'M15')) """) - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) - def testSubscriptExpression(self): - code = textwrap.dedent("""\ + def testSubscriptExpression(self): + code = textwrap.dedent("""\ foo = d[not a] """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testListWithFunctionCalls(self): - unformatted_code = textwrap.dedent("""\ + def testListWithFunctionCalls(self): + unformatted_code = textwrap.dedent( + """\ def foo(): return [ Bar( @@ -2646,7 +2862,8 @@ def foo(): zzz='a third long string') ] """) - expected_code = textwrap.dedent("""\ + expected_code = textwrap.dedent( + """\ def foo(): return [ Bar(xxx='some string', @@ -2657,29 +2874,31 @@ def foo(): zzz='a third long string') ] """) - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) - def testEllipses(self): - unformatted_code = textwrap.dedent("""\ + def testEllipses(self): + unformatted_code = textwrap.dedent( + """\ X=... Y = X if ... else X """) - expected_code = textwrap.dedent("""\ + expected_code = textwrap.dedent( + """\ X = ... Y = X if ... else X """) - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) - def testPseudoParens(self): - unformatted_code = """\ + def testPseudoParens(self): + unformatted_code = """\ my_dict = { 'key': # Some comment about the key {'nested_key': 1, }, } """ - expected_code = """\ + expected_code = """\ my_dict = { 'key': # Some comment about the key { @@ -2687,84 +2906,88 @@ def testPseudoParens(self): }, } """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) + 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("""\ + def testSplittingBeforeFirstArgumentOnFunctionCall(self): + """Tests split_before_first_argument on a function call.""" + 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")) """) - try: - style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{based_on_style: yapf, split_before_first_argument: True}')) - - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - 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("""\ + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig( + '{based_on_style: yapf, split_before_first_argument: True}')) + + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + 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( + """\ 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 """) - try: - style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{based_on_style: yapf, split_before_first_argument: True}')) - - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - 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("""\ + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig( + '{based_on_style: yapf, split_before_first_argument: True}')) + + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + 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( + """\ 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 """) - try: - style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{based_on_style: yapf, split_before_first_argument: True}')) - - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - 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("""\ + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig( + '{based_on_style: yapf, split_before_first_argument: True}')) + + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + 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( + """\ date_time_values = ( { u'year': year, @@ -2776,7 +2999,8 @@ def testCoalesceBracketsOnDict(self): } ) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ date_time_values = ({ u'year': year, u'month': month, @@ -2787,19 +3011,19 @@ def testCoalesceBracketsOnDict(self): }) """) - try: - style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{based_on_style: yapf, coalesce_brackets: True}')) - - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) - - def testSplitAfterComment(self): - code = textwrap.dedent("""\ + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig( + '{based_on_style: yapf, coalesce_brackets: True}')) + + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testSplitAfterComment(self): + code = textwrap.dedent( + """\ if __name__ == "__main__": with another_resource: account = { @@ -2808,23 +3032,24 @@ def testSplitAfterComment(self): } """) - try: - style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{based_on_style: yapf, coalesce_brackets: True, ' - 'dedent_closing_brackets: true}')) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) - - @unittest.skipUnless(not py3compat.PY3, 'Requires Python 2.7') - def testAsyncAsNonKeyword(self): - try: - style.SetGlobalStyle(style.CreatePEP8Style()) + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig( + '{based_on_style: yapf, coalesce_brackets: True, ' + 'dedent_closing_brackets: true}')) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + @unittest.skipUnless(not py3compat.PY3, 'Requires Python 2.7') + def testAsyncAsNonKeyword(self): + try: + style.SetGlobalStyle(style.CreatePEP8Style()) - # In Python 2, async may be used as a non-keyword identifier. - code = textwrap.dedent("""\ + # In Python 2, async may be used as a non-keyword identifier. + code = textwrap.dedent( + """\ from util import async @@ -2834,36 +3059,39 @@ def foo(self): async.run() """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) - def testDisableEndingCommaHeuristic(self): - code = textwrap.dedent("""\ + def testDisableEndingCommaHeuristic(self): + code = textwrap.dedent("""\ x = [1, 2, 3, 4, 5, 6, 7,] """) - try: - style.SetGlobalStyle( - style.CreateStyleFromConfig('{based_on_style: yapf,' - ' disable_ending_comma_heuristic: True}')) - - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) - - def testDedentClosingBracketsWithTypeAnnotationExceedingLineLength(self): - unformatted_code = textwrap.dedent("""\ + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig( + '{based_on_style: yapf,' + ' disable_ending_comma_heuristic: True}')) + + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testDedentClosingBracketsWithTypeAnnotationExceedingLineLength(self): + unformatted_code = textwrap.dedent( + """\ def function(first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None) -> None: pass def function(first_argument_xxxxxxxxxxxxxxxxxxxxxxx=(0,), second_argument=None) -> None: pass - """) # noqa - expected_formatted_code = textwrap.dedent("""\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ def function( first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None ) -> None: @@ -2874,29 +3102,31 @@ def function( first_argument_xxxxxxxxxxxxxxxxxxxxxxx=(0,), second_argument=None ) -> None: pass - """) # noqa - - try: - style.SetGlobalStyle( - 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)) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) + """) # noqa - def testIndentClosingBracketsWithTypeAnnotationExceedingLineLength(self): - unformatted_code = textwrap.dedent("""\ + try: + style.SetGlobalStyle( + 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)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testIndentClosingBracketsWithTypeAnnotationExceedingLineLength(self): + unformatted_code = textwrap.dedent( + """\ def function(first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None) -> None: pass def function(first_argument_xxxxxxxxxxxxxxxxxxxxxxx=(0,), second_argument=None) -> None: pass - """) # noqa - expected_formatted_code = textwrap.dedent("""\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ def function( first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None ) -> None: @@ -2907,29 +3137,31 @@ def function( first_argument_xxxxxxxxxxxxxxxxxxxxxxx=(0,), second_argument=None ) -> None: pass - """) # noqa - - try: - style.SetGlobalStyle( - 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)) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) + """) # noqa - def testIndentClosingBracketsInFunctionCall(self): - unformatted_code = textwrap.dedent("""\ + try: + style.SetGlobalStyle( + 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)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testIndentClosingBracketsInFunctionCall(self): + unformatted_code = textwrap.dedent( + """\ def function(first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None, third_and_final_argument=True): pass def function(first_argument_xxxxxxxxxxxxxxxxxxxxxxx=(0,), second_and_last_argument=None): pass - """) # noqa - expected_formatted_code = textwrap.dedent("""\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ def function( first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None, @@ -2942,21 +3174,22 @@ def function( first_argument_xxxxxxxxxxxxxxxxxxxxxxx=(0,), second_and_last_argument=None ): pass - """) # noqa - - try: - style.SetGlobalStyle( - 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)) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) + """) # noqa - def testIndentClosingBracketsInTuple(self): - unformatted_code = textwrap.dedent("""\ + try: + style.SetGlobalStyle( + 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)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testIndentClosingBracketsInTuple(self): + unformatted_code = textwrap.dedent( + """\ def function(): some_var = ('a long element', 'another long element', 'short element', 'really really long element') return True @@ -2964,8 +3197,9 @@ def function(): def function(): some_var = ('a couple', 'small', 'elemens') return False - """) # noqa - expected_formatted_code = textwrap.dedent("""\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ def function(): some_var = ( 'a long element', 'another long element', 'short element', @@ -2977,21 +3211,22 @@ def function(): def function(): some_var = ('a couple', 'small', 'elemens') return False - """) # noqa - - try: - style.SetGlobalStyle( - style.CreateStyleFromConfig('{based_on_style: yapf,' - ' indent_closing_brackets: True}')) + """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, - reformatter.Reformat(llines)) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) - - def testIndentClosingBracketsInList(self): - unformatted_code = textwrap.dedent("""\ + try: + style.SetGlobalStyle( + 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)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testIndentClosingBracketsInList(self): + unformatted_code = textwrap.dedent( + """\ def function(): some_var = ['a long element', 'another long element', 'short element', 'really really long element'] return True @@ -2999,8 +3234,9 @@ def function(): def function(): some_var = ['a couple', 'small', 'elemens'] return False - """) # noqa - expected_formatted_code = textwrap.dedent("""\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ def function(): some_var = [ 'a long element', 'another long element', 'short element', @@ -3014,19 +3250,20 @@ def function(): return False """) - try: - style.SetGlobalStyle( - 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)) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) - - def testIndentClosingBracketsInDict(self): - unformatted_code = textwrap.dedent("""\ + try: + style.SetGlobalStyle( + 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)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testIndentClosingBracketsInDict(self): + 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 @@ -3034,8 +3271,9 @@ def function(): def function(): some_var = {1: 'a couple', 2: 'small', 3: 'elemens'} return False - """) # noqa - expected_formatted_code = textwrap.dedent("""\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ def function(): some_var = { 1: @@ -3053,21 +3291,22 @@ def function(): def function(): some_var = {1: 'a couple', 2: 'small', 3: 'elemens'} return False - """) # noqa + """) # noqa - try: - style.SetGlobalStyle( - 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)) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) - - def testMultipleDictionariesInList(self): - unformatted_code = textwrap.dedent("""\ + try: + style.SetGlobalStyle( + 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)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testMultipleDictionariesInList(self): + unformatted_code = textwrap.dedent( + """\ class A: def b(): d = { @@ -3093,7 +3332,8 @@ def b(): ] } """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ class A: def b(): @@ -3116,182 +3356,69 @@ def b(): }] } """) - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - - def testForceMultilineDict_True(self): - try: - style.SetGlobalStyle( - 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) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + + def testForceMultilineDict_True(self): + try: + style.SetGlobalStyle( + 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( + """\ responseDict = { 'childDict': { 'spam': 'eggs' } } """) - self.assertCodeEqual(expected, actual) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) - - def testForceMultilineDict_False(self): - try: - style.SetGlobalStyle( - style.CreateStyleFromConfig('{force_multiline_dict: false}')) - unformatted_code = textwrap.dedent("""\ + self.assertCodeEqual(expected, actual) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testForceMultilineDict_False(self): + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig('{force_multiline_dict: false}')) + 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)) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) - - @unittest.skipUnless(py3compat.PY38, 'Requires Python 3.8') - def testWalrus(self): - unformatted_code = textwrap.dedent("""\ + 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()) + + @unittest.skipUnless(py3compat.PY38, 'Requires Python 3.8') + def testWalrus(self): + 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') """) - 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 + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected, reformatter.Reformat(llines)) - 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 = '' +########## for Align_ArgAssign()########### - 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,' - 'split_before_first_argument: true}')) - unformatted_code = textwrap.dedent("""\ + def testAlignArgAssignTypedName(self): + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig( + '{align_argument_assignment: true,' + 'split_before_first_argument: true}')) + unformatted_code = textwrap.dedent( + """\ def f1( self, *, @@ -3304,7 +3431,8 @@ def f1( ini_section: str="" ): pass """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ def f1( self, *, @@ -3317,19 +3445,19 @@ def f1( 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}')) - unformatted_code = textwrap.dedent("""\ + 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}')) + unformatted_code = textwrap.dedent( + """\ arglist = test( first_argument='', second_argument=fun( @@ -3339,7 +3467,8 @@ def testAlignArgAssignNestedArglistInBetween(self): fourth_argument=4 ) """) - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ arglist = test( first_argument ='', second_argument =fun( @@ -3351,19 +3480,20 @@ def testAlignArgAssignNestedArglistInBetween(self): 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,' - 'new_alignment_after_commentline:true}')) - unformatted_code = textwrap.dedent("""\ + 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,' + 'new_alignment_after_commentline:true}')) + unformatted_code = textwrap.dedent( + """\ arglist = test( client_id=0, username_id=1, @@ -3371,158 +3501,55 @@ def testAlignArgAssignCommentLineInBetween(self): user_name='xxxxxxxxxxxxxxxxxxxxx' ) """) - expected_formatted_code = textwrap.dedent("""\ + 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}')) - unformatted_code = textwrap.dedent("""\ + 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}')) + 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}')) - unformatted_code = textwrap.dedent("""\ + 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}')) + 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)) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) - - ########for align dictionary colons######### - def testAlignDictColonNestedDictInBetween(self): - try: - style.SetGlobalStyle( - 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] -}] -""") - 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,' - '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}')) - 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()) - - 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()) - - - + 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() + unittest.main() From 2b4397be6867c54fb051b5b1d0f0d2d0c3da0987 Mon Sep 17 00:00:00 2001 From: Xiao Wang Date: Mon, 3 Oct 2022 15:54:49 +0200 Subject: [PATCH 09/11] run argument assignment alignment over the yapf codes --- yapf/__init__.py | 178 +- yapf/pyparser/pyparser.py | 10 +- yapf/pyparser/split_penalty_visitor.py | 33 +- yapf/pytree/blank_line_calculator.py | 34 +- yapf/pytree/comment_splicer.py | 40 +- yapf/pytree/continuation_splicer.py | 6 +- yapf/pytree/pytree_unwrapper.py | 36 +- yapf/pytree/pytree_utils.py | 42 +- yapf/pytree/split_penalty.py | 41 +- yapf/pytree/subtype_assigner.py | 27 +- yapf/third_party/yapf_diff/yapf_diff.py | 41 +- yapf/yapflib/errors.py | 4 +- yapf/yapflib/file_resources.py | 18 +- yapf/yapflib/format_decision_state.py | 59 +- yapf/yapflib/format_token.py | 555 ++-- yapf/yapflib/object_state.py | 39 +- yapf/yapflib/py3compat.py | 4 +- yapf/yapflib/reformatter.py | 1389 +++++----- yapf/yapflib/style.py | 542 ++-- yapf/yapflib/yapf_api.py | 69 +- yapftests/blank_line_calculator_test.py | 69 +- yapftests/comment_splicer_test.py | 50 +- yapftests/file_resources_test.py | 111 +- yapftests/format_token_test.py | 10 +- yapftests/line_joiner_test.py | 18 +- yapftests/logical_line_test.py | 20 +- yapftests/main_test.py | 5 +- yapftests/pytree_unwrapper_test.py | 269 +- yapftests/pytree_utils_test.py | 52 +- yapftests/reformatter_basic_test.py | 2861 ++++++++++---------- yapftests/reformatter_buganizer_test.py | 393 ++- yapftests/reformatter_facebook_test.py | 87 +- yapftests/reformatter_pep8_test.py | 248 +- yapftests/reformatter_python3_test.py | 87 +- yapftests/reformatter_style_config_test.py | 42 +- yapftests/reformatter_verify_test.py | 26 +- yapftests/split_penalty_test.py | 266 +- yapftests/style_test.py | 55 +- yapftests/subtype_assigner_test.py | 547 ++-- yapftests/utils.py | 44 +- yapftests/yapf_test.py | 450 +-- yapftests/yapf_test_helper.py | 6 +- 42 files changed, 4735 insertions(+), 4148 deletions(-) diff --git a/yapf/__init__.py b/yapf/__init__.py index 94e445b59..9b69f719e 100644 --- a/yapf/__init__.py +++ b/yapf/__init__.py @@ -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: @@ -99,10 +100,10 @@ def main(argv): 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..bb5e48f69 100644 --- a/yapf/pyparser/pyparser.py +++ b/yapf/pyparser/pyparser.py @@ -110,11 +110,11 @@ 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 = '\\' diff --git a/yapf/pyparser/split_penalty_visitor.py b/yapf/pyparser/split_penalty_visitor.py index 047b48a3d..ebcd4ee42 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) @@ -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 @@ -543,8 +544,8 @@ def visit_Attribute(self, node): # attr=Identifier) 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) diff --git a/yapf/pytree/blank_line_calculator.py b/yapf/pytree/blank_line_calculator.py index 9d218bf97..b699a4d3a 100644 --- a/yapf/pytree/blank_line_calculator.py +++ b/yapf/pytree/blank_line_calculator.py @@ -33,13 +33,14 @@ _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): @@ -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..953a7853f 100644 --- a/yapf/pytree/comment_splicer.py +++ b/yapf/pytree/comment_splicer.py @@ -178,15 +178,16 @@ def _VisitNodeRec(node): 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_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: @@ -238,9 +237,9 @@ def _CreateCommentsFromPrefix(comment_prefix, 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))) + 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..959682790 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): @@ -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: diff --git a/yapf/pytree/pytree_utils.py b/yapf/pytree/pytree_utils.py index 66a54e617..b87599774 100644 --- a/yapf/pytree/pytree_utils.py +++ b/yapf/pytree/pytree_utils.py @@ -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/split_penalty.py b/yapf/pytree/split_penalty.py index b53ffbf85..8b8318a69 100644 --- a/yapf/pytree/split_penalty.py +++ b/yapf/pytree/split_penalty.py @@ -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) @@ -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..74108c8ed 100644 --- a/yapf/pytree/subtype_assigner.py +++ b/yapf/pytree/subtype_assigner.py @@ -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 @@ -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): diff --git a/yapf/third_party/yapf_diff/yapf_diff.py b/yapf/third_party/yapf_diff/yapf_diff.py index 810a6a2d4..df5cb33da 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 ' @@ -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..112fb3512 100644 --- a/yapf/yapflib/file_resources.py +++ b/yapf/yapflib/file_resources.py @@ -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..bfe7dc58f 100644 --- a/yapf/yapflib/format_decision_state.py +++ b/yapf/yapflib/format_decision_state.py @@ -98,27 +98,30 @@ 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. @@ -704,8 +707,8 @@ 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. @@ -829,8 +832,8 @@ def _PushParameterListState(self, newline): 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. @@ -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) @@ -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 @@ -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( @@ -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 eb053e3e9..4a1f9f6b1 100644 --- a/yapf/yapflib/format_token.py +++ b/yapf/yapflib/format_token.py @@ -30,7 +30,7 @@ def _TabbedContinuationAlignPadding(spaces, align_style, tab_width): - """Build padding string for continuation alignment in tabbed indentation. + """Build padding string for continuation alignment in tabbed indentation. Arguments: spaces: (int) The number of spaces to place before the token for alignment. @@ -40,15 +40,15 @@ def _TabbedContinuationAlignPadding(spaces, align_style, tab_width): Returns: A padding string for alignment with style specified by align_style option. """ - if align_style in ('FIXED', 'VALIGN-RIGHT'): - if spaces > 0: - return '\t' * int((spaces + tab_width - 1) / tab_width) - return '' - return ' ' * spaces + if align_style in ('FIXED', 'VALIGN-RIGHT'): + if spaces > 0: + return '\t' * int((spaces + tab_width - 1) / tab_width) + return '' + return ' ' * spaces class FormatToken(object): - """Enhanced token information for formatting. + """Enhanced token information for formatting. This represents the token plus additional information useful for reformatting the code. @@ -83,57 +83,58 @@ class FormatToken(object): newlines: The number of newlines needed before this token. """ - def __init__(self, node, name): - """Constructor. + def __init__(self, node, name): + """Constructor. Arguments: 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.column = node.column - self.lineno = node.lineno - 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.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( - node, pytree_utils.Annotation.MUST_SPLIT, default=False) - self.newlines = pytree_utils.GetNodeAnnotation( - node, pytree_utils.Annotation.NEWLINES) - self.spaces_required_before = 0 - - 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 - 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) - if height: - return ('\n' + without_newlines) * height - return self.whitespace_prefix - - def AddWhitespacePrefix(self, newlines_before, spaces=0, indent_level=0): - """Register a token's whitespace prefix. + self.node = node + self.name = name + self.type = node.type + self.column = node.column + self.lineno = node.lineno + 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.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( + node, pytree_utils.Annotation.MUST_SPLIT, default=False) + self.newlines = pytree_utils.GetNodeAnnotation( + node, pytree_utils.Annotation.NEWLINES) + self.spaces_required_before = 0 + + 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 + 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) + if height: + return ('\n' + without_newlines) * height + return self.whitespace_prefix + + def AddWhitespacePrefix(self, newlines_before, spaces=0, indent_level=0): + """Register a token's whitespace prefix. This is the whitespace that will be output before a token's string. @@ -142,233 +143,233 @@ def AddWhitespacePrefix(self, newlines_before, spaces=0, indent_level=0): spaces: (int) The number of spaces to place before the token. indent_level: (int) The indentation level. """ - if style.Get('USE_TABS'): - if newlines_before > 0: - indent_before = '\t' * indent_level + _TabbedContinuationAlignPadding( - spaces, style.Get('CONTINUATION_ALIGN_STYLE'), - style.Get('INDENT_WIDTH')) - else: - indent_before = '\t' * indent_level + ' ' * spaces - else: - 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) - - # 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) - 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')) - - def RetainHorizontalSpacing(self, first_column, depth): - """Retains a token's horizontal spacing.""" - previous = self.previous_token - if not previous: - return - - if previous.is_pseudo: - previous = previous.previous_token - if not previous: - return - - cur_lineno = self.lineno - prev_lineno = previous.lineno - if previous.is_multiline_string: - prev_lineno += previous.value.count('\n') - - if (cur_lineno != prev_lineno or - (previous.is_pseudo and previous.value != ')' and - cur_lineno != previous.previous_token.lineno)): - self.spaces_required_before = ( - self.column - first_column + depth * style.Get('INDENT_WIDTH')) - return - - cur_column = self.column - prev_column = previous.column - prev_len = len(previous.value) - - if previous.is_pseudo and previous.value == ')': - prev_column -= 1 - prev_len = 0 - - if previous.is_multiline_string: - prev_len = len(previous.value.split('\n')[-1]) - if '\n' in previous.value: - prev_column = 0 # Last line starts in column 0. - - self.spaces_required_before = cur_column - (prev_column + prev_len) - - def OpensScope(self): - return self.value in _OPENING_BRACKETS - - def ClosesScope(self): - return self.value in _CLOSING_BRACKETS - - 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 += ', pseudo)' if self.is_pseudo else ')' - return msg - - @property - def node_split_penalty(self): - """Split penalty attached to the pytree node of this token.""" - return pytree_utils.GetNodeAnnotation( - self.node, pytree_utils.Annotation.SPLIT_PENALTY, default=0) - - @property - def is_binary_op(self): - """Token is a binary operator.""" - return subtypes.BINARY_OPERATOR in self.subtypes - - @property - @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 - }) - - @property - def is_simple_expr(self): - """Token is an operator in a simple expression.""" - return subtypes.SIMPLE_EXPRESSION in self.subtypes - - @property - def is_subscript_colon(self): - """Token is a subscript colon.""" - return subtypes.SUBSCRIPT_COLON in self.subtypes - - @property - def is_comment(self): - return self.type == token.COMMENT - - @property - def is_continuation(self): - return self.type == CONTINUATION - - @property - @py3compat.lru_cache() - def is_keyword(self): - return keyword.iskeyword(self.value) - - @property - def is_name(self): - return self.type == token.NAME and not self.is_keyword - - @property - def is_number(self): - return self.type == token.NUMBER - - @property - def is_string(self): - return self.type == token.STRING - - @property - def is_multiline_string(self): - """Test if this string is a multiline string. + if style.Get('USE_TABS'): + if newlines_before > 0: + indent_before = '\t' * indent_level + _TabbedContinuationAlignPadding( + spaces, style.Get('CONTINUATION_ALIGN_STYLE'), + style.Get('INDENT_WIDTH')) + else: + indent_before = '\t' * indent_level + ' ' * spaces + else: + 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) + + # 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) + 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')) + + def RetainHorizontalSpacing(self, first_column, depth): + """Retains a token's horizontal spacing.""" + previous = self.previous_token + if not previous: + return + + if previous.is_pseudo: + previous = previous.previous_token + if not previous: + return + + cur_lineno = self.lineno + prev_lineno = previous.lineno + if previous.is_multiline_string: + prev_lineno += previous.value.count('\n') + + if (cur_lineno != prev_lineno or + (previous.is_pseudo and previous.value != ')' and + cur_lineno != previous.previous_token.lineno)): + self.spaces_required_before = ( + self.column - first_column + depth * style.Get('INDENT_WIDTH')) + return + + cur_column = self.column + prev_column = previous.column + prev_len = len(previous.value) + + if previous.is_pseudo and previous.value == ')': + prev_column -= 1 + prev_len = 0 + + if previous.is_multiline_string: + prev_len = len(previous.value.split('\n')[-1]) + if '\n' in previous.value: + prev_column = 0 # Last line starts in column 0. + + self.spaces_required_before = cur_column - (prev_column + prev_len) + + def OpensScope(self): + return self.value in _OPENING_BRACKETS + + def ClosesScope(self): + return self.value in _CLOSING_BRACKETS + + 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 += ', pseudo)' if self.is_pseudo else ')' + return msg + + @property + def node_split_penalty(self): + """Split penalty attached to the pytree node of this token.""" + return pytree_utils.GetNodeAnnotation( + self.node, pytree_utils.Annotation.SPLIT_PENALTY, default=0) + + @property + def is_binary_op(self): + """Token is a binary operator.""" + return subtypes.BINARY_OPERATOR in self.subtypes + + @property + @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 + }) + + @property + def is_simple_expr(self): + """Token is an operator in a simple expression.""" + return subtypes.SIMPLE_EXPRESSION in self.subtypes + + @property + def is_subscript_colon(self): + """Token is a subscript colon.""" + return subtypes.SUBSCRIPT_COLON in self.subtypes + + @property + def is_comment(self): + return self.type == token.COMMENT + + @property + def is_continuation(self): + return self.type == CONTINUATION + + @property + @py3compat.lru_cache() + def is_keyword(self): + return keyword.iskeyword(self.value) + + @property + def is_name(self): + return self.type == token.NAME and not self.is_keyword + + @property + def is_number(self): + return self.type == token.NUMBER + + @property + def is_string(self): + return self.type == token.STRING + + @property + def is_multiline_string(self): + """Test if this string is a multiline string. Returns: A multiline string always ends with triple quotes, so if it is a string token, inspect the last 3 characters and return True if it is a triple double or triple single quote mark. """ - return self.is_string and self.value.endswith(('"""', "'''")) - - @property - def is_docstring(self): - return self.is_string and self.previous_token is None - - @property - def is_pylint_comment(self): - 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) - - @property - def is_copybara_comment(self): - return self.is_comment and re.match( - r'#.*\bcopybara:\s*(strip|insert|replace)', self.value) - - @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 - previous_subtypes = {0} - 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))) + return self.is_string and self.value.endswith(('"""', "'''")) + + @property + def is_docstring(self): + return self.is_string and self.previous_token is None + + @property + def is_pylint_comment(self): + 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) + + @property + def is_copybara_comment(self): + return self.is_comment and re.match( + r'#.*\bcopybara:\s*(strip|insert|replace)', self.value) + + @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 + previous_subtypes = {0} + 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/object_state.py b/yapf/yapflib/object_state.py index ec259e682..1f3da3630 100644 --- a/yapf/yapflib/object_state.py +++ b/yapf/yapflib/object_state.py @@ -70,10 +70,11 @@ def Clone(self): 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): @@ -166,18 +169,19 @@ def SplitBeforeClosingBracket(self, indent): 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] 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): @@ -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..f319d4172 100644 --- a/yapf/yapflib/py3compat.py +++ b/yapf/yapflib/py3compat.py @@ -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 diff --git a/yapf/yapflib/reformatter.py b/yapf/yapflib/reformatter.py index c7992d290..071754c59 100644 --- a/yapf/yapflib/reformatter.py +++ b/yapf/yapflib/reformatter.py @@ -38,7 +38,7 @@ def Reformat(llines, verify=False, lines=None): - """Reformat the logical lines. + """Reformat the logical lines. Arguments: llines: (list of logical_line.LogicalLine) Lines we want to format. @@ -49,137 +49,139 @@ def Reformat(llines, verify=False, lines=None): Returns: A string representing the reformatted code. """ - final_lines = [] - prev_line = None # The previous line. - indent_width = style.Get('INDENT_WIDTH') - - for lline in _SingleOrMergedLines(llines): - first_token = lline.first - _FormatFirstToken(first_token, lline.depth, prev_line, final_lines) - - indent_amt = indent_width * lline.depth - state = format_decision_state.FormatDecisionState(lline, indent_amt) - state.MoveStateToNextToken() - - if not lline.disable: - if lline.first.is_comment: - lline.first.value = lline.first.value.rstrip() - elif lline.last.is_comment: - lline.last.value = lline.last.value.rstrip() - 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) - if any(tok.is_comment for tok in lline.tokens): - _RetainVerticalSpacingBeforeComments(lline) - - if lline.disable or _LineHasContinuationMarkers(lline): - _RetainHorizontalSpacing(lline) - _RetainRequiredVerticalSpacing(lline, prev_line, lines) - _EmitLineUnformatted(state) - - elif (_LineContainsPylintDisableLineTooLong(lline) or _LineContainsI18n(lline)): - # Don't modify vertical spacing, but fix any horizontal spacing issues. - _RetainRequiredVerticalSpacing(lline, prev_line, lines) - _EmitLineUnformatted(state) - - elif _CanPlaceOnSingleLine(lline) and not any(tok.must_break_before - for tok in lline.tokens): - # The logical line fits on one line. - while state.next_token: - state.AddTokenToState(newline=False, dry_run=False) - - elif not _AnalyzeSolutionSpace(state): - # Failsafe mode. If there isn't a solution to the line, then just emit - # it as is. - state = format_decision_state.FormatDecisionState(lline, indent_amt) - state.MoveStateToNextToken() - _RetainHorizontalSpacing(lline) - _RetainRequiredVerticalSpacing(lline, prev_line, None) - _EmitLineUnformatted(state) - - final_lines.append(lline) - prev_line = lline - - if style.Get('ALIGN_ARGUMENT_ASSIGNMENT'): - _AlignArgAssign(final_lines) - - _AlignTrailingComments(final_lines) - return _FormatFinalLines(final_lines, verify) + final_lines = [] + prev_line = None # The previous line. + indent_width = style.Get('INDENT_WIDTH') + + for lline in _SingleOrMergedLines(llines): + first_token = lline.first + _FormatFirstToken(first_token, lline.depth, prev_line, final_lines) + + indent_amt = indent_width * lline.depth + state = format_decision_state.FormatDecisionState(lline, indent_amt) + state.MoveStateToNextToken() + + if not lline.disable: + if lline.first.is_comment: + lline.first.value = lline.first.value.rstrip() + elif lline.last.is_comment: + lline.last.value = lline.last.value.rstrip() + 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) + if any(tok.is_comment for tok in lline.tokens): + _RetainVerticalSpacingBeforeComments(lline) + + if lline.disable or _LineHasContinuationMarkers(lline): + _RetainHorizontalSpacing(lline) + _RetainRequiredVerticalSpacing(lline, prev_line, lines) + _EmitLineUnformatted(state) + + elif (_LineContainsPylintDisableLineTooLong(lline) or + _LineContainsI18n(lline)): + # Don't modify vertical spacing, but fix any horizontal spacing issues. + _RetainRequiredVerticalSpacing(lline, prev_line, lines) + _EmitLineUnformatted(state) + + elif _CanPlaceOnSingleLine(lline) and not any(tok.must_break_before + for tok in lline.tokens): + # The logical line fits on one line. + while state.next_token: + state.AddTokenToState(newline=False, dry_run=False) + + elif not _AnalyzeSolutionSpace(state): + # Failsafe mode. If there isn't a solution to the line, then just emit + # it as is. + state = format_decision_state.FormatDecisionState(lline, indent_amt) + state.MoveStateToNextToken() + _RetainHorizontalSpacing(lline) + _RetainRequiredVerticalSpacing(lline, prev_line, None) + _EmitLineUnformatted(state) + + final_lines.append(lline) + prev_line = lline + + if style.Get('ALIGN_ARGUMENT_ASSIGNMENT'): + _AlignArgAssign(final_lines) + + _AlignTrailingComments(final_lines) + return _FormatFinalLines(final_lines, verify) def _RetainHorizontalSpacing(line): - """Retain all horizontal spacing between tokens.""" - for tok in line.tokens: - tok.RetainHorizontalSpacing(line.first.column, line.depth) + """Retain all horizontal spacing between tokens.""" + for tok in line.tokens: + tok.RetainHorizontalSpacing(line.first.column, line.depth) def _RetainRequiredVerticalSpacing(cur_line, prev_line, lines): - """Retain all vertical spacing between lines.""" - prev_tok = None - if prev_line is not None: - prev_tok = prev_line.last + """Retain all vertical spacing between lines.""" + prev_tok = None + if prev_line is not None: + prev_tok = prev_line.last - if cur_line.disable: - # After the first token we are acting on a single line. So if it is - # disabled we must not reformat. - lines = set() + if cur_line.disable: + # After the first token we are acting on a single line. So if it is + # disabled we must not reformat. + lines = set() - for cur_tok in cur_line.tokens: - _RetainRequiredVerticalSpacingBetweenTokens(cur_tok, prev_tok, lines) - prev_tok = cur_tok + for cur_tok in cur_line.tokens: + _RetainRequiredVerticalSpacingBetweenTokens(cur_tok, prev_tok, lines) + prev_tok = cur_tok def _RetainRequiredVerticalSpacingBetweenTokens(cur_tok, prev_tok, lines): - """Retain vertical spacing between two tokens if not in editable range.""" - if prev_tok is None: - return - - if prev_tok.is_string: - prev_lineno = prev_tok.lineno + prev_tok.value.count('\n') - elif prev_tok.is_pseudo: - if not prev_tok.previous_token.is_multiline_string: - prev_lineno = prev_tok.previous_token.lineno - else: - prev_lineno = prev_tok.lineno + """Retain vertical spacing between two tokens if not in editable range.""" + if prev_tok is None: + return + + if prev_tok.is_string: + prev_lineno = prev_tok.lineno + prev_tok.value.count('\n') + elif prev_tok.is_pseudo: + if not prev_tok.previous_token.is_multiline_string: + prev_lineno = prev_tok.previous_token.lineno else: - prev_lineno = prev_tok.lineno + prev_lineno = prev_tok.lineno + else: + prev_lineno = prev_tok.lineno - if cur_tok.is_comment: - cur_lineno = cur_tok.lineno - cur_tok.value.count('\n') - else: - cur_lineno = cur_tok.lineno + if cur_tok.is_comment: + cur_lineno = cur_tok.lineno - cur_tok.value.count('\n') + else: + cur_lineno = cur_tok.lineno - if not prev_tok.is_comment and prev_tok.value.endswith('\\'): - prev_lineno += prev_tok.value.count('\n') + if not prev_tok.is_comment and prev_tok.value.endswith('\\'): + prev_lineno += prev_tok.value.count('\n') - required_newlines = cur_lineno - prev_lineno - if cur_tok.is_comment and not prev_tok.is_comment: - # 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) + required_newlines = cur_lineno - prev_lineno + if cur_tok.is_comment and not prev_tok.is_comment: + # 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) - cur_tok.AdjustNewlinesBefore(required_newlines) + cur_tok.AdjustNewlinesBefore(required_newlines) def _RetainVerticalSpacingBeforeComments(line): - """Retain vertical spacing before comments.""" - prev_token = None - for tok in line.tokens: - if tok.is_comment and prev_token: - if tok.lineno - tok.value.count('\n') - prev_token.lineno > 1: - tok.AdjustNewlinesBefore(ONE_BLANK_LINE) + """Retain vertical spacing before comments.""" + prev_token = None + for tok in line.tokens: + if tok.is_comment and prev_token: + if tok.lineno - tok.value.count('\n') - prev_token.lineno > 1: + tok.AdjustNewlinesBefore(ONE_BLANK_LINE) - prev_token = tok + prev_token = tok def _EmitLineUnformatted(state): - """Emit the line without formatting. + """Emit the line without formatting. The line contains code that if reformatted would break a non-syntactic convention. E.g., i18n comments and function calls are tightly bound by @@ -190,23 +192,23 @@ def _EmitLineUnformatted(state): state: (format_decision_state.FormatDecisionState) The format decision state. """ - while state.next_token: - previous_token = state.next_token.previous_token - previous_lineno = previous_token.lineno + while state.next_token: + previous_token = state.next_token.previous_token + previous_lineno = previous_token.lineno - if previous_token.is_multiline_string or previous_token.is_string: - previous_lineno += previous_token.value.count('\n') + if previous_token.is_multiline_string or previous_token.is_string: + previous_lineno += previous_token.value.count('\n') - if previous_token.is_continuation: - newline = False - else: - newline = state.next_token.lineno > previous_lineno + if previous_token.is_continuation: + newline = False + else: + newline = state.next_token.lineno > previous_lineno - state.AddTokenToState(newline=newline, dry_run=False) + state.AddTokenToState(newline=newline, dry_run=False) def _LineContainsI18n(line): - """Return true if there are i18n comments or function calls in the line. + """Return true if there are i18n comments or function calls in the line. I18n comments and pseudo-function calls are closely related. They cannot be moved apart without breaking i18n. @@ -217,33 +219,33 @@ def _LineContainsI18n(line): Returns: True if the line contains i18n comments or function calls. False otherwise. """ - if style.Get('I18N_COMMENT'): - for tok in line.tokens: - if tok.is_comment and re.match(style.Get('I18N_COMMENT'), tok.value): - # Contains an i18n comment. - return True - - if style.Get('I18N_FUNCTION_CALL'): - length = len(line.tokens) - for index in range(length - 1): - if (line.tokens[index + 1].value == '(' and - line.tokens[index].value in style.Get('I18N_FUNCTION_CALL')): - return True - return False + if style.Get('I18N_COMMENT'): + for tok in line.tokens: + if tok.is_comment and re.match(style.Get('I18N_COMMENT'), tok.value): + # Contains an i18n comment. + return True + + if style.Get('I18N_FUNCTION_CALL'): + length = len(line.tokens) + for index in range(length - 1): + if (line.tokens[index + 1].value == '(' and + line.tokens[index].value in style.Get('I18N_FUNCTION_CALL')): + return True + return False def _LineContainsPylintDisableLineTooLong(line): - """Return true if there is a "pylint: disable=line-too-long" comment.""" - return re.search(r'\bpylint:\s+disable=line-too-long\b', line.last.value) + """Return true if there is a "pylint: disable=line-too-long" comment.""" + return re.search(r'\bpylint:\s+disable=line-too-long\b', line.last.value) def _LineHasContinuationMarkers(line): - """Return true if the line has continuation markers in it.""" - return any(tok.is_continuation for tok in line.tokens) + """Return true if the line has continuation markers in it.""" + return any(tok.is_continuation for tok in line.tokens) def _CanPlaceOnSingleLine(line): - """Determine if the logical line can go on a single line. + """Determine if the logical line can go on a single line. Arguments: line: (logical_line.LogicalLine) The line currently being formatted. @@ -251,395 +253,377 @@ def _CanPlaceOnSingleLine(line): Returns: True if the line can or should be added to a single line. False otherwise. """ - token_names = [x.name for x in line.tokens] - 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_index = -1 - if (last.is_pylint_comment or last.is_pytype_comment or last.is_copybara_comment): - 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])) + token_names = [x.name for x in line.tokens] + 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_index = -1 + if (last.is_pylint_comment or last.is_pytype_comment or + last.is_copybara_comment): + 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])) def _AlignTrailingComments(final_lines): - """Align trailing comments to the same column.""" - final_lines_index = 0 - while final_lines_index < len(final_lines): - line = final_lines[final_lines_index] - assert line.tokens - - processed_content = False - - for tok in line.tokens: - if (tok.is_comment and isinstance(tok.spaces_required_before, list) and - tok.value.startswith('#')): - # All trailing comments and comments that appear on a line by themselves - # in this block should be indented at the same level. The block is - # terminated by an empty line or EOF. Enumerate through each line in - # the block and calculate the max line length. Once complete, use the - # 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 - - while True: - # EOF - if final_lines_index + len(all_pc_line_lengths) == len(final_lines): - break - - this_line = final_lines[final_lines_index + - len(all_pc_line_lengths)] - - # Blank line - note that content is preformatted so we don't need to - # worry about spaces/tabs; a blank line will always be '\n\n'. - assert this_line.tokens - if (all_pc_line_lengths and - this_line.tokens[0].formatted_whitespace_prefix.startswith( - '\n\n')): - break + """Align trailing comments to the same column.""" + final_lines_index = 0 + while final_lines_index < len(final_lines): + line = final_lines[final_lines_index] + assert line.tokens + + processed_content = False + + for tok in line.tokens: + if (tok.is_comment and isinstance(tok.spaces_required_before, list) and + tok.value.startswith('#')): + # All trailing comments and comments that appear on a line by themselves + # in this block should be indented at the same level. The block is + # terminated by an empty line or EOF. Enumerate through each line in + # the block and calculate the max line length. Once complete, use the + # 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 + + while True: + # EOF + if final_lines_index + len(all_pc_line_lengths) == len(final_lines): + break + + this_line = final_lines[final_lines_index + len(all_pc_line_lengths)] + + # Blank line - note that content is preformatted so we don't need to + # worry about spaces/tabs; a blank line will always be '\n\n'. + assert this_line.tokens + if (all_pc_line_lengths and + this_line.tokens[0].formatted_whitespace_prefix.startswith('\n\n') + ): + break - if this_line.disable: - all_pc_line_lengths.append([]) - continue + if this_line.disable: + all_pc_line_lengths.append([]) + continue - # Calculate the length of each line in this logical line. - line_content = '' - pc_line_lengths = [] + # Calculate the length of each line in this logical line. + line_content = '' + pc_line_lengths = [] - for line_tok in this_line.tokens: - whitespace_prefix = line_tok.formatted_whitespace_prefix + for line_tok in this_line.tokens: + whitespace_prefix = line_tok.formatted_whitespace_prefix - newline_index = whitespace_prefix.rfind('\n') - if newline_index != -1: - max_line_length = max(max_line_length, len(line_content)) - line_content = '' + newline_index = whitespace_prefix.rfind('\n') + if newline_index != -1: + max_line_length = max(max_line_length, len(line_content)) + line_content = '' - whitespace_prefix = whitespace_prefix[newline_index + 1:] + whitespace_prefix = whitespace_prefix[newline_index + 1:] - if line_tok.is_comment: - pc_line_lengths.append(len(line_content)) - else: - line_content += '{}{}'.format( - whitespace_prefix, line_tok.value) + if line_tok.is_comment: + pc_line_lengths.append(len(line_content)) + else: + line_content += '{}{}'.format(whitespace_prefix, line_tok.value) - if pc_line_lengths: - max_line_length = max(max_line_length, max(pc_line_lengths)) + if pc_line_lengths: + max_line_length = max(max_line_length, max(pc_line_lengths)) - all_pc_line_lengths.append(pc_line_lengths) + all_pc_line_lengths.append(pc_line_lengths) - # Calculate the aligned column value - max_line_length += 2 + # Calculate the aligned column value + max_line_length += 2 - aligned_col = None - for potential_col in tok.spaces_required_before: - if potential_col > max_line_length: - aligned_col = potential_col - break + aligned_col = None + for potential_col in tok.spaces_required_before: + if potential_col > max_line_length: + aligned_col = potential_col + break - if aligned_col is None: - aligned_col = max_line_length + if aligned_col is None: + aligned_col = max_line_length - # Update the comment token values based on the aligned values - for all_pc_line_lengths_index, pc_line_lengths in enumerate( - all_pc_line_lengths): - if not pc_line_lengths: - continue + # Update the comment token values based on the aligned values + for all_pc_line_lengths_index, pc_line_lengths in enumerate( + all_pc_line_lengths): + if not pc_line_lengths: + continue - this_line = final_lines[final_lines_index + - all_pc_line_lengths_index] + this_line = final_lines[final_lines_index + all_pc_line_lengths_index] - pc_line_length_index = 0 - for line_tok in this_line.tokens: - if line_tok.is_comment: - assert pc_line_length_index < len(pc_line_lengths) - assert pc_line_lengths[pc_line_length_index] < aligned_col + pc_line_length_index = 0 + for line_tok in this_line.tokens: + if line_tok.is_comment: + assert pc_line_length_index < len(pc_line_lengths) + assert pc_line_lengths[pc_line_length_index] < aligned_col - # Note that there may be newlines embedded in the comments, so - # we need to apply a whitespace prefix to each line. - whitespace = ' ' * ( - aligned_col - pc_line_lengths[pc_line_length_index] - 1) - pc_line_length_index += 1 + # Note that there may be newlines embedded in the comments, so + # we need to apply a whitespace prefix to each line. + whitespace = ' ' * ( + aligned_col - pc_line_lengths[pc_line_length_index] - 1) + pc_line_length_index += 1 - line_content = [] + line_content = [] - for comment_line_index, comment_line in enumerate( - line_tok.value.split('\n')): - line_content.append( - '{}{}'.format(whitespace, comment_line.strip())) + for comment_line_index, comment_line in enumerate( + line_tok.value.split('\n')): + line_content.append( + '{}{}'.format(whitespace, comment_line.strip())) - if comment_line_index == 0: - whitespace = ' ' * (aligned_col - 1) + if comment_line_index == 0: + whitespace = ' ' * (aligned_col - 1) - line_content = '\n'.join(line_content) + line_content = '\n'.join(line_content) - # Account for initial whitespace already slated for the - # beginning of the line. - existing_whitespace_prefix = \ - line_tok.formatted_whitespace_prefix.lstrip('\n') + # Account for initial whitespace already slated for the + # beginning of the line. + existing_whitespace_prefix = \ + line_tok.formatted_whitespace_prefix.lstrip('\n') - if line_content.startswith(existing_whitespace_prefix): - line_content = line_content[ - len(existing_whitespace_prefix):] + if line_content.startswith(existing_whitespace_prefix): + line_content = line_content[len(existing_whitespace_prefix):] - line_tok.value = line_content + line_tok.value = line_content - assert pc_line_length_index == len(pc_line_lengths) + assert pc_line_length_index == len(pc_line_lengths) - final_lines_index += len(all_pc_line_lengths) + final_lines_index += len(all_pc_line_lengths) - processed_content = True - break + processed_content = True + break - if not processed_content: - final_lines_index += 1 + if not processed_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! + """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 + 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 is 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 + 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 is 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 _FormatFinalLines(final_lines, verify): - """Compose the final output from the finalized lines.""" - formatted_code = [] - for line in final_lines: - formatted_line = [] - for tok in line.tokens: - if not tok.is_pseudo: - formatted_line.append(tok.formatted_whitespace_prefix) - formatted_line.append(tok.value) - elif (not tok.next_token.whitespace_prefix.startswith('\n') and - not tok.next_token.whitespace_prefix.startswith(' ')): - if (tok.previous_token.value == ':' or - tok.next_token.value not in ',}])'): - formatted_line.append(' ') - - formatted_code.append(''.join(formatted_line)) - if verify: - verifier.VerifyCode(formatted_code[-1]) - - return ''.join(formatted_code) + '\n' + """Compose the final output from the finalized lines.""" + formatted_code = [] + for line in final_lines: + formatted_line = [] + for tok in line.tokens: + if not tok.is_pseudo: + formatted_line.append(tok.formatted_whitespace_prefix) + formatted_line.append(tok.value) + elif (not tok.next_token.whitespace_prefix.startswith('\n') and + not tok.next_token.whitespace_prefix.startswith(' ')): + if (tok.previous_token.value == ':' or + tok.next_token.value not in ',}])'): + formatted_line.append(' ') + + formatted_code.append(''.join(formatted_line)) + if verify: + verifier.VerifyCode(formatted_code[-1]) + + return ''.join(formatted_code) + '\n' class _StateNode(object): - """An edge in the solution space from 'previous.state' to 'state'. + """An edge in the solution space from 'previous.state' to 'state'. Attributes: state: (format_decision_state.FormatDecisionState) The format decision state @@ -649,16 +633,16 @@ class _StateNode(object): previous: (_StateNode) The previous state node in the graph. """ - # TODO(morbo): Add a '__cmp__' method. + # TODO(morbo): Add a '__cmp__' method. - def __init__(self, state, newline, previous): - self.state = state.Clone() - self.newline = newline - self.previous = previous + def __init__(self, state, newline, previous): + self.state = state.Clone() + self.newline = newline + self.previous = previous - def __repr__(self): # pragma: no cover - return 'StateNode(state=[\n{0}\n], newline={1})'.format( - self.state, self.newline) + def __repr__(self): # pragma: no cover + return 'StateNode(state=[\n{0}\n], newline={1})'.format( + self.state, self.newline) # A tuple of (penalty, count) that is used to prioritize the BFS. In case of @@ -669,11 +653,12 @@ 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): - """Analyze the entire solution space starting from initial_state. + """Analyze the entire solution space starting from initial_state. This implements a variant of Dijkstra's algorithm on the graph that spans the solution space (LineStates are the nodes). The algorithm tries to find @@ -687,49 +672,49 @@ def _AnalyzeSolutionSpace(initial_state): Returns: True if a formatting solution was found. False otherwise. """ - count = 0 - seen = set() - p_queue = [] - - # Insert start element. - node = _StateNode(initial_state, False, None) - heapq.heappush(p_queue, _QueueItem(_OrderedPenalty(0, count), node)) - - count += 1 - while p_queue: - item = p_queue[0] - penalty = item.ordered_penalty.penalty - node = item.state_node - if not node.state.next_token: - break - heapq.heappop(p_queue) - - if count > 10000: - node.state.ignore_stack_for_comparison = True - - # Unconditionally add the state and check if it was present to avoid having - # to hash it twice in the common case (state hashing is expensive). - before_seen_count = len(seen) - seen.add(node.state) - # If seen didn't change size, the state was already present. - if before_seen_count == len(seen): - continue - - # FIXME(morbo): Add a 'decision' element? - - count = _AddNextStateToQueue(penalty, node, False, count, p_queue) - count = _AddNextStateToQueue(penalty, node, True, count, p_queue) + count = 0 + seen = set() + p_queue = [] + + # Insert start element. + node = _StateNode(initial_state, False, None) + heapq.heappush(p_queue, _QueueItem(_OrderedPenalty(0, count), node)) + + count += 1 + while p_queue: + item = p_queue[0] + penalty = item.ordered_penalty.penalty + node = item.state_node + if not node.state.next_token: + break + heapq.heappop(p_queue) + + if count > 10000: + node.state.ignore_stack_for_comparison = True + + # Unconditionally add the state and check if it was present to avoid having + # to hash it twice in the common case (state hashing is expensive). + before_seen_count = len(seen) + seen.add(node.state) + # If seen didn't change size, the state was already present. + if before_seen_count == len(seen): + continue + + # FIXME(morbo): Add a 'decision' element? + + count = _AddNextStateToQueue(penalty, node, False, count, p_queue) + count = _AddNextStateToQueue(penalty, node, True, count, p_queue) + + if not p_queue: + # We weren't able to find a solution. Do nothing. + return False - if not p_queue: - # We weren't able to find a solution. Do nothing. - return False - - _ReconstructPath(initial_state, heapq.heappop(p_queue).state_node) - return True + _ReconstructPath(initial_state, heapq.heappop(p_queue).state_node) + return True def _AddNextStateToQueue(penalty, previous_node, newline, count, p_queue): - """Add the following state to the analysis queue. + """Add the following state to the analysis queue. Assume the current state is 'previous_node' and has been reached with a penalty of 'penalty'. Insert a line break if 'newline' is True. @@ -745,23 +730,23 @@ def _AddNextStateToQueue(penalty, previous_node, newline, count, p_queue): Returns: The updated number of elements in the queue. """ - must_split = previous_node.state.MustSplit() - if newline and not previous_node.state.CanSplit(must_split): - # Don't add a newline if the token cannot be split. - return count - if not newline and must_split: - # Don't add a token we must split but where we aren't splitting. - return count + must_split = previous_node.state.MustSplit() + if newline and not previous_node.state.CanSplit(must_split): + # Don't add a newline if the token cannot be split. + return count + if not newline and must_split: + # Don't add a token we must split but where we aren't splitting. + return count - 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)) - return count + 1 + 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)) + return count + 1 def _ReconstructPath(initial_state, current): - """Reconstruct the path through the queue with lowest penalty. + """Reconstruct the path through the queue with lowest penalty. Arguments: initial_state: (format_decision_state.FormatDecisionState) The initial state @@ -769,21 +754,21 @@ def _ReconstructPath(initial_state, current): current: (_StateNode) The node in the decision graph that is the end point of the path with the least penalty. """ - path = collections.deque() + path = collections.deque() - while current.previous: - path.appendleft(current) - current = current.previous + while current.previous: + path.appendleft(current) + current = current.previous - for node in path: - initial_state.AddTokenToState(newline=node.newline, dry_run=False) + for node in path: + initial_state.AddTokenToState(newline=node.newline, dry_run=False) NESTED_DEPTH = [] def _FormatFirstToken(first_token, indent_depth, prev_line, final_lines): - """Format the first token in the logical line. + """Format the first token in the logical line. Add a newline and the required indent before the first token of the logical line. @@ -796,22 +781,22 @@ def _FormatFirstToken(first_token, indent_depth, prev_line, final_lines): final_lines: (list of logical_line.LogicalLine) The logical lines that have already been processed. """ - global NESTED_DEPTH - while NESTED_DEPTH and NESTED_DEPTH[-1] > indent_depth: - NESTED_DEPTH.pop() + global NESTED_DEPTH + while NESTED_DEPTH and NESTED_DEPTH[-1] > indent_depth: + NESTED_DEPTH.pop() - first_nested = False - if _IsClassOrDef(first_token): - if not NESTED_DEPTH: - NESTED_DEPTH = [indent_depth] - elif NESTED_DEPTH[-1] < indent_depth: - first_nested = True - NESTED_DEPTH.append(indent_depth) + first_nested = False + if _IsClassOrDef(first_token): + if not NESTED_DEPTH: + NESTED_DEPTH = [indent_depth] + elif NESTED_DEPTH[-1] < indent_depth: + first_nested = True + NESTED_DEPTH.append(indent_depth) - first_token.AddWhitespacePrefix( - _CalculateNumberOfNewlines( - first_token, indent_depth, prev_line, final_lines, first_nested), - indent_level=indent_depth) + first_token.AddWhitespacePrefix( + _CalculateNumberOfNewlines( + first_token, indent_depth, prev_line, final_lines, first_nested), + indent_level=indent_depth) NO_BLANK_LINES = 1 @@ -820,14 +805,15 @@ def _FormatFirstToken(first_token, indent_depth, prev_line, final_lines): 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') + if tok.value in {'class', 'def', '@'}: + return True + 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): - """Calculate the number of newlines we need to add. + first_token, indent_depth, prev_line, final_lines, first_nested): + """Calculate the number of newlines we need to add. Arguments: first_token: (format_token.FormatToken) The first token in the logical @@ -842,99 +828,102 @@ def _CalculateNumberOfNewlines( Returns: The number of newlines needed before the first token. """ - # TODO(morbo): Special handling for imports. - # TODO(morbo): Create a knob that can tune these. - if prev_line is None: - # The first line in the file. Don't add blank lines. - # FIXME(morbo): Is this correct? - if first_token.newlines is not None: - first_token.newlines = None - return 0 - - if first_token.is_docstring: - if (prev_line.first.value == 'class' and - style.Get('BLANK_LINE_BEFORE_CLASS_DOCSTRING')): - # Enforce a blank line before a class's docstring. - return ONE_BLANK_LINE - elif (prev_line.first.value.startswith('#') and - style.Get('BLANK_LINE_BEFORE_MODULE_DOCSTRING')): - # Enforce a blank line before a module's docstring. - return ONE_BLANK_LINE - # The docstring shouldn't have a newline before it. - return NO_BLANK_LINES + # TODO(morbo): Special handling for imports. + # TODO(morbo): Create a knob that can tune these. + if prev_line is None: + # The first line in the file. Don't add blank lines. + # FIXME(morbo): Is this correct? + if first_token.newlines is not None: + first_token.newlines = None + return 0 + + if first_token.is_docstring: + if (prev_line.first.value == 'class' and + style.Get('BLANK_LINE_BEFORE_CLASS_DOCSTRING')): + # Enforce a blank line before a class's docstring. + return ONE_BLANK_LINE + elif (prev_line.first.value.startswith('#') and + style.Get('BLANK_LINE_BEFORE_MODULE_DOCSTRING')): + # Enforce a blank line before a module's docstring. + return ONE_BLANK_LINE + # The docstring shouldn't have a newline before it. + return NO_BLANK_LINES - if first_token.is_name and not indent_depth: - if prev_line.first.value in {'from', 'import'}: - # Support custom number of blank lines between top-level imports and - # variable definitions. - return 1 + style.Get('BLANK_LINES_BETWEEN_TOP_LEVEL_IMPORTS_AND_VARIABLES') - - prev_last_token = prev_line.last - if prev_last_token.is_docstring: - if (not indent_depth and first_token.value in {'class', 'def', 'async'}): - # Separate a class or function from the module-level docstring with - # appropriate number of blank lines. - return 1 + style.Get('BLANK_LINES_AROUND_TOP_LEVEL_DEFINITION') - if (first_nested and not style.Get('BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF') and - _IsClassOrDef(first_token)): - first_token.newlines = None - return NO_BLANK_LINES + if first_token.is_name and not indent_depth: + if prev_line.first.value in {'from', 'import'}: + # Support custom number of blank lines between top-level imports and + # variable definitions. + return 1 + style.Get( + 'BLANK_LINES_BETWEEN_TOP_LEVEL_IMPORTS_AND_VARIABLES') + + prev_last_token = prev_line.last + if prev_last_token.is_docstring: + if (not indent_depth and first_token.value in {'class', 'def', 'async'}): + # Separate a class or function from the module-level docstring with + # appropriate number of blank lines. + return 1 + style.Get('BLANK_LINES_AROUND_TOP_LEVEL_DEFINITION') + if (first_nested and + not style.Get('BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF') and + _IsClassOrDef(first_token)): + first_token.newlines = None + return NO_BLANK_LINES + if _NoBlankLinesBeforeCurrentToken(prev_last_token.value, first_token, + prev_last_token): + return NO_BLANK_LINES + else: + return ONE_BLANK_LINE + + if _IsClassOrDef(first_token): + # TODO(morbo): This can go once the blank line calculator is more + # sophisticated. + if not indent_depth: + # This is a top-level class or function. + is_inline_comment = prev_last_token.whitespace_prefix.count('\n') == 0 + if (not prev_line.disable and prev_last_token.is_comment and + not is_inline_comment): + # This token follows a non-inline comment. if _NoBlankLinesBeforeCurrentToken(prev_last_token.value, first_token, prev_last_token): - return NO_BLANK_LINES - else: - return ONE_BLANK_LINE - - if _IsClassOrDef(first_token): - # TODO(morbo): This can go once the blank line calculator is more - # sophisticated. - if not indent_depth: - # This is a top-level class or function. - is_inline_comment = prev_last_token.whitespace_prefix.count('\n') == 0 - if (not prev_line.disable and prev_last_token.is_comment and - not is_inline_comment): - # This token follows a non-inline comment. - if _NoBlankLinesBeforeCurrentToken(prev_last_token.value, first_token, - prev_last_token): - # Assume that the comment is "attached" to the current line. - # Therefore, we want two blank lines before the comment. - index = len(final_lines) - 1 - while index > 0: - if not final_lines[index - 1].is_comment: - break - index -= 1 - if final_lines[index - 1].first.value == '@': - final_lines[index].first.AdjustNewlinesBefore(NO_BLANK_LINES) - else: - prev_last_token.AdjustNewlinesBefore( - 1 + style.Get('BLANK_LINES_AROUND_TOP_LEVEL_DEFINITION')) - if first_token.newlines is not None: - first_token.newlines = None - return NO_BLANK_LINES - elif _IsClassOrDef(prev_line.first): - if first_nested and not style.Get('BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF'): - first_token.newlines = None - return NO_BLANK_LINES - - # Calculate how many newlines were between the original lines. We want to - # retain that formatting if it doesn't violate one of the style guide rules. - if first_token.is_comment: - first_token_lineno = first_token.lineno - first_token.value.count('\n') - else: - first_token_lineno = first_token.lineno + # Assume that the comment is "attached" to the current line. + # Therefore, we want two blank lines before the comment. + index = len(final_lines) - 1 + while index > 0: + if not final_lines[index - 1].is_comment: + break + index -= 1 + if final_lines[index - 1].first.value == '@': + final_lines[index].first.AdjustNewlinesBefore(NO_BLANK_LINES) + else: + prev_last_token.AdjustNewlinesBefore( + 1 + style.Get('BLANK_LINES_AROUND_TOP_LEVEL_DEFINITION')) + if first_token.newlines is not None: + first_token.newlines = None + return NO_BLANK_LINES + elif _IsClassOrDef(prev_line.first): + if first_nested and not style.Get( + 'BLANK_LINE_BEFORE_NESTED_CLASS_OR_DEF'): + first_token.newlines = None + return NO_BLANK_LINES - prev_last_token_lineno = prev_last_token.lineno - if prev_last_token.is_multiline_string: - prev_last_token_lineno += prev_last_token.value.count('\n') + # Calculate how many newlines were between the original lines. We want to + # retain that formatting if it doesn't violate one of the style guide rules. + if first_token.is_comment: + first_token_lineno = first_token.lineno - first_token.value.count('\n') + else: + first_token_lineno = first_token.lineno - if first_token_lineno - prev_last_token_lineno > 1: - return ONE_BLANK_LINE + prev_last_token_lineno = prev_last_token.lineno + if prev_last_token.is_multiline_string: + prev_last_token_lineno += prev_last_token.value.count('\n') - return NO_BLANK_LINES + if first_token_lineno - prev_last_token_lineno > 1: + return ONE_BLANK_LINE + + return NO_BLANK_LINES def _SingleOrMergedLines(lines): - """Generate the lines we want to format. + """Generate the lines we want to format. Arguments: lines: (list of logical_line.LogicalLine) Lines we want to format. @@ -943,46 +932,46 @@ 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 - last_was_merged = False - while index < len(lines): - if lines[index].disable: - line = lines[index] - index += 1 - while index < len(lines): - column = line.last.column + 2 - if lines[index].lineno != line.lineno: - break - if line.last.value != ':': - leaf = pytree.Leaf( - type=token.SEMI, value=';', context=('', (line.lineno, column))) - line.AppendToken( - format_token.FormatToken(leaf, pytree_utils.NodeName(leaf))) - for tok in lines[index].tokens: - line.AppendToken(tok) - index += 1 - yield line - elif line_joiner.CanMergeMultipleLines(lines[index:], last_was_merged): - # TODO(morbo): This splice is potentially very slow. Come up with a more - # performance-friendly way of determining if two lines can be merged. - next_line = lines[index + 1] - for tok in next_line.tokens: - lines[index].AppendToken(tok) - if (len(next_line.tokens) == 1 and next_line.first.is_multiline_string): - # This may be a multiline shebang. In that case, we want to retain the - # formatting. Otherwise, it could mess up the shell script's syntax. - lines[index].disable = True - yield lines[index] - index += 2 - last_was_merged = True - else: - yield lines[index] - index += 1 - last_was_merged = False + index = 0 + last_was_merged = False + while index < len(lines): + if lines[index].disable: + line = lines[index] + index += 1 + while index < len(lines): + column = line.last.column + 2 + if lines[index].lineno != line.lineno: + break + if line.last.value != ':': + leaf = pytree.Leaf( + type=token.SEMI, value=';', context=('', (line.lineno, column))) + line.AppendToken( + format_token.FormatToken(leaf, pytree_utils.NodeName(leaf))) + for tok in lines[index].tokens: + line.AppendToken(tok) + index += 1 + yield line + elif line_joiner.CanMergeMultipleLines(lines[index:], last_was_merged): + # TODO(morbo): This splice is potentially very slow. Come up with a more + # performance-friendly way of determining if two lines can be merged. + next_line = lines[index + 1] + for tok in next_line.tokens: + lines[index].AppendToken(tok) + if (len(next_line.tokens) == 1 and next_line.first.is_multiline_string): + # This may be a multiline shebang. In that case, we want to retain the + # formatting. Otherwise, it could mess up the shell script's syntax. + lines[index].disable = True + yield lines[index] + index += 2 + last_was_merged = True + else: + yield lines[index] + index += 1 + last_was_merged = False def _NoBlankLinesBeforeCurrentToken(text, cur_token, prev_token): - """Determine if there are no blank lines before the current token. + """Determine if there are no blank lines before the current token. The previous token is a docstring or comment. The prev_token_lineno is the start of the text of that token. Counting the number of newlines in its text @@ -1000,8 +989,8 @@ def _NoBlankLinesBeforeCurrentToken(text, cur_token, prev_token): Returns: True if there is no blank line before the current token. """ - cur_token_lineno = cur_token.lineno - if cur_token.is_comment: - cur_token_lineno -= cur_token.value.count('\n') - num_newlines = text.count('\n') if not prev_token.is_comment else 0 - return prev_token.lineno + num_newlines == cur_token_lineno - 1 + cur_token_lineno = cur_token.lineno + if cur_token.is_comment: + cur_token_lineno -= cur_token.value.count('\n') + num_newlines = text.count('\n') if not prev_token.is_comment else 0 + return prev_token.lineno + num_newlines == cur_token_lineno - 1 diff --git a/yapf/yapflib/style.py b/yapf/yapflib/style.py index e1939e289..bfd19bdae 100644 --- a/yapf/yapflib/style.py +++ b/yapf/yapflib/style.py @@ -22,33 +22,33 @@ class StyleConfigError(errors.YapfError): - """Raised when there's a problem reading the style configuration.""" - pass + """Raised when there's a problem reading the style configuration.""" + pass def Get(setting_name): - """Get a style setting.""" - return _style[setting_name] + """Get a style setting.""" + return _style[setting_name] def GetOrDefault(setting_name, default_value): - """Get a style setting or default value if the setting does not exist.""" - return _style.get(setting_name, default_value) + """Get a style setting or default value if the setting does not exist.""" + return _style.get(setting_name, default_value) def Help(): - """Return dict mapping style names to help strings.""" - return _STYLE_HELP + """Return dict mapping style names to help strings.""" + return _STYLE_HELP def SetGlobalStyle(style): - """Set a style dict.""" - global _style - global _GLOBAL_STYLE_FACTORY - factory = _GetStyleFactory(style) - if factory: - _GLOBAL_STYLE_FACTORY = factory - _style = style + """Set a style dict.""" + global _style + global _GLOBAL_STYLE_FACTORY + factory = _GetStyleFactory(style) + if factory: + _GLOBAL_STYLE_FACTORY = factory + _style = style _STYLE_HELP = dict( @@ -355,7 +355,7 @@ def method(): a_very_long_statement_that_extends_beyond_the_final_column # Comment <-- the end of line comments are aligned based on the line length short # This is a shorter statement - """), # noqa + """), # noqa SPLIT_ARGUMENTS_WHEN_COMMA_TERMINATED =textwrap.dedent( """\ Split before arguments if the argument list is terminated by a @@ -398,7 +398,7 @@ def method(): foo = ('This is a really long string: {}, {}, {}, {}' .format(a, b, c, d)) - """), # noqa + """), # noqa SPLIT_BEFORE_EXPRESSION_AFTER_OPENING_PAREN =textwrap.dedent( """\ Split after the opening paren which surrounds an expression if it doesn't @@ -472,133 +472,134 @@ def method(): from a_very_long_or_indented_module_name_yada_yad import ( long_argument_1, long_argument_2, long_argument_3) - """), # noqa + """), # noqa 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', + # BASED_ON_STYLE='Which predefined style this style is based on', ) def CreatePEP8Style(): - """Create the PEP8 formatting style.""" - return dict( - ALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENT =True, - ALIGN_ARGUMENT_ASSIGNMENT =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, - ) + """Create the PEP8 formatting style.""" + return dict( + ALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENT =True, + ALIGN_ARGUMENT_ASSIGNMENT =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['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 - return style + """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['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 + return style def CreateYapfStyle(): - """Create the YAPF formatting style.""" - 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['SPLIT_BEFORE_EXPRESSION_AFTER_OPENING_PAREN'] = True - return style + """Create the YAPF formatting style.""" + 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['SPLIT_BEFORE_EXPRESSION_AFTER_OPENING_PAREN'] = True + return style def CreateFacebookStyle(): - """Create the Facebook formatting style.""" - 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 - return style + """Create the Facebook formatting style.""" + 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 + return style _STYLE_NAME_TO_FACTORY = dict( @@ -617,55 +618,55 @@ def CreateFacebookStyle(): def _GetStyleFactory(style): - for def_style, factory in _DEFAULT_STYLE_TO_FACTORY: - if style == def_style: - return factory - return None + for def_style, factory in _DEFAULT_STYLE_TO_FACTORY: + if style == def_style: + return factory + return None def _ContinuationAlignStyleStringConverter(s): - """Option value converter for a continuation align style string.""" - accepted_styles = ('SPACE', 'FIXED', 'VALIGN-RIGHT') - if s: - r = s.strip('"\'').replace('_', '-').upper() - if r not in accepted_styles: - raise ValueError('unknown continuation align style: %r' % (s,)) - else: - r = accepted_styles[0] - return r + """Option value converter for a continuation align style string.""" + accepted_styles = ('SPACE', 'FIXED', 'VALIGN-RIGHT') + if s: + r = s.strip('"\'').replace('_', '-').upper() + if r not in accepted_styles: + raise ValueError('unknown continuation align style: %r' % (s,)) + else: + r = accepted_styles[0] + return r def _StringListConverter(s): - """Option value converter for a comma-separated list of strings.""" - return [part.strip() for part in s.split(',')] + """Option value converter for a comma-separated list of strings.""" + return [part.strip() for part in s.split(',')] def _StringSetConverter(s): - """Option value converter for a comma-separated set of strings.""" - if len(s) > 2 and s[0] in '"\'': - s = s[1:-1] - return {part.strip() for part in s.split(',')} + """Option value converter for a comma-separated set of strings.""" + if len(s) > 2 and s[0] in '"\'': + s = s[1:-1] + return {part.strip() for part in s.split(',')} def _BoolConverter(s): - """Option value converter for a boolean.""" - return py3compat.CONFIGPARSER_BOOLEAN_STATES[s.lower()] + """Option value converter for a boolean.""" + return py3compat.CONFIGPARSER_BOOLEAN_STATES[s.lower()] def _IntListConverter(s): - """Option value converter for a comma-separated list of integers.""" - s = s.strip() - if s.startswith('[') and s.endswith(']'): - s = s[1:-1] + """Option value converter for a comma-separated list of integers.""" + s = s.strip() + if s.startswith('[') and s.endswith(']'): + s = s[1:-1] - return [int(part.strip()) for part in s.split(',') if part.strip()] + return [int(part.strip()) for part in s.split(',') if part.strip()] def _IntOrIntListConverter(s): - """Option value converter for an integer or list of integers.""" - if len(s) > 2 and s[0] in '"\'': - s = s[1:-1] - return _IntListConverter(s) if ',' in s else int(s) + """Option value converter for an integer or list of integers.""" + if len(s) > 2 and s[0] in '"\'': + s = s[1:-1] + return _IntListConverter(s) if ',' in s else int(s) # Different style options need to have their values interpreted differently when @@ -742,7 +743,7 @@ def _IntOrIntListConverter(s): def CreateStyleFromConfig(style_config): - """Create a style dict from the given config. + """Create a style dict from the given config. Arguments: style_config: either a style name or a file name. The file is expected to @@ -758,106 +759,107 @@ def CreateStyleFromConfig(style_config): StyleConfigError: if an unknown style option was encountered. """ - def GlobalStyles(): - for style, _ in _DEFAULT_STYLE_TO_FACTORY: - yield style - - def_style = False - if style_config is None: - for style in GlobalStyles(): - if _style == style: - def_style = True - break - if not def_style: - return _style - return _GLOBAL_STYLE_FACTORY() - - if isinstance(style_config, dict): - config = _CreateConfigParserFromConfigDict(style_config) - elif isinstance(style_config, py3compat.basestring): - style_factory = _STYLE_NAME_TO_FACTORY.get(style_config.lower()) - if style_factory is not None: - return style_factory() - if style_config.startswith('{'): - # Most likely a style specification from the command line. - config = _CreateConfigParserFromConfigString(style_config) - else: - # Unknown config name: assume it's a file name then. - config = _CreateConfigParserFromConfigFile(style_config) - return _CreateStyleFromConfigParser(config) + def GlobalStyles(): + for style, _ in _DEFAULT_STYLE_TO_FACTORY: + yield style + + def_style = False + if style_config is None: + for style in GlobalStyles(): + if _style == style: + def_style = True + break + if not def_style: + return _style + return _GLOBAL_STYLE_FACTORY() + + if isinstance(style_config, dict): + config = _CreateConfigParserFromConfigDict(style_config) + elif isinstance(style_config, py3compat.basestring): + style_factory = _STYLE_NAME_TO_FACTORY.get(style_config.lower()) + if style_factory is not None: + return style_factory() + if style_config.startswith('{'): + # Most likely a style specification from the command line. + config = _CreateConfigParserFromConfigString(style_config) + else: + # Unknown config name: assume it's a file name then. + config = _CreateConfigParserFromConfigFile(style_config) + return _CreateStyleFromConfigParser(config) def _CreateConfigParserFromConfigDict(config_dict): - config = py3compat.ConfigParser() - config.add_section('style') - for key, value in config_dict.items(): - config.set('style', key, str(value)) - return config + config = py3compat.ConfigParser() + config.add_section('style') + for key, value in config_dict.items(): + config.set('style', key, str(value)) + return config def _CreateConfigParserFromConfigString(config_string): - """Given a config string from the command line, return a config parser.""" - if config_string[0] != '{' or config_string[-1] != '}': - raise StyleConfigError("Invalid style dict syntax: '{}'.".format(config_string)) - config = py3compat.ConfigParser() - config.add_section('style') - for key, value, _ in re.findall( - r'([a-zA-Z0-9_]+)\s*[:=]\s*' - r'(?:' - r'((?P[\'"]).*?(?P=quote)|' - r'[a-zA-Z0-9_]+)' - r')', config_string): # yapf: disable - config.set('style', key, value) - return config + """Given a config string from the command line, return a config parser.""" + if config_string[0] != '{' or config_string[-1] != '}': + raise StyleConfigError( + "Invalid style dict syntax: '{}'.".format(config_string)) + config = py3compat.ConfigParser() + config.add_section('style') + for key, value, _ in re.findall( + r'([a-zA-Z0-9_]+)\s*[:=]\s*' + r'(?:' + r'((?P[\'"]).*?(?P=quote)|' + r'[a-zA-Z0-9_]+)' + r')', config_string): # yapf: disable + config.set('style', key, value) + return config def _CreateConfigParserFromConfigFile(config_filename): - """Read the file and return a ConfigParser object.""" - if not os.path.exists(config_filename): - # Provide a more meaningful error here. + """Read the file and return a ConfigParser object.""" + if not os.path.exists(config_filename): + # Provide a more meaningful error here. + raise StyleConfigError( + '"{0}" is not a valid style or file path'.format(config_filename)) + with open(config_filename) as style_file: + config = py3compat.ConfigParser() + if config_filename.endswith(PYPROJECT_TOML): + try: + import toml + except ImportError: + raise errors.YapfError( + "toml package is needed for using pyproject.toml as a " + "configuration file") + + pyproject_toml = toml.load(style_file) + 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)) + config.add_section('style') + for k, v in style_dict.items(): + config.set('style', k, str(v)) + return config + + config.read_file(style_file) + if config_filename.endswith(SETUP_CONFIG): + if not config.has_section('yapf'): raise StyleConfigError( - '"{0}" is not a valid style or file path'.format(config_filename)) - with open(config_filename) as style_file: - config = py3compat.ConfigParser() - if config_filename.endswith(PYPROJECT_TOML): - try: - import toml - except ImportError: - raise errors.YapfError( - "toml package is needed for using pyproject.toml as a " - "configuration file") - - pyproject_toml = toml.load(style_file) - 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)) - config.add_section('style') - for k, v in style_dict.items(): - config.set('style', k, str(v)) - return config - - config.read_file(style_file) - if config_filename.endswith(SETUP_CONFIG): - if not config.has_section('yapf'): - raise StyleConfigError( - 'Unable to find section [yapf] in {0}'.format(config_filename)) - return config - - if config_filename.endswith(LOCAL_STYLE): - if not config.has_section('style'): - raise StyleConfigError( - 'Unable to find section [style] in {0}'.format(config_filename)) - return config - - if not config.has_section('style'): - raise StyleConfigError( - 'Unable to find section [style] in {0}'.format(config_filename)) - return config + 'Unable to find section [yapf] in {0}'.format(config_filename)) + return config + + if config_filename.endswith(LOCAL_STYLE): + if not config.has_section('style'): + raise StyleConfigError( + 'Unable to find section [style] in {0}'.format(config_filename)) + return config + + if not config.has_section('style'): + raise StyleConfigError( + 'Unable to find section [style] in {0}'.format(config_filename)) + return config def _CreateStyleFromConfigParser(config): - """Create a style dict from a configuration file. + """Create a style dict from a configuration file. Arguments: config: a ConfigParser object. @@ -868,32 +870,32 @@ def _CreateStyleFromConfigParser(config): Raises: StyleConfigError: if an unknown style option was encountered. """ - # 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() - 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() - base_style = _STYLE_NAME_TO_FACTORY[based_on]() - else: - base_style = _GLOBAL_STYLE_FACTORY() - - # Read all options specified in the file and update the style. - for option, value in config.items(section): - if option.lower() == 'based_on_style': - # Now skip this one - we've already handled it and it's not one of the - # recognized style options. - continue - option = option.upper() - if option not in _STYLE_OPTION_VALUE_CONVERTER: - raise StyleConfigError('Unknown style option "{0}"'.format(option)) - try: - base_style[option] = _STYLE_OPTION_VALUE_CONVERTER[option](value) - except ValueError: - raise StyleConfigError( - "'{}' is not a valid setting for {}.".format(value, option)) - return base_style + # 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() + 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() + base_style = _STYLE_NAME_TO_FACTORY[based_on]() + else: + base_style = _GLOBAL_STYLE_FACTORY() + + # Read all options specified in the file and update the style. + for option, value in config.items(section): + if option.lower() == 'based_on_style': + # Now skip this one - we've already handled it and it's not one of the + # recognized style options. + continue + option = option.upper() + if option not in _STYLE_OPTION_VALUE_CONVERTER: + raise StyleConfigError('Unknown style option "{0}"'.format(option)) + try: + base_style[option] = _STYLE_OPTION_VALUE_CONVERTER[option](value) + except ValueError: + 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 diff --git a/yapf/yapflib/yapf_api.py b/yapf/yapflib/yapf_api.py index c17451434..f53e08afe 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: @@ -92,18 +93,18 @@ def FormatFile(filename, original_source, newline, encoding = ReadFile(filename, logger) 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') 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,8 +230,8 @@ 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) @@ -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 @@ -302,17 +305,19 @@ def _MarkLinesToFormat(llines, lines): 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'): 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..520c1ef53 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 @@ -138,7 +142,8 @@ def testInlineAfterSeparateLine(self): 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,7 +161,8 @@ def testSeparateLineAfterInline(self): 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 @@ -257,7 +267,8 @@ def foo(): pass 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 @@ -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): @@ -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..cbd1c1b05 100644 --- a/yapftests/file_resources_test.py +++ b/yapftests/file_resources_test.py @@ -167,12 +167,12 @@ 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 @@ -186,8 +186,8 @@ def test_setup_config(self): # 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 @@ -206,8 +206,8 @@ def test_pyproject_toml(self): # 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. @@ -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)]) diff --git a/yapftests/format_token_test.py b/yapftests/format_token_test.py index 3bb1ce9f5..292059721 100644 --- a/yapftests/format_token_test.py +++ b/yapftests/format_token_test.py @@ -99,18 +99,19 @@ def testIsMultilineString(self): child2 = pytree.Leaf(token.EQUAL, '=') child3 = pytree.Leaf(token.STRING, "'hello world'") child4 = pytree.Leaf(token.COMMA, ',') - child5 = pytree.Leaf(token.COMMENT,'# comment') + 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..7960eb236 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()) diff --git a/yapftests/main_test.py b/yapftests/main_test.py index c83b8b66a..4258c311f 100644 --- a/yapftests/main_test.py +++ b/yapftests/main_test.py @@ -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..439615f17 100644 --- a/yapftests/pytree_unwrapper_test.py +++ b/yapftests/pytree_unwrapper_test.py @@ -43,17 +43,19 @@ 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""" @@ -61,51 +63,59 @@ def testSimpleMultilineStatement(self): 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""" 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..1b4940eaf 100644 --- a/yapftests/pytree_utils_test.py +++ b/yapftests/pytree_utils_test.py @@ -89,10 +89,10 @@ def _BuildSimpleTree(self): # 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]) + 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,13 +102,13 @@ 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 @@ -122,13 +122,13 @@ 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 @@ -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/reformatter_basic_test.py b/yapftests/reformatter_basic_test.py index 3e242dd6e..36103c8f7 100644 --- a/yapftests/reformatter_basic_test.py +++ b/yapftests/reformatter_basic_test.py @@ -25,63 +25,63 @@ class BasicReformatterTest(yapf_test_helper.YAPFTest): - @classmethod - def setUpClass(cls): - style.SetGlobalStyle(style.CreateYapfStyle()) - - def testSplittingAllArgs(self): - style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{split_all_comma_separated_values: true, column_limit: 40}')) - unformatted_code = textwrap.dedent( - """\ + @classmethod + def setUpClass(cls): + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testSplittingAllArgs(self): + style.SetGlobalStyle( + style.CreateStyleFromConfig( + '{split_all_comma_separated_values: true, column_limit: 40}')) + unformatted_code = textwrap.dedent( + """\ responseDict = {"timestamp": timestamp, "someValue": value, "whatever": 120} - """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ responseDict = { "timestamp": timestamp, "someValue": value, "whatever": 120 } """) - 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)) - 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', } """) - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent( - """\ + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + 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( - """\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ def foo(long_arg, really_long_arg, really_really_long_arg, cant_keep_all_these_args): pass """) - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent( - """\ + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + 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( - """\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ foo_tuple = [ long_arg, really_long_arg, @@ -89,78 +89,78 @@ def foo(long_arg, cant_keep_all_these_args ] """) - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - unformatted_code = textwrap.dedent( - """\ + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + 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( - """\ + 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( + """\ 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) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - - def testSplittingTopLevelAllArgs(self): - style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{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( - """\ + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + + def testSplittingTopLevelAllArgs(self): + style.SetGlobalStyle( + style.CreateStyleFromConfig( + '{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( + """\ responseDict = {"timestamp": timestamp, "someValue": value, "whatever": 120} - """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ responseDict = { "timestamp": timestamp, "someValue": value, "whatever": 120 } """) - 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( - """\ + 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( + """\ def foo(long_arg, really_long_arg, really_really_long_arg, cant_keep_all_these_args): pass - """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ def foo(long_arg, really_long_arg, really_really_long_arg, cant_keep_all_these_args): pass """) - 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( - """\ + 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( + """\ foo_tuple = [long_arg, really_long_arg, really_really_long_arg, cant_keep_all_these_args] - """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ foo_tuple = [ long_arg, really_long_arg, @@ -168,69 +168,69 @@ def foo(long_arg, cant_keep_all_these_args ] """) - 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( - """\ + 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( + """\ 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( - """\ + 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( + """\ 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) - actual_formatted_code = reformatter.Reformat(llines) - self.assertEqual(40, len(actual_formatted_code.splitlines()[-1])) - self.assertCodeEqual(expected_formatted_code, actual_formatted_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, this_will_not_fit_xxxxxxxxx)) """) - 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)) - # Exercise the case where there's no opening bracket (for a, b) - unformatted_code = textwrap.dedent( - """\ + # Exercise the case where there's no opening bracket (for a, b) + 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) """) - 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)) - # Don't require splitting before comments. - unformatted_code = textwrap.dedent( - """\ + # Don't require splitting before comments. + unformatted_code = textwrap.dedent( + """\ KO = { 'ABC': Abc, # abc 'DEF': Def, # def @@ -239,8 +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 @@ -249,12 +249,12 @@ def foo(long_arg, 'JKL': Jkl, } """) - 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)) - def testSimpleFunctionsWithTrailingComments(self): - unformatted_code = textwrap.dedent( - """\ + def testSimpleFunctionsWithTrailingComments(self): + unformatted_code = textwrap.dedent( + """\ def g(): # Trailing comment if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): @@ -266,8 +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'): @@ -280,143 +280,144 @@ def f( # Intermediate comment xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'): pass """) - 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)) - def testBlankLinesBetweenTopLevelImportsAndVariables(self): - unformatted_code = textwrap.dedent( - """\ + def testBlankLinesBetweenTopLevelImportsAndVariables(self): + 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' """) - 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)) - 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' """) - try: - style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{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)) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) - - unformatted_code = textwrap.dedent( - """\ + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig( + '{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)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + 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)) + 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 class Baz(): pass """) - 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)) - 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 def foobar(): pass """) - 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)) - 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() """) - 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)) - def testBlankLinesAtEndOfFile(self): - unformatted_code = textwrap.dedent( - """\ + def testBlankLinesAtEndOfFile(self): + 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)) + 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)) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - def testIndentBlankLines(self): - unformatted_code = textwrap.dedent( - """\ + def testIndentBlankLines(self): + unformatted_code = textwrap.dedent( + """\ class foo(object): def foobar(self): @@ -434,28 +435,29 @@ def bar(): return 0 """) - expected_formatted_code = """\ + expected_formatted_code = """\ class foo(object):\n \n def foobar(self):\n \n pass\n \n def barfoo(self, x, y): # bar\n \n if x:\n \n return y\n\n\ndef bar():\n \n return 0 """ # noqa - try: - style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{based_on_style: yapf, indent_blank_lines: true}')) - - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) - - 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( - """\ + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig( + '{based_on_style: yapf, indent_blank_lines: true}')) + + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + 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( + """\ x = { 'a':37,'b':42, 'c':927} @@ -471,8 +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' @@ -492,12 +494,12 @@ def g(self, x, y=42): def f(a): return 37 + -+a[42 - x:y**3] """) - 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)) - def testComments(self): - unformatted_code = textwrap.dedent( - """\ + def testComments(self): + unformatted_code = textwrap.dedent( + """\ class Foo(object): pass @@ -519,8 +521,8 @@ class Baz(object): class Qux(object): pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent( + """\ class Foo(object): pass @@ -547,31 +549,31 @@ class Baz(object): class Qux(object): pass """) - 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)) - def testSingleComment(self): - code = textwrap.dedent("""\ + def testSingleComment(self): + code = textwrap.dedent("""\ # Thing 1 """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testCommentsWithTrailingSpaces(self): - unformatted_code = textwrap.dedent( - """\ + def testCommentsWithTrailingSpaces(self): + unformatted_code = textwrap.dedent( + """\ # Thing 1 \n# Thing 2 \n""") - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent( + """\ # Thing 1 # Thing 2 """) - 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)) - def testCommentsInDataLiteral(self): - code = textwrap.dedent( - """\ + def testCommentsInDataLiteral(self): + code = textwrap.dedent( + """\ def f(): return collections.OrderedDict({ # First comment. @@ -584,22 +586,22 @@ def f(): # Ending comment. }) """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testEndingWhitespaceAfterSimpleStatement(self): - code = textwrap.dedent( - """\ + def testEndingWhitespaceAfterSimpleStatement(self): + code = textwrap.dedent( + """\ import foo as bar # Thing 1 # Thing 2 """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testDocstrings(self): - unformatted_code = textwrap.dedent( - '''\ + def testDocstrings(self): + unformatted_code = textwrap.dedent( + '''\ u"""Module-level docstring.""" import os class Foo(object): @@ -616,8 +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 @@ -634,12 +636,12 @@ def qux(self): print('hello {}'.format('world')) return 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)) - def testDocstringAndMultilineComment(self): - unformatted_code = textwrap.dedent( - '''\ + def testDocstringAndMultilineComment(self): + unformatted_code = textwrap.dedent( + '''\ """Hello world""" # A multiline # comment @@ -653,8 +655,8 @@ def foo(self): # comment pass ''') - expected_formatted_code = textwrap.dedent( - '''\ + expected_formatted_code = textwrap.dedent( + '''\ """Hello world""" @@ -671,12 +673,12 @@ def foo(self): # comment pass ''') - 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)) - def testMultilineDocstringAndMultilineComment(self): - unformatted_code = textwrap.dedent( - '''\ + def testMultilineDocstringAndMultilineComment(self): + unformatted_code = textwrap.dedent( + '''\ """Hello world RIP Dennis Richie. @@ -699,8 +701,8 @@ def foo(self): # comment pass ''') - expected_formatted_code = textwrap.dedent( - '''\ + expected_formatted_code = textwrap.dedent( + '''\ """Hello world RIP Dennis Richie. @@ -726,40 +728,40 @@ def foo(self): # comment pass ''') - 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)) - def testTupleCommaBeforeLastParen(self): - unformatted_code = textwrap.dedent("""\ + def testTupleCommaBeforeLastParen(self): + 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)) + 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( - """\ + def testNoBreakOutsideOfBracket(self): + # FIXME(morbo): How this is formatted is not correct. But it's syntactically + # correct. + 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) - """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - def testBlankLinesBeforeDecorators(self): - unformatted_code = textwrap.dedent( - """\ + def testBlankLinesBeforeDecorators(self): + unformatted_code = textwrap.dedent( + """\ @foo() class A(object): @bar() @@ -767,8 +769,8 @@ class A(object): def x(self): pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent( + """\ @foo() class A(object): @@ -777,90 +779,90 @@ class A(object): def x(self): pass """) - 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)) - def testCommentBetweenDecorators(self): - unformatted_code = textwrap.dedent( - """\ + def testCommentBetweenDecorators(self): + unformatted_code = textwrap.dedent( + """\ @foo() # frob @bar def x (self): pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent( + """\ @foo() # frob @bar def x(self): pass """) - 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)) - def testListComprehension(self): - unformatted_code = textwrap.dedent( - """\ + def testListComprehension(self): + 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] """) - 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)) - def testListComprehensionPreferOneLine(self): - unformatted_code = textwrap.dedent( - """\ + def testListComprehensionPreferOneLine(self): + 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 ] """) - 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)) - def testListComprehensionPreferOneLineOverArithmeticSplit(self): - unformatted_code = textwrap.dedent( - """\ + def testListComprehensionPreferOneLineOverArithmeticSplit(self): + 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( - """\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ def given(used_identifiers): return (sum(len(identifier) for identifier in used_identifiers) / len(used_identifiers)) """) - 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)) - def testListComprehensionPreferThreeLinesForLineWrap(self): - unformatted_code = textwrap.dedent( - """\ + def testListComprehensionPreferThreeLinesForLineWrap(self): + 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 @@ -868,36 +870,36 @@ def given(y): if long_var_name == 2 and number_two == 3 ] """) - 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)) - def testListComprehensionPreferNoBreakForTrivialExpression(self): - unformatted_code = textwrap.dedent( - """\ + def testListComprehensionPreferNoBreakForTrivialExpression(self): + 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 () if long_var_name == 2 and number_two == 3 ] """) - 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)) - def testOpeningAndClosingBrackets(self): - unformatted_code = """\ + def testOpeningAndClosingBrackets(self): + unformatted_code = """\ foo( (1, ) ) foo( ( 1, 2, 3 ) ) foo( ( 1, 2, 3, ) ) """ - expected_formatted_code = """\ + expected_formatted_code = """\ foo((1,)) foo((1, 2, 3)) foo(( @@ -906,105 +908,105 @@ def testOpeningAndClosingBrackets(self): 3, )) """ - 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)) - def testSingleLineFunctions(self): - unformatted_code = textwrap.dedent( - """\ + def testSingleLineFunctions(self): + unformatted_code = textwrap.dedent( + """\ def foo(): return 42 """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent( + """\ def foo(): return 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)) - 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 = """\ + 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 = """\ find_symbol(node.type) + "< " + " ".join(find_pattern(n) for n in node.child) + " >" """ # noqa - expected_formatted_code = """\ + expected_formatted_code = """\ find_symbol(node.type) + "< " + " ".join( find_pattern(n) for n in node.child) + " >" """ - 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)) - def testNoSpacesBetweenSubscriptsAndCalls(self): - unformatted_code = textwrap.dedent( - """\ + def testNoSpacesBetweenSubscriptsAndCalls(self): + 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) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - def testNoSpacesBetweenOpeningBracketAndStartingOperator(self): - # Unary operator. - unformatted_code = textwrap.dedent( - """\ + def testNoSpacesBetweenOpeningBracketAndStartingOperator(self): + # Unary operator. + 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)) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - # Varargs and kwargs. - unformatted_code = textwrap.dedent( - """\ + # Varargs and kwargs. + 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) """) - 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)) - def testMultilineCommentReformatted(self): - unformatted_code = textwrap.dedent( - """\ + def testMultilineCommentReformatted(self): + 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. pass """) - 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)) - def testDictionaryMakerFormatting(self): - unformatted_code = textwrap.dedent( - """\ + def testDictionaryMakerFormatting(self): + 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', 'yield_stmt': 'import_stmt', lambda: 'global_stmt': 'exec_stmt', 'assert_stmt': 'if_stmt', 'while_stmt': 'for_stmt', }) - """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ _PYTHON_STATEMENTS = frozenset({ lambda x, y: 'simple_stmt': 'small_stmt', 'expr_stmt': 'print_stmt', @@ -1017,32 +1019,32 @@ def testDictionaryMakerFormatting(self): 'while_stmt': 'for_stmt', }) """) - 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)) - def testSimpleMultilineCode(self): - unformatted_code = textwrap.dedent( - """\ + def testSimpleMultilineCode(self): + 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) aaaaaaaaaaaaaa.bbbbbbbbbbbbbb.ccccccc(zzzzzzzzzzzz, xxxxxxxxxxx, yyyyyyyyyyyy, vvvvvvvvv) - """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - def testMultilineComment(self): - code = textwrap.dedent( - """\ + def testMultilineComment(self): + code = textwrap.dedent( + """\ if Foo: # Hello world # Yo man. @@ -1051,19 +1053,19 @@ def testMultilineComment(self): # Yo man. a = 42 """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testSpaceBetweenStringAndParentheses(self): - code = textwrap.dedent("""\ + def testSpaceBetweenStringAndParentheses(self): + code = textwrap.dedent("""\ b = '0' ('hello') """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testMultilineString(self): - code = textwrap.dedent( - """\ + def testMultilineString(self): + code = textwrap.dedent( + """\ code = textwrap.dedent('''\ if Foo: # Hello world @@ -1074,11 +1076,11 @@ def testMultilineString(self): a = 42 ''') """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + 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"]+"""
@@ -1086,9 +1088,9 @@ def f(): Residence: """+palace["Winter"]+"""
""" - ''') # noqa - expected_formatted_code = textwrap.dedent( - '''\ + ''') # noqa + 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"] + """
@@ -1096,13 +1098,13 @@ def f(): Residence: """ + palace["Winter"] + """
""" - ''') # noqa - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + ''') # noqa + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - def testSimpleMultilineWithComments(self): - code = textwrap.dedent( - """\ + def testSimpleMultilineWithComments(self): + code = textwrap.dedent( + """\ if ( # This is the first comment a and # This is the second comment # This is the third comment @@ -1110,28 +1112,28 @@ def testSimpleMultilineWithComments(self): # Whoa! A normal comment!! pass # Another trailing comment """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testMatchingParenSplittingMatching(self): - unformatted_code = textwrap.dedent( - """\ + def testMatchingParenSplittingMatching(self): + 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,)) """) - 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)) - def testContinuationIndent(self): - unformatted_code = textwrap.dedent( - '''\ + def testContinuationIndent(self): + unformatted_code = textwrap.dedent( + '''\ class F: def _ProcessArgLists(self, node): """Common method for processing argument lists.""" @@ -1141,8 +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): @@ -1153,19 +1155,19 @@ def _ProcessArgLists(self, node): child, subtype=_ARGLIST_TOKEN_TO_SUBTYPE.get(child.value, format_token.Subtype.NONE)) - ''') # noqa - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + ''') # noqa + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - def testTrailingCommaAndBracket(self): - unformatted_code = textwrap.dedent( - '''\ + def testTrailingCommaAndBracket(self): + unformatted_code = textwrap.dedent( + '''\ a = { 42, } b = ( 42, ) c = [ 42, ] ''') - expected_formatted_code = textwrap.dedent( - '''\ + expected_formatted_code = textwrap.dedent( + '''\ a = { 42, } @@ -1174,27 +1176,27 @@ def testTrailingCommaAndBracket(self): 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)) - def testI18n(self): - code = textwrap.dedent( - """\ + def testI18n(self): + 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)) + """) # 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)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testI18nCommentsInDataLiteral(self): - code = textwrap.dedent( - """\ + def testI18nCommentsInDataLiteral(self): + code = textwrap.dedent( + """\ def f(): return collections.OrderedDict({ #. First i18n comment. @@ -1204,12 +1206,12 @@ def f(): 'snork': 'bar#.*=\\\\0', }) """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testClosingBracketIndent(self): - code = textwrap.dedent( - '''\ + def testClosingBracketIndent(self): + code = textwrap.dedent( + '''\ def f(): def g(): @@ -1217,13 +1219,13 @@ def g(): xxxxxxxxxxxxxxxxxxxxx( yyyyyyyyyyyyy[zzzzz].aaaaaaaa[0]) == 'bbbbbbb'): pass - ''') # noqa - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + ''') # noqa + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testClosingBracketsInlinedInCall(self): - unformatted_code = textwrap.dedent( - """\ + def testClosingBracketsInlinedInCall(self): + unformatted_code = textwrap.dedent( + """\ class Foo(object): def bar(self): @@ -1237,8 +1239,8 @@ def bar(self): "porkporkpork": 5, }) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent( + """\ class Foo(object): def bar(self): @@ -1252,12 +1254,12 @@ def bar(self): "porkporkpork": 5, }) """) - 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)) - def testLineWrapInForExpression(self): - code = textwrap.dedent( - """\ + def testLineWrapInForExpression(self): + code = textwrap.dedent( + """\ class A: def x(self, node, name, n=1): @@ -1266,11 +1268,11 @@ def x(self, node, name, n=1): node.pre_order())): pass """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testFunctionCallContinuationLine(self): - code = """\ + def testFunctionCallContinuationLine(self): + code = """\ class foo: def bar(self, node, name, n=1): @@ -1280,33 +1282,34 @@ def bar(self, node, name, n=1): bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb( cccc, ddddddddddddddddddddddddddddddddddddd))] """ - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testI18nNonFormatting(self): - code = textwrap.dedent( - """\ + def testI18nNonFormatting(self): + code = textwrap.dedent( + """\ class F(object): def __init__(self, fieldname, #. Error message indicating an invalid e-mail address. message=N_('Please check your email address.'), **kwargs): pass - """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testNoSpaceBetweenUnaryOpAndOpeningParen(self): - code = textwrap.dedent("""\ + def testNoSpaceBetweenUnaryOpAndOpeningParen(self): + code = textwrap.dedent( + """\ if ~(a or b): pass """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testCommentBeforeFuncDef(self): - code = textwrap.dedent( - """\ + def testCommentBeforeFuncDef(self): + code = textwrap.dedent( + """\ class Foo(object): a = 42 @@ -1320,12 +1323,12 @@ def __init__(self, bbbbbbbbbbbbbbb=False): pass """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testExcessLineCountWithDefaultKeywords(self): - unformatted_code = textwrap.dedent( - """\ + def testExcessLineCountWithDefaultKeywords(self): + unformatted_code = textwrap.dedent( + """\ class Fnord(object): def Moo(self): aaaaaaaaaaaaaaaa = self._bbbbbbbbbbbbbbbbbbbbbbb( @@ -1333,8 +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): @@ -1347,21 +1350,21 @@ def Moo(self): hhhhhhhhhhhhh=hhhhhhhhhhhhh, iiiiiii=iiiiiiiiiiiiii) """) - 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)) - def testSpaceAfterNotOperator(self): - code = textwrap.dedent( - """\ + def testSpaceAfterNotOperator(self): + code = textwrap.dedent( + """\ if not (this and that): pass """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testNoPenaltySplitting(self): - code = textwrap.dedent( - """\ + def testNoPenaltySplitting(self): + code = textwrap.dedent( + """\ def f(): if True: if True: @@ -1370,32 +1373,32 @@ def f(): for f in os.listdir(filename) if IsPythonFile(os.path.join(filename, f))) """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testExpressionPenalties(self): - code = textwrap.dedent( - """\ + def testExpressionPenalties(self): + code = textwrap.dedent( + """\ def f(): if ((left.value == '(' and right.value == ')') or (left.value == '[' and right.value == ']') or (left.value == '{' and right.value == '}')): return False """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testLineDepthOfSingleLineStatement(self): - unformatted_code = textwrap.dedent( - """\ + def testLineDepthOfSingleLineStatement(self): + 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): @@ -1407,17 +1410,17 @@ def testLineDepthOfSingleLineStatement(self): with open(a) as fd: a = fd.read() """) - 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)) - def testSplitListWithTerminatingComma(self): - unformatted_code = textwrap.dedent( - """\ + def testSplitListWithTerminatingComma(self): + 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', @@ -1432,12 +1435,12 @@ def testSplitListWithTerminatingComma(self): lambda a, b: 37, ] """) - 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)) - def testSplitListWithInterspersedComments(self): - code = textwrap.dedent( - """\ + def testSplitListWithInterspersedComments(self): + code = textwrap.dedent( + """\ FOO = [ 'bar', # bar 'baz', # baz @@ -1452,36 +1455,36 @@ def testSplitListWithInterspersedComments(self): lambda a, b: 37 # lambda ] """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testRelativeImportStatements(self): - code = textwrap.dedent("""\ + def testRelativeImportStatements(self): + code = textwrap.dedent("""\ from ... import bork """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testSingleLineList(self): - # A list on a single line should prefer to remain contiguous. - unformatted_code = textwrap.dedent( - """\ + def testSingleLineList(self): + # A list on a single line should prefer to remain contiguous. + unformatted_code = textwrap.dedent( + """\ bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = aaaaaaaaaaa( ("...", "."), "..", ".............................................." ) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent( + """\ bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = aaaaaaaaaaa( ("...", "."), "..", "..............................................") - """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - def testBlankLinesBeforeFunctionsNotInColumnZero(self): - unformatted_code = textwrap.dedent( - """\ + def testBlankLinesBeforeFunctionsNotInColumnZero(self): + unformatted_code = textwrap.dedent( + """\ import signal @@ -1496,8 +1499,8 @@ def timeout(seconds=1): except: pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent( + """\ import signal try: @@ -1511,13 +1514,13 @@ def timeout(seconds=1): pass except: pass - """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - def testNoKeywordArgumentBreakage(self): - code = textwrap.dedent( - """\ + def testNoKeywordArgumentBreakage(self): + code = textwrap.dedent( + """\ class A(object): def b(self): @@ -1525,22 +1528,22 @@ def b(self): cccccccccccccccccccc=True): pass """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testTrailerOnSingleLine(self): - code = """\ + def testTrailerOnSingleLine(self): + code = """\ urlpatterns = patterns('', url(r'^$', 'homepage_view'), url(r'^/login/$', 'login_view'), url(r'^/login/$', 'logout_view'), url(r'^/user/(?P\\w+)/$', 'profile_view')) """ - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testIfConditionalParens(self): - code = textwrap.dedent( - """\ + def testIfConditionalParens(self): + code = textwrap.dedent( + """\ class Foo: def bar(): @@ -1549,87 +1552,87 @@ def bar(): child.value in substatement_names): pass """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testContinuationMarkers(self): - code = textwrap.dedent( - """\ + def testContinuationMarkers(self): + 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 "\\ "sit amet vitae augue. Nam tincidunt congue enim, ut porta lorem lacinia consectetur. "\\ "Donec ut libero sed arcu vehicula ultricies a non tortor. Lorem ipsum dolor sit amet" - """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + """) # noqa + 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)) + """) # 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 """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testCommentsWithContinuationMarkers(self): - code = textwrap.dedent( - """\ + def testCommentsWithContinuationMarkers(self): + code = textwrap.dedent( + """\ def fn(arg): v = fn2(key1=True, #c1 key2=arg)\\ .fn3() """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testMultipleContinuationMarkers(self): - code = textwrap.dedent( - """\ + def testMultipleContinuationMarkers(self): + code = textwrap.dedent( + """\ xyz = \\ \\ some_thing() """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testContinuationMarkerAfterStringWithContinuation(self): - code = """\ + def testContinuationMarkerAfterStringWithContinuation(self): + code = """\ s = 'foo \\ bar' \\ .format() """ - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testEmptyContainers(self): - code = textwrap.dedent( - """\ + def testEmptyContainers(self): + code = textwrap.dedent( + """\ flags.DEFINE_list( 'output_dirs', [], 'Lorem ipsum dolor sit amet, consetetur adipiscing elit. Donec a diam lectus. ' 'Sed sit amet ipsum mauris. Maecenas congue.') - """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testSplitStringsIfSurroundedByParens(self): - unformatted_code = textwrap.dedent( - """\ + def testSplitStringsIfSurroundedByParens(self): + unformatted_code = textwrap.dedent( + """\ a = foo.bar({'xxxxxxxxxxxxxxxxxxxxxxx' 'yyyyyyyyyyyyyyyyyyyyyyyyyy': baz[42]} + 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' 'bbbbbbbbbbbbbbbbbbbbbbbbbb' 'cccccccccccccccccccccccccccccccc' 'ddddddddddddddddddddddddddddd') - """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ a = foo.bar({'xxxxxxxxxxxxxxxxxxxxxxx' 'yyyyyyyyyyyyyyyyyyyyyyyyyy': baz[42]} + 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' @@ -1637,21 +1640,21 @@ def testSplitStringsIfSurroundedByParens(self): 'cccccccccccccccccccccccccccccccc' 'ddddddddddddddddddddddddddddd') """) - 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)) - code = textwrap.dedent( - """\ + code = textwrap.dedent( + """\ a = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' \ 'bbbbbbbbbbbbbbbbbbbbbbbbbb' 'cccccccccccccccccccccccccccccccc' \ 'ddddddddddddddddddddddddddddd' """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testMultilineShebang(self): - code = textwrap.dedent( - """\ + def testMultilineShebang(self): + code = textwrap.dedent( + """\ #!/bin/sh if "true" : '''\' then @@ -1667,30 +1670,30 @@ def testMultilineShebang(self): assert os.environ['FOO'] == '123' """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testNoSplittingAroundTermOperators(self): - code = textwrap.dedent( - """\ + def testNoSplittingAroundTermOperators(self): + code = textwrap.dedent( + """\ a_very_long_function_call_yada_yada_etc_etc_etc(long_arg1, long_arg2 / long_arg3) """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testNoSplittingAroundCompOperators(self): - code = textwrap.dedent( - """\ + def testNoSplittingAroundCompOperators(self): + code = textwrap.dedent( + """\ c = (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa is not bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) c = (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa in bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) c = (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not in bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) c = (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa is bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) c = (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <= bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) - """) # noqa - expected_code = textwrap.dedent( - """\ + """) # noqa + expected_code = textwrap.dedent( + """\ c = ( aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa is not bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) @@ -1708,43 +1711,43 @@ def testNoSplittingAroundCompOperators(self): aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <= bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) - def testNoSplittingWithinSubscriptList(self): - code = textwrap.dedent( - """\ + def testNoSplittingWithinSubscriptList(self): + code = textwrap.dedent( + """\ somequitelongvariablename.somemember[(a, b)] = { 'somelongkey': 1, 'someotherlongkey': 2 } """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testExcessCharacters(self): - code = textwrap.dedent( - """\ + def testExcessCharacters(self): + code = textwrap.dedent( + """\ class foo: 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)) + """) # noqa + 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( - """\ + """) # noqa + expected_code = textwrap.dedent( + """\ def _(): if True: if True: @@ -1752,48 +1755,48 @@ def _(): if_attribute) == has_value: return True """) - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) - def testDictSetGenerator(self): - code = textwrap.dedent( - """\ + def testDictSetGenerator(self): + code = textwrap.dedent( + """\ foo = { variable: 'hello world. How are you today?' for variable in fnord if variable != 37 } """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testUnaryOpInDictionaryValue(self): - code = textwrap.dedent( - """\ + def testUnaryOpInDictionaryValue(self): + code = textwrap.dedent( + """\ beta = "123" test = {'alpha': beta[-1]} print(beta[-1]) """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testUnaryNotOperator(self): - code = textwrap.dedent( - """\ + def testUnaryNotOperator(self): + code = textwrap.dedent( + """\ if True: if True: if True: if True: remote_checksum = self.get_checksum(conn, tmp, dest, inject, not directory_prepended, source) - """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testRelaxArraySubscriptAffinity(self): - code = """\ + def testRelaxArraySubscriptAffinity(self): + code = """\ class A(object): def f(self, aaaaaaaaa, bbbbbbbbbbbbb, row): @@ -1805,44 +1808,44 @@ def f(self, aaaaaaaaa, bbbbbbbbbbbbb, row): bbbbbbbbbbbbb[ '..............'] = row[5] if row[5] is not None else 5 """ - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) - - def testFunctionCallInDict(self): - 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" - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) - - def testUnbreakableNot(self): - code = textwrap.dedent( - """\ + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) + + def testFunctionCallInDict(self): + 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" + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) + + def testUnbreakableNot(self): + code = textwrap.dedent( + """\ def test(): if not "Foooooooooooooooooooooooooooooo" or "Foooooooooooooooooooooooooooooo" == "Foooooooooooooooooooooooooooooo": pass - """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testSplitListWithComment(self): - code = textwrap.dedent( - """\ + def testSplitListWithComment(self): + code = textwrap.dedent( + """\ a = [ 'a', 'b', 'c' # hello world ] """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testOverColumnLimit(self): - unformatted_code = textwrap.dedent( - """\ + def testOverColumnLimit(self): + unformatted_code = textwrap.dedent( + """\ class Test: def testSomething(self): @@ -1851,9 +1854,9 @@ def testSomething(self): ('aaaaaaaaaaaaa', 'bbbb'): 'ccccccccccccccccccccccccccccccccccccccccccc', ('aaaaaaaaaaaaa', 'bbbb'): 'ccccccccccccccccccccccccccccccccccccccccccc', } - """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ class Test: def testSomething(self): @@ -1866,35 +1869,35 @@ def testSomething(self): 'ccccccccccccccccccccccccccccccccccccccccccc', } """) - 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)) - def testEndingComment(self): - code = textwrap.dedent( - """\ + def testEndingComment(self): + code = textwrap.dedent( + """\ a = f( a="something", b="something requiring comment which is quite long", # comment about b (pushes line over 79) c="something else, about which comment doesn't make sense") - """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testContinuationSpaceRetention(self): - code = textwrap.dedent( - """\ + def testContinuationSpaceRetention(self): + code = textwrap.dedent( + """\ def fn(): return module \\ .method(Object(data, fn2(arg) )) """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testIfExpressionWithFunctionCall(self): - code = textwrap.dedent( - """\ + def testIfExpressionWithFunctionCall(self): + code = textwrap.dedent( + """\ if x or z.y( a, c, @@ -1902,53 +1905,53 @@ def testIfExpressionWithFunctionCall(self): bbbbbbbbbbbbbbbbbbbbb=bbbbbbbbbbbbbbbbbb): pass """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testUnformattedAfterMultilineString(self): - code = textwrap.dedent( - """\ + def testUnformattedAfterMultilineString(self): + code = textwrap.dedent( + """\ def foo(): com_text = \\ ''' TEST ''' % (input_fname, output_fname) """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testNoSpacesAroundKeywordDefaultValues(self): - code = textwrap.dedent( - """\ + def testNoSpacesAroundKeywordDefaultValues(self): + code = textwrap.dedent( + """\ sources = { 'json': request.get_json(silent=True) or {}, 'json2': request.get_json(silent=True), } json = request.get_json(silent=True) or {} """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testNoSplittingBeforeEndingSubscriptBracket(self): - unformatted_code = textwrap.dedent( - """\ + def testNoSplittingBeforeEndingSubscriptBracket(self): + 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( - """\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ if True: if True: status = cf.describe_stacks( StackName=stackname)[u'Stacks'][0][u'StackStatus'] """) - 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)) - def testNoSplittingOnSingleArgument(self): - unformatted_code = textwrap.dedent( - """\ + def testNoSplittingOnSingleArgument(self): + unformatted_code = textwrap.dedent( + """\ xxxxxxxxxxxxxx = (re.search(r'(\\d+\\.\\d+\\.\\d+\\.)\\d+', aaaaaaa.bbbbbbbbbbbb).group(1) + re.search(r'\\d+\\.\\d+\\.\\d+\\.(\\d+)', @@ -1958,28 +1961,28 @@ 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)) xxxxxxxxxxxxxx = ( re.search(r'(\\d+\\.\\d+\\.\\d+\\.)\\d+', aaaaaaa.bbbbbbbbbbbb).group(a.b) + re.search(r'\\d+\\.\\d+\\.\\d+\\.(\\d+)', ccccccc).group(c.d)) - """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - def testSplittingArraysSensibly(self): - unformatted_code = textwrap.dedent( - """\ + def testSplittingArraysSensibly(self): + unformatted_code = textwrap.dedent( + """\ while True: while True: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = list['bbbbbbbbbbbbbbbbbbbbbbbbb'].split(',') aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = list('bbbbbbbbbbbbbbbbbbbbbbbbb').split(',') - """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ while True: while True: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = list[ @@ -1987,31 +1990,31 @@ def testSplittingArraysSensibly(self): aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = list( 'bbbbbbbbbbbbbbbbbbbbbbbbb').split(',') """) - 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)) - def testComprehensionForAndIf(self): - unformatted_code = textwrap.dedent( - """\ + def testComprehensionForAndIf(self): + 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( - """\ + """) # noqa + expected_formatted_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 - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - def testFunctionCallArguments(self): - unformatted_code = textwrap.dedent( - """\ + def testFunctionCallArguments(self): + unformatted_code = textwrap.dedent( + """\ def f(): if True: pytree_utils.InsertNodesBefore(_CreateCommentsFromPrefix( @@ -2021,8 +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( @@ -2032,26 +2035,26 @@ def f(): pytree_utils.InsertNodesBefore( _CreateCommentsFromPrefix( comment_prefix, comment_lineno, comment_column, standalone=True)) - """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - def testBinaryOperators(self): - unformatted_code = textwrap.dedent( - """\ + def testBinaryOperators(self): + 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)) + 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 @@ -2060,32 +2063,32 @@ def f(): current.value in ']}'): pass """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testContiguousList(self): - code = textwrap.dedent( - """\ + def testContiguousList(self): + code = textwrap.dedent( + """\ [retval1, retval2] = a_very_long_function(argument_1, argument2, argument_3, argument_4) - """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testArgsAndKwargsFormatting(self): - code = textwrap.dedent( - """\ + def testArgsAndKwargsFormatting(self): + code = textwrap.dedent( + """\ a(a=aaaaaaaaaaaaaaaaaaaaa, b=aaaaaaaaaaaaaaaaaaaaaaaa, c=aaaaaaaaaaaaaaaaaa, *d, **e) """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + 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', @@ -2093,12 +2096,12 @@ def foo(): zzz='a third long string') ] """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testCommentColumnLimitOverflow(self): - code = textwrap.dedent( - """\ + def testCommentColumnLimitOverflow(self): + code = textwrap.dedent( + """\ def f(): if True: TaskManager.get_tags = MagicMock( @@ -2107,12 +2110,12 @@ def f(): # side_effect=[(157031694470475), (157031694470475),], ) """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testMultilineLambdas(self): - unformatted_code = textwrap.dedent( - """\ + def testMultilineLambdas(self): + unformatted_code = textwrap.dedent( + """\ class SomeClass(object): do_something = True @@ -2122,9 +2125,9 @@ def succeeded(self, dddddddddddddd): if self.do_something: d.addCallback(lambda _: self.aaaaaa.bbbbbbbbbbbbbbbb.cccccccccccccccccccccccccccccccc(dddddddddddddd)) return d - """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ class SomeClass(object): do_something = True @@ -2137,18 +2140,19 @@ def succeeded(self, dddddddddddddd): return d """) - try: - style.SetGlobalStyle( - 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)) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) - - def testMultilineDictionaryKeys(self): - unformatted_code = textwrap.dedent( - """\ + try: + style.SetGlobalStyle( + 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)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testMultilineDictionaryKeys(self): + unformatted_code = textwrap.dedent( + """\ MAP_WITH_LONG_KEYS = { ('lorem ipsum', 'dolor sit amet'): 1, @@ -2157,9 +2161,9 @@ def testMultilineDictionaryKeys(self): ('vehicula convallis nulla. Vestibulum dictum nisl in malesuada finibus.',): 3 } - """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ MAP_WITH_LONG_KEYS = { ('lorem ipsum', 'dolor sit amet'): 1, @@ -2169,21 +2173,22 @@ def testMultilineDictionaryKeys(self): ('vehicula convallis nulla. Vestibulum dictum nisl in malesuada finibus.',): 3 } - """) # noqa - - try: - style.SetGlobalStyle( - 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)) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) - - def testStableDictionaryFormatting(self): - code = textwrap.dedent( - """\ + """) # noqa + + try: + style.SetGlobalStyle( + 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)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testStableDictionaryFormatting(self): + code = textwrap.dedent( + """\ class A(object): def method(self): @@ -2196,36 +2201,36 @@ def method(self): } }] } - """) # noqa - - try: - style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{based_on_style: pep8, indent_width: 2, ' - 'continuation_indent_width: 4, ' - 'indent_dictionary_value: True}')) - - llines = yapf_test_helper.ParseAndUnwrap(code) - reformatted_code = reformatter.Reformat(llines) - self.assertCodeEqual(code, 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 testStableInlinedDictionaryFormatting(self): - try: - style.SetGlobalStyle(style.CreatePEP8Style()) - unformatted_code = textwrap.dedent( - """\ + """) # noqa + + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig( + '{based_on_style: pep8, indent_width: 2, ' + 'continuation_indent_width: 4, ' + 'indent_dictionary_value: True}')) + + llines = yapf_test_helper.ParseAndUnwrap(code) + reformatted_code = reformatter.Reformat(llines) + self.assertCodeEqual(code, 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 testStableInlinedDictionaryFormatting(self): + try: + style.SetGlobalStyle(style.CreatePEP8Style()) + 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( - """\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ def _(): url = "http://{0}/axis-cgi/admin/param.cgi?{1}".format( value, urllib.urlencode({ @@ -2234,46 +2239,46 @@ def _(): })) """) - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - reformatted_code = reformatter.Reformat(llines) - self.assertCodeEqual(expected_formatted_code, reformatted_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) - reformatted_code = reformatter.Reformat(llines) - self.assertCodeEqual(expected_formatted_code, reformatted_code) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) + 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( - """\ + def testDontSplitKeywordValueArguments(self): + 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)) """) - 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)) - def testDontAddBlankLineAfterMultilineString(self): - code = textwrap.dedent( - """\ + def testDontAddBlankLineAfterMultilineString(self): + code = textwrap.dedent( + """\ query = '''SELECT id FROM table WHERE day in {}''' days = ",".join(days) """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testFormattingListComprehensions(self): - code = textwrap.dedent( - """\ + def testFormattingListComprehensions(self): + code = textwrap.dedent( + """\ def a(): if True: if True: @@ -2282,13 +2287,13 @@ def a(): x for x, y in self._heap_this_is_very_long if x.route[0] == choice ] self._heap = [x for x in self._heap if x.route and x.route[0] == choice] - """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testNoSplittingWhenBinPacking(self): - code = textwrap.dedent( - """\ + def testNoSplittingWhenBinPacking(self): + code = textwrap.dedent( + """\ a_very_long_function_name( long_argument_name_1=1, long_argument_name_2=2, @@ -2300,45 +2305,45 @@ def testNoSplittingWhenBinPacking(self): long_argument_name_1=1, long_argument_name_2=2, long_argument_name_3=3, long_argument_name_4=4 ) - """) # noqa - - try: - style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{based_on_style: pep8, indent_width: 2, ' - 'continuation_indent_width: 4, indent_dictionary_value: True, ' - 'dedent_closing_brackets: True, ' - 'split_before_named_assigns: False}')) - - llines = yapf_test_helper.ParseAndUnwrap(code) - reformatted_code = reformatter.Reformat(llines) - self.assertCodeEqual(code, 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( - """\ + """) # noqa + + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig( + '{based_on_style: pep8, indent_width: 2, ' + 'continuation_indent_width: 4, indent_dictionary_value: True, ' + 'dedent_closing_brackets: True, ' + 'split_before_named_assigns: False}')) + + llines = yapf_test_helper.ParseAndUnwrap(code) + reformatted_code = reformatter.Reformat(llines) + self.assertCodeEqual(code, 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( + """\ 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 """) - 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)) - def testSplittingOneArgumentList(self): - unformatted_code = textwrap.dedent( - """\ + def testSplittingOneArgumentList(self): + unformatted_code = textwrap.dedent( + """\ def _(): if True: if True: @@ -2346,9 +2351,9 @@ def _(): if True: if True: boxes[id_] = np.concatenate((points.min(axis=0), qoints.max(axis=0))) - """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ def _(): if True: if True: @@ -2358,12 +2363,12 @@ def _(): boxes[id_] = np.concatenate( (points.min(axis=0), qoints.max(axis=0))) """) - 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)) - def testSplittingBeforeFirstElementListArgument(self): - unformatted_code = textwrap.dedent( - """\ + def testSplittingBeforeFirstElementListArgument(self): + unformatted_code = textwrap.dedent( + """\ class _(): @classmethod def _pack_results_for_constraint_or(cls, combination, constraints): @@ -2375,9 +2380,9 @@ def _pack_results_for_constraint_or(cls, combination, constraints): clue for clue in combination if not clue == Verifier.UNMATCHED ), constraints, InvestigationResult.OR ) - """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ class _(): @classmethod @@ -2388,13 +2393,13 @@ def _pack_results_for_constraint_or(cls, combination, constraints): return cls._create_investigation_result( (clue for clue in combination if not clue == Verifier.UNMATCHED), constraints, InvestigationResult.OR) - """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - def testSplittingArgumentsTerminatedByComma(self): - unformatted_code = textwrap.dedent( - """\ + def testSplittingArgumentsTerminatedByComma(self): + 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,) @@ -2404,9 +2409,9 @@ def testSplittingArgumentsTerminatedByComma(self): a_very_long_function_name(long_argument_name_1, long_argument_name_2, long_argument_name_3, long_argument_name_4,) r =f0 (1, 2,3,) - """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ function_name(argument_name_1=1, argument_name_2=2, argument_name_3=3) function_name( @@ -2435,35 +2440,35 @@ def testSplittingArgumentsTerminatedByComma(self): ) """) - try: - style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{based_on_style: yapf, ' - 'split_arguments_when_comma_terminated: True}')) - - 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) - reformatted_code = reformatter.Reformat(llines) - self.assertCodeEqual(expected_formatted_code, reformatted_code) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) - - def testImportAsList(self): - code = textwrap.dedent( - """\ + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig( + '{based_on_style: yapf, ' + 'split_arguments_when_comma_terminated: True}')) + + 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) + reformatted_code = reformatter.Reformat(llines) + self.assertCodeEqual(expected_formatted_code, reformatted_code) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testImportAsList(self): + code = textwrap.dedent( + """\ from toto import titi, tata, tutu # noqa from toto import titi, tata, tutu from toto import (titi, tata, tutu) """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testDictionaryValuesOnOwnLines(self): - unformatted_code = textwrap.dedent( - """\ + def testDictionaryValuesOnOwnLines(self): + unformatted_code = textwrap.dedent( + """\ a = { 'aaaaaaaaaaaaaaaaaaaaaaaa': Check('ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ', '=', True), @@ -2487,8 +2492,8 @@ def testDictionaryValuesOnOwnLines(self): Check('QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ', '=', False), } """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent( + """\ a = { 'aaaaaaaaaaaaaaaaaaaaaaaa': Check('ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ', '=', True), @@ -2511,48 +2516,48 @@ def testDictionaryValuesOnOwnLines(self): 'jjjjjjjjjjjjjjjjjjjjjjjjjj': Check('QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ', '=', False), } - """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - def testDictionaryOnOwnLine(self): - unformatted_code = textwrap.dedent( - """\ + def testDictionaryOnOwnLine(self): + 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)) + """) # 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, collection_key=collection.key, collection_key2=collection.key2) """) - 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)) - def testNestedListsInDictionary(self): - unformatted_code = textwrap.dedent( - """\ + def testNestedListsInDictionary(self): + unformatted_code = textwrap.dedent( + """\ _A = { 'cccccccccc': ('^^1',), 'rrrrrrrrrrrrrrrrrrrrrrrrr': ('^7913', # AAAAAAAAAAAAAA. @@ -2580,9 +2585,9 @@ def testNestedListsInDictionary(self): 'cccccccccc': ('^21109', # PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP. ), } - """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ _A = { 'cccccccccc': ('^^1',), 'rrrrrrrrrrrrrrrrrrrrrrrrr': ( @@ -2616,12 +2621,12 @@ def testNestedListsInDictionary(self): ), } """) - 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)) - def testNestedDictionary(self): - unformatted_code = textwrap.dedent( - """\ + def testNestedDictionary(self): + unformatted_code = textwrap.dedent( + """\ class _(): def _(): breadcrumbs = [{'name': 'Admin', @@ -2631,8 +2636,8 @@ def _(): 'url': url_for(".home")}, {'title': title}] """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent( + """\ class _(): def _(): breadcrumbs = [ @@ -2645,13 +2650,13 @@ def _(): }, ] breadcrumbs = [{'name': 'Admin', 'url': url_for(".home")}, {'title': title}] - """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - def testDictionaryElementsOnOneLine(self): - code = textwrap.dedent( - """\ + def testDictionaryElementsOnOneLine(self): + code = textwrap.dedent( + """\ class _(): @mock.patch.dict( @@ -2666,46 +2671,46 @@ def _(): Environment.YYYYYYY: 'some text more text even more text yet ag', Environment.ZZZZZZZZZZZ: 'some text more text even more text yet again tex', } - """) # noqa - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testNotInParams(self): - unformatted_code = textwrap.dedent( - """\ + def testNotInParams(self): + 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( - """\ + """) # noqa + 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 - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) + """) # noqa + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) - def testNamedAssignNotAtEndOfLine(self): - unformatted_code = textwrap.dedent( - """\ + def testNamedAssignNotAtEndOfLine(self): + 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( filename, mode='w', encoding=encoding) as fd: pass """) - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) - def testBlankLineBeforeClassDocstring(self): - unformatted_code = textwrap.dedent( - '''\ + def testBlankLineBeforeClassDocstring(self): + unformatted_code = textwrap.dedent( + '''\ class A: """Does something. @@ -2716,8 +2721,8 @@ class A: def __init__(self): pass ''') - expected_code = textwrap.dedent( - '''\ + expected_code = textwrap.dedent( + '''\ class A: """Does something. @@ -2727,11 +2732,11 @@ class A: def __init__(self): pass ''') - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) + 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. @@ -2742,8 +2747,8 @@ class A: def __init__(self): pass ''') - expected_formatted_code = textwrap.dedent( - '''\ + expected_formatted_code = textwrap.dedent( + '''\ class A: """Does something. @@ -2755,20 +2760,21 @@ def __init__(self): pass ''') - try: - style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{based_on_style: yapf, ' - 'blank_line_before_class_docstring: True}')) - - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) - - def testBlankLineBeforeModuleDocstring(self): - unformatted_code = textwrap.dedent( - '''\ + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig( + '{based_on_style: yapf, ' + 'blank_line_before_class_docstring: True}')) + + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testBlankLineBeforeModuleDocstring(self): + unformatted_code = textwrap.dedent( + '''\ #!/usr/bin/env python # -*- coding: utf-8 name> -*- @@ -2778,8 +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.""" @@ -2788,11 +2794,11 @@ def foobar(): def foobar(): pass ''') - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) + 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.""" @@ -2801,8 +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> -*- @@ -2813,44 +2819,45 @@ def foobar(): pass ''') - try: - style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{based_on_style: pep8, ' - 'blank_line_before_module_docstring: True}')) - - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) - - def testTupleCohesion(self): - unformatted_code = textwrap.dedent( - """\ + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig( + '{based_on_style: pep8, ' + 'blank_line_before_module_docstring: True}')) + + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testTupleCohesion(self): + 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, ('a string that may be too long %s' % 'M15')) """) - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) - def testSubscriptExpression(self): - code = textwrap.dedent("""\ + def testSubscriptExpression(self): + code = textwrap.dedent("""\ foo = d[not a] """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) - def testListWithFunctionCalls(self): - unformatted_code = textwrap.dedent( - """\ + def testListWithFunctionCalls(self): + unformatted_code = textwrap.dedent( + """\ def foo(): return [ Bar( @@ -2862,8 +2869,8 @@ def foo(): zzz='a third long string') ] """) - expected_code = textwrap.dedent( - """\ + expected_code = textwrap.dedent( + """\ def foo(): return [ Bar(xxx='some string', @@ -2874,31 +2881,31 @@ def foo(): zzz='a third long string') ] """) - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) - def testEllipses(self): - unformatted_code = textwrap.dedent( - """\ + def testEllipses(self): + unformatted_code = textwrap.dedent( + """\ X=... Y = X if ... else X """) - expected_code = textwrap.dedent( - """\ + expected_code = textwrap.dedent( + """\ X = ... Y = X if ... else X """) - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) - def testPseudoParens(self): - unformatted_code = """\ + def testPseudoParens(self): + unformatted_code = """\ my_dict = { 'key': # Some comment about the key {'nested_key': 1, }, } """ - expected_code = """\ + expected_code = """\ my_dict = { 'key': # Some comment about the key { @@ -2906,88 +2913,91 @@ def testPseudoParens(self): }, } """ - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_code, reformatter.Reformat(llines)) + 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( - """\ + def testSplittingBeforeFirstArgumentOnFunctionCall(self): + """Tests split_before_first_argument on a function call.""" + 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")) """) - try: - style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{based_on_style: yapf, split_before_first_argument: True}')) - - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - 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( - """\ + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig( + '{based_on_style: yapf, split_before_first_argument: True}')) + + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + 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( + """\ 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 """) - try: - style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{based_on_style: yapf, split_before_first_argument: True}')) - - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - 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( - """\ + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig( + '{based_on_style: yapf, split_before_first_argument: True}')) + + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + 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( + """\ 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 """) - try: - style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{based_on_style: yapf, split_before_first_argument: True}')) - - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - 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( - """\ + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig( + '{based_on_style: yapf, split_before_first_argument: True}')) + + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + 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( + """\ date_time_values = ( { u'year': year, @@ -2999,8 +3009,8 @@ def testCoalesceBracketsOnDict(self): } ) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent( + """\ date_time_values = ({ u'year': year, u'month': month, @@ -3011,19 +3021,20 @@ def testCoalesceBracketsOnDict(self): }) """) - try: - style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{based_on_style: yapf, coalesce_brackets: True}')) - - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) - - def testSplitAfterComment(self): - code = textwrap.dedent( - """\ + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig( + '{based_on_style: yapf, coalesce_brackets: True}')) + + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual( + expected_formatted_code, reformatter.Reformat(llines)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testSplitAfterComment(self): + code = textwrap.dedent( + """\ if __name__ == "__main__": with another_resource: account = { @@ -3032,24 +3043,24 @@ def testSplitAfterComment(self): } """) - try: - style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{based_on_style: yapf, coalesce_brackets: True, ' - 'dedent_closing_brackets: true}')) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) - - @unittest.skipUnless(not py3compat.PY3, 'Requires Python 2.7') - def testAsyncAsNonKeyword(self): - try: - style.SetGlobalStyle(style.CreatePEP8Style()) - - # In Python 2, async may be used as a non-keyword identifier. - code = textwrap.dedent( - """\ + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig( + '{based_on_style: yapf, coalesce_brackets: True, ' + 'dedent_closing_brackets: true}')) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + @unittest.skipUnless(not py3compat.PY3, 'Requires Python 2.7') + def testAsyncAsNonKeyword(self): + try: + style.SetGlobalStyle(style.CreatePEP8Style()) + + # In Python 2, async may be used as a non-keyword identifier. + code = textwrap.dedent( + """\ from util import async @@ -3059,39 +3070,39 @@ def foo(self): async.run() """) - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) - def testDisableEndingCommaHeuristic(self): - code = textwrap.dedent("""\ + def testDisableEndingCommaHeuristic(self): + code = textwrap.dedent("""\ x = [1, 2, 3, 4, 5, 6, 7,] """) - try: - style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{based_on_style: yapf,' - ' disable_ending_comma_heuristic: True}')) - - llines = yapf_test_helper.ParseAndUnwrap(code) - self.assertCodeEqual(code, reformatter.Reformat(llines)) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) - - def testDedentClosingBracketsWithTypeAnnotationExceedingLineLength(self): - unformatted_code = textwrap.dedent( - """\ + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig( + '{based_on_style: yapf,' + ' disable_ending_comma_heuristic: True}')) + + llines = yapf_test_helper.ParseAndUnwrap(code) + self.assertCodeEqual(code, reformatter.Reformat(llines)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testDedentClosingBracketsWithTypeAnnotationExceedingLineLength(self): + unformatted_code = textwrap.dedent( + """\ def function(first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None) -> None: pass def function(first_argument_xxxxxxxxxxxxxxxxxxxxxxx=(0,), second_argument=None) -> None: pass - """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ def function( first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None ) -> None: @@ -3102,31 +3113,32 @@ def function( first_argument_xxxxxxxxxxxxxxxxxxxxxxx=(0,), second_argument=None ) -> None: pass - """) # noqa - - try: - style.SetGlobalStyle( - 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)) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) - - def testIndentClosingBracketsWithTypeAnnotationExceedingLineLength(self): - unformatted_code = textwrap.dedent( - """\ + """) # noqa + + try: + style.SetGlobalStyle( + 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)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testIndentClosingBracketsWithTypeAnnotationExceedingLineLength(self): + unformatted_code = textwrap.dedent( + """\ def function(first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None) -> None: pass def function(first_argument_xxxxxxxxxxxxxxxxxxxxxxx=(0,), second_argument=None) -> None: pass - """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ def function( first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None ) -> None: @@ -3137,31 +3149,32 @@ def function( first_argument_xxxxxxxxxxxxxxxxxxxxxxx=(0,), second_argument=None ) -> None: pass - """) # noqa - - try: - style.SetGlobalStyle( - 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)) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) - - def testIndentClosingBracketsInFunctionCall(self): - unformatted_code = textwrap.dedent( - """\ + """) # noqa + + try: + style.SetGlobalStyle( + 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)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testIndentClosingBracketsInFunctionCall(self): + unformatted_code = textwrap.dedent( + """\ def function(first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None, third_and_final_argument=True): pass def function(first_argument_xxxxxxxxxxxxxxxxxxxxxxx=(0,), second_and_last_argument=None): pass - """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ def function( first_argument_xxxxxxxxxxxxxxxx=(0,), second_argument=None, @@ -3174,22 +3187,23 @@ def function( first_argument_xxxxxxxxxxxxxxxxxxxxxxx=(0,), second_and_last_argument=None ): pass - """) # noqa - - try: - style.SetGlobalStyle( - 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)) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) - - def testIndentClosingBracketsInTuple(self): - unformatted_code = textwrap.dedent( - """\ + """) # noqa + + try: + style.SetGlobalStyle( + 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)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testIndentClosingBracketsInTuple(self): + unformatted_code = textwrap.dedent( + """\ def function(): some_var = ('a long element', 'another long element', 'short element', 'really really long element') return True @@ -3197,9 +3211,9 @@ def function(): def function(): some_var = ('a couple', 'small', 'elemens') return False - """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ def function(): some_var = ( 'a long element', 'another long element', 'short element', @@ -3211,22 +3225,23 @@ def function(): def function(): some_var = ('a couple', 'small', 'elemens') return False - """) # noqa - - try: - style.SetGlobalStyle( - 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)) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) - - def testIndentClosingBracketsInList(self): - unformatted_code = textwrap.dedent( - """\ + """) # noqa + + try: + style.SetGlobalStyle( + 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)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testIndentClosingBracketsInList(self): + unformatted_code = textwrap.dedent( + """\ def function(): some_var = ['a long element', 'another long element', 'short element', 'really really long element'] return True @@ -3234,9 +3249,9 @@ def function(): def function(): some_var = ['a couple', 'small', 'elemens'] return False - """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ def function(): some_var = [ 'a long element', 'another long element', 'short element', @@ -3250,20 +3265,21 @@ def function(): return False """) - try: - style.SetGlobalStyle( - 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)) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) - - def testIndentClosingBracketsInDict(self): - unformatted_code = textwrap.dedent( - """\ + try: + style.SetGlobalStyle( + 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)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testIndentClosingBracketsInDict(self): + 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 @@ -3271,9 +3287,9 @@ def function(): def function(): some_var = {1: 'a couple', 2: 'small', 3: 'elemens'} return False - """) # noqa - expected_formatted_code = textwrap.dedent( - """\ + """) # noqa + expected_formatted_code = textwrap.dedent( + """\ def function(): some_var = { 1: @@ -3291,22 +3307,23 @@ def function(): def function(): some_var = {1: 'a couple', 2: 'small', 3: 'elemens'} return False - """) # noqa - - try: - style.SetGlobalStyle( - 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)) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) - - def testMultipleDictionariesInList(self): - unformatted_code = textwrap.dedent( - """\ + """) # noqa + + try: + style.SetGlobalStyle( + 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)) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testMultipleDictionariesInList(self): + unformatted_code = textwrap.dedent( + """\ class A: def b(): d = { @@ -3332,8 +3349,8 @@ def b(): ] } """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent( + """\ class A: def b(): @@ -3356,69 +3373,70 @@ def b(): }] } """) - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) - - def testForceMultilineDict_True(self): - try: - style.SetGlobalStyle( - 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) + self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(llines)) + + def testForceMultilineDict_True(self): + try: + style.SetGlobalStyle( + 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( + """\ responseDict = { 'childDict': { 'spam': 'eggs' } } """) - self.assertCodeEqual(expected, actual) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) - - def testForceMultilineDict_False(self): - try: - style.SetGlobalStyle( - style.CreateStyleFromConfig('{force_multiline_dict: false}')) - unformatted_code = textwrap.dedent( - """\ + self.assertCodeEqual(expected, actual) + finally: + style.SetGlobalStyle(style.CreateYapfStyle()) + + def testForceMultilineDict_False(self): + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig('{force_multiline_dict: false}')) + 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)) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) - - @unittest.skipUnless(py3compat.PY38, 'Requires Python 3.8') - def testWalrus(self): - unformatted_code = textwrap.dedent( - """\ + 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()) + + @unittest.skipUnless(py3compat.PY38, 'Requires Python 3.8') + def testWalrus(self): + 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') """) - llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) - self.assertCodeEqual(expected, reformatter.Reformat(llines)) + llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) + self.assertCodeEqual(expected, reformatter.Reformat(llines)) ########## for Align_ArgAssign()########### - def testAlignArgAssignTypedName(self): - try: - style.SetGlobalStyle( - style.CreateStyleFromConfig( - '{align_argument_assignment: true,' - 'split_before_first_argument: true}')) - unformatted_code = textwrap.dedent( - """\ + def testAlignArgAssignTypedName(self): + try: + style.SetGlobalStyle( + style.CreateStyleFromConfig( + '{align_argument_assignment: true,' + 'split_before_first_argument: true}')) + unformatted_code = textwrap.dedent( + """\ def f1( self, *, @@ -3431,8 +3449,8 @@ def f1( ini_section: str="" ): pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent( + """\ def f1( self, *, @@ -3445,19 +3463,20 @@ def f1( 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}')) - unformatted_code = textwrap.dedent( - """\ + 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}')) + unformatted_code = textwrap.dedent( + """\ arglist = test( first_argument='', second_argument=fun( @@ -3467,8 +3486,8 @@ def testAlignArgAssignNestedArglistInBetween(self): fourth_argument=4 ) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent( + """\ arglist = test( first_argument ='', second_argument =fun( @@ -3480,20 +3499,21 @@ def testAlignArgAssignNestedArglistInBetween(self): 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,' - 'new_alignment_after_commentline:true}')) - unformatted_code = textwrap.dedent( - """\ + 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,' + 'new_alignment_after_commentline:true}')) + unformatted_code = textwrap.dedent( + """\ arglist = test( client_id=0, username_id=1, @@ -3501,55 +3521,58 @@ def testAlignArgAssignCommentLineInBetween(self): user_name='xxxxxxxxxxxxxxxxxxxxx' ) """) - expected_formatted_code = textwrap.dedent( - """\ + 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}')) - unformatted_code = textwrap.dedent( - """\ + 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}')) + 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}')) - unformatted_code = textwrap.dedent( - """\ + 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}')) + 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)) - finally: - style.SetGlobalStyle(style.CreateYapfStyle()) + 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() + unittest.main() diff --git a/yapftests/reformatter_buganizer_test.py b/yapftests/reformatter_buganizer_test.py index 54a62b588..8c0d4aa49 100644 --- a/yapftests/reformatter_buganizer_test.py +++ b/yapftests/reformatter_buganizer_test.py @@ -854,7 +854,8 @@ def testB65241516(self): 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' """) @@ -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): @@ -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) @@ -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) @@ -2187,10 +2296,12 @@ def testB15597568(self): 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: @@ -2248,11 +2361,13 @@ def testB14468247(self): 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..564dce281 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): @@ -384,7 +411,8 @@ def _pack_results_for_constraint_or(cls, combination, constraints): 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 diff --git a/yapftests/reformatter_pep8_test.py b/yapftests/reformatter_pep8_test.py index acc218d24..cfd3bb703 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()) @@ -535,8 +580,8 @@ def _(): + str(42)) """ 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()) @@ -590,13 +635,14 @@ class nested_class(): return nested_function ''' 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 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({ @@ -708,7 +762,8 @@ def _(): @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: ... @@ -722,7 +777,8 @@ def testSpaceBetweenDictColonAndElipses(self): 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..4809f8c35 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 """) @@ -110,7 +120,8 @@ def testExecAsNonKeyword(self): def testAsyncFunctions(self): if sys.version_info[1] < 5: return - code = textwrap.dedent("""\ + code = textwrap.dedent( + """\ import asyncio import time @@ -143,8 +154,8 @@ 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()) @@ -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 @@ -192,7 +205,8 @@ def testMatrixMultiplication(self): 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) @@ -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: @@ -346,8 +367,8 @@ 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()) @@ -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..d60df6cde 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') """) @@ -62,18 +66,20 @@ def testOperatorNoSpaceStyle(self): 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 @@ -83,7 +89,8 @@ def testOperatorPrecedenceStyle(self): 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,8 +123,8 @@ 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 @@ -127,7 +135,8 @@ def testNoSplitBeforeFirstArgumentStyle1(self): pep8_no_split_before_first['SPLIT_BEFORE_FIRST_ARGUMENT'] = 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) @@ -168,7 +177,8 @@ def testNoSplitBeforeFirstArgumentStyle2(self): pep8_no_split_before_first['SPLIT_BEFORE_FIRST_ARGUMENT'] = False 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..344330eb6 100644 --- a/yapftests/split_penalty_test.py +++ b/yapftests/split_penalty_test.py @@ -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..02e605328 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 @@ -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 @@ -276,12 +284,12 @@ def testDefaultBasedOnStyle(self): 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..8018f0a25 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""" 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("""\ 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("""\ 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("""\ [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..974c126cc 100644 --- a/yapftests/yapf_test.py +++ b/yapftests/yapf_test.py @@ -57,7 +57,8 @@ def testNoEndingNewline(self): unformatted_code = textwrap.dedent("""\ if True: pass""") - expected_formatted_code = textwrap.dedent("""\ + expected_formatted_code = textwrap.dedent( + """\ if True: pass """) @@ -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 """) @@ -264,8 +280,8 @@ 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() @@ -274,11 +290,13 @@ def testNoFile(self): 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. @@ -421,10 +444,10 @@ def assertYapfReformats(self, cmdline = YAPF_BINARY + (extra_options or []) 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: @@ -462,8 +488,8 @@ def foo(): def testInPlaceReformattingBlank(self): 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: @@ -473,8 +499,8 @@ def testInPlaceReformattingBlank(self): def testInPlaceReformattingEmpty(self): 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 ''') @@ -558,23 +596,25 @@ def testReadSingleLineCodeFromStdin(self): 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 @@ -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 = [ @@ -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(): @@ -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: "@,**,-"}', @@ -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') """) @@ -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 @@ -1905,7 +2027,8 @@ def _OwnStyle(cls): 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] } @@ -1953,7 +2077,8 @@ def _OwnStyle(cls): 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 ] @@ -2009,7 +2135,8 @@ def _OwnStyle(cls): 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..127a2a180 100644 --- a/yapftests/yapf_test_helper.py +++ b/yapftests/yapf_test_helper.py @@ -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 378d9627fbc520cdf3816fb250e8ed10a8497e47 Mon Sep 17 00:00:00 2001 From: Xiao Wang Date: Tue, 3 Jan 2023 10:18:49 +0100 Subject: [PATCH 10/11] change the format back to based-on-yapf --- yapf/__init__.py | 178 +++++----- yapf/pyparser/pyparser.py | 10 +- yapf/pyparser/split_penalty_visitor.py | 33 +- yapf/pytree/blank_line_calculator.py | 34 +- yapf/pytree/comment_splicer.py | 40 +-- yapf/pytree/continuation_splicer.py | 6 +- yapf/pytree/pytree_unwrapper.py | 36 +- yapf/pytree/pytree_utils.py | 42 +-- yapf/pytree/split_penalty.py | 41 ++- yapf/pytree/subtype_assigner.py | 27 +- yapf/third_party/yapf_diff/yapf_diff.py | 41 ++- yapf/yapflib/errors.py | 4 +- yapf/yapflib/file_resources.py | 18 +- yapf/yapflib/format_decision_state.py | 59 ++-- yapf/yapflib/format_token.py | 96 +++-- yapf/yapflib/object_state.py | 39 +-- yapf/yapflib/py3compat.py | 4 +- yapf/yapflib/reformatter.py | 33 +- yapf/yapflib/style.py | 448 ++++++++++-------------- yapf/yapflib/yapf_api.py | 69 ++-- 20 files changed, 576 insertions(+), 682 deletions(-) diff --git a/yapf/__init__.py b/yapf/__init__.py index 9b69f719e..94e445b59 100644 --- a/yapf/__init__.py +++ b/yapf/__init__.py @@ -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: @@ -100,10 +99,10 @@ def main(argv): 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 bb5e48f69..a8a28ebc8 100644 --- a/yapf/pyparser/pyparser.py +++ b/yapf/pyparser/pyparser.py @@ -110,11 +110,11 @@ 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 = '\\' diff --git a/yapf/pyparser/split_penalty_visitor.py b/yapf/pyparser/split_penalty_visitor.py index ebcd4ee42..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) @@ -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 @@ -544,8 +543,8 @@ def visit_Attribute(self, node): # attr=Identifier) 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) diff --git a/yapf/pytree/blank_line_calculator.py b/yapf/pytree/blank_line_calculator.py index b699a4d3a..9d218bf97 100644 --- a/yapf/pytree/blank_line_calculator.py +++ b/yapf/pytree/blank_line_calculator.py @@ -33,14 +33,13 @@ _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): @@ -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 953a7853f..ae5ffe66f 100644 --- a/yapf/pytree/comment_splicer.py +++ b/yapf/pytree/comment_splicer.py @@ -178,16 +178,15 @@ def _VisitNodeRec(node): 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_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: @@ -237,9 +238,9 @@ def _CreateCommentsFromPrefix( 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))) + 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 959682790..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): @@ -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: diff --git a/yapf/pytree/pytree_utils.py b/yapf/pytree/pytree_utils.py index b87599774..66a54e617 100644 --- a/yapf/pytree/pytree_utils.py +++ b/yapf/pytree/pytree_utils.py @@ -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/split_penalty.py b/yapf/pytree/split_penalty.py index 8b8318a69..b53ffbf85 100644 --- a/yapf/pytree/split_penalty.py +++ b/yapf/pytree/split_penalty.py @@ -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) @@ -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 74108c8ed..0ee247a82 100644 --- a/yapf/pytree/subtype_assigner.py +++ b/yapf/pytree/subtype_assigner.py @@ -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 @@ -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): diff --git a/yapf/third_party/yapf_diff/yapf_diff.py b/yapf/third_party/yapf_diff/yapf_diff.py index df5cb33da..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 ' @@ -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 112fb3512..b5e2612bd 100644 --- a/yapf/yapflib/file_resources.py +++ b/yapf/yapflib/file_resources.py @@ -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 bfe7dc58f..efcef0ba4 100644 --- a/yapf/yapflib/format_decision_state.py +++ b/yapf/yapflib/format_decision_state.py @@ -98,30 +98,27 @@ 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. @@ -707,8 +704,8 @@ 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. @@ -832,8 +829,8 @@ def _PushParameterListState(self, newline): 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. @@ -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) @@ -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 @@ -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( @@ -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 4a1f9f6b1..01d16225a 100644 --- a/yapf/yapflib/format_token.py +++ b/yapf/yapflib/format_token.py @@ -119,8 +119,8 @@ 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) + 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 @@ -151,8 +151,8 @@ 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()] @@ -162,15 +162,15 @@ def AddWhitespacePrefix(self, newlines_before, spaces=0, indent_level=0): 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.""" @@ -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): @@ -327,9 +325,8 @@ def is_copybara_comment(self): @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): @@ -358,18 +355,15 @@ def is_argname_start(self): 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))) + 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/object_state.py b/yapf/yapflib/object_state.py index 1f3da3630..ec259e682 100644 --- a/yapf/yapflib/object_state.py +++ b/yapf/yapflib/object_state.py @@ -70,11 +70,10 @@ def Clone(self): 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): @@ -169,19 +166,18 @@ def SplitBeforeClosingBracket(self, indent): 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] 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): @@ -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 f319d4172..e4cb9788f 100644 --- a/yapf/yapflib/py3compat.py +++ b/yapf/yapflib/py3compat.py @@ -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 diff --git a/yapf/yapflib/reformatter.py b/yapf/yapflib/reformatter.py index 071754c59..c8032eb87 100644 --- a/yapf/yapflib/reformatter.py +++ b/yapf/yapflib/reformatter.py @@ -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) @@ -163,8 +163,8 @@ def _RetainRequiredVerticalSpacingBetweenTokens(cur_tok, prev_tok, lines): 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) + required_newlines = max(required_newlines - deletable_lines, + desired_newlines) cur_tok.AdjustNewlinesBefore(required_newlines) @@ -265,9 +265,8 @@ def _CanPlaceOnSingleLine(line): 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): @@ -370,8 +369,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) @@ -653,8 +652,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): @@ -794,8 +793,8 @@ 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) @@ -807,12 +806,12 @@ def _FormatFirstToken(first_token, indent_depth, prev_line, final_lines): 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: diff --git a/yapf/yapflib/style.py b/yapf/yapflib/style.py index bfd19bdae..ee19070c5 100644 --- a/yapf/yapflib/style.py +++ b/yapf/yapflib/style.py @@ -52,25 +52,20 @@ 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_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.""" - ), - NEW_ALIGNMENT_AFTER_COMMENTLINE =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_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 = { @@ -78,15 +73,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 @@ -106,8 +98,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: @@ -115,22 +106,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: @@ -147,10 +133,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. @@ -160,11 +145,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: @@ -182,33 +165,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: @@ -226,8 +203,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: @@ -238,16 +214,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 @@ -256,26 +229,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. @@ -285,8 +253,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. @@ -296,14 +263,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. @@ -313,8 +278,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 @@ -356,31 +320,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': @@ -388,8 +345,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)) @@ -399,24 +355,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: @@ -432,36 +383,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, @@ -473,12 +415,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', ) @@ -487,68 +427,68 @@ def method(): def CreatePEP8Style(): """Create the PEP8 formatting style.""" return dict( - ALIGN_CLOSING_BRACKET_WITH_VISUAL_INDENT =True, - ALIGN_ARGUMENT_ASSIGNMENT =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_ARGUMENT_ASSIGNMENT=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, ) @@ -603,10 +543,10 @@ def CreateFacebookStyle(): _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 = [ @@ -677,68 +617,68 @@ 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, - 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, + 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, ) @@ -893,8 +833,8 @@ 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 diff --git a/yapf/yapflib/yapf_api.py b/yapf/yapflib/yapf_api.py index f53e08afe..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: @@ -93,18 +92,18 @@ def FormatFile( original_source, newline, encoding = ReadFile(filename, logger) 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') 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,8 +228,8 @@ 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) @@ -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 @@ -305,19 +302,17 @@ def _MarkLinesToFormat(llines, lines): 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'): From f52471c65487a247a7e6f347ff127cbe519d4bc0 Mon Sep 17 00:00:00 2001 From: Xiao Wang Date: Tue, 3 Jan 2023 10:25:19 +0100 Subject: [PATCH 11/11] change the format back to based-on-yapf 2 --- yapftests/blank_line_calculator_test.py | 69 +- yapftests/comment_splicer_test.py | 50 +- yapftests/file_resources_test.py | 111 +-- yapftests/line_joiner_test.py | 18 +- yapftests/logical_line_test.py | 20 +- yapftests/main_test.py | 5 +- yapftests/pytree_unwrapper_test.py | 269 +++--- yapftests/pytree_utils_test.py | 52 +- yapftests/reformatter_basic_test.py | 932 ++++++++------------- yapftests/reformatter_buganizer_test.py | 393 +++------ yapftests/reformatter_facebook_test.py | 87 +- yapftests/reformatter_pep8_test.py | 248 ++---- yapftests/reformatter_python3_test.py | 87 +- yapftests/reformatter_style_config_test.py | 42 +- yapftests/reformatter_verify_test.py | 26 +- yapftests/split_penalty_test.py | 266 +++--- yapftests/style_test.py | 55 +- yapftests/subtype_assigner_test.py | 531 ++++++------ yapftests/utils.py | 44 +- yapftests/yapf_test.py | 450 ++++------ yapftests/yapf_test_helper.py | 6 +- 21 files changed, 1471 insertions(+), 2290 deletions(-) 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 520c1ef53..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 @@ -142,8 +138,7 @@ def testInlineAfterSeparateLine(self): 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 @@ -161,8 +156,7 @@ def testSeparateLineAfterInline(self): 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 @@ -267,8 +257,7 @@ def foo(): pass 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 @@ -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): @@ -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 cbd1c1b05..31184c4a3 100644 --- a/yapftests/file_resources_test.py +++ b/yapftests/file_resources_test.py @@ -167,12 +167,12 @@ 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 @@ -186,8 +186,8 @@ def test_setup_config(self): # 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 @@ -206,8 +206,8 @@ def test_pyproject_toml(self): # 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. @@ -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)]) 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 7960eb236..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()) diff --git a/yapftests/main_test.py b/yapftests/main_test.py index 4258c311f..c83b8b66a 100644 --- a/yapftests/main_test.py +++ b/yapftests/main_test.py @@ -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 439615f17..525278def 100644 --- a/yapftests/pytree_unwrapper_test.py +++ b/yapftests/pytree_unwrapper_test.py @@ -43,19 +43,17 @@ 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""" @@ -63,59 +61,51 @@ def testSimpleMultilineStatement(self): 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""" 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 1b4940eaf..c175f833e 100644 --- a/yapftests/pytree_utils_test.py +++ b/yapftests/pytree_utils_test.py @@ -89,10 +89,10 @@ def _BuildSimpleTree(self): # 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]) + 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,13 +102,13 @@ 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 @@ -122,13 +122,13 @@ 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 @@ -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/reformatter_basic_test.py b/yapftests/reformatter_basic_test.py index 36103c8f7..8735b287e 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,25 +153,21 @@ 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)) @@ -199,13 +177,11 @@ def foo(long_arg, 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 @@ -560,11 +509,9 @@ def testSingleComment(self): 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. @@ -744,14 +683,12 @@ def testTupleCommaBeforeLastParen(self): 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 () @@ -912,12 +835,10 @@ def testOpeningAndClosingBrackets(self): 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 """) @@ -939,12 +860,10 @@ def testNoQueueSeletionInMiddleOfLine(self): 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. @@ -1064,8 +972,7 @@ def testSpaceBetweenStringAndParentheses(self): 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): @@ -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 @@ -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): @@ -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() @@ -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: @@ -1822,8 +1674,7 @@ def testFunctionCallInNestedDict(self): 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,10 +2025,9 @@ 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) reformatted_code = reformatter.Reformat(llines) @@ -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({ @@ -2250,14 +2067,12 @@ def _(): 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, @@ -2326,14 +2138,12 @@ def testNoSplittingWhenBinPacking(self): 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( @@ -2457,8 +2261,7 @@ def testSplittingArgumentsTerminatedByComma(self): 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, @@ -2856,8 +2634,7 @@ def testSubscriptExpression(self): 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 """) @@ -2918,13 +2692,11 @@ def testPseudoParens(self): 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(): @@ -3384,8 +3127,7 @@ def testForceMultilineDict_True(self): "responseDict = {'childDict': {'spam': 'eggs'}}\n") llines = yapf_test_helper.ParseAndUnwrap(unformatted_code) actual = reformatter.Reformat(llines) - expected = textwrap.dedent( - """\ + 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)) + 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') """) @@ -3432,11 +3171,9 @@ def testWalrus(self): 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, *, @@ -3449,8 +3186,7 @@ def f1( ini_section: str="" ): pass """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ def f1( self, *, @@ -3464,8 +3200,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()) @@ -3475,8 +3211,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( @@ -3486,8 +3221,7 @@ def testAlignArgAssignNestedArglistInBetween(self): fourth_argument=4 ) """) - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ arglist = test( first_argument ='', second_argument =fun( @@ -3500,8 +3234,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()) @@ -3509,11 +3243,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, @@ -3521,8 +3253,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, @@ -3530,8 +3261,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()) @@ -3539,15 +3270,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)) + self.assertCodeEqual(expected_formatted_code, + reformatter.Reformat(llines)) finally: style.SetGlobalStyle(style.CreateYapfStyle()) @@ -3555,22 +3285,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()) diff --git a/yapftests/reformatter_buganizer_test.py b/yapftests/reformatter_buganizer_test.py index 8c0d4aa49..54a62b588 100644 --- a/yapftests/reformatter_buganizer_test.py +++ b/yapftests/reformatter_buganizer_test.py @@ -854,8 +854,7 @@ def testB65241516(self): 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' """) @@ -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): @@ -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) @@ -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) @@ -2296,12 +2187,10 @@ def testB15597568(self): 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: @@ -2361,13 +2248,11 @@ def testB14468247(self): 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 564dce281..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): @@ -411,8 +384,7 @@ def _pack_results_for_constraint_or(cls, combination, constraints): 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 diff --git a/yapftests/reformatter_pep8_test.py b/yapftests/reformatter_pep8_test.py index cfd3bb703..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()) @@ -580,8 +535,8 @@ def _(): + str(42)) """ 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()) @@ -635,14 +590,13 @@ class nested_class(): return nested_function ''' 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 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({ @@ -762,8 +708,7 @@ def _(): @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: ... @@ -777,8 +722,7 @@ def testSpaceBetweenDictColonAndElipses(self): 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 4809f8c35..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 """) @@ -120,8 +110,7 @@ def testExecAsNonKeyword(self): def testAsyncFunctions(self): if sys.version_info[1] < 5: return - code = textwrap.dedent( - """\ + code = textwrap.dedent("""\ import asyncio import time @@ -154,8 +143,8 @@ 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()) @@ -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 @@ -205,8 +192,7 @@ def testMatrixMultiplication(self): 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) @@ -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: @@ -367,8 +346,8 @@ 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()) @@ -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 d60df6cde..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') """) @@ -66,20 +62,18 @@ def testOperatorNoSpaceStyle(self): 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 @@ -89,8 +83,7 @@ def testOperatorPrecedenceStyle(self): 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,8 +115,8 @@ 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 @@ -135,8 +127,7 @@ def testNoSplitBeforeFirstArgumentStyle1(self): pep8_no_split_before_first['SPLIT_BEFORE_FIRST_ARGUMENT'] = 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) @@ -177,8 +168,7 @@ def testNoSplitBeforeFirstArgumentStyle2(self): pep8_no_split_before_first['SPLIT_BEFORE_FIRST_ARGUMENT'] = False 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 344330eb6..f7474a398 100644 --- a/yapftests/split_penalty_test.py +++ b/yapftests/split_penalty_test.py @@ -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 02e605328..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 @@ -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 @@ -284,12 +276,12 @@ def testDefaultBasedOnStyle(self): 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 8018f0a25..c9855ccb1 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,307 @@ 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""" 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("""\ 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("""\ 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("""\ [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 974c126cc..2330f4e18 100644 --- a/yapftests/yapf_test.py +++ b/yapftests/yapf_test.py @@ -57,8 +57,7 @@ def testNoEndingNewline(self): unformatted_code = textwrap.dedent("""\ if True: pass""") - expected_formatted_code = textwrap.dedent( - """\ + expected_formatted_code = textwrap.dedent("""\ if True: pass """) @@ -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 """) @@ -280,8 +264,8 @@ 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() @@ -290,13 +274,11 @@ def testNoFile(self): 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. @@ -444,10 +421,10 @@ def assertYapfReformats( cmdline = YAPF_BINARY + (extra_options or []) 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: @@ -488,8 +462,8 @@ def foo(): def testInPlaceReformattingBlank(self): 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: @@ -499,8 +473,8 @@ def testInPlaceReformattingBlank(self): def testInPlaceReformattingEmpty(self): 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 ''') @@ -596,25 +558,23 @@ def testReadSingleLineCodeFromStdin(self): 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 @@ -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 = [ @@ -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(): @@ -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: "@,**,-"}', @@ -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') """) @@ -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 @@ -2027,8 +1905,7 @@ def _OwnStyle(cls): 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] } @@ -2077,8 +1953,7 @@ def _OwnStyle(cls): 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 ] @@ -2135,8 +2009,7 @@ def _OwnStyle(cls): 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 127a2a180..cb56ec865 100644 --- a/yapftests/yapf_test_helper.py +++ b/yapftests/yapf_test_helper.py @@ -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))