[config.git] / djavu-asus / elpy / rpc-venv / lib / python3.11 / site-packages / yapftests / comment_splicer_test.py

# Copyright 2015 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.
"""Tests for yapf.comment_splicer."""

import textwrap
import unittest

from yapf.pytree import comment_splicer
from yapf.pytree import pytree_utils

from yapftests import yapf_test_helper


class CommentSplicerTest(yapf_test_helper.YAPFTest):

  def _AssertNodeType(self, expected_type, node):
    self.assertEqual(expected_type, pytree_utils.NodeName(node))

  def _AssertNodeIsComment(self, node, text_in_comment=None):
    if pytree_utils.NodeName(node) == 'simple_stmt':
      self._AssertNodeType('COMMENT', node.children[0])
      node_value = node.children[0].value
    else:
      self._AssertNodeType('COMMENT', node)
      node_value = node.value
    if text_in_comment is not None:
      self.assertIn(text_in_comment, node_value)

  def _FindNthChildNamed(self, node, name, n=1):
    for i, child in enumerate(
        [c for c in node.pre_order() if pytree_utils.NodeName(c) == name]):
      if i == n - 1:
        return child
    raise RuntimeError('No Nth child for n={0}'.format(n))

  def testSimpleInline(self):
    code = textwrap.dedent("""\
        foo = 1 # and a comment
    """)
    tree = pytree_utils.ParseCodeToTree(code)
    comment_splicer.SpliceComments(tree)

    expr = tree.children[0].children[0]
    # Check that the expected node is still expr_stmt, but now it has 4 children
    # (before comment splicing it had 3), the last child being the comment.
    self._AssertNodeType('expr_stmt', expr)
    self.assertEqual(4, len(expr.children))
    comment_node = expr.children[3]
    self._AssertNodeIsComment(comment_node, '# and a comment')

  def testSimpleSeparateLine(self):
    code = textwrap.dedent("""\
        foo = 1
        # first comment
        bar = 2
    """)
    tree = pytree_utils.ParseCodeToTree(code)
    comment_splicer.SpliceComments(tree)

    # The comment should've been added to the root's children (now 4, including
    # the ENDMARKER in the end.
    self.assertEqual(4, len(tree.children))
    comment_node = tree.children[1]
    self._AssertNodeIsComment(comment_node)

  def testTwoLineComment(self):
    code = textwrap.dedent("""\
        foo = 1
        # first comment
        # second comment
        bar = 2
    """)
    tree = pytree_utils.ParseCodeToTree(code)
    comment_splicer.SpliceComments(tree)

    # This is similar to the single-line standalone comment.
    self.assertEqual(4, len(tree.children))
    self._AssertNodeIsComment(tree.children[1])

  def testCommentIsFirstChildInCompound(self):
    code = textwrap.dedent("""
        if x:
          # a comment
          foo = 1
    """)
    tree = pytree_utils.ParseCodeToTree(code)
    comment_splicer.SpliceComments(tree)

    # Look into the suite node under the 'if'. We don't care about the NEWLINE
    # leaf but the new COMMENT must be a child of the suite and before the
    # actual code leaf.
    if_suite = tree.children[0].children[3]
    self._AssertNodeType('NEWLINE', if_suite.children[0])
    self._AssertNodeIsComment(if_suite.children[1])

  def testCommentIsLastChildInCompound(self):
    code = textwrap.dedent("""\
        if x:
          foo = 1
          # a comment
    """)
    tree = pytree_utils.ParseCodeToTree(code)
    comment_splicer.SpliceComments(tree)

    # Look into the suite node under the 'if'. We don't care about the DEDENT
    # leaf but the new COMMENT must be a child of the suite and after the
    # actual code leaf.
    if_suite = tree.children[0].children[3]
    self._AssertNodeType('DEDENT', if_suite.children[-1])
    self._AssertNodeIsComment(if_suite.children[-2])

  def testInlineAfterSeparateLine(self):
    code = textwrap.dedent("""\
        bar = 1
        # line comment
        foo = 1 # inline comment
    """)
    tree = pytree_utils.ParseCodeToTree(code)
    comment_splicer.SpliceComments(tree)

    # The separate line comment should become a child of the root, while
    # the inline comment remains within its simple_node.
    sep_comment_node = tree.children[1]
    self._AssertNodeIsComment(sep_comment_node, '# line comment')

    expr = tree.children[2].children[0]
    inline_comment_node = expr.children[-1]
    self._AssertNodeIsComment(inline_comment_node, '# inline comment')

  def testSeparateLineAfterInline(self):
    code = textwrap.dedent("""\
        bar = 1
        foo = 1 # inline comment
        # line comment
    """)
    tree = pytree_utils.ParseCodeToTree(code)
    comment_splicer.SpliceComments(tree)

    # The separate line comment should become a child of the root, while
    # the inline comment remains within its simple_node.
    sep_comment_node = tree.children[-2]
    self._AssertNodeIsComment(sep_comment_node, '# line comment')

    expr = tree.children[1].children[0]
    inline_comment_node = expr.children[-1]
    self._AssertNodeIsComment(inline_comment_node, '# inline comment')

  def testCommentBeforeDedent(self):
    code = textwrap.dedent("""\
        if bar:
          z = 1
        # a comment
        j = 2
    """)
    tree = pytree_utils.ParseCodeToTree(code)
    comment_splicer.SpliceComments(tree)

    # The comment should go under the tree root, not under the 'if'.
    self._AssertNodeIsComment(tree.children[1])
    if_suite = tree.children[0].children[3]
    self._AssertNodeType('DEDENT', if_suite.children[-1])

  def testCommentBeforeDedentTwoLevel(self):
    code = textwrap.dedent("""\
        if foo:
          if bar:
            z = 1
          # a comment
        y = 1
    """)
    tree = pytree_utils.ParseCodeToTree(code)
    comment_splicer.SpliceComments(tree)

    if_suite = tree.children[0].children[3]
    # The comment is in the first if_suite, not the nested if under it. It's
    # right before the DEDENT
    self._AssertNodeIsComment(if_suite.children[-2])
    self._AssertNodeType('DEDENT', if_suite.children[-1])

  def testCommentBeforeDedentTwoLevelImproperlyIndented(self):
    code = textwrap.dedent("""\
        if foo:
          if bar:
            z = 1
           # comment 2
        y = 1
    """)
    tree = pytree_utils.ParseCodeToTree(code)
    comment_splicer.SpliceComments(tree)

    # The comment here is indented by 3 spaces, which is unlike any of the
    # surrounding statement indentation levels. The splicer attaches it to the
    # "closest" parent with smaller indentation.
    if_suite = tree.children[0].children[3]
    # The comment is in the first if_suite, not the nested if under it. It's
    # right before the DEDENT
    self._AssertNodeIsComment(if_suite.children[-2])
    self._AssertNodeType('DEDENT', if_suite.children[-1])

  def testCommentBeforeDedentThreeLevel(self):
    code = textwrap.dedent("""\
        if foo:
          if bar:
            z = 1
            # comment 2
          # comment 1
        # comment 0
        j = 2
    """)
    tree = pytree_utils.ParseCodeToTree(code)
    comment_splicer.SpliceComments(tree)

    # comment 0 should go under the tree root
    self._AssertNodeIsComment(tree.children[1], '# comment 0')

    # comment 1 is in the first if_suite, right before the DEDENT
    if_suite_1 = self._FindNthChildNamed(tree, 'suite', n=1)
    self._AssertNodeIsComment(if_suite_1.children[-2], '# comment 1')
    self._AssertNodeType('DEDENT', if_suite_1.children[-1])

    # comment 2 is in if_suite nested under the first if suite,
    # right before the DEDENT
    if_suite_2 = self._FindNthChildNamed(tree, 'suite', n=2)
    self._AssertNodeIsComment(if_suite_2.children[-2], '# comment 2')
    self._AssertNodeType('DEDENT', if_suite_2.children[-1])

  def testCommentsInClass(self):
    code = textwrap.dedent("""\
        class Foo:
          '''docstring abc...'''
          # top-level comment
          def foo(): pass
          # another comment
    """)

    tree = pytree_utils.ParseCodeToTree(code)
    comment_splicer.SpliceComments(tree)

    class_suite = tree.children[0].children[3]
    another_comment = class_suite.children[-2]
    self._AssertNodeIsComment(another_comment, '# another')

    # It's OK for the comment to be a child of funcdef, as long as it's
    # the first child and thus comes before the 'def'.
    funcdef = class_suite.children[3]
    toplevel_comment = funcdef.children[0]
    self._AssertNodeIsComment(toplevel_comment, '# top-level')

  def testMultipleBlockComments(self):
    code = textwrap.dedent("""\
        # Block comment number 1

        # Block comment number 2
        def f():
          pass
    """)

    tree = pytree_utils.ParseCodeToTree(code)
    comment_splicer.SpliceComments(tree)

    funcdef = tree.children[0]
    block_comment_1 = funcdef.children[0]
    self._AssertNodeIsComment(block_comment_1, '# Block comment number 1')

    block_comment_2 = funcdef.children[1]
    self._AssertNodeIsComment(block_comment_2, '# Block comment number 2')

  def testCommentsOnDedents(self):
    code = textwrap.dedent("""\
        class Foo(object):
          # A comment for qux.
          def qux(self):
            pass

          # Interim comment.

          def mux(self):
            pass
    """)

    tree = pytree_utils.ParseCodeToTree(code)
    comment_splicer.SpliceComments(tree)

    classdef = tree.children[0]
    class_suite = classdef.children[6]
    qux_comment = class_suite.children[1]
    self._AssertNodeIsComment(qux_comment, '# A comment for qux.')

    interim_comment = class_suite.children[4]
    self._AssertNodeIsComment(interim_comment, '# Interim comment.')

  def testExprComments(self):
    code = textwrap.dedent("""\
        foo( # Request fractions of an hour.
          948.0/3600, 20)
    """)
    tree = pytree_utils.ParseCodeToTree(code)
    comment_splicer.SpliceComments(tree)

    trailer = self._FindNthChildNamed(tree, 'trailer', 1)
    comment = trailer.children[1]
    self._AssertNodeIsComment(comment, '# Request fractions of an hour.')

  def testMultipleCommentsInOneExpr(self):
    code = textwrap.dedent("""\
        foo( # com 1
          948.0/3600, # com 2
          20 + 12 # com 3
          )
    """)
    tree = pytree_utils.ParseCodeToTree(code)
    comment_splicer.SpliceComments(tree)

    trailer = self._FindNthChildNamed(tree, 'trailer', 1)
    self._AssertNodeIsComment(trailer.children[1], '# com 1')

    arglist = self._FindNthChildNamed(tree, 'arglist', 1)
    self._AssertNodeIsComment(arglist.children[2], '# com 2')

    arith_expr = self._FindNthChildNamed(tree, 'arith_expr', 1)
    self._AssertNodeIsComment(arith_expr.children[-1], '# com 3')


