nanoc 3.2.4 → 3.3.0

data/test/base/core_ext/array_spec.rb

@@ -0,0 +1,73 @@
+# encoding: utf-8
+
+describe 'Array#symbolize_keys' do
+
+  it 'should convert keys to symbols' do
+    array_old = [ :abc, 'xyz', { 'foo' => 'bar', :baz => :qux } ]
+    array_new = [ :abc, 'xyz', { :foo  => 'bar', :baz => :qux } ]
+    array_old.symbolize_keys.must_equal array_new
+  end
+
+end
+
+describe 'Array#stringify_keys' do
+
+  it 'should convert keys to strings' do
+    array_old = [ :abc, 'xyz', { :foo  => 'bar', 'baz' => :qux } ]
+    array_new = [ :abc, 'xyz', { 'foo' => 'bar', 'baz' => :qux } ]
+    array_old.stringify_keys.must_equal array_new
+  end
+
+end
+
+describe 'Array#freeze_recursively' do
+
+  it 'should prevent first-level elements from being modified' do
+    array = [ :a, [ :b, :c ], :d ]
+    array.freeze_recursively
+
+    raised = false
+    begin
+      array[0] = 123
+    rescue => e
+      raised = true
+      assert_match /^can't modify frozen /, e.message
+    end
+    assert raised
+  end
+
+  it 'should prevent second-level elements from being modified' do
+    array = [ :a, [ :b, :c ], :d ]
+    array.freeze_recursively
+
+    raised = false
+    begin
+      array[1][0] = 123
+    rescue => e
+      raised = true
+      assert_match /^can't modify frozen /, e.message
+    end
+    assert raised
+  end
+
+  it 'should not freeze infinitely' do
+    a = []
+    a << a
+
+    a.freeze_recursively
+
+    assert a.frozen?
+    assert a[0].frozen?
+    assert_equal a, a[0]
+  end
+
+end
+
+describe 'Array#checksum' do
+
+  it 'should work' do
+    expectation = '78468f950645150238a26f5b8f2dde39a75a7028'
+    [ [ :foo, 123 ]].checksum.must_equal expectation
+  end
+
+end

data/test/base/core_ext/hash_spec.rb

@@ -0,0 +1,98 @@
+# encoding: utf-8
+
+describe 'Hash#symbolize_keys' do
+
+  it 'should convert keys to symbols' do
+    hash_old = { 'foo' => 'bar' }
+    hash_new = { :foo  => 'bar' }
+    hash_old.symbolize_keys.must_equal hash_new
+  end
+
+end
+
+describe 'Hash#stringify_keys' do
+
+  it 'should leave strings as strings' do
+    hash_old = { 'foo' => 'bar' }
+    hash_new = { 'foo' => 'bar' }
+    hash_old.stringify_keys.must_equal hash_new
+  end
+
+  it 'should convert symbols to strings' do
+    hash_old = { :foo  => 'bar' }
+    hash_new = { 'foo' => 'bar' }
+    hash_old.stringify_keys.must_equal hash_new
+  end
+
+  it 'should convert integers to strings' do
+    hash_old = { 123   => 'bar' }
+    hash_new = { '123' => 'bar' }
+    hash_old.stringify_keys.must_equal hash_new
+  end
+
+  it 'should convert nil to an empty string' do
+    hash_old = { nil => 'bar' }
+    hash_new = { ''  => 'bar' }
+    hash_old.stringify_keys.must_equal hash_new
+  end
+
+end
+
+describe 'Hash#freeze_recursively' do
+
+  it 'should prevent first-level elements from being modified' do
+    hash = { :a => { :b => :c } }
+    hash.freeze_recursively
+
+    raised = false
+    begin
+      hash[:a] = 123
+    rescue => e
+      raised = true
+      assert_match /^can't modify frozen /, e.message
+    end
+    assert raised
+  end
+
+  it 'should prevent second-level elements from being modified' do
+    hash = { :a => { :b => :c } }
+    hash.freeze_recursively
+
+    raised = false
+    begin
+      hash[:a][:b] = 123
+    rescue => e
+      raised = true
+      assert_match /^can't modify frozen /, e.message
+    end
+    assert raised
+  end
+
+  it 'should not freeze infinitely' do
+    a = {}
+    a[:x] = a
+
+    a.freeze_recursively
+
+    assert a.frozen?
+    assert a[:x].frozen?
+    assert_equal a, a[:x]
+  end
+
+end
+
+describe 'Hash#checksum' do
+
+  it 'should work' do
+    expectation = '78468f950645150238a26f5b8f2dde39a75a7028'
+    { :foo => 123 }.checksum.must_equal expectation
+    [ [ :foo, 123 ]].checksum.must_equal expectation
+  end
+
+  it 'should sort keys' do
+    a = { :a => 1, :c => 2, :b => 3 }.checksum
+    b = { :a => 1, :b => 3, :c => 2 }.checksum
+    a.must_equal b
+  end
+
+end

