feedtools 0.2.22 → 0.2.23

data/lib/feed_tools/database_feed_cache.rb

@@ -31,7 +31,7 @@ module FeedTools
   # The default caching mechanism for the FeedTools module
   class DatabaseFeedCache < ActiveRecord::Base
     # Overrides the default table name to use the "feeds" table.
-    def self.table_name() "feeds" end
+    set_table_name("cached_feeds")
   
     # If ActiveRecord is not already connected, attempts to find a configuration file and use
     # it to open a connection for ActiveRecord.
@@ -53,7 +53,8 @@ module FeedTools
             "./config/database.yml",
             "../config/database.yml",
             "./database.yml",
-            "../database.yml"
+            "../database.yml",
+            "../../database.yml"
           ]
           database_config_file = nil
           for file in possible_config_files
@@ -108,7 +109,7 @@ module FeedTools
     # True if the appropriate database table already exists
     def DatabaseFeedCache.table_exists?
       begin
-        ActiveRecord::Base.connection.execute "select id, url, 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"
       rescue ActiveRecord::StatementInvalid

data/lib/feed_tools/feed.rb

@@ -21,124 +21,27 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
+require 'rexml/document'
+require 'feed_tools/feed_item'
+require 'feed_tools/feed_structures'
 require 'feed_tools/helpers/generic_helper'
+require 'feed_tools/helpers/xml_helper'
+require 'feed_tools/helpers/html_helper'
 
 module FeedTools
   # The <tt>FeedTools::Feed</tt> class represents a web feed's structure.
   class Feed
-    # :stopdoc:
-    include REXML
-    class << self
-      include FeedTools::GenericHelper
-      private :validate_options
-    end
-    include FeedTools::GenericHelper
-    private :validate_options
-    # :startdoc:
-  
-    # Represents a feed/feed item's category
-    class Category
-    
-      # The category term value
-      attr_accessor :term
-      # The categorization scheme
-      attr_accessor :scheme
-      # A human-readable description of the category
-      attr_accessor :label
-    
-      alias_method :value, :term
-      alias_method :category, :term
-      alias_method :domain, :scheme
-    end
-  
-    # Represents a feed/feed item's author
-    class Author
-
-      # The author's real name
-      attr_accessor :name
-      # The author's email address
-      attr_accessor :email
-      # The url of the author's homepage
-      attr_accessor :url
-      # The raw value of the author tag if present
-      attr_accessor :raw
-    end
-  
-    # Represents a feed's image
-    class Image
-
-      # The image's title
-      attr_accessor :title
-      # The image's description
-      attr_accessor :description
-      # The image's url
-      attr_accessor :url
-      # The url to link the image to
-      attr_accessor :link
-      # The width of the image
-      attr_accessor :width
-      # The height of the image
-      attr_accessor :height
-      # The style of the image
-      # Possible values are "icon", "image", or "image-wide"
-      attr_accessor :style
-    end
-
-    # Represents a feed's text input element.
-    # Be aware that this will be ignored for feed generation.  It's a
-    # pointless element that aggregators usually ignore and it doesn't have an
-    # equivalent in all feeds types.
-    class TextInput
-
-      # The label of the Submit button in the text input area.
-      attr_accessor :title
-      # The description explains the text input area.
-      attr_accessor :description
-      # The URL of the CGI script that processes text input requests.
-      attr_accessor :link
-      # The name of the text object in the text input area.
-      attr_accessor :name
-    end
-  
-    # Represents a feed's cloud.
-    # Be aware that this will be ignored for feed generation.
-    class Cloud
-
-      # The domain of the cloud.
-      attr_accessor :domain
-      # The path for the cloud.
-      attr_accessor :path
-      # The port the cloud is listening on.
-      attr_accessor :port
-      # The web services protocol the cloud uses.
-      # Possible values are either "xml-rpc" or "soap".
-      attr_accessor :protocol
-      # The procedure to use to request notification.
-      attr_accessor :register_procedure
-    end
-  
-    # Represents a simple hyperlink
-    class Link
-
-      # The url that is being linked to
-      attr_accessor :url
-      # The content of the hyperlink
-      attr_accessor :value
-    
-      alias_method :href, :url
-    end
-  
     # Initialize the feed object
     def initialize
       super
       @cache_object = nil
       @http_headers = nil
-      @xml_doc = nil
+      @xml_document = nil
       @feed_data = nil
       @feed_data_type = :xml
       @root_node = nil
       @channel_node = nil
-      @url = nil
+      @href = nil
       @id = nil
       @title = nil
       @description = nil
@@ -147,6 +50,7 @@ module FeedTools
       @time_to_live = nil
       @entries = nil
       @live = false
+      @encoding = nil
     end
           
     # Loads the feed specified by the url, pulling the data from the
@@ -155,7 +59,7 @@ module FeedTools
     # * <tt>:cache_only</tt> - If set to true, the feed will only be
     #   pulled from the cache.
     def Feed.open(url, options={})
-      validate_options([ :cache_only ],
+      FeedTools::GenericHelper.validate_options([ :cache_only ],
                        options.keys)
       options = { :cache_only => false }.merge(options)
       
@@ -165,17 +69,17 @@ module FeedTools
       end
       
       # clean up the url
-      url = FeedTools.normalize_url(url)
+      url = FeedTools::UriHelper.normalize_url(url)
 
       # create and load the new feed
       feed = FeedTools::Feed.new
-      feed.url = url
+      feed.href = url
       feed.update! unless options[:cache_only]
       return feed
     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.
+    # 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 !FeedTools.feed_cache.nil? &&
           !FeedTools.feed_cache.set_up_correctly?
@@ -193,6 +97,32 @@ module FeedTools
         @live = false
       else
         load_remote_feed!
+        
+        # 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,
+              "application/atom+xml")
+          if autodiscovered_url.nil?
+            autodiscovered_url =
+              FeedTools::HtmlHelper.extract_link_by_mime_type(self.feed_data,
+                "application/rss+xml")
+          end
+          if autodiscovered_url.nil?
+            autodiscovered_url =
+              FeedTools::HtmlHelper.extract_link_by_mime_type(self.feed_data,
+                "application/rdf+xml")
+          end
+          unless autodiscovered_url.nil?
+            self.feed_data = nil
+            self.href = autodiscovered_url
+            self.expire! unless self.cache_object.nil?
+            self.update!
+          end
+        end
       end
     end
   
@@ -207,20 +137,20 @@ module FeedTools
         @http_headers = YAML.load(self.cache_object.http_headers)
       end
     
-      if (self.url =~ /^feed:/) == 0
+      if (self.href =~ /^feed:/) == 0
         # Woah, Nelly, how'd that happen?  You should've already been
         # corrected.  So let's fix that url.  And please,
         # just use less crappy browsers instead of badly defined
         # pseudo-protocol hacks.
-        self.url = FeedTools.normalize_url(self.url)
+        self.href = FeedTools::UriHelper.normalize_url(self.href)
       end
     
       # Find out what method we're going to be using to obtain this feed.
       begin
-        uri = URI.parse(self.url)
+        uri = URI.parse(self.href)
       rescue URI::InvalidURIError
         raise FeedAccessError,
-          "Cannot retrieve feed using invalid URL: " + self.url.to_s
+          "Cannot retrieve feed using invalid URL: " + self.href.to_s
       end
       retrieval_method = "http"
       case uri.scheme
@@ -262,12 +192,15 @@ module FeedTools
             feed_uri = URI.parse(feed_url)
           rescue URI::InvalidURIError
             # Uh, maybe try to fix it?
-            feed_uri = URI.parse(FeedTools.normalize_url(feed_url))
+            feed_uri = URI.parse(FeedTools::UriHelper.normalize_url(feed_url))
           end
           
           begin
-            # TODO: Proxy host and proxy port would go here if implemented
-            http = Net::HTTP.new(feed_uri.host, (feed_uri.port or 80))
+            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
@@ -282,7 +215,7 @@ module FeedTools
                   if redirected_response.last.code.to_i == 301
                     # Reset the cache object or we may get duplicate entries
                     self.cache_object = nil
-                    self.url = redirected_response.last['location']
+                    self.href = redirected_response.last['location']
                   else
                     # Jump out as soon as we hit anything that isn't a
                     # permanently moved redirection.
@@ -316,7 +249,7 @@ module FeedTools
                       if !cached_feed.expired? &&
                           !cached_feed.http_headers.blank?
                         # Copy the cached state
-                        self.url = cached_feed.url
+                        self.href = cached_feed.href
 
                         @feed_data = cached_feed.feed_data
                         @feed_data_type = cached_feed.feed_data_type
@@ -372,7 +305,7 @@ module FeedTools
       
         begin
           begin
-            @http_response = http_fetch.call(self.url, headers, 10, [], false)
+            @http_response = http_fetch.call(self.href, headers, 10, [], false)
           rescue => error
             if error.respond_to?(:response)
               # You might not believe this, but...
@@ -385,8 +318,8 @@ module FeedTools
               # we get to blame other people's bad software and/or bad
               # configuration files.
               if error.response.code.to_i == 404 &&
-                  FeedTools.user_agent != nil
-                @http_response = http_fetch.call(self.url, {}, 10, [], true)
+                  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 " +
@@ -464,14 +397,18 @@ module FeedTools
         # Not supported... yet
       elsif retrieval_method == "ftp"
         # Not supported... yet
