Support hooks that work on non-python files.

Author: domdfcoding

formate/__init__.py

@@ -44,7 +44,7 @@
 
 # this package
 from formate.classes import FormateConfigDict, Hook
-from formate.config import parse_hooks, wants_filename, wants_global_config
+from formate.config import get_hooks_for_filetype, parse_hooks, wants_filename, wants_global_config
 from formate.utils import _find_from_parents, syntaxerror_for_file
 
 __author__: str = "Dominic Davis-Foster"
@@ -279,6 +279,7 @@ def run(self) -> bool:
 		"""
 
 		hooks = parse_hooks(self.config)
+		hooks = get_hooks_for_filetype(self.file_to_format.suffix, hooks)
 		reformatted_source = StringList(call_hooks(hooks, self._unformatted_source, self.filename))
 		reformatted_source.blankline(ensure_single=True)
 

formate/__main__.py

@@ -38,6 +38,9 @@
 from consolekit.tracebacks import handle_tracebacks, traceback_option
 from domdf_python_tools.typing import PathLike
 
+# this package
+from formate.config import NoSupportedHooksError
+
 __all__ = ("main", "version_callback")
 
 
@@ -129,17 +132,29 @@ def main(
 
 		path = PathPlus(path)
 
-		if path.suffix not in {".py", ".pyi", ''} or path.is_dir():  # pylint: disable=loop-invariant-statement
+		if path.is_dir():  # pylint: disable=loop-invariant-statement
+			if verbose >= 2:
+				click.echo(f"Skipping directory {path}")
+
+			continue
+
+		if not path.exists():  # pylint: disable=loop-invariant-statement
 			if verbose >= 2:
-				click.echo(f"Skipping {path} as it doesn't appear to be a Python file")
+				click.echo(f"Skipping {path} as it doesn't exist")
 
 			continue
 
 		r = Reformatter(path, config=config)
 
 		with handle_tracebacks(show_traceback, cls=SyntaxTracebackHandler):
 			with syntaxerror_for_file(path):
-				ret_for_file = r.run()
+				try:
+					ret_for_file = r.run()
+				except NoSupportedHooksError:
+					if verbose >= 2:
+						click.echo(f"Skipping {path} as no hooks support this filetype.")
+
+					continue
 
 		if ret_for_file:
 			if verbose:

formate/classes.py

@@ -27,7 +27,7 @@
 #
 
 # stdlib
-from typing import Any, Callable, Dict, Iterator, List, Mapping, Optional, Sequence, Union
+from typing import Any, Callable, Dict, Iterator, List, Mapping, Optional, Sequence, Set, Union
 
 # 3rd party
 import attrs
@@ -110,6 +110,14 @@ class Hook:
 	#: A read-only view on the global configuration mapping, for hooks to do with as they wish.
 	global_config: Mapping[str, Any] = attrs.field(factory=dict)
 
+	@property
+	def supported_filetypes(self) -> Set[str]:
+		"""
+		The extensions of filetypes supported by this hook.
+		"""
+
+		return getattr(self.entry_point.obj, "supported_filetypes", {".py", ".pyi"})  # type: ignore[union-attr]
+
 	@classmethod
 	def parse(cls, data: HooksMapping) -> Iterator["Hook"]:
 		r"""

formate/config.py

@@ -39,11 +39,50 @@
 from formate.classes import FormateConfigDict, Hook
 from formate.utils import import_entry_points
 
-__all__ = ("parse_hooks", "parse_global_config", "load_toml", "wants_global_config", "wants_filename", "_C_str")
+__all__ = (
+		"parse_hooks",
+		"parse_global_config",
+		"load_toml",
+		"wants_global_config",
+		"wants_filename",
+		"_C_str",
+		"HookConfigError",
+		"NoHooksError",
+		"NoSupportedHooksError",
+		"formats_filetypes",
+		"get_hooks_for_filetype",
+		)
 
 _C_str = TypeVar("_C_str", bound=Callable[..., str])
 
 
