feed-abstract 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+pkg/*
+*.gem
+.bundle
+Gemfile.lock
+*.swp

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in feed-abstract.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1,23 @@
+= Feed::Abstract
+
+Feed::Abstract creates a common object graph for RSS, Atom, and RDF feeds using the classes returned by RSS::Parser 
+
+== Installation
+
+ gem install feed-abstract
+
+== Usage 
+
+See Feed::Abstract::Feed for basic examples. Also see the Feed::Abstract::Channel and Feed::Abstract::Item namespaces.
+
+== Author
+
+Dan Collis Puro, Berkman Center for Internet & Society
+djcp@cyber.law.harvard.edu
+
+== License & Copyright
+
+GPLv3
+
+2011 President and Fellows of Harvard College
+

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/feed-abstract.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "feed-abstract/version"
+
+Gem::Specification.new do |s|
+  s.name        = "feed-abstract"
+  s.version     = Feed::Abstract::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Daniel Collis-Puro"]
+  s.email       = ["djcp@cyber.law.harvard.edu"]
+  s.homepage    = "https://github.com/berkmancenter/feed-abstract"
+  s.summary     = %q{Abstracts RSS/Atom/RDF parsing features from the ruby standard lib into a common object graph.}
+  s.description = %q{This library creates a common object graph for the RSS/Atom/RDF parsing classes in the ruby standard library. This allows you parse different feed formats and get back the same (or at least a very similar) set of results - item authors are accessible under an "author(s)" attribute, categories/tags/subjects are accessible under "category(ies)" attributes, etc. We do our best to make sure the data makes sense, too - RSS items lack an "updated" attribute, so we use "pubDate" to populate it. }
+  s.files         = `git ls-files`.split("\n")
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  s.add_development_dependency "rspec", "2.6"
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+end

data/lib/feed-abstract.rb

@@ -0,0 +1,33 @@
+# encoding: UTF-8
+
+$LOAD_PATH.unshift(File.dirname(__FILE__)) unless $LOAD_PATH.include?(File.dirname(__FILE__))
+
+require 'rss'
+
+require "feed-abstract/version"
+require 'feed-abstract/mixins'
+
+require 'feed-abstract/channel/atom'
+require 'feed-abstract/channel/rss'
+require 'feed-abstract/channel/rdf'
+
+require 'feed-abstract/items/rss'
+require 'feed-abstract/items/atom'
+require 'feed-abstract/items/rdf'
+
+require 'feed-abstract/item/rss'
+require 'feed-abstract/item/atom'
+require 'feed-abstract/item/rdf'
+
+require 'feed-abstract/feed'
+
+
+#RSS::Rss::Channel::Item.class_eval{
+#  def foobar
+#    'asdfasdf'
+#  end
+#}
+
+#RSS::Rss::Channel::Item.instance_eval{
+#  install_get_attribute('category', '', false )
+#}

data/lib/feed-abstract/channel/atom.rb

@@ -0,0 +1,47 @@
+# encoding: UTF-8
+
+module Feed
+  class Abstract
+
+    # You don't want this class. You want Feed::Abstract::Channel::Atom, Feed::Abstract::Channel::RSS or Feed::Abstract::Channel::RDF.
+    class Channel
+
+      # See Feed::AbstractMixins::Atom for more instance methods.
+      class Atom
+        include Feed::AbstractMixins::Atom
+
+        attr_reader :feed, :source
+
+        def initialize(feed)
+          @feed = @source = feed
+        end
+
+        def description
+          @feed.subtitle.content
+        end
+        alias :subtitle :description
+
+        # A string representing the application that created this feed.
+        def generator
+          return '' if @feed.generator.nil?
+          @feed.generator.content
+        end
+
+        # A URL (perhaps with domain, depending on input) representing an icon for the feed.
+        def icon
+          return '' if @feed.icon.nil?
+          @feed.icon.content
+        end
+
+        # A URL (perhaps with domain, depending on input) representing a logo for the feed.
+        def logo
+          return '' if @feed.logo.nil?
+          @feed.logo.content
+        end
+
+      end
+    end
+
+
+  end
+end

data/lib/feed-abstract/channel/rdf.rb

@@ -0,0 +1,63 @@
+# encoding: UTF-8
+
+module Feed
+  class Abstract
+    class Channel
+      class RDF < RSS
+
+        # The authors list as an array.
+        def authors
+          return [] if @feed.channel.dc_publishers.empty?
+          @feed.channel.dc_publishers
+        end
+
+        # The authors list as a string, joined with a comma. 
+        def author
+          return '' if self.authors.empty?
+          self.authors.join(', ')
+        end
+
+        # The generator of this feed.
+        def generator
+          return '' unless @feed.channel.respond_to?(:about)
+          if @feed.channel.about.match(/connotea/i)
+            return 'Connotea'
+          end
+          ''
+        end
+
+        # The category list as an array.
+        def categories
+          return [] if @feed.channel.dc_subjects.empty?
+          @feed.channel.dc_subjects.collect{|c| c.content}
+        end
+
+        # The category list as a string, joined with a comma.
+        def category
+          return '' if self.categories.empty?
+          self.categories.join(', ')
+        end
+
+        # A URL (with or without domain depending on input) to a icon representing this feed.
+        def icon
+          return '' if @feed.channel.image.nil?
+          @feed.channel.image.resource
+        end
+        alias :logo :icon 
+
+        # Copyright info.
+        def rights
+          return '' if @feed.channel.dc_rights.nil?
+          @feed.channel.dc_rights
+        end
+
+        # A Time object representing when this feed was updated, or at least "dated" according to the RDF spec.
+        def updated
+          return '' if @feed.channel.dc_date.nil?
+          @feed.channel.dc_date
+        end
+
+      end
+    end
+  end
+end

data/lib/feed-abstract/channel/rss.rb

@@ -0,0 +1,91 @@
+# encoding: UTF-8
+
+module Feed
+  class Abstract
+    class Channel
+      class RSS
+        include Feed::AbstractMixins::RSS
+        attr_reader :feed, :source
+
+        def initialize(feed)
+          @feed = @source = feed
+        end
+
+        def title
+          @feed.channel.title
+        end
+
+        def description
+          @feed.channel.description
+        end
+        alias :subtitle :description
+
+        # The generator of this feed as a string. Sometimes a URL, sometimes a string (e.g. the application name).
+        def generator
+          if ! @feed.channel.generator.nil? && @feed.channel.generator.match(/wordpress\.org/i)
+            return 'WordPress'
+          elsif @feed.channel.link.match(/www\.delicious\.com/i)
+            return 'Delicious'
+          end
+          return '' if @feed.channel.generator.nil?
+          @feed.channel.generator
+        end
+
+        def link
+          return '' if @feed.channel.link.nil?
+          @feed.channel.link
+        end
+
+        # Copyright info.
+        def rights
+          return '' if @feed.channel.copyright.nil? && @feed.channel.dc_rights.nil?
+          [@feed.channel.copyright,@feed.channel.dc_rights].compact.join(' ')
+        end
+
+        # A Time object.
+        def updated
+          return '' if @feed.channel.lastBuildDate.nil?
+          @feed.channel.lastBuildDate
+        end
+
+        # A globally unique ID for this feed. A URL in this case.
+        def guid
+          return '' if @feed.channel.link.nil?
+          @feed.channel.link
+        end
+
+        # The authors (a merge of the RSS managingEditor and dc:publisher elements) as an array.
+        def authors
+          return [] if @feed.channel.managingEditor.nil? && @feed.channel.dc_publishers.empty?
+          [@feed.channel.managingEditor, @feed.channel.dc_publishers].flatten.uniq
+        end
+
+        # The author list joined with a comma.
+        def author
+          return '' if self.authors.empty?
+          self.authors.join(', ')
+        end
+
+        # The category list (a merge of the RSS category and dc:subject elements) as an array. 
+        def categories
+          return [] if @feed.channel.categories.empty? && @feed.channel.dc_subjects.empty?
+          [@feed.channel.categories, @feed.channel.dc_subjects].flatten.uniq.collect{|c| c.content}
+        end
+
+        # The category list as a string, joined with a comma.
+        def category
+          return '' if @feed.channel.categories.empty?
+          @feed.channel.categories.collect{|c| c.content}.join(', ')
+        end
+
+        # A URL to an icon representing this feed.
+        def icon
+          return '' if @feed.channel.image.nil?
+          @feed.channel.image.url
+        end
+        alias :logo :icon 
+
+      end
+    end
+  end
+end

data/lib/feed-abstract/feed.rb

@@ -0,0 +1,74 @@
+# encoding: UTF-8
+
+module Feed
+  class ParserError < Exception
+  end
+
+  class Abstract
+
+    # Feed::Abstract::Feed is the main class. It invokes RSS::Parser and negotiates which of the Feed::Abstract::Channel and Feed::Abstract::Item classes get dispatched to normalize the object graph of the feed you're parsing. 
+    class Feed
+      attr_reader :channel, :raw_feed, :items
+
+      # === Parameters
+      # * xml - a string or object instance that responds to <b>read</b>
+      # * :do_validate - whether or not the feed should be validated. Passed through to RSS::Parser
+      # * :ignore_unknown_element - passed through to RSS::Parser
+      #
+      # === Returns
+      # An object with three attributes:
+      # * channel - an instance of Feed::Abstract::Channel matching the type of feed we recognized
+      # * items - an array of items matching the type of feed we recognized.
+      # * raw_feed - the raw feed object returned by RSS::Parser, which might include RSS::Atom::Feed, RSS::RDF, or RSS::Rss
+      # You will most likely be using the <b>channel</b> and <b>items</b> attributes.
+      #
+      # === Notes
+      # If a feed can't be parsed, we'll throw a Feed::ParserError.
+      #
+      # == Examples
+      #
+      #  f = Feed::Abstract::Feed.new(File.open('/home/foo/xml/feed.rss2'))
+      #  puts f.channel.title
+      #  puts f.channel.description
+      #
+      #  f.items.each do|item|
+      #   puts item.title
+      #   puts item.link
+      #  end
+      #
+      #  f = Feed::Abstract::Feed.new(File.open('/home/foo/xml/feed.atom'))
+      #  puts f.channel.generator
+      #
+      #  puts "All tags / categories / subjects in this feed: " + f.items.collect{|i| i.categories}.flatten.uniq.sort.join(', ')
+      #  
+      #  f = Feed::Abstract::Feed.new(Net::HTTP.get(URI.parse('http://rss.slashdot.org/Slashdot/slashdot')))
+      #  puts f.items.collect{|i| i.link}
+      #   
+      def initialize(xml = nil, options = {:do_validate => false, :ignore_unknown_element => true})
+        input = (xml.respond_to?(:read)) ? xml.read : xml
+        @raw_feed = RSS::Parser.parse(input,options[:do_validate], options[:ignore_unknown_element])
+        if @raw_feed == nil
+          raise Feed::ParserError
+        end
+        negotiate_channel_class
+      end
+
+      private 
+
+      #Here's an easy extension point for custom parsers.
+      def negotiate_channel_class
+        if @raw_feed.class == RSS::Atom::Feed
+          @channel = Channel::Atom.new(@raw_feed)
+          @items = Items::Atom.new(@raw_feed)
+        elsif @raw_feed.class == RSS::RDF
+          @channel = Channel::RDF.new(@raw_feed)
+          @items = Items::RDF.new(@raw_feed)
+        else
+          @channel = Channel::RSS.new(@raw_feed)
+          @items = Items::RSS.new(@raw_feed)
+        end
+      end
+
+    end
+  end
+end

data/lib/feed-abstract/item/atom.rb

@@ -0,0 +1,50 @@
+# encoding: UTF-8
+
+module Feed
+  class Abstract
+
+    # You don't want this class. You want Feed::Abstract::Item::Atom, Feed::Abstract::Item::RSS or  Feed::Abstract::Item::RDF.
+    class Item
+
+      # See Feed::AbstractMixins::Atom for more instance methods.
+      class Atom
+        include Feed::AbstractMixins::Atom
+        attr_reader :item, :source
+
+        def initialize(item)
+          @item = @source = item
+        end
+
+        # The full content of the item, most likely html.
+        def content
+          return '' if @item.content.nil?
+          @item.content.content
+        end
+
+        # The contributor list as an array.
+        def contributors
+          return [] if @item.contributors.empty?
+          @item.contributors.collect{|c| c.name.content}
+        end
+
+        #The contributor list as a strong joined with a comma.
+        def contributor
+          return '' if @item.contributors.empty?
+          @item.contributors.collect{|c| c.name.content}.join(', ')
+        end
+
+        def summary
+          return '' if @item.summary.nil?
+          @item.summary.content
+        end
+
+        # A Time object
+        def published
+          return '' if @item.published.nil?
+          @item.published.content
+        end
+
+      end
+    end
+  end
+end

data/lib/feed-abstract/item/rdf.rb

@@ -0,0 +1,48 @@
+# encoding: UTF-8
+
+module Feed
+  class Abstract
+    class Item
+      class RDF < RSS
+
+        # The author list (from the dc:creator element) as an array.
+        def authors
+          (@item.dc_creators.empty?) ? [] : @item.dc_creators.collect{|c| c.content}
+        end
+
+        # The author list as a string, joined with a comma.
+        def author
+          return '' if self.authors.empty?
+          self.authors.join(', ')
+        end
+
+        # The category list (parsed from the dc:subject element) as an array.
+        def categories
+          return [] if @item.dc_subjects.empty?
+          @item.dc_subjects.collect{|c| c.content}
+        end
+
+        # The category list as a string, joined with a comma.
+        def category
+          return '' if self.categories.empty?
+          self.categories.join(', ')
+        end
+
+        # A Time object.
+        def updated
+          return '' if @item.dc_date.nil?
+          @item.dc_date
+        end
+        alias :published :updated
+
+        # A globally unique id, in this case probably a URL.
+        def guid
+          return '' if @item.about.nil?
+          @item.about
+        end
+
+
+      end
+    end
+  end
+end