htmlrender

Documentation

Index

• Constants
• Variables
• type Custom
• type Formatter
  • func NewFormatter(fc FormatterConf) (*Formatter, error)
  • func (f *Formatter) FormatString(r gemtext.LineReader) (string, error)
  • func (f *Formatter) FormatWriter(r gemtext.LineReader, w io.Writer) error
• type FormatterConf
• type HTMLElement
  • func (h HTMLElement) Write(w io.Writer, l gemtext.Line, r LineReader) (err error)
• type LineReader

Constants

const (
	CSSClassUnknownCustom    = `gem-unknown-element`
	CSSClassText             = `gem-text`
	CSSClassLink             = `gem-link`
	CSSClassLinkRocket       = `gem-link-rocket`
	CSSClassPreformattedText = `gem-preformatted-text`
	CSSClass1stHeader        = `gem-header-1`
	CSSClass2ndHeader        = `gem-header-2`
	CSSClass3rdHeader        = `gem-header-3`
	CSSClassUnorderedList    = `gem-list-unordered`
	CSSClassQuote            = `gem-quote`
)

CSS Classes for the default element types

Variables

var LineHeading1 = HTMLElement{
	Tags:  []string{"h1"},
	Class: CSSClass1stHeader,
}

var LineHeading2 = HTMLElement{
	Tags:  []string{"h2"},
	Class: CSSClass2ndHeader,
}

var LineHeading3 = HTMLElement{
	Tags:  []string{"h3"},
	Class: CSSClass3rdHeader,
}

var LineLink = HTMLElement{
	Tags:   []string{"a"},
	Class:  CSSClassLink,
	Prefix: "<b class='" + CSSClassLinkRocket + "'>=> </b>",
	Suffix: "<br>",
	MetaWriter: func(tag string, metas map[gemtext.MetaType]string) string {
		return "href='" + metas[gemtext.LinkRef] + "'"
	},
}

var LinePreformattedText = HTMLElement{
	Tags:      []string{"pre"},
	Class:     CSSClassPreformattedText,
	Linebreak: true,
	MetaWriter: func(tag string, metas map[gemtext.MetaType]string) string {
		if metas[gemtext.PreformattedTextAlttext] == "" {
			return ""
		}
		return "title='" + metas[gemtext.PreformattedTextAlttext] + "'"
	},
}

var LineQuote = HTMLElement{
	Tags:         []string{"blockquote"},
	Class:        CSSClassQuote,
	Linebreak:    true,
	JoinAdjacent: true,
}

var LineText = HTMLElement{
	Tags:         []string{"p"},
	Class:        CSSClassText,
	JoinAdjacent: true,
	Linebreak:    true,
}

var LineUnorderedList = HTMLElement{
	Tags:         []string{"ul"},
	Class:        CSSClassUnorderedList,
	Linebreak:    true,
	JoinAdjacent: true,
	AlwaysTags:   []string{"li"},
}

Types

type Custom

type Custom interface {
	Write(w io.Writer, l gemtext.Line, r LineReader) error
}

Custom defines a custom unit

type Formatter

type Formatter struct {
	// contains filtered or unexported fields
}

func NewFormatter

func NewFormatter(fc FormatterConf) (*Formatter, error)

func (*Formatter) FormatString

func (f *Formatter) FormatString(r gemtext.LineReader) (string, error)

FormatString writes a parsed gemtext file into html and returns a string See FormatWriter for more documentation

func (*Formatter) FormatWriter

func (f *Formatter) FormatWriter(r gemtext.LineReader, w io.Writer) error

FormatWriter writes a parsed gemtext file into html the html header, footer, and stylesheets is left up to the caller to handle

type FormatterConf

type FormatterConf struct {
	CustomTypes  map[string]Custom
	BuiltinTypes map[gemtext.LineType]Custom
}

type HTMLElement

type HTMLElement struct {
	// the html tags used (in order of highest to lowest)
	Tags []string

	// the css class given to an instance of this
	// (only given to the top level tag if more than 1 is used)
	Class string

	// whether or not it will merge the tags with the next and previous tags
	JoinAdjacent bool

	// AdjacentTags are html takes like the ones in tags but are repeated
	// for every line regardless of JoinAdjactent
	AlwaysTags []string

	// print a linebreak before and after the line content?
	Linebreak bool

	// suffix the result with this
	Suffix string
	// prefix the result with this
	Prefix string

	// a small function that decides how to write the other meta tags
	// such as for links
	MetaWriter func(tag string, metas map[gemtext.MetaType]string) string
}

HTMLElement writes an html element from a gemtext block with some metadata

func (HTMLElement) Write

func (h HTMLElement) Write(w io.Writer, l gemtext.Line, r LineReader) (err error)

type LineReader

type LineReader interface {
	Current() gemtext.Line
	Peek(i int) gemtext.Line
	PeekBack() gemtext.Line
	PeekAhead() gemtext.Line
}

LineReader is a linereader but somewhat more restricted