Pacote de renderização de resposta simples, leve e rápida (JSON, JSONP, XML, YAML, HTML, Arquivo) para Go

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 usando
go $ go get github.com/thedevsaddam/renderer/..

Uso

Para usar o pacote importe-o em seu *.gocódigo
go 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, Templatequalquer um destes métodos. Estes são baseados no html/templatepacote.

Ao usar o Templatemé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 Templatemé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, HTMLvocê pode analisar um diretório de modelos usando patterne chamar o modelo por seu nome. Veja o exemplo de código abaixo:

html / index.html
html {{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.html
html {{define "header"}} <head> <title>Header</title> <h1>Header section</h1> </head> {{end}}

html / footer.html
html {{define "footer"}} <footer>Copyright &copy; 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 Viewpara 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.lout
html <html> <head> <title>{{block "title" .}} {{end}}</title> </head> <body> {{ template "content" . }} </body> </html>

ver / home.tpl ver / sobre.tpl
html {{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 .