sitemap_generator 1.1.1 → 1.2.0

data/Rakefile

@@ -49,12 +49,16 @@ end
 #
 task :default => :test
 
+desc "Run specs"
 namespace :test do
   #desc "Test as a gem, plugin and Rails 3 gem"
   #task :all => ['test:gem', 'test:plugin']
 
+  desc "Run specs on a gem install"
   task :gem => ['test:prepare:gem', 'multi_spec']
+  desc "Run specs on a plugin install"
   task :plugin => ['test:prepare:plugin', 'multi_spec']
+  desc "Run specs on a rails3 install"
   task :rails3 => ['test:prepare:rails3', 'multi_spec']
 
   task :multi_spec do
@@ -63,18 +67,21 @@ namespace :test do
   end
 
   namespace :prepare do
+    desc "Prepare the gem install for testing"
     task :gem do
       ENV["SITEMAP_RAILS"] = 'gem'
       Helpers.prepare_path(Helpers.local_path('spec/mock_app_gem/vendor/gems/sitemap_generator-1.2.3'))
       rm_rf(Helpers.local_path('spec/mock_app_gem/public/sitemap*'))
     end
 
+    desc "Prepare the plugin install for testing"
     task :plugin do
       ENV["SITEMAP_RAILS"] = 'plugin'
       Helpers.prepare_path(Helpers.local_path('spec/mock_app_plugin/vendor/plugins/sitemap_generator-1.2.3'))
       rm_rf(Helpers.local_path('spec/mock_app_plugin/public/sitemap*'))
     end
 
+    desc "Prepare the rails3 install for testing"
     task :rails3 do
       ENV["SITEMAP_RAILS"] = 'rails3'
       rm_rf(Helpers.local_path('spec/mock_rails3_gem/public/sitemap*'))

data/VERSION

@@ -1 +1 @@
-1.1.1
+1.2.0

data/lib/sitemap_generator.rb

@@ -1,6 +1,4 @@
 require 'sitemap_generator/builder'
-require 'sitemap_generator/mapper'
-require 'sitemap_generator/link'
 require 'sitemap_generator/link_set'
 require 'sitemap_generator/templates'
 require 'sitemap_generator/utilities'
@@ -9,6 +7,10 @@ require 'sitemap_generator/railtie' if SitemapGenerator::Utilities.rails3?
 require 'active_support/core_ext/numeric'
 
 module SitemapGenerator
+  class SitemapError <StandardError; end
+  class SitemapFullError < SitemapError; end
+  class SitemapFinalizedError < SitemapError; end
+  
   silence_warnings do
     VERSION = File.read(File.dirname(__FILE__) + "/../VERSION").strip
     MAX_SITEMAP_FILES    = 50_000        # max sitemap links per index file

data/lib/sitemap_generator/builder.rb

@@ -1,6 +1,7 @@
-require 'sitemap_generator/builder/helper'
 require 'sitemap_generator/builder/sitemap_file'
 require 'sitemap_generator/builder/sitemap_index_file'
+require 'sitemap_generator/builder/sitemap_url'
+require 'sitemap_generator/builder/sitemap_index_url'
 
 module SitemapGenerator
   module Builder

data/lib/sitemap_generator/builder/sitemap_file.rb

@@ -1,6 +1,6 @@
-require 'sitemap_generator/builder/helper'
 require 'builder'
 require 'zlib'
+require 'action_view'
 
 module SitemapGenerator
   module Builder
@@ -8,13 +8,12 @@ module SitemapGenerator
     # General Usage:
     #
     #   sitemap = SitemapFile.new('public/', 'sitemap.xml', 'http://example.com')
-    #       <- creates a new sitemap file in directory public/
-    #   sitemap.add_link({ ... })    <- add a link to the sitemap
-    #   sitemap.finalize!            <- write and close the sitemap file
+    #   sitemap.add('/', { ... })    <- add a link to the sitemap
+    #   sitemap.finalize!            <- creates a new sitemap file in directory public/
+    #       and freezes the object to protect it from further modification
     #
     class SitemapFile
