feedtools 0.2.18 → 0.2.19

data/lib/feed_tools/feed.rb

@@ -29,9 +29,11 @@ module FeedTools
     # :stopdoc:
     include REXML
     class << self
-      include GenericHelper
+      include FeedTools::GenericHelper
       private :validate_options
     end
+    include FeedTools::GenericHelper
+    private :validate_options
     # :startdoc:
   
     # Represents a feed/feed item's category
@@ -143,7 +145,7 @@ module FeedTools
       @link = nil
       @last_retrieved = nil
       @time_to_live = nil
-      @items = nil
+      @entries = nil
       @live = false
     end
           
@@ -175,10 +177,12 @@ module FeedTools
     # 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.http_headers.nil? && !(self.cache_object.nil?) &&
+      if self.http_headers.blank? && !(self.cache_object.nil?) &&
           !(self.cache_object.http_headers.nil?)
         @http_headers = YAML.load(self.cache_object.http_headers)
         @http_headers = {} unless @http_headers.kind_of? Hash
+      elsif self.http_headers.blank?
+        @http_headers = {}
       end
       if self.expired? == false
         @live = false
@@ -240,11 +244,12 @@ module FeedTools
             self.http_headers['last-modified'] unless
             self.http_headers['last-modified'].nil?
         end
-        headers["User-Agent"] =
-          FeedTools.user_agent unless FeedTools.user_agent.nil?
+        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, http_headers, redirect_limit,
+        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
@@ -256,11 +261,13 @@ module FeedTools
           end
           
           begin
-            Net::HTTP.start(feed_uri.host, (feed_uri.port or 80)) do |http|
+            # TODO: Proxy host and proxy port would go here if implemented
+            http = Net::HTTP.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
-              http_headers = {} if no_headers
-              response = http.request_get(final_uri, http_headers)
+              request_headers = {} if no_headers
+              response = http.request_get(final_uri, request_headers)
 
               case response
               when Net::HTTPSuccess
@@ -289,7 +296,8 @@ module FeedTools
                   response_chain << [feed_url, response]
                   new_location = response['location']
                   if response_chain.assoc(new_location) != nil
-                    raise FeedAccessError, "Redirection loop detected: #{new_location}"
+                    raise FeedAccessError,
+                      "Redirection loop detected: #{new_location}"
                   end
               
                   # Find out if we've already seen the url we've been
@@ -300,13 +308,21 @@ module FeedTools
                       :cache_only => true)
                     if cached_feed.cache_object != nil &&
                         cached_feed.cache_object.new_record? != true
-                      unless cached_feed.expired?
-                        # Copy the cached state, starting with the url
+                      if !cached_feed.expired? &&
+                          !cached_feed.http_headers.blank?
+                        # Copy the cached state
                         self.url = cached_feed.url
-                        self.title = cached_feed.title
-                        self.link = cached_feed.link
-                        self.feed_data = cached_feed.feed_data
-                        self.feed_data_type = cached_feed.feed_data_type
+
+                        @feed_data = cached_feed.feed_data
+                        @feed_data_type = cached_feed.feed_data_type
+
+                        if @feed_data.blank?
+                          raise "Invalid cache data."
+                        end
+
+                        @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
@@ -342,6 +358,10 @@ module FeedTools
             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
       
@@ -375,12 +395,12 @@ module FeedTools
             end
           end
           unless @http_response.kind_of? Net::HTTPRedirection
+            @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
-            self.feed_data = self.http_response.body
           end
         rescue FeedAccessError
           @live = false
@@ -451,9 +471,9 @@ module FeedTools
           open(file_name) do |file|
             @http_response = nil
             @http_headers = {}
+            @feed_data = file.read
+            @feed_data_type = :xml
             self.last_retrieved = Time.now.gmtime
-            self.feed_data = file.read
-            self.feed_data_type = :xml
           end
         rescue
           @live = false
@@ -478,8 +498,71 @@ module FeedTools
 
     # Returns a hash of the http headers from the response.
     def http_headers
+      if @http_headers.blank?
+        if !self.cache_object.nil? && !self.cache_object.http_headers.nil?
+          @http_headers = YAML.load(self.cache_object.http_headers)
+          @http_headers = {} unless @http_headers.kind_of? Hash
+        else
+          @http_headers = {}
+        end
+      end
       return @http_headers
     end
+    
+    # Returns the encoding that the feed was parsed with
+    def encoding
+      if @encoding.nil?
+        unless self.http_headers.blank?
+          @encoding = "utf-8"
+        else
+          @encoding = self.encoding_from_xml_data
+        end
+      end
+      return @encoding
+    end
+    
+    # Returns the encoding of feed calculated only from the xml data.
+    # I.e., the encoding we would come up with if we ignore RFC 3023.
+    def encoding_from_xml_data
+      if @encoding_from_xml_data.nil?
+        raw_data = self.feed_data
+        encoding_from_xml_instruct = 
+          raw_data.scan(
+            /^<\?xml [^>]*encoding="([\w]*)"[^>]*\?>/
+          ).flatten.first
+        unless encoding_from_xml_instruct.blank?
+          encoding_from_xml_instruct.downcase!
+        end
+        if encoding_from_xml_instruct.blank?
+          doc = Document.new(raw_data)
+          encoding_from_xml_instruct = doc.encoding.downcase
+          if encoding_from_xml_instruct == "utf-8"
+            # REXML has a tendency to report utf-8 overzealously, take with
+            # grain of salt
+            encoding_from_xml_instruct = nil
+          end
+        else
+          @encoding_from_xml_data = encoding_from_xml_instruct
+        end
+        if encoding_from_xml_instruct.blank?
+          sniff_table = {
+            "Lo\247\224" => "ebcdic-cp-us",
+            "<?xm" => "utf-8"
+          }
+          sniff = self.feed_data[0..3]
+          if sniff_table[sniff] != nil
+            @encoding_from_xml_data = sniff_table[sniff].downcase
+          end
+        else
+          @encoding_from_xml_data = encoding_from_xml_instruct
+        end
+        if @encoding_from_xml_data.blank?
+          # Safest assumption
+          @encoding_from_xml_data = "utf-8"
+        end
+      end
+      return @encoding_from_xml_data
+    end
   
     # Returns the feed's raw data.
     def feed_data
@@ -493,12 +576,40 @@ module FeedTools
   
     # Sets the feed's data.
     def feed_data=(new_feed_data)
+      @http_headers = {}
+      @cache_object = nil
+      @url = nil
+      @id = nil
+      @encoding = nil
       @feed_data = new_feed_data
       unless self.cache_object.nil?
         self.cache_object.feed_data = new_feed_data
       end
     end
     
+    # Returns the feed's raw data as utf-8.
+    def feed_data_utf_8(force_encoding=nil)
+      if @feed_data_utf_8.nil?
+        raw_data = self.feed_data
+        if force_encoding.nil?
+          use_encoding = self.encoding
+        else
+          use_encoding = force_encoding
+        end
+        if use_encoding != "utf-8"
+          begin
+            @feed_data_utf_8 =
+              Iconv.new('utf-8', use_encoding).iconv(raw_data)
+          rescue
+            return raw_data
+          end
+        else
+          return self.feed_data
+        end
+      end
+      return @feed_data_utf_8
+    end
+    
     # Returns the data type of the feed
     # Possible values:
     # * :xml
@@ -526,24 +637,15 @@ module FeedTools
         @xml_doc = nil
       else
         if @xml_doc.nil?
-          # INQUIRY: Is there any way of saying "dude, rescue *everything*"?
           begin
             begin
-              # TODO: :ignore_whitespace_nodes => :all
-              # Add that?
-              # ======================================
-              @xml_doc = Document.new(feed_data)
-            rescue Exception
-              # Something failed especially badly, attempt to repair the
-              # xml with htree.
-              @xml_doc = HTree.parse(feed_data).to_rexml
-            rescue
+              @xml_doc = Document.new(self.feed_data_utf_8,
+                :ignore_whitespace_nodes => :all)
+            rescue Object
               # Something failed, attempt to repair the xml with htree.
-              @xml_doc = HTree.parse(feed_data).to_rexml
+              @xml_doc = HTree.parse(self.feed_data_utf_8).to_rexml
             end
-          rescue Exception
-            @xml_doc = nil
-          rescue
+          rescue Object
             @xml_doc = nil
           end
         end
@@ -551,14 +653,23 @@ module FeedTools
       return @xml_doc
     end
   
-    # Returns the first node within the channel_node that matches the xpath query.
-    def find_node(xpath)
-      return XPath.first(channel_node, xpath)
+    # Returns the first node within the channel_node that matches the xpath
+    # query.
+    def find_node(xpath, select_result_value=false)
+      if self.feed_data_type != :xml
+        raise "The feed data type is not xml."
+      end
+      return try_xpaths(self.channel_node, [xpath],
+        :select_result_value => select_result_value)
     end
   
     # Returns all nodes within the channel_node that match the xpath query.
-    def find_all_nodes(xpath)
-      return XPath.match(channel_node, xpath)
+    def find_all_nodes(xpath, select_result_value=false)
+      if self.feed_data_type != :xml
+        raise "The feed data type is not xml."
+      end
+      return try_xpaths_all(self.channel_node, [xpath],
+        :select_result_value => select_result_value)
     end
   
     # Returns the root node of the feed.
