Merge PR #690: refactor(rename): export NormalizedLabel/RefDefBracketBytes, remove lsp duplicates

Author: merge-queue-bot

PLAN.md

@@ -227,5 +227,5 @@ footer: |
 | 2606240211 | ✅     | sonnet | [Add dedicated unit tests for locate.go helpers](plan/2606240211_arch-fix-locate-helper-tests.md)                                       |
 | 2606240212 | 🔲     | sonnet | [Add dedicated unit tests for lsp/rename.go helpers](plan/2606240212_arch-fix-lsp-rename-helper-tests.md)                               |
 | 2606240213 | 🔲     | sonnet | [Add dedicated unit tests for export.go helpers and two small rename helpers](plan/2606240213_arch-fix-export-helper-tests.md)          |
-| 2606240214 | 🔲     | sonnet | [Remove duplicated helpers between lsp/rename.go and rename/rename.go](plan/2606240214_arch-fix-rename-dedup.md)                        |
+| 2606240214 | ✅     | sonnet | [Remove duplicated helpers between lsp/rename.go and rename/rename.go](plan/2606240214_arch-fix-rename-dedup.md)                        |
 <?/catalog?>

cmd/mdsmith/rename.go

@@ -244,7 +244,7 @@ func computeRenameChanges(
 		}
 		return changes, -1
 	}
-	edits, err := rename.LinkRef(src, rename.NormalizeLabel(oldName), newName)
+	edits, err := rename.LinkRef(src, oldName, newName)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "mdsmith: %v\n", err)
 		return nil, 2

internal/lsp/rename.go

@@ -8,7 +8,6 @@ import (
 	"github.com/jeduden/mdsmith/internal/index"
 	"github.com/jeduden/mdsmith/internal/mdtext"
 	"github.com/jeduden/mdsmith/internal/rename"
-	"github.com/jeduden/mdsmith/pkg/goldmark/util"
 )
 
 // handlePrepareRename answers textDocument/prepareRename. The
@@ -225,7 +224,7 @@ func refDefPrepareRange(source []byte, line int, _ string) (prepareRenameResult,
 		return prepareRenameResult{}, false
 	}
 	row := lines[line-1]
-	m := refDefBracketBytes(row)
+	m := rename.RefDefBracketBytes(row)
 	if m == nil {
 		return prepareRenameResult{}, false
 	}
@@ -240,35 +239,6 @@ func refDefPrepareRange(source []byte, line int, _ string) (prepareRenameResult,
 	}, true
 }
 
-// refDefBracketBytes returns the [start, end) byte offsets of the
-// label inside a CommonMark reference-definition line, or nil when
-// row is not a reference definition.
-func refDefBracketBytes(row []byte) []int {
-	i := 0
-	for i < len(row) && i < 3 && row[i] == ' ' {
-		i++
-	}
-	if i >= len(row) || row[i] != '[' {
-		return nil
-	}
-	open := i + 1
-	closeIdx := -1
-	for j := open; j < len(row); j++ {
-		if row[j] == ']' {
-			closeIdx = j
-			break
-		}
-	}
-	if closeIdx < 0 || closeIdx == open {
-		return nil
-	}
-	// After `]` we need `:` to qualify as a definition.
-	if closeIdx+1 >= len(row) || row[closeIdx+1] != ':' {
-		return nil
-	}
-	return []int{open, closeIdx}
-}
-
 // refUsePrepareRange builds the rename range for a reference-style
 // link use (`[text][label]`, `[label][]`, or `[label]`). The cursor
 // position determines whether the user is editing the label or the
@@ -319,7 +289,7 @@ func refUseLabelBytes(row []byte, cursorByte int, label string) (int, int, bool)
 			return start, end, true
 		}
 		// Shortcut `[label]`: this pair's content normalizes to label.
-		if normalizedLabel(row[pr.open+1:pr.close]) == label {
+		if rename.NormalizedLabel(row[pr.open+1:pr.close]) == label {
 			return pr.open + 1, pr.close, true
 		}
 	}
