domino

package module
v0.0.0-...-303e5f0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 22, 2014 License: MIT Imports: 5 Imported by: 1

README

Domino

Domino is a Go library for creating and manipulating HTML documents using an elegant DOM API. It allows you to write HTML pages in pure Go reasonably concisely, which eliminates the need to learn another template language, and lets you take advantage of the more powerful features of Go.

Go:

package main

import "fmt"
import . "github.com/Knio/Domino"

func main() {
	d := NewDocument("Dominate your HTML")

	d.Head.Add(
		Link(Attr{"rel": "stylesheet", "href": "style.css"}),
		Script(Attr{"type": "text/javascript", "src": "script.js"}),
	)

	c := NewContext(d.Body.Div(Attr{"id": "header"}))

	c.Push(Ol())
	for _, i := range []string{"home", "about", "contact"} {
		Li(c, A(i, Attr{"href": fmt.Sprintf("/%s", i)}))
	}
	c.Pop()

	c.Div(Attr{"class": "body"}, P("Lorem ipsum.."))

	fmt.Print(d.IndentString())
}

HTML:

<!DOCTYPE html>
<html>
    <head>
        <title>Dominate your HTML</title>
        <link href="style.css" rel="stylesheet">
        <script src="script.js" type="text/javascript"></script>
    </head>
    <body>
        <div id="header"></div>
        <ol>
            <li>
                <a href="/home">home</a>
            </li>
            <li>
                <a href="/about">about</a>
            </li>
            <li>
                <a href="/contact">contact</a>
            </li>
        </ol>
        <div class="body">
            <p>Lorem ipsum..</p>
        </div>
    </body>
</html>

Compatibility

Domino is compatible with Go 1.1 and above.

Installation

The recommended way to install domino is with

go get github.com/Knio/Domino

Developed By

Git repository located at github.com/Knio/Domino

Documentation

Overview

Domino is a Go library for creating and manipulating HTML documents using an elegant DOM API. It allows you to write HTML pages in pure Go reasonably concisely, which eliminates the need to learn another template language, and lets you take advantage of the more powerful features of Go.

Index

Examples

Constants

This section is empty.

Variables

View Source 
var NSpaces = 4

NSpaces can be adjusted to determine how many spaces are used in each indent.

Functions

This section is empty.

Types

type Attr 

type Attr map[string]interface{}

Attr is a shorthand for map[string]interface{}, used when declaring attributes for DomNodes.

type Context 

type Context struct {
	*DomNode
	// contains filtered or unexported fields
}

Context is a stack of dom nodes, the last-in node becomes the focused node and from there you can add elements, text etc. to it before popping to get back up the stack. See examples.

Example 
// Establish a new context on a <div>
c := NewContext(Div())

// Push a <ul> on to the stack, adding it to the div automatically.
c.Push(Ul())
for i := 0; i < 2; i++ {
	// Add to the current context's focus <ul>
	c.Li(fmt.Sprintf("hello %d", i+1))
}
// Pop the <ul> off the stack, context focuses on the <div> again.
c.Pop()

// Add some spans to the div from before
Span(c, "end1")
c.Add(Span("end2"))
fmt.Println(c)

Output:

<div><ul><li>hello 1</li><li>hello 2</li></ul><span>end1</span><span>end2</span></div>

func NewContext 

func NewContext(n *DomNode) *Context

NewContext creates a context focused on the passed in dom node.

func (*Context) Pop 

func (c *Context) Pop()

Pop a node off of the stack, focus moves to the last-in node.

func (*Context) Push 

func (c *Context) Push(n *DomNode)

Push a node on to the stack and focus it. Adds the given node to the current focused node for convenience. See PushNoAdd if this behavior is undesired.

func (*Context) PushNoAdd 

func (c *Context) PushNoAdd(n *DomNode)

PushNoAdd pushes a new node on to the stack and focuses it, but does not add it to the current focused node's children.

type Document 

type Document struct {
	Html *DomNode
	Head *DomNode
	Body *DomNode
	// contains filtered or unexported fields
}

Document is a convenience type to help build a standard HTML5 document. It provides a doctype, and header/title/body structure.

