feed_me 0.0.5

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Jonas Nicklas
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,23 @@
+Feed Me
+=======
+
+Feed Me is a simple parser for RSS2 and Atom feed, adding other feed formats should be trivial. Feed Me is pretty minimal and basically only does translation/cleanup from different feed formats to a consistent API. It is designed to be minimal.
+
+Feed Me is built on the excellent Hpricot parser written by _why the lucky stiff.
+
+Use it like this:
+
+    file = File.read('some_feed.atom')
+    
+    feed = FeedMe.parse(file)
+    
+    feed.title
+    feed.author.name
+    feed.entries.each do |entry|
+      entry.title
+      entry.content
+    end
+
+Check out the specs or lib/feed_me/consts.rb for the complete API.
+
+DISCLAIMER: This is very much alpha software, use at your own risk!

data/Rakefile

@@ -0,0 +1,59 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'spec/rake/spectask'
+
+file_list = FileList['spec/*_spec.rb']
+
+namespace :spec do
+  desc "Run all examples with RCov"
+  Spec::Rake::SpecTask.new('rcov') do |t|
+    t.spec_files = file_list
+    t.rcov = true
+    t.rcov_dir = "doc/coverage"
+    t.rcov_opts = ['--exclude', 'spec']
+  end
+  
+  desc "Generate an html report"
+  Spec::Rake::SpecTask.new('report') do |t|
+    t.spec_files = file_list
+    t.rcov_opts = ['--exclude', 'spec']
+    t.spec_opts = ["--format", "html:doc/reports/specs.html"]
+    t.fail_on_error = false
+  end
+
+end
+
+desc 'Default: run specs.'
+task :default => 'spec:rcov'
+
+PLUGIN = "feed_me"
+NAME = "feed_me"
+AUTHOR = ["Jonas Nicklas", "Jonathan Stott"]
+EMAIL = "jonas.nicklas@gmail.com"
+HOMEPAGE = "http://github.com/jnicklas/feed_me"
+SUMMARY = "Nice and simple RSS and atom feed parsing built on hpricot"
+
+spec = Gem::Specification.new do |s|
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = NAME
+    s.platform = Gem::Platform::RUBY
+    s.has_rdoc = true
+    s.extra_rdoc_files = ["README", "LICENSE", 'TODO']
+    s.summary = SUMMARY
+    s.description = s.summary
+    s.authors = AUTHOR
+    s.email = EMAIL
+    s.homepage = HOMEPAGE
+    s.require_path = 'lib'
+    s.autorequire = PLUGIN
+    s.add_dependency('hpricot')
+    s.files = %w(LICENSE README Rakefile TODO) + Dir.glob("{lib,specs}/**/*")
+  end
+  Jeweler::GemcutterTasks.new
+rescue
+  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install namelessjon-jeweler -s http://gems.github.com"
+end

data/TODO

@@ -0,0 +1,2 @@
+TODO:
+- Add categories to atom feeds

data/lib/feed_me.rb

@@ -0,0 +1,36 @@
+# make sure we're running inside Merb
+if defined?(Merb::Plugins)
+  dependency 'hpricot'
+else
+  require 'rubygems'
+  require 'hpricot'
+end
+require 'time'
+
+unless nil.respond_to? :try
+  # the ultimate duck
+  class Object
+    def try(method, *args)
+      self.send(method, *args)
+    rescue NoMethodError
+      nil
+    end
+  end
+end
+
+module FeedMe
+  class InvalidFeedFormat < StandardError ; end
+
+  def self.parse(feed)
+    FeedMe::FeedParser.parse(feed)
+  end
+
+  def self.open(file)
+    FeedMe::FeedParser.parse(file)
+  end
+end
+
+['consts', 'abstract_parser', 'feed_struct', 'simple_struct',
+  'feed_parser', 'item_parser'].each do |f|
+  require File.join(File.dirname(__FILE__), 'feed_me', f)
+end

data/lib/feed_me/abstract_parser.rb

