func fetch(urls []string) Entries {
var result Entries
p := gofeed.NewParser()
for _, url := range urls {
resp, err := http.Get(url)
if err != nil {
log.Error("cannot fetch feed", "url", url, "error", err.Error())
continue
}
feed, err := p.Parse(resp.Body)
resp.Body.Close()
if err != nil {
log.Error("cannot parse feed", "url", url, "error", err.Error())
continue
}
for _, it := range feed.Items {
result = append(result, &Entry{
Feed: Feed{
Title: html.UnescapeString(feed.Title),
Link: feed.Link,
},
Title: html.UnescapeString(it.Title),
Link: it.Link,
Published: parseTime(it.Published),
})
}
}
return result
}
func ExampleParser_ParseURL() {
fp := gofeed.NewParser()
feed, err := fp.ParseURL("http://feeds.twit.tv/twit.xml")
if err != nil {
panic(err)
}
fmt.Println(feed.Title)
}
func TestParser_ParseURL_Failure(t *testing.T) {
server, client := mockServerResponse(404, "")
fp := gofeed.NewParser()
fp.Client = client
feed, err := fp.ParseURL(server.URL)
assert.NotNil(t, err)
assert.IsType(t, gofeed.HTTPError{}, err)
assert.Nil(t, feed)
}
func ExampleParser_ParseString() {
feedData := `<rss version="2.0">
<channel>
<title>Sample Feed</title>
</channel>
</rss>`
fp := gofeed.NewParser()
feed, err := fp.ParseString(feedData)
if err != nil {
panic(err)
}
fmt.Println(feed.Title)
}
func main() {
app := cli.NewApp()
app.Name = "ftest"
app.Usage = "provide a feed file path or url to parse and print"
app.Flags = []cli.Flag{
cli.StringFlag{
Name: "type,t",
Value: "universal",
Usage: "type of parser (atom, rss, universal)",
},
}
app.Action = func(c *cli.Context) {
if c.NArg() == 0 {
fmt.Println("Missing feed path or url")
os.Exit(1)
}
feedType := c.String("type")
feedLoc := c.Args()[0]
fc, err := fetchFeed(feedLoc)
if err != nil {
fmt.Println(err.Error())
os.Exit(1)
}
var feed interface{}
if strings.EqualFold(feedType, "rss") ||
strings.EqualFold(feedType, "r") {
p := rss.Parser{}
feed, err = p.Parse(strings.NewReader(fc))
} else if strings.EqualFold(feedType, "atom") ||
strings.EqualFold(feedType, "a") {
p := atom.Parser{}
feed, err = p.Parse(strings.NewReader(fc))
} else {
p := gofeed.NewParser()
feed, err = p.ParseString(fc)
}
if err != nil {
fmt.Println(err.Error())
os.Exit(1)
}
fmt.Println(feed)
}
app.Run(os.Args)
}
func TestParser_ParseURL_Success(t *testing.T) {
var feedTests = []struct {
file string
feedType string
feedTitle string
hasError bool
}{
{"atom03_feed.xml", "atom", "Feed Title", false},
{"atom10_feed.xml", "atom", "Feed Title", false},
{"rss_feed.xml", "rss", "Feed Title", false},
{"rdf_feed.xml", "rss", "Feed Title", false},
{"unknown_feed.xml", "", "", true},
}
for _, test := range feedTests {
fmt.Printf("Testing %s... ", test.file)
// Get feed content
path := fmt.Sprintf("testdata/parser/universal/%s", test.file)
f, _ := ioutil.ReadFile(path)
// Get actual value
server, client := mockServerResponse(200, string(f))
fp := gofeed.NewParser()
fp.Client = client
feed, err := fp.ParseURL(server.URL)
if test.hasError {
assert.NotNil(t, err)
assert.Nil(t, feed)
} else {
assert.NotNil(t, feed)
assert.Nil(t, err)
assert.Equal(t, feed.FeedType, test.feedType)
assert.Equal(t, feed.Title, test.feedTitle)
}
}
}