big_sitemap 0.8.3 → 1.0.0

data/lib/big_sitemap/builder.rb

@@ -14,35 +14,36 @@ class BigSitemap
       @gzip           = options.delete(:gzip)
       @max_urls       = options.delete(:max_urls) || MAX_URLS
       @type           = options.delete(:type)
-      @paths          = []
+      @filepaths      = []
       @parts          = options.delete(:start_part_id) || 0
-      @custom_part_nr = options.delete(:partial_update)
+      @partial_update = options.delete(:partial_update)
 
-      @filename = options.delete(:filename)
+      @filename         = options.delete(:filename)
       @current_filename = nil
       @tmp_filename     = nil
-      @target = _get_writer
+      @target           = _get_writer
 
       @level = 0
       @opened_tags = []
       _init_document
     end
 
-    def add_url!(url, time = nil, frequency = nil, priority = nil, part_nr = nil)
-      _rotate(part_nr) if @max_urls == @urls
-
+    def add_url!(location, options={})
+      _rotate(options[:id]) if @max_urls == @urls
       _open_tag 'url'
-      tag! 'loc', url
-      tag! 'lastmod', time.utc.strftime('%Y-%m-%dT%H:%M:%S+00:00') if time
-      tag! 'changefreq', frequency if frequency
-      tag! 'priority', priority if priority
+
+      tag! 'loc', location
+      tag! 'lastmod', options[:last_modified].utc.strftime('%Y-%m-%dT%H:%M:%S+00:00') if options[:last_modified]
+      tag! 'changefreq', options[:change_frequency] || 'weekly'
+      tag! 'priority', options[:priority] if options[:priority]
+
       _close_tag 'url'
 
       @urls += 1
     end
 
-    def paths!
-      @paths
+    def filepaths!
+      @filepaths
     end
 
     def close!
@@ -60,7 +61,7 @@ class BigSitemap
 
     def _get_writer
       filename = @filename.dup
-      filename << "_#{@parts}" if @parts > 0
+      filename << "_#{@parts}" if @parts > 0 && @type != 'index'
       filename << '.xml'
       filename << '.gz' if @gzip
       _open_writer(filename)
@@ -69,28 +70,28 @@ class BigSitemap
     def _open_writer(filename)
       @current_filename = filename
       @tmp_filename     = filename + ".tmp"
-      @paths << filename
-      file = ::File.open(@tmp_filename, 'w+')
+      @filepaths << filename
+      file = ::File.open(@tmp_filename, 'w+:ASCII-8BIT')
       @gzip ? ::Zlib::GzipWriter.new(file) : file
     end
 
-    def _init_document( name = 'urlset', attrs = HEADER_ATTRIBUTES)
+    def _init_document(name='urlset', attrs=HEADER_ATTRIBUTES)
       @urls = 0
       target!.print '<?xml version="1.0" encoding="UTF-8"?>'
       _newline
       _open_tag name, attrs
     end
 
-    def _rotate(part_nr = nil)
+    def _rotate(part_nr=nil)
       # write out the current document and start writing into a new file
       close!
-      @parts = (part_nr && @custom_part_nr) ? part_nr : @parts + 1
+      @parts = part_nr || @parts + 1
       @target = _get_writer
       _init_document
     end
 
     # opens a tag, bumps up level but doesn't require a block
-    def _open_tag(name, attrs = {})
+    def _open_tag(name, attrs={})
       _indent
       _start_tag(name, attrs)
       _newline
@@ -98,8 +99,8 @@ class BigSitemap
       @opened_tags << name
     end
 