@@ -0,0 +1,119 @@
+class FeedMe::AbstractParser
+
+  class << self
+
+    attr_accessor :properties, :root_nodes
+
+    def build(xml, format, *args)
+      # in a world with activesupport this would have been written as
+      #   format_parser = (format.to_s.camelize + self.to_s).constantize
+      camelized_format = format.to_s.split('_').map{ |w| w.capitalize }.join('')
+      bare_class = self.to_s.split('::').last
+
+      begin
+        format_parser = FeedMe.const_get(camelized_format + bare_class)
+      rescue NameError
+      end
+
+      if format_parser.is_a?(Class) and format_parser.ancestors.include?(self)
+        return format_parser.new(xml, format, *args)
+      else
+        return self.new(xml, format, *args)
+      end
+
+    end
+
+  end
+
+  def initialize(xml, format)
+    self.xml = xml
+    self.format = format
+    self.properties = self.class.properties[self.format]
+
+    append_methods
+  end
+
+  def to_hash
+    hash = {}
+    self.properties.each do |method, p|
+      hash[method] = self.send(method)
+    end
+    return hash
+  end
+
+  attr_accessor :xml, :format, :properties
+
+  alias_method :root_node, :xml
+
+  protected
+
+  def fetch_rss_person(selector)
+    item = fetch(selector)
+    if(item)
+      email, name = item.split(/\s+/, 2)
+      name = name.match( /\((.*?)\)/ ).to_a[1] if name # strip parentheses
+    else
+      name, email = nil
+    end
+    FeedMe::SimpleStruct.new(:email => email, :name => name, :uri => nil)
+  end
+
+  def append_methods
+    self.properties.each do |method, p|
+      unless respond_to?(method)
+        block = get_proc_for_property(method, p)
+        # meta programming magic
+        (class << self; self; end).module_eval do
+          define_method method, &block
+        end
+      end
+    end
+  end
+
+  def get_proc_for_property(method, p)
+    if p.class == Array
+      return caching_proc(method, &proc { fetch("/#{p[0]}", root_node, p[1].to_sym) })
+    elsif p.class == Hash
+      return caching_proc(method, &proc { FeedMe::FeedStruct.new(root_node, p) })
+    elsif p != :undefined
+      return caching_proc(method, &proc { fetch("/#{p}", root_node) })
+    else
+      return proc { nil }
+    end
+  end
+
+  def caching_proc(name, &block)
+    proc do
+      ivar = instance_variable_get("@#{name}")
+      unless ivar
+        result = yield
+        instance_variable_set("@#{name}", result)
+        return result
+      end
+      ivar
+    end
+  end
+
+  def fetch(selector, search_in = xml, method = :inner_html)
+    item = search_in.search(selector)
+
+    unless method == :array
+      self.try("extract_" + method.to_s, item.first) unless item.empty?
+    else
+      item.map { |i| self.try("extract_inner_html", i) }
+    end
+  end
+
+  def extract_inner_html(item)
+    item.inner_html
+  end
+
+  def extract_href(item)
+    item[:href]
+  end
+
+  def extract_time(item)
+    Time.parse(item.inner_html).utc
+  end
+
+end

data/lib/feed_me/consts.rb

@@ -0,0 +1,69 @@
+module FeedMe
+
+  ROOT_NODES = {
+    :atom => "//feed[@xmlns='http://www.w3.org/2005/Atom']",
+    :rss2 => "//rss[@version=2.0]/channel"
+  }
+
+  FEED_PROPERTIES = {
+    :atom => {
+      :title => :title,
+      :updated_at => [:updated, :time],
+      :feed_id => :id,
+      :url => ["link[@rel=alternate]", :href],
+      :href => ["link[@rel=self]", :href],
+      :description => :subtitle,
+      :generator => :generator,
+      :author => {
+        :email => 'author/email',
+        :name => 'author/name',
+        :uri => 'author/uri'
+      },
+      :entries => :special
+    },
+    :rss2 => {
+      :title => :title,
+      :updated_at => [:lastBuildDate, :time],
+      :feed_id => :undefined,
+      :url => :link,
+      :href => :undefined,
+      :description => :description,
+      :generator => :generator,
+      :author => :special,
+      :entries => :special
+    }
+  }
+
+  ITEM_PROPERTIES = {
+    :atom => {
+      :title => :title,
+      :updated_at => [:updated, :time],
+      :item_id => :id,
+      :url => ["link[@rel=alternate]", :href],
+      :content => :content,
+      :author => {
+        :email => 'author/email',
+        :name => 'author/name',
+        :uri => 'author/uri'
+      }
+    },
+    :rss2 => {
+      :title => :title,
+      :updated_at => [:pubDate, :time],
+      :item_id => :guid,
+      :url => :link,
+      :content => :description,
+      :author => :special,
+      :categories => [:category, :array]
+    }
+  }
+
+  AUTHOR_PROPERTIES = {
+    :atom => {
+      :name => :name,
+      :uri => :uri,
+      :email => :email
+    }
+  }
+
+end

