mirror of
https://github.com/miniflux/v2.git
synced 2025-06-27 16:36:00 +00:00
86c58e11f6
There is no need to use SHA256 everywhere, especially on small inputs where we
don't care about its cryptographic properties. We're using FNV as it's the
faster available hash in go's standard library, and we're picking its "a"
version as it's slightly better avalanche characteristics, which are
relevant for small inputs.
This commit has the side-effect of invalidating all favicons saved in the
database, which is desirable to benefit from the resize process implemented in
777d0dd2, as it didn't apply retro-actively.
We're also making use of hex.EncodeToString instead of fmt.Sprintf, as it's
marginally faster.
Note that we can't change the usage of sha256 for feed.Hash as it's used to
deduplicate entries in the database.
115 lines
2.8 KiB
Go
115 lines
2.8 KiB
Go
// SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
|
|
package rdf // import "miniflux.app/v2/internal/reader/rdf"
|
|
|
|
import (
|
|
"html"
|
|
"log/slog"
|
|
"strings"
|
|
"time"
|
|
|
|
"miniflux.app/v2/internal/crypto"
|
|
"miniflux.app/v2/internal/model"
|
|
"miniflux.app/v2/internal/reader/date"
|
|
"miniflux.app/v2/internal/reader/sanitizer"
|
|
"miniflux.app/v2/internal/urllib"
|
|
)
|
|
|
|
type RDFAdapter struct {
|
|
rdf *RDF
|
|
}
|
|
|
|
func NewRDFAdapter(rdf *RDF) *RDFAdapter {
|
|
return &RDFAdapter{rdf}
|
|
}
|
|
|
|
func (r *RDFAdapter) BuildFeed(baseURL string) *model.Feed {
|
|
feed := &model.Feed{
|
|
Title: stripTags(r.rdf.Channel.Title),
|
|
FeedURL: strings.TrimSpace(baseURL),
|
|
SiteURL: strings.TrimSpace(r.rdf.Channel.Link),
|
|
Description: strings.TrimSpace(r.rdf.Channel.Description),
|
|
}
|
|
|
|
if feed.Title == "" {
|
|
feed.Title = baseURL
|
|
}
|
|
|
|
if siteURL, err := urllib.AbsoluteURL(feed.FeedURL, feed.SiteURL); err == nil {
|
|
feed.SiteURL = siteURL
|
|
}
|
|
|
|
for _, item := range r.rdf.Items {
|
|
entry := model.NewEntry()
|
|
itemLink := strings.TrimSpace(item.Link)
|
|
|
|
// Populate the entry URL.
|
|
if itemLink == "" {
|
|
entry.URL = feed.SiteURL // Fallback to the feed URL if the entry URL is empty.
|
|
} else if entryURL, err := urllib.AbsoluteURL(feed.SiteURL, itemLink); err == nil {
|
|
entry.URL = entryURL
|
|
} else {
|
|
entry.URL = itemLink
|
|
}
|
|
|
|
// Populate the entry title.
|
|
for _, title := range []string{item.Title, item.DublinCoreTitle} {
|
|
title = strings.TrimSpace(title)
|
|
if title != "" {
|
|
entry.Title = html.UnescapeString(title)
|
|
break
|
|
}
|
|
}
|
|
|
|
// If the entry title is empty, we use the entry URL as a fallback.
|
|
if entry.Title == "" {
|
|
entry.Title = entry.URL
|
|
}
|
|
|
|
// Populate the entry content.
|
|
if item.DublinCoreContent != "" {
|
|
entry.Content = item.DublinCoreContent
|
|
} else {
|
|
entry.Content = item.Description
|
|
}
|
|
|
|
// Generate the entry hash.
|
|
hashValue := itemLink
|
|
if hashValue == "" {
|
|
hashValue = item.Title + item.Description // Fallback to the title and description if the link is empty.
|
|
}
|
|
|
|
entry.Hash = crypto.SHA256(hashValue)
|
|
|
|
// Populate the entry date.
|
|
entry.Date = time.Now()
|
|
if item.DublinCoreDate != "" {
|
|
if itemDate, err := date.Parse(item.DublinCoreDate); err != nil {
|
|
slog.Debug("Unable to parse date from RDF feed",
|
|
slog.String("date", item.DublinCoreDate),
|
|
slog.String("link", itemLink),
|
|
slog.Any("error", err),
|
|
)
|
|
} else {
|
|
entry.Date = itemDate
|
|
}
|
|
}
|
|
|
|
// Populate the entry author.
|
|
switch {
|
|
case item.DublinCoreCreator != "":
|
|
entry.Author = stripTags(item.DublinCoreCreator)
|
|
case r.rdf.Channel.DublinCoreCreator != "":
|
|
entry.Author = stripTags(r.rdf.Channel.DublinCoreCreator)
|
|
}
|
|
|
|
feed.Entries = append(feed.Entries, entry)
|
|
}
|
|
|
|
return feed
|
|
}
|
|
|
|
func stripTags(value string) string {
|
|
return strings.TrimSpace(sanitizer.StripTags(value))
|
|
}
|