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)