feed_me 0.0.5 → 0.6.0

data/README

@@ -3,7 +3,7 @@ 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.
+Feed Me is built on the excellent Nokogiri parser.
 
 Use it like this:
 
@@ -20,4 +20,4 @@ Use it like this:
 
 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!
+DISCLAIMER: This is very much alpha software, use at your own risk!

data/Rakefile

@@ -23,8 +23,13 @@ namespace :spec do
 
 end
 
+desc "Run all examples"
+Spec::Rake::SpecTask.new('spec') do |t|
+  t.spec_files = file_list
+end
+
 desc 'Default: run specs.'
-task :default => 'spec:rcov'
+task :default => 'spec'
 
 PLUGIN = "feed_me"
 NAME = "feed_me"
@@ -53,7 +58,6 @@ begin
     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/lib/feed_me.rb

@@ -1,23 +1,6 @@
-# make sure we're running inside Merb
-if defined?(Merb::Plugins)
-  dependency 'hpricot'
-else
-  require 'rubygems'
-  require 'hpricot'
-end
+require 'nokogiri'
 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
 
@@ -30,7 +13,7 @@ module FeedMe
   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
+require 'feed_me/abstract_parser'
+require 'feed_me/feed_parser'
+require 'feed_me/item_parser'
+require 'feed_me/person_parser'

data/lib/feed_me/abstract_parser.rb

@@ -2,118 +2,121 @@ class FeedMe::AbstractParser
 
   class << self
 
-    attr_accessor :properties, :root_nodes
+    def properties
+      @properties ||= {}
+    end
 
-    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
+    def property(name, options={})
+      options[:path] ||= name
+      properties[name.to_sym] = options
 
-      begin
-        format_parser = FeedMe.const_get(camelized_format + bare_class)
-      rescue NameError
-      end
+      class_eval <<-RUBY, __FILE__, __LINE__+1
+        def #{name}
+          get_property(:#{name})
+        end
+      RUBY
+    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
+    def has_many(name, options={})
+      raise ArgumentError, "must specify :use option" unless options[:use]
+      options[:path] ||= name
+      options[:association] = :has_many
+      properties[name.to_sym] = options
 
+      class_eval <<-RUBY, __FILE__, __LINE__+1
+        def #{name}
+          get_has_many_association(:#{name})
+        end
+      RUBY
     end
 
-  end
+    def has_one(name, options={})
+      raise ArgumentError, "must specify :use option" unless options[:use]
+      options[:path] ||= name
+      options[:association] = :has_one
+      properties[name.to_sym] = options
+
+      class_eval <<-RUBY, __FILE__, __LINE__+1
+        def #{name}
+          get_has_one_association(:#{name})
+        end
+      RUBY
+    end
 
-  def initialize(xml, format)
-    self.xml = xml
-    self.format = format
-    self.properties = self.class.properties[self.format]
+  end
 
-    append_methods
+  def initialize(feed, xml)
+    @xml = xml
+    @feed = feed
   end
 
   def to_hash
     hash = {}
-    self.properties.each do |method, p|
+    self.class.properties.each do |method, p|
       hash[method] = self.send(method)
     end
     return hash
   end
 
-  attr_accessor :xml, :format, :properties
+  attr_reader :xml, :feed
 
   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
+private
+
+  def get_has_many_association(name)
+    return nil unless xml
+    association = self.class.properties[name]
+    
+    nodes = xml.xpath("./#{association[:path]}")
+    parser = FeedMe.const_get(association[:use].to_s)
+    
+    nodes.map do |node|
+      parser.new(self, node)
     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
+  def get_has_one_association(name)
+    return nil unless xml
+    association = self.class.properties[name]
+    
+    node = xml.xpath("./#{association[:path]}").first
+    parser = FeedMe.const_get(association[:use].to_s)
+    
+    parser.new(self, node)
   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) })
+  def get_property(name)
+    return nil unless xml
+    property = self.class.properties[name]
+
+    values = xml.xpath("./#{property[:path]}").map do |node|
+      result = extract_result(node, property[:from])
+      cast_result(result, property[:as])
+    end
+    
+    case property[:cardinality]
+    when :many
+      return values
     else