data/lib/feed_me/feed_parser.rb

@@ -0,0 +1,59 @@
+module FeedMe
+
+  class FeedParser < AbstractParser
+
+    self.properties = FEED_PROPERTIES
+
+    class << self
+
+      def open(file)
+        self.parse(Kernel.open(file).read)
+      end
+
+      # parses the passed feed and identifeis what kind of feed it is
+      # then returns a parser object
+      def parse(feed)
+        xml = Hpricot.XML(feed)
+
+        root_node, format = self.identify(xml)
+        raise InvalidFeedFormat if format.nil?
+
+        self.build(root_node, format)
+      end
+
+      protected
+
+      def identify(xml)
+        FeedMe::ROOT_NODES.each do |f, s|
+          item = xml.at(s)
+          return item, f if item
+        end
+      end
+
+    end
+  end
+
+  class AtomFeedParser < FeedParser
+    self.properties = FEED_PROPERTIES
+
+    def entries
+      xml.search('entry').map do |el|
+        ItemParser.build(el, self.format, self)
+      end
+    end
+  end
+
+  class Rss2FeedParser < FeedParser
+    self.properties = FEED_PROPERTIES
+
+    def entries
+      xml.search('item').map do |el|
+        ItemParser.build(el, self.format, self)
+      end
+    end
+
+    def author
+      fetch_rss_person("managingEditor")
+    end
+  end
+end

data/lib/feed_me/feed_struct.rb

@@ -0,0 +1,13 @@
+module FeedMe
+
+  class FeedStruct < AbstractParser
+
+    def initialize(xml, properties)
+      self.xml = xml
+      self.properties = properties
+      append_methods
+    end
+
+  end
+
+end

data/lib/feed_me/item_parser.rb

@@ -0,0 +1,25 @@
+module FeedMe
+
+  class ItemParser < AbstractParser
+
+    self.properties = ITEM_PROPERTIES
+
+    attr_accessor :feed
+
+    def initialize(xml, format, feed)
+      super(xml, format)
+      self.feed = feed
+    end
+
+  end
+
+  class Rss2ItemParser < ItemParser
+
+    self.properties = ITEM_PROPERTIES
+
+    def author
+      fetch_rss_person("author")
+    end
+
+  end
+end

data/lib/feed_me/merbtasks.rb

@@ -0,0 +1,6 @@
+namespace :feed_me do
+  desc "Do something for feed_me"
+  task :default do
+    puts "feed_me doesn't do anything"
+  end
+end

data/lib/feed_me/simple_struct.rb

@@ -0,0 +1,15 @@
+module FeedMe
+
+  class SimpleStruct
+
+    def initialize(hash = {})
+      (class << self; self; end).module_eval do
+        hash.each do |method, result|
+          define_method( method ) { result }
+        end
+      end
+    end
+
+  end
+
+end

data/spec/feed_parser_spec.rb

