Language detection: switch to go-enry with hint-seeded classifier (#41)

- Add github.com/go-enry/go-enry/v2 dependency to go.mod
- guessLang: JSON fast path, then enry strategies (shebangs, XML, modelines,
  content heuristics), then enry's Linguist-trained Bayesian classifier over
  regex-hint candidate languages; curated dropdown expanded with typescript,
  html, css, xml, php, ruby, perl, lua, dockerfile, toml, ini, diff, csharp
- enry display names normalized to lowercase stored ids (Dockerfile->dockerfile,
  Shell->bash, C#->csharp); unsupported languages render unhighlighted
- Tests: existing languages, all new languages, magic markers (enry shebang/
  DOCTYPE/FROM/diff handling), canonical mapping

guess.go

@@ -5,16 +5,68 @@ import (
 	"net/http"
 	"regexp"
 	"strings"
+
+	"github.com/go-enry/go-enry/v2"
 )
 
-// guessLang heuristically detects a language from source content.
+// hintRule is a lightweight regex hint that nudges detection. Hints don't
+// decide on their own: matching hints are passed to enry's classifier as
+// candidate languages, and enry (trained on Linguist samples) makes the final
+// call. Adding a language later is usually a one-line addition here plus the
+// dropdown in web/templates/new.html.
+type hintRule struct {
+	lang string // enry language name
+	re   *regexp.Regexp
+}
+
+// hintRules are evaluated in order; keep more specific languages earlier so
+// ties break in their favor.
+var hintRules = []hintRule{
+	{"Dockerfile", regexp.MustCompile(`(?mi)^(FROM\s+\S+:\S*|RUN\s+\S+|COPY\s+\S+\s+\S+|ENTRYPOINT\s+|WORKDIR\s+/)`)},
+	{"Diff", regexp.MustCompile(`(?m)^(diff --git|--- a/|\+\+\+ b/|@@ -\d+)`)},
+	{"PHP", regexp.MustCompile(`(?m)<\?php|\$\w+\s*=\s*[^=]|\becho\s+["'$]`)},
+	{"HTML", regexp.MustCompile(`(?i)<(!DOCTYPE|html|head|body|div|span|script|p|a)\b`)},
+	{"XML", regexp.MustCompile(`(?m)^<\?xml\b|<\/?[a-zA-Z][\w.-]*:[\w.-]*[>\s]`)},
+	{"CSS", regexp.MustCompile(`(?m)(^|\})\s*[^{}@]+\{[^}]*:[^}]*\}|@(media|import|font-face)\b`)},
+	{"TypeScript", regexp.MustCompile(`(?m)(:\s*(string|number|boolean|any)\b|\binterface \w+ \{|\btype \w+ =|\bimplements \w+)`)},
+	{"TOML", regexp.MustCompile(`(?m)^\[[\w."-]+\]\s*$|^\w[\w-]*\s*=\s*("[^"]*"|\d+|true|false|\[[^\]]*\])\s*$`)},
+	{"INI", regexp.MustCompile(`(?m)^\[[\w.-]+\]\s*$|^\w[\w.-]*\s*=\s*\S+\s*$`)},
+	{"Ruby", regexp.MustCompile(`(?m)(\bdef \w+($|\s)|\brequire ['"]|\bputs \w+|@\w+\s*=\s*[^=]|\bend\b\s*$)`)},
+	{"Perl", regexp.MustCompile(`(?m)(\buse strict\b|\bmy \$\w+|->\{|sub \w+ \{)`)},
+	{"Lua", regexp.MustCompile(`(?m)(\bfunction\s+\w+\s*\(|\blocal \w+\s*=|\bthen\b|\belseif\b|\.\.\.)`)},
+	{"Go", regexp.MustCompile(`(?m)^\s*(package \w+|import \(|func (\w+|\() )`)},
+	{"Python", regexp.MustCompile(`(?m)^\s*(def \w+|class \w+|import \w+|from \w+ import |@\w+)`)},
+	{"JavaScript", regexp.MustCompile(`(?m)(\bconst \w+ = |require\(|import \w+ from |=> \{|\bconsole\.log\()` )},
+	{"Rust", regexp.MustCompile(`(?m)(\bfn \w+|let mut \b|\bimpl \b|use std::)`)},
+	{"Java", regexp.MustCompile(`(?m)(\bpublic (static |final |class )|\bSystem\.out\.print|import java\.)`)},
+	{"C", regexp.MustCompile(`(?m)(#include\s*<\w+\.h>|printf\(|\bint main\()` )},
+	{"C++", regexp.MustCompile(`(?m)(#include\s*<(iostream|vector|string)>|std::|\bcout\s*<<)`)},
+	{"SQL", regexp.MustCompile(`(?i)\b(SELECT .+ FROM|INSERT INTO|CREATE TABLE|UPDATE \w+ SET)\b`)},
+	{"YAML", regexp.MustCompile(`(?m)^(\w[\w-]*:\s*(\||\S)|  \w[\w-]*: |---\s*$)`)},
+	{"Markdown", regexp.MustCompile("(?m)^(#{1,6} \\S|\\|.*\\||-\\s\\[\\s?\\]|```)")},
+	{"Shell", regexp.MustCompile(`(?m)^(#!.*bash|#!.*sh|\w+\(\)\s*\{)` )},
+}
+
+// canonical maps enry display names to the lowercase ids we store and render.
+var canonical = map[string]string{
+	"Dockerfile": "dockerfile",
+	"C#":         "csharp",
+	"Shell":      "bash",
+}
+
+// guessLang detects a language from pasted content. Order: fast decisive
+// paths (empty, JSON, unambiguous markers enry can't see without a filename),
+// then enry strategies (shebangs, XML decl, modelines, content heuristics),
+// then enry's classifier seeded by our regex hints.
 func guessLang(s string) string {
 	src := strings.TrimSpace(s)
 	if src == "" {
 		return ""
 	}
 
-	// JSON: must start with { or [ and parse
+	// JSON: must start with { or [ and parse — cheaper and more decisive
+	// than the classifier for pasted JSON, and handles compact single-line
+	// JSON that content heuristics miss.
 	if src[0] == '{' || src[0] == '[' {
 		var v any
 		if json.Unmarshal([]byte(src), &v) == nil {
@@ -22,43 +74,38 @@ func guessLang(s string) string {
 		}
 	}
 
-	rules := []struct {
-		lang string
-		re   *regexp.Regexp
-	}{
-		{"python", regexp.MustCompile(`(?m)^\s*(def |class |import |from \w+ import |@decorator)`)},
-		{"python", regexp.MustCompile(`(^|\n)\s*#!.*python`)},
-		{"go", regexp.MustCompile(`(?m)^\s*(package \w+|import \(|func (\w+|\() )`)},
-		{"rust", regexp.MustCompile(`(?m)(\bfn \w+|let mut \b|\bimpl \b|\bmatch \w+ \{|use std::)`)},
-		{"javascript", regexp.MustCompile(`(?m)(\bconst \w+ = |require\(|import \w+ from |=> \{|\bconsole\.log\()` )},
-		{"java", regexp.MustCompile(`(?m)(\bpublic (static |final |class )|\bSystem\.out\.print|import java\.)`)},
-		{"c", regexp.MustCompile(`(?m)(#include\s*<\w+\.h>|printf\(|\bint main\()` )},
-		{"cpp", regexp.MustCompile(`(?m)(#include\s*<(iostream|vector|string)>|std::|\bcout\s*<<)`)},
-		{"bash", regexp.MustCompile(`(?m)^(#!.*bash|#!.*sh|\w+\(\)\s*\{)` )},
-		{"sql", regexp.MustCompile(`(?i)\b(SELECT .+ FROM|INSERT INTO|CREATE TABLE|UPDATE \w+ SET)\b`)},
-		{"yaml", regexp.MustCompile(`(?m)^(\w[\w-]*:\s*(\||\S)|  \w[\w-]*: |---\s*$)`)},
-		{"markdown", regexp.MustCompile("(?m)^(#{1,6} \\S|\\|.*\\||-\\s\\[\\s?\\]|```)")},
+	// enry's built-in strategies: shebangs, XML declaration, modelines,
+	// content heuristics.
+	if lang := enry.GetLanguage("", []byte(src)); lang != "" && lang != enry.OtherLanguage {
+		return normalizeLang(lang)
 	}
 
-	scores := map[string]int{}
-	for _, r := range rules {
-		n := len(r.re.FindAllString(src, -1))
-		if n > 0 {
-			// later generic rules shouldn't drown out earlier specific ones
-			scores[r.lang] += n
+	// collect hint-matched languages as classifier candidates
+	cands := []string{}
+	for _, h := range hintRules {
+		if h.re.MatchString(src) {
+			cands = append(cands, h.lang)
 		}
 	}
+	if len(cands) > 0 {
+		// enry's Bayesian classifier (trained on Linguist samples) picks the
+		// best of the hint candidates; fall back to the first hint if it
+		// can't decide.
+		if lang, _ := enry.GetLanguageByClassifier([]byte(src), cands); lang != "" {
+			return normalizeLang(lang)
+		}
+		return normalizeLang(cands[0])
+	}
 
-	best, bestN := "", 0
-	for lang, n := range scores {
-		if n > bestN {
-			best, bestN = lang, n
-		}
+	return "text"
+}
+
+// normalizeLang maps enry display names to our lowercase stored ids.
+func normalizeLang(lang string) string {
+	if c, ok := canonical[lang]; ok {
+		return c
 	}
-	if bestN == 0 {
-		return "text"
-	}
-	return best
+	return strings.ToLower(lang)
 }
 
 func (a *apiServer) handleGuessLang(w http.ResponseWriter, r *http.Request) {