-      return proc { nil }
+      return values.first
     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
+  def extract_result(node, from)
+    if from
+      node[from]
+    else
+      node.inner_html
     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?
+  def cast_result(result, as)
+    if as == :time
+      Time.parse(result)
     else
-      item.map { |i| self.try("extract_inner_html", i) }
+      result
     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/feed_parser.rb

@@ -2,10 +2,22 @@ module FeedMe
 
   class FeedParser < AbstractParser
 
-    self.properties = FEED_PROPERTIES
-
     class << self
 
+      def root_node(node=nil)
+        @root_node = node if node
+        @root_node
+      end
+
+      def parsers
+        @parsers ||= []
+      end
+
+      def inherited(subclass)
+        super
+        parsers << subclass
+      end
+
       def open(file)
         self.parse(Kernel.open(file).read)
       end
@@ -13,47 +25,60 @@ module FeedMe
       # 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
+        document = Nokogiri::XML(feed)
+        if root = document.root 
+          root.add_namespace_definition('atom', 'http://www.w3.org/2005/Atom')
+          parsers.each do |parser|
+            node = root.xpath(parser.root_node).first
+            if node
+              return parser.new(node, document.encoding)
+            end
+          end
         end
+        # if we cannot find a parser, raise an error.
+        raise InvalidFeedFormat
       end
 
+    end # class << self
+
+    def initialize(xml, encoding)
+      @xml = xml
+      @encoding = encoding
     end
+
+    attr_reader :encoding
+
   end
 
   class AtomFeedParser < FeedParser
-    self.properties = FEED_PROPERTIES
+    root_node "//atom:feed"
 
-    def entries
-      xml.search('entry').map do |el|
-        ItemParser.build(el, self.format, self)
-      end
-    end
+    property :title, :path => 'atom:title'
+    property :feed_id, :path => 'atom:id'
+    property :description, :path => 'atom:subtitle'
+    property :generator, :path => 'atom:generator'
+    property :updated_at, :path => 'atom:updated', :as => :time
+    property :url, :path => "atom:link[@rel='alternate']", :from => :href
+    property :href, :path => "atom:link[@rel='self']", :from => :href
+
+    has_many :entries, :path => 'atom:entry', :use => :AtomItemParser
+
+    has_one :author, :path => 'atom:author', :use => :AtomPersonParser
   end
 
   class Rss2FeedParser < FeedParser
-    self.properties = FEED_PROPERTIES
+    root_node "//rss[@version='2.0']/channel"
 
-    def entries
-      xml.search('item').map do |el|
-        ItemParser.build(el, self.format, self)
-      end
-    end
+    property :title
+    property :updated_at, :path => :lastBuildDate, :as => :time
+    property :feed_id, :path => :undefined
+    property :url, :path => :link
+    property :href, :path => :undefined
+    property :description
+    property :generator
 
-    def author
-      fetch_rss_person("managingEditor")
-    end
+    has_many :entries, :path => 'item', :use => :Rss2ItemParser
+
+    has_one :author, :path => 'managingEditor', :use => :Rss2PersonParser
   end
 end

data/lib/feed_me/item_parser.rb

@@ -1,25 +1,25 @@
 module FeedMe
 
-  class ItemParser < AbstractParser
+  class ItemParser < AbstractParser; end
 
-    self.properties = ITEM_PROPERTIES
-
-    attr_accessor :feed
-
-    def initialize(xml, format, feed)
-      super(xml, format)
-      self.feed = feed
-    end
+  class AtomItemParser < ItemParser
+    property :title, :path => 'atom:title'
+    property :updated_at, :path => "atom:updated", :as => :time
+    property :item_id, :path => "atom:id"
+    property :url, :path => "atom:link[@rel='alternate']", :from => :href
+    property :content, :path => 'atom:content'
 
+    has_one :author, :path => 'atom:author', :use => :AtomPersonParser
   end
 
   class Rss2ItemParser < ItemParser
-
-    self.properties = ITEM_PROPERTIES
-
-    def author
-      fetch_rss_person("author")
-    end
-
+    property :title
+    property :updated_at, :path => :pubDate, :as => :time
+    property :item_id, :path => :guid
+    property :url, :path => :link
+    property :content, :path => :description
+    property :categories, :path => :category, :cardinality => :many
+
+    has_one :author, :use => :Rss2PersonParser
   end
