Add elastic-like fuzziness parameter

Author: cyradin

internal/routes/dictionary_fix.go

@@ -2,8 +2,12 @@ package routes
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
+	"fmt"
 	"regexp"
+	"strconv"
+	"strings"
 	"unicode/utf8"
 
 	"github.com/f1monkey/spellchecker-web/internal/spellchecker"
@@ -17,12 +21,12 @@ type dictionaryGetter interface {
 }
 
 type DictionaryFixRequest struct {
-	Code string `path:"code" minLength:"1"`
-
-	Text                string  `json:"text" description:"Phrase to be checked"`
-	Limit               int     `json:"limit" default:"5" desciption:"Max suggestions per word"`
-	MaxErrors           int     `json:"maxErrors" default:"2" desciption:"Max spellchecker errors allowed"`
-	SimilarityThreshold float64 `json:"similarityThreshold" minimum:"0" maximum:"1" desciption:"Word similarity percent required"`
+	Code                string         `path:"code" minLength:"1" description:"Dictionary code to use for spellchecking."`
+	Text                string         `json:"text" description:"Input text to be checked and corrected."`
+	Limit               int            `json:"limit" default:"5" description:"Maximum number of suggestions to return per word."`
+	MaxErrors           int            `json:"maxErrors" default:"2" description:"Maximum number of bit-level differences allowed between the input word and a dictionary word. Examples: deletion=1 bit (proble→problem), insertion=1 bit (problemm→problem), substitution=2 bits (problam→problem), transposition=0 bits (problme→problem). Not recommended to set higher than 2, as it can impact performance."`
+	Fuzziness           FuzzinessValue `json:"fuzziness" description:"Maximum allowed Levenshtein edit distance. Allowed values: '0','1','2'... (fixed distance), 'AUTO' (auto by word length, default AUTO:3,6), 'AUTO:low,high' (custom range). See: https://www.elastic.co/docs/reference/elasticsearch/rest-apis/common-options#fuzziness"`
+	SimilarityThreshold float64        `json:"similarityThreshold" minimum:"0" maximum:"1" description:"Required similarity ratio between input word and candidate suggestion (0.0–1.0). Example: 0.6 = candidate must be at least 60% similar to input."`
 }
 
 type DictionaryFixResponse struct {
@@ -62,6 +66,11 @@ func dictionaryFix(registry dictionaryGetter, splitter *regexp.Regexp) usecase.I
 				return status.Wrap(err, status.Internal)
 			}
 
+			fuzziness, err := input.Fuzziness.Parse()
+			if err != nil {
+				return status.Wrap(err, status.InvalidArgument)
+			}
+
 			if input.Text == "" {
 				output.Fixes = make([]Fix, 0)
 				return nil
@@ -85,7 +94,7 @@ func dictionaryFix(registry dictionaryGetter, splitter *regexp.Regexp) usecase.I
 
 				suggestions := sc.Suggest(&f1mspellchecker.SearchOptions{
 					MaxErrors:  input.MaxErrors,
-					FilterFunc: spellchecker.ScoringFunc(input.MaxErrors, input.SimilarityThreshold),
+					FilterFunc: spellchecker.ScoringFunc(fuzziness, input.SimilarityThreshold),
 				}, word, input.Limit)
 
 				if suggestions.ExactMatch {
@@ -129,3 +138,43 @@ func dictionaryFix(registry dictionaryGetter, splitter *regexp.Regexp) usecase.I
 
 	return u
 }
+
+type FuzzinessValue string
+
+// Parse converts FuzzinessValue into spellchecker.Fuzziness.
+func (fv FuzzinessValue) Parse() (spellchecker.Fuzziness, error) {
+	raw := strings.TrimSpace(strings.ToUpper(string(fv)))
+
+	switch {
+	case raw == "":
+		return spellchecker.FixedFuzziness(0), nil
+	case raw == "AUTO":
+		return spellchecker.AutoFuzziness{Low: 3, High: 6}, nil
+	case strings.HasPrefix(raw, "AUTO:"):
+		parts := strings.Split(strings.TrimPrefix(raw, "AUTO:"), ",")
+		if len(parts) != 2 {
+			return nil, fmt.Errorf("invalid AUTO fuzziness format: %q", raw)
+		}
+		low, err1 := strconv.Atoi(parts[0])
+		high, err2 := strconv.Atoi(parts[1])
+		if err1 != nil || err2 != nil {
+			return nil, fmt.Errorf("invalid AUTO fuzziness values: %q", raw)
+		}
+		return spellchecker.AutoFuzziness{Low: low, High: high}, nil
+	default:
+		if n, err := strconv.Atoi(raw); err == nil {
+			return spellchecker.FixedFuzziness(n), nil
+		}
+		return nil, fmt.Errorf("unknown fuzziness value: %q", raw)
+	}
+}
+
+// UnmarshalJSON validates that fuzziness is passed as a JSON string.
+func (fv *FuzzinessValue) UnmarshalJSON(data []byte) error {
+	var raw string
+	if err := json.Unmarshal(data, &raw); err != nil {
+		return fmt.Errorf("fuzziness must be a string: %w", err)
+	}
+	*fv = FuzzinessValue(raw)
+	return nil
+}

internal/spellchecker/scoring.go

@@ -7,10 +7,36 @@ import (
 	"github.com/f1monkey/spellchecker/v2"
 )
 
-func ScoringFunc(maxErrors int, similarityThreshold float64) spellchecker.FilterFunc {
+type Fuzziness interface {
+	MaxAllowedErrors(wordLen int) int
+}
+
+type FixedFuzziness int
+
+func (f FixedFuzziness) MaxAllowedErrors(_ int) int {
+	return int(f)
+}
+
+type AutoFuzziness struct {
+	Low, High int
+}
+
+func (a AutoFuzziness) MaxAllowedErrors(wordLen int) int {
+	if wordLen < a.Low {
+		return 0
+	}
+
+	if wordLen < a.High {
+		return 1
+	}
+
+	return 2
+}
+
+func ScoringFunc(fuzziness Fuzziness, similarityThreshold float64) spellchecker.FilterFunc {
 	return func(src, candidate []rune, count uint) (float64, bool) {
 		distance, prefixLen, suffixLen := levenshtein.Calculate(src, candidate, 0, 1, 1, 1)
-		if distance > maxErrors {
+		if distance > fuzziness.MaxAllowedErrors(len(src)) {
 			return 0, false
 		}