-      include SitemapGenerator::Builder::Helper
-
+      include ActionView::Helpers::NumberHelper
       attr_accessor :sitemap_path, :public_path, :filesize, :link_count, :hostname
 
       # <tt>public_path</tt> full path of the directory to write sitemaps in.
@@ -25,7 +24,7 @@ module SitemapGenerator
       #
       # <tt>hostname</tt> hostname including protocol to use in all links
       #   e.g. http://en.google.ca
-      def initialize(public_path, sitemap_path, hostname)
+      def initialize(public_path, sitemap_path, hostname='http://example.com')
         self.sitemap_path = sitemap_path
         self.public_path = public_path
         self.hostname = hostname
@@ -70,79 +69,47 @@ module SitemapGenerator
         (self.filesize + bytes) < SitemapGenerator::MAX_SITEMAP_FILESIZE && self.link_count < SitemapGenerator::MAX_SITEMAP_LINKS
       end
 
-      # Add a link to the sitemap file and return a boolean indicating whether the
-      # link was added.
+      # Add a link to the sitemap file.
+      #
+      # If a link cannot be added, for example if the file is too large or the link
+      # limit has been reached, a SitemapGenerator::SitemapFull exception is raised.
       #
-      # If a link cannot be added, the file is too large or the link limit has been reached.
-      def add_link(link)
-        xml = build_xml(::Builder::XmlMarkup.new, link)
-        unless file_can_fit?(bytesize(xml))
-          self.finalize!
-          return false
+      # If the Sitemap has already been finalized a SitemapGenerator::SitemapFinalized
+      # exception is raised.
+      #
+      # Call with:
+      #   sitemap_url - a SitemapUrl instance
+      #   sitemap, options - a Sitemap instance and options hash
+      #   path, options - a path for the URL and options hash
+      def add(link, options={})
+        xml = if link.is_a?(SitemapGenerator::Builder::SitemapUrl)
+          link.to_xml
+        else
+          SitemapGenerator::Builder::SitemapUrl.new(link, options).to_xml
         end
 
+        if self.finalized?
+          raise SitemapGenerator::SitemapFinalized
+        elsif !file_can_fit?(bytesize(xml))
+          raise SitemapGenerator::SitemapFull
+        end
+
+        # Add the XML
         @xml_content << xml
         self.filesize += bytesize(xml)
         self.link_count += 1
         true
       end
-      alias_method :<<, :add_link
-
-      # Return XML as a String
-      def build_xml(builder, link)
-        builder.url do
-          builder.loc        link[:loc]
-          builder.lastmod    w3c_date(link[:lastmod])   if link[:lastmod]
-          builder.changefreq link[:changefreq]          if link[:changefreq]
-          builder.priority   link[:priority]            if link[:priority]
-
-          unless link[:images].blank?
-            link[:images].each do |image|
-              builder.image:image do
-                builder.image :loc, image[:loc]
-                builder.image :caption, image[:caption]             if image[:caption]
-                builder.image :geo_location, image[:geo_location]   if image[:geo_location]
-                builder.image :title, image[:title]                 if image[:title]
-                builder.image :license, image[:license]             if image[:license]
-              end
-            end
-          end
-
-          unless link[:video].blank?
-            video = link[:video]
-            builder.video :video do
-              # required elements
-              builder.video :content_loc, video[:content_loc]           if video[:content_loc]
-              if video[:player_loc]
-                builder.video :player_loc, video[:player_loc], :allow_embed => (video[:allow_embed] ? 'yes' : 'no'), :autoplay => video[:autoplay]
-              end
-              builder.video :thumbnail_loc, video[:thumbnail_loc]
-              builder.video :title, video[:title]
-              builder.video :description, video[:description]
-
-              builder.video :rating, video[:rating]                     if video[:rating]
-              builder.video :view_count, video[:view_count]             if video[:view_count]
-              builder.video :publication_date, video[:publication_date] if video[:publication_date]
-              builder.video :expiration_date, video[:expiration_date]   if video[:expiration_date]
-              builder.video :duration, video[:duration]                 if video[:duration]
-              builder.video :family_friendly, (video[:family_friendly] ? 'yes' : 'no')  if video[:family_friendly]
-              builder.video :duration, video[:duration]                 if video[:duration]
-              video[:tags].each {|tag| builder.video :tag, tag }        if video[:tags]
-              builder.video :tag, video[:tag]                           if video[:tag]
-              builder.video :category, video[:category]                 if video[:category]
-              builder.video :gallery_loc, video[:gallery_loc]           if video[:gallery_loc]
-            end
-          end
-        end
-        builder << ''
-      end
 
