fix(occurrence): reduce ApplySettings cognitive complexity; add missing test coverage

Extract per-setting helper methods from ApplySettings to satisfy the
gocognit <= 30 limit. Also add tests for file-scope each mode,
section-scope combined and pattern modes, type-error paths in
ApplySettings helpers, and multi-section range-skip branches,
raising unit coverage from 79% to 99%.

Author: claude

internal/rules/occurrence/rule.go

@@ -297,88 +297,116 @@ func (r *Rule) ApplySettings(s map[string]any) error {
 	// before the pattern is compiled.
 	rawPattern := ""
 	for k, v := range s {
+		var err error
 		switch k {
 		case "scope":
-			str, ok := v.(string)
-			if !ok {
-				return fmt.Errorf("occurrence: scope must be a string, got %T", v)
-			}
-			switch str {
-			case "file", "section", "paragraph":
-				r.Scope = str
-			default:
-				return fmt.Errorf("occurrence: scope must be file, section, or paragraph, got %q", str)
-			}
+			err = r.applyScope(v)
 		case "tokens":
-			ss, ok := settings.ToStringSlice(v)
-			if !ok {
-				return fmt.Errorf("occurrence: tokens must be a list of strings, got %T", v)
-			}
-			r.Tokens = ss
-			// tokens uses the default replace merge mode (not append); no
-			// SettingMergeMode override is needed.
+			err = r.applyTokens(v)
 		case "pattern":
-			str, ok := v.(string)
-			if !ok {
-				return fmt.Errorf("occurrence: pattern must be a string, got %T", v)
-			}
-			rawPattern = str
+			rawPattern, err = extractPattern(v)
 		case "min":
-			n, ok := settings.ToInt(v)
-			if !ok {
-				return fmt.Errorf("occurrence: min must be an integer, got %T", v)
-			}
-			if n < 0 {
-				return fmt.Errorf("occurrence: min must be >= 0, got %d", n)
-			}
-			r.Min = n
+			err = r.applyMin(v)
 		case "max":
-			n, ok := settings.ToInt(v)
-			if !ok {
-				return fmt.Errorf("occurrence: max must be an integer, got %T", v)
-			}
-			r.Max = n
+			err = r.applyMax(v)
 		case "count":
-			str, ok := v.(string)
-			if !ok {
-				return fmt.Errorf("occurrence: count must be a string, got %T", v)
-			}
-			switch str {
-			case "each", "combined":
-				r.Count = str
-			default:
-				return fmt.Errorf("occurrence: count must be each or combined, got %q", str)
-			}
+			err = r.applyCount(v)
 		case "case-sensitive":
-			b, ok := v.(bool)
-			if !ok {
-				return fmt.Errorf("occurrence: case-sensitive must be a bool, got %T", v)
-			}
-			r.CaseSensitive = b
+			err = r.applyCaseSensitive(v)
 		default:
 			return fmt.Errorf("occurrence: unknown setting %q", k)
 		}
+		if err != nil {
+			return err
+		}
+	}
+	return r.finalizeSettings(rawPattern)
+}
+
+func (r *Rule) applyScope(v any) error {
+	str, ok := v.(string)
+	if !ok {
+		return fmt.Errorf("occurrence: scope must be a string, got %T", v)
+	}
+	switch str {
+	case "file", "section", "paragraph":
+		r.Scope = str
+		return nil
+	default:
+		return fmt.Errorf("occurrence: scope must be file, section, or paragraph, got %q", str)
+	}
+}
+
+func (r *Rule) applyTokens(v any) error {
+	ss, ok := settings.ToStringSlice(v)
+	if !ok {
+		return fmt.Errorf("occurrence: tokens must be a list of strings, got %T", v)
+	}
+	// tokens uses the default replace merge mode (not append); no
+	// SettingMergeMode override is needed.
+	r.Tokens = ss
+	return nil
+}
+
+func extractPattern(v any) (string, error) {
+	str, ok := v.(string)
+	if !ok {
+		return "", fmt.Errorf("occurrence: pattern must be a string, got %T", v)
+	}
+	return str, nil
+}
+
+func (r *Rule) applyMin(v any) error {
+	n, ok := settings.ToInt(v)
+	if !ok {
+		return fmt.Errorf("occurrence: min must be an integer, got %T", v)
+	}
+	if n < 0 {
+		return fmt.Errorf("occurrence: min must be >= 0, got %d", n)
+	}
+	r.Min = n
+	return nil
+}
+
+func (r *Rule) applyMax(v any) error {
+	n, ok := settings.ToInt(v)
+	if !ok {
+		return fmt.Errorf("occurrence: max must be an integer, got %T", v)
+	}
+	r.Max = n
+	return nil
+}
+
+func (r *Rule) applyCount(v any) error {
+	str, ok := v.(string)
+	if !ok {
+		return fmt.Errorf("occurrence: count must be a string, got %T", v)
 	}
-	// Compile pattern after all scalar settings are applied so CaseSensitive
-	// is final when deciding the (?i) prefix.
+	switch str {
+	case "each", "combined":
+		r.Count = str
+		return nil
+	default:
+		return fmt.Errorf("occurrence: count must be each or combined, got %q", str)
+	}
+}
+
+func (r *Rule) applyCaseSensitive(v any) error {
+	b, ok := v.(bool)
+	if !ok {
+		return fmt.Errorf("occurrence: case-sensitive must be a bool, got %T", v)
+	}
+	r.CaseSensitive = b
+	return nil
+}
+
+// finalizeSettings compiles the pattern (if any) and builds lowerTokens.
+// Called after all scalar settings are applied so CaseSensitive is final.
+func (r *Rule) finalizeSettings(rawPattern string) error {
 	if rawPattern != "" {
-		r.patternSource = rawPattern
-		src := rawPattern
-		if !r.CaseSensitive {
-			src = "(?i)" + rawPattern
+		if err := r.compileAndSetPattern(rawPattern); err != nil {
+			return err
 		}
-		var compiled *regexp.Regexp
-		if actual, loaded := compiledPatterns.Load(src); loaded {
-			compiled = actual.(*regexp.Regexp)
-		} else {
-			re, err := regexp.Compile(src)
-			if err != nil {
-				return fmt.Errorf("occurrence: pattern %q is not a valid Go RE2 regex: %w", rawPattern, err)
-			}
-			actual, _ := compiledPatterns.LoadOrStore(src, re)
-			compiled = actual.(*regexp.Regexp)
-		}
-		r.Pattern = compiled
 	}
 	if len(r.Tokens) > 0 && r.Pattern != nil {
 		return fmt.Errorf("occurrence: tokens and pattern are mutually exclusive")
@@ -392,6 +420,28 @@ func (r *Rule) ApplySettings(s map[string]any) error {
 	return nil
 }
 
+// compileAndSetPattern compiles rawPattern (with (?i) prefix when not
+// CaseSensitive) and stores the result in r.Pattern and r.patternSource.
+func (r *Rule) compileAndSetPattern(rawPattern string) error {
+	src := rawPattern
+	if !r.CaseSensitive {
+		src = "(?i)" + rawPattern
+	}
+	if actual, loaded := compiledPatterns.Load(src); loaded {
+		r.patternSource = rawPattern
+		r.Pattern = actual.(*regexp.Regexp)
+		return nil
+	}
+	re, err := regexp.Compile(src)
+	if err != nil {
+		return fmt.Errorf("occurrence: pattern %q is not a valid Go RE2 regex: %w", rawPattern, err)
+	}
+	actual, _ := compiledPatterns.LoadOrStore(src, re)
+	r.patternSource = rawPattern
+	r.Pattern = actual.(*regexp.Regexp)
+	return nil
+}
+
 // DefaultSettings implements rule.Configurable.
 func (r *Rule) DefaultSettings() map[string]any {
 	return map[string]any{

internal/rules/occurrence/rule_test.go

@@ -277,3 +277,147 @@ func TestDefaultSettings_Keys(t *testing.T) {
 	assert.Contains(t, d, "count")
 	assert.Contains(t, d, "case-sensitive")
 }
+
+// --- file scope, each mode ---
+
+func TestCheck_File_EachToken_ExceedsMax(t *testing.T) {
+	r := &Rule{}
+	mustApply(t, r, map[string]any{"tokens": []any{"word"}, "max": 3, "scope": "file", "count": "each"})
+	// "word" total: 2 + 2 = 4 > max 3
+	src := "# Title\n\nword word.\n\nalso word word.\n"
+	diags := r.Check(mustFile(t, src))
+	require.Len(t, diags, 1)
+	assert.Contains(t, diags[0].Message, "file")
+}
+
+func TestCheck_File_EachToken_UnderMax_NoDiagnostic(t *testing.T) {
+	r := &Rule{}
+	mustApply(t, r, map[string]any{"tokens": []any{"word"}, "max": 3, "scope": "file", "count": "each"})
+	src := "# Title\n\nword word.\n\nalso word here.\n"
+	assert.Empty(t, r.Check(mustFile(t, src)))
+}
+
+func TestCheck_File_EachPattern_ExceedsMax(t *testing.T) {
+	r := &Rule{}
+	mustApply(t, r, map[string]any{"pattern": "—", "max": 2, "scope": "file", "count": "each"})
+	// 3 em-dashes across two paragraphs → exceeds max 2
+	src := "# T\n\nFirst — second.\n\nThird — fourth — end.\n"
+	diags := r.Check(mustFile(t, src))
+	require.Len(t, diags, 1)
+	assert.Contains(t, diags[0].Message, "file")
+}
+
+// --- section scope: combined and pattern ---
+
+func TestCheck_Section_NoHeadings_NoDiagnostic(t *testing.T) {
+	r := &Rule{}
+	mustApply(t, r, map[string]any{"tokens": []any{"word"}, "max": 1, "scope": "section", "count": "each"})
+	// no headings → no sections → no diagnostics
+	src := "plain paragraph word word word.\n"
+	assert.Empty(t, r.Check(mustFile(t, src)))
+}
+
+func TestCheck_Section_Combined_ExceedsMax(t *testing.T) {
+	r := &Rule{}
+	mustApply(t, r, map[string]any{"tokens": []any{"a", "b"}, "max": 3, "scope": "section", "count": "combined"})
+	// "a" × 3, "b" × 1 → combined 4 > max 3
+	src := "# Title\n\na a a b.\n"
+	diags := r.Check(mustFile(t, src))
+	require.Len(t, diags, 1)
+	assert.Contains(t, diags[0].Message, "section")
+}
+
+func TestCheck_Section_Pattern_ExceedsMax(t *testing.T) {
+	r := &Rule{}
+	mustApply(t, r, map[string]any{"pattern": "—", "max": 2, "scope": "section", "count": "each"})
+	// 3 em-dashes in the section → exceeds max 2
+	src := "# Title\n\nFirst — second — third — end.\n"
+	diags := r.Check(mustFile(t, src))
+	require.Len(t, diags, 1)
+	assert.Contains(t, diags[0].Message, "section")
+}
+
+// --- ApplySettings type-error paths ---
+
+func TestApplySettings_ScopeWrongType(t *testing.T) {
+	r := &Rule{}
+	err := r.ApplySettings(map[string]any{"scope": 42})
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "scope")
+}
+
+func TestApplySettings_TokensWrongType(t *testing.T) {
+	r := &Rule{}
+	err := r.ApplySettings(map[string]any{"tokens": "word"})
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "tokens")
+}
+
+func TestApplySettings_PatternWrongType(t *testing.T) {
+	r := &Rule{}
+	err := r.ApplySettings(map[string]any{"pattern": 42})
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "pattern")
+}
+
+func TestApplySettings_MaxWrongType(t *testing.T) {
+	r := &Rule{}
+	err := r.ApplySettings(map[string]any{"max": "two"})
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "max")
+}
+
+func TestApplySettings_CountWrongType(t *testing.T) {
+	r := &Rule{}
+	err := r.ApplySettings(map[string]any{"count": 42})
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "count")
+}
+
+func TestApplySettings_CaseSensitiveWrongType(t *testing.T) {
+	r := &Rule{}
+	err := r.ApplySettings(map[string]any{"case-sensitive": "yes"})
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "case-sensitive")
+}
+
+func TestApplySettings_MinWrongType(t *testing.T) {
+	r := &Rule{}
+	err := r.ApplySettings(map[string]any{"min": "two"})
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "min")
+}
+
+// --- paragraph scope: pattern with count=each ---
+
+func TestCheck_Paragraph_PatternEach_ExceedsMax(t *testing.T) {
+	r := &Rule{}
+	mustApply(t, r, map[string]any{"pattern": "—", "max": 2, "count": "each"})
+	src := "# Title\n\nFirst — second — third — end.\n"
+	diags := r.Check(mustFile(t, src))
+	require.Len(t, diags, 1)
+	assert.Contains(t, diags[0].Message, "3")
+	assert.Contains(t, diags[0].Message, "max 2")
+}
+
+// --- section scope: combined with multiple sections (exercises range-skip) ---
+
+func TestCheck_Section_Combined_MultipleHeadings(t *testing.T) {
+	r := &Rule{}
+	mustApply(t, r, map[string]any{"tokens": []any{"a", "b"}, "max": 3, "scope": "section", "count": "combined"})
+	// section A: "a"×3 + "b"×1 = 4 > max 3; section B: "a"×1 = 1 ≤ max 3
+	src := "# A\n\na a a b.\n\n## B\n\na once.\n"
+	diags := r.Check(mustFile(t, src))
+	require.Len(t, diags, 1)
+	assert.Equal(t, 1, diags[0].Line)
+}
+
+func TestCheck_Section_PatternMultipleHeadings(t *testing.T) {
+	r := &Rule{}
+	mustApply(t, r, map[string]any{"pattern": "—", "max": 2, "scope": "section", "count": "each"})
+	// section A: 3 dashes > max 2; section B: 1 dash ≤ max 2
+	src := "# A\n\nFirst — second — third — end.\n\n## B\n\nOnly — one.\n"
+	diags := r.Check(mustFile(t, src))
+	require.Len(t, diags, 1)
+	assert.Equal(t, 1, diags[0].Line)
+}