gopatterns/pkg/pattern/template/storage.go

package template

import (
	"fmt"
	"io/fs"
	"os"

	"git.wtrh.nl/patterns/gopatterns/pkg/pattern"
	"gopkg.in/yaml.v3"
)

type Storage struct {
	dir fs.FS
}

func NewStorage(dir string) (Storage, error) {
	_, err := os.Stat(dir)
	if err != nil {
		return Storage{}, err
	}

	return Storage{dir: os.DirFS(dir)}, nil
}

func (s Storage) Dimensions(sizes Sizes) (pattern.Dimensions, error) {
	f, err := s.dir.Open("dimension_names.yaml")
	if err != nil {
		return nil, fmt.Errorf("open \"dimension_names.yaml\": %w", err)
	}

	namedDimensions := pattern.Dimensions{}

	err = yaml.NewDecoder(f).Decode(&namedDimensions)
	if err != nil {
		return nil, fmt.Errorf("decode yaml from \"dimension_names.yaml\": %w", err)
	}

	for id, dimension := range namedDimensions {
		size, ok := sizes[string(id)]
		if !ok {
			delete(namedDimensions, id)
			continue
		}

		dimension.Value = size
		namedDimensions[id] = dimension
	}

	return namedDimensions, nil
}

// Request contains the information to draw a pattern for a specific owner, with corresponding
// sizes and the template name.
type Request struct {
	Sizes    Sizes  `yaml:"sizes,omitempty"`
	Owner    string `yaml:"owner"`
	Template string `yaml:"template,omitempty"`
}

// LoadTemplate reads and decodes a [Template] from a yaml file.
func (s Storage) LoadTemplate(name string) (Template, error) {
	fh, err := s.dir.Open(name + ".yaml")
	if err != nil {
		return Template{}, fmt.Errorf("open template file %q: %w", name, err)
	}

	template := Template{}

	err = yaml.NewDecoder(fh).Decode(&template)
	if err != nil {
		return Template{}, fmt.Errorf("decode content of file %q as yaml: %w", name, err)
	}

	return template, nil
}