-      # Insert the content into the XML "wrapper" and write and close the file.
+      # Write out the Sitemap file and freeze this object.
       #
       # All the xml content in the instance is cleared, but attributes like
       # <tt>filesize</tt> are still available.
+      #
+      # A SitemapGenerator::SitemapFinalized exception is raised if the Sitemap
+      # has already been finalized
       def finalize!
-        return if self.frozen?
+        raise SitemapGenerator::SitemapFinalized if self.finalized?
 
         open(self.full_path, 'wb') do |file|
           gz = Zlib::GzipWriter.new(file)
@@ -155,7 +122,20 @@ module SitemapGenerator
         self.freeze
       end
 
-      # Return the bytesize length of the string
+      def finalized?
+        return self.frozen?
+      end
+
+      # Return a summary string
+      def summary
+        uncompressed_size = number_to_human_size(filesize)
+        compressed_size =   number_to_human_size(File.size?(full_path))
+        "+ #{'%-21s' % self.sitemap_path} #{'%13s' % self.link_count} links / #{'%10s' % uncompressed_size} / #{'%10s' % compressed_size} gzipped"
+      end
+
+      protected
+
+      # Return the bytesize length of the string.  Ruby 1.8.6 compatible.
       def bytesize(string)
         string.respond_to?(:bytesize) ? string.bytesize : string.length
       end

data/lib/sitemap_generator/builder/sitemap_index_file.rb

@@ -1,10 +1,12 @@
 module SitemapGenerator
   module Builder
     class SitemapIndexFile < SitemapFile
+      attr_accessor :sitemaps
 
       def initialize(*args)
         super(*args)
 
+        self.sitemaps = []
         @xml_content = '' # XML urlset content
         @xml_wrapper_start = <<-HTML
           <?xml version="1.0" encoding="UTF-8"?>
@@ -20,13 +22,25 @@ module SitemapGenerator
         self.filesize = bytesize(@xml_wrapper_start) + bytesize(@xml_wrapper_end)
       end
 
-      # Return XML as a String
-      def build_xml(builder, link)
-        builder.sitemap do
-          builder.loc        link[:loc]
-          builder.lastmod    w3c_date(link[:lastmod])   if link[:lastmod]
+      # Finalize sitemaps as they are added to the index
+      def add(link, options={})
+        if link.is_a?(SitemapFile)
+          self.sitemaps << link
+          link.finalize!
         end
-        builder << ''
+        super(SitemapGenerator::Builder::SitemapIndexUrl.new(link, options))
+      end
+
+      # Return the total number of links in all sitemaps reference by this index file
+      def total_link_count
+        self.sitemaps.inject(0) { |link_count_sum, sitemap| link_count_sum + sitemap.link_count }
+      end
+
+      # Return a summary string
+      def summary
+        uncompressed_size = number_to_human_size(filesize)
+        compressed_size =   number_to_human_size(File.size?(full_path))
+        "+ #{'%-21s' % self.sitemap_path} #{'%10s' % self.link_count} sitemaps / #{'%10s' % uncompressed_size} / #{'%10s' % compressed_size} gzipped"
       end
     end
   end

data/lib/sitemap_generator/builder/sitemap_index_url.rb

