sitemap_generator 2.2.1 → 3.0.0

data/spec/sitemap_generator/sitemap_namer_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe 'SitemapGenerator::SitemapNamer' do
+
+  it "should generate file names" do
+    namer = SitemapGenerator::SitemapNamer.new(:sitemap)
+    namer.to_s.should == "sitemap1.xml.gz"
+    namer.next.to_s.should == "sitemap2.xml.gz"
+    namer.next.to_s.should == "sitemap3.xml.gz"
+  end
+
+  it "should set the file extension" do
+    namer = SitemapGenerator::SitemapNamer.new(:sitemap, :extension => '.xyz')
+    namer.to_s.should == "sitemap1.xyz"
+    namer.next.to_s.should == "sitemap2.xyz"
+    namer.next.to_s.should == "sitemap3.xyz"
+  end
+
+  it "should set the starting index" do
+    namer = SitemapGenerator::SitemapNamer.new(:sitemap, :start => 10)
+    namer.to_s.should == "sitemap10.xml.gz"
+    namer.next.to_s.should == "sitemap11.xml.gz"
+    namer.next.to_s.should == "sitemap12.xml.gz"
+  end
+
+  it "should accept a string name" do
+    namer = SitemapGenerator::SitemapNamer.new('abc-def')
+    namer.to_s.should == "abc-def1.xml.gz"
+    namer.next.to_s.should == "abc-def2.xml.gz"
+    namer.next.to_s.should == "abc-def3.xml.gz"
+  end
+
+  it "should return previous name" do
+    namer = SitemapGenerator::SitemapNamer.new(:sitemap)
+    namer.to_s.should == "sitemap1.xml.gz"
+    namer.next.to_s.should == "sitemap2.xml.gz"
+    namer.previous.to_s.should == "sitemap1.xml.gz"
+    namer.next.to_s.should == "sitemap2.xml.gz"
+  end
+
+  it "should raise if already at the start" do
+    namer = SitemapGenerator::SitemapNamer.new(:sitemap)
+    namer.to_s.should == "sitemap1.xml.gz"
+    lambda { namer.previous }.should raise_error
+  end
+
+  it "should handle names with underscores" do
+    namer = SitemapGenerator::SitemapNamer.new("sitemap1_")
+    namer.to_s.should == "sitemap1_1.xml.gz"
+  end
+end
+
+describe SitemapGenerator::SitemapIndexNamer do
+  it "should always return the same name" do
+    default = "sitemap_index.xml.gz"
+    namer = SitemapGenerator::SitemapIndexNamer.new(:sitemap_index)
+    namer.to_s.should == default
+    namer.next.to_s.should == default
+    namer.previous.to_s.should == default
+  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

data/spec/sitemap_generator/utilities_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe SitemapGenerator::Utilities do
+
+  describe "assert_valid_keys" do
+    it "should raise error on invalid keys" do
+      lambda {
+        SitemapGenerator::Utilities.assert_valid_keys({ :name => "Rob", :years => "28" }, :name, :age)
+      }.should raise_exception(ArgumentError)
+      lambda {
+        SitemapGenerator::Utilities.assert_valid_keys({ :name => "Rob", :age => "28" }, "name", "age")
+      }.should raise_exception(ArgumentError)
+    end
+
+    it "should not raise error on valid keys" do
+      lambda {
+        SitemapGenerator::Utilities.assert_valid_keys({ :name => "Rob", :age => "28" }, :name, :age)
+      }.should_not raise_exception
+
+      lambda {
+        SitemapGenerator::Utilities.assert_valid_keys({ :name => "Rob" }, :name, :age)
+      }.should_not raise_exception
+    end
+  end
+
+  describe "titleize" do
+    it "should titleize words and replace underscores" do
+      SitemapGenerator::Utilities.titleize('google').should == 'Google'
+      SitemapGenerator::Utilities.titleize('amy_and_jon').should == 'Amy And Jon'
+    end
+  end
+
+  describe "truthy?" do
+    it "should be truthy" do
+      ['1', 1, 't', 'true', true].each do |value|
+        SitemapGenerator::Utilities.truthy?(value).should be_true
+      end
+      SitemapGenerator::Utilities.truthy?(nil).should be_false
+    end
+  end
+
+  describe "falsy?" do
+    it "should be falsy" do
+      ['0', 0, 'f', 'false', false].each do |value|
+        SitemapGenerator::Utilities.falsy?(value).should be_true
+      end
+      SitemapGenerator::Utilities.falsy?(nil).should be_false
+    end
+  end
+end

