--- /dev/null
+// Copyright 2011 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"
+ "errors"
+ "fmt"
+ "html/template"
+ "io"
+ "io/ioutil"
+ "log"
+ "net/url"
+ "regexp"
+ "strings"
+ "time"
+ "unicode"
+ "unicode/utf8"
+
+ "github.com/yuin/goldmark"
+ "github.com/yuin/goldmark/ast"
+ "github.com/yuin/goldmark/renderer/html"
+ "github.com/yuin/goldmark/text"
+)
+
+var (
+ parsers = make(map[string]ParseFunc)
+ funcs = template.FuncMap{}
+)
+
+// Template returns an empty template with the action functions in its FuncMap.
+func Template() *template.Template {
+ return template.New("").Funcs(funcs)
+}
+
+// Render renders the doc to the given writer using the provided template.
+func (d *Doc) Render(w io.Writer, t *template.Template) error {
+ data := struct {
+ *Doc
+ Template *template.Template
+ PlayEnabled bool
+ NotesEnabled bool
+ }{d, t, PlayEnabled, NotesEnabled}
+ return t.ExecuteTemplate(w, "root", data)
+}
+
+// Render renders the section to the given writer using the provided template.
+func (s *Section) Render(w io.Writer, t *template.Template) error {
+ data := struct {
+ *Section
+ Template *template.Template
+ PlayEnabled bool
+ }{s, t, PlayEnabled}
+ return t.ExecuteTemplate(w, "section", data)
+}
+
+type ParseFunc func(ctx *Context, fileName string, lineNumber int, inputLine string) (Elem, error)
+
+// Register binds the named action, which does not begin with a period, to the
+// specified parser to be invoked when the name, with a period, appears in the
+// present input text.
+func Register(name string, parser ParseFunc) {
+ if len(name) == 0 || name[0] == ';' {
+ panic("bad name in Register: " + name)
+ }
+ parsers["."+name] = parser
+}
+
+// Doc represents an entire document.
+type Doc struct {
+ Title string
+ Subtitle string
+ Summary string
+ Time time.Time
+ Authors []Author
+ TitleNotes []string
+ Sections []Section
+ Tags []string
+ OldURL []string
+}
+
+// Author represents the person who wrote and/or is presenting the document.
+type Author struct {
+ Elem []Elem
+}
+
+// TextElem returns the first text elements of the author details.
+// This is used to display the author' name, job title, and company
+// without the contact details.
+func (p *Author) TextElem() (elems []Elem) {
+ for _, el := range p.Elem {
+ if _, ok := el.(Text); !ok {
+ break
+ }
+ elems = append(elems, el)
+ }
+ return
+}
+
+// Section represents a section of a document (such as a presentation slide)
+// comprising a title and a list of elements.
+type Section struct {
+ Number []int
+ Title string
+ ID string // HTML anchor ID
+ Elem []Elem
+ Notes []string
+ Classes []string
+ Styles []string
+}
+
+// HTMLAttributes for the section
+func (s Section) HTMLAttributes() template.HTMLAttr {
+ if len(s.Classes) == 0 && len(s.Styles) == 0 {
+ return ""
+ }
+
+ var class string
+ if len(s.Classes) > 0 {
+ class = fmt.Sprintf(`class=%q`, strings.Join(s.Classes, " "))
+ }
+ var style string
+ if len(s.Styles) > 0 {
+ style = fmt.Sprintf(`style=%q`, strings.Join(s.Styles, " "))
+ }
+ return template.HTMLAttr(strings.Join([]string{class, style}, " "))
+}
+
+// Sections contained within the section.
+func (s Section) Sections() (sections []Section) {
+ for _, e := range s.Elem {
+ if section, ok := e.(Section); ok {
+ sections = append(sections, section)
+ }
+ }
+ return
+}
+
+// Level returns the level of the given section.
+// The document title is level 1, main section 2, etc.
+func (s Section) Level() int {
+ return len(s.Number) + 1
+}
+
+// FormattedNumber returns a string containing the concatenation of the
+// numbers identifying a Section.
+func (s Section) FormattedNumber() string {
+ b := &bytes.Buffer{}
+ for _, n := range s.Number {
+ fmt.Fprintf(b, "%v.", n)
+ }
+ return b.String()
+}
+
+func (s Section) TemplateName() string { return "section" }
+
+// Elem defines the interface for a present element. That is, something that
+// can provide the name of the template used to render the element.
+type Elem interface {
+ TemplateName() string
+}
+
+// renderElem implements the elem template function, used to render
+// sub-templates.
+func renderElem(t *template.Template, e Elem) (template.HTML, error) {
+ var data interface{} = e
+ if s, ok := e.(Section); ok {
+ data = struct {
+ Section
+ Template *template.Template
+ }{s, t}
+ }
+ return execTemplate(t, e.TemplateName(), data)
+}
+
+// pageNum derives a page number from a section.
+func pageNum(s Section, offset int) int {
+ if len(s.Number) == 0 {
+ return offset
+ }
+ return s.Number[0] + offset
+}
+
+func init() {
+ funcs["elem"] = renderElem
+ funcs["pagenum"] = pageNum
+}
+
+// execTemplate is a helper to execute a template and return the output as a
+// template.HTML value.
+func execTemplate(t *template.Template, name string, data interface{}) (template.HTML, error) {
+ b := new(bytes.Buffer)
+ err := t.ExecuteTemplate(b, name, data)
+ if err != nil {
+ return "", err
+ }
+ return template.HTML(b.String()), nil
+}
+
+// Text represents an optionally preformatted paragraph.
+type Text struct {
+ Lines []string
+ Pre bool
+ Raw string // original text, for Pre==true
+}
+
+func (t Text) TemplateName() string { return "text" }
+
+// List represents a bulleted list.
+type List struct {
+ Bullet []string
+}
+
+func (l List) TemplateName() string { return "list" }
+
+// Lines is a helper for parsing line-based input.
+type Lines struct {
+ line int // 0 indexed, so has 1-indexed number of last line returned
+ text []string
+ comment string
+}
+
+func readLines(r io.Reader) (*Lines, error) {
+ var lines []string
+ s := bufio.NewScanner(r)
+ for s.Scan() {
+ lines = append(lines, s.Text())
+ }
+ if err := s.Err(); err != nil {
+ return nil, err
+ }
+ return &Lines{0, lines, "#"}, nil
+}
+
+func (l *Lines) next() (text string, ok bool) {
+ for {
+ current := l.line
+ l.line++
+ if current >= len(l.text) {
+ return "", false
+ }
+ text = l.text[current]
+ // Lines starting with l.comment are comments.
+ if l.comment == "" || !strings.HasPrefix(text, l.comment) {
+ ok = true
+ break
+ }
+ }
+ return
+}
+
+func (l *Lines) back() {
+ l.line--
+}
+
+func (l *Lines) nextNonEmpty() (text string, ok bool) {
+ for {
+ text, ok = l.next()
+ if !ok {
+ return
+ }
+ if len(text) > 0 {
+ break
+ }
+ }
+ return
+}
+
+// A Context specifies the supporting context for parsing a presentation.
+type Context struct {
+ // ReadFile reads the file named by filename and returns the contents.
+ ReadFile func(filename string) ([]byte, error)
+}
+
+// ParseMode represents flags for the Parse function.
+type ParseMode int
+
+const (
+ // If set, parse only the title and subtitle.
+ TitlesOnly ParseMode = 1
+)
+
+// Parse parses a document from r.
+func (ctx *Context) Parse(r io.Reader, name string, mode ParseMode) (*Doc, error) {
+ doc := new(Doc)
+ lines, err := readLines(r)
+ if err != nil {
+ return nil, err
+ }
+
+ // Detect Markdown-enabled vs legacy present file.
+ // Markdown-enabled files have a title line beginning with "# "
+ // (like preprocessed C files of yore).
+ isMarkdown := false
+ for i := lines.line; i < len(lines.text); i++ {
+ line := lines.text[i]
+ if line == "" {
+ continue
+ }
+ isMarkdown = strings.HasPrefix(line, "# ")
+ break
+ }
+
+ sectionPrefix := "*"
+ if isMarkdown {
+ sectionPrefix = "##"
+ lines.comment = "//"
+ }
+
+ for i := lines.line; i < len(lines.text); i++ {
+ if strings.HasPrefix(lines.text[i], sectionPrefix) {
+ break
+ }
+
+ if isSpeakerNote(lines.text[i]) {
+ doc.TitleNotes = append(doc.TitleNotes, trimSpeakerNote(lines.text[i]))
+ }
+ }
+
+ err = parseHeader(doc, isMarkdown, lines)
+ if err != nil {
+ return nil, err
+ }
+ if mode&TitlesOnly != 0 {
+ return doc, nil
+ }
+
+ // Authors
+ if doc.Authors, err = parseAuthors(name, sectionPrefix, lines); err != nil {
+ return nil, err
+ }
+
+ // Sections
+ if doc.Sections, err = parseSections(ctx, name, sectionPrefix, lines, []int{}); err != nil {
+ return nil, err
+ }
+
+ return doc, nil
+}
+
+// Parse parses a document from r. Parse reads assets used by the presentation
+// from the file system using ioutil.ReadFile.
+func Parse(r io.Reader, name string, mode ParseMode) (*Doc, error) {
+ ctx := Context{ReadFile: ioutil.ReadFile}
+ return ctx.Parse(r, name, mode)
+}
+
+// isHeading matches any section heading.
+var (
+ isHeadingLegacy = regexp.MustCompile(`^\*+( |$)`)
+ isHeadingMarkdown = regexp.MustCompile(`^\#+( |$)`)
+)
+
+// lesserHeading returns true if text is a heading of a lesser or equal level
+// than that denoted by prefix.
+func lesserHeading(isHeading *regexp.Regexp, text, prefix string) bool {
+ return isHeading.MatchString(text) && !strings.HasPrefix(text, prefix+prefix[:1])
+}
+
+// parseSections parses Sections from lines for the section level indicated by
+// number (a nil number indicates the top level).
+func parseSections(ctx *Context, name, prefix string, lines *Lines, number []int) ([]Section, error) {
+ isMarkdown := prefix[0] == '#'
+ isHeading := isHeadingLegacy
+ if isMarkdown {
+ isHeading = isHeadingMarkdown
+ }
+ var sections []Section
+ for i := 1; ; i++ {
+ // Next non-empty line is title.
+ text, ok := lines.nextNonEmpty()
+ for ok && text == "" {
+ text, ok = lines.next()
+ }
+ if !ok {
+ break
+ }
+ if text != prefix && !strings.HasPrefix(text, prefix+" ") {
+ lines.back()
+ break
+ }
+ // Markdown sections can end in {#id} to set the HTML anchor for the section.
+ // This is nicer than the default #TOC_1_2-style anchor.
+ title := strings.TrimSpace(text[len(prefix):])
+ id := ""
+ if isMarkdown && strings.HasSuffix(title, "}") {
+ j := strings.LastIndex(title, "{#")
+ if j >= 0 {
+ id = title[j+2 : len(title)-1]
+ title = strings.TrimSpace(title[:j])
+ }
+ }
+ section := Section{
+ Number: append(append([]int{}, number...), i),
+ Title: title,
+ ID: id,
+ }
+ text, ok = lines.nextNonEmpty()
+ for ok && !lesserHeading(isHeading, text, prefix) {
+ var e Elem
+ r, _ := utf8.DecodeRuneInString(text)
+ switch {
+ case !isMarkdown && unicode.IsSpace(r):
+ i := strings.IndexFunc(text, func(r rune) bool {
+ return !unicode.IsSpace(r)
+ })
+ if i < 0 {
+ break
+ }
+ indent := text[:i]
+ var s []string
+ for ok && (strings.HasPrefix(text, indent) || text == "") {
+ if text != "" {
+ text = text[i:]
+ }
+ s = append(s, text)
+ text, ok = lines.next()
+ }
+ lines.back()
+ pre := strings.Join(s, "\n")
+ raw := pre
+ pre = strings.Replace(pre, "\t", " ", -1) // browsers treat tabs badly
+ pre = strings.TrimRightFunc(pre, unicode.IsSpace)
+ e = Text{Lines: []string{pre}, Pre: true, Raw: raw}
+ case !isMarkdown && strings.HasPrefix(text, "- "):
+ var b []string
+ for {
+ if strings.HasPrefix(text, "- ") {
+ b = append(b, text[2:])
+ } else if len(b) > 0 && strings.HasPrefix(text, " ") {
+ b[len(b)-1] += "\n" + strings.TrimSpace(text)
+ } else {
+ break
+ }
+ if text, ok = lines.next(); !ok {
+ break
+ }
+ }
+ lines.back()
+ e = List{Bullet: b}
+ case isSpeakerNote(text):
+ section.Notes = append(section.Notes, trimSpeakerNote(text))
+ case strings.HasPrefix(text, prefix+prefix[:1]+" ") || text == prefix+prefix[:1]:
+ lines.back()
+ subsecs, err := parseSections(ctx, name, prefix+prefix[:1], lines, section.Number)
+ if err != nil {
+ return nil, err
+ }
+ for _, ss := range subsecs {
+ section.Elem = append(section.Elem, ss)
+ }
+ case strings.HasPrefix(text, prefix+prefix[:1]):
+ return nil, fmt.Errorf("%s:%d: badly nested section inside %s: %s", name, lines.line, prefix, text)
+ case strings.HasPrefix(text, "."):
+ args := strings.Fields(text)
+ if args[0] == ".background" {
+ section.Classes = append(section.Classes, "background")
+ section.Styles = append(section.Styles, "background-image: url('"+args[1]+"')")
+ break
+ }
+ parser := parsers[args[0]]
+ if parser == nil {
+ return nil, fmt.Errorf("%s:%d: unknown command %q", name, lines.line, text)
+ }
+ t, err := parser(ctx, name, lines.line, text)
+ if err != nil {
+ return nil, err
+ }
+ e = t
+
+ case isMarkdown:
+ // Collect Markdown lines, including blank lines and indented text.
+ var block []string
+ endLine, endBlock := lines.line-1, -1 // end is last non-empty line
+ for ok {
+ trim := strings.TrimSpace(text)
+ if trim != "" {
+ // Command breaks text block.
+ // Section heading breaks text block in markdown.
+ if text[0] == '.' || text[0] == '#' || isSpeakerNote(text) {
+ break
+ }
+ if strings.HasPrefix(text, `\.`) { // Backslash escapes initial period.
+ text = text[1:]
+ }
+ endLine, endBlock = lines.line, len(block)
+ }
+ block = append(block, text)
+ text, ok = lines.next()
+ }
+ block = block[:endBlock+1]
+ lines.line = endLine + 1
+ if len(block) == 0 {
+ break
+ }
+
+ // Replace all leading tabs with 4 spaces,
+ // which render better in code blocks.
+ // CommonMark defines that for parsing the structure of the file
+ // a tab is equivalent to 4 spaces, so this change won't
+ // affect the later parsing at all.
+ // An alternative would be to apply this to code blocks after parsing,
+ // at the same time that we update <a> targets, but that turns out
+ // to be quite difficult to modify in the AST.
+ for i, line := range block {
+ if len(line) > 0 && line[0] == '\t' {
+ short := strings.TrimLeft(line, "\t")
+ line = strings.Repeat(" ", len(line)-len(short)) + short
+ block[i] = line
+ }
+ }
+ html, err := renderMarkdown([]byte(strings.Join(block, "\n")))
+ if err != nil {
+ return nil, err
+ }
+ e = HTML{HTML: html}
+
+ default:
+ // Collect text lines.
+ var block []string
+ for ok && strings.TrimSpace(text) != "" {
+ // Command breaks text block.
+ // Section heading breaks text block in markdown.
+ if text[0] == '.' || isSpeakerNote(text) {
+ break
+ }
+ if strings.HasPrefix(text, `\.`) { // Backslash escapes initial period.
+ text = text[1:]
+ }
+ block = append(block, text)
+ text, ok = lines.next()
+ }
+ if len(block) == 0 {
+ break
+ }
+ e = Text{Lines: block}
+ }
+ if e != nil {
+ section.Elem = append(section.Elem, e)
+ }
+ text, ok = lines.nextNonEmpty()
+ }
+ if isHeading.MatchString(text) {
+ lines.back()
+ }
+ sections = append(sections, section)
+ }
+
+ if len(sections) == 0 {
+ return nil, fmt.Errorf("%s:%d: unexpected line: %s", name, lines.line+1, lines.text[lines.line])
+ }
+ return sections, nil
+}
+
+func parseHeader(doc *Doc, isMarkdown bool, lines *Lines) error {
+ var ok bool
+ // First non-empty line starts header.
+ doc.Title, ok = lines.nextNonEmpty()
+ if !ok {
+ return errors.New("unexpected EOF; expected title")
+ }
+ if isMarkdown {
+ doc.Title = strings.TrimSpace(strings.TrimPrefix(doc.Title, "#"))
+ }
+
+ for {
+ text, ok := lines.next()
+ if !ok {
+ return errors.New("unexpected EOF")
+ }
+ if text == "" {
+ break
+ }
+ if isSpeakerNote(text) {
+ continue
+ }
+ if strings.HasPrefix(text, "Tags:") {
+ tags := strings.Split(text[len("Tags:"):], ",")
+ for i := range tags {
+ tags[i] = strings.TrimSpace(tags[i])
+ }
+ doc.Tags = append(doc.Tags, tags...)
+ } else if strings.HasPrefix(text, "Summary:") {
+ doc.Summary = strings.TrimSpace(text[len("Summary:"):])
+ } else if strings.HasPrefix(text, "OldURL:") {
+ doc.OldURL = append(doc.OldURL, strings.TrimSpace(text[len("OldURL:"):]))
+ } else if t, ok := parseTime(text); ok {
+ doc.Time = t
+ } else if doc.Subtitle == "" {
+ doc.Subtitle = text
+ } else {
+ return fmt.Errorf("unexpected header line: %q", text)
+ }
+ }
+ return nil
+}
+
+func parseAuthors(name, sectionPrefix string, lines *Lines) (authors []Author, err error) {
+ // This grammar demarcates authors with blanks.
+
+ // Skip blank lines.
+ if _, ok := lines.nextNonEmpty(); !ok {
+ return nil, errors.New("unexpected EOF")
+ }
+ lines.back()
+
+ var a *Author
+ for {
+ text, ok := lines.next()
+ if !ok {
+ return nil, errors.New("unexpected EOF")
+ }
+
+ // If we find a section heading, we're done.
+ if strings.HasPrefix(text, sectionPrefix) {
+ lines.back()
+ break
+ }
+
+ if isSpeakerNote(text) {
+ continue
+ }
+
+ // If we encounter a blank we're done with this author.
+ if a != nil && len(text) == 0 {
+ authors = append(authors, *a)
+ a = nil
+ continue
+ }
+ if a == nil {
+ a = new(Author)
+ }
+
+ // Parse the line. Those that
+ // - begin with @ are twitter names,
+ // - contain slashes are links, or
+ // - contain an @ symbol are an email address.
+ // The rest is just text.
+ var el Elem
+ switch {
+ case strings.HasPrefix(text, "@"):
+ el = parseAuthorURL(name, "http://twitter.com/"+text[1:])
+ case strings.Contains(text, ":"):
+ el = parseAuthorURL(name, text)
+ case strings.Contains(text, "@"):
+ el = parseAuthorURL(name, "mailto:"+text)
+ }
+ if l, ok := el.(Link); ok {
+ l.Label = text
+ el = l
+ }
+ if el == nil {
+ el = Text{Lines: []string{text}}
+ }
+ a.Elem = append(a.Elem, el)
+ }
+ if a != nil {
+ authors = append(authors, *a)
+ }
+ return authors, nil
+}
+
+func parseAuthorURL(name, text string) Elem {
+ u, err := url.Parse(text)
+ if err != nil {
+ log.Printf("parsing %s author block: invalid URL %q: %v", name, text, err)
+ return nil
+ }
+ return Link{URL: u}
+}
+
+func parseTime(text string) (t time.Time, ok bool) {
+ t, err := time.Parse("15:04 2 Jan 2006", text)
+ if err == nil {
+ return t, true
+ }
+ t, err = time.Parse("2 Jan 2006", text)
+ if err == nil {
+ // at 11am UTC it is the same date everywhere
+ t = t.Add(time.Hour * 11)
+ return t, true
+ }
+ return time.Time{}, false
+}
+
+func isSpeakerNote(s string) bool {
+ return strings.HasPrefix(s, ": ") || s == ":"
+}
+
+func trimSpeakerNote(s string) string {
+ if s == ":" {
+ return ""
+ }
+ return strings.TrimPrefix(s, ": ")
+}
+
+func renderMarkdown(input []byte) (template.HTML, error) {
+ md := goldmark.New(goldmark.WithRendererOptions(html.WithUnsafe()))
+ reader := text.NewReader(input)
+ doc := md.Parser().Parse(reader)
+ fixupMarkdown(doc)
+ var b strings.Builder
+ if err := md.Renderer().Render(&b, input, doc); err != nil {
+ return "", err
+ }
+ return template.HTML(b.String()), nil
+}
+
+func fixupMarkdown(n ast.Node) {
+ ast.Walk(n, func(n ast.Node, entering bool) (ast.WalkStatus, error) {
+ if entering {
+ switch n := n.(type) {
+ case *ast.Link:
+ n.SetAttributeString("target", []byte("_blank"))
+ // https://developers.google.com/web/tools/lighthouse/audits/noopener
+ n.SetAttributeString("rel", []byte("noopener"))
+ }
+ }
+ return ast.WalkContinue, nil
+ })
+}
projects / dotfiles / .git / blobdiff