-end
+end

data/lib/feed_me/person_parser.rb

@@ -0,0 +1,23 @@
+module FeedMe
+
+  class PersonParser < AbstractParser; end
+
+  class AtomPersonParser < PersonParser
+    property :email, :path => 'atom:email'
+    property :name, :path => 'atom:name'
+    property :uri, :path => 'atom:uri'
+  end
+
+  class Rss2PersonParser < PersonParser
+    attr_reader :uri
+
+    def email
+      xml.inner_html.split(/\s+/, 2)[0] if xml
+    end
+
+    def name
+      xml.inner_html.split(/\s+/, 2)[1].to_s[/\((.*?)\)/, 1] if xml
+    end
+  end
+
+end

data/spec/feed_parser_spec.rb

@@ -5,24 +5,32 @@ 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
+
+  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 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)
+    @atom = FeedMe::FeedParser.parse(open(fixture('welformed.atom')).read)
+    @rss2 = FeedMe::FeedParser.parse(open(fixture('welformed.rss2')).read)
   end
 
   it "should be an atom parser for an atom feed" do
@@ -36,19 +44,6 @@ describe FeedMe::FeedParser do
     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
@@ -60,6 +55,16 @@ describe FeedMe::FeedParser do
     it_should_behave_like "all parsing methods"
   end
 
+  describe '#encoding' do
+    it "should return the encoding for an atom feed" do
+      @atom.encoding.should == 'UTF-8'
+    end
+
+    it "should return the encoding for an atom feed" do
+      @rss2.encoding.should == 'iso-8859-1'
+    end
+  end
+
   describe '#title' do
     it "should be valid for an atom feed" do
       @atom.title.should == "Test feed"
@@ -130,16 +135,6 @@ describe FeedMe::FeedParser do
     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"

data/spec/item_parser_spec.rb

@@ -6,9 +6,9 @@ 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)
+    @atom = @atom_feed.entries.first
     @rss2_feed = FeedMe::FeedParser.open(fixture('welformed.rss2'))
-    @rss2 = FeedMe::ItemParser.build(@rss2_feed.root_node.search('/item').first, :rss2, @rss2_feed)
+    @rss2 = @rss2_feed.entries.first
   end
 
   describe '#to_hash' do
@@ -67,16 +67,6 @@ describe FeedMe::ItemParser do
     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']
@@ -170,9 +160,9 @@ 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)
+    @atom = @atom_feed.entries[1]
     @rss2_feed = FeedMe::FeedParser.open(fixture('welformed.rss2'))
-    @rss2 = FeedMe::ItemParser.build(@rss2_feed.root_node.search('/item')[1], :rss2, @rss2_feed)
+    @rss2 = @rss2_feed.entries[1]
   end
 
   describe '#author.name' do

data/spec/spec_helper.rb

@@ -2,7 +2,9 @@ $TESTING=true
 $:.push File.join(File.dirname(__FILE__), '..', 'lib')
 
 require 'rubygems'
-# require 'ruby-debug'
+require 'ruby-debug'
+require 'spec'
+require 'spec/autorun'
 
 module Fixtures
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: feed_me
 version: !ruby/object:Gem::Version 
-  version: 0.0.5
+  version: 0.6.0
 platform: ruby
 authors: 
 - Jonas Nicklas
@@ -10,7 +10,7 @@ autorequire: feed_me
 bindir: bin
 cert_chain: []
 
-date: 2009-11-06 00:00:00 +00:00
+date: 2010-01-18 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -40,12 +40,9 @@ files:
 - 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
+- lib/feed_me/person_parser.rb
 has_rdoc: true
 homepage: http://github.com/jnicklas/feed_me
 licenses: []
@@ -77,5 +74,4 @@ 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

data/lib/feed_me/consts.rb

@@ -1,69 +0,0 @@
-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_struct.rb

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

data/lib/feed_me/merbtasks.rb

@@ -1,6 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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/simple_struct_spec.rb

@@ -1,14 +0,0 @@
-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