sitemap_generator_ftbpro 5.0.4

data/spec/sitemap_generator/sitemap_groups_spec.rb

@@ -0,0 +1,144 @@
+require "spec_helper"
+
+def with_max_links(num)
+  SitemapGenerator::Utilities.with_warnings(nil) do
+    original = SitemapGenerator::MAX_SITEMAP_LINKS
+    SitemapGenerator.const_set(:MAX_SITEMAP_LINKS, num)
+    yield
+    SitemapGenerator.const_set(:MAX_SITEMAP_LINKS, original)
+  end
+end
+
+describe "Sitemap Groups" do
+  let(:linkset) { ::SitemapGenerator::LinkSet.new(:default_host => 'http://test.com') }
+
+  before :each do
+    FileUtils.rm_rf(SitemapGenerator.app.root + 'public/')
+  end
+
+  it "should not finalize the default sitemap if using groups" do
+    linkset.create do
+      group(:filename => :sitemap_en) do
+        add '/en'
+      end
+    end
+    file_should_exist(SitemapGenerator.app.root + 'public/sitemap.xml.gz')
+    file_should_exist(SitemapGenerator.app.root + 'public/sitemap_en.xml.gz')
+    file_should_not_exist(SitemapGenerator.app.root + 'public/sitemap1.xml.gz')
+  end
+
+  it "should not write out empty groups" do
+    linkset.create do
+      group(:filename => :sitemap_en) { }
+    end
+    file_should_not_exist(SitemapGenerator.app.root + 'public/sitemap_en.xml.gz')
+  end
+
+  it "should add default links if no groups are created" do
+    linkset.create do
+    end
+    linkset.link_count.should == 1
+    file_should_exist(SitemapGenerator.app.root + 'public/sitemap.xml.gz')
+    file_should_not_exist(SitemapGenerator.app.root + 'public/sitemap1.xml.gz')
+  end
+
+  it "should add links to the default sitemap" do
+    linkset.create do
+      add '/before'
+      group(:filename => :sitemap_en) do
+        add '/link'
+      end
+      add '/after'
+    end
+    linkset.link_count.should == 4
+    file_should_exist(SitemapGenerator.app.root + 'public/sitemap.xml.gz')
+    file_should_exist(SitemapGenerator.app.root + 'public/sitemap1.xml.gz')
+    file_should_exist(SitemapGenerator.app.root + 'public/sitemap_en.xml.gz')
+  end
+
+  it "should rollover when sitemaps are full" do
+    with_max_links(1) {
+      linkset.include_index = false
+      linkset.include_root = false
+      linkset.create do
+        add '/before'
+        group(:filename => :sitemap_en, :sitemaps_path => 'en/') do
+          add '/one'
+          add '/two'
+        end
+        add '/after'
+      end
+    }
+    linkset.link_count.should == 4
+    file_should_exist(SitemapGenerator.app.root + 'public/sitemap.xml.gz')
+    file_should_exist(SitemapGenerator.app.root + 'public/sitemap1.xml.gz')
+    file_should_exist(SitemapGenerator.app.root + 'public/sitemap2.xml.gz')
+    file_should_not_exist(SitemapGenerator.app.root + 'public/sitemap3.xml.gz')
+    file_should_exist(SitemapGenerator.app.root + 'public/en/sitemap_en.xml.gz')
+    file_should_exist(SitemapGenerator.app.root + 'public/en/sitemap_en1.xml.gz')
+    file_should_not_exist(SitemapGenerator.app.root + 'public/en/sitemap_en2.xml.gz')
+  end
+
+  it "should support multiple groups" do
+    linkset.create do
+      group(:filename => :sitemap_en, :sitemaps_path => 'en/') do
+        add '/one'
+      end
+      group(:filename => :sitemap_fr, :sitemaps_path => 'fr/') do
+        add '/one'
+      end
+    end
+    linkset.link_count.should == 2
+    file_should_exist(SitemapGenerator.app.root + 'public/sitemap.xml.gz')
+    file_should_exist(SitemapGenerator.app.root + 'public/en/sitemap_en.xml.gz')
+    file_should_exist(SitemapGenerator.app.root + 'public/fr/sitemap_fr.xml.gz')
+  end
+
+  it "the sitemap shouldn't be finalized until the end if the groups don't conflict" do
+    linkset.create do
+      add 'one'
+      group(:filename => :first) { add '/two' }
+      add 'three'
+      group(:filename => :second) { add '/four' }
+      add 'five'
+    end
+    linkset.link_count.should == 6
+    file_should_exist(SitemapGenerator.app.root + 'public/sitemap.xml.gz')
+    file_should_exist(SitemapGenerator.app.root + 'public/sitemap1.xml.gz')
+    file_should_exist(SitemapGenerator.app.root + 'public/first.xml.gz')
+    file_should_exist(SitemapGenerator.app.root + 'public/second.xml.gz')
+    gzipped_xml_file_should_validate_against_schema(SitemapGenerator.app.root + 'public/sitemap.xml.gz', 'siteindex')
+    gzipped_xml_file_should_validate_against_schema(SitemapGenerator.app.root + 'public/sitemap1.xml.gz', 'sitemap')
+  end
+
+  it "groups should share the sitemap if the sitemap location is unchanged" do
+    linkset.create do
+      add 'one'
+      group(:default_host => 'http://newhost.com') { add '/two' }
+      add 'three'
+      group(:default_host => 'http://betterhost.com') { add '/four' }
+      add 'five'
+    end
+    linkset.link_count.should == 6
+    file_should_exist(SitemapGenerator.app.root + 'public/sitemap.xml.gz')
+    file_should_not_exist(SitemapGenerator.app.root + 'public/sitemap1.xml.gz')
+    gzipped_xml_file_should_validate_against_schema(SitemapGenerator.app.root + 'public/sitemap.xml.gz', 'sitemap')
+  end
+
+  it "sitemaps should be finalized if virtual location settings are changed" do
+    linkset.create do
+      add 'one'
+      group(:sitemaps_path => :en) { add '/two' }
+      add 'three'
+      group(:sitemaps_host => 'http://newhost.com') { add '/four' }
+      add 'five'
+    end
+    linkset.link_count.should == 6
+    file_should_exist(SitemapGenerator.app.root + 'public/sitemap.xml.gz')
+    file_should_exist(SitemapGenerator.app.root + 'public/sitemap1.xml.gz')
+    file_should_exist(SitemapGenerator.app.root + 'public/sitemap2.xml.gz')
+    file_should_exist(SitemapGenerator.app.root + 'public/sitemap3.xml.gz')
+    file_should_not_exist(SitemapGenerator.app.root + 'public/sitemap4.xml.gz')
+    file_should_exist(SitemapGenerator.app.root + 'public/en/sitemap.xml.gz')
+  end
+end

