feedtools 0.2.23 → 0.2.24

data/CHANGELOG

@@ -1,3 +1,16 @@
+== FeedTools 0.2.24
+ * fixed autodiscovery bugs
+ * updated autodiscovery to handle relative uris
+ * added per feed configuration
+ * rewrote http retrieval code
+ * supports authenticated http proxies
+ * supports basic http auth
+ * fixed relative url resolution issues
+ * corrected db schema files to match migration file
+ * fixed bug in the save method
+ * fixed some major http bugs
+ * updated dependancies
+ * no longer causes problems with frozen rails
 == FeedTools 0.2.23
  * autodiscovery implemented
  * now knows a title from a hole in the ground

data/db/schema.mysql.sql

@@ -1,5 +1,5 @@
 -- Example MySQL schema
-  CREATE TABLE `feeds` (
+  CREATE TABLE `cached_feeds` (
     `id`              int(10) unsigned NOT NULL auto_increment,
     `href`            varchar(255) default NULL,
     `title`           varchar(255) default NULL,

data/db/schema.postgresql.sql

@@ -1,5 +1,5 @@
 -- Example PostgreSQL schema
-  CREATE TABLE feeds (
+  CREATE TABLE cached_feeds (
     id                SERIAL PRIMARY KEY NOT NULL,
     href              varchar(255) default NULL,
     title             varchar(255) default NULL,

data/db/schema.sqlite.sql

@@ -1,5 +1,5 @@
 -- Example Sqlite schema
-  CREATE TABLE feeds (
+  CREATE TABLE cached_feeds (
     id                INTEGER PRIMARY KEY NOT NULL,
     href              VARCHAR(255) DEFAULT NULL,
     title             VARCHAR(255) DEFAULT NULL,

data/lib/feed_tools.rb

@@ -21,7 +21,7 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
-if Object.const_defined?(:FEED_TOOLS_ENV)
+if Object.const_defined?(:FEED_TOOLS_NAMESPACES)
   warn("FeedTools may have been loaded improperly.  This may be caused " +
     "by the presence of the RUBYOPT environment variable or by using " +
     "load instead of require.  This can also be caused by missing " +
@@ -32,8 +32,6 @@ FEED_TOOLS_ENV = ENV['FEED_TOOLS_ENV'] ||
                  ENV['RAILS_ENV'] ||
                  'development' # :nodoc:
 
-FEED_TOOLS_VERSION = "0.2.23"
-
 FEED_TOOLS_NAMESPACES = {
   "admin" => "http://webns.net/mvcb/",
   "ag" => "http://purl.org/rss/1.0/modules/aggregation/",
@@ -58,6 +56,7 @@ FEED_TOOLS_NAMESPACES = {
   "image" => "http://purl.org/rss/1.0/modules/image/",
   "feedburner" => "http://rssnamespace.org/feedburner/ext/1.0",
   "foaf" => "http://xmlns.com/foaf/0.1/",
+  "foo" => "http://hsivonen.iki.fi/FooML",
   "fm" => "http://freshmeat.net/rss/fm/",
   "itunes" => "http://www.itunes.com/dtds/podcast-1.0.dtd",
   "l" => "http://purl.org/rss/1.0/modules/link/",
@@ -94,6 +93,8 @@ $:.unshift(File.dirname(__FILE__))
 $:.unshift(File.dirname(__FILE__) + "/feed_tools/vendor")
 
 begin
+  require 'feed_tools/version'
+
   begin
     require 'iconv'
   rescue Object
@@ -133,8 +134,12 @@ begin
   require 'yaml'
   require 'base64'
 
-  require_gem('activesupport', '>= 1.1.1')
-  require_gem('activerecord', '>= 1.11.1')
+  if !defined?(ActiveSupport)
+    require_gem('activesupport', '>= 1.1.1')
+  end
+  if !defined?(ActiveRecord)
+    require_gem('activerecord', '>= 1.11.1')
+  end
 
   begin
     require_gem('uuidtools', '>= 0.1.2')
@@ -186,13 +191,19 @@ module FeedTools
       config_hash = {}
       @configurations = {
         :feed_cache => nil,
+        :disable_update_from_remote => false,
         :proxy_address => nil,
         :proxy_port => nil,
-        :user_agent => "FeedTools/#{FEED_TOOLS_VERSION} " + 
+        :proxy_user => nil,
+        :proxy_password => nil,
+        :user_agent =>
+          "FeedTools/#{FeedTools::FEED_TOOLS_VERSION::STRING} " + 
           "+http://www.sporkmonger.com/projects/feedtools/",
-        :generator_name => "FeedTools/#{FEED_TOOLS_VERSION}",
-        :generator_href => "http://www.sporkmonger.com/projects/feedtools/",
-        :tidy_enabled => true,
+        :generator_name =>
+          "FeedTools/#{FeedTools::FEED_TOOLS_VERSION::STRING}",
+        :generator_href =>
+          "http://www.sporkmonger.com/projects/feedtools/",
+        :tidy_enabled => false,
         :tidy_options => {},
         :idn_enabled => true,
         :sanitization_enabled => true,
@@ -357,7 +368,7 @@ module REXML # :nodoc:
             ns = node.namespace( prefix )
           end
           !(node.node_type == :element and
-            node.name.downcase == name and node.namespace == ns )
+            node.name.downcase == name.downcase and node.namespace == ns )
         end
         return n
 
@@ -420,7 +431,7 @@ module REXML # :nodoc:
           for element in nodeset
             if element.node_type == :element
               for attribute_name in element.attributes.keys
-                if attribute_name.downcase == name
+                if attribute_name.downcase == name.downcase
                   attrib = element.attribute( attribute_name,
                     @namespaces[prefix] )
                   new_nodeset << attrib if attrib
@@ -438,7 +449,8 @@ module REXML # :nodoc:
         return new_nodeset
 
       when :parent
-        return internal_parse( path_stack, nodeset.collect{|n| n.parent}.compact )
+        return internal_parse( path_stack,
+          nodeset.collect{|n| n.parent}.compact )
 
       when :ancestor
         new_nodeset = []

data/lib/feed_tools/database_feed_cache.rb

@@ -51,14 +51,17 @@ module FeedTools
         begin
           possible_config_files = [
             "./config/database.yml",
-            "../config/database.yml",
             "./database.yml",
+            "../config/database.yml",
             "../database.yml",
-            "../../database.yml"
+            "../../config/database.yml",
+            "../../database.yml",
+            "../../../config/database.yml",
+            "../../../database.yml"
           ]
           database_config_file = nil
           for file in possible_config_files
-            if File.exists? file
+            if File.exists?(File.expand_path(file))
               database_config_file = file
               break
             end
@@ -109,9 +112,9 @@ module FeedTools
     # True if the appropriate database table already exists
     def DatabaseFeedCache.table_exists?
       begin
-        ActiveRecord::Base.connection.execute "select id, href, title, " +
+        ActiveRecord::Base.connection.execute("select id, href, title, " +
           "link, feed_data, feed_data_type, http_headers, last_retrieved " +
-          "from #{self.table_name()} limit 1"
+          "from #{self.table_name()} limit 1")
       rescue ActiveRecord::StatementInvalid
         return false
       rescue

data/lib/feed_tools/feed.rb

@@ -24,6 +24,7 @@
 require 'rexml/document'
 require 'feed_tools/feed_item'
 require 'feed_tools/feed_structures'
+require 'feed_tools/helpers/retrieval_helper'
 require 'feed_tools/helpers/generic_helper'
 require 'feed_tools/helpers/xml_helper'
 require 'feed_tools/helpers/html_helper'
@@ -51,19 +52,22 @@ module FeedTools
       @entries = nil
       @live = false
       @encoding = nil
+      @options = nil
     end
           
     # Loads the feed specified by the url, pulling the data from the
-    # cache if it hasn't expired.
-    # Options are:
-    # * <tt>:cache_only</tt> - If set to true, the feed will only be
-    #   pulled from the cache.
+    # cache if it hasn't expired.  Options supplied will override the
+    # default options.
     def Feed.open(url, options={})
-      FeedTools::GenericHelper.validate_options([ :cache_only ],
-                       options.keys)
-      options = { :cache_only => false }.merge(options)
+      FeedTools::GenericHelper.validate_options(
+        FeedTools.configurations.keys, options.keys)
+
+      # create the new feed
+      feed = FeedTools::Feed.new
+
+      feed.configurations = FeedTools.configurations.merge(options)
       
-      if options[:cache_only] && FeedTools.feed_cache.nil?
+      if feed.configurations[:feed_cache] != nil && FeedTools.feed_cache.nil?
         raise(ArgumentError, "There is currently no caching mechanism set. " +
           "Cannot retrieve cached feeds.")
       end
@@ -71,16 +75,32 @@ module FeedTools
       # clean up the url
       url = FeedTools::UriHelper.normalize_url(url)
 
-      # create and load the new feed
-      feed = FeedTools::Feed.new
+      # load the new feed
       feed.href = url
-      feed.update! unless options[:cache_only]
+      feed.update! unless feed.configurations[:disable_update_from_remote]
       return feed
     end
+    
+    # Returns the load options for this feed.
+    def configurations
+      if @configurations.blank?
+        @configurations = FeedTools.configurations.dup
+      end
+      return @configurations
+    end
+    
+    # Sets the load options for this feed.
+    def configurations=(new_configurations)
+      @configurations = new_configurations
+    end
 
     # Loads the feed from the remote url if the feed has expired from the
     # cache or cannot be retrieved from the cache for some reason.
     def update!
+      if self.configurations[:disable_update_from_remote]
+        # Don't do anything if this option is set
+        return
+      end
       if !FeedTools.feed_cache.nil? &&
           !FeedTools.feed_cache.set_up_correctly?
         raise "Your feed cache system is incorrectly set up.  " +
@@ -101,7 +121,7 @@ module FeedTools
         # Handle autodiscovery
         if self.http_headers['content-type'] =~ /text\/html/ ||
             self.http_headers['content-type'] =~ /application\/xhtml\+xml/
-          
+
           autodiscovered_url = nil
           autodiscovered_url =
             FeedTools::HtmlHelper.extract_link_by_mime_type(self.feed_data,
@@ -117,9 +137,19 @@ module FeedTools
                 "application/rdf+xml")
           end
           unless autodiscovered_url.nil?
+            begin
+              autodiscovered_url = FeedTools::UriHelper.resolve_relative_uri(
+                autodiscovered_url, [self.href])
+            rescue Exception
+            end
             self.feed_data = nil
             self.href = autodiscovered_url
-            self.expire! unless self.cache_object.nil?
+            if FeedTools.feed_cache.nil?
+              self.cache_object = nil
+            else
+              self.cache_object =
+                FeedTools.feed_cache.find_by_href(autodiscovered_url)
+            end
             self.update!
           end
         end
@@ -170,226 +200,67 @@ module FeedTools
     
       # No need for http headers unless we're actually doing http
       if retrieval_method == "http"
-        # Set up the appropriate http headers
-        headers = {}
-        unless self.http_headers.nil?
-          headers["If-None-Match"] =
-            self.http_headers['etag'] unless self.http_headers['etag'].nil?
-          headers["If-Modified-Since"] =
-            self.http_headers['last-modified'] unless
-            self.http_headers['last-modified'].nil?
-        end
-        unless FeedTools.configurations[:user_agent].nil?
-          headers["User-Agent"] = FeedTools.configurations[:user_agent]
-        end
-
-        # The http feed access method
-        http_fetch = lambda do |feed_url, request_headers, redirect_limit,
-            response_chain, no_headers|
-          raise FeedAccessError, 'Redirect too deep' if redirect_limit == 0
-          feed_uri = nil
-          begin
-            feed_uri = URI.parse(feed_url)
-          rescue URI::InvalidURIError
-            # Uh, maybe try to fix it?
-            feed_uri = URI.parse(FeedTools::UriHelper.normalize_url(feed_url))
-          end
-          
-          begin
-            proxy_address = (FeedTools.configurations[:proxy_address] || nil)
-            proxy_port = (FeedTools.configurations[:proxy_port].to_i || nil)
-
-            http = Net::HTTP::Proxy(proxy_address, proxy_port).new(
-              feed_uri.host, (feed_uri.port or 80))
-            http.start do
-              final_uri = feed_uri.path 
-              final_uri += ('?' + feed_uri.query) if feed_uri.query
-              request_headers = {} if no_headers
-              response = http.request_get(final_uri, request_headers)
-
-              case response
-              when Net::HTTPSuccess
-                # We've reached the final destination, process all previous
-                # redirections, and see if we need to update the url.
-                for redirected_response in response_chain
-                  if redirected_response.last.code.to_i == 301
-                    # Reset the cache object or we may get duplicate entries
-                    self.cache_object = nil
-                    self.href = redirected_response.last['location']
-                  else
-                    # Jump out as soon as we hit anything that isn't a
-                    # permanently moved redirection.
-                    break
-                  end
-                end
-                response
-              when Net::HTTPRedirection
-                if response.code.to_i == 304
-                  response.error!
-                else
-                  if response['location'].nil?
-                    raise FeedAccessError,
-                      "No location to redirect to supplied: " + response.code
-                  end
-                  response_chain << [feed_url, response]
-                  new_location = response['location']
-                  if response_chain.assoc(new_location) != nil
-                    raise FeedAccessError,
-                      "Redirection loop detected: #{new_location}"
-                  end
-              
-                  # Find out if we've already seen the url we've been
-                  # redirected to.
-                  found_redirect = false
-                  begin
-                    cached_feed = FeedTools::Feed.open(new_location,
-                      :cache_only => true)
-                    if cached_feed.cache_object != nil &&
-                        cached_feed.cache_object.new_record? != true
-                      if !cached_feed.expired? &&
-                          !cached_feed.http_headers.blank?
-                        # Copy the cached state
-                        self.href = cached_feed.href
-
-                        @feed_data = cached_feed.feed_data
-                        @feed_data_type = cached_feed.feed_data_type
-
-                        if @feed_data.blank?
-                          raise "Invalid cache data."
-                        end
+        begin
+          @http_response = (FeedTools::RetrievalHelper.http_get(
+            self.href, :feed_object => self) do |url, response|
+              # Find out if we've already seen the url we've been
+              # redirected to.
+              follow_redirect = true
 
-                        @title = nil; self.title
-                        @link = nil; self.link
-                        
-                        self.last_retrieved = cached_feed.last_retrieved
-                        self.http_headers = cached_feed.http_headers
-                        self.cache_object = cached_feed.cache_object
-                        @live = false
-                        found_redirect = true
-                      end
+              begin
+                cached_feed = FeedTools::Feed.open(url,
+                  :disable_update_from_remote => true)
+                if cached_feed.cache_object != nil &&
+                    cached_feed.cache_object.new_record? != true
+                  if !cached_feed.expired? &&
+                      !cached_feed.http_headers.blank?
+                    # Copy the cached state
+                    self.href = cached_feed.href
+    
+                    @feed_data = cached_feed.feed_data
+                    @feed_data_type = cached_feed.feed_data_type
+    
+                    if @feed_data.blank?
+                      raise "Invalid cache data."
                     end
-                  rescue
-                    # If anything goes wrong, ignore it.
-                  end
-                  unless found_redirect
-                    # TODO: deal with stupid people using relative urls
-                    # in Location header
-                    # =================================================
-                    http_fetch.call(new_location, http_headers,
-                      redirect_limit - 1, response_chain, no_headers)
-                  else
-                    response
-                  end
-                end
-              else
-                class << response
-                  def response_chain
-                    return @response_chain
+    
+                    @title = nil; self.title
+                    @link = nil; self.link
+                  
+                    self.last_retrieved = cached_feed.last_retrieved
+                    self.http_headers = cached_feed.http_headers
+                    self.cache_object = cached_feed.cache_object
+                    @live = false
+                    follow_redirect = false
                   end
                 end
-                response.instance_variable_set("@response_chain",
-                  response_chain)
-                response.error!
-              end
-            end
-          rescue SocketError
-            raise FeedAccessError, 'Socket error prevented feed retrieval'
-          rescue Timeout::Error
-            raise FeedAccessError, 'Timeout while attempting to retrieve feed'
-          rescue Errno::ENETUNREACH
-            raise FeedAccessError, 'Network was unreachable'
-          rescue Errno::ECONNRESET
-            raise FeedAccessError, 'Connection was reset by peer'
-          end
-        end
-      
-        begin
-          begin
-            @http_response = http_fetch.call(self.href, headers, 10, [], false)
-          rescue => error
-            if error.respond_to?(:response)
-              # You might not believe this, but...
-              #
-              # Under certain circumstances, web servers will try to block
-              # based on the User-Agent header.  This is *retarded*.  But
-              # we won't let their stupid error stop us!
-              #
-              # This is, of course, a quick-n-dirty hack.  But at least
-              # we get to blame other people's bad software and/or bad
-              # configuration files.
-              if error.response.code.to_i == 404 &&
-                  FeedTools.configurations[:user_agent] != nil
-                @http_response = http_fetch.call(self.href, {}, 10, [], true)
-                if @http_response != nil && @http_response.code.to_i == 200
-                  warn("The server appears to be blocking based on the " +
-                    "User-Agent header.  This is stupid, and you should " +
-                    "inform the webmaster of this.")
-                end
-              else
-                raise error
+              rescue
+                # If anything goes wrong, ignore it.
               end
-            else
-              raise error
-            end
-          end
-          unless @http_response.kind_of? Net::HTTPRedirection
+              follow_redirect
+            end)
+          case @http_response
+          when Net::HTTPSuccess
             @feed_data = self.http_response.body
             @http_headers = {}
             self.http_response.each_header do |key, value|
               self.http_headers[key.downcase] = value
             end
             self.last_retrieved = Time.now.gmtime
-          end
-        rescue FeedAccessError
-          @live = false
-          if self.feed_data.nil?
-            raise
-          end
-        rescue Timeout::Error
-          # if we time out, do nothing, it should fall back to the feed_data
-          # stored in the cache.
-          @live = false
-          if self.feed_data.nil?
-            raise
-          end
-        rescue Errno::ECONNRESET
-          # if the connection gets reset by peer, oh well, fall back to the
-          # feed_data stored in the cache
-          @live = false
-          if self.feed_data.nil?
-            raise
-          end
-        rescue => error
-          # heck, if anything at all bad happens, fall back to the feed_data
-          # stored in the cache.
-        
-          # If we can, get the HTTPResponse...
-          @http_response = nil
-          if error.respond_to?(:each_header)
-            @http_response = error
-          end
-          if error.respond_to?(:response) &&
-              error.response.respond_to?(:each_header)
-            @http_response = error.response
-          end
-          if @http_response != nil
+            @live = true
+          when Net::HTTPNotModified
             @http_headers = {}
             self.http_response.each_header do |key, value|
               self.http_headers[key.downcase] = value
             end
-            if self.http_response.code.to_i == 304
-              self.last_retrieved = Time.now.gmtime
-            end
+            self.last_retrieved = Time.now.gmtime
+            @live = true
+          else
+            @live = false
           end
+        rescue Exception => error
           @live = false
           if self.feed_data.nil?
-            if error.respond_to?(:response) &&
-                error.response.respond_to?(:response_chain)
-              redirects = error.response.response_chain.map do |pair|
-                pair.first
-              end
-              error.message << (" - Redirects: " + redirects.inspect)
-            end
             raise error
           end
         end
@@ -407,7 +278,7 @@ module FeedTools
         # with 'file://', strip the 'file://' off the front of the url.
         file_name = self.href.gsub(/^file:\/\//, "")
         if RUBY_PLATFORM =~ /mswin/
-          file_name = file_name[1..-1] if file_name[1..1] == "/"
+          file_name = file_name[1..-1] if file_name[0..0] == "/"
         end
         begin
           open(file_name) do |file|
@@ -885,7 +756,7 @@ module FeedTools
             end
           rescue
           end
-          if FeedTools.configurations[:url_normalization_enabled]
+          if self.configurations[:url_normalization_enabled]
             @href = FeedTools::UriHelper.normalize_url(@href)
           end            
           @href.strip! unless @href.nil?
@@ -925,7 +796,7 @@ module FeedTools
         @title = FeedTools::HtmlHelper.process_text_construct(title_node,
           self.feed_type, self.feed_version)
         if self.feed_type == "atom" ||
-            FeedTools.configurations[:always_strip_wrapper_elements]
+            self.configurations[:always_strip_wrapper_elements]
           @title = FeedTools::HtmlHelper.strip_wrapper_element(@title)
         end
         @title = nil if @title.blank?
@@ -943,7 +814,6 @@ module FeedTools
     # Returns the feed subtitle
     def subtitle
       if @subtitle.nil?
-        repair_entities = false
         subtitle_node = FeedTools::XmlHelper.try_xpaths(self.channel_node, [
           "atom10:subtitle",
           "subtitle",
@@ -968,7 +838,7 @@ module FeedTools
         @subtitle = FeedTools::HtmlHelper.process_text_construct(
           subtitle_node, self.feed_type, self.feed_version)
         if self.feed_type == "atom" ||
-            FeedTools.configurations[:always_strip_wrapper_elements]
+            self.configurations[:always_strip_wrapper_elements]
           @subtitle = FeedTools::HtmlHelper.strip_wrapper_element(@subtitle)
         end
         if @subtitle.blank?
@@ -1125,7 +995,7 @@ module FeedTools
           end
         rescue
         end
-        if FeedTools.configurations[:url_normalization_enabled]
+        if self.configurations[:url_normalization_enabled]
           @link = FeedTools::UriHelper.normalize_url(@link)
         end
         unless self.cache_object.nil?
@@ -1179,7 +1049,7 @@ module FeedTools
             end
           rescue
           end
-          if FeedTools.configurations[:url_normalization_enabled]
+          if self.configurations[:url_normalization_enabled]
             link_object.href =
               FeedTools::UriHelper.normalize_url(link_object.href)
           end
@@ -1609,12 +1479,12 @@ module FeedTools
           unless time_string.blank?
             @time = Time.parse(time_string).gmtime
           else
-            if FeedTools.configurations[:timestamp_estimation_enabled]
+            if self.configurations[:timestamp_estimation_enabled]
               @time = Time.now.gmtime
             end
           end
         rescue
-          if FeedTools.configurations[:timestamp_estimation_enabled]
+          if self.configurations[:timestamp_estimation_enabled]
             @time = Time.now.gmtime
           end
         end
@@ -1750,7 +1620,7 @@ module FeedTools
               end
             rescue
             end
-            if FeedTools.configurations[:url_normalization_enabled]
+            if self.configurations[:url_normalization_enabled]
               image.href = FeedTools::UriHelper.normalize_url(image.href)
             end            
             image.href.strip! unless image.href.nil?
@@ -1835,7 +1705,7 @@ module FeedTools
         @rights = FeedTools::HtmlHelper.process_text_construct(rights_node,
           self.feed_type, self.feed_version)
         if self.feed_type == "atom" ||
-            FeedTools.configurations[:always_strip_wrapper_elements]
+            self.configurations[:always_strip_wrapper_elements]
           @rights = FeedTools::HtmlHelper.strip_wrapper_element(@rights)
         end
       end
@@ -1944,10 +1814,10 @@ module FeedTools
       if @time_to_live.nil? || @time_to_live == 0
         # Default to one hour
         @time_to_live = 1.hour
-      elsif FeedTools.configurations[:max_ttl] != nil &&
-          FeedTools.configurations[:max_ttl] != 0 &&
-          @time_to_live >= FeedTools.configurations[:max_ttl].to_i
-        @time_to_live = FeedTools.configurations[:max_ttl].to_i
+      elsif self.configurations[:max_ttl] != nil &&
+          self.configurations[:max_ttl] != 0 &&
+          @time_to_live >= self.configurations[:max_ttl].to_i
+        @time_to_live = self.configurations[:max_ttl].to_i
       end
       @time_to_live = @time_to_live.round
       return @time_to_live
@@ -2034,7 +1904,7 @@ module FeedTools
           end
         rescue
         end
-        if FeedTools.configurations[:url_normalization_enabled]
+        if self.configurations[:url_normalization_enabled]
           @docs = FeedTools::UriHelper.normalize_url(@docs)
         end
       end
@@ -2145,17 +2015,17 @@ module FeedTools
       end
     
       # Sort the items
-      if FeedTools.configurations[:entry_sorting_property] == "time"
+      if self.configurations[:entry_sorting_property] == "time"
         @entries = @entries.sort do |a, b|
           (b.time or Time.utc(1970)) <=> (a.time or Time.utc(1970))
         end
-      elsif FeedTools.configurations[:entry_sorting_property] != nil
-        sorting_property = FeedTools.configurations[:entry_sorting_property]
+      elsif self.configurations[:entry_sorting_property] != nil
+        sorting_property = self.configurations[:entry_sorting_property]
         @entries = @entries.sort do |a, b|
           eval("a.#{sorting_property}") <=> eval("b.#{sorting_property}")
         end
       else
-        @entries = @entries.reverse
+        return @entries.reverse
       end
       return @entries
     end
@@ -2255,7 +2125,7 @@ module FeedTools
         xml_builder=Builder::XmlMarkup.new(
           :indent => 2, :escape_attrs => false))
       xml_builder.instruct! :xml, :version => "1.0",
-        :encoding => (FeedTools.configurations[:output_encoding] or "utf-8")
+        :encoding => (self.configurations[:output_encoding] or "utf-8")
       if feed_type.nil?
         feed_type = self.feed_type
       end
@@ -2335,7 +2205,7 @@ module FeedTools
             end
             xml_builder.tag!(
               "admin:generatorAgent",
-              "rdf:resource" => FeedTools.configurations[:generator_href])
+              "rdf:resource" => self.configurations[:generator_href])
             build_xml_hook(feed_type, feed_version, xml_builder)
           end
           unless self.images.blank?
@@ -2408,7 +2278,7 @@ module FeedTools
             end
             xml_builder.ttl((time_to_live / 1.minute).to_s)
             xml_builder.generator(
-              FeedTools.configurations[:generator_href])
+              self.configurations[:generator_href])
             build_xml_hook(feed_type, feed_version, xml_builder)
             unless items.nil?
               for item in items
@@ -2467,8 +2337,8 @@ module FeedTools
           unless self.rights.blank?
             xml_builder.rights(self.rights)
           end
-          xml_builder.generator(FeedTools.configurations[:generator_name] +
-            " - " + FeedTools.configurations[:generator_href])
+          xml_builder.generator(self.configurations[:generator_name] +
+            " - " + self.configurations[:generator_href])
           if self.id != nil
             unless FeedTools::UriHelper.is_uri? self.id
               if self.link != nil
@@ -2498,6 +2368,18 @@ module FeedTools
 
     # Persists the current feed state to the cache.
     def save
+      if self.configurations[:feed_cache].nil?
+        # The cache is disabled for this feed, do nothing.
+        return
+      end
+      if self.http_headers['content-type'] =~ /text\/html/ ||
+          self.http_headers['content-type'] =~ /application\/xhtml\+xml/
+        if self.title.nil? && self.link.nil? && self.entries.blank?
+          # Don't save html pages to the cache, it messes with
+          # autodiscovery.
+          return
+        end
+      end
       unless self.href =~ /^file:\/\//
         if FeedTools.feed_cache.nil?
           raise "Caching is currently disabled.  Cannot save to cache."