Merge pull request #3426 from victormlg/md-cf-promises

ENT-12737: Added check_syntax for cf3 in markdown parser

Author: olehermanse

scripts/markdown-code-checker.py

@@ -1,14 +1,17 @@
 from cfbs.pretty import pretty_file
+from cfbs.utils import user_error
+import json
+from shutil import which
 import markdown_it
 import os
 import argparse
-import sys
+import subprocess
 
 
-def extract_inline_code(file_path, languages):
+def extract_inline_code(path, languages):
     """extract inline code, language and filters from markdown"""
 
-    with open(file_path, "r") as f:
+    with open(path, "r") as f:
         content = f.read()
 
     md = markdown_it.MarkdownIt("commonmark")
@@ -19,6 +22,9 @@ def extract_inline_code(file_path, languages):
         if child.type != "fence":
             continue
 
+        if not child.info:
+            continue
+
         info_string = child.info.split()
         language = info_string[0]
         flags = info_string[1:]
@@ -59,53 +65,99 @@ def get_markdown_files(start, languages):
     return return_dict
 
 
-def extract(path, i, language, first_line, last_line):
+def extract(origin_path, snippet_path, _language, first_line, last_line):
 
-    with open(path, "r") as f:
-        content = f.read()
+    try:
+        with open(origin_path, "r") as f:
+            content = f.read()
 
-    code_snippet = "\n".join(content.split("\n")[first_line + 1 : last_line - 1])
+        code_snippet = "\n".join(content.split("\n")[first_line + 1 : last_line - 1])
 
-    with open(f"{path}.snippet-{i}.{language}", "w") as f:
-        f.write(code_snippet)
+        with open(snippet_path, "w") as f:
+            f.write(code_snippet)
+    except IOError:
+        user_error(f"Couldn't open '{origin_path}' or '{snippet_path}'")
 
 
-def check_syntax():
-    pass
+def check_syntax(origin_path, snippet_path, language, first_line, _last_line):
+    snippet_abs_path = os.path.abspath(snippet_path)
+
+    if not os.path.exists(snippet_path):
+        user_error(
+            f"Couldn't find the file '{snippet_path}'. Run --extract to extract the inline code."
+        )
+
+    match language:
+        case "cf":
+            try:
+                p = subprocess.run(
+                    ["/var/cfengine/bin/cf-promises", snippet_abs_path],
+                    capture_output=True,
+                    text=True,
+                )
+                err = p.stderr
+
+                if err:
+                    err = err.replace(snippet_abs_path, f"{origin_path}:{first_line}")
+                    print(err)
+            except OSError:
+                user_error(f"'{snippet_abs_path}' doesn't exist")
+            except ValueError:
+                user_error("Invalid subprocess arguments")
+            except subprocess.CalledProcessError:
+                user_error(f"Couldn't run cf-promises on '{snippet_abs_path}'")
+            except subprocess.TimeoutExpired:
+                user_error("Timed out")
 
 
 def check_output():
     pass
 
 
-def replace():
-    pass
+def replace(origin_path, snippet_path, _language, first_line, last_line):
 
+    try:
+        with open(snippet_path, "r") as f:
+            pretty_content = f.read()
 
-def autoformat(path, i, language, first_line, last_line):
+        with open(origin_path, "r") as f:
+            origin_lines = f.read().split("\n")
+            pretty_lines = pretty_content.split("\n")
 
-    match language:
-        case "json":
-            file_name = f"{path}.snippet-{i}.{language}"
+            offset = len(pretty_lines) - len(
+                origin_lines[first_line + 1 : last_line - 1]
+            )
 
-            try:
-                pretty_file(file_name)
-                with open(file_name, "r") as f:
-                    pretty_content = f.read()
-            except:
-                print(
-                    f"[error] Couldn't find the file '{file_name}'. Run --extract to extract the inline code."
-                )
-                return
+        origin_lines[first_line + 1 : last_line - 1] = pretty_lines
 
