Albirew/nyaa-pantsu
Archivé
1
0
Bifurcation 0
Ce dépôt a été archivé le 2022-05-07. Vous pouvez voir ses fichiers ou le cloner, mais pas ouvrir de ticket ou de demandes d'ajout, ni soumettre de changements.
nyaa-pantsu/vendor/github.com/CloudyKit/jet/template.go
akuma06 5991a21818 First batch of changes for the refactor (#1078)
* First batch of changes for the refactor

Added the support of gin in routes and other services/utils
Begining implementation of JetHTML

* Remove os folder

* Move scrapers to own repo

* Second batch of changes

All .jet.html are the working templates.
You can now test this PR, the index Page and upload works. If you want to complete the other html templates, you're welcome

* Move captcha to util

* Move uploadService to utils

* Use govalidator instead of regex

* Third batch of changes

All the front end should as previously.
I also fixed some minor things unrelated to the refactor (mostly style issues on static pages)
Now errors can be accessed by importing the "errors" helpers and using the `yield errors(name="xxx")` command in templates.
Same for infos.
Templates are now more hierarchized with a base template "base.jet.html" which is extended depending on the context in "index_site" or "index_admin" layouts. Those layouts are extended than in every pages.
Other helpers are captcha to render a captcha `yield captcha(captchaid="xxx")`
And also csrf, with the command `yield csrf_field()`
To translate, you don't have anymore to do `call $.T "xxx"`, you just have to do `T("xxx")`.

Pages for the website part are in folders in the folder "templates/site". Pages for the admin part are in "templates/admin". Layouts are separated in "templates/layouts". Helpers and menu are in "templates/layouts/helpers" and "templates/layouts/menu". Error pages should be put in "templates/errors"

* Added test on templates

When adding a new template, you have to tell to template_test.go, the context of the new template (if it doesn't use the common context)

* Panel admin works

Now the templating part should work. The PR can now be fully tested.

I think we should push the templating PR  and do the routes/controllers/removal of services in another branch. So we know that this one is functional

* Updated dependencies

* Fixed test for modelhelper

* Fix testing for commentlist

* Fix travis :')

* Just renamed router and removed network

* Applying same SEO fix

* Update form_validator.go

* Added back regexp package
2017-06-28 21:42:38 +10:00

403 lignes
11 Kio
Go

// Copyright 2016 José Santos <henrique_1609@me.com>
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Jet is a fast and dynamic template engine for the Go programming language, set of features
// includes very fast template execution, a dynamic and flexible language, template inheritance, low number of allocations,
// special interfaces to allow even further optimizations.
package jet
import (
"fmt"
"io"
"io/ioutil"
"path"
"reflect"
"strings"
"sync"
"text/template"
)
// Set is responsible to load,invoke parse and cache templates and relations
// every jet template is associated with one set.
// create a set with jet.NewSet(escapeeFn) returns a pointer to the Set
type Set struct {
loader Loader
templates map[string]*Template // parsed templates
escapee SafeWriter // escapee to use at runtime
globals VarMap // global scope for this template set
tmx *sync.RWMutex // template parsing mutex
gmx *sync.RWMutex // global variables map mutex
defaultExtensions []string
developmentMode bool
}
// SetDevelopmentMode set's development mode on/off, in development mode template will be recompiled on every run
func (s *Set) SetDevelopmentMode(b bool) *Set {
s.developmentMode = b
return s
}
func (a *Set) LookupGlobal(key string) (val interface{}, found bool) {
a.gmx.RLock()
val, found = a.globals[key]
a.gmx.RUnlock()
return
}
// AddGlobal add or set a global variable into the Set
func (s *Set) AddGlobal(key string, i interface{}) *Set {
s.gmx.Lock()
if s.globals == nil {
s.globals = make(VarMap)
}
s.globals[key] = reflect.ValueOf(i)
s.gmx.Unlock()
return s
}
func (s *Set) AddGlobalFunc(key string, fn Func) *Set {
return s.AddGlobal(key, fn)
}
// NewSetLoader creates a new set with custom Loader
func NewSetLoader(escapee SafeWriter, loader Loader) *Set {
return &Set{loader: loader, tmx: &sync.RWMutex{}, gmx: &sync.RWMutex{}, escapee: escapee, templates: make(map[string]*Template), defaultExtensions: append([]string{}, defaultExtensions...)}
}
// NewHTMLSetLoader creates a new set with custom Loader
func NewHTMLSetLoader(loader Loader) *Set {
return NewSetLoader(template.HTMLEscape, loader)
}
// NewSet creates a new set, dirs is a list of directories to be searched for templates
func NewSet(escapee SafeWriter, dirs ...string) *Set {
return NewSetLoader(escapee, &OSFileSystemLoader{dirs: dirs})
}
// NewHTMLSet creates a new set, dirs is a list of directories to be searched for templates
func NewHTMLSet(dirs ...string) *Set {
return NewSet(template.HTMLEscape, dirs...)
}
// AddPath add path to the lookup list, when loading a template the Set will
// look into the lookup list for the file matching the provided name.
func (s *Set) AddPath(path string) {
if loader, ok := s.loader.(hasAddPath); ok {
loader.AddPath(path)
} else {
panic(fmt.Sprintf("AddPath() not supported on custom loader of type %T", s.loader))
}
}
// AddGopathPath add path based on GOPATH env to the lookup list, when loading a template the Set will
// look into the lookup list for the file matching the provided name.
func (s *Set) AddGopathPath(path string) {
if loader, ok := s.loader.(hasAddGopathPath); ok {
loader.AddGopathPath(path)
} else {
panic(fmt.Sprintf("AddGopathPath() not supported on custom loader of type %T", s.loader))
}
}
// resolveName try to resolve a template name, the steps as follow
// 1. try provided path
// 2. try provided path+defaultExtensions
// ex: set.resolveName("catalog/products.list") with defaultExtensions set to []string{".html.jet",".jet"}
// try catalog/products.list
// try catalog/products.list.html.jet
// try catalog/products.list.jet
func (s *Set) resolveName(name string) (newName, fileName string, foundLoaded, foundFile bool) {
newName = name
if _, foundLoaded = s.templates[newName]; foundLoaded {
return
}
if fileName, foundFile = s.loader.Exists(name); foundFile {
return
}
for _, extension := range s.defaultExtensions {
newName = name + extension
if _, foundLoaded = s.templates[newName]; foundLoaded {
return
}
if fileName, foundFile = s.loader.Exists(newName); foundFile {
return
}
}
return
}
func (s *Set) resolveNameSibling(name, sibling string) (newName, fileName string, foundLoaded, foundFile, isRelativeName bool) {
if sibling != "" {
i := strings.LastIndex(sibling, "/")
if i != -1 {
if newName, fileName, foundLoaded, foundFile = s.resolveName(path.Join(sibling[:i+1], name)); foundFile || foundLoaded {
isRelativeName = true
return
}
}
}
newName, fileName, foundLoaded, foundFile = s.resolveName(name)
return
}
// Parse parses the template, this method will link the template to the set but not the set to
func (s *Set) Parse(name, content string) (*Template, error) {
sc := *s
sc.developmentMode = true
sc.tmx.RLock()
t, err := sc.parse(name, content)
sc.tmx.RUnlock()
return t, err
}
func (s *Set) loadFromFile(name, fileName string) (template *Template, err error) {
f, err := s.loader.Open(fileName)
if err != nil {
return nil, err
}
defer f.Close()
content, err := ioutil.ReadAll(f)
if err != nil {
return nil, err
}
return s.parse(name, string(content))
}
func (s *Set) getTemplateWhileParsing(parentName, name string) (template *Template, err error) {
name = path.Clean(name)
if s.developmentMode {
if newName, fileName, _, foundPath, _ := s.resolveNameSibling(name, parentName); foundPath {
return s.loadFromFile(newName, fileName)
} else {
return nil, fmt.Errorf("template %s can't be loaded", name)
}
}
if newName, fileName, foundLoaded, foundPath, isRelative := s.resolveNameSibling(name, parentName); foundPath {
template, err = s.loadFromFile(newName, fileName)
s.templates[newName] = template
if !isRelative {
s.templates[name] = template
}
} else if foundLoaded {
template = s.templates[newName]
if !isRelative && name != newName {
s.templates[name] = template
}
} else {
err = fmt.Errorf("template %s can't be loaded", name)
}
return
}
// getTemplate gets a template already loaded by name
func (s *Set) getTemplate(name, sibling string) (template *Template, err error) {
name = path.Clean(name)
if s.developmentMode {
s.tmx.RLock()
defer s.tmx.RUnlock()
if newName, fileName, foundLoaded, foundFile, _ := s.resolveNameSibling(name, sibling); foundFile || foundLoaded {
if foundFile {
template, err = s.loadFromFile(newName, fileName)
} else {
template, _ = s.templates[newName]
}
} else {
err = fmt.Errorf("template %s can't be loaded", name)
}
return
}
//fast path
s.tmx.RLock()
newName, fileName, foundLoaded, foundFile, isRelative := s.resolveNameSibling(name, sibling)
if foundLoaded {
template = s.templates[newName]
s.tmx.RUnlock()
if !isRelative && name != newName {
// creates an alias
s.tmx.Lock()
if _, found := s.templates[name]; !found {
s.templates[name] = template
}
s.tmx.Unlock()
}
return
}
s.tmx.RUnlock()
//not found parses and cache
s.tmx.Lock()
defer s.tmx.Unlock()
newName, fileName, foundLoaded, foundFile, isRelative = s.resolveNameSibling(name, sibling)
if foundLoaded {
template = s.templates[newName]
if !isRelative && name != newName {
// creates an alias
if _, found := s.templates[name]; !found {
s.templates[name] = template
}
}
} else if foundFile {
template, err = s.loadFromFile(newName, fileName)
if !isRelative && name != newName {
// creates an alias
if _, found := s.templates[name]; !found {
s.templates[name] = template
}
}
s.templates[newName] = template
} else {
err = fmt.Errorf("template %s can't be loaded", name)
}
return
}
func (s *Set) GetTemplate(name string) (template *Template, err error) {
template, err = s.getTemplate(name, "")
return
}
func (s *Set) LoadTemplate(name, content string) (template *Template, err error) {
if s.developmentMode {
s.tmx.RLock()
defer s.tmx.RUnlock()
template, err = s.parse(name, content)
return
}
//fast path
var found bool
s.tmx.RLock()
if template, found = s.templates[name]; found {
s.tmx.RUnlock()
return
}
s.tmx.RUnlock()
//not found parses and cache
s.tmx.Lock()
defer s.tmx.Unlock()
if template, found = s.templates[name]; found {
return
}
if template, err = s.parse(name, content); err == nil {
s.templates[name] = template
}
return
}
func (t *Template) String() (template string) {
if t.extends != nil {
if len(t.Root.Nodes) > 0 && len(t.imports) == 0 {
template += fmt.Sprintf("{{extends %q}}", t.extends.ParseName)
} else {
template += fmt.Sprintf("{{extends %q}}", t.extends.ParseName)
}
}
for k, _import := range t.imports {
if t.extends == nil && k == 0 {
template += fmt.Sprintf("{{import %q}}", _import.ParseName)
} else {
template += fmt.Sprintf("\n{{import %q}}", _import.ParseName)
}
}
if t.extends != nil || len(t.imports) > 0 {
if len(t.Root.Nodes) > 0 {
template += "\n" + t.Root.String()
}
} else {
template += t.Root.String()
}
return
}
func (t *Template) addBlocks(blocks map[string]*BlockNode) {
if len(blocks) > 0 {
if t.processedBlocks == nil {
t.processedBlocks = make(map[string]*BlockNode)
}
for key, value := range blocks {
t.processedBlocks[key] = value
}
}
}
type VarMap map[string]reflect.Value
func (scope VarMap) Set(name string, v interface{}) VarMap {
scope[name] = reflect.ValueOf(v)
return scope
}
func (scope VarMap) SetFunc(name string, v Func) VarMap {
scope[name] = reflect.ValueOf(v)
return scope
}
func (scope VarMap) SetWriter(name string, v SafeWriter) VarMap {
scope[name] = reflect.ValueOf(v)
return scope
}
// Execute executes the template in the w Writer
func (t *Template) Execute(w io.Writer, variables VarMap, data interface{}) error {
return t.ExecuteI18N(nil, w, variables, data)
}
type Translator interface {
Msg(key, defaultValue string) string
Trans(format, defaultFormat string, v ...interface{}) string
}
func (t *Template) ExecuteI18N(translator Translator, w io.Writer, variables VarMap, data interface{}) (err error) {
st := pool_State.Get().(*Runtime)
defer st.recover(&err)
st.blocks = t.processedBlocks
st.translator = translator
st.variables = variables
st.set = t.set
st.Writer = w
// resolve extended template
for t.extends != nil {
t = t.extends
}
if data != nil {
st.context = reflect.ValueOf(data)
}
st.executeList(t.Root)
return
}