Skip to content

Latest commit

 

History

History
139 lines (102 loc) · 3.62 KB

README.md

File metadata and controls

139 lines (102 loc) · 3.62 KB
Raw

Scriggo

The world’s most powerful template engine and Go embeddable interpreter.

Go Reference Go Report Card Coverage

Website | Get Started | Documentation | Community | Contributing

Features

  • Fast, a very fast embeddable pure Go language interpreter.
  • Modern and powerful template engine with Go as scripting language.
  • Native support for Markdown in templates.
  • Secure by default. No access to packages unless explicitly enabled.
  • Easy to embed and to interop with any Go application.

Get Started with Programs

Execute a Go program embedded in your application:

package main

import "github.com/open2b/scriggo"

func main() {

    // src is the source code of the program to run.
    src := []byte(`
        package main

        func main() {
            println("Hello, World!")
        }
    `)

    // Create a file system with the file of the program to run.
    fsys := scriggo.Files{"main.go": src}

    // Build the program.
    program, err := scriggo.Build(fsys, nil)
    if err != nil {
        panic(err)
    }
 
    // Run the program.
    err = program.Run(nil)
    if err != nil {
        panic(err)
    }

}

Get Started with Templates

Scriggo, in templates, supports inheritance, macros, partials, imports and contextual autoescaping but most of all it uses the Go language as the template scripting language.

{% extends "layout.html" %}
{% import "banners.html" %}
{% macro Body %}
    <ul>
      {% for product in products %}
      <li><a href="{{ product.URL }}">{{ product.Name }}</a></li>
      {% end %}
    </ul>
    {{ render "pagination.html" }}
    {{ Banner() }}
{% end %}

Scriggo template files can be written in plain text, HTML, Markdown, CSS, JavaScript and JSON.

Execute a Scriggo template in your application

// Build and run a Scriggo template.
package main

import (
	"os"

	"github.com/open2b/scriggo"
	"github.com/open2b/scriggo/builtin"
	"github.com/open2b/scriggo/native"
)

func main() {

    // Content of the template file to run.
    content := []byte(`
    <!DOCTYPE html>
    <html>
    <head>Hello</head> 
    <body>
        Hello, {{ capitalize(who) }}!
    </body>
    </html>
    `)

    // Create a file system with the file of the template to run.
    fsys := scriggo.Files{"index.html": content}

    // Declare some globals.
    var who = "world"
    opts := &scriggo.BuildOptions{
        Globals: native.Declarations{
            "who":        &who,               // global variable
            "capitalize": builtin.Capitalize, // global function
        },
    }

    // Build the template.
    template, err := scriggo.BuildTemplate(fsys, "index.html", opts)
    if err != nil {
        panic(err)
    }
 
    // Run the template and print it to the standard output.
    err = template.Run(os.Stdout, nil, nil)
    if err != nil {
        panic(err)
    }

}

For a complete get started guide see the Scriggo site.

Contributing

Want to help contribute to Scriggo? See CONTRIBUTING.md.