rgarner/rss_aware_atom_feed_helper.rb

## rss_aware_atom_feed_helper.rb
##
# RSS-aware patched helper. See http://www.zephyros-systems.co.uk/blog/?p=179
#
require 'set'

module ActionView
  # = Action View Atom Feed Helpers
  module Helpers #:nodoc:
    module AtomFeedHelper
      # Adds easy defaults to writing Atom feeds with the Builder template engine (this does not work on ERb or any other
      # template languages).
      #
      # Full usage example:
      #
      #   config/routes.rb:
      #     Basecamp::Application.routes.draw do
      #       resources :posts
      #       root :to => "posts#index"
      #     end
      #
      #   app/controllers/posts_controller.rb:
      #     class PostsController < ApplicationController::Base
      #       # GET /posts.html
      #       # GET /posts.atom
      #       def index
      #         @posts = Post.find(:all)
      #
      #         respond_to do |format|
      #           format.html
      #           format.atom
      #         end
      #       end
      #     end
      #
      #   app/views/posts/index.atom.builder:
      #     atom_feed do |feed|
      #       feed.title("My great blog!")
      #       feed.updated(@posts.first.created_at)
      #
      #       for post in @posts
      #         feed.entry(post) do |entry|
      #           entry.title(post.title)
      #           entry.content(post.body, :type => 'html')
      #
      #           entry.author do |author|
      #             author.name("DHH")
      #           end
      #         end
      #       end
      #     end
      #
      # The options for atom_feed are:
      #
      # * <tt>:language</tt>: Defaults to "en-US".
      # * <tt>:root_url</tt>: The HTML alternative that this feed is doubling for. Defaults to / on the current host.
      # * <tt>:url</tt>: The URL for this feed. Defaults to the current URL.
      # * <tt>:id</tt>: The id for this feed. Defaults to "tag:#{request.host},#{options[:schema_date]}:#{request.request_uri.split(".")[0]}"
      # * <tt>:schema_date</tt>: The date at which the tag scheme for the feed was first used. A good default is the year you
      #   created the feed. See http://feedvalidator.org/docs/error/InvalidTAG.html for more information. If not specified,
      #   2005 is used (as an "I don't care" value).
      # * <tt>:instruct</tt>: Hash of XML processing instructions in the form {target => {attribute => value, }} or {target => [{attribute => value, }, ]}
      #
      # Other namespaces can be added to the root element:
      #
      #   app/views/posts/index.atom.builder:
      #     atom_feed({'xmlns:app' => 'http://www.w3.org/2007/app',
      #         'xmlns:openSearch' => 'http://a9.com/-/spec/opensearch/1.1/'}) do |feed|
      #       feed.title("My great blog!")
      #       feed.updated((@posts.first.created_at))
      #       feed.tag!(openSearch:totalResults, 10)
      #
      #       for post in @posts
      #         feed.entry(post) do |entry|
      #           entry.title(post.title)
      #           entry.content(post.body, :type => 'html')
      #           entry.tag!('app:edited', Time.now)
      #
      #           entry.author do |author|
      #             author.name("DHH")
      #           end
      #         end
      #       end
      #     end
      #
      # The Atom spec defines five elements (content rights title subtitle
      # summary) which may directly contain xhtml content if :type => 'xhtml'
      # is specified as an attribute.  If so, this helper will take care of
      # the enclosing div and xhtml namespace declaration.  Example usage:
      #
      #    entry.summary :type => 'xhtml' do |xhtml|
      #      xhtml.p pluralize(order.line_items.count, "line item")
      #      xhtml.p "Shipped to #{order.address}"
      #      xhtml.p "Paid by #{order.pay_type}"
      #    end
      #
      #
      # atom_feed yields an AtomFeedBuilder instance.  Nested elements yield
      # an AtomBuilder instance.
      def atom_feed(options = {}, &block)
        if options[:schema_date]
          options[:schema_date] = options[:schema_date].strftime("%Y-%m-%d") if options[:schema_date].respond_to?(:strftime)
        else
          options[:schema_date] = "2005" # The Atom spec copyright date
        end

        xml = options.delete(:xml) || eval("xml", block.binding)
        xml = rssify(xml) if (rssify = options.delete(:rssify))

        xml.instruct!
        if options[:instruct]
          options[:instruct].each do |target, attrs|
            if attrs.respond_to?(:keys)
              xml.instruct!(target, attrs)
            elsif attrs.respond_to?(:each)
              attrs.each { |attr_group| xml.instruct!(target, attr_group) }
            end
          end
        end

        feed_opts = {
            "xml:lang" => options[:language] || "en-US",
            "xmlns#{':a' if rssify}" => 'http://www.w3.org/2005/Atom'
        }
        feed_opts.merge!(options).reject! { |k, v| !k.to_s.match(/^xml/) }

        xml.feed(feed_opts) do
          xml.id(options[:id] || "tag:#{request.host},#{options[:schema_date]}:#{request.fullpath.split(".")[0]}")
          xml.link(:rel => 'alternate', :type => 'text/html', :href => options[:root_url] || (request.protocol + request.host_with_port))
          xml.link(:rel => 'self', :type => 'application/atom+xml', :href => options[:url] || request.url)

          yield AtomFeedBuilder.new(xml, self, options)
        end
      end

      ##
      # ATOM elements with their analogues in RSS. Expressed in the form of a hash,
      # the LHS is the atom name, RHS is *either* a string with the RSS name, *or*
      # a hash of the RSS name to a custom tagger lambda which will call the xml builder itself
      #
      # Anything that is RSS should appear here, even if it has the same element name in ATOM.
      # Things that don't will fall back to the ATOM namespace.
      ATOM_RSS_METHOD_MAP = {
          'id' => 'guid',
          'title' => 'title',
          'subtitle' => 'description',
          'feed' =>
              {
                  'channel' => lambda do |xml, *options, &block|
                    xml.tag!("rss", :version => '2.0') do
                      xml.tag! "channel", *options, &block
                    end
                  end
              },
          'entry' => 'item',
          'link' =>
              {
                  'link' => lambda do |xml, *options, &block|
                    tag_with = 'link'
                    rel = options.last[:rel]
                    if rel == 'alternate' && options.last[:type] == 'text/html'
                      options.last.delete(:rel)
                      options.last.delete(:type)
                      options.unshift(options.last.delete(:href))
                    else
                      tag_with = 'a:link'
                    end
                    xml.tag! tag_with, *options, &block
                  end
              },
          'content' =>
              {
                  'description' => lambda do |xml, *options, &block|
                    # 'description' element has no type="html""
                    options.last.delete(:type)
                    xml.tag! 'description', *options, &block
                  end
              },
          'published' =>
              {
                  'pubDate' => lambda do |xml, *options, &block|
                    options[0] = DateTime.parse(options[0]).rfc822
                    xml.tag! 'pubDate', *options, &block
                  end
              }
      }

      ##
      # Modify this instance of Builder::XmlMarkup to
      # intercept atom calls and patch them to their RSS equivalents
      def rssify(xml)
        ATOM_RSS_METHOD_MAP.each_pair do |atom_name, handler|
          rss_method_name, custom_tagger = *(handler.is_a?(Hash) ?
              [handler.keys.first, handler.values.first] : [handler, nil])

          xml.class_eval do
            define_method atom_name do |*options, &block|
              if custom_tagger
                custom_tagger.call(xml, *options, &block)
              else
                xml.tag!(rss_method_name, *options, &block)
              end
            end
          end
        end
        ##
        # Define the fallback to atom for method_missing
        xml.class_eval do
          define_method :method_missing_with_fallback_to_atom do |sym, *args, &block|
            # Violation of DRY (see ATOM_RSS_METHOD_MAP above). TODO: make it not one.
            @@known ||= [:rss, :title, :description, :guid, :channel, :item, :link, :description, :pubDate]
            sym_s = sym.to_s
            sym = "a:#{sym_s}".to_sym unless @@known.include?(sym) || sym_s.include?(':')
            method_missing_without_fallback_to_atom sym, *args, &block
          end
          alias_method_chain :method_missing, :fallback_to_atom
        end

        xml
      end

      class AtomBuilder
        (XHTML_TAG_NAMES = %w(content rights title subtitle summary).to_set) unless defined?(XHTML_TAG_NAMES)

        def initialize(xml)
          @xml = xml
        end

        private
        # Delegate to xml builder, first wrapping the element in a xhtml
        # namespaced div element if the method and arguments indicate
        # that an xhtml_block? is desired.
        def method_missing(method, *arguments, &block)
          if xhtml_block?(method, arguments)
            @xml.__send__(method, *arguments) do
              @xml.div(:xmlns => 'http://www.w3.org/1999/xhtml') do |xhtml|
                block.call(xhtml)
              end
            end
          else
            @xml.__send__(method, *arguments, &block)
          end
        end

        # True if the method name matches one of the five elements defined
        # in the Atom spec as potentially containing XHTML content and
        # if :type => 'xhtml' is, in fact, specified.
        def xhtml_block?(method, arguments)
          if XHTML_TAG_NAMES.include?(method.to_s)
            last = arguments.last
            last.is_a?(Hash) && last[:type].to_s == 'xhtml'
          end
        end
      end

      class AtomFeedBuilder < AtomBuilder
        def initialize(xml, view, feed_options = {})
          @xml, @view, @feed_options = xml, view, feed_options
        end

        # Accepts a Date or Time object and inserts it in the proper format. If nil is passed, current time in UTC is used.
        def updated(date_or_time = nil)
          @xml.updated((date_or_time || Time.now.utc).xmlschema)
        end

        # Creates an entry tag for a specific record and prefills the id using class and id.
        #
        # Options:
        #
        # * <tt>:published</tt>: Time first published. Defaults to the created_at attribute on the record if one such exists.
        # * <tt>:updated</tt>: Time of update. Defaults to the updated_at attribute on the record if one such exists.
        # * <tt>:url</tt>: The URL for this entry. Defaults to the polymorphic_url for the record.
        # * <tt>:id</tt>: The ID for this entry. Defaults to "tag:#{@view.request.host},#{@feed_options[:schema_date]}:#{record.class}/#{record.id}"
        def entry(record, options = {})
          @xml.entry do
            @xml.id(options[:id] || "tag:#{@view.request.host},#{@feed_options[:schema_date]}:#{record.class}/#{record.id}")

            if options[:published] || (record.respond_to?(:created_at) && record.created_at)
              @xml.published((options[:published] || record.created_at).xmlschema)
            end

            if options[:updated] || (record.respond_to?(:updated_at) && record.updated_at)
              @xml.updated((options[:updated] || record.updated_at).xmlschema)
            end

            @xml.link(:rel => 'alternate', :type => 'text/html', :href => options[:url] || @view.polymorphic_url(record))

            yield AtomBuilder.new(@xml)
          end
        end
      end

    end
  end
