# Copyright 2016 Google Inc. All Rights Reserved.
|
#
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
# you may not use this file except in compliance with the License.
|
# You may obtain a copy of the License at
|
#
|
# http://www.apache.org/licenses/LICENSE-2.0
|
#
|
# Unless required by applicable law or agreed to in writing, software
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
# See the License for the specific language governing permissions and
|
# limitations under the License.
|
"""PEP8 tests for yapf.reformatter."""
|
|
import textwrap
|
import unittest
|
|
from yapf.yapflib import reformatter
|
from yapf.yapflib import style
|
|
from yapftests import yapf_test_helper
|
|
|
class TestsForPEP8Style(yapf_test_helper.YAPFTest):
|
|
@classmethod
|
def setUpClass(cls):
|
style.SetGlobalStyle(style.CreatePEP8Style())
|
|
def testIndent4(self):
|
unformatted_code = textwrap.dedent("""\
|
if a+b:
|
pass
|
""")
|
expected_formatted_code = textwrap.dedent("""\
|
if a + b:
|
pass
|
""")
|
uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
|
self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
|
|
def testSingleLineIfStatements(self):
|
code = textwrap.dedent("""\
|
if True: a = 42
|
elif False: b = 42
|
else: c = 42
|
""")
|
uwlines = yapf_test_helper.ParseAndUnwrap(code)
|
self.assertCodeEqual(code, reformatter.Reformat(uwlines))
|
|
def testNoBlankBetweenClassAndDef(self):
|
unformatted_code = textwrap.dedent("""\
|
class Foo:
|
|
def joe():
|
pass
|
""")
|
expected_formatted_code = textwrap.dedent("""\
|
class Foo:
|
def joe():
|
pass
|
""")
|
uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
|
self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
|
|
def testSingleWhiteBeforeTrailingComment(self):
|
unformatted_code = textwrap.dedent("""\
|
if a+b: # comment
|
pass
|
""")
|
expected_formatted_code = textwrap.dedent("""\
|
if a + b: # comment
|
pass
|
""")
|
uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
|
self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
|
|
def testSpaceBetweenEndingCommandAndClosingBracket(self):
|
unformatted_code = textwrap.dedent("""\
|
a = (
|
1,
|
)
|
""")
|
expected_formatted_code = textwrap.dedent("""\
|
a = (1, )
|
""")
|
uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
|
self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
|
|
def testContinuedNonOutdentedLine(self):
|
code = textwrap.dedent("""\
|
class eld(d):
|
if str(geom.geom_type).upper(
|
) != self.geom_type and not self.geom_type == 'GEOMETRY':
|
ror(code='om_type')
|
""")
|
uwlines = yapf_test_helper.ParseAndUnwrap(code)
|
self.assertCodeEqual(code, reformatter.Reformat(uwlines))
|
|
def testWrappingPercentExpressions(self):
|
unformatted_code = textwrap.dedent("""\
|
def f():
|
if True:
|
zzzzz = '%s-%s' % (xxxxxxxxxxxxxxxxxxxxxxxxxx + 1, xxxxxxxxxxxxxxxxx.yyy + 1)
|
zzzzz = '%s-%s'.ww(xxxxxxxxxxxxxxxxxxxxxxxxxx + 1, xxxxxxxxxxxxxxxxx.yyy + 1)
|
zzzzz = '%s-%s' % (xxxxxxxxxxxxxxxxxxxxxxx + 1, xxxxxxxxxxxxxxxxxxxxx + 1)
|
zzzzz = '%s-%s'.ww(xxxxxxxxxxxxxxxxxxxxxxx + 1, xxxxxxxxxxxxxxxxxxxxx + 1)
|
""")
|
expected_formatted_code = textwrap.dedent("""\
|
def f():
|
if True:
|
zzzzz = '%s-%s' % (xxxxxxxxxxxxxxxxxxxxxxxxxx + 1,
|
xxxxxxxxxxxxxxxxx.yyy + 1)
|
zzzzz = '%s-%s'.ww(xxxxxxxxxxxxxxxxxxxxxxxxxx + 1,
|
xxxxxxxxxxxxxxxxx.yyy + 1)
|
zzzzz = '%s-%s' % (xxxxxxxxxxxxxxxxxxxxxxx + 1,
|
xxxxxxxxxxxxxxxxxxxxx + 1)
|
zzzzz = '%s-%s'.ww(xxxxxxxxxxxxxxxxxxxxxxx + 1,
|
xxxxxxxxxxxxxxxxxxxxx + 1)
|
""")
|
uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
|
self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
|
|
def testAlignClosingBracketWithVisualIndentation(self):
|
unformatted_code = textwrap.dedent("""\
|
TEST_LIST = ('foo', 'bar', # first comment
|
'baz' # second comment
|
)
|
""")
|
expected_formatted_code = textwrap.dedent("""\
|
TEST_LIST = (
|
'foo',
|
'bar', # first comment
|
'baz' # second comment
|
)
|
""")
|
uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
|
self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
|
|
unformatted_code = textwrap.dedent("""\
|
def f():
|
|
def g():
|
while (xxxxxxxxxxxxxxxxxxxx(yyyyyyyyyyyyy[zzzzz]) == 'aaaaaaaaaaa' and
|
xxxxxxxxxxxxxxxxxxxx(yyyyyyyyyyyyy[zzzzz].aaaaaaaa[0]) == 'bbbbbbb'
|
):
|
pass
|
""")
|
expected_formatted_code = textwrap.dedent("""\
|
def f():
|
def g():
|
while (xxxxxxxxxxxxxxxxxxxx(yyyyyyyyyyyyy[zzzzz]) == 'aaaaaaaaaaa'
|
and xxxxxxxxxxxxxxxxxxxx(
|
yyyyyyyyyyyyy[zzzzz].aaaaaaaa[0]) == 'bbbbbbb'):
|
pass
|
""")
|
uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
|
self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
|
|
def testIndentSizeChanging(self):
|
unformatted_code = textwrap.dedent("""\
|
if True:
|
runtime_mins = (program_end_time - program_start_time).total_seconds() / 60.0
|
""")
|
expected_formatted_code = textwrap.dedent("""\
|
if True:
|
runtime_mins = (
|
program_end_time - program_start_time).total_seconds() / 60.0
|
""")
|
uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
|
self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
|
|
def testHangingIndentCollision(self):
|
unformatted_code = textwrap.dedent("""\
|
if (aaaaaaaaaaaaaa + bbbbbbbbbbbbbbbb == ccccccccccccccccc and xxxxxxxxxxxxx or yyyyyyyyyyyyyyyyy):
|
pass
|
elif (xxxxxxxxxxxxxxx(aaaaaaaaaaa, bbbbbbbbbbbbbb, cccccccccccc, dddddddddd=None)):
|
pass
|
|
|
def h():
|
if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'):
|
pass
|
|
for connection in itertools.chain(branch.contact, branch.address, morestuff.andmore.andmore.andmore.andmore.andmore.andmore.andmore):
|
dosomething(connection)
|
""")
|
expected_formatted_code = textwrap.dedent("""\
|
if (aaaaaaaaaaaaaa + bbbbbbbbbbbbbbbb == ccccccccccccccccc and xxxxxxxxxxxxx
|
or yyyyyyyyyyyyyyyyy):
|
pass
|
elif (xxxxxxxxxxxxxxx(
|
aaaaaaaaaaa, bbbbbbbbbbbbbb, cccccccccccc, dddddddddd=None)):
|
pass
|
|
|
def h():
|
if (xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0]) == 'aaaaaaaaaaa' and
|
xxxxxxxxxxxx.yyyyyyyy(zzzzzzzzzzzzz[0].mmmmmmmm[0]) == 'bbbbbbb'):
|
pass
|
|
for connection in itertools.chain(
|
branch.contact, branch.address,
|
morestuff.andmore.andmore.andmore.andmore.andmore.andmore.andmore):
|
dosomething(connection)
|
""")
|
uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
|
self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
|
|
def testSplittingBeforeLogicalOperator(self):
|
try:
|
style.SetGlobalStyle(
|
style.CreateStyleFromConfig(
|
'{based_on_style: pep8, split_before_logical_operator: True}'))
|
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
|
update.message.delete_chat_photo or update.message.group_chat_created or
|
update.message.supergroup_chat_created or update.message.channel_chat_created
|
or update.message.migrate_to_chat_id or update.message.migrate_from_chat_id or
|
update.message.pinned_message)
|
""")
|
expected_formatted_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 update.message.delete_chat_photo
|
or update.message.group_chat_created
|
or update.message.supergroup_chat_created
|
or update.message.channel_chat_created
|
or update.message.migrate_to_chat_id
|
or update.message.migrate_from_chat_id
|
or update.message.pinned_message)
|
""")
|
uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
|
self.assertCodeEqual(expected_formatted_code,
|
reformatter.Reformat(uwlines))
|
finally:
|
style.SetGlobalStyle(style.CreatePEP8Style())
|
|
def testContiguousListEndingWithComment(self):
|
unformatted_code = textwrap.dedent("""\
|
if True:
|
if True:
|
keys.append(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) # may be unassigned.
|
""")
|
expected_formatted_code = textwrap.dedent("""\
|
if True:
|
if True:
|
keys.append(
|
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) # may be unassigned.
|
""")
|
uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
|
self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
|
|
def testSplittingBeforeFirstArgument(self):
|
try:
|
style.SetGlobalStyle(
|
style.CreateStyleFromConfig(
|
'{based_on_style: pep8, split_before_first_argument: True}'))
|
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)
|
""")
|
expected_formatted_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)
|
""")
|
uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
|
self.assertCodeEqual(expected_formatted_code,
|
reformatter.Reformat(uwlines))
|
finally:
|
style.SetGlobalStyle(style.CreatePEP8Style())
|
|
def testSplittingExpressionsInsideSubscripts(self):
|
unformatted_code = textwrap.dedent("""\
|
def foo():
|
df = df[(df['campaign_status'] == 'LIVE') & (df['action_status'] == 'LIVE')]
|
""")
|
expected_formatted_code = textwrap.dedent("""\
|
def foo():
|
df = df[(df['campaign_status'] == 'LIVE')
|
& (df['action_status'] == 'LIVE')]
|
""")
|
uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
|
self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
|
|
def testSplitListsAndDictSetMakersIfCommaTerminated(self):
|
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("""\
|
DJANGO_TEMPLATES_OPTIONS = {"context_processors": []}
|
DJANGO_TEMPLATES_OPTIONS = {
|
"context_processors": [],
|
}
|
x = ["context_processors"]
|
x = [
|
"context_processors",
|
]
|
""")
|
uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
|
self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
|
|
def testSplitAroundNamedAssigns(self):
|
unformatted_code = textwrap.dedent("""\
|
class a():
|
def a(): return a(
|
aaaaaaaaaa=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)
|
""")
|
expected_formatted_code = textwrap.dedent("""\
|
class a():
|
def a():
|
return a(
|
aaaaaaaaaa=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
|
)
|
""")
|
uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
|
self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
|
|
def testUnaryOperator(self):
|
unformatted_code = textwrap.dedent("""\
|
if not -3 < x < 3:
|
pass
|
if -3 < x < 3:
|
pass
|
""")
|
expected_formatted_code = textwrap.dedent("""\
|
if not -3 < x < 3:
|
pass
|
if -3 < x < 3:
|
pass
|
""")
|
uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
|
self.assertCodeEqual(expected_formatted_code, reformatter.Reformat(uwlines))
|
|
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("""\
|
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."),
|
}
|
""")
|
expected_formatted_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."
|
),
|
}
|
""")
|
uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
|
self.assertCodeEqual(expected_formatted_code,
|
reformatter.Reformat(uwlines))
|
|
unformatted_code = textwrap.dedent("""\
|
X = {'a': 1, 'b': 2, 'key': this_is_a_function_call_that_goes_over_the_column_limit_im_pretty_sure()}
|
""")
|
expected_formatted_code = textwrap.dedent("""\
|
X = {
|
'a': 1,
|
'b': 2,
|
'key': this_is_a_function_call_that_goes_over_the_column_limit_im_pretty_sure()
|
}
|
""")
|
uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
|
self.assertCodeEqual(expected_formatted_code,
|
reformatter.Reformat(uwlines))
|
|
unformatted_code = textwrap.dedent("""\
|
attrs = {
|
'category': category,
|
'role': forms.ModelChoiceField(label=_("Role"), required=False, queryset=category_roles, initial=selected_role, empty_label=_("No access"),),
|
}
|
""")
|
expected_formatted_code = textwrap.dedent("""\
|
attrs = {
|
'category': category,
|
'role': forms.ModelChoiceField(
|
label=_("Role"),
|
required=False,
|
queryset=category_roles,
|
initial=selected_role,
|
empty_label=_("No access"),
|
),
|
}
|
""")
|
uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
|
self.assertCodeEqual(expected_formatted_code,
|
reformatter.Reformat(uwlines))
|
|
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."),
|
)
|
""")
|
expected_formatted_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."
|
),
|
)
|
""")
|
uwlines = yapf_test_helper.ParseAndUnwrap(unformatted_code)
|
self.assertCodeEqual(expected_formatted_code,
|
reformatter.Reformat(uwlines))
|
finally:
|
style.SetGlobalStyle(style.CreatePEP8Style())
|
|
|
if __name__ == '__main__':
|
unittest.main()
|
