Skip to content

💫 Toolkit to help you get started with SDD or any other process!

fix(workflows): stop list-literal-then-index expressions silently corrupting (#4572)

Noor ul aine03327fb2802
diff --git a/src/specify_cli/workflows/expressions.py b/src/specify_cli/workflows/expressions.py
index fe8098f32..426f71af9 100644
--- a/src/specify_cli/workflows/expressions.py
+++ b/src/specify_cli/workflows/expressions.py
@@ -416,6 +416,41 @@ def _find_top_level(text: str, token: str) -> int:
return -1
+def _is_single_list_literal(expr: str) -> bool:
+ """Return ``True`` only when *expr* is exactly one bracketed list
+ literal -- the opening ``[`` closes at the FINAL character, not partway
+ through the string.
+
+ ``expr.startswith("[") and expr.endswith("]")`` alone also matches a
+ list literal immediately followed by an index suffix, e.g.
+ ``[1,2,3][1]`` (meant as "index 1 of [1,2,3]", i.e. 2). Naively
+ stripping the outer brackets from that string yields the garbage
+ ``1,2,3][1``, which then silently evaluates to ``[1, 2, None]`` instead
+ of raising or resolving the index -- the same "grabs the wrong span"
+ failure mode the string-literal check above guards against, just never
+ given the same treatment for brackets.
+ """
+ if not (expr.startswith("[") and expr.endswith("]")):
+ return False
+ quote: str | None = None
+ depth = 0
+ n = len(expr)
+ for i, ch in enumerate(expr):
+ if quote is not None:
+ if ch == quote:
+ quote = None
+ continue
+ if ch in ("'", '"'):
+ quote = ch
+ elif ch in "([{":
+ depth += 1
+ elif ch in ")]}":
+ depth -= 1
+ if depth == 0:
+ return i == n - 1
+ return False
+
+
def _apply_filter(value: Any, filter_expr: str, namespace: dict[str, Any]) -> Any:
"""Apply a single pipe filter segment to *value*.
@@ -647,7 +682,7 @@ def _evaluate_simple_expression(expr: str, namespace: dict[str, Any]) -> Any:
return None
# List literal (simple)
- if expr.startswith("[") and expr.endswith("]"):
+ if _is_single_list_literal(expr):
inner = expr[1:-1].strip()
if not inner:
return []
diff --git a/tests/test_workflows.py b/tests/test_workflows.py
index 771e34afb..e559e14a3 100644
--- a/tests/test_workflows.py
+++ b/tests/test_workflows.py
@@ -416,6 +416,29 @@ class TestExpressions:
# …but an intentional empty-string element is still preserved.
assert evaluate_expression("{{ ['', 'a'] }}", ctx) == ["", "a"]
+ def test_list_literal_followed_by_index_is_not_misparsed_as_one_literal(self):
+ """A list literal immediately followed by an index suffix, e.g.
+ ``[1,2,3][1]``, both starts with ``[`` and ends with ``]`` -- the
+ same shape as a genuine single list literal. Naively stripping the
+ outer brackets from ``[1,2,3][1]`` yields ``1,2,3][1``, which then
+ silently evaluates to ``[1, 2, None]`` instead of raising or
+ resolving the index. It must not be misclassified as one literal;
+ falling through to unresolvable (``None``) is safe, unlike silently
+ returning a wrong-looking list.
+ """
+ from specify_cli.workflows.expressions import evaluate_expression
+ from specify_cli.workflows.base import StepContext
+
+ ctx = StepContext()
+ assert evaluate_expression("{{ [1,2,3][1] }}", ctx) is None
+ assert evaluate_expression("{{ [1,2][0] }}", ctx) is None
+ # Genuine list literals -- including ones a bracket-depth scan must
+ # still recognize as ending exactly at the final character -- are
+ # unaffected.
+ assert evaluate_expression("{{ [1, 2, 3] }}", ctx) == [1, 2, 3]
+ assert evaluate_expression("{{ [[1, 2], 3] }}", ctx) == [[1, 2], 3]
+ assert evaluate_expression("{{ ['a]', 'b'] }}", ctx) == ["a]", "b"]
+
def test_operator_splitting_is_quote_aware(self):
from specify_cli.workflows.expressions import (
evaluate_condition,