268 lines
7.6 KiB
Go
268 lines
7.6 KiB
Go
|
// Copyright 2012 The Go Authors. All rights reserved.
|
||
|
|
// Use of this source code is governed by a BSD-style
|
||
|
|
// license that can be found in the LICENSE file.
|
||
|
|
|
||
|
|
package present
|
||
|
|
|
||
|
|
import (
|
||
|
|
"bufio"
|
||
|
|
"bytes"
|
||
|
|
"fmt"
|
||
|
|
"html/template"
|
||
|
|
"path/filepath"
|
||
|
|
"regexp"
|
||
|
|
"strconv"
|
||
|
|
"strings"
|
||
|
|
)
|
||
|
|
|
||
|
|
// PlayEnabled specifies whether runnable playground snippets should be
|
||
|
|
// displayed in the present user interface.
|
||
|
|
var PlayEnabled = false
|
||
|
|
|
||
|
|
// TODO(adg): replace the PlayEnabled flag with something less spaghetti-like.
|
||
|
|
// Instead this will probably be determined by a template execution Context
|
||
|
|
// value that contains various global metadata required when rendering
|
||
|
|
// templates.
|
||
|
|
|
||
|
|
// NotesEnabled specifies whether presenter notes should be displayed in the
|
||
|
|
// present user interface.
|
||
|
|
var NotesEnabled = false
|
||
|
|
|
||
|
|
func init() {
|
||
|
|
Register("code", parseCode)
|
||
|
|
Register("play", parseCode)
|
||
|
|
}
|
||
|
|
|
||
|
|
type Code struct {
|
||
|
|
Text template.HTML
|
||
|
|
Play bool // runnable code
|
||
|
|
Edit bool // editable code
|
||
|
|
FileName string // file name
|
||
|
|
Ext string // file extension
|
||
|
|
Raw []byte // content of the file
|
||
|
|
}
|
||
|
|
|
||
|
|
func (c Code) TemplateName() string { return "code" }
|
||
|
|
|
||
|
|
// The input line is a .code or .play entry with a file name and an optional HLfoo marker on the end.
|
||
|
|
// Anything between the file and HL (if any) is an address expression, which we treat as a string here.
|
||
|
|
// We pick off the HL first, for easy parsing.
|
||
|
|
var (
|
||
|
|
highlightRE = regexp.MustCompile(`\s+HL([a-zA-Z0-9_]+)?$`)
|
||
|
|
hlCommentRE = regexp.MustCompile(`(.+) // HL(.*)$`)
|
||
|
|
codeRE = regexp.MustCompile(`\.(code|play)\s+((?:(?:-edit|-numbers)\s+)*)([^\s]+)(?:\s+(.*))?$`)
|
||
|
|
)
|
||
|
|
|
||
|
|
// parseCode parses a code present directive. Its syntax:
|
||
|
|
// .code [-numbers] [-edit] <filename> [address] [highlight]
|
||
|
|
// The directive may also be ".play" if the snippet is executable.
|
||
|
|
func parseCode(ctx *Context, sourceFile string, sourceLine int, cmd string) (Elem, error) {
|
||
|
|
cmd = strings.TrimSpace(cmd)
|
||
|
|
|
||
|
|
// Pull off the HL, if any, from the end of the input line.
|
||
|
|
highlight := ""
|
||
|
|
if hl := highlightRE.FindStringSubmatchIndex(cmd); len(hl) == 4 {
|
||
|
|
if hl[2] < 0 || hl[3] < 0 {
|
||
|
|
return nil, fmt.Errorf("%s:%d invalid highlight syntax", sourceFile, sourceLine)
|
||
|
|
}
|
||
|
|
highlight = cmd[hl[2]:hl[3]]
|
||
|
|
cmd = cmd[:hl[2]-2]
|
||
|
|
}
|
||
|
|
|
||
|
|
// Parse the remaining command line.
|
||
|
|
// Arguments:
|
||
|
|
// args[0]: whole match
|
||
|
|
// args[1]: .code/.play
|
||
|
|
// args[2]: flags ("-edit -numbers")
|
||
|
|
// args[3]: file name
|
||
|
|
// args[4]: optional address
|
||
|
|
args := codeRE.FindStringSubmatch(cmd)
|
||
|
|
if len(args) != 5 {
|
||
|
|
return nil, fmt.Errorf("%s:%d: syntax error for .code/.play invocation", sourceFile, sourceLine)
|
||
|
|
}
|
||
|
|
command, flags, file, addr := args[1], args[2], args[3], strings.TrimSpace(args[4])
|
||
|
|
play := command == "play" && PlayEnabled
|
||
|
|
|
||
|
|
// Read in code file and (optionally) match address.
|
||
|
|
filename := filepath.Join(filepath.Dir(sourceFile), file)
|
||
|
|
textBytes, err := ctx.ReadFile(filename)
|
||
|
|
if err != nil {
|
||
|
|
return nil, fmt.Errorf("%s:%d: %v", sourceFile, sourceLine, err)
|
||
|
|
}
|
||
|
|
lo, hi, err := addrToByteRange(addr, 0, textBytes)
|
||
|
|
if err != nil {
|
||
|
|
return nil, fmt.Errorf("%s:%d: %v", sourceFile, sourceLine, err)
|
||
|
|
}
|
||
|
|
if lo > hi {
|
||
|
|
// The search in addrToByteRange can wrap around so we might
|
||
|
|
// end up with the range ending before its starting point
|
||
|
|
hi, lo = lo, hi
|
||
|
|
}
|
||
|
|
|
||
|
|
// Acme pattern matches can stop mid-line,
|
||
|
|
// so run to end of line in both directions if not at line start/end.
|
||
|
|
for lo > 0 && textBytes[lo-1] != '\n' {
|
||
|
|
lo--
|
||
|
|
}
|
||
|
|
if hi > 0 {
|
||
|
|
for hi < len(textBytes) && textBytes[hi-1] != '\n' {
|
||
|
|
hi++
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
lines := codeLines(textBytes, lo, hi)
|
||
|
|
|
||
|
|
data := &codeTemplateData{
|
||
|
|
Lines: formatLines(lines, highlight),
|
||
|
|
Edit: strings.Contains(flags, "-edit"),
|
||
|
|
Numbers: strings.Contains(flags, "-numbers"),
|
||
|
|
}
|
||
|
|
|
||
|
|
// Include before and after in a hidden span for playground code.
|
||
|
|
if play {
|
||
|
|
data.Prefix = textBytes[:lo]
|
||
|
|
data.Suffix = textBytes[hi:]
|
||
|
|
}
|
||
|
|
|
||
|
|
var buf bytes.Buffer
|
||
|
|
if err := codeTemplate.Execute(&buf, data); err != nil {
|
||
|
|
return nil, err
|
||
|
|
}
|
||
|
|
return Code{
|
||
|
|
Text: template.HTML(buf.String()),
|
||
|
|
Play: play,
|
||
|
|
Edit: data.Edit,
|
||
|
|
FileName: filepath.Base(filename),
|
||
|
|
Ext: filepath.Ext(filename),
|
||
|
|
Raw: rawCode(lines),
|
||
|
|
}, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
// formatLines returns a new slice of codeLine with the given lines
|
||
|
|
// replacing tabs with spaces and adding highlighting where needed.
|
||
|
|
func formatLines(lines []codeLine, highlight string) []codeLine {
|
||
|
|
formatted := make([]codeLine, len(lines))
|
||
|
|
for i, line := range lines {
|
||
|
|
// Replace tabs with spaces, which work better in HTML.
|
||
|
|
line.L = strings.Replace(line.L, "\t", " ", -1)
|
||
|
|
|
||
|
|
// Highlight lines that end with "// HL[highlight]"
|
||
|
|
// and strip the magic comment.
|
||
|
|
if m := hlCommentRE.FindStringSubmatch(line.L); m != nil {
|
||
|
|
line.L = m[1]
|
||
|
|
line.HL = m[2] == highlight
|
||
|
|
}
|
||
|
|
|
||
|
|
formatted[i] = line
|
||
|
|
}
|
||
|
|
return formatted
|
||
|
|
}
|
||
|
|
|
||
|
|
// rawCode returns the code represented by the given codeLines without any kind
|
||
|
|
// of formatting.
|
||
|
|
func rawCode(lines []codeLine) []byte {
|
||
|
|
b := new(bytes.Buffer)
|
||
|
|
for _, line := range lines {
|
||
|
|
b.WriteString(line.L)
|
||
|
|
b.WriteByte('\n')
|
||
|
|
}
|
||
|
|
return b.Bytes()
|
||
|
|
}
|
||
|
|
|
||
|
|
type codeTemplateData struct {
|
||
|
|
Lines []codeLine
|
||
|
|
Prefix, Suffix []byte
|
||
|
|
Edit, Numbers bool
|
||
|
|
}
|
||
|
|
|
||
|
|
var leadingSpaceRE = regexp.MustCompile(`^[ \t]*`)
|
||
|
|
|
||
|
|
var codeTemplate = template.Must(template.New("code").Funcs(template.FuncMap{
|
||
|
|
"trimSpace": strings.TrimSpace,
|
||
|
|
"leadingSpace": leadingSpaceRE.FindString,
|
||
|
|
}).Parse(codeTemplateHTML))
|
||
|
|
|
||
|
|
const codeTemplateHTML = `
|
||
|
|
{{with .Prefix}}<pre style="display: none"><span>{{printf "%s" .}}</span></pre>{{end}}
|
||
|
|
|
||
|
|
<pre{{if .Edit}} contenteditable="true" spellcheck="false"{{end}}{{if .Numbers}} class="numbers"{{end}}>{{/*
|
||
|
|
*/}}{{range .Lines}}<span num="{{.N}}">{{/*
|
||
|
|
*/}}{{if .HL}}{{leadingSpace .L}}<b>{{trimSpace .L}}</b>{{/*
|
||
|
|
*/}}{{else}}{{.L}}{{end}}{{/*
|
||
|
|
*/}}</span>
|
||
|
|
{{end}}</pre>
|
||
|
|
|
||
|
|
{{with .Suffix}}<pre style="display: none"><span>{{printf "%s" .}}</span></pre>{{end}}
|
||
|
|
`
|
||
|
|
|
||
|
|
// codeLine represents a line of code extracted from a source file.
|
||
|
|
type codeLine struct {
|
||
|
|
L string // The line of code.
|
||
|
|
N int // The line number from the source file.
|
||
|
|
HL bool // Whether the line should be highlighted.
|
||
|
|
}
|
||
|
|
|
||
|
|
// codeLines takes a source file and returns the lines that
|
||
|
|
// span the byte range specified by start and end.
|
||
|
|
// It discards lines that end in "OMIT".
|
||
|
|
func codeLines(src []byte, start, end int) (lines []codeLine) {
|
||
|
|
startLine := 1
|
||
|
|
for i, b := range src {
|
||
|
|
if i == start {
|
||
|
|
break
|
||
|
|
}
|
||
|
|
if b == '\n' {
|
||
|
|
startLine++
|
||
|
|
}
|
||
|
|
}
|
||
|
|
s := bufio.NewScanner(bytes.NewReader(src[start:end]))
|
||
|
|
for n := startLine; s.Scan(); n++ {
|
||
|
|
l := s.Text()
|
||
|
|
if strings.HasSuffix(l, "OMIT") {
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
lines = append(lines, codeLine{L: l, N: n})
|
||
|
|
}
|
||
|
|
// Trim leading and trailing blank lines.
|
||
|
|
for len(lines) > 0 && len(lines[0].L) == 0 {
|
||
|
|
lines = lines[1:]
|
||
|
|
}
|
||
|
|
for len(lines) > 0 && len(lines[len(lines)-1].L) == 0 {
|
||
|
|
lines = lines[:len(lines)-1]
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
func parseArgs(name string, line int, args []string) (res []interface{}, err error) {
|
||
|
|
res = make([]interface{}, len(args))
|
||
|
|
for i, v := range args {
|
||
|
|
if len(v) == 0 {
|
||
|
|
return nil, fmt.Errorf("%s:%d bad code argument %q", name, line, v)
|
||
|
|
}
|
||
|
|
switch v[0] {
|
||
|
|
case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
|
||
|
|
n, err := strconv.Atoi(v)
|
||
|
|
if err != nil {
|
||
|
|
return nil, fmt.Errorf("%s:%d bad code argument %q", name, line, v)
|
||
|
|
}
|
||
|
|
res[i] = n
|
||
|
|
case '/':
|
||
|
|
if len(v) < 2 || v[len(v)-1] != '/' {
|
||
|
|
return nil, fmt.Errorf("%s:%d bad code argument %q", name, line, v)
|
||
|
|
}
|
||
|
|
res[i] = v
|
||
|
|
case '$':
|
||
|
|
res[i] = "$"
|
||
|
|
case '_':
|
||
|
|
if len(v) == 1 {
|
||
|
|
// Do nothing; "_" indicates an intentionally empty parameter.
|
||
|
|
break
|
||
|
|
}
|
||
|
|
fallthrough
|
||
|
|
default:
|
||
|
|
return nil, fmt.Errorf("%s:%d bad code argument %q", name, line, v)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return
|
||
|
|
}
|