@@ -0,0 +1,28 @@
+require 'builder'
+
+module SitemapGenerator
+  module Builder
+    class SitemapIndexUrl < SitemapUrl
+
+      def initialize(path, options={})
+        if path.is_a?(SitemapGenerator::Builder::SitemapIndexFile)
+          options.reverse_merge!(:host => path.hostname, :lastmod => Time.now, :changefreq => 'always', :priority => 1.0)
+          path = path.sitemap_path
+          super(path, options)
+        else
+          super
+        end
+      end
+
+      # Return the URL as XML
+      def to_xml(builder=nil)
+        builder = ::Builder::XmlMarkup.new if builder.nil?
+        builder.sitemap do
+          builder.loc        self[:loc]
+          builder.lastmod    w3c_date(self[:lastmod])   if self[:lastmod]
+        end
+        builder << '' # force to string
+      end
+    end
+  end
+end

data/lib/sitemap_generator/builder/sitemap_url.rb

@@ -0,0 +1,97 @@
+require 'builder'
+require 'uri'
+
+module SitemapGenerator
+  module Builder
+    class SitemapUrl < Hash
+
+      # Call with:
+      #   sitemap - a Sitemap instance, or
+      #   path, options - a path for the URL and options hash
+      def initialize(path, options={})
+        if path.is_a?(SitemapGenerator::Builder::SitemapFile)
+          options.reverse_merge!(:host => path.hostname, :lastmod => path.lastmod)
+          path = path.sitemap_path
+        end
+
+        options.assert_valid_keys(:priority, :changefreq, :lastmod, :host, :images, :video)
+        options.reverse_merge!(:priority => 0.5, :changefreq => 'weekly', :lastmod => Time.now, :host => Sitemap.default_host, :images => [])
+        self.merge!(
+          :path => path,
+          :priority => options[:priority],
+          :changefreq => options[:changefreq],
+          :lastmod => options[:lastmod],
+          :host => options[:host],
+          :loc => URI.join(options[:host], path).to_s,
+          :images => prepare_images(options[:images], options[:host]),
+          :video => options[:video]
+        )
+      end
+
+      # Return the URL as XML
+      def to_xml(builder=nil)
+        builder = ::Builder::XmlMarkup.new if builder.nil?
+        builder.url do
+          builder.loc        self[:loc]
+          builder.lastmod    w3c_date(self[:lastmod])   if self[:lastmod]
+          builder.changefreq self[:changefreq]          if self[:changefreq]
+          builder.priority   self[:priority]            if self[:priority]
+
+          unless self[:images].blank?
+            self[:images].each do |image|
+              builder.image:image do
+                builder.image :loc, image[:loc]
+                builder.image :caption, image[:caption]             if image[:caption]
+                builder.image :geo_location, image[:geo_location]   if image[:geo_location]
+                builder.image :title, image[:title]                 if image[:title]
+                builder.image :license, image[:license]             if image[:license]
+              end
+            end
+          end
+
+          unless self[:video].blank?
+            video = self[:video]
+            builder.video :video do
+              builder.video :content_loc, video[:content_loc]           if video[:content_loc]
+              if video[:player_loc]
+                builder.video :player_loc, video[:player_loc], :allow_embed => (video[:allow_embed] ? 'yes' : 'no'), :autoplay => video[:autoplay]
+              end
+              builder.video :thumbnail_loc, video[:thumbnail_loc]
+              builder.video :title, video[:title]
+              builder.video :description, video[:description]
+
+              builder.video :rating, video[:rating]                     if video[:rating]
+              builder.video :view_count, video[:view_count]             if video[:view_count]
+              builder.video :publication_date, video[:publication_date] if video[:publication_date]
+              builder.video :expiration_date, video[:expiration_date]   if video[:expiration_date]
+              builder.video :duration, video[:duration]                 if video[:duration]
+              builder.video :family_friendly, (video[:family_friendly] ? 'yes' : 'no')  if video[:family_friendly]
+              builder.video :duration, video[:duration]                 if video[:duration]
+              video[:tags].each {|tag| builder.video :tag, tag }        if video[:tags]
+              builder.video :tag, video[:tag]                           if video[:tag]
+              builder.video :category, video[:category]                 if video[:category]
+              builder.video :gallery_loc, video[:gallery_loc]           if video[:gallery_loc]
+            end
+          end
+        end
+        builder << '' # Force to string
+      end
+
+      protected
+
+      # Return an Array of image option Hashes suitable to be parsed by SitemapGenerator::Builder::SitemapFile
+      def prepare_images(images, host)
+        images.delete_if { |key,value| key[:loc] == nil }
+        images.each do |r|
+          r.assert_valid_keys(:loc, :caption, :geo_location, :title, :license)
+          r[:loc] = URI.join(host, r[:loc]).to_s
+        end
+        images[0..(SitemapGenerator::MAX_SITEMAP_IMAGES-1)]
+      end
+
+      def w3c_date(date)
+         date.utc.strftime("%Y-%m-%dT%H:%M:%S+00:00")
+      end
+    end
+  end
+end

