]*\btype\s*=\s*["']application/(rss|atom)\+xml["'][^>]*>`,
+ )
+ reLinkHref = regexp.MustCompile(`(?i)\bhref\s*=\s*["']([^"']+)["']`)
+ reLinkTitle = regexp.MustCompile(`(?i)\btitle\s*=\s*["']([^"']+)["']`)
+ reLinkType = regexp.MustCompile(`(?i)\btype\s*=\s*["']application/(rss|atom)\+xml["']`)
+
+ // Pattern 2: Markdown links [text](url)
+ reMarkdownLink = regexp.MustCompile(`\[([^\]]*)\]\((https?://[^)\s]+)\)`)
+
+ // Pattern 3: Bare URLs in text
+ reURL = regexp.MustCompile(`https?://[^\s<>"'\)\]]+`)
+)
+
+// Discover extracts feed URLs from the given text content.
+// The input can be HTML (complete or partial), Markdown, or plain text.
+// It uses regex-based detection (not HTML parsing) to handle all input types robustly.
+//
+// Detection is performed in priority order:
+// 1. HTML tags with RSS/Atom type attributes
+// 2. Markdown links [text](url) matching feed URL patterns
+// 3. Bare URLs matching common feed path/query patterns
+//
+// Results are deduplicated by URL and ordered by detection priority.
+func Discover(text string) []FeedLink {
+ if strings.TrimSpace(text) == "" {
+ return nil
+ }
+
+ seen := make(map[string]bool)
+ var results []FeedLink
+
+ // Priority 1: HTML tags
+ linkMatches := reLinkTag.FindAllString(text, -1)
+ for _, tag := range linkMatches {
+ href := extractAttr(reLinkHref, tag)
+ if href == "" {
+ continue
+ }
+ if seen[href] {
+ continue
+ }
+ seen[href] = true
+
+ fl := FeedLink{URL: href}
+ fl.Title = extractAttr(reLinkTitle, tag)
+
+ typeMatch := reLinkType.FindStringSubmatch(tag)
+ if len(typeMatch) > 1 {
+ fl.Type = strings.ToLower(typeMatch[1]) // "rss" or "atom"
+ }
+
+ results = append(results, fl)
+ }
+
+ // Priority 2: Markdown links with feed-like URLs
+ mdMatches := reMarkdownLink.FindAllStringSubmatch(text, -1)
+ for _, m := range mdMatches {
+ if len(m) < 3 {
+ continue
+ }
+ title, url := m[1], m[2]
+ if seen[url] {
+ continue
+ }
+ if !looksLikeFeedURL(url) {
+ continue
+ }
+ seen[url] = true
+ results = append(results, FeedLink{
+ URL: url,
+ Title: strings.TrimSpace(title),
+ Type: guessTypeFromURL(url),
+ })
+ }
+
+ // Priority 3: Bare URLs matching feed patterns
+ urlMatches := reURL.FindAllString(text, -1)
+ for _, url := range urlMatches {
+ // Clean trailing punctuation that may be part of surrounding text
+ url = strings.TrimRight(url, ".,;:!?")
+ if seen[url] {
+ continue
+ }
+ if !looksLikeFeedURL(url) {
+ continue
+ }
+ seen[url] = true
+ results = append(results, FeedLink{
+ URL: url,
+ Type: guessTypeFromURL(url),
+ })
+ }
+
+ return results
+}
+
+// looksLikeFeedURL checks whether a URL matches common feed path or query patterns.
+func looksLikeFeedURL(url string) bool {
+ lower := strings.ToLower(url)
+
+ for _, p := range feedPathPatterns {
+ if strings.Contains(lower, p) {
+ return true
+ }
+ }
+
+ for _, p := range feedQueryPatterns {
+ if strings.Contains(lower, p) {
+ return true
+ }
+ }
+
+ return false
+}
+
+// guessTypeFromURL attempts to determine the feed type from URL patterns.
+// Returns "rss", "atom", or empty string if undetermined.
+func guessTypeFromURL(url string) string {
+ lower := strings.ToLower(url)
+
+ if strings.Contains(lower, "atom") {
+ return "atom"
+ }
+ if strings.Contains(lower, "rss") {
+ return "rss"
+ }
+
+ // Generic feed paths — cannot determine type
+ return ""
+}
+
+// extractAttr extracts the first capture group from a regex match on the input string.
+func extractAttr(re *regexp.Regexp, input string) string {
+ m := re.FindStringSubmatch(input)
+ if len(m) > 1 {
+ return strings.TrimSpace(m[1])
+ }
+ return ""
+}
diff --git a/rss/discover_test.go b/rss/discover_test.go
new file mode 100644
index 00000000..1c4204c7
--- /dev/null
+++ b/rss/discover_test.go
@@ -0,0 +1,156 @@
+package rss
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+)
+
+func TestDiscover_HTMLLinkTags(t *testing.T) {
+ html := `
+
+ My Site
+
+
+
+
+Hello
+`
+
+ links := Discover(html)
+ require.Len(t, links, 2)
+
+ assert.Equal(t, "https://example.com/feed.xml", links[0].URL)
+ assert.Equal(t, "RSS Feed", links[0].Title)
+ assert.Equal(t, "rss", links[0].Type)
+
+ assert.Equal(t, "https://example.com/atom.xml", links[1].URL)
+ assert.Equal(t, "Atom Feed", links[1].Title)
+ assert.Equal(t, "atom", links[1].Type)
+}
+
+func TestDiscover_HTMLLinkTags_AttributeOrder(t *testing.T) {
+ // Attributes in different order, single quotes
+ html := ``
+ links := Discover(html)
+ require.Len(t, links, 1)
+ assert.Equal(t, "https://blog.example.com/rss", links[0].URL)
+ assert.Equal(t, "Blog", links[0].Title)
+ assert.Equal(t, "rss", links[0].Type)
+}
+
+func TestDiscover_MarkdownLinks(t *testing.T) {
+ md := `# My Bookmarks
+
+Here are some feeds:
+- [Tech News](https://news.example.com/rss.xml)
+- [Go Blog](https://go.dev/blog/feed.atom)
+- [Not a feed](https://example.com/about)
+`
+ links := Discover(md)
+ require.Len(t, links, 2)
+
+ assert.Equal(t, "https://news.example.com/rss.xml", links[0].URL)
+ assert.Equal(t, "Tech News", links[0].Title)
+ assert.Equal(t, "rss", links[0].Type)
+
+ assert.Equal(t, "https://go.dev/blog/feed.atom", links[1].URL)
+ assert.Equal(t, "Go Blog", links[1].Title)
+ assert.Equal(t, "atom", links[1].Type)
+}
+
+func TestDiscover_BareURLs(t *testing.T) {
+ text := `Check out these feeds:
+https://example.com/feed.xml
+https://blog.example.com/rss
+https://news.example.com/atom.xml
+https://example.com/about (not a feed)
+`
+ links := Discover(text)
+ require.Len(t, links, 3)
+
+ assert.Equal(t, "https://example.com/feed.xml", links[0].URL)
+ assert.Equal(t, "https://blog.example.com/rss", links[1].URL)
+ assert.Equal(t, "https://news.example.com/atom.xml", links[2].URL)
+}
+
+func TestDiscover_BareURLs_QueryParams(t *testing.T) {
+ text := `Feed URL: https://example.com/api?feed=rss&lang=en`
+ links := Discover(text)
+ require.Len(t, links, 1)
+ assert.Equal(t, "https://example.com/api?feed=rss&lang=en", links[0].URL)
+}
+
+func TestDiscover_Deduplication(t *testing.T) {
+ // Same URL appears in HTML link tag and as bare URL
+ text := `
+Check out: https://example.com/feed.xml`
+
+ links := Discover(text)
+ require.Len(t, links, 1) // deduplicated
+ assert.Equal(t, "https://example.com/feed.xml", links[0].URL)
+ assert.Equal(t, "Feed", links[0].Title) // from HTML tag (higher priority)
+}
+
+func TestDiscover_PartialHTML(t *testing.T) {
+ // Incomplete HTML fragment
+ fragment := `Some content
+
+More broken`
+
+ links := Discover(fragment)
+ require.Len(t, links, 1)
+ assert.Equal(t, "https://example.com/feed", links[0].URL)
+}
+
+func TestDiscover_Empty(t *testing.T) {
+ assert.Nil(t, Discover(""))
+ assert.Nil(t, Discover(" "))
+}
+
+func TestDiscover_NoFeeds(t *testing.T) {
+ links := Discover("Hello world! Visit https://example.com for more info.")
+ assert.Empty(t, links)
+}
+
+func TestDiscover_MixedContent(t *testing.T) {
+ // HTML link + Markdown link + bare URL, all different
+ mixed := `
+Some text with [B Feed](https://b.com/feed.xml) and also
+https://c.com/rss.xml is available.`
+
+ links := Discover(mixed)
+ require.Len(t, links, 3)
+ assert.Equal(t, "https://a.com/atom.xml", links[0].URL)
+ assert.Equal(t, "atom", links[0].Type)
+ assert.Equal(t, "https://b.com/feed.xml", links[1].URL)
+ assert.Equal(t, "https://c.com/rss.xml", links[2].URL)
+ assert.Equal(t, "rss", links[2].Type)
+}
+
+func TestDiscover_TrailingPunctuation(t *testing.T) {
+ text := `Check https://example.com/feed.xml.`
+ links := Discover(text)
+ require.Len(t, links, 1)
+ assert.Equal(t, "https://example.com/feed.xml", links[0].URL)
+}
+
+func TestLooksLikeFeedURL(t *testing.T) {
+ assert.True(t, looksLikeFeedURL("https://example.com/feed.xml"))
+ assert.True(t, looksLikeFeedURL("https://example.com/rss"))
+ assert.True(t, looksLikeFeedURL("https://example.com/atom.xml"))
+ assert.True(t, looksLikeFeedURL("https://example.com/index.xml"))
+ assert.True(t, looksLikeFeedURL("https://example.com/feed/"))
+ assert.True(t, looksLikeFeedURL("https://example.com/api?feed=rss"))
+ assert.True(t, looksLikeFeedURL("https://example.com/blog.rss"))
+ assert.False(t, looksLikeFeedURL("https://example.com/about"))
+ assert.False(t, looksLikeFeedURL("https://example.com/image.png"))
+}
+
+func TestGuessTypeFromURL(t *testing.T) {
+ assert.Equal(t, "rss", guessTypeFromURL("https://example.com/rss.xml"))
+ assert.Equal(t, "atom", guessTypeFromURL("https://example.com/atom.xml"))
+ assert.Equal(t, "", guessTypeFromURL("https://example.com/feed.xml"))
+ assert.Equal(t, "", guessTypeFromURL("https://example.com/index.xml"))
+}
diff --git a/rss/fetch.go b/rss/fetch.go
new file mode 100644
index 00000000..4aff047f
--- /dev/null
+++ b/rss/fetch.go
@@ -0,0 +1,108 @@
+package rss
+
+import (
+ "compress/gzip"
+ "fmt"
+ "io"
+ "net/http"
+ "time"
+)
+
+const (
+ defaultUserAgent = "Yao-Robot/1.0"
+ defaultTimeout = 30
+ acceptHeader = "application/rss+xml, application/atom+xml, application/xml, text/xml"
+)
+
+// Fetch retrieves a remote RSS/Atom feed by URL and parses it into a Feed.
+// Supports gzip decompression and conditional requests (ETag / Last-Modified)
+// for bandwidth-efficient polling.
+func Fetch(url string, opts *FetchOptions) (*FetchResult, error) {
+ if url == "" {
+ return nil, fmt.Errorf("url is required")
+ }
+ if opts == nil {
+ opts = &FetchOptions{}
+ }
+
+ userAgent := opts.UserAgent
+ if userAgent == "" {
+ userAgent = defaultUserAgent
+ }
+ timeout := opts.Timeout
+ if timeout <= 0 {
+ timeout = defaultTimeout
+ }
+
+ client := &http.Client{Timeout: time.Duration(timeout) * time.Second}
+
+ req, err := http.NewRequest("GET", url, nil)
+ if err != nil {
+ return nil, fmt.Errorf("failed to create request: %s", err.Error())
+ }
+
+ // Standard headers
+ req.Header.Set("User-Agent", userAgent)
+ req.Header.Set("Accept", acceptHeader)
+ req.Header.Set("Accept-Encoding", "gzip")
+
+ // Conditional request headers
+ if opts.ETag != "" {
+ req.Header.Set("If-None-Match", opts.ETag)
+ }
+ if opts.LastModified != "" {
+ req.Header.Set("If-Modified-Since", opts.LastModified)
+ }
+
+ resp, err := client.Do(req)
+ if err != nil {
+ return nil, fmt.Errorf("HTTP request failed: %s", err.Error())
+ }
+ defer resp.Body.Close()
+
+ result := &FetchResult{
+ StatusCode: resp.StatusCode,
+ ETag: resp.Header.Get("ETag"),
+ LastModified: resp.Header.Get("Last-Modified"),
+ }
+
+ // Handle 304 Not Modified
+ if resp.StatusCode == http.StatusNotModified {
+ result.NotModified = true
+ return result, nil
+ }
+
+ // Reject non-200 responses
+ if resp.StatusCode != http.StatusOK {
+ return nil, fmt.Errorf("HTTP %d for %s", resp.StatusCode, url)
+ }
+
+ // Handle gzip decompression.
+ // Because we manually set Accept-Encoding: "gzip" above, Go's default transport
+ // does NOT auto-decompress — the Content-Encoding header is preserved, and we
+ // must decompress ourselves. This is correct and intentional.
+ var reader io.Reader = resp.Body
+ if resp.Header.Get("Content-Encoding") == "gzip" {
+ gz, err := gzip.NewReader(resp.Body)
+ if err != nil {
+ return nil, fmt.Errorf("failed to create gzip reader: %s", err.Error())
+ }
+ defer gz.Close()
+ reader = gz
+ }
+
+ // Read body
+ body, err := io.ReadAll(reader)
+ if err != nil {
+ return nil, fmt.Errorf("failed to read response body: %s", err.Error())
+ }
+
+ // Parse feed using existing Parse function
+ feed, err := Parse(string(body))
+ if err != nil {
+ return nil, fmt.Errorf("failed to parse feed: %s", err.Error())
+ }
+
+ result.Feed = feed
+ return result, nil
+}
diff --git a/rss/fetch_test.go b/rss/fetch_test.go
new file mode 100644
index 00000000..d4422d70
--- /dev/null
+++ b/rss/fetch_test.go
@@ -0,0 +1,248 @@
+package rss
+
+import (
+ "compress/gzip"
+ "net/http"
+ "net/http/httptest"
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+)
+
+// testFeedXML is a minimal RSS feed for fetch testing.
+const testFeedXML = `
+
+
+ Test Feed
+ https://example.com
+ A test feed
+ -
+ Post 1
+ https://example.com/post1
+
+
+`
+
+func TestFetchBasic(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ w.Header().Set("Content-Type", "application/rss+xml")
+ w.Header().Set("ETag", `"abc123"`)
+ w.Header().Set("Last-Modified", "Wed, 01 Jan 2025 00:00:00 GMT")
+ w.WriteHeader(http.StatusOK)
+ w.Write([]byte(testFeedXML))
+ }))
+ defer server.Close()
+
+ result, err := Fetch(server.URL, nil)
+ require.NoError(t, err)
+
+ assert.Equal(t, 200, result.StatusCode)
+ assert.False(t, result.NotModified)
+ assert.Equal(t, `"abc123"`, result.ETag)
+ assert.Equal(t, "Wed, 01 Jan 2025 00:00:00 GMT", result.LastModified)
+
+ require.NotNil(t, result.Feed)
+ assert.Equal(t, "Test Feed", result.Feed.Title)
+ assert.Equal(t, "rss2.0", result.Feed.Format)
+ assert.Len(t, result.Feed.Items, 1)
+ assert.Equal(t, "Post 1", result.Feed.Items[0].Title)
+}
+
+func TestFetchConditional304(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if r.Header.Get("If-None-Match") == `"abc123"` {
+ w.WriteHeader(http.StatusNotModified)
+ return
+ }
+ w.Header().Set("ETag", `"abc123"`)
+ w.WriteHeader(http.StatusOK)
+ w.Write([]byte(testFeedXML))
+ }))
+ defer server.Close()
+
+ result, err := Fetch(server.URL, &FetchOptions{ETag: `"abc123"`})
+ require.NoError(t, err)
+
+ assert.Equal(t, 304, result.StatusCode)
+ assert.True(t, result.NotModified)
+ assert.Nil(t, result.Feed)
+}
+
+func TestFetchConditionalLastModified(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if r.Header.Get("If-Modified-Since") == "Wed, 01 Jan 2025 00:00:00 GMT" {
+ w.WriteHeader(http.StatusNotModified)
+ return
+ }
+ w.WriteHeader(http.StatusOK)
+ w.Write([]byte(testFeedXML))
+ }))
+ defer server.Close()
+
+ result, err := Fetch(server.URL, &FetchOptions{
+ LastModified: "Wed, 01 Jan 2025 00:00:00 GMT",
+ })
+ require.NoError(t, err)
+
+ assert.Equal(t, 304, result.StatusCode)
+ assert.True(t, result.NotModified)
+ assert.Nil(t, result.Feed)
+}
+
+func TestFetchGzip(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ // Only serve gzip if client accepts it
+ if r.Header.Get("Accept-Encoding") != "gzip" {
+ w.WriteHeader(http.StatusOK)
+ w.Write([]byte(testFeedXML))
+ return
+ }
+ w.Header().Set("Content-Encoding", "gzip")
+ w.Header().Set("Content-Type", "application/rss+xml")
+ w.WriteHeader(http.StatusOK)
+
+ gz := gzip.NewWriter(w)
+ gz.Write([]byte(testFeedXML))
+ gz.Close()
+ }))
+ defer server.Close()
+
+ result, err := Fetch(server.URL, nil)
+ require.NoError(t, err)
+
+ assert.Equal(t, 200, result.StatusCode)
+ require.NotNil(t, result.Feed)
+ assert.Equal(t, "Test Feed", result.Feed.Title)
+}
+
+func TestFetchCustomUserAgent(t *testing.T) {
+ var receivedUA string
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ receivedUA = r.Header.Get("User-Agent")
+ w.WriteHeader(http.StatusOK)
+ w.Write([]byte(testFeedXML))
+ }))
+ defer server.Close()
+
+ _, err := Fetch(server.URL, &FetchOptions{UserAgent: "MyBot/2.0"})
+ require.NoError(t, err)
+
+ assert.Equal(t, "MyBot/2.0", receivedUA)
+}
+
+func TestFetchDefaultUserAgent(t *testing.T) {
+ var receivedUA string
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ receivedUA = r.Header.Get("User-Agent")
+ w.WriteHeader(http.StatusOK)
+ w.Write([]byte(testFeedXML))
+ }))
+ defer server.Close()
+
+ _, err := Fetch(server.URL, nil)
+ require.NoError(t, err)
+
+ assert.Equal(t, "Yao-Robot/1.0", receivedUA)
+}
+
+func TestFetchAcceptHeader(t *testing.T) {
+ var receivedAccept string
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ receivedAccept = r.Header.Get("Accept")
+ w.WriteHeader(http.StatusOK)
+ w.Write([]byte(testFeedXML))
+ }))
+ defer server.Close()
+
+ _, err := Fetch(server.URL, nil)
+ require.NoError(t, err)
+
+ assert.Equal(t, "application/rss+xml, application/atom+xml, application/xml, text/xml", receivedAccept)
+}
+
+func TestFetch404(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ w.WriteHeader(http.StatusNotFound)
+ }))
+ defer server.Close()
+
+ _, err := Fetch(server.URL, nil)
+ assert.Error(t, err)
+ assert.Contains(t, err.Error(), "HTTP 404")
+}
+
+func TestFetch500(t *testing.T) {
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ w.WriteHeader(http.StatusInternalServerError)
+ }))
+ defer server.Close()
+
+ _, err := Fetch(server.URL, nil)
+ assert.Error(t, err)
+ assert.Contains(t, err.Error(), "HTTP 500")
+}
+
+func TestFetchEmptyURL(t *testing.T) {
+ _, err := Fetch("", nil)
+ assert.Error(t, err)
+ assert.Contains(t, err.Error(), "url is required")
+}
+
+func TestFetchInvalidURL(t *testing.T) {
+ _, err := Fetch("http://localhost:99999/nonexistent", &FetchOptions{Timeout: 1})
+ assert.Error(t, err)
+}
+
+func TestFetchAtomFeed(t *testing.T) {
+ atomXML := `
+
+ Atom Test
+
+ 2025-01-01T00:00:00Z
+
+ Atom Entry
+
+ urn:uuid:1
+ 2025-01-01T00:00:00Z
+
+`
+
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ w.Header().Set("Content-Type", "application/atom+xml")
+ w.WriteHeader(http.StatusOK)
+ w.Write([]byte(atomXML))
+ }))
+ defer server.Close()
+
+ result, err := Fetch(server.URL, nil)
+ require.NoError(t, err)
+
+ require.NotNil(t, result.Feed)
+ assert.Equal(t, "atom1.0", result.Feed.Format)
+ assert.Equal(t, "Atom Test", result.Feed.Title)
+ assert.Len(t, result.Feed.Items, 1)
+}
+
+func TestMapToFetchOptions(t *testing.T) {
+ input := map[string]interface{}{
+ "user_agent": "TestBot/1.0",
+ "timeout": float64(60),
+ "etag": `"xyz"`,
+ "last_modified": "Wed, 01 Jan 2025 00:00:00 GMT",
+ }
+
+ opts, err := mapToFetchOptions(input)
+ require.NoError(t, err)
+
+ assert.Equal(t, "TestBot/1.0", opts.UserAgent)
+ assert.Equal(t, 60, opts.Timeout)
+ assert.Equal(t, `"xyz"`, opts.ETag)
+ assert.Equal(t, "Wed, 01 Jan 2025 00:00:00 GMT", opts.LastModified)
+}
+
+func TestMapToFetchOptionsNil(t *testing.T) {
+ opts, err := mapToFetchOptions(nil)
+ require.NoError(t, err)
+ assert.NotNil(t, opts)
+}
diff --git a/rss/parse.go b/rss/parse.go
new file mode 100644
index 00000000..5843c1fa
--- /dev/null
+++ b/rss/parse.go
@@ -0,0 +1,138 @@
+package rss
+
+import (
+ "bytes"
+ "encoding/xml"
+ "fmt"
+ "io"
+ "strings"
+)
+
+// Parse parses an RSS 2.0 or Atom 1.0 XML string into a unified Feed struct.
+// It auto-detects the feed format by inspecting the root XML element.
+func Parse(data string) (*Feed, error) {
+ trimmed := strings.TrimSpace(data)
+ if trimmed == "" {
+ return nil, fmt.Errorf("empty input")
+ }
+
+ format, err := detectFormat([]byte(trimmed))
+ if err != nil {
+ return nil, err
+ }
+
+ b := []byte(trimmed)
+ switch format {
+ case "rss":
+ return parseRSS(b)
+ case "atom":
+ return parseAtom(b)
+ default:
+ return nil, fmt.Errorf("unsupported feed format: %s", format)
+ }
+}
+
+// Validate checks whether the input string is a valid RSS 2.0 or Atom 1.0 feed.
+// Returns nil on success, or a descriptive error explaining what is wrong.
+//
+// Process convention:
+// - success → true (bool)
+// - failure → error description string
+func Validate(data string) error {
+ trimmed := strings.TrimSpace(data)
+ if trimmed == "" {
+ return fmt.Errorf("empty input: expected an XML document containing an RSS or Atom feed")
+ }
+
+ // Step 1: check if it is valid XML at all
+ decoder := xml.NewDecoder(bytes.NewReader([]byte(trimmed)))
+ var rootFound bool
+ for {
+ tok, err := decoder.Token()
+ if err == io.EOF {
+ break
+ }
+ if err != nil {
+ return fmt.Errorf("not valid XML: %s", err.Error())
+ }
+ if _, ok := tok.(xml.StartElement); ok {
+ rootFound = true
+ break
+ }
+ }
+ if !rootFound {
+ return fmt.Errorf("not valid XML: no root element found")
+ }
+
+ // Step 2: detect format
+ format, err := detectFormat([]byte(trimmed))
+ if err != nil {
+ return err
+ }
+
+ // Step 3: attempt a full parse to verify structural integrity
+ b := []byte(trimmed)
+ switch format {
+ case "rss":
+ feed, err := parseRSS(b)
+ if err != nil {
+ return fmt.Errorf("RSS 2.0 parse error: %s", err.Error())
+ }
+ if feed.Title == "" {
+ return fmt.Errorf("RSS 2.0 feed is missing required
element in <channel>")
+ }
+ case "atom":
+ feed, err := parseAtom(b)
+ if err != nil {
+ return fmt.Errorf("Atom 1.0 parse error: %s", err.Error())
+ }
+ if feed.Title == "" {
+ return fmt.Errorf("Atom feed is missing required <title> element")
+ }
+ default:
+ return fmt.Errorf("unsupported feed format: %s", format)
+ }
+
+ return nil
+}
+
+// detectFormat inspects the root XML element to determine the feed format.
+// Returns "rss" for RSS 2.0, "atom" for Atom 1.0, or an error.
+func detectFormat(data []byte) (string, error) {
+ decoder := xml.NewDecoder(bytes.NewReader(data))
+ for {
+ tok, err := decoder.Token()
+ if err == io.EOF {
+ return "", fmt.Errorf("not valid XML: unexpected end of document before root element")
+ }
+ if err != nil {
+ return "", fmt.Errorf("not valid XML: %s", err.Error())
+ }
+
+ se, ok := tok.(xml.StartElement)
+ if !ok {
+ continue
+ }
+
+ local := strings.ToLower(se.Name.Local)
+
+ switch {
+ case local == "rss":
+ return "rss", nil
+
+ case local == "rdf":
+ // RDF-based RSS 1.0 (root element is <rdf:RDF>)
+ // We treat it as RSS for parsing purposes
+ return "rss", nil
+
+ case local == "feed":
+ return "atom", nil
+
+ default:
+ return "", fmt.Errorf(
+ "unrecognized feed format: root element is <%s>, expected <rss>, <feed>, or <rdf:RDF>",
+ se.Name.Local,
+ )
+ }
+ }
+}
diff --git a/rss/parse_test.go b/rss/parse_test.go
new file mode 100644
index 00000000..9b9212d4
--- /dev/null
+++ b/rss/parse_test.go
@@ -0,0 +1,158 @@
+package rss
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+)
+
+// --- Parse tests ---
+
+func TestParse_RSS(t *testing.T) {
+ feed, err := Parse(testRSS)
+ require.NoError(t, err)
+ assert.Equal(t, "rss2.0", feed.Format)
+ assert.Equal(t, "Example Blog", feed.Title)
+ assert.Len(t, feed.Items, 2)
+}
+
+func TestParse_Atom(t *testing.T) {
+ feed, err := Parse(testAtom)
+ require.NoError(t, err)
+ assert.Equal(t, "atom1.0", feed.Format)
+ assert.Equal(t, "Example Atom Feed", feed.Title)
+ assert.Len(t, feed.Items, 2)
+}
+
+func TestParse_Podcast(t *testing.T) {
+ feed, err := Parse(testPodcast)
+ require.NoError(t, err)
+ assert.Equal(t, "rss2.0", feed.Format)
+ assert.NotNil(t, feed.Podcast)
+ assert.Equal(t, "Jane Doe", feed.Podcast.Author)
+}
+
+func TestParse_Empty(t *testing.T) {
+ _, err := Parse("")
+ assert.Error(t, err)
+ assert.Contains(t, err.Error(), "empty input")
+}
+
+func TestParse_Whitespace(t *testing.T) {
+ _, err := Parse(" \n\t ")
+ assert.Error(t, err)
+ assert.Contains(t, err.Error(), "empty input")
+}
+
+func TestParse_NotXML(t *testing.T) {
+ _, err := Parse("This is not XML at all")
+ assert.Error(t, err)
+}
+
+func TestParse_HTML(t *testing.T) {
+ _, err := Parse(`<html><head><title>Not a feed