-        # Technically, CDF feeds are supposed to be able to be accessed directly
-        # from an ftp server.  This is silly, but we'll humor Microsoft.
+        # Technically, CDF feeds are supposed to be able to be accessed
+        # directly from an ftp server.  This is silly, but we'll humor
+        # Microsoft.
         #
-        # Eventually.
+        # Eventually.  If they're lucky.  And someone demands it.
       elsif retrieval_method == "file"
         # Now that we've gone to all that trouble to ensure the url begins
         # with 'file://', strip the 'file://' off the front of the url.
-        file_name = self.url.gsub(/^file:\/\//, "")
+        file_name = self.href.gsub(/^file:\/\//, "")
+        if RUBY_PLATFORM =~ /mswin/
+          file_name = file_name[1..-1] if file_name[1..1] == "/"
+        end
         begin
           open(file_name) do |file|
             @http_response = nil
@@ -520,7 +457,7 @@ module FeedTools
         unless self.http_headers.blank?
           @encoding = "utf-8"
         else
-          @encoding = self.encoding_from_xml_data
+          @encoding = self.encoding_from_feed_data
         end
       end
       return @encoding
@@ -528,8 +465,8 @@ module FeedTools
     
     # 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?
+    def encoding_from_feed_data
+      if @encoding_from_feed_data.nil?
         raw_data = self.feed_data
         encoding_from_xml_instruct = 
           raw_data.scan(
@@ -539,7 +476,7 @@ module FeedTools
           encoding_from_xml_instruct.downcase!
         end
         if encoding_from_xml_instruct.blank?
-          doc = Document.new(raw_data)
+          doc = REXML::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
@@ -547,7 +484,7 @@ module FeedTools
             encoding_from_xml_instruct = nil
           end
         else
-          @encoding_from_xml_data = encoding_from_xml_instruct
+          @encoding_from_feed_data = encoding_from_xml_instruct
         end
         if encoding_from_xml_instruct.blank?
           sniff_table = {
@@ -556,17 +493,17 @@ module FeedTools
           }
           sniff = self.feed_data[0..3]
           if sniff_table[sniff] != nil
-            @encoding_from_xml_data = sniff_table[sniff].downcase
+            @encoding_from_feed_data = sniff_table[sniff].downcase
           end
         else
-          @encoding_from_xml_data = encoding_from_xml_instruct
+          @encoding_from_feed_data = encoding_from_xml_instruct
         end
-        if @encoding_from_xml_data.blank?
+        if @encoding_from_feed_data.blank?
           # Safest assumption
-          @encoding_from_xml_data = "utf-8"
+          @encoding_from_feed_data = "utf-8"
         end
       end
-      return @encoding_from_xml_data
+      return @encoding_from_feed_data
     end
   
     # Returns the feed's raw data.
@@ -581,11 +518,10 @@ module FeedTools
   
     # Sets the feed's data.
     def feed_data=(new_feed_data)
+      for var in self.instance_variables
+        self.instance_variable_set(var, nil)
+      end
       @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
@@ -637,25 +573,25 @@ module FeedTools
     end
   
     # Returns a REXML Document of the feed_data
-    def xml
+    def xml_document
       if self.feed_data_type != :xml
-        @xml_doc = nil
+        @xml_document = nil
       else
-        if @xml_doc.nil?
+        if @xml_document.nil?
           begin
             begin
-              @xml_doc = Document.new(self.feed_data_utf_8,
-                :ignore_whitespace_nodes => :all)
+              @xml_document = REXML::Document.new(self.feed_data_utf_8)
             rescue Object
               # Something failed, attempt to repair the xml with htree.
-              @xml_doc = HTree.parse(self.feed_data_utf_8).to_rexml
+              @xml_document = HTree.parse(self.feed_data_utf_8).to_rexml
             end
           rescue Object
-            @xml_doc = nil
+            @xml_document = nil
+            raise
           end
         end
       end
-      return @xml_doc
+      return @xml_document
     end
   
     # Returns the first node within the channel_node that matches the xpath
@@ -664,7 +600,7 @@ module FeedTools
       if self.feed_data_type != :xml
         raise "The feed data type is not xml."
       end
-      return try_xpaths(self.channel_node, [xpath],
+      return FeedTools::XmlHelper.try_xpaths(self.channel_node, [xpath],
         :select_result_value => select_result_value)
     end
   
@@ -673,7 +609,7 @@ module FeedTools
       if self.feed_data_type != :xml
         raise "The feed data type is not xml."
       end
-      return try_xpaths_all(self.channel_node, [xpath],
+      return FeedTools::XmlHelper.try_xpaths_all(self.channel_node, [xpath],
         :select_result_value => select_result_value)
     end
   
@@ -685,10 +621,10 @@ module FeedTools
         # E.g.: http://smogzer.tripod.com/smog.rdf
         # ===================================================================
         begin
-          if xml.nil?
+          if self.xml_document.nil?
             return nil
           else
-            @root_node = xml.root
+            @root_node = self.xml_document.root
           end
         rescue
           return nil
@@ -699,14 +635,14 @@ module FeedTools
   
     # Returns the channel node of the feed.
     def channel_node
-      if @channel_node.nil? && root_node != nil
-        @channel_node = try_xpaths(root_node, [
+      if @channel_node.nil? && self.root_node != nil
+        @channel_node = FeedTools::XmlHelper.try_xpaths(self.root_node, [
           "channel",
           "CHANNEL",
           "feedinfo"
         ])
         if @channel_node == nil
-          @channel_node = root_node
+          @channel_node = self.root_node
         end
       end
       return @channel_node
@@ -714,14 +650,19 @@ module FeedTools
   
     # The cache object that handles the feed persistence.
     def cache_object
-      if !@url.nil? && @url =~ /^file:\/\//
+      if !@href.nil? && @href =~ /^file:\/\//
         return nil
       end
       unless FeedTools.feed_cache.nil?
         if @cache_object.nil?
           begin
-            if @url != nil
-              @cache_object = FeedTools.feed_cache.find_by_url(@url)
+            if @href != nil
+              begin
+                @cache_object = FeedTools.feed_cache.find_by_href(@href)
+              rescue
+                warn("The feed cache seems to be having trouble with the " +
+                  "find_by_href method.  This may cause unexpected results.")
+              end
             end
             if @cache_object.nil?
               @cache_object = FeedTools.feed_cache.new
@@ -736,8 +677,8 @@ module FeedTools
     # Sets the cache object for this feed.
     #
     # This can be any object, but it must accept the following messages:
-    # url
-    # url=
+    # href
+    # href=
     # title
     # title=
     # link
@@ -773,7 +714,11 @@ module FeedTools
         when "rss"
           @feed_type = "rss"
         when "channel"
-          @feed_type = "cdf"
+          if self.root_node.namespace == FEED_TOOLS_NAMESPACES['rss11']
+            @feed_type = "rss"
+          else
+            @feed_type = "cdf"
+          end
         end
       end
       return @feed_type
@@ -794,26 +739,33 @@ module FeedTools
         end
         version = nil
         begin
-          version = XPath.first(root_node, "@version").to_s.strip.to_f
+          version_string = FeedTools::XmlHelper.try_xpaths(self.root_node, [
+            "@version"
+          ], :select_result_value => true)
+          unless version_string.nil?
+            version = version_string.to_f
+          end
         rescue
         end
         version = nil if version == 0.0
-        default_namespace = XPath.first(root_node, "@xmlns").to_s.strip
+        default_namespace = FeedTools::XmlHelper.try_xpaths(self.root_node, [
+          "@xmlns"
+        ], :select_result_value => true)
         case self.feed_type
         when "atom"
-          if default_namespace == "http://www.w3.org/2005/Atom"
+          if default_namespace == FEED_TOOLS_NAMESPACES['atom10']
             @feed_version = 1.0
           elsif version != nil
             @feed_version = version
-          elsif default_namespace == "http://purl.org/atom/ns#"
+          elsif default_namespace == FEED_TOOLS_NAMESPACES['atom03']
             @feed_version = 0.3
           end
         when "rss"
-          if default_namespace == "http://my.netscape.com/rdf/simple/0.9/"
+          if default_namespace == FEED_TOOLS_NAMESPACES['rss09']
             @feed_version = 0.9
-          elsif default_namespace == "http://purl.org/rss/1.0/"
+          elsif default_namespace == FEED_TOOLS_NAMESPACES['rss10']
             @feed_version = 1.0
-          elsif default_namespace == "http://purl.org/net/rss1.1#"
+          elsif default_namespace == FEED_TOOLS_NAMESPACES['rss11']
             @feed_version = 1.1
           elsif version != nil
             case version
@@ -828,7 +780,7 @@ module FeedTools
         when "cdf"
           @feed_version = 0.4
         when "!okay/news"
-          @feed_version = nil
+          @feed_version = 1.0
         end
       end
       return @feed_version
@@ -842,15 +794,15 @@ module FeedTools
     # Returns the feed's unique id
     def id
       if @id.nil?
-        @id = select_not_blank([
-          try_xpaths(self.channel_node, [
+        @id = FeedTools::XmlHelper.select_not_blank([
+          FeedTools::XmlHelper.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, [
+          FeedTools::XmlHelper.try_xpaths(self.root_node, [
             "atom10:id/text()",
             "atom03:id/text()",
             "atom:id/text()",
@@ -868,106 +820,114 @@ module FeedTools
     end
   
     # Returns the feed url.
-    def url
-      original_url = @url
-      override_url = lambda do |result|
-        begin
-          if result.nil? && self.feed_data != nil
-            true
-          elsif result != nil &&
-              !(["http", "https"].include?(URI.parse(result.to_s).scheme))
-            if self.feed_data != nil
+    def href
+      if @href_overridden != true || @href.nil?
+        original_href = @href
+      
+        override_href = lambda do |current_href|
+          begin
+            if current_href.nil? && self.feed_data != nil
+              # The current url is nil and we have feed data to go on
               true
+            elsif current_href != nil && !(["http", "https"].include?(
+                URI.parse(current_href.to_s).scheme))
+              if self.feed_data != nil
+                # The current url is set, but isn't a http/https url and
+                # we have feed data to use to replace the current url with
+                true
+              else
+                # The current url is set, but isn't a http/https url but
+                # we don't have feed data to use to replace the current url
+                # with so we'll have to wait until we do
+                false
+              end
             else
+              # The current url is set to an http/https url and there's
+              # no compelling reason to override it
               false
             end
-          else
-            false
+          rescue
+            # Something went wrong, so we should err on the side of caution
+            # and attempt to override the url
+            true
           end
-        rescue
-          true
-        end
-      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
+        if override_href.call(@href) && self.feed_data != nil
+          # rdf:about is ordered last because a lot of people put the url to
+          # the feed inside it instead of a link to their blog.
+          # Ordering it last gives them as many chances as humanly possible
+          # for them to redeem themselves.  If the link turns out to be the
+          # same as the blog link, it will be reset to the original value.
+          for link_object in self.links
+            if link_object.rel == 'self'
+              if link_object.href != self.link
+                @href = link_object.href
+                @href_overridden = true
+                return @href
+              end
+            end
+          end
+          @href = FeedTools::XmlHelper.try_xpaths(self.channel_node, [
+            "admin:feed/@rdf:resource",
+            "admin:feed/@resource",
+            "feed/@rdf:resource",
+            "feed/@resource",
+            "@rdf:about",
+            "@about"
+          ], :select_result_value => true) do |result|
+            override_href.call(FeedTools::UriHelper.normalize_url(result))
+          end
+          begin
+            if !(@href =~ /^file:/) &&
+                !FeedTools::UriHelper.is_uri?(@href)
+              @href = FeedTools::UriHelper.resolve_relative_uri(
+                @href, [self.base_uri])
+            end
+          rescue
+          end
+          if FeedTools.configurations[:url_normalization_enabled]
+            @href = FeedTools::UriHelper.normalize_url(@href)
+          end            
+          @href.strip! unless @href.nil?
+          @href = nil if @href.blank?
+          @href_overridden = true
+          if @href == nil
+            @href = original_href
+            @href_overridden = false
+          end
+          if @href == self.link
+            @href = original_href
+            @href_overridden = false
+          end
+        end
+      end
+      return @href
     end
   
     # Sets the feed url and prepares the cache_object if necessary.
-    def url=(new_url)
-      @url = FeedTools.normalize_url(new_url)
-      self.cache_object.url = new_url unless self.cache_object.nil?
+    def href=(new_href)
+      @href = FeedTools::UriHelper.normalize_url(new_href)
+      self.cache_object.href = new_href unless self.cache_object.nil?
     end
   
     # Returns the feed title
     def title
       if @title.nil?
         repair_entities = false
-        title_node = try_xpaths(self.channel_node, [
+        title_node = FeedTools::XmlHelper.try_xpaths(self.channel_node, [
           "atom10:title",
           "atom03:title",
           "atom:title",
           "title",
-          "dc:title"
+          "dc:title",
+          "channelTitle"
         ])
-        if title_node.nil?
-          return nil
-        end
-        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" ||
-            title_encoding == "base64"
-          @title = Base64.decode64(title_node.inner_xml.strip)
-        elsif title_type == "xhtml" || title_mode == "xhtml" ||
-            title_type == "xml" || title_mode == "xml" ||
-            title_type == "application/xhtml+xml"
-          @title = title_node.inner_xml
-        elsif title_type == "escaped" || title_mode == "escaped"
-          @title = FeedTools.unescape_entities(
-            title_node.inner_xml)
-        else
-          @title = title_node.inner_xml
-          repair_entities = true
+        @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]
+          @title = FeedTools::HtmlHelper.strip_wrapper_element(@title)
         end
-        unless @title.nil?
-          @title = FeedTools.sanitize_html(@title, :strip)
-          @title = FeedTools.unescape_entities(@title) if repair_entities
-          @title = FeedTools.tidy_html(@title) unless repair_entities
-        end
-        @title.gsub!(/>\n</, "><")
-        @title.gsub!(/\n/, " ")
-        @title.strip!
         @title = nil if @title.blank?
         self.cache_object.title = @title unless self.cache_object.nil?
       end
@@ -984,7 +944,7 @@ module FeedTools
     def subtitle
       if @subtitle.nil?
         repair_entities = false
-        subtitle_node = try_xpaths(self.channel_node, [
+        subtitle_node = FeedTools::XmlHelper.try_xpaths(self.channel_node, [
           "atom10:subtitle",
           "subtitle",
           "atom03:tagline",
@@ -992,44 +952,24 @@ module FeedTools
           "description",
           "summary",
           "abstract",
-          "ABSTRACT",
           "content:encoded",
           "encoded",
           "content",
           "xhtml:body",
           "body",
+          "xhtml:div",
+          "div",
+          "p:payload",
+          "payload",
+          "channelDescription",
           "blurb",
           "info"
         ])
-        if subtitle_node.nil?
-          return nil
-        end
-        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 !subtitle_encoding.blank?
-          @subtitle =
-            "[Embedded data objects are not currently supported.]"
-        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
-          @subtitle = subtitle_node.inner_xml
-          repair_entities = true
+        @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]
+          @subtitle = FeedTools::HtmlHelper.strip_wrapper_element(@subtitle)
         end
         if @subtitle.blank?
           @subtitle = self.itunes_summary
@@ -1037,15 +977,6 @@ module FeedTools
         if @subtitle.blank?
           @subtitle = self.itunes_subtitle
         end
-
-        unless @subtitle.blank?
-          @subtitle = FeedTools.sanitize_html(@subtitle, :strip)
-          @subtitle = FeedTools.unescape_entities(@subtitle) if repair_entities
-          @subtitle = FeedTools.tidy_html(@subtitle)
-        end
-
-        @subtitle = @subtitle.strip unless @subtitle.nil?
-        @subtitle = nil if @subtitle.blank?
       end
       return @subtitle
     end
@@ -1058,17 +989,20 @@ module FeedTools
     # Returns the contents of the itunes:summary element
     def itunes_summary
       if @itunes_summary.nil?
-        @itunes_summary = select_not_blank([
-          try_xpaths(self.channel_node, [
+        @itunes_summary = FeedTools::XmlHelper.select_not_blank([
+          FeedTools::XmlHelper.try_xpaths(self.channel_node, [
             "itunes:summary/text()"
-          ]),
-          try_xpaths(self.root_node, [
+          ], :select_result_value => true),
+          FeedTools::XmlHelper.try_xpaths(self.root_node, [
             "itunes:summary/text()"
-          ])
+          ], :select_result_value => true)
         ])
         unless @itunes_summary.blank?
-          @itunes_summary = FeedTools.unescape_entities(@itunes_summary)
-          @itunes_summary = FeedTools.sanitize_html(@itunes_summary)
+          @itunes_summary =
+            FeedTools::HtmlHelper.unescape_entities(@itunes_summary)
+          @itunes_summary =
+            FeedTools::HtmlHelper.sanitize_html(@itunes_summary)
+          @itunes_summary.strip!
         else
           @itunes_summary = nil
         end
@@ -1084,17 +1018,20 @@ module FeedTools
     # Returns the contents of the itunes:subtitle element
     def itunes_subtitle
       if @itunes_subtitle.nil?
-        @itunes_subtitle = select_not_blank([
-          try_xpaths(self.channel_node, [
+        @itunes_subtitle = FeedTools::XmlHelper.select_not_blank([
+          FeedTools::XmlHelper.try_xpaths(self.channel_node, [
             "itunes:subtitle/text()"
-          ]),
-          try_xpaths(self.root_node, [
+          ], :select_result_value => true),
+          FeedTools::XmlHelper.try_xpaths(self.root_node, [
             "itunes:subtitle/text()"
-          ])
+          ], :select_result_value => true)
         ])
         unless @itunes_subtitle.blank?
-          @itunes_subtitle = FeedTools.unescape_entities(@itunes_subtitle)
-          @itunes_subtitle = FeedTools.sanitize_html(@itunes_subtitle)
+          @itunes_subtitle =
+            FeedTools::HtmlHelper.unescape_entities(@itunes_subtitle)
+          @itunes_subtitle =
+            FeedTools::HtmlHelper.sanitize_html(@itunes_subtitle)
+          @itunes_subtitle.strip!
         else
           @itunes_subtitle = nil
         end
@@ -1107,84 +1044,89 @@ module FeedTools
       @itunes_subtitle = new_itunes_subtitle
     end
 
+    # Returns the contents of the media:text element
+    def media_text
+      if @media_text.nil?
+        @media_text = FeedTools::XmlHelper.select_not_blank([
+          FeedTools::XmlHelper.try_xpaths(self.channel_node, [
+            "media:text/text()"
+          ], :select_result_value => true),
+          FeedTools::XmlHelper.try_xpaths(self.root_node, [
+            "media:text/text()"
+          ], :select_result_value => true)
+        ])
+        unless @media_text.blank?
+          @media_text = FeedTools::HtmlHelper.unescape_entities(@media_text)
+          @media_text = FeedTools::HtmlHelper.sanitize_html(@media_text)
+          @media_text.strip!
+        else
+          @media_text = nil
+        end
+      end
+      return @media_text
+    end
+
+    # Sets the contents of the media:text element
+    def media_text=(new_media_text)
+      @media_text = new_media_text
+    end
+
     # Returns the feed link
     def link
       if @link.nil?
-        @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) &&
-              !(self.guid =~ /^urn:uuid:/) &&
-              !(self.guid =~ /^tag:/)
-            @link = self.guid
+        max_score = 0
+        for link_object in self.links.reverse
+          score = 0
+          if FeedTools::HtmlHelper.html_type?(link_object.type)
+            score = score + 2
+          elsif link_object.type != nil
+            score = score - 1
+          end
+          if FeedTools::HtmlHelper.xml_type?(link_object.type)
+            score = score + 1
           end
+          if link_object.rel == "alternate"
+            score = score + 1
+          end
+          if link_object.rel == "self"
+            score = score - 1
+          end
+          if score >= max_score
+            max_score = score
+            @link = link_object.href
+          end
+        end
+        if @link.blank?
+          @link = FeedTools::XmlHelper.try_xpaths(self.channel_node, [
+            "@href",
+            "@rdf:about",
+            "@about"
+          ], :select_result_value => true)
         end
-        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
+        if @link.blank?
+          if FeedTools::UriHelper.is_uri?(self.id) &&
+              (self.id =~ /^http/)
+            @link = self.id
+          end
         end
         if !@link.blank?
-          @link = FeedTools.unescape_entities(@link)
+          @link = FeedTools::HtmlHelper.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
+        @link = nil if @link.blank?
+        begin
+          if !(@link =~ /^file:/) &&
+              !FeedTools::UriHelper.is_uri?(@link)
+            channel_base_uri = nil
+            unless self.channel_node.nil?
+              channel_base_uri = self.channel_node.base_uri
             end
+            @link = FeedTools::UriHelper.resolve_relative_uri(
+              @link, [channel_base_uri, self.base_uri])
           end
+        rescue
         end
-        @link = nil if @link.blank?
         if FeedTools.configurations[:url_normalization_enabled]
-          @link = FeedTools.normalize_url(@link)
+          @link = FeedTools::UriHelper.normalize_url(@link)
         end
         unless self.cache_object.nil?
           self.cache_object.link = @link
@@ -1200,11 +1142,143 @@ module FeedTools
         self.cache_object.link = new_link
       end
     end
+    
+    # Returns the links collection
+    def links
+      if @links.blank?
+        @links = []
+        link_nodes =
+          FeedTools::XmlHelper.combine_xpaths_all(self.channel_node, [
+            "atom10:link",
+            "atom03:link",
+            "atom:link",
+            "link",
+            "channelLink",
+            "a",
+            "url",
+            "href"
+          ])
+        for link_node in link_nodes
+          link_object = FeedTools::Link.new
+          link_object.href = FeedTools::XmlHelper.try_xpaths(link_node, [
+            "@atom10:href",
+            "@atom03:href",
+            "@atom:href",
+            "@href",
+            "text()"
+          ], :select_result_value => true)
+          if link_object.href.nil? && link_node.base_uri != nil
+            link_object.href = ""
+          end
+          begin
+            if !(link_object.href =~ /^file:/) &&
+                !FeedTools::UriHelper.is_uri?(link_object.href)
+              link_object.href = FeedTools::UriHelper.resolve_relative_uri(
+                link_object.href,
+                [link_node.base_uri, self.base_uri])
+            end
+          rescue
+          end
+          if FeedTools.configurations[:url_normalization_enabled]
+            link_object.href =
+              FeedTools::UriHelper.normalize_url(link_object.href)
+          end
+          link_object.href.strip! unless link_object.href.nil?
+          next if link_object.href.blank?
+          link_object.hreflang = FeedTools::XmlHelper.try_xpaths(link_node, [
+            "@atom10:hreflang",
+            "@atom03:hreflang",
+            "@atom:hreflang",
+            "@hreflang"
+          ], :select_result_value => true)
+          unless link_object.hreflang.nil?
+            link_object.hreflang = link_object.hreflang.downcase
+          end
+          link_object.rel = FeedTools::XmlHelper.try_xpaths(link_node, [
+            "@atom10:rel",
+            "@atom03:rel",
+            "@atom:rel",
+            "@rel"
+          ], :select_result_value => true)
+          unless link_object.rel.nil?
+            link_object.rel = link_object.rel.downcase
+          end
+          link_object.type = FeedTools::XmlHelper.try_xpaths(link_node, [
+            "@atom10:type",
+            "@atom03:type",
+            "@atom:type",
+            "@type"
+          ], :select_result_value => true)
+          unless link_object.type.nil?
+            link_object.type = link_object.type.downcase
+          end
+          link_object.title = FeedTools::XmlHelper.try_xpaths(link_node, [
+            "@atom10:title",
+            "@atom03:title",
+            "@atom:title",
+            "@title",
+            "text()"
+          ], :select_result_value => true)
+          # This catches the ambiguities between atom, rss, and cdf
+          if link_object.title == link_object.href
+            link_object.title = nil
+          end
+          link_object.length = FeedTools::XmlHelper.try_xpaths(link_node, [
+            "@atom10:length",
+            "@atom03:length",
+            "@atom:length",
+            "@length"
+          ], :select_result_value => true)
+          if !link_object.length.nil?
+            link_object.length = link_object.length.to_i
+          else
+            if !link_object.type.nil? && link_object.type[0..4] != "text" &&
+                link_object.type[-3..-1] != "xml" &&
+                link_object.href =~ /^http:\/\//
+              # Retrieve the length with an http HEAD request
+            else
+              link_object.length = nil
+            end
+          end
+          @links << link_object
+        end
+      end
+      return @links
+    end
+    
+    # Sets the links collection
+    def links=(new_links)
+      @links = new_links
+    end
+    
+    # Returns the base uri for the feed, used for resolving relative paths
+    def base_uri
+      if @base_uri.nil?
+        @base_uri = FeedTools::XmlHelper.try_xpaths(self.channel_node, [
+          "@base"
+        ], :select_result_value => true)
+        if @base_uri.blank?
+          @base_uri =
+            FeedTools::GenericHelper.recursion_trap(:feed_base_uri) do
+              self.href
+            end
+        end
+        if !@base_uri.blank?
+          @base_uri = FeedTools::UriHelper.normalize_url(@base_uri)
+        end
+      end
+      return @base_uri
+    end
+            
+    # Sets the base uri for the feed
+    def base_uri=(new_base_uri)
+      @base_uri = new_base_uri
+    end
 
     # Returns the url to the icon file for this feed.
     def icon
       if @icon.nil?
-        icon_node = try_xpaths(self.channel_node, [
+        icon_node = FeedTools::XmlHelper.try_xpaths(self.channel_node, [
           "link[@rel='icon']",
           "link[@rel='shortcut icon']",
           "link[@type='image/x-icon']",
@@ -1213,15 +1287,26 @@ module FeedTools
           "LOGO[@STYLE='ICON']"
         ])
         unless icon_node.nil?
-          @icon = FeedTools.unescape_entities(
-            XPath.first(icon_node, "@href").to_s)
-          if @icon.blank?
-            @icon = FeedTools.unescape_entities(
-              XPath.first(icon_node, "text()").to_s)
-            unless FeedTools.is_uri? @icon
-              @icon = nil
+          @icon = FeedTools::XmlHelper.try_xpaths(icon_node, [
+            "@atom10:href",
+            "@atom03:href",
+            "@atom:href",
+            "@href",
+            "text()"
+          ], :select_result_value => true)
+          begin
+            if !(@icon =~ /^file:/) &&
+                !FeedTools::UriHelper.is_uri?(@icon)
+              channel_base_uri = nil
+              unless self.channel_node.nil?
+                channel_base_uri = self.channel_node.base_uri
+              end
+              @icon = FeedTools::UriHelper.resolve_relative_uri(
+                @icon, [channel_base_uri, self.base_uri])
             end
+          rescue
           end
+          @icon = nil unless FeedTools::UriHelper.is_uri?(@icon)
           @icon = nil if @icon.blank?
         end
       end
@@ -1236,7 +1321,8 @@ module FeedTools
       if @favicon.nil?
         if !self.link.blank?
           begin
-            link_uri = URI.parse(FeedTools.normalize_url(self.link))
+            link_uri = URI.parse(
+              FeedTools::UriHelper.normalize_url(self.link))
             if link_uri.scheme == "http"
               @favicon =
                 "http://" + link_uri.host + "/favicon.ico"
@@ -1244,9 +1330,10 @@ module FeedTools
           rescue
             @favicon = nil
           end
-          if @favicon.nil? && !self.url.blank?
+          if @favicon.nil? && !self.href.blank?
             begin
-              feed_uri = URI.parse(FeedTools.normalize_url(self.url))
+              feed_uri = URI.parse(
+                FeedTools::UriHelper.normalize_url(self.href))
               if feed_uri.scheme == "http"
                 @favicon =
                   "http://" + feed_uri.host + "/favicon.ico"
@@ -1265,8 +1352,8 @@ module FeedTools
     # Returns the feed author
     def author
       if @author.nil?
-        @author = FeedTools::Feed::Author.new
-        author_node = try_xpaths(self.channel_node, [
+        @author = FeedTools::Author.new
+        author_node = FeedTools::XmlHelper.try_xpaths(self.channel_node, [
           "atom10:author",
           "atom03:author",
           "atom:author",
@@ -1276,16 +1363,18 @@ module FeedTools
           "dc:creator"
         ])
         unless author_node.nil?
-          @author.raw = FeedTools.unescape_entities(
-            XPath.first(author_node, "text()").to_s).strip
-          @author.raw = nil if @author.raw.blank?
+          @author.raw = FeedTools::XmlHelper.try_xpaths(
+            author_node, ["text()"], :select_result_value => true)
+          @author.raw = FeedTools::HtmlHelper.unescape_entities(@author.raw)
           unless @author.raw.nil?
             raw_scan = @author.raw.scan(
               /(.*)\((\b[A-Z0-9._%-\+]+@[A-Z0-9._%-]+\.[A-Z]{2,4}\b)\)/i)
             if raw_scan.nil? || raw_scan.size == 0
               raw_scan = @author.raw.scan(
                 /(\b[A-Z0-9._%-\+]+@[A-Z0-9._%-]+\.[A-Z]{2,4}\b)\s*\((.*)\)/i)
-              author_raw_pair = raw_scan.first.reverse unless raw_scan.size == 0
+              unless raw_scan.size == 0
+                author_raw_pair = raw_scan.first.reverse
+              end
             else
               author_raw_pair = raw_scan.first
             end
@@ -1302,16 +1391,16 @@ module FeedTools
             else
               unless @author.raw.include?("@")
                 # We can be reasonably sure we are looking at something
-                # that the creator didn't intend to contain an email address if
-                # it got through the preceeding regexes and it doesn't
+                # that the creator didn't intend to contain an email address
+                # if it got through the preceeding regexes and it doesn't
                 # contain the tell-tale '@' symbol.
                 @author.name = @author.raw
               end
             end
           end
           if @author.name.blank?
-            @author.name = FeedTools.unescape_entities(
-              try_xpaths(author_node, [
+            @author.name = FeedTools::HtmlHelper.unescape_entities(
+              FeedTools::XmlHelper.try_xpaths(author_node, [
                 "atom10:name/text()",
                 "atom03:name/text()",
                 "atom:name/text()",
@@ -1321,8 +1410,8 @@ module FeedTools
             )
           end
           if @author.email.blank?
-            @author.email = FeedTools.unescape_entities(
-              try_xpaths(author_node, [
+            @author.email = FeedTools::HtmlHelper.unescape_entities(
+              FeedTools::XmlHelper.try_xpaths(author_node, [
                 "atom10:email/text()",
                 "atom03:email/text()",
                 "atom:email/text()",
@@ -1332,8 +1421,8 @@ module FeedTools
             )
           end
           if @author.url.blank?
-            @author.url = FeedTools.unescape_entities(
-              try_xpaths(author_node, [
+            @author.url = FeedTools::HtmlHelper.unescape_entities(
+              FeedTools::XmlHelper.try_xpaths(author_node, [
                 "atom10:url/text()",
                 "atom03:url/text()",
                 "atom:url/text()",
@@ -1342,7 +1431,7 @@ module FeedTools
                 "atom03:uri/text()",
                 "atom:uri/text()",
                 "uri/text()",
-                "@url",
+                "@href",
                 "@uri",
                 "@href"
               ], :select_result_value => true)
@@ -1352,6 +1441,16 @@ module FeedTools
           @author.raw = nil if @author.raw.blank?
           @author.email = nil if @author.email.blank?
           @author.url = nil if @author.url.blank?
+          if @author.url != nil
+            begin
+              if !(@author.url =~ /^file:/) &&
+                  !FeedTools::UriHelper.is_uri?(@author.url)
+                @author.url = FeedTools::UriHelper.resolve_relative_uri(
+                  @author.url, [author_node.base_uri, self.base_uri])
+              end
+            rescue
+            end
+          end
         end
         # Fallback on the itunes module if we didn't find an author name
         begin
@@ -1374,7 +1473,7 @@ module FeedTools
         # We're not looking at an author object, this is probably a string,
         # default to setting the author's name.
         if @author.nil?
-          @author = FeedTools::Feed::Author.new
+          @author = FeedTools::Author.new
         end
         @author.name = new_author
       end
@@ -1383,14 +1482,13 @@ module FeedTools
     # Returns the feed publisher
     def publisher
       if @publisher.nil?
-        @publisher = FeedTools::Feed::Author.new
-        publisher_node = try_xpaths(self.channel_node, [
-          "webMaster/text()",
-          "dc:publisher/text()"
-        ])
+        @publisher = FeedTools::Author.new
+        @publisher.raw = FeedTools::HtmlHelper.unescape_entities(        
+          FeedTools::XmlHelper.try_xpaths(self.channel_node, [
+            "webMaster/text()",
+            "dc:publisher/text()"
+          ], :select_result_value => true))
 
-        # Set the author name
-        @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)
@@ -1428,6 +1526,20 @@ module FeedTools
         @publisher.raw = nil if @publisher.raw.blank?
         @publisher.email = nil if @publisher.email.blank?
         @publisher.url = nil if @publisher.url.blank?
+        if @publisher.url != nil
+          begin
+            if !(@publisher.url =~ /^file:/) &&
+                !FeedTools::UriHelper.is_uri?(@publisher.url)
+              channel_base_uri = nil
+              unless self.channel_node.nil?
+                channel_base_uri = self.channel_node.base_uri
+              end
+              @publisher.url = FeedTools::UriHelper.resolve_relative_uri(
+                @publisher.url, [channel_base_uri, self.base_uri])
+            end
+          rescue
+          end
+        end        
       end
       return @publisher
     end
@@ -1443,7 +1555,7 @@ module FeedTools
         # We're not looking at an Author object, this is probably a string,
         # default to setting the publisher's name.
         if @publisher.nil?
-          @publisher = FeedTools::Feed::Author.new
+          @publisher = FeedTools::Author.new
         end
         @publisher.name = new_publisher
       end
@@ -1457,8 +1569,8 @@ module FeedTools
     # attribute.
     def itunes_author
       if @itunes_author.nil?
-        @itunes_author = FeedTools.unescape_entities(
-          try_xpaths(self.channel_node, [
+        @itunes_author = FeedTools::HtmlHelper.unescape_entities(
+          FeedTools::XmlHelper.try_xpaths(self.channel_node, [
             "itunes:author/text()"
           ], :select_result_value => true)
         )
@@ -1470,7 +1582,7 @@ module FeedTools
     # Returns the feed time
     def time
       if @time.nil?
-        time_string = try_xpaths(self.channel_node, [
+        time_string = FeedTools::XmlHelper.try_xpaths(self.channel_node, [
           "atom10:updated/text()",
           "atom03:updated/text()",
           "atom:updated/text()",
@@ -1480,6 +1592,7 @@ module FeedTools
           "atom:modified/text()",
           "modified/text()",
           "time/text()",
+          "lastBuildDate/text()",
           "atom10:issued/text()",
           "atom03:issued/text()",
           "atom:issued/text()",
@@ -1488,8 +1601,8 @@ module FeedTools
           "atom03:published/text()",
           "atom:published/text()",
           "published/text()",
-          "pubDate/text()",
           "dc:date/text()",
+          "pubDate/text()",
           "date/text()"
         ], :select_result_value => true)
         begin
@@ -1509,15 +1622,15 @@ module FeedTools
       return @time
     end
   
-    # Sets the feed item time
+    # Sets the feed time
     def time=(new_time)
       @time = new_time
     end
   
-    # Returns the feed item updated time
+    # Returns the feed updated time
     def updated
       if @updated.nil?
-        updated_string = try_xpaths(self.channel_node, [
+        updated_string = FeedTools::XmlHelper.try_xpaths(self.channel_node, [
           "atom10:updated/text()",
           "atom03:updated/text()",
           "atom:updated/text()",
@@ -1525,7 +1638,8 @@ module FeedTools
           "atom10:modified/text()",
           "atom03:modified/text()",
           "atom:modified/text()",
-          "modified/text()"
+          "modified/text()",
+          "lastBuildDate/text()"
         ], :select_result_value => true)
         unless updated_string.blank?
           @updated = Time.parse(updated_string).gmtime rescue nil
@@ -1536,26 +1650,27 @@ module FeedTools
       return @updated
     end
   
-    # Sets the feed item updated time
+    # Sets the feed updated time
     def updated=(new_updated)
       @updated = new_updated
     end
 
-    # Returns the feed item published time
+    # Returns the feed published time
     def published
       if @published.nil?
-        published_string = try_xpaths(self.channel_node, [
-          "atom10:published/text()",
-          "atom03:published/text()",
-          "atom:published/text()",
-          "published/text()",
-          "pubDate/text()",
-          "atom10:issued/text()",
-          "atom03:issued/text()",
-          "atom:issued/text()",
-          "issued/text()",
-          "dc:date/text()"
-        ], :select_result_value => true)
+        published_string =
+          FeedTools::XmlHelper.try_xpaths(self.channel_node, [
+            "atom10:published/text()",
+            "atom03:published/text()",
+            "atom:published/text()",
+            "published/text()",
+            "dc:date/text()",
+            "pubDate/text()",
+            "atom10:issued/text()",
+            "atom03:issued/text()",
+            "atom:issued/text()",
+            "issued/text()"
+          ], :select_result_value => true)
         unless published_string.blank?
           @published = Time.parse(published_string).gmtime rescue nil
         else
@@ -1565,7 +1680,7 @@ module FeedTools
       return @published
     end
   
-    # Sets the feed item published time
+    # Sets the feed published time
     def published=(new_published)
       @published = new_published
     end
@@ -1574,22 +1689,24 @@ module FeedTools
     def categories
       if @categories.nil?
         @categories = []
-        category_nodes = try_xpaths_all(self.channel_node, [
-          "category",
-          "dc:subject"
-        ])
+        category_nodes =
+          FeedTools::XmlHelper.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 = try_xpaths(category_node, [
+            category = FeedTools::Category.new
+            category.term = FeedTools::XmlHelper.try_xpaths(category_node, [
               "@term",
               "text()"
             ], :select_result_value => true)
             category.term.strip! unless category.term.blank?
-            category.label = try_xpaths(category_node, ["@label"],
+            category.label = FeedTools::XmlHelper.try_xpaths(
+              category_node, ["@label"],
               :select_result_value => true)
             category.label.strip! unless category.label.blank?
-            category.scheme = try_xpaths(category_node, [
+            category.scheme = FeedTools::XmlHelper.try_xpaths(category_node, [
               "@scheme",
               "@domain"
             ], :select_result_value => true)
@@ -1605,63 +1722,69 @@ module FeedTools
     def images
       if @images.nil?
         @images = []
-        image_nodes = try_xpaths_all(self.channel_node, [
-          "image",
-          "logo",
-          "apple-wallpapers:image",
-          "atom10:link",
-          "atom03:link",
-          "atom:link",
-          "link"
-        ])
+        image_nodes = FeedTools::XmlHelper.combine_xpaths_all(
+          self.channel_node, [
+            "image",
+            "logo",
+            "apple-wallpapers:image",
+            "imageUrl"
+          ]
+        )
         unless image_nodes.blank?
           for image_node in image_nodes
-            image = FeedTools::Feed::Image.new
-            image.url = try_xpaths(image_node, [
+            image = FeedTools::Image.new
+            image.href = FeedTools::XmlHelper.try_xpaths(image_node, [
               "url/text()",
               "@rdf:resource",
+              "@href",
               "text()"
             ], :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.href.nil? && image_node.base_uri != nil
+              image.href = ""
             end
-            if image.url.blank? && image_node.name == "LOGO"
-              image.url = try_xpaths(image_node, [
-                "@href"
-              ], :select_result_value => true)
+            begin
+              if !(image.href =~ /^file:/) &&
+                  !FeedTools::UriHelper.is_uri?(image.href)
+                image.href = FeedTools::UriHelper.resolve_relative_uri(
+                  image.href, [image_node.base_uri, self.base_uri])
+              end
+            rescue
             end
-            image.url.strip! unless image.url.nil?
-            image.title = try_xpaths(image_node,
+            if FeedTools.configurations[:url_normalization_enabled]
+              image.href = FeedTools::UriHelper.normalize_url(image.href)
+            end            
+            image.href.strip! unless image.href.nil?
+            next if image.href.blank?
+            image.title = FeedTools::XmlHelper.try_xpaths(image_node,
               ["title/text()"], :select_result_value => true)
             image.title.strip! unless image.title.nil?
-            image.description = try_xpaths(image_node,
+            image.description = FeedTools::XmlHelper.try_xpaths(image_node,
               ["description/text()"], :select_result_value => true)
             image.description.strip! unless image.description.nil?
-            image.link = try_xpaths(image_node,
+            image.link = FeedTools::XmlHelper.try_xpaths(image_node,
               ["link/text()"], :select_result_value => true)
             image.link.strip! unless image.link.nil?
-            image.height = try_xpaths(image_node,
+            image.height = FeedTools::XmlHelper.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,
+            image.width = FeedTools::XmlHelper.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, [
+            image.style = FeedTools::XmlHelper.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?
+            @images << image unless image.href.nil?
+          end
+        end
+        for link_object in self.links
+          if link_object.type != nil && link_object.type =~ /^image/
+            image = FeedTools::Image.new
+            image.href = link_object.href
+            image.title = link_object.title
+            @images << image unless image.href.nil?
           end
         end
       end
@@ -1671,20 +1794,25 @@ module FeedTools
     # Returns the feed's text input field
     def text_input
       if @text_input.nil?
-        @text_input = FeedTools::Feed::TextInput.new
-        text_input_node = try_xpaths(self.channel_node, ["textInput"])
+        @text_input = FeedTools::TextInput.new
+        text_input_node =
+          FeedTools::XmlHelper.try_xpaths(self.channel_node, ["textInput"])
         unless text_input_node.nil?
           @text_input.title =
-            try_xpaths(text_input_node, ["title/text()"],
+            FeedTools::XmlHelper.try_xpaths(text_input_node,
+              ["title/text()"],
               :select_result_value => true)
           @text_input.description =
-            try_xpaths(text_input_node, ["description/text()"],
+            FeedTools::XmlHelper.try_xpaths(text_input_node,
+              ["description/text()"],
               :select_result_value => true)
           @text_input.link =
-            try_xpaths(text_input_node, ["link/text()"],
+            FeedTools::XmlHelper.try_xpaths(text_input_node,
+              ["link/text()"],
               :select_result_value => true)
           @text_input.name =
-            try_xpaths(text_input_node, ["name/text()"],
+            FeedTools::XmlHelper.try_xpaths(text_input_node,
+              ["name/text()"],
               :select_result_value => true)
         end
       end
@@ -1692,10 +1820,10 @@ module FeedTools
     end
       
     # Returns the feed's copyright information
-    def copyright
-      if @copyright.nil?
+    def rights
+      if @rights.nil?
         repair_entities = false
-        copyright_node = try_xpaths(self.channel_node, [
+        rights_node = FeedTools::XmlHelper.try_xpaths(self.channel_node, [
           "atom10:copyright",
           "atom03:copyright",
           "atom:copyright",
@@ -1704,63 +1832,40 @@ module FeedTools
           "dc:rights",
           "rights"
         ])
-        if copyright_node.nil?
-          return nil
+        @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]
+          @rights = FeedTools::HtmlHelper.strip_wrapper_element(@rights)
         end
-        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.blank?
-          @copyright =
-            "[Embedded data objects are not currently supported.]"
-        elsif copyright_node.cdatas.size > 0
-          @copyright = copyright_node.cdatas.first.value
-        elsif copyright_type == "base64" || copyright_mode == "base64" ||
-            copyright_encoding == "base64"
-          @copyright = Base64.decode64(copyright_node.inner_xml.strip)
-        elsif copyright_type == "xhtml" || copyright_mode == "xhtml" ||
-            copyright_type == "xml" || copyright_mode == "xml" ||
-            copyright_type == "application/xhtml+xml"
-          @copyright = copyright_node.inner_xml
-        elsif copyright_type == "escaped" || copyright_mode == "escaped"
-          @copyright = FeedTools.unescape_entities(
-            copyright_node.inner_xml)
-        else
-          @copyright = copyright_node.inner_xml
-          repair_entities = true
-        end
-
-        unless @copyright.nil?
-          @copyright = FeedTools.sanitize_html(@copyright, :strip)
-          @copyright = FeedTools.unescape_entities(@copyright) if repair_entities
-          @copyright = FeedTools.tidy_html(@copyright)
-        end
-
-        @copyright = @copyright.strip unless @copyright.nil?
-        @copyright = nil if @copyright.blank?
       end
-      return @copyright
+      return @rights
     end
 
-    # Sets the feed's copyright information
-    def copyright=(new_copyright)
-      @copyright = new_copyright
+    # Sets the feed's rights information
+    def rights=(new_rights)
+      @rights = new_rights
     end
 
+    def license #:nodoc:
+      raise "Not implemented yet."
+    end
+    
+    def license=(new_license) #:nodoc:
+      raise "Not implemented yet."
+    end
+    
     # Returns the number of seconds before the feed should expire
     def time_to_live
       if @time_to_live.nil?
         unless channel_node.nil?
           # get the feed time to live from the xml document
-          update_frequency = try_xpaths(self.channel_node,
+          update_frequency = FeedTools::XmlHelper.try_xpaths(
+            self.channel_node,
             ["syn:updateFrequency/text()"], :select_result_value => true)
           if !update_frequency.blank?
-            update_period = try_xpaths(self.channel_node,
+            update_period = FeedTools::XmlHelper.try_xpaths(
+              self.channel_node,
               ["syn:updatePeriod/text()"], :select_result_value => true)
             if update_period == "daily"
               @time_to_live = update_frequency.to_i.day
@@ -1777,10 +1882,12 @@ module FeedTools
           end
           if @time_to_live.nil?
             # usually expressed in minutes
-            update_frequency = try_xpaths(self.channel_node, ["ttl/text()"],
+            update_frequency = FeedTools::XmlHelper.try_xpaths(
+              self.channel_node, ["ttl/text()"],
               :select_result_value => true)
             if !update_frequency.blank?
-              update_span = try_xpaths(self.channel_node, ["ttl/@span"],
+              update_span = FeedTools::XmlHelper.try_xpaths(
+                self.channel_node, ["ttl/@span"],
                 :select_result_value => true)
               if update_span == "seconds"
                 @time_to_live = update_frequency.to_i
@@ -1804,24 +1911,28 @@ module FeedTools
           if @time_to_live.nil?
             @time_to_live = 0
             update_frequency_days =
-              XPath.first(channel_node, "SCHEDULE/INTERVALTIME/@DAY").to_s
+              FeedTools::XmlHelper.try_xpaths(self.channel_node,
+              ["schedule/intervaltime/@day"], :select_result_value => true)
             update_frequency_hours =
-              XPath.first(channel_node, "schedule/intervaltime/@hour").to_s
+              FeedTools::XmlHelper.try_xpaths(self.channel_node,
+              ["schedule/intervaltime/@hour"], :select_result_value => true)
             update_frequency_minutes =
-              XPath.first(channel_node, "schedule/intervaltime/@min").to_s
+              FeedTools::XmlHelper.try_xpaths(self.channel_node,
+              ["schedule/intervaltime/@min"], :select_result_value => true)
             update_frequency_seconds =
-              XPath.first(channel_node, "schedule/intervaltime/@sec").to_s
-            if update_frequency_days != ""
+              FeedTools::XmlHelper.try_xpaths(self.channel_node,
+              ["schedule/intervaltime/@sec"], :select_result_value => true)
+            if !update_frequency_days.blank?
               @time_to_live = @time_to_live + update_frequency_days.to_i.day
             end
-            if update_frequency_hours != ""
+            if !update_frequency_hours.blank?
               @time_to_live = @time_to_live + update_frequency_hours.to_i.hour
             end
-            if update_frequency_minutes != ""
+            if !update_frequency_minutes.blank?
               @time_to_live = @time_to_live +
                 update_frequency_minutes.to_i.minute
             end
-            if update_frequency_seconds != ""
+            if !update_frequency_seconds.blank?
               @time_to_live = @time_to_live + update_frequency_seconds.to_i
             end
             if @time_to_live == 0
@@ -1851,18 +1962,23 @@ module FeedTools
     # Returns the feed's cloud
     def cloud
       if @cloud.nil?
-        @cloud = FeedTools::Feed::Cloud.new
-        @cloud.domain = try_xpaths(self.channel_node, ["cloud/@domain"],
+        @cloud = FeedTools::Cloud.new
+        @cloud.domain = FeedTools::XmlHelper.try_xpaths(
+          self.channel_node, ["cloud/@domain"],
           :select_result_value => true)
-        @cloud.port = try_xpaths(self.channel_node, ["cloud/@port"],
+        @cloud.port = FeedTools::XmlHelper.try_xpaths(
+          self.channel_node, ["cloud/@port"],
           :select_result_value => true)
-        @cloud.path = try_xpaths(self.channel_node, ["cloud/@path"],
+        @cloud.path = FeedTools::XmlHelper.try_xpaths(
+          self.channel_node, ["cloud/@path"],
           :select_result_value => true)
         @cloud.register_procedure =
-          try_xpaths(self.channel_node, ["cloud/@registerProcedure"],
+          FeedTools::XmlHelper.try_xpaths(
+            self.channel_node, ["cloud/@registerProcedure"],
             :select_result_value => true)
         @cloud.protocol =
-          try_xpaths(self.channel_node, ["cloud/@protocol"],
+          FeedTools::XmlHelper.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
@@ -1879,14 +1995,23 @@ module FeedTools
     # Returns the feed generator
     def generator
       if @generator.nil?
-        @generator = try_xpaths(self.channel_node, ["generator/text()"],
+        @generator = FeedTools::XmlHelper.try_xpaths(
+          self.channel_node, ["generator/text()"],
           :select_result_value => true)
-        @generator = FeedTools.strip_html(@generator) unless @generator.nil?
+        unless @generator.nil?
+          @generator =
+            FeedTools::HtmlHelper.convert_html_to_plain_text(@generator)
+        end
       end
       return @generator
     end
 
     # Sets the feed generator
+    #
+    # Note: Setting this variable will NOT cause this to appear in any
+    # generated output.  The generator string is created from the
+    # <tt>:generator_name</tt> and <tt>:generator_href</tt> configuration
+    # variables.
     def generator=(new_generator)
       @generator = new_generator
     end
@@ -1894,9 +2019,24 @@ module FeedTools
     # Returns the feed docs
     def docs
       if @docs.nil?
-        @docs = try_xpaths(self.channel_node, ["docs/text()"],
+        @docs = FeedTools::XmlHelper.try_xpaths(
+          self.channel_node, ["docs/text()"],
           :select_result_value => true)
-        @docs = FeedTools.strip_html(@docs) unless @docs.nil?
+        begin
+          if !(@docs =~ /^file:/) &&
+              !FeedTools::UriHelper.is_uri?(@docs)
+            channel_base_uri = nil
+            unless self.channel_node.nil?
+              channel_base_uri = self.channel_node.base_uri
+            end
+            @docs = FeedTools::UriHelper.resolve_relative_uri(
+              @docs, [channel_base_uri, self.base_uri])
+          end
+        rescue
+        end
+        if FeedTools.configurations[:url_normalization_enabled]
+          @docs = FeedTools::UriHelper.normalize_url(@docs)
+        end
       end
       return @docs
     end
@@ -1909,15 +2049,15 @@ module FeedTools
     # Returns the feed language
     def language
       if @language.nil?
-        @language = select_not_blank([
-          try_xpaths(self.channel_node, [
+        @language = FeedTools::XmlHelper.select_not_blank([
+          FeedTools::XmlHelper.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, [
+          FeedTools::XmlHelper.try_xpaths(self.root_node, [
             "@xml:lang",
             "xml:lang/text()"
           ], :select_result_value => true)
@@ -1938,7 +2078,7 @@ module FeedTools
     # Returns true if this feed contains explicit material.
     def explicit?
       if @explicit.nil?
-        explicit_string = try_xpaths(self.channel_node, [
+        explicit_string = FeedTools::XmlHelper.try_xpaths(self.channel_node, [
           "media:adult/text()",
           "itunes:explicit/text()"
         ], :select_result_value => true)
@@ -1958,24 +2098,32 @@ module FeedTools
   
     # Returns the feed entries
     def entries
-      if @entries.blank?
-        raw_entries = select_not_blank([
-          try_xpaths_all(self.channel_node, [
+      if @entries.nil?
+        raw_entries = FeedTools::XmlHelper.select_not_blank([
+          FeedTools::XmlHelper.try_xpaths_all(self.channel_node, [
             "atom10:entry",
             "atom03:entry",
             "atom:entry",
             "entry"
           ]),
-          try_xpaths_all(self.root_node, [
+          FeedTools::XmlHelper.try_xpaths_all(self.root_node, [
             "rss10:item",
+            "rss11:items/rss11:item",
+            "rss11:items/item",
+            "items/rss11:item",
+            "items/item",
             "item",
             "atom10:entry",
             "atom03:entry",
             "atom:entry",
             "entry"
           ]),
-          try_xpaths_all(self.channel_node, [
+          FeedTools::XmlHelper.try_xpaths_all(self.channel_node, [
             "rss10:item",
+            "rss11:items/rss11:item",
+            "rss11:items/item",
+            "items/rss11:item",
+            "items/item",
             "item"
           ])
         ])
@@ -1987,14 +2135,27 @@ module FeedTools
             new_entry = FeedItem.new
             new_entry.feed_data = entry_node.to_s
             new_entry.feed_data_type = self.feed_data_type
+            new_entry.root_node = entry_node
+            if new_entry.root_node.namespace.blank?
+              new_entry.root_node.add_namespace(self.root_node.namespace)
+            end
             @entries << new_entry
           end
         end
       end
     
       # Sort the items
-      @entries = @entries.sort do |a, b|
-        (b.time or Time.utc(1970)) <=> (a.time or Time.utc(1970))
+      if FeedTools.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]
+        @entries = @entries.sort do |a, b|
+          eval("a.#{sorting_property}") <=> eval("b.#{sorting_property}")
+        end
+      else
+        @entries = @entries.reverse
       end
       return @entries
     end
@@ -2090,58 +2251,73 @@ module FeedTools
     end
 
     # Generates xml based on the content of the feed
-    def build_xml(feed_type=(self.feed_type or "atom"), version=nil,
+    def build_xml(feed_type=(self.feed_type or "atom"), feed_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)
-        version = 1.0
+      if feed_type.nil?
+        feed_type = self.feed_type
+      end
+      if feed_version.nil?
+        feed_version = self.feed_version
       end
-      if feed_type == "rss" && (version == 0.9 || version == 1.0 ||
-          version == 1.1)
+      if feed_type == "rss" &&
+          (feed_version == nil || feed_version <= 0.0)
+        feed_version = 1.0
+      elsif feed_type == "atom" &&
+          (feed_version == nil || feed_version <= 0.0)
+        feed_version = 1.0
+      end
+      if feed_type == "rss" &&
+          (feed_version == 0.9 || feed_version == 1.0 || feed_version == 1.1)
         # RDF-based rss format
         return xml_builder.tag!("rdf:RDF",
             "xmlns" => FEED_TOOLS_NAMESPACES['rss10'],
+            "xmlns:content" => FEED_TOOLS_NAMESPACES['content'],
             "xmlns:rdf" => FEED_TOOLS_NAMESPACES['rdf'],
             "xmlns:dc" => FEED_TOOLS_NAMESPACES['dc'],
             "xmlns:syn" => FEED_TOOLS_NAMESPACES['syn'],
+            "xmlns:admin" => FEED_TOOLS_NAMESPACES['admin'],
             "xmlns:taxo" => FEED_TOOLS_NAMESPACES['taxo'],
             "xmlns:itunes" => FEED_TOOLS_NAMESPACES['itunes'],
             "xmlns:media" => FEED_TOOLS_NAMESPACES['media']) do
           channel_attributes = {}
           unless self.link.nil?
             channel_attributes["rdf:about"] =
-              FeedTools.escape_entities(self.link)
+              FeedTools::HtmlHelper.escape_entities(self.link)
           end
           xml_builder.channel(channel_attributes) do
-            unless title.nil? || title == ""
-              xml_builder.title(title)
+            unless self.title.blank?
+              xml_builder.title(
+                FeedTools::HtmlHelper.strip_html_tags(self.title))
             else
               xml_builder.title
             end
-            unless link.nil? || link == ""
-              xml_builder.link(link)
+            unless self.link.blank?
+              xml_builder.link(self.link)
             else
               xml_builder.link
             end
-            unless images.nil? || images.empty?
-              xml_builder.image("rdf:resource" => FeedTools.escape_entities(
-                images.first.url))
+            unless images.blank?
+              xml_builder.image("rdf:resource" =>
+                FeedTools::HtmlHelper.escape_entities(
+                  images.first.url))
             end
             unless description.nil? || description == ""
               xml_builder.description(description)
             else
               xml_builder.description
             end
-            unless language.nil? || language == ""
-              xml_builder.tag!("dc:language", language)
+            unless self.language.blank?
+              xml_builder.tag!("dc:language", self.language)
+            end
+            unless self.rights.blank?
+              xml_builder.tag!("dc:rights", self.rights)
             end
             xml_builder.tag!("syn:updatePeriod", "hourly")
             xml_builder.tag!("syn:updateFrequency",
-              (time_to_live / 1.hour).to_s)
+              (self.time_to_live / 1.hour).to_s)
             xml_builder.tag!("syn:updateBase", Time.mktime(1970).iso8601)
             xml_builder.items do
               xml_builder.tag!("rdf:Seq") do
@@ -2152,14 +2328,17 @@ module FeedTools
                         "item link field."
                     end
                     xml_builder.tag!("rdf:li", "rdf:resource" =>
-                      FeedTools.escape_entities(item.link))
+                      FeedTools::HtmlHelper.escape_entities(item.link))
                   end
                 end
               end
             end
-            build_xml_hook(feed_type, version, xml_builder)
+            xml_builder.tag!(
+              "admin:generatorAgent",
+              "rdf:resource" => FeedTools.configurations[:generator_href])
+            build_xml_hook(feed_type, feed_version, xml_builder)
           end
-          unless images.nil? || images.empty?
+          unless self.images.blank?
             best_image = nil
             for image in self.images
               if image.link != nil
@@ -2167,9 +2346,9 @@ module FeedTools
                 break
               end
             end
-            best_image = images.first if best_image.nil?
-            xml_builder.image(
-                "rdf:about" => FeedTools.escape_entities(best_image.url)) do
+            best_image = self.images.first if best_image.nil?
+            xml_builder.image("rdf:about" =>
+                FeedTools::HtmlHelper.escape_entities(best_image.url)) do
               if !best_image.title.blank?
                 xml_builder.title(best_image.title)
               elsif !self.title.blank?
@@ -2191,13 +2370,14 @@ module FeedTools
           end
           unless items.nil?
             for item in items
-              item.build_xml(feed_type, version, xml_builder)
+              item.build_xml(feed_type, feed_version, xml_builder)
             end
           end
         end
       elsif feed_type == "rss"
         # normal rss format
         return xml_builder.rss("version" => "2.0",
+            "xmlns:content" => FEED_TOOLS_NAMESPACES['content'],
             "xmlns:rdf" => FEED_TOOLS_NAMESPACES['rdf'],
             "xmlns:dc" => FEED_TOOLS_NAMESPACES['dc'],
             "xmlns:taxo" => FEED_TOOLS_NAMESPACES['taxo'],
@@ -2205,29 +2385,41 @@ module FeedTools
             "xmlns:itunes" => FEED_TOOLS_NAMESPACES['itunes'],
             "xmlns:media" => FEED_TOOLS_NAMESPACES['media']) do
           xml_builder.channel do
-            unless title.blank?
-              xml_builder.title(title)
+            unless self.title.blank?
+              xml_builder.title(
+                FeedTools::HtmlHelper.strip_html_tags(self.title))
             end
-            unless link.blank?
+            unless self.link.blank?
               xml_builder.link(link)
             end
-            unless description.blank?
+            unless self.description.blank?
               xml_builder.description(description)
+            else
+              xml_builder.description
+            end
+            unless self.published.blank?
+              xml_builder.pubDate(self.published.rfc822)
+            end
+            unless self.updated.blank?
+              xml_builder.lastBuildDate(self.updated.rfc822)
+            end
+            unless self.copyright.blank?
+              xml_builder.copyright(self.copyright)
             end
             xml_builder.ttl((time_to_live / 1.minute).to_s)
             xml_builder.generator(
               FeedTools.configurations[:generator_href])
-            build_xml_hook(feed_type, version, xml_builder)
+            build_xml_hook(feed_type, feed_version, xml_builder)
             unless items.nil?
               for item in items
-                item.build_xml(feed_type, version, xml_builder)
+                item.build_xml(feed_type, feed_version, xml_builder)
               end
             end
           end
         end
-      elsif feed_type == "atom" && version == 0.3
+      elsif feed_type == "atom" && feed_version == 0.3
         raise "Atom 0.3 is obsolete."
-      elsif feed_type == "atom" && version == 1.0
+      elsif feed_type == "atom" && feed_version == 1.0
         # normal atom format
         return xml_builder.feed("xmlns" => FEED_TOOLS_NAMESPACES['atom10'],
             "xml:lang" => language) do
@@ -2248,18 +2440,18 @@ module FeedTools
               xml_builder.uri(self.author.url)
             end
           end
-          unless self.url.blank?
-            xml_builder.link("href" => self.url,
+          unless self.href.blank?
+            xml_builder.link("href" => self.href,
                 "rel" => "self",
                 "type" => "application/atom+xml")
           end
           unless self.link.blank?
-            xml_builder.link("href" => FeedTools.escape_entities(self.link),
-                "rel" => "alternate",
-                "type" => "text/html",
-                "title" => FeedTools.escape_entities(self.title))
+            xml_builder.link(
+              "href" =>
+                FeedTools::HtmlHelper.escape_entities(self.link),
+              "rel" => "alternate")
           end
-          unless description.blank?
+          unless self.subtitle.blank?
             xml_builder.subtitle(self.subtitle,
                 "type" => "html")
           end
@@ -2272,12 +2464,15 @@ module FeedTools
           else
             xml_builder.updated(Time.now.gmtime.iso8601)
           end
+          unless self.rights.blank?
+            xml_builder.rights(self.rights)
+          end
           xml_builder.generator(FeedTools.configurations[:generator_name] +
             " - " + FeedTools.configurations[:generator_href])
           if self.id != nil
-            unless FeedTools.is_uri? self.id
+            unless FeedTools::UriHelper.is_uri? self.id
               if self.link != nil
-                xml_builder.id(FeedTools.build_urn_uri(self.link))
+                xml_builder.id(FeedTools::UriHelper.build_urn_uri(self.link))
               else
                 raise "The unique id must be a valid URI."
               end
@@ -2285,14 +2480,14 @@ module FeedTools
               xml_builder.id(self.id)
             end
           elsif self.link != nil
-            xml_builder.id(FeedTools.build_urn_uri(self.link))
+            xml_builder.id(FeedTools::UriHelper.build_urn_uri(self.link))
           else
             raise "Cannot build feed, missing feed unique id."
           end
-          build_xml_hook(feed_type, version, xml_builder)
+          build_xml_hook(feed_type, feed_version, xml_builder)
           unless items.nil?
             for item in items
-              item.build_xml(feed_type, version, xml_builder)
+              item.build_xml(feed_type, feed_version, xml_builder)
             end
           end
         end
@@ -2303,15 +2498,15 @@ module FeedTools
 
     # Persists the current feed state to the cache.
     def save
-      unless self.url =~ /^file:\/\//
+      unless self.href =~ /^file:\/\//
         if FeedTools.feed_cache.nil?
           raise "Caching is currently disabled.  Cannot save to cache."
-        elsif self.url.nil?
+        elsif self.href.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
+          self.cache_object.href = self.href
           unless self.feed_data.nil?
             self.cache_object.title = self.title
             self.cache_object.link = self.link
@@ -2324,15 +2519,17 @@ module FeedTools
         end
       end
     end
-  
+
+    alias_method :url, :href
+    alias_method :url=, :href=  
     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 :copyright, :rights
+    alias_method :copyright=, :rights=
     alias_method :ttl, :time_to_live
     alias_method :ttl=, :time_to_live=
     alias_method :guid, :id
@@ -2362,7 +2559,12 @@ module FeedTools
   
     # Returns a simple representation of the feed object's state.
     def inspect
-      return "#<FeedTools::Feed:0x#{self.object_id.to_s(16)} URL:#{self.url}>"
+      return "#<FeedTools::Feed:0x#{self.object_id.to_s(16)} URL:#{self.href}>"
+    end
+    
+    # Allows sorting feeds by title
+    def <=>(other_feed)
+      return self.title.to_s <=> other_feed.title.to_s
     end
   end
 end