def __init__(
self,
log_printer: LogPrinter,
project_dir: str,
flush_cache: bool=False):
"""
Initialize FileCache.
:param log_printer: A LogPrinter object to use for logging.
:param project_dir: The root directory of the project to be used
as a key identifier.
:param flush_cache: Flush the cache and rebuild it.
"""
self.log_printer = log_printer
self.project_dir = project_dir
self.current_time = int(time.time())
cache_data = pickle_load(log_printer, project_dir, {})
last_time = -1
if "time" in cache_data:
last_time = cache_data["time"]
if not flush_cache and last_time > self.current_time:
log_printer.warn("It seems like you went back in time - your "
"system time is behind the last recorded run "
"time on this project. The cache will "
"be force flushed.")
flush_cache = True
self.data = cache_data.get("files", {})
if flush_cache:
self.flush_cache()
def __init__(self,
section: Section,
message_queue,
timeout=0):
"""
Constructs a new bear.
:param section: The section object where bear settings are
contained.
:param message_queue: The queue object for messages. Can be ``None``.
:param timeout: The time the bear is allowed to run. To set no
time limit, use 0.
:raises TypeError: Raised when ``message_queue`` is no queue.
:raises RuntimeError: Raised when bear requirements are not fulfilled.
"""
Printer.__init__(self)
LogPrinter.__init__(self, self)
if message_queue is not None and not hasattr(message_queue, "put"):
raise TypeError("message_queue has to be a Queue or None.")
self.section = section
self.message_queue = message_queue
self.timeout = timeout
self.setup_dependencies()
cp = type(self).check_prerequisites()
if cp is not True:
error_string = ("The bear " + self.name +
" does not fulfill all requirements.")
if cp is not False:
error_string += " " + cp
self.warn(error_string)
raise RuntimeError(error_string)
def __init__(self,
log_level=LOG_LEVEL.WARNING,
timestamp_format="%X"):
Printer.__init__(self)
LogPrinter.__init__(self, self, log_level, timestamp_format)
self.logs = []
def __init__(self, section: Section, message_queue, timeout=0):
"""
Constructs a new bear.
:param section: The section object where bear settings are
contained.
:param message_queue: The queue object for messages. Can be `None`.
:param timeout: The time the bear is allowed to run. To set no
time limit, use 0.
:raises TypeError: Raised when `message_queue` is no queue.
:raises RuntimeError: Raised when bear requirements are not fulfilled.
"""
Printer.__init__(self)
LogPrinter.__init__(self, self)
if message_queue is not None and not hasattr(message_queue, "put"):
raise TypeError("message_queue has to be a Queue or None.")
self.section = section
self.message_queue = message_queue
self.timeout = timeout
cp = type(self).check_prerequisites()
if cp is not True:
error_string = ("The bear " + type(self).__name__ +
" does not fulfill all requirements.")
if cp is not False:
error_string += " " + cp
self.warn(error_string)
raise RuntimeError(error_string)
def test_run_coala_no_autoapply(self, debug=False):
with bear_test_module(), \
prepare_file(['#fixme '], None) as (lines, filename):
self.assertEqual(
1,
len(
run_coala(console_printer=ConsolePrinter(),
log_printer=LogPrinter(),
arg_list=('-c', os.devnull, '-f',
re.escape(filename), '-b',
'SpaceConsistencyTestBear',
'--apply-patches', '-S',
'use_spaces=yeah'),
autoapply=False,
debug=debug)[0]['cli']))
self.assertEqual(
0,
len(
run_coala(console_printer=ConsolePrinter(),
log_printer=LogPrinter(),
arg_list=('-c', os.devnull, '-f',
re.escape(filename), '-b',
'SpaceConsistencyTestBear',
'--apply-patches', '-S',
'use_spaces=yeah'),
debug=debug)[0]['cli']))
def __init__(self,
section: Section,
message_queue,
timeout=0):
Printer.__init__(self)
LogPrinter.__init__(self, self)
if not hasattr(message_queue, "put") and message_queue is not None:
raise TypeError("message_queue has to be a Queue or None.")
self.section = section
self.message_queue = message_queue
self.timeout = timeout
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 test_file_cache_proxy_integration(self, debug=False):
with bear_test_module(), \
prepare_file(['disk-copy\n'], None) as (_, filename):
memory_data = 'in-memory\n'
proxy = FileProxy(filename, None, memory_data)
proxymap = FileProxyMap([proxy])
self.cache.set_proxymap(proxymap)
results, exitcode, file_dicts = run_coala(
console_printer=ConsolePrinter(),
log_printer=LogPrinter(),
arg_list=(
'-c',
os.devnull,
'-f',
filename,
'-b',
'TestBear',
),
autoapply=False,
debug=debug,
cache=self.cache)
self.assertEqual(exitcode, 0)
self.assertEqual(len(results), 1)
# run_coala() output's name is always lower case
self.assertEqual(file_dicts['cli'][filename.lower()],
(memory_data, ))
def main():
# Note: We parse the args here once to check whether to show bears or not.
arg_parser = default_arg_parser()
args = arg_parser.parse_args()
console_printer = ConsolePrinter()
if args.show_bears or args.show_all_bears:
log_printer = LogPrinter(console_printer)
sections, _ = load_configuration(arg_list=None, log_printer=log_printer)
if args.show_all_bears:
local_bears, global_bears = collect_all_bears_from_sections(
sections, log_printer)
else:
# We ignore missing settings as it's not important.
local_bears, global_bears = fill_settings(
sections,
acquire_settings=lambda *args, **kwargs: {},
log_printer=log_printer)
show_bears(local_bears, global_bears, args.show_all_bears,
console_printer)
return 0
partial_print_sec_beg = functools.partial(
print_section_beginning,
console_printer)
results, exitcode, _ = run_coala(
print_results=print_results,
acquire_settings=acquire_settings,
print_section_beginning=partial_print_sec_beg,
nothing_done=nothing_done)
return exitcode
def main():
try:
console_printer = ConsolePrinter()
log_printer = LogPrinter(console_printer)
# Note: We parse the args here once to check whether to show bears or
# not.
args = default_arg_parser().parse_args()
if args.show_bears:
sections, _ = load_configuration(arg_list=None,
log_printer=log_printer)
local_bears, global_bears = collect_all_bears_from_sections(
sections, log_printer)
if args.filter_by_language:
local_bears = filter_section_bears_by_languages(
local_bears, args.filter_by_language)
global_bears = filter_section_bears_by_languages(
global_bears, args.filter_by_language)
show_bears(local_bears, global_bears, args.show_description
or args.show_details, args.show_details,
console_printer)
return 0
except BaseException as exception: # pylint: disable=broad-except
return get_exitcode(exception, log_printer)
partial_print_sec_beg = functools.partial(print_section_beginning,
console_printer)
results, exitcode, _ = run_coala(
print_results=print_results,
acquire_settings=acquire_settings,
print_section_beginning=partial_print_sec_beg,
nothing_done=nothing_done)
return exitcode
def main(log_printer=None, section: Section = None):
start_path = get_config_directory(section)
log_printer = log_printer or LogPrinter(ConsolePrinter())
if start_path is None:
log_printer.err("Can only delete .orig files if .coafile is found")
return 255
orig_files = Globbing.glob(
os.path.abspath(os.path.join(start_path, '**', '*.orig')))
not_deleted = 0
for ofile in orig_files:
log_printer.info("Deleting old backup file... " +
os.path.relpath(ofile))
try:
os.remove(ofile)
except OSError as oserror:
not_deleted += 1
log_printer.warn("Couldn't delete... {}. {}".format(
os.path.relpath(ofile), oserror.strerror))
if not_deleted:
log_printer.warn(
str(not_deleted) + " .orig backup files could not be"
" deleted, possibly because you lack the permission"
" to do so. coala may not be able to create"
" backup files when patches are applied.")
return 0
def main():
arg_parser = _get_arg_parser()
args = arg_parser.parse_args()
printer = ConsolePrinter()
log_printer = LogPrinter(printer)
project_dir = os.getcwd()
if not args.non_interactive:
print_welcome_message(printer)
project_dir = ask_question("What is your project directory?",
default=project_dir,
typecast=valid_path)
project_files, ignore_globs = get_project_files(log_printer, printer,
project_dir)
used_languages = list(get_used_languages(project_files))
print_used_languages(printer, used_languages)
relevant_bears = filter_relevant_bears(used_languages, arg_parser)
print_relevant_bears(printer, relevant_bears)
if args.non_interactive:
unusable_bears = get_non_optional_settings_bears(relevant_bears)
remove_unusable_bears(relevant_bears, unusable_bears)
print_relevant_bears(printer, relevant_bears, 'usable')
settings = generate_settings(project_dir, project_files, ignore_globs,
relevant_bears)
write_coafile(printer, project_dir, settings)
def generate_ignore_field(project_dir, languages, extset, ignore_globs):
"""
Generate the ignore field for the ``default`` section.
:param project_dir:
Full path of the user's project directory.
:param languages:
A list of languages present in the project.
:param extset:
A dict with language name as key and a set of extensions as
value. This includes only those extensions used by the project.
:return:
A comma-separated string containing the globs to ignore.
"""
null_printer = LogPrinter(NullPrinter())
all_files = set(
collect_files("**", null_printer, ignored_file_paths=ignore_globs))
ignores = []
for glob in ignore_globs:
gitignore_files = {
file
for file in collect_files([glob], null_printer)
}
if not all_files.isdisjoint(gitignore_files):
ignores.append(os.path.relpath(glob, project_dir))
return ", ".join(ignores)
def setUp(self):
current_dir = os.path.split(__file__)[0]
self.caching_test_dir = os.path.join(current_dir, 'caching_testfiles')
self.log_printer = LogPrinter(NullPrinter())
self.cache = FileCache(self.log_printer,
'coala_test',
flush_cache=True)
def main(log_printer=None, section: Section = None):
configure_logging()
start_path = get_config_directory(section)
log_printer = (LogPrinter(ConsolePrinter())
if log_printer is None else log_printer)
if start_path is None:
return 255
# start_path may have unintended glob characters
orig_files = Globbing.glob(
os.path.join(glob_escape(start_path), '**', '*.orig'))
not_deleted = 0
for ofile in orig_files:
log_printer.info('Deleting old backup file... ' +
os.path.relpath(ofile))
try:
os.remove(ofile)
except OSError as oserror:
not_deleted += 1
log_printer.warn("Couldn't delete {}. {}".format(
os.path.relpath(ofile), oserror.strerror))
if not_deleted:
log_printer.warn(
str(not_deleted) + ' .orig backup files could not be'
' deleted, possibly because you lack the permission'
' to do so. coala may not be able to create'
' backup files when patches are applied.')
return 0
def apply(self, result, original_file_dict, file_diff_dict):
"""
(G)enerate patches
"""
console_printer = ConsolePrinter()
log_printer = LogPrinter()
to_filename = sorted(
result.diffs.items())[OBJECT_INDEX][FILENAME_INDEX]
filtered_bears = filter_bears(find_language(to_filename))
filtered_bears.insert(0, DefaultBear())
possible_options = [b.name for b in filtered_bears]
console_printer.print('[{:>4}] *0. Do Nothing'.format(''))
# Let the user choose a bear that wants to apply on the files
for i, action in enumerate(possible_options, 1):
show_possibilities(console_printer, i, action)
choose_action = str(input('[{:>4}] Enter a number: '.format('')))
if choose_action is '' or choose_action is '0':
return False
choose_action = int(choose_action)
chosen_bear = [possible_options[choose_action - 1]]
return mode_normal(console_printer,
log_printer,
create_arg_parser([to_filename], chosen_bear),
debug=False)
def setUp(self):
config_path = os.path.abspath(os.path.join(
os.path.dirname(__file__),
'section_executor_test_files',
'.coafile'))
self.testcode_c_path = os.path.join(os.path.dirname(config_path),
'testcode.c')
self.unreadable_path = os.path.join(os.path.dirname(config_path),
'unreadable')
self.result_queue = queue.Queue()
self.queue = queue.Queue()
self.log_queue = queue.Queue()
self.console_printer = ConsolePrinter()
log_printer = LogPrinter(ConsolePrinter())
self.log_printer = ProcessingTestLogPrinter(self.log_queue)
(self.sections,
self.local_bears,
self.global_bears,
targets) = gather_configuration(lambda *args: True,
log_printer,
arg_list=['--config',
re.escape(config_path)])
self.assertEqual(len(self.local_bears['cli']), 1)
self.assertEqual(len(self.global_bears['cli']), 1)
self.assertEqual(targets, [])
def test_profiler_dependency(self, debug=False):
with bear_test_module():
with prepare_file(['#fixme '], None) as (lines, filename):
results = run_coala(console_printer=ConsolePrinter(),
log_printer=LogPrinter(),
arg_list=(
'-c',
os.devnull,
'-f',
filename,
'-b',
'DependentBear',
'-S',
'use_spaces=yeah',
'--profile',
'profiled_bears',
),
autoapply=False,
debug=debug)
cli_result = results[0]['cli']
self.assertEqual(len(cli_result), 1)
profiled_files = os.listdir('profiled_bears')
self.assertEqual(len(profiled_files), 1)
self.assertEqual(profiled_files[0],
'cli_SpaceConsistencyTestBear.prof')
shutil.rmtree('profiled_bears')
def setUp(self):
self.log_printer = LogPrinter(NullPrinter())
# Needed so coala doesn't error out
self.min_args = ['-f', '*.java', '-b', 'JavaTestBear']
self.original_user_coafile = Constants.user_coafile
self.original_system_coafile = Constants.system_coafile
def test_section_deprecation(self):
section = Section('')
log_printer = LogPrinter(NullPrinter())
with LogCapture() as capture:
fail_acquire_settings(log_printer, {}, section)
capture.check(
('root', 'WARNING', 'fail_acquire_settings: section parameter '
'is deprecated.'))
def get_all_bears_names():
from coalib.settings.Section import Section
printer = LogPrinter(NullPrinter())
local_bears, global_bears = collect_bears(
Section("").bear_dirs(), ["**"], [BEAR_KIND.LOCAL, BEAR_KIND.GLOBAL],
printer,
warn_if_unused_glob=False)
return [bear.name for bear in itertools.chain(local_bears, global_bears)]
def test_(self):
log_printer = LogPrinter(NullPrinter())
self.assertRaises(TypeError, fail_acquire_settings, log_printer, None)
self.assertRaises(AssertionError,
fail_acquire_settings,
log_printer,
{"setting": ["description", "bear"]})
self.assertEqual(fail_acquire_settings(log_printer, {}), None)
def main():
configure_logging()
try:
console_printer = ConsolePrinter()
log_printer = LogPrinter(console_printer)
# Note: We parse the args here once to check whether to show bears or
# not.
args = default_arg_parser().parse_args()
# Defer imports so if e.g. --help is called they won't be run
from coalib.coala_modes import (mode_format, mode_json,
mode_non_interactive, mode_normal)
from coalib.output.ConsoleInteraction import (
show_bears, show_language_bears_capabilities)
console_printer = ConsolePrinter(print_colored=not args.no_color)
configure_logging(not args.no_color)
if args.json: # needs to be checked in order to display bears in json
return mode_json(args)
if args.show_bears:
from coalib.settings.ConfigurationGathering import (
get_filtered_bears)
local_bears, global_bears = get_filtered_bears(
args.filter_by_language, log_printer)
show_bears(local_bears, global_bears, args.show_description
or args.show_details, args.show_details,
console_printer)
return 0
elif args.show_capabilities:
from coalib.collecting.Collectors import (
filter_capabilities_by_languages)
from coalib.settings.ConfigurationGathering import (
get_filtered_bears)
local_bears, global_bears = get_filtered_bears(
args.filter_by_language, log_printer)
capabilities = filter_capabilities_by_languages(
local_bears, args.show_capabilities)
show_language_bears_capabilities(capabilities, console_printer)
return 0
except BaseException as exception: # pylint: disable=broad-except
return get_exitcode(exception, log_printer)
if args.format:
return mode_format()
if args.non_interactive:
return mode_non_interactive(console_printer, args)
return mode_normal(console_printer, log_printer)
def setUp(self):
self.project_dir = os.path.join(
os.path.dirname(os.path.realpath(__file__)), "project_dir")
os.makedirs(self.project_dir, exist_ok=True)
self.arg_parser = _get_arg_parser()
self.printer = ConsolePrinter()
self.log_printer = LogPrinter(self.printer)
self.old_argv = deepcopy(sys.argv)
del sys.argv[1:]
def generate_settings(project_dir,
project_files,
ignore_globs,
relevant_bears,
incomplete_sections=False):
"""
Generates the settings for the given project.
:param project_dir:
Full path of the user's project directory.
:param project_files:
A list of file paths matched in the user's project directory.
:param ignore_globs:
The list of ignore glob expressions.
:param relevant_bears:
A dict with language name as key and bear classes as value.
:param incomplete_sections:
When bears with non optional settings are found, user is asked for
setting value of non optional bears and then a ``Section`` object
having ``files`` field, ``bears`` field and settings, is returned.
If incomplete_sections is set to ``True``, then no user input will
be asked and a ``Section`` object having only the ``files`` and
``bears`` field will be returned.
In CI mode, bears with non optional setting are not added in coafile.
But if incomplete_sections is set to ``True`` in CI mode, then those
bears are also added in the coafile.
:return:
A dict with section name as key and a ``Section`` object as value.
"""
lang_map = {lang.lower(): lang for lang in relevant_bears}
lang_files = split_by_language(project_files)
extset = get_extensions(project_files)
settings = OrderedDict()
settings["default"] = generate_section(
"default", [ext for lang in lang_files for ext in extset[lang]],
relevant_bears[lang_map["all"]])
ignored_files = generate_ignore_field(project_dir, lang_files.keys(),
extset, ignore_globs)
if ignored_files:
settings["default"]["ignore"] = ignored_files
for lang in lang_files:
if lang != "unknown" and lang != "all":
settings[lang_map[lang]] = generate_section(
lang, extset[lang], relevant_bears[lang_map[lang]])
log_printer = LogPrinter(ConsolePrinter())
if not incomplete_sections:
fill_settings(settings, acquire_settings, log_printer)
return settings
def setUp(self):
self.file = os.path.join(tempfile.gettempdir(), 'ConfParserTestFile')
with open(self.file, 'w', encoding='utf-8') as file:
file.write(self.example_file)
self.log_printer = LogPrinter()
self.write_file_name = os.path.join(tempfile.gettempdir(),
'ConfWriterTestFile')
self.uut = ConfWriter(self.write_file_name)
def test_(self):
log_printer = LogPrinter(NullPrinter())
section = Section('')
self.assertRaises(TypeError, fail_acquire_settings, log_printer, None,
section)
self.assertRaises(AssertionError, fail_acquire_settings, log_printer,
{'setting': ['description', 'bear']}, section)
self.assertEqual(fail_acquire_settings(log_printer, {}, section), None,
section)
def test_tagging(self):
log_printer = LogPrinter(NullPrinter())
execute_coala(coala_ci.main, "coala-ci", 'docs', "-S", "tag=test_tag",
"-c", self.coafile)
tag_path = get_tag_path("test_tag", self.unescaped_coafile,
log_printer)
self.assertTrue(os.path.exists(tag_path))
execute_coala(coala_ci.main, "coala-ci", 'docs', "-S", "dtag=test_tag",
"-c", self.coafile)
self.assertFalse(os.path.exists(tag_path))
def __init__(self,
filename,
log_level=LOG_LEVEL.WARNING,
timestamp_format="%X"):
"""
Creates a new FilePrinter. If the directory of the given file doesn't exist or if there's any access problems,
an exception will be thrown.
:param filename: the name of the file to put the data into (string).
"""
self.file = None
if not isinstance(filename, str):
raise TypeError("filename must be a string.")
LogPrinter.__init__(self,
timestamp_format=timestamp_format,
log_level=log_level)
self.file = open(filename, 'a+')
def mode_json(args):
import json
from coalib.coala_main import run_coala
from coalib.misc.DictUtilities import inverse_dicts
from coalib.misc.Exceptions import get_exitcode
from coalib.output.Logging import configure_json_logging
from coalib.output.JSONEncoder import create_json_encoder
from coalib.output.printers.LogPrinter import LogPrinter
from coalib.settings.ConfigurationGathering import get_filtered_bears
if args.log_json:
log_stream = configure_json_logging()
JSONEncoder = create_json_encoder(use_relpath=args.relpath)
results = []
if args.show_bears:
try:
local_bears, global_bears = get_filtered_bears(
args.filter_by_language, LogPrinter())
bears = inverse_dicts(local_bears, global_bears)
for bear, _ in sorted(bears.items(),
key=lambda bear_tuple: bear_tuple[0].name):
results.append(bear)
except BaseException as exception: # pylint: disable=broad-except
return get_exitcode(exception)
else:
results, exitcode, _ = run_coala()
retval = {'bears': results} if args.show_bears else {'results': results}
if args.log_json:
retval['logs'] = [
json.loads(line) for line in log_stream.getvalue().splitlines()
]
if args.output:
filename = str(args.output[0])
with open(filename, 'w+') as fp:
json.dump(retval,
fp,
cls=JSONEncoder,
sort_keys=True,
indent=2,
separators=(',', ': '))
else:
print(
json.dumps(retval,
cls=JSONEncoder,
sort_keys=True,
indent=2,
separators=(',', ': ')))
return 0 if args.show_bears else exitcode
def main():
configure_logging()
try:
console_printer = ConsolePrinter()
log_printer = LogPrinter(console_printer)
# Note: We parse the args here once to check whether to show bears or
# not.
args = default_arg_parser().parse_args()
console_printer = ConsolePrinter(print_colored=not args.no_color)
if args.show_bears:
from coalib.settings.ConfigurationGathering import (
get_filtered_bears)
local_bears, global_bears = get_filtered_bears(
args.filter_by_language, log_printer)
show_bears(local_bears, global_bears, args.show_description
or args.show_details, args.show_details,
console_printer)
return 0
elif args.show_capabilities:
from coalib.collecting.Collectors import (
filter_capabilities_by_languages)
from coalib.settings.ConfigurationGathering import (
get_filtered_bears)
local_bears, global_bears = get_filtered_bears(
args.filter_by_language, log_printer)
capabilities = filter_capabilities_by_languages(
local_bears, args.show_capabilities)
show_language_bears_capabilities(capabilities, console_printer)
return 0
except BaseException as exception: # pylint: disable=broad-except
return get_exitcode(exception, log_printer)
import functools
from coalib.coala_main import run_coala
partial_print_sec_beg = functools.partial(print_section_beginning,
console_printer)
results, exitcode, _ = run_coala(
print_results=print_results,
acquire_settings=acquire_settings,
print_section_beginning=partial_print_sec_beg,
nothing_done=nothing_done,
console_printer=console_printer)
return exitcode
def test_run_coala_bear_run_raises(self):
configure_logging()
with bear_test_module(), \
prepare_file(['#fixme '], None) as (lines, filename), \
self.assertRaisesRegex(
RuntimeError, r"^That's all the RaiseTestBear can do\.$"):
run_coala(console_printer=ConsolePrinter(),
log_printer=LogPrinter(),
arg_list=('-c', os.devnull, '-f', re.escape(filename),
'-b', 'RaiseTestBear'),
debug=True)
def setUp(self):
config_path = os.path.abspath(
os.path.join(os.path.dirname(__file__),
'section_executor_test_files', '.coafile'))
self.testcode_c_path = os.path.join(os.path.dirname(config_path),
'testcode.c')
self.unreadable_path = os.path.join(os.path.dirname(config_path),
'unreadable')
factory_test_path = os.path.abspath(
os.path.join(os.path.dirname(__file__), 'file_factory_test_files'))
self.factory_test_file = os.path.join(factory_test_path,
'factory_test.txt')
self.a_bear_test_path = os.path.join(factory_test_path,
'a_bear_test.txt')
self.b_bear_test_path = os.path.join(factory_test_path,
'b_bear_test.txt')
self.c_bear_test_path = os.path.join(factory_test_path,
'c_bear_test.txt')
self.d_bear_test_path = os.path.join(factory_test_path,
'd_bear_test.txt')
self.e_bear_test_path = os.path.join(factory_test_path,
'e_bear_test.txt')
self.n_bear_test_path = os.path.join(factory_test_path,
'n_bear_test.txt')
self.n_bear_test_path_2 = os.path.join(factory_test_path,
'n_bear_test2.txt')
self.x_bear_test_path = os.path.join(factory_test_path,
'x_bear_test.txt')
filename_list = [
self.factory_test_file, self.a_bear_test_path,
self.b_bear_test_path, self.c_bear_test_path,
self.d_bear_test_path, self.e_bear_test_path,
self.n_bear_test_path, self.n_bear_test_path_2,
self.x_bear_test_path
]
self.file_dict = get_file_dict(filename_list)
self.result_queue = queue.Queue()
self.queue = queue.Queue()
self.log_queue = queue.Queue()
self.console_printer = ConsolePrinter()
log_printer = LogPrinter(ConsolePrinter())
self.log_printer = ProcessingTestLogPrinter(self.log_queue)
(self.sections, self.local_bears, self.global_bears,
targets) = gather_configuration(lambda *args: True,
log_printer,
arg_list=['--config', config_path])
self.assertEqual(len(self.local_bears['cli']), 1)
self.assertEqual(len(self.global_bears['cli']), 1)
self.assertEqual(targets, [])
def get_all_bears():
"""
Get a ``list`` of all available bears.
"""
from coalib.settings.Section import Section
printer = LogPrinter(NullPrinter())
local_bears, global_bears = collect_bears(
Section('').bear_dirs(), ['**'], [BEAR_KIND.LOCAL, BEAR_KIND.GLOBAL],
printer,
warn_if_unused_glob=False)
return list(itertools.chain(local_bears, global_bears))
def __init__(self):
LogPrinter.__init__(self, self)
def __init__(self, result_queue, log_queue):
Interactor.__init__(self)
LogPrinter.__init__(self)
self.result_queue = result_queue
self.log_queue = log_queue
self.set_up = False
def __init__(self, log_level=LOG_LEVEL.WARNING, timestamp_format="%X"):
ColorPrinter.__init__(self)
LogPrinter.__init__(self, log_level=log_level, timestamp_format=timestamp_format)
def __init__(self):
GObject.Object.__init__(self)
self.log_printer = LogPrinter(ConsolePrinter())
class CoalaViewActivatable(GObject.Object, Gedit.ViewActivatable):
"""
A class inherited from Gedit.ViewActivatable - it gets created for every
gedit view. This class has a property `view` which is the Gedit.View that
the class is related to. From the Gedit.View, the Gedit.Document associated
to it can be got using `view.get_buffer()`.
"""
__gtype_name__ = "CoalaViewActivatable"
view = GObject.Property(type=Gedit.View)
def __init__(self):
GObject.Object.__init__(self)
self.log_printer = LogPrinter(ConsolePrinter())
def do_activate(self):
"""
This function is called when the view is created - it will
be called only once in a lifetime of a view.
"""
self.register_marks()
self.view.get_buffer().connect("saved", lambda x: self.analyze())
def register_marks(self):
"""
Creates mark-attributes for all result severities.
"""
self.view.set_show_line_marks(True)
for name, val in RESULT_SEVERITY.str_dict.items():
attr = GtkSource.MarkAttributes()
attr.set_icon_name(RESULT_SEVERITY_ICONS[val])
attr.connect("query_tooltip_markup", self.show_mark_tooltip)
self.view.set_mark_attributes(get_mark_category(name), attr, 0)
self.log_printer.info("Mark attribute created for", name)
def show_mark_tooltip(self, mark_attr, mark):
result = getattr(mark, COALA_KEY + "Result")
return str(result.origin) + ": " + str(result.message)
def show_result(self, result):
"""
Takes a result and shows it in gedit's UI.
:param result: The result to display.
"""
document = self.view.get_buffer()
for sourcerange in result.affected_code:
_iter = document.get_iter_at_line(sourcerange.start.line-1)
mark = document.create_source_mark(
None,
get_mark_category(result.severity),
_iter)
setattr(mark, COALA_KEY + "Result", result)
self.log_printer.info("Created mark at", sourcerange.start.line)
def analyze(self):
"""
This function fetches the location of the file in this view
and runs coala on it.
"""
document = self.view.get_buffer()
location = document.get_location()
if location == None:
self.log_printer.warn("coala cannot run on unsaved files")
return
results = CoalaViewActivatable.run_coala(location.get_path())
document.remove_source_marks(document.get_start_iter(),
document.get_end_iter())
for section_results in results.values():
for result in section_results:
self.show_result(result)
@staticmethod
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 test_log_level(self):
uut = LogPrinter()
self.assertEqual(uut.log_level, logging.DEBUG)
uut.log_level = logging.INFO
self.assertEqual(uut.log_level, logging.INFO)
def test_logging(self):
uut = LogPrinter(timestamp_format="")
uut.logger = mock.MagicMock()
uut.log_message(self.log_message)
msg = Constants.COMPLEX_TEST_STRING
uut.logger.log.assert_called_with(logging.ERROR, msg)
uut = LogPrinter(log_level=LOG_LEVEL.DEBUG)
uut.logger = mock.MagicMock()
uut.log(LOG_LEVEL.ERROR, Constants.COMPLEX_TEST_STRING)
uut.logger.log.assert_called_with(logging.ERROR, msg)
uut.debug(Constants.COMPLEX_TEST_STRING, "d")
uut.logger.log.assert_called_with(logging.DEBUG, msg + " d")
uut.log_level = LOG_LEVEL.DEBUG
uut.log_exception("Something failed.", NotImplementedError(msg))
uut.logger.log.assert_any_call(logging.ERROR, "Something failed.")
uut.logger.log.assert_called_with(
logging.INFO,
"Exception was:\n{exception}: {msg}".format(
exception="NotImplementedError",
msg=msg))
def test_get_state(self):
uut = LogPrinter()
self.assertNotIn('logger', uut.__getstate__())
def test_set_state(self):
uut = LogPrinter()
state = uut.__getstate__()
uut.__setstate__(state)
self.assertIs(uut.logger, logging.getLogger())
def __init__(self, log_queue):
LogPrinter.__init__(self, self)
self.log_queue = log_queue
self.set_up = False
def __init__(self):
ColorPrinter.__init__(self)
LogPrinter.__init__(self)
def test_logging(self):
uut = LogPrinter(StringPrinter(), timestamp_format="")
uut.log_message(self.log_message, end="")
self.assertEqual(uut.printer.string, str(self.log_message))
uut = LogPrinter(StringPrinter(), log_level=LOG_LEVEL.DEBUG)
uut.log_message(self.log_message, end="")
self.assertEqual(
uut.printer.string,
"[ERROR][" + self.timestamp.strftime("%X") + "] " +
Constants.COMPLEX_TEST_STRING)
uut.printer.clear()
uut.log(LOG_LEVEL.ERROR,
Constants.COMPLEX_TEST_STRING,
timestamp=self.timestamp,
end="")
self.assertEqual(
uut.printer.string,
"[ERROR][" + self.timestamp.strftime("%X") + "] " +
Constants.COMPLEX_TEST_STRING)
uut.printer.clear()
uut.debug(Constants.COMPLEX_TEST_STRING,
"d",
timestamp=self.timestamp,
end="")
self.assertEqual(
uut.printer.string,
"[DEBUG][" + self.timestamp.strftime("%X") + "] " +
Constants.COMPLEX_TEST_STRING + " d")
uut.printer.clear()
uut.log_level = LOG_LEVEL.INFO
uut.debug(Constants.COMPLEX_TEST_STRING,
timestamp=self.timestamp,
end="")
self.assertEqual(uut.printer.string, "")
uut.printer.clear()
uut.info(Constants.COMPLEX_TEST_STRING,
"d",
timestamp=self.timestamp,
end="")
self.assertEqual(
uut.printer.string,
"[INFO][" + self.timestamp.strftime("%X") + "] " +
Constants.COMPLEX_TEST_STRING + " d")
uut.log_level = LOG_LEVEL.WARNING
uut.printer.clear()
uut.debug(Constants.COMPLEX_TEST_STRING,
timestamp=self.timestamp,
end="")
self.assertEqual(uut.printer.string, "")
uut.printer.clear()
uut.warn(Constants.COMPLEX_TEST_STRING,
"d",
timestamp=self.timestamp,
end="")
self.assertEqual(
uut.printer.string,
"[WARNING][" + self.timestamp.strftime("%X") + "] " +
Constants.COMPLEX_TEST_STRING + " d")
uut.printer.clear()
uut.err(Constants.COMPLEX_TEST_STRING,
"d",
timestamp=self.timestamp,
end="")
self.assertEqual(
uut.printer.string,
"[ERROR][" + self.timestamp.strftime("%X") + "] " +
Constants.COMPLEX_TEST_STRING + " d")
uut.log_level = LOG_LEVEL.DEBUG
uut.printer.clear()
uut.log_exception(
"Something failed.",
NotImplementedError(Constants.COMPLEX_TEST_STRING),
timestamp=self.timestamp)
self.assertTrue(uut.printer.string.startswith(
"[ERROR][" + self.timestamp.strftime("%X") +
"] Something failed.\n" +
"[DEBUG][" + self.timestamp.strftime("%X") +
"] Exception was:"))
uut.log_level = LOG_LEVEL.INFO
uut.printer.clear()
logged = uut.log_exception(
"Something failed.",
NotImplementedError(Constants.COMPLEX_TEST_STRING),
timestamp=self.timestamp,
end="")
self.assertTrue(uut.printer.string.startswith(
"[ERROR][" + self.timestamp.strftime("%X") +
"] Something failed."))
