Arborescence dans s3_nodes, contenus sous des clés o/<id> figées au dépôt, corbeille dans s3_trash, configuration admin dans s3_config. Délégations S3 dans List/Stat/Open/Put/Mkdir/Move/Copy/Delete/Walk/corbeille, miniatures, partages, tags, recherche (noms et tags). Pas d'historique. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LNfwm4pfYR9C914C2EeiuB
269 lines
7.2 KiB
Go
269 lines
7.2 KiB
Go
package storage
|
|
|
|
import (
|
|
"io/fs"
|
|
"os"
|
|
"path"
|
|
"path/filepath"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
"unicode"
|
|
"unicode/utf8"
|
|
)
|
|
|
|
// Recherche plein texte : noms des fichiers et dossiers, tags, et contenu des
|
|
// fichiers texte de moins de 512 Ko (notes, configurations, code, journaux...).
|
|
// Le texte de chaque fichier est lu une fois puis gardé en mémoire tant que le
|
|
// fichier ne change pas (date et taille) : seule la première recherche lit tous
|
|
// les fichiers texte, les suivantes ne relisent que ceux modifiés.
|
|
|
|
// Hit est un résultat de recherche. Snippet est l'extrait du contenu qui
|
|
// correspond (vide si seul le nom correspond).
|
|
type Hit struct {
|
|
Entry
|
|
Snippet string `json:"snippet,omitempty"`
|
|
}
|
|
|
|
type indexDoc struct {
|
|
mod time.Time
|
|
size int64
|
|
text string // texte extrait
|
|
fold string // texte normalisé (minuscules, sans accents), même nombre de runes
|
|
}
|
|
|
|
type textIndex struct {
|
|
mu sync.Mutex
|
|
docs map[string]indexDoc
|
|
}
|
|
|
|
// fold met en minuscules et retire les accents des lettres latines courantes,
|
|
// rune pour rune : la position d'une correspondance vaut pour le texte d'origine.
|
|
func fold(s string) string {
|
|
return strings.Map(func(r rune) rune {
|
|
r = unicode.ToLower(r)
|
|
if f, ok := foldMap[r]; ok {
|
|
return f
|
|
}
|
|
return r
|
|
}, s)
|
|
}
|
|
|
|
var foldMap = func() map[rune]rune {
|
|
m := map[rune]rune{}
|
|
for base, accented := range map[rune]string{
|
|
'a': "àáâãäåāăą", 'c': "çćĉċč", 'd': "ď", 'e': "èéêëēĕėęě", 'g': "ĝğġģ",
|
|
'i': "ìíîïĩīĭįı", 'n': "ñńņňʼn", 'o': "òóôõöøōŏő", 'r': "ŕŗř", 's': "śŝşš",
|
|
't': "ţťŧ", 'u': "ùúûüũūŭůűų", 'y': "ýÿŷ", 'z': "źżž",
|
|
} {
|
|
for _, r := range accented {
|
|
m[r] = base
|
|
}
|
|
}
|
|
return m
|
|
}()
|
|
|
|
// maxIndexedSize borne la taille d'un fichier dont le contenu est indexé.
|
|
const maxIndexedSize = 512 << 10
|
|
|
|
// textExts : extensions de fichiers dont le contenu est du texte indexé.
|
|
var textExts = map[string]bool{
|
|
".txt": true, ".md": true, ".markdown": true, ".rst": true, ".log": true, ".csv": true, ".tsv": true,
|
|
".json": true, ".yaml": true, ".yml": true, ".toml": true, ".ini": true, ".conf": true, ".cfg": true,
|
|
".env": true, ".xml": true, ".html": true, ".htm": true, ".css": true, ".js": true, ".mjs": true,
|
|
".ts": true, ".tsx": true, ".jsx": true, ".py": true, ".go": true, ".rs": true, ".java": true,
|
|
".c": true, ".h": true, ".cpp": true, ".hpp": true, ".cs": true, ".php": true, ".rb": true,
|
|
".sh": true, ".bash": true, ".zsh": true, ".ps1": true, ".sql": true, ".tf": true, ".lua": true,
|
|
".service": true, ".sub": true, ".srt": true, ".tex": true, ".bib": true, ".gitignore": true,
|
|
}
|
|
|
|
// IsText indique si le contenu d'un fichier est indexé et prévisualisé comme du texte.
|
|
func IsText(name string) bool {
|
|
ext := strings.ToLower(path.Ext(name))
|
|
if ext == "" {
|
|
switch strings.ToLower(path.Base(name)) {
|
|
case "dockerfile", "makefile", "readme", "license", "changelog":
|
|
return true
|
|
}
|
|
}
|
|
return textExts[ext]
|
|
}
|
|
|
|
// extractText renvoie le texte d'un fichier indexable (vide si ce n'en est pas un).
|
|
func extractText(abs string, fi fs.FileInfo) string {
|
|
if !IsText(fi.Name()) || fi.Size() > maxIndexedSize {
|
|
return ""
|
|
}
|
|
b, err := os.ReadFile(abs)
|
|
if err != nil || !utf8.Valid(b) {
|
|
return ""
|
|
}
|
|
return string(b)
|
|
}
|
|
|
|
// content renvoie le texte indexé d'un fichier, relu seulement s'il a changé ;
|
|
// appelé sous index.mu.
|
|
func (s *Store) content(rel, abs string, fi fs.FileInfo) indexDoc {
|
|
d, ok := s.index.docs[rel]
|
|
if ok && d.mod.Equal(fi.ModTime()) && d.size == fi.Size() {
|
|
return d
|
|
}
|
|
d = indexDoc{mod: fi.ModTime(), size: fi.Size()}
|
|
d.text = extractText(abs, fi)
|
|
d.fold = fold(d.text)
|
|
s.index.docs[rel] = d
|
|
return d
|
|
}
|
|
|
|
// snippet renvoie la ligne du texte qui contient la position i (en octets
|
|
// de fold), raccourcie autour de la correspondance.
|
|
func snippet(d indexDoc, i, n int) string {
|
|
runes := []rune(d.text)
|
|
at := utf8.RuneCountInString(d.fold[:i])
|
|
end := at + utf8.RuneCountInString(d.fold[i:i+n])
|
|
lo, hi := at, end
|
|
for lo > 0 && runes[lo-1] != '\n' {
|
|
lo--
|
|
}
|
|
for hi < len(runes) && runes[hi] != '\n' {
|
|
hi++
|
|
}
|
|
const ctx = 40
|
|
pre, post := "", ""
|
|
if at-lo > ctx {
|
|
lo, pre = at-ctx, "…"
|
|
}
|
|
if hi-end > ctx {
|
|
hi, post = end+ctx, "…"
|
|
}
|
|
return pre + string(runes[lo:hi]) + post
|
|
}
|
|
|
|
// Filter restreint une recherche aux éléments portant un tag ou favoris.
|
|
type Filter struct {
|
|
Tag string
|
|
Favorite bool
|
|
}
|
|
|
|
// Search renvoie les entrées dont le nom, les tags ou, pour un fichier, le
|
|
// contenu contiennent tous les mots de q (casse et accents ignorés), et qui
|
|
// passent le filtre. Les correspondances sur le nom viennent en premier.
|
|
// q peut être vide si un filtre est donné.
|
|
func (s *Store) Search(q string, f Filter, limit int) ([]Hit, error) {
|
|
terms := strings.Fields(fold(q))
|
|
tag := fold(strings.TrimSpace(strings.TrimPrefix(strings.TrimSpace(f.Tag), "#")))
|
|
if len(terms) == 0 && tag == "" && !f.Favorite {
|
|
return []Hit{}, nil
|
|
}
|
|
meta := s.metaSnapshot()
|
|
if s.s3 != nil { // S3 : noms et tags seulement, pas de plein texte
|
|
out := []Hit{}
|
|
err := s.s3Walk("", func(rel string, e Entry) error {
|
|
if rel == "" || len(out) >= limit {
|
|
return nil
|
|
}
|
|
hit := Hit{Entry: e}
|
|
decorate(&hit.Entry, meta)
|
|
if f.Favorite && !hit.Favorite {
|
|
return nil
|
|
}
|
|
tags := fold(strings.Join(hit.Tags, "\n"))
|
|
if tag != "" && !strings.Contains("\n"+tags+"\n", "\n"+tag+"\n") {
|
|
return nil
|
|
}
|
|
name := fold(e.Name) + "\n" + tags
|
|
for _, t := range terms {
|
|
if !strings.Contains(name, t) {
|
|
return nil
|
|
}
|
|
}
|
|
out = append(out, hit)
|
|
return nil
|
|
})
|
|
return out, err
|
|
}
|
|
s.index.mu.Lock()
|
|
defer s.index.mu.Unlock()
|
|
if s.index.docs == nil {
|
|
s.index.docs = map[string]indexDoc{}
|
|
}
|
|
seen := map[string]bool{}
|
|
var byName, byContent []Hit
|
|
err := filepath.WalkDir(s.root, func(p string, d fs.DirEntry, err error) error {
|
|
if err != nil || p == s.root {
|
|
return nil
|
|
}
|
|
if strings.HasPrefix(d.Name(), ".") {
|
|
if d.IsDir() {
|
|
return filepath.SkipDir
|
|
}
|
|
return nil
|
|
}
|
|
if d.Type()&fs.ModeSymlink != 0 || (!d.IsDir() && !d.Type().IsRegular()) {
|
|
return nil
|
|
}
|
|
fi, err := d.Info()
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
rel, err := filepath.Rel(s.root, p)
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
rel = filepath.ToSlash(rel)
|
|
hit := Hit{Entry: toEntry(rel, fi)}
|
|
decorate(&hit.Entry, meta)
|
|
if f.Favorite && !hit.Favorite {
|
|
return nil
|
|
}
|
|
tags := fold(strings.Join(hit.Tags, "\n"))
|
|
if tag != "" && !strings.Contains("\n"+tags+"\n", "\n"+tag+"\n") {
|
|
return nil
|
|
}
|
|
name := fold(d.Name()) + "\n" + tags
|
|
var doc indexDoc
|
|
if !d.IsDir() {
|
|
seen[rel] = true
|
|
if len(terms) > 0 {
|
|
doc = s.content(rel, p, fi)
|
|
}
|
|
}
|
|
inName := true
|
|
for _, t := range terms {
|
|
if strings.Contains(name, t) {
|
|
continue
|
|
}
|
|
inName = false
|
|
i := strings.Index(doc.fold, t)
|
|
if i < 0 {
|
|
return nil
|
|
}
|
|
if hit.Snippet == "" {
|
|
hit.Snippet = snippet(doc, i, len(t))
|
|
}
|
|
}
|
|
if inName {
|
|
byName = append(byName, hit)
|
|
} else {
|
|
byContent = append(byContent, hit)
|
|
}
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for rel := range s.index.docs {
|
|
if !seen[rel] {
|
|
delete(s.index.docs, rel) // fichier supprimé ou déplacé
|
|
}
|
|
}
|
|
out := append(byName, byContent...)
|
|
if len(out) > limit {
|
|
out = out[:limit]
|
|
}
|
|
if out == nil {
|
|
out = []Hit{}
|
|
}
|
|
return out, nil
|
|
}
|