fix(core): resolve Lang and Transform in section order, not map order (#1143)

* fix(core): resolve Lang and Transform in section order, not map order

* fix(core): rename variables to eliminate shadowing

---------

Co-authored-by: VXNCXNX <VXNCXNX@users.noreply.github.com>

Author: VXNCXNX

internal/core/file.go

@@ -13,7 +13,6 @@ import (
 	"github.com/jdkato/prose/v3/summarize"
 	"github.com/jdkato/prose/v3/tag"
 
-	"github.com/errata-ai/vale/v3/internal/glob"
 	"github.com/errata-ai/vale/v3/internal/nlp"
 	"github.com/errata-ai/vale/v3/internal/system"
 )
@@ -152,24 +151,30 @@ func NewFile(src string, config *Config) (*File, error) {
 	}
 
 	lang := "en"
-	for syntax, code := range config.FormatToLang {
-		sec, err := glob.Compile(syntax)
-		if err != nil {
-			return &File{}, err
-		} else if sec.Match(path) {
-			lang = code
-			break
+	if code, found := config.FormatToLang["*"]; found && code != "" {
+		lang = code
+	}
+	for _, sec := range config.RuleKeys {
+		if pat, found := config.SecToPat[sec]; found && pat.Match(path) {
+			// Sections are visited in the order they were written, so a
+			// later one wins -- for this file, and no other. See #965.
+			if code, ok := config.FormatToLang[sec]; ok {
+				lang = code
+			}
 		}
 	}
 
 	transform := ""
-	for sec, p := range config.Stylesheets {
-		pat, err := glob.Compile(sec)
-		if err != nil {
-			return &File{}, NewE100(path, err)
-		} else if pat.Match(path) {
-			transform = p
-			break
+	if p, found := config.Stylesheets["*"]; found {
+		transform = p
+	}
+	for _, sec := range config.RuleKeys {
+		if pat, found := config.SecToPat[sec]; found && pat.Match(path) {
+			// Sections are visited in the order they were written, so a
+			// later one wins -- for this file, and no other. See #965.
+			if p, ok := config.Stylesheets[sec]; ok {
+				transform = p
+			}
 		}
 	}
 	content := Sanitize(string(fbytes))

internal/core/file_test.go

@@ -0,0 +1,108 @@
+package core
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/errata-ai/vale/v3/internal/glob"
+)
+
+// TestNewFileSectionOrderWins verifies that when multiple config sections
+// match the same file, NewFile resolves Lang and Transform deterministically
+// by taking the LAST matching section in the order it was written -- the
+// same "later one wins" semantics the rule/level resolution loop documents
+// for #965 -- rather than depending on Go's randomized map iteration order.
+func TestNewFileSectionOrderWins(t *testing.T) {
+	sections := []struct {
+		name string
+		lang string
+		xslt string
+	}{
+		{"*.md", "en", "one.xsl"},
+		{"*.md", "fr", "two.xsl"},
+		{"*.md", "de", "three.xsl"},
+		{"*.md", "ja", "four.xsl"},
+		{"*.md", "es", "five.xsl"},
+		{"*.md", "it", "six.xsl"},
+	}
+
+	cfg, err := NewConfig(&CLIFlags{})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	for i, s := range sections {
+		// Reuse the same glob pattern across sections, but track each
+		// occurrence under its own key so every one can carry its own
+		// Lang/Transform value -- mirroring how repeated real config
+		// sections (e.g. multiple `[*.md]` blocks) are keyed internally.
+		key := s.name
+		if i > 0 {
+			key = s.name + string(rune('a'+i))
+		}
+
+		pat, cerr := glob.Compile(s.name)
+		if cerr != nil {
+			t.Fatal(cerr)
+		}
+
+		cfg.SecToPat[key] = pat
+		cfg.RuleKeys = append(cfg.RuleKeys, key)
+		cfg.FormatToLang[key] = s.lang
+		cfg.Stylesheets[key] = s.xslt
+		cfg.SChecks[key] = map[string]bool{}
+		cfg.SLevels[key] = map[string]string{}
+	}
+
+	wantLang := sections[len(sections)-1].lang
+	wantTransform := sections[len(sections)-1].xslt
+
+	docPath := filepath.Join(t.TempDir(), "doc.md")
+	if werr := os.WriteFile(docPath, []byte("# Title\n"), 0600); werr != nil {
+		t.Fatal(werr)
+	}
+
+	const iterations = 50
+	for i := 0; i < iterations; i++ {
+		f, ferr := NewFile(docPath, cfg)
+		if ferr != nil {
+			t.Fatal(ferr)
+		}
+
+		if f.NLP.Lang != wantLang {
+			t.Fatalf("iteration %d: expected Lang %q (the last written matching section), got %q",
+				i, wantLang, f.NLP.Lang)
+		}
+
+		if f.Transform != wantTransform {
+			t.Fatalf("iteration %d: expected Transform %q (the last written matching section), got %q",
+				i, wantTransform, f.Transform)
+		}
+	}
+}
+
+// TestNewFileGlobalLangFallback verifies that the `[*] Lang = ...` global
+// default still applies when no format-specific section matches the file.
+func TestNewFileGlobalLangFallback(t *testing.T) {
+	cfg, err := NewConfig(&CLIFlags{})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	cfg.FormatToLang["*"] = "ja"
+
+	docPath := filepath.Join(t.TempDir(), "doc.txt")
+	if werr := os.WriteFile(docPath, []byte("hello\n"), 0600); werr != nil {
+		t.Fatal(werr)
+	}
+
+	f, err := NewFile(docPath, cfg)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if f.NLP.Lang != "ja" {
+		t.Fatalf("expected global Lang fallback %q, got %q", "ja", f.NLP.Lang)
+	}
+}