sitemap_generator 5.2.0 → 5.3.0

data/spec/sitemap_generator/builder/sitemap_index_file_spec.rb

@@ -1,124 +0,0 @@
-require 'spec_helper'
-
-describe 'SitemapGenerator::Builder::SitemapIndexFile' do
-  let(:location) { SitemapGenerator::SitemapLocation.new(:filename => 'sitemap.xml.gz', :public_path => '/public/', :host => 'http://example.com/') }
-  let(:index)    { SitemapGenerator::Builder::SitemapIndexFile.new(location) }
-
-  before :each do
-    index.location[:sitemaps_path] = 'test/'
-  end
-
-  it "should return the URL" do
-    index.location.url.should == 'http://example.com/test/sitemap.xml.gz'
-  end
-
-  it "should return the path" do
-    index.location.path.should == '/public/test/sitemap.xml.gz'
-  end
-
-  it "should be empty" do
-    index.empty?.should be_true
-    index.link_count.should == 0
-  end
-
-  it "should not have a last modification data" do
-    index.lastmod.should be_nil
-  end
-
-  it "should not be finalized" do
-    index.finalized?.should be_false
-  end
-
-  it "filename should be set" do
-    index.location.filename.should == 'sitemap.xml.gz'
-  end
-
-  it "should have a default namer" do
-    index = SitemapGenerator::Builder::SitemapIndexFile.new
-    index.location.filename.should == 'sitemap.xml.gz'
-  end
-
-  describe "link_count" do
-    it "should return the link count" do
-      index.instance_variable_set(:@link_count, 10)
-      index.link_count.should == 10
-    end
-  end
-
-  describe "create_index?" do
-    it "should return false" do
-      index.location[:create_index] = false
-      index.create_index?.should be_false
-
-      index.instance_variable_set(:@link_count, 10)
-      index.create_index?.should be_false
-    end
-
-    it "should return true" do
-      index.location[:create_index] = true
-      index.create_index?.should be_true
-
-      index.instance_variable_set(:@link_count, 1)
-      index.create_index?.should be_true
-    end
-
-    it "when :auto, should be true if more than one link" do
-      index.instance_variable_set(:@link_count, 1)
-      index.location[:create_index] = :auto
-      index.create_index?.should be_false
-
-      index.instance_variable_set(:@link_count, 2)
-      index.create_index?.should be_true
-    end
-  end
-
-  describe "add" do
-    it "should use the host provided" do
-      url = SitemapGenerator::Builder::SitemapIndexUrl.new('/one', :host => 'http://newhost.com/')
-      SitemapGenerator::Builder::SitemapIndexUrl.expects(:new).with('/one', :host => 'http://newhost.com').returns(url)
-      index.add '/one', :host => 'http://newhost.com'
-    end
-
-    it "should use the host from the location" do
-      url = SitemapGenerator::Builder::SitemapIndexUrl.new('/one', :host => 'http://example.com/')
-      SitemapGenerator::Builder::SitemapIndexUrl.expects(:new).with('/one', :host => 'http://example.com/').returns(url)
-      index.add '/one'
-    end
-
-    describe "when adding manually" do
-      it "should reserve a name" do
-        index.expects(:reserve_name)
-        index.add '/link'
-      end
-
-      it "should create index" do
-        index.create_index?.should be_false
-        index.add '/one'
-        index.create_index?.should be_true
-      end
-    end
-  end
-
-  describe "index_url" do
-    it "when not creating an index, should be the first sitemap url" do
-      index.instance_variable_set(:@create_index, false)
-      index.instance_variable_set(:@first_sitemap_url, 'http://test.com/index.xml')
-      index.create_index?.should be_false
-      index.index_url.should == 'http://test.com/index.xml'
-    end
-
-    it "if there's no first sitemap url, should default to the index location url" do
-      index.instance_variable_set(:@create_index, false)
-      index.instance_variable_set(:@first_sitemap_url, nil)
-      index.create_index?.should be_false
-      index.index_url.should == index.location.url
-      index.index_url.should == 'http://example.com/test/sitemap.xml.gz'
-    end
-
-    it "when creating an index, should be the index location url" do
-      index.instance_variable_set(:@create_index, true)
-      index.index_url.should == index.location.url
-      index.index_url.should == 'http://example.com/test/sitemap.xml.gz'
-    end
-  end
-end

data/spec/sitemap_generator/builder/sitemap_index_url_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-describe SitemapGenerator::Builder::SitemapIndexUrl do
-  let(:index) {
-    SitemapGenerator::Builder::SitemapIndexFile.new(
-      :sitemaps_path => 'sitemaps/',
-      :host => 'http://test.com',
-      :filename => 'sitemap_index.xml.gz'
-    )
-  }
-  let(:url)  { SitemapGenerator::Builder::SitemapUrl.new(index) }
-
-  it "should return the correct url" do
-    url[:loc].should == 'http://test.com/sitemaps/sitemap_index.xml.gz'
-  end
-
-  it "should use the host from the index" do
-    host = 'http://myexample.com'
-    index.location.expects(:host).returns(host)
-    url[:host].should == host
-  end
-
-  it "should use the public path for the link" do
-    path = '/path'
-    index.location.expects(:path_in_public).returns(path)
-    url[:loc].should == 'http://test.com/path'
-  end
-end

