RSS implemented and tested

rss/feed.go

@@ -3,10 +3,11 @@ package rss
 import (
 	"bytes"
 	"encoding/gob"
-	"errors"
+	"fmt"
 	"io/ioutil"
 	"net/http"
 	"regexp"
+	"strings"
 	"time"
 
 	"github.com/mmcdole/gofeed"
@@ -17,26 +18,41 @@ type Feed struct {
 	Items         []string
 	ItemFilter    string
 	ContentFilter string
-	Source        string
+	Link          string
 }
 
-func NewFeed(source, itemFilter, contentFilter string) (*Feed, error) {
+func (feed *Feed) String() string {
+	return fmt.Sprintf("Updated: %v, Items: %v, ItemFilter: %q, ContentFilter: %q, Link; %v",
+		feed.Updated.Local(),
+		feed.Items,
+		feed.ItemFilter,
+		feed.ContentFilter,
+		feed.Link,
+	)
+}
+
+func (feed *Feed) ID() string {
+	return strings.Join(regexp.MustCompile("[a-zA-Z0-9]*").FindAllString(feed.Link, -1), "_")
+}
+
+func NewFeed(source, itemFilter, contentFilter string) (*Feed, []*Item, error) {
 	if _, err := regexp.Compile(itemFilter); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	if _, err := regexp.Compile(contentFilter); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	f := &Feed{
 		Items:         []string{},
 		ItemFilter:    itemFilter,
 		ContentFilter: contentFilter,
-		Source:        source,
+		Link:          source,
 	}
-	if _, err := f.Update(); err != nil {
-		return nil, err
+	items, err := f.Update()
+	if err != nil {
+		return nil, nil, err
 	}
-	return f, errors.New("not implemented")
+	return f, items, nil
 }
 
 func Deserialize(src []byte) (*Feed, error) {
@@ -47,15 +63,15 @@ func Deserialize(src []byte) (*Feed, error) {
 	return &dst, err
 }
 
-func (f *Feed) Serialize() ([]byte, error) {
+func (feed *Feed) Serialize() ([]byte, error) {
 	var buffer bytes.Buffer
 	enc := gob.NewEncoder(&buffer)
-	err := enc.Encode(f)
+	err := enc.Encode(feed)
 	return buffer.Bytes(), err
 }
 
-func (f *Feed) Update() ([]*Item, error) {
-	resp, err := http.Get(f.Source)
+func (feed *Feed) Update() ([]*Item, error) {
+	resp, err := http.Get(feed.Link)
 	if err != nil {
 		return nil, err
 	}
@@ -64,46 +80,46 @@ func (f *Feed) Update() ([]*Item, error) {
 		return nil, err
 	}
 	parser := gofeed.NewParser()
-	feed, err := parser.Parse(bytes.NewBuffer(body))
+	gofeed, err := parser.Parse(bytes.NewBuffer(body))
 	if err != nil {
 		return nil, err
 	}
-	return f.fromGofeed(feed)
+	return feed.fromGofeed(gofeed)
 }
 
-func (f *Feed) fromGofeed(feed *gofeed.Feed) ([]*Item, error) {
-	updated := feed.PublishedParsed
+func (feed *Feed) fromGofeed(gofeed *gofeed.Feed) ([]*Item, error) {
+	updated := gofeed.PublishedParsed
 	if updated == nil {
-		updated = feed.UpdatedParsed
+		updated = gofeed.UpdatedParsed
 	}
-	if updated == nil && len(feed.Items) > 0 {
-		updated = gofeedItemTS(feed.Items[0])
+	if updated == nil && len(gofeed.Items) > 0 {
+		updated = gofeedItemTS(gofeed.Items[0])
 	}
 	if updated == nil {
 		t := time.Now()
 		updated = &t
 	}
-	newitems, err := f.appendNewItems(feed.Items)
+	newitems, err := feed.appendNewItems(gofeed.Items)
 	if err != nil {
 		return nil, err
 	}
-	f.Updated = *updated
+	feed.Updated = *updated
 	return newitems, nil
 }
 
-func (f *Feed) appendNewItems(items []*gofeed.Item) ([]*Item, error) {
+func (feed *Feed) appendNewItems(items []*gofeed.Item) ([]*Item, error) {
 	newitems := []*Item{}
 	for i := range items {
 		t := gofeedItemTS(items[i])
-		if t.Before(f.Updated) {
+		if t.Before(feed.Updated) {
 			continue
 		}
-		if ok, _ := regexp.MatchString(f.ItemFilter, items[i].Title); !ok {
+		if ok, _ := regexp.MatchString(feed.ItemFilter, items[i].Title); !ok {
 			continue
 		}
-		item := fromGofeedItem(items[i], f.ContentFilter)
+		item := fromGofeedItem(items[i], feed.ContentFilter)
 		newitems = append(newitems, item)
-		f.Items = append(f.Items, item.Name)
+		feed.Items = append(feed.Items, item.Name)
 	}
 	return newitems, nil
 }