Example 
// Create a document with the title Domino
d := NewDocument("Domino")

// Add an H1 to the body.
d.Body.H1("Hello World!")

// Add a script & style tag to the header.
d.Head.Script(Attr{"type": "text/javascript", "src": "//google.com/jquery.js"})
d.Head.Style(NewTextNode("a {\n    color: #FFF;\n}"))

fmt.Println(d.IndentString())

Output:

<!DOCTYPE html>
<html>
    <head>
        <title>Domino</title>
        <script src="//google.com/jquery.js" type="text/javascript"></script>
        <style>
            a {
                color: #FFF;
            }
        </style>
    </head>
    <body>
        <h1>Hello World!</h1>
    </body>
</html>

func NewDocument 

func NewDocument(title string) *Document

NewDocument creates a new HTML5 document with a title using the text provided

func (*Document) IndentString 

func (d *Document) IndentString() string

IndentString returns the HTML for the document with proper formatting.

func (*Document) SetTitle 

func (d *Document) SetTitle(title string)

SetTitle sets the title of the document.

func (*Document) String 

func (d *Document) String() string

String returns the HTML for the document.

type DomNode 

type DomNode struct {
	NodeName string
	Attrs    Attr
	Children []Node
}

DomNode is a node in a dom tree. It has children nodes and attributes.

func A 

func A(args ...interface{}) *DomNode

func Abbr 

func Abbr(args ...interface{}) *DomNode

func Address 

func Address(args ...interface{}) *DomNode

func Area 

func Area(args ...interface{}) *DomNode

func Article 

func Article(args ...interface{}) *DomNode

func Aside 

func Aside(args ...interface{}) *DomNode

func Audio 

func Audio(args ...interface{}) *DomNode

func B 

func B(args ...interface{}) *DomNode

func Base 

func Base(args ...interface{}) *DomNode

func Bdi 

func Bdi(args ...interface{}) *DomNode

func Bdo 

func Bdo(args ...interface{}) *DomNode

func Blockquote 

func Blockquote(args ...interface{}) *DomNode

func Body 

func Body(args ...interface{}) *DomNode

func Br 

func Br(args ...interface{}) *DomNode

func Button 

func Button(args ...interface{}) *DomNode

func Canvas 

func Canvas(args ...interface{}) *DomNode

func Caption 

func Caption(args ...interface{}) *DomNode

func Cite 

func Cite(args ...interface{}) *DomNode

func Code 

func Code(args ...interface{}) *DomNode

func Col 

func Col(args ...interface{}) *DomNode

func Colgroup 

func Colgroup(args ...interface{}) *DomNode

func Command 

func Command(args ...interface{}) *DomNode

func Datalist 

func Datalist(args ...interface{}) *DomNode

func Dd 

func Dd(args ...interface{}) *DomNode

func Del 

func Del(args ...interface{}) *DomNode

func Details 

func Details(args ...interface{}) *DomNode

func Dfn 

func Dfn(args ...interface{}) *DomNode

func Div 

func Div(args ...interface{}) *DomNode

func Dl 

func Dl(args ...interface{}) *DomNode

func Dt 

func Dt(args ...interface{}) *DomNode

func Em 

func Em(args ...interface{}) *DomNode

func Embed 

func Embed(args ...interface{}) *DomNode

func Fieldset 

func Fieldset(args ...interface{}) *DomNode

func Figcaption 

func Figcaption(args ...interface{}) *DomNode

func Figure 

func Figure(args ...interface{}) *DomNode
func Footer(args ...interface{}) *DomNode

func Form 

func Form(args ...interface{}) *DomNode

func H1 

func H1(args ...interface{}) *DomNode

func H2 

func H2(args ...interface{}) *DomNode

func H3 

func H3(args ...interface{}) *DomNode

func H4 

func H4(args ...interface{}) *DomNode

func H5 

func H5(args ...interface{}) *DomNode

func H6 

func H6(args ...interface{}) *DomNode
func Head(args ...interface{}) *DomNode
func Header(args ...interface{}) *DomNode

func Hgroup 