data/spec/sitemap_generator/video_sitemap_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+describe "SitemapGenerator" do
+  let(:url_options) do
+    {
+      :host => 'http://example.com',
+      :path => 'cool_video.html'
+    }
+  end
+
+  let(:video_options) do
+    {
+      :thumbnail_loc => 'http://example.com/video1_thumbnail.png',
+      :title => 'Cool Video',
+      :content_loc => 'http://example.com/cool_video.mpg',
+      :player_loc => 'http://example.com/cool_video_player.swf',
+      :gallery_loc => 'http://example.com/cool_video_gallery',
+      :gallery_title => 'Gallery Title',
+      :allow_embed => true,
+      :autoplay => 'id=123',
+      :description => 'An new perspective in cool video technology',
+      :tags => %w(tag1 tag2 tag3),
+      :category => 'cat1',
+      :uploader => 'sokrates',
+      :uploader_info => 'http://sokrates.example.com',
+      :expiration_date => Time.at(0),
+      :publication_date => Time.at(0),
+      :family_friendly => true,
+      :view_count => 123,
+      :duration => 456,
+      :rating => 0.499999999
+    }
+  end
+
+  # Return XML for the <URL> element.
+  def video_xml(video_options)
+    SitemapGenerator::Builder::SitemapUrl.new(url_options[:path], {
+      :host => url_options[:host],
+      :video => video_options
+    }).to_xml
+  end
+
+  # Return a Nokogiri document from the XML.  The root of the document is the <URL> element.
+  def video_doc(xml)
+    Nokogiri::XML.parse("<root xmlns:video='http://www.google.com/schemas/sitemap-video/1.1'>#{xml}</root>")
+  end
+
+  # Validate the contents of the video element
+  def validate_video_element(video_doc, video_options)
+    video_doc.at_xpath('video:thumbnail_loc').text.should == video_options[:thumbnail_loc]
+    video_doc.at_xpath("video:thumbnail_loc").text.should == video_options[:thumbnail_loc]
+    video_doc.at_xpath("video:gallery_loc").text.should   == video_options[:gallery_loc]
+    video_doc.at_xpath("video:gallery_loc").attribute('title').text.should == video_options[:gallery_title]
+    video_doc.at_xpath("video:title").text.should         == video_options[:title]
+    video_doc.at_xpath("video:view_count").text.should    == video_options[:view_count].to_s
+    video_doc.at_xpath("video:duration").text.should      == video_options[:duration].to_s
+    video_doc.at_xpath("video:rating").text.should        == ('%0.1f' % video_options[:rating])
+    video_doc.at_xpath("video:content_loc").text.should   == video_options[:content_loc]
+    video_doc.at_xpath("video:category").text.should      == video_options[:category]
+    video_doc.xpath("video:tag").collect(&:text).should   == video_options[:tags]
+    video_doc.at_xpath("video:expiration_date").text.should  == video_options[:expiration_date].iso8601
+    video_doc.at_xpath("video:publication_date").text.should == video_options[:publication_date].iso8601
+    video_doc.at_xpath("video:player_loc").text.should    == video_options[:player_loc]
+    video_doc.at_xpath("video:player_loc").attribute('allow_embed').text.should == (video_options[:allow_embed] ? 'yes' : 'no')
+    video_doc.at_xpath("video:player_loc").attribute('autoplay').text.should    == video_options[:autoplay]
+    video_doc.at_xpath("video:uploader").text.should      == video_options[:uploader]
+    video_doc.at_xpath("video:uploader").attribute("info").text.should == video_options[:uploader_info]
+    xml_fragment_should_validate_against_schema(video_doc, 'http://www.google.com/schemas/sitemap-video/1.1', 'sitemap-video')
+  end
+
+  it "should add a valid video sitemap element" do
+    xml = video_xml(video_options)
+    doc = video_doc(xml)
+    doc.at_xpath("//url/loc").text.should == File.join(url_options[:host], url_options[:path])
+    validate_video_element(doc.at_xpath('//url/video:video'), video_options)
+  end
+
+  it "should support multiple video elements" do
+    xml = video_xml([video_options, video_options])
+    doc = video_doc(xml)
+    doc.at_xpath("//url/loc").text.should == File.join(url_options[:host], url_options[:path])
+    doc.xpath('//url/video:video').count.should == 2
+    doc.xpath('//url/video:video').each do |video|
+      validate_video_element(video, video_options)
+    end
+  end
+
+  it "should default allow_embed to 'yes'" do
+    xml = video_xml(video_options.merge(:allow_embed => nil))
+    doc = video_doc(xml)
+    doc.at_xpath("//url/video:video/video:player_loc").attribute('allow_embed').text.should == 'yes'
+  end
+
+  it "should not include optional elements if they are not passed" do
+    optional = [:player_loc, :content_loc, :category, :tags, :tag, :uploader, :gallery_loc, :family_friendly, :publication_date, :expiration_date, :view_count, :rating, :duration]
+    required_options = video_options.delete_if { |k,v| optional.include?(k) }
+    xml = video_xml(required_options)
+    doc = video_doc(xml)
+    optional.each do |element|
+      doc.at_xpath("//url/video:video/video:#{element}").should be_nil
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+require "bundler/setup"
+Bundler.require
+require 'rspec/autorun'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir[File.expand_path(File.join(File.dirname(__FILE__),'support','**','*.rb'))].each {|f| require f}
+
+SitemapGenerator.verbose = false
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+  config.include(FileMacros)
+  config.include(XmlMacros)
+
+  # Pass :focus option to +describe+ or +it+ to run that spec only
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.filter_run :focus => true
+  config.run_all_when_everything_filtered = true
+end

