Scriggo

The scriggo command is a command-line tool used for managing and executing Scriggo templates. It supports HTML and Markdown, and provides capabilities for:

• Serving and building templates: Render templates with HTML and Markdown support.
• Interpreter initialization: Initialize an interpreter for running Scriggo programs written in Go.
• Code generation: Generate code for package importers.

Scriggo templates use a syntax that allows for powerful logic using Go as the scripting language. Key features include:

• Inheritance: Use {% extends "layout.html" %} to extend a base template.
• Imports: Use {% import "module.html" %} to include other files.
• Macros: Define reusable blocks with {% macro Name %} ... {% end %}.
• Partials: Render other templates using {{ render "filename.html" }}.
• Contextual Autoescaping: Built-in security for rendering content.
• Multi-format support: Templates can be written in plain text, HTML, Markdown, CSS, JavaScript, and JSON.

{% 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 %}

After compiling the WebAssembly binary, you must serve the following files using a web server to run the Scriggo playground in a browser:

• index.html
• playground.js
• scriggo.wasm
• wasm_exec.js

To compile Scriggo for use in a web environment on Linux, set the Go target environment to JavaScript/Wasm, import the necessary packages into a Go file, and build the .wasm binary. You must also copy the wasm_exec.js file from your Go installation to your project directory to enable the Wasm runtime in the browser.

export GOOS=js
export GOARCH=wasm
scriggo import -v -o packages.go
go build -tags osusergo,netgo -trimpath -o scriggo.wasm
cp "$(go env GOROOT)/misc/wasm/wasm_exec.js" .

To compile Scriggo for use in a web environment on Windows, set the Go target environment to JavaScript/Wasm using SET, import the packages, and build the .wasm binary. You must copy wasm_exec.js from your Go installation directory (typically C:\Program Files\Go\misc\wasm\wasm_exec.js) to your project directory.

SET GOOS=js
SET GOARCH=wasm
scriggo import -v -o packages.go
go build -tags osusergo,netgo -trimpath -o scriggo.wasm
copy "C:\Program Files\Go\misc\wasm\wasm_exec.js" .

To use Scriggo's syntax highlighting with highlight.js, you must build a custom version of the highlight.js library that includes the scriggo.js language definition. This requires node and the highlight.js source repository.

# 1. Clone highlight.js
git clone https://github.com/highlightjs/highlight.js
cd highlight.js

# 2. Checkout a specific release tag (e.g., 11.2.0)
git checkout 11.2.0

# 3. Install dependencies
npm install

# 4. Copy the Scriggo language definition into highlight.js
cp <path to Scriggo repo>/highlighters/highlight.js/scriggo.js src/languages

# 5. Build the syntax source with Scriggo support
node tools/build.js scriggo

# 6. Copy the built file to your destination
cp build/highlight.js <destination directory>
# OR for the minified version:
cp build/highlight.min.js <destination directory>

You can execute Scriggo programs (Go-like source code) by building them from a file system and then running the resulting program. Use scriggo.Build to compile the source and program.Run to execute it. The source code is provided via a scriggo.Files map.

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)
    }

}

If you want Scriggo to determine file formats using logic other than file extensions, implement the FormatFS interface. This interface embeds fs.FS and adds a Format(name string) (Format, error) method.

type MyFormatFS interface {
	fs.FS
	Format(name string) (scriggo.Format, error)
}

When Scriggo processes a Go package, it maps exported package-level identifiers to Scriggo-compatible values:

Note on Generics: Scriggo currently skips generic functions, generic types, and general interfaces during the extraction process.