@@ -568,7 +679,15 @@ module FeedTools
         # break this stuff.
         # E.g.: http://smogzer.tripod.com/smog.rdf
         # ===================================================================
-        @root_node = xml.root
+        begin
+          if xml.nil?
+            return nil
+          else
+            @root_node = xml.root
+          end
+        rescue
+          return nil
+        end
       end
       return @root_node
     end
@@ -576,13 +695,11 @@ module FeedTools
     # Returns the channel node of the feed.
     def channel_node
       if @channel_node.nil? && root_node != nil
-        @channel_node = XPath.first(root_node, "channel")
-        if @channel_node == nil
-          @channel_node = XPath.first(root_node, "CHANNEL")
-        end
-        if @channel_node == nil
-          @channel_node = XPath.first(root_node, "feedinfo")
-        end
+        @channel_node = try_xpaths(root_node, [
+          "channel",
+          "CHANNEL",
+          "feedinfo"
+        ])
         if @channel_node == nil
           @channel_node = root_node
         end
@@ -592,12 +709,13 @@ module FeedTools
   
     # The cache object that handles the feed persistence.
     def cache_object
+      if !@url.nil? && @url =~ /^file:\/\//
+        return nil
+      end
       unless FeedTools.feed_cache.nil?
         if @cache_object.nil?
           begin
-            if @id != nil
-              @cache_object = FeedTools.feed_cache.find_by_id(@id)
-            elsif @url != nil
+            if @url != nil
               @cache_object = FeedTools.feed_cache.find_by_url(@url)
             end
             if @cache_object.nil?
@@ -719,43 +837,22 @@ module FeedTools
     # Returns the feed's unique id
     def id
       if @id.nil?
-        unless channel_node.nil?
-          @id = XPath.first(channel_node, "id/text()").to_s
-          if @id == ""
-            @id = XPath.first(channel_node, "atom10:id/text()",
-              FEED_TOOLS_NAMESPACES).to_s
-          end
-          if @id == ""
-            @id = XPath.first(channel_node, "atom03:id/text()",
-              FEED_TOOLS_NAMESPACES).to_s
-          end
-          if @id == ""
-            @id = XPath.first(channel_node, "atom:id/text()").to_s
-          end
-          if @id == ""
-            @id = XPath.first(channel_node, "guid/text()").to_s
-          end
-        end
-        unless root_node.nil?
-          if @id == "" || @id.nil?
-            @id = XPath.first(root_node, "id/text()").to_s
-          end
-          if @id == ""
-            @id = XPath.first(channel_node, "atom10:id/text()",
-              FEED_TOOLS_NAMESPACES).to_s
-          end
-          if @id == ""
-            @id = XPath.first(channel_node, "atom03:id/text()",
-              FEED_TOOLS_NAMESPACES).to_s
-          end
-          if @id == ""
-            @id = XPath.first(channel_node, "atom:id/text()").to_s
-          end
-          if @id == ""
-            @id = XPath.first(root_node, "guid/text()").to_s
-          end
-        end
-        @id = nil if @id == ""
+        @id = select_not_blank([
+          try_xpaths(self.channel_node, [
+            "atom10:id/text()",
+            "atom03:id/text()",
+            "atom:id/text()",
+            "id/text()",
+            "guid/text()"
+          ], :select_result_value => true),
+          try_xpaths(self.root_node, [
+            "atom10:id/text()",
+            "atom03:id/text()",
+            "atom:id/text()",
+            "id/text()",
+            "guid/text()"
+          ], :select_result_value => true)
+        ])
       end
       return @id
     end
@@ -768,12 +865,12 @@ module FeedTools
     # Returns the feed url.
     def url
       original_url = @url
-      override_url = lambda do
+      override_url = lambda do |result|
         begin
-          if @url == nil && self.feed_data != nil
+          if result.nil? && self.feed_data != nil
             true
-          elsif @url != nil &&
-              !(["http", "https"].include?(URI.parse(@url).scheme))
+          elsif result != nil &&
+              !(["http", "https"].include?(URI.parse(result.to_s).scheme))
             if self.feed_data != nil
               true
             else
@@ -786,47 +883,32 @@ module FeedTools
           true
         end
       end
-      if override_url.call
-        @url = XPath.first(channel_node, "link[@rel='self']/@href").to_s
-        @url = nil if @url == ""
-        if override_url.call
-          @url = XPath.first(channel_node, "atom:link[@rel='self']/@href").to_s
-          @url = nil if @url == ""
-        end
-        if override_url.call
-          @url = XPath.first(channel_node, "atom10:link[@rel='self']/@href",
-            FEED_TOOLS_NAMESPACES).to_s
-          @url = nil if @url == ""
-        end
-        if override_url.call
-          @url = XPath.first(channel_node, "atom03:link[@rel='self']/@href",
-            FEED_TOOLS_NAMESPACES).to_s
-          @url = nil if @url == ""
-        end
-        if override_url.call
-          @url = XPath.first(channel_node, "admin:feed/@rdf:resource").to_s
-          @url = nil if @url == ""
-        end
-        if override_url.call
-          @url = XPath.first(channel_node, "admin:feed/@rdf:resource",
-            FEED_TOOLS_NAMESPACES).to_s
-          @url = nil if @url == ""
-        end
-        if override_url.call
-          @url = XPath.first(channel_node, "admin:feed/@resource").to_s
-          @url = nil if @url == ""
-        end
-        if override_url.call
-          @url = XPath.first(channel_node, "feed/@rdf:resource").to_s
-          @url = nil if @url == ""
-        end
-        if override_url.call
-          @url = XPath.first(channel_node, "feed/@resource").to_s
-          @url = nil if @url == ""
-        end
+      if override_url.call(@url)
+        # rdf:about is ordered last because a lot of people accidentally
+        # put the link in that field instead of the url to the feed.
+        # Ordering it last gives them as many chances as humanly possible
+        # for them to redeem themselves.  If the link turns out to be the
+        @url = try_xpaths(self.channel_node, [
+          "link[@rel='self']/@href",
+          "atom10:link[@rel='self']/@href",
+          "atom03:link[@rel='self']/@href",
+          "atom:link[@rel='self']/@href",
+          "admin:feed/@rdf:resource",
+          "admin:feed/@resource",
+          "feed/@rdf:resource",
+          "feed/@resource",
+          "@rdf:about",
+          "@about"
+        ], :select_result_value => true) do |result|
+          override_url.call(FeedTools.normalize_url(result))
+        end
+        @url = FeedTools.normalize_url(@url)
         if @url == nil
           @url = original_url
         end
+        if @url == self.link
+          @url = original_url
+        end
       end
       return @url
     end
@@ -840,37 +922,23 @@ module FeedTools
     # Returns the feed title
     def title
       if @title.nil?
-        unless channel_node.nil?
-          repair_entities = false
-          title_node = XPath.first(channel_node, "atom10:title",
-            FEED_TOOLS_NAMESPACES)
-          if title_node.nil?
-            title_node = XPath.first(channel_node, "title")
-          end
-          if title_node.nil?
-            title_node = XPath.first(channel_node, "atom03:title",
-              FEED_TOOLS_NAMESPACES)
-          end
-          if title_node.nil?
-            title_node = XPath.first(channel_node, "atom:title")
-          end
-          if title_node.nil?
-            title_node = XPath.first(channel_node, "dc:title",
-              FEED_TOOLS_NAMESPACES)
-          end
-          if title_node.nil?
-            title_node = XPath.first(channel_node, "dc:title")
-          end
-          if title_node.nil?
-            title_node = XPath.first(channel_node, "TITLE")
-          end
-        end
+        repair_entities = false
+        title_node = try_xpaths(self.channel_node, [
+          "atom10:title",
+          "atom03:title",
+          "atom:title",
+          "title",
+          "dc:title"
+        ])
         if title_node.nil?
           return nil
         end
-        title_type = XPath.first(title_node, "@type").to_s
-        title_mode = XPath.first(title_node, "@mode").to_s
-        title_encoding = XPath.first(title_node, "@encoding").to_s
+        title_type = try_xpaths(title_node, "@type",
+          :select_result_value => true)
+        title_mode = try_xpaths(title_node, "@mode",
+          :select_result_value => true)
+        title_encoding = try_xpaths(title_node, "@encoding",
+          :select_result_value => true)
         
         # Note that we're checking for misuse of type, mode and encoding here
         if title_type == "base64" || title_mode == "base64" ||
@@ -895,7 +963,7 @@ module FeedTools
         @title.gsub!(/>\n</, "><")
         @title.gsub!(/\n/, " ")
         @title.strip!
-        @title = nil if @title == ""
+        @title = nil if @title.blank?
         self.cache_object.title = @title unless self.cache_object.nil?
       end
       return @title
@@ -907,124 +975,98 @@ module FeedTools
       self.cache_object.title = new_title unless self.cache_object.nil?
     end
 