data/spec/sitemap_generator/sitemap_location_spec.rb

@@ -0,0 +1,210 @@
+require 'spec_helper'
+
+describe SitemapGenerator::SitemapLocation do
+  let(:default_host) { 'http://example.com' }
+  let(:location)     { SitemapGenerator::SitemapLocation.new }
+
+  it "public_path should default to the public directory in the application root" do
+    location.public_path.should == SitemapGenerator.app.root + 'public/'
+  end
+
+  it "should have a default namer" do
+    location[:namer].should_not be_nil
+    location[:filename].should be_nil
+    location.filename.should == 'sitemap1.xml.gz'
+  end
+
+  it "should require a filename" do
+    location[:filename] = nil
+    lambda {
+      location.filename.should be_nil
+    }.should raise_error
+  end
+
+  it "should require a namer" do
+    location[:namer] = nil
+    lambda {
+      location.filename.should be_nil
+    }.should raise_error
+  end
+
+  it "should require a host" do
+    location = SitemapGenerator::SitemapLocation.new(:filename => nil, :namer => nil)
+    lambda {
+      location.host.should be_nil
+    }.should raise_error
+  end
+
+  it "should accept a Namer option" do
+    @namer = SitemapGenerator::SimpleNamer.new(:xxx)
+    location = SitemapGenerator::SitemapLocation.new(:namer => @namer)
+    location.filename.should == @namer.to_s
+  end
+
+  it "should protect the filename from further changes in the Namer" do
+    @namer = SitemapGenerator::SimpleNamer.new(:xxx)
+    location = SitemapGenerator::SitemapLocation.new(:namer => @namer)
+    location.filename.should == @namer.to_s
+    @namer.next
+    location.filename.should == @namer.previous.to_s
+  end
+
+  it "should allow changing the namer" do
+    @namer1 = SitemapGenerator::SimpleNamer.new(:xxx)
+    location = SitemapGenerator::SitemapLocation.new(:namer => @namer1)
+    location.filename.should == @namer1.to_s
+    @namer2 = SitemapGenerator::SimpleNamer.new(:yyy)
+    location[:namer] = @namer2
+    location.filename.should == @namer2.to_s
+  end
+
+  describe "testing options and #with" do
+
+    # Array of tuples with instance options and expected method return values
+    tests = [
+      [{
+        :sitemaps_path => nil,
+        :public_path => '/public',
+        :filename => 'sitemap.xml.gz',
+        :host => 'http://test.com' },
+      { :url => 'http://test.com/sitemap.xml.gz',
+        :directory => '/public',
+        :path => '/public/sitemap.xml.gz',
+        :path_in_public => 'sitemap.xml.gz'
+      }],
+      [{
+        :sitemaps_path => 'sitemaps/en/',
+        :public_path => '/public/system/',
+        :filename => 'sitemap.xml.gz',
+        :host => 'http://test.com/plus/extra/' },
+      { :url => 'http://test.com/plus/extra/sitemaps/en/sitemap.xml.gz',
+        :directory => '/public/system/sitemaps/en',
+        :path => '/public/system/sitemaps/en/sitemap.xml.gz',
+        :path_in_public => 'sitemaps/en/sitemap.xml.gz'
+      }]
+    ]
+    tests.each do |opts, returns|
+      returns.each do |method, value|
+        it "#{method} should return #{value}" do
+          location.with(opts).send(method).should == value
+        end
+      end
+    end
+  end
+
+  describe "when duplicated" do
+    it "should not inherit some objects" do
+      location = SitemapGenerator::SitemapLocation.new(:filename => 'xxx', :host => default_host, :public_path => 'public/')
+      location.url.should == default_host+'/xxx'
+      location.public_path.to_s.should == 'public/'
+      dup = location.dup
+      dup.url.should == location.url
+      dup.url.should_not be(location.url)
+      dup.public_path.to_s.should == location.public_path.to_s
+      dup.public_path.should_not be(location.public_path)
+    end
+  end
+
+  describe "filesize" do
+    it "should read the size of the file at path" do
+      location.expects(:path).returns('/somepath')
+      File.expects(:size?).with('/somepath')
+      location.filesize
+    end
+  end
+
+  describe "public_path" do
+    it "should append a trailing slash" do
+      location = SitemapGenerator::SitemapLocation.new(:public_path => 'public/google')
+      location.public_path.to_s.should == 'public/google/'
+      location[:public_path] = 'new/path'
+      location.public_path.to_s.should == 'new/path/'
+      location[:public_path] = 'already/slashed/'
+      location.public_path.to_s.should == 'already/slashed/'
+    end
+  end
+
+  describe "sitemaps_path" do
+    it "should append a trailing slash" do
+      location = SitemapGenerator::SitemapLocation.new(:sitemaps_path => 'public/google')
+      location.sitemaps_path.to_s.should == 'public/google/'
+      location[:sitemaps_path] = 'new/path'
+      location.sitemaps_path.to_s.should == 'new/path/'
+      location[:sitemaps_path] = 'already/slashed/'
+      location.sitemaps_path.to_s.should == 'already/slashed/'
+    end
+  end
+
+  describe "url" do
+    it "should handle paths not ending in slash" do
+      location = SitemapGenerator::SitemapLocation.new(
+          :public_path => 'public/google', :filename => 'xxx',
+          :host => default_host, :sitemaps_path => 'sub/dir')
+      location.url.should == default_host + '/sub/dir/xxx'
+    end
+  end
+
+  describe "write" do
+    it "should output summary line when verbose" do
+      location = SitemapGenerator::SitemapLocation.new(:public_path => 'public/', :verbose => true)
+      location.adapter.stubs(:write)
+      location.expects(:summary)
+      location.write('data', 1)
+    end
+
+    it "should not output summary line when not verbose" do
+      location = SitemapGenerator::SitemapLocation.new(:public_path => 'public/', :verbose => false)
+      location.adapter.stubs(:write)
+      location.expects(:summary).never
+      location.write('data', 1)
+    end
+  end
+
+  describe "filename" do
+    it "should strip gz extension if not compressing" do
+      location = SitemapGenerator::SitemapLocation.new(:namer => SitemapGenerator::SimpleNamer.new(:sitemap), :compress => false)
+      location.filename.should == 'sitemap.xml'
+    end
+
+    it "should not strip gz extension if compressing" do
+      location = SitemapGenerator::SitemapLocation.new(:namer => SitemapGenerator::SimpleNamer.new(:sitemap), :compress => true)
+      location.filename.should == 'sitemap.xml.gz'
+    end
+
+    it "should strip gz extension if :all_but_first and first file" do
+      namer = SitemapGenerator::SimpleNamer.new(:sitemap)
+      namer.stubs(:start?).returns(true)
+      location = SitemapGenerator::SitemapLocation.new(:namer => namer, :compress => :all_but_first)
+      location.filename.should == 'sitemap.xml'
+    end
+
+    it "should strip gz extension if :all_but_first and first file" do
+      namer = SitemapGenerator::SimpleNamer.new(:sitemap)
+      namer.stubs(:start?).returns(false)
+      location = SitemapGenerator::SitemapLocation.new(:namer => namer, :compress => :all_but_first)
+      location.filename.should == 'sitemap.xml.gz'
+    end
+  end
+
+  describe "when not compressing" do
+    it "the URL should point to the uncompressed file" do
+      location = SitemapGenerator::SitemapLocation.new(
+        :namer => SitemapGenerator::SimpleNamer.new(:sitemap),
+        :host => 'http://example.com',
+        :compress => false
+      )
+      location.url.should == 'http://example.com/sitemap.xml'
+    end
+  end
+end
+
+describe SitemapGenerator::SitemapIndexLocation do
+  let(:location)     { SitemapGenerator::SitemapIndexLocation.new }
+
+  it "should have a default namer" do
+    location = SitemapGenerator::SitemapIndexLocation.new
+    location[:namer].should_not be_nil
+    location[:filename].should be_nil
+    location.filename.should == 'sitemap.xml.gz'
+  end
+end

