add testing support with pytest, improve CLI error handling and language formatters

Author: rongxin-liu

.github/workflows/main.yml

@@ -10,8 +10,8 @@ jobs:
 
       - name: Run tests
         run: |
-          pip install .
-          style50 --help
+          pip install '.[test]'
+          python -m pytest
 
       - name: Install pypa/build
         run: python -m pip install build --user

setup.py

@@ -30,6 +30,11 @@
         "termcolor",
         "jinja2>=2.10",
     ],
+    extras_require={
+        "test": [
+            "pytest",
+        ],
+    },
     dependency_links=["git+https://github.com/jeffkaufman/icdiff.git"],
     keywords=["style", "style50"],
     name="style50",

style50/__main__.py

@@ -33,7 +33,7 @@ def main():
     parser.add_argument("file", metavar="FILE", nargs="+", help="file or directory to lint")
     parser.add_argument("-o", "--output", action="store", default="character",
                         choices=["character", "split", "unified", "score", "json", "html", "format"], metavar="MODE",
-                        help="output mode, which can be character (default), split, unified, score, or json")
+                        help="output mode, which can be character (default), split, unified, score, json, html, or format")
     parser.add_argument("-v", "--verbose", action="store_true",
                         help="print full tracebacks of errors")
     parser.add_argument("-V", "--version", action="version",

style50/_api.py

@@ -170,15 +170,7 @@ def _check(self, file):
         except IndexError:
             pass
 
-        # Optional per-run configuration hook (e.g., clang-format style override)
-        if hasattr(check, "configure"):
-            try:
-                check.configure(clang_format_style=self.clang_format_style)
-            except TypeError:
-                # Backward compatible if configure() signature differs
-                check.configure()
-
-        return check(code)
+        return check(code, clang_format_style=self.clang_format_style)
 
     @staticmethod
     def split_diff(old, new):
@@ -311,7 +303,8 @@ class StyleCheck(metaclass=StyleMeta):
     # Contains substrings to be matched against libmagic's output if file extension not recognized
     magic_names = []
 
-    def __init__(self, code):
+    def __init__(self, code, **kwargs):
+        self._config = kwargs
         self.original = code
 
         comments = self.count_comments(code)

style50/languages.py

@@ -20,42 +20,28 @@ class C(StyleCheck):
         "clang-format", f"-style={styleConfig}"
     ]
 
-    _clang_format_style_override = None
-
-    @classmethod
-    def configure(cls, clang_format_style=None):
-        if clang_format_style is None:
-            cls._clang_format_style_override = None
-            return
-
-        # Guard against VS Code extension accidentally passing stringified undefined/null.
-        if isinstance(clang_format_style, str):
-            normalized = clang_format_style.strip().strip('"').strip("'").strip()
-            if normalized.lower() in {"", "undefined", "null", "none"}:
-                cls._clang_format_style_override = None
-                return
-
-        cls._clang_format_style_override = clang_format_style
-
     # Match (1) /**/ comments, and (2) // comments.
     match_comments = re.compile(r"(\/\*.*?\*\/)|(\/\/[^\n]*)", re.DOTALL)
 
     # Matches string literals.
     match_literals = re.compile(r'"(?:\\.|[^"\\])*"', re.DOTALL)
 
-    def __init__(self, code):
-
-        # Call parent init.
-        StyleCheck.__init__(self, code)
-
     def count_comments(self, code):
         # Remove all string literals.
         stripped = self.match_literals.sub("", code)
         return sum(1 for _ in self.match_comments.finditer(stripped))
 
     def style(self, code):
-        if self._clang_format_style_override:
-            return self.run(["clang-format", f"-style={self._clang_format_style_override}"], input=code)
+        clang_format_style = self._config.get("clang_format_style")
+        if isinstance(clang_format_style, str):
+            normalized = clang_format_style.strip().strip('"').strip("'").strip()
+            if normalized.lower() in {"", "undefined", "null", "none"}:
+                clang_format_style = None
+
+        if clang_format_style:
+            cmd = [c for c in self.clangFormat if not str(c).startswith("-style=")]
+            cmd.append(f"-style={clang_format_style}")
+            return self.run(cmd, input=code)
         return self.run(self.clangFormat, input=code)
 
 
