vhdl-style-guide/vsg/__main__.py

399 lines
15 KiB
Python

#!/usr/bin/env python
import argparse
import sys
import os
import json
import shutil
import glob
import yaml
from . import junit
from . import rule_list
from . import severity
from . import version
from . import vhdlFile
def parse_command_line_arguments():
'''Parses the command line arguments and returns them.'''
parser = argparse.ArgumentParser(
prog='VHDL Style Guide (VSG)',
description='''Analyzes VHDL files for style guide violations.
Reference documentation is located at:
http://vhdl-style-guide.readthedocs.io/en/latest/index.html''')
parser.add_argument('-f', '--filename', nargs='+', help='File to analyze')
parser.add_argument('-lr', '--local_rules', help='Path to local rules')
parser.add_argument('-c', '--configuration', nargs='+', help='JSON or YAML configuration file(s)')
parser.add_argument('--fix', default=False, action='store_true', help='Fix issues found')
parser.add_argument('-fp', '--fix_phase', default=10, action='store', help='Fix issues up to and including this phase')
parser.add_argument('-j', '--junit', action='store', help='Extract Junit file')
parser.add_argument('-of', '--output_format', action='store', default='vsg', choices=['vsg', 'syntastic'], help='Sets the output format.')
parser.add_argument('-b', '--backup', default=False, action='store_true', help='Creates a copy of input file for comparison with fixed version.')
parser.add_argument('-oc', '--output_configuration', default=None, action='store', help='Write configuration to file name.')
parser.add_argument('-rc', '--rule_configuration', default=None, action='store', help='Display configuration of a rule')
parser.add_argument('--style', action='store', default=None, choices=get_predefined_styles(), help='Use predefined style')
parser.add_argument('-v', '--version', default=False, action='store_true', help='Displays version information')
parser.add_argument('--debug', default=False, action='store_true', help='Displays verbose debug information')
if len(sys.argv) == 1:
parser.print_help()
sys.exit(1)
else:
return parser.parse_args()
def get_predefined_styles():
'''
Reads all predefined styles and returns a list of names.
Parameters : None
Returns : (list of strings)
'''
lReturn = []
sStylePath = os.path.join(os.path.dirname(__file__), 'styles')
lStyles = os.listdir(sStylePath)
for sStyle in lStyles:
if sStyle.endswith('.yaml'):
with open(os.path.join(sStylePath, sStyle)) as yaml_file:
tempConfiguration = yaml.full_load(yaml_file)
lReturn.append(tempConfiguration['name'])
return lReturn
def read_predefined_style(sStyleName):
'''
Reads a predefined style file.
Parameters :
sStyleName : (string)
Returns : (dictionary)
'''
dReturn = {}
if sStyleName is not None:
sFileName = os.path.join(os.path.dirname(__file__), 'styles', sStyleName + '.yaml')
dReturn = open_configuration_file(sFileName)
return dReturn
def open_configuration_file(sFileName, sJUnitFileName=None):
'''Attempts to open a configuration file and read it's contents.'''
try:
with open(sFileName) as yaml_file:
tempConfiguration = yaml.full_load(yaml_file)
except IOError:
print('ERROR: Could not find configuration file: ' + sFileName)
write_invalid_configuration_junit_file(sFileName, sJUnitFileName)
sys.exit(1)
except yaml.scanner.ScannerError as e:
print('ERROR: Invalid configuration file: ' + sFileName)
print(e)
write_invalid_configuration_junit_file(sFileName, sJUnitFileName)
exit()
except yaml.parser.ParserError as e:
print('ERROR: Invalid configuration file: ' + sFileName)
print(e)
write_invalid_configuration_junit_file(sFileName, sJUnitFileName)
exit()
return tempConfiguration
def validate_file_exists(sFilename, sConfigName):
'''Validates a file exist while using the glob function to expand filenames.'''
if isinstance(sFilename, dict):
sExpandedFilename = list(sFilename.keys())[0]
else:
sExpandedFilename = sFilename
lFileNames = glob.glob(expand_filename(sExpandedFilename))
if len(lFileNames) == 0:
print('ERROR: Could not find file ' + sFilename + ' in configuration file ' + sConfigName)
sys.exit(1)
def read_configuration_files(dStyle, commandLineArguments):
dConfiguration = dStyle
if commandLineArguments.configuration:
for sConfigFilename in commandLineArguments.configuration:
try:
tempConfiguration = open_configuration_file(sConfigFilename, commandLineArguments.junit)
except AttributeError:
tempConfiguration = open_configuration_file(sConfigFilename)
for sKey in tempConfiguration.keys():
if sKey == 'file_list':
if 'file_list' not in dConfiguration:
dConfiguration['file_list'] = []
for iIndex, sFilename in enumerate(tempConfiguration['file_list']):
validate_file_exists(sFilename, sConfigFilename)
try:
for sGlobbedFilename in glob.glob(expand_filename(sFilename)):
dConfiguration['file_list'].append(sGlobbedFilename)
except TypeError:
sKey = list(sFilename.keys())[0]
for sGlobbedFilename in glob.glob(expand_filename(sKey)):
dTemp = {}
dTemp[sGlobbedFilename] = {}
dTemp[sGlobbedFilename].update(tempConfiguration['file_list'][iIndex][sKey])
dConfiguration['file_list'].append(dTemp)
elif sKey == 'rule':
for sRule in tempConfiguration[sKey]:
try:
dConfiguration[sKey][sRule] = tempConfiguration[sKey][sRule]
except:
dConfiguration[sKey] = {}
dConfiguration[sKey][sRule] = tempConfiguration[sKey][sRule]
else:
dConfiguration[sKey] = tempConfiguration[sKey]
return dConfiguration
def write_invalid_configuration_junit_file(sFileName, sJUnitFileName):
if sJUnitFileName:
oJunitFile = junit.xmlfile(sJUnitFileName)
oJunitTestsuite = junit.testsuite('vhdl-style-guide', str(0))
oJunitTestcase = junit.testcase(sFileName, str(0), 'failure')
oFailure = junit.failure('Failure')
oFailure.add_text('Invalid JSON format. Review configuration for errors.')
oJunitTestcase.add_failure(oFailure)
oJunitTestsuite.add_testcase(oJunitTestcase)
oJunitFile.add_testsuite(oJunitTestsuite)
write_junit_xml_file(oJunitFile)
def write_vhdl_file(oVhdlFile):
try:
with open(oVhdlFile.filename, 'w') as oFile:
for oLine in oVhdlFile.lines[1:]:
oFile.write(oLine.line + '\n')
except PermissionError as err:
print (err, "Could not write fixes back to file.")
def write_junit_xml_file(oJunitFile):
with open(oJunitFile.filename, 'w') as oFile:
for sLine in oJunitFile.build_junit():
oFile.write(sLine + '\n')
def update_command_line_arguments(commandLineArguments, configuration):
if 'skip_phase' in configuration:
commandLineArguments.skip_phase = configuration['skip_phase']
else:
commandLineArguments.skip_phase = []
if not configuration:
return
if 'file_list' in configuration:
for sFilename in configuration['file_list']:
if isinstance(sFilename, dict):
sFilename = list(sFilename.keys())[0]
try:
commandLineArguments.filename.extend(glob.glob(expand_filename(sFilename)))
except:
commandLineArguments.filename = glob.glob(expand_filename(sFilename))
if 'local_rules' in configuration:
commandLineArguments.local_rules = expand_filename(configuration['local_rules'])
def expand_filename(sFileName):
'''Expands environment variables in filenames.'''
return os.path.expanduser(os.path.expandvars(sFileName))
def create_backup_file(sFileName):
'''Copies existing file and adds .bak to the end.'''
shutil.copy2(sFileName, sFileName + '.bak')
def read_vhdlfile(sFileName):
try:
lLines = []
with open(sFileName) as oFile:
for sLine in oFile:
lLines.append(sLine)
oFile.close()
return lLines
except IOError:
return []
def generate_output_configuration(commandLineArguments, configuration):
'''
Creates a configuration based on parameters passed on the command line.
It will send the output to a file in JSON format.
Parameters:
commandLineArguments: (argparse object)
configuration: (configuration dictionary)
Returns: Nothing
'''
if commandLineArguments.output_configuration:
fExitStatus = 0
# Create empty file so it can be used to create the rule list
oVhdlFile = vhdlFile.vhdlFile([''])
oRules = rule_list.rule_list(oVhdlFile, configuration['severity_list'], commandLineArguments.local_rules)
oRules.configure(configuration)
dOutputConfiguration = {}
dOutputConfiguration['cwd'] = os.getcwd()
if commandLineArguments.filename:
dOutputConfiguration['file_list'] = []
for sFileName in commandLineArguments.filename:
dOutputConfiguration['file_list'].append(sFileName)
if commandLineArguments.local_rules:
dOutputConfiguration['local_rules'] = commandLineArguments.local_rules
dOutputConfiguration['rule'] = oRules.get_configuration()
with open(commandLineArguments.output_configuration, 'w') as json_file:
json.dump(dOutputConfiguration, json_file, sort_keys=True, indent=2)
sys.exit(fExitStatus)
def display_rule_configuration(commandLineArguments, configuration):
'''
Displays the configuration of a rule passed on the command line.
Parameters:
commandLineArguments: (argparse object)
configuration: (configuration dictionary)
Returns: Nothing
'''
if commandLineArguments.rule_configuration:
fExitStatus = 0
# Create empty file so it can be used to create the rule list
oVhdlFile = vhdlFile.vhdlFile([''])
oRules = rule_list.rule_list(oVhdlFile, configuration['severity_list'], commandLineArguments.local_rules)
oRules.configure(configuration)
dOutputConfiguration = {}
if commandLineArguments.local_rules:
dOutputConfiguration['local_rules'] = commandLineArguments.local_rules
dFullConfiguration = oRules.get_configuration()
if commandLineArguments.rule_configuration in dFullConfiguration:
dOutputConfiguration['rule'] = {}
dOutputConfiguration['rule'][commandLineArguments.rule_configuration] = dFullConfiguration[commandLineArguments.rule_configuration]
# Format the data for displaying
print(json.dumps(dOutputConfiguration, indent=2))
else:
print('ERROR: rule ' + commandLineArguments.rule_configuration + ' was not found.')
fExitStatus = 1
sys.exit(fExitStatus)
def validate_files_exist_to_analyze(sName):
if sName == None:
print('ERROR: No file defined by the -f command line option or filename given in configuration file.')
sys.exit(1)
def add_debug_to_configuration(oCLA, dConfiguration):
'''
Adds debug values to the configuration dictionary for later use.
Parameters:
oCLA: (command line argument object)
dConfiguration: (dictionary)
Returns: Nothing
'''
try:
dConfiguration['debug'] = oCLA.debug
except TypeError:
dConfiguration = {}
dConfiguration['debug'] = oCLA.debug
return dConfiguration
def main():
'''Main routine of the VHDL Style Guide (VSG) program.'''
fExitStatus = 0
commandLineArguments = parse_command_line_arguments()
version.print_version(commandLineArguments)
dStyle = read_predefined_style(commandLineArguments.style)
configuration = read_configuration_files(dStyle, commandLineArguments)
update_command_line_arguments(commandLineArguments, configuration)
configuration = add_debug_to_configuration(commandLineArguments, configuration)
# Add local rule path to system path so the rules can be loaded
if commandLineArguments.local_rules:
sys.path.append(os.path.abspath(commandLineArguments.local_rules))
if commandLineArguments.junit:
oJunitFile = junit.xmlfile(commandLineArguments.junit)
oJunitTestsuite = junit.testsuite('vhdl-style-guide', str(0))
oSeverityList = severity.create_list(configuration)
configuration['severity_list'] = oSeverityList
generate_output_configuration(commandLineArguments, configuration)
display_rule_configuration(commandLineArguments, configuration)
validate_files_exist_to_analyze(commandLineArguments.filename)
for iIndex, sFileName in enumerate(commandLineArguments.filename):
oVhdlFile = vhdlFile.vhdlFile(read_vhdlfile(sFileName))
oVhdlFile.filename = sFileName
oRules = rule_list.rule_list(oVhdlFile, oSeverityList, commandLineArguments.local_rules)
oRules.configure(configuration)
try:
oRules.configure(configuration['file_list'][iIndex][sFileName])
except TypeError:
pass
except KeyError:
pass
if commandLineArguments.fix:
if commandLineArguments.backup:
create_backup_file(sFileName)
oRules.fix(commandLineArguments.fix_phase, commandLineArguments.skip_phase)
write_vhdl_file(oVhdlFile)
oRules.oSeverityList.clear_severity_counts()
oRules.clear_violations()
oRules.check_rules(commandLineArguments.skip_phase)
oRules.report_violations(commandLineArguments.output_format)
fExitStatus = update_exit_status(fExitStatus, oRules)
if commandLineArguments.junit:
oJunitTestsuite.add_testcase(oRules.extract_junit_testcase(sFileName))
if commandLineArguments.junit:
oJunitFile.add_testsuite(oJunitTestsuite)
write_junit_xml_file(oJunitFile)
sys.exit(fExitStatus)
def update_exit_status(fExitStatus, oRules):
if fExitStatus == 1 or oRules.violations:
return 1
else:
return 0
if __name__ == '__main__':
main()