-    # Returns the feed description
-    def description
-      if @description.nil?
-        unless channel_node.nil?
-          repair_entities = false
-          description_node = XPath.first(channel_node, "description")
-          if description_node.nil?
-            description_node = XPath.first(channel_node, "tagline")
-          end
-          if description_node.nil?
-            description_node = XPath.first(channel_node, "subtitle")
-          end
-          if description_node.nil?
-            description_node = XPath.first(channel_node, "summary")
-          end
-          if description_node.nil?
-            description_node = XPath.first(channel_node, "abstract")
-          end
-          if description_node.nil?
-            description_node = XPath.first(channel_node, "ABSTRACT")
-          end
-          if description_node.nil?
-            description_node = XPath.first(channel_node, "info")
-          end
-          if description_node.nil?
-            description_node = XPath.first(channel_node, "content:encoded")
-          end
-          if description_node.nil?
-            description_node = XPath.first(channel_node, "content:encoded",
-              FEED_TOOLS_NAMESPACES)
-          end
-          if description_node.nil?
-            description_node = XPath.first(root_node, "encoded")
-          end
-          if description_node.nil?
-            description_node = XPath.first(channel_node, "content")
-          end
-          if description_node.nil?
-            description_node = XPath.first(channel_node, "xhtml:body")
-          end
-          if description_node.nil?
-            description_node = XPath.first(channel_node, "body")
-          end
-          if description_node.nil?
-            description_node = XPath.first(channel_node, "blurb")
-          end
-        end
-        if description_node.nil?
+    # Returns the feed subtitle
+    def subtitle
+      if @subtitle.nil?
+        repair_entities = false
+        subtitle_node = try_xpaths(self.channel_node, [
+          "atom10:subtitle",
+          "subtitle",
+          "atom03:tagline",
+          "tagline",
+          "description",
+          "summary",
+          "abstract",
+          "ABSTRACT",
+          "content:encoded",
+          "encoded",
+          "content",
+          "xhtml:body",
+          "body",
+          "blurb",
+          "info"
+        ])
+        if subtitle_node.nil?
           return nil
         end
-        description_type = XPath.first(description_node, "@type").to_s
-        description_mode = XPath.first(description_node, "@mode").to_s
-        description_encoding = XPath.first(description_node, "@encoding").to_s
+        subtitle_type = try_xpaths(subtitle_node, "@type",
+          :select_result_value => true)
+        subtitle_mode = try_xpaths(subtitle_node, "@mode",
+          :select_result_value => true)
+        subtitle_encoding = try_xpaths(subtitle_node, "@encoding",
+          :select_result_value => true)
 
         # Note that we're checking for misuse of type, mode and encoding here
-        if description_encoding != ""
-          @description =
+        if !subtitle_encoding.blank?
+          @subtitle =
             "[Embedded data objects are not currently supported.]"
-        elsif description_node.cdatas.size > 0
-          @description = description_node.cdatas.first.value
-        elsif description_type == "base64" || description_mode == "base64" ||
-            description_encoding == "base64"
-          @description = Base64.decode64(description_node.inner_xml.strip)
-        elsif description_type == "xhtml" || description_mode == "xhtml" ||
-            description_type == "xml" || description_mode == "xml" ||
-            description_type == "application/xhtml+xml"
-          @description = description_node.inner_xml
-        elsif description_type == "escaped" || description_mode == "escaped"
-          @description = FeedTools.unescape_entities(
-            description_node.inner_xml)
+        elsif subtitle_node.cdatas.size > 0
+          @subtitle = subtitle_node.cdatas.first.value
+        elsif subtitle_type == "base64" || subtitle_mode == "base64" ||
+            subtitle_encoding == "base64"
+          @subtitle = Base64.decode64(subtitle_node.inner_xml.strip)
+        elsif subtitle_type == "xhtml" || subtitle_mode == "xhtml" ||
+            subtitle_type == "xml" || subtitle_mode == "xml" ||
+            subtitle_type == "application/xhtml+xml"
+          @subtitle = subtitle_node.inner_xml
+        elsif subtitle_type == "escaped" || subtitle_mode == "escaped"
+          @subtitle = FeedTools.unescape_entities(
+            subtitle_node.inner_xml)
         else
-          @description = description_node.inner_xml
+          @subtitle = subtitle_node.inner_xml
           repair_entities = true
         end
-        if @description == ""
-          @description = self.itunes_summary
-          @description = "" if @description.nil?
+        if @subtitle.blank?
+          @subtitle = self.itunes_summary
         end
-        if @description == ""
-          @description = self.itunes_subtitle
-          @description = "" if @description.nil?
+        if @subtitle.blank?
+          @subtitle = self.itunes_subtitle
         end
 
-        unless @description.nil?
-          @description = FeedTools.sanitize_html(@description, :strip)
-          @description = FeedTools.unescape_entities(@description) if repair_entities
-          @description = FeedTools.tidy_html(@description)
+        unless @subtitle.blank?
+          @subtitle = FeedTools.sanitize_html(@subtitle, :strip)
+          @subtitle = FeedTools.unescape_entities(@subtitle) if repair_entities
+          @subtitle = FeedTools.tidy_html(@subtitle)
         end
 
-        @description = @description.strip unless @description.nil?
-        @description = nil if @description == ""
+        @subtitle = @subtitle.strip unless @subtitle.nil?
+        @subtitle = nil if @subtitle.blank?
       end
-      return @description
+      return @subtitle
     end
 
-    # Sets the feed description
-    def description=(new_description)
-      @description = new_description
+    # Sets the feed subtitle
+    def subtitle=(new_subtitle)
+      @subtitle = new_subtitle
     end
 
     # Returns the contents of the itunes:summary element
     def itunes_summary
       if @itunes_summary.nil?
-        unless channel_node.nil?
-          @itunes_summary = FeedTools.unescape_entities(XPath.first(channel_node,
-            "itunes:summary/text()").to_s)
-        end
-        unless root_node.nil?
-          if @itunes_summary == "" || @itunes_summary.nil?
-            @itunes_summary = FeedTools.unescape_entities(XPath.first(root_node,
-              "itunes:summary/text()").to_s)
-          end
-        end
-        if @itunes_summary == ""
+        @itunes_summary = select_not_blank([
+          try_xpaths(self.channel_node, [
+            "itunes:summary/text()"
+          ]),
+          try_xpaths(self.root_node, [
+            "itunes:summary/text()"
+          ])
+        ])
+        unless @itunes_summary.blank?
+          @itunes_summary = FeedTools.unescape_entities(@itunes_summary)
+          @itunes_summary = FeedTools.sanitize_html(@itunes_summary)
+        else
           @itunes_summary = nil
         end
-        @itunes_summary =
-          FeedTools.sanitize_html(@itunes_summary) unless @itunes_summary.nil?
       end
       return @itunes_summary
     end
@@ -1037,21 +1079,19 @@ module FeedTools
     # Returns the contents of the itunes:subtitle element
     def itunes_subtitle
       if @itunes_subtitle.nil?
-        unless channel_node.nil?
-          @itunes_subtitle = FeedTools.unescape_entities(XPath.first(channel_node,
-            "itunes:subtitle/text()").to_s)
-        end
-        unless root_node.nil?
-          if @itunes_subtitle == "" || @itunes_subtitle.nil?
-            @itunes_subtitle = FeedTools.unescape_entities(XPath.first(root_node,
-              "itunes:subtitle/text()").to_s)
-          end
-        end
-        if @itunes_subtitle == ""
-          @itunes_subtitle = nil
-        end
-        unless @itunes_subtitle.nil?
+        @itunes_subtitle = select_not_blank([
+          try_xpaths(self.channel_node, [
+            "itunes:subtitle/text()"
+          ]),
+          try_xpaths(self.root_node, [
+            "itunes:subtitle/text()"
+          ])
+        ])
+        unless @itunes_subtitle.blank?
+          @itunes_subtitle = FeedTools.unescape_entities(@itunes_subtitle)
           @itunes_subtitle = FeedTools.sanitize_html(@itunes_subtitle)
+        else
+          @itunes_subtitle = nil
         end
       end
       return @itunes_subtitle
@@ -1065,43 +1105,80 @@ module FeedTools
     # Returns the feed link
     def link
       if @link.nil?
-        unless channel_node.nil?
-          # get the feed link from the xml document
-          @link = XPath.first(channel_node, "link[@rel='alternate' @type='text/html']/@href").to_s
-          if @link == ""
-            @link = XPath.first(channel_node, "link[@rel='alternate']/@href").to_s
-          end
-          if @link == ""
-            @link = XPath.first(channel_node, "link/@href").to_s
-          end
-          if @link == ""
-            @link = XPath.first(channel_node, "link/text()").to_s
-          end
-          if @link == ""
-            @link = XPath.first(channel_node, "@href").to_s
-          end
-          if @link == ""
-            @link = XPath.first(channel_node, "@HREF").to_s
-          end
-          if @link == ""
-            @link = XPath.first(channel_node, "a/@href").to_s
-          end
-          if @link == ""
-            @link = XPath.first(channel_node, "A/@HREF").to_s
-          end
-        end
-        if @link == "" || @link.nil?
-          if FeedTools.is_uri? self.guid
+        @link = try_xpaths(self.channel_node, [
+          "atom10:link[@type='application/xhtml+xml']/@href",
+          "atom10:link[@type='text/html']/@href",
+          "atom10:link[@rel='alternate']/@href",
+          "atom03:link[@type='application/xhtml+xml']/@href",
+          "atom03:link[@type='text/html']/@href",
+          "atom03:link[@rel='alternate']/@href",
+          "atom:link[@type='application/xhtml+xml']/@href",
+          "atom:link[@type='text/html']/@href",
+          "atom:link[@rel='alternate']/@href",
+          "link[@type='application/xhtml+xml']/@href",
+          "link[@type='text/html']/@href",
+          "link[@rel='alternate']/@href",
+          "link/text()",
+          "@href",
+          "a/@href"
+        ], :select_result_value => true)
+        if @link.blank?
+          if FeedTools.is_uri?(self.guid)
             @link = self.guid
           end
         end