func Hgroup(args ...interface{}) *DomNode

func Hr 

func Hr(args ...interface{}) *DomNode

func Html 

func Html(args ...interface{}) *DomNode

func I 

func I(args ...interface{}) *DomNode

func Iframe 

func Iframe(args ...interface{}) *DomNode

func Img 

func Img(args ...interface{}) *DomNode

func Input_ 

func Input_(args ...interface{}) *DomNode

func Ins 

func Ins(args ...interface{}) *DomNode

func Kbd 

func Kbd(args ...interface{}) *DomNode

func Keygen 

func Keygen(args ...interface{}) *DomNode

func Label 

func Label(args ...interface{}) *DomNode

func Legend 

func Legend(args ...interface{}) *DomNode

func Li 

func Li(args ...interface{}) *DomNode
func Link(args ...interface{}) *DomNode

func Map_ 

func Map_(args ...interface{}) *DomNode

func Mark 

func Mark(args ...interface{}) *DomNode
func Menu(args ...interface{}) *DomNode

func Meta 

func Meta(args ...interface{}) *DomNode

func Meter 

func Meter(args ...interface{}) *DomNode
func Nav(args ...interface{}) *DomNode

func NewDomNode 

func NewDomNode(name string, args ...interface{}) *DomNode

NewDomNode creates a new dom node with it's name (div, ul, html) and any number of arguments, these can be: children dom or text nodes, or Attr lists.

func Noscript 

func Noscript(args ...interface{}) *DomNode

func Object 

func Object(args ...interface{}) *DomNode

func Ol 

func Ol(args ...interface{}) *DomNode

func Optgroup 

func Optgroup(args ...interface{}) *DomNode

func Option 

func Option(args ...interface{}) *DomNode

func Output 

func Output(args ...interface{}) *DomNode

func P 

func P(args ...interface{}) *DomNode

func Param 

func Param(args ...interface{}) *DomNode

func Pre 

func Pre(args ...interface{}) *DomNode

func Progress 

func Progress(args ...interface{}) *DomNode

func Q 

func Q(args ...interface{}) *DomNode

func Rp 

func Rp(args ...interface{}) *DomNode

func Rt 

func Rt(args ...interface{}) *DomNode

func Ruby 

func Ruby(args ...interface{}) *DomNode

func S 

func S(args ...interface{}) *DomNode

func Samp 

func Samp(args ...interface{}) *DomNode

func Script 

func Script(args ...interface{}) *DomNode

func Section 

func Section(args ...interface{}) *DomNode

func Select 

func Select(args ...interface{}) *DomNode

func Small 

func Small(args ...interface{}) *DomNode

func Source 

func Source(args ...interface{}) *DomNode

func Span 

func Span(args ...interface{}) *DomNode

func Strong 

func Strong(args ...interface{}) *DomNode

func Style 

func Style(args ...interface{}) *DomNode

func Sub 

func Sub(args ...interface{}) *DomNode

func Summary 

func Summary(args ...interface{}) *DomNode

func Sup 

func Sup(args ...interface{}) *DomNode

func Table 

func Table(args ...interface{}) *DomNode

func Tbody 

func Tbody(args ...interface{}) *DomNode

func Td 

func Td(args ...interface{}) *DomNode

func Textarea 

func Textarea(args ...interface{}) *DomNode

func Tfoot 

func Tfoot(args ...interface{}) *DomNode

func Th 

func Th(args ...interface{}) *DomNode

func Thead 

func Thead(args ...interface{}) *DomNode

func Time 

func Time(args ...interface{}) *DomNode

func Title 

func Title(args ...interface{}) *DomNode

func Tr 

func Tr(args ...interface{}) *DomNode

func Track 

func Track(args ...interface{}) *DomNode

func U 

func U(args ...interface{}) *DomNode

func Ul 

func Ul(args ...interface{}) *DomNode

func Var 

func Var(args ...interface{}) *DomNode

func Video 

func Video(args ...interface{}) *DomNode

func Wbr 

func Wbr(args ...interface{}) *DomNode

func (*DomNode) A 