+class HookConfigError(ValueError):
+	"""
+	Base exception for errors with hook configuration.
+	"""
+
+
+class NoHooksError(HookConfigError):
+	"""
+	Exception for when no hooks are configured.
+	"""
+
+	def __init__(self):
+		super().__init__("No hooks configured")
+
+
+class NoSupportedHooksError(HookConfigError):
+	"""
+	Exception for when no hooks support the given file type.
+
+	:param filetype:
+	"""
+
+	def __init__(self, filetype: str):
+		super().__init__(f"No supported hooks for this file type ({filetype})")
+		self.filetype = filetype
+
+
 def parse_hooks(config: Mapping) -> List[Hook]:
 	"""
 	Given a mapping parsed from a TOML file (or similar), return a list of hooks selected by the user.
@@ -68,6 +107,28 @@ def parse_hooks(config: Mapping) -> List[Hook]:
 	return hooks
 
 
+def get_hooks_for_filetype(filetype: str, hooks: List[Hook]) -> List[Hook]:
+	"""
+	Filters the hooks to those that support the given filetype.
+
+	:param filetype:
+	:param hooks:
+	"""
+
+	if not hooks:
+		raise NoHooksError()
+
+	supported_hooks: List[Hook] = []
+	for hook in hooks:
+		if filetype in hook.supported_filetypes:
+			supported_hooks.append(hook)
+
+	if not supported_hooks:
+		raise NoSupportedHooksError(filetype=filetype)
+
+	return supported_hooks
+
+
 def parse_global_config(config: Mapping) -> MappingProxyType:
 	"""
 	Returns a read-only view on the global configuration mapping, for hooks to do with as they wish.
@@ -127,3 +188,19 @@ def wants_filename(func: _C_str) -> _C_str:
 
 	func.wants_filename = True  # type: ignore[attr-defined]
 	return func
+
+
+def formats_filetypes(*filetypes) -> Callable[[_C_str], _C_str]:
+	r"""
+	Decorator to indicate to ``formate`` that the hook formats the specified filetypes (as extensions, e.g. ``".js"``.
+
+	.. versionadded:: 1.2.0
+
+	:param \*filetypes:
+	"""
+
+	def deco(func: _C_str) -> _C_str:
+		func.supported_filetypes = set(filetypes)  # type: ignore[attr-defined]
+		return func
+
+	return deco

formate/mini_hooks.py

@@ -39,7 +39,7 @@
 from domdf_python_tools.typing import PathLike
 
 # this package
-from formate.config import wants_filename
+from formate.config import formats_filetypes, wants_filename
 
 __all__ = ("check_ast", "newline_after_equals", "noqa_reformat", "squish_stubs")
 
@@ -71,6 +71,7 @@ def check_ast(source: str) -> str:
 	return source
 
 