-        if @link == "" && channel_node != nil
-          # Technically, we shouldn't use the base attribute for this, but if the href attribute
-          # is missing, it's already a given that we're looking at a messed up CDF file.  We can
-          # always pray it's correct.
+        if @link.blank? && channel_node != nil
+          # Technically, we shouldn't use the base attribute for this, but
+          # if the href attribute is missing, it's already a given that we're
+          # looking at a messed up CDF file.  We can always pray it's correct.
           @link = XPath.first(channel_node, "@base").to_s
         end
-        @link = FeedTools.normalize_url(@link)
+        if !@link.blank?
+          @link = FeedTools.unescape_entities(@link)
+        end
+        if @link.blank?
+          link_node = try_xpaths(self.channel_node, [
+            "atom10:link",
+            "atom03:link",
+            "atom:link",
+            "link"
+          ])
+          if link_node != nil
+            if link_node.attributes['type'].to_s =~ /^image/ ||
+                link_node.attributes['type'].to_s =~ /^application/ || 
+                link_node.attributes['type'].to_s =~ /xml/ ||
+                link_node.attributes['rel'].to_s =~ /self/
+              for child in self.channel_node
+                if child.class == REXML::Element
+                  if child.name.downcase == "link"
+                    if child.attributes['type'].to_s =~ /^image/ ||
+                        child.attributes['type'].to_s =~ /^application/ || 
+                        child.attributes['type'].to_s =~ /xml/ ||
+                        child.attributes['rel'].to_s =~ /self/
+                      @link = nil
+                      next
+                    else
+                      @link = child.attributes['href'].to_s
+                      if @link.blank?
+                        @link = child.inner_xml
+                      end
+                      if @link.blank?
+                        next
+                      end
+                      break
+                    end
+                  end
+                end
+              end
+            else
+              @link = link_node.attributes['href'].to_s
+            end
+          end
+        end
+        @link = nil if @link.blank?
+        if FeedTools.configurations[:url_normalization_enabled]
+          @link = FeedTools.normalize_url(@link)
+        end
         unless self.cache_object.nil?
           self.cache_object.link = @link
         end
@@ -1118,87 +1195,83 @@ module FeedTools
     end
 
     # Returns the url to the icon file for this feed.
-    #
-    # This method uses the url from the link field in order to avoid grabbing
-    # the favicon for services like feedburner.
     def icon
       if @icon.nil?
-        icon_node = XPath.first(channel_node, "link[@rel='icon']")
-        if icon_node.nil?
-          icon_node = XPath.first(channel_node, "link[@rel='shortcut icon']")
-        end
-        if icon_node.nil?
-          icon_node = XPath.first(channel_node, "link[@type='image/x-icon']")
-        end
-        if icon_node.nil?
-          icon_node = XPath.first(channel_node, "icon")
-        end
-        if icon_node.nil?
-          icon_node = XPath.first(channel_node, "logo[@style='icon']")
-        end
-        if icon_node.nil?
-          icon_node = XPath.first(channel_node, "LOGO[@STYLE='ICON']")
-        end
+        icon_node = try_xpaths(self.channel_node, [
+          "link[@rel='icon']",
+          "link[@rel='shortcut icon']",
+          "link[@type='image/x-icon']",
+          "icon",
+          "logo[@style='icon']",
+          "LOGO[@STYLE='ICON']"
+        ])
         unless icon_node.nil?
           @icon = FeedTools.unescape_entities(
             XPath.first(icon_node, "@href").to_s)
-          if @icon == ""
+          if @icon.blank?
             @icon = FeedTools.unescape_entities(
               XPath.first(icon_node, "text()").to_s)
             unless FeedTools.is_uri? @icon
-              @icon = ""
+              @icon = nil
             end
           end
-          if @icon == "" && self.link != nil && self.link != ""
+          @icon = nil if @icon.blank?
+        end
+      end
+      return @icon
+    end
+    
+    # Returns the favicon url for this feed.
+    # This method first tries to use the url from the link field instead of
+    # the feed url, in order to avoid grabbing the favicon for services like
+    # feedburner.
+    def favicon
+      if @favicon.nil?
+        if !self.link.blank?
+          begin
             link_uri = URI.parse(FeedTools.normalize_url(self.link))
-            @icon =
-              link_uri.scheme + "://" + link_uri.host + "/favicon.ico"
+            if link_uri.scheme == "http"
+              @favicon =
+                "http://" + link_uri.host + "/favicon.ico"
+            end
+          rescue
+            @favicon = nil
+          end
+          if @favicon.nil? && !self.url.blank?
+            begin
+              feed_uri = URI.parse(FeedTools.normalize_url(self.url))
+              if feed_uri.scheme == "http"
+                @favicon =
+                  "http://" + feed_uri.host + "/favicon.ico"
+              end
+            rescue
+              @favicon = nil
+            end
           end
-          @icon = nil if @icon == ""
+        else
+          @favicon = nil
         end
       end
-      return @icon
+      return @favicon
     end
 
     # Returns the feed author
     def author
       if @author.nil?
         @author = FeedTools::Feed::Author.new
-        unless channel_node.nil?
-          author_node = XPath.first(channel_node, "atom10:author",
-            FEED_TOOLS_NAMESPACES)
-          if author_node.nil?
-            author_node = XPath.first(channel_node, "atom03:author",
-              FEED_TOOLS_NAMESPACES)
-          end
-          if author_node.nil?
-            author_node = XPath.first(channel_node, "atom:author")
-          end
-          if author_node.nil?
-            author_node = XPath.first(channel_node, "author")
-          end
-          if author_node.nil?
-            author_node = XPath.first(channel_node, "managingEditor")
-          end
-          if author_node.nil?
-            author_node = XPath.first(channel_node, "dc:author",
-              FEED_TOOLS_NAMESPACES)
-          end
-          if author_node.nil?
-            author_node = XPath.first(channel_node, "dc:author")
-          end
-          if author_node.nil?
-            author_node = XPath.first(channel_node, "dc:creator",
-              FEED_TOOLS_NAMESPACES)
-          end
-          if author_node.nil?
-            author_node = XPath.first(channel_node, "dc:creator")
-          end
-        end
+        author_node = try_xpaths(self.channel_node, [
+          "atom10:author",
+          "atom03:author",
+          "atom:author",
+          "author",
+          "managingEditor",
+          "dc:author",
+          "dc:creator"
+        ])
         unless author_node.nil?
           @author.raw = FeedTools.unescape_entities(
-            XPath.first(author_node, "text()").to_s)
-          @author.raw = nil if @author.raw == ""
+            XPath.first(author_node, "text()").to_s).strip
+          @author.raw = nil if @author.raw.blank?
           unless @author.raw.nil?
             raw_scan = @author.raw.scan(
               /(.*)\((\b[A-Z0-9._%-\+]+@[A-Z0-9._%-]+\.[A-Z]{2,4}\b)\)/i)
@@ -1229,35 +1302,37 @@ module FeedTools
               end
             end
           end
-          @author.name = "" if @author.name.nil?
-          if @author.name == ""
+          if @author.name.blank?
             @author.name = FeedTools.unescape_entities(
-              XPath.first(author_node, "name/text()").to_s)
-          end
-          if @author.name == ""
-            @author.name = FeedTools.unescape_entities(
-              XPath.first(author_node, "@name").to_s)
-          end
-          if @author.email == ""
-            @author.email = FeedTools.unescape_entities(
-              XPath.first(author_node, "email/text()").to_s)
+              try_xpaths(author_node, [
+                "name/text()",
+                "@name"
+              ], :select_result_value => true)
+            )
           end
-          if @author.email == ""
+          if @author.email.blank?
             @author.email = FeedTools.unescape_entities(
-              XPath.first(author_node, "@email").to_s)
+              try_xpaths(author_node, [
+                "email/text()",
+                "@email"
+              ], :select_result_value => true)
+            )
           end
-          if @author.url == ""
+          if @author.url.blank?
             @author.url = FeedTools.unescape_entities(
-              XPath.first(author_node, "url/text()").to_s)
-          end
-          if @author.url == ""
-            @author.url = FeedTools.unescape_entities(
-              XPath.first(author_node, "@url").to_s)
-          end
-          @author.name = nil if @author.name == ""
-          @author.raw = nil if @author.raw == ""
-          @author.email = nil if @author.email == ""
-          @author.url = nil if @author.url == ""
+              try_xpaths(author_node, [
+                "url/text()",
+                "uri/text()",
+                "@url",
+                "@uri",
+                "@href"
+              ], :select_result_value => true)
+            )
+          end
+          @author.name = nil if @author.name.blank?
+          @author.raw = nil if @author.raw.blank?
+          @author.email = nil if @author.email.blank?
+          @author.url = nil if @author.url.blank?
         end
         # Fallback on the itunes module if we didn't find an author name
         begin
