{module.type}")
+note(f"Round-trip matches original: {module.get_code() == source}")
+
+heading("Listing top-level function definitions")
+note(
+ "iter_funcdefs walks the module's direct children and yields "
+ "each function definition node. Each node knows its name and "
+ "where it lives in the source."
+)
+
+rows = []
+for funcdef in module.iter_funcdefs():
+ name = funcdef.name.value
+ start_line, start_col = funcdef.start_pos
+ end_line, end_col = funcdef.end_pos
+ params = [p.name.value for p in funcdef.get_params()]
+ rows.append(
+ f"{name}| Function | Parameters | Location |
|---|
{text}
"), append=True) diff --git a/examples/parso/rename_identifier/code.py b/examples/parso/rename_identifier/code.py new file mode 100644 index 0000000..b6ed4c4 --- /dev/null +++ b/examples/parso/rename_identifier/code.py @@ -0,0 +1,61 @@ +# --------------------------------------------------------------------- +# Round-trip parsing means we can change a single leaf in the tree and +# get back the original source with just that change applied -- all +# whitespace, comments and formatting are preserved exactly. +# --------------------------------------------------------------------- + +heading("Renaming a variable while keeping formatting intact") +note( + "We'll rename every occurrence oftmp to "
+ "buffer in this snippet by walking the tree's "
+ "leaves and rewriting matching Name tokens."
+)
+
+source = """\
+def normalize(values):
+ # Scale values into the unit interval.
+ tmp = max(values) # peak value
+ if tmp == 0:
+ return values
+ return [v / tmp for v in values] # divide each by the peak
+"""
+
+display(HTML(f"{source}"), append=True)
+
+module = parso.parse(source)
+
+
+def walk_leaves(node):
+ """Yield every leaf (token) in the tree, in source order."""
+ if hasattr(node, "children"):
+ for child in node.children:
+ yield from walk_leaves(child)
+ else:
+ yield node
+
+
+# Mutate matching Name leaves directly. The tree remembers the
+# surrounding whitespace via each leaf's `prefix`, so get_code()
+# stitches everything back together untouched.
+renamed = 0
+for leaf in walk_leaves(module):
+ if leaf.type == "name" and leaf.value == "tmp":
+ leaf.value = "buffer"
+ renamed += 1
+
+note(f"Rewrote {renamed} occurrence(s) of tmp:")
+display(
+ HTML(
+ f"{module.get_code()}"
+ ),
+ append=True,
+)
+
+heading("Why this works")
+note(
+ "Each leaf carries its value (the token text) and a "
+ "prefix (whitespace and comments preceding it). "
+ "Editing only value leaves comments, indentation, and "
+ "blank lines exactly where they were -- the foundation parso lays "
+ "for refactoring tools."
+)
diff --git a/examples/parso/rename_identifier/config.toml b/examples/parso/rename_identifier/config.toml
new file mode 100644
index 0000000..71aa241
--- /dev/null
+++ b/examples/parso/rename_identifier/config.toml
@@ -0,0 +1 @@
+packages = ["parso"]
diff --git a/examples/parso/rename_identifier/setup.py b/examples/parso/rename_identifier/setup.py
new file mode 100644
index 0000000..62782f6
--- /dev/null
+++ b/examples/parso/rename_identifier/setup.py
@@ -0,0 +1,22 @@
+"""Setup for the third example: same names, no IPython shim."""
+import js
+from pyscript import window, HTML, display as _display
+
+js.alert = window.alert
+
+
+def display(*args, **kwargs):
+ return _display(
+ *args, **kwargs, target=__pyscript_display_target__,
+ )
+
+
+def heading(text, level=2):
+ display(HTML(f"{text}
"), append=True) + + +import parso diff --git a/examples/parso/syntax_errors/code.py b/examples/parso/syntax_errors/code.py new file mode 100644 index 0000000..8144fb2 --- /dev/null +++ b/examples/parso/syntax_errors/code.py @@ -0,0 +1,58 @@ +# --------------------------------------------------------------------- +# Parso recovers from errors, so it can report ALL of them in one pass. +# Python's built-in compile() bails out at the first syntax error; +# parso keeps going and produces a tree plus a list of issues. +# --------------------------------------------------------------------- + +heading("A messy script with several problems") +note( + "Below is some intentionally broken Python. We'll ask parso " + "for every syntax error in one go, instead of fixing them one " + "at a time and re-running." +) + +broken_source = """\ +def greet(name) + print('hello', name) + +for i in range(3) + print(i) + +continue + +x = 1 + +""" + +# Pretty-print the source with line numbers so the errors line up. +numbered = ""
+for i, line in enumerate(broken_source.splitlines(), start=1):
+ numbered += f"{i:>3} {line}\n"
+numbered += ""
+display(HTML(numbered), append=True)
+
+heading("Asking parso for all the issues")
+note(
+ "load_grammar gives us a grammar object whose iter_errors "
+ "method yields one Issue per problem found. Each issue knows "
+ "its message and start/end position."
+)
+
+grammar = parso.load_grammar()
+module = grammar.parse(broken_source)
+issues = list(grammar.iter_errors(module))
+
+note(f"Found {len(issues)} issue(s):")
+rows = []
+for issue in issues:
+ line, col = issue.start_pos
+ rows.append(
+ f"{issue.message}| Position | Message |
|---|
{text}
"), append=True) + + +import parso