We recently incorporated RSS feeds into Kotoba. I noted while implementing my solution that there are some tutorials [1, 2] out there that provide quick-and-dirty solutions to getting RSS feeds into a Rails application. While the tutorials are a good start, they do neglect the fact these implementations will drive a lot of (unnecessary) traffic between your site and the site with the RSS feed.

What can you do? What else! The time honored solution for all things that ail software: cache it.

First, let us create our RSS controller, or:

require 'kotoba_rss/feed'

class RssController < ApplicationController

def parse_feed feed_url = params['rss_url'] || 'http://word.wardosworld.com/?feed=rss2&cat=6' maximum_number_of_items = params['maximum_number_of_items'].to_i || 5 title = params['title'] || t('rss.rss_feed') details = params['details'] || t('rss.read_more') details_url = params['details_url'] || 'http://word.wardosworld.com/?cat=6' feed(feed_url, maximum_number_of_items, title, details, details_url) end

def feed(feed_url, maximum_number_of_items, title, details, details_url) kotoba_rss_feed = Kotoba_Rss::Feed.new result = kotoba_rss_feed.get(feed_url) return render( :partial => '/rss/feed', :layout => 'popup', :locals => { :result => result, :maximum_number_of_items => maximum_number_of_items, :title => title, :details => details, :details_url => details_url } ) end end

The next step is to create a class that will fetch RSS feeds for the rest of our application caching as appropriate, lib/kotoba_rss/feed.rb:

require "rss" require 'rss/2.0' require 'open-uri'

class Kotoba_Rss::Feed

def initialize @cache = Kotoba_Rss::Cache.instance end

def get(url) result = nil if @cache.has_expired?(url) open(url) do |http| response = http.read result = RSS::Parser.parse(response, false) end @cache.add(url,result) else result = @cache.get(url) end return result end

end

Finally, we want to be able to cache our RSS feed results between calls, lib/kotoba_rss/cache.rb:

# Keep a cache of fetched RSS feeds. This is to ensure

we do not hit an RSS feed too often; an issue when we

have many page fetches.

This is also a very useful thing when we are fetching

from sites that might be throttling requests from specific

users and, or domains (e.g. twitter.com).

class Kotoba_Rss::Cache include Singleton

ENTRY_EXPIRES_IN_SECONDS = 300 # 5 minutes

def initialize @cache = Hash.new end

def add(url, result) entity = Kotoba_Rss::Cache::Entry.new(Time.now,result) @cache[url] = entity end

def get(url) @cache[url].feed_result end

def has_expired?(url) if @cache.has_key?(url) entry = @cache[url] current_time = Time.now time_expired = current_time - entry.feed_time if time_expired > ENTRY_EXPIRES_IN_SECONDS return true else return false end else # if we do not have the URL yet then # consider it expired return true end end

end

In the same file, lib/kotoba_rss/cache.rb, I also include:

class Kotoba_Rss::Cache::Entry attr_reader :feed_time, :feed_result

def initialize(time, result) @feed_time = time @feed_result = result end

end

I consider Kotoba_Rss::Cache::Entry an inner class that is only really useful for Kotaba_Rss::Cache, thus a great candidate for being included in its parent’s file; however, if you prefer you can certainly put it in its own file. In truth, Kotaba_Rss::Cache can also be included in lib/kotoba_rss/feed.rb which makes an even better design (note to self to refactor afterwards).

To use we have in our ApplicationHelper

def link_to_blog_popup link_to( image_gif('blog',t('meta.blog')), { :action => 'parse_feed', :controller => 'rss', :rss_url => 'http://word.wardosworld.com/?feed=rss2&cat=6', :maximum_number_of_items => 10, :title => t('meta.blog'), :details => t('meta.blog_read_more'), :details_url => 'http://word.wardosworld.com/?cat=6' } , :class => 'popup', :onclick => "return hs.htmlExpand(this, { objectType: 'ajax', contentId: 'popup', wrapperClassName: 'highslide-no-border', dimmingOpacity: 0.75, align: 'center'} )" ) end

Note that we are using I18n t() method for localization.

In summary, we have a good separation of responsibility between all our moving parts. We are using a controller the way it is intended, with our presentation properly off-loaded to views. In our library we have a means of making a service that invisibly caches its results.

In my experience, caches should almost always be hidden from the caller; otherwise, you begin to degrade cohesion and venture into the land of tight coupling. Additionally, it makes the cache design much harder with multiple point of entry.

That is it. Whenever we have held a result in our cache longer than ENTRY_EXPIRES_IN_SECONDS our RSS feed will get new result that it stores in its cache. This will ensure that as our site grows (and it will!) we will not be hitting external services with every page fetch; something that would yield little value to our users (slower fetches) and make us bad clients of other sites’ feeds.