-
some source code
+ Context("Listing blocks", func() {
+
+ It("source block with multiple lines", func() {
+ content := "```\nsome source code\n\nhere\n```"
+ expected := `
+
+
some source code
+
+ here
+
+
+ Context("Literal blocks", func() {
+
+ It("literal block with multiple lines", func() {
+ content := " some source code\nhere\n"
+ expected := `
`
- verify(GinkgoT(), expected, content)
+ verify(GinkgoT(), expected, content)
+ })
})
})
diff --git a/renderer/html5/literal_blocks.go b/renderer/html5/literal_blocks.go
new file mode 100644
index 00000000..10762518
--- /dev/null
+++ b/renderer/html5/literal_blocks.go
@@ -0,0 +1,33 @@
+package html5
+
+import (
+ "bytes"
+ "html/template"
+
+ asciidoc "github.com/bytesparadise/libasciidoc/context"
+ "github.com/bytesparadise/libasciidoc/types"
+ "github.com/pkg/errors"
+ log "github.com/sirupsen/logrus"
+)
+
+var literalBlockTmpl *template.Template
+
+// initializes the templates
+func init() {
+ literalBlockTmpl = newHTMLTemplate("literal block", `
`)
+}
+
+func renderLiteralBlock(ctx asciidoc.Context, block types.LiteralBlock) ([]byte, error) {
+ log.Debugf("rendering delimited block with content: %s", block.Content)
+ result := bytes.NewBuffer(nil)
+ err := literalBlockTmpl.Execute(result, block)
+ if err != nil {
+ return nil, errors.Wrapf(err, "unable to render delimited block")
+ }
+ // log.Debugf("rendered delimited block: %s", result.Bytes())
+ return result.Bytes(), nil
+}
diff --git a/renderer/html5/renderer.go b/renderer/html5/renderer.go
index 9bb6fb94..2b10a923 100644
--- a/renderer/html5/renderer.go
+++ b/renderer/html5/renderer.go
@@ -118,6 +118,8 @@ func processElement(ctx asciidoc.Context, element types.DocElement) ([]byte, err
return renderInlineImage(ctx, *element.(*types.InlineImage))
case *types.DelimitedBlock:
return renderDelimitedBlock(ctx, *element.(*types.DelimitedBlock))
+ case *types.LiteralBlock:
+ return renderLiteralBlock(ctx, *element.(*types.LiteralBlock))
case *types.InlineContent:
return renderInlineContent(ctx, *element.(*types.InlineContent))
case *types.StringElement:
diff --git a/types/grammar_types.go b/types/grammar_types.go
index 95d1099f..ba74191a 100644
--- a/types/grammar_types.go
+++ b/types/grammar_types.go
@@ -109,11 +109,11 @@ type DocumentAttributeDeclaration struct {
// NewDocumentAttributeDeclaration initializes a new DocumentAttributeDeclaration
func NewDocumentAttributeDeclaration(name []interface{}, value []interface{}) (*DocumentAttributeDeclaration, error) {
- attrName, err := stringify(name)
+ attrName, err := Stringify(name)
if err != nil {
return nil, errors.Wrapf(err, "error while initializing a DocumentAttributeDeclaration")
}
- attrValue, err := stringify(value)
+ attrValue, err := Stringify(value)
if err != nil {
return nil, errors.Wrapf(err, "error while initializing a DocumentAttributeDeclaration")
}
@@ -136,7 +136,7 @@ type DocumentAttributeReset struct {
// NewDocumentAttributeReset initializes a new Document Attribute Resets.
func NewDocumentAttributeReset(name []interface{}) (*DocumentAttributeReset, error) {
- attrName, err := stringify(name)
+ attrName, err := Stringify(name)
if err != nil {
return nil, errors.Wrapf(err, "error while initializing a DocumentAttributeReset")
}
@@ -161,7 +161,7 @@ type DocumentAttributeSubstitution struct {
// NewDocumentAttributeSubstitution initializes a new Document Attribute Substitutions
func NewDocumentAttributeSubstitution(name []interface{}) (*DocumentAttributeSubstitution, error) {
- attrName, err := stringify(name)
+ attrName, err := Stringify(name)
if err != nil {
return nil, errors.Wrapf(err, "error while initializing a DocumentAttributeSubstitution")
}
@@ -195,9 +195,9 @@ type FrontMatter struct {
// NewYamlFrontMatter initializes a new FrontMatter from the given `content`
func NewYamlFrontMatter(content []interface{}) (*FrontMatter, error) {
- c, err := stringify(content)
+ c, err := Stringify(content)
if err != nil {
- return nil, errors.Wrapf(err, "unable to 'stringify' content in front-matter of document")
+ return nil, errors.Wrapf(err, "unable to 'Stringify' content in front-matter of document")
}
attributes := make(map[string]interface{})
err = yaml.Unmarshal([]byte(*c), &attributes)
@@ -475,7 +475,7 @@ func NewInlineContent(text []byte, elements []interface{}) (*InlineContent, erro
mergedInlineElements[i] = element.(InlineElement)
}
result := &InlineContent{Elements: mergedInlineElements}
- log.Debugf("Initialized new InlineContent with %d element(s): '%s'", len(result.Elements), result.String(0))
+ log.Debugf("Initialized new InlineContent with %d element(s): %s", len(result.Elements), result.String(0))
return result, nil
}
@@ -530,7 +530,7 @@ type BlockImage struct {
// NewBlockImage initializes a new `BlockImage`
func NewBlockImage(input []byte, imageMacro ImageMacro, attributes []interface{}) (*BlockImage, error) {
- log.Debugf("Initializing a new BlockImage from '%s'", input)
+ log.Debugf("Initializing a new BlockImage from %s", input)
id, title, link := newElementAttributes(attributes)
return &BlockImage{
Macro: imageMacro,
@@ -552,7 +552,7 @@ type InlineImage struct {
// NewInlineImage initializes a new `InlineImage` (similar to BlockImage, but without attributes)
func NewInlineImage(input []byte, imageMacro ImageMacro) (*InlineImage, error) {
- log.Debugf("Initializing a new InlineImage from '%s'", input)
+ log.Debugf("Initializing a new InlineImage from %s", input)
return &InlineImage{
Macro: imageMacro,
}, nil
@@ -599,7 +599,7 @@ type ImageMacro struct {
// NewImageMacro initializes a new `ImageMacro`
func NewImageMacro(input []byte, path string, attributes interface{}) (*ImageMacro, error) {
- log.Debugf("Initializing a new ImageMacro from '%s'", input)
+ log.Debugf("Initializing a new ImageMacro from %s", input)
var alt string
var width, height *string
if attributes != nil {
@@ -644,7 +644,7 @@ func (m *ImageMacro) String(indentLevel int) string {
if m.Height != nil {
height = *m.Height
}
- return fmt.Sprintf("%s<%T> %s['%s', w='%s' h='%s']", indent(indentLevel), m, m.Path, m.Alt, width, height)
+ return fmt.Sprintf("%s<%T> %s[%s, w=%s h=%s]", indent(indentLevel), m, m.Path, m.Alt, width, height)
}
// Accept implements Visitable#Accept(Visitor)
@@ -672,8 +672,8 @@ func (m *ImageMacro) Accept(v Visitor) error {
type DelimitedBlockKind int
const (
- // SourceBlock a source block
- SourceBlock DelimitedBlockKind = iota
+ // FencedBlock a fenced block
+ FencedBlock DelimitedBlockKind = iota
)
// DelimitedBlock the structure for the delimited blocks
@@ -684,19 +684,22 @@ type DelimitedBlock struct {
// NewDelimitedBlock initializes a new `DelimitedBlock` of the given kind with the given content
func NewDelimitedBlock(kind DelimitedBlockKind, content []interface{}) (*DelimitedBlock, error) {
- c, err := stringify(content)
+ c, err := Stringify(content)
if err != nil {
return nil, errors.Wrapf(err, "unable to initialize a new delimited block")
}
+ // remove "\n" or "\r\n", depending on the OS.
+ blockContent := strings.TrimSuffix(strings.TrimSuffix(*c, "\n"), "\r")
+ log.Debugf("Initialized a new DelimitedBlock with content=`%s`", blockContent)
return &DelimitedBlock{
Kind: kind,
- Content: strings.TrimSuffix(strings.TrimSuffix(*c, "\n"), "\r"), // remove "\n" or "\r\n", depending on the OS.
+ Content: blockContent,
}, nil
}
// String implements the DocElement#String() method
func (b *DelimitedBlock) String(indentLevel int) string {
- return fmt.Sprintf("%s<%T> %v", indent(indentLevel), b, b.Content)
+ return fmt.Sprintf("%s<%T|%v> %v", indent(indentLevel), b, b.Kind, b.Content)
}
// Accept implements Visitable#Accept(Visitor)
@@ -716,6 +719,54 @@ func (b *DelimitedBlock) Accept(v Visitor) error {
return nil
}
+// ------------------------------------------
+// Literal blocks
+// ------------------------------------------
+
+// LiteralBlock the structure for the literal blocks
+type LiteralBlock struct {
+ Content string
+}
+
+// NewLiteralBlock initializes a new `DelimitedBlock` of the given kind with the given content,
+// along with the given heading spaces
+func NewLiteralBlock(spaces, content []interface{}) (*LiteralBlock, error) {
+ // concatenates the spaces with the actual content in a single 'stringified' value
+ // log.Debugf("Initializing a new LiteralBlock with spaces='%v' and content=`%v`", spaces, content)
+ c, err := Stringify(append(spaces, content...))
+ if err != nil {
+ return nil, errors.Wrapf(err, "unable to initialize a new literal block")
+ }
+ // remove "\n" or "\r\n", depending on the OS.
+ blockContent := strings.TrimSuffix(strings.TrimSuffix(*c, "\n"), "\r")
+ log.Debugf("Initialized a new LiteralBlock with content=`%s`", blockContent)
+ return &LiteralBlock{
+ Content: blockContent,
+ }, nil
+}
+
+// String implements the DocElement#String() method
+func (b *LiteralBlock) String(indentLevel int) string {
+ return fmt.Sprintf("%s<%T> %v", indent(indentLevel), b, b.Content)
+}
+
+// Accept implements Visitable#Accept(Visitor)
+func (b *LiteralBlock) Accept(v Visitor) error {
+ err := v.BeforeVisit(b)
+ if err != nil {
+ return errors.Wrapf(err, "error while pre-visiting delimited block")
+ }
+ err = v.Visit(b)
+ if err != nil {
+ return errors.Wrapf(err, "error while visiting delimited block")
+ }
+ err = v.AfterVisit(b)
+ if err != nil {
+ return errors.Wrapf(err, "error while post-visiting delimited block")
+ }
+ return nil
+}
+
// ------------------------------------------
// Meta Elements
// ------------------------------------------
@@ -762,7 +813,7 @@ type ElementID struct {
// NewElementID initializes a new `ElementID` from the given path
func NewElementID(id string) (*ElementID, error) {
- log.Debugf("Initializing a new ElementID with value=`%s`", id)
+ log.Debugf("Initializing a new ElementID with value=%s", id)
return &ElementID{Value: id}, nil
}
@@ -778,11 +829,11 @@ type ElementTitle struct {
// NewElementTitle initializes a new `ElementTitle` from the given content
func NewElementTitle(content []interface{}) (*ElementTitle, error) {
- c, err := stringify(content)
+ c, err := Stringify(content)
if err != nil {
return nil, errors.Wrapf(err, "failed to initialize a new ElementTitle")
}
- log.Debugf("Initializing a new ElementTitle with content=%s", c)
+ log.Debugf("Initializing a new ElementTitle with content=%s", *c)
return &ElementTitle{Value: *c}, nil
}
@@ -807,7 +858,7 @@ func NewStringElement(content interface{}) *StringElement {
// String implements the DocElement#String() method
func (s *StringElement) String(indentLevel int) string {
- return fmt.Sprintf("%s`%s`", indent(indentLevel), s.Content)
+ return fmt.Sprintf("%s%s", indent(indentLevel), s.Content)
}
// PlainString implements the InlineElement#PlainString() method
@@ -939,11 +990,11 @@ type ExternalLink struct {
// NewExternalLink initializes a new `ExternalLink`
func NewExternalLink(url, text []interface{}) (*ExternalLink, error) {
- urlStr, err := stringify(url)
+ urlStr, err := Stringify(url)
if err != nil {
return nil, errors.Wrapf(err, "failed to initialize a new ExternalLink element")
}
- textStr, err := stringify(text)
+ textStr, err := Stringify(text)
if err != nil {
return nil, errors.Wrapf(err, "failed to initialize a new ExternalLink element")
}
diff --git a/types/type_utils.go b/types/type_utils.go
index f31c3b02..33958caf 100644
--- a/types/type_utils.go
+++ b/types/type_utils.go
@@ -93,7 +93,8 @@ func appendBuffer(elements []interface{}, buff *bytes.Buffer) ([]interface{}, *b
return elements, buff
}
-func stringify(elements []interface{}) (*string, error) {
+//Stringify convert the given elements into a string
+func Stringify(elements []interface{}) (*string, error) {
mergedElements := merge(elements)
b := make([]byte, 0)
buff := bytes.NewBuffer(b)
@@ -114,7 +115,7 @@ func stringify(elements []interface{}) (*string, error) {
case *StringElement:
buff.WriteString(element.Content)
case []interface{}:
- stringifiedElement, err := stringify(element)
+ stringifiedElement, err := Stringify(element)
if err != nil {
// no need to wrap the error again in the same function
return nil, err