go-render / go-renderer / go-response / golang json response / golang render json / render / renderer / response / response renderer

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 .

Related Posts