@@ -1290,15 +1365,14 @@ module FeedTools
     def publisher
       if @publisher.nil?
         @publisher = FeedTools::Feed::Author.new
+        publisher_node = try_xpaths(self.channel_node, [
+          "webMaster/text()",
+          "dc:publisher/text()"
+        ])
 
         # Set the author name
-        @publisher.raw = FeedTools.unescape_entities(
-          XPath.first(channel_node, "dc:publisher/text()").to_s)
-        if @publisher.raw == ""
-          @publisher.raw = FeedTools.unescape_entities(
-            XPath.first(channel_node, "webMaster/text()").to_s)
-        end
-        unless @publisher.raw == ""
+        @publisher.raw = FeedTools.unescape_entities(publisher_node.to_s)
+        unless @publisher.raw.blank?
           raw_scan = @publisher.raw.scan(
             /(.*)\((\b[A-Z0-9._%-\+]+@[A-Z0-9._%-]+\.[A-Z]{2,4}\b)\)/i)
           if raw_scan.nil? || raw_scan.size == 0
@@ -1331,10 +1405,10 @@ module FeedTools
           end
         end
 
-        @publisher.name = nil if @publisher.name == ""
-        @publisher.raw = nil if @publisher.raw == ""
-        @publisher.email = nil if @publisher.email == ""
-        @publisher.url = nil if @publisher.url == ""
+        @publisher.name = nil if @publisher.name.blank?
+        @publisher.raw = nil if @publisher.raw.blank?
+        @publisher.email = nil if @publisher.email.blank?
+        @publisher.url = nil if @publisher.url.blank?
       end
       return @publisher
     end
@@ -1364,9 +1438,12 @@ module FeedTools
     # attribute.
     def itunes_author
       if @itunes_author.nil?
-        @itunes_author = FeedTools.unescape_entities(XPath.first(channel_node,
-          "itunes:author/text()").to_s)
-        @itunes_author = nil if @itunes_author == ""
+        @itunes_author = FeedTools.unescape_entities(
+          try_xpaths(self.channel_node, [
+            "itunes:author/text()"
+          ], :select_result_value => true)
+        )
+        @itunes_author = nil if @itunes_author.blank?
       end
       return @itunes_author
     end
@@ -1374,29 +1451,40 @@ module FeedTools
     # Returns the feed time
     def time
       if @time.nil?
-        unless channel_node.nil?
-          time_string = XPath.first(channel_node, "pubDate/text()").to_s
-          if time_string == ""
-            time_string = XPath.first(channel_node, "dc:date/text()").to_s
-          end
-          if time_string == ""
-            time_string = XPath.first(channel_node, "issued/text()").to_s
-          end
-          if time_string == ""
-            time_string = XPath.first(channel_node, "updated/text()").to_s
-          end
-          if time_string == ""
-            time_string = XPath.first(channel_node, "time/text()").to_s
-          end
-        end
+        time_string = try_xpaths(self.channel_node, [
+          "atom10:updated/text()",
+          "atom03:updated/text()",
+          "atom:updated/text()",
+          "updated/text()",
+          "atom10:modified/text()",
+          "atom03:modified/text()",
+          "atom:modified/text()",
+          "modified/text()",
+          "time/text()",
+          "atom10:issued/text()",
+          "atom03:issued/text()",
+          "atom:issued/text()",
+          "issued/text()",
+          "atom10:published/text()",
+          "atom03:published/text()",
+          "atom:published/text()",
+          "published/text()",
+          "pubDate/text()",
+          "dc:date/text()",
+          "date/text()"
+        ], :select_result_value => true)
         begin
-          if time_string != nil && time_string != ""
+          unless time_string.blank?
             @time = Time.parse(time_string).gmtime
           else
-            @time = Time.now.gmtime
+            if FeedTools.configurations[:timestamp_estimation_enabled]
+              @time = Time.now.gmtime
+            end
           end
         rescue
-          @time = Time.now.gmtime
+          if FeedTools.configurations[:timestamp_estimation_enabled]
+            @time = Time.now.gmtime
+          end
         end
       end
       return @time
@@ -1410,13 +1498,11 @@ module FeedTools
     # Returns the feed item updated time
     def updated
       if @updated.nil?
-        unless channel_node.nil?
-          updated_string = XPath.first(channel_node, "updated/text()").to_s
-          if updated_string == ""
-            updated_string = XPath.first(channel_node, "modified/text()").to_s
-          end
-        end
-        if updated_string != nil && updated_string != ""
+        updated_string = try_xpaths(self.channel_node, [
+          "updated/text()",
+          "modified/text()"
+        ], :select_result_value => true)
+        unless updated_string.blank?
           @updated = Time.parse(updated_string).gmtime rescue nil
         else
           @updated = nil
@@ -1430,51 +1516,16 @@ module FeedTools
       @updated = new_updated
     end
 
-    # Returns the feed item issued time
-    def issued
-      if @issued.nil?
-        unless channel_node.nil?
-          issued_string = XPath.first(channel_node, "issued/text()").to_s
-          if issued_string == ""
-            issued_string = XPath.first(channel_node, "pubDate/text()").to_s
-          end
-          if issued_string == ""
-            issued_string = XPath.first(channel_node, "dc:date/text()").to_s
-          end
-          if issued_string == ""
-            issued_string = XPath.first(channel_node, "published/text()").to_s
-          end
-        end
-        if issued_string != nil && issued_string != ""
-          @issued = Time.parse(issued_string).gmtime rescue nil
-        else
-          @issued = nil
-        end
-      end
-      return @issued
-    end
-  
-    # Sets the feed item issued time
-    def issued=(new_issued)
-      @issued = new_issued
-    end
-
     # Returns the feed item published time
     def published
       if @published.nil?
-        unless channel_node.nil?
-          published_string = XPath.first(channel_node, "published/text()").to_s
-          if published_string == ""
-            published_string = XPath.first(channel_node, "pubDate/text()").to_s
-          end
-          if published_string == ""
-            published_string = XPath.first(channel_node, "dc:date/text()").to_s
-          end
-          if published_string == ""
-            published_string = XPath.first(channel_node, "issued/text()").to_s
-          end
-        end
-        if published_string != nil && published_string != ""
+        published_string = try_xpaths(self.channel_node, [
+          "published/text()",
+          "pubDate/text()",
+          "issued/text()",
+          "dc:date/text()"
+        ], :select_result_value => true)
+        unless published_string.blank?
           @published = Time.parse(published_string).gmtime rescue nil
         else
           @published = nil
@@ -1492,28 +1543,26 @@ module FeedTools
     def categories
       if @categories.nil?
         @categories = []
-        category_nodes = XPath.match(channel_node, "category")
-        if category_nodes.nil? || category_nodes.empty?
-          category_nodes = XPath.match(channel_node, "dc:subject")
-        end
+        category_nodes = try_xpaths_all(self.channel_node, [
+          "category",
+          "dc:subject"
+        ])
         unless category_nodes.nil?
           for category_node in category_nodes
             category = FeedTools::Feed::Category.new
-            category.term = XPath.first(category_node, "@term").to_s
-            if category.term == ""
-              category.term = XPath.first(category_node, "text()").to_s
-            end
-            category.term.strip! unless category.term.nil?
-            category.term = nil if category.term == ""
-            category.label = XPath.first(category_node, "@label").to_s
-            category.label.strip! unless category.label.nil?
-            category.label = nil if category.label == ""
-            category.scheme = XPath.first(category_node, "@scheme").to_s
-            if category.scheme == ""
-              category.scheme = XPath.first(category_node, "@domain").to_s
-            end
-            category.scheme.strip! unless category.scheme.nil?
-            category.scheme = nil if category.scheme == ""
+            category.term = try_xpaths(category_node, [
+              "@term",
+              "text()"
+            ], :select_result_value => true)
+            category.term.strip! unless category.term.blank?
+            category.label = try_xpaths(category_node, ["@label"],
+              :select_result_value => true)
+            category.label.strip! unless category.label.blank?
+            category.scheme = try_xpaths(category_node, [
+              "@scheme",
+              "@domain"
+            ], :select_result_value => true)
+            category.scheme.strip! unless category.scheme.blank?
             @categories << category
           end
         end
@@ -1525,55 +1574,61 @@ module FeedTools
     def images
       if @images.nil?
         @images = []
-        unless channel_node.nil?
-          image_nodes = XPath.match(channel_node, "image")
-          if image_nodes.nil? || image_nodes.empty?
-            image_nodes = XPath.match(channel_node, "link")
-          end
-          if image_nodes.nil? || image_nodes.empty?
-            image_nodes = XPath.match(channel_node, "logo")
-          end
-          if image_nodes.nil? || image_nodes.empty?
-            image_nodes = XPath.match(channel_node, "LOGO")
-          end
-          unless image_nodes.nil?
-            for image_node in image_nodes
-              image = FeedTools::Feed::Image.new
-              image.url = XPath.first(image_node, "url/text()").to_s
-              if image.url == ""
-                image.url = XPath.first(image_node, "@rdf:resource").to_s
-              end
-              if image.url == "" && (image_node.name == "logo" ||
-                  (image_node.attributes['type'] =~ /^image/) == 0)
-                image.url = XPath.first(image_node, "@href").to_s
+        image_nodes = try_xpaths_all(self.channel_node, [
+          "image",
+          "logo",
+          "atom10:link",
+          "atom03:link",
+          "atom:link",
+          "link"
+        ])
+        unless image_nodes.blank?
+          for image_node in image_nodes
+            image = FeedTools::Feed::Image.new
+            image.url = try_xpaths(image_node, [
+              "url/text()",
+              "@rdf:resource"
+            ], :select_result_value => true)
+            if image.url.blank? && (image_node.name == "logo" ||
+                (image_node.attributes['type'].to_s =~ /^image/) == 0)
+              image.url = try_xpaths(image_node, [
+                "@atom10:href",
+                "@atom03:href",
+                "@atom:href",
+                "@href"
+              ], :select_result_value => true)
+              if image.url == self.link && image.url != nil
+                image.url = nil
               end