data/test/base/core_ext/pathname_spec.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+describe 'Pathname#checksum' do
+
+  it 'should work on empty files' do
+    begin
+      FileUtils.mkdir_p('tmp')
+      File.open('tmp/myfile', 'w') { |io| io.write('') }
+      pathname = Pathname.new('tmp/myfile')
+      pathname.checksum.must_equal 'da39a3ee5e6b4b0d3255bfef95601890afd80709'
+    ensure
+      FileUtils.rm_rf('tmp')
+    end
+  end
+
+  it 'should work on all files' do
+    begin
+      FileUtils.mkdir_p('tmp')
+      File.open('tmp/myfile', 'w') { |io| io.write('abc') }
+      pathname = Pathname.new('tmp/myfile')
+      pathname.checksum.must_equal 'a9993e364706816aba3e25717850c26c9cd0d89d'
+    ensure
+      FileUtils.rm_rf('tmp')
+    end
+  end
+
+end

data/test/base/core_ext/string_spec.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+describe 'String#cleaned_identifier' do
+
+  it 'should not convert already clean paths' do
+    '/foo/bar/'.cleaned_identifier.must_equal '/foo/bar/'
+  end
+
+  it 'should prepend slash if necessary' do
+    'foo/bar/'.cleaned_identifier.must_equal '/foo/bar/'
+  end
+
+  it 'should append slash if necessary' do
+    '/foo/bar'.cleaned_identifier.must_equal '/foo/bar/'
+  end
+
+  it 'should remove double slashes at start' do
+    '//foo/bar/'.cleaned_identifier.must_equal '/foo/bar/'
+  end
+
+  it 'should remove double slashes at end' do
+    '/foo/bar//'.cleaned_identifier.must_equal '/foo/bar/'
+  end
+
+end
+
+describe 'String#checksum' do
+
+  it 'should work on empty strings' do
+    ''.checksum.must_equal 'da39a3ee5e6b4b0d3255bfef95601890afd80709'
+  end
+
+  it 'should work on all strings' do
+    'abc'.checksum.must_equal 'a9993e364706816aba3e25717850c26c9cd0d89d'
+  end
+
+end

data/test/base/test_checksum_store.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+class Nanoc::ChecksumStoreTest < MiniTest::Unit::TestCase
+
+  include Nanoc::TestHelpers
+
+  def test_get_with_existing_object
+    require 'pstore'
+
+    # Create store
+    FileUtils.mkdir_p('tmp')
+    pstore = PStore.new('tmp/checksums')
+    pstore.transaction do
+      pstore[:data] = { [ :item, '/moo/' ] => 'zomg' }
+      pstore[:version] = 1
+    end
+
+    # Check
+    store = Nanoc::ChecksumStore.new
+    store.load
+    obj = Nanoc::Item.new('Moo?', {}, '/moo/')
+    assert_equal 'zomg', store[obj]
+  end
+
+  def test_get_with_nonexistant_object
+    store = Nanoc::ChecksumStore.new
+    store.load
+
+    # Check
+    obj = Nanoc::Item.new('Moo?', {}, '/animals/cow/')
+    new_checksum = 'Moo?'.checksum + '-' + {}.checksum
+    assert_equal nil, store[obj]
+  end
+
+end

