def validate_file_name(file_path, input_language):
"""Checks if file_name matches specified language"""
# Check if file_name and input_language are strings
if not (isinstance(file_path, str)
and isinstance(input_language, str)):
return "Parameters file_path and input_language must be a string"
# Extract file name from file path
file_name = path.split(file_path)[1]
# Get file extension
response = Language.recognize(file_name)
# Check if error encountered
if isinstance(response, list) and not response[0]:
# Parse error
Error.parse(response)
# Check if file_name is a valid
special_characters = "\\/:*?\"<>|"
for character in special_characters:
if file_name.find(character) != -1:
return "File name must not contain '%s'" % special_characters
# Else save response
recognized_language = response
# Check if file_name extension matches language
error_message = "Extension and language don't match"
# Return validation result
if input_language != recognized_language:
return error_message
def validate_file_path(file_path):
"""Checks if file_path is valid"""
# Check if file_path is a string
if not isinstance(file_path, str):
return "Parameter file_path must be a string"
# Check if file exists
if not path.isfile(file_path):
return "File - {} Does not exist".format(file_path)
# Get extension from file_path
response = Language.recognize(file_path)
# Check if error encountered
if isinstance(response, tuple) and not response[0]:
# Parse error
Error.parse(response)
# Save error response
extension = response[1]
else:
# Else save response
extension = response
# Check if is supported language source code
if extension.startswith('Unsupported file extension '):
return "Unsupported file type"
def test_recognize(self):
"""Tests Language.recognize"""
# Create test set with valid data
valid_test_set = [
"python_file.py",
"java_file.java",
"cpp_file.cpp",
"c_file.c",
"java_file.JAVA",
"java_file.JaVa",
"python_\x09.py",
]
# Add expected response
for i, test in enumerate(valid_test_set):
valid_test_set[i] = (test, test.split('_')[0].lower())
# Create test set with invalid date
unsupported_error = "Unsupported file extension {}"
invalid_type_error = "Parameter file_path must be a string"
# Create test set for unsupported languages
unsupported_test_set = [
"Unsupported_file_type.abc",
"Unsupported_random_file_type.random",
"Unsupported_num_file.123",
"\x03.hex",
]
# Create test set for invalid types
invalid_type_test_set = [
1234,
b'python_file.py',
]
# Add expected results
for i, test in enumerate(unsupported_test_set):
unsupported_test_set[i] = (test, (None,
unsupported_error.format(
path.splitext(test)[1])))
for i, test in enumerate(invalid_type_test_set):
invalid_type_test_set[i] = (test, (None, invalid_type_error))
# Merge invalid test sets
invalid_test_set = unsupported_test_set + invalid_type_test_set
# Merge both test sets
test_set = valid_test_set + invalid_test_set
# Run test for all tests in test_set
for test in test_set:
self.assertEqual(Language.recognize(test[0]), test[1])
def PLC():
"""Main PLC application"""
# Create user input string template
input_msg = "{} or 'q' to abort: "
# Create input messages
input_file_path_msg = input_msg.format("Path to Program File")
input_language_msg = input_msg.format("To Language")
input_file_name_msg = input_msg.format("Output File Path")
# Create variable to store function result
lang_from = None
#
# Get User Input
#
validate_methods = [
(FilePath.validate_file_path, "file_path", input_file_path_msg),
(Language.validate, "lang_to", input_language_msg),
(FilePath.validate_file_name, "outfile_path", input_file_name_msg),
]
# Validate user input
for func, var_name, input_str in validate_methods:
# Get input from user
user_input_val, error = get_user_input(func, var_name, input_str)
user_input_val = str(user_input_val)
# Check if input is currently at to language
# and input language is same as output language
if var_name == "lang_to" and user_input_val.lower() == lang_from:
error = "Language of file is same as to conversion language"
# If error encountered, print error and exit
while error:
# Parse the error
Error.parse(error, user_input=True)
# Get input from user
user_input_val, error = get_user_input(func, var_name, input_str)
# Check if input is currently at to language
# and input language is same as output language
if var_name == "lang_to" and user_input_val.lower() == lang_from:
error = "Language of file is same as to conversion language"
# Store latest value of var
user_input[var_name] = user_input_val
# If var_name is file_path recognize language of infile
if var_name == "file_path":
lang_from = Language.recognize(user_input_val)
# else if var_name is language,
# store lowercase string of var_name
elif var_name == "lang_to":
user_input[var_name] = user_input_val.lower()
#
# Start Conversion
#
# Make local variables for keys in user_input dict
file_path = user_input['file_path']
lang_to = user_input['lang_to']
outfile_path = user_input['outfile_path']
print(lang_from, "->", lang_to)
# Create code processor instance
code_processor = CodeProcessor(file_path, lang_from, lang_to, outfile_path)
# Run convert method of code processor
code_processor.convert()
# Write converted file to disk
error = code_processor.write_file_to_disk()
# Check if error occurred
if error:
Error.parse(error, user_input=False)
return 0
