sitemap_generator_ftbpro 5.0.4

data/spec/sitemap_generator/core_ext/bigdecimal_spec.rb

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,30 @@
+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

data/spec/sitemap_generator/helpers/number_helper_spec.rb

@@ -0,0 +1,196 @@
+require 'spec_helper'
+require 'sitemap_generator/helpers/number_helper'
+
+def kilobytes(number)
+  number * 1024
+end
+
+def megabytes(number)
+  kilobytes(number) * 1024
+end
+
+def gigabytes(number)
+  megabytes(number) * 1024
+end
+
+def terabytes(number)
+  gigabytes(number) * 1024
+end
+
+describe SitemapGenerator::Helpers::NumberHelper do
+  include SitemapGenerator::Helpers::NumberHelper
+
+  it "should number_with_delimiter" do
+    number_with_delimiter(12345678).should == "12,345,678"
+    number_with_delimiter(0).should == "0"
+    number_with_delimiter(123).should == "123"
+    number_with_delimiter(123456).should == "123,456"
+    number_with_delimiter(123456.78).should == "123,456.78"
+    number_with_delimiter(123456.789).should == "123,456.789"
+    number_with_delimiter(123456.78901).should == "123,456.78901"
+    number_with_delimiter(123456789.78901).should == "123,456,789.78901"
+    number_with_delimiter(0.78901).should == "0.78901"
+    number_with_delimiter("123456.78").should == "123,456.78"
+  end
+
+  it "should number_with_delimiter_with_options_hash" do
+    number_with_delimiter(12345678, :delimiter => ' ').should == '12 345 678'
+    number_with_delimiter(12345678.05, :separator => '-').should == '12,345,678-05'
+    number_with_delimiter(12345678.05, :separator => ',', :delimiter => '.').should == '12.345.678,05'
+    number_with_delimiter(12345678.05, :delimiter => '.', :separator => ',').should == '12.345.678,05'
+  end
+
+  it "should number_with_precision" do
+    number_with_precision(-111.2346).should == "-111.235"
+    number_with_precision(111.2346).should == "111.235"
+    number_with_precision(31.825, :precision => 2).should == "31.83"
+    number_with_precision(111.2346, :precision => 2).should == "111.23"
+    number_with_precision(111, :precision => 2).should == "111.00"
+    number_with_precision("111.2346").should == "111.235"
+    number_with_precision("31.825", :precision => 2).should == "31.83"
+    number_with_precision((32.6751 * 100.00), :precision => 0).should == "3268"
+    number_with_precision(111.50, :precision => 0).should == "112"
+    number_with_precision(1234567891.50, :precision => 0).should == "1234567892"
+    number_with_precision(0, :precision => 0).should == "0"
+    number_with_precision(0.001, :precision => 5).should == "0.00100"
+    number_with_precision(0.00111, :precision => 3).should == "0.001"
+    # Odd difference between Ruby versions
+    if RUBY_VERSION < '1.9.3'
+      number_with_precision(9.995, :precision => 2).should == "9.99"
+    else
+      number_with_precision(9.995, :precision => 2).should == "10.00"
+    end
+    number_with_precision(10.995, :precision => 2).should == "11.00"
+  end
+
+  it "should number_with_precision_with_custom_delimiter_and_separator" do
+    number_with_precision(31.825, :precision => 2, :separator => ',').should == '31,83'
+    number_with_precision(1231.825, :precision => 2, :separator => ',', :delimiter => '.').should == '1.231,83'
+  end
+
+  it "should number_with_precision_with_significant_digits" do
+    number_with_precision(123987, :precision => 3, :significant => true).should == "124000"
+    number_with_precision(123987876, :precision => 2, :significant => true ).should == "120000000"
+    number_with_precision("43523", :precision => 1, :significant => true ).should == "40000"
+    number_with_precision(9775, :precision => 4, :significant => true ).should == "9775"
+    number_with_precision(5.3923, :precision => 2, :significant => true ).should == "5.4"
+    number_with_precision(5.3923, :precision => 1, :significant => true ).should == "5"
+    number_with_precision(1.232, :precision => 1, :significant => true ).should == "1"
+    number_with_precision(7, :precision => 1, :significant => true ).should == "7"
+    number_with_precision(1, :precision => 1, :significant => true ).should == "1"
+    number_with_precision(52.7923, :precision => 2, :significant => true ).should == "53"
+    number_with_precision(9775, :precision => 6, :significant => true ).should == "9775.00"
+    number_with_precision(5.3929, :precision => 7, :significant => true ).should == "5.392900"
+    number_with_precision(0, :precision => 2, :significant => true ).should == "0.0"
+    number_with_precision(0, :precision => 1, :significant => true ).should == "0"
+    number_with_precision(0.0001, :precision => 1, :significant => true ).should == "0.0001"
+    number_with_precision(0.0001, :precision => 3, :significant => true ).should == "0.000100"
+    number_with_precision(0.0001111, :precision => 1, :significant => true ).should == "0.0001"
+    number_with_precision(9.995, :precision => 3, :significant => true).should == "10.0"
+    number_with_precision(9.994, :precision => 3, :significant => true).should == "9.99"
+    number_with_precision(10.995, :precision => 3, :significant => true).should == "11.0"
+  end
+
+  it "should number_with_precision_with_strip_insignificant_zeros" do
+    number_with_precision(9775.43, :precision => 4, :strip_insignificant_zeros => true ).should == "9775.43"
+    number_with_precision(9775.2, :precision => 6, :significant => true, :strip_insignificant_zeros => true ).should == "9775.2"
+    number_with_precision(0, :precision => 6, :significant => true, :strip_insignificant_zeros => true ).should == "0"
+  end
+
+  it "should number_with_precision_with_significant_true_and_zero_precision" do
+    # Zero precision with significant is a mistake (would always return zero),
+    # so we treat it as if significant was false (increases backwards compatibily for number_to_human_size)
+    number_with_precision(123.987, :precision => 0, :significant => true).should == "124"
+    number_with_precision(12, :precision => 0, :significant => true ).should == "12"
+    number_with_precision("12.3", :precision => 0, :significant => true ).should == "12"
+  end
+
+  it "should number_to_human_size" do
+    number_to_human_size(0).should == '0 Bytes'
+    number_to_human_size(1).should == '1 Byte'
+    number_to_human_size(3.14159265).should == '3 Bytes'
+    number_to_human_size(123.0).should == '123 Bytes'
+    number_to_human_size(123).should == '123 Bytes'
+    number_to_human_size(1234).should == '1.21 KB'
+    number_to_human_size(12345).should == '12.1 KB'
+    number_to_human_size(1234567).should == '1.18 MB'
+    number_to_human_size(1234567890).should == '1.15 GB'
+    number_to_human_size(1234567890123).should == '1.12 TB'
+    number_to_human_size(terabytes(1026)).should == '1030 TB'
+    number_to_human_size(kilobytes(444)).should == '444 KB'
+    number_to_human_size(megabytes(1023)).should == '1020 MB'
+    number_to_human_size(terabytes(3)).should == '3 TB'
+    number_to_human_size(1234567, :precision => 2).should == '1.2 MB'
+    number_to_human_size(3.14159265, :precision => 4).should == '3 Bytes'
+    number_to_human_size('123').should == '123 Bytes'
+    number_to_human_size(kilobytes(1.0123), :precision => 2).should == '1 KB'
+    number_to_human_size(kilobytes(1.0100), :precision => 4).should == '1.01 KB'
+    number_to_human_size(kilobytes(10.000), :precision => 4).should == '10 KB'
+    number_to_human_size(1.1).should == '1 Byte'
+    number_to_human_size(10).should == '10 Bytes'
+  end
+
+  it "should number_to_human_size_with_options_hash" do
+    number_to_human_size(1234567, :precision => 2).should == '1.2 MB'
+    number_to_human_size(3.14159265, :precision => 4).should == '3 Bytes'
+    number_to_human_size(kilobytes(1.0123), :precision => 2).should == '1 KB'
+    number_to_human_size(kilobytes(1.0100), :precision => 4).should == '1.01 KB'
+    number_to_human_size(kilobytes(10.000), :precision => 4).should == '10 KB'
+    number_to_human_size(1234567890123, :precision => 1).should == '1 TB'
+    number_to_human_size(524288000, :precision=>3).should == '500 MB'
+    number_to_human_size(9961472, :precision=>0).should == '10 MB'
+    number_to_human_size(41010, :precision => 1).should == '40 KB'
+    number_to_human_size(41100, :precision => 2).should == '40 KB'
+    number_to_human_size(kilobytes(1.0123), :precision => 2, :strip_insignificant_zeros => false).should == '1.0 KB'
+    number_to_human_size(kilobytes(1.0123), :precision => 3, :significant => false).should == '1.012 KB'
+    number_to_human_size(kilobytes(1.0123), :precision => 0, :significant => true) #ignores significant it precision is 0.should == '1 KB'
+  end
+
+  it "should number_to_human_size_with_custom_delimiter_and_separator" do
+   number_to_human_size(kilobytes(1.0123), :precision => 3, :separator => ',')                    .should == '1,01 KB'
+   number_to_human_size(kilobytes(1.0100), :precision => 4, :separator => ',')                    .should == '1,01 KB'
+   number_to_human_size(terabytes(1000.1), :precision => 5, :delimiter => '.', :separator => ',') .should == '1.000,1 TB'
+  end
+
+  it "should number_helpers_should_return_nil_when_given_nil" do
+    number_with_delimiter(nil).should be_nil
+    number_with_precision(nil).should be_nil
+    number_to_human_size(nil).should be_nil
+  end
+
+  it "should number_helpers_should_return_non_numeric_param_unchanged" do
+    number_with_delimiter("x").should == "x"
+    number_with_precision("x.").should == "x."
+    number_with_precision("x").should == "x"
+    number_to_human_size('x').should == "x"
+  end
+
+  it "should number_helpers_should_raise_error_if_invalid_when_specified" do
+    lambda do
+      number_to_human_size("x", :raise => true)
+    end.should raise_error(SitemapGenerator::Helpers::NumberHelper::InvalidNumberError)
+    begin
+      number_to_human_size("x", :raise => true)
+    rescue SitemapGenerator::Helpers::NumberHelper::InvalidNumberError => e
+      e.number.should == "x"
+    end
+
+    lambda do
+      number_with_precision("x", :raise => true)
+    end.should raise_error(SitemapGenerator::Helpers::NumberHelper::InvalidNumberError)
+    begin
+      number_with_precision("x", :raise => true)
+    rescue SitemapGenerator::Helpers::NumberHelper::InvalidNumberError => e
+      e.number.should == "x"
+    end
+
+    lambda do
+      number_with_delimiter("x", :raise => true)
+    end.should raise_error(SitemapGenerator::Helpers::NumberHelper::InvalidNumberError)
+    begin
+      number_with_delimiter("x", :raise => true)
+    rescue SitemapGenerator::Helpers::NumberHelper::InvalidNumberError => e
+      e.number.should == "x"
+    end
+  end
+end