func (n *DomNode) A(args ...interface{}) *DomNode

func (*DomNode) Abbr 

func (n *DomNode) Abbr(args ...interface{}) *DomNode

func (*DomNode) Add 

func (n *DomNode) Add(children ...Node) Node

Add a new child node.

func (*DomNode) Address 

func (n *DomNode) Address(args ...interface{}) *DomNode

func (*DomNode) Area 

func (n *DomNode) Area(args ...interface{}) *DomNode

func (*DomNode) Article 

func (n *DomNode) Article(args ...interface{}) *DomNode

func (*DomNode) Aside 

func (n *DomNode) Aside(args ...interface{}) *DomNode

func (*DomNode) Audio 

func (n *DomNode) Audio(args ...interface{}) *DomNode

func (*DomNode) B 

func (n *DomNode) B(args ...interface{}) *DomNode

func (*DomNode) Base 

func (n *DomNode) Base(args ...interface{}) *DomNode

func (*DomNode) Bdi 

func (n *DomNode) Bdi(args ...interface{}) *DomNode

func (*DomNode) Bdo 

func (n *DomNode) Bdo(args ...interface{}) *DomNode

func (*DomNode) Blockquote 

func (n *DomNode) Blockquote(args ...interface{}) *DomNode

func (*DomNode) Body 

func (n *DomNode) Body(args ...interface{}) *DomNode

func (*DomNode) Br 

func (n *DomNode) Br(args ...interface{}) *DomNode

func (*DomNode) Button 

func (n *DomNode) Button(args ...interface{}) *DomNode

func (*DomNode) Canvas 

func (n *DomNode) Canvas(args ...interface{}) *DomNode

func (*DomNode) Caption 

func (n *DomNode) Caption(args ...interface{}) *DomNode

func (*DomNode) Cite 

func (n *DomNode) Cite(args ...interface{}) *DomNode

func (*DomNode) Clear 

func (n *DomNode) Clear() *DomNode

Clear removes all children.

func (*DomNode) Code 

func (n *DomNode) Code(args ...interface{}) *DomNode

func (*DomNode) Col 

func (n *DomNode) Col(args ...interface{}) *DomNode

func (*DomNode) Colgroup 

func (n *DomNode) Colgroup(args ...interface{}) *DomNode

func (*DomNode) Command 

func (n *DomNode) Command(args ...interface{}) *DomNode

func (*DomNode) Datalist 

func (n *DomNode) Datalist(args ...interface{}) *DomNode

func (*DomNode) Dd 

func (n *DomNode) Dd(args ...interface{}) *DomNode

func (*DomNode) Del 

func (n *DomNode) Del(args ...interface{}) *DomNode

func (*DomNode) Details 

func (n *DomNode) Details(args ...interface{}) *DomNode

func (*DomNode) Dfn 

func (n *DomNode) Dfn(args ...interface{}) *DomNode

func (*DomNode) Div 

func (n *DomNode) Div(args ...interface{}) *DomNode

func (*DomNode) Dl 

func (n *DomNode) Dl(args ...interface{}) *DomNode

func (*DomNode) Dt 

func (n *DomNode) Dt(args ...interface{}) *DomNode

func (*DomNode) Em 

func (n *DomNode) Em(args ...interface{}) *DomNode

func (*DomNode) Embed 

func (n *DomNode) Embed(args ...interface{}) *DomNode

func (*DomNode) Fieldset 

func (n *DomNode) Fieldset(args ...interface{}) *DomNode

func (*DomNode) Figcaption 

func (n *DomNode) Figcaption(args ...interface{}) *DomNode

func (*DomNode) Figure 

func (n *DomNode) Figure(args ...interface{}) *DomNode

func (*DomNode) Footer 

func (n *DomNode) Footer(args ...interface{}) *DomNode

func (*DomNode) Form 

func (n *DomNode) Form(args ...interface{}) *DomNode

func (*DomNode) H1 

func (n *DomNode) H1(args ...interface{}) *DomNode

func (*DomNode) H2 

func (n *DomNode) H2(args ...interface{}) *DomNode

func (*DomNode) H3 