data/spec/sitemap_generator/builder/sitemap_url_spec.rb

@@ -1,192 +0,0 @@
-require 'spec_helper'
-
-describe SitemapGenerator::Builder::SitemapUrl do
-  let(:loc) {
-    SitemapGenerator::SitemapLocation.new(
-      :sitemaps_path => 'sitemaps/',
-      :public_path => '/public',
-      :host => 'http://test.com',
-      :namer => SitemapGenerator::SimpleNamer.new(:sitemap)
-    )}
-  let(:sitemap_file) { SitemapGenerator::Builder::SitemapFile.new(loc) }
-
-  def new_url(*args)
-    if args.empty?
-      args = ['/home', { :host => 'http://example.com' }]
-    end
-    SitemapGenerator::Builder::SitemapUrl.new(*args)
-  end
-
-  it "should build urls for sitemap files" do
-    url = SitemapGenerator::Builder::SitemapUrl.new(sitemap_file)
-    url[:loc].should == 'http://test.com/sitemaps/sitemap.xml.gz'
-  end
-
-  it "lastmod should default to the last modified date for sitemap files" do
-    lastmod = (Time.now - 1209600)
-    sitemap_file.expects(:lastmod).returns(lastmod)
-    url = SitemapGenerator::Builder::SitemapUrl.new(sitemap_file)
-    url[:lastmod].should == lastmod
-  end
-
-  it "should support string option keys" do
-    url = new_url('/home', 'host' => 'http://string.com', 'priority' => 1)
-    url[:priority].should == 1
-    url[:host].should == 'http://string.com'
-  end
-
-  it "should support subdirectory routing" do
-    url = SitemapGenerator::Builder::SitemapUrl.new('/profile', :host => 'http://example.com/subdir/')
-    url[:loc].should == 'http://example.com/subdir/profile'
-    url = SitemapGenerator::Builder::SitemapUrl.new('profile', :host => 'http://example.com/subdir/')
-    url[:loc].should == 'http://example.com/subdir/profile'
-    url = SitemapGenerator::Builder::SitemapUrl.new('/deep/profile/', :host => 'http://example.com/subdir/')
-    url[:loc].should == 'http://example.com/subdir/deep/profile/'
-    url = SitemapGenerator::Builder::SitemapUrl.new('/deep/profile', :host => 'http://example.com/subdir')
-    url[:loc].should == 'http://example.com/subdir/deep/profile'
-    url = SitemapGenerator::Builder::SitemapUrl.new('deep/profile', :host => 'http://example.com/subdir')
-    url[:loc].should == 'http://example.com/subdir/deep/profile'
-    url = SitemapGenerator::Builder::SitemapUrl.new('deep/profile/', :host => 'http://example.com/subdir/')
-    url[:loc].should == 'http://example.com/subdir/deep/profile/'
-    url = SitemapGenerator::Builder::SitemapUrl.new('/', :host => 'http://example.com/subdir/')
-    url[:loc].should == 'http://example.com/subdir/'
-  end
-
-  it "should not fail on a nil path segment" do
-    lambda do
-      SitemapGenerator::Builder::SitemapUrl.new(nil, :host => 'http://example.com')[:loc].should == 'http://example.com'
-    end.should_not raise_error
-  end
-
-  it "should support a :videos option" do
-    loc = SitemapGenerator::Builder::SitemapUrl.new('', :host => 'http://test.com', :videos => [1,2,3])
-    loc[:videos].should == [1,2,3]
-  end
-
-  it "should support a singular :video option" do
-    loc = SitemapGenerator::Builder::SitemapUrl.new('', :host => 'http://test.com', :video => 1)
-    loc[:videos].should == [1]
-  end
-
-  it "should support an array :video option" do
-    loc = SitemapGenerator::Builder::SitemapUrl.new('', :host => 'http://test.com', :video => [1,2], :videos => [3,4])
-    loc[:videos].should == [3,4,1,2]
-  end
-
-  it "should support a :alternates option" do
-    loc = SitemapGenerator::Builder::SitemapUrl.new('', :host => 'http://test.com', :alternates => [1,2,3])
-    loc[:alternates].should == [1,2,3]
-  end
-
-  it "should support a singular :alternate option" do
-    loc = SitemapGenerator::Builder::SitemapUrl.new('', :host => 'http://test.com', :alternate => 1)
-    loc[:alternates].should == [1]
-  end
-
-  it "should support an array :alternate option" do
-    loc = SitemapGenerator::Builder::SitemapUrl.new('', :host => 'http://test.com', :alternate => [1,2], :alternates => [3,4])
-    loc[:alternates].should == [3,4,1,2]
-  end
-
-  it "should not fail if invalid characters are used in the URL" do
-    special = ':$&+,;:=?@'
-    url = SitemapGenerator::Builder::SitemapUrl.new("/#{special}", :host => "http://example.com/#{special}/")
-    url[:loc].should == "http://example.com/#{special}/#{special}"
-  end
-
-  describe "w3c_date" do
-    it "should convert dates and times to W3C format" do
-      url = new_url
-      url.send(:w3c_date, Date.new(0)).should == '0000-01-01'
-      url.send(:w3c_date, Time.at(0).utc).should == '1970-01-01T00:00:00+00:00'
-      url.send(:w3c_date, DateTime.new(0)).should == '0000-01-01T00:00:00+00:00'
-    end
-
-    it "should return strings unmodified" do
-      new_url.send(:w3c_date, '2010-01-01').should == '2010-01-01'
-    end
-
-    it "should try to convert to utc" do
-      time = Time.at(0)
-      time.expects(:respond_to?).times(2).returns(false, true) # iso8601, utc
-      new_url.send(:w3c_date, time).should == '1970-01-01T00:00:00+00:00'
-    end
-
-    it "should include timezone for objects which do not respond to iso8601 or utc" do
-      time = Time.at(0)
-      time.expects(:respond_to?).times(2).returns(false, false) # iso8601, utc
-      time.expects(:strftime).times(2).returns('+0800', '1970-01-01T00:00:00')
-      new_url.send(:w3c_date, time).should == '1970-01-01T00:00:00+08:00'
-    end
-
-    it "should support integers" do
-      new_url.send(:w3c_date, Time.at(0).to_i).should == '1970-01-01T00:00:00+00:00'
-    end
-  end
-
-  describe "yes_or_no" do
-    it "should recognize truthy values" do
-      new_url.send(:yes_or_no, 1).should == 'yes'
-      new_url.send(:yes_or_no, 0).should == 'yes'
-      new_url.send(:yes_or_no, 'yes').should == 'yes'
-      new_url.send(:yes_or_no, 'Yes').should == 'yes'
-      new_url.send(:yes_or_no, 'YES').should == 'yes'
-      new_url.send(:yes_or_no, true).should == 'yes'
-      new_url.send(:yes_or_no, Object.new).should == 'yes'
-    end
-
-    it "should recognize falsy values" do
-      new_url.send(:yes_or_no, nil).should   == 'no'
-      new_url.send(:yes_or_no, 'no').should  == 'no'
-      new_url.send(:yes_or_no, 'No').should  == 'no'
-      new_url.send(:yes_or_no, 'NO').should  == 'no'
-      new_url.send(:yes_or_no, false).should == 'no'
-    end
-
-    it "should raise on unrecognized strings" do
-      lambda { new_url.send(:yes_or_no, 'dunno')  }.should raise_error(ArgumentError)
-      lambda { new_url.send(:yes_or_no, 'yessir') }.should raise_error(ArgumentError)
-    end
-  end
-
-  describe "yes_or_no_with_default" do
-    it "should use the default if the value is nil" do
-      url = new_url
-      url.expects(:yes_or_no).with(true).returns('surely')
-      url.send(:yes_or_no_with_default, nil, true).should == 'surely'
-    end
-
-    it "should use the value if it is not nil" do
-      url = new_url
-      url.expects(:yes_or_no).with('surely').returns('absolutely')
-      url.send(:yes_or_no_with_default, 'surely', true).should == 'absolutely'
-    end
-  end
-
-  describe "format_float" do
-    it "should not modify if a string" do
-      new_url.send(:format_float, '0.4').should == '0.4'
-    end
-
-    it "should round to one decimal place" do
-      url = new_url
-      url.send(:format_float, 0.499999).should == '0.5'
-      url.send(:format_float, 3.444444).should == '3.4'
-    end
-  end
-
-  describe "expires" do
-    let(:url)  { SitemapGenerator::Builder::SitemapUrl.new('/path', :host => 'http://example.com', :expires => time) }
-    let(:time) { Time.at(0).utc }
-
-    it "should include the option" do
-      url[:expires].should == time
-    end
-
-    it "should format it and include it in the XML" do
-      xml = url.to_xml
-      doc = Nokogiri::XML("<root xmlns='http://www.sitemaps.org/schemas/sitemap/0.9' xmlns:xhtml='http://www.w3.org/1999/xhtml'>#{xml}</root>")
-      doc.css('url expires').text.should == url.send(:w3c_date, time)
-    end
-  end
-end