-              if image.url == "" && image_node.name == "LOGO"
-                image.url = XPath.first(image_node, "@HREF").to_s
-              end
-              image.url.strip! unless image.url.nil?
-              image.url = nil if image.url == ""
-              image.title = XPath.first(image_node, "title/text()").to_s
-              image.title.strip! unless image.title.nil?
-              image.title = nil if image.title == ""
-              image.description =
-                XPath.first(image_node, "description/text()").to_s
-              image.description.strip! unless image.description.nil?
-              image.description = nil if image.description == ""
-              image.link = XPath.first(image_node, "link/text()").to_s
-              image.link.strip! unless image.link.nil?
-              image.link = nil if image.link == ""
-              image.height = XPath.first(image_node, "height/text()").to_s.to_i
-              image.height = nil if image.height <= 0
-              image.width = XPath.first(image_node, "width/text()").to_s.to_i
-              image.width = nil if image.width <= 0
-              image.style = XPath.first(image_node, "@style").to_s.downcase
-              if image.style == ""
-                image.style = XPath.first(image_node, "@STYLE").to_s.downcase
-              end
-              image.style.strip! unless image.style.nil?
-              image.style = nil if image.style == ""
-              @images << image
             end
+            if image.url.blank? && image_node.name == "LOGO"
+              image.url = try_xpaths(image_node, [
+                "@href"
+              ], :select_result_value => true)
+            end
+            image.url.strip! unless image.url.nil?
+            image.title = try_xpaths(image_node,
+              ["title/text()"], :select_result_value => true)
+            image.title.strip! unless image.title.nil?
+            image.description = try_xpaths(image_node,
+              ["description/text()"], :select_result_value => true)
+            image.description.strip! unless image.description.nil?
+            image.link = try_xpaths(image_node,
+              ["link/text()"], :select_result_value => true)
+            image.link.strip! unless image.link.nil?
+            image.height = try_xpaths(image_node,
+              ["height/text()"], :select_result_value => true).to_i
+            image.height = nil if image.height <= 0
+            image.width = try_xpaths(image_node,
+              ["width/text()"], :select_result_value => true).to_i
+            image.width = nil if image.width <= 0
+            image.style = try_xpaths(image_node, [
+              "style/text()",
+              "@style"
+            ], :select_result_value => true)
+            image.style.strip! unless image.style.nil?
+            image.style.downcase! unless image.style.nil?
+            @images << image unless image.url.nil?
           end
         end
       end
@@ -1584,20 +1639,20 @@ module FeedTools
     def text_input
       if @text_input.nil?
         @text_input = FeedTools::Feed::TextInput.new
-        text_input_node = XPath.first(channel_node, "textInput")
+        text_input_node = try_xpaths(self.channel_node, ["textInput"])
         unless text_input_node.nil?
           @text_input.title =
-            XPath.first(text_input_node, "title/text()").to_s
-          @text_input.title = nil if @text_input.title == ""
+            try_xpaths(text_input_node, ["title/text()"],
+              :select_result_value => true)
           @text_input.description =
-            XPath.first(text_input_node, "description/text()").to_s
-          @text_input.description = nil if @text_input.description == ""
+            try_xpaths(text_input_node, ["description/text()"],
+              :select_result_value => true)
           @text_input.link =
-            XPath.first(text_input_node, "link/text()").to_s
-          @text_input.link = nil if @text_input.link == ""
+            try_xpaths(text_input_node, ["link/text()"],
+              :select_result_value => true)
           @text_input.name =
-            XPath.first(text_input_node, "name/text()").to_s
-          @text_input.name = nil if @text_input.name == ""
+            try_xpaths(text_input_node, ["name/text()"],
+              :select_result_value => true)
         end
       end
       return @text_input
@@ -1606,43 +1661,28 @@ module FeedTools
     # Returns the feed's copyright information
     def copyright
       if @copyright.nil?
-        unless root_node.nil?
-          repair_entities = false
-          copyright_node = XPath.first(channel_node, "dc:rights")
-          if copyright_node.nil?
-            copyright_node = XPath.first(channel_node, "dc:rights",
-              FEED_TOOLS_NAMESPACES)
-          end
-          if copyright_node.nil?
-            copyright_node = XPath.first(channel_node, "rights",
-              FEED_TOOLS_NAMESPACES)
-          end
-          if copyright_node.nil?
-            copyright_node = XPath.first(channel_node, "copyright",
-              FEED_TOOLS_NAMESPACES)
-          end
-          if copyright_node.nil?
-            copyright_node = XPath.first(channel_node, "atom03:copyright",
-              FEED_TOOLS_NAMESPACES)
-          end
-          if copyright_node.nil?
-            copyright_node = XPath.first(channel_node, "atom10:copyright",
-              FEED_TOOLS_NAMESPACES)
-          end
-          if copyright_node.nil?
-            copyright_node = XPath.first(channel_node, "copyrights",
-              FEED_TOOLS_NAMESPACES)
-          end
-        end
+        repair_entities = false
+        copyright_node = try_xpaths(self.channel_node, [
+          "atom10:copyright",
+          "atom03:copyright",
+          "atom:copyright",
+          "copyright",
+          "copyrights",
+          "dc:rights",
+          "rights"
+        ])
         if copyright_node.nil?
           return nil
         end
-        copyright_type = XPath.first(copyright_node, "@type").to_s
-        copyright_mode = XPath.first(copyright_node, "@mode").to_s
-        copyright_encoding = XPath.first(copyright_node, "@encoding").to_s
+        copyright_type = try_xpaths(copyright_node, "@type",
+          :select_result_value => true)
+        copyright_mode = try_xpaths(copyright_node, "@mode",
+          :select_result_value => true)
+        copyright_encoding = try_xpaths(copyright_node, "@encoding",
+          :select_result_value => true)
 
         # Note that we're checking for misuse of type, mode and encoding here
-        if copyright_encoding != ""
+        if !copyright_encoding.blank?
           @copyright =
             "[Embedded data objects are not currently supported.]"
         elsif copyright_node.cdatas.size > 0
@@ -1669,7 +1709,7 @@ module FeedTools
         end
 
         @copyright = @copyright.strip unless @copyright.nil?
-        @copyright = nil if @copyright == ""
+        @copyright = nil if @copyright.blank?
       end
       return @copyright
     end
@@ -1684,9 +1724,11 @@ module FeedTools
       if @time_to_live.nil?
         unless channel_node.nil?
           # get the feed time to live from the xml document
-          update_frequency = XPath.first(channel_node, "syn:updateFrequency/text()").to_s
-          if update_frequency != ""
-            update_period = XPath.first(channel_node, "syn:updatePeriod/text()").to_s
+          update_frequency = try_xpaths(self.channel_node,
+            ["syn:updateFrequency/text()"], :select_result_value => true)
+          if !update_frequency.blank?
+            update_period = try_xpaths(self.channel_node,
+              ["syn:updatePeriod/text()"], :select_result_value => true)
             if update_period == "daily"
               @time_to_live = update_frequency.to_i.day
             elsif update_period == "weekly"
@@ -1702,9 +1744,11 @@ module FeedTools
           end
           if @time_to_live.nil?
             # usually expressed in minutes
-            update_frequency = XPath.first(channel_node, "ttl/text()").to_s
-            if update_frequency != ""
-              update_span = XPath.first(channel_node, "ttl/@span").to_s
+            update_frequency = try_xpaths(self.channel_node, ["ttl/text()"],
+              :select_result_value => true)
+            if !update_frequency.blank?
+              update_span = try_xpaths(self.channel_node, ["ttl/@span"],
+                :select_result_value => true)
               if update_span == "seconds"
                 @time_to_live = update_frequency.to_i
               elsif update_span == "minutes"
@@ -1719,19 +1763,6 @@ module FeedTools
                 @time_to_live = update_frequency.to_i.month
               elsif update_span == "years"
                 @time_to_live = update_frequency.to_i.year
-              elsif update_frequency.to_i >= 3000
-                # Normally, this should default to minutes, but realistically,
-                # if they meant minutes, you're rarely going to see a value
-                # higher than 120.  If we see >= 3000, we're either dealing
-                # with a stupid pseudo-spec that decided to use seconds, or
-                # we're looking at someone who only has weekly updated
-                # content.  Worst case, we misreport the time, and we update
-                # too often.  Best case, we avoid accidentally updating the
-                # feed only once a year.  In the interests of being pragmatic,
-                # and since the problem we avoid is a far greater one than
-                # the one we cause, just run the check and hope no one
-                # actually gets hurt.
-                @time_to_live = update_frequency.to_i
               else
                 @time_to_live = update_frequency.to_i.minute
               end