func (n *DomNode) H3(args ...interface{}) *DomNode

func (*DomNode) H4 

func (n *DomNode) H4(args ...interface{}) *DomNode

func (*DomNode) H5 

func (n *DomNode) H5(args ...interface{}) *DomNode

func (*DomNode) H6 

func (n *DomNode) H6(args ...interface{}) *DomNode

func (*DomNode) Head 

func (n *DomNode) Head(args ...interface{}) *DomNode

func (*DomNode) Header 

func (n *DomNode) Header(args ...interface{}) *DomNode

func (*DomNode) Hgroup 

func (n *DomNode) Hgroup(args ...interface{}) *DomNode

func (*DomNode) Hr 

func (n *DomNode) Hr(args ...interface{}) *DomNode

func (*DomNode) Html 

func (n *DomNode) Html(args ...interface{}) *DomNode

func (*DomNode) I 

func (n *DomNode) I(args ...interface{}) *DomNode

func (*DomNode) Iframe 

func (n *DomNode) Iframe(args ...interface{}) *DomNode

func (*DomNode) Img 

func (n *DomNode) Img(args ...interface{}) *DomNode

func (*DomNode) IndentString 

func (n *DomNode) IndentString() string

IndentString returns HTML for this node and all it's ancestors with indentation.

func (*DomNode) Input_ 

func (n *DomNode) Input_(args ...interface{}) *DomNode

func (*DomNode) Ins 

func (n *DomNode) Ins(args ...interface{}) *DomNode

func (*DomNode) Kbd 

func (n *DomNode) Kbd(args ...interface{}) *DomNode

func (*DomNode) Keygen 

func (n *DomNode) Keygen(args ...interface{}) *DomNode

func (*DomNode) Label 

func (n *DomNode) Label(args ...interface{}) *DomNode

func (*DomNode) Legend 

func (n *DomNode) Legend(args ...interface{}) *DomNode

func (*DomNode) Li 

func (n *DomNode) Li(args ...interface{}) *DomNode
func (n *DomNode) Link(args ...interface{}) *DomNode

func (*DomNode) Map_ 

func (n *DomNode) Map_(args ...interface{}) *DomNode

func (*DomNode) Mark 

func (n *DomNode) Mark(args ...interface{}) *DomNode

func (*DomNode) Menu 

func (n *DomNode) Menu(args ...interface{}) *DomNode

func (*DomNode) Meta 

func (n *DomNode) Meta(args ...interface{}) *DomNode

func (*DomNode) Meter 

func (n *DomNode) Meter(args ...interface{}) *DomNode

func (*DomNode) Nav 

func (n *DomNode) Nav(args ...interface{}) *DomNode

func (*DomNode) Noscript 

func (n *DomNode) Noscript(args ...interface{}) *DomNode

func (*DomNode) Object 

func (n *DomNode) Object(args ...interface{}) *DomNode

func (*DomNode) Ol 

func (n *DomNode) Ol(args ...interface{}) *DomNode

func (*DomNode) Optgroup 

func (n *DomNode) Optgroup(args ...interface{}) *DomNode

func (*DomNode) Option 

func (n *DomNode) Option(args ...interface{}) *DomNode

func (*DomNode) Output 

func (n *DomNode) Output(args ...interface{}) *DomNode

func (*DomNode) P 

func (n *DomNode) P(args ...interface{}) *DomNode

func (*DomNode) Param 

func (n *DomNode) Param(args ...interface{}) *DomNode

func (*DomNode) Pre 

func (n *DomNode) Pre(args ...interface{}) *DomNode

func (*DomNode) Progress 

func (n *DomNode) Progress(args ...interface{}) *DomNode

func (*DomNode) Q 

func (n *DomNode) Q(args ...interface{}) *DomNode

func (*DomNode) Rp 

func (n *DomNode) Rp(args ...interface{}) *DomNode

func (*DomNode) Rt 

func (n *DomNode) Rt(args ...interface{}) *DomNode

func (*DomNode) Ruby 

func (n *DomNode) Ruby(args ...interface{}) *DomNode

func (*DomNode) S 

