init template

render/reference.go

@@ -0,0 +1,78 @@
+package render
+
+import "gitoa.ru/go-4devs/mime"
+
+type Option func(*Reference)
+
+func WithParam(name string, val interface{}) Option {
+	return func(r *Reference) {
+		r.Params[name] = val
+	}
+}
+
+func WithEngine(name string) Option {
+	return func(r *Reference) {
+		r.Engine = name
+	}
+}
+
+func WithFormat(ext mime.Ext) Option {
+	return func(r *Reference) {
+		r.Format = ext
+	}
+}
+
+func NewReference(name string, opts ...Option) Reference {
+	ref := Reference{
+		name: name,
+	}
+
+	for _, opt := range opts {
+		opt(&ref)
+	}
+
+	return ref
+}
+
+type Reference struct {
+	name   string
+	Engine string
+	Format mime.Ext
+	Params Params
+}
+
+func (r Reference) Name() string {
+	if !r.Format.Is(mime.ExtUnrecognized) {
+		return r.name + "." + r.Format.String()
+	}
+
+	return r.name
+}
+
+func (r Reference) String() string {
+	if r.Engine != "" {
+		return r.name + "." + r.Format.String() + "." + r.Engine
+	}
+
+	return r.name + "." + r.Format.String()
+}
+
+func (r Reference) IsEngine(engines ...string) bool {
+	for _, engine := range engines {
+		if engine == r.Engine {
+			return true
+		}
+	}
+
+	return false
+}
+
+func (r Reference) IsFromat(formats ...mime.Ext) bool {
+	return r.Format.Is(formats...)
+}
+
+type Params map[string]interface{}
+
+func (p Params) Get(name string) interface{} {
+	return p[name]
+}

render/render.go

@@ -0,0 +1,77 @@
+package render
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+)
+
+var ErrNotFound = errors.New("not found")
+
+func New(parser Parser, engines ...Engine) *Render {
+	return &Render{
+		parser:  parser,
+		engines: engines,
+	}
+}
+
+type Render struct {
+	engines []Engine
+	parser  Parser
+}
+
+type Execute func(ctx context.Context, wr io.Writer, data interface{}, params Params) error
+
+type Engine interface {
+	Support(context.Context, Reference) bool
+	Load(ctx context.Context, reference Reference) (Execute, error)
+}
+
+type Parser func(ctx context.Context, name string, opts ...Option) (Reference, error)
+
+// Add add engine. This function is not thread-safe.
+func (e *Render) Add(engine ...Engine) {
+	e.engines = append(e.engines, engine...)
+}
+
+func (e *Render) WithParser(parser Parser) *Render {
+	return New(parser, e.engines...)
+}
+
+func (e *Render) Load(ctx context.Context, reference Reference) (Execute, error) {
+	for _, engine := range e.engines {
+		if engine.Support(ctx, reference) {
+			exec, err := engine.Load(ctx, reference)
+			if err != nil {
+				return nil, fmt.Errorf("render load:%w", err)
+			}
+
+			return exec, nil
+		}
+	}
+
+	return nil, fmt.Errorf("loader:%w", ErrNotFound)
+}
+
+func (e *Render) Parse(ctx context.Context, name string, opts ...Option) (Reference, error) {
+	return e.parser(ctx, name, opts...)
+}
+
+func (e *Render) Execute(ctx context.Context, wr io.Writer, name string, data interface{}, opts ...Option) error {
+	reference, rerr := e.parser(ctx, name, opts...)
+	if rerr != nil {
+		return fmt.Errorf("parse: %w", rerr)
+	}
+
+	execute, err := e.Load(ctx, reference)
+	if err != nil {
+		return fmt.Errorf("engine load:%w", err)
+	}
+
+	if err := execute(ctx, wr, data, reference.Params); err != nil {
+		return fmt.Errorf("render execute:%w", err)
+	}
+
+	return nil
+}