[brettheap]

Lane: openreposhape-5 (openRepoShape-5)
Claim: #249 (comment)
Claim: #250 (comment)

What

The reader (scripts/repo_shape.py). It now has one rule for where a quoted scalar starts and one for where it ends. That replaces three separate toggles and a first-and-last-character test.

• _unquoted(text, flow=False) yields each character that no quoted scalar holds. A quote opens a quoted scalar only where a scalar begins: at the start of the text, or after - , : , [, {, or a , inside a flow, with any spaces after each. Anywhere else (it's, a"b) the quote is an ordinary character of a plain scalar. On a block line, a , or [ in the middle of a plain scalar is not structure either, so k: a, 'b # c' is the plain scalar a, 'b followed by a comment, which is how YAML reads it.
• _quote_end(text, start) decides where the scalar ends: at a " that no backslash escapes, or a ' that is not doubled.
• _strip_comment, _split_key and _split_flow read structure through _unquoted, so all three agree (scripts/repo_shape.py treats a quote character in the MIDDLE of a plain scalar as opening a quote, so k: [it's, a] reads ["it's, a"] where its block twin reads ["it's", "a"], k: it's fine # note keeps the comment in the value, and #244 turns k: [a"b\", c] from right (by accident) into one item #249).
• _scalar hands any text that begins with a quote to the new _quoted_scalar. The whole text must be one quoted scalar, or it raises quoted scalar without a closing quote: … or quoted scalar with text after its closing quote: … (scripts/repo_shape.py _scalar takes any text that starts and ends with a quote for a quoted scalar and anything else for plain text, so an unterminated "abc reads as "abc, - "a\" reads as a\, and "a" b "c" reads as a" b "c, where PyYAML refuses each #250). load_yaml turns either into REFUSED yaml-unparsable.
• _unquote_key sends every key that begins with a quote through _scalar, so "a" b: 1 is refused instead of becoming the key "a" b.
• _split_key refuses a [ or { later in a key, by name (see "Why _split_key refuses a bracket later in a key" below). A [ or { that opens the text still makes a flow item.
• One paragraph is added to the reader's header comment. _split_key_flow, _flow, _flow_value, _tokenise and _parse_* are untouched; scripts/repo_shape.py reads ? a: b in a flow mapping as the literal key ? a, where the block reader refuses explicit keys, and refuses {a: } and {a:} as not a flow collection: '' instead of reading {'a': None} #252 and scripts/repo_shape.py: the double-quoted reader that #247 adds (fix/adopt-plan-linebreak-names, not yet on main) resolves \x00 inside a block-scalar KEY, and _parse_mapping splits the NUL-joined sentinel record, so "a\x00b": | reads as the key a with the body b<NUL>text where main reads the literal key a\x00b #248 work in those and have landed.

The template renderer (scripts/shape_materialize.py render). In a .yaml/.yml template, a value that sits between double quotes ("{{ELECTED_BY}}") is now spelled by double_quoted. That is the writer this reader takes back unchanged. For any value with no quote, no backslash and no character str.isprintable refuses, double_quoted returns the value itself between quotes. So commits, digests, dates and ordinary names (O'Brien & Co: #1 [draft] {x} é 日本 😀 included) render byte for byte as before in all 19 templated files, and README/AGENTS templates keep raw values. A name that holds a character str.isprintable refuses (a no-break space, U+3000, the ideographic space common in Japanese names, a zero-width joiner in an emoji sequence, or a soft hyphen) now renders as an escape in project.yaml, family.yaml and single-repository.yaml (山田\u3000太郎), and reads back equal. It is the same rule the adoption plan writer already follows.

Why

The two issues' tables, read with each tree's own reader (issue_tables.py). Every head result matches PyYAML 6.0.3:

document	150c41d	head
k: [it's, a]	["it's, a"]	["it's", "a"]
k: {a: it's, b: 1}	{"a": "it's, b: 1"}	{"a": "it's", "b": 1}
k: it's fine # note	"it's fine # note"	"it's fine"
k: [it's, a] # note	refused: not a flow collection	["it's", "a"]
it's: 1	refused: expected key: value	{"it's": 1}
k: [a"b, c]	['a"b, c']	['a"b', 'c']
k: [a"b\", c]	['a"b\\", c']	['a"b\\"', 'c']
created_by: "Brett Heap	'"Brett Heap'	refused: no closing quote
k:\n - "a\"	['a\\']	refused: no closing quote
k: "a" b "c"	'a" b "c'	refused: text after its closing quote
k: 'a' b 'c'	"a' b 'c"	refused: text after its closing quote
k: ["a\", b]	['"a\\", b']	refused: no closing quote

The other five #250 rows (k: "abc, k: "a\", b, k: "a"b, k: 'abc, k: ["a, b]) are refused on head the same way.

Why _split_key refuses a bracket later in a key. _split_key has always returned None for any [ or { ("a flow collection is not a key in this subset"). On 150c41d a quote toggle hid the bracket whenever the key held a quote pair, so note "[1]": x was a mapping entry by accident. Reading quotes only where a scalar begins lets that rule see the bracket. As a mapping entry that would be a refusal, but _parse_sequence takes None to mean "a scalar item", so - note "[1]": x would have read as the string note "[1]": x where YAML has a mapping: a silent misread of valid YAML. Review found it (20 of the 300 documents that regressed on one fuzz seed read that way), so the rule is now in two parts. A [ or { that OPENS the text still returns None, so - [a, b] and - {a: b} stay flow items. One LATER in the key, before its : , raises a key holding [or{ is not supported: <key>.

document	150c41d	head	PyYAML
- note "[1]": x	[{'note "[1]"': 'x'}]	refused, names the key	[{'note "[1]"': 'x'}]
note "[1]": x	{'note "[1]"': 'x'}	refused, names the key	{'note "[1]"': 'x'}
- a[b]: c	['a[b]: c'], a string	refused, names the key	[{'a[b]': 'c'}]
a[b]: c	refused: expected key: value	refused, names the key	{'a[b]': 'c'}
k:\n - a{b}: c	{'k': ['a{b}: c']}, a string	refused, names the key	{'k': [{'a{b}': 'c'}]}
k: {a[b]: c}	refused: flow mapping entry without a key	refused, names the key	refused
- [a, b], - {a: b}	flow items	flow items	flow items

So the bracket-in-key class is now refusals, not silent misreads, and the refusal covers 150c41d's own silent misread of - a[b]: c too. The class is narrow in practice: no writer in this tree can emit such a key (the adoption plan and manifest writers write literal keys and put free text in values), so only a hand edit of a fixed schema reaches it. Reading a[b]: c as YAML does (the key a[b]) would mean telling a block key from a flow-entry key, which is _split_key_flow's business (#252's function); accepting a mid-key bracket in _split_key alone newly reads 6,521 more invalid documents on one seed. That stays a follow-up (see Left out).

Why the renderer had to change as well. render pasted free text raw between a template's double quotes. So scaffold-project.py --elected-by 'Robert "Bob" Smith' wrote elected_by: "Robert "Bob" Smith", which is not YAML. The old reader read it correctly by accident. With the reader fix alone, the scaffold would create and push all three repositories and then write a manifest its own validator refuses. A mutant of this branch without the renderer change shows exactly that: three bare remotes exist, then REFUSED yaml-unparsable: …/project.yaml: quoted scalar with text after its closing quote: '"Atlas "the" Project"'. On 150c41d some values were already misread rather than refused: --reference 'docs\notes # 1' reads back as docs, a line feed and otes # 1. I rendered every quoting template with 11 free-text values through each tree's own render and reader (render_real.py). On 150c41d 64 of 88 read back exactly. On head all 88 do. The other free-text placeholders that reach render are --name, --reference, family.py --created-by/--name, and the adoption plan's elected_by/reference. All three writers (scaffold, adopt execute, family.py init) render through this one function, and none pre-escapes, so nothing is escaped twice. Nothing in the tree digests or re-renders a templated file: shape-pin files: rows digest only the verbatim and from-shape copies.

Test expectations changed on purpose

• tests/test_yaml_flow_quotes.py, DANGLING_BACKSLASH_BEFORE_THE_CLOSER (scripts/repo_shape.py _split_flow ignores a backslash inside a double-quoted flow item, so pins: ["x\",y"] reads back as two items x\ and y" where the same text as a block sequence item reads as the one item x",y #213's review, N5). These four rows pinned the plain-text read of a double-quoted flow item whose last character is a backslash (k: ["a\] read as ['"a\\']), and their block twins reading the same. The table's own comment said that if a later change refused an unterminated double-quoted scalar, "these become refusals together with their block twins, and that is the change to make here, not a regression". They are now refusals, with their twins. The test is renamed …_is_refused_with_its_twin and its docstring updated. Two sentences of the module docstring that described the old toggle are reworded.
• No test pinned a "quote in a plain item" read. The single-quoted toggle rows (['x\', 'it''s, a]'], {'a\': 'it''s: b'}) read exactly as before, and their test is unchanged.

Evidence

• New tests. The three files below hold 157 cases:

  • tests/test_yaml_quote_boundaries.py, 73 cases: scripts/repo_shape.py treats a quote character in the MIDDLE of a plain scalar as opening a quote, so k: [it's, a] reads ["it's, a"] where its block twin reads ["it's", "a"], k: it's fine # note keeps the comment in the value, and #244 turns k: [a"b\", c] from right (by accident) into one item #249's rows and their neighbours, scripts/repo_shape.py _scalar takes any text that starts and ends with a quote for a quoted scalar and anything else for plain text, so an unterminated "abc reads as "abc, - "a\" reads as a\, and "a" b "c" reads as a" b "c, where PyYAML refuses each #250's rows plus key, flow-mapping and no-space-comment forms, rows that must not change, a double_quoted round trip beside a plain quote, a load_yaml refusal, and the bracket-in-a-key rows (eight refused by name, the message quoting the key, a file read through load_yaml, seven flow items and values that must still read). Two rows pin that a : with no space after it opens no quoted scalar: k: [a:'b, c'] reads as the two items a:'b and c', and k: a:'b # c' as a:'b.
  • tests/test_template_quoted_values.py, 67 cases: every quoting template times 7 free-text values, byte identity for ordinary values, raw values in a Markdown template, and one real scaffold into local bare remotes.
  • tests/test_yaml_flow_quotes.py, 17 cases, of which the four N5 rows changed.

  Every expectation was checked against PyYAML 6.0.3. They disagree on eight documents, and the subset refuses each on purpose. One is k: "a"#c: PyYAML reads a, but YAML requires a space before a comment, so the subset refuses it rather than guess. The other seven are new bracket-in-key rows, which PyYAML reads as a mapping whose key holds a bracket, and which the subset refuses by name. The module docstring of tests/test_yaml_quote_boundaries.py still names only the first; re-verification counted all eight.

• Fail on 150c41d. With the three files copied onto 150c41d, 77 of the 157 cases fail (48 of 73, 25 of 67, 4 of 17) and 80 pass; all 157 pass on head. The 80 that pass are guards, and free text that 150c41d reads by accident. Of the bracket-in-a-key rows, all ten refusal rows fail on 150c41d and the seven flow-item guards pass on both.

• Mutations. Each of the following makes at least one new test fail: each changed function reverted to its 150c41d body (_strip_comment 5, _split_key 9, _unquote_key 1, _scalar 21, _split_flow 14), each rule of the new helpers mutated (comma outside a flow 2, bracket mid-scalar 1, - 2, : 22, '' 6, backslash 31, text after the close 6, unclosed read as plain 15, unclosed as an ordinary character 1), and each part of the bracket rule (no raise, the start-of-text test inverted, a bracket always None, the flag never set: 10 to 12 each). A : that opens a quoted scalar with no space after it fails 2, the two rows above; review found it surviving the earlier tests. Removing the renderer change fails 41, including the real scaffold. Escaping Markdown templates too fails 1. The mutants that survive change nothing on any valid document, as review showed: the header comment; .yml dropped from render (both .yml templates are verbatim copies and never rendered); _strip_comment's i == 0 branch (unreachable, _significant_text drops a whole-line comment first); ]/} no longer closing a block-line flow; and a tab after : or - (PyYAML refuses those documents itself).

• Reach. All 14 tracked YAML files read identically on 150c41d and head, both raw (7 ok; 7 templates refuse identically on their raw block placeholders) and with {{X}} rendered to bare words, and again identically between this branch with and without the bracket refusal. Nothing this repository writes holds a quote in a plain scalar, a bracket in a key, an unclosed quoted scalar, or text after a closing quote:

  • adopt-project.py y() (the adoption plan, and shape-doctor.py's placement plan) writes plain only for values matching _PLAIN_RE, and spells everything else with double_quoted. Its keys are literals, and plan paths are values.
  • The pin writers (bump-leg.py, update-shape.py, family.py, and the shape pin's files: rows) quote only hex.
  • family.py's member rows and every unquoted template value pass checked_value/naming-policy alphabets, which hold no quote.
  • The one writer that could emit the scripts/repo_shape.py _scalar takes any text that starts and ends with a quote for a quoted scalar and anything else for plain text, so an unterminated "abc reads as "abc, - "a\" reads as a\, and "a" b "c" reads as a" b "c, where PyYAML refuses each #250 construct was render's quoted placeholders. That is fixed above.

• Differential fuzz. PyYAML 6.0.3 as the oracle only.

  • Raw text in all six contexts (flow sequence, flow mapping, value, item, key, nested item; seed 2490250; 785,646 documents, 305,393 valid), this branch against current main (c3f4987):
    • 13,752 valid documents are fixed.
    • 768 valid documents regress, and every one is a refusal, with the new message: none reads as a string. Every one has a [ or { in a key. Before the refusal, against 150c41d, the same 768 were 694 refusals and 74 reads as a string.
    • 73,380 invalid documents that main read are now refused, and 5,955 that main refused are now read: 5,154 are a plain scalar that begins with a flow indicator in a key (,": v; main reads the quote-free twin too, follow-up 3), 775 are a flow mapping with a stray closer and an empty value (k: {a"]:}; main refused only because its quote toggle swallowed the :}, and reads the twin k: {a]x:} the same way, a composition with scripts/repo_shape.py reads ? a: b in a flow mapping as the literal key ? a, where the block reader refuses explicit keys, and refuses {a: } and {a:} as not a flow collection: '' instead of reading {'a': None} #252's empty value, follow-up 2), and 26 are in other contexts.
    • 0 crashes.
  • The refusal alone, seed 7249250 (70,941 inputs, 425,646 documents), against main c3f4987, this branch before and after it. Regressions: 300, of which 280 refused and 20 silently read before; 300 refused and 0 read after. Fixed: 7,199 both. Invalid documents newly read: 3,560 both. Misreads of valid documents that become refusals: 538 before, 2,088 after, so 1,550 more, - a[b]: c among them. 0 crashes.
  • Flow against block, on the merged reader: seed 2490251, 100,000 documents, 0 wrong in the flow form, 0 in its block twin, 0 where they differ; seed 2490252 with the adopt-project.py plan writes a plan its own loader cannot parse when a source name holds a line break (the macOS Icon\r file), so check refuses the whole plan as yaml-unparsable with no entry to edit #199 code points, 60,000 documents, 0 wrong, 0 wrong, 0 differing. (Earlier, on the uncommitted first version: seeds 2130213 and 1990213, 0 wrong in either form; review re-ran two more seeds on 21fc213, 0 wrong.)
  • double_quoted round trip (seed 19913, 40,000 strings in 5 positions, 0 mismatches) and scripts/repo_shape.py treats a quote character in the MIDDLE of a plain scalar as opening a quote, so k: [it's, a] reads ["it's, a"] where its block twin reads ["it's", "a"], k: it's fine # note keeps the comment in the value, and #244 turns k: [a"b\", c] from right (by accident) into one item #249's class densely (seed 2130213, 50,000 valid documents; 150c41d reads 19,949 wrong, head reads 0 wrong) were run on the first version, and the review re-ran the round trip on 21fc213 (seed 4925049, 30,000 strings, 0 mismatches). Neither touches _split_key's new rule, and they were not re-run on the merged head.

• Targeted runs (git-filter-repo 2.47.0 on PATH). The five streams below ran on b764657, the head before the last merge of origin/main. That merge (60588d5, scaffold-project.py --referent-chain writes each middle link into project.yaml as typed (naming_block, scripts/shape_materialize.py:1010-1011) and checks none, so a link holding # scaffolds all three repositories, exits 0, and pushes a manifest the project's own validators refuse as yaml-unparsable, and a link holding ' or ] is recorded as a different chain #251 and a family.py change) touched neither repo_shape.py nor render, so on the pushed head b72ab0f I re-ran the four reader files (187 passed) and test_scaffold_referent_chain_links, test_template_quoted_values, test_cli_reference and test_yaml_quote_boundaries (197 passed).

  • The three new or changed files, test_yaml_flow_mappings, test_yaml_block_scalar_keys, test_load_yaml_refusals, test_adopt_plan_escapes, test_manifest_validator, test_pin_validator, test_neutral_pin_validator, test_repo_hygiene, test_cli_reference and test_adopt_plan: 512 passed, 1 skipped (test_adopt_plan.py:393, SHAPE_MEDXEHR_CLONE unset).
  • The four reader files alone (test_yaml_quote_boundaries, test_yaml_block_scalar_keys, test_yaml_flow_quotes, test_yaml_flow_mappings): 187 passed.
  • test_shape_doctor: 191 passed.
  • The renderer's callers, test_scaffold_e2e, test_scaffold_pin_and_reuse, test_reference_default, test_family, test_windows_paths, test_naming_policy: 366 passed.
  • test_adopt_e2e, test_adopt_spec_only, test_update_shape: 110 passed.
  • Review also ran, on 21fc213: test_shape_advisory, test_bump_leg, test_reuse_visibility, test_update_shape_add, test_scaffold_ignored_shape_files (97 passed) and test_adopt_submodules (132 passed). They were not re-run on the merged head.

Composition

This branch carries origin/main at 60588d5, by four merges (eb6df75, c3f4987, 5751460, 60588d5). Only the first conflicted, in one hunk of a comment: both this branch and #252 (landed as 4b2add8) add a paragraph to the reader's header comment right after "confident tone.". Both paragraphs are kept, this branch's first, with a # line between them. Every code hunk merged by itself, including #252's _split_key_flow, which calls this branch's _split_key, and shape_materialize.py. The merges of #248 (c3f4987, a block scalar's record as a pair), of #251 (23e16ae) and of the two others were clean. repo_shape.py is the same file after the last three merges as after the second. On the merged reader, test_yaml_flow_mappings, test_yaml_block_scalar_keys and test_scaffold_referent_chain_links pass beside this branch's files (see Evidence).

git merge-tree --write-tree of the head against origin/main: clean. Against another lane's open PR:

• scaffold-project.py: a leg path the project's own YAML reader would read back as another type (null, ~, true, False, 2026, 1.5) is refused before anything is created, under --dry-run alike, through the one definition adopt-project.py asks, so --spec-path 2026 no longer creates three repositories whose first bootstrap fails manifest-leg-path, and adopt-project.py execute no longer says adoption verified before that bootstrap fails (#225) #266 (fix/leg-path-yaml-scalars) conflicts in one place: the from repo_shape import (…) block of scripts/shape_materialize.py, where this branch adds double_quoted and scaffold-project.py: a leg path the project's own YAML reader would read back as another type (null, ~, true, False, 2026, 1.5) is refused before anything is created, under --dry-run alike, through the one definition adopt-project.py asks, so --spec-path 2026 no longer creates three repositories whose first bootstrap fails manifest-leg-path, and adopt-project.py execute no longer says adoption verified before that bootstrap fails (#225) #266 adds parse_yaml. Whichever lands second resolves it as double_quoted, file_sha256, parse_yaml,. There is no semantic interaction: a leg path is an unquoted template value, and SAFE_PATH_RE admits no quote.

Left out

• Reading a [ or { inside a plain block key as YAML does. a[b]: c and - a[b]: c are refused by name here; YAML reads the key a[b]. Reading them needs block keys and flow-entry keys told apart (_split_key_flow's business), and must refuse only a block key that BEGINS with [ or {. A first try that accepted a mid-key bracket in _split_key alone fixed all 300 regressions on one seed, but newly read 6,521 more invalid documents (keys beginning ] or }, and {a[b]: c} entries). Candidate follow-up.
• A plain flow item followed by a nested flow, and unbalanced brackets. k: [x [a, b]] reads as the one scalar x [a, b], and k: {a:}#}: b} reads {'a:}#}': 'b'}, because _flow checks only a body's ends. PyYAML refuses both. Candidate follow-up.
• Implicit single-pair mappings in a flow sequence. [k: v] still reads as the string 'k: v', as scripts/repo_shape.py _split_flow ignores a backslash inside a double-quoted flow item, so pins: ["x\",y"] reads back as two items x\ and y" where the same text as a block sequence item reads as the one item x",y #213's review (F4) found.
• Not supported, by choice. A quoted scalar spanning lines is outside the subset, and 150c41d did not always refuse it. When the continuation line was indented deeper, it was refused as unexpected indentation. When the continuation sat at the parent's column, it was MISREAD: k: "a then b: c" read as {'k': '"a', 'b': 'c"'}, and - 'a then - b' as ["'a", "b'"]. Every such form is now refused at its first line, naming the unclosed scalar. k: "a"#c is refused too, as explained above.
• Not run: the full suite, and the macOS and Windows CI legs. The new tests write their files as bytes, pass no text to git's stdin, and pass the scaffold its arguments as a list.

Closes #249
Closes #250

🤖 Generated with Claude Code

[brettheap]

(lane openRepoShape-5, 2026-10-11T23:46Z) @codex review

[sourcery-ai]

Sorry @brettheap, you've used your own review budget of 250,000 diff characters for the last 7 days.

You can request another review in 1 day and 13 hours by commenting @sourcery-ai review. Upgrade to get a review now.

[chatgpt-codex-connector]

You have reached your Codex usage limits for code reviews. You can see your limits in the Codex usage dashboard.
To continue using code reviews, you can upgrade your account or add credits to your account and enable them for code reviews in your settings.

[sourcery-ai]

Reviewer's Guide

The PR replaces inconsistent quote toggles with shared YAML scalar-boundary parsing, explicitly refuses malformed or unsupported constructs instead of silently misreading them, and updates YAML template rendering to escape free-text values so generated files round-trip correctly.

Sequence diagram for safe YAML template rendering

sequenceDiagram
    participant Caller
    participant Render as render
    participant Quoted as double_quoted
    participant File as YAML file
    participant Reader as load_yaml
    Caller->>Render: render(text, values, source)
    alt source is .yaml or .yml
        Render->>Quoted: double_quoted(value)
        Quoted-->>Render: escaped YAML scalar
    else other template
        Render->>Render: replace placeholder with raw value
    end
    Render->>File: write rendered template
    File->>Reader: load_yaml
    Reader-->>Caller: original value or REFUSED yaml-unparsable

Loading

Flow diagram for YAML scalar boundary parsing

flowchart TD
    Input["YAML text"] --> Unquoted["_unquoted"]
    Unquoted --> Start{"Quote at scalar start?"}
    Start -->|No| Plain["Treat quote as plain-scalar text"]
    Start -->|Yes| End["_quote_end"]
    End -->|Closed| Structure["Expose comments, keys, and flow delimiters"]
    End -->|Unclosed| Refuse["YamlError: quoted scalar without a closing quote"]
    Structure --> Consumers["_strip_comment / _split_key / _split_flow"]
    Consumers --> Scalar["_scalar → _quoted_scalar"]
    Scalar -->|Trailing text| RefuseTrailing["YamlError: text after closing quote"]

Loading

Flow diagram for refusing unsupported key brackets

flowchart TD
    Text["Mapping text"] --> Split["_split_key"]
    Split --> Scan["Scan structure via _unquoted"]
    Scan --> Opening{"[` or `{` at text start?"}
    Opening -->|Yes| FlowItem["Return None: flow item"]
    Opening -->|No| MidKey["Bracket occurs before key separator"]
    MidKey --> Refuse["YamlError: key holding bracket is not supported"]
    Scan --> Separator["Find top-level `: `"]
    Separator --> Pair["Return key/value pair"]

Loading

File-Level Changes

Change	Details	Files
Unified quoted-scalar boundary detection across YAML structure parsing.	Added _quote_end to recognize escaped double quotes and doubled single quotes. Added _unquoted as the shared source of structural characters for comments, keys, and flow splitting. Treats quotes in plain scalars as ordinary characters while opening quotes only at scalar boundaries. Refuses unclosed quoted scalars and text after a quoted scalar's closing quote. Routes quoted keys through scalar validation and refuses unsupported mid-key brackets/braces.	scripts/repo_shape.py
Made YAML template rendering safely round-trip arbitrary quoted free-text values.	Uses double_quoted for values substituted into double-quoted YAML placeholders. Preserves raw substitution for non-YAML templates and ordinary values that need no escaping. Ensures generated manifests remain readable after quotes, backslashes, comments, and non-printable characters are supplied.	scripts/shape_materialize.py
Added comprehensive regression coverage for quote boundaries, refusals, and renderer round trips.	Added cases for flow/block consistency, comments, escaped and doubled quotes, malformed scalars, and bracket-in-key refusals. Added template coverage across YAML and Markdown templates, including an end-to-end local scaffold. Updated dangling-backslash flow tests to expect explicit YAML refusals.	tests/test_yaml_quote_boundaries.py tests/test_template_quoted_values.py tests/test_yaml_flow_quotes.py

Assessment against linked issues

Issue	Objective	Addressed	Explanation
#249	Make quote characters open quoted scalars only at the beginning of a scalar, while treating quotes in the middle of plain scalars as ordinary text consistently in comments, keys, flow mappings, and flow sequences.	✅
#249	Ensure the affected inputs are parsed like their block-form equivalents, including separating k: [it's, a], preserving keys such as it's, removing trailing comments from values such as it's fine # note, and correctly splitting a"b\ flow items.	✅
#249	Reject malformed quoted scalars rather than silently misreading them, and preserve reader/writer round trips for quoted template values.	✅
#250	Make the YAML reader recognize quoted scalars based on an actual valid closing quote, including escaped double quotes and doubled single quotes, and refuse unterminated scalars or text following the closing quote with YamlError.	✅
#250	Apply the quoted-scalar boundary rules consistently in block values, flow collections, keys, and comment/key splitting so malformed inputs such as escaped closing quotes, trailing text, and quoted scalars followed by content are refused rather than silently misread.	✅
#250	Preserve valid YAML behavior and writer/reader round trips while adding regression coverage for the issue's examples, including flow-versus-block consistency and the tracked YAML/template paths.	✅

Possibly linked issues

• scripts/repo_shape.py treats a quote character in the MIDDLE of a plain scalar as opening a quote, so k: [it's, a] reads ["it's, a"] where its block twin reads ["it's", "a"], k: it's fine # note keeps the comment in the value, and #244 turns k: [a"b\", c] from right (by accident) into one item #249: PR directly fixes the reported quote-boundary bugs and adds coverage for all documented examples, including the escaped-quote case.

---

Tips and commands

Interacting with Sourcery

• Trigger a new review: Comment @sourcery-ai review on the pull request.
• Continue discussions: Reply directly to Sourcery's review comments.
• Generate a GitHub issue from a review comment: Ask Sourcery to create an
  issue from a review comment by replying to it. You can also reply to a
  review comment with @sourcery-ai issue to create an issue from it.
• Generate a pull request title: Write @sourcery-ai anywhere in the pull
  request title to generate a title at any time. You can also comment
  @sourcery-ai title on the pull request to (re-)generate the title at any time.
• Generate a pull request summary: Write @sourcery-ai summary anywhere in
  the pull request body to generate a PR summary at any time exactly where you
  want it. You can also comment @sourcery-ai summary on the pull request to
  (re-)generate the summary at any time.
• Generate reviewer's guide: Comment @sourcery-ai guide on the pull
  request to (re-)generate the reviewer's guide at any time.
• Resolve all Sourcery comments: Comment @sourcery-ai resolve on the
  pull request to resolve all Sourcery comments. Useful if you've already
  addressed all the comments and don't want to see them anymore.
• Dismiss all Sourcery reviews: Comment @sourcery-ai dismiss on the pull
  request to dismiss all existing Sourcery reviews. Especially useful if you
  want to start fresh with a new review - don't forget to comment
  @sourcery-ai review to trigger a new review!

Customizing Your Experience

Access your dashboard to:

• Enable or disable review features such as the Sourcery-generated pull request
  summary, the reviewer's guide, and others.
• Change the review language.
• Add, remove or edit custom review instructions.
• Adjust other review settings.

Getting Help

• Contact our support team for questions or feedback.
• Visit our documentation for detailed guides and information.
• Keep in touch with the Sourcery team by following us on X/Twitter, LinkedIn or GitHub.

[sonarqubecloud]

Quality Gate passed

Issues
1 New issue
0 Accepted issues

Measures
0 Security Hotspots
0.0% Coverage on New Code
0.0% Duplication on New Code

See analysis details on SonarQube Cloud