108 lines
2.1 KiB
Go
108 lines
2.1 KiB
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
|
|
}
|