Switch to functional options

README.md

@@ -36,8 +36,9 @@ import (
 	"github.com/charmbracelet/glamour/ansi"
 )
 
-r, _ := glamour.NewTermRenderer("dark", ansi.Options{
+r, _ := glamour.NewTermRenderer(
-    WordWrap: int(40),
+	glamour.WithStandardStyle("dark"),
+	glamour.WithWordWrap(40),
 })
 
 out, _ := r.Render(in)

examples/custom_renderer/main.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 
 	"github.com/charmbracelet/glamour"
-	"github.com/charmbracelet/glamour/ansi"
 )
 
 func main() {
@@ -17,9 +16,10 @@ line.
 Bye!
 `
 
-	r, _ := glamour.NewTermRenderer("dark", ansi.Options{
+	r, _ := glamour.NewTermRenderer(
-		WordWrap: int(40),
+		glamour.WithStandardStyle("dark"),
-	})
+		glamour.WithWordWrap(40),
+	)
 
 	out, _ := r.Render(in)
 	fmt.Print(out)

glamour.go

@@ -3,9 +3,8 @@ package glamour
 import (
 	"bytes"
 	"encoding/json"
-	"fmt"
-	"io"
 	"io/ioutil"
+	"net/http"
 	"os"
 
 	"github.com/rakyll/statik/fs"
@@ -19,12 +18,26 @@ import (
 	_ "github.com/charmbracelet/glamour/statik" // pre-generated styles
 )
 
+var statikFS http.FileSystem
+
+// A TermRendererOption sets an option on a TermRenderer.
+type TermRendererOption func(*TermRenderer) error
+
 // TermRenderer can be used to render markdown content, posing a depth of
 // customization and styles to fit your needs.
 type TermRenderer struct {
-	md        goldmark.Markdown
+	md          goldmark.Markdown
-	buf       bytes.Buffer
+	ansiOptions ansi.Options
-	renderBuf bytes.Buffer
+	buf         bytes.Buffer
+	renderBuf   bytes.Buffer
+}
+
+func init() {
+	var err error
+	statikFS, err = fs.New()
+	if err != nil {
+		panic(err)
+	}
 }
 
 // Render initializes a new TermRenderer and renders a markdown with a specific
@@ -37,55 +50,116 @@ func Render(in string, stylePath string) (string, error) {
 // RenderBytes initializes a new TermRenderer and renders a markdown with a
 // specific style.
 func RenderBytes(in []byte, stylePath string) ([]byte, error) {
-	r, err := NewTermRenderer(stylePath, ansi.Options{
+	r, err := NewTermRenderer(
-		WordWrap: 80,
+		WithStylePath(stylePath),
-	})
+	)
 	if err != nil {
 		return nil, err
 	}
 	return r.RenderBytes(in)
 }
 
-// NewTermRenderer returns a new TermRenderer with style and options set.
+// NewTermRenderer returns a new TermRenderer the given options.
-func NewTermRenderer(stylePath string, options ansi.Options) (*TermRenderer, error) {
+func NewTermRenderer(options ...TermRendererOption) (*TermRenderer, error) {
-	if stylePath == "" {
+	tr := &TermRenderer{
-		return NewTermRendererFromBytes([]byte("{}"), options)
+		md: goldmark.New(
-	}
+			goldmark.WithExtensions(
-
+				extension.GFM,
-	b, err := loadStyle(stylePath)
+				extension.DefinitionList,
-	if err != nil {
+			),
-		return nil, err
+			goldmark.WithParserOptions(
-	}
+				parser.WithAutoHeadingID(),
-	return NewTermRendererFromBytes(b, options)
+			),
-}
-
-// NewTermRendererFromBytes returns a new TermRenderer with style and options
-// set.
-func NewTermRendererFromBytes(b []byte, options ansi.Options) (*TermRenderer, error) {
-	err := json.Unmarshal(b, &options.Styles)
-	if err != nil {
-		// FIXME: wrap error once we depend on Go 1.13
-		return nil, fmt.Errorf("parsing style: %v", err)
-	}
-
-	md := goldmark.New(
-		goldmark.WithExtensions(
-			extension.GFM,
-			extension.DefinitionList,
 		),
-		goldmark.WithParserOptions(
+		ansiOptions: ansi.Options{
-			parser.WithAutoHeadingID(),
+			WordWrap: 80,
+		},
+	}
+	for _, o := range options {
+		if err := o(tr); err != nil {
+			return nil, err
+		}
+	}
+	ar := ansi.NewRenderer(tr.ansiOptions)
+	tr.md.SetRenderer(
+		renderer.NewRenderer(
+			renderer.WithNodeRenderers(
+				util.Prioritized(ar, 1000),
+			),
 		),
 	)
+	return tr, nil
+}
 
-	ar := ansi.NewRenderer(options)
+// WithBaseURL sets a TermRenderer's base URL.
-	md.SetRenderer(
+func WithBaseURL(baseURL string) TermRendererOption {
-		renderer.NewRenderer(
+	return func(tr *TermRenderer) error {
-			renderer.WithNodeRenderers(util.Prioritized(ar, 1000))))
+		tr.ansiOptions.BaseURL = baseURL
+		return nil
+	}
+}
 
-	return &TermRenderer{
+// WithStandardStyle sets a TermRenderer's styles with a standard (builtin)
-		md: md,
+// style.
-	}, nil
+func WithStandardStyle(style string) TermRendererOption {
+	return func(tr *TermRenderer) error {
+		jsonBytes, err := fs.ReadFile(statikFS, "/"+style+".json")
+		if err != nil {
+			return err
+		}
+		return json.Unmarshal(jsonBytes, &tr.ansiOptions.Styles)
+	}
+}
+
+// WithStylePath sets a TermRenderer's style from stylePath. stylePath is first
+// interpreted as a filename. If no such file exists, it is re-interpreted as a
+// standard style.
+func WithStylePath(stylePath string) TermRendererOption {
+	return func(tr *TermRenderer) error {
+		jsonBytes, err := ioutil.ReadFile(stylePath)
+		if os.IsNotExist(err) {
+			jsonBytes, err = fs.ReadFile(statikFS, "/"+stylePath+".json")
+		}
+		if err != nil {
+			return err
+		}
+		return json.Unmarshal(jsonBytes, &tr.ansiOptions.Styles)
+	}
+}
+
+// WithStyles sets a TermRenderer's styles.
+func WithStyles(styles ansi.StyleConfig) TermRendererOption {
+	return func(tr *TermRenderer) error {
+		tr.ansiOptions.Styles = styles
+		return nil
+	}
+}
+
+// WithStylesFromJSONBytes sets a TermRenderer's styles by parsing styles from
+// jsonBytes.
+func WithStylesFromJSONBytes(jsonBytes []byte) TermRendererOption {
+	return func(tr *TermRenderer) error {
+		return json.Unmarshal(jsonBytes, &tr.ansiOptions.Styles)
+	}
+}
+
+// WithStylesFromJSONFile sets a TermRenderer's styles from a JSON file.
+func WithStylesFromJSONFile(filename string) TermRendererOption {
+	return func(tr *TermRenderer) error {
+		jsonBytes, err := ioutil.ReadFile(filename)
+		if err != nil {
+			return err
+		}
+		return json.Unmarshal(jsonBytes, &tr.ansiOptions.Styles)
+	}
+}
+
+// WithWordWrap sets a TermRenderer's word wrap.
+func WithWordWrap(wordWrap int) TermRendererOption {
+	return func(tr *TermRenderer) error {
+		tr.ansiOptions.WordWrap = wordWrap
+		return nil
+	}
 }
 
 func (tr *TermRenderer) Read(b []byte) (int, error) {
@@ -120,24 +194,3 @@ func (tr *TermRenderer) RenderBytes(in []byte) ([]byte, error) {
 	err := tr.md.Convert(in, &buf)
 	return buf.Bytes(), err
 }
-
-func loadStyle(f string) ([]byte, error) {
-	var r io.ReadCloser
-
-	r, err := os.Open(f)
-	if err != nil {
-		statikFS, err := fs.New()
-		if err != nil {
-			return nil, err
-		}
-
-		r, err = statikFS.Open("/" + f + ".json")
-		if err != nil {
-			// FIXME: wrap error once we depend on Go 1.13
-			return nil, fmt.Errorf("loading style %s: %v", f, err)
-		}
-	}
-
-	defer r.Close()
-	return ioutil.ReadAll(r)
-}

glamour_test.go

@@ -4,8 +4,6 @@ import (
 	"bytes"
 	"io/ioutil"
 	"testing"
-
-	"github.com/charmbracelet/glamour/ansi"
 )
 
 const (
@@ -15,9 +13,9 @@ const (
 )
 
 func TestTermRendererWriter(t *testing.T) {
-	r, err := NewTermRenderer("styles/dark.json", ansi.Options{
+	r, err := NewTermRenderer(
-		WordWrap: 80,
+		WithStandardStyle("dark"),
-	})
+	)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -63,9 +61,9 @@ func TestTermRendererWriter(t *testing.T) {
 }
 
 func TestTermRenderer(t *testing.T) {
-	r, err := NewTermRenderer("styles/dark.json", ansi.Options{
+	r, err := NewTermRenderer(
-		WordWrap: 80,
+		WithStandardStyle("dark"),
-	})
+	)
 	if err != nil {
 		t.Fatal(err)
 	}