Initial commit

main.go

@@ -0,0 +1,203 @@
+// Copyright 2024 Ismo Vuorinen. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+// SPDX-License-Identifier: MIT
+//
+// Paperboy is a simple RSS feed reader that generates
+// a Markdown file with the latest articles from multiple feeds.
+
+//go:build go1.16
+// +build go1.16
+
+package main
+
+import (
+	"cmp"
+	"fmt"
+	"log"
+	"net/url"
+	"os"
+	"regexp"
+	"slices"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/mmcdole/gofeed"
+	"gopkg.in/yaml.v2"
+)
+
+// Version and Build information
+// These variables are set during build time
+var (
+	version string = "dev"
+	build   string = time.Now().Format("20060102")
+)
+
+// Config represents the structure of the YAML configuration file
+type Config struct {
+	Template string   `yaml:"template"`
+	Output   string   `yaml:"output"`
+	Feeds    []string `yaml:"feeds"`
+}
+
+// Article represents a feed article
+type Article struct {
+	PublishAt time.Time
+	Title     string
+	URL       string
+	URLDomain string
+}
+
+func main() {
+	log.Printf("Paperboy v.%s (build %s)", version, build)
+
+	// Read YAML configuration file
+	configFile := "config.yaml"
+	configData, err := os.ReadFile(configFile)
+	if err != nil {
+		log.Fatalf("Error reading config.yaml file: %v", err)
+	}
+
+	// Parse YAML configuration
+	var config Config
+	err = yaml.Unmarshal(configData, &config)
+	if err != nil {
+		log.Fatalf("Error parsing config.yaml file: %v", err)
+	}
+
+	log.Printf("Feeds: %d", len(config.Feeds))
+
+	// Fetch articles from each feed URL
+	articlesByWeek := make(map[string][]Article)
+	var weeks []string
+
+	for _, feedURL := range config.Feeds {
+
+		log.Printf("Fetching articles from %s", feedURL)
+
+		articles, err := fetchArticles(feedURL)
+		if err != nil {
+			log.Printf("Error fetching articles from %s: %v", feedURL, err)
+			continue
+		}
+
+		log.Printf("-> Got %d articles", len(articles))
+
+		// Group articles by publish week
+		for _, article := range articles {
+			year, week := article.PublishAt.UTC().ISOWeek()
+			// Format week in the format "YYYY-WW"
+			// e.g. 2021-01
+			id := fmt.Sprintf("%d-%02d", year, week)
+			articlesByWeek[id] = append(articlesByWeek[id], article)
+
+			if !slices.Contains(weeks, id) {
+				weeks = append(weeks, id)
+			}
+		}
+	}
+
+	// Sort weeks
+	sort.Strings(weeks)
+	slices.Reverse(weeks)
+
+	// Generate Markdown output
+	output := generateMarkdown(config.Template, articlesByWeek, weeks)
+
+	// Write Markdown output to file
+	outputFile := config.Output
+	err = os.WriteFile(outputFile, []byte(output), 0644)
+	if err != nil {
+		log.Fatalf("Error writing output file: %v", err)
+	}
+}
+
+// fetchArticles fetches articles from a given feed URL
+func fetchArticles(feedURL string) ([]Article, error) {
+	fp := gofeed.NewParser()
+	feed, err := fp.ParseURL(feedURL)
+	if err != nil {
+		return nil, fmt.Errorf("error fetching feed: %v", err)
+	}
+
+	var articles []Article
+	for _, item := range feed.Items {
+		// Parse publish date
+		publishAt := item.PublishedParsed.UTC()
+		articleDomain := getURLDomain(item.Link)
+
+		articles = append(articles, Article{
+			Title:     item.Title,
+			URL:       item.Link,
+			PublishAt: publishAt,
+			URLDomain: articleDomain,
+		})
+	}
+
+	return articles, nil
+}
+
+// generateMarkdown generates Markdown output with header and footer
+func generateMarkdown(templateFile string, articlesByWeek map[string][]Article, weeks []string) string {
+	// Read template file
+	templateData, err := os.ReadFile(templateFile)
+	if err != nil {
+		log.Fatalf("Error reading template file: %v", err)
+	}
+
+	// Split template into header and footer sections
+	templateParts := strings.SplitN(string(templateData), "---", 3)
+	if len(templateParts) != 3 {
+		log.Fatalf("Invalid template format")
+	}
+
+	header := strings.TrimSpace(templateParts[0])
+	footer := strings.TrimSpace(templateParts[2])
+
+	// Generate Markdown output
+	var output strings.Builder
+	output.WriteString(header)
+	output.WriteString("\n\n")
+
+	for _, week := range weeks {
+		articles := articlesByWeek[week]
+		if len(articles) == 0 {
+			continue
+		}
+
+		// Sort articles by publish date
+		slices.SortFunc(articles, func(a, b Article) int {
+			return cmp.Compare(a.PublishAt.Unix(), b.PublishAt.Unix())
+		})
+
+		output.WriteString(fmt.Sprintf("## Week: %s\n\n", week))
+		for _, article := range articles {
+			output.WriteString(fmt.Sprintf("- %s @ %s: [%s](%s)\n", article.PublishAt.Format("2006-01-02"), article.URLDomain, article.Title, article.URL))
+		}
+		output.WriteString("\n")
+
+	}
+
+	output.WriteString(footer)
+	output.WriteString("\n")
+
+	return output.String()
+}
+
+// getURLDomain extracts the domain from a URL-like string
+// e.g. "https://example.com" -> "example.com"
+func getURLDomain(urlString string) string {
+	urlString = strings.TrimSpace(urlString)
+
+	if regexp.MustCompile(`^https?`).MatchString(urlString) {
+		read, _ := url.Parse(urlString)
+		urlString = read.Host
+	}
+
+	if regexp.MustCompile(`^www\.`).MatchString(urlString) {
+		urlString = regexp.MustCompile(`^www\.`).ReplaceAllString(urlString, "")
+	}
+
+	return regexp.MustCompile(`([a-z0-9\-]+\.)+[a-z0-9\-]+`).FindString(urlString)
+}