Developing a Command-Line RSS Reader in Go

Table of Contents

  1. Introduction
  2. Prerequisites
  3. Setup

  4. Creating the RSS Reader - Step 1: Parsing the RSS Feed - Step 2: Displaying the News Items - Step 3: User Interaction

  5. Conclusion

Introduction

Welcome to this tutorial on developing a command-line RSS reader in Go! In this tutorial, we’ll explore how to create a Go program that can fetch and display the latest news items from an RSS feed. By the end of this tutorial, you’ll have a working RSS reader that you can use to keep up with your favorite news sources right from the command line.

Prerequisites

Before starting this tutorial, you’ll need to have Go installed on your system. If you haven’t already installed Go, please refer to the official Go documentation for instructions on how to install it: https://golang.org/doc/install

Setup

To begin, create a new directory for our project and navigate into it:

mkdir rss-reader
cd rss-reader

Next, initialize a new Go module by running the following command:

go mod init github.com/your-username/rss-reader

We’re now ready to start coding our RSS reader!

Creating the RSS Reader

Step 1: Parsing the RSS Feed

To fetch and parse an RSS feed in Go, we’ll utilize the “encoding/xml” package. Create a new file called reader.go and add the following code:

package main

import (
	"encoding/xml"
	"fmt"
	"net/http"
	"os"
)

type Item struct {
	XMLName xml.Name `xml:"item"`
	Title   string   `xml:"title"`
	Link    string   `xml:"link"`
}

type Channel struct {
	XMLName xml.Name `xml:"channel"`
	Items   []Item   `xml:"item"`
}

type Feed struct {
	XMLName xml.Name `xml:"rss"`
	Channel Channel  `xml:"channel"`
}

func parseFeed(url string) (*Feed, error) {
	response, err := http.Get(url)
	if err != nil {
		return nil, err
	}
	defer response.Body.Close()

	if response.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("fetching feed: %s", response.Status)
	}

	var feed Feed
	err = xml.NewDecoder(response.Body).Decode(&feed)
	if err != nil {
		return nil, err
	}

	return &feed, nil
}

In the above code, we define the necessary data structures to represent the RSS feed. The Feed struct represents the entire feed, while the Channel struct contains the list of news items (Item struct). The parseFeed() function fetches the RSS feed from the provided URL, parses it, and returns the parsed feed data.

Step 2: Displaying the News Items

Now that we can parse the RSS feed, let’s display the fetched news items. Modify the reader.go file and add the following code below the parseFeed() function:

func displayItems(items []Item) {
	for _, item := range items {
		fmt.Printf("* %s\n  %s\n\n", item.Title, item.Link)
	}
}

func main() {
	if len(os.Args) < 2 {
		fmt.Println("Please provide an RSS feed URL.")
		return
	}

	feedURL := os.Args[1]
	feed, err := parseFeed(feedURL)
	if err != nil {
		fmt.Printf("Error fetching feed: %s\n", err)
		return
	}

	displayItems(feed.Channel.Items)
}

In the above code, the displayItems() function takes a slice of news Items and prints each item’s title and link. The main() function checks if the user has provided an RSS feed URL as a command-line argument. If a URL is provided, it calls the parseFeed() function to fetch and parse the feed. Finally, it passes the parsed items to the displayItems() function to display the news items.

Step 3: User Interaction

To make the RSS reader more interactive, we can modify the code to prompt the user for the feed URL if it’s not provided as a command-line argument. Modify the main() function in reader.go to the following:

func main() {
	var feedURL string
	if len(os.Args) < 2 {
		fmt.Print("Enter RSS feed URL: ")
		fmt.Scanln(&feedURL)
	} else {
		feedURL = os.Args[1]
	}

	feed, err := parseFeed(feedURL)
	if err != nil {
		fmt.Printf("Error fetching feed: %s\n", err)
		return
	}

	displayItems(feed.Channel.Items)
}

With this modification, if the user doesn’t provide a feed URL as a command-line argument, the program will prompt for it. The user can then enter the URL, and the program will fetch and display the news items accordingly.

Conclusion

Congratulations! You have successfully developed a command-line RSS reader in Go. You’ve learned how to fetch and parse an RSS feed using the encoding/xml package, display the news items, and make the program interactive by accepting user input. Feel free to enhance your RSS reader further by adding features like caching, filtering, or categorizing news items.

In this tutorial, we covered the categories of Networking and Web Programming and File I/O and System Interaction. By building this project, you gained hands-on experience with Go’s networking capabilities, data parsing using XML, and command-line interaction. Keep exploring Go’s powerful standard library and community packages to build even more impressive applications. Happy coding!

Published:

Related Articles