From d57c9c186bb3eeb9b8d2a7672eadf2dfdcd7be62 Mon Sep 17 00:00:00 2001 From: JHertz5 Date: Sun, 20 Oct 2024 15:03:37 +0100 Subject: [PATCH] Issue#1273: Added rules to enforce `in` keywords in for loops/generates (#1274) * Issue#1273: Added rules for_generate_statement_502 and iteration_scheme_502. * Issue#1273: Added tests for rules for_generate_statement_502 and iteration_scheme_502. * Issue#1273: Added documentation for rules for_generate_statement_502 and iteration_scheme_502. --- ...figuring_uppercase_and_lowercase_rules.rst | 2 + docs/for_generate_statement_rules.rst | 21 ++++++ docs/iteration_scheme_rules.rst | 21 ++++++ docs/rule_groups/case_keyword_rule_group.rst | 2 + docs/rule_groups/case_rule_group.rst | 2 + tests/for_generate_statement/__init__.py | 0 .../rule_502_test_input.fixed_lower.vhd | 14 ++++ .../rule_502_test_input.fixed_upper.vhd | 14 ++++ .../rule_502_test_input.vhd | 14 ++++ tests/for_generate_statement/test_rule_502.py | 73 ++++++++++++++++++ .../rule_502_test_input.fixed_lower.vhd | 14 ++++ .../rule_502_test_input.fixed_upper.vhd | 14 ++++ .../iteration_scheme/rule_502_test_input.vhd | 14 ++++ tests/iteration_scheme/test_rule_502.py | 74 +++++++++++++++++++ vsg/rules/for_generate_statement/__init__.py | 1 + vsg/rules/for_generate_statement/rule_502.py | 34 +++++++++ vsg/rules/iteration_scheme/__init__.py | 1 + vsg/rules/iteration_scheme/rule_502.py | 34 +++++++++ 18 files changed, 349 insertions(+) create mode 100644 tests/for_generate_statement/__init__.py create mode 100644 tests/for_generate_statement/rule_502_test_input.fixed_lower.vhd create mode 100644 tests/for_generate_statement/rule_502_test_input.fixed_upper.vhd create mode 100644 tests/for_generate_statement/rule_502_test_input.vhd create mode 100644 tests/for_generate_statement/test_rule_502.py create mode 100644 tests/iteration_scheme/rule_502_test_input.fixed_lower.vhd create mode 100644 tests/iteration_scheme/rule_502_test_input.fixed_upper.vhd create mode 100644 tests/iteration_scheme/rule_502_test_input.vhd create mode 100644 tests/iteration_scheme/test_rule_502.py create mode 100644 vsg/rules/for_generate_statement/rule_502.py create mode 100644 vsg/rules/iteration_scheme/rule_502.py diff --git a/docs/configuring_uppercase_and_lowercase_rules.rst b/docs/configuring_uppercase_and_lowercase_rules.rst index 372e9379..37e193f6 100644 --- a/docs/configuring_uppercase_and_lowercase_rules.rst +++ b/docs/configuring_uppercase_and_lowercase_rules.rst @@ -324,6 +324,7 @@ Rules Enforcing Case * `for_generate_statement_500 `_ * `for_generate_statement_501 `_ +* `for_generate_statement_502 `_ * `function_004 `_ * `function_005 `_ @@ -370,6 +371,7 @@ Rules Enforcing Case * `iteration_scheme_500 `_ * `iteration_scheme_501 `_ +* `iteration_scheme_502 `_ * `library_004 `_ * `library_005 `_ diff --git a/docs/for_generate_statement_rules.rst b/docs/for_generate_statement_rules.rst index 421e27e8..f9c01e38 100644 --- a/docs/for_generate_statement_rules.rst +++ b/docs/for_generate_statement_rules.rst @@ -44,3 +44,24 @@ This rule checks the *generate* keyword has proper case. .. code-block:: vhdl for x in range (3 downto 0) generate + +for_generate_statement_502 +########################## + +|phase_6| |error| |case| |case_keyword| + +This rule checks the **in** keyword has proper case. + +|configuring_uppercase_and_lowercase_rules_link| + +**Violation** + +.. code-block:: vhdl + + gen_label : for lv_thing IN t_thing generate + +**Fix** + +.. code-block:: vhdl + + gen_label : for lv_thing in t_thing generate diff --git a/docs/iteration_scheme_rules.rst b/docs/iteration_scheme_rules.rst index 1b1f32f1..8d9020df 100644 --- a/docs/iteration_scheme_rules.rst +++ b/docs/iteration_scheme_rules.rst @@ -151,3 +151,24 @@ This rule checks the **for** keyword has proper case. .. code-block:: vhdl for x in (31 downto 0) loop + +iteration_scheme_502 +#################### + +|phase_6| |error| |case| |case_keyword| + +This rule checks the **in** keyword has proper case. + +|configuring_uppercase_and_lowercase_rules_link| + +**Violation** + +.. code-block:: vhdl + + for lv_thing IN t_thing loop + +**Fix** + +.. code-block:: vhdl + + for lv_thing in t_thing loop diff --git a/docs/rule_groups/case_keyword_rule_group.rst b/docs/rule_groups/case_keyword_rule_group.rst index a9897316..5fe6c093 100644 --- a/docs/rule_groups/case_keyword_rule_group.rst +++ b/docs/rule_groups/case_keyword_rule_group.rst @@ -63,6 +63,7 @@ Rules Enforcing Case::Keyword Rule Group * `file_002 <../file_rules.html#file-002>`_ * `for_generate_statement_500 <../for_generate_statement_rules.html#for-generate-statement-500>`_ * `for_generate_statement_501 <../for_generate_statement_rules.html#for-generate-statement-501>`_ +* `for_generate_statement_502 <../for_generate_statement_rules.html#for-generate-statement-502>`_ * `function_004 <../function_rules.html#function-004>`_ * `function_005 <../function_rules.html#function-005>`_ * `function_013 <../function_rules.html#function-013>`_ @@ -91,6 +92,7 @@ Rules Enforcing Case::Keyword Rule Group * `instantiation_031 <../instantiation_rules.html#instantiation-031>`_ * `iteration_scheme_500 <../iteration_scheme_rules.html#iteration-scheme-500>`_ * `iteration_scheme_501 <../iteration_scheme_rules.html#iteration-scheme-501>`_ +* `iteration_scheme_502 <../iteration_scheme_rules.html#iteration-scheme-502>`_ * `library_004 <../library_rules.html#library-004>`_ * `library_005 <../library_rules.html#library-005>`_ * `logical_operator_500 <../logical_operator_rules.html#logical-operator-500>`_ diff --git a/docs/rule_groups/case_rule_group.rst b/docs/rule_groups/case_rule_group.rst index 36b4d729..f78914cc 100644 --- a/docs/rule_groups/case_rule_group.rst +++ b/docs/rule_groups/case_rule_group.rst @@ -89,6 +89,7 @@ Rules Enforcing Case Rule Group * `file_002 <../file_rules.html#file-002>`_ * `for_generate_statement_500 <../for_generate_statement_rules.html#for-generate-statement-500>`_ * `for_generate_statement_501 <../for_generate_statement_rules.html#for-generate-statement-501>`_ +* `for_generate_statement_502 <../for_generate_statement_rules.html#for-generate-statement-502>`_ * `function_004 <../function_rules.html#function-004>`_ * `function_005 <../function_rules.html#function-005>`_ * `function_010 <../function_rules.html#function-010>`_ @@ -127,6 +128,7 @@ Rules Enforcing Case Rule Group * `instantiation_031 <../instantiation_rules.html#instantiation-031>`_ * `iteration_scheme_500 <../iteration_scheme_rules.html#iteration-scheme-500>`_ * `iteration_scheme_501 <../iteration_scheme_rules.html#iteration-scheme-501>`_ +* `iteration_scheme_502 <../iteration_scheme_rules.html#iteration-scheme-502>`_ * `library_004 <../library_rules.html#library-004>`_ * `library_005 <../library_rules.html#library-005>`_ * `library_500 <../library_rules.html#library-500>`_ diff --git a/tests/for_generate_statement/__init__.py b/tests/for_generate_statement/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tests/for_generate_statement/rule_502_test_input.fixed_lower.vhd b/tests/for_generate_statement/rule_502_test_input.fixed_lower.vhd new file mode 100644 index 00000000..887afc6c --- /dev/null +++ b/tests/for_generate_statement/rule_502_test_input.fixed_lower.vhd @@ -0,0 +1,14 @@ + +architecture rtl of fifo is + +begin + + gen_label : for x in range (3 downto 0) generate + + end generate; + + gen_label : for x in range (3 downto 0) generate + + end generate; + +end architecture; diff --git a/tests/for_generate_statement/rule_502_test_input.fixed_upper.vhd b/tests/for_generate_statement/rule_502_test_input.fixed_upper.vhd new file mode 100644 index 00000000..6b4a9278 --- /dev/null +++ b/tests/for_generate_statement/rule_502_test_input.fixed_upper.vhd @@ -0,0 +1,14 @@ + +architecture rtl of fifo is + +begin + + gen_label : for x IN range (3 downto 0) generate + + end generate; + + gen_label : for x IN range (3 downto 0) generate + + end generate; + +end architecture; diff --git a/tests/for_generate_statement/rule_502_test_input.vhd b/tests/for_generate_statement/rule_502_test_input.vhd new file mode 100644 index 00000000..a60e4e7a --- /dev/null +++ b/tests/for_generate_statement/rule_502_test_input.vhd @@ -0,0 +1,14 @@ + +architecture rtl of fifo is + +begin + + gen_label : for x in range (3 downto 0) generate + + end generate; + + gen_label : for x IN range (3 downto 0) generate + + end generate; + +end architecture; diff --git a/tests/for_generate_statement/test_rule_502.py b/tests/for_generate_statement/test_rule_502.py new file mode 100644 index 00000000..171a4a9e --- /dev/null +++ b/tests/for_generate_statement/test_rule_502.py @@ -0,0 +1,73 @@ +# -*- coding: utf-8 -*- + +import os +import unittest + +from tests import utils +from vsg import vhdlFile +from vsg.rules import for_generate_statement + +sTestDir = os.path.dirname(__file__) + +lFile, eError = vhdlFile.utils.read_vhdlfile(os.path.join(sTestDir, "rule_502_test_input.vhd")) + +lExpected_lower = [] +lExpected_lower.append("") +utils.read_file(os.path.join(sTestDir, "rule_502_test_input.fixed_lower.vhd"), lExpected_lower) + +lExpected_upper = [] +lExpected_upper.append("") +utils.read_file(os.path.join(sTestDir, "rule_502_test_input.fixed_upper.vhd"), lExpected_upper) + + +class test_for_generate_statement_rule(unittest.TestCase): + def setUp(self): + self.oFile = vhdlFile.vhdlFile(lFile) + self.assertIsNone(eError) + + def test_rule_502_lower(self): + oRule = for_generate_statement.rule_502() + self.assertTrue(oRule) + self.assertEqual(oRule.name, "for_generate_statement") + self.assertEqual(oRule.identifier, "502") + + lExpected = [10] + + oRule.analyze(self.oFile) + self.assertEqual(utils.extract_violation_lines_from_violation_object(oRule.violations), lExpected) + + def test_rule_502_upper(self): + oRule = for_generate_statement.rule_502() + oRule.case = "upper" + self.assertTrue(oRule) + self.assertEqual(oRule.name, "for_generate_statement") + self.assertEqual(oRule.identifier, "502") + + lExpected = [6] + oRule.analyze(self.oFile) + self.assertEqual(utils.extract_violation_lines_from_violation_object(oRule.violations), lExpected) + + def test_fix_rule_502_lower(self): + oRule = for_generate_statement.rule_502() + + oRule.fix(self.oFile) + + lActual = self.oFile.get_lines() + + self.assertEqual(lExpected_lower, lActual) + + oRule.analyze(self.oFile) + self.assertEqual(oRule.violations, []) + + def test_fix_rule_502_upper(self): + oRule = for_generate_statement.rule_502() + oRule.case = "upper" + + oRule.fix(self.oFile) + + lActual = self.oFile.get_lines() + + self.assertEqual(lExpected_upper, lActual) + + oRule.analyze(self.oFile) + self.assertEqual(oRule.violations, []) diff --git a/tests/iteration_scheme/rule_502_test_input.fixed_lower.vhd b/tests/iteration_scheme/rule_502_test_input.fixed_lower.vhd new file mode 100644 index 00000000..60b02c7b --- /dev/null +++ b/tests/iteration_scheme/rule_502_test_input.fixed_lower.vhd @@ -0,0 +1,14 @@ + +architecture rtl of fifo is + +begin + + process begin + + for x in (31 downto 0) loop end loop; + + for x in (31 downto 0) loop end loop; + + end process; + +end; diff --git a/tests/iteration_scheme/rule_502_test_input.fixed_upper.vhd b/tests/iteration_scheme/rule_502_test_input.fixed_upper.vhd new file mode 100644 index 00000000..c6913e06 --- /dev/null +++ b/tests/iteration_scheme/rule_502_test_input.fixed_upper.vhd @@ -0,0 +1,14 @@ + +architecture rtl of fifo is + +begin + + process begin + + for x IN (31 downto 0) loop end loop; + + for x IN (31 downto 0) loop end loop; + + end process; + +end; diff --git a/tests/iteration_scheme/rule_502_test_input.vhd b/tests/iteration_scheme/rule_502_test_input.vhd new file mode 100644 index 00000000..8fe7b38e --- /dev/null +++ b/tests/iteration_scheme/rule_502_test_input.vhd @@ -0,0 +1,14 @@ + +architecture rtl of fifo is + +begin + + process begin + + for x in (31 downto 0) loop end loop; + + for x IN (31 downto 0) loop end loop; + + end process; + +end; diff --git a/tests/iteration_scheme/test_rule_502.py b/tests/iteration_scheme/test_rule_502.py new file mode 100644 index 00000000..173d586f --- /dev/null +++ b/tests/iteration_scheme/test_rule_502.py @@ -0,0 +1,74 @@ +# -*- coding: utf-8 -*- + +import os +import unittest + +from tests import utils +from vsg import vhdlFile +from vsg.rules import iteration_scheme + +sTestDir = os.path.dirname(__file__) + +lFile, eError = vhdlFile.utils.read_vhdlfile(os.path.join(sTestDir, "rule_502_test_input.vhd")) + +lExpected_lower = [] +lExpected_lower.append("") +utils.read_file(os.path.join(sTestDir, "rule_502_test_input.fixed_lower.vhd"), lExpected_lower) + +lExpected_upper = [] +lExpected_upper.append("") +utils.read_file(os.path.join(sTestDir, "rule_502_test_input.fixed_upper.vhd"), lExpected_upper) + + +class test_iteration_scheme_rule(unittest.TestCase): + def setUp(self): + self.oFile = vhdlFile.vhdlFile(lFile) + self.assertIsNone(eError) + + def test_rule_502_lower(self): + oRule = iteration_scheme.rule_502() + self.assertTrue(oRule) + self.assertEqual(oRule.name, "iteration_scheme") + self.assertEqual(oRule.identifier, "502") + self.assertEqual(oRule.groups, ["case", "case::keyword"]) + + lExpected = [10] + + oRule.analyze(self.oFile) + self.assertEqual(utils.extract_violation_lines_from_violation_object(oRule.violations), lExpected) + + def test_rule_502_upper(self): + oRule = iteration_scheme.rule_502() + oRule.case = "upper" + self.assertTrue(oRule) + self.assertEqual(oRule.name, "iteration_scheme") + self.assertEqual(oRule.identifier, "502") + + lExpected = [8] + oRule.analyze(self.oFile) + self.assertEqual(utils.extract_violation_lines_from_violation_object(oRule.violations), lExpected) + + def test_fix_rule_502_lower(self): + oRule = iteration_scheme.rule_502() + + oRule.fix(self.oFile) + + lActual = self.oFile.get_lines() + + self.assertEqual(lExpected_lower, lActual) + + oRule.analyze(self.oFile) + self.assertEqual(oRule.violations, []) + + def test_fix_rule_502_upper(self): + oRule = iteration_scheme.rule_502() + oRule.case = "upper" + + oRule.fix(self.oFile) + + lActual = self.oFile.get_lines() + + self.assertEqual(lExpected_upper, lActual) + + oRule.analyze(self.oFile) + self.assertEqual(oRule.violations, []) diff --git a/vsg/rules/for_generate_statement/__init__.py b/vsg/rules/for_generate_statement/__init__.py index 3c6ea275..f3535725 100644 --- a/vsg/rules/for_generate_statement/__init__.py +++ b/vsg/rules/for_generate_statement/__init__.py @@ -2,3 +2,4 @@ from .rule_500 import rule_500 from .rule_501 import rule_501 +from .rule_502 import rule_502 diff --git a/vsg/rules/for_generate_statement/rule_502.py b/vsg/rules/for_generate_statement/rule_502.py new file mode 100644 index 00000000..453dcdbe --- /dev/null +++ b/vsg/rules/for_generate_statement/rule_502.py @@ -0,0 +1,34 @@ +# -*- coding: utf-8 -*- + +from vsg import token +from vsg.rules import token_case_in_range_bounded_by_tokens + +lTokens = [] +lTokens.append(token.parameter_specification.in_keyword) + +oStartToken = token.for_generate_statement.for_keyword +oEndToken = token.for_generate_statement.generate_keyword + + +class rule_502(token_case_in_range_bounded_by_tokens): + """ + This rule checks the **in** keyword has proper case. + + |configuring_uppercase_and_lowercase_rules_link| + + **Violation** + + .. code-block:: vhdl + + gen_label : for lv_thing IN t_thing generate + + **Fix** + + .. code-block:: vhdl + + gen_label : for lv_thing in t_thing generate + """ + + def __init__(self): + super().__init__(lTokens, oStartToken, oEndToken) + self.groups.append("case::keyword") diff --git a/vsg/rules/iteration_scheme/__init__.py b/vsg/rules/iteration_scheme/__init__.py index 03bdfbd6..48dbfd13 100644 --- a/vsg/rules/iteration_scheme/__init__.py +++ b/vsg/rules/iteration_scheme/__init__.py @@ -6,3 +6,4 @@ from .rule_300 import rule_300 from .rule_301 import rule_301 from .rule_500 import rule_500 from .rule_501 import rule_501 +from .rule_502 import rule_502 diff --git a/vsg/rules/iteration_scheme/rule_502.py b/vsg/rules/iteration_scheme/rule_502.py new file mode 100644 index 00000000..29fd77dc --- /dev/null +++ b/vsg/rules/iteration_scheme/rule_502.py @@ -0,0 +1,34 @@ +# -*- coding: utf-8 -*- + +from vsg import token +from vsg.rules import token_case_in_range_bounded_by_tokens + +lTokens = [] +lTokens.append(token.parameter_specification.in_keyword) + +oStartToken = token.iteration_scheme.for_keyword +oEndToken = token.loop_statement.loop_keyword + + +class rule_502(token_case_in_range_bounded_by_tokens): + """ + This rule checks the **in** keyword has proper case. + + |configuring_uppercase_and_lowercase_rules_link| + + **Violation** + + .. code-block:: vhdl + + for lv_thing IN t_thing loop + + **Fix** + + .. code-block:: vhdl + + for lv_thing in t_thing loop + """ + + def __init__(self): + super().__init__(lTokens, oStartToken, oEndToken) + self.groups.append("case::keyword")