Refactoring rule whitespace_007 for new parser.
This commit is contained in:
parent
1490212573
commit
36d24bf31c
|
|
@ -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):
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
|
|
@ -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.'
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
@ -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;
|
||||
|
|
@ -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, [])
|
||||
|
||||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
Loading…
Reference in New Issue