@@ -1740,7 +1771,7 @@ module FeedTools
           if @time_to_live.nil?
             @time_to_live = 0
             update_frequency_days =
-              XPath.first(channel_node, "schedule/intervaltime/@days").to_s
+              XPath.first(channel_node, "SCHEDULE/INTERVALTIME/@DAY").to_s
             update_frequency_hours =
               XPath.first(channel_node, "schedule/intervaltime/@hour").to_s
             update_frequency_minutes =
@@ -1769,6 +1800,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
       end
       @time_to_live = @time_to_live.round
       return @time_to_live
@@ -1784,20 +1819,21 @@ module FeedTools
     def cloud
       if @cloud.nil?
         @cloud = FeedTools::Feed::Cloud.new
-        @cloud.domain = XPath.first(channel_node, "cloud/@domain").to_s
-        @cloud.port = XPath.first(channel_node, "cloud/@port").to_s
-        @cloud.path = XPath.first(channel_node, "cloud/@path").to_s
+        @cloud.domain = try_xpaths(self.channel_node, ["cloud/@domain"],
+          :select_result_value => true)
+        @cloud.port = try_xpaths(self.channel_node, ["cloud/@port"],
+          :select_result_value => true)
+        @cloud.path = try_xpaths(self.channel_node, ["cloud/@path"],
+          :select_result_value => true)
         @cloud.register_procedure =
-          XPath.first(channel_node, "cloud/@registerProcedure").to_s
+          try_xpaths(self.channel_node, ["cloud/@registerProcedure"],
+            :select_result_value => true)
         @cloud.protocol =
-          XPath.first(channel_node, "cloud/@protocol").to_s.downcase
-        @cloud.domain = nil if @cloud.domain == ""
-        @cloud.port = nil if @cloud.port == ""
-        @cloud.port = @cloud.port.to_i unless @cloud.port.nil?
+          try_xpaths(self.channel_node, ["cloud/@protocol"],
+            :select_result_value => true)
+        @cloud.protocol.downcase unless @cloud.protocol.nil?
+        @cloud.port = @cloud.port.to_s.to_i
         @cloud.port = nil if @cloud.port == 0
-        @cloud.path = nil if @cloud.path == ""
-        @cloud.register_procedure = nil if @cloud.register_procedure == ""
-        @cloud.protocol = nil if @cloud.protocol == ""
       end
       return @cloud
     end
@@ -1810,9 +1846,9 @@ module FeedTools
     # Returns the feed generator
     def generator
       if @generator.nil?
-        @generator = XPath.first(channel_node, "generator/text()").to_s
-        @generator = FeedTools.strip_html(@generator)
-        @generator = nil if @generator == ""
+        @generator = try_xpaths(self.channel_node, ["generator/text()"],
+          :select_result_value => true)
+        @generator = FeedTools.strip_html(@generator) unless @generator.nil?
       end
       return @generator
     end
@@ -1825,9 +1861,9 @@ module FeedTools
     # Returns the feed docs
     def docs
       if @docs.nil?
-        @docs = XPath.first(channel_node, "docs/text()").to_s
-        @docs = FeedTools.strip_html(@docs)
-        @docs = nil if @docs == ""
+        @docs = try_xpaths(self.channel_node, ["docs/text()"],
+          :select_result_value => true)
+        @docs = FeedTools.strip_html(@docs) unless @docs.nil?
       end
       return @docs
     end
@@ -1840,23 +1876,23 @@ module FeedTools
     # Returns the feed language
     def language
       if @language.nil?
-        unless channel_node.nil?
-          @language = XPath.first(channel_node, "language/text()").to_s
-          if @language == ""
-            @language = XPath.first(channel_node, "dc:language/text()").to_s
-          end
-          if @language == ""
-            @language = XPath.first(channel_node, "xml:lang/text()").to_s
-          end
-          if @language == ""
-            @language = XPath.first(root_node, "xml:lang/text()").to_s
-          end
-        end
-        if @language == "" || @language.nil?
+        @language = select_not_blank([
+          try_xpaths(self.channel_node, [
+            "language/text()",
+            "dc:language/text()",
+            "@dc:language",
+            "@xml:lang",
+            "xml:lang/text()"
+          ], :select_result_value => true),
+          try_xpaths(self.root_node, [
+            "@xml:lang",
+            "xml:lang/text()"
+          ], :select_result_value => true)
+        ])
+        if @language.blank?
           @language = "en-us"
         end
         @language = @language.downcase
-        @language = nil if @language == ""
       end
       return @language
     end
@@ -1869,12 +1905,11 @@ module FeedTools
     # Returns true if this feed contains explicit material.
     def explicit?
       if @explicit.nil?
-        if XPath.first(channel_node,
-              "media:adult/text()").to_s.downcase == "true" ||
-            XPath.first(channel_node,
-              "itunes:explicit/text()").to_s.downcase == "yes" ||
-            XPath.first(channel_node,
-              "itunes:explicit/text()").to_s.downcase == "true"
+        explicit_string = try_xpaths(self.channel_node, [
+          "media:adult/text()",
+          "itunes:explicit/text()"
+        ], :select_result_value => true)
+        if explicit_string == "true" || explicit_string == "yes"
           @explicit = true
         else
           @explicit = false
@@ -1888,66 +1923,68 @@ module FeedTools
       @explicit = (new_explicit ? true : false)
     end
   
-    # Returns the feed items
-    def items
-      if @items.nil?
-        unless root_node.nil?
-          raw_items = XPath.match(root_node, "item")
-          if raw_items == nil || raw_items == []
-            raw_items = XPath.match(channel_node, "item")
-          end
-          if raw_items == nil || raw_items == []
-            raw_items = XPath.match(channel_node, "ITEM")
-          end
-          if raw_items == nil || raw_items == []
-            raw_items = XPath.match(root_node, "ITEM")
-          end
-          if raw_items == nil || raw_items == []
-            raw_items = XPath.match(channel_node, "entry")
-          end
-          if raw_items == nil || raw_items == []
-            raw_items = XPath.match(root_node, "entry")
-          end
-        end
+    # Returns the feed entries
+    def entries
+      if @entries.blank?
+        raw_entries = select_not_blank([
+          try_xpaths_all(self.channel_node, [
+            "atom10:entry",
+            "atom03:entry",
+            "atom:entry",
+            "entry"
+          ]),
+          try_xpaths_all(self.root_node, [
+            "rss10:item",
+            "item",
+            "atom10:entry",
+            "atom03:entry",
+            "atom:entry",
+            "entry"
+          ]),
+          try_xpaths_all(self.channel_node, [
+            "rss10:item",
+            "item"
+          ])
+        ])
 
         # create the individual feed items
-        @items = []
-        if raw_items != nil
-          for item_node in raw_items.reverse
-            new_item = FeedItem.new
-            new_item.feed_data = item_node.to_s
-            new_item.feed_data_type = self.feed_data_type
-            @items << new_item
+        @entries = []
+        unless raw_entries.blank?
+          for entry_node in raw_entries.reverse
+            new_entry = FeedItem.new
+            new_entry.feed_data = entry_node.to_s
+            new_entry.feed_data_type = self.feed_data_type
+            @entries << new_entry
           end
         end
       end
     
       # Sort the items
-      @items = @items.sort do |a,b|
-        (b.time or Time.mktime(1970)) <=> (a.time or Time.mktime(1970))
+      @entries = @entries.sort do |a, b|
+        (b.time or Time.utc(1970)) <=> (a.time or Time.utc(1970))
       end
-      return @items
+      return @entries
     end
 
-    # Sets the items array to a new array.
-    def items=(new_items)
-      for item in new_items
-        unless item.kind_of? FeedTools::FeedItem
+    # Sets the entries array to a new array.
+    def entries=(new_entries)
+      for entry in new_entries
+        unless entry.kind_of? FeedTools::FeedItem
           raise ArgumentError,
-            "You should only add FeedItem objects to the items array."
+            "You should only add FeedItem objects to the entries array."
         end
       end
-      @items = new_items
+      @entries = new_entries
     end
     
     # Syntactic sugar for appending feed items to a feed.
-    def <<(new_item)
-      @items ||= []
-      unless new_item.kind_of? FeedTools::FeedItem
+    def <<(new_entry)
+      @entries ||= []
+      unless new_entry.kind_of? FeedTools::FeedItem
         raise ArgumentError,
-          "You should only add FeedItem objects to the items array."
+          "You should only add FeedItem objects to the entries array."
       end
-      @items << new_item
+      @entries << new_entry
     end
   
     # The time that the feed was last requested from the remote server.  Nil
@@ -2020,11 +2057,14 @@ module FeedTools
     end
 
     # Generates xml based on the content of the feed
