html.go

Documentation: github.com/russross/blackfriday/v2

     1  //
     2  // Blackfriday Markdown Processor
     3  // Available at http://github.com/russross/blackfriday
     4  //
     5  // Copyright © 2011 Russ Ross <russ@russross.com>.
     6  // Distributed under the Simplified BSD License.
     7  // See README.md for details.
     8  //
     9  
    10  //
    11  //
    12  // HTML rendering backend
    13  //
    14  //
    15  
    16  package blackfriday
    17  
    18  import (
    19  	"bytes"
    20  	"fmt"
    21  	"io"
    22  	"regexp"
    23  	"strings"
    24  )
    25  
    26  // HTMLFlags control optional behavior of HTML renderer.
    27  type HTMLFlags int
    28  
    29  // HTML renderer configuration options.
    30  const (
    31  	HTMLFlagsNone           HTMLFlags = 0
    32  	SkipHTML                HTMLFlags = 1 << iota // Skip preformatted HTML blocks
    33  	SkipImages                                    // Skip embedded images
    34  	SkipLinks                                     // Skip all links
    35  	Safelink                                      // Only link to trusted protocols
    36  	NofollowLinks                                 // Only link with rel="nofollow"
    37  	NoreferrerLinks                               // Only link with rel="noreferrer"
    38  	NoopenerLinks                                 // Only link with rel="noopener"
    39  	HrefTargetBlank                               // Add a blank target
    40  	CompletePage                                  // Generate a complete HTML page
    41  	UseXHTML                                      // Generate XHTML output instead of HTML
    42  	FootnoteReturnLinks                           // Generate a link at the end of a footnote to return to the source
    43  	Smartypants                                   // Enable smart punctuation substitutions
    44  	SmartypantsFractions                          // Enable smart fractions (with Smartypants)
    45  	SmartypantsDashes                             // Enable smart dashes (with Smartypants)
    46  	SmartypantsLatexDashes                        // Enable LaTeX-style dashes (with Smartypants)
    47  	SmartypantsAngledQuotes                       // Enable angled double quotes (with Smartypants) for double quotes rendering
    48  	SmartypantsQuotesNBSP                         // Enable « French guillemets » (with Smartypants)
    49  	TOC                                           // Generate a table of contents
    50  )
    51  
    52  var (
    53  	htmlTagRe = regexp.MustCompile("(?i)^" + htmlTag)
    54  )
    55  
    56  const (
    57  	htmlTag = "(?:" + openTag + "|" + closeTag + "|" + htmlComment + "|" +
    58  		processingInstruction + "|" + declaration + "|" + cdata + ")"
    59  	closeTag              = "</" + tagName + "\\s*[>]"
    60  	openTag               = "<" + tagName + attribute + "*" + "\\s*/?>"
    61  	attribute             = "(?:" + "\\s+" + attributeName + attributeValueSpec + "?)"
    62  	attributeValue        = "(?:" + unquotedValue + "|" + singleQuotedValue + "|" + doubleQuotedValue + ")"
    63  	attributeValueSpec    = "(?:" + "\\s*=" + "\\s*" + attributeValue + ")"
    64  	attributeName         = "[a-zA-Z_:][a-zA-Z0-9:._-]*"
    65  	cdata                 = "<!\\[CDATA\\[[\\s\\S]*?\\]\\]>"
    66  	declaration           = "<![A-Z]+" + "\\s+[^>]*>"
    67  	doubleQuotedValue     = "\"[^\"]*\""
    68  	htmlComment           = "<!---->|<!--(?:-?[^>-])(?:-?[^-])*-->"
    69  	processingInstruction = "[<][?].*?[?][>]"
    70  	singleQuotedValue     = "'[^']*'"
    71  	tagName               = "[A-Za-z][A-Za-z0-9-]*"
    72  	unquotedValue         = "[^\"'=<>`\\x00-\\x20]+"
    73  )
    74  
    75  // HTMLRendererParameters is a collection of supplementary parameters tweaking
    76  // the behavior of various parts of HTML renderer.
    77  type HTMLRendererParameters struct {
    78  	// Prepend this text to each relative URL.
    79  	AbsolutePrefix string
    80  	// Add this text to each footnote anchor, to ensure uniqueness.
    81  	FootnoteAnchorPrefix string
    82  	// Show this text inside the <a> tag for a footnote return link, if the
    83  	// HTML_FOOTNOTE_RETURN_LINKS flag is enabled. If blank, the string
    84  	// <sup>[return]</sup> is used.
    85  	FootnoteReturnLinkContents string
    86  	// If set, add this text to the front of each Heading ID, to ensure
    87  	// uniqueness.
    88  	HeadingIDPrefix string
    89  	// If set, add this text to the back of each Heading ID, to ensure uniqueness.
    90  	HeadingIDSuffix string
    91  	// Increase heading levels: if the offset is 1, <h1> becomes <h2> etc.
    92  	// Negative offset is also valid.
    93  	// Resulting levels are clipped between 1 and 6.
    94  	HeadingLevelOffset int
    95  
    96  	Title string // Document title (used if CompletePage is set)
    97  	CSS   string // Optional CSS file URL (used if CompletePage is set)
    98  	Icon  string // Optional icon file URL (used if CompletePage is set)
    99  
   100  	Flags HTMLFlags // Flags allow customizing this renderer's behavior
   101  }
   102  
   103  // HTMLRenderer is a type that implements the Renderer interface for HTML output.
   104  //
   105  // Do not create this directly, instead use the NewHTMLRenderer function.
   106  type HTMLRenderer struct {
   107  	HTMLRendererParameters
   108  
   109  	closeTag string // how to end singleton tags: either " />" or ">"
   110  
   111  	// Track heading IDs to prevent ID collision in a single generation.
   112  	headingIDs map[string]int
   113  
   114  	lastOutputLen int
   115  	disableTags   int
   116  
   117  	sr *SPRenderer
   118  }
   119  
   120  const (
   121  	xhtmlClose = " />"
   122  	htmlClose  = ">"
   123  )
   124  
   125  // NewHTMLRenderer creates and configures an HTMLRenderer object, which
   126  // satisfies the Renderer interface.
   127  func NewHTMLRenderer(params HTMLRendererParameters) *HTMLRenderer {
   128  	// configure the rendering engine
   129  	closeTag := htmlClose
   130  	if params.Flags&UseXHTML != 0 {
   131  		closeTag = xhtmlClose
   132  	}
   133  
   134  	if params.FootnoteReturnLinkContents == "" {
   135  		// U+FE0E is VARIATION SELECTOR-15.
   136  		// It suppresses automatic emoji presentation of the preceding
   137  		// U+21A9 LEFTWARDS ARROW WITH HOOK on iOS and iPadOS.
   138  		params.FootnoteReturnLinkContents = "<span aria-label='Return'>↩\ufe0e</span>"
   139  	}
   140  
   141  	return &HTMLRenderer{
   142  		HTMLRendererParameters: params,
   143  
   144  		closeTag:   closeTag,
   145  		headingIDs: make(map[string]int),
   146  
   147  		sr: NewSmartypantsRenderer(params.Flags),
   148  	}
   149  }
   150  
   151  func isHTMLTag(tag []byte, tagname string) bool {
   152  	found, _ := findHTMLTagPos(tag, tagname)
   153  	return found
   154  }
   155  
   156  // Look for a character, but ignore it when it's in any kind of quotes, it
   157  // might be JavaScript
   158  func skipUntilCharIgnoreQuotes(html []byte, start int, char byte) int {
   159  	inSingleQuote := false
   160  	inDoubleQuote := false
   161  	inGraveQuote := false
   162  	i := start
   163  	for i < len(html) {
   164  		switch {
   165  		case html[i] == char && !inSingleQuote && !inDoubleQuote && !inGraveQuote:
   166  			return i
   167  		case html[i] == '\'':
   168  			inSingleQuote = !inSingleQuote
   169  		case html[i] == '"':
   170  			inDoubleQuote = !inDoubleQuote
   171  		case html[i] == '`':
   172  			inGraveQuote = !inGraveQuote
   173  		}
   174  		i++
   175  	}
   176  	return start
   177  }
   178  
   179  func findHTMLTagPos(tag []byte, tagname string) (bool, int) {
   180  	i := 0
   181  	if i < len(tag) && tag[0] != '<' {
   182  		return false, -1
   183  	}
   184  	i++
   185  	i = skipSpace(tag, i)
   186  
   187  	if i < len(tag) && tag[i] == '/' {
   188  		i++
   189  	}
   190  
   191  	i = skipSpace(tag, i)
   192  	j := 0
   193  	for ; i < len(tag); i, j = i+1, j+1 {
   194  		if j >= len(tagname) {
   195  			break
   196  		}
   197  
   198  		if strings.ToLower(string(tag[i]))[0] != tagname[j] {
   199  			return false, -1
   200  		}
   201  	}
   202  
   203  	if i == len(tag) {
   204  		return false, -1
   205  	}
   206  
   207  	rightAngle := skipUntilCharIgnoreQuotes(tag, i, '>')
   208  	if rightAngle >= i {
   209  		return true, rightAngle
   210  	}
   211  
   212  	return false, -1
   213  }
   214  
   215  func skipSpace(tag []byte, i int) int {
   216  	for i < len(tag) && isspace(tag[i]) {
   217  		i++
   218  	}
   219  	return i
   220  }
   221  
   222  func isRelativeLink(link []byte) (yes bool) {
   223  	// a tag begin with '#'
   224  	if link[0] == '#' {
   225  		return true
   226  	}
   227  
   228  	// link begin with '/' but not '//', the second maybe a protocol relative link
   229  	if len(link) >= 2 && link[0] == '/' && link[1] != '/' {
   230  		return true
   231  	}
   232  
   233  	// only the root '/'
   234  	if len(link) == 1 && link[0] == '/' {
   235  		return true
   236  	}
   237  
   238  	// current directory : begin with "./"
   239  	if bytes.HasPrefix(link, []byte("./")) {
   240  		return true
   241  	}
   242  
   243  	// parent directory : begin with "../"
   244  	if bytes.HasPrefix(link, []byte("../")) {
   245  		return true
   246  	}
   247  
   248  	return false
   249  }
   250  
   251  func (r *HTMLRenderer) ensureUniqueHeadingID(id string) string {
   252  	for count, found := r.headingIDs[id]; found; count, found = r.headingIDs[id] {
   253  		tmp := fmt.Sprintf("%s-%d", id, count+1)
   254  
   255  		if _, tmpFound := r.headingIDs[tmp]; !tmpFound {
   256  			r.headingIDs[id] = count + 1
   257  			id = tmp
   258  		} else {
   259  			id = id + "-1"
   260  		}
   261  	}
   262  
   263  	if _, found := r.headingIDs[id]; !found {
   264  		r.headingIDs[id] = 0
   265  	}
   266  
   267  	return id
   268  }
   269  
   270  func (r *HTMLRenderer) addAbsPrefix(link []byte) []byte {
   271  	if r.AbsolutePrefix != "" && isRelativeLink(link) && link[0] != '.' {
   272  		newDest := r.AbsolutePrefix
   273  		if link[0] != '/' {
   274  			newDest += "/"
   275  		}
   276  		newDest += string(link)
   277  		return []byte(newDest)
   278  	}
   279  	return link
   280  }
   281  
   282  func appendLinkAttrs(attrs []string, flags HTMLFlags, link []byte) []string {
   283  	if isRelativeLink(link) {
   284  		return attrs
   285  	}
   286  	val := []string{}
   287  	if flags&NofollowLinks != 0 {
   288  		val = append(val, "nofollow")
   289  	}
   290  	if flags&NoreferrerLinks != 0 {
   291  		val = append(val, "noreferrer")
   292  	}
   293  	if flags&NoopenerLinks != 0 {
   294  		val = append(val, "noopener")
   295  	}
   296  	if flags&HrefTargetBlank != 0 {
   297  		attrs = append(attrs, "target=\"_blank\"")
   298  	}
   299  	if len(val) == 0 {
   300  		return attrs
   301  	}
   302  	attr := fmt.Sprintf("rel=%q", strings.Join(val, " "))
   303  	return append(attrs, attr)
   304  }
   305  
   306  func isMailto(link []byte) bool {
   307  	return bytes.HasPrefix(link, []byte("mailto:"))
   308  }
   309  
   310  func needSkipLink(flags HTMLFlags, dest []byte) bool {
   311  	if flags&SkipLinks != 0 {
   312  		return true
   313  	}
   314  	return flags&Safelink != 0 && !isSafeLink(dest) && !isMailto(dest)
   315  }
   316  
   317  func isSmartypantable(node *Node) bool {
   318  	pt := node.Parent.Type
   319  	return pt != Link && pt != CodeBlock && pt != Code
   320  }
   321  
   322  func appendLanguageAttr(attrs []string, info []byte) []string {
   323  	if len(info) == 0 {
   324  		return attrs
   325  	}
   326  	endOfLang := bytes.IndexAny(info, "\t ")
   327  	if endOfLang < 0 {
   328  		endOfLang = len(info)
   329  	}
   330  	return append(attrs, fmt.Sprintf("class=\"language-%s\"", info[:endOfLang]))
   331  }
   332  
   333  func (r *HTMLRenderer) tag(w io.Writer, name []byte, attrs []string) {
   334  	w.Write(name)
   335  	if len(attrs) > 0 {
   336  		w.Write(spaceBytes)
   337  		w.Write([]byte(strings.Join(attrs, " ")))
   338  	}
   339  	w.Write(gtBytes)
   340  	r.lastOutputLen = 1
   341  }
   342  
   343  func footnoteRef(prefix string, node *Node) []byte {
   344  	urlFrag := prefix + string(slugify(node.Destination))
   345  	anchor := fmt.Sprintf(`<a href="#fn:%s">%d</a>`, urlFrag, node.NoteID)
   346  	return []byte(fmt.Sprintf(`<sup class="footnote-ref" id="fnref:%s">%s</sup>`, urlFrag, anchor))
   347  }
   348  
   349  func footnoteItem(prefix string, slug []byte) []byte {
   350  	return []byte(fmt.Sprintf(`<li id="fn:%s%s">`, prefix, slug))
   351  }
   352  
   353  func footnoteReturnLink(prefix, returnLink string, slug []byte) []byte {
   354  	const format = ` <a class="footnote-return" href="#fnref:%s%s">%s</a>`
   355  	return []byte(fmt.Sprintf(format, prefix, slug, returnLink))
   356  }
   357  
   358  func itemOpenCR(node *Node) bool {
   359  	if node.Prev == nil {
   360  		return false
   361  	}
   362  	ld := node.Parent.ListData
   363  	return !ld.Tight && ld.ListFlags&ListTypeDefinition == 0
   364  }
   365  
   366  func skipParagraphTags(node *Node) bool {
   367  	grandparent := node.Parent.Parent
   368  	if grandparent == nil || grandparent.Type != List {
   369  		return false
   370  	}
   371  	tightOrTerm := grandparent.Tight || node.Parent.ListFlags&ListTypeTerm != 0
   372  	return grandparent.Type == List && tightOrTerm
   373  }
   374  
   375  func cellAlignment(align CellAlignFlags) string {
   376  	switch align {
   377  	case TableAlignmentLeft:
   378  		return "left"
   379  	case TableAlignmentRight:
   380  		return "right"
   381  	case TableAlignmentCenter:
   382  		return "center"
   383  	default:
   384  		return ""
   385  	}
   386  }
   387  
   388  func (r *HTMLRenderer) out(w io.Writer, text []byte) {
   389  	if r.disableTags > 0 {
   390  		w.Write(htmlTagRe.ReplaceAll(text, []byte{}))
   391  	} else {
   392  		w.Write(text)
   393  	}
   394  	r.lastOutputLen = len(text)
   395  }
   396  
   397  func (r *HTMLRenderer) cr(w io.Writer) {
   398  	if r.lastOutputLen > 0 {
   399  		r.out(w, nlBytes)
   400  	}
   401  }
   402  
   403  var (
   404  	nlBytes    = []byte{'\n'}
   405  	gtBytes    = []byte{'>'}
   406  	spaceBytes = []byte{' '}
   407  )
   408  
   409  var (
   410  	brTag              = []byte("<br>")
   411  	brXHTMLTag         = []byte("<br />")
   412  	emTag              = []byte("<em>")
   413  	emCloseTag         = []byte("</em>")
   414  	strongTag          = []byte("<strong>")
   415  	strongCloseTag     = []byte("</strong>")
   416  	delTag             = []byte("<del>")
   417  	delCloseTag        = []byte("</del>")
   418  	ttTag              = []byte("<tt>")
   419  	ttCloseTag         = []byte("</tt>")
   420  	aTag               = []byte("<a")
   421  	aCloseTag          = []byte("</a>")
   422  	preTag             = []byte("<pre>")
   423  	preCloseTag        = []byte("</pre>")
   424  	codeTag            = []byte("<code>")
   425  	codeCloseTag       = []byte("</code>")
   426  	pTag               = []byte("<p>")
   427  	pCloseTag          = []byte("</p>")
   428  	blockquoteTag      = []byte("<blockquote>")
   429  	blockquoteCloseTag = []byte("</blockquote>")
   430  	hrTag              = []byte("<hr>")
   431  	hrXHTMLTag         = []byte("<hr />")
   432  	ulTag              = []byte("<ul>")
   433  	ulCloseTag         = []byte("</ul>")
   434  	olTag              = []byte("<ol>")
   435  	olCloseTag         = []byte("</ol>")
   436  	dlTag              = []byte("<dl>")
   437  	dlCloseTag         = []byte("</dl>")
   438  	liTag              = []byte("<li>")
   439  	liCloseTag         = []byte("</li>")
   440  	ddTag              = []byte("<dd>")
   441  	ddCloseTag         = []byte("</dd>")
   442  	dtTag              = []byte("<dt>")
   443  	dtCloseTag         = []byte("</dt>")
   444  	tableTag           = []byte("<table>")
   445  	tableCloseTag      = []byte("</table>")
   446  	tdTag              = []byte("<td")
   447  	tdCloseTag         = []byte("</td>")
   448  	thTag              = []byte("<th")
   449  	thCloseTag         = []byte("</th>")
   450  	theadTag           = []byte("<thead>")
   451  	theadCloseTag      = []byte("</thead>")
   452  	tbodyTag           = []byte("<tbody>")
   453  	tbodyCloseTag      = []byte("</tbody>")
   454  	trTag              = []byte("<tr>")
   455  	trCloseTag         = []byte("</tr>")
   456  	h1Tag              = []byte("<h1")
   457  	h1CloseTag         = []byte("</h1>")
   458  	h2Tag              = []byte("<h2")
   459  	h2CloseTag         = []byte("</h2>")
   460  	h3Tag              = []byte("<h3")
   461  	h3CloseTag         = []byte("</h3>")
   462  	h4Tag              = []byte("<h4")
   463  	h4CloseTag         = []byte("</h4>")
   464  	h5Tag              = []byte("<h5")
   465  	h5CloseTag         = []byte("</h5>")
   466  	h6Tag              = []byte("<h6")
   467  	h6CloseTag         = []byte("</h6>")
   468  
   469  	footnotesDivBytes      = []byte("\n<div class=\"footnotes\">\n\n")
   470  	footnotesCloseDivBytes = []byte("\n</div>\n")
   471  )
   472  
   473  func headingTagsFromLevel(level int) ([]byte, []byte) {
   474  	if level <= 1 {
   475  		return h1Tag, h1CloseTag
   476  	}
   477  	switch level {
   478  	case 2:
   479  		return h2Tag, h2CloseTag
   480  	case 3:
   481  		return h3Tag, h3CloseTag
   482  	case 4:
   483  		return h4Tag, h4CloseTag
   484  	case 5:
   485  		return h5Tag, h5CloseTag
   486  	}
   487  	return h6Tag, h6CloseTag
   488  }
   489  
   490  func (r *HTMLRenderer) outHRTag(w io.Writer) {
   491  	if r.Flags&UseXHTML == 0 {
   492  		r.out(w, hrTag)
   493  	} else {
   494  		r.out(w, hrXHTMLTag)
   495  	}
   496  }
   497  
   498  // RenderNode is a default renderer of a single node of a syntax tree. For
   499  // block nodes it will be called twice: first time with entering=true, second
   500  // time with entering=false, so that it could know when it's working on an open
   501  // tag and when on close. It writes the result to w.
   502  //
   503  // The return value is a way to tell the calling walker to adjust its walk
   504  // pattern: e.g. it can terminate the traversal by returning Terminate. Or it
   505  // can ask the walker to skip a subtree of this node by returning SkipChildren.
   506  // The typical behavior is to return GoToNext, which asks for the usual
   507  // traversal to the next node.
   508  func (r *HTMLRenderer) RenderNode(w io.Writer, node *Node, entering bool) WalkStatus {
   509  	attrs := []string{}
   510  	switch node.Type {
   511  	case Text:
   512  		if r.Flags&Smartypants != 0 {
   513  			var tmp bytes.Buffer
   514  			escapeHTML(&tmp, node.Literal)
   515  			r.sr.Process(w, tmp.Bytes())
   516  		} else {
   517  			if node.Parent.Type == Link {
   518  				escLink(w, node.Literal)
   519  			} else {
   520  				escapeHTML(w, node.Literal)
   521  			}
   522  		}
   523  	case Softbreak:
   524  		r.cr(w)
   525  		// TODO: make it configurable via out(renderer.softbreak)
   526  	case Hardbreak:
   527  		if r.Flags&UseXHTML == 0 {
   528  			r.out(w, brTag)
   529  		} else {
   530  			r.out(w, brXHTMLTag)
   531  		}
   532  		r.cr(w)
   533  	case Emph:
   534  		if entering {
   535  			r.out(w, emTag)
   536  		} else {
   537  			r.out(w, emCloseTag)
   538  		}
   539  	case Strong:
   540  		if entering {
   541  			r.out(w, strongTag)
   542  		} else {
   543  			r.out(w, strongCloseTag)
   544  		}
   545  	case Del:
   546  		if entering {
   547  			r.out(w, delTag)
   548  		} else {
   549  			r.out(w, delCloseTag)
   550  		}
   551  	case HTMLSpan:
   552  		if r.Flags&SkipHTML != 0 {
   553  			break
   554  		}
   555  		r.out(w, node.Literal)
   556  	case Link:
   557  		// mark it but don't link it if it is not a safe link: no smartypants
   558  		dest := node.LinkData.Destination
   559  		if needSkipLink(r.Flags, dest) {
   560  			if entering {
   561  				r.out(w, ttTag)
   562  			} else {
   563  				r.out(w, ttCloseTag)
   564  			}
   565  		} else {
   566  			if entering {
   567  				dest = r.addAbsPrefix(dest)
   568  				var hrefBuf bytes.Buffer
   569  				hrefBuf.WriteString("href=\"")
   570  				escLink(&hrefBuf, dest)
   571  				hrefBuf.WriteByte('"')
   572  				attrs = append(attrs, hrefBuf.String())
   573  				if node.NoteID != 0 {
   574  					r.out(w, footnoteRef(r.FootnoteAnchorPrefix, node))
   575  					break
   576  				}
   577  				attrs = appendLinkAttrs(attrs, r.Flags, dest)
   578  				if len(node.LinkData.Title) > 0 {
   579  					var titleBuff bytes.Buffer
   580  					titleBuff.WriteString("title=\"")
   581  					escapeHTML(&titleBuff, node.LinkData.Title)
   582  					titleBuff.WriteByte('"')
   583  					attrs = append(attrs, titleBuff.String())
   584  				}
   585  				r.tag(w, aTag, attrs)
   586  			} else {
   587  				if node.NoteID != 0 {
   588  					break
   589  				}
   590  				r.out(w, aCloseTag)
   591  			}
   592  		}
   593  	case Image:
   594  		if r.Flags&SkipImages != 0 {
   595  			return SkipChildren
   596  		}
   597  		if entering {
   598  			dest := node.LinkData.Destination
   599  			dest = r.addAbsPrefix(dest)
   600  			if r.disableTags == 0 {
   601  				//if options.safe && potentiallyUnsafe(dest) {
   602  				//out(w, `<img src="" alt="`)
   603  				//} else {
   604  				r.out(w, []byte(`<img src="`))
   605  				escLink(w, dest)
   606  				r.out(w, []byte(`" alt="`))
   607  				//}
   608  			}
   609  			r.disableTags++
   610  		} else {
   611  			r.disableTags--
   612  			if r.disableTags == 0 {
   613  				if node.LinkData.Title != nil {
   614  					r.out(w, []byte(`" title="`))
   615  					escapeHTML(w, node.LinkData.Title)
   616  				}
   617  				r.out(w, []byte(`" />`))
   618  			}
   619  		}
   620  	case Code:
   621  		r.out(w, codeTag)
   622  		escapeAllHTML(w, node.Literal)
   623  		r.out(w, codeCloseTag)
   624  	case Document:
   625  		break
   626  	case Paragraph:
   627  		if skipParagraphTags(node) {
   628  			break
   629  		}
   630  		if entering {
   631  			// TODO: untangle this clusterfuck about when the newlines need
   632  			// to be added and when not.
   633  			if node.Prev != nil {
   634  				switch node.Prev.Type {
   635  				case HTMLBlock, List, Paragraph, Heading, CodeBlock, BlockQuote, HorizontalRule:
   636  					r.cr(w)
   637  				}
   638  			}
   639  			if node.Parent.Type == BlockQuote && node.Prev == nil {
   640  				r.cr(w)
   641  			}
   642  			r.out(w, pTag)
   643  		} else {
   644  			r.out(w, pCloseTag)
   645  			if !(node.Parent.Type == Item && node.Next == nil) {
   646  				r.cr(w)
   647  			}
   648  		}
   649  	case BlockQuote:
   650  		if entering {
   651  			r.cr(w)
   652  			r.out(w, blockquoteTag)
   653  		} else {
   654  			r.out(w, blockquoteCloseTag)
   655  			r.cr(w)
   656  		}
   657  	case HTMLBlock:
   658  		if r.Flags&SkipHTML != 0 {
   659  			break
   660  		}
   661  		r.cr(w)
   662  		r.out(w, node.Literal)
   663  		r.cr(w)
   664  	case Heading:
   665  		headingLevel := r.HTMLRendererParameters.HeadingLevelOffset + node.Level
   666  		openTag, closeTag := headingTagsFromLevel(headingLevel)
   667  		if entering {
   668  			if node.IsTitleblock {
   669  				attrs = append(attrs, `class="title"`)
   670  			}
   671  			if node.HeadingID != "" {
   672  				id := r.ensureUniqueHeadingID(node.HeadingID)
   673  				if r.HeadingIDPrefix != "" {
   674  					id = r.HeadingIDPrefix + id
   675  				}
   676  				if r.HeadingIDSuffix != "" {
   677  					id = id + r.HeadingIDSuffix
   678  				}
   679  				attrs = append(attrs, fmt.Sprintf(`id="%s"`, id))
   680  			}
   681  			r.cr(w)
   682  			r.tag(w, openTag, attrs)
   683  		} else {
   684  			r.out(w, closeTag)
   685  			if !(node.Parent.Type == Item && node.Next == nil) {
   686  				r.cr(w)
   687  			}
   688  		}
   689  	case HorizontalRule:
   690  		r.cr(w)
   691  		r.outHRTag(w)
   692  		r.cr(w)
   693  	case List:
   694  		openTag := ulTag
   695  		closeTag := ulCloseTag
   696  		if node.ListFlags&ListTypeOrdered != 0 {
   697  			openTag = olTag
   698  			closeTag = olCloseTag
   699  		}
   700  		if node.ListFlags&ListTypeDefinition != 0 {
   701  			openTag = dlTag
   702  			closeTag = dlCloseTag
   703  		}
   704  		if entering {
   705  			if node.IsFootnotesList {
   706  				r.out(w, footnotesDivBytes)
   707  				r.outHRTag(w)
   708  				r.cr(w)
   709  			}
   710  			r.cr(w)
   711  			if node.Parent.Type == Item && node.Parent.Parent.Tight {
   712  				r.cr(w)
   713  			}
   714  			r.tag(w, openTag[:len(openTag)-1], attrs)
   715  			r.cr(w)
   716  		} else {
   717  			r.out(w, closeTag)
   718  			//cr(w)
   719  			//if node.parent.Type != Item {
   720  			//	cr(w)
   721  			//}
   722  			if node.Parent.Type == Item && node.Next != nil {
   723  				r.cr(w)
   724  			}
   725  			if node.Parent.Type == Document || node.Parent.Type == BlockQuote {
   726  				r.cr(w)
   727  			}
   728  			if node.IsFootnotesList {
   729  				r.out(w, footnotesCloseDivBytes)
   730  			}
   731  		}
   732  	case Item:
   733  		openTag := liTag
   734  		closeTag := liCloseTag
   735  		if node.ListFlags&ListTypeDefinition != 0 {
   736  			openTag = ddTag
   737  			closeTag = ddCloseTag
   738  		}
   739  		if node.ListFlags&ListTypeTerm != 0 {
   740  			openTag = dtTag
   741  			closeTag = dtCloseTag
   742  		}
   743  		if entering {
   744  			if itemOpenCR(node) {
   745  				r.cr(w)
   746  			}
   747  			if node.ListData.RefLink != nil {
   748  				slug := slugify(node.ListData.RefLink)
   749  				r.out(w, footnoteItem(r.FootnoteAnchorPrefix, slug))
   750  				break
   751  			}
   752  			r.out(w, openTag)
   753  		} else {
   754  			if node.ListData.RefLink != nil {
   755  				slug := slugify(node.ListData.RefLink)
   756  				if r.Flags&FootnoteReturnLinks != 0 {
   757  					r.out(w, footnoteReturnLink(r.FootnoteAnchorPrefix, r.FootnoteReturnLinkContents, slug))
   758  				}
   759  			}
   760  			r.out(w, closeTag)
   761  			r.cr(w)
   762  		}
   763  	case CodeBlock:
   764  		attrs = appendLanguageAttr(attrs, node.Info)
   765  		r.cr(w)
   766  		r.out(w, preTag)
   767  		r.tag(w, codeTag[:len(codeTag)-1], attrs)
   768  		escapeAllHTML(w, node.Literal)
   769  		r.out(w, codeCloseTag)
   770  		r.out(w, preCloseTag)
   771  		if node.Parent.Type != Item {
   772  			r.cr(w)
   773  		}
   774  	case Table:
   775  		if entering {
   776  			r.cr(w)
   777  			r.out(w, tableTag)
   778  		} else {
   779  			r.out(w, tableCloseTag)
   780  			r.cr(w)
   781  		}
   782  	case TableCell:
   783  		openTag := tdTag
   784  		closeTag := tdCloseTag
   785  		if node.IsHeader {
   786  			openTag = thTag
   787  			closeTag = thCloseTag
   788  		}
   789  		if entering {
   790  			align := cellAlignment(node.Align)
   791  			if align != "" {
   792  				attrs = append(attrs, fmt.Sprintf(`align="%s"`, align))
   793  			}
   794  			if node.Prev == nil {
   795  				r.cr(w)
   796  			}
   797  			r.tag(w, openTag, attrs)
   798  		} else {
   799  			r.out(w, closeTag)
   800  			r.cr(w)
   801  		}
   802  	case TableHead:
   803  		if entering {
   804  			r.cr(w)
   805  			r.out(w, theadTag)
   806  		} else {
   807  			r.out(w, theadCloseTag)
   808  			r.cr(w)
   809  		}
   810  	case TableBody:
   811  		if entering {
   812  			r.cr(w)
   813  			r.out(w, tbodyTag)
   814  			// XXX: this is to adhere to a rather silly test. Should fix test.
   815  			if node.FirstChild == nil {
   816  				r.cr(w)
   817  			}
   818  		} else {
   819  			r.out(w, tbodyCloseTag)
   820  			r.cr(w)
   821  		}
   822  	case TableRow:
   823  		if entering {
   824  			r.cr(w)
   825  			r.out(w, trTag)
   826  		} else {
   827  			r.out(w, trCloseTag)
   828  			r.cr(w)
   829  		}
   830  	default:
   831  		panic("Unknown node type " + node.Type.String())
   832  	}
   833  	return GoToNext
   834  }
   835  
   836  // RenderHeader writes HTML document preamble and TOC if requested.
   837  func (r *HTMLRenderer) RenderHeader(w io.Writer, ast *Node) {
   838  	r.writeDocumentHeader(w)
   839  	if r.Flags&TOC != 0 {
   840  		r.writeTOC(w, ast)
   841  	}
   842  }
   843  
   844  // RenderFooter writes HTML document footer.
   845  func (r *HTMLRenderer) RenderFooter(w io.Writer, ast *Node) {
   846  	if r.Flags&CompletePage == 0 {
   847  		return
   848  	}
   849  	io.WriteString(w, "\n</body>\n</html>\n")
   850  }
   851  
   852  func (r *HTMLRenderer) writeDocumentHeader(w io.Writer) {
   853  	if r.Flags&CompletePage == 0 {
   854  		return
   855  	}
   856  	ending := ""
   857  	if r.Flags&UseXHTML != 0 {
   858  		io.WriteString(w, "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" ")
   859  		io.WriteString(w, "\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n")
   860  		io.WriteString(w, "<html xmlns=\"http://www.w3.org/1999/xhtml\">\n")
   861  		ending = " /"
   862  	} else {
   863  		io.WriteString(w, "<!DOCTYPE html>\n")
   864  		io.WriteString(w, "<html>\n")
   865  	}
   866  	io.WriteString(w, "<head>\n")
   867  	io.WriteString(w, "  <title>")
   868  	if r.Flags&Smartypants != 0 {
   869  		r.sr.Process(w, []byte(r.Title))
   870  	} else {
   871  		escapeHTML(w, []byte(r.Title))
   872  	}
   873  	io.WriteString(w, "</title>\n")
   874  	io.WriteString(w, "  <meta name=\"GENERATOR\" content=\"Blackfriday Markdown Processor v")
   875  	io.WriteString(w, Version)
   876  	io.WriteString(w, "\"")
   877  	io.WriteString(w, ending)
   878  	io.WriteString(w, ">\n")
   879  	io.WriteString(w, "  <meta charset=\"utf-8\"")
   880  	io.WriteString(w, ending)
   881  	io.WriteString(w, ">\n")
   882  	if r.CSS != "" {
   883  		io.WriteString(w, "  <link rel=\"stylesheet\" type=\"text/css\" href=\"")
   884  		escapeHTML(w, []byte(r.CSS))
   885  		io.WriteString(w, "\"")
   886  		io.WriteString(w, ending)
   887  		io.WriteString(w, ">\n")
   888  	}
   889  	if r.Icon != "" {
   890  		io.WriteString(w, "  <link rel=\"icon\" type=\"image/x-icon\" href=\"")
   891  		escapeHTML(w, []byte(r.Icon))
   892  		io.WriteString(w, "\"")
   893  		io.WriteString(w, ending)
   894  		io.WriteString(w, ">\n")
   895  	}
   896  	io.WriteString(w, "</head>\n")
   897  	io.WriteString(w, "<body>\n\n")
   898  }
   899  
   900  func (r *HTMLRenderer) writeTOC(w io.Writer, ast *Node) {
   901  	buf := bytes.Buffer{}
   902  
   903  	inHeading := false
   904  	tocLevel := 0
   905  	headingCount := 0
   906  
   907  	ast.Walk(func(node *Node, entering bool) WalkStatus {
   908  		if node.Type == Heading && !node.HeadingData.IsTitleblock {
   909  			inHeading = entering
   910  			if entering {
   911  				node.HeadingID = fmt.Sprintf("toc_%d", headingCount)
   912  				if node.Level == tocLevel {
   913  					buf.WriteString("</li>\n\n<li>")
   914  				} else if node.Level < tocLevel {
   915  					for node.Level < tocLevel {
   916  						tocLevel--
   917  						buf.WriteString("</li>\n</ul>")
   918  					}
   919  					buf.WriteString("</li>\n\n<li>")
   920  				} else {
   921  					for node.Level > tocLevel {
   922  						tocLevel++
   923  						buf.WriteString("\n<ul>\n<li>")
   924  					}
   925  				}
   926  
   927  				fmt.Fprintf(&buf, `<a href="#toc_%d">`, headingCount)
   928  				headingCount++
   929  			} else {
   930  				buf.WriteString("</a>")
   931  			}
   932  			return GoToNext
   933  		}
   934  
   935  		if inHeading {
   936  			return r.RenderNode(&buf, node, entering)
   937  		}
   938  
   939  		return GoToNext
   940  	})
   941  
   942  	for ; tocLevel > 0; tocLevel-- {
   943  		buf.WriteString("</li>\n</ul>")
   944  	}
   945  
   946  	if buf.Len() > 0 {
   947  		io.WriteString(w, "<nav>\n")
   948  		w.Write(buf.Bytes())
   949  		io.WriteString(w, "\n\n</nav>\n")
   950  	}
   951  	r.lastOutputLen = buf.Len()
   952  }
   953
View as plain text