From 36d24bf31c2d3a02b2b07277efcf961fe1c19e40 Mon Sep 17 00:00:00 2001 From: Jeremiah Leary Date: Mon, 2 Nov 2020 22:12:45 -0600 Subject: [PATCH] Refactoring rule whitespace_007 for new parser. --- vsg/parser.py | 6 ++ vsg/rules/__init__.py | 1 + vsg/rules/n_spaces_after_tokens.py | 97 +++++++++++++++++++ vsg/rules/whitespace/rule_007.py | 29 +++--- .../whitespace/rule_007_test_input.fixed.vhd | 18 ++++ vsg/tests/whitespace/rule_007_test_input.vhd | 18 ++++ vsg/tests/whitespace/test_rule_007.py | 46 +++++++++ vsg/tests/whitespace/test_rule_whitespace.py | 16 --- vsg/token/ieee/std_logic_1164/type.py | 20 ++++ 9 files changed, 217 insertions(+), 34 deletions(-) create mode 100644 vsg/rules/n_spaces_after_tokens.py create mode 100644 vsg/tests/whitespace/rule_007_test_input.fixed.vhd create mode 100644 vsg/tests/whitespace/rule_007_test_input.vhd create mode 100644 vsg/tests/whitespace/test_rule_007.py create mode 100644 vsg/token/ieee/std_logic_1164/type.py diff --git a/vsg/parser.py b/vsg/parser.py index ee6f7f59..b2356881 100644 --- a/vsg/parser.py +++ b/vsg/parser.py @@ -53,6 +53,12 @@ class todo(item): ############################################################################### +class type(item): + + def __init__(self, sString): + item.__init__(self, sString) + + class function(item): def __init__(self, sString): diff --git a/vsg/rules/__init__.py b/vsg/rules/__init__.py index 3f22f038..cd4083e6 100644 --- a/vsg/rules/__init__.py +++ b/vsg/rules/__init__.py @@ -36,6 +36,7 @@ from .single_space_between_token_pairs import single_space_between_token_pairs from .single_space_between_token_pairs_bounded_by_tokens import single_space_between_token_pairs_bounded_by_tokens from .n_spaces_between_token_pairs_when_bounded_by_tokens import n_spaces_between_token_pairs_when_bounded_by_tokens from .n_spaces_before_and_after_tokens import n_spaces_before_and_after_tokens +from .n_spaces_after_tokens import n_spaces_after_tokens from .consistent_token_case import consistent_token_case from .token_prefix import token_prefix from .token_prefix_between_tokens import token_prefix_between_tokens diff --git a/vsg/rules/n_spaces_after_tokens.py b/vsg/rules/n_spaces_after_tokens.py new file mode 100644 index 00000000..d0eafc64 --- /dev/null +++ b/vsg/rules/n_spaces_after_tokens.py @@ -0,0 +1,97 @@ + + +from vsg import parser +from vsg import rule_item +from vsg import violation + +from vsg.vhdlFile import utils + + +class n_spaces_after_tokens(rule_item.Rule): + ''' + Checks for a single space between two tokens. + + Parameters + ---------- + + name : string + The group the rule belongs to. + + identifier : string + unique identifier. Usually in the form of 00N. + + lTokens : list of token type pairs + The tokens to check for a single space between + ''' + + def __init__(self, name, identifier, iSpaces, lTokens, bNIsMinimum=False): + rule_item.Rule.__init__(self, name=name, identifier=identifier) + self.solution = None + self.phase = 2 + self.iSpaces = iSpaces + self.lTokens = lTokens + self.bNIsMinimum = bNIsMinimum + + def analyze(self, oFile): + lToi = [] + + lToi = oFile.get_n_tokens_before_and_after_tokens(1, self.lTokens) + + for oToi in lToi: + iLine, lTokens = utils.get_toi_parameters(oToi) + dAction = {} + + oRight = lTokens[-1] + if not isinstance(oRight, parser.carriage_return): + if isinstance(oRight, parser.whitespace): + if self.bNIsMinimum: + if self.iSpaces > len(oRight.get_value()): + dAction['right'] = {} + dAction['right']['action'] = 'adjust' + elif self.iSpaces != len(oLeft.get_value()): + dAction['right'] = {} + dAction['right']['action'] = 'adjust' + else: + dAction['right'] = {} + dAction['right']['action'] = 'insert' + + if len(list(dAction.keys())) > 0: + sSolution = create_solution_text(dAction, self.iSpaces, lTokens) + oViolation = violation.New(iLine, oToi, sSolution) + oViolation.set_action(dAction) + self.add_violation(oViolation) + + + def fix(self, oFile): + ''' + Applies fixes for any rule violations. + ''' + if self.fixable: + self.analyze(oFile) + self._print_debug_message('Fixing rule: ' + self.name + '_' + self.identifier) + self._fix_violation(oFile) + self.violations = [] + + def _fix_violation(self, oFile): + for oViolation in self.violations: + lTokens = oViolation.get_tokens() + dAction = oViolation.get_action() + lKeys = list(dAction.keys()) + for sKey in lKeys: + if sKey == 'right': + if dAction[sKey]['action'] == 'adjust': + lTokens[-1].set_value(' '*self.iSpaces) + else: + lTokens.insert(len(lTokens) -1, parser.whitespace(' ')) + oViolation.set_tokens(lTokens) + oFile.update(self.violations) + + +def create_solution_text(dAction, iNumSpaces, lTokens): + sReturn = '' + for sKey in list(dAction.keys()): + if sKey == 'right': + if dAction[sKey]['action'] == 'adjust': + sReturn += 'Remove all but one space after ' + lTokens[1].get_value() + else: + sReturn += 'Add ' + str(iNumSpaces) + ' space(s) after ' + lTokens[1].get_value() diff --git a/vsg/rules/whitespace/rule_007.py b/vsg/rules/whitespace/rule_007.py index 56c2c4df..0c01fab6 100644 --- a/vsg/rules/whitespace/rule_007.py +++ b/vsg/rules/whitespace/rule_007.py @@ -1,24 +1,17 @@ -from vsg import rule -from vsg import utils +from vsg import parser -import re +from vsg.rules import n_spaces_after_tokens + +lTokens = [] +lTokens.append(parser.comma) -class rule_007(rule.rule): - '''Whitespace rule 007 checks for spaces after a comma.''' +class rule_007(n_spaces_after_tokens): + ''' + Checks for spaces after a comma. + ''' def __init__(self): - rule.rule.__init__(self, 'whitespace', '007') - self.phase = 2 - self.solution = 'Add a space after the comma.' - - def _analyze(self, oFile, oLine, iLineNumber): - if re.match('^.*,\S', oLine.line) and not re.match('^.*--.*,\S', oLine.line): - dViolation = utils.create_violation_dict(iLineNumber) - self.add_violation(dViolation) - - def _fix_violations(self, oFile): - for dViolation in self.violations: - oLine = utils.get_violating_line(oFile, dViolation) - oLine.update_line(re.sub(r',(\S)', r', \1', oLine.line)) + n_spaces_after_tokens.__init__(self, 'whitespace', '007', 1, lTokens, bNIsMinimum=True) + self.solution = 'Add a space after comma.' diff --git a/vsg/tests/whitespace/rule_007_test_input.fixed.vhd b/vsg/tests/whitespace/rule_007_test_input.fixed.vhd new file mode 100644 index 00000000..cb029f2f --- /dev/null +++ b/vsg/tests/whitespace/rule_007_test_input.fixed.vhd @@ -0,0 +1,18 @@ + +architecture RTL of FIFO is + + signal a, b, c, d : std_logic; + + signal a, b, c, d : std_logic; + +begin + + process (a, b, c, d) is + begin + end process; + + process (a, b, c, d) is + begin + end process; + +end architecture RTL; diff --git a/vsg/tests/whitespace/rule_007_test_input.vhd b/vsg/tests/whitespace/rule_007_test_input.vhd new file mode 100644 index 00000000..4e276221 --- /dev/null +++ b/vsg/tests/whitespace/rule_007_test_input.vhd @@ -0,0 +1,18 @@ + +architecture RTL of FIFO is + + signal a, b, c, d : std_logic; + + signal a,b,c,d : std_logic; + +begin + + process (a, b, c, d) is + begin + end process; + + process (a,b,c,d) is + begin + end process; + +end architecture RTL; diff --git a/vsg/tests/whitespace/test_rule_007.py b/vsg/tests/whitespace/test_rule_007.py new file mode 100644 index 00000000..6839c6fa --- /dev/null +++ b/vsg/tests/whitespace/test_rule_007.py @@ -0,0 +1,46 @@ + +import os +import unittest + +from vsg.rules import whitespace +from vsg import vhdlFile +from vsg.tests import utils + +sTestDir = os.path.dirname(__file__) + +lFile = utils.read_vhdlfile(os.path.join(sTestDir,'rule_007_test_input.vhd')) +lExpected = [] +lExpected.append('') +utils.read_file(os.path.join(sTestDir, 'rule_007_test_input.fixed.vhd'), lExpected) + + +class test_context_rule(unittest.TestCase): + + def setUp(self): + self.oFile = vhdlFile.vhdlFile(lFile) + + def test_rule_007(self): + oRule = whitespace.rule_007() + self.assertTrue(oRule) + self.assertEqual(oRule.name, 'whitespace') + self.assertEqual(oRule.identifier, '007') + + lExpected = [6, 6, 6, 14, 14, 14] + + oRule.analyze(self.oFile) + self.assertEqual(lExpected, utils.extract_violation_lines_from_violation_object(oRule.violations)) + + def test_fix_rule_007(self): + oRule = whitespace.rule_007() + + oRule.fix(self.oFile) + + lActual = [] + for oLine in self.oFile.lines: + lActual.append(oLine.line) + + self.assertEqual(lExpected, lActual) + + oRule.analyze(self.oFile) + self.assertEqual(oRule.violations, []) + diff --git a/vsg/tests/whitespace/test_rule_whitespace.py b/vsg/tests/whitespace/test_rule_whitespace.py index beac4602..4ac56b4a 100644 --- a/vsg/tests/whitespace/test_rule_whitespace.py +++ b/vsg/tests/whitespace/test_rule_whitespace.py @@ -69,22 +69,6 @@ class testRuleWhitespaceMethods(unittest.TestCase): self.assertEqual(self.oFile.lines[4].line, ' ) pass') self.assertEqual(self.oFile.lines[5].line, ' This is a test of parentehsis (pass) -- ) pass') - def test_007(self): - oRule = whitespace.rule_007() - self.assertTrue(oRule) - self.assertEqual(oRule.name, 'whitespace') - self.assertEqual(oRule.identifier, '007') - self.assertEqual(oRule.phase, 2) - - dExpected = utils.add_violation_list([1,3]) - self.oFile.lines.append(line.line(' This is a test,of commas (failure )')) - self.oFile.lines.append(line.line(' This is a test, of commas (pass)')) - self.oFile.lines.append(line.line(' This is a test of commas,(failure )')) - self.oFile.lines.append(line.line(' This is a test of commas -- 1,2,3,4 (PASS)')) - self.oFile.lines.append(line.line(' ) pass')) - oRule.analyze(self.oFile) - self.assertEqual(oRule.violations, dExpected) - def test_008(self): oRule = whitespace.rule_008() self.assertTrue(oRule) diff --git a/vsg/token/ieee/std_logic_1164/type.py b/vsg/token/ieee/std_logic_1164/type.py new file mode 100644 index 00000000..eb3f9cda --- /dev/null +++ b/vsg/token/ieee/std_logic_1164/type.py @@ -0,0 +1,20 @@ + +from vsg import parser + + +class std_logic_vector(parser.type): + + def __init__(self, sString): + parser.type.__init__(self, sString) + + +class std_ulogic_vector(parser.type): + + def __init__(self, sString): + parser.type.__init__(self, sString) + + +class std_ulogic(parser.type): + + def __init__(self, sString): + parser.type.__init__(self, sString)