@@ -340,10 +310,10 @@ func matchLeadingPair(row []byte, pairs []bracketPair, i int, label string) (int
 	if next.open != pr.close+1 {
 		return 0, 0, false
 	}
-	if normalizedLabel(row[next.open+1:next.close]) == label {
+	if rename.NormalizedLabel(row[next.open+1:next.close]) == label {
 		return next.open + 1, next.close, true
 	}
-	if next.close == next.open+1 && normalizedLabel(row[pr.open+1:pr.close]) == label {
+	if next.close == next.open+1 && rename.NormalizedLabel(row[pr.open+1:pr.close]) == label {
 		return pr.open + 1, pr.close, true
 	}
 	return 0, 0, false
@@ -363,19 +333,15 @@ func matchTrailingPair(row []byte, pairs []bracketPair, i int, label string) (in
 	if prev.close+1 != pr.open {
 		return 0, 0, false
 	}
-	if pr.close == pr.open+1 && normalizedLabel(row[prev.open+1:prev.close]) == label {
+	if pr.close == pr.open+1 && rename.NormalizedLabel(row[prev.open+1:prev.close]) == label {
 		return prev.open + 1, prev.close, true
 	}
-	if normalizedLabel(row[pr.open+1:pr.close]) == label {
+	if rename.NormalizedLabel(row[pr.open+1:pr.close]) == label {
 		return pr.open + 1, pr.close, true
 	}
 	return 0, 0, false
 }
 
-func normalizedLabel(b []byte) string {
-	return string(util.ToLinkReference(b))
-}
-
 // bracketPairs returns every top-level `[` / `]` pair on row, in
 // left-to-right order. The walker is depth-aware: a `[` opens a new
 // nesting level and a `]` closes the innermost open `[`, so a

internal/lsp/rename_coverage_test.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/jeduden/mdsmith/internal/rename"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -199,7 +200,7 @@ func TestRefDefBracketBytesEdgeCases(t *testing.T) {
 		{"    [over]: x", nil}, // 4 leading spaces is over the limit
 	}
 	for _, tc := range cases {
-		got := refDefBracketBytes([]byte(tc.row))
+		got := rename.RefDefBracketBytes([]byte(tc.row))
 		assert.Equal(t, tc.want, got, "row=%q", tc.row)
 	}
 }

internal/rename/heading.go

@@ -135,15 +135,6 @@ func FindHeadingLine(source []byte, headingText string) (int, bool) {
 	return 0, false
 }
 
-// NormalizeLabel collapses a link-reference label to its canonical
-// matching form (lowercased, whitespace-collapsed), the same
-// normalization LinkRef expects its oldLabel argument in. The CLI
-// normalizes `--link-ref oldlabel` through this before calling
-// LinkRef.
-func NormalizeLabel(s string) string {
-	return normalizedLabel([]byte(s))
-}
-
 // firstControlRune returns the first newline / carriage return in s,
 // or 0 when s is a single line. Heading text and link-ref labels are
 // single-line surfaces; a control rune would rewrite them into

internal/rename/heading_test.go

@@ -218,11 +218,6 @@ func TestFindHeadingLine(t *testing.T) {
 	assert.False(t, ok)
 }
 
-func TestNormalizeLabel(t *testing.T) {
-	assert.Equal(t, "docs api", NormalizeLabel("Docs  API"))
-	assert.Equal(t, "x", NormalizeLabel("X"))
-}
-
 func TestFirstControlRune(t *testing.T) {
 	assert.Equal(t, '\r', firstControlRune("a\rb"))
 	assert.Equal(t, rune(0), firstControlRune("clean"))

internal/rename/helpers_test.go

@@ -32,7 +32,7 @@ func TestRefDefBracketBytes(t *testing.T) {
 	}
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
-			assert.Equal(t, tc.want, refDefBracketBytes([]byte(tc.row)))
+			assert.Equal(t, tc.want, RefDefBracketBytes([]byte(tc.row)))
 		})
 	}
 }

internal/rename/rename.go

