Added codeblock format and improved rendering performance and FormatWrapper interface

Author: dchenk

README.md

@@ -39,6 +39,7 @@ fmt.Println(string(html))
  - Indent
  - List (ul and ol, including nested lists)
  - Text alignment
+ - Code block
 
 ### Embeds
  - Image (an inline format)

block_formats.go

@@ -149,3 +149,48 @@ func (inf *indentFormat) Fmt() *Format {
 func (inf *indentFormat) HasFormat(o *Op) bool {
 	return o.Attrs["indent"] == inf.in
 }
+
+// code block
+type codeBlockFormat struct {
+	o *Op
+}
+
+func (cf *codeBlockFormat) Fmt() *Format {
+	return &Format{
+		Place: Tag,
+		Block: true,
+	}
+}
+
+func (cf *codeBlockFormat) HasFormat(o *Op) bool {
+	return false // Only a wrapper.
+}
+
+// codeBlockFormat implements the FormatWrapper interface.
+func (*codeBlockFormat) Wrap() (string, string) {
+	return "<pre>", "\n</pre>"
+}
+
+// codeBlockFormat implements the FormatWrapper interface.
+func (*codeBlockFormat) Open(open []*Format, _ *Op) bool {
+	// If there is a code block already open, no need to open another.
+	for i := range open {
+		if open[i].Place == Tag && open[i].Val == "<pre>" {
+			return false
+		}
+	}
+	return true
+}
+
+// codeBlockFormat implements the FormatWrapper interface.
+func (cf *codeBlockFormat) Close(_ []*Format, o *Op, doingBlock bool) bool {
+	if doingBlock && !o.HasAttr("code-block") {
+		return true
+	}
+	// We are simply adding another line to the code block. The previous line should end with
+	// a "\n" though all instances of "\n" are stripped out by the split from the start.
+	if !doingBlock {
+		o.Data = "\n" + o.Data
+	}
+	return false
+}

inline_formats.go

@@ -71,7 +71,7 @@ type linkFormat struct {
 func (*linkFormat) Fmt() *Format { return new(Format) } // Only a wrapper.
 
 func (lf *linkFormat) HasFormat(*Op) bool {
-	return false
+	return false // Only a wrapper.
 }
 
 func (lf *linkFormat) Wrap() (string, string) {

render.go

@@ -62,44 +62,27 @@ func RenderExtended(ops []byte, customFormats func(string, *Op) Formatter) (html
 		// Open the a block element, write its body, and close it to move on only when the ending "\n" of the block is reached.
 		if strings.IndexByte(o.Data, '\n') != -1 {
 
-			if o.Data == "\n" { // Write a block element and flush the temporary buffer.
+			// Extract text from between the block-terminating line feeds and write each part as its own Op.
+			split := strings.Split(o.Data, "\n")
 
-				// Avoid empty paragraphs and "\n" in the output.
-				if tempBuf.Len() == 0 {
-					o.Data = "<br>"
-				} else {
-					o.Data = ""
-				}
-
-				o.writeBlock(fs, tempBuf, finalBuf, fms)
-
-			} else { // Extract the block-terminating line feeds and write each part as its own Op.
-
-				split := strings.Split(o.Data, "\n")
+			for i := range split {
 
-				for i := range split {
+				o.Data = split[i]
 
-					o.Data = split[i]
+				// If the current o.Data still has an "\n" following (its not the last in split), then it ends a block.
+				if i < len(split)-1 {
 
-					// If the current o.Data still has an "\n" following (its not the last in split), then it ends a block.
-					if i < len(split)-1 {
+					o.writeBlock(fs, tempBuf, finalBuf, fms)
 
-						// Avoid having empty paragraphs.
-						if tempBuf.Len() == 0 && o.Data == "" {
-							o.Data = "<br>"
-						}
+				} else if o.Data != "" { // If the last element in split is just "" then the last character in the rawOp is "\n".
 
-						o.writeBlock(fs, tempBuf, finalBuf, fms)
-
-					} else if o.Data != "" { // If the last element in split is just "" then the last character in the rawOp is "\n".
-						o.writeInline(fs, tempBuf, fms)
-					}
+					o.writeInline(fs, tempBuf, fms)
 
 				}
 
 			}
 
-		} else { // We are just adding stuff inline.
+		} else {
 			o.writeInline(fs, tempBuf, fms)
 		}
 
@@ -154,19 +137,6 @@ type Op struct {
 func (o *Op) writeBlock(fs *formatState, tempBuf *bytes.Buffer, finalBuf *bytes.Buffer, newFms []*Format) {
 
 	// Close the inline formats opened within the block to the tempBuf and block formats of wrappers to finalBuf.
-	//wrapFs := &formatState{make([]*Format, 0, 2)}
-	//inlineFs := &formatState{make([]*Format, 0, 2)}
-	//for i := range fs.open {
-	//	if fs.open[i].wrap {
-	//		wrapFs.add(fs.open[i])
-	//	} else {
-	//		inlineFs.add(fs.open[i])
-	//	}
-	//}
-	//wrapFs.closePrevious(finalBuf, o, true)
-	//inlineFs.closePrevious(tempBuf, o, true)
-	//fs.open = append(wrapFs.open, inlineFs.open...) // There may be something left open.
-	//fs.closePrevious(tempBuf, o, true)
 	closedTemp := &formatState{}
 
 	for i := len(fs.open) - 1; i >= 0; i-- { // Start with the last format opened.
@@ -208,11 +178,6 @@ func (o *Op) writeBlock(fs *formatState, tempBuf *bytes.Buffer, finalBuf *bytes.
 		style   string
 	}
 
-	// At least a format from the Op.Type should be set.
-	if len(newFms) == 0 {
-		return
-	}
-
 	// Merge all formats into a single tag.
 	for i := range newFms {
 		fm := newFms[i]
@@ -222,9 +187,7 @@ func (o *Op) writeBlock(fs *formatState, tempBuf *bytes.Buffer, finalBuf *bytes.
 			switch fm.Place {
 			case Tag:
 				// If an opening tag is not specified by the Op insert type, it may be specified by an attribute.
-				if v != "" {
-					block.tagName = v // Override whatever value is set.
-				}
+				block.tagName = v // Override whatever value is set.
 			case Class:
 				block.classes = append(block.classes, v)
 			case Style:
@@ -239,6 +202,11 @@ func (o *Op) writeBlock(fs *formatState, tempBuf *bytes.Buffer, finalBuf *bytes.
 		}
 	}
 
+	// Avoid empty paragraphs and "\n" in the output for text blocks.
+	if o.Data == "" && block.tagName == "p" && tempBuf.Len() == 0 {
+		o.Data = "<br>"
+	}
+
 	if block.tagName != "" {
 		finalBuf.WriteByte('<')
 		finalBuf.WriteString(block.tagName)
@@ -258,9 +226,6 @@ func (o *Op) writeBlock(fs *formatState, tempBuf *bytes.Buffer, finalBuf *bytes.
 		closeTag(finalBuf, block.tagName)
 	}
 
-	// Write out the closes by FormatWrapper formats, starting from the last written.
-	//fs.closePrevious(finalBuf, o, true)
-
 	tempBuf.Reset()
 
 }
@@ -368,6 +333,8 @@ func (o *Op) getFormatter(keyword string, customFormats func(string, *Op) Format
 			sf.t = "sub"
 		}
 		return sf
+	case "code-block":
+		return &codeBlockFormat{o}
 	}
 
 	return nil

render_test.go

@@ -57,7 +57,7 @@ func TestSimple(t *testing.T) {
 
 func TestRender(t *testing.T) {
 
-	pairNames := []string{"ops1", "nested", "ordering", "list1", "list2", "list3", "list4", "indent"}
+	pairNames := []string{"ops1", "nested", "ordering", "list1", "list2", "list3", "list4", "indent", "code1", "code2"}
 
 	for _, n := range pairNames {
 

tests/code1.html

@@ -0,0 +1,4 @@
+<pre>some code
+  and more
+</pre><p>plain text</p><pre>more code
+</pre>

tests/code1.json

@@ -0,0 +1,29 @@
+[
+	{
+		"insert": "some code"
+	},
+	{
+		"attributes": {
+			"code-block": true
+		},
+		"insert": "\n"
+	},
+	{
+		"insert": "  and more"
+	},
+	{
+		"attributes": {
+			"code-block": true
+		},
+		"insert": "\n"
+	},
+	{
+		"insert": "plain text\nmore code"
+	},
+	{
+		"attributes": {
+			"code-block": true
+		},
+		"insert": "\n"
+	}
+]

tests/code2.html

@@ -0,0 +1,5 @@
+<pre>
+some code
+  and more
+</pre><p>plain text</p><pre>more code
+</pre>

tests/code2.json

@@ -0,0 +1,35 @@
+[
+	{
+		"attributes": {
+			"code-block": true
+		},
+		"insert": "\n"
+	},
+	{
+		"insert": "some code"
+	},
+	{
+		"attributes": {
+			"code-block": true
+		},
+		"insert": "\n"
+	},
+	{
+		"insert": "  and more"
+	},
+	{
+		"attributes": {
+			"code-block": true
+		},
+		"insert": "\n"
+	},
+	{
+		"insert": "plain text\nmore code"
+	},
+	{
+		"attributes": {
+			"code-block": true
+		},
+		"insert": "\n"
+	}
+]