func (n *DomNode) S(args ...interface{}) *DomNode

func (*DomNode) Samp 

func (n *DomNode) Samp(args ...interface{}) *DomNode

func (*DomNode) Script 

func (n *DomNode) Script(args ...interface{}) *DomNode

func (*DomNode) Section 

func (n *DomNode) Section(args ...interface{}) *DomNode

func (*DomNode) Select 

func (n *DomNode) Select(args ...interface{}) *DomNode

func (*DomNode) Small 

func (n *DomNode) Small(args ...interface{}) *DomNode

func (*DomNode) Source 

func (n *DomNode) Source(args ...interface{}) *DomNode

func (*DomNode) Span 

func (n *DomNode) Span(args ...interface{}) *DomNode

func (*DomNode) String 

func (n *DomNode) String() string

String returns HTML for this node and all it's ancestors.

func (*DomNode) StringBuild 

func (n *DomNode) StringBuild(b *bytes.Buffer, indent bool, depth int)

StringBuild appends the html for this node and all it's ancestors to the provided buffer.

func (*DomNode) Strong 

func (n *DomNode) Strong(args ...interface{}) *DomNode

func (*DomNode) Style 

func (n *DomNode) Style(args ...interface{}) *DomNode

func (*DomNode) Sub 

func (n *DomNode) Sub(args ...interface{}) *DomNode

func (*DomNode) Summary 

func (n *DomNode) Summary(args ...interface{}) *DomNode

func (*DomNode) Sup 

func (n *DomNode) Sup(args ...interface{}) *DomNode

func (*DomNode) Table 

func (n *DomNode) Table(args ...interface{}) *DomNode

func (*DomNode) Tbody 

func (n *DomNode) Tbody(args ...interface{}) *DomNode

func (*DomNode) Td 

func (n *DomNode) Td(args ...interface{}) *DomNode

func (*DomNode) Text 

func (n *DomNode) Text(text string) *DomNode

Text adds a text node with the provided text.

func (*DomNode) Textarea 

func (n *DomNode) Textarea(args ...interface{}) *DomNode

func (*DomNode) Tfoot 

func (n *DomNode) Tfoot(args ...interface{}) *DomNode

func (*DomNode) Th 

func (n *DomNode) Th(args ...interface{}) *DomNode

func (*DomNode) Thead 

func (n *DomNode) Thead(args ...interface{}) *DomNode

func (*DomNode) Time 

func (n *DomNode) Time(args ...interface{}) *DomNode

func (*DomNode) Title 

func (n *DomNode) Title(args ...interface{}) *DomNode

func (*DomNode) Tr 

func (n *DomNode) Tr(args ...interface{}) *DomNode

func (*DomNode) Track 

func (n *DomNode) Track(args ...interface{}) *DomNode

func (*DomNode) U 

func (n *DomNode) U(args ...interface{}) *DomNode

func (*DomNode) Ul 

func (n *DomNode) Ul(args ...interface{}) *DomNode

func (*DomNode) Var 

func (n *DomNode) Var(args ...interface{}) *DomNode

func (*DomNode) Video 

func (n *DomNode) Video(args ...interface{}) *DomNode

func (*DomNode) Wbr 

func (n *DomNode) Wbr(args ...interface{}) *DomNode

type Node 

type Node interface {
	String() string
	IndentString() string
	StringBuild(*bytes.Buffer, bool, int)
}

Node is basically a stringer interface but with the ability to append to a buffer for performance reasons.

type TextNode 

type TextNode struct {
	Value string
}

TextNode represents text in the dom tree. Text can not have child nodes or attributes.

func NewTextNode 

func NewTextNode(value string) *TextNode

NewTextNode creates a new text node with the provided text.

func (*TextNode) IndentString 

func (n *TextNode) IndentString() string

IndentString appends it's value to the provided buffer.

func (*TextNode) String 

func (n *TextNode) String() string

String returns HTML for this node and all its ancestors

func (*TextNode) StringBuild 

func (n *TextNode) StringBuild(b *bytes.Buffer, indent bool, depth int)

StringBuild appends it's value to the provided buffer.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.