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 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):
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 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 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 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 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 read_coafile(self):
if os.path.isfile(self.src + '/.coafile'):
self.sections_dict = load_configuration(
["-c", self.src + '/.coafile'], LogPrinter(NullPrinter()))[0]
for section in self.sections_dict:
section_row = self.add_section(name=section)
for setting in self.sections_dict[section].contents:
if "comment" in setting:
continue
self.section_stack_map[section_row].add_setting(
self.sections_dict[section].contents[setting])
self.section_stack_map[section_row].add_setting()
def get_bears():
"""
Get a dict of bears with the bear class as key.
:return:
A dict with bear classes as key and the list of sections
as value.
"""
log_printer = LogPrinter(NullPrinter())
sections, _ = load_configuration(None, log_printer)
local_bears, global_bears = collect_all_bears_from_sections(
sections, log_printer)
return inverse_dicts(local_bears, global_bears)
def test_tagging(self):
with bear_test_module(), \
prepare_file(["\t#include <a>"], None) as (lines, filename):
log_printer = LogPrinter(NullPrinter())
execute_coala(coala_ci.main, "coala-ci", "default", "-c",
self.coafile, "-f", re.escape(filename), "-b",
"SpaceConsistencyTestBear", "-S", "tag=test_tag")
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", "default", "-c",
self.coafile, "-f", re.escape(filename), "-b",
"SpaceConsistencyTestBear", "-S", "dtag=test_tag")
self.assertFalse(os.path.exists(tag_path))
def get_exitcode(exception, log_printer=None):
log_printer = log_printer or LogPrinter(NullPrinter())
if isinstance(exception, KeyboardInterrupt): # Ctrl+C
print("Program terminated by user.")
exitcode = 130
elif isinstance(exception, EOFError): # Ctrl+D
print("Found EOF. Exiting gracefully.")
exitcode = 0
elif isinstance(exception, SystemExit):
exitcode = exception.code
elif isinstance(exception, BaseException):
log_printer.log_exception(Constants.CRASH_MESSAGE, exception)
exitcode = 255
else:
exitcode = 0
return exitcode
def test_print_results_missing_file(self):
self.log_printer = LogPrinter(NullPrinter())
with retrieve_stdout() as stdout:
print_results(
self.log_printer,
Section(""),
[Result("t", "msg"),
Result.from_values("t", "msg", file="file", line=5)],
{},
{},
color=False)
self.assertEqual("\n" + STR_PROJECT_WIDE + "\n"
"| | [NORMAL] t:\n"
"| | msg\n"
# Second results file isn't there, no context is
# printed, only a warning log message which we
# don't catch
"| | [NORMAL] t:\n"
"| | msg\n", stdout.getvalue())
def filter_relevant_bears(used_languages, arg_parser=None):
"""
From the bear dict, filter the bears per relevant language.
:param used_languages:
A list of tuples with language name as the first element
and percentage usage as the second element; sorted by
percentage usage.
:return:
A dict with language name as key and bear classes as value.
"""
log_printer = LogPrinter(NullPrinter())
used_languages.append(("All", 100))
all_bears_by_lang = {
lang: set(
inverse_dicts(
*get_filtered_bears([lang], log_printer, arg_parser)).keys())
for lang, _ in used_languages
}
bears_by_lang = {}
for lang in all_bears_by_lang:
if lang in IMPORTANT_BEAR_LIST:
bears_by_lang[lang] = {
bear
for bear in all_bears_by_lang[lang]
if bear.name in IMPORTANT_BEAR_LIST[lang]
}
else:
bears_by_lang[lang] = all_bears_by_lang[lang]
# Each language would also have the language independent bears. We remove
# those and put them in the "All" category.
lang_bears = {
lang: bears_by_lang[lang] - bears_by_lang["All"]
for lang, _ in used_languages
}
lang_bears["All"] = bears_by_lang["All"]
return lang_bears
def get_exitcode(exception, log_printer=None):
log_printer = (LogPrinter(NullPrinter())
if log_printer is None else log_printer)
if isinstance(exception, KeyboardInterrupt): # Ctrl+C
print('Program terminated by user.')
exitcode = 130
elif isinstance(exception, EOFError): # Ctrl+D
print('Found EOF. Exiting gracefully.')
exitcode = 0
elif isinstance(exception, SystemExit):
exitcode = exception.code
elif isinstance(exception, VersionConflict):
log_message = Constants.VERSION_CONFLICT_MESSAGE % str(exception.req)
log_printer.log_exception(log_message, exception)
exitcode = 13
elif isinstance(exception, BaseException):
log_printer.log_exception(Constants.CRASH_MESSAGE, exception)
exitcode = 255
else:
exitcode = 0
return exitcode
def filter_relevant_bears(used_languages, printer, arg_parser, extracted_info):
"""
From the bear dict, filter the bears per relevant language.
:param used_languages:
A list of tuples with language name as the first element
and percentage usage as the second element; sorted by
percentage usage.
:param printer:
``ConsolePrinter`` object to be used for console interactions.
:param arg_parser:
``argparse.ArgumentParser`` object containing the arguments
passed.
:param extracted_info:
list of information extracted from ``InfoExtractor`` classes.
:return:
A dict with language name as key and bear classes as value.
"""
args = arg_parser.parse_args() if arg_parser else None
log_printer = LogPrinter(NullPrinter())
used_languages.append(("All", 100))
bears_by_lang = {
lang: set(
inverse_dicts(*get_filtered_bears(
[lang], log_printer, arg_parser, silent=True)).keys())
for lang, _ in used_languages
}
# Each language would also have the language independent bears. We remove
# those and put them in the "All" category.
all_lang_bears = bears_by_lang["All"]
bears_by_lang = {
lang: bears_by_lang[lang] - bears_by_lang["All"]
for lang, _ in used_languages
}
bears_by_lang["All"] = all_lang_bears
selected_bears = {}
candidate_bears = copy.copy(bears_by_lang)
to_propose_bears = {}
# Initialize selected_bears with IMPORTANT_BEAR_LIST
for lang, lang_bears in candidate_bears.items():
if lang_bears and lang in IMPORTANT_BEAR_LIST:
selected_bears[lang] = set()
for bear in lang_bears:
if bear.__name__ in IMPORTANT_BEAR_LIST[lang]:
selected_bears[lang].add(bear)
if lang_bears and lang not in IMPORTANT_BEAR_LIST:
selected_bears[lang] = set(lang_bears)
candidate_bears[lang] = set([
bear for bear in lang_bears
if lang in selected_bears and bear not in selected_bears[lang]
])
if not args.no_filter_by_capabilities:
# Ask user for capablities
user_selected_capabilities = set()
if not args.non_interactive:
user_selected_capabilities = ask_to_select_capabilties(
list(ALL_CAPABILITIES), list(DEFAULT_CAPABILTIES), printer)
desired_capabilities = (user_selected_capabilities
if user_selected_capabilities else
DEFAULT_CAPABILTIES)
# Filter bears based on capabilties
for lang, lang_bears in candidate_bears.items():
# Eliminate bears which doesn't contain the desired capabilites
capable_bears = get_bears_with_given_capabilities(
lang_bears, desired_capabilities)
candidate_bears[lang] = capable_bears
lint_task_info = extracted_info.get("LintTaskInfo", [])
project_dependency_info = extracted_info.get("ProjectDependencyInfo", [])
# Use lint_task_info to propose bears to user.
for lang, lang_bears in candidate_bears.items():
matching_linter_bears = get_matching_linter_bears(
lang_bears, lint_task_info)
to_propose_bears[lang] = matching_linter_bears
# Use project_dependency_info to propose bears to user.
for lang, lang_bears in candidate_bears.items():
matching_dep_bears = get_bears_with_matching_dependencies(
lang_bears, project_dependency_info)
if to_propose_bears.get(lang):
to_propose_bears[lang].update(matching_dep_bears)
else:
to_propose_bears[lang] = matching_dep_bears
for lang, lang_bears in to_propose_bears.items():
for bear in lang_bears:
# get the non-optional settings of the bears
settings = bear.get_non_optional_settings()
if settings:
user_input_reqd = False
for setting in settings:
if not is_autofill_possible(setting, lang, bear,
extracted_info):
user_input_reqd = True
break
if user_input_reqd:
# Ask user to activate the bear
if (args and not args.non_interactive
and prompt_to_activate(bear, printer)):
selected_bears[lang].add(bear)
else:
# All the non-optional settings can be filled automatically
selected_bears[lang].add(bear)
else:
# no non-optional setting, select it right away!
selected_bears[lang].add(bear)
if not args.no_filter_by_capabilities:
# capabilities satisfied till now
satisfied_capabilities = get_bears_capabilties(selected_bears)
remaining_capabilities = {
lang: [
cap for cap in desired_capabilities
if lang in satisfied_capabilities
and cap not in satisfied_capabilities[lang]
]
for lang in candidate_bears
}
filtered_bears = {}
for lang, lang_bears in candidate_bears.items():
filtered_bears[lang] = get_bears_with_given_capabilities(
lang_bears, remaining_capabilities[lang])
# Remove overlapping capabilty bears
filtered_bears = remove_bears_with_conflicting_capabilties(
filtered_bears)
# Add to the selectecd_bears
for lang, lang_bears in filtered_bears.items():
if not selected_bears.get(lang):
selected_bears[lang] = lang_bears
else:
selected_bears[lang].update(lang_bears)
return selected_bears
def test_non_printing(self):
self.uut = NullPrinter()
self.assertEqual(self.uut.print("anything"), None)
self.assertEqual(self.uut.print("anything", color="red"), None)
def setUp(self):
log_printer = LogPrinter(NullPrinter())
self.cache = ProxyMapFileCache(log_printer,
'coala_test',
flush_cache=True)
def setUp(self):
self.old_argv = sys.argv
self.log_printer = LogPrinter(NullPrinter())
def setUp(self):
self.log_printer = LogPrinter(NullPrinter())
# Needed so coala doesn't error out
self.min_args = ['-f', '*.java', '-b', 'JavaTestBear']
def setUp(self):
self.log_printer = LogPrinter(NullPrinter())
def get_all_bears(bear_dirs):
local_bears, global_bears = collect_bears(
bear_dirs, ['**'], [BEAR_KIND.LOCAL, BEAR_KIND.GLOBAL],
NullPrinter(),
warn_if_unused_glob=False)
return list(itertools.chain(local_bears, global_bears))
continue
if requirement.version:
marker = '==' if requirement.package in PINNED_PACKAGES else '~='
output.write('{0}{1}{2}\n'.format(requirement.package, marker,
requirement.version))
else:
output.write(requirement.package + '\n')
if __name__ == '__main__':
args = get_args()
bear_dirs = [PROJECT_BEAR_DIR]
printer = NullPrinter()
log_printer = LogPrinter(printer)
if args.bear_dirs is not None:
bear_dirs.extend(args.bear_dirs)
pip_reqs, npm_reqs, gem_reqs = (get_all_requirements(
get_all_bears(bear_dirs, log_printer)))
write_gem_requirements(gem_reqs)
write_npm_requirements(npm_reqs)
output = None
if args.output == '-':
class NullPrinterTest(unittest.TestCase):
def test_non_printing(self):
self.uut = NullPrinter()
self.assertEqual(self.uut.print("anything"), None)
self.assertEqual(self.uut.print("anything", color="red"), None)
def test_raises(self):
uut = LogPrinter(NullPrinter())
self.assertRaises(TypeError, uut.log, 5)
self.assertRaises(TypeError, uut.log_exception, "message", 5)
self.assertRaises(TypeError, uut.log_message, 5)