data/spec/sitemap_generator/interpreter_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+require 'sitemap_generator/interpreter'
+
+describe SitemapGenerator::Interpreter do
+  let(:link_set)    { SitemapGenerator::LinkSet.new }
+  let(:interpreter) { SitemapGenerator::Interpreter.new(:link_set => link_set) }
+
+  # The interpreter doesn't have the URL helpers included for some reason, so it
+  # fails when adding links.  That messes up later specs unless we reset the sitemap object.
+  after :all do
+    SitemapGenerator::Sitemap.reset!
+  end
+
+  it "should find the config file if Rails.root doesn't end in a slash" do
+    SitemapGenerator::Utilities.with_warnings(nil) do
+      Rails = stub(:root => SitemapGenerator.app.root.to_s.sub(/\/$/, ''))
+    end
+    # Rails.expects(:root).returns(rails_root).at_least_once
+    lambda { SitemapGenerator::Interpreter.run }.should_not raise_exception(Errno::ENOENT)
+  end
+
+  it "should set the verbose option" do
+    SitemapGenerator::Interpreter.any_instance.expects(:instance_eval)
+    interpreter = SitemapGenerator::Interpreter.run(:verbose => true)
+    interpreter.instance_variable_get(:@linkset).verbose.should be_true
+  end
+
+  describe "link_set" do
+    it "should default to the default LinkSet" do
+      SitemapGenerator::Interpreter.new.sitemap.should be(SitemapGenerator::Sitemap)
+    end
+
+    it "should allow setting the LinkSet as an option" do
+      interpreter.sitemap.should be(link_set)
+    end
+  end
+
+  describe "public interface" do
+    describe "add" do
+      it "should add a link to the sitemap" do
+        link_set.expects(:add).with('test', :option => 'value')
+        interpreter.add('test', :option => 'value')
+      end
+    end
+
+    describe "group" do
+      it "should start a new group" do
+        link_set.expects(:group).with('test', :option => 'value')
+        interpreter.group('test', :option => 'value')
+      end
+    end
+
+    describe "sitemap" do
+      it "should return the LinkSet" do
+        interpreter.sitemap.should be(link_set)
+      end
+    end
+    
+    describe "add_to_index" do
+      it "should add a link to the sitemap index" do
+        link_set.expects(:add_to_index).with('test', :option => 'value')
+        interpreter.add_to_index('test', :option => 'value')
+      end
+    end
+  end
+
+  describe "eval" do
+    it "should yield the LinkSet to the block" do
+      interpreter.eval(:yield_sitemap => true) do |sitemap|
+        sitemap.should be(link_set)
+      end
+    end
+
+    it "should not yield the LinkSet to the block" do
+      local = interpreter         # prevent undefined method
+      local_be = self.method(:be) # prevent undefined method
+      local.eval(:yield_sitemap => false) do
+        self.should local_be.call(local)
+      end
+    end
+
+    it "should not yield the LinkSet to the block by default" do
+      local = interpreter         # prevent undefined method
+      local_be = self.method(:be) # prevent undefined method
+      local.eval do
+        self.should local_be.call(local)
+      end
+    end
+  end
+end