data/spec/sitemap_generator/core_ext/bigdecimal_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-require 'bigdecimal'
-
-describe SitemapGenerator::BigDecimal do
-  describe "to_yaml" do
-    it "should serialize correctly" do
-      SitemapGenerator::BigDecimal.new('100000.30020320320000000000000000000000000000001').to_yaml.should =~ /^--- 100000\.30020320320000000000000000000000000000001\n/
-      SitemapGenerator::BigDecimal.new('Infinity').to_yaml.should =~ /^--- \.Inf\n/
-      SitemapGenerator::BigDecimal.new('NaN').to_yaml.should =~ /^--- \.NaN\n/
-      SitemapGenerator::BigDecimal.new('-Infinity').to_yaml.should =~ /^--- -\.Inf\n/
-    end
-  end
-
-  describe "to_d" do
-    it "should convert correctly" do
-      bd = SitemapGenerator::BigDecimal.new '10'
-      bd.to_d.should == bd
-    end
-  end
-end

data/spec/sitemap_generator/core_ext/numeric_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-
-describe SitemapGenerator::Numeric do
-  def numeric(size)
-    SitemapGenerator::Numeric.new(size)
-  end
-
-  describe "bytes" do
-    it "should define equality of different units" do
-      relationships = {
-        numeric(  1024).bytes     => numeric(  1).kilobyte,
-        numeric(  1024).kilobytes => numeric(  1).megabyte,
-        numeric(3584.0).kilobytes => numeric(3.5).megabytes,
-        numeric(3584.0).megabytes => numeric(3.5).gigabytes,
-        numeric(1).kilobyte ** 4  => numeric(  1).terabyte,
-        numeric(1024).kilobytes + numeric(2).megabytes =>   numeric(3).megabytes,
-        numeric(             2).gigabytes / 4 => numeric(512).megabytes,
-        numeric(256).megabytes * 20 +numeric( 5).gigabytes => numeric(10).gigabytes,
-        numeric(1).kilobyte ** 5 => numeric(1).petabyte,
-        numeric(1).kilobyte ** 6 => numeric(1).exabyte
-      }
-
-      relationships.each do |left, right|
-        left.should == right
-      end
-    end
-
-    it "should represent units as bytes" do
-      numeric(3).megabytes.should == 3145728
-      numeric(3).megabyte .should == 3145728
-      numeric(3).kilobytes.should == 3072
-      numeric(3).kilobyte .should == 3072
-      numeric(3).gigabytes.should == 3221225472
-      numeric(3).gigabyte .should == 3221225472
-      numeric(3).terabytes.should == 3298534883328
-      numeric(3).terabyte .should == 3298534883328
-      numeric(3).petabytes.should == 3377699720527872
-      numeric(3).petabyte .should == 3377699720527872
-      numeric(3).exabytes .should == 3458764513820540928
-      numeric(3).exabyte  .should == 3458764513820540928
-    end
-  end
-end