-    def build_xml(feed_type=(self.feed_type or "rss"), version=nil,
-        xml_builder=Builder::XmlMarkup.new(:indent => 2))
-      if feed_type == "rss" && (version == nil || version == 0.0)
+    def build_xml(feed_type=(self.feed_type or "atom"), version=nil,
+        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")
+      if feed_type == "rss" && (version == nil || version <= 0.0)
         version = 1.0
-      elsif feed_type == "atom" && (version == nil || version == 0.0)
+      elsif feed_type == "atom" && (version == nil || version <= 0.0)
         version = 1.0
       end
       if feed_type == "rss" && (version == 0.9 || version == 1.0 ||
@@ -2040,7 +2080,8 @@ module FeedTools
             "xmlns:media" => FEED_TOOLS_NAMESPACES['media']) do
           channel_attributes = {}
           unless self.link.nil?
-            channel_attributes["rdf:about"] = CGI.escapeHTML(self.link)
+            channel_attributes["rdf:about"] =
+              FeedTools.escape_entities(self.link)
           end
           xml_builder.channel(channel_attributes) do
             unless title.nil? || title == ""
@@ -2054,7 +2095,7 @@ module FeedTools
               xml_builder.link
             end
             unless images.nil? || images.empty?
-              xml_builder.image("rdf:resource" => CGI.escapeHTML(
+              xml_builder.image("rdf:resource" => FeedTools.escape_entities(
                 images.first.url))
             end
             unless description.nil? || description == ""
@@ -2078,7 +2119,7 @@ module FeedTools
                         "item link field."
                     end
                     xml_builder.tag!("rdf:li", "rdf:resource" =>
-                      CGI.escapeHTML(item.link))
+                      FeedTools.escape_entities(item.link))
                   end
                 end
               end
@@ -2095,20 +2136,20 @@ module FeedTools
             end
             best_image = images.first if best_image.nil?
             xml_builder.image(
-                "rdf:about" => CGI.escapeHTML(best_image.url)) do
-              if best_image.title != nil && best_image.title != ""
+                "rdf:about" => FeedTools.escape_entities(best_image.url)) do
+              if !best_image.title.blank?
                 xml_builder.title(best_image.title)
-              elsif self.title != nil && self.title != ""
+              elsif !self.title.blank?
                 xml_builder.title(self.title)
               else
                 xml_builder.title
               end
-              unless best_image.url.nil? || best_image.url == ""
+              unless best_image.url.blank?
                 xml_builder.url(best_image.url)
               end
-              if best_image.link != nil && best_image.link != ""
+              if !best_image.link.blank?
                 xml_builder.link(best_image.link)
-              elsif self.link != nil && self.link != ""
+              elsif !self.link.blank?
                 xml_builder.link(self.link)
               else
                 xml_builder.link
@@ -2131,18 +2172,18 @@ module FeedTools
             "xmlns:itunes" => FEED_TOOLS_NAMESPACES['itunes'],
             "xmlns:media" => FEED_TOOLS_NAMESPACES['media']) do
           xml_builder.channel do
-            unless title.nil? || title == ""
+            unless title.blank?
               xml_builder.title(title)
             end
-            unless link.nil? || link == ""
+            unless link.blank?
               xml_builder.link(link)
             end
-            unless description.nil? || description == ""
+            unless description.blank?
               xml_builder.description(description)
             end
             xml_builder.ttl((time_to_live / 1.minute).to_s)
             xml_builder.generator(
-              "http://www.sporkmonger.com/projects/feedtools")
+              FeedTools.configurations[:generator_href])
             build_xml_hook(feed_type, version, xml_builder)
             unless items.nil?
               for item in items
@@ -2152,53 +2193,12 @@ module FeedTools
           end
         end
       elsif feed_type == "atom" && version == 0.3
-        # normal atom format
-        return xml_builder.feed("xmlns" => FEED_TOOLS_NAMESPACES['atom03'],
-            "version" => version,
-            "xml:lang" => language) do
-          unless title.nil? || title == ""
-            xml_builder.title(title,
-                "mode" => "escaped",
-                "type" => "text/html")
-          end
-          xml_builder.author do
-            unless self.author.nil? || self.author.name.nil?
-              xml_builder.name(self.author.name)
-            else
-              xml_builder.name("n/a")
-            end
-            unless self.author.nil? || self.author.email.nil?
-              xml_builder.email(self.author.email)
-            end
-            unless self.author.nil? || self.author.url.nil?
-              xml_builder.url(self.author.url)
-            end
-          end
-          unless link.nil? || link == ""
-            xml_builder.link("href" => link,
-                "rel" => "alternate",
-                "type" => "text/html",
-                "title" => title)
-          end
-          unless description.nil? || description == ""
-            xml_builder.tagline(description,
-                "mode" => "escaped",
-                "type" => "text/html")
-          end
-          xml_builder.generator("FeedTools",
-              "url" => "http://www.sporkmonger.com/projects/feedtools")
-          build_xml_hook(feed_type, version, xml_builder)
-          unless items.nil?
-            for item in items
-              item.build_xml(feed_type, version, xml_builder)
-            end
-          end
-        end
+        raise "Atom 0.3 is obsolete."
       elsif feed_type == "atom" && version == 1.0
         # normal atom format
         return xml_builder.feed("xmlns" => FEED_TOOLS_NAMESPACES['atom10'],
             "xml:lang" => language) do
-          unless title.nil? || title == ""
+          unless title.blank?
             xml_builder.title(title,
                 "type" => "html")
           end
@@ -2212,22 +2212,22 @@ module FeedTools
               xml_builder.email(self.author.email)
             end
             unless self.author.nil? || self.author.url.nil?
-              xml_builder.url(self.author.url)
+              xml_builder.uri(self.author.url)
             end
           end
-          unless self.url.nil? || self.url == ""
+          unless self.url.blank?
             xml_builder.link("href" => self.url,
                 "rel" => "self",
                 "type" => "application/atom+xml")
           end
-          unless self.link.nil? || self.link == ""
-            xml_builder.link("href" => self.link,
+          unless self.link.blank?
+            xml_builder.link("href" => FeedTools.escape_entities(self.link),
                 "rel" => "alternate",
                 "type" => "text/html",
-                "title" => self.title)
+                "title" => FeedTools.escape_entities(self.title))
           end
-          unless description.nil? || description == ""
-            xml_builder.subtitle(description,
+          unless description.blank?
+            xml_builder.subtitle(self.subtitle,
                 "type" => "html")
           else
             xml_builder.subtitle(FeedTools.no_content_string,
@@ -2242,8 +2242,8 @@ module FeedTools
           else
             xml_builder.updated(Time.now.gmtime.iso8601)
           end
-          xml_builder.generator("FeedTools - " +
-            "http://www.sporkmonger.com/projects/feedtools")
+          xml_builder.generator(FeedTools.configurations[:generator_name] +
+            " - " + FeedTools.configurations[:generator_href])
           if self.id != nil
             unless FeedTools.is_uri? self.id
               if self.link != nil
@@ -2266,46 +2266,49 @@ module FeedTools
             end
           end
         end
+      else
+        raise "Unsupported feed format/version."
       end
     end
 
     # Persists the current feed state to the cache.
     def save
-      if FeedTools.feed_cache.nil?
-        raise "Caching is currently disabled.  Cannot save to cache."
-      elsif self.url.nil?
-        raise "The url field must be set to save to the cache."
-      elsif self.cache_object.nil?
-        raise "The cache_object is currently nil.  Cannot save to cache."
-      else
-        self.cache_object.url = self.url
-        unless self.feed_data.nil?
-          self.cache_object.title = self.title
-          self.cache_object.link = self.link
-          self.cache_object.feed_data = self.feed_data
-          self.cache_object.feed_data_type = self.feed_data_type.to_s
-        end
-        unless self.http_response.nil?
+      unless self.url =~ /^file:\/\//
+        if FeedTools.feed_cache.nil?
+          raise "Caching is currently disabled.  Cannot save to cache."
+        elsif self.url.nil?
+          raise "The url field must be set to save to the cache."
+        elsif self.cache_object.nil?
+          raise "The cache_object is currently nil.  Cannot save to cache."
+        else
+          self.cache_object.url = self.url
+          unless self.feed_data.nil?
+            self.cache_object.title = self.title
+            self.cache_object.link = self.link
+            self.cache_object.feed_data = self.feed_data
+            self.cache_object.feed_data_type = self.feed_data_type.to_s
+          end
           self.cache_object.http_headers = self.http_headers.to_yaml
+          self.cache_object.last_retrieved = self.last_retrieved
+          self.cache_object.save
         end
-        self.cache_object.last_retrieved = self.last_retrieved
-        self.cache_object.save
       end
     end
   
-    alias_method :tagline, :description
-    alias_method :tagline=, :description=
-    alias_method :subtitle, :description
-    alias_method :subtitle=, :description=
-    alias_method :abstract, :description
-    alias_method :abstract=, :description=
-    alias_method :content, :description
-    alias_method :content=, :description=
+    alias_method :tagline, :subtitle
+    alias_method :tagline=, :subtitle=
+    alias_method :description, :subtitle
+    alias_method :description=, :subtitle=
+    alias_method :abstract, :subtitle
+    alias_method :abstract=, :subtitle=
+    alias_method :content, :subtitle
+    alias_method :content=, :subtitle=
     alias_method :ttl, :time_to_live
     alias_method :ttl=, :time_to_live=
     alias_method :guid, :id
     alias_method :guid=, :id=
-    alias_method :entries, :items
+    alias_method :items, :entries
+    alias_method :items=, :entries=
   
     # passes missing methods to the cache_object
     def method_missing(msg, *params)