data/spec/sitemap_generator/sitemap_namer_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+describe SitemapGenerator::SimpleNamer do
+  it "should generate file names" do
+    namer = SitemapGenerator::SimpleNamer.new(:sitemap)
+    namer.to_s.should == "sitemap.xml.gz"
+    namer.next.to_s.should == "sitemap1.xml.gz"
+    namer.next.to_s.should == "sitemap2.xml.gz"
+  end
+
+  it "should set the file extension" do
+    namer = SitemapGenerator::SimpleNamer.new(:sitemap, :extension => '.xyz')
+    namer.to_s.should == "sitemap.xyz"
+    namer.next.to_s.should == "sitemap1.xyz"
+    namer.next.to_s.should == "sitemap2.xyz"
+  end
+
+  it "should set the starting index" do
+    namer = SitemapGenerator::SimpleNamer.new(:sitemap, :start => 10)
+    namer.to_s.should == "sitemap.xml.gz"
+    namer.next.to_s.should == "sitemap10.xml.gz"
+    namer.next.to_s.should == "sitemap11.xml.gz"
+  end
+
+  it "should accept a string name" do
+    namer = SitemapGenerator::SimpleNamer.new('abc-def')
+    namer.to_s.should == "abc-def.xml.gz"
+    namer.next.to_s.should == "abc-def1.xml.gz"
+    namer.next.to_s.should == "abc-def2.xml.gz"
+  end
+
+  it "should return previous name" do
+    namer = SitemapGenerator::SimpleNamer.new(:sitemap)
+    namer.to_s.should == "sitemap.xml.gz"
+    namer.next.to_s.should == "sitemap1.xml.gz"
+    namer.previous.to_s.should == "sitemap.xml.gz"
+    namer.next.next.to_s.should == "sitemap2.xml.gz"
+    namer.previous.to_s.should == "sitemap1.xml.gz"
+    namer.next.next.to_s.should == "sitemap3.xml.gz"
+    namer.previous.to_s.should == "sitemap2.xml.gz"
+  end
+
+  it "should raise if already at the start" do
+    namer = SitemapGenerator::SimpleNamer.new(:sitemap)
+    namer.to_s.should == "sitemap.xml.gz"
+    lambda { namer.previous }.should raise_error
+  end
+
+  it "should handle names with underscores" do
+    namer = SitemapGenerator::SimpleNamer.new("sitemap1_")
+    namer.to_s.should == "sitemap1_.xml.gz"
+    namer.next.to_s.should == "sitemap1_1.xml.gz"
+  end
+
+  it "should reset the namer" do
+    namer = SitemapGenerator::SimpleNamer.new(:sitemap)
+    namer.to_s.should == "sitemap.xml.gz"
+    namer.next.to_s.should == "sitemap1.xml.gz"
+    namer.reset
+    namer.to_s.should == "sitemap.xml.gz"
+    namer.next.to_s.should == "sitemap1.xml.gz"
+  end
+
+  describe "should handle the zero option" do
+    it "as a string" do
+      namer = SitemapGenerator::SimpleNamer.new(:sitemap, :zero => "string")
+      namer.to_s.should == "sitemapstring.xml.gz"
+      namer.next.to_s.should == "sitemap1.xml.gz"
+    end
+
+    it "as an integer" do
+      namer = SitemapGenerator::SimpleNamer.new(:sitemap, :zero => 0)
+      namer.to_s.should == "sitemap0.xml.gz"
+      namer.next.to_s.should == "sitemap1.xml.gz"
+    end
+
+    it "as a string" do
+      namer = SitemapGenerator::SimpleNamer.new(:sitemap, :zero => "_index")
+      namer.to_s.should == "sitemap_index.xml.gz"
+      namer.next.to_s.should == "sitemap1.xml.gz"
+    end
+
+    it "as a symbol" do
+      namer = SitemapGenerator::SimpleNamer.new(:sitemap, :zero => :index)
+      namer.to_s.should == "sitemapindex.xml.gz"
+      namer.next.to_s.should == "sitemap1.xml.gz"
+    end
+
+    it "with a starting index" do
+      namer = SitemapGenerator::SimpleNamer.new(:sitemap, :zero => 'abc', :start => 10)
+      namer.to_s.should == "sitemapabc.xml.gz"
+      namer.next.to_s.should == "sitemap10.xml.gz"
+      namer.next.to_s.should == "sitemap11.xml.gz"
+    end
+  end
+end

