Refactor public API

Author: lafriks

avatars.go

@@ -3,19 +3,30 @@ package avatars
 import (
 	"bytes"
 	"html"
+	"image"
 	"image/png"
 
 	"github.com/lafriks/go-avatars/bottts"
+	"github.com/lafriks/go-avatars/rnd"
 
 	"github.com/fogleman/gg"
 	"github.com/lafriks/go-svg"
 	"github.com/lafriks/go-svg/renderer"
 	rendr_gg "github.com/lafriks/go-svg/renderer/gg"
 )
 
-// SVG generates an SVG avatar using the given name as seed.
-func SVG(name string, opts ...Option) ([]byte, error) {
-	attrs, body := bottts.Generate(name)
+// Avatar that was generated using specified seed.
+type Avatar struct {
+	r    *rnd.Random
+	name string
+	svg  []byte
+}
+
+// Generate an avatar using the given name as seed.
+func Generate(name string, opts ...Option) (*Avatar, error) {
+	r := rnd.NewRandom(name)
+
+	attrs, body := bottts.Generate(r)
 
 	res := bytes.Buffer{}
 	res.WriteString("<svg")
@@ -29,23 +40,32 @@ func SVG(name string, opts ...Option) ([]byte, error) {
 	res.WriteString(">\n")
 	res.WriteString(body)
 	res.WriteString("\n</svg>")
-	return res.Bytes(), nil
+	return &Avatar{
+		name: name,
+		r:    r,
+		svg:  res.Bytes(),
+	}, nil
 }
 
-// PNG generates an PNG avatar using the given name as seed.
-func PNG(name string, opts ...Option) ([]byte, error) {
-	avatar, err := SVG(name, opts...)
-	if err != nil {
-		return nil, err
-	}
+// Name of the avatar.
+func (a *Avatar) Name() string {
+	return a.name
+}
 
-	opt := options(opts...)
+// SVG content of the avatar.
+func (a *Avatar) SVG() []byte {
+	return a.svg
+}
 
-	s, err := svg.Parse(bytes.NewReader(avatar), svg.IgnoreErrorMode)
+// Image rendered from the SVG.
+func (a *Avatar) Image(opts ...RenderOption) (image.Image, error) {
+	s, err := svg.Parse(bytes.NewReader(a.svg), svg.IgnoreErrorMode)
 	if err != nil {
 		return nil, err
 	}
 
+	opt := renderOptions(opts...)
+
 	gc := gg.NewContext(opt.Size, opt.Size)
 	rendr_gg.Draw(gc, s, renderer.Target(
 		float64(opt.Padding),
@@ -54,8 +74,18 @@ func PNG(name string, opts ...Option) ([]byte, error) {
 		float64(opt.Size-opt.Padding*2),
 	))
 
+	return gc.Image(), nil
+}
+
+// PNG encoded image.
+func (a *Avatar) PNG(opts ...RenderOption) ([]byte, error) {
+	img, err := a.Image(opts...)
+	if err != nil {
+		return nil, err
+	}
+
 	buf := bytes.NewBuffer(nil)
-	if err := png.Encode(buf, gc.Image()); err != nil {
+	if err := png.Encode(buf, img); err != nil {
 		return nil, err
 	}
 	return buf.Bytes(), nil

bottts/avatar.go

@@ -21,24 +21,22 @@ func group(r *rnd.Random, content string, chance, x, y int) string {
 }
 
 // Generate generates a bottts avatar.
-func Generate(seed string) (map[string]string, string) {
-	r := rnd.NewRandom(seed)
-
+func Generate(r *rnd.Random) (map[string]string, string) {
 	var texture string
 	if r.Chance(textureChance) {
 		texture = textures[r.Pick(textureNames)]
 	}
 
 	primaryColor, secondaryColor := r.PickColors(600, 400)
 
-	body := []string{
-		group(r, sides[r.Pick(sideNames)](secondaryColor), sidesChance, 0, 66),
-		group(r, tops[r.Pick(topNames)](secondaryColor), topChance, 41, 0),
-		group(r, face[r.Pick(faceNames)](primaryColor, texture), 100, 25, 44),
-		group(r, mouth[r.Pick(mouthNames)], 100, 52, 124),
-		group(r, eyes[r.Pick(eyeNames)], 100, 38, 76),
-	}
+	var buf strings.Builder
+	buf.WriteString(group(r, sides[r.Pick(sideNames)](secondaryColor), sidesChance, 0, 66))
+	buf.WriteString(group(r, tops[r.Pick(topNames)](secondaryColor), topChance, 41, 0))
+	buf.WriteString(group(r, face[r.Pick(faceNames)](primaryColor, texture), 100, 25, 44))
+	buf.WriteString(group(r, mouth[r.Pick(mouthNames)], 100, 52, 124))
+	buf.WriteString(group(r, eyes[r.Pick(eyeNames)], 100, 38, 76))
+
 	return map[string]string{
 		"viewBox": "0 0 180 180",
-	}, strings.Join(body, "")
+	}, buf.String()
 }

example/sample/main.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"bytes"
 	"image"
 	"image/draw"
 	"image/png"
@@ -16,12 +15,11 @@ func main() {
 	img := image.NewRGBA(image.Rect(0, 0, size*10, size*4))
 
 	for i := 0; i < 40; i++ {
-		seed := time.Now().Format(time.RFC3339Nano)
-		buf, err := avatars.PNG(seed, avatars.RenderSize(size))
+		a, err := avatars.Generate(time.Now().Format(time.RFC3339Nano))
 		if err != nil {
 			panic(err)
 		}
-		av, err := png.Decode(bytes.NewReader(buf))
+		av, err := a.Image(avatars.RenderSize(size))
 		if err != nil {
 			panic(err)
 		}

example/test/main.go

@@ -21,18 +21,18 @@ func main() {
 	}
 	seed := time.Now().Format(time.RFC3339Nano)
 
-	svg, err := avatars.SVG(seed)
+	a, err := avatars.Generate(seed)
 	if err != nil {
 		panic(err)
 	}
-	if err := ioutil.WriteFile("test.svg", svg, fs.FileMode(0644)); err != nil {
+	if err := ioutil.WriteFile("test.svg", a.SVG(), fs.FileMode(0644)); err != nil {
 		panic(err)
 	}
-	png, err := avatars.PNG(seed, avatars.RenderSize(size))
+	img, err := a.PNG(avatars.RenderSize(size))
 	if err != nil {
 		panic(err)
 	}
-	if err := ioutil.WriteFile("test.png", png, fs.FileMode(0644)); err != nil {
+	if err := ioutil.WriteFile("test.png", img, fs.FileMode(0644)); err != nil {
 		panic(err)
 	}
 }

options.go

@@ -2,33 +2,50 @@ package avatars
 
 // Options for the avatar service.
 type Options struct {
+}
+
+// Option is a function that applies an option to the avatar service.
+type Option interface {
+	apply(a *Options)
+}
+
+func options(opts ...Option) *Options {
+	opt := &Options{}
+	for _, o := range opts {
+		o.apply(opt)
+	}
+	return opt
+}
+
+// RenderOptions is a set of options for rendering an avatar.
+type RenderOptions struct {
 	// Size of the rendered avatar.
 	Size int
 	// Padding between the rendered avatar and the border.
 	Padding int
 }
 
-// Option is a function that applies an option to the avatar service.
-type Option interface {
-	apply(a *Options)
+// Render is a function that applies a render option to the avatar service.
+type RenderOption interface {
+	apply(a *RenderOptions)
 }
 
 // RenderSize sets the size of the rendered avatar in pixels.
 type RenderSize int
 
-func (s RenderSize) apply(a *Options) {
+func (s RenderSize) apply(a *RenderOptions) {
 	a.Size = int(s)
 }
 
-// Padding sets the padding between the rendered avatar and the border.
-type Padding int
+// RenderPadding sets the padding between the rendered avatar and the border.
+type RenderPadding int
 
-func (s Padding) apply(a *Options) {
+func (s RenderPadding) apply(a *RenderOptions) {
 	a.Padding = int(s)
 }
 
-func options(opts ...Option) *Options {
-	opt := &Options{
+func renderOptions(opts ...RenderOption) *RenderOptions {
+	opt := &RenderOptions{
 		Size: 256,
 	}
 	for _, o := range opts {