MINOR: support GitLab wiki formats and CRLF in remote files

Update the remote file fetching logic to robustly handle payloads from GitLab wiki pages and other markdown-formatted dictionary sources.

Changes include:
- Normalizing Windows-style CRLF line endings to standard LF.
- Adding a stripCodeFence helper to safely remove markdown code blocks, regardless of whether a language tag (like yaml) is provided.
- Enhancing fallback parsing to correctly process markdown list items by stripping "- " prefixes from newline-separated entries.
- Adding a comprehensive test suite to validate parsing behavior across JSON, YAML, plain text, and Markdown formats with mixed line endings.

Author: oktalz

aspell/remote.go

@@ -70,18 +70,22 @@ func fetchRemoteFile(aspell Aspell) ([]string, error) {
 		if !ok {
 			return nil, fmt.Errorf("aspell remote file: key %q not found or not a string/array in response", aspell.RemoteFile.AllowedItemsKey)
 		}
-		content = strings.TrimRight(content, "\n")
-		if strings.HasPrefix(content, "```yaml\n") && strings.HasSuffix(content, "\n```") {
-			content = strings.TrimPrefix(content, "```yaml\n")
-			content = strings.TrimSuffix(content, "\n```")
-			err = yaml.Unmarshal([]byte(content), &allowedWords)
-			if err != nil {
-				return nil, fmt.Errorf("aspell remote file: failed to parse YAML block: %w", err)
-			}
-			slog.Info("aspell remote file: loaded words", "format", "yaml block", "count", len(allowedWords), "sample", wordSample(allowedWords))
+		content = strings.ReplaceAll(content, "\r\n", "\n")
+		content = strings.TrimSpace(content)
+		content = stripCodeFence(content)
+		if err = yaml.Unmarshal([]byte(content), &allowedWords); err == nil && len(allowedWords) > 0 {
+			slog.Info("aspell remote file: loaded words", "format", "yaml list", "count", len(allowedWords), "sample", wordSample(allowedWords))
 			return allowedWords, nil
 		}
-		allowedWords = strings.Split(content, "\n")
+		allowedWords = allowedWords[:0]
+		for line := range strings.SplitSeq(content, "\n") {
+			line = strings.TrimSpace(line)
+			line = strings.TrimPrefix(line, "- ")
+			if line == "" {
+				continue
+			}
+			allowedWords = append(allowedWords, line)
+		}
 		slog.Info("aspell remote file: loaded words", "format", "newline-separated", "count", len(allowedWords), "sample", wordSample(allowedWords))
 	} else {
 		for _, item := range items {
@@ -93,6 +97,19 @@ func fetchRemoteFile(aspell Aspell) ([]string, error) {
 	return allowedWords, nil
 }
 
+// stripCodeFence removes a surrounding markdown code fence, with or
+// without a language tag, as produced by GitLab wiki pages.
+func stripCodeFence(content string) string {
+	if !strings.HasPrefix(content, "```") || !strings.HasSuffix(content, "\n```") {
+		return content
+	}
+	_, body, found := strings.Cut(content, "\n")
+	if !found {
+		return content
+	}
+	return strings.TrimSuffix(body, "\n```")
+}
+
 func wordSample(words []string) []string {
 	if len(words) <= 3 {
 		return words

aspell/remote_test.go

@@ -0,0 +1,70 @@
+package aspell
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"slices"
+	"testing"
+)
+
+func serveContent(t *testing.T, body string) *httptest.Server {
+	t.Helper()
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = w.Write([]byte(body))
+	}))
+	t.Cleanup(srv.Close)
+	return srv
+}
+
+func Test_fetchRemoteFile_formats(t *testing.T) {
+	tests := []struct {
+		name string
+		body string
+		want []string
+	}{
+		{
+			name: "gitlab wiki CRLF plain fence with list items",
+			body: `{"content": "` + "```" + `\r\n- ACL\r\n- eab\r\n- verifier\r\n` + "```" + `"}`,
+			want: []string{"ACL", "eab", "verifier"},
+		},
+		{
+			name: "yaml block LF",
+			body: `{"content": "` + "```yaml" + `\n- word1\n- word2\n` + "```" + `"}`,
+			want: []string{"word1", "word2"},
+		},
+		{
+			name: "yaml block CRLF",
+			body: `{"content": "` + "```yaml" + `\r\n- word1\r\n- word2\r\n` + "```" + `"}`,
+			want: []string{"word1", "word2"},
+		},
+		{
+			name: "plain newline-separated",
+			body: `{"content": "word1\nword2"}`,
+			want: []string{"word1", "word2"},
+		},
+		{
+			name: "plain CRLF-separated",
+			body: `{"content": "word1\r\nword2\r\n"}`,
+			want: []string{"word1", "word2"},
+		},
+		{
+			name: "JSON array",
+			body: `{"content": ["word1", "word2"]}`,
+			want: []string{"word1", "word2"},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			srv := serveContent(t, tt.body)
+			a := Aspell{RemoteFile: RemoteFile{URL: srv.URL, AllowedItemsKey: "content"}}
+			got, err := fetchRemoteFile(a)
+			if err != nil {
+				t.Fatalf("fetchRemoteFile() error = %v", err)
+			}
+			if !slices.Equal(got, tt.want) {
+				t.Errorf("fetchRemoteFile() = %q, want %q", got, tt.want)
+			}
+		})
+	}
+}