data/spec/sitemap_generator/templates_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe "Templates class" do
+
+  it "should provide method access to each template" do
+    SitemapGenerator::Templates::FILES.each do |name, file|
+      SitemapGenerator.templates.send(name).should_not be(nil)
+      SitemapGenerator.templates.send(name).should == File.read(File.join(SitemapGenerator.root, 'templates', file))
+    end
+  end
+
+  describe "templates" do
+    before :each do
+      SitemapGenerator.templates.sitemap_sample = nil
+      File.expects(:read).returns('read file')
+    end
+
+    it "should only be read once" do
+      File.expects(:read).once
+      SitemapGenerator.templates.sitemap_sample
+      SitemapGenerator.templates.sitemap_sample
+    end
+  end
+end

data/spec/sitemap_generator/utilities/existence_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+class EmptyTrue
+  def empty?() true; end
+end
+
+class EmptyFalse
+  def empty?() false; end
+end
+
+BLANK = [ EmptyTrue.new, nil, false, '', '   ', "  \n\t  \r ", [], {} ]
+NOT   = [ EmptyFalse.new, Object.new, true, 0, 1, 'a', [nil], { nil => 0 } ]
+
+describe Object do
+  let(:utils) { SitemapGenerator::Utilities }
+
+  it "should define blankness" do
+    BLANK.each { |v| utils.blank?(v).should be_true }
+    NOT.each   { |v| utils.blank?(v).should be_false }
+  end
+
+  it "should define presence" do
+    BLANK.each { |v| utils.present?(v).should be_false }
+    NOT.each   { |v| utils.present?(v).should be_true }
+  end
+end

