rfeedfinder 0.9.12 → 0.9.13

data/History.txt

@@ -1,3 +1,7 @@
+== 0.9.13 2008-10-11
+
+* Correct getLinks method, thanks kdoya
+
 == 0.9.12 2008-03-04
 
 * Correct nytimes.com bug, thanks Sebastian

data/lib/rfeedfinder.rb

@@ -1,140 +1,102 @@
 require 'net/http'
 require 'rubygems'
-require 'htmlentities'
 require 'open-uri'
 require 'hpricot'
 require 'timeout'
 
-require 'rfeedfinder/version'
+require File.dirname(__FILE__) + "/rfeedfinder/version"
 
-module Rfeedfinder
 
-  module_function
-  
-  def makeFullURI(uri)
-    uri = uri.strip.sub(/^feed(.*)/, 'http\1').downcase
-    if /^http|https/.match(uri)
-      return uri
-    else
-      return "http://" << uri
-    end
-  end
-
-  def getLinks(data, baseuri)
-    return searchLinks(data, baseuri, "[@rel=alternate]&[@type=xml]&[@href=http]")
-  end
-
-  def getALinks(data, baseuri)
-    return searchLinks(data, baseuri, "a")
-  end
-  
-  def getFrameLinks(data, baseuri)
-    links = searchLinks(data, baseuri, "frame")
-    links += searchLinks(data, baseuri, "FRAME")
-    return links
-  end
-  
-  def searchLinks(data, baseuri, regexp)
-    links = []
-    data.search(regexp).map!{|link| 
-      if !link.to_s.strip.empty? and link.kind_of? Hpricot::Elem and !(link.kind_of? Hpricot::Text)
-        uri = link[:href].to_s
-        uri = link[:HREF].to_s if uri.empty?
-        uri = link[:src].to_s if uri.empty?
-        uri = link[:SRC].to_s if uri.empty?
-        if !uri.strip.empty? and uri !~ /^javascript/
-          uri = URI.join(baseuri, uri).to_s if uri !~ /^http:\/\//
-          links << uri 
-        end
-      end
-    }
-    #links.each{|link| puts "searchLinks: #{link}"}
-    return links.uniq
-  end
-
-  def getLocalLinks(links, baseuri)
-    locallinks = []
-    links.each do |link|
-      locallinks << URI.join(baseuri, link).to_s if link =~ /^\//
-    end
-    links = links.select{|link| link !~ /^\//} #remove local links from link array
-    return [links, locallinks]
+class Rfeedfinder
+  # 
+  # Takes:
+  # * +init_values+ (hash) 
+  #   * +:proxy+: (string) proxy information to use. Defaults to a blank string
+  #   * +:user_agent+: (string) user agent to identify as. Defaults to Ruby/#{RUBY_VERSION} - Rfeedfinder VERSION
+  #   * +:from+: (string) contact info to the responsible person. FIXME: Is this correct? Defaults to rfeedfinder@googlegroups.com
+  #   * +:keep_data+: (boolean) if the data downloaded for the feeds should be returned along with the URLs. Defaults to false
+  #   * +:use_google+: (boolean) tries to find a URL using a google "I'm feeling lucky" search. Defaults to false
+  # 
+  #   
+  #   Example:
+  #   
+  #   Rfeedfinder.new({:proxy => "http://127.0.0.1:1234",
+  #                    :user_agent => "MyApp",
+  #                    :from => "contant@domain.com",
+  #                    :referer => "http://domain.com"})
+  #                    
+  #     
+  # Returns a new instance of Rfeedfinder 
+  # 
+  def initialize(init_values = {})
+    @options = init_values
   end
 
-  def isFeedLink?(link)
-    return link.downcase =~ /\.rss$|\.rdf$|\.xml$|\.atom$/
-  end
-
-  def isXMLRelatedLink?(link)
-    return link.downcase =~ /rss|rdf|xml|atom/
+  # 
+  # Takes:
+  # * +uri+ (string)
+  # 
+  # Returns:
+  # * array of urls
+  # 
+  def feeds(uri)
+    Rfeedfinder.feeds(uri, @options.dup)
   end
 
-  def tryBrokenRedirect(data)
-    newuris = (data/:newLocation)
-    if !newuris.empty?
-      return newuris[0].strip
-    end
-  end
-  
-  def verifyRedirect(feedlist)
-    feedlist.each do |feed|
-      begin
-       response = Net::HTTP.get_response(URI.parse(feed))
-       #puts "Verify #{feed} - code: #{response.code}"
-       if response.code == "302"
-         newuri = response.body.match(/<a href=\"([^>]+)\">/)[1]
-         
-         feedlist.delete(feed)
-         feedlist << newuri
-         feedlist.uniq!
-       end
-     rescue
-       # rescue net error
-     end
-    end
-    return feedlist
-  end
-
-  def isFeedData?(data)
-    # if no html tag and rss, rdf or feed tag, it's a feed
-    return ((data/"html|HTML").empty? and (!(data/:rss).nil? or !(data/:rdf).nil? or !(data/:feed).nil?))
+  # 
+  # Takes:
+  # * +uri+ (string)
+  # 
+  # Returns:
+  # * url (string)
+  # 
+  def feed(uri)
+    result = Rfeedfinder.feed(uri, @options.dup)
   end
 
-  def isFeed?(uri)
-    uri.gsub!(/\/\/www\d\./, "//www.")
-    begin
-      protocol = URI.split(uri)
-      return false if !protocol[0].index(/^[http|https]/)
-    rescue
-      # URI error
-      return false
-    end
+  # 
+  # Takes:
+  # * +uri+ (string): The URI to check
+  # * +options+ (hash) 
+  #   * +:proxy+: (string) proxy information to use. Defaults to a blank string
+  #   * +:user_agent+: (string) user agent to identify as. Defaults to Ruby/#{RUBY_VERSION} - Rfeedfinder VERSION
+  #   * +:from+: (string) contact info to the responsible person. FIXME: Is this correct? Defaults to rfeedfinder@googlegroups.com
+  #   * +:keep_data+: (boolean) if the data downloaded for the feeds should be returned along with the URLs. Defaults to false
+  #   * +:use_google+: (boolean) tries to find a URL using a google "I'm feeling lucky" search. Defaults to false
+  # 
+  #   
+  #   Example:
+  #   
+  #   Rfeedfinder.feeds("www.google.com", {:proxy => "http://127.0.0.1:1234",
+  #                    :user_agent => "MyApp",
+  #                    :from => "contant@domain.com",
+  #                    :referer => "http://domain.com"})
+  #                    
+  #     
+  # Returns:
+  # * array of urls
+  # * array of hashes if the :keep_data option is true
+  #   Example:
+  #   [{:url => "url1", :data => "some data"},{:url => "url2", :data => "feed data"}]
+  # 
+  # Raises:
+  # * ArgumentError if +uri+ is not a valid URL, and :use_google => false
+  # * ArgumentError if :use_google => true but it's not your lucky day
+  # 
+  def self.feeds(uri, options = {})
     
-    data = open_doc(uri)
-    return false if data.nil?
+    # We have to create a hash for the data
+    # if the user has asked us to keep the data
+    options[:data] = {} if options[:keep_data]  
+
+    options[:original_uri] = uri if !Rfeedfinder.isAValidURL?(uri) and options[:use_google]
     
-    return isFeedData?(data)
-  end
+    uri = URI.decode(uri)
+    options[:recurs] = [uri] if options[:recurs].nil?
+    fulluri = Rfeedfinder.makeFullURI(uri)
 
-  def getFeedsFromSyndic8(uri)
-    feeds = []
-    begin
-      server = Syndic8.new
-      feedids = server.find_feeds(uri)
-      infolist = server.feed_info(feedids, ['headlines_rank','status','dataurl'])
-      infolist.sort_by{|feedInfo| feedInfo[:headlines_rank]}
-      infolist.each do |feed|
-        feeds << feed[:dataurl] if feed[:status]=='Syndicated'
-      end
-    rescue
-    end
-    return feeds
-  end
-  
-  def feeds(uri, all=false, querySyndic8=false, _recurs=nil)
-    uri = HTMLEntities.decode_entities(uri)
-    _recurs = [uri] if _recurs.nil?
-    fulluri = makeFullURI(uri)
+    raise ArgumentError, "#{fulluri} is not a valid URI." \
+      if !Rfeedfinder.isAValidURL?(fulluri) and !options[:use_google]
     
     # Add youtube support
     if fulluri =~ /youtube\.com\/user\/(.*[^\/])/
@@ -143,70 +105,77 @@ module Rfeedfinder
     if fulluri =~ /youtube\.com\/tag\/(.*[^\/])/
       fulluri = "http://www.youtube.com/rss/tag/#{$1}/videos.rss"
     end
-    
-    data = open_doc(fulluri)
+        
+    data = Rfeedfinder.open_doc(fulluri, options)
     return [] if data.nil?
 
+    # If we used the google link finder, then we should set the new URL
+    fulluri = options[:google_link] if options[:google_link]
+  
     # is this already a feed?
-    if isFeedData?(data)
+    if Rfeedfinder.isFeedData?(data)
       feedlist = [fulluri]
-      verifyRedirect(feedlist)
+      Rfeedfinder.verifyRedirect(feedlist)
       return feedlist
     end
     
     #verify redirection
-    newuri = tryBrokenRedirect(data)
+    newuri = Rfeedfinder.tryBrokenRedirect(data)
     if !newuri.nil? and !newuri.empty?
-      unless _recurs.include?(newuri)
-        _recurs << newuri
-        return feeds(newuri, all=all, querySyndic8=querySyndic8, _recurs=_recurs)
+      options[:recurs] = [] unless options[:recurs]
+      unless options[:recurs].include?(newuri)
+        options[:recurs] << newuri
+        return feeds(newuri, options)
       end
     end
      
     #verify frameset
-    frames = getFrameLinks(data, fulluri)
+    frames = Rfeedfinder.getFrameLinks(data, fulluri)
     frames.each {|newuri|
       if !newuri.nil? and !newuri.empty?
-        unless _recurs.include?(newuri)
-          _recurs << newuri
-          return feeds(newuri, all=all, querySyndic8=querySyndic8, _recurs=_recurs)
+        options[:recurs] = [] unless options[:recurs]
+        unless options[:recurs].include?(newuri)
+          options[:recurs] << newuri
+          return feeds(newuri, options)
         end
       end
     }
-
-    # nope, it's a page, try LINK tags first
-    outfeeds = getLinks(data, fulluri)
-    outfeeds.select {|link| isFeed?(link)}
     
+    # nope, it's a page, try LINK tags first
+    outfeeds = Rfeedfinder.getLinks(data, fulluri).select {|link| Rfeedfinder.isFeed?(link, options)}
+      
     #_debuglog('found %s feeds through LINK tags' % len(outfeeds))
     if outfeeds.empty?
       # no LINK tags, look for regular <A> links that point to feeds
       begin
-        links = getALinks(data, fulluri)
+        links = Rfeedfinder.getALinks(data, fulluri)
       rescue
         links = []
       end
       
       # Get local links
-      links, locallinks = getLocalLinks(links, fulluri)
+      links, locallinks = Rfeedfinder.getLocalLinks(links, fulluri)
+
+      # TODO:
+      # implement support for :only_first down her
 
       # look for obvious feed links on the same server
-      selected_feeds = locallinks.select{|link| isFeedLink?(link) and isFeed?(link)}
+      selected_feeds = locallinks.select{|link| Rfeedfinder.isFeedLink?(link) and Rfeedfinder.isFeed?(link, options)}
       outfeeds << selected_feeds unless selected_feeds.empty?
       # outfeeds.each{|link| puts "1 #{link}"}
       
       # look harder for feed links on the same server
-      selected_feeds = locallinks.select{|link| isXMLRelatedLink?(link) and isFeed?(link)} if outfeeds.empty?
+      selected_feeds = locallinks.select{|link| Rfeedfinder.isXMLRelatedLink?(link) and Rfeedfinder.isFeed?(link, options)} if outfeeds.empty?
       outfeeds << selected_feeds unless selected_feeds.empty?
       # outfeeds.each{|link| puts "2 #{link}"}
 
       # look for obvious feed links on another server
-      selected_feeds = links.select {|link| isFeedLink?(link) and isFeed?(link)} if outfeeds.empty?
+      selected_feeds = links.select {|link| Rfeedfinder.isFeedLink?(link) and Rfeedfinder.isFeed?(link, options)} if outfeeds.empty?
       outfeeds << selected_feeds unless selected_feeds.empty?
       # outfeeds.each{|link| puts "3 #{link}"}
 
       # look harder for feed links on another server
-      selected_feeds = links.select {|link| isXMLRelatedLink?(link) and isFeed?(link)} if outfeeds.empty?
+      selected_feeds = links.select {|link| Rfeedfinder.isXMLRelatedLink?(link) and Rfeedfinder.isFeed?(link, options)} if outfeeds.empty?
       outfeeds << selected_feeds unless selected_feeds.empty?
       # outfeeds.each{|link| puts "4 #{link}"}
     end
@@ -226,63 +195,300 @@ module Rfeedfinder
         
       guesses.each { |guess|  
         uri = URI.join(fulluri, guess).to_s
-        outfeeds << uri if isFeed?(uri)
+        outfeeds << uri if Rfeedfinder.isFeed?(uri, options)
       }
     end
     
     # try with adding ending slash
     if outfeeds.empty? and fulluri !~ /\/$/
-      outfeeds = feeds(fulluri + "/", all=all, querySyndic8=querySyndic8, _recurs=_recurs)
+      outfeeds = Rfeedfinder.feeds(fulluri + "/", options)
     end
-    
-    # still no luck, search Syndic8 for feeds (requires xmlrpclib)
-    #_debuglog('still no luck, searching Syndic8')
-    outfeeds << getFeedsFromSyndic8(uri) if querySyndic8 and outfeeds.empty?
-    #outfeeds = list(set(outfeeds)) if hasattr(__builtins__, 'set') or __builtins__.has_key('set')
-    
+        
     # Verify redirection
-    verifyRedirect(outfeeds)
+    Rfeedfinder.verifyRedirect(outfeeds)
+    
+    # This has to be used until proper :only_first support has been built in
+    outfeeds = outfeeds.first if options[:only_first] and outfeeds.size > 1
     
-    return outfeeds.flatten
+    if options[:keep_data]
+      output = []
+      outfeeds.each do |feed|
+        output << {:url => feed, :data => options[:data][feed]}
+      end
+      return output
+    else
+      return outfeeds
+    end
   end
 
-  def feed(uri)
-    #todo: give preference to certain feed formats
-    feedlist = feeds(uri)
+
+  # 
+  # Takes:
+  # * +uri+ (string): The URI to check
+  # * +options+ (hash) 
+  #   * +:proxy+: (string) proxy information to use. Defaults to a blank string
+  #   * +:user_agent+: (string) user agent to identify as. Defaults to Ruby/#{RUBY_VERSION} - Rfeedfinder VERSION
+  #   * +:from+: (string) contact info to the responsible person. FIXME: Is this correct? Defaults to rfeedfinder@googlegroups.com
+  #   * +:keep_data+: (boolean) if the data downloaded for the feeds should be returned along with the URLs. Defaults to false
+  #   * +:use_google+: (boolean) tries to find a URL using a google "I'm feeling lucky" search. Defaults to false
+  # 
+  #   
+  #   Example:
+  #   
+  #   Rfeedfinder.feeds("www.google.com", {:proxy => "http://127.0.0.1:1234",
+  #                    :user_agent => "MyApp",
+  #                    :from => "contant@domain.com",
+  #                    :referer => "http://domain.com"})
+  #                    
+  #     
+  # Returns:
+  # * one URL as a string or nil
+  # * one hash if the :keep_data option is true
+  #   Example:
+  #   {:url => "url1", :data => "some data"}
+  # 
+  # Raises:
+  # * ArgumentError if +uri+ is not a valid URL, and :use_google => false
+  # * ArgumentError if :use_google => true but it's not your lucky day
+  #     
+  def self.feed(uri, options = {})
+    options[:only_first] = true
+    feedlist = Rfeedfinder.feeds(uri, options)
     unless feedlist.empty?
       return feedlist[0]
     else
       return nil
     end
   end
+
+  # 
+  # Takes:
+  # * +data+ (string)
+  # 
+  # Returns:
+  # * +true+ if the data has a rss, rdf or feed tag
+  # * +false+ if the data has a html tag
+  # 
+  def self.isFeedData?(data)
+    # if no html tag and rss, rdf or feed tag, it's a feed
+    # puts data
+    return ((data/"html|HTML").empty? and (!(data/:rss).nil? or !(data/:rdf).nil? or !(data/:feed).nil?))
+  end
+
+  # 
+  # Takes:
+  # * +uri+ (string)
+  # 
+  # Downloads the URI and checkes the content
+  # with the +isFeedData?+ class method
+  # 
+  # Returns:
+  # * +true+ if the uri points to a feed
+  # * +false+ if not
+  # 
+  def self.isFeed?(uri, options)
+    # We return false if the user only wants one result
+    # and we already have found it so there aren't made
+    # any additional external calls
+    return false if options[:only_first] and options[:already_found_one]
+    
+    uri.gsub!(/\/\/www\d\./, "//www.")
+    begin
+      protocol = URI.split(uri)
+      return false if !protocol[0].index(/^[http|https]/)
+    rescue
+      # URI error
+      return false
+    end
+    
+    data = Rfeedfinder.open_doc(uri, options)
+    return false if data.nil?
+    
+    if Rfeedfinder.isFeedData?(data)
+      options[:already_found_one] = true if options[:only_first]
+      return true
+    else
+      return false
+    end
+  end
+
+  protected
+  def self.makeFullURI(uri)
+    uri = uri.strip.sub(/^feed(.*)/, 'http\1').downcase
+    if /^http|https/.match(uri)
+      return uri
+    else
+      return "http://" << uri
+    end
+  end
+
+  def self.getLinks(data, baseuri)
+    return Rfeedfinder.searchLinks(data, baseuri, "[@rel='alternate'][@type*='xml'][@href*='http']")
+  end
+
+  def self.getALinks(data, baseuri)
+    return Rfeedfinder.searchLinks(data, baseuri, "a")
+  end
+  
+  def self.getFrameLinks(data, baseuri)
+    links = Rfeedfinder.searchLinks(data, baseuri, "frame")
+    links += Rfeedfinder.searchLinks(data, baseuri, "FRAME")
+    return links
+  end
   
-  def open_doc(link)
+  def self.searchLinks(data, baseuri, regexp)
+    links = []
+    data.search(regexp).map!{|link| 
+      if !link.to_s.strip.empty? and link.kind_of? Hpricot::Elem and !(link.kind_of? Hpricot::Text)
+        uri = link[:href].to_s
+        uri = link[:HREF].to_s if uri.empty?
+        uri = link[:src].to_s if uri.empty?
+        uri = link[:SRC].to_s if uri.empty?
+        if !uri.strip.empty? and uri !~ /^javascript/
+          uri = URI.join(baseuri, uri).to_s if uri !~ /^http:\/\//
+          links << uri 
+        end
+      end
+    }
+    #links.each{|link| puts "Rfeedfinder.searchLinks: #{link}"}
+    return links.uniq
+  end
+
+  def self.getLocalLinks(links, baseuri)
+    locallinks = []
+    links.each do |link|
+      locallinks << URI.join(baseuri, link).to_s if link =~ /^\//
+    end
+    links = links.select{|link| link !~ /^\//} #remove local links from link array
+    return [links, locallinks]
+  end
+
+  def self.isFeedLink?(link)
+    return link.downcase =~ /\.rss$|\.rdf$|\.xml$|\.atom$/
+  end
+
+  def self.isXMLRelatedLink?(link)
+    return link.downcase =~ /rss|rdf|xml|atom/
+  end
+
+  def self.tryBrokenRedirect(data)
+    newuris = (data/:newLocation)
+    if !newuris.empty?
+      return newuris[0].strip
+    end
+  end
+  
+  def self.verifyRedirect(feedlist)
+    feedlist.each do |feed|
+      begin
+       response = Net::HTTP.get_response(URI.parse(feed))
+       #puts "Verify #{feed} - code: #{response.code}"
+       if response.code == "302"
+         newuri = response.body.match(/<a href=\"([^>]+)\">/)[1]
+         
+         feedlist.delete(feed)
+         feedlist << newuri
+         feedlist.uniq!
+       end
+     rescue
+       # rescue net error
+     end
+    end
+    return feedlist
+  end
+  
+  def self.open_doc(link, options)
+
+    # Setting default values for missing options
+    options[:proxy] = URI.parse(options[:proxy]) if options[:proxy]  
+    options[:user_agent] = options[:user_agent] || "Ruby/#{RUBY_VERSION} - " + \
+      "Rfeedfinder #{Rfeedfinder::VERSION::STRING}"
+    options[:from] = options[:from] || "rfeedfinder@googlegroups.com"
+    options[:referer] = options[:referer] || "http://rfeedfinder.rubyforge.org/"
+      
     data = nil
+    
+    if !Rfeedfinder.isAValidURL?(link) and options[:use_google]
+      # Used google lucky script as found on 
+      # http://www.leancrew.com/all-this/2006/07/lucky-linking/
+      # It doesn't work to well...
+      # TODO: Improve it somehow. The real google function works a lot better!
+      # TODO: Build in support for languages through parameter "hl" (=> "en" by default)
+      prefix = "http://www.google.com/search?q="
+      suffix = "&btnI=I'm+Feeling+Lucky"
+      goodURL = URI.escape(prefix + options[:original_uri] + suffix)
+      puts "Checking #{goodURL}"
+      response = Net::HTTP.get_response(URI.parse(goodURL))
+      link = response.to_hash['location'].first
+      options[:google_link] = link
+      raise ArgumentError, "Google couldn't save us. We couldn't find anything for #{options[:original_uri]}" if link.nil?
+    end
+    
     begin
-      Timeout::timeout(20) {
-        data = Hpricot(open(link,
-               "User-Agent" => "Ruby/#{RUBY_VERSION} - Rfeedfinder",
-               "From" => "rfeedfinder@googlegroups.com",
-               "Referer" => "http://rfeedfinder.rubyforge.org/"), :xml => true)
-      }
+      
+      Timeout::timeout(20) do
+      
+        data = Hpricot(open(link, {
+               "User-Agent" => options[:user_agent],
+               "From" => options[:from],
+               "Referer" => options[:referer],
+               :proxy => options[:proxy]
+               }), :xml => true)
+      
+      end
+
     rescue OpenURI::HTTPError
+
       begin
-        Timeout::timeout(20) {
+
+        Timeout::timeout(20) do
+          
           html = Net::HTTP.get(URI.parse(link))
           data = Hpricot(html, :xml => true) if html.to_s !~ /404 Not Found/
-        }
+
+        end
+
       rescue Timeout::Error
         return nil
+
       rescue => err
         puts "Error while opening #{link} with Hpricot: #{err.class} " << $!
         return nil
+
       end
+
     rescue Timeout::Error 
       return nil
+
     rescue => err
       puts "Error while opening #{link} with Hpricot: #{err.class} " << $!
       return nil
+
     end
+    
+    # Store the data for the URL if the user has requested it
+    options[:data][link] = data.to_original_html if options[:keep_data]
+    
     return data
   end
+
+  def self.isAValidURL?(url_to_check)
+    return false if url_to_check == nil
+
+    # The protocols that we allow are the following
+    protocol_whitelist = ["http", "https"]
+    # I guess we could have included some more, but that doesn't really
+    # make sense anyway as these are the ones that should be used.
+    # We'll see if the need arises and then add more later if needed.
+
+    re = Regexp.new("(#{protocol_whitelist.join('|')}):" + \
+      "\/\/([[:alpha:][:digit:].]{2,})([.]{1})([[:alpha:]]{2,4})(\/)")
+
+    # For the sake of the regular expression check we add a back slash
+    # at the end of the URL
+    url_to_check += "/"
+    return true unless (re =~ url_to_check) == nil
+    false
+  end
+
 end

data/lib/rfeedfinder/version.rb

@@ -1,9 +1,9 @@
-module Rfeedfinder #:nodoc:
+class Rfeedfinder #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 9
-    TINY  = 12
+    TINY  = 13
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end
-end
+end

data/test/test_rfeedfinder.rb

@@ -6,12 +6,12 @@ class TestRfeedfinder < Test::Unit::TestCase
   end
   
   def test_feed
-    feed_finder "scripting.com",
+    feed_finder "http://scripting.com",
                "http://www.scripting.com/rss.xml"
   end
   
   def test_feeds
-    feeds = Rfeedfinder.feeds("flickr.com/photos/alx")
+    feeds = Rfeedfinder.feeds("http://flickr.com/photos/alx")
     assert_equal 2, feeds.size 
   end
   
@@ -143,6 +143,6 @@ class TestRfeedfinder < Test::Unit::TestCase
   end
   
   def test_nytimes
-    feed_finder "http://www.nytimes.com/"
+    feed_finder "http://www.nytimes.com/services/xml/rss/nyt/HomePage.xml"
   end
 end

metadata

@@ -1,33 +1,59 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.4
-specification_version: 1
 name: rfeedfinder
 version: !ruby/object:Gem::Version 
-  version: 0.9.12
-date: 2008-04-03 00:00:00 +02:00
-summary: rFeedFinder uses RSS autodiscovery, Atom autodiscovery, spidering, URL correction, and Web service queries -- whatever it takes -- to find the feed.
-require_paths: 
-- lib
-email: alx.girard@gmail.com
-homepage: http://rfeedfinder.rubyforge.org
-rubyforge_project: rfeedfinder
-description: rFeedFinder uses RSS autodiscovery, Atom autodiscovery, spidering, URL correction, and Web service queries -- whatever it takes -- to find the feed.
-autorequire: 
-default_executable: 
-bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
+  version: 0.9.13
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - Alexandre Girard
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-10-11 00:00:00 +02: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.6"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: htmlentities
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 4.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.7.0
+    version: 
+description: rFeedFinder uses RSS autodiscovery, Atom autodiscovery, spidering, URL correction, and Web service queries -- whatever it takes -- to find the feed.
+email: alx.girard@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- License.txt
+- Manifest.txt
+- README.txt
+- website/index.txt
 files: 
 - History.txt
 - License.txt
@@ -45,40 +71,33 @@ files:
 - website/javascripts/rounded_corners_lite.inc.js
 - website/stylesheets/screen.css
 - website/template.rhtml
-test_files: 
-- test/test_helper.rb
-- test/test_rfeedfinder.rb
+has_rdoc: true
+homepage: http://rfeedfinder.rubyforge.org
+post_install_message: 
 rdoc_options: 
 - --main
 - README.txt
-extra_rdoc_files: 
-- History.txt
-- License.txt
-- Manifest.txt
-- README.txt
-- website/index.txt
-executables: []
-
-extensions: []
-
+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: []
 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: hpricot
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Version::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0.6"
-    version: 
-- !ruby/object:Gem::Dependency 
-  name: htmlentities
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Version::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 4.0.0
-    version: 
+rubyforge_project: rfeedfinder
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: rFeedFinder uses RSS autodiscovery, Atom autodiscovery, spidering, URL correction, and Web service queries -- whatever it takes -- to find the feed.
+test_files: 
+- test/test_helper.rb
+- test/test_rfeedfinder.rb