From 26248678aafc2f8e277d4bdafc116f2b349b02c5 Mon Sep 17 00:00:00 2001 From: clsr Date: Fri, 18 Aug 2017 13:45:49 +0200 Subject: Initial commit --- content.go | 610 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 610 insertions(+) create mode 100644 content.go (limited to 'content.go') diff --git a/content.go b/content.go new file mode 100644 index 0000000..971e9e3 --- /dev/null +++ b/content.go @@ -0,0 +1,610 @@ +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 +} + +// 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) + } + r, err := parseContentRaw(p, block) + return TextPreContents{r.Contents}, err +} + +// 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 +} + +// 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 string +} + +// 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 + } + if r.Contents != "" { + ss := strings.Split(r.Contents, "\n") + for _, s := range ss { + if err := writeIndent(w, s, n+1); err != nil { + return err + } + } + } + return nil +} + +func parseContentRaw(p *Parser, block *TokenBlock) (*RawBlock, error) { + arg := "" + if len(block.Args) > 0 { + arg = block.Args[0] + } + rb := &RawBlock{arg, ""} + + if err := p.Next(); err != nil { + return rb, err + } + + 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() + } + rb.Contents = strings.Join(lines, "\n") + + 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 { + rows []Block +} + +// NewTableBlock creates a new TableBlock. +func NewTableBlock() *TableBlock { + return &TableBlock{} +} + +// Name returns the block name "table". +func (t *TableBlock) Name() string { + return "table" +} + +// Args returns the block's nil arguments. +func (t *TableBlock) Args() []string { + return nil +} + +// WriteIndent writes the table header and contents indented by n tabs. +func (t *TableBlock) WriteIndent(w io.Writer, n int) error { + if err := writeIndent(w, t.Name(), n); err != nil { + return err + } + for _, row := range t.rows { + if err := row.WriteIndent(w, n+1); err != nil { + return err + } + } + return nil +} + +// Rows returns the table's rows. +func (t *TableBlock) Rows() []Block { + return t.rows +} + +// AppendRow adds a new row to the end of the table. +func (t *TableBlock) AppendRow(row Block) { + t.rows = append(t.rows, row) +} + +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.AppendRow(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 +} + +// 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 += " " + Escape(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 +} -- cgit