brianr/MojoTemplateFormatter
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
65c32231cce90c6dc8d0b62c80af49ffce067ab4
MojoTemplateFormatter/mojofmt.py

986 lines
32 KiB
Python
Raw Normal View History

GPT-5 Attempt Sat 9thAug2025
2025-08-09 15:52:03 +01:00
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
mojofmt: Formatter for Mojolicious Embedded Perl templates (.ep, .htm.ep, .html.ep)
Features:
- Indent HTML structure and Mojolicious line directives consistently
- Preserve chomp markers (<%- ... -%>) and do not alter newline semantics
- Handle helper begin/end blocks and Perl brace-based indentation for directives
- Treat pre/script/style/textarea content as opaque (unchanged)
- Optionally normalize spacing inside <% %> delimiters and after % directives
- Integrate with perltidy for Perl code formatting (if available on PATH)
- Reformat extended multi-line Perl blocks between lines with only <% and %>
- CLI with --write/--check/--diff, --out, --stdin/--stdout modes
- --self-test for sanity checks (includes perltidy probe)
- Logging: --log-level error|info|debug (and --verbose as shorthand for info)
- Optional --perl-keyword-spacing to aggressively insert spaces after Perl keywords
"""
from __future__ import annotations
import argparse
import difflib
import logging
import os
import re
import shutil
import subprocess
import sys
from dataclasses import dataclass, replace as dc_replace
from pathlib import Path
from typing import Iterable, List, Optional, Tuple
VERSION = "0.1.9"
DEFAULT_EXTENSIONS = (".ep", ".htm.ep", ".html.ep")
VOID_ELEMENTS = {
"area", "base", "br", "col", "embed", "hr", "img", "input",
"link", "meta", "param", "source", "track", "wbr",
}
RAW_ELEMENTS = {"pre", "script", "style", "textarea"}
logger = logging.getLogger("mojofmt")
TAG_RE = re.compile(
r"""
<
(?P<slash>/)?
(?P<name>[A-Za-z][\w:-]*)
(?P<attrs>(?:\s+[^<>]*?)?)
(?P<self>/)?
>
""",
re.VERBOSE,
)
# Mojolicious inline tags on a single line: <%...%>
TPL_TAG_RE = re.compile(
r"""
<%
(?P<leftchomp>-)? # optional left chomp
(?P<kind>==|=|\#)? # kind: ==, =, or #
(?P<body>.*?) # inner code/comment (non-greedy, no newlines)
(?P<rightchomp>-)? # optional right chomp
%>
""",
re.VERBOSE,
)
# Line directives: starts with % (possibly %= %== %#) after indentation
LINE_DIR_RE = re.compile(r"^(?P<indent>\s*)%(?P<kind>==|=|\#)?(?P<body>.*)$")
# Whitespace condensing for single-line normalization
WS_RE = re.compile(r"[ \t]+")
# begin/end detection (heuristic)
BEGIN_RE = re.compile(r"\bbegin\b")
END_LINE_RE = re.compile(r"^\s*%\s*end\b")
END_TAG_ONLY_RE = re.compile(r"^\s*<%-?\s*end\s*-?%>\s*$")
# leading } in a directive (e.g., % } or % }} )
LEADING_RBRACE_COUNT_RE = re.compile(r"^\s*%\s*(?P<braces>\}+)")
# <% } %> alone
TAG_CLOSING_BRACE_ONLY_RE = re.compile(r"^\s*<%-?\s*\}+\s*-?%>\s*$")
# Detect raw element opening/closing (as standalone lines)
RAW_OPEN_RE = re.compile(r"^\s*<(?P<name>pre|script|style|textarea)\b[^>]*>\s*$", re.I)
RAW_CLOSE_RE = re.compile(r"^\s*</(?P<name>pre|script|style|textarea)\s*>\s*$", re.I)
# Extended EP block delimiters (opening/closing on their own lines)
OPEN_BLOCK_RE = re.compile(r'^(?P<base>[ \t]*)<%(?P<left>-?)(?![=#])\s*$')
Fix problem with extended block perl
2025-08-09 16:14:30 +01:00
CLOSE_BLOCK_RE = re.compile(
r'^(?P<base>[ \t]*)(?P<right>-?)%(?:>| >)\s*$'
)
GPT-5 Attempt Sat 9thAug2025
2025-08-09 15:52:03 +01:00
@dataclass
class Config:
indent_width: int = 2
eol: str = "lf" # lf|crlf|preserve
normalize_delimiter_spacing: bool = True
perltidy_path: Optional[str] = None # if None, use PATH
perltidy_options: Optional[List[str]] = None
extensions: Tuple[str, ...] = DEFAULT_EXTENSIONS
respect_gitignore: bool = True
verbose: bool = False # kept for shorthand with --verbose
perl_keyword_spacing: bool = False # optional post-pass
def load_config(cli_args: argparse.Namespace) -> Config:
cfg = Config()
if cli_args.indent is not None:
cfg.indent_width = cli_args.indent
if cli_args.eol is not None:
cfg.eol = cli_args.eol
if cli_args.no_space_in_delims:
cfg.normalize_delimiter_spacing = False
if cli_args.perltidy:
cfg.perltidy_path = cli_args.perltidy
cfg.verbose = cli_args.verbose
cfg.perl_keyword_spacing = getattr(cli_args, "perl_keyword_spacing", False)
return cfg
def setup_logging(level_name: Optional[str], verbose_flag: bool) -> None:
if level_name:
name = level_name.lower()
elif verbose_flag:
name = "info"
else:
name = "error"
level = {
"error": logging.ERROR,
"warning": logging.WARNING,
"info": logging.INFO,
"debug": logging.DEBUG,
"critical": logging.CRITICAL,
}.get(name, logging.ERROR)
fmt = "mojofmt: %(levelname)s: %(message)s"
logging.basicConfig(level=level, format=fmt)
def detect_eol(text: str) -> str:
if "\r\n" in text:
return "crlf"
return "lf"
def normalize_eol(text: str, eol: str) -> str:
if eol == "preserve":
return text
s = text.replace("\r\n", "\n").replace("\r", "\n")
if eol == "lf":
return s
elif eol == "crlf":
return s.replace("\n", "\r\n")
else:
return s
_PERLTIDY_WARNED = False # avoid spamming logs if perltidy missing repeatedly
def run_perltidy(code: str, cfg: Config) -> Tuple[int, str, str]:
global _PERLTIDY_WARNED
exe = cfg.perltidy_path or shutil.which("perltidy")
if not exe:
if not _PERLTIDY_WARNED:
logger.error("perltidy not found; Perl inside template will not be reformatted")
_PERLTIDY_WARNED = True
return (127, code, "perltidy not found")
args: List[str] = [exe]
if cfg.perltidy_options:
args += cfg.perltidy_options
if not any(opt.startswith("-st") for opt in cfg.perltidy_options):
args.append("-st")
else:
args += [
f"-i={cfg.indent_width}",
f"-ci={cfg.indent_width}",
"-l=100",
"-q",
"-se",
"-st",
"-nbbc",
"-noll",
]
logger.debug("Running perltidy: %s", " ".join(args))
try:
proc = subprocess.run(
args,
input=code,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
text=True,
check=False,
)
if proc.returncode != 0:
logger.debug("perltidy non-zero exit %s: %s", proc.returncode, (proc.stderr or "").strip())
return (proc.returncode, proc.stdout, proc.stderr)
except FileNotFoundError:
if not _PERLTIDY_WARNED:
logger.error("perltidy not found while executing")
_PERLTIDY_WARNED = True
return (127, code, "perltidy not found")
def perltidy_probe(cfg: Config) -> Tuple[bool, str]:
exe = cfg.perltidy_path or shutil.which("perltidy")
if not exe:
return (False, "perltidy not found on PATH (install Perl::Tidy or pass --perltidy)")
snippet = "my $x= {a=>1,b =>2 };"
rc, out, err = run_perltidy(snippet, cfg)
if rc != 0:
return (False, f"perltidy exit {rc}: {(err or '').strip()}")
want = ["my $x = {", "a => 1", "b => 2"]
if all(w in out for w in want):
return (True, f"perltidy OK: {exe}")
if out and out.strip() and out.strip() != snippet:
return (True, f"perltidy OK (non-default style): {exe}")
return (False, "perltidy produced unexpected output")
def tidy_perl_statement_oneline(code: str, cfg: Config) -> str:
rc, out, _ = run_perltidy(code, cfg)
if rc != 0:
out = code
out = out.strip()
out = " ".join(out.splitlines())
out = WS_RE.sub(" ", out).strip()
out = enforce_perl_keyword_spacing(out, cfg.perl_keyword_spacing)
return out
def tidy_perl_expression(code: str, cfg: Config) -> str:
wrapped = f"do {{ {code} }}"
rc, out, _ = run_perltidy(wrapped, cfg)
if rc != 0:
inner = code.strip()
return enforce_perl_keyword_spacing(inner, cfg.perl_keyword_spacing)
text = out
try:
start = text.index("{")
depth = 0
end_idx = None
for i in range(start, len(text)):
ch = text[i]
if ch == "{":
depth += 1
elif ch == "}":
depth -= 1
if depth == 0:
end_idx = i
break
if end_idx is None:
inner = code.strip()
else:
inner = text[start + 1 : end_idx]
except ValueError:
inner = code.strip()
inner = " ".join(line.strip() for line in inner.splitlines())
inner = WS_RE.sub(" ", inner).strip()
inner = enforce_perl_keyword_spacing(inner, cfg.perl_keyword_spacing)
return inner
def tidy_perl_block_multiline(code: str, cfg: Config) -> Optional[str]:
"""
Format a multi-line chunk of Perl by wrapping it in a do { ... } block for perltidy.
Returns the formatted inner text (without the wrapper) or None on failure.
"""
wrapped = "do {\n" + code + "\n}"
rc, out, _ = run_perltidy(wrapped, cfg)
if rc != 0 or not out:
return None
try:
start = out.index("{")
except ValueError:
return None
depth = 0
end_idx = None
for i in range(start, len(out)):
ch = out[i]
if ch == "{":
depth += 1
elif ch == "}":
depth -= 1
if depth == 0:
end_idx = i
break
if end_idx is None:
return None
inner = out[start + 1 : end_idx]
if inner.startswith("\n"):
inner = inner[1:]
if inner.endswith("\n"):
inner = inner[:-1]
return inner
def _split_code_and_strings(s: str):
chunks = []
buf: List[str] = []
in_single = in_double = False
i = 0
while i < len(s):
ch = s[i]
if not in_single and not in_double:
if ch == "'":
if buf:
chunks.append(("code", "".join(buf)))
buf = []
in_single = True
buf.append(ch)
elif ch == '"':
if buf:
chunks.append(("code", "".join(buf)))
buf = []
in_double = True
buf.append(ch)
else:
buf.append(ch)
elif in_single:
buf.append(ch)
if ch == "\\":
if i + 1 < len(s):
buf.append(s[i + 1]); i += 1
elif ch == "'":
chunks.append(("str", "".join(buf))); buf = []; in_single = False
elif in_double:
buf.append(ch)
if ch == "\\":
if i + 1 < len(s):
buf.append(s[i + 1]); i += 1
elif ch == '"':
chunks.append(("str", "".join(buf))); buf = []; in_double = False
i += 1
if buf:
chunks.append(("code" if not (in_single or in_double) else "str", "".join(buf)))
return chunks
def _split_unquoted_comment(code_chunk: str):
idx = code_chunk.find("#")
if idx == -1:
return code_chunk, None
return code_chunk[:idx], code_chunk[idx:]
def enforce_perl_keyword_spacing(s: str, enable: bool) -> str:
if not enable or not s:
return s
# Add space after control keywords before '('
ctrl_paren = re.compile(r"\b(?P<kw>if|elsif|unless|while|until|for|foreach|given|when)\s*\(")
# Add space after declarators before sigils/paren
decl = re.compile(r"\b(?P<kw>my|our|state|local)\s*(?=[\$\@\%\*\&\\\(])")
# sub name spacing and brace spacing
sub_named = re.compile(r"\bsub\s*([A-Za-z_]\w*)")
sub_named_brace = re.compile(r"\bsub\s+([A-Za-z_]\w*)\s*\{")
sub_anon = re.compile(r"\bsub\s*\{")
# Calls which often appear without space
call_paren = re.compile(r"\b(?P<kw>return|print|say|die|warn|exit)\s*\(")
call_space = re.compile(r"\b(?P<kw>return|print|say|die|warn|exit)\s*(?=\S)")
# else/continue/do/eval blocks
else_brace = re.compile(r"\b(?P<kw>else|continue|do|eval)\s*\{")
# Ensure space before a brace after a closing paren: "){" -> ") {"
brace_after_paren = re.compile(r"\)\s*\{")
# Ensure space between '}' and a following keyword: "}else" -> "} else"
brace_then_kw = re.compile(r"\}\s*(?=\b(?:else|elsif|continue|when)\b)")
out: List[str] = []
for kind, chunk in _split_code_and_strings(s):
if kind != "code":
out.append(chunk)
continue
code, comment = _split_unquoted_comment(chunk)
code = ctrl_paren.sub(lambda m: f"{m.group('kw')} (", code)
code = decl.sub(lambda m: f"{m.group('kw')} ", code)
code = sub_named.sub(lambda m: f"sub {m.group(1)}", code)
code = sub_named_brace.sub(lambda m: f"sub {m.group(1)} {{", code)
code = sub_anon.sub("sub {", code)
code = call_paren.sub(lambda m: f"{m.group('kw')} (", code)
code = call_space.sub(lambda m: f"{m.group('kw')} ", code)
code = brace_then_kw.sub("} ", code)
code = else_brace.sub(lambda m: f"{m.group('kw')} {{", code)
code = brace_after_paren.sub(") {", code)
out.append(code + (comment or ""))
return "".join(out)
def _common_leading_ws(lines: List[str]) -> str:
ws = None
for ln in lines:
if not ln.strip():
continue
lead = len(ln) - len(ln.lstrip(' \t'))
s = ln[:lead]
if ws is None:
ws = s
else:
i = 0
while i < len(ws) and i < len(s) and ws[i] == s[i]:
i += 1
ws = ws[:i]
return ws or ""
def _dedent_block(text: str) -> str:
lines = text.splitlines()
# Trim leading/trailing all-whitespace lines
while lines and not lines[0].strip():
lines.pop(0)
while lines and not lines[-1].strip():
lines.pop()
if not lines:
return ""
prefix = _common_leading_ws(lines)
if not prefix:
return "\n".join(lines)
plen = len(prefix)
out = []
for ln in lines:
out.append(ln[plen:] if ln.startswith(prefix) else ln)
return "\n".join(out)
def _naive_perl_indent(code: str, width: int = 2) -> str:
lines = code.splitlines()
indent = 0
out = []
for raw in lines:
ln = raw.rstrip()
if not ln:
out.append("")
continue
stripped = ln.lstrip()
# dedent on leading closing braces
leading_closes = 0
i = 0
while i < len(stripped) and stripped[i] == '}':
leading_closes += 1
i += 1
indent_before = max(0, indent - leading_closes)
out.append((" " * (indent_before * width)) + stripped)
opens = ln.count("{")
closes = ln.count("}")
indent += (opens - closes)
if indent < 0:
indent = 0
return "\n".join(out)
def normalize_tpl_tag(
leftchomp: Optional[str],
kind: Optional[str],
body: str,
rightchomp: Optional[str],
cfg: Config,
) -> Tuple[str, str, str, str, str]:
if not cfg.normalize_delimiter_spacing or (kind == "#"):
return ("<%", leftchomp or "", kind or "", body, (rightchomp or "") + "%>")
body = body.strip()
left_space = " "
right_space = " " if rightchomp == "" else ""
open_part = "<%" + (leftchomp or "") + (kind or "") + left_space
close_part = right_space + (rightchomp or "") + "%>"
return (open_part, "", "", body, close_part)
def substitute_tpl_tags_in_line(line: str, cfg: Config) -> str:
parts: List[str] = []
last = 0
for m in TPL_TAG_RE.finditer(line):
parts.append(line[last : m.start()])
leftchomp = m.group("leftchomp") or ""
kind = m.group("kind") or ""
body = m.group("body")
rightchomp = m.group("rightchomp") or ""
open_part, _, _, new_body, close_part = normalize_tpl_tag(
leftchomp, kind, body, rightchomp, cfg
)
if kind == "#":
inner = body
else:
if kind in ("=", "=="):
inner = tidy_perl_expression(body, cfg)
else:
inner = tidy_perl_statement_oneline(body, cfg)
parts.append(open_part + inner + close_part)
last = m.end()
parts.append(line[last:])
return "".join(parts)
def derive_html_tag_deltas(line_wo_tpl: str) -> Tuple[int, int, Optional[str], Optional[str]]:
"""
Return (pre_dedent, net_total, raw_open, raw_close):
- pre_dedent: end tags at beginning of line (dedent before printing)
- net_total: total start tags (+1) minus end tags (-1) across the line for non-void, non-self-closing tags
- raw_open, raw_close: raw elements opened/closed on this line if they match exactly
"""
s = line_wo_tpl
raw_open = None
raw_close = None
m_open = RAW_OPEN_RE.match(s)
if m_open:
raw_open = m_open.group("name").lower()
m_close = RAW_CLOSE_RE.match(s)
if m_close:
raw_close = m_close.group("name").lower()
pre_dedent = 0
i = 0
while i < len(s) and s[i].isspace():
i += 1
while True:
m = TAG_RE.match(s, i)
if not m:
break
if m.group("slash"):
pre_dedent += 1
i = m.end()
while i < len(s) and s[i].isspace():
i += 1
continue
else:
break
net = 0
for m in TAG_RE.finditer(s):
slash = m.group("slash")
name = (m.group("name") or "").lower()
selfclose = bool(m.group("self"))
if slash:
net -= 1
else:
if selfclose or name in VOID_ELEMENTS:
pass
else:
net += 1
return pre_dedent, net, raw_open, raw_close
def strip_tpl_tags(line: str) -> str:
return TPL_TAG_RE.sub(lambda m: " " * (m.end() - m.start()), line)
def is_standalone_statement_tag(line: str) -> bool:
s = line.strip()
if not (s.startswith("<%") and s.endswith("%>")):
return False
if s.startswith("<%=") or s.startswith("<%=="):
return False
return True
def compute_perl_deltas(line: str) -> Tuple[int, int]:
"""
Return (perl_dedent_before, perl_delta_after_for_next_line).
Only line directives (starting with %) and standalone <% ... %> statement lines
affect Perl depth. Also account for % end / <% end %> and begin blocks.
"""
dedent_before = 0
delta_after = 0
if END_LINE_RE.match(line) or END_TAG_ONLY_RE.match(line):
dedent_before += 1
m = LEADING_RBRACE_COUNT_RE.match(line)
if m:
braces = m.group("braces") or ""
dedent_before += len(braces)
if TAG_CLOSING_BRACE_ONLY_RE.match(line):
dedent_before += 1
is_dir = bool(LINE_DIR_RE.match(line))
is_stmt_tag_only = is_standalone_statement_tag(line)
if is_dir:
body = LINE_DIR_RE.match(line).group("body")
open_count = body.count("{")
close_count = body.count("}")
delta_after += (open_count - close_count)
if BEGIN_RE.search(line):
delta_after += 1
elif is_stmt_tag_only:
bodies = [m.group("body") or "" for m in TPL_TAG_RE.finditer(line)]
open_count = sum(b.count("{") for b in bodies)
close_count = sum(b.count("}") for b in bodies)
delta_after += (open_count - close_count)
if BEGIN_RE.search(line):
delta_after += 1
return dedent_before, delta_after
def format_line_directive(line: str, cfg: Config) -> Optional[str]:
"""
If the line is a Mojolicious line directive (% ...), return a formatted
directive string WITHOUT leading indentation (indent applied separately).
Otherwise return None.
"""
m = LINE_DIR_RE.match(line)
if not m:
return None
kind = m.group("kind") or ""
body = m.group("body")
if kind == "#":
if cfg.normalize_delimiter_spacing:
trimmed = body.strip()
return "%#" + ((" " + trimmed) if trimmed else "")
else:
return "%#" + body
if kind in ("=", "=="):
inner = tidy_perl_expression(body, cfg)
else:
inner = tidy_perl_statement_oneline(body, cfg)
if cfg.normalize_delimiter_spacing:
return "%" + kind + ((" " + inner) if inner else "")
else:
return "%" + kind + ((" " + inner) if inner else "")
def rstrip_trailing_ws(line: str) -> str:
return line.rstrip(" \t")
def format_extended_perl_blocks(text: str, cfg: Config) -> str:
"""
Detect blocks where <% and %> are on their own lines (with optional chomp markers),
format the inner Perl with perltidy (wrapped in do { ... }) or a naive indenter,
and reinsert with the original base indentation.
"""
lines = text.splitlines()
i = 0
out: List[str] = []
n = len(lines)
while i < n:
m_open = OPEN_BLOCK_RE.match(lines[i])
if not m_open:
out.append(lines[i])
i += 1
continue
# Find closing delimiter
j = i + 1
close = None
while j < n:
m_close = CLOSE_BLOCK_RE.match(lines[j])
if m_close:
close = m_close
break
j += 1
if close is None:
out.append(lines[i])
i += 1
continue
base = m_open.group("base") or ""
left = m_open.group("left") or ""
right = close.group("right") or ""
body_lines = lines[i + 1 : j]
inner = "\n".join(body_lines)
# Dedent before formatting
inner = _dedent_block(inner)
# Try perltidy; fallback to naive indentation
tidied = tidy_perl_block_multiline(inner, cfg)
if tidied is None:
logger.debug("EP block %d-%d: perltidy failed/unavailable; using naive indenter", i + 1, j + 1)
tidied = _naive_perl_indent(inner, width=cfg.indent_width)
else:
logger.debug("EP block %d-%d: perltidy formatted (%d lines)", i + 1, j + 1, len(tidied.splitlines()))
tidied = tidied.rstrip("\n")
out.append(f"{base}<%{left}")
if tidied:
for ln in tidied.splitlines():
out.append((base + ln) if ln else base)
out.append(f"{base}{right}%>")
i = j + 1 # continue after closing line
return "\n".join(out) + ("\n" if text.endswith("\n") else "")
def format_string(src: str, cfg: Config) -> str:
original_eol = detect_eol(src)
text = src.replace("\r\n", "\n").replace("\r", "\n")
lines = text.split("\n")
html_depth = 0
perl_depth = 0
in_raw: Optional[str] = None
out_lines: List[str] = []
for orig_line in lines:
line = orig_line
if in_raw:
m_close = RAW_CLOSE_RE.match(line)
if m_close and m_close.group("name").lower() == in_raw:
indent_level = max(0, html_depth - 1) + perl_depth
indent = " " * (cfg.indent_width * indent_level)
new_line = indent + line.lstrip()
out_lines.append(rstrip_trailing_ws(new_line))
html_depth = max(0, html_depth - 1)
in_raw = None
else:
out_lines.append(line)
continue
perl_dedent_before, perl_delta_after = compute_perl_deltas(line)
line_wo_tpl = strip_tpl_tags(line)
html_pre_dedent, html_net, raw_open, raw_close = derive_html_tag_deltas(line_wo_tpl)
base_html_depth = max(0, html_depth - html_pre_dedent)
base_perl_depth = max(0, perl_depth - perl_dedent_before)
indent_level = max(0, base_html_depth + base_perl_depth)
indent = " " * (cfg.indent_width * indent_level)
formatted_directive = format_line_directive(line, cfg)
if formatted_directive is not None:
content = formatted_directive
else:
content = substitute_tpl_tags_in_line(line, cfg).lstrip()
new_line = indent + content.lstrip()
out_lines.append(rstrip_trailing_ws(new_line))
html_depth = max(0, base_html_depth + html_net + html_pre_dedent)
if raw_open and (raw_open.lower() in RAW_ELEMENTS):
in_raw = raw_open.lower()
perl_depth = max(0, base_perl_depth + perl_delta_after)
result = "\n".join(out_lines)
# Post-pass: format extended <% ... %> blocks
result = format_extended_perl_blocks(result, cfg)
if not result.endswith("\n"):
result += "\n"
eol_mode = cfg.eol if cfg.eol != "preserve" else original_eol
result = normalize_eol(result, eol_mode)
return result
def read_text(path: Path) -> str:
with path.open("rb") as f:
raw = f.read()
try:
return raw.decode("utf-8")
except UnicodeDecodeError:
return raw.decode(errors="replace")
def write_text(path: Path, text: str) -> None:
with path.open("wb") as f:
f.write(text.encode("utf-8"))
def is_supported_file(path: Path, exts: Tuple[str, ...]) -> bool:
name = path.name.lower()
return any(name.endswith(ext) for ext in exts)
def iter_files(paths: List[str], exts: Tuple[str, ...]) -> Iterable[Path]:
for p in paths:
pth = Path(p)
if pth.is_dir():
for root, _, files in os.walk(pth):
for fn in files:
fp = Path(root) / fn
if is_supported_file(fp, exts):
logger.debug("Found file: %s", fp)
yield fp
else:
if is_supported_file(pth, exts):
logger.debug("Found file: %s", pth)
yield pth
def unified_diff(a: str, b: str, path: Path) -> str:
a_lines = a.splitlines(keepends=True)
b_lines = b.splitlines(keepends=True)
return "".join(
difflib.unified_diff(
a_lines, b_lines, fromfile=str(path), tofile=str(path) + " (formatted)"
)
)
def process_file(path: Path, cfg: Config, write: bool, show_diff: bool, backup: bool = False) -> Tuple[bool, str]:
original = read_text(path)
formatted = format_string(original, cfg)
changed = original != formatted
if changed:
logger.info("Formatted: %s", path)
if show_diff:
sys.stdout.write(unified_diff(original, formatted, path))
if write:
if backup:
bak_path = path.with_name(path.name + ".bak")
write_text(bak_path, original)
logger.info("Backup written: %s", bak_path)
write_text(path, formatted)
logger.info("Overwritten: %s", path)
else:
logger.info("Unchanged: %s", path)
return changed, formatted
def process_stdin_stdout(cfg: Config) -> int:
data = sys.stdin.read()
formatted = format_string(data, cfg)
sys.stdout.write(formatted)
logger.info("Formatted stdin to stdout")
return 0
def build_arg_parser() -> argparse.ArgumentParser:
p = argparse.ArgumentParser(description="Format Mojolicious templates (.ep, .htm.ep, .html.ep)")
p.add_argument("paths", nargs="*", help="Files or directories")
p.add_argument("-w", "--write", action="store_true", help="Overwrite files in place (writes a .bak backup)")
p.add_argument("-o", "--out", help="Write formatted output to this file (single input file or --stdin). Conflicts with --write/--check/--diff")
p.add_argument("--check", action="store_true", help="Exit non-zero if any file would change")
p.add_argument("--diff", action="store_true", help="Print unified diff for changes")
p.add_argument("--stdin", action="store_true", help="Read from stdin")
p.add_argument("--stdout", action="store_true", help="Write to stdout (with --stdin)")
p.add_argument("--perltidy", help="Path to perltidy executable (defaults to PATH)")
p.add_argument("--indent", type=int, help="Indent width (spaces, default 2)")
p.add_argument("--eol", choices=["lf", "crlf", "preserve"], default="lf", help="EOL handling (default lf)")
p.add_argument("--no-space-in-delims", action="store_true", help="Do not normalize spaces inside <%% %%> delimiters")
p.add_argument("--perl-keyword-spacing", action="store_true", help="Aggressively insert a space after Perl keywords (if(...)->if (...), my$->my $, return(...)->return (...), etc.)")
p.add_argument("--self-test", dest="self_test", action="store_true", help="Run internal sanity checks and exit 0/1")
p.add_argument("--log-level", choices=["error", "info", "debug"], help="Logging level (default error)")
p.add_argument("--verbose", action="store_true", help="Shorthand for --log-level info")
p.add_argument("--version", action="store_true", help="Print version and exit")
return p
def self_test(cfg: Config) -> int:
failures: List[str] = []
def check(name: str, cond: bool, detail: Optional[str] = None):
if not cond:
failures.append(name + (": " + detail if detail else ""))
# T0: perltidy availability and behavior
ok, msg = perltidy_probe(cfg)
if not ok:
failures.append("perltidy: " + msg)
else:
logger.info(msg)
# T1: idempotence on a mixed template
src_a = "% if (1) {\n<ul>\n% for my $i (1..2) {\n<li><%= $i %></li>\n% }\n</ul>\n% }\n"
fmt_a1 = format_string(src_a, cfg)
fmt_a2 = format_string(fmt_a1, cfg)
check("idempotence", fmt_a1 == fmt_a2)
# T2: chomp markers preserved
src_b = "<li><%= $title -%>\n<%= $sub %></li>\n"
fmt_b = format_string(src_b, cfg)
check("chomp presence", "-%>" in fmt_b)
check("no-left-chomp-added", "<%-" not in fmt_b)
# T3: raw element inner content unchanged
src_c = "<script>\n var x=1; // keep spacing\nif(true){console.log(x)}\n</script>\n"
fmt_c = format_string(src_c, cfg)
c_lines = src_c.splitlines()
f_lines = fmt_c.splitlines()
if len(c_lines) >= 3 and len(f_lines) >= 3:
check("raw inner unchanged", c_lines[1:-1] == f_lines[1:-1], detail=f"got {f_lines[1:-1]!r}")
else:
check("raw structure", False, "unexpected line count")
# T4: delimiter spacing normalization for <% %>
src_d = "<%my $x=1;%>\n"
fmt_d = format_string(src_d, cfg)
check("delimiter spacing", "<% " in fmt_d and "%>" in fmt_d)
# T5: keyword spacing with flag on
cfg_kw = dc_replace(cfg, perl_keyword_spacing=True)
fmt_k1 = format_string("<% if($x){ %>\n", cfg_kw)
check("kw if(...)", "if (" in fmt_k1 and " {" in fmt_k1)
fmt_k2 = format_string("<%= return(1) %>\n", cfg_kw)
check("kw return(...)", "return (" in fmt_k2)
fmt_k3 = format_string('<% say"hi"; %>\n', cfg_kw)
check("kw say \"...\"", 'say "' in fmt_k3)
fmt_k4 = format_string("<% my($x,$y)=@_; %>\n", cfg_kw)
check("kw my $", "my (" in fmt_k4 and " = @_" in fmt_k4)
fmt_k5 = format_string("<% sub foo{ %>\n", cfg_kw)
check("kw sub foo {", "sub foo {" in fmt_k5)
# T6: extended EP block formatting
src_e = "<%\nmy $x=1;\nif($x){\nsay \"hi\";\n}\n%>\n"
fmt_e = format_string(src_e, cfg)
check("extended block indented", ("if (" in fmt_e and "say" in fmt_e and "{\n" in fmt_e) or ("if(" not in fmt_e))
if failures:
logger.error("SELF-TEST FAILURES:")
for f in failures:
logger.error(" - %s", f)
return 1
logger.info("Self-test passed")
return 0
def main(argv: Optional[List[str]] = None) -> int:
parser = build_arg_parser()
args = parser.parse_args(argv)
setup_logging(args.log_level, args.verbose)
if args.version:
print(f"mojofmt {VERSION}")
return 0
if args.self_test:
cfg = load_config(args)
return self_test(cfg)
# Validate --out usage
if args.out:
if args.write or args.check or args.diff:
parser.error("--out conflicts with --write/--check/--diff")
cfg = load_config(args)
out_path = Path(args.out)
if args.stdin:
data = sys.stdin.read()
formatted = format_string(data, cfg)
write_text(out_path, formatted)
logger.info("Wrote %s (from stdin)", out_path)
return 0
# must be exactly one input file
if not args.paths or len(args.paths) != 1:
parser.error("--out requires exactly one input file (or use --stdin)")
in_path = Path(args.paths[0])
original = read_text(in_path)
formatted = format_string(original, cfg)
write_text(out_path, formatted)
logger.info("Wrote %s (from %s)", out_path, in_path)
return 0
cfg = load_config(args)
if args.stdin:
return process_stdin_stdout(cfg)
if not args.paths:
parser.error("No input paths provided (or use --stdin).")
any_changed = False
any_error = False
for path in iter_files(args.paths, cfg.extensions):
try:
changed, _ = process_file(path, cfg, write=args.write, show_diff=args.diff, backup=args.write)
any_changed = any_changed or changed
except Exception as e:
any_error = True
logger.error("Error processing %s: %s", path, e)
if args.check and any_changed:
return 1
return 1 if any_error else 0
if __name__ == "__main__":
sys.exit(main())
Reference in New Issue Copy Permalink