data/lib/sitemap_generator/link_set.rb

@@ -8,26 +8,43 @@ module SitemapGenerator
     include ActionView::Helpers::NumberHelper  # for number_with_delimiter
 
     attr_accessor :default_host, :public_path, :sitemaps_path
-    attr_accessor :sitemap, :sitemaps, :sitemap_index
+    attr_accessor :sitemap, :sitemap_index
     attr_accessor :verbose, :yahoo_app_id
 
     # Evaluate the sitemap config file and write all sitemaps.
     #
-    # This should be refactored so that we can have multiple instances
+    # The Sitemap Interpreter includes the URL helpers and API methods
+    # that the block argument to `add_links` is evaluted within.
+    #
+    # TODO: Refactor so that we can have multiple instances
     # of LinkSet.
     def create
       require 'sitemap_generator/interpreter'
 
       self.public_path = File.join(::Rails.root, 'public/') if self.public_path.nil?
 
+      # Default host is not set yet.  Set it on these objects when `add_links` is called
+      self.sitemap_index = SitemapGenerator::Builder::SitemapIndexFile.new(public_path, sitemap_index_path)
+      self.sitemap = SitemapGenerator::Builder::SitemapFile.new(public_path, new_sitemap_path)
+
       start_time = Time.now
       SitemapGenerator::Interpreter.run
-      finalize!
+      unless self.sitemap.finalized?
+        self.sitemap_index.add(self.sitemap)
+        puts self.sitemap.summary if verbose
+      end
+      self.sitemap_index.finalize!
       end_time = Time.now
-
-      puts "\nSitemap stats: #{number_with_delimiter(self.link_count)} links / #{self.sitemaps.size} files / " + ("%dm%02ds" % (end_time - start_time).divmod(60)) if verbose
+      
+      if verbose
+        puts self.sitemap_index.summary 
+        puts "\nSitemap stats: #{number_with_delimiter(self.sitemap_index.total_link_count)} links / #{self.sitemap_index.sitemaps.size} sitemaps / " +
+              ("%dm%02ds" % (end_time - start_time).divmod(60))
+      end
     end
 
+    # Constructor
+    #
     # <tt>public_path</tt> (optional) full path to the directory to write sitemaps in.
     #   Defaults to your Rails <tt>public/</tt> directory.
     #
@@ -40,15 +57,10 @@ module SitemapGenerator
       self.default_host = default_host
       self.public_path = public_path
       self.sitemaps_path = sitemaps_path
-
-      # Completed sitemaps
-      self.sitemaps = []
-    end
-
-    def link_count
-      self.sitemaps.inject(0) { |link_count_sum, sitemap| link_count_sum + sitemap.link_count }
     end
 
+    # Entry point for users.
+    #
     # Called within the user's eval'ed sitemap config file.  Add links to sitemap files
     # passing a block.
     #
@@ -56,61 +68,29 @@ module SitemapGenerator
     def add_links
       raise ArgumentError, "Default hostname not set" if default_host.blank?
 