@@ -104,9 +90,6 @@ class Js(C):
          ((?<![\*\/])\/(?![\/\*]).*?(?<![\\])\/) # JS regexes, trying hard not to be tripped up by comments
          """, re.VERBOSE)
 
-    # C.__init__ checks for clang-format but we don't need this for Js
-    __init__ = StyleCheck.__init__
-
     # TODO: Determine which options, if any should be passed here
     def style(self, code):
         opts = jsbeautifier.default_options()

tests/test_cli.py

@@ -0,0 +1,48 @@
+import subprocess
+import sys
+
+
+def run_style50(args, *, cwd=None):
+    return subprocess.run(
+        [sys.executable, "-m", "style50", *args],
+        cwd=cwd,
+        check=False,
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+
+
+def test_format_mode_requires_one_file(tmp_path):
+    f1 = tmp_path / "a.py"
+    f2 = tmp_path / "b.py"
+    f1.write_text("x=1\n", encoding="utf-8")
+    f2.write_text("y=2\n", encoding="utf-8")
+
+    proc = run_style50(["-o", "format", str(f1), str(f2)])
+    assert proc.returncode != 0
+    assert "format mode requires exactly one file" in (proc.stderr + proc.stdout)
+
+
+def test_format_mode_outputs_formatted_code(tmp_path):
+    f = tmp_path / "t.py"
+    f.write_text("x=1\nprint(  x)\n", encoding="utf-8")
+
+    proc = run_style50(["-o", "format", str(f)])
+    assert proc.returncode == 0
+    assert "print(" in proc.stdout
+    assert proc.stdout.endswith("\n")
+
+
+def test_clang_format_style_arg_is_accepted_in_format_mode(tmp_path):
+    """
+    The flag should be accepted even for non-clang languages (it will be unused).
+    This ensures the CLI contract used by the VS Code extension is stable.
+    """
+    f = tmp_path / "t.py"
+    f.write_text("x=1\n", encoding="utf-8")
+
+    proc = run_style50(["-o", "format", "--clang-format-style", "{IndentWidth: 2}", str(f)])
+    assert proc.returncode == 0
+    assert proc.stdout.strip() != ""
+

tests/test_languages.py

@@ -0,0 +1,95 @@
+import pytest
+
+
+def test_python_formatter_runs():
+    from style50.languages import Python
+
+    original = "x=1\n\nprint(  x)\n"
+    formatted = Python(original).styled
+    assert isinstance(formatted, str)
+    assert formatted.endswith("\n")
+
+
+def test_js_formatter_runs():
+    from style50.languages import Js
+
+    original = "function f(){return 1;}\n"
+    formatted = Js(original).styled
+    assert isinstance(formatted, str)
+    assert formatted.endswith("\n")
+
+
+def test_css_formatter_runs():
+    from style50.languages import Css
+
+    original = "body{color:red;}\n"
+    formatted = Css(original).styled
+    assert isinstance(formatted, str)
+    assert formatted.endswith("\n")
+
+
+def test_sql_formatter_runs():
+    from style50.languages import Sql
+
+    original = "select * from foo;\n"
+    formatted = Sql(original).styled
+    assert isinstance(formatted, str)
+    assert "FROM" in formatted
+
+
+def test_html_formatter_invokes_djhtml(monkeypatch):
+    from style50.languages import Html
+    from style50._api import StyleCheck
+
+    calls = {"cmd": None}
+
+    def fake_run(command, input=None, exit=0, shell=False):
+        calls["cmd"] = command
+        # Pretend the formatter normalizes whitespace, but keep it simple.
+        return "<!doctype html>\n"
+
+    monkeypatch.setattr(StyleCheck, "run", staticmethod(fake_run))
+    formatted = Html("<html></html>\n").styled
+    assert calls["cmd"] == ["djhtml", "-"]
+    assert formatted == "<!doctype html>\n"
+
+
+def test_clang_format_style_override_preserves_java_flags(monkeypatch):
+    """
+    Ensure override style does not drop Java's '-assume-filename=.java' flag.
+    This is tested by capturing the command rather than invoking clang-format.
+    """
+    from style50.languages import Java
+    from style50._api import StyleCheck
+
+    seen = {"cmd": None}
+
+    def fake_run(command, input=None, exit=0, shell=False):
+        seen["cmd"] = command
+        return input.decode() if isinstance(input, (bytes, bytearray)) else (input or "")
+
+    monkeypatch.setattr(StyleCheck, "run", staticmethod(fake_run))
+    _ = Java("class X{}\n", clang_format_style="{IndentWidth: 2}").styled
+
+    assert isinstance(seen["cmd"], list)
+    assert "clang-format" in seen["cmd"][0]
+    assert any(arg.startswith("-style=") for arg in seen["cmd"])
+    assert "-assume-filename=.java" in seen["cmd"]
+
+
+@pytest.mark.parametrize("value", ["undefined", "null", "none", "  'undefined'  "])
+def test_clang_format_style_override_ignores_stringified_nulls(monkeypatch, value):
+    from style50.languages import C
+    from style50._api import StyleCheck
+
+    seen = {"cmd": None}
+
+    def fake_run(command, input=None, exit=0, shell=False):
+        seen["cmd"] = command
+        return input.decode() if isinstance(input, (bytes, bytearray)) else (input or "")
+
+    monkeypatch.setattr(StyleCheck, "run", staticmethod(fake_run))
+    _ = C("int main(){}\n", clang_format_style=value).styled
+
+    assert seen["cmd"] == C.clangFormat
+