-    def _start_tag(name, attrs = {})
-      attrs = attrs.map { |attr,value| %Q( #{attr}="#{value}") }.join('')
+    def _start_tag(name, attrs={})
+      attrs = attrs.map { |attr, value| %Q( #{attr}="#{value}") }.join('')
       target!.print "<#{name}#{attrs}>"
     end
 
@@ -131,12 +132,10 @@ class BigSitemap
     end
 
     def _indent
-      return if @gzip
       target!.print "  " * @level
     end
 
     def _newline
-      return if @gzip
       target!.puts ''
     end
   end
@@ -147,10 +146,12 @@ class BigSitemap
       super(name, attrs)
     end
 
-    def add_url!(url, time = nil)
+    def add_url!(location, options={})
       _open_tag 'sitemap'
-      tag! 'loc', url
-      tag! 'lastmod', time.utc.strftime('%Y-%m-%dT%H:%M:%S+00:00') if time
+
+      tag! 'loc', location
+      tag! 'lastmod', options[:last_modified].utc.strftime('%Y-%m-%dT%H:%M:%S+00:00') if options[:last_modified]
+
       _close_tag 'sitemap'
     end
   end

data/test/big_sitemap_test.rb

@@ -31,379 +31,271 @@ class BigSitemapTest < Test::Unit::TestCase
     assert_equal url, sitemap.instance_variable_get(:@options)[:base_url]
   end
 
-  should 'generate a sitemap index file' do
-    generate_sitemap_files
-    assert File.exists?(sitemaps_index_file)
+  should 'generate sitemap index file' do
+    generate_sitemap { add '/foo' }
+    assert File.exists? first_sitemap_file
   end
 
-  should 'generate a single sitemap model file' do
-    create_sitemap
-    add_model
-    @sitemap.generate
-    assert File.exists?(first_sitemaps_model_file), "#{first_sitemaps_model_file} exists"
+  should 'generate static file' do
+    generate_sitemap { add '/foo' }
+    assert File.exists? first_sitemap_file
   end
 
-  should 'generate two sitemap model files' do
-    generate_two_model_sitemap_files
-    assert File.exists?(first_sitemaps_model_file), "#{first_sitemaps_model_file} exists"
-    assert File.exists?(second_sitemaps_model_file), "#{second_sitemaps_model_file} exists"
-    assert !File.exists?(third_sitemaps_model_file), "#{third_sitemaps_model_file} does not exist"
-  end
-
-  should 'generate two sitemap model files for the same model with different options' do
-    create_sitemap
-    add_model(:path => 'foo')
-    add_model(:path => 'bar')
-    @sitemap.generate
+  should 'should add paths' do
+    generate_sitemap do
+      add '/', {:last_modified => Time.now, :change_frequency => 'weekly', :priority => 0.5}
+      add '/about', {:last_modified => Time.now, :change_frequency => 'weekly', :priority => 0.5}
+    end
 
-    assert File.exists?(first_sitemaps_model_file), "#{first_sitemaps_model_file} exists"
-    assert File.exists?(second_sitemaps_model_file), "#{second_sitemaps_model_file} exists"
+    elems = elements first_sitemap_file, 'loc'
+    assert_equal 'http://example.com/', elems.first.text
+    assert_equal 'http://example.com/about', elems.last.text
   end
 
   context 'Sitemap index file' do
     should 'contain one sitemapindex element' do
-      generate_sitemap_files
+      generate_sitemap { add '/' }
       assert_equal 1, num_elements(sitemaps_index_file, 'sitemapindex')
     end
 
     should 'contain one sitemap element' do
-      generate_sitemap_files
+      generate_sitemap { add '/' }  
       assert_equal 1, num_elements(sitemaps_index_file, 'sitemap')
     end
 
     should 'contain one loc element' do
-      generate_one_sitemap_model_file
+      generate_sitemap { add '/' }  
       assert_equal 1, num_elements(sitemaps_index_file, 'loc')
     end
 
     should 'contain one lastmod element' do
-      generate_one_sitemap_model_file
+      generate_sitemap { add '/' }  
       assert_equal 1, num_elements(sitemaps_index_file, 'lastmod')
     end
 
     should 'contain two loc elements' do
-      generate_two_model_sitemap_files
+      generate_sitemap(:max_per_sitemap => 2) do
+        4.times { add '/' }
+      end
+
       assert_equal 2, num_elements(sitemaps_index_file, 'loc')
     end
 
     should 'contain two lastmod elements' do
-      generate_two_model_sitemap_files
+      generate_sitemap(:max_per_sitemap => 2) do
+        4.times { add '/' }
+      end
+
       assert_equal 2, num_elements(sitemaps_index_file, 'lastmod')
     end
 
     should 'not be gzipped' do
-      generate_sitemap_files(:gzip => false)
+      generate_sitemap(:gzip => false) { add '/' }
       assert File.exists?(unzipped_sitemaps_index_file)
     end
   end
 
-  context 'Sitemap model file' do
+  context 'Sitemap file' do
     should 'contain one urlset element' do
-      generate_one_sitemap_model_file
-      assert_equal 1, num_elements(first_sitemaps_model_file, 'urlset')
+      generate_sitemap { add '/' }
+      assert_equal 1, num_elements(first_sitemap_file, 'urlset')
     end
 
     should 'contain several loc elements' do
-      generate_one_sitemap_model_file
-      assert_equal default_num_items, num_elements(first_sitemaps_model_file, 'loc')
+      generate_sitemap do
+        3.times { add '/' }
+      end
+
+      assert_equal 3, num_elements(first_sitemap_file, 'loc')
     end
 
     should 'contain several lastmod elements' do
-      generate_one_sitemap_model_file
-      assert_equal default_num_items, num_elements(first_sitemaps_model_file, 'lastmod')
+      generate_sitemap do
+        3.times { add '/', :last_modified => Time.now }
+      end
+
+      assert_equal 3, num_elements(first_sitemap_file, 'lastmod')
     end
 
     should 'contain several changefreq elements' do
-      generate_one_sitemap_model_file
-      assert_equal default_num_items, num_elements(first_sitemaps_model_file, 'changefreq')
+      generate_sitemap do
+        3.times { add '/' }
+      end
+
+      assert_equal 3, num_elements(first_sitemap_file, 'changefreq')
     end
 
     should 'contain several priority elements' do
-      generate_one_sitemap_model_file(:priority => 0.2)
-      assert_equal default_num_items, num_elements(first_sitemaps_model_file, 'priority')
+      generate_sitemap do
+        3.times { add '/', :priority => 0.2 }
+      end
+
+      assert_equal 3, num_elements(first_sitemap_file, 'priority')
     end
 
     should 'have a change frequency of weekly by default' do
-      generate_one_sitemap_model_file
-      assert_equal 'weekly', elements(first_sitemaps_model_file, 'changefreq').first.text
-    end
+      generate_sitemap do
+        3.times { add '/' }
+      end
 
-    should 'have a change frequency of daily' do
-      generate_one_sitemap_model_file(:change_frequency => 'daily')
-      assert_equal 'daily', elements(first_sitemaps_model_file, 'changefreq').first.text
+      assert_equal 'weekly', elements(first_sitemap_file, 'changefreq').first.text
     end
 
-    should 'be able to use a lambda to specify change frequency' do
-      generate_one_sitemap_model_file(:change_frequency => lambda {|m| m.change_frequency})
-      assert_equal TestModel.new.change_frequency, elements(first_sitemaps_model_file, 'changefreq').first.text
+    should 'have a change frequency of daily' do
+      generate_sitemap { add '/', :change_frequency => 'daily' }
+      assert_equal 'daily', elements(first_sitemap_file, 'changefreq').first.text
     end
 
     should 'have a priority of 0.2' do
-      generate_one_sitemap_model_file(:priority => 0.2)
-      assert_equal '0.2', elements(first_sitemaps_model_file, 'priority').first.text
-    end
-
-    should 'be able to use a lambda to specify priority' do
-      generate_one_sitemap_model_file(:priority => lambda {|m| m.priority})
-      assert_equal TestModel.new.priority.to_s, elements(first_sitemaps_model_file, 'priority').first.text
-    end
-
-    should 'be able to use a lambda to specify lastmod' do
-      generate_one_sitemap_model_file(:last_modified => lambda {|m| m.updated_at})
-      assert_equal TestModel.new.updated_at.utc.strftime('%Y-%m-%dT%H:%M:%S+00:00'), elements(first_sitemaps_model_file, 'lastmod').first.text
+      generate_sitemap { add '/', :priority => 0.2 }
+      assert_equal '0.2', elements(first_sitemap_file, 'priority').first.text
     end
 
     should 'contain two loc element' do
-      generate_two_model_sitemap_files
-      assert_equal 2, num_elements(first_sitemaps_model_file, 'loc')
-      assert_equal 2, num_elements(second_sitemaps_model_file, 'loc')
-    end
+      generate_sitemap(:max_per_sitemap => 2) do
+        4.times { add '/' }
+      end
 
-    should 'contain two lastmod element' do
-      generate_two_model_sitemap_files
-      assert_equal 2, num_elements(first_sitemaps_model_file, 'lastmod')
-      assert_equal 2, num_elements(second_sitemaps_model_file, 'lastmod')
+      assert_equal 2, num_elements(first_sitemap_file, 'loc')
+      assert_equal 2, num_elements(second_sitemap_file, 'loc')
     end
 
     should 'contain two changefreq elements' do
-      generate_two_model_sitemap_files
-      assert_equal 2, num_elements(first_sitemaps_model_file, 'changefreq')
-      assert_equal 2, num_elements(second_sitemaps_model_file, 'changefreq')
+      generate_sitemap(:max_per_sitemap => 2) do
+        4.times { add '/' }
+      end
+
+      assert_equal 2, num_elements(first_sitemap_file, 'changefreq')
+      assert_equal 2, num_elements(second_sitemap_file, 'changefreq')
     end
 
     should 'contain two priority element' do
-      generate_two_model_sitemap_files(:priority => 0.2)
-      assert_equal 2, num_elements(first_sitemaps_model_file, 'priority')
-      assert_equal 2, num_elements(second_sitemaps_model_file, 'priority')
-    end
+      generate_sitemap(:max_per_sitemap => 2) do
+        4.times { add '/', :priority => 0.2 }
+      end
 
-    should 'strip leading slashes from controller paths' do
-      create_sitemap
-      add_model
-      @sitemap.add(TestModel, :path => '/test_controller').generate
-      assert(
-        !elements(first_sitemaps_model_file, 'loc').first.text.match(/\/\/test_controller\//),
-        'URL does not contain a double-slash before the controller path'
-      )
+      assert_equal 2, num_elements(first_sitemap_file, 'priority')
+      assert_equal 2, num_elements(second_sitemap_file, 'priority')
     end
 
     should 'not be gzipped' do
-      generate_one_sitemap_model_file(:gzip => false)
-      assert File.exists?(unzipped_first_sitemaps_model_file)
-    end
-  end
-
-  context 'add method' do
-    should 'be chainable' do
-      create_sitemap
-      assert_equal BigSitemap, @sitemap.add(TestModel).class
-    end
-  end
-
-  context 'add static method' do
-    should 'should generate static content' do
-      create_sitemap
-      @sitemap.add_static('/', Time.now, 'weekly', 0.5)
-      @sitemap.add_static('/about', Time.now, 'weekly', 0.5)
-      @sitemap.generate_static
-      elems = elements(static_sitemaps_file, 'loc')
-      assert_equal "/", elems.first.text
-      assert_equal "/about", elems.last.text
+      generate_sitemap(:gzip => false) { add '/' }
+      assert File.exists?(unzipped_first_sitemap_file)
     end
   end
 
   context 'sanatize XML chars' do
     should 'should transform ampersands' do
-      create_sitemap
-      @sitemap.add_static('/something&else', Time.now, 'weekly', 0.5)
-      @sitemap.generate_static
-      elems = elements(static_sitemaps_file, 'loc')
-      assert Zlib::GzipReader.open(static_sitemaps_file).read.include?("/something&amp;else")
-      assert_equal "/something&else", elems.first.text
+      generate_sitemap { add '/something&else' }
+      elems = elements(first_sitemap_file, 'loc')
+
+      assert Zlib::GzipReader.open(first_sitemap_file).read.include?("/something&amp;else")
+      assert_equal 'http://example.com/something&else', elems.first.text
     end
   end
 
   context 'clean method' do
     should 'be chainable' do
-      create_sitemap
-      assert_equal BigSitemap, @sitemap.clean.class
+      sitemap = generate_sitemap { add '/' }
+      assert_equal BigSitemap, sitemap.clean.class
     end
 
     should 'clean all sitemap files' do
-      generate_sitemap_files
-      assert Dir.entries(sitemaps_dir).size > 2, "#{sitemaps_dir} is not empty" # ['.', '..'].size == 2
-      @sitemap.clean
-      assert_equal 2, Dir.entries(sitemaps_dir).size, "#{sitemaps_dir} is empty"
-    end
-  end
-
-  context 'generate method' do
-    should 'be chainable' do
-      create_sitemap
-      assert_equal BigSitemap, @sitemap.generate.class
+      sitemap = generate_sitemap { add '/' }
+      assert Dir["#{sitemaps_dir}/sitemap*"].size > 0, "#{sitemaps_dir} has sitemap files"
+      sitemap.clean
+      assert_equal 0, Dir["#{sitemaps_dir}/sitemap*"].size, "#{sitemaps_dir} is empty of sitemap files"
     end
   end
 
   context 'sitemap index' do
     should 'generate for all xml files in directory' do
-      create_sitemap
-      @sitemap.clean
+      sitemap = generate_sitemap {}
       File.open("#{sitemaps_dir}/sitemap_file1.xml", 'w')
       File.open("#{sitemaps_dir}/sitemap_file2.xml.gz", 'w')
       File.open("#{sitemaps_dir}/sitemap_file3.txt", 'w')
       File.open("#{sitemaps_dir}/file4.xml", 'w')
       File.open(unzipped_sitemaps_index_file, 'w')
-      @sitemap.send :generate_sitemap_index
+      sitemap.send :generate_sitemap_index
 
       elem = elements(sitemaps_index_file, 'loc')
       assert_equal 2, elem.size #no index and file3 and file4 found
-      assert_equal "http://example.com/sitemaps/sitemap_file1.xml", elem.first.text
-      assert_equal "http://example.com/sitemaps/sitemap_file2.xml.gz", elem.last.text
+      assert_equal "http://example.com/sitemap_file1.xml", elem.first.text
+      assert_equal "http://example.com/sitemap_file2.xml.gz", elem.last.text
     end
 
     should 'generate for all for given file' do
-      create_sitemap
-      @sitemap.clean
+      sitemap = generate_sitemap {}
       File.open("#{sitemaps_dir}/sitemap_file1.xml", 'w')
       File.open("#{sitemaps_dir}/sitemap_file2.xml.gz", 'w')
       files = ["#{sitemaps_dir}/sitemap_file1.xml", "#{sitemaps_dir}/sitemap_file2.xml.gz"]
-      @sitemap.send :generate_sitemap_index, files
+      sitemap.send :generate_sitemap_index, files
 
       elem = elements(sitemaps_index_file, 'loc')
       assert_equal 2, elem.size
-      assert_equal "http://example.com/sitemaps/sitemap_file1.xml", elem.first.text
-      assert_equal "http://example.com/sitemaps/sitemap_file2.xml.gz", elem.last.text
-    end
-  end
-
-  context 'get_last_id' do
-    should 'return last id' do
-      create_sitemap.clean
-      filename = "#{sitemaps_dir}/sitemap_file"
-      File.open("#{filename}_1.xml", 'w')
-      File.open("#{filename}_23.xml", 'w')
-      File.open("#{filename}_42.xml.gz", 'w')
-      File.open("#{filename}_9.xml", 'w')
-      assert_equal 42, @sitemap.send(:get_last_id, filename)
-    end
-
-    should 'return nil' do
-      create_sitemap.clean
-      filename = "#{sitemaps_dir}/sitemap_file"
-      assert_equal nil, @sitemap.send(:get_last_id, filename)
+      assert_equal "http://example.com/sitemap_file1.xml", elem.first.text
+      assert_equal "http://example.com/sitemap_file2.xml.gz", elem.last.text
     end
   end
 
   context 'partial update' do
-
-    context 'prepare_update' do
-      should 'generate correct condition for partial update' do
-        filename = "#{sitemaps_dir}/sitemap_test_models"
-
-        create_sitemap(:partial_update => true).clean
-        add_model(:num_items => 50) #TestModel
-
-        File.open("#{filename}_23.xml", 'w')
-        assert_equal "(id >= 23)", @sitemap.send(:prepare_update).first.last[:conditions]
-
-        File.open("#{filename}_42.xml", 'w')
-        assert_equal "(id >= 23) AND (id >= 42)", @sitemap.send(:prepare_update).first.last[:conditions]
+    should 'not recreate old files' do
+      # The first run should generate all the files
+      generate_sitemap(:max_per_sitemap => 2, :partial_update => true, :gzip => false) do
+        [10, 20, 30, 40, 50].each do |i|
+          add "/#{i}", :id => i
+        end
       end
 
-      should 'generate correct condition for partial update with custom column' do
-        filename = "#{sitemaps_dir}/sitemap_test_models"
+      filename = "#{sitemaps_dir}/sitemap"
 
-        create_sitemap(:partial_update => true).clean
-        add_model(:num_items => 50, :primary_column => 'name') #TestModel
+      assert File.exists? "#{filename}.xml" # ids 10 and 20
+      assert File.exists? "#{filename}_30.xml" # ids 30 and 40
+      assert File.exists? "#{filename}_50.xml" # id 50
 
-        File.open("#{filename}_666.xml", 'w')
-        assert_equal "(name >= 666)", @sitemap.send(:prepare_update).first.last[:conditions]
-      end
-    end
+      # Move the files so we can test if they are re-created
+      FileUtils.mv "#{filename}.xml", "#{filename}.bak.xml"
+      FileUtils.mv "#{filename}_30.xml", "#{filename}_30.bak.xml"
 
-    should 'generate for all xml files in directory and delete last file' do
-      TestModel.current_id = last_id = 27
-      filename = "#{sitemaps_dir}/sitemap_test_models"
+      # Store the original file size so we can compare it later
+      original_size = File.size "#{filename}_50.xml"
 
-      create_sitemap(:partial_update => true, :gzip => false, :batch_size => 5, :max_per_sitemap => 5, :max_per_index => 100).clean
-      add_model(:num_items => 50 - last_id) #TestModel
+      start_id = nil
 
-      File.open("#{filename}.xml", 'w')
-      File.open("#{filename}_5.xml", 'w')
-      File.open("#{filename}_9.xml", 'w')
-      File.open("#{filename}_23.xml", 'w')
-      File.open("#{filename}_#{last_id}.xml", 'w')
-      @sitemap.generate
+      # Run a new update starting from the first ID of the last sitemap
+      generate_sitemap(:max_per_sitemap => 2, :partial_update => true, :gzip => false) do
+        start_id = first_id_of_last_sitemap
 
-      # Dir["#{sitemaps_dir}/*"].each do |d| puts d; end
-
-      assert File.exists?("#{filename}_48.xml")
-      assert File.exists?("#{filename}_#{last_id}.xml")
-      elems = elements("#{filename}_#{last_id}.xml", 'loc').map(&:text)
-
-      assert_equal 5, elems.size
-      (28..32).each do |i|
-        assert elems.include? "http://example.com/test_models/#{i}"
+        [50, 60, 70, 80].each do |i|
+          add "/#{i}", :id => i
+        end
       end
 
-      elems = elements(unzipped_sitemaps_index_file, 'loc').map(&:text)
-      assert elems.include? "http://example.com/sitemaps/sitemap_test_models.xml"
-      assert elems.include? "http://example.com/sitemaps/sitemap_test_models_9.xml"
-      assert elems.include? "http://example.com/sitemaps/sitemap_test_models_#{last_id}.xml"
-      assert elems.include? "http://example.com/sitemaps/sitemap_test_models_48.xml"
-    end
-
-    should 'generate sitemap, update should respect old files' do
-      max_id = 23
-      TestModel.current_id = 0
-      filename = "#{sitemaps_dir}/sitemap_test_models"
-
-      create_sitemap(:partial_update => true, :gzip => false, :batch_size => 5, :max_per_sitemap => 5, :max_per_index => 100).clean
-      add_model(:num_items => max_id) #TestModel
-      @sitemap.generate
-
-      # Dir["#{sitemaps_dir}/*"].each do |d| puts d; end
+      # Check the correct ID is returned for the beginning of the last sitemap
+      assert_equal 50, start_id
 
-      assert_equal 5, elements("#{filename}.xml", 'loc').size
-      assert_equal 5, elements("#{filename}_6.xml", 'loc').size
-      assert_equal 3, elements("#{filename}_21.xml", 'loc').size
+      # Since we did a partial update, the earlier files shouldn't have been recreated
+      assert !File.exists?("#{filename}.xml") # ids 10 and 20
+      assert !File.exists?("#{filename}_30.xml") # ids 30 and 40
 
-      TestModel.current_id = 20 #last_id is 21, so start with one below
-      create_sitemap(:partial_update => true, :gzip => false, :batch_size => 5, :max_per_sitemap => 5, :max_per_index => 100)
-      add_model( :num_items => 48 - TestModel.current_id ) #TestModel
-      @sitemap.generate
+      # The last file of the first run should have been recreated with new records
+      # and a larger file size
+      assert (original_size < File.size?("#{filename}_50.xml"))
 
-      assert_equal 5, elements("#{filename}_6.xml", 'loc').size
-      assert_equal 5, elements("#{filename}_21.xml", 'loc').size
+      elems = elements("#{filename}_50.xml", 'loc').map(&:text)
 
-      # Dir["#{sitemaps_dir}/*"].each do |d| puts d; end
+      assert_equal 2, elems.size
 
-      elems = elements("#{filename}_26.xml", 'loc').map(&:text)
-      (26..30).each do |i|
-         assert elems.include? "http://example.com/test_models/#{i}"
+      [50, 60].each do |i|
+        assert elems.include? "http://example.com/#{i}"
       end
 
-      #puts `cat /tmp/sitemaps/sitemap_test_models_41.xml`
-
-      assert_equal 3, elements("#{filename}_46.xml", 'loc').size
-    end
-
-    context 'escape' do
-      should 'add if not number' do
-        create_sitemap
-        data = {
-           42 => 42,
-          '23' => 23,
-          "test" => "'test'",
-          "test10" => "'test10'",
-          "10test" => "'10test'",
-          "10t' est" => "'10t\\' est'",
-        }
-        data.each do |key, value|
-          assert_equal value, @sitemap.send(:escape_if_string, key)
-        end
+      elems = elements(unzipped_sitemaps_index_file, 'loc').map(&:text)
 
-      end
+      assert elems.include? 'http://example.com/sitemap.bak.xml'
+      assert elems.include? 'http://example.com/sitemap_30.bak.xml'
+      assert elems.include? 'http://example.com/sitemap_50.xml'
+      assert elems.include? 'http://example.com/sitemap_70.xml'
     end
 
     context 'lockfile' do
@@ -411,10 +303,10 @@ class BigSitemapTest < Test::Unit::TestCase
         sitemap = BigSitemap.new(:base_url => 'http://example.com', :document_root => tmp_dir)
 
         sitemap.with_lock do
-          assert File.exists?('/tmp/sitemaps/generator.lock')
+          assert File.exists?("#{sitemaps_dir}/generator.lock")
         end
 
-        assert !File.exists?('/tmp/sitemaps/generator.lock')
+        assert !File.exists?("#{sitemaps_dir}/generator.lock")
       end
 
       should 'not catch error not related to lock' do
@@ -425,7 +317,6 @@ class BigSitemapTest < Test::Unit::TestCase
             raise "Wrong"
           end
         end
-
       end
 
       should 'throw error if lock exits' do
@@ -442,53 +333,18 @@ class BigSitemapTest < Test::Unit::TestCase
 
         end
       end
-
     end
   end
 
   private
-    def delete_tmp_files
-      FileUtils.rm_rf(sitemaps_dir)
-    end
-
-    def create_sitemap(options={})
-      @sitemap = BigSitemap.new({
-        :base_url      => 'http://example.com',
-        :document_root => tmp_dir,
-        :ping_google => false
-      }.update(options))
-    end
-
-    def generate_sitemap_files(options={})
-      create_sitemap(options)
-      add_model
-      @sitemap.generate
+    def generate_sitemap(options={}, &block)
+      BigSitemap.generate(options.merge(:base_url => 'http://example.com', :document_root => tmp_dir), &block)
     end
 
-    def generate_one_sitemap_model_file(options={})
-      change_frequency = options.delete(:change_frequency)
-      priority         = options.delete(:priority)
-      create_sitemap(options.merge(:max_per_sitemap => default_num_items, :batch_size => default_num_items))
-      add_model(:change_frequency => change_frequency, :priority => priority)
-      @sitemap.generate
-    end
-
-    def generate_two_model_sitemap_files(options={})
-      change_frequency = options.delete(:change_frequency)
-      priority         = options.delete(:priority)
-      create_sitemap(options.merge(:max_per_sitemap => 2, :batch_size => 1))
-      add_model(:num_items => 4, :change_frequency => change_frequency, :priority => priority)
-      @sitemap.generate
-    end
-
-    def add_model(options={})
-      num_items = options.delete(:num_items) || default_num_items
-      TestModel.stubs(:count_for_sitemap).returns(num_items)
-      @sitemap.add(TestModel, options)
-    end
-
-    def default_num_items
-      10
+    def delete_tmp_files
+      Dir["#{sitemaps_dir}/sitemap*"].each do |f|
+        FileUtils.rm_rf f
+      end
     end
 
     def sitemaps_index_file
@@ -499,28 +355,24 @@ class BigSitemapTest < Test::Unit::TestCase
       "#{sitemaps_dir}/sitemap_index.xml"
     end
 
-    def unzipped_first_sitemaps_model_file
-      "#{sitemaps_dir}/sitemap_test_models.xml"
-    end
-
-    def first_sitemaps_model_file
-      "#{sitemaps_dir}/sitemap_test_models.xml.gz"
+    def unzipped_first_sitemap_file
+      "#{sitemaps_dir}/sitemap.xml"
     end
 
-    def static_sitemaps_file
-      "#{sitemaps_dir}/sitemap_static.xml.gz"
+    def first_sitemap_file
+      "#{sitemaps_dir}/sitemap.xml.gz"
     end
 
-    def second_sitemaps_model_file
-      "#{sitemaps_dir}/sitemap_test_models_1.xml.gz"
+    def second_sitemap_file
+      "#{sitemaps_dir}/sitemap_1.xml.gz"
     end
 
-    def third_sitemaps_model_file
-      "#{sitemaps_dir}/sitemap_test_models_2.xml.gz"
+    def third_sitemap_file
+      "#{sitemaps_dir}/sitemap_2.xml.gz"
     end
 
     def sitemaps_dir
-      "#{tmp_dir}/sitemaps"
+      tmp_dir
     end
 
     def tmp_dir