my-log/formatters/plain.go

package formatters

import (
	"bytes"

	"codeberg.org/danjones000/my-log/config"
	"codeberg.org/danjones000/my-log/models"
	"codeberg.org/danjones000/my-log/tools"
)

func newPlain(ff config.Formatters) (Formatter, error) {
	return &PlainText{}, nil
}

type PlainText struct {
	// config might go here some day
}

func (pt *PlainText) Name() string {
	return "plain"
}

func (pt *PlainText) Logs(logs []models.Log) (out []byte, err error) {
	if len(logs) == 0 {
		return
	}

	buff := &bytes.Buffer{}
	first := true
	for _, log := range logs {
		o, _ := pt.Log(log)
		if !first {
			buff.WriteByte(10)
			buff.WriteByte(10)
		}
		first = false
		buff.Write(o)
	}
	out = buff.Bytes()
	return
}

func (pt *PlainText) Log(log models.Log) (out []byte, err error) {
	if len(log.Entries) == 0 {
		return
	}

	buff := &bytes.Buffer{}
	buff.WriteString(log.Name)
	buff.WriteString("\n#######")
	written := false
	for _, e := range log.Entries {
		bb := pt.entryBuffer(e)
		if bb.Len() > 0 {
			buff.WriteByte(10)
			buff.WriteByte(10)
			buff.ReadFrom(bb)
			written = true
		}
	}
	if written {
		out = buff.Bytes()
	}
	return
}

func (pt *PlainText) entryBuffer(entry models.Entry) *bytes.Buffer {
	buff := &bytes.Buffer{}
	buff.WriteString("Title: ")
	buff.WriteString(entry.Title)
	buff.WriteByte(10)
	buff.WriteString("Date: ")
	buff.WriteString(entry.Date.Format(tools.DateFormat))
	for _, m := range entry.Fields {
		bb, err := pt.metaBuffer(m)
		if (bb.Len() > 0) && (err == nil) {
			buff.WriteByte(10)
			buff.ReadFrom(bb)
		}
	}

	return buff
}

func (pt *PlainText) Entry(entry models.Entry) ([]byte, error) {
	buff := pt.entryBuffer(entry)
	return buff.Bytes(), nil
}

func (pt *PlainText) metaBuffer(meta models.Meta) (*bytes.Buffer, error) {
	buff := &bytes.Buffer{}
	buff.WriteString(meta.Key)
	buff.WriteString(": ")
	n, err := tools.WriteValue(buff, meta.Value)
	if n == 0 || err != nil {
		return &bytes.Buffer{}, err
	}
	return buff, nil
}

func (pt *PlainText) Meta(meta models.Meta) (out []byte, err error) {
	buff, err := pt.metaBuffer(meta)
	if err != nil {
		return
	}
	out = buff.Bytes()
	return
}