Method Process

server/web_files.go:104–153

(path string, file http.File, data any)

}

func (tp *templateProcessor) Process(path string, file http.File, data any) ([]byte, error) {
	stat, e := file.Stat()
	if e != nil {
		return nil, e
	}

	if stat.IsDir() || (tp.filter != nil && !tp.filter(path)) {
		return nil, ErrUnprocessed
	}

	name := stat.Name()
	tag := strconv.FormatInt(stat.ModTime().UnixMilli(), 10) + strconv.FormatInt(stat.Size(), 10)

	cached, ok := tp.cache.Get(name)
	if !ok {
		nc := newTemplateCache(name)
		// SetIfAbsent avoids two concurrent first-requests creating
		// (and parsing into) two different templateCache instances.
		if tp.cache.SetIfAbsent(name, nc) {
			cached = nc
		} else {
			cached, _ = tp.cache.Get(name)
		}
	}

	// Hold the lock while reading/(re)parsing the template and capturing the
	// parsed template pointer, to avoid a data race between Parse (write) and
	// Execute (read) when the underlying file changes.
	cached.l.Lock()
	if tag != cached.tag {
		content, e := io.ReadAll(file)
		if e != nil {
			cached.l.Unlock()
			return nil, e
		}
		if e := cached.Parse(string(content)); e != nil {
			cached.l.Unlock()
			return nil, e
		}
		cached.tag = tag
	}
	t := cached.t
	cached.l.Unlock()

	buf := bytes.NewBuffer(nil)
	if e := t.Execute(buf, data); e != nil {
		return nil, e
	}
	return buf.Bytes(), nil
}

func newTemplateCache(name string) *templateCache {
	return &templateCache{name: strings.ToLower(name), l: sync.Mutex{}}