def test_run(self):
results = execute_section(self.sections["default"],
self.global_bears["default"],
self.local_bears["default"],
lambda *args: self.result_queue.put(args[2]),
self.log_printer,
{})
self.assertTrue(results[0])
local_results = self.result_queue.get(timeout=0)
global_results = self.result_queue.get(timeout=0)
self.assertTrue(self.result_queue.empty())
self.assertEqual(len(local_results), 1)
self.assertEqual(len(global_results), 1)
# Result dict also returned
# One file
self.assertEqual(len(results[1]), 1)
# One global bear
self.assertEqual(len(results[2]), 1)
local_result = local_results[0]
global_result = global_results[0]
self.assertEqual(str(local_result),
"Result:\n origin: 'LocalTestBear'\n file: None\n "
"line nr: None\n severity: 1\n'test msg'")
file = (platform.system() == 'Windows' and
self.testcode_c_path.lower() or self.testcode_c_path)
self.assertEqual(str(global_result),
"Result:\n origin: 'GlobalTestBear'\n file: {}"
"\n line nr: None\n severity: 1\n'test "
"message'".format(repr(file)))
def Analyze(self):
"""
This method analyzes the document and sends back the result
:return: The output is a list with an element for each section.
It contains:
- The name of the section
- Boolean which is true if all bears in the section executed
successfully
- List of results where each result is a list which contains:
(str)origin, (str)message, (str)file, (str)line_nr,
(str)severity
"""
retval = []
if self.path == "" or self.config_file == "":
return retval
args = ["--config=" + self.config_file]
log_printer = ListLogPrinter()
exitcode = 0
try:
yielded_results = False
(sections,
local_bears,
global_bears,
targets) = gather_configuration(fail_acquire_settings,
log_printer,
arg_list=args)
for section_name in sections:
section = sections[section_name]
if not section.is_enabled(targets):
continue
if any([fnmatch(self.path, file_pattern)
for file_pattern in path_list(section["files"])]):
section["files"].value = self.path
section_result = execute_section(
section=section,
global_bear_list=global_bears[section_name],
local_bear_list=local_bears[section_name],
print_results=lambda *args: True,
log_printer=log_printer,
file_diff_dict={})
yielded_results = yielded_results or section_result[0]
retval.append(
DbusDocument.results_to_dbus_struct(section_result,
section_name))
if yielded_results:
exitcode = 1
except BaseException as exception: # pylint: disable=broad-except
exitcode = exitcode or get_exitcode(exception, log_printer)
logs = [log.to_string_dict() for log in log_printer.logs]
return (exitcode, logs, retval)
def test_run(self):
self.sections['default'].append(Setting('jobs', "1"))
results = execute_section(self.sections["default"],
self.global_bears["default"],
self.local_bears["default"],
lambda *args: self.result_queue.put(args[2]),
self.log_printer)
self.assertTrue(results[0])
local_results = self.result_queue.get(timeout=0)
global_results = self.result_queue.get(timeout=0)
self.assertTrue(self.result_queue.empty())
self.assertEqual(len(local_results), 1)
self.assertEqual(len(global_results), 1)
# Result dict also returned
# One file
self.assertEqual(len(results[1]), 1)
# One global bear
self.assertEqual(len(results[2]), 1)
local_result = local_results[0]
global_result = global_results[0]
self.assertRegex(repr(local_result),
"<Result object\\(id={}, origin='LocalTestBear', "
"affected_code=\\(\\), severity=NORMAL, message='test"
" msg'\\) at 0x[0-9a-fA-F]+>".format(
hex(local_result.id)))
self.assertRegex(repr(global_result),
"<Result object\\(id={}, origin='GlobalTestBear', "
"affected_code=\\(.*start=.*file=.*section_executor_"
"test_files.*line=None.*end=.*\\), severity=NORMAL, "
"message='test message'\\) at "
"0x[0-9a-fA-F]+>".format(hex(global_result.id)))
def main():
log_printer = LogPrinter(ConsolePrinter())
exitcode = 0
try:
yielded_results = False
(sections,
local_bears,
global_bears,
targets) = gather_configuration(lambda *args: True, log_printer)
for section_name in sections:
section = sections[section_name]
if not section.is_enabled(targets):
continue
results = execute_section(
section=section,
global_bear_list=global_bears[section_name],
local_bear_list=local_bears[section_name],
print_results=lambda *args: True,
log_printer=log_printer,
file_diff_dict={})
yielded_results = yielded_results or results[0]
if yielded_results:
exitcode = 1
except BaseException as exception: # pylint: disable=broad-except
exitcode = exitcode or get_exitcode(exception, log_printer)
return exitcode
def test_run(self):
self.sections['default'].append(Setting('jobs', "1"))
results = execute_section(self.sections["default"],
self.global_bears["default"],
self.local_bears["default"],
lambda *args: self.result_queue.put(args[2]),
self.log_printer)
self.assertTrue(results[0])
local_results = self.result_queue.get(timeout=0)
global_results = self.result_queue.get(timeout=0)
self.assertTrue(self.result_queue.empty())
self.assertEqual(len(local_results), 1)
self.assertEqual(len(global_results), 1)
# Result dict also returned
# One file
self.assertEqual(len(results[1]), 1)
# One global bear
self.assertEqual(len(results[2]), 1)
local_result = local_results[0]
global_result = global_results[0]
self.assertRegex(repr(local_result),
"<Result object\\(id={}, origin='LocalTestBear', "
"affected_code=\\(\\), severity=NORMAL, message='test"
" msg'\\) at 0x[0-9a-fA-F]+>".format(
hex(local_result.id)))
self.assertRegex(repr(global_result),
"<Result object\\(id={}, origin='GlobalTestBear', "
"affected_code=\\(.*start=.*file=.*section_executor_"
"test_files.*line=None.*end=.*\\), severity=NORMAL, "
"message='test message'\\) at "
"0x[0-9a-fA-F]+>".format(hex(global_result.id)))
def Analyze(self):
"""
This method analyzes the document and sends back the result
:return: The output is a list with an element for each section.
It contains:
- The name of the section
- Boolean which is true if all bears in the section executed
successfully
- List of results where each result is a string dictionary
which contains: id, origin, message, file, line_nr, severity
"""
retval = []
if self.path == "" or self.config_file == "":
return retval
args = ["--config=" + self.config_file]
log_printer = ListLogPrinter()
exitcode = 0
try:
yielded_results = False
(sections, local_bears, global_bears,
targets) = gather_configuration(fail_acquire_settings,
log_printer,
arg_list=args)
for section_name in sections:
section = sections[section_name]
if not section.is_enabled(targets):
continue
if any([
fnmatch(self.path, file_pattern)
for file_pattern in path_list(section["files"])
]):
section["files"].value = self.path
section_result = execute_section(
section=section,
global_bear_list=global_bears[section_name],
local_bear_list=local_bears[section_name],
print_results=lambda *args: True,
log_printer=log_printer)
yielded_results = yielded_results or section_result[0]
retval.append(
DbusDocument.results_to_dbus_struct(
section_result, section_name))
if yielded_results:
exitcode = 1
except BaseException as exception: # pylint: disable=broad-except
exitcode = exitcode or get_exitcode(exception, log_printer)
logs = [log.to_string_dict() for log in log_printer.logs]
return (exitcode, logs, retval)
def test_empty_run(self):
execute_section(self.sections['cli'], [], [],
lambda *args: self.result_queue.put(args[2]),
None,
self.log_printer,
console_printer=self.console_printer)
self.sections['cli'].append(Setting('jobs', 'bogus!'))
results = execute_section(self.sections['cli'], [], [],
lambda *args: self.result_queue.put(args[2]),
None,
self.log_printer,
console_printer=self.console_printer)
# No results
self.assertFalse(results[0])
# One file
self.assertEqual(len(results[1]), 1)
# No global bear
self.assertEqual(len(results[2]), 0)
def test_empty_run(self):
self.sections["default"].append(Setting("jobs", "bogus!"))
results = execute_section(
self.sections["default"], [], [], lambda *args: self.result_queue.put(args[2]), self.log_printer
)
# No results
self.assertFalse(results[0])
# One file
self.assertEqual(len(results[1]), 1)
# No global bear
self.assertEqual(len(results[2]), 0)
def test_mixed_run(self):
self.sections['mixed'].append(Setting('jobs', '1'))
log_printer = ListLogPrinter()
global_bears = self.global_bears['mixed']
local_bears = self.local_bears['mixed']
bears = global_bears + local_bears
with LogCapture() as capture:
execute_section(self.sections['mixed'],
global_bears,
local_bears,
lambda *args: self.result_queue.put(args[2]),
None,
log_printer,
console_printer=self.console_printer)
capture.check(
('root', 'ERROR', "Bears that uses raw files can't be mixed with "
'Bears that uses text files. Please move the '
'following bears to their own section: ' +
', '.join(bear.name for bear in bears if not bear.USE_RAW_FILES)))
def test_empty_run(self):
self.sections['default'].append(Setting('jobs', "bogus!"))
results = execute_section(self.sections["default"], [], [],
lambda *args: self.result_queue.put(args[2]),
self.log_printer)
# No results
self.assertFalse(results[0])
# One file
self.assertEqual(len(results[1]), 1)
# No global bear
self.assertEqual(len(results[2]), 0)
def test_mixed_run(self):
self.sections['mixed'].append(Setting('jobs', '1'))
log_printer = ListLogPrinter()
global_bears = self.global_bears['mixed']
local_bears = self.local_bears['mixed']
bears = global_bears + local_bears
with LogCapture() as capture:
execute_section(self.sections['mixed'],
global_bears,
local_bears,
lambda *args: self.result_queue.put(args[2]),
None,
log_printer,
console_printer=self.console_printer)
capture.check(
('root', 'ERROR', "Bears that uses raw files can't be mixed with "
'Bears that uses text files. Please move the '
'following bears to their own section: ' +
', '.join(bear.name for bear in bears if not bear.USE_RAW_FILES))
)
def test_loaded_bears_with_error_result(self):
class BearWithMissingPrerequisites(Bear):
def __init__(self, section, queue, timeout=0.1):
Bear.__init__(self, section, queue, timeout)
def run(self):
return []
@classmethod
def check_prerequisites(cls):
return False
multiprocessing.Queue()
tmp_local_bears = copy.copy(self.local_bears['cli'])
tmp_local_bears.append(BearWithMissingPrerequisites)
cache = FileCache(self.log_printer,
'coala_test_on_error',
flush_cache=True)
results = execute_section(self.sections['cli'],
[],
tmp_local_bears,
lambda *args: self.result_queue.put(args[2]),
cache,
self.log_printer,
console_printer=self.console_printer)
self.assertEqual(len(cache.data), 0)
cache = FileCache(self.log_printer,
'coala_test_on_error',
flush_cache=False)
results = execute_section(self.sections['cli'],
[],
self.local_bears['cli'],
lambda *args: self.result_queue.put(args[2]),
cache,
self.log_printer,
console_printer=self.console_printer)
self.assertGreater(len(cache.data), 0)
def test_loaded_bears_with_error_result(self):
class BearWithMissingPrerequisites(Bear):
def __init__(self, section, queue, timeout=0.1):
Bear.__init__(self, section, queue, timeout)
def run(self):
return []
@classmethod
def check_prerequisites(cls):
return False
multiprocessing.Queue()
tmp_local_bears = copy.copy(self.local_bears['cli'])
tmp_local_bears.append(BearWithMissingPrerequisites)
cache = FileCache(self.log_printer,
'coala_test_on_error',
flush_cache=True)
results = execute_section(self.sections['cli'],
[],
tmp_local_bears,
lambda *args: self.result_queue.put(args[2]),
cache,
self.log_printer,
console_printer=self.console_printer)
self.assertEqual(len(cache.data), 0)
cache = FileCache(self.log_printer,
'coala_test_on_error',
flush_cache=False)
results = execute_section(self.sections['cli'],
[],
self.local_bears['cli'],
lambda *args: self.result_queue.put(args[2]),
cache,
self.log_printer,
console_printer=self.console_printer)
self.assertGreater(len(cache.data), 0)
def test_empty_run(self):
results = execute_section(self.sections["default"],
[],
[],
lambda *args: self.result_queue.put(args[2]),
self.log_printer,
{})
# No results
self.assertFalse(results[0])
# One file
self.assertEqual(len(results[1]), 1)
# No global bear
self.assertEqual(len(results[2]), 0)
def test_empty_run(self):
execute_section(self.sections['cli'],
[],
[],
lambda *args: self.result_queue.put(args[2]),
None,
self.log_printer,
console_printer=self.console_printer)
self.sections['cli'].append(Setting('jobs', 'bogus!'))
results = execute_section(self.sections['cli'],
[],
[],
lambda *args: self.result_queue.put(args[2]),
None,
self.log_printer,
console_printer=self.console_printer)
# No results
self.assertFalse(results[0])
# One file
self.assertEqual(len(results[1]), 1)
# No global bear
self.assertEqual(len(results[2]), 0)
def main():
log_printer = ListLogPrinter()
exitcode = 0
results = {}
try:
yielded_results = False
section_results = []
(sections,
local_bears,
global_bears,
targets) = gather_configuration(fail_acquire_settings, log_printer)
for section_name in sections:
section = sections[section_name]
if not section.is_enabled(targets):
continue
section_result = execute_section(
section=section,
global_bear_list=global_bears[section_name],
local_bear_list=local_bears[section_name],
print_results=lambda *args: True,
log_printer=log_printer,
file_diff_dict={})
yielded_results = yielded_results or section_result[0]
results_for_section = []
for i in [1, 2]:
for key, value in section_result[i].items():
for result in value:
if isinstance(result, HiddenResult):
continue
results_for_section.append(result)
results[section_name] = results_for_section
if yielded_results:
exitcode = 1
except BaseException as exception: # pylint: disable=broad-except
exitcode = exitcode or get_exitcode(exception, log_printer)
retval = {"logs": log_printer.logs, "results": results}
retval = json.dumps(retval,
cls=JSONEncoder,
sort_keys=True,
indent=2,
separators=(',', ': '))
print(retval)
return exitcode
def run_coala(path):
"""
Run coala on the file at the given path. The config file is got using
the `find-config` option of coala.
:param path: The path of the file to analyze.
:return: The result dictionary from coala.
"""
results = {}
log_printer = LogPrinter(ConsolePrinter())
cwd = os.getcwd()
try:
os.chdir(os.path.dirname(path))
args = [
"--find-config", "--limit-files", path, '-S', 'autoapply=false'
]
sections, local_bears, global_bears, targets = (
# Use `lambda *args: True` so that `gather_configuration` does
# nothing when it needs to request settings from user.
gather_configuration(lambda *args: True,
log_printer,
arg_list=args))
for section_name in sections:
section = sections[section_name]
if not section.is_enabled(targets):
continue
section_result = execute_section(
section=section,
global_bear_list=global_bears[section_name],
local_bear_list=local_bears[section_name],
print_results=lambda *args: True,
log_printer=log_printer)
results_for_section = []
for i in 1, 2:
for value in section_result[i].values():
for result in value:
if isinstance(result, HiddenResult):
continue
results_for_section.append(result)
results[section_name] = results_for_section
except BaseException as exception:
log_printer.log_exception(str(exception), exception)
finally:
os.chdir(cwd)
return results
def run_coala(path):
"""
Run coala on the file at the given path. The config file is got using
the `find-config` option of coala.
:param path: The path of the file to analyze.
:return: The result dictionary from coala.
"""
results = {}
log_printer = LogPrinter(ConsolePrinter())
cwd = os.getcwd()
try:
os.chdir(os.path.dirname(path))
args = ["--find-config", "--limit-files", path, '-S',
'autoapply=false']
sections, local_bears, global_bears, targets = (
# Use `lambda *args: True` so that `gather_configuration` does
# nothing when it needs to request settings from user.
gather_configuration(lambda *args: True,
log_printer,
arg_list=args))
for section_name in sections:
section = sections[section_name]
if not section.is_enabled(targets):
continue
section_result = execute_section(
section=section,
global_bear_list=global_bears[section_name],
local_bear_list=local_bears[section_name],
print_results=lambda *args: True,
log_printer=log_printer)
results_for_section = []
for i in 1, 2:
for value in section_result[i].values():
for result in value:
if isinstance(result, HiddenResult):
continue
results_for_section.append(result)
results[section_name] = results_for_section
except BaseException as exception:
log_printer.log_exception(str(exception), exception)
finally:
os.chdir(cwd)
return results
def main():
log_printer = LogPrinter(ConsolePrinter())
console_printer = ConsolePrinter()
exitcode = 0
try:
did_nothing = True
yielded_results = False
(sections,
local_bears,
global_bears,
targets) = gather_configuration(acquire_settings, log_printer)
if bool(sections["default"].get("show_bears", "False")):
show_bears(local_bears,
global_bears,
console_printer)
did_nothing = False
else:
for section_name in sections:
section = sections[section_name]
if not section.is_enabled(targets):
continue
file_diff_dict = {}
print_section_beginning(console_printer, section)
results = execute_section(
section=section,
global_bear_list=global_bears[section_name],
local_bear_list=local_bears[section_name],
print_results=print_results,
log_printer=log_printer,
file_diff_dict=file_diff_dict)
yielded_results = yielded_results or results[0]
finalize(file_diff_dict, results[3], log_printer)
did_nothing = False
if did_nothing:
nothing_done(console_printer)
if yielded_results:
exitcode = 1
except BaseException as exception: # pylint: disable=broad-except
exitcode = exitcode or get_exitcode(exception, log_printer)
return exitcode
def test_run(self):
self.sections["default"].append(Setting("jobs", "1"))
cache = FileCache(self.log_printer, "coala_test", flush_cache=True)
results = execute_section(
self.sections["default"],
self.global_bears["default"],
self.local_bears["default"],
lambda *args: self.result_queue.put(args[2]),
cache,
self.log_printer,
console_printer=self.console_printer,
)
self.assertTrue(results[0])
local_results = self.result_queue.get(timeout=0)
global_results = self.result_queue.get(timeout=0)
self.assertTrue(self.result_queue.empty())
self.assertEqual(len(local_results), 1)
self.assertEqual(len(global_results), 1)
# Result dict also returned
# One file
self.assertEqual(len(results[1]), 1)
# One global bear
self.assertEqual(len(results[2]), 1)
local_result = local_results[0]
global_result = global_results[0]
self.assertRegex(
repr(local_result),
"<Result object\\(id={}, origin='LocalTestBear', aff"
"ected_code=\\(\\), severity=NORMAL, confidence=100"
", message='test msg', aspect=NoneType\\) at "
"0x[0-9a-fA-F]+>".format(hex(local_result.id)),
)
self.assertRegex(
repr(global_result),
"<Result object\\(id={}, origin='GlobalTestBear', "
"affected_code=\\(.*start=.*file=.*section_executor_"
"test_files.*line=None.*end=.*\\), severity=NORMAL, c"
"onfidence=100, message='test message', "
"aspect=NoneType\\"
") at 0x[0-9a-fA-F]+>".format(hex(global_result.id)),
)
def test_run(self):
self.sections['cli'].append(Setting('jobs', '1'))
cache = FileCache(self.log_printer, 'coala_test', flush_cache=True)
results = execute_section(self.sections['cli'],
self.global_bears['cli'],
self.local_bears['cli'],
lambda *args: self.result_queue.put(args[2]),
cache,
self.log_printer,
console_printer=self.console_printer)
self.assertTrue(results[0])
local_results = self.result_queue.get(timeout=0)
global_results = self.result_queue.get(timeout=0)
self.assertTrue(self.result_queue.empty())
self.assertEqual(len(local_results), 1)
self.assertEqual(len(global_results), 1)
# Result dict also returned
# One file
self.assertEqual(len(results[1]), 1)
# One global bear
self.assertEqual(len(results[2]), 1)
local_result = local_results[0]
global_result = global_results[0]
self.assertRegex(
repr(local_result), f'<Result object\\(id={hex(local_result.id)}, '
"origin='LocalTestBear', aff"
'ected_code=\\(\\), severity=NORMAL, confidence=100'
", message='test msg', aspect=NoneType, "
'applied_actions=\\{\\}\\) at '
'0x[0-9a-fA-F]+>')
self.assertRegex(
repr(global_result),
f'<Result object\\(id={hex(global_result.id)}, '
"origin='GlobalTestBear', "
'affected_code=\\(.*start=.*file=.*section_executor_'
'test_files.*line=None.*end=.*\\), severity=NORMAL, c'
"onfidence=100, message='test message', "
'aspect=NoneType, applied_actions=\\{\\}\\'
') at 0x[0-9a-fA-F]+>')
def test_mixed_run(self):
self.sections['mixed'].append(Setting('jobs', '1'))
log_printer = ListLogPrinter()
global_bears = self.global_bears['mixed']
local_bears = self.local_bears['mixed']
bears = global_bears + local_bears
results = execute_section(self.sections['mixed'],
global_bears,
local_bears,
lambda *args: self.result_queue.put(args[2]),
None,
log_printer,
console_printer=self.console_printer)
self.assertIn("Bears that uses raw files can't be mixed with "
'Bears that uses text files. Please move the following '
'bears to their own section: ' +
', '.join(bear.name for bear in bears
if not bear.USE_RAW_FILES),
[log.message for log in log_printer.logs])
def test_run(self):
self.sections['cli'].append(Setting('jobs', '1'))
cache = FileCache(self.log_printer, 'coala_test', flush_cache=True)
results = execute_section(self.sections['cli'],
self.global_bears['cli'],
self.local_bears['cli'],
lambda *args: self.result_queue.put(args[2]),
cache,
self.log_printer,
console_printer=self.console_printer)
self.assertTrue(results[0])
local_results = self.result_queue.get(timeout=0)
global_results = self.result_queue.get(timeout=0)
self.assertTrue(self.result_queue.empty())
self.assertEqual(len(local_results), 1)
self.assertEqual(len(global_results), 1)
# Result dict also returned
# One file
self.assertEqual(len(results[1]), 1)
# One global bear
self.assertEqual(len(results[2]), 1)
local_result = local_results[0]
global_result = global_results[0]
self.assertRegex(repr(local_result),
"<Result object\\(id={}, origin='LocalTestBear', aff"
'ected_code=\\(\\), severity=NORMAL, confidence=100'
", message='test msg', aspect=NoneType, "
'applied_actions={}\\) at '
'0x[0-9a-fA-F]+>'.format(hex(local_result.id), '{}'))
self.assertRegex(repr(global_result),
"<Result object\\(id={}, origin='GlobalTestBear', "
'affected_code=\\(.*start=.*file=.*section_executor_'
'test_files.*line=None.*end=.*\\), severity=NORMAL, c'
"onfidence=100, message='test message', "
'aspect=NoneType, applied_actions={}\\'
') at 0x[0-9a-fA-F]+>'.format(hex(global_result.id),
'{}'))
def test_raw_run(self):
self.sections['raw'].append(Setting('jobs', '1'))
results = execute_section(self.sections['raw'],
self.global_bears['raw'],
self.local_bears['raw'],
lambda *args: self.result_queue.put(args[2]),
None,
self.log_printer,
console_printer=self.console_printer)
self.assertTrue(results[0])
# One file
self.assertEqual(len(results[1]), 1)
# One global bear
self.assertEqual(len(results[2]), 1)
# The only file tested should be the unreadable file
# HACK: The real test of seeing the content of the array
# is the same as expected will fail on Windows
# due to a problem with how coala handles path.
self.assertEqual(self.unreadable_path.lower(),
results[1].keys()[0].lower())
# HACK: This is due to the problem with how coala handles paths
# that makes it problematic for Windows compatibility
self.unreadable_path = results[1].keys()[0]
self.assertEqual([bear.name for bear in self.global_bears['raw']],
results[2].keys())
self.assertEqual(results[1][self.unreadable_path],
[Result('LocalTestRawBear', 'test msg')])
self.assertEqual(results[2][self.global_bears['raw'][0].name],
[Result.from_values('GlobalTestRawBear',
'test message',
self.unreadable_path)])
def test_raw_run(self):
self.sections['raw'].append(Setting('jobs', '1'))
results = execute_section(self.sections['raw'],
self.global_bears['raw'],
self.local_bears['raw'],
lambda *args: self.result_queue.put(args[2]),
None,
self.log_printer,
console_printer=self.console_printer)
self.assertTrue(results[0])
# One file
self.assertEqual(len(results[1]), 1)
# One global bear
self.assertEqual(len(results[2]), 1)
# The only file tested should be the unreadable file
# HACK: The real test of seeing the content of the array
# is the same as expected will fail on Windows
# due to a problem with how coala handles path.
self.assertEqual(self.unreadable_path.lower(),
results[1].keys()[0].lower())
# HACK: This is due to the problem with how coala handles paths
# that makes it problematic for Windows compatibility
self.unreadable_path = results[1].keys()[0]
self.assertEqual([bear.name for bear in self.global_bears['raw']],
results[2].keys())
self.assertEqual(results[1][self.unreadable_path],
[Result('LocalTestRawBear', 'test msg')])
self.assertEqual(results[2][self.global_bears['raw'][0].name], [
Result.from_values('GlobalTestRawBear', 'test message',
self.unreadable_path)
])
def run_coala(console_printer=None,
log_printer=None,
print_results=do_nothing,
acquire_settings=fail_acquire_settings,
print_section_beginning=do_nothing,
nothing_done=do_nothing,
autoapply=True,
force_show_patch=False,
arg_parser=None,
arg_list=None):
"""
This is a main method that should be usable for almost all purposes and
reduces executing coala to one function call.
:param console_printer: Object to print messages on the console.
:param log_printer: A LogPrinter object to use for logging.
:param print_results: A callback that takes a LogPrinter, a
section, a list of results to be printed,
the file dict and the mutable file diff
dict.
:param acquire_settings: The method to use for requesting settings.
It will get a parameter which is a
dictionary with the settings name as key
and a list containing a description in [0]
and the names of the bears who need this
setting in all following indexes.
:param print_section_beginning: A callback that will be called with a
section name string whenever analysis of a
new section is started.
:param nothing_done: A callback that will be called with only a
log printer that shall indicate that
nothing was done.
:param autoapply: Set this to false to not autoapply any
actions. If you set this to `False`,
`force_show_patch` will be ignored.
:param force_show_patch: If set to True, a patch will be always
shown. (Using ApplyPatchAction.)
:param arg_parser: Instance of ArgParser that is used to parse
non-setting arguments.
:param arg_list: The CLI argument list.
:return: A dictionary containing a list of results
for all analyzed sections as key.
"""
log_printer = (
LogPrinter(ConsolePrinter(), LOG_LEVEL.DEBUG) if log_printer is None
else log_printer)
exitcode = 0
results = {}
file_dicts = {}
try:
yielded_results = yielded_unfixed_results = False
did_nothing = True
sections, local_bears, global_bears, targets = gather_configuration(
acquire_settings,
log_printer,
arg_parser=arg_parser,
arg_list=arg_list)
log_printer.debug('Platform {} -- Python {}, coalib {}'
.format(platform.system(), platform.python_version(),
VERSION))
settings_hash = get_settings_hash(sections, targets)
flush_cache = bool(sections['cli'].get('flush_cache', False) or
settings_changed(log_printer, settings_hash))
cache = None
if not sections['cli'].get('disable_caching', False):
cache = FileCache(log_printer, os.getcwd(), flush_cache)
for section_name, section in sections.items():
if not section.is_enabled(targets):
continue
if not autoapply:
section['default_actions'] = ''
elif force_show_patch:
section['default_actions'] = '*: ShowPatchAction'
section['show_result_on_top'] = 'yeah'
print_section_beginning(section)
section_result = execute_section(
section=section,
global_bear_list=global_bears[section_name],
local_bear_list=local_bears[section_name],
print_results=print_results,
cache=cache,
log_printer=log_printer,
console_printer=console_printer)
yielded, yielded_unfixed, results[section_name] = (
simplify_section_result(section_result))
yielded_results = yielded_results or yielded
yielded_unfixed_results = (
yielded_unfixed_results or yielded_unfixed)
did_nothing = False
file_dicts[section_name] = section_result[3]
update_settings_db(log_printer, settings_hash)
if cache:
cache.write()
if did_nothing:
nothing_done(log_printer)
exitcode = 2
elif yielded_unfixed_results:
exitcode = 1
elif yielded_results:
exitcode = 5
except BaseException as exception: # pylint: disable=broad-except
exitcode = exitcode or get_exitcode(exception, log_printer)
return results, exitcode, file_dicts
def run_coala(log_printer=None,
print_results=do_nothing,
acquire_settings=fail_acquire_settings,
print_section_beginning=do_nothing,
nothing_done=do_nothing,
autoapply=True):
"""
This is a main method that should be usable for almost all purposes and
reduces executing coala to one function call.
:param log_printer: A LogPrinter object to use for logging.
:param print_results: A callback that takes a LogPrinter, a
section, a list of results to be printed,
the file dict and the mutable file diff
dict.
:param acquire_settings: The method to use for requesting settings.
It will get a parameter which is a
dictionary with the settings name as key
and a list containing a description in [0]
and the names of the bears who need this
setting in all following indexes.
:param print_section_beginning: A callback that will be called with a
section name string whenever analysis of a
new section is started.
:param nothing_done: A callback that will be called with only a
log printer that shall indicate that
nothing was done.
:param autoapply: Set to False to autoapply nothing by
default; this is overridable via any
configuration file/CLI.
:return: A dictionary containing a list of results
for all analyzed sections as key.
"""
log_printer = log_printer or LogPrinter(ConsolePrinter())
exitcode = 0
results = {}
file_dicts = {}
try:
yielded_results = yielded_unfixed_results = False
did_nothing = True
sections, local_bears, global_bears, targets = gather_configuration(
acquire_settings, log_printer, autoapply=autoapply)
log_printer.debug("Platform {} -- Python {}, pip {}, coalib {}".format(
platform.system(), platform.python_version(), pip.__version__,
VERSION))
tag = str(sections['default'].get('tag', None))
dtag = str(sections['default'].get('dtag', None))
config_file = os.path.abspath(str(sections["default"].get("config")))
# Deleting all .orig files, so the latest files are up to date!
coala_delete_orig.main(log_printer, sections["default"])
delete_tagged_results(dtag, config_file, log_printer)
for section_name, section in sections.items():
if not section.is_enabled(targets):
continue
print_section_beginning(section)
section_result = execute_section(
section=section,
global_bear_list=global_bears[section_name],
local_bear_list=local_bears[section_name],
print_results=print_results,
log_printer=log_printer)
yielded, yielded_unfixed, results[section_name] = (
simplify_section_result(section_result))
yielded_results = yielded_results or yielded
yielded_unfixed_results = (yielded_unfixed_results
or yielded_unfixed)
did_nothing = False
file_dicts[section_name] = section_result[3]
tag_results(tag, config_file, results, log_printer)
if did_nothing:
nothing_done(log_printer)
elif yielded_unfixed_results:
exitcode = 1
elif yielded_results:
exitcode = 5
except BaseException as exception: # pylint: disable=broad-except
exitcode = exitcode or get_exitcode(exception, log_printer)
return results, exitcode, file_dicts
def run_coala(log_printer=None,
print_results=do_nothing,
acquire_settings=do_nothing,
print_section_beginning=do_nothing,
finalize=do_nothing,
nothing_done=do_nothing,
show_bears=do_nothing):
"""
This is a main method that should be usable for almost all purposes and
reduces executing coala to one function call.
:param log_printer: A LogPrinter object to use for logging.
:param print_results: A callback that takes a LogPrinter, a
section, a list of results to be printed,
the file dict and the mutable file diff
dict.
:param acquire_settings: The method to use for requesting settings.
It will get a parameter which is a
dictionary with the settings name as key
and a list containing a description in [0]
and the names of the bears who need this
setting in all following indexes.
:param print_section_beginning: A callback that will be called with a
section name string whenever analysis of a
new section is started.
:param finalize: The method to use for requesting settings.
It will get a parameter which is a
dictionary with the settings name as key
and a list containing a description in [0]
and the names of the bears who need this
setting in all following indexes.
:param nothing_done: A callback that will be called without
parameters if nothing was done.
:param show_bears: A callback that will be called with first
a list of local bears, second a list of
global bears to output them.
:return: A dictionary containing a list of results
for all analyzed sections as key.
"""
log_printer = log_printer or LogPrinter(ConsolePrinter())
exitcode = 0
results = None
try:
yielded_results = False
did_nothing = True
(sections,
local_bears,
global_bears,
targets) = gather_configuration(acquire_settings, log_printer)
if bool(sections["default"].get("show_bears", "False")):
show_bears(local_bears,
global_bears)
did_nothing = False
else:
results = {}
for section_name in sections:
section = sections[section_name]
if not section.is_enabled(targets):
continue
print_section_beginning(section)
file_diff_dict = {}
section_result = execute_section(
section=section,
global_bear_list=global_bears[section_name],
local_bear_list=local_bears[section_name],
print_results=print_results,
log_printer=log_printer,
file_diff_dict=file_diff_dict)
yielded_results = yielded_results or section_result[0]
finalize(file_diff_dict, section_result[3], log_printer)
results_for_section = []
for value in chain(section_result[1].values(),
section_result[2].values()):
for result in value:
if not isinstance(result, HiddenResult):
results_for_section.append(result)
results[section_name] = results_for_section
did_nothing = False
if did_nothing:
nothing_done()
if yielded_results:
exitcode = 1
except BaseException as exception: # pylint: disable=broad-except
exitcode = exitcode or get_exitcode(exception, log_printer)
return results, exitcode
def run_coala(log_printer=None,
print_results=do_nothing,
acquire_settings=fail_acquire_settings,
print_section_beginning=do_nothing,
nothing_done=do_nothing,
autoapply=True,
arg_parser=None):
"""
This is a main method that should be usable for almost all purposes and
reduces executing coala to one function call.
:param log_printer: A LogPrinter object to use for logging.
:param print_results: A callback that takes a LogPrinter, a
section, a list of results to be printed,
the file dict and the mutable file diff
dict.
:param acquire_settings: The method to use for requesting settings.
It will get a parameter which is a
dictionary with the settings name as key
and a list containing a description in [0]
and the names of the bears who need this
setting in all following indexes.
:param print_section_beginning: A callback that will be called with a
section name string whenever analysis of a
new section is started.
:param nothing_done: A callback that will be called with only a
log printer that shall indicate that
nothing was done.
:param autoapply: Set to False to autoapply nothing by
default; this is overridable via any
configuration file/CLI.
:return: A dictionary containing a list of results
for all analyzed sections as key.
"""
log_printer = log_printer or LogPrinter(ConsolePrinter(), LOG_LEVEL.DEBUG)
exitcode = 0
results = {}
file_dicts = {}
try:
yielded_results = yielded_unfixed_results = False
did_nothing = True
sections, local_bears, global_bears, targets = gather_configuration(
acquire_settings,
log_printer,
autoapply=autoapply,
arg_parser=arg_parser)
log_printer.debug("Platform {} -- Python {}, pip {}, coalib {}"
.format(platform.system(), platform.python_version(),
pip.__version__, VERSION))
config_file = os.path.abspath(str(sections["default"].get("config")))
settings_hash = get_settings_hash(sections)
flush_cache = bool(sections["default"].get("flush_cache", False) or
settings_changed(log_printer, settings_hash))
cache = FileCache(log_printer, os.getcwd(), flush_cache)
for section_name, section in sections.items():
if not section.is_enabled(targets):
continue
print_section_beginning(section)
section_result = execute_section(
section=section,
global_bear_list=global_bears[section_name],
local_bear_list=local_bears[section_name],
print_results=print_results,
cache=cache,
log_printer=log_printer)
yielded, yielded_unfixed, results[section_name] = (
simplify_section_result(section_result))
yielded_results = yielded_results or yielded
yielded_unfixed_results = (
yielded_unfixed_results or yielded_unfixed)
did_nothing = False
file_dicts[section_name] = section_result[3]
update_settings_db(log_printer, settings_hash)
if sections["default"].get("changed_files", False):
cache.write()
if did_nothing:
nothing_done(log_printer)
elif yielded_unfixed_results:
exitcode = 1
elif yielded_results:
exitcode = 5
except BaseException as exception: # pylint: disable=broad-except
exitcode = exitcode or get_exitcode(exception, log_printer)
return results, exitcode, file_dicts
def run_coala(log_printer=None,
print_results=do_nothing,
acquire_settings=fail_acquire_settings,
print_section_beginning=do_nothing,
nothing_done=do_nothing,
show_bears=do_nothing,
autoapply=True):
"""
This is a main method that should be usable for almost all purposes and
reduces executing coala to one function call.
:param log_printer: A LogPrinter object to use for logging.
:param print_results: A callback that takes a LogPrinter, a
section, a list of results to be printed,
the file dict and the mutable file diff
dict.
:param acquire_settings: The method to use for requesting settings.
It will get a parameter which is a
dictionary with the settings name as key
and a list containing a description in [0]
and the names of the bears who need this
setting in all following indexes.
:param print_section_beginning: A callback that will be called with a
section name string whenever analysis of a
new section is started.
:param nothing_done: A callback that will be called with only a
log printer that shall indicate that
nothing was done.
:param show_bears: A callback that will be called with first
a list of local bears, second a list of
global bears to output them. A third bool
parameter may be used to indicate if a
compressed output (True) or a normal output
(False) is desired, the former being used
for showing all available bears to the
user.
:param autoapply: Set to False to autoapply nothing by
default; this is overridable via any
configuration file/CLI.
:return: A dictionary containing a list of results
for all analyzed sections as key.
"""
log_printer = log_printer or LogPrinter(ConsolePrinter())
exitcode = 0
results = None
try:
yielded_results = yielded_unfixed_results = False
did_nothing = True
sections, local_bears, global_bears, targets = gather_configuration(
acquire_settings, log_printer, autoapply=autoapply)
tag = str(sections['default'].get('tag', None))
dtag = str(sections['default'].get('dtag', None))
config_file = os.path.abspath(str(sections["default"].get("config")))
show_all_bears = bool(sections['default'].get('show_all_bears', False))
show_bears_ = bool(sections["default"].get("show_bears", "False"))
# Deleting all .orig files, so the latest files are up to date!
coala_delete_orig.main(log_printer, sections["default"])
delete_tagged_results(dtag, config_file, log_printer)
if show_bears_ or show_all_bears:
if show_all_bears:
(local_bears, global_bears) = collect_all_bears_from_sections(
sections, log_printer)
show_bears(local_bears, global_bears, show_all_bears)
did_nothing = False
else:
results = {}
for section_name, section in sections.items():
if not section.is_enabled(targets):
continue
print_section_beginning(section)
section_result = execute_section(
section=section,
global_bear_list=global_bears[section_name],
local_bear_list=local_bears[section_name],
print_results=print_results,
log_printer=log_printer)
yielded, yielded_unfixed, results[section_name] = (
simplify_section_result(section_result))
yielded_results = yielded_results or yielded
yielded_unfixed_results = (yielded_unfixed_results
or yielded_unfixed)
did_nothing = False
tag_results(tag, config_file, results, log_printer)
if did_nothing:
nothing_done(log_printer)
elif yielded_unfixed_results:
exitcode = 1
elif yielded_results:
exitcode = 5
except BaseException as exception: # pylint: disable=broad-except
exitcode = exitcode or get_exitcode(exception, log_printer)
return results, exitcode
def run_coala(log_printer=None,
print_results=do_nothing,
acquire_settings=fail_acquire_settings,
print_section_beginning=do_nothing,
nothing_done=do_nothing,
show_bears=do_nothing,
autoapply=True):
"""
This is a main method that should be usable for almost all purposes and
reduces executing coala to one function call.
:param log_printer: A LogPrinter object to use for logging.
:param print_results: A callback that takes a LogPrinter, a
section, a list of results to be printed,
the file dict and the mutable file diff
dict.
:param acquire_settings: The method to use for requesting settings.
It will get a parameter which is a
dictionary with the settings name as key
and a list containing a description in [0]
and the names of the bears who need this
setting in all following indexes.
:param print_section_beginning: A callback that will be called with a
section name string whenever analysis of a
new section is started.
:param nothing_done: A callback that will be called with only a
log printer that shall indicate that
nothing was done.
:param show_bears: A callback that will be called with first
a list of local bears, second a list of
global bears to output them. A third bool
parameter may be used to indicate if a
compressed output (True) or a normal output
(False) is desired, the former being used
for showing all available bears to the
user.
:param autoapply: Set to False to autoapply nothing by
default; this is overridable via any
configuration file/CLI.
:return: A dictionary containing a list of results
for all analyzed sections as key.
"""
log_printer = log_printer or LogPrinter(ConsolePrinter())
exitcode = 0
results = None
try:
yielded_results = False
did_nothing = True
sections, local_bears, global_bears, targets = (
gather_configuration(acquire_settings, log_printer))
tag = str(sections['default'].get('tag', None))
dtag = str(sections['default'].get('dtag', None))
if not autoapply and 'autoapply' not in sections['default']:
sections['default']['autoapply'] = "False"
show_all_bears = bool(sections['default'].get('show_all_bears', False))
show_bears_ = bool(sections["default"].get("show_bears", "False"))
if show_all_bears:
show_bears_ = True
for section in sections:
bear_dirs = sections[section].bear_dirs()
local_bears[section] = collect_bears(bear_dirs,
["**"],
[BEAR_KIND.LOCAL],
log_printer)
global_bears[section] = collect_bears(bear_dirs,
["**"],
[BEAR_KIND.GLOBAL],
log_printer)
if dtag != "None":
delete_tagged_results(
dtag,
os.path.abspath(str(sections["default"].get("config"))))
if show_bears_:
show_bears(local_bears,
global_bears,
show_all_bears)
did_nothing = False
else:
results = {}
for section_name in sections:
section = sections[section_name]
if not section.is_enabled(targets):
continue
print_section_beginning(section)
section_result = execute_section(
section=section,
global_bear_list=global_bears[section_name],
local_bear_list=local_bears[section_name],
print_results=print_results,
log_printer=log_printer)
yielded_results = yielded_results or section_result[0]
results_for_section = []
for value in chain(section_result[1].values(),
section_result[2].values()):
if value is None:
continue
for result in value:
results_for_section.append(result)
results[section_name] = results_for_section
did_nothing = False
if tag != "None":
tag_results(
tag,
os.path.abspath(str(sections["default"].get("config"))),
results)
if did_nothing:
nothing_done(log_printer)
if yielded_results:
exitcode = 1
except BaseException as exception: # pylint: disable=broad-except
exitcode = exitcode or get_exitcode(exception, log_printer)
return results, exitcode
def run_coala(log_printer=None,
print_results=do_nothing,
acquire_settings=fail_acquire_settings,
print_section_beginning=do_nothing,
nothing_done=do_nothing,
show_bears=do_nothing,
autoapply=True):
"""
This is a main method that should be usable for almost all purposes and
reduces executing coala to one function call.
:param log_printer: A LogPrinter object to use for logging.
:param print_results: A callback that takes a LogPrinter, a
section, a list of results to be printed,
the file dict and the mutable file diff
dict.
:param acquire_settings: The method to use for requesting settings.
It will get a parameter which is a
dictionary with the settings name as key
and a list containing a description in [0]
and the names of the bears who need this
setting in all following indexes.
:param print_section_beginning: A callback that will be called with a
section name string whenever analysis of a
new section is started.
:param nothing_done: A callback that will be called with only a
log printer that shall indicate that
nothing was done.
:param show_bears: A callback that will be called with first
a list of local bears, second a list of
global bears to output them. A third bool
parameter may be used to indicate if a
compressed output (True) or a normal output
(False) is desired, the former being used
for showing all available bears to the
user.
:param autoapply: Set to False to autoapply nothing by
default; this is overridable via any
configuration file/CLI.
:return: A dictionary containing a list of results
for all analyzed sections as key.
"""
log_printer = log_printer or LogPrinter(ConsolePrinter())
exitcode = 0
results = None
try:
yielded_results = False
did_nothing = True
sections, local_bears, global_bears, targets = (gather_configuration(
acquire_settings, log_printer))
tag = str(sections['default'].get('tag', None))
dtag = str(sections['default'].get('dtag', None))
if not autoapply and 'autoapply' not in sections['default']:
sections['default']['autoapply'] = "False"
show_all_bears = bool(sections['default'].get('show_all_bears', False))
show_bears_ = bool(sections["default"].get("show_bears", "False"))
if show_all_bears:
show_bears_ = True
for section in sections:
bear_dirs = sections[section].bear_dirs()
local_bears[section] = collect_bears(bear_dirs, ["**"],
[BEAR_KIND.LOCAL],
log_printer)
global_bears[section] = collect_bears(bear_dirs, ["**"],
[BEAR_KIND.GLOBAL],
log_printer)
if dtag != "None":
delete_tagged_results(
dtag, os.path.abspath(str(sections["default"].get("config"))))
if show_bears_:
show_bears(local_bears, global_bears, show_all_bears)
did_nothing = False
else:
results = {}
for section_name in sections:
section = sections[section_name]
if not section.is_enabled(targets):
continue
print_section_beginning(section)
section_result = execute_section(
section=section,
global_bear_list=global_bears[section_name],
local_bear_list=local_bears[section_name],
print_results=print_results,
log_printer=log_printer)
yielded_results = yielded_results or section_result[0]
results_for_section = []
for value in chain(section_result[1].values(),
section_result[2].values()):
if value is None:
continue
for result in value:
results_for_section.append(result)
results[section_name] = results_for_section
did_nothing = False
if tag != "None":
tag_results(
tag,
os.path.abspath(str(sections["default"].get("config"))),
results)
if did_nothing:
nothing_done(log_printer)
if yielded_results:
exitcode = 1
except BaseException as exception: # pylint: disable=broad-except
exitcode = exitcode or get_exitcode(exception, log_printer)
return results, exitcode
def run_coala(console_printer=None,
log_printer=None,
print_results=do_nothing,
acquire_settings=fail_acquire_settings,
print_section_beginning=do_nothing,
nothing_done=do_nothing,
autoapply=True,
force_show_patch=False,
arg_parser=None,
arg_list=None,
args=None,
debug=False,
cache=None):
"""
This is a main method that should be usable for almost all purposes and
reduces executing coala to one function call.
:param console_printer: Object to print messages on the console.
:param log_printer: A LogPrinter object to use for logging.
:param print_results: A callback that takes a LogPrinter, a
section, a list of results to be printed,
the file dict and the mutable file diff
dict.
:param acquire_settings: The method to use for requesting settings.
It will get a parameter which is a
dictionary with the settings name as key
and a list containing a description in [0]
and the names of the bears who need this
setting in all following indexes.
:param print_section_beginning: A callback that will be called with a
section name string whenever analysis of a
new section is started.
:param nothing_done: A callback that will be called with only a
log printer that shall indicate that
nothing was done.
:param autoapply: Set this to false to not autoapply any
actions. If you set this to `False`,
`force_show_patch` will be ignored.
:param force_show_patch: If set to True, a patch will be always
shown. (Using ApplyPatchAction.)
:param arg_parser: Instance of ArgParser that is used to parse
non-setting arguments.
:param arg_list: The CLI argument list.
:param args: Alternative pre-parsed CLI arguments.
:param debug: Run in debug mode, bypassing
multiprocessing, and not catching any
exceptions.
:param cache: Instance of a FileCache instance.
:return: A dictionary containing a list of results
for all analyzed sections as key.
"""
all_actions_possible = provide_all_actions()
apply_single = None
if getattr(args, 'single_action', None) is not None:
while True:
for i, action in enumerate(all_actions_possible, 1):
console_printer.print(format_lines('{}'.format(
action), symbol='['))
line = format_lines(STR_ENTER_LETTER, symbol='[')
choice = input(line)
if choice.isalpha():
choice = choice.upper()
choice = '(' + choice + ')'
if choice == '(N)':
apply_single = 'Do (N)othing'
break
for i, action in enumerate(all_actions_possible, 1):
if choice in action:
apply_single = action
break
if apply_single:
break
console_printer.print(format_lines(
'Please enter a valid letter.',
symbol='['))
args.apply_patch = False
exitcode = 0
sections = {}
results = {}
file_dicts = {}
try:
yielded_results = yielded_unfixed_results = False
did_nothing = True
sections, local_bears, global_bears, targets = gather_configuration(
acquire_settings,
arg_parser=arg_parser,
arg_list=arg_list,
args=args)
logging.debug('Platform {} -- Python {}, coalib {}'
.format(platform.system(), platform.python_version(),
VERSION))
settings_hash = get_settings_hash(sections, targets)
flush_cache = bool(sections['cli'].get('flush_cache', False) or
settings_changed(None, settings_hash))
if cache is None and not sections['cli'].get('disable_caching', False):
cache = FileDictFileCache(None, os.getcwd(), flush_cache)
if targets:
sections = OrderedDict(
(section_name, sections[section_name])
for section_name in targets)
# Collect all the filters and try to filter sections
filters = collect_filters(args, arg_list, arg_parser)
if len(filters) > 0:
all_sections = list(sections.values())
try:
filtered = apply_filters(filters, sections=all_sections)
sections = OrderedDict(
(sect.name.lower(), sect) for sect in filtered)
except (InvalidFilterException, NotImplementedError) as ex:
console_printer.print(ex)
for section_name, section in sections.items():
if not section.is_enabled(targets):
continue
if not autoapply:
section['default_actions'] = ''
elif force_show_patch:
section['default_actions'] = '*: ShowPatchAction'
section['show_result_on_top'] = 'yeah'
print_section_beginning(section)
section_result = execute_section(
section=section,
global_bear_list=global_bears[section_name],
local_bear_list=local_bears[section_name],
print_results=print_results,
cache=cache,
log_printer=None,
console_printer=console_printer,
debug=debug or args and args.debug,
apply_single=(apply_single
if apply_single is not None else
False))
yielded, yielded_unfixed, results[section_name] = (
simplify_section_result(section_result))
yielded_results = yielded_results or yielded
yielded_unfixed_results = (
yielded_unfixed_results or yielded_unfixed)
did_nothing = False
file_dicts[section_name] = section_result[3]
update_settings_db(None, settings_hash)
if cache:
cache.write()
if CounterHandler.get_num_calls_for_level('ERROR') > 0:
exitcode = 1
elif did_nothing:
nothing_done(None)
exitcode = 2
elif yielded_unfixed_results:
exitcode = 1
elif yielded_results:
exitcode = 5
except BaseException as exception: # pylint: disable=broad-except
if not isinstance(exception, SystemExit):
if args and args.debug or (
sections and sections.get('cli', {}).get('debug', False)
):
import ipdb
with ipdb.launch_ipdb_on_exception():
raise
if debug:
raise
exitcode = exitcode or get_exitcode(exception)
return results, exitcode, file_dicts
def run_coala(log_printer=None,
print_results=do_nothing,
acquire_settings=fail_acquire_settings,
print_section_beginning=do_nothing,
nothing_done=do_nothing,
autoapply=True,
arg_parser=None,
arg_list=None):
"""
This is a main method that should be usable for almost all purposes and
reduces executing coala to one function call.
:param log_printer: A LogPrinter object to use for logging.
:param print_results: A callback that takes a LogPrinter, a
section, a list of results to be printed,
the file dict and the mutable file diff
dict.
:param acquire_settings: The method to use for requesting settings.
It will get a parameter which is a
dictionary with the settings name as key
and a list containing a description in [0]
and the names of the bears who need this
setting in all following indexes.
:param print_section_beginning: A callback that will be called with a
section name string whenever analysis of a
new section is started.
:param nothing_done: A callback that will be called with only a
log printer that shall indicate that
nothing was done.
:param autoapply: Set to False to autoapply nothing by
default; this is overridable via any
configuration file/CLI.
:param arg_list: The CLI argument list.
:return: A dictionary containing a list of results
for all analyzed sections as key.
"""
configure_logging()
log_printer = (LogPrinter(ConsolePrinter(), LOG_LEVEL.DEBUG)
if log_printer is None else log_printer)
exitcode = 0
results = {}
file_dicts = {}
try:
yielded_results = yielded_unfixed_results = False
did_nothing = True
sections, local_bears, global_bears, targets = gather_configuration(
acquire_settings,
log_printer,
autoapply=autoapply,
arg_parser=arg_parser,
arg_list=arg_list)
log_printer.debug("Platform {} -- Python {}, pip {}, coalib {}".format(
platform.system(), platform.python_version(), pip.__version__,
VERSION))
config_file = os.path.abspath(str(sections["default"].get("config")))
settings_hash = get_settings_hash(sections, targets)
flush_cache = bool(sections["default"].get("flush_cache", False)
or settings_changed(log_printer, settings_hash))
disable_caching = bool(sections["default"].get("disable_caching",
False))
cache = None
if not sections["default"].get("disable_caching", False):
cache = FileCache(log_printer, os.getcwd(), flush_cache)
for section_name, section in sections.items():
if not section.is_enabled(targets):
continue
print_section_beginning(section)
section_result = execute_section(
section=section,
global_bear_list=global_bears[section_name],
local_bear_list=local_bears[section_name],
print_results=print_results,
cache=cache,
log_printer=log_printer)
yielded, yielded_unfixed, results[section_name] = (
simplify_section_result(section_result))
yielded_results = yielded_results or yielded
yielded_unfixed_results = (yielded_unfixed_results
or yielded_unfixed)
did_nothing = False
file_dicts[section_name] = section_result[3]
update_settings_db(log_printer, settings_hash)
if cache:
cache.write()
if did_nothing:
nothing_done(log_printer)
elif yielded_unfixed_results:
exitcode = 1
elif yielded_results:
exitcode = 5
except BaseException as exception: # pylint: disable=broad-except
exitcode = exitcode or get_exitcode(exception, log_printer)
return results, exitcode, file_dicts
def run_coala(log_printer=None,
print_results=do_nothing,
acquire_settings=fail_acquire_settings,
print_section_beginning=do_nothing,
nothing_done=do_nothing,
show_bears=do_nothing,
autoapply=True):
"""
This is a main method that should be usable for almost all purposes and
reduces executing coala to one function call.
:param log_printer: A LogPrinter object to use for logging.
:param print_results: A callback that takes a LogPrinter, a
section, a list of results to be printed,
the file dict and the mutable file diff
dict.
:param acquire_settings: The method to use for requesting settings.
It will get a parameter which is a
dictionary with the settings name as key
and a list containing a description in [0]
and the names of the bears who need this
setting in all following indexes.
:param print_section_beginning: A callback that will be called with a
section name string whenever analysis of a
new section is started.
:param nothing_done: A callback that will be called with only a
log printer that shall indicate that
nothing was done.
:param show_bears: A callback that will be called with first
a list of local bears, second a list of
global bears to output them. A third bool
parameter may be used to indicate if a
compressed output (True) or a normal output
(False) is desired, the former being used
for showing all available bears to the
user.
:param autoapply: Set to False to autoapply nothing by
default; this is overridable via any
configuration file/CLI.
:return: A dictionary containing a list of results
for all analyzed sections as key.
"""
log_printer = log_printer or LogPrinter(ConsolePrinter())
exitcode = 0
results = None
try:
yielded_results = yielded_unfixed_results = False
did_nothing = True
sections, local_bears, global_bears, targets = gather_configuration(
acquire_settings,
log_printer,
autoapply=autoapply)
tag = str(sections['default'].get('tag', None))
dtag = str(sections['default'].get('dtag', None))
config_file = os.path.abspath(str(sections["default"].get("config")))
show_all_bears = bool(sections['default'].get('show_all_bears', False))
show_bears_ = bool(sections["default"].get("show_bears", "False"))
# Deleting all .orig files, so the latest files are up to date!
coala_delete_orig.main(log_printer, sections["default"])
delete_tagged_results(dtag, config_file, log_printer)
if show_bears_ or show_all_bears:
if show_all_bears:
(local_bears,
global_bears) = collect_all_bears_from_sections(sections,
log_printer)
show_bears(local_bears, global_bears, show_all_bears)
did_nothing = False
else:
results = {}
for section_name, section in sections.items():
if not section.is_enabled(targets):
continue
print_section_beginning(section)
section_result = execute_section(
section=section,
global_bear_list=global_bears[section_name],
local_bear_list=local_bears[section_name],
print_results=print_results,
log_printer=log_printer)
yielded, yielded_unfixed, results[section_name] = (
simplify_section_result(section_result))
yielded_results = yielded_results or yielded
yielded_unfixed_results = (
yielded_unfixed_results or yielded_unfixed)
did_nothing = False
tag_results(tag, config_file, results, log_printer)
if did_nothing:
nothing_done(log_printer)
elif yielded_unfixed_results:
exitcode = 1
elif yielded_results:
exitcode = 5
except BaseException as exception: # pylint: disable=broad-except
exitcode = exitcode or get_exitcode(exception, log_printer)
return results, exitcode
def run_coala(console_printer=None,
log_printer=None,
print_results=do_nothing,
acquire_settings=fail_acquire_settings,
print_section_beginning=do_nothing,
nothing_done=do_nothing,
autoapply=True,
force_show_patch=False,
arg_parser=None,
arg_list=None):
"""
This is a main method that should be usable for almost all purposes and
reduces executing coala to one function call.
:param console_printer: Object to print messages on the console.
:param log_printer: A LogPrinter object to use for logging.
:param print_results: A callback that takes a LogPrinter, a
section, a list of results to be printed,
the file dict and the mutable file diff
dict.
:param acquire_settings: The method to use for requesting settings.
It will get a parameter which is a
dictionary with the settings name as key
and a list containing a description in [0]
and the names of the bears who need this
setting in all following indexes.
:param print_section_beginning: A callback that will be called with a
section name string whenever analysis of a
new section is started.
:param nothing_done: A callback that will be called with only a
log printer that shall indicate that
nothing was done.
:param autoapply: Set this to false to not autoapply any
actions. If you set this to `False`,
`force_show_patch` will be ignored.
:param force_show_patch: If set to True, a patch will be always
shown. (Using ApplyPatchAction.)
:param arg_parser: Instance of ArgParser that is used to parse
non-setting arguments.
:param arg_list: The CLI argument list.
:return: A dictionary containing a list of results
for all analyzed sections as key.
"""
log_printer = (LogPrinter(ConsolePrinter(), LOG_LEVEL.DEBUG)
if log_printer is None else log_printer)
exitcode = 0
results = {}
file_dicts = {}
try:
yielded_results = yielded_unfixed_results = False
did_nothing = True
sections, local_bears, global_bears, targets = gather_configuration(
acquire_settings,
log_printer,
arg_parser=arg_parser,
arg_list=arg_list)
log_printer.debug('Platform {} -- Python {}, coalib {}'.format(
platform.system(), platform.python_version(), VERSION))
settings_hash = get_settings_hash(sections, targets)
flush_cache = bool(sections['cli'].get('flush_cache', False)
or settings_changed(log_printer, settings_hash))
cache = None
if not sections['cli'].get('disable_caching', False):
cache = FileCache(log_printer, os.getcwd(), flush_cache)
for section_name, section in sections.items():
if not section.is_enabled(targets):
continue
if not autoapply:
section['default_actions'] = ''
elif force_show_patch:
section['default_actions'] = '*: ShowPatchAction'
section['show_result_on_top'] = 'yeah'
print_section_beginning(section)
section_result = execute_section(
section=section,
global_bear_list=global_bears[section_name],
local_bear_list=local_bears[section_name],
print_results=print_results,
cache=cache,
log_printer=log_printer,
console_printer=console_printer)
yielded, yielded_unfixed, results[section_name] = (
simplify_section_result(section_result))
yielded_results = yielded_results or yielded
yielded_unfixed_results = (yielded_unfixed_results
or yielded_unfixed)
did_nothing = False
file_dicts[section_name] = section_result[3]
update_settings_db(log_printer, settings_hash)
if cache:
cache.write()
if CounterHandler.get_num_calls_for_level('ERROR') > 0:
exitcode = 1
elif did_nothing:
nothing_done(log_printer)
exitcode = 2
elif yielded_unfixed_results:
exitcode = 1
elif yielded_results:
exitcode = 5
except BaseException as exception: # pylint: disable=broad-except
exitcode = exitcode or get_exitcode(exception, log_printer)
return results, exitcode, file_dicts
def run_coala(console_printer=None,
log_printer=None,
print_results=do_nothing,
acquire_settings=fail_acquire_settings,
print_section_beginning=do_nothing,
nothing_done=do_nothing,
autoapply=True,
force_show_patch=False,
arg_parser=None,
arg_list=None,
args=None,
debug=False):
"""
This is a main method that should be usable for almost all purposes and
reduces executing coala to one function call.
:param console_printer: Object to print messages on the console.
:param log_printer: A LogPrinter object to use for logging.
:param print_results: A callback that takes a LogPrinter, a
section, a list of results to be printed,
the file dict and the mutable file diff
dict.
:param acquire_settings: The method to use for requesting settings.
It will get a parameter which is a
dictionary with the settings name as key
and a list containing a description in [0]
and the names of the bears who need this
setting in all following indexes.
:param print_section_beginning: A callback that will be called with a
section name string whenever analysis of a
new section is started.
:param nothing_done: A callback that will be called with only a
log printer that shall indicate that
nothing was done.
:param autoapply: Set this to false to not autoapply any
actions. If you set this to `False`,
`force_show_patch` will be ignored.
:param force_show_patch: If set to True, a patch will be always
shown. (Using ApplyPatchAction.)
:param arg_parser: Instance of ArgParser that is used to parse
non-setting arguments.
:param arg_list: The CLI argument list.
:param args: Alternative pre-parsed CLI arguments.
:param debug: Run in debug mode, bypassing
multiprocessing, and not catching any
exceptions.
:return: A dictionary containing a list of results
for all analyzed sections as key.
"""
all_actions_possible = provide_all_actions()
apply_single = None
if getattr(args, 'single_action', None) is not None:
while True:
for i, action in enumerate(all_actions_possible, 1):
console_printer.print(
format_lines('{}'.format(action), symbol='['))
line = format_lines(STR_ENTER_NUMBER, symbol='[')
choice = input(line)
if choice.isalpha():
choice = choice.upper()
choice = '(' + choice + ')'
if choice == '(N)':
apply_single = 'Do (N)othing'
break
for i, action in enumerate(all_actions_possible, 1):
if choice in action:
apply_single = action
break
if apply_single:
break
console_printer.print(
format_lines('Please enter a valid letter.', symbol='['))
args.apply_patch = False
log_printer = (LogPrinter(ConsolePrinter(), LOG_LEVEL.DEBUG)
if log_printer is None else log_printer)
exitcode = 0
sections = {}
results = {}
file_dicts = {}
try:
yielded_results = yielded_unfixed_results = False
did_nothing = True
sections, local_bears, global_bears, targets = gather_configuration(
acquire_settings,
log_printer,
arg_parser=arg_parser,
arg_list=arg_list,
args=args)
log_printer.debug('Platform {} -- Python {}, coalib {}'.format(
platform.system(), platform.python_version(), VERSION))
settings_hash = get_settings_hash(sections, targets)
flush_cache = bool(sections['cli'].get('flush_cache', False)
or settings_changed(log_printer, settings_hash))
cache = None
if not sections['cli'].get('disable_caching', False):
cache = FileCache(log_printer, os.getcwd(), flush_cache)
for section_name, section in sections.items():
if not section.is_enabled(targets):
continue
if not autoapply:
section['default_actions'] = ''
elif force_show_patch:
section['default_actions'] = '*: ShowPatchAction'
section['show_result_on_top'] = 'yeah'
print_section_beginning(section)
section_result = execute_section(
section=section,
global_bear_list=global_bears[section_name],
local_bear_list=local_bears[section_name],
print_results=print_results,
cache=cache,
log_printer=log_printer,
console_printer=console_printer,
debug=debug or args and args.debug,
apply_single=(apply_single
if apply_single is not None else False))
yielded, yielded_unfixed, results[section_name] = (
simplify_section_result(section_result))
yielded_results = yielded_results or yielded
yielded_unfixed_results = (yielded_unfixed_results
or yielded_unfixed)
did_nothing = False
file_dicts[section_name] = section_result[3]
update_settings_db(log_printer, settings_hash)
if cache:
cache.write()
if CounterHandler.get_num_calls_for_level('ERROR') > 0:
exitcode = 1
elif did_nothing:
nothing_done(log_printer)
exitcode = 2
elif yielded_unfixed_results:
exitcode = 1
elif yielded_results:
exitcode = 5
except BaseException as exception: # pylint: disable=broad-except
if not isinstance(exception, SystemExit):
if args and args.debug or (sections and sections.get(
'cli', {}).get('debug', False)):
import ipdb
with ipdb.launch_ipdb_on_exception():
raise
if debug:
raise
exitcode = exitcode or get_exitcode(exception, log_printer)
return results, exitcode, file_dicts