@@ -0,0 +1,295 @@
+require File.join( File.dirname(__FILE__), "spec_helper" )
+
+require 'feed_me'
+
+describe "all parsing methods", :shared => true do
+  it "should identify an atom feed" do
+    @atom.should be_an_instance_of(FeedMe::AtomFeedParser)
+    @atom.format.should == :atom
+    @atom.root_node.xpath == "//feed[@xmlns='http://www.w3.org/2005/Atom']"
+  end
+
+  it "should identify an rss2 feed" do
+    @rss2.should be_an_instance_of(FeedMe::Rss2FeedParser)
+    @rss2.format.should == :rss2
+    @rss2.root_node.xpath == "//rss[@version=2.0]/channel"
+  end
+end
+
+describe FeedMe::FeedParser do
+
+  before :each do
+    @atom_feed = hpricot_fixture('welformed.atom') / "//feed[@xmlns='http://www.w3.org/2005/Atom']"
+    @atom = FeedMe::FeedParser.build(@atom_feed, :atom)
+    @rss2_feed = hpricot_fixture('welformed.rss2') / "//rss[@version=2.0]/channel"
+    @rss2 = FeedMe::FeedParser.build(@rss2_feed, :rss2)
+  end
+
+  it "should be an atom parser for an atom feed" do
+    @atom.should be_an_instance_of(FeedMe::AtomFeedParser)
+  end
+
+  describe ".parse" do
+    before(:each) do
+      @atom = FeedMe::FeedParser.parse(open(fixture('welformed.atom')).read)
+      @rss2 = FeedMe::FeedParser.parse(open(fixture('welformed.rss2')).read)
+    end
+
+    it_should_behave_like "all parsing methods"
+
+    describe "with bad input" do
+      it "should raise on an empty body" do
+        lambda { FeedMe::FeedParser.parse("") }.should raise_error(FeedMe::InvalidFeedFormat)
+      end
+
+      it "should raise on a body with non-recognised xml" do
+        lambda {
+          FeedMe::FeedParser.parse(%Q|<?xml version="1.0" encoding="UTF-8"?>"<foo>bar</foo>|)
+        }.should raise_error(FeedMe::InvalidFeedFormat)
+      end
+    end
+
+  end
+
+  describe ".open" do
+    before(:each) do
+      @atom = FeedMe::FeedParser.open(fixture('welformed.atom'))
+      @rss2 = FeedMe::FeedParser.open(fixture('welformed.rss2'))
+    end
+
+    it_should_behave_like "all parsing methods"
+  end
+
+  describe '#title' do
+    it "should be valid for an atom feed" do
+      @atom.title.should == "Test feed"
+    end
+
+    it "should be valid for an rss2 feed" do
+      @rss2.title.should == "Lift Off News"
+    end
+  end
+
+  describe '#description' do
+    it "should be valid for an atom feed" do
+      @atom.description.should == "Monkey test feed"
+    end
+
+    it "should be valid for an rss2 feed" do
+      @rss2.description.should == "Liftoff to Space Exploration."
+    end
+  end
+
+  describe '#feed_id' do
+    it "should be valid for an atom feed" do
+      @atom.feed_id.should == "tag:imaginary.host:nyheter"
+    end
+
+    it "should be nil for an rss2 feed" do
+      @rss2.feed_id.should be_nil
+    end
+  end
+
+  describe '#updated_at' do
+    it "should be valid for an atom feed" do
+      @atom.updated_at.should == Time.utc(2008, 3, 7, 20, 41, 10)
+    end
+
+    it "should be valid for an rss2 feed" do
+      @rss2.updated_at.should == Time.utc(2003, 6, 10, 9, 41, 1)
+    end
+  end
+
+  describe '#href' do
+    it "should be valid for an atom feed" do
+      @atom.href.should == "http://imaginary.host/posts.atom"
+    end
+
+    it "should be nil for an atom feed" do
+      @rss2.href.should be_nil
+    end
+  end
+
+  describe '#url' do
+    it "should be valid for an atom feed" do
+      @atom.url.should == "http://imaginary.host/posts"
+    end
+
+    it "should be valid for an rss2 feed" do
+      @rss2.url.should == "http://liftoff.msfc.nasa.gov/"
+    end
+  end
+
+  describe '#generator' do
+    it "should be valid for an atom feed" do
+      @atom.generator.should == "Roll your own"
+    end
+
+    it "should be valid for an rss2 feed" do
+      @rss2.generator.should == "Weblog Editor 2.0"
+    end
+  end
+
+  describe '#format' do
+    it "should be :atom for an atom feed" do
+      @atom.format.should == :atom
+    end
+
+    it "should be :rss2 for an rss2 feed" do
+      @rss2.format.should == :rss2
+    end
+  end
+
+  describe '#author.name' do
+    it "should be valid for an atom feed" do
+      @atom.author.name.should == "Frank"
+    end
+
+    it "should be valid for an rss2 feed" do
+      @rss2.author.name.should == "Mary Jo"
+    end
+  end
+
+  describe '#author.email' do
+    it "should be valid for an atom feed" do
+      @atom.author.email.should == "frank@imaginary.host"
+    end
+
+    it "should be valid for an rss2 feed" do
+      @rss2.author.email.should == "editor@example.com"
+    end
+  end
+
+  describe '#author.uri' do
+    it "should be valid for an atom feed" do
+      @atom.author.uri.should == "http://imaginary.host/students/frank"
+    end
+
+    it "should be nil for an rss2 feed" do
+      @rss2.author.uri.should be_nil
+    end
+  end
+
+  describe '#entries' do
+    it "should return an array of entries for an atom feed" do
+      @atom.entries.should be_an_instance_of(Array)
+    end
+
+    it "should have the correct length for an atom feed" do
+      @atom.should have(3).entries
+    end
+
+    it "should return items that are properly parsed for an atom feed" do
+      @atom.entries.first.title.should == "First title"
+      @atom.entries.first.url.should == "http://imaginary.host/posts/3"
+    end
+
+    it "should return an array of entries for an rss2 feed" do
+      @rss2.entries.should be_an_instance_of(Array)
+    end
+
+    it "should have the correct length for an rss2 feed" do
+      @rss2.should have(4).entries
+    end
+
+    it "should return items that are properly parsed for an rss2 feed" do
+      @rss2.entries.first.title.should == "Star City"
+      @rss2.entries.first.url.should == "http://liftoff.msfc.nasa.gov/news/2003/news-starcity.asp"
+      @rss2.entries.first.item_id.should == "http://liftoff.msfc.nasa.gov/2003/06/03.html#item573"
+    end
+
+    it "should allow items to be read more than once" do
+      item = @rss2.entries.first
+      item.item_id.should == "http://liftoff.msfc.nasa.gov/2003/06/03.html#item573"
+      item.item_id.should == "http://liftoff.msfc.nasa.gov/2003/06/03.html#item573"
+    end
+  end
+
+  describe '#to_hash' do
+    it "should serialize the title of an atom feed" do
+      @atom.to_hash[:title].should == "Test feed"
+    end
+
+    it "should serialize the description of an atom feed" do
+      @atom.to_hash[:description].should == "Monkey test feed"
+    end
+
+    it "should serialize the feed_id of an atom feed" do
+      @atom.to_hash[:feed_id].should == "tag:imaginary.host:nyheter"
+    end
+
+    it "should serialize the updated_at time of an atom feed" do
+      @atom.to_hash[:updated_at].should == Time.utc(2008, 3, 7, 20, 41, 10)
+    end
+
+    it "should serialize the href of an atom feed" do
+      @atom.to_hash[:href].should == "http://imaginary.host/posts.atom"
+    end
+
+    it "should serialize the url of an atom feed" do
+      @atom.to_hash[:url].should == "http://imaginary.host/posts"
+    end
+
+    it "should serialize the generator of an atom feed" do
+      @atom.to_hash[:generator].should == "Roll your own"
+    end
+
+    it "should serialize the entries of an atom feed" do
+      @atom.to_hash[:entries].should be_an_instance_of(Array)
+      @atom.to_hash[:entries].first.title.should == "First title"
+      @atom.to_hash[:entries].first.url.should == "http://imaginary.host/posts/3"
+    end
+
+    it "should serialize the author of an atom feed" do
+      author = @atom.to_hash[:author]
+
+      author.name.should == "Frank"
+      author.email.should == "frank@imaginary.host"
+      author.uri.should == "http://imaginary.host/students/frank"
+    end
+
+    it "should serialize the title of an rss2 feed" do
+      @rss2.to_hash[:title].should == "Lift Off News"
+    end
+
+    it "should serialize the description of an rss2 feed" do
+      @rss2.to_hash[:description].should == "Liftoff to Space Exploration."
+    end
+
+    it "should serialize the feed_id of an rss2 feed" do
+      @rss2.to_hash[:feed_id].should be_nil
+    end
+
+    it "should serialize the updated_at time of an rss2 feed" do
+      @rss2.to_hash[:updated_at].should == Time.utc(2003, 6, 10, 9, 41, 1)
+    end
+
+    it "should serialize the href of an rss2 feed" do
+      @rss2.to_hash[:href].should be_nil
+    end
+
+    it "should serialize the url of an rss2 feed" do
+      @rss2.to_hash[:url].should == "http://liftoff.msfc.nasa.gov/"
+    end
+
+    it "should serialize the generator of an rss2 feed" do
+      @rss2.to_hash[:generator].should == "Weblog Editor 2.0"
+    end
+
+    it "should serialize the entries of an rss2 feed" do
+      @rss2.to_hash[:entries].should be_an_instance_of(Array)
+      @rss2.to_hash[:entries].first.title.should == "Star City"
+      @rss2.to_hash[:entries].first.url.should == "http://liftoff.msfc.nasa.gov/news/2003/news-starcity.asp"
+    end
+
+    it "should serialize the author of an rss2 feed" do
+
+      author = @rss2.to_hash[:author]
+
+      author.name.should == "Mary Jo"
+      author.email.should == "editor@example.com"
+      author.uri.should be_nil
+    end
+  end
+
+end

data/spec/item_parser_spec.rb

@@ -0,0 +1,188 @@
+require File.join( File.dirname(__FILE__), "spec_helper" )
+
+require 'feed_me'
+
+describe FeedMe::ItemParser do
+
+  before :each do
+    @atom_feed = FeedMe::FeedParser.open(fixture('welformed.atom'))
+    @atom = FeedMe::ItemParser.build(@atom_feed.root_node.search('/entry').first, :atom, @atom_feed)
+    @rss2_feed = FeedMe::FeedParser.open(fixture('welformed.rss2'))
+    @rss2 = FeedMe::ItemParser.build(@rss2_feed.root_node.search('/item').first, :rss2, @rss2_feed)
+  end
+
+  describe '#to_hash' do
+    it "should serialize the parsed properties to a hash" do
+
+    end
+  end
+
+  describe '#title' do
+    it "should be valid for an atom feed" do
+      @atom.title.should == "First title"
+    end
+
+    it "should be valid for an rss2 feed" do
+      @rss2.title.should == "Star City"
+    end
+  end
+
+  describe '#content' do
+    it "should be valid for an atom feed" do
+      @atom.content.should == "Here be content"
+    end
+
+    it "should be valid for an rss2 feed" do
+      @rss2.content.should == "This is content"
+    end
+  end
+
+  describe '#item_id' do
+    it "should be valid for an atom feed" do
+      @atom.item_id.should == "tag:imaginary.host,2008-03-07:nyheter/3"
+    end
+
+    it "should be valid for an rss2 feed" do
+      @rss2.item_id.should == "http://liftoff.msfc.nasa.gov/2003/06/03.html#item573"
+    end
+  end
+
+  describe '#updated_at' do
+    it "should be valid for an atom feed" do
+      @atom.updated_at.should == Time.utc( 2008, 3, 7, 20, 41, 10 )
+    end
+
+    it "should be valid for an rss2 feed" do
+      @rss2.updated_at.should == Time.utc(2003, 6, 3, 9, 39, 21)
+    end
+  end
+
+  describe '#url' do
+    it "should be valid for an atom feed" do
+      @atom.url.should == "http://imaginary.host/posts/3"
+    end
+
+    it "should be valid for an rss2 feed" do
+      @rss2.url.should == "http://liftoff.msfc.nasa.gov/news/2003/news-starcity.asp"
+    end
+  end
+
+  describe '#format' do
+    it "should be :atom for an atom feed" do
+      @atom.format.should == :atom
+    end
+
+    it "should be :rss2 for an rss2 feed" do
+      @rss2.format.should == :rss2
+    end
+  end
+
+  describe '#categories' do
+    it "should be correct for an rss2 feed" do
+      @rss2.categories.should == ['news', 'chuck']
+    end
+  end
+
+  describe '#author.name' do
+    it "should be valid for an atom feed" do
+      @atom.author.name.should == "Jonas Nicklas"
+    end
+
+    it "should be valid for an rss2 feed" do
+      @rss2.author.name.should == "Chuck Norris"
+    end
+  end
+
+  describe '#author.email' do
+    it "should be valid for an atom feed" do
+      @atom.author.email.should == "jonas.nicklas@imaginary.host"
+    end
+
+    it "should be valid for an rss2 feed" do
+      @rss2.author.email.should == "da_man@example.com"
+    end
+  end
+
+  describe '#author.uri' do
+    it "should be valid for an atom feed" do
+      @atom.author.uri.should == "http://imaginary.host/students/jnicklas"
+    end
+
+    it "should be nil for an rss2 feed" do
+      @rss2.author.uri.should be_nil
+    end
+  end
+
+  describe '#to_hash' do
+
+    it "should serialize the title for an atom feed" do
+      @atom.to_hash[:title].should == "First title"
+    end
+
+    it "should serialize the item_id for an atom feed" do
+      @atom.to_hash[:item_id].should == "tag:imaginary.host,2008-03-07:nyheter/3"
+    end
+
+    it "should serialize updated_at for an atom feed" do
+      @atom.to_hash[:updated_at].should == Time.utc( 2008, 3, 7, 20, 41, 10 )
+    end
+
+    it "should serialize the url for an atom feed" do
+      @atom.to_hash[:url].should == "http://imaginary.host/posts/3"
+    end
+
+    it "should serialize the author of an atom feed" do
+      author = @atom.to_hash[:author]
+
+      author.name.should == "Jonas Nicklas"
+      author.email.should == "jonas.nicklas@imaginary.host"
+      author.uri.should == "http://imaginary.host/students/jnicklas"
+    end
+
+    it "should serialize the title for an rss2 feed" do
+      @rss2.to_hash[:title].should == "Star City"
+    end
+
+    it "should serialize the item_id for an rss2 feed" do
+      @rss2.to_hash[:item_id].should == "http://liftoff.msfc.nasa.gov/2003/06/03.html#item573"
+    end
+
+    it "should serialize updated_at for an rss2 feed" do
+      @rss2.to_hash[:updated_at].should == Time.utc(2003, 6, 3, 9, 39, 21)
+    end
+
+    it "should serialize the url for an rss2 feed" do
+      @rss2.to_hash[:url].should == "http://liftoff.msfc.nasa.gov/news/2003/news-starcity.asp"
+    end
+
+    it "should serialize the author of an rss2 feed" do
+      author = @rss2.to_hash[:author]
+
+      author.name.should == "Chuck Norris"
+      author.email.should == "da_man@example.com"
+      author.uri.should be_nil
+    end
+  end
+
+end
+
+describe "Without an author", FeedMe::ItemParser do
+
+  before :each do
+    @atom_feed = FeedMe::FeedParser.open(fixture('welformed.atom'))
+    @atom = FeedMe::ItemParser.build(@atom_feed.root_node.search('/entry')[1], :atom, @atom_feed)
+    @rss2_feed = FeedMe::FeedParser.open(fixture('welformed.rss2'))
+    @rss2 = FeedMe::ItemParser.build(@rss2_feed.root_node.search('/item')[1], :rss2, @rss2_feed)
+  end
+
+  describe '#author.name' do
+    it "should be valid for an atom feed" do
+      @atom.author.name.should be_nil
+    end
+
+    it "should be valid for an rss2 feed" do
+      @rss2.author.name.should be_nil
+    end
+  end
+
+end

data/spec/simple_struct_spec.rb

@@ -0,0 +1,14 @@
+require File.join( File.dirname(__FILE__), "spec_helper" )
+
+require 'feed_me'
+
+describe FeedMe::SimpleStruct do
+
+  it "should append methods" do
+    struct = FeedMe::SimpleStruct.new(:foo => "blah", :bar => 23)
+
+    struct.foo.should == "blah"
+    struct.bar.should == 23
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+$TESTING=true
+$:.push File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'rubygems'
+# require 'ruby-debug'
+
+module Fixtures
+
+  def fixture_path
+    File.join(File.dirname(__FILE__), 'fixtures')
+  end
+
+  def fixture(name)
+    File.join(fixture_path, name)
+  end
+
+  def hpricot_fixture(name)
+    Hpricot.XML(open(fixture(name)).read)
+  end
+
+end
+
+Spec::Runner.configure do |config|
+  config.include(Fixtures)
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+name: feed_me
+version: !ruby/object:Gem::Version 
+  version: 0.0.5
+platform: ruby
+authors: 
+- Jonas Nicklas
+- Jonathan Stott
+autorequire: feed_me
+bindir: bin
+cert_chain: []
+
+date: 2009-11-06 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hpricot
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Nice and simple RSS and atom feed parsing built on hpricot
+email: jonas.nicklas@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README
+- TODO
+files: 
+- LICENSE
+- README
+- Rakefile
+- TODO
+- lib/feed_me.rb
+- lib/feed_me/abstract_parser.rb
+- lib/feed_me/consts.rb
+- lib/feed_me/feed_parser.rb
+- lib/feed_me/feed_struct.rb
+- lib/feed_me/item_parser.rb
+- lib/feed_me/merbtasks.rb
+- lib/feed_me/simple_struct.rb
+has_rdoc: true
+homepage: http://github.com/jnicklas/feed_me
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Nice and simple RSS and atom feed parsing built on hpricot
+test_files: 
+- spec/feed_parser_spec.rb
+- spec/item_parser_spec.rb
+- spec/simple_struct_spec.rb
+- spec/spec_helper.rb