Refactoring rule whitespace_007 for new parser.

This commit is contained in:
Jeremiah Leary 2020-11-02 22:12:45 -06:00
parent 1490212573
commit 36d24bf31c
9 changed files with 217 additions and 34 deletions

View File

@ -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):

View File

@ -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

View File

@ -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()

View File

@ -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.'

View File

@ -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;

View File

@ -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;

View File

@ -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, [])

View File

@ -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)

View File

@ -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)