add new dependencies for CSS and SQL formatting, and improve CLI with 'format' output mode

Author: rongxin-liu

setup.py

@@ -20,10 +20,13 @@
     install_requires=[
         "autopep8>=2.1.0",
         "clang-format>=18.1.2",
+        "cssbeautifier>=1.15.4",
+        "djhtml>=3.0",
         "icdiff",
         "jsbeautifier",
         "pycodestyle==2.12.0",
         "python-magic",
+        "sqlparse>=0.5.0",
         "termcolor",
         "jinja2>=2.10",
     ],
@@ -40,6 +43,6 @@
         ]
     },
     url="https://github.com/cs50/style50",
-    version="2.11.0",
+    version="3.0.0",
     include_package_data=True,
 )

style50/__main__.py

@@ -32,7 +32,7 @@ def main():
     parser = argparse.ArgumentParser(prog="style50")
     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"], metavar="MODE",
+                        choices=["character", "split", "unified", "score", "json", "html", "format"], metavar="MODE",
                         help="output mode, which can be character (default), split, unified, score, or json")
     parser.add_argument("-v", "--verbose", action="store_true",
                         help="print full tracebacks of errors")
@@ -43,10 +43,19 @@ def main():
                         help="print supported file extensions (as JSON list) and exit")
     parser.add_argument("-i", "--ignore", action="append", metavar="PATTERN",
                         help="paths/patterns to be ignored")
+    parser.add_argument("--clang-format-style", metavar="STYLE",
+                        help="clang-format style string or file:// URI (overrides default CS50 config)")
 
     args = parser.parse_args()
     ignore = args.ignore or filter(None, os.getenv("STYLE50_IGNORE", "").split(","))
-    Style50(args.output).run(args.file, ignore=ignore)
+
+    if args.output == "format":
+        if len(args.file) != 1:
+            sys.exit("format mode requires exactly one file")
+        sys.stdout.write(Style50("format", clang_format_style=args.clang_format_style).format_file(args.file[0]))
+        return
+
+    Style50(args.output, clang_format_style=args.clang_format_style).run(args.file, ignore=ignore)
 
 
 

style50/_api.py

@@ -33,12 +33,13 @@ class Style50:
     # Dict that maps substrings of libmagic's outputs to classes. Used as fallback when file extension unrecognized
     magic_map = {}
 
-    def __init__(self, output="character"):
+    def __init__(self, output="character", clang_format_style=None):
 
         self._warn_chars = set()
+        self.clang_format_style = clang_format_style
 
         # Set run function as apropriate for output mode.
-        if output == "score":
+        if output in ["score", "format"]:
             self.diff = lambda old, new: ""
         elif output in ["json", "html"]:
             self.diff = self.html_diff
@@ -54,6 +55,11 @@ def __init__(self, output="character"):
 
         self.output = output
 
+    def format_file(self, path):
+        """Format a single file and return the styled code."""
+        results = self._check(path)
+        return results.styled
+
     def run(self, *args, **kwargs):
         """Wraps Style50.check and renders the results using the renderer determined by self.output"""
         results = self.check(*args, **kwargs)
@@ -164,6 +170,14 @@ 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)
 
     @staticmethod

style50/languages.py

@@ -4,7 +4,9 @@
 from tokenize import generate_tokens, STRING, INDENT, COMMENT, TokenError
 
 import autopep8
+import cssbeautifier
 import jsbeautifier
+import sqlparse
 
 from . import StyleCheck, Error
 
@@ -18,6 +20,23 @@ 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)
 
@@ -35,6 +54,8 @@ def count_comments(self, 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)
         return self.run(self.clangFormat, input=code)
 
 
@@ -101,3 +122,32 @@ class Java(C):
     extensions = ["java"]
     magic_names = ["Java source"]
     clangFormat = C.clangFormat.copy() + ["-assume-filename=.java"]
+
+
+class Html(StyleCheck):
+    extensions = ["html"]
+    magic_names = ["HTML document"]
+
+    def style(self, code):
+        # djhtml reads from stdin when path is '-'
+        return self.run(["djhtml", "-"], input=code, exit=None)
+
+
+class Css(StyleCheck):
+    extensions = ["css"]
+    magic_names = []
+
+    def style(self, code):
+        opts = cssbeautifier.default_options()
+        opts.indent_size = 4
+        opts.end_with_newline = True
+        return cssbeautifier.beautify(code, opts)
+
+
+class Sql(StyleCheck):
+    extensions = ["sql"]
+    magic_names = []
+
+    def style(self, code):
+        # Keep this lightweight and dependency-minimal while producing stable formatting.
+        return sqlparse.format(code, reindent=True, keyword_case="upper", indent_width=4) + ("\n" if not code.endswith("\n") else "")