package cnm import ( "io" "strings" ) func init() { RegisterTextContentParser("", parseTextPlain) RegisterTextContentParser("plain", parseTextPlain) RegisterTextContentParser("pre", parseTextPre) } // Block represents an arbitrary CNM within the "content" top-level block. type Block interface { // Name returns the name of the block. Name() string // Args returns the block arguments. Args() []string WriteIndent(w io.Writer, n int) error } // ContainerBlock represents a content block that contains only other blocks. type ContainerBlock interface { Block // Children returns the child blocks. Children() []Block // AppendChild adds a new child block to the end of the list of children. AppendChild(Block) } // ContentBlock represents a block that holds other content blocks. type ContentBlock struct { name string args []string children []Block } // WriteIndent writes the block header and its children indented by n tabs. func (cb *ContentBlock) WriteIndent(w io.Writer, n int) error { ss := []string{Escape(cb.name)} ss = append(ss, cb.args...) if err := WriteIndent(w, JoinEscape(ss), n); err != nil { return err } for _, ch := range cb.children { if err := ch.WriteIndent(w, n+1); err != nil { return err } } return nil } // NewContentBlock creates a new ContentBlock with a name and argument. func NewContentBlock(name string, args ...string) *ContentBlock { var a []string for _, arg := range args { if arg != "" { a = append(a, arg) } } return &ContentBlock{name: name, args: a} } // Name returns the block's name. func (cb *ContentBlock) Name() string { return cb.name } // Args returns the block arguments. func (cb *ContentBlock) Args() []string { return cb.args } // Children returns the block's child blocks. func (cb *ContentBlock) Children() []Block { return cb.children } // AppendChild adds a new child block to the end of the list of children. func (cb *ContentBlock) AppendChild(block Block) { cb.children = append(cb.children, block) } func (cb *ContentBlock) parse(p *Parser, block *TokenBlock) (err error) { for err == nil { if !p.Empty() && p.Indent() <= block.Indent() { break } token := p.Block() if blk, ok := token.(*TokenBlock); ok { var b Block switch blk.Name { case "section": b, err = parseContentSection(p, blk) case "text": b, err = parseContentText(p, blk) case "raw": b, err = parseContentRaw(p, blk) case "list": b, err = parseContentList(p, blk) case "table": b, err = parseContentTable(p, blk) case "embed": b, err = parseContentEmbed(p, blk) default: err = parseUnknown(p, blk) } if b != nil { cb.AppendChild(b) } } else if err = p.Next(); err != nil { break } } return } // SectionBlock represents a "section" content block. type SectionBlock struct { ContentBlock } // NewSectionBlock creates a new SectionBlock with a title. func NewSectionBlock(title string) *SectionBlock { return &SectionBlock{*NewContentBlock("section", title)} } // Title returns the section block's title. func (b *SectionBlock) Title() string { return strings.Join(b.args, " ") } func parseContentSection(p *Parser, block *TokenBlock) (*SectionBlock, error) { sec := NewSectionBlock(strings.Join(block.Args, " ")) if err := p.Next(); err != nil { return sec, err } return sec, sec.parse(p, block) } // TextBlock represents a "text" content block. type TextBlock struct { // Format is the text format (first word of the block argument). Format string // Contents are the text contents. Contents TextContents } // NewTextBlock creates a new TextBlock containing arbitrary text contents. func NewTextBlock(format string, contents TextContents) *TextBlock { return &TextBlock{format, contents} } // Name returns the block name "text". func (t *TextBlock) Name() string { return "text" } // Args returns the block's arguments (format). func (t *TextBlock) Args() []string { if t.Format == "" { return nil } return []string{t.Format} } // WriteIndent writes the block header and its content indented by n tabs. func (t *TextBlock) WriteIndent(w io.Writer, n int) error { s := t.Name() if t.Format != "" { s += " " + Escape(t.Format) } if err := WriteIndent(w, s, n); err != nil { return err } if err := t.Contents.WriteIndent(w, n+1); err != nil { return err } return nil } func parseContentText(p *Parser, block *TokenBlock) (*TextBlock, error) { format := "" if len(block.Args) >= 1 { format = block.Args[0] } tb := NewTextBlock(format, nil) if err := p.Next(); err != nil { return tb, err } var err error tb.Contents, err = parseTextFormat(p, block, tb.Format) return tb, err } func parseTextFormat(p *Parser, block *TokenBlock, format string) (TextContents, error) { if parser := GetTextContentParser(format); parser != nil { return parser(p, block) } return parseTextRaw(p, block) } // TextContents represents the textual contents of a text block. type TextContents interface { WriteIndent(w io.Writer, n int) error } // TextContentParser parses text content in a text block. type TextContentParser func(p *Parser, block *TokenBlock) (TextContents, error) var textContentParsers = map[string]TextContentParser{} // GetTextContentParser retrieves a text content parser or nil if it doesn't // exist. func GetTextContentParser(name string) TextContentParser { return textContentParsers[name] } // RegisterTextContentParser registers a new text content parser for a format. func RegisterTextContentParser(name string, parser TextContentParser) { if parser == nil { delete(textContentParsers, name) } else { textContentParsers[name] = parser } } // TextPlainContents represents a list of simple text paragraphs. type TextPlainContents struct { // Paragraphs is a list of simple text paragraphs. Paragraphs []string } // WriteIndent writes the plain text content indented by n tabs. func (t TextPlainContents) WriteIndent(w io.Writer, n int) error { for i, p := range t.Paragraphs { if i != 0 { if err := WriteIndent(w, "", 0); err != nil { return err } } if err := WriteIndent(w, Escape(p), n); err != nil { return err } } return nil } // NewTextPlainBlock creates a new TextBlock containing TextPlainContents. func NewTextPlainBlock(paragraphs []string) *TextBlock { par := make([]string, len(paragraphs)) copy(par, paragraphs) return NewTextBlock("", TextPlainContents{par}) } func parseTextPlain(p *Parser, block *TokenBlock) (TextContents, error) { txt := TextPlainContents{} paragraph := "" var err error for err == nil { if !p.Empty() && p.Indent() <= block.Indent() { break } token := p.SimpleText() end := false if text, ok := token.(*TokenSimpleText); ok { if text.Text == "" { end = true } else if paragraph == "" { paragraph = text.Text } else { paragraph += " " + text.Text } } else if _, ok := token.(*TokenEmptyLine); ok && paragraph != "" { end = true } if end { txt.Paragraphs = append(txt.Paragraphs, paragraph) paragraph = "" } err = p.Next() } if paragraph != "" { txt.Paragraphs = append(txt.Paragraphs, paragraph) } return txt, err } // TextPreContents represents preformatted contents of a text block. type TextPreContents struct { // Text is the preformatted content. Text string } // WriteIndent writes the preformatted text content indented by n tabs. func (t TextPreContents) WriteIndent(w io.Writer, n int) error { ss := strings.Split(t.Text, "\n") for _, s := range ss { if err := WriteIndent(w, EscapeNonspace(s), n); err != nil { return err } } return nil } // NewTextPreBlock creates a new TextBlock containing TextPreContents. func NewTextPreBlock(text string) *TextBlock { return NewTextBlock("", TextPreContents{text}) } func parseTextPre(p *Parser, block *TokenBlock) (TextContents, error) { var lines []string var ls []string var err error for err == nil { if !p.Empty() && p.Indent() <= block.Indent() { break } token := p.RawText() if text, ok := token.(*TokenRawText); ok { if len(ls) > 0 { lines = append(lines, ls...) ls = ls[:0] } lines = append(lines, Unescape(text.Text)) } else if _, ok := token.(*TokenEmptyLine); ok && len(lines) > 0 { ls = append(ls, "") } err = p.Next() } return TextPreContents{strings.Join(lines, "\n")}, err } // TextRawContents represents raw contents of a text or raw block. type TextRawContents struct { // Text is the raw content. Text string } // WriteIndent writes the raw content indented by n tabs. func (t TextRawContents) WriteIndent(w io.Writer, n int) error { ss := strings.Split(t.Text, "\n") for _, s := range ss { if err := WriteIndent(w, s, n); err != nil { return err } } return nil } func parseTextRaw(p *Parser, block *TokenBlock) (TextContents, error) { var lines []string var ls []string var err error for err == nil { if !p.Empty() && p.Indent() <= block.Indent() { break } token := p.RawText() if text, ok := token.(*TokenRawText); ok { if len(ls) > 0 { lines = append(lines, ls...) ls = ls[:0] } lines = append(lines, text.Text) } else if _, ok := token.(*TokenEmptyLine); ok && len(lines) > 0 { ls = append(ls, "") } err = p.Next() } return TextRawContents{strings.Join(lines, "\n")}, err } // RawBlock represents a "raw" content block. type RawBlock struct { // Syntax is the syntax of the block contents (first word of block argument) Syntax string // Contents is the raw content. Contents TextRawContents } // NewRawBlock creates a new RawBlock. func NewRawBlock(syntax, contents string) *RawBlock { return &RawBlock{syntax, TextRawContents{contents}} } // Name returns the block name "raw". func (r *RawBlock) Name() string { return "raw" } // Args returns the block's arguments (syntax). func (r *RawBlock) Args() []string { if r.Syntax == "" { return nil } return []string{r.Syntax} } // WriteIndent writes the raw content indented by n tabs. func (r *RawBlock) WriteIndent(w io.Writer, n int) error { s := r.Name() if r.Syntax != "" { s += " " + Escape(r.Syntax) } if err := WriteIndent(w, s, n); err != nil { return err } r.Contents.WriteIndent(w, n+1) return nil } func parseContentRaw(p *Parser, block *TokenBlock) (*RawBlock, error) { arg := "" if len(block.Args) > 0 { arg = block.Args[0] } rb := &RawBlock{arg, TextRawContents{}} if err := p.Next(); err != nil { return rb, err } tc, err := parseTextRaw(p, block) if tc != nil { rb.Contents = tc.(TextRawContents) } return rb, err } // ListBlock represents a "list" content block. type ListBlock struct { ContentBlock } // NewListBlock creates a new ListBlock. // // If the ordered parameter is true, the list is created in "ordered" mode. func NewListBlock(ordered bool) *ListBlock { arg := "" if ordered { arg = "ordered" } return &ListBlock{*NewContentBlock("list", arg)} } // Ordered returns true if the list is in ordered mode (first word of the // block argument is "ordered"). func (b *ListBlock) Ordered() bool { return len(b.args) >= 1 && b.args[0] == "ordered" } func parseContentList(p *Parser, block *TokenBlock) (*ListBlock, error) { list := NewListBlock(false) list.args = block.Args if err := p.Next(); err != nil { return list, err } return list, list.parse(p, block) } // TableBlock represents a "table" content block. type TableBlock struct { ContentBlock } // NewTableBlock creates a new TableBlock. func NewTableBlock() *TableBlock { return &TableBlock{*NewContentBlock("table", "")} } func (t *TableBlock) parse(p *Parser, block *TokenBlock) (err error) { for err == nil { if !p.Empty() && p.Indent() <= block.Indent() { break } token := p.Block() if blk, ok := token.(*TokenBlock); ok { var b Block switch blk.Name { case "row": b, err = parseTableRow(p, blk) case "header": b, err = parseTableHeader(p, blk) default: err = parseUnknown(p, blk) } if b != nil { t.AppendChild(b) } } else if err = p.Next(); err != nil { break } } return } func parseContentTable(p *Parser, block *TokenBlock) (*TableBlock, error) { table := NewTableBlock() if err := p.Next(); err != nil { return table, err } return table, table.parse(p, block) } // RowBlock represents a "row" table block. type RowBlock struct { ContentBlock } // NewRowBlock creates a new RowBlock. func NewRowBlock() *RowBlock { return &RowBlock{*NewContentBlock("row", "")} } func parseTableRow(p *Parser, block *TokenBlock) (*RowBlock, error) { row := NewRowBlock() if err := p.Next(); err != nil { return row, err } return row, row.parse(p, block) } // HeaderBlock represents a "header" table block. type HeaderBlock struct { ContentBlock } // NewHeaderBlock creates a new HeaderBlock. func NewHeaderBlock() *HeaderBlock { return &HeaderBlock{*NewContentBlock("header", "")} } func parseTableHeader(p *Parser, block *TokenBlock) (*HeaderBlock, error) { hdr := NewHeaderBlock() if err := p.Next(); err != nil { return hdr, err } return hdr, hdr.parse(p, block) } // EmbedBlock represents an "embed" content block. type EmbedBlock struct { // Type is the content type (first word of block argument). Type string // URL is the content URL (second word of the block argument). URL string // Description is the content description (block body as simple text). Description string } // NewEmbedBlock creates a new EmbedBlock. func NewEmbedBlock(typ, url, desc string) *EmbedBlock { return &EmbedBlock{typ, url, desc} } // Name returns the block name "embed". func (e *EmbedBlock) Name() string { return "embed" } // Args returns the block argument (type and URL). func (e *EmbedBlock) Args() []string { if e.Type != "" && e.URL != "" { return []string{e.Type, e.URL} } return []string{e.Type} } // WriteIndent writes the embed block header and contents indented by n tabs. func (e *EmbedBlock) WriteIndent(w io.Writer, n int) error { if e.URL == "" { return nil } s := e.Name() + " " if e.Type == "" { s += "*/*" } else { s += Escape(e.Type) } s += " " + EscapeAll(e.URL) if err := WriteIndent(w, s, n); err != nil { return err } if err := WriteIndent(w, Escape(e.Description), n+1); err != nil { return err } return nil } func parseContentEmbed(p *Parser, block *TokenBlock) (*EmbedBlock, error) { embed := &EmbedBlock{} if len(block.Args) >= 1 { embed.Type = block.Args[0] if len(block.Args) >= 2 { embed.URL = block.Args[1] } } if err := p.Next(); err != nil { return embed, err } s, err := getSimpleText(p, block) embed.Description = s return embed, err }