Improved documentation, added strike and background formats

Author: dchenk

.travis.yml

@@ -0,0 +1,4 @@
+language: go
+
+go:
+  - 1.9

README.md

@@ -2,3 +2,49 @@
 
 Package `quill` takes a Quill-based Delta (https://github.com/quilljs/delta) as a JSON array of `insert` operations
 and renders the defined HTML document.
+
+Complete documentation at GoDoc: [https://godoc.org/github.com/dchenk/go-render-quill](https://godoc.org/github.com/dchenk/go-render-quill)
+
+## Usage
+
+```
+import "github.com/dchenk/go-render-quill"
+
+var delta = `[{"insert":"This "},{"attributes":{"italic":true},"insert":"is"},
+    {"insert":" "},{"attributes":{"bold":true},"insert":"great!"},{"insert":"\n"}]`
+
+html, err := quill.Render(delta)
+if err != nil {
+	panic(err)
+}
+fmt.Println(string(html))
+// Output: <p>This <em>is</em> <strong>great!</strong></p>
+```
+
+## Supported Formats
+
+### Inline
+ - Background color
+ - Bold
+ - Text color
+ - Italic
+ - Link
+ - Strikethrough
+ - Underline
+
+### Block
+ - Blockquote
+ - Header
+ - Indent
+ - List (ul and ol, including nested lists)
+ - Text alignment
+
+### Embeds
+ - Image (an inline format)
+
+## Extending
+
+The simple `Formatter` interface is all you need to implement for most block and inline formats. Instead of `Render` use `RenderExtended`
+and provide a function that returns a `Formatter` for inserts that have the format you need.
+
+For more control, you can also implement `FormatWriter` or `FormatWrapper`.

inline_formats.go

@@ -109,3 +109,33 @@ func (imf *imageFormat) Write(buf io.Writer) {
 	buf.Write([]byte{'>'})
 
 }
+
+// strikethrough
+type strikeFormat struct{}
+
+func (*strikeFormat) Fmt() *Format {
+	return &Format{
+		Val:   "s",
+		Place: Tag,
+	}
+}
+
+func (*strikeFormat) HasFormat(o *Op) bool {
+	return o.HasAttr("strike")
+}
+
+// background
+type bkgFormat struct {
+	c string
+}
+
+func (bf *bkgFormat) Fmt() *Format {
+	return &Format{
+		Val:   "background-color:" + bf.c + ";",
+		Place: Style,
+	}
+}
+
+func (*bkgFormat) HasFormat(o *Op) bool {
+	return o.HasAttr("background")
+}

render.go

@@ -1,4 +1,4 @@
-// Package `quill` takes a Quill-based Delta (https://github.com/quilljs/delta) as a JSON array of `insert` operations
+// Package quill takes a Quill-based Delta (https://github.com/quilljs/delta) as a JSON array of `insert` operations
 // and renders the defined HTML document.
 //
 // This library is designed to be easily extendable. Simply call RenderExtended with a function that may provide its
@@ -354,6 +354,12 @@ func (o *Op) getFormatter(keyword string, customFormats func(string, *Op) Format
 		return &indentFormat{
 			in: o.Attrs["indent"],
 		}
+	case "strike":
+		return new(strikeFormat)
+	case "background":
+		return &bkgFormat{
+			c: o.Attrs["background"],
+		}
 	}
 
 	return nil
@@ -375,7 +381,7 @@ type Formatter interface {
 	HasFormat(*Op) bool // Say if the Op has the Format that Fmt returns.
 }
 
-// A Formatter may also be a FormatWriter if it wishes to write the body of the Op in some custom way (useful for embeds).
+// A FormatWriter can write the body of an Op in a custom way (useful for embeds).
 type FormatWriter interface {
 	Formatter
 	Write(io.Writer) // Write the entire body of the element.

render_test.go

@@ -10,14 +10,17 @@ import (
 func TestSimple(t *testing.T) {
 
 	cases := []string{
-		`[{"insert": "\n"}]`,
-		`[{"insert": "line1\nline2\n"}]`,
-		`[{"insert": "line1\n\nline3\n"}]`,
-		`[{"insert": "bkqt"}, {"attributes": {"blockquote": true}, "insert": "\n"}]`,
-		`[{"attributes": {"color": "#a10000"}, "insert": "colored"}, {"insert": "\n"}]`,
-		`[{"insert":"abc "},{"attributes":{"bold":true},"insert":"bld"},{"attributes":{"list":"bullet"},"insert":"\n"}]`,
-		`[{"insert":{"image":"source-url"}},{"insert":"\n"}]`,
-		`[{"insert":"text "},{"insert":{"image":"source-url"}},{"insert":" more text\n"}]`,
+		`[{"insert": "\n"}]`,                                                                                             // blank
+		`[{"insert": "line1\nline2\n"}]`,                                                                                 // two paragraphs (single op)
+		`[{"insert": "line1\n\nline3\n"}]`,                                                                               // blank line
+		`[{"insert": "bkqt"}, {"attributes": {"blockquote": true}, "insert": "\n"}]`,                                     // blockquote
+		`[{"attributes": {"color": "#a10000"}, "insert": "colored"}, {"insert": "\n"}]`,                                  // color
+		`[{"attributes":{"strike":true},"insert":"striked"},{"insert":"\n"}]`,                                            // strikethrough
+		`[{"insert":"abc "},{"attributes":{"bold":true},"insert":"bld"},{"attributes":{"list":"bullet"},"insert":"\n"}]`, // list
+		`[{"insert":{"image":"source-url"}},{"insert":"\n"}]`,                                                            // image
+		`[{"insert":"text "},{"insert":{"image":"source-url"}},{"insert":" more text\n"}]`,                               // image
+		`[{"insert":"abc "},{"attributes":{"background":"#66a3e0"},"insert":"colored"},{"insert":" plain\n"}]`,           // background
+		`[{"attributes":{"underline":true},"insert":"underlined"},{"insert":"\n"}]`,                                      // underlined
 	}
 
 	want := []string{
@@ -26,9 +29,12 @@ func TestSimple(t *testing.T) {
 		"<p>line1</p><p><br></p><p>line3</p>",
 		"<blockquote>bkqt</blockquote>",
 		`<p><span style="color:#a10000;">colored</span></p>`,
+		"<p><s>striked</s></p>",
 		"<ul><li>abc <strong>bld</strong></li></ul>",
 		`<p><img src="source-url"></p>`,
 		`<p>text <img src="source-url"> more text</p>`,
+		`<p>abc <span style="background-color:#66a3e0;">colored</span> plain</p>`,
+		"<p><u>underlined</u></p>",
 	}
 
 	for i := range cases {
@@ -61,18 +67,18 @@ func TestRender(t *testing.T) {
 func testPair(opsFile, htmlFile string) error {
 	ops, err := ioutil.ReadFile("./tests/" + opsFile)
 	if err != nil {
-		return fmt.Errorf("could not read %s; %s\n", opsFile, err)
+		return fmt.Errorf("could not read %s; %s", opsFile, err)
 	}
 	html, err := ioutil.ReadFile("./tests/" + htmlFile)
 	if err != nil {
-		return fmt.Errorf("could not read %s; %s\n", htmlFile, err)
+		return fmt.Errorf("could not read %s; %s", htmlFile, err)
 	}
 	got, err := Render(ops)
 	if err != nil {
-		return fmt.Errorf("error rendering; %s\n", err)
+		return fmt.Errorf("error rendering; %s", err)
 	}
 	if !bytes.Equal(html, got) {
-		return fmt.Errorf("bad rendering; \nwanted: \n%s\ngot: \n%s\n", html, got)
+		return fmt.Errorf("bad rendering; \nwanted: \n%s\ngot: \n%s", html, got)
 	}
 	return nil
 }