-      # I'd rather have these calls in <tt>create</tt> but we have to wait
-      # for <tt>default_host</tt> to be set by the user's sitemap config
-      new_sitemap
-      add_default_links
-
-      yield Mapper.new(self)
-    end
+      # Set default host on the sitemap objects and seed the sitemap with the default links
+      self.sitemap.hostname = self.sitemap_index.hostname = default_host
+      self.sitemap.add('/', :lastmod => Time.now, :changefreq => 'always', :priority => 1.0)
+      self.sitemap.add(self.sitemap_index, :lastmod => Time.now, :changefreq => 'always', :priority => 1.0)
 
-    # Called from Mapper.
-    #
-    # Add a link to the current sitemap.
-    def add_link(link)
-      unless self.sitemap << link
-        new_sitemap
-        self.sitemap << link
-      end
+      yield self
     end
 
-    # Add the current sitemap to the <tt>sitemaps</tt> Array and
-    # start a new sitemap.
-    #
-    # If the current sitemap is nil or empty it is not added.
-    def new_sitemap
-      unless self.sitemap_index
-        self.sitemap_index = SitemapGenerator::Builder::SitemapIndexFile.new(public_path, sitemap_index_path, default_host)
-      end
-
-      unless self.sitemap
-        self.sitemap = SitemapGenerator::Builder::SitemapFile.new(public_path, new_sitemap_path, default_host)
-      end
-
-      # Mark the sitemap as complete and add it to the sitemap index
-      unless self.sitemap.empty?
-        self.sitemap.finalize!
-        self.sitemap_index << Link.generate(self.sitemap)
-        self.sitemaps << self.sitemap
-        show_progress(self.sitemap) if verbose
-
+    # Add a link to a Sitemap.  If a new Sitemap is required, one will be created for
+    # you.
+    def add(link, options={})
+      begin
+        self.sitemap.add(link, options)
+      rescue SitemapGenerator::SitemapError => e
+        if e.is_a?(SitemapGenerator::SitemapFullError)
+          self.sitemap_index.add(self.sitemap)
+          puts self.sitemap.summary if verbose
+        end
         self.sitemap = SitemapGenerator::Builder::SitemapFile.new(public_path, new_sitemap_path, default_host)
+        retry
       end
     end
 
-    # Report progress line.
-    def show_progress(sitemap)
-      uncompressed_size = number_to_human_size(sitemap.filesize)
-      compressed_size =   number_to_human_size(File.size?(sitemap.full_path))
-      puts "+ #{sitemap.sitemap_path}   #{sitemap.link_count} links / #{uncompressed_size} / #{compressed_size} gzipped"
-    end
-
-    # Finalize all sitemap files
-    def finalize!
-      new_sitemap
-      self.sitemap_index.finalize!
-    end
-
     # Ping search engines.
     #
     # @see http://en.wikipedia.org/wiki/Sitemap_index
@@ -149,18 +129,17 @@ module SitemapGenerator
       end
     end
 
-    protected
-
-    def add_default_links
-      self.sitemap << Link.generate('/', :lastmod => Time.now, :changefreq => 'always', :priority => 1.0)
-      self.sitemap << Link.generate(self.sitemap_index, :lastmod => Time.now, :changefreq => 'always', :priority => 1.0)
+    def link_count
+      self.sitemap_index.total_link_count
     end
+    
+    protected
 
     # Return the current sitemap filename with index.
     #
     # The index depends on the length of the <tt>sitemaps</tt> array.
     def new_sitemap_path
-      File.join(self.sitemaps_path || '', "sitemap#{self.sitemaps.length + 1}.xml.gz")
+      File.join(self.sitemaps_path || '', "sitemap#{self.sitemap_index.sitemaps.length + 1}.xml.gz")
     end
 
     # Return the current sitemap index filename.

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: sitemap_generator
 version: !ruby/object:Gem::Version 
-  hash: 17
+  hash: 31
   prerelease: false
   segments: 
   - 1
-  - 1
-  - 1
-  version: 1.1.1
+  - 2
+  - 0
+  version: 1.2.0
 platform: ruby
 authors: 
 - Karl Varga
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-27 00:00:00 -07:00
+date: 2010-10-14 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -76,14 +76,12 @@ files:
 - VERSION
 - lib/sitemap_generator.rb
 - lib/sitemap_generator/builder.rb
