111 lines
4.6 KiB
Go
111 lines
4.6 KiB
Go
package lang
|
|
|
|
import (
|
|
"encoding/json"
|
|
"regexp"
|
|
"strings"
|
|
|
|
"github.com/go-enry/go-enry/v2"
|
|
)
|
|
|
|
// 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.
|
|
// GuessLang detects a language from pasted content.
|
|
func GuessLang(s string) string {
|
|
src := strings.TrimSpace(s)
|
|
if src == "" {
|
|
return ""
|
|
}
|
|
|
|
// 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 {
|
|
return "json"
|
|
}
|
|
}
|
|
|
|
// enry's built-in strategies: shebangs, XML declaration, modelines,
|
|
// content heuristics.
|
|
if lang := enry.GetLanguage("", []byte(src)); lang != "" && lang != enry.OtherLanguage {
|
|
return normalizeLang(lang)
|
|
}
|
|
|
|
// 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])
|
|
}
|
|
|
|
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
|
|
}
|
|
return strings.ToLower(lang)
|
|
}
|
|
|