-            with open(path, "r") as f:
-                origin_content = f.read()
+        with open(origin_path, "w") as f:
+            f.write("\n".join(origin_lines))
+    except FileNotFoundError:
+        user_error(
+            f"Couldn't find the file '{snippet_path}'. Run --extract to extract the inline code."
+        )
+    except IOError:
+        user_error(f"Couldn't open '{origin_path}' or '{snippet_path}'")
 
-                lines = origin_content.split("\n")
-                lines[first_line + 1 : last_line - 1] = pretty_content.split("\n")
+    return offset
 
-            with open(path, "w") as f:
-                f.write("\n".join(lines))
+
+def autoformat(_origin_path, snippet_path, language, _first_line, _last_line):
+
+    match language:
+        case "json":
+            try:
+                pretty_file(snippet_path)
+            except FileNotFoundError:
+                user_error(
+                    f"Couldn't find the file '{snippet_path}'. Run --extract to extract the inline code."
+                )
+            except PermissionError:
+                user_error(f"Not enough permissions to open '{snippet_path}'")
+            except IOError:
+                user_error(f"Couldn't open '{snippet_path}'")
+            except json.decoder.JSONDecodeError:
+                user_error(f"Invalid json")
 
 
 def parse_args():
@@ -166,44 +218,72 @@ def parse_args():
     args = parse_args()
 
     if not os.path.exists(args.path):
-        print("[error] This path doesn't exist")
-        sys.exit(-1)
+        user_error("This path doesn't exist")
+
+    if (
+        args.syntax_check
+        and "cf3" in args.languages
+        and not which("/var/cfengine/bin/cf-promises")
+    ):
+        user_error("cf-promises is not installed")
 
     for language in args.languages:
         if language not in supported_languages:
-            print(
-                f"[error] Unsupported language '{language}'. The supported languages are: {", ".join(supported_languages.keys())}"
+            user_error(
+                f"Unsupported language '{language}'. The supported languages are: {", ".join(supported_languages.keys())}"
             )
-            sys.exit(-1)
 
     parsed_markdowns = get_markdown_files(args.path, args.languages)
 
-    for path in parsed_markdowns["files"].keys():
-        for i, code_block in enumerate(parsed_markdowns["files"][path]["code-blocks"]):
+    for origin_path in parsed_markdowns["files"].keys():
+        offset = 0
+        for i, code_block in enumerate(
+            parsed_markdowns["files"][origin_path]["code-blocks"]
+        ):
+
+            # adjust line numbers after replace
+            for cb in parsed_markdowns["files"][origin_path]["code-blocks"][i:]:
+                cb["first_line"] += offset
+                cb["last_line"] += offset
+
+            language = supported_languages[code_block["language"]]
+            snippet_path = f"{origin_path}.snippet-{i+1}.{language}"
 
             if args.extract and "noextract" not in code_block["flags"]:
                 extract(
-                    path,
-                    i + 1,
-                    supported_languages[code_block["language"]],
+                    origin_path,
+                    snippet_path,
+                    language,
                     code_block["first_line"],
                     code_block["last_line"],
                 )
 
             if args.syntax_check and "novalidate" not in code_block["flags"]:
-                check_syntax()
+                check_syntax(
+                    origin_path,
+                    snippet_path,
+                    language,
+                    code_block["first_line"],
+                    code_block["last_line"],
+                )
 
             if args.autoformat and "noautoformat" not in code_block["flags"]:
                 autoformat(
-                    path,
-                    i + 1,
-                    supported_languages[code_block["language"]],
+                    origin_path,
+                    snippet_path,
+                    language,
                     code_block["first_line"],
                     code_block["last_line"],
                 )
 
-            if args.replace and "noreplace" not in code_block["flags"]:
-                replace()
-
             if args.output_check and "noexecute" not in code_block["flags"]:
                 check_output()
+
+            if args.replace and "noreplace" not in code_block["flags"]:
+                offset = replace(
+                    origin_path,
+                    snippet_path,
+                    language,
+                    code_block["first_line"],
+                    code_block["last_line"],
+                )