-- lib/sitemap_generator/builder/helper.rb
 - lib/sitemap_generator/builder/sitemap_file.rb
-- lib/sitemap_generator/builder/sitemap_file.rb.orig
 - lib/sitemap_generator/builder/sitemap_index_file.rb
+- lib/sitemap_generator/builder/sitemap_index_url.rb
+- lib/sitemap_generator/builder/sitemap_url.rb
 - lib/sitemap_generator/interpreter.rb
-- lib/sitemap_generator/link.rb
 - lib/sitemap_generator/link_set.rb
-- lib/sitemap_generator/mapper.rb
 - lib/sitemap_generator/railtie.rb
 - lib/sitemap_generator/tasks.rb
 - lib/sitemap_generator/templates.rb

data/lib/sitemap_generator/builder/helper.rb

@@ -1,10 +0,0 @@
-module SitemapGenerator
-  module Builder
-    module Helper
-
-      def w3c_date(date)
-         date.utc.strftime("%Y-%m-%dT%H:%M:%S+00:00")
-      end
-    end
-  end
-end

data/lib/sitemap_generator/builder/sitemap_file.rb.orig

@@ -1,133 +0,0 @@
-require 'sitemap_generator/builder/helper'
-require 'builder'
-require 'zlib'
-
-module SitemapGenerator
-  module Builder
-    class SitemapFile
-      include SitemapGenerator::Builder::Helper
-
-      attr_accessor :sitemap_path, :public_path, :filesize, :link_count, :hostname
-
-      # <tt>public_path</tt> full path of the directory to write sitemaps in.
-      #   Usually your Rails <tt>public/</tt> directory.
-      #
-      # <tt>sitemap_path</tt> relative path including filename of the sitemap
-      #   file relative to <tt>public_path</tt>
-      #
-      # <tt>hostname</tt> hostname including protocol to use in all links
-      #   e.g. http://en.google.ca
-      def initialize(public_path, sitemap_path, hostname)
-        self.sitemap_path = sitemap_path
-        self.public_path = public_path
-        self.hostname = hostname
-        self.link_count = 0
-
-        @xml_content       = ''     # XML urlset content
-        @xml_wrapper_start = <<-HTML
-          <?xml version="1.0" encoding="UTF-8"?>
-            <urlset
-              xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-              xmlns:image="http://www.google.com/schemas/sitemap-image/1.1"
-              xsi:schemaLocation="http://www.sitemaps.org/schemas/sitemap/0.9
-                http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd"
-              xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
-            >
-        HTML
-<<<<<<< HEAD
-        @xml_wrapper_start.gsub!(/\s+/, ' ').gsub!(/ *> */, '>').strip!
-=======
-        @xml_wrapper_start.gsub!(/\s+/, ' ').gsub!(/ *> */, '>').gsub!(' <','<')
->>>>>>> 7f3f574... removing first space on xml start. ' <?xml...' becames '<?xml...>' it's allow firefox xml view
-        @xml_wrapper_end   = %q[</urlset>]
-        self.filesize = bytesize(@xml_wrapper_start) + bytesize(@xml_wrapper_end)
-      end
-
-      def lastmod
-        File.mtime(self.full_path) rescue nil
-      end
-
-      def empty?
-        self.link_count == 0
-      end
-
-      def full_url
-        URI.join(self.hostname, self.sitemap_path).to_s
-      end
-
-      def full_path
-        @full_path ||= File.join(self.public_path, self.sitemap_path)
-      end
-
-      # Return a boolean indicating whether the sitemap file can fit another link
-      # of <tt>bytes</tt> bytes in size.
-      def file_can_fit?(bytes)
-        (self.filesize + bytes) < SitemapGenerator::MAX_SITEMAP_FILESIZE && self.link_count < SitemapGenerator::MAX_SITEMAP_LINKS
-      end
-
-      # Add a link to the sitemap file and return a boolean indicating whether the
-      # link was added.
-      #
-      # If a link cannot be added, the file is too large or the link limit has been reached.
-      def add_link(link)
-        xml = build_xml(::Builder::XmlMarkup.new, link)
-        unless file_can_fit?(bytesize(xml))
-          self.finalize!
-          return false
-        end
-
-        @xml_content << xml
-        self.filesize += bytesize(xml)
-        self.link_count += 1
-        true
-      end
-      alias_method :<<, :add_link
-
-      # Return XML as a String
-      def build_xml(builder, link)
-        builder.url do
-          builder.loc        link[:loc]
-          builder.lastmod    w3c_date(link[:lastmod])   if link[:lastmod]
-          builder.changefreq link[:changefreq]          if link[:changefreq]
-          builder.priority   link[:priority]            if link[:priority]
-
-          unless link[:images].blank?
-            link[:images].each do |image|
-              builder.image:image do
-                builder.image :loc, image[:loc]
-                builder.image :caption, image[:caption]             if image[:caption]
-                builder.image :geo_location, image[:geo_location]   if image[:geo_location]
-                builder.image :title, image[:title]                 if image[:title]
-                builder.image :license, image[:license]             if image[:license]
-              end
-            end
-          end
-        end
-        builder << ''
-      end
-
-      # Insert the content into the XML "wrapper" and write and close the file.
-      #
-      # All the xml content in the instance is cleared, but attributes like
-      # <tt>filesize</tt> are still available.
-      def finalize!
-        return if self.frozen?
-
-        open(self.full_path, 'wb') do |file|
-          gz = Zlib::GzipWriter.new(file)
-          gz.write @xml_wrapper_start
-          gz.write @xml_content
-          gz.write @xml_wrapper_end
-          gz.close
-        end
-        @xml_content = @xml_wrapper_start = @xml_wrapper_end = ''
-        self.freeze
-      end
-
-      # Return the bytesize length of the string
-      def bytesize(string)
-        string.respond_to?(:bytesize) ? string.bytesize : string.length
-      end
-    end
-  end
-end