data/spec/sitemap_generator/utilities/hash_spec.rb

@@ -0,0 +1,57 @@
+require "spec_helper"
+
+describe SitemapGenerator::Utilities do
+  let(:utils) { SitemapGenerator::Utilities }
+
+  describe "assert_valid_keys" do
+    it "should raise" do
+      lambda do
+        utils.assert_valid_keys({ :failore => "stuff", :funny => "business" }, [ :failure, :funny])
+        utils.assert_valid_keys({ :failore => "stuff", :funny => "business" }, :failure, :funny)
+      end.should raise_error(ArgumentError, "Unknown key(s): failore")
+    end
+
+    it "should not raise" do
+      lambda do
+        utils.assert_valid_keys({ :failure => "stuff", :funny => "business" }, [ :failure, :funny ])
+        utils.assert_valid_keys({ :failure => "stuff", :funny => "business" }, :failure, :funny)
+      end.should_not raise_error
+    end
+  end
+
+  describe "keys" do
+    before :each do
+      @strings = { 'a' => 1, 'b' => 2 }
+      @symbols = { :a  => 1, :b  => 2 }
+      @mixed   = { :a  => 1, 'b' => 2 }
+      @fixnums = {  0  => 1,  1  => 2 }
+      if RUBY_VERSION < '1.9.0'
+        @illegal_symbols = { "\0" => 1, "" => 2, [] => 3 }
+      else
+        @illegal_symbols = { [] => 3 }
+      end
+    end
+
+    it "should symbolize_keys" do
+      utils.symbolize_keys(@symbols).should == @symbols
+      utils.symbolize_keys(@strings).should == @symbols
+      utils.symbolize_keys(@mixed).should == @symbols
+    end
+
+    it "should symbolize_keys!" do
+      utils.symbolize_keys!(@symbols.dup).should == @symbols
+      utils.symbolize_keys!(@strings.dup).should == @symbols
+      utils.symbolize_keys!(@mixed.dup).should == @symbols
+    end
+
+    it "should symbolize_keys_preserves_keys_that_cant_be_symbolized" do
+      utils.symbolize_keys(@illegal_symbols).should == @illegal_symbols
+      utils.symbolize_keys!(@illegal_symbols.dup).should == @illegal_symbols
+    end
+
+    it "should symbolize_keys_preserves_fixnum_keys" do
+      utils.symbolize_keys(@fixnums).should == @fixnums
+      utils.symbolize_keys!(@fixnums.dup).should == @fixnums
+    end
+  end
+end

data/spec/sitemap_generator/utilities/rounding_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe SitemapGenerator::Utilities do
+  describe "rounding" do
+    let(:utils) { SitemapGenerator::Utilities }
+
+    it "should round for positive number" do
+      utils.round(1.4)      .should == 1
+      utils.round(1.6)     .should == 2
+      utils.round(1.6, 0)  .should == 2
+      utils.round(1.4, 1)  .should == 1.4
+      utils.round(1.4, 3)  .should == 1.4
+      utils.round(1.45, 1) .should == 1.5
+      utils.round(1.445, 2).should == 1.45
+      # Demonstrates a bug in the round method
+      # utils.round(9.995, 2).should == 10 
+    end
+
+    it "should round for negative number" do
+      utils.round(-1.4)    .should == -1
+      utils.round(-1.6)    .should == -2
+      utils.round(-1.4, 1) .should == -1.4
+      utils.round(-1.45, 1).should == -1.5
+    end
+
+    it "should round with negative precision" do
+      utils.round(123456.0, -1).should == 123460.0
+      utils.round(123456.0, -2).should == 123500.0
+    end
+  end
+end