end

module RssAwareAtomFeedHelper
  # Keeps ActiveRecord dependencies quiet. TODO: find a way of removing
end
	##
	# RSS-aware patched helper. See http://www.zephyros-systems.co.uk/blog/?p=179
	#
	require 'set'

	module ActionView
	# = Action View Atom Feed Helpers
	module Helpers #:nodoc:
	module AtomFeedHelper
	# Adds easy defaults to writing Atom feeds with the Builder template engine (this does not work on ERb or any other
	# template languages).
	#
	# Full usage example:
	#
	# config/routes.rb:
	# Basecamp::Application.routes.draw do
	# resources :posts
	# root :to => "posts#index"
	# end
	#
	# app/controllers/posts_controller.rb:
	# class PostsController < ApplicationController::Base
	# # GET /posts.html
	# # GET /posts.atom
	# def index
	# @posts = Post.find(:all)
	#
	# respond_to do \|format\|
	# format.html
	# format.atom
	# end
	# end
	# end
	#
	# app/views/posts/index.atom.builder:
	# atom_feed do \|feed\|
	# feed.title("My great blog!")
	# feed.updated(@posts.first.created_at)
	#
	# for post in @posts
	# feed.entry(post) do \|entry\|
	# entry.title(post.title)
	# entry.content(post.body, :type => 'html')
	#
	# entry.author do \|author\|
	# author.name("DHH")
	# end
	# end
	# end
	# end
	#
	# The options for atom_feed are:
	#
	# * <tt>:language</tt>: Defaults to "en-US".
	# * <tt>:root_url</tt>: The HTML alternative that this feed is doubling for. Defaults to / on the current host.
	# * <tt>:url</tt>: The URL for this feed. Defaults to the current URL.
	# * <tt>:id</tt>: The id for this feed. Defaults to "tag:#{request.host},#{options[:schema_date]}:#{request.request_uri.split(".")[0]}"
	# * <tt>:schema_date</tt>: The date at which the tag scheme for the feed was first used. A good default is the year you
	# created the feed. See http://feedvalidator.org/docs/error/InvalidTAG.html for more information. If not specified,
	# 2005 is used (as an "I don't care" value).
	# * <tt>:instruct</tt>: Hash of XML processing instructions in the form {target => {attribute => value, }} or {target => [{attribute => value, }, ]}
	#
	# Other namespaces can be added to the root element:
	#
	# app/views/posts/index.atom.builder:
	# atom_feed({'xmlns:app' => 'http://www.w3.org/2007/app',
	# 'xmlns:openSearch' => 'http://a9.com/-/spec/opensearch/1.1/'}) do \|feed\|
	# feed.title("My great blog!")
	# feed.updated((@posts.first.created_at))
	# feed.tag!(openSearch:totalResults, 10)
	#
	# for post in @posts
	# feed.entry(post) do \|entry\|
	# entry.title(post.title)
	# entry.content(post.body, :type => 'html')
	# entry.tag!('app:edited', Time.now)
	#
	# entry.author do \|author\|
	# author.name("DHH")
	# end
	# end
	# end
	# end
	#
	# The Atom spec defines five elements (content rights title subtitle
	# summary) which may directly contain xhtml content if :type => 'xhtml'
	# is specified as an attribute. If so, this helper will take care of
	# the enclosing div and xhtml namespace declaration. Example usage:
	#
	# entry.summary :type => 'xhtml' do \|xhtml\|
	# xhtml.p pluralize(order.line_items.count, "line item")
	# xhtml.p "Shipped to #{order.address}"
	# xhtml.p "Paid by #{order.pay_type}"
	# end
	#
	#
	# atom_feed yields an AtomFeedBuilder instance. Nested elements yield
	# an AtomBuilder instance.
	def atom_feed(options = {}, &block)
	if options[:schema_date]
	options[:schema_date] = options[:schema_date].strftime("%Y-%m-%d") if options[:schema_date].respond_to?(:strftime)
	else
	options[:schema_date] = "2005" # The Atom spec copyright date
	end

	xml = options.delete(:xml) \|\| eval("xml", block.binding)
	xml = rssify(xml) if (rssify = options.delete(:rssify))

	xml.instruct!
	if options[:instruct]
	options[:instruct].each do \|target, attrs\|
	if attrs.respond_to?(:keys)
	xml.instruct!(target, attrs)
	elsif attrs.respond_to?(:each)
	attrs.each { \|attr_group\| xml.instruct!(target, attr_group) }
	end
	end
	end

	feed_opts = {
	"xml:lang" => options[:language] \|\| "en-US",
	"xmlns#{':a' if rssify}" => 'http://www.w3.org/2005/Atom'
	}
	feed_opts.merge!(options).reject! { \|k, v\| !k.to_s.match(/^xml/) }

	xml.feed(feed_opts) do
	xml.id(options[:id] \|\| "tag:#{request.host},#{options[:schema_date]}:#{request.fullpath.split(".")[0]}")
	xml.link(:rel => 'alternate', :type => 'text/html', :href => options[:root_url] \|\| (request.protocol + request.host_with_port))
	xml.link(:rel => 'self', :type => 'application/atom+xml', :href => options[:url] \|\| request.url)

	yield AtomFeedBuilder.new(xml, self, options)
	end
	end

	##
	# ATOM elements with their analogues in RSS. Expressed in the form of a hash,
	# the LHS is the atom name, RHS is either a string with the RSS name, or
	# a hash of the RSS name to a custom tagger lambda which will call the xml builder itself
	#
	# Anything that is RSS should appear here, even if it has the same element name in ATOM.
	# Things that don't will fall back to the ATOM namespace.
	ATOM_RSS_METHOD_MAP = {
	'id' => 'guid',
	'title' => 'title',
	'subtitle' => 'description',
	'feed' =>
	{
	'channel' => lambda do \|xml, *options, &block\|
	xml.tag!("rss", :version => '2.0') do
	xml.tag! "channel", *options, &block
	end
	end
	},
	'entry' => 'item',
	'link' =>
	{
	'link' => lambda do \|xml, *options, &block\|
	tag_with = 'link'
	rel = options.last[:rel]
	if rel == 'alternate' && options.last[:type] == 'text/html'
	options.last.delete(:rel)
	options.last.delete(:type)
	options.unshift(options.last.delete(:href))
	else
	tag_with = 'a:link'
	end
	xml.tag! tag_with, *options, &block
	end
	},
	'content' =>
	{
	'description' => lambda do \|xml, *options, &block\|
	# 'description' element has no type="html""
	options.last.delete(:type)
	xml.tag! 'description', *options, &block
	end
	},
	'published' =>
	{
	'pubDate' => lambda do \|xml, *options, &block\|
	options[0] = DateTime.parse(options[0]).rfc822
	xml.tag! 'pubDate', *options, &block
	end
	}
	}

	##
	# Modify this instance of Builder::XmlMarkup to
	# intercept atom calls and patch them to their RSS equivalents
	def rssify(xml)
	ATOM_RSS_METHOD_MAP.each_pair do \|atom_name, handler\|
	rss_method_name, custom_tagger = *(handler.is_a?(Hash) ?
	[handler.keys.first, handler.values.first] : [handler, nil])

	xml.class_eval do
	define_method atom_name do \|*options, &block\|
	if custom_tagger
	custom_tagger.call(xml, *options, &block)
	else
	xml.tag!(rss_method_name, *options, &block)
	end
	end
	end
	end
	##
	# Define the fallback to atom for method_missing
	xml.class_eval do
	define_method :method_missing_with_fallback_to_atom do \|sym, *args, &block\|
	# Violation of DRY (see ATOM_RSS_METHOD_MAP above). TODO: make it not one.
	@@known \|\|= [:rss, :title, :description, :guid, :channel, :item, :link, :description, :pubDate]
	sym_s = sym.to_s
	sym = "a:#{sym_s}".to_sym unless @@known.include?(sym) \|\| sym_s.include?(':')
	method_missing_without_fallback_to_atom sym, *args, &block
	end
	alias_method_chain :method_missing, :fallback_to_atom
	end

	xml
	end

	class AtomBuilder
	(XHTML_TAG_NAMES = %w(content rights title subtitle summary).to_set) unless defined?(XHTML_TAG_NAMES)

	def initialize(xml)
	@xml = xml
	end

	private
	# Delegate to xml builder, first wrapping the element in a xhtml
	# namespaced div element if the method and arguments indicate
	# that an xhtml_block? is desired.
	def method_missing(method, *arguments, &block)
	if xhtml_block?(method, arguments)
	@xml.__send__(method, *arguments) do
	@xml.div(:xmlns => 'http://www.w3.org/1999/xhtml') do \|xhtml\|
	block.call(xhtml)
	end
	end
	else
	@xml.__send__(method, *arguments, &block)
	end
	end

	# True if the method name matches one of the five elements defined
	# in the Atom spec as potentially containing XHTML content and
	# if :type => 'xhtml' is, in fact, specified.
	def xhtml_block?(method, arguments)
	if XHTML_TAG_NAMES.include?(method.to_s)
	last = arguments.last
	last.is_a?(Hash) && last[:type].to_s == 'xhtml'
	end
	end
	end

	class AtomFeedBuilder < AtomBuilder
	def initialize(xml, view, feed_options = {})
	@xml, @view, @feed_options = xml, view, feed_options
	end

	# Accepts a Date or Time object and inserts it in the proper format. If nil is passed, current time in UTC is used.
	def updated(date_or_time = nil)
	@xml.updated((date_or_time \|\| Time.now.utc).xmlschema)
	end

	# Creates an entry tag for a specific record and prefills the id using class and id.
	#
	# Options:
	#
	# * <tt>:published</tt>: Time first published. Defaults to the created_at attribute on the record if one such exists.
	# * <tt>:updated</tt>: Time of update. Defaults to the updated_at attribute on the record if one such exists.
	# * <tt>:url</tt>: The URL for this entry. Defaults to the polymorphic_url for the record.
	# * <tt>:id</tt>: The ID for this entry. Defaults to "tag:#{@view.request.host},#{@feed_options[:schema_date]}:#{record.class}/#{record.id}"
	def entry(record, options = {})
	@xml.entry do
	@xml.id(options[:id] \|\| "tag:#{@view.request.host},#{@feed_options[:schema_date]}:#{record.class}/#{record.id}")

	if options[:published] \|\| (record.respond_to?(:created_at) && record.created_at)
	@xml.published((options[:published] \|\| record.created_at).xmlschema)
	end

	if options[:updated] \|\| (record.respond_to?(:updated_at) && record.updated_at)
	@xml.updated((options[:updated] \|\| record.updated_at).xmlschema)
	end

	@xml.link(:rel => 'alternate', :type => 'text/html', :href => options[:url] \|\| @view.polymorphic_url(record))

	yield AtomBuilder.new(@xml)
	end
	end
	end

	end
	end
	end

	module RssAwareAtomFeedHelper
	# Keeps ActiveRecord dependencies quiet. TODO: find a way of removing
	end