+@formats_filetypes(".pyi")
 @wants_filename
 def squish_stubs(source: str, formate_filename: PathLike) -> str:
 	"""
@@ -87,7 +88,7 @@ def squish_stubs(source: str, formate_filename: PathLike) -> str:
 	filename = PathPlus(formate_filename)
 
 	if filename.suffix != ".pyi":
-		return source
+		raise ValueError(f"Unsupported filetype {filename.suffix!r}")
 
 	blocks = _breakup_source(source)
 	return str(_reformat_blocks(blocks))

tests/test_integration.py

@@ -1,6 +1,6 @@
 # stdlib
 import re
-from typing import Union, no_type_check
+from typing import List, Mapping, Union, no_type_check
 
 # 3rd party
 import pytest
@@ -10,11 +10,14 @@
 from consolekit.terminal_colours import strip_ansi
 from consolekit.testing import CliRunner, Result, click_version
 from domdf_python_tools.paths import PathPlus, in_directory
+from domdf_python_tools.typing import PathLike
 
 # this package
+import formate
 from formate import Reformatter, reformat_file
 from formate.__main__ import main
-from formate.config import load_toml
+from formate.classes import EntryPoint, Hook
+from formate.config import formats_filetypes, load_toml, wants_filename
 
 path_sub = re.compile(r" .*/pytest-of-.*/pytest-\d+")
 
@@ -169,6 +172,32 @@ def test_reformatter_class(
 	advanced_file_regression.check_file(tmp_pathplus / "code.py")
 
 
+@pytest.mark.usefixtures("demo_environment")
+def test_reformatter_class_non_python_hook(
+		tmp_pathplus: PathPlus,
+		monkeypatch,
+		):
+
+	config = load_toml(tmp_pathplus / "formate.toml")
+	config["hooks"]["format-foo"] = {"priority": 10}  # type: ignore[index]
+
+	(tmp_pathplus / "code.foo").touch()
+
+	@formats_filetypes(".foo")
+	@wants_filename
+	def format_foo(source: str, formate_filename: PathLike) -> str:
+		return "Result of format-foo"
+
+	def parse_hooks(config: Mapping) -> List[Hook]:
+		return [Hook(name="format-foo", entry_point=EntryPoint("format-foo", format_foo))]
+
+	monkeypatch.setattr(formate, "parse_hooks", parse_hooks)
+	r = Reformatter(tmp_pathplus / "code.foo", config)
+
+	assert r.run()
+	assert r.to_string() == "Result of format-foo\n"
+
+
 @pytest.mark.usefixtures("demo_environment")
 def test_cli(
 		tmp_pathplus: PathPlus,
@@ -243,6 +272,41 @@ def test_cli_verbose_verbose(
 	check_out(result, advanced_data_regression)
 
 
+@pytest.mark.usefixtures("demo_environment")
+def test_cli_verbose_verbose_no_supported_hooks(
+		tmp_pathplus: PathPlus,
+		advanced_file_regression: AdvancedFileRegressionFixture,
+		advanced_data_regression: AdvancedDataRegressionFixture,
+		):
+
+	result: Result
+	(tmp_pathplus / "code.c").touch()
+	(tmp_pathplus / "a_dir").mkdir()
+
+	with in_directory(tmp_pathplus):
+		runner = CliRunner(mix_stderr=False)
+		result = runner.invoke(
+				main,
+				args=["code.py", "a_dir", "--no-colour", "--diff", "--verbose", "-v"],
+				)
+
+	assert result.exit_code == 1
+
+	advanced_file_regression.check_file(tmp_pathplus / "code.py")
+
+	# Calling a second time shouldn't change anything
+	with in_directory(tmp_pathplus):
+		runner = CliRunner(mix_stderr=False)
+		result = runner.invoke(
+				main,
+				args=["code.py", "code.c", "--no-colour", "--diff", "--verbose", "-v"],
+				)
+
+	assert result.exit_code == 0
+
+	check_out(result, advanced_data_regression)
+
+
 @pytest.mark.usefixtures("demo_environment")
 @max_version("3.9.9", reason="Output differs on Python 3.10+")
 @not_pypy("Output differs on PyPy")

tests/test_integration_/test_cli_verbose_verbose.yml

@@ -2,5 +2,5 @@ err:
 - ''
 out:
 - Checking code.py
-- Skipping code.c as it doesn't appear to be a Python file
+- Skipping code.c as it doesn't exist
 - ''

tests/test_integration_/test_cli_verbose_verbose_no_supported_hooks._py_

@@ -0,0 +1,11 @@
+class F:
+	# stdlib
+	from collections import Counter
+	from collections.abc import Iterable
+
+	def foo(self):
+		pass
+
+
+print("hello world")
+assert t.uname == "\udce4\udcf6\udcfc"

tests/test_integration_/test_cli_verbose_verbose_no_supported_hooks.yml

@@ -0,0 +1,6 @@
+err:
+- ''
+out:
+- Checking code.py
+- Skipping code.c as no hooks support this filetype.
+- ''

tests/test_mini_hooks.py

@@ -252,8 +252,8 @@ def foo():
 	new_code = squish_stubs(code, formate_filename="code.pyi")
 	assert new_code != code
 
-	new_code = squish_stubs(code, formate_filename="code.py")
-	assert new_code == code
+	with pytest.raises(ValueError, match=r"Unsupported filetype '\.py'"):
+		squish_stubs(code, formate_filename="code.py")
 
 
 newline_after_equals_src = """