def testFormatFileLinesSelection(self):
unformatted_code = textwrap.dedent(u"""\
if a: b
if f: g
if h: i
""")
expected_formatted_code_lines1and2 = textwrap.dedent(u"""\
if a: b
if f: g
if h: i
""")
expected_formatted_code_lines3 = textwrap.dedent(u"""\
if a: b
if f: g
if h: i
""")
with utils.TempFileContents(self.test_tmpdir,
unformatted_code) as filepath:
formatted_code, _, _ = yapf_api.FormatFile(filepath,
style_config='pep8',
lines=[(1, 2)])
self.assertCodeEqual(expected_formatted_code_lines1and2,
formatted_code)
formatted_code, _, _ = yapf_api.FormatFile(filepath,
style_config='pep8',
lines=[(3, 3)])
self.assertCodeEqual(expected_formatted_code_lines3,
formatted_code)
def testUseTabsContinuationAlignStyleVAlignRight(self):
unformatted_code = """\
def foo_function(arg1, arg2, arg3):
return ['hello', 'world',]
"""
expected_formatted_code = """\
def foo_function(arg1, arg2,
arg3):
return [
'hello',
'world',
]
"""
style_contents = u"""\
[style]
based_on_style = chromium
USE_TABS = true
COLUMN_LIMIT=32
INDENT_WIDTH=4
CONTINUATION_INDENT_WIDTH=8
CONTINUATION_ALIGN_STYLE = valign-right
"""
with utils.TempFileContents(self.test_tmpdir,
style_contents) as stylepath:
self.assertYapfReformats(
unformatted_code,
expected_formatted_code,
extra_options=['--style={0}'.format(stylepath)])
def testDisabledSemiColonSeparatedStatements(self):
code = textwrap.dedent(u"""\
# yapf: disable
if True: a ; b
""")
with utils.TempFileContents(self.test_tmpdir, code) as filepath:
formatted_code, _, _ = yapf_api.FormatFile(filepath, style_config='pep8')
self.assertCodeEqual(code, formatted_code)
def testFormatFileDiff(self):
unformatted_code = textwrap.dedent(u"""\
if True:
pass
""")
with utils.TempFileContents(self.test_tmpdir, unformatted_code) as filepath:
diff, _, _ = yapf_api.FormatFile(filepath, print_diff=True)
self.assertTrue(u'+ pass' in diff)
def testDisablePartOfMultilineComment(self):
unformatted_code = textwrap.dedent(u"""\
if a: b
# This is a multiline comment that disables YAPF.
# yapf: disable
if f: g
# yapf: enable
# This is a multiline comment that enables YAPF.
if h: i
""")
expected_formatted_code = textwrap.dedent(u"""\
if a: b
# This is a multiline comment that disables YAPF.
# yapf: disable
if f: g
# yapf: enable
# This is a multiline comment that enables YAPF.
if h: i
""")
with utils.TempFileContents(self.test_tmpdir,
unformatted_code) as filepath:
formatted_code, _, _ = yapf_api.FormatFile(filepath,
style_config='pep8')
self.assertCodeEqual(expected_formatted_code, formatted_code)
code = textwrap.dedent(u"""\
def foo_function():
# some comment
# yapf: disable
foo(
bar,
baz
)
# yapf: enable
""")
with utils.TempFileContents(self.test_tmpdir, code) as filepath:
formatted_code, _, _ = yapf_api.FormatFile(filepath,
style_config='pep8')
self.assertCodeEqual(code, formatted_code)
def testDefaultBasedOnStyle(self):
cfg = textwrap.dedent(u'''\
[style]
continuation_indent_width = 20
''')
with utils.TempFileContents(self.test_tmpdir, cfg) as filepath:
cfg = style.CreateStyleFromConfig(filepath)
self.assertTrue(_LooksLikePEP8Style(cfg))
self.assertEqual(cfg['CONTINUATION_INDENT_WIDTH'], 20)
def testErrorNoStyleSection(self):
cfg = textwrap.dedent(u'''\
[s]
indent_width=2
''')
with utils.TempFileContents(self.test_tmpdir, cfg) as filepath:
with self.assertRaisesRegexp(style.StyleConfigError,
'Unable to find section'):
style.CreateStyleFromConfig(filepath)
def testDisabledHorizontalFormattingOnNewLine(self):
code = textwrap.dedent(u"""\
# yapf: disable
a = [
1]
# yapf: enable
""")
with utils.TempFileContents(self.test_tmpdir, code) as filepath:
formatted_code, _, _ = yapf_api.FormatFile(filepath, style_config='pep8')
self.assertCodeEqual(code, formatted_code)
def testUnicodeEncodingPipedToFile(self):
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:
subprocess.check_call(YAPF_BINARY + ['--diff', filepath], stdout=out)
def testErrorUnknownStyleOption(self):
cfg = textwrap.dedent(u'''\
[style]
indent_width=2
hummus=2
''')
with utils.TempFileContents(self.test_tmpdir, cfg) as filepath:
with self.assertRaisesRegexp(style.StyleConfigError,
'Unknown style option'):
style.CreateStyleFromConfig(filepath)
def testInPlaceReformattingEmpty(self):
unformatted_code = u''
expected_formatted_code = u''
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:
reformatted_code = fd.read()
self.assertEqual(reformatted_code, expected_formatted_code)
def testStringListOptionValue(self):
cfg = textwrap.dedent(u'''\
[style]
based_on_style = pep8
I18N_FUNCTION_CALL = N_, V_, T_
''')
with utils.TempFileContents(self.test_tmpdir, cfg) as filepath:
cfg = style.CreateStyleFromConfig(filepath)
self.assertTrue(_LooksLikePEP8Style(cfg))
self.assertEqual(cfg['I18N_FUNCTION_CALL'], ['N_', 'V_', 'T_'])
def testCommentsUnformatted(self):
code = textwrap.dedent(u"""\
foo = [# A list of things
# bork
'one',
# quark
'two'] # yapf: disable
""")
with utils.TempFileContents(self.test_tmpdir, code) as filepath:
formatted_code, _, _ = yapf_api.FormatFile(filepath, style_config='pep8')
self.assertCodeEqual(code, formatted_code)
def testBoolOptionValue(self):
cfg = textwrap.dedent(u'''\
[style]
based_on_style = pep8
SPLIT_BEFORE_NAMED_ASSIGNS=False
split_before_logical_operator = true
''')
with utils.TempFileContents(self.test_tmpdir, cfg) as filepath:
cfg = style.CreateStyleFromConfig(filepath)
self.assertTrue(_LooksLikePEP8Style(cfg))
self.assertEqual(cfg['SPLIT_BEFORE_NAMED_ASSIGNS'], False)
self.assertEqual(cfg['SPLIT_BEFORE_LOGICAL_OPERATOR'], True)
def testEncodingVerification(self):
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:
subprocess.check_call(YAPF_BINARY + ['--diff', filepath], stdout=out)
def testEncodingVerification(self):
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:
try:
subprocess.check_call(YAPF_BINARY + ['--diff', filepath], stdout=out)
except subprocess.CalledProcessError as e:
self.assertEqual(e.returncode, 1) # Indicates the text changed.
def testInPlaceReformatting(self):
unformatted_code = textwrap.dedent(u"""\
def foo():
x = 37
""")
expected_formatted_code = textwrap.dedent("""\
def foo():
x = 37
""")
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:
reformatted_code = fd.read()
self.assertEqual(reformatted_code, expected_formatted_code)
def testSemicolonStatementsDisabled(self):
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"""\
def f():
x = y + 42 ; z = n * 42 # yapf: disable
if True:
a += 1
b += 1
c += 1
""")
with utils.TempFileContents(self.test_tmpdir, unformatted_code) as filepath:
formatted_code, _, _ = yapf_api.FormatFile(filepath, style_config='pep8')
self.assertCodeEqual(expected_formatted_code, formatted_code)
def testFormatFileInPlace(self):
unformatted_code = u'True==False\n'
formatted_code = u'True == False\n'
with utils.TempFileContents(self.test_tmpdir, unformatted_code) as filepath:
result, _, _ = yapf_api.FormatFile(filepath, in_place=True)
self.assertEqual(result, None)
with open(filepath) as fd:
if sys.version_info[0] <= 2:
self.assertCodeEqual(formatted_code, fd.read().decode('ascii'))
else:
self.assertCodeEqual(formatted_code, fd.read())
self.assertRaises(
ValueError,
yapf_api.FormatFile,
filepath,
in_place=True,
print_diff=True)
def testSetCustomStyleBasedOnChromium(self):
unformatted_code = textwrap.dedent("""\
def foo(): # trail
x = 37
""")
expected_formatted_code = textwrap.dedent("""\
def foo(): # trail
x = 37
""")
style_file = textwrap.dedent(u'''\
[style]
based_on_style = chromium
SPACES_BEFORE_COMMENT = 4
''')
with utils.TempFileContents(self.test_tmpdir, style_file) as stylepath:
self.assertYapfReformats(
unformatted_code,
expected_formatted_code,
extra_options=['--style={0}'.format(stylepath)])
def testDisabledWithPrecedingText(self):
code = textwrap.dedent(u"""\
# TODO(fix formatting): yapf: disable
A = [
{
"aaaaaaaaaaaaaaaaaaa": '''
bbbbbbbbbbb: "ccccccccccc"
dddddddddddddd: 1
eeeeeeee: 0
ffffffffff: "ggggggg"
''',
},
]
""")
with utils.TempFileContents(self.test_tmpdir, code) as filepath:
formatted_code, _, _ = yapf_api.FormatFile(filepath,
style_config='chromium')
self.assertCodeEqual(code, formatted_code)
def testDisabledMultilineStringInDictionary(self):
code = textwrap.dedent(u"""\
# yapf: disable
A = [
{
"aaaaaaaaaaaaaaaaaaa": '''
bbbbbbbbbbb: "ccccccccccc"
dddddddddddddd: 1
eeeeeeee: 0
ffffffffff: "ggggggg"
''',
},
]
""")
with utils.TempFileContents(self.test_tmpdir, code) as filepath:
formatted_code, _, _ = yapf_api.FormatFile(filepath,
style_config='chromium')
self.assertCodeEqual(code, formatted_code)
def testFormatFile(self):
unformatted_code = textwrap.dedent(u"""\
if True:
pass
""")
expected_formatted_code_pep8 = textwrap.dedent(u"""\
if True:
pass
""")
expected_formatted_code_chromium = textwrap.dedent(u"""\
if True:
pass
""")
with utils.TempFileContents(self.test_tmpdir, unformatted_code) as filepath:
formatted_code, _, _ = yapf_api.FormatFile(filepath, style_config='pep8')
self.assertCodeEqual(expected_formatted_code_pep8, formatted_code)
formatted_code, _, _ = yapf_api.FormatFile(
filepath, style_config='chromium')
self.assertCodeEqual(expected_formatted_code_chromium, formatted_code)
def testDisableLinesPattern(self):
unformatted_code = textwrap.dedent(u"""\
if a: b
# yapf: disable
if f: g
if h: i
""")
expected_formatted_code = textwrap.dedent(u"""\
if a: b
# yapf: disable
if f: g
if h: i
""")
with utils.TempFileContents(self.test_tmpdir, unformatted_code) as filepath:
formatted_code, _, _ = yapf_api.FormatFile(filepath, style_config='pep8')
self.assertCodeEqual(expected_formatted_code, formatted_code)
def testUseTabs(self):
unformatted_code = textwrap.dedent("""\
def foo_function():
if True:
pass
""")
expected_formatted_code = textwrap.dedent("""\
def foo_function():
if True:
pass
""")
style_contents = textwrap.dedent(u'''\
[style]
based_on_style = chromium
USE_TABS = true
INDENT_WIDTH=1
''')
with utils.TempFileContents(self.test_tmpdir, style_contents) as stylepath:
self.assertYapfReformats(
unformatted_code,
expected_formatted_code,
extra_options=['--style={0}'.format(stylepath)])
def testUseTabsWith(self):
unformatted_code = """\
def f():
return ['hello', 'world',]
"""
expected_formatted_code = """\
def f():
return [
'hello',
'world',
]
"""
style_contents = u"""\
[style]
based_on_style = chromium
USE_TABS = true
INDENT_WIDTH=1
"""
with utils.TempFileContents(self.test_tmpdir,
style_contents) as stylepath:
self.assertYapfReformats(
unformatted_code,
expected_formatted_code,
extra_options=['--style={0}'.format(stylepath)])
def testCRLFLineEnding(self):
code = u'class _():\r\n pass\r\n'
with utils.TempFileContents(self.test_tmpdir, code) as filepath:
formatted_code, _, _ = yapf_api.FormatFile(filepath,
style_config='chromium')
self.assertCodeEqual(code, formatted_code)
