]> git.lizzy.rs Git - rust.git/blobdiff - util/export.py
Add bors dummy jobs
[rust.git] / util / export.py
index 9ef06e6a2bacc9125ef6fbfe825849bb9cf9b486..5d1bd60acf3d66ff0a6eb8202e16ad052c767a6d 100755 (executable)
 #!/usr/bin/env python
 
-import os
+# Build the gh-pages
+
+from collections import OrderedDict
 import re
+import sys
 import json
 
-level_re = re.compile(r'''(Forbid|Deny|Warn|Allow)''')
-conf_re = re.compile(r'''define_Conf! {\n([^}]*)\n}''', re.MULTILINE)
-confvar_re = re.compile(r'''/// Lint: (\w+). (.*).*\n *\("([^"]*)", (?:[^,]*), (.*) => (.*)\),''')
+from lintlib import parse_all, log
+
 lint_subheadline = re.compile(r'''^\*\*([\w\s]+?)[:?.!]?\*\*(.*)''')
+rust_code_block = re.compile(r'''```rust.+?```''', flags=re.DOTALL)
 
-conf_template = """
+CONF_TEMPLATE = """\
 This lint has the following configuration variables:
 
-* `%s: %s`: %s (defaults to `%s`).
-"""
-
-# TODO: actual logging
-def warn(*args): print(args)
-def debug(*args): print(args)
-def info(*args): print(args)
-
-def parse_path(p="clippy_lints/src"):
-    lints = []
-    for f in os.listdir(p):
-        if f.endswith(".rs"):
-            parse_file(lints, os.path.join(p, f))
-
-    conf = parse_conf(p)
-    info(conf)
-
-    for lint_id in conf:
-        lint = next(l for l in lints if l['id'] == lint_id)
-        if lint:
-            lint['docs']['Configuration'] = (conf_template % conf[lint_id]).strip()
-
-    return lints
-
+* `%s: %s`: %s (defaults to `%s`)."""
 
-def parse_conf(p):
-    c = {}
-    with open(p + '/utils/conf.rs') as f:
-        f = f.read()
 
-        m = re.search(conf_re, f)
-        m = m.groups()[0]
+def parse_code_block(match):
+    lines = []
 
-        m = re.findall(confvar_re, m)
+    for line in match.group(0).split('\n'):
+        if not line.startswith('# '):
+            lines.append(line)
 
-        for (lint, doc, name, default, ty) in m:
-            c[lint.lower()] = (name, ty, doc, default)
+    return '\n'.join(lines)
 
-    return c
 
-def parseLintDef(level, comment, name):
-    lint = {}
-    lint['id'] = name
-    lint['level'] = level
-    lint['docs'] = {}
+def parse_lint_def(lint):
+    lint_dict = {}
+    lint_dict['id'] = lint.name
+    lint_dict['group'] = lint.group
+    lint_dict['level'] = lint.level
+    lint_dict['docs'] = OrderedDict()
 
     last_section = None
 
-    for line in comment:
-        if len(line.strip()) == 0:
-            continue
-
+    for line in lint.doc:
         match = re.match(lint_subheadline, line)
         if match:
             last_section = match.groups()[0]
-        if match:
             text = match.groups()[1]
         else:
             text = line
 
         if not last_section:
-            warn("Skipping comment line as it was not preceded by a heading")
-            debug("in lint `%s`, line `%s`" % name, line)
-
-        lint['docs'][last_section] = (lint['docs'].get(last_section, "") + "\n" + text).strip()
-
-    return lint
-
-def parse_file(d, f):
-    last_comment = []
-    comment = True
-
-    with open(f) as rs:
-        for line in rs:
-            if comment:
-                if line.startswith("///"):
-                    if line.startswith("/// "):
-                        last_comment.append(line[4:])
-                    else:
-                        last_comment.append(line[3:])
-                elif line.startswith("declare_lint!"):
-                    comment = False
-                    deprecated = False
-                    restriction = False
-                elif line.startswith("declare_restriction_lint!"):
-                    comment = False
-                    deprecated = False
-                    restriction = True
-                elif line.startswith("declare_deprecated_lint!"):
-                    comment = False
-                    deprecated = True
-                else:
-                    last_comment = []
-            if not comment:
-                l = line.strip()
-                m = re.search(r"pub\s+([A-Z_][A-Z_0-9]*)", l)
-
-                if m:
-                    name = m.group(1).lower()
-
-                    # Intentionally either a never looping or infinite loop
-                    while not deprecated and not restriction:
-                        m = re.search(level_re, line)
-                        if m:
-                            level = m.group(0)
-                            break
-
-                        line = next(rs)
-
-                    if deprecated:
-                        level = "Deprecated"
-                    elif restriction:
-                        level = "Allow"
-
-                    info("found %s with level %s in %s" % (name, level, f))
-                    d.append(parseLintDef(level, last_comment, name=name))
-                    last_comment = []
-                    comment = True
-                if "}" in l:
-                    warn("Warning: Missing Lint-Name in", f)
-                    comment = True
+            log.warning("Skipping comment line as it was not preceded by a heading")
+            log.debug("in lint `%s`, line `%s`", lint.name, line)
+
+        if last_section not in lint_dict['docs']:
+            lint_dict['docs'][last_section] = ""
+
+        lint_dict['docs'][last_section] += text + "\n"
+
+    for section in lint_dict['docs']:
+        lint_dict['docs'][section] = re.sub(rust_code_block, parse_code_block, lint_dict['docs'][section].strip())
+
+    return lint_dict
+
 
 def main():
-    lints = parse_path()
-    info("got %s lints" % len(lints))
-    with open("util/gh-pages/lints.json", "w") as file:
-        json.dump(lints, file, indent=2)
-        info("wrote JSON for great justice")
+    lintlist, configs = parse_all()
+    lints = {}
+    for lint in lintlist:
+        lints[lint.name] = parse_lint_def(lint)
+        if lint.name in configs:
+            lints[lint.name]['docs']['Configuration'] = \
+                CONF_TEMPLATE % configs[lint.name]
+
+    outfile = sys.argv[1] if len(sys.argv) > 1 else "util/gh-pages/lints.json"
+    with open(outfile, "w") as fp:
+        lints = list(lints.values())
+        lints.sort(key=lambda x: x['id'])
+        json.dump(lints, fp, indent=2)
+        log.info("wrote JSON for great justice")
+
 
 if __name__ == "__main__":
     main()