data/spec/sitemap_generator/file_adaptor_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-describe "SitemapGenerator::FileAdapter" do
-  let(:location) { SitemapGenerator::SitemapLocation.new }
-  let(:adapter)  { SitemapGenerator::FileAdapter.new }
-
-  describe "write" do
-    it "should gzip contents if filename ends in .gz" do
-      adapter.expects(:gzip).once
-      location.stubs(:filename).returns('sitemap.xml.gz')
-      adapter.write(location, 'data')
-    end
-
-    it "should not gzip contents if filename does not end in .gz" do
-      adapter.expects(:plain).once
-      location.stubs(:filename).returns('sitemap.xml')
-      adapter.write(location, 'data')
-    end
-  end
-end

data/spec/sitemap_generator/geo_sitemap_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-
-describe "SitemapGenerator" do
-
-  it "should add the geo sitemap element" do
-    loc = 'http://www.example.com/geo_page.kml'
-    format = 'kml'
-
-    geo_xml_fragment = SitemapGenerator::Builder::SitemapUrl.new('geo_page.kml',
-      :host => 'http://www.example.com',
-      :geo => {
-        :format => format
-      }
-    ).to_xml
-
-    # Check that the options were parsed correctly
-    doc = Nokogiri::XML.parse("<root xmlns:geo='#{SitemapGenerator::SCHEMAS['geo']}'>#{geo_xml_fragment}</root>")
-    url = doc.at_xpath("//url")
-    url.should_not be_nil
-    url.at_xpath("loc").text.should == loc
-
-    geo = url.at_xpath("geo:geo")
-    geo.should_not be_nil
-    geo.at_xpath("geo:format").text.should == format
-
-    # Google's documentation and published schema don't match some valid elements may
-    # not validate.
-    xml_fragment_should_validate_against_schema(geo, 'sitemap-geo', 'xmlns:geo' => SitemapGenerator::SCHEMAS['geo'])
-  end
-end