Renderizador de pacote
Pacote de renderização de resposta simples, leve e rápida (JSON, JSONP, XML, YAML, HTML, Arquivo) para Go
Instalação
Instale o pacote usandogo $ go get github.com/thedevsaddam/renderer/..
Uso
Para usar o pacote importe-o em seu *.go
códigogo import "github.com/thedevsaddam/renderer"
Exemplo
package main
import (
"io"
"log"
"net/http"
"os"
"github.com/thedevsaddam/renderer"
)
func main() {
r := renderer.New()
mux := http.NewServeMux()
usr := struct {
Name string
Age int
}{"John Doe", 30}
// serving String as text/plain
mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
r.String(w, http.StatusOK, "Welcome to renderer")
})
// serving success but no content
mux.HandleFunc("/no-content", func(w http.ResponseWriter, req *http.Request) {
r.NoContent(w)
})
// serving JSON
mux.HandleFunc("/json", func(w http.ResponseWriter, req *http.Request) {
r.JSON(w, http.StatusOK, usr)
})
// serving JSONP
mux.HandleFunc("/jsonp", func(w http.ResponseWriter, req *http.Request) {
r.JSONP(w, http.StatusOK, "callback", usr)
})
// serving XML
mux.HandleFunc("/xml", func(w http.ResponseWriter, req *http.Request) {
r.XML(w, http.StatusOK, usr)
})
// serving YAML
mux.HandleFunc("/yaml", func(w http.ResponseWriter, req *http.Request) {
r.YAML(w, http.StatusOK, usr)
})
// serving File as arbitary binary data
mux.HandleFunc("/binary", func(w http.ResponseWriter, req *http.Request) {
var reader io.Reader
reader, _ = os.Open("../README.md")
r.Binary(w, http.StatusOK, reader, "readme.md", true)
})
// serving File as inline
mux.HandleFunc("/file-inline", func(w http.ResponseWriter, req *http.Request) {
r.FileView(w, http.StatusOK, "../README.md", "readme.md")
})
// serving File as attachment
mux.HandleFunc("/file-download", func(w http.ResponseWriter, req *http.Request) {
r.FileDownload(w, http.StatusOK, "../README.md", "readme.md")
})
// serving File from reader as inline
mux.HandleFunc("/file-reader", func(w http.ResponseWriter, req *http.Request) {
var reader io.Reader
reader, _ = os.Open("../README.md")
r.File(w, http.StatusOK, reader, "readme.md", true)
})
// serving custom response using render and chaining methods
mux.HandleFunc("/render", func(w http.ResponseWriter, req *http.Request) {
w.Header().Set(renderer.ContentType, renderer.ContentText)
r.Render(w, http.StatusOK, []byte("Send the message as text response"))
})
port := ":9000"
log.Println("Listening on port", port)
http.ListenAndServe(port, mux)
}
Como renderizar o template html?
Bem, você pode analisar HTML modelo usando HTML
, View
, Template
qualquer um destes métodos. Estes são baseados no html/template
pacote.
Ao usar o Template
método, você pode simplesmente passar os layouts de base e o caminho dos modelos como um pedaço de string.
Exemplo de modelo
Você pode analisar o modelo em tempo real usando o Template
método. Você pode definir o delimitador, injetar o FuncMap facilmente.
template / layout.tmpl template / index.tmpl “ `html {{definir” title “}} Página inicial {{end}}html <html> <head> <title>{{ template "title" . }}</title> </head> <body> {{ template "content" . }} </body> {{ block "sidebar" .}}{{end}} </html>
{{definir “conteúdo”}}
<h1> Olá, {{.Nome | toUpper}} </h1>
Lorem ipsum dolor sit amet, consectetur adipisicing elit. </p>
{{end}} html {{define “sidebar”}} código de barra lateral simples {{end}} template/partial.tmpl
template.go
```go
package main
import (
"html/template"
"log"
"net/http"
"strings"
"github.com/thedevsaddam/renderer"
)
var r *renderer.Render
var err error
func init() {
r = renderer.New()
if err != nil {
log.Fatal(err)
}
}
func toUpper(s string) string {
return strings.ToUpper(s)
}
func handler(w http.ResponseWriter, req *http.Request) {
usr := struct {
Name string
Age int
}{"john doe", 30}
tpls := []string{"template/layout.tmpl", "template/index.tmpl", "template/partial.tmpl"}
r.FuncMap(template.FuncMap{
"toUpper": toUpper,
})
err = r.Template(w, http.StatusOK, tpls, usr)
if err != nil {
log.Fatal(err) //respond with error page or message
}
}
func main() {
http.HandleFunc("/", handler)
log.Println("Listening port: 9000")
http.ListenAndServe(":9000", nil)
}
Exemplo de HTML
Ao usar, HTML
você pode analisar um diretório de modelos usando pattern
e chamar o modelo por seu nome. Veja o exemplo de código abaixo:
html / index.htmlhtml {{define "indexPage"}} <html> {{template "header"}} <body> <h3>Index</h3> <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit</p> </body> {{template "footer"}} </html> {{end}}
html / header.htmlhtml {{define "header"}} <head> <title>Header</title> <h1>Header section</h1> </head> {{end}}
html / footer.htmlhtml {{define "footer"}} <footer>Copyright © 2020</footer> {{end}}
html.go
“ `go
package main
import (
“log”
“net / http”
"github.com/thedevsaddam/renderer"
)
var r * renderer.Render
função init () {
r = renderer.New (
renderer.Options {
ParseGlobPattern: “html / *. html”,
},
)
}
manipulador de função (w http.ResponseWriter, req * http.Request) {
err: = r.HTML (w, http.StatusOK, “indexPage”, nil)
if err! = nil {
log.Fatal (err)
}
}
função main () {
http.HandleFunc (“/”, handler)
log.Println (“Listening port: 9000”)
http.ListenAndServe (“: 9000”, nil)
}
“ `
Veja o exemplo
Ao usar View
para analisar o modelo, você pode passar vários layouts e modelos. Aqui, o nome do modelo será o nome do arquivo. Veja o exemplo para ter uma ideia.
view / base.louthtml <html> <head> <title>{{block "title" .}} {{end}}</title> </head> <body> {{ template "content" . }} </body> </html>
ver / home.tpl ver / sobre.tplhtml {{define "title"}}Home{{end}} {{define "content"}} <h3>Home page</h3> <ul> <li><a href="/">Home</a></li> <li><a href="/about">About Me</a></li> </ul> <p> Lorem ipsum dolor sit amet</p> {{end}}
html {{define "title"}}About Me{{end}} {{define "content"}} <h2>This is About me page.</h2> <ul> Lorem ipsum dolor sit amet, consectetur adipisicing elit, </ul> <p><a href="/">Home</a></p> {{end}}
view.go
“ `go
package main
import (
“log”
“net / http”
"github.com/thedevsaddam/renderer"
)
var r * renderer.Render
var err error
func init () {
r = renderer.New (renderer.Options {
TemplateDir: “view”,
})
if err! = nil {
log.Fatal (err)
}
}
func home (w http.ResponseWriter, req * http.Request) {
err = r.VIEW (w, http.StatusOK, “home”, nil)
if err! = nil {
log.Fatal (err)
}
}
func sobre (w http.ResponseWriter, req * http.Request) {
err = r.VIEW (w, http.StatusOK, “sobre”, nil)
if err! = nil {
log.Fatal (err)
}
}
func main () {
http.HandleFunc (“/”, home)
http.HandleFunc (“/ about”, about)
log.Println (“Porta de escuta: 9000 n / is root n / about is about page”)
http .ListenAndServe (“: 9000”, nil)
}
“ `
Nota: Este é um invólucro em cima dos pacotes integrados go para fornecer açúcar sintático.
Contribuição
Suas sugestões serão mais do que apreciadas.
Leia o guia de contribuição aqui
Veja todos os contribuidores
Leia o documento da API para saber sobre as opções e métodos disponíveis
Licença
O renderizador é um software de código aberto licenciado sob a Licença MIT .