data/lib/sitemap_generator/link.rb

@@ -1,37 +0,0 @@
-module SitemapGenerator
-  module Link
-    extend self
-
-    # Return a Hash of options suitable to pass to a SitemapGenerator::Builder::SitemapFile instance.
-    def generate(path, options = {})
-      if path.is_a?(SitemapGenerator::Builder::SitemapFile)
-        options.reverse_merge!(:host => path.hostname, :lastmod => path.lastmod)
-        path = path.sitemap_path
-      end
-
-      options.assert_valid_keys(:priority, :changefreq, :lastmod, :host, :images, :video)
-      options.reverse_merge!(:priority => 0.5, :changefreq => 'weekly', :lastmod => Time.now, :host => Sitemap.default_host, :images => [])
-      {
-        :path => path,
-        :priority => options[:priority],
-        :changefreq => options[:changefreq],
-        :lastmod => options[:lastmod],
-        :host => options[:host],
-        :loc => URI.join(options[:host], path).to_s,
-        :images => prepare_images(options[:images], options[:host]),
-        :video => options[:video]
-      }
-    end
-
-    # Return an Array of image option Hashes suitable to be parsed by SitemapGenerator::Builder::SitemapFile
-    def prepare_images(images, host)
-      images.delete_if { |key,value| key[:loc] == nil }
-      images.each do |r|
-        r.assert_valid_keys(:loc, :caption, :geo_location, :title, :license)
-        r[:loc] = URI.join(host, r[:loc]).to_s
-      end
-      images[0..(SitemapGenerator::MAX_SITEMAP_IMAGES-1)]
-    end
-  end
-end
-

data/lib/sitemap_generator/mapper.rb

@@ -1,16 +0,0 @@
-module SitemapGenerator
-  # Generator instances are used to build links.
-  # The object passed to the add_links block in config/sitemap.rb is a Generator instance.
-  class Mapper
-    attr_accessor :set
-
-    def initialize(set)
-      @set = set
-    end
-
-    def add(loc, options = {})
-      set.add_link Link.generate(loc, options)
-    end
-  end
-end
-