def check_pre_commit_hook( term: Terminal, pre_commit_hook: PreCommitHook ) -> None: if pre_commit_hook.exists(): if pre_commit_hook.is_autohooks_pre_commit_hook(): term.ok('autohooks pre-commit hook is active.') if pre_commit_hook.is_current_autohooks_pre_commit_hook(): term.ok('autohooks pre-commit hook is up-to-date.') else: term.warning( 'autohooks pre-commit hook is outdated. Please run ' '\'autohooks activate --force\' to update your pre-commit ' 'hook.' ) hook_mode = pre_commit_hook.read_mode() if hook_mode == Mode.UNKNOWN: term.warning( f'Unknown autohooks mode in {str(pre_commit_hook)}. ' f'Falling back to "{str(hook_mode.get_effective_mode())}" ' 'mode.' ) else: term.error( 'autohooks pre-commit hook is not active. But a different ' f'pre-commit hook has been found at {str(pre_commit_hook)}.' ) else: term.error( 'autohooks pre-commit hook not active. Please run \'autohooks ' 'activate\'.' )
def install_hooks(term: Terminal, args: Namespace) -> None: pre_commit_hook = PreCommitHook() pyproject_toml = get_pyproject_toml_path() config = load_config_from_pyproject_toml(pyproject_toml) if pre_commit_hook.exists() and not args.force: term.ok('autohooks pre-commit hook is already installed at {}.'.format( str(pre_commit_hook))) with term.indent(): term.print() term.info( "Run 'autohooks activate --force' to override the current " "installed pre-commit hook.") term.info( "Run 'autohooks check' to validate the current status of " "the installed pre-commit hook.") else: if not config.is_autohooks_enabled(): term.warning('autohooks is not enabled in your {} file. ' 'Run \'autohooks check\' for more ' 'details.'.format(str(pyproject_toml))) if args.mode: mode = Mode.from_string(args.mode) else: mode = config.get_mode() pre_commit_hook.write(mode=mode) term.ok( 'autohooks pre-commit hook installed at {} using {} mode.'.format( str(pre_commit_hook), str(mode.get_effective_mode())))
def install_git_hook(self) -> None: try: pre_commit_hook = PreCommitHook() if not pre_commit_hook.exists(): config = load_config_from_pyproject_toml() pre_commit_hook.write(mode=config.get_mode()) except Exception: # pylint: disable=broad-except pass
def run() -> int: term = Terminal() _set_terminal(term) config = load_config_from_pyproject_toml() pre_commit_hook = PreCommitHook() check_hook_is_current(term, pre_commit_hook) if config.has_autohooks_config(): check_hook_mode(term, config.get_mode(), pre_commit_hook.read_mode()) plugins = get_project_autohooks_plugins_path() plugins_dir_name = str(plugins) if plugins.is_dir(): sys.path.append(plugins_dir_name) term.bold_info('autohooks => pre-commit') with autohooks_module_path(), term.indent(): for name in config.get_pre_commit_script_names(): term.info('Running {}'.format(name)) with term.indent(): try: plugin = load_plugin(name) if not has_precommit_function(plugin): term.fail( 'No precommit function found in plugin {}. ' 'Your autohooks settings may be invalid.'.format( name)) return 1 if has_precommit_parameters(plugin): retval = plugin.precommit(config=config.get_config()) else: term.warning( 'precommit function without kwargs is deprecated. ' 'Please update {} to a newer version.'.format( name)) retval = plugin.precommit() if retval: return retval except ImportError as e: term.error('An error occurred while importing pre-commit ' 'hook {}. {}.'.format(name, e)) return 1 except Exception as e: # pylint: disable=broad-except term.error('An error occurred while running pre-commit ' 'hook {}. {}.'.format(name, e)) return 1 return 0
def check_hooks(term: Terminal) -> None: pre_commit_hook = PreCommitHook() hook_mode = pre_commit_hook.read_mode() check_pre_commit_hook(term, pre_commit_hook, hook_mode) pyproject_toml = get_pyproject_toml_path() check_config(term, pyproject_toml, pre_commit_hook, hook_mode)
def test_modified_pre_commit_template(self): template = PreCommitTemplate() rendered = template.render(mode=Mode.PIPENV) lines = rendered.split('\n') lines[1] = "" path = FakeReadPath("\n".join(lines)) pre_commit_hook = PreCommitHook(path) self.assertFalse( pre_commit_hook.is_current_autohooks_pre_commit_hook())
def test_poetry_mode(self): write_path = Mock() pre_commit_hook = PreCommitHook(write_path) pre_commit_hook.write(mode=Mode.POETRY) write_path.chmod.assert_called_with(0o775) self.assertTrue(write_path.write_text.called) args, _kwargs = write_path.write_text.call_args text = args[0] self.assertRegex(text, f'^#!{POETRY_SHEBANG} *')
def test_pythonpath_mode(self): write_path = Mock() pre_commit_hook = PreCommitHook(write_path) pre_commit_hook.write(mode=Mode.PYTHONPATH) write_path.chmod.assert_called_with(0o775) self.assertTrue(write_path.write_text.called) args, _kwargs = write_path.write_text.call_args text = args[0] self.assertRegex(text, '^#!{} *'.format(PYTHON3_SHEBANG))
def test_read_version(self): template = PreCommitTemplate() with tempfile.TemporaryDirectory() as tempdir: tmp_hook_path = Path(tempdir) / 'pre-commit-test' # Find version using all shebang modes for mode in [m for m in Mode if m.value > 0]: with open(str(tmp_hook_path), 'w', encoding='utf-8') as tmpfile: tmpfile.write(template.render(mode=mode)) pre_commit_hook = PreCommitHook(tmp_hook_path) self.assertEqual(TEMPLATE_VERSION, pre_commit_hook.read_version())
def check_hooks(term: Terminal) -> None: pre_commit_hook = PreCommitHook() check_pre_commit_hook(term, pre_commit_hook) pyproject_toml = get_pyproject_toml_path() check_config(term, pyproject_toml, pre_commit_hook)
def check_hook_is_current(term: Terminal, pre_commit_hook: PreCommitHook) -> None: if not pre_commit_hook.is_current_autohooks_pre_commit_hook(): term.warning( 'autohooks pre-commit hook is outdated. Please run ' '\'autohooks activate --force\' to update your pre-commit ' 'hook.')
def test_str_conversion(self): path = Mock() path.__str__ = Mock(return_value="foo") pre_commit_hook = PreCommitHook(path) self.assertEqual(str(pre_commit_hook), 'foo') path.__str__.assert_called_with()
def test_install(self): pre_commit_hook = PreCommitHook() self.assertFalse(pre_commit_hook.exists()) pre_commit_hook.write(mode=Mode.PIPENV) self.assertTrue(pre_commit_hook.exists())
def test_empty_content(self): path = FakeReadPath("") pre_commit_hook = PreCommitHook(path) self.assertEqual(pre_commit_hook.read_version(), -1)
def test_other_hook(self): path = FakeReadPath('foo\nbar') pre_commit_hook = PreCommitHook(path) self.assertFalse( pre_commit_hook.is_current_autohooks_pre_commit_hook())
def test_pre_commit_template(self): template = PreCommitTemplate() path = FakeReadPath(template.render(mode=Mode.PIPENV)) pre_commit_hook = PreCommitHook(path) self.assertTrue(pre_commit_hook.is_autohooks_pre_commit_hook())
def test_pythonpath_mode(self): path = FakeReadPath("#!{}".format(PYTHON3_SHEBANG)) pre_commit_hook = PreCommitHook(path) self.assertEqual(pre_commit_hook.read_mode(), Mode.PYTHONPATH)
def test_poetry_multiline_mode(self): path = FakeReadPath(f"#!{POETRY_MULTILINE_SHEBANG}") pre_commit_hook = PreCommitHook(path) self.assertEqual(pre_commit_hook.read_mode(), Mode.POETRY_MULTILINE)
def test_pipenv_mode(self): path = FakeReadPath("#!{}".format(PIPENV_SHEBANG)) pre_commit_hook = PreCommitHook(path) self.assertEqual(pre_commit_hook.read_mode(), Mode.PIPENV)
def test_poetry_mode(self): path = FakeReadPath("#!{}".format(POETRY_SHEBANG)) pre_commit_hook = PreCommitHook(path) self.assertEqual(pre_commit_hook.read_mode(), Mode.POETRY)
def test_undefined_mode(self): path = FakeReadPath("") pre_commit_hook = PreCommitHook(path) self.assertEqual(pre_commit_hook.read_mode(), Mode.UNDEFINED)
def test_unknown_mode(self): path = FakeReadPath("#!foo") pre_commit_hook = PreCommitHook(path) self.assertEqual(pre_commit_hook.read_mode(), Mode.UNKNOWN)
def test_no_meta(self): path = FakeReadPath("\n# foo = bar") pre_commit_hook = PreCommitHook(path) self.assertEqual(pre_commit_hook.read_version(), -1)
def test_no_toml(self): path = FakeReadPath("\n# \n") pre_commit_hook = PreCommitHook(path) self.assertEqual(pre_commit_hook.read_version(), -1)
def check_config( term: Terminal, pyproject_toml: Path, pre_commit_hook: PreCommitHook, ) -> None: if not pyproject_toml.exists(): term.error( 'Missing {} file. Please add a pyproject.toml file and include ' 'a "{}" section.'.format(str(pyproject_toml), AUTOHOOKS_SECTION) ) else: config = load_config_from_pyproject_toml(pyproject_toml) if not config.is_autohooks_enabled(): term.error( 'autohooks is not enabled in your {} file. Please add ' 'a "{}" section.'.format(str(pyproject_toml), AUTOHOOKS_SECTION) ) elif pre_commit_hook.exists(): config_mode = config.get_mode() hook_mode = pre_commit_hook.read_mode() if config_mode == Mode.UNDEFINED: term.warning( 'autohooks mode is not defined in {}.'.format( str(pyproject_toml) ) ) elif config_mode == Mode.UNKNOWN: term.warning( 'Unknown autohooks mode in {}.'.format(str(pyproject_toml)) ) if ( config_mode.get_effective_mode() != hook_mode.get_effective_mode() ): term.warning( 'autohooks mode "{}" in pre-commit hook {} differs from ' 'mode "{}" in {}.'.format( str(hook_mode), str(pre_commit_hook), str(config_mode), str(pyproject_toml), ) ) term.info( 'Using autohooks mode "{}".'.format( str(hook_mode.get_effective_mode()) ) ) plugins = config.get_pre_commit_script_names() if not plugins: term.error( 'No autohooks plugin is activated in {} for your pre ' 'commit hook. Please add a ' '"pre-commit = [plugin1, plugin2]" ' 'setting.'.format(str(pyproject_toml)) ) else: with autohooks_module_path(): for name in plugins: try: plugin = load_plugin(name) if not has_precommit_function(plugin): term.error( 'Plugin "{}" has no precommit function. ' 'The function is required to run the ' 'plugin as git pre commit hook.'.format( name ) ) elif not has_precommit_parameters(plugin): term.warning( 'Plugin "{}" uses a deprecated signature ' 'for its precommit function. It is missing ' 'the **kwargs parameter.'.format(name) ) else: term.ok( 'Plugin "{}" active and loadable.'.format( name ) ) except ImportError as e: term.error( '"{}" is not a valid autohooks ' 'plugin. {}'.format(name, e) )
def test_read_version(self): path = FakeReadPath("\n# meta = {version=123}") pre_commit_hook = PreCommitHook(path) self.assertEqual(pre_commit_hook.read_version(), 123)
def check_config( term: Terminal, pyproject_toml: Path, pre_commit_hook: PreCommitHook, ) -> None: if not pyproject_toml.exists(): term.error( f'Missing {str(pyproject_toml)} file. Please add a pyproject.toml ' f'file and include a "{AUTOHOOKS_SECTION}" section.' ) else: config = load_config_from_pyproject_toml(pyproject_toml) if not config.is_autohooks_enabled(): term.error( f'autohooks is not enabled in your {str(pyproject_toml)} file.' f' Please add a "{AUTOHOOKS_SECTION}" section.' ) elif pre_commit_hook.exists(): config_mode = config.get_mode() hook_mode = pre_commit_hook.read_mode() if config_mode == Mode.UNDEFINED: term.warning( f'autohooks mode is not defined in {str(pyproject_toml)}.' ) elif config_mode == Mode.UNKNOWN: term.warning( f'Unknown autohooks mode in {str(pyproject_toml)}.' ) if ( config_mode.get_effective_mode() != hook_mode.get_effective_mode() ): term.warning( f'autohooks mode "{str(hook_mode)}" in pre-commit ' f'hook {str(pre_commit_hook)} differs from ' f'mode "{str(config_mode)}" in {str(pyproject_toml)}.' ) term.info( f'Using autohooks mode "{str(hook_mode.get_effective_mode())}".' ) plugins = config.get_pre_commit_script_names() if not plugins: term.error( 'No autohooks plugin is activated in ' f'{str(pyproject_toml)} for your pre commit hook. Please ' 'add a "pre-commit = [plugin1, plugin2]" setting.' ) else: with autohooks_module_path(): for name in plugins: try: plugin = load_plugin(name) if not has_precommit_function(plugin): term.error( f'Plugin "{name}" has no precommit ' 'function. The function is required to run' ' the plugin as git pre commit hook.' ) elif not has_precommit_parameters(plugin): term.warning( f'Plugin "{name}" uses a deprecated ' 'signature for its precommit function. It ' 'is missing the **kwargs parameter.' ) else: term.ok(f'Plugin "{name}" active and loadable.') except ImportError as e: term.error( f'"{name}" is not a valid autohooks ' f'plugin. {e}' )