if __name__ == '__main__':
  unittest.main()
Commit	Line	Data
53e6db90 DC	1	# Copyright 2015 Google Inc. All Rights Reserved.
	2	#
	3	# Licensed under the Apache License, Version 2.0 (the "License");
	4	# you may not use this file except in compliance with the License.
	5	# You may obtain a copy of the License at
	6	#
	7	# http://www.apache.org/licenses/LICENSE-2.0
	8	#
	9	# Unless required by applicable law or agreed to in writing, software
	10	# distributed under the License is distributed on an "AS IS" BASIS,
	11	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	12	# See the License for the specific language governing permissions and
	13	# limitations under the License.
	14	"""Tests for yapf.comment_splicer."""
	15
	16	import textwrap
	17	import unittest
	18
	19	from yapf.pytree import comment_splicer
	20	from yapf.pytree import pytree_utils
	21
	22	from yapftests import yapf_test_helper
	23
	24
	25	class CommentSplicerTest(yapf_test_helper.YAPFTest):
	26
	27	def _AssertNodeType(self, expected_type, node):
	28	self.assertEqual(expected_type, pytree_utils.NodeName(node))
	29
	30	def _AssertNodeIsComment(self, node, text_in_comment=None):
	31	if pytree_utils.NodeName(node) == 'simple_stmt':
	32	self._AssertNodeType('COMMENT', node.children[0])
	33	node_value = node.children[0].value
	34	else:
	35	self._AssertNodeType('COMMENT', node)
	36	node_value = node.value
	37	if text_in_comment is not None:
	38	self.assertIn(text_in_comment, node_value)
	39
	40	def _FindNthChildNamed(self, node, name, n=1):
	41	for i, child in enumerate(
	42	[c for c in node.pre_order() if pytree_utils.NodeName(c) == name]):
	43	if i == n - 1:
	44	return child
	45	raise RuntimeError('No Nth child for n={0}'.format(n))
	46
	47	def testSimpleInline(self):
	48	code = textwrap.dedent("""\
	49	foo = 1 # and a comment
	50	""")
	51	tree = pytree_utils.ParseCodeToTree(code)
	52	comment_splicer.SpliceComments(tree)
	53
	54	expr = tree.children[0].children[0]
	55	# Check that the expected node is still expr_stmt, but now it has 4 children
	56	# (before comment splicing it had 3), the last child being the comment.
	57	self._AssertNodeType('expr_stmt', expr)
	58	self.assertEqual(4, len(expr.children))
	59	comment_node = expr.children[3]
	60	self._AssertNodeIsComment(comment_node, '# and a comment')
	61
	62	def testSimpleSeparateLine(self):
	63	code = textwrap.dedent("""\
	64	foo = 1
65	# first comment
66	bar = 2
67	""")
68	tree = pytree_utils.ParseCodeToTree(code)
69	comment_splicer.SpliceComments(tree)
70
71	# The comment should've been added to the root's children (now 4, including
72	# the ENDMARKER in the end.
73	self.assertEqual(4, len(tree.children))
74	comment_node = tree.children[1]
75	self._AssertNodeIsComment(comment_node)
76
77	def testTwoLineComment(self):
78	code = textwrap.dedent("""\
79	foo = 1
80	# first comment
81	# second comment
82	bar = 2
83	""")
84	tree = pytree_utils.ParseCodeToTree(code)
85	comment_splicer.SpliceComments(tree)
86
87	# This is similar to the single-line standalone comment.
88	self.assertEqual(4, len(tree.children))
89	self._AssertNodeIsComment(tree.children[1])
90
91	def testCommentIsFirstChildInCompound(self):
92	code = textwrap.dedent("""
93	if x:
94	# a comment
95	foo = 1
96	""")
97	tree = pytree_utils.ParseCodeToTree(code)
98	comment_splicer.SpliceComments(tree)
99
100	# Look into the suite node under the 'if'. We don't care about the NEWLINE
101	# leaf but the new COMMENT must be a child of the suite and before the
102	# actual code leaf.
103	if_suite = tree.children[0].children[3]
104	self._AssertNodeType('NEWLINE', if_suite.children[0])
105	self._AssertNodeIsComment(if_suite.children[1])
106
107	def testCommentIsLastChildInCompound(self):
108	code = textwrap.dedent("""\
109	if x:
110	foo = 1
111	# a comment
112	""")
113	tree = pytree_utils.ParseCodeToTree(code)
114	comment_splicer.SpliceComments(tree)
115
116	# Look into the suite node under the 'if'. We don't care about the DEDENT
117	# leaf but the new COMMENT must be a child of the suite and after the
118	# actual code leaf.
119	if_suite = tree.children[0].children[3]
120	self._AssertNodeType('DEDENT', if_suite.children[-1])
121	self._AssertNodeIsComment(if_suite.children[-2])
122
123	def testInlineAfterSeparateLine(self):
124	code = textwrap.dedent("""\
125	bar = 1
126	# line comment
127	foo = 1 # inline comment
128	""")
129	tree = pytree_utils.ParseCodeToTree(code)
130	comment_splicer.SpliceComments(tree)
131
132	# The separate line comment should become a child of the root, while
133	# the inline comment remains within its simple_node.
134	sep_comment_node = tree.children[1]
135	self._AssertNodeIsComment(sep_comment_node, '# line comment')
136
137	expr = tree.children[2].children[0]
138	inline_comment_node = expr.children[-1]
139	self._AssertNodeIsComment(inline_comment_node, '# inline comment')
140
141	def testSeparateLineAfterInline(self):
142	code = textwrap.dedent("""\
143	bar = 1
144	foo = 1 # inline comment
145	# line comment
146	""")
147	tree = pytree_utils.ParseCodeToTree(code)
148	comment_splicer.SpliceComments(tree)
149
150	# The separate line comment should become a child of the root, while
151	# the inline comment remains within its simple_node.
152	sep_comment_node = tree.children[-2]
153	self._AssertNodeIsComment(sep_comment_node, '# line comment')
154
155	expr = tree.children[1].children[0]
156	inline_comment_node = expr.children[-1]
157	self._AssertNodeIsComment(inline_comment_node, '# inline comment')
158
159	def testCommentBeforeDedent(self):
160	code = textwrap.dedent("""\
161	if bar:
162	z = 1
163	# a comment
164	j = 2
165	""")
166	tree = pytree_utils.ParseCodeToTree(code)
167	comment_splicer.SpliceComments(tree)
168
169	# The comment should go under the tree root, not under the 'if'.
170	self._AssertNodeIsComment(tree.children[1])
171	if_suite = tree.children[0].children[3]
172	self._AssertNodeType('DEDENT', if_suite.children[-1])
173
174	def testCommentBeforeDedentTwoLevel(self):
175	code = textwrap.dedent("""\
176	if foo:
177	if bar:
178	z = 1
179	# a comment
180	y = 1
181	""")
182	tree = pytree_utils.ParseCodeToTree(code)
183	comment_splicer.SpliceComments(tree)
184
185	if_suite = tree.children[0].children[3]
186	# The comment is in the first if_suite, not the nested if under it. It's
187	# right before the DEDENT
188	self._AssertNodeIsComment(if_suite.children[-2])
189	self._AssertNodeType('DEDENT', if_suite.children[-1])
190
191	def testCommentBeforeDedentTwoLevelImproperlyIndented(self):
192	code = textwrap.dedent("""\
193	if foo:
194	if bar:
195	z = 1
196	# comment 2
197	y = 1
198	""")
199	tree = pytree_utils.ParseCodeToTree(code)
200	comment_splicer.SpliceComments(tree)
201
202	# The comment here is indented by 3 spaces, which is unlike any of the
203	# surrounding statement indentation levels. The splicer attaches it to the
204	# "closest" parent with smaller indentation.
205	if_suite = tree.children[0].children[3]
206	# The comment is in the first if_suite, not the nested if under it. It's
207	# right before the DEDENT
208	self._AssertNodeIsComment(if_suite.children[-2])
209	self._AssertNodeType('DEDENT', if_suite.children[-1])
210
211	def testCommentBeforeDedentThreeLevel(self):
212	code = textwrap.dedent("""\
213	if foo:
214	if bar:
215	z = 1
216	# comment 2
217	# comment 1
218	# comment 0
219	j = 2
220	""")
221	tree = pytree_utils.ParseCodeToTree(code)
222	comment_splicer.SpliceComments(tree)
223
224	# comment 0 should go under the tree root
225	self._AssertNodeIsComment(tree.children[1], '# comment 0')
226
227	# comment 1 is in the first if_suite, right before the DEDENT
228	if_suite_1 = self._FindNthChildNamed(tree, 'suite', n=1)
229	self._AssertNodeIsComment(if_suite_1.children[-2], '# comment 1')
230	self._AssertNodeType('DEDENT', if_suite_1.children[-1])
231
232	# comment 2 is in if_suite nested under the first if suite,
233	# right before the DEDENT
234	if_suite_2 = self._FindNthChildNamed(tree, 'suite', n=2)
235	self._AssertNodeIsComment(if_suite_2.children[-2], '# comment 2')
236	self._AssertNodeType('DEDENT', if_suite_2.children[-1])
237
238	def testCommentsInClass(self):
239	code = textwrap.dedent("""\
240	class Foo:
241	'''docstring abc...'''
242	# top-level comment
243	def foo(): pass
244	# another comment
245	""")
246
247	tree = pytree_utils.ParseCodeToTree(code)
248	comment_splicer.SpliceComments(tree)
249
250	class_suite = tree.children[0].children[3]
251	another_comment = class_suite.children[-2]
252	self._AssertNodeIsComment(another_comment, '# another')
253
254	# It's OK for the comment to be a child of funcdef, as long as it's
255	# the first child and thus comes before the 'def'.
256	funcdef = class_suite.children[3]
257	toplevel_comment = funcdef.children[0]
258	self._AssertNodeIsComment(toplevel_comment, '# top-level')
259
260	def testMultipleBlockComments(self):
261	code = textwrap.dedent("""\
262	# Block comment number 1
263
264	# Block comment number 2
265	def f():
266	pass
267	""")
268
269	tree = pytree_utils.ParseCodeToTree(code)
270	comment_splicer.SpliceComments(tree)
271
272	funcdef = tree.children[0]
273	block_comment_1 = funcdef.children[0]
274	self._AssertNodeIsComment(block_comment_1, '# Block comment number 1')
275
276	block_comment_2 = funcdef.children[1]
277	self._AssertNodeIsComment(block_comment_2, '# Block comment number 2')
278
279	def testCommentsOnDedents(self):
280	code = textwrap.dedent("""\
281	class Foo(object):
282	# A comment for qux.
283	def qux(self):
284	pass
285
286	# Interim comment.
287
288	def mux(self):
289	pass
290	""")
291
292	tree = pytree_utils.ParseCodeToTree(code)
293	comment_splicer.SpliceComments(tree)
294
295	classdef = tree.children[0]
296	class_suite = classdef.children[6]
297	qux_comment = class_suite.children[1]
298	self._AssertNodeIsComment(qux_comment, '# A comment for qux.')
299
300	interim_comment = class_suite.children[4]
301	self._AssertNodeIsComment(interim_comment, '# Interim comment.')
302
303	def testExprComments(self):
304	code = textwrap.dedent("""\
305	foo( # Request fractions of an hour.
306	948.0/3600, 20)
307	""")
308	tree = pytree_utils.ParseCodeToTree(code)
309	comment_splicer.SpliceComments(tree)
310
311	trailer = self._FindNthChildNamed(tree, 'trailer', 1)
312	comment = trailer.children[1]
313	self._AssertNodeIsComment(comment, '# Request fractions of an hour.')
314
315	def testMultipleCommentsInOneExpr(self):
316	code = textwrap.dedent("""\
317	foo( # com 1
318	948.0/3600, # com 2
319	20 + 12 # com 3
320	)
321	""")
322	tree = pytree_utils.ParseCodeToTree(code)
323	comment_splicer.SpliceComments(tree)
324
325	trailer = self._FindNthChildNamed(tree, 'trailer', 1)
326	self._AssertNodeIsComment(trailer.children[1], '# com 1')
327
328	arglist = self._FindNthChildNamed(tree, 'arglist', 1)
329	self._AssertNodeIsComment(arglist.children[2], '# com 2')
330
331	arith_expr = self._FindNthChildNamed(tree, 'arith_expr', 1)
332	self._AssertNodeIsComment(arith_expr.children[-1], '# com 3')
333
334
335	if __name__ == '__main__':
336	unittest.main()