@@ -62,14 +62,17 @@ func (e LabelConflictError) Error() string {
 }
 
 // LinkRef computes the in-file edits that rename a link-reference
-// label from oldLabel (already normalized via util.ToLinkReference)
-// to newName. The rewrite is file-local: the `[label]: url`
-// definition plus every `[text][label]` and shortcut `[label]` use.
+// label from oldLabel to newName. The rewrite is file-local: the
+// `[label]: url` definition plus every `[text][label]` and shortcut
+// `[label]` use. oldLabel is normalized internally (CommonMark
+// link-label normalization: lowercase, whitespace collapsed) so
+// callers may pass raw label text or a pre-normalized form.
 //
 // Returns ErrEmptyLabel, an InvalidLabelRuneError, or a
 // LabelConflictError without producing any edit when the rename is
 // unsafe, so callers can surface the failure before applying.
 func LinkRef(source []byte, oldLabel, newName string) ([]Edit, error) {
+	oldLabel = NormalizedLabel([]byte(oldLabel))
 	if strings.TrimSpace(newName) == "" {
 		return nil, ErrEmptyLabel
 	}
@@ -80,7 +83,7 @@ func LinkRef(source []byte, oldLabel, newName string) ([]Edit, error) {
 	// → "Docs API") is allowed — it refreshes casing/spacing across
 	// the def and every use. labelConflict matches on the normalized
 	// form so such a rename never collides with itself.
-	newLabel := normalizedLabel([]byte(newName))
+	newLabel := NormalizedLabel([]byte(newName))
 	if conflict := labelConflict(source, oldLabel, newLabel); conflict != "" {
 		return nil, LabelConflictError{Conflict: conflict}
 	}
@@ -124,7 +127,10 @@ func invalidLinkRefRune(s string) rune {
 	return 0
 }
 
-func normalizedLabel(b []byte) string {
+// NormalizedLabel returns the CommonMark-normalized form of a link
+// label — lowercase with internal whitespace collapsed — by delegating
+// to goldmark's util.ToLinkReference.
+func NormalizedLabel(b []byte) string {
 	return string(util.ToLinkReference(b))
 }
 
@@ -173,7 +179,7 @@ func validRefDefMatches(body []byte) []validRefDefMatch {
 			continue
 		}
 		raw := body[m[2]:m[3]]
-		norm := normalizedLabel(raw)
+		norm := NormalizedLabel(raw)
 		out = append(out, validRefDefMatch{
 			bodyLine:  bodyLine,
 			rawLabel:  string(raw),
@@ -246,7 +252,7 @@ func refDefEditsInBody(
 			continue
 		}
 		row := lines[fileLine-1]
-		bracket := refDefBracketBytes(row)
+		bracket := RefDefBracketBytes(row)
 		startCh := mdtext.UTF16FromByteOffset(row, bracket[0])
 		endCh := mdtext.UTF16FromByteOffset(row, bracket[1])
 		out = append(out, Edit{
@@ -276,7 +282,7 @@ func refUseEditsInBody(
 		if !ok || l.Reference == nil {
 			return ast.WalkContinue, nil
 		}
-		if normalizedLabel(l.Reference.Value) != oldLabel {
+		if NormalizedLabel(l.Reference.Value) != oldLabel {
 			return ast.WalkContinue, nil
 		}
 		edit, ok := refUseEdit(l, body, lines, fmOffset, newName, idx)
@@ -376,10 +382,10 @@ func linkTextBounds(l *ast.Link, body []byte) (int, int) {
 	return start, end
 }
 
-// refDefBracketBytes returns the [start, end) byte offsets of the
+// RefDefBracketBytes returns the [start, end) byte offsets of the
 // label inside a CommonMark reference-definition line, or nil when
 // row is not a reference definition.
-func refDefBracketBytes(row []byte) []int {
+func RefDefBracketBytes(row []byte) []int {
 	i := 0
 	for i < len(row) && i < 3 && row[i] == ' ' {
 		i++

internal/rename/rename_test.go

@@ -63,6 +63,15 @@ func TestLinkRef_SameNormalizedFormRefreshesCasing(t *testing.T) {
 	require.Len(t, edits, 2)
 }
 
+func TestLinkRef_NormalizesOldLabel(t *testing.T) {
+	// LinkRef normalizes oldLabel internally, so callers may pass
+	// the raw label text without pre-normalizing it.
+	src := []byte("See [spec].\n\n[spec]: u\n")
+	edits, err := LinkRef(src, "Spec", "rfc")
+	require.NoError(t, err)
+	require.Len(t, edits, 2)
+}
+
 func TestLinkRef_CodeFenceDefNotRewritten(t *testing.T) {
 	src := []byte("Use [spec].\n\n```\n[spec]: fake\n```\n\n[spec]: real\n")
 	edits, err := LinkRef(src, "spec", "rfc")
@@ -124,3 +133,21 @@ func TestLinkRef_NoMatchingLabel(t *testing.T) {
 	require.NoError(t, err)
 	assert.Empty(t, edits)
 }
+
+func TestNormalizedLabel(t *testing.T) {
+	cases := []struct {
+		input string
+		want  string
+	}{
+		{"spec", "spec"},
+		{"Spec", "spec"},
+		{"API Docs", "api docs"},
+		{"API  Docs", "api docs"},
+		{"  leading  ", "leading"},
+	}
+	for _, tc := range cases {
+		t.Run(tc.input, func(t *testing.T) {
+			assert.Equal(t, tc.want, NormalizedLabel([]byte(tc.input)))
+		})
+	}
+}

plan/2606240212_arch-fix-lsp-rename-helper-tests.md

@@ -4,7 +4,7 @@ title: Add dedicated unit tests for lsp/rename.go helpers
 status: "🔲"
 model: sonnet
 summary: >-
-  internal/lsp/rename.go has 15 unexported
+  internal/lsp/rename.go has 13 unexported
   helpers without dedicated unit tests. Add a
   named test for each so the audit policy is
   satisfied.
@@ -13,7 +13,7 @@ summary: >-
 
 ## Goal
 
-Add a named unit test for each of the 15 unexported
+Add a named unit test for each of the 13 unexported
 helpers in `internal/lsp/rename.go`. The 2026-06-24
 audit requires it.
 
@@ -23,10 +23,11 @@ Go arch doc §"Tests" requires every production function
 to have a dedicated test by name. The 2026-06-24 audit
 (range: 1599c9f..09f22d3) flagged this file.
 
-`atxHeadingTextByteRange` already has a test. The
-three trivial pass-through methods on the workspace
-adapter carry exemption comments. The 15 helpers
-below need dedicated tests:
+`atxHeadingTextByteRange` already has a test.
+Three pass-through adapter methods carry exemption
+comments. Two helpers were removed from this file.
+Both now live in `internal/rename` with tests.
+The 13 helpers below need tests:
 
 - `isValidRefDefLine`
 - `headingPrepareRange`
@@ -36,13 +37,11 @@ below need dedicated tests:
 - `trimRightSpace`
 - `trimmedRange`
 - `refDefPrepareRange`
-- `refDefBracketBytes`
 - `refUsePrepareRange`
 - `refUseLabelBytes` (one partial test exists;
   add broader coverage)
 - `matchLeadingPair`
 - `matchTrailingPair`
-- `normalizedLabel`
 - `bracketPairs`
 
 ## Tasks
@@ -64,11 +63,10 @@ below need dedicated tests:
       `TestskipLeadingSpaces`,
       `TesttrimRightSpace`, `TesttrimmedRange`,
       `TestrefDefPrepareRange`,
-      `TestrefDefBracketBytes`,
       `TestrefUsePrepareRange`,
       `TestrefUseLabelBytes`,
       `TestmatchLeadingPair`,
       `TestmatchTrailingPair`,
-      `TestnormalizedLabel`, `TestbracketPairs`.
+      `TestbracketPairs`.
 - [ ] `go test ./internal/lsp/...` is green.
 - [ ] `mdsmith check .` is green.