data/test/base/test_code_snippet.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+class Nanoc::CodeSnippetTest < MiniTest::Unit::TestCase
+
+  include Nanoc::TestHelpers
+
+  def test_load
+    # Initialize
+    $complete_insane_parrot = 'meow'
+
+    # Create code and load it
+    code_snippet = Nanoc::CodeSnippet.new("$complete_insane_parrot = 'woof'", 'parrot.rb')
+    code_snippet.load
+
+    # Ensure code is loaded
+    assert_equal('woof', $complete_insane_parrot)
+  end
+
+  def test_load_with_toplevel_binding
+    # Initialize
+    @foo = 'meow'
+
+    # Create code and load it
+    code_snippet = Nanoc::CodeSnippet.new("@foo = 'woof'", 'dog.rb')
+    code_snippet.load
+
+    # Ensure binding is correct
+    assert_equal('meow', @foo)
+  end
+
+end

data/test/base/test_compiler.rb

@@ -0,0 +1,403 @@
+# encoding: utf-8
+
+class Nanoc::CompilerTest < MiniTest::Unit::TestCase
+
+  include Nanoc::TestHelpers
+
+  def test_compilation_rule_for
+    # Mock rules
+    rules = [ mock, mock, mock ]
+    rules[0].expects(:applicable_to?).returns(false)
+    rules[1].expects(:applicable_to?).returns(true)
+    rules[1].expects(:rep_name).returns('wrong')
+    rules[2].expects(:applicable_to?).returns(true)
+    rules[2].expects(:rep_name).returns('right')
+
+    # Create compiler
+    compiler = Nanoc::Compiler.new(nil)
+    compiler.rules_collection.instance_eval { @item_compilation_rules = rules }
+
+    # Mock rep
+    rep = mock
+    rep.stubs(:name).returns('right')
+    item = mock
+    rep.stubs(:item).returns(item)
+
+    # Test
+    assert_equal rules[2], compiler.rules_collection.compilation_rule_for(rep)
+  end
+
+  def test_routing_rule_for
+    # Mock rules
+    rules = [ mock, mock, mock ]
+    rules[0].expects(:applicable_to?).returns(false)
+    rules[1].expects(:applicable_to?).returns(true)
+    rules[1].expects(:rep_name).returns('wrong')
+    rules[2].expects(:applicable_to?).returns(true)
+    rules[2].expects(:rep_name).returns('right')
+
+    # Create compiler
+    compiler = Nanoc::Compiler.new(nil)
+    compiler.rules_collection.instance_eval { @item_routing_rules = rules }
+
+    # Mock rep
+    rep = mock
+    rep.stubs(:name).returns('right')
+    item = mock
+    rep.stubs(:item).returns(item)
+
+    # Test
+    assert_equal rules[2], compiler.rules_collection.routing_rule_for(rep)
+  end
+
+  def test_filter_for_layout_with_existant_layout
+    # Mock site
+    site = mock
+
+    # Create compiler
+    compiler = Nanoc::Compiler.new(site)
+    compiler.rules_collection.layout_filter_mapping[/.*/] = [ :erb, { :foo => 'bar' } ]
+
+    # Mock layout
+    layout = MiniTest::Mock.new
+    layout.expect(:identifier, '/some_layout/')
+
+    # Check
+    assert_equal([ :erb, { :foo => 'bar' } ], compiler.rules_collection.filter_for_layout(layout))
+  end
+
+  def test_filter_for_layout_with_existant_layout_and_unknown_filter
+    # Mock site
+    site = mock
+
+    # Create compiler
+    compiler = Nanoc::Compiler.new(site)
+    compiler.rules_collection.layout_filter_mapping[/.*/] = [ :some_unknown_filter, { :foo => 'bar' } ]
+
+    # Mock layout
+    layout = MiniTest::Mock.new
+    layout.expect(:identifier, '/some_layout/')
+
+    # Check
+    assert_equal([ :some_unknown_filter, { :foo => 'bar' } ], compiler.rules_collection.filter_for_layout(layout))
+  end
+
+  def test_filter_for_layout_with_nonexistant_layout
+    # Mock site
+    site = mock
+
+    # Create compiler
+    compiler = Nanoc::Compiler.new(site)
+    compiler.rules_collection.layout_filter_mapping[%r{^/foo/$}] = [ :erb, { :foo => 'bar' } ]
+
+    # Mock layout
+    layout = MiniTest::Mock.new
+    layout.expect(:identifier, '/bar/')
+
+    # Check
+    assert_equal(nil, compiler.rules_collection.filter_for_layout(layout))
+  end
+
+  def test_filter_for_layout_with_many_layouts
+    # Mock site
+    site = mock
+
+    # Create compiler
+    compiler = Nanoc::Compiler.new(site)
+    compiler.rules_collection.layout_filter_mapping[%r{^/a/b/c/.*/$}] = [ :erb, { :char => 'd' } ]
+    compiler.rules_collection.layout_filter_mapping[%r{^/a/.*/$}]     = [ :erb, { :char => 'b' } ]
+    compiler.rules_collection.layout_filter_mapping[%r{^/a/b/.*/$}]   = [ :erb, { :char => 'c' } ] # never used!
+    compiler.rules_collection.layout_filter_mapping[%r{^/.*/$}]       = [ :erb, { :char => 'a' } ]
+
+    # Mock layout
+    layouts = [ mock, mock, mock, mock ]
+    layouts[0].stubs(:identifier).returns('/a/b/c/d/')
+    layouts[1].stubs(:identifier).returns('/a/b/c/')
+    layouts[2].stubs(:identifier).returns('/a/b/')
+    layouts[3].stubs(:identifier).returns('/a/')
+
+    # Get expectations
+    expectations = {
+      0 => 'd',
+      1 => 'b', # never used! not c, because b takes priority
+      2 => 'b',
+      3 => 'a'
+    }
+
+    # Check
+    expectations.each_pair do |num, char|
+      filter_and_args = compiler.rules_collection.filter_for_layout(layouts[num])
+      refute_nil(filter_and_args)
+      assert_equal(char, filter_and_args[1][:char])
+    end
+  end
+
+  def test_compile_rep_should_write_proper_snapshots
+    # Mock rep
+    item = Nanoc::Item.new('<%= 1 %> <%%= 2 %> <%%%= 3 %>', {}, '/moo/')
+    rep  = Nanoc::ItemRep.new(item, :blah)
+
+    # Set snapshot filenames
+    rep.raw_paths = {
+      :raw  => 'raw.txt',
+      :pre  => 'pre.txt',
+      :post => 'post.txt',
+      :last => 'last.txt'
+    }
+
+    # Create rule
+    rule_block = proc do
+      filter :erb
+      filter :erb
+      layout '/blah/'
+      filter :erb
+    end
+    rule = Nanoc::Rule.new(/blah/, :meh, rule_block)
+
+    # Create layout
+    layout = Nanoc::Layout.new('head <%= yield %> foot', {}, '/blah/')
+
+    # Create site
+    site = mock
+    site.stubs(:config).returns({})
+    site.stubs(:items).returns([])
+    site.stubs(:layouts).returns([ layout ])
+
+    # Create compiler
+    compiler = Nanoc::Compiler.new(site)
+    compiler.rules_collection.expects(:compilation_rule_for).times(2).with(rep).returns(rule)
+    compiler.rules_collection.layout_filter_mapping[%r{^/blah/$}] = [ :erb, {} ]
+    site.stubs(:compiler).returns(compiler)
+
+    # Compile
+    compiler.send(:compile_rep, rep)
+
+    # Test
+    assert File.file?('raw.txt')
+    assert File.file?('pre.txt')
+    assert File.file?('post.txt')
+    assert File.file?('last.txt')
+    assert_equal '<%= 1 %> <%%= 2 %> <%%%= 3 %>', File.read('raw.txt')
+    assert_equal '1 2 <%= 3 %>',                  File.read('pre.txt')
+    assert_equal 'head 1 2 3 foot',               File.read('post.txt')
+    assert_equal 'head 1 2 3 foot',               File.read('last.txt')
+  end
+
+  def test_compile_with_no_reps
+    with_site do |site|
+      site.compile
+
+      assert Dir['output/*'].empty?
+    end
+  end
+
+  def test_compile_with_one_rep
+    with_site do |site|
+      File.open('content/index.html', 'w') { |io| io.write('o hello') }
+
+      site.compile
+
+      assert Dir['output/*'].size == 1
+      assert File.file?('output/index.html')
+      assert File.read('output/index.html') == 'o hello'
+    end
+  end
+
+  def test_compile_with_two_independent_reps
+    with_site do |site|
+      File.open('content/foo.html', 'w') { |io| io.write('o hai') }
+      File.open('content/bar.html', 'w') { |io| io.write('o bai') }
+
+      site.compile
+
+      assert Dir['output/*'].size == 2
+      assert File.file?('output/foo/index.html')
+      assert File.file?('output/bar/index.html')
+      assert File.read('output/foo/index.html') == 'o hai'
+      assert File.read('output/bar/index.html') == 'o bai'
+    end
+  end
+
+  def test_compile_with_two_dependent_reps
+    with_site(:compilation_rule_content => 'filter :erb') do |site|
+      File.open('content/foo.html', 'w') do |io|
+        io.write('<%= @items.find { |i| i.identifier == "/bar/" }.compiled_content %>!!!')
+      end
+      File.open('content/bar.html', 'w') do |io|
+        io.write('manatee')
+      end
+
+      site.compile
+
+      assert Dir['output/*'].size == 2
+      assert File.file?('output/foo/index.html')
+      assert File.file?('output/bar/index.html')
+      assert File.read('output/foo/index.html') == 'manatee!!!'
+      assert File.read('output/bar/index.html') == 'manatee'
+    end
+  end
+
+  def test_compile_with_two_mutually_dependent_reps
+    with_site(:compilation_rule_content => 'filter :erb') do |site|
+      File.open('content/foo.html', 'w') do |io|
+        io.write('<%= @items.find { |i| i.identifier == "/bar/" }.compiled_content %>')
+      end
+      File.open('content/bar.html', 'w') do |io|
+        io.write('<%= @items.find { |i| i.identifier == "/foo/" }.compiled_content %>')
+      end
+
+      assert_raises Nanoc::Errors::RecursiveCompilation do
+        site.compile
+      end
+    end
+  end
+
+  def test_disallow_routes_not_starting_with_slash
+    # Create site
+    Nanoc::CLI.run %w( create_site bar)
+
+    FileUtils.cd('bar') do
+      # Create routes
+      File.open('Rules', 'w') do |io|
+        io.write "compile '*' do\n"
+        io.write "  layout 'default'\n"
+        io.write "end\n"
+        io.write "\n"
+        io.write "route '*' do\n"
+        io.write "  'index.html'\n"
+        io.write "end\n"
+        io.write "\n"
+        io.write "layout '*', :erb\n"
+      end
+
+      # Create site
+      site = Nanoc::Site.new('.')
+      error = assert_raises(RuntimeError) do
+        site.compile
+      end
+      assert_match /^The path returned for the.*does not start with a slash. Please ensure that all routing rules return a path that starts with a slash./, error.message
+    end
+  end
+
+  def test_load_should_be_idempotent
+    # Create site
+    Nanoc::CLI.run %w( create_site bar)
+
+    FileUtils.cd('bar') do
+      site = Nanoc::Site.new('.')
+
+      compiler = Nanoc::Compiler.new(site)
+      def compiler.route_reps
+        raise 'oh my gosh it is borken'
+      end
+
+      assert site.instance_eval { !@loaded }
+      assert_raises(RuntimeError) { compiler.load }
+      assert site.instance_eval { !@loaded }
+      assert_raises(RuntimeError) { compiler.load }
+    end
+  end
+
+  def test_compile_should_recompile_all_reps
+    Nanoc::CLI.run %w( create_site bar )
+
+    FileUtils.cd('bar') do
+      Nanoc::CLI.run %w( compile )
+
+      site = Nanoc::Site.new('.')
+      site.compile
+
+      # At this point, even the already compiled items in the previous pass
+      # should have their compiled content assigned, so this should work:
+      site.items[0].reps[0].compiled_content
+    end
+  end
+
+  def test_disallow_multiple_snapshots_with_the_same_name
+    # Create site
+    Nanoc::CLI.run %w( create_site bar )
+
+    FileUtils.cd('bar') do
+      # Create routes
+      File.open('Rules', 'w') do |io|
+        io.write "compile '*' do\n"
+        io.write "  snapshot :aaa\n"
+        io.write "  snapshot :aaa\n"
+        io.write "end\n"
+        io.write "\n"
+        io.write "route '*' do\n"
+        io.write "  '/index.html'\n"
+        io.write "end\n"
+        io.write "\n"
+        io.write "layout '*', :erb\n"
+      end
+
+      # Compile
+      site = Nanoc::Site.new('.')
+      assert_raises Nanoc::Errors::CannotCreateMultipleSnapshotsWithSameName do
+        site.compile
+      end
+    end
+  end
+
+  def test_include_compiled_content_of_active_item_at_previous_snapshot
+    with_site do |site|
+      # Create item
+      File.open('content/index.html', 'w') do |io|
+        io.write('[<%= @item.compiled_content(:snapshot => :aaa) %>]')
+      end
+
+      # Create routes
+      File.open('Rules', 'w') do |io|
+        io.write "compile '*' do\n"
+        io.write "  snapshot :aaa\n"
+        io.write "  filter :erb\n"
+        io.write "  filter :erb\n"
+        io.write "end\n"
+        io.write "\n"
+        io.write "route '*' do\n"
+        io.write "  '/index.html'\n"
+        io.write "end\n"
+        io.write "\n"
+        io.write "layout '*', :erb\n"
+      end
+
+      # Compile
+      site = Nanoc::Site.new('.')
+      site.compile
+
+      # Check
+      assert_equal '[[[<%= @item.compiled_content(:snapshot => :aaa) %>]]]', File.read('output/index.html')
+    end
+  end
+
+  def test_layout_with_extra_filter_args
+    with_site do |site|
+      # Create item
+      File.open('content/index.html', 'w') do |io|
+        io.write('This is <%= @foo %>.')
+      end
+
+      # Create routes
+      File.open('Rules', 'w') do |io|
+        io.write "compile '*' do\n"
+        io.write "  filter :erb, :locals => { :foo => 123 }\n"
+        io.write "end\n"
+        io.write "\n"
+        io.write "route '*' do\n"
+        io.write "  '/index.html'\n"
+        io.write "end\n"
+        io.write "\n"
+        io.write "layout '*', :erb\n"
+      end
+
+      # Compile
+      site = Nanoc::Site.new('.')
+      site.compile
+
+      # Check
+      assert_equal 'This is 123.', File.read('output/index.html')
+    end
+  end
+
+end