data/spec/support/file_macros.rb

@@ -0,0 +1,39 @@
+module FileMacros
+  module ExampleMethods
+
+    def files_should_be_identical(first, second)
+      identical_files?(first, second).should be(true)
+    end
+
+    def files_should_not_be_identical(first, second)
+      identical_files?(first, second).should be(false)
+    end
+
+    def file_should_exist(file)
+      File.exists?(file).should be(true), "File #{file} should exist"
+    end
+
+    def directory_should_exist(dir)
+      File.exists?(dir).should be(true), "Directory #{dir} should exist"
+      File.directory?(dir).should be(true), "#{dir} should be a directory"
+    end
+
+    def directory_should_not_exist(dir)
+      File.exists?(dir).should be(false), "Directory #{dir} should not exist"
+    end
+
+    def file_should_not_exist(file)
+      File.exists?(file).should be(false), "File #{file} should not exist"
+    end
+
+    def identical_files?(first, second)
+      file_should_exist(first)
+      file_should_exist(second)
+      open(second, 'r').read.should == open(first, 'r').read
+    end
+  end
+
+  def self.included(receiver)
+    receiver.send :include, ExampleMethods
+  end
+end

data/spec/support/schemas/siteindex.xsd

@@ -0,0 +1,73 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+            targetNamespace="http://www.sitemaps.org/schemas/sitemap/0.9"
+            xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
+            elementFormDefault="qualified">
+<xsd:annotation>
+  <xsd:documentation>
+    XML Schema for Sitemap index files.
+    Last Modifed 2009-04-08
+  </xsd:documentation>
+</xsd:annotation>
+
+<xsd:element name="sitemapindex">
+  <xsd:annotation>
+    <xsd:documentation>
+      Container for a set of up to 50,000 sitemap URLs.
+      This is the root element of the XML file.
+    </xsd:documentation>
+  </xsd:annotation>
+  <xsd:complexType>
+    <xsd:sequence>
+      <xsd:element name="sitemap" type="tSitemap" maxOccurs="unbounded"/>
+    </xsd:sequence>
+  </xsd:complexType>
+</xsd:element>
+
+<xsd:complexType name="tSitemap">
+  <xsd:annotation>
+    <xsd:documentation>
+      Container for the data needed to describe a sitemap.
+    </xsd:documentation>
+  </xsd:annotation>
+  <xsd:all>
+    <xsd:element name="loc" type="tLocSitemap"/>
+    <xsd:element name="lastmod" type="tLastmodSitemap" minOccurs="0"/>
+  </xsd:all>
+</xsd:complexType>
+
+<xsd:simpleType name="tLocSitemap">
+  <xsd:annotation>
+    <xsd:documentation>
+      REQUIRED: The location URI of a sitemap.
+      The URI must conform to RFC 2396 (http://www.ietf.org/rfc/rfc2396.txt).
+    </xsd:documentation>
+  </xsd:annotation>
+  <xsd:restriction base="xsd:anyURI">
+    <xsd:minLength value="12"/>
+    <xsd:maxLength value="2048"/>
+  </xsd:restriction>
+</xsd:simpleType>
+
+<xsd:simpleType name="tLastmodSitemap">
+  <xsd:annotation>
+    <xsd:documentation>
+      OPTIONAL: The date the document was last modified. The date must conform
+      to the W3C DATETIME format (http://www.w3.org/TR/NOTE-datetime).
+      Example: 2005-05-10
+      Lastmod may also contain a timestamp.
+      Example: 2005-05-10T17:33:30+08:00
+    </xsd:documentation>
+  </xsd:annotation>
+  <xsd:union>
+    <xsd:simpleType>
+      <xsd:restriction base="xsd:date"/>
+    </xsd:simpleType>
+    <xsd:simpleType>
+      <xsd:restriction base="xsd:dateTime"/>
+      </xsd:simpleType>
+  </xsd:union>
+</xsd:simpleType>
+
+
+</xsd:schema>