--- /dev/null
+// Copyright 2020 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.
+
+// Present2md converts legacy-syntax present files to Markdown-syntax present files.
+//
+// Usage:
+//
+// present2md [-w] [file ...]
+//
+// By default, present2md prints the Markdown-syntax form of each input file to standard output.
+// If no input file is listed, standard input is used.
+//
+// The -w flag causes present2md to update the files in place, overwriting each with its
+// Markdown-syntax equivalent.
+//
+// Examples
+//
+// present2md your.article
+// present2md -w *.article
+//
+package main
+
+import (
+ "bytes"
+ "flag"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "log"
+ "net/url"
+ "os"
+ "strings"
+ "unicode"
+ "unicode/utf8"
+
+ "golang.org/x/tools/present"
+)
+
+func usage() {
+ fmt.Fprintf(os.Stderr, "usage: present2md [-w] [file ...]\n")
+ os.Exit(2)
+}
+
+var (
+ writeBack = flag.Bool("w", false, "write conversions back to original files")
+ exitStatus = 0
+)
+
+func main() {
+ log.SetPrefix("present2md: ")
+ log.SetFlags(0)
+ flag.Usage = usage
+ flag.Parse()
+
+ args := flag.Args()
+ if len(args) == 0 {
+ if *writeBack {
+ log.Fatalf("cannot use -w with standard input")
+ }
+ convert(os.Stdin, "stdin", false)
+ return
+ }
+
+ for _, arg := range args {
+ f, err := os.Open(arg)
+ if err != nil {
+ log.Print(err)
+ exitStatus = 1
+ continue
+ }
+ err = convert(f, arg, *writeBack)
+ f.Close()
+ if err != nil {
+ log.Print(err)
+ exitStatus = 1
+ }
+ }
+ os.Exit(exitStatus)
+}
+
+// convert reads the data from r, parses it as legacy present,
+// and converts it to Markdown-enabled present.
+// If any errors occur, the data is reported as coming from file.
+// If writeBack is true, the converted version is written back to file.
+// If writeBack is false, the converted version is printed to standard output.
+func convert(r io.Reader, file string, writeBack bool) error {
+ data, err := ioutil.ReadAll(r)
+ if err != nil {
+ return err
+ }
+ if bytes.HasPrefix(data, []byte("# ")) {
+ return fmt.Errorf("%v: already markdown", file)
+ }
+
+ doc, err := present.Parse(bytes.NewReader(data), file, 0)
+ if err != nil {
+ return err
+ }
+
+ // Title and Subtitle, Time, Tags.
+ var md bytes.Buffer
+ fmt.Fprintf(&md, "# %s\n", doc.Title)
+ if doc.Subtitle != "" {
+ fmt.Fprintf(&md, "%s\n", doc.Subtitle)
+ }
+ if !doc.Time.IsZero() {
+ fmt.Fprintf(&md, "%s\n", doc.Time.Format("2 Jan 2006"))
+ }
+ if len(doc.Tags) > 0 {
+ fmt.Fprintf(&md, "Tags: %s\n", strings.Join(doc.Tags, ", "))
+ }
+
+ // Summary, defaulting to first paragraph of section.
+ // (Summaries must be explicit for Markdown-enabled present,
+ // and the expectation is that they will be shorter than the
+ // whole first paragraph. But this is what the blog does today.)
+ if strings.HasSuffix(file, ".article") && len(doc.Sections) > 0 {
+ for _, elem := range doc.Sections[0].Elem {
+ text, ok := elem.(present.Text)
+ if !ok || text.Pre {
+ // skip everything but non-text elements
+ continue
+ }
+ fmt.Fprintf(&md, "Summary:")
+ for i, line := range text.Lines {
+ fmt.Fprintf(&md, " ")
+ printStyled(&md, line, i == 0)
+ }
+ fmt.Fprintf(&md, "\n")
+ break
+ }
+ }
+
+ // Authors
+ for _, a := range doc.Authors {
+ fmt.Fprintf(&md, "\n")
+ for _, elem := range a.Elem {
+ switch elem := elem.(type) {
+ default:
+ // Can only happen if this type switch is incomplete, which is a bug.
+ log.Fatalf("%s: unexpected author type %T", file, elem)
+ case present.Text:
+ for _, line := range elem.Lines {
+ fmt.Fprintf(&md, "%s\n", markdownEscape(line, true))
+ }
+ case present.Link:
+ fmt.Fprintf(&md, "%s\n", markdownEscape(elem.Label, true))
+ }
+ }
+ }
+
+ // Invariant: the output ends in non-blank line now,
+ // and after printing any piece of the file below,
+ // the output should still end in a non-blank line.
+ // If a blank line separator is needed, it should be printed
+ // before the block that needs separating, not after.
+
+ if len(doc.TitleNotes) > 0 {
+ fmt.Fprintf(&md, "\n")
+ for _, line := range doc.TitleNotes {
+ fmt.Fprintf(&md, ": %s\n", line)
+ }
+ }
+
+ if len(doc.Sections) == 1 && strings.HasSuffix(file, ".article") {
+ // Blog drops section headers when there is only one section.
+ // Don't print a title in this case, to make clear that it's being dropped.
+ fmt.Fprintf(&md, "\n##\n")
+ printSectionBody(file, 1, &md, doc.Sections[0].Elem)
+ } else {
+ for _, s := range doc.Sections {
+ fmt.Fprintf(&md, "\n")
+ fmt.Fprintf(&md, "## %s\n", markdownEscape(s.Title, false))
+ printSectionBody(file, 1, &md, s.Elem)
+ }
+ }
+
+ if !writeBack {
+ os.Stdout.Write(md.Bytes())
+ return nil
+ }
+ return ioutil.WriteFile(file, md.Bytes(), 0666)
+}
+
+func printSectionBody(file string, depth int, w *bytes.Buffer, elems []present.Elem) {
+ for _, elem := range elems {
+ switch elem := elem.(type) {
+ default:
+ // Can only happen if this type switch is incomplete, which is a bug.
+ log.Fatalf("%s: unexpected present element type %T", file, elem)
+
+ case present.Text:
+ fmt.Fprintf(w, "\n")
+ lines := elem.Lines
+ for len(lines) > 0 && lines[0] == "" {
+ lines = lines[1:]
+ }
+ if elem.Pre {
+ for _, line := range strings.Split(strings.TrimRight(elem.Raw, "\n"), "\n") {
+ if line == "" {
+ fmt.Fprintf(w, "\n")
+ } else {
+ fmt.Fprintf(w, "\t%s\n", line)
+ }
+ }
+ } else {
+ for _, line := range elem.Lines {
+ printStyled(w, line, true)
+ fmt.Fprintf(w, "\n")
+ }
+ }
+
+ case present.List:
+ fmt.Fprintf(w, "\n")
+ for _, item := range elem.Bullet {
+ fmt.Fprintf(w, " - ")
+ for i, line := range strings.Split(item, "\n") {
+ if i > 0 {
+ fmt.Fprintf(w, " ")
+ }
+ printStyled(w, line, false)
+ fmt.Fprintf(w, "\n")
+ }
+ }
+
+ case present.Section:
+ fmt.Fprintf(w, "\n")
+ sep := " "
+ if elem.Title == "" {
+ sep = ""
+ }
+ fmt.Fprintf(w, "%s%s%s\n", strings.Repeat("#", depth+2), sep, markdownEscape(elem.Title, false))
+ printSectionBody(file, depth+1, w, elem.Elem)
+
+ case interface{ PresentCmd() string }:
+ // If there are multiple present commands in a row, don't print a blank line before the second etc.
+ b := w.Bytes()
+ sep := "\n"
+ if len(b) > 0 {
+ i := bytes.LastIndexByte(b[:len(b)-1], '\n')
+ if b[i+1] == '.' {
+ sep = ""
+ }
+ }
+ fmt.Fprintf(w, "%s%s\n", sep, elem.PresentCmd())
+ }
+ }
+}
+
+func markdownEscape(s string, startLine bool) string {
+ var b strings.Builder
+ for i, r := range s {
+ switch {
+ case r == '#' && i == 0,
+ r == '*',
+ r == '_',
+ r == '<' && (i == 0 || s[i-1] != ' ') && i+1 < len(s) && s[i+1] != ' ',
+ r == '[' && strings.Contains(s[i:], "]("):
+ b.WriteRune('\\')
+ }
+ b.WriteRune(r)
+ }
+ return b.String()
+}
+
+// Copy of ../../present/style.go adjusted to produce Markdown instead of HTML.
+
+/*
+ Fonts are demarcated by an initial and final char bracketing a
+ space-delimited word, plus possibly some terminal punctuation.
+ The chars are
+ _ for italic
+ * for bold
+ ` (back quote) for fixed width.
+ Inner appearances of the char become spaces. For instance,
+ _this_is_italic_!
+ becomes
+ <i>this is italic</i>!
+*/
+
+func printStyled(w *bytes.Buffer, text string, startLine bool) {
+ w.WriteString(font(text, startLine))
+}
+
+// font returns s with font indicators turned into HTML font tags.
+func font(s string, startLine bool) string {
+ if !strings.ContainsAny(s, "[`_*") {
+ return markdownEscape(s, startLine)
+ }
+ words := split(s)
+ var b bytes.Buffer
+Word:
+ for w, word := range words {
+ words[w] = markdownEscape(word, startLine && w == 0) // for all the continue Word
+ if len(word) < 2 {
+ continue Word
+ }
+ if link, _ := parseInlineLink(word); link != "" {
+ words[w] = link
+ continue Word
+ }
+ const marker = "_*`"
+ // Initial punctuation is OK but must be peeled off.
+ first := strings.IndexAny(word, marker)
+ if first == -1 {
+ continue Word
+ }
+ // Opening marker must be at the beginning of the token or else preceded by punctuation.
+ if first != 0 {
+ r, _ := utf8.DecodeLastRuneInString(word[:first])
+ if !unicode.IsPunct(r) {
+ continue Word
+ }
+ }
+ open, word := markdownEscape(word[:first], startLine && w == 0), word[first:]
+ char := word[0] // ASCII is OK.
+ close := ""
+ switch char {
+ default:
+ continue Word
+ case '_':
+ open += "_"
+ close = "_"
+ case '*':
+ open += "**"
+ close = "**"
+ case '`':
+ open += "`"
+ close = "`"
+ }
+ // Closing marker must be at the end of the token or else followed by punctuation.
+ last := strings.LastIndex(word, word[:1])
+ if last == 0 {
+ continue Word
+ }
+ if last+1 != len(word) {
+ r, _ := utf8.DecodeRuneInString(word[last+1:])
+ if !unicode.IsPunct(r) {
+ continue Word
+ }
+ }
+ head, tail := word[:last+1], word[last+1:]
+ b.Reset()
+ var wid int
+ for i := 1; i < len(head)-1; i += wid {
+ var r rune
+ r, wid = utf8.DecodeRuneInString(head[i:])
+ if r != rune(char) {
+ // Ordinary character.
+ b.WriteRune(r)
+ continue
+ }
+ if head[i+1] != char {
+ // Inner char becomes space.
+ b.WriteRune(' ')
+ continue
+ }
+ // Doubled char becomes real char.
+ // Not worth worrying about "_x__".
+ b.WriteByte(char)
+ wid++ // Consumed two chars, both ASCII.
+ }
+ text := b.String()
+ if close == "`" {
+ for strings.Contains(text, close) {
+ open += "`"
+ close += "`"
+ }
+ } else {
+ text = markdownEscape(text, false)
+ }
+ words[w] = open + text + close + tail
+ }
+ return strings.Join(words, "")
+}
+
+// split is like strings.Fields but also returns the runs of spaces
+// and treats inline links as distinct words.
+func split(s string) []string {
+ var (
+ words = make([]string, 0, 10)
+ start = 0
+ )
+
+ // appendWord appends the string s[start:end] to the words slice.
+ // If the word contains the beginning of a link, the non-link portion
+ // of the word and the entire link are appended as separate words,
+ // and the start index is advanced to the end of the link.
+ appendWord := func(end int) {
+ if j := strings.Index(s[start:end], "[["); j > -1 {
+ if _, l := parseInlineLink(s[start+j:]); l > 0 {
+ // Append portion before link, if any.
+ if j > 0 {
+ words = append(words, s[start:start+j])
+ }
+ // Append link itself.
+ words = append(words, s[start+j:start+j+l])
+ // Advance start index to end of link.
+ start = start + j + l
+ return
+ }
+ }
+ // No link; just add the word.
+ words = append(words, s[start:end])
+ start = end
+ }
+
+ wasSpace := false
+ for i, r := range s {
+ isSpace := unicode.IsSpace(r)
+ if i > start && isSpace != wasSpace {
+ appendWord(i)
+ }
+ wasSpace = isSpace
+ }
+ for start < len(s) {
+ appendWord(len(s))
+ }
+ return words
+}
+
+// parseInlineLink parses an inline link at the start of s, and returns
+// a rendered Markdown link and the total length of the raw inline link.
+// If no inline link is present, it returns all zeroes.
+func parseInlineLink(s string) (link string, length int) {
+ if !strings.HasPrefix(s, "[[") {
+ return
+ }
+ end := strings.Index(s, "]]")
+ if end == -1 {
+ return
+ }
+ urlEnd := strings.Index(s, "]")
+ rawURL := s[2:urlEnd]
+ const badURLChars = `<>"{}|\^[] ` + "`" // per RFC2396 section 2.4.3
+ if strings.ContainsAny(rawURL, badURLChars) {
+ return
+ }
+ if urlEnd == end {
+ simpleURL := ""
+ url, err := url.Parse(rawURL)
+ if err == nil {
+ // If the URL is http://foo.com, drop the http://
+ // In other words, render [[http://golang.org]] as:
+ // <a href="http://golang.org">golang.org</a>
+ if strings.HasPrefix(rawURL, url.Scheme+"://") {
+ simpleURL = strings.TrimPrefix(rawURL, url.Scheme+"://")
+ } else if strings.HasPrefix(rawURL, url.Scheme+":") {
+ simpleURL = strings.TrimPrefix(rawURL, url.Scheme+":")
+ }
+ }
+ return renderLink(rawURL, simpleURL), end + 2
+ }
+ if s[urlEnd:urlEnd+2] != "][" {
+ return
+ }
+ text := s[urlEnd+2 : end]
+ return renderLink(rawURL, text), end + 2
+}
+
+func renderLink(href, text string) string {
+ text = font(text, false)
+ if text == "" {
+ text = markdownEscape(href, false)
+ }
+ return "[" + text + "](" + href + ")"
+}
projects / dotfiles / .git / blobdiff