summaryrefslogtreecommitdiff
path: root/internal/yaml/yaml.go
blob: 9dc2615841f7b52642c7ee8d962555b829ad06a5 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
package yaml

import (
	"fmt"
	"io/ioutil"

	"gopkg.in/yaml.v3"

	C "github.com/Necoro/feed2imap-go/internal/config"
	F "github.com/Necoro/feed2imap-go/internal/feed"
)

type config struct {
	C.GlobalOptions `yaml:",inline"`
	GlobalConfig    C.Map `yaml:",inline"`
	Feeds           []configGroupFeed
}

type group struct {
	Group string
	Feeds []configGroupFeed
}

type feed struct {
	Name      string
	Url       string
	C.Options `yaml:",inline"`
}

type configGroupFeed struct {
	Target *string
	Feed   feed  `yaml:",inline"`
	Group  group `yaml:",inline"`
}

func (grpFeed *configGroupFeed) isGroup() bool {
	return grpFeed.Group.Group != ""
}

func (grpFeed *configGroupFeed) isFeed() bool {
	return grpFeed.Feed.Name != "" || grpFeed.Feed.Url != ""
}

func (grpFeed *configGroupFeed) target() string {
	if grpFeed.Target != nil {
		return *grpFeed.Target
	}
	if grpFeed.Feed.Name != "" {
		return grpFeed.Feed.Name
	}

	return grpFeed.Group.Group
}

func parse(buf []byte) (config, error) {
	parsedCfg := config{GlobalOptions: C.DefaultGlobalOptions}

	if err := yaml.Unmarshal(buf, &parsedCfg); err != nil {
		return config{}, fmt.Errorf("while unmarshalling: %w", err)
	}
	//fmt.Printf("--- parsedCfg:\n%+v\n\n", parsedCfg)

	return parsedCfg, nil
}

func appTarget(target []string, app string) []string {
	switch {
	case len(target) == 0 && app == "":
		return []string{}
	case len(target) == 0:
		return []string{app}
	case app == "":
		return target
	default:
		return append(target, app)
	}
}

// Parse the group structure and populate the `Target` fields in the feeds
func buildFeeds(cfg []configGroupFeed, target []string, feeds F.Feeds) error {
	for idx := range cfg {
		f := &cfg[idx] // cannot use `_, f := range cfg` as it returns copies(!), but we need the originals
		target := appTarget(target, f.target())
		switch {
		case f.isFeed() && f.isGroup():
			return fmt.Errorf("Entry with Target %s is both a Feed and a group", target)

		case f.isFeed():
			name := f.Feed.Name
			if name == "" {
				return fmt.Errorf("Unnamed feed")
			}

			if _, ok := feeds[name]; ok {
				return fmt.Errorf("Duplicate Feed Name '%s'", name)
			}
			feeds[name] = &F.Feed{
				Name:    f.Feed.Name,
				Target:  target,
				Url:     f.Feed.Url,
				Options: f.Feed.Options,
			}

		case f.isGroup():
			if err := buildFeeds(f.Group.Feeds, target, feeds); err != nil {
				return err
			}
		}
	}

	return nil
}

func Load(path string) (*C.Config, F.Feeds, error) {
	buf, err := ioutil.ReadFile(path)
	if err != nil {
		return nil, nil, fmt.Errorf("while reading '%s': %w", path, err)
	}

	var parsedCfg config
	if parsedCfg, err = parse(buf); err != nil {
		return nil, nil, err
	}

	feeds := F.Feeds{}

	if err := buildFeeds(parsedCfg.Feeds, []string{}, feeds); err != nil {
		return nil, nil, fmt.Errorf("while parsing: %w", err)
	}

	return &C.Config{
		GlobalOptions: parsedCfg.GlobalOptions,
		GlobalConfig:  parsedCfg.GlobalConfig,
	}, feeds, nil
}