nanoc 3.2.4 → 3.3.0

data/test/cli/commands/test_help.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+class Nanoc::CLI::Commands::HelpTest < MiniTest::Unit::TestCase
+
+  include Nanoc::TestHelpers
+
+  def test_run
+    Nanoc::CLI.run %w( help )
+    Nanoc::CLI.run %w( help co )
+  end
+
+end

data/test/cli/commands/test_info.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+class Nanoc::CLI::Commands::InfoTest < MiniTest::Unit::TestCase
+
+  include Nanoc::TestHelpers
+
+  def test_run
+    Nanoc::CLI.run %w( info )
+  end
+
+end

data/test/cli/commands/test_prune.rb

@@ -0,0 +1,98 @@
+# encoding: utf-8
+
+class Nanoc::CLI::Commands::PruneTest < MiniTest::Unit::TestCase
+
+  include Nanoc::TestHelpers
+
+  def test_run_without_yes
+    with_site do |site|
+      # Set output dir
+      File.open('config.yaml', 'w') { |io| io.write 'output_dir: output2' }
+      FileUtils.mkdir_p('output2')
+
+      # Create source files
+      File.open('content/index.html', 'w') { |io| io.write 'stuff' }
+
+      # Create output files
+      File.open('output2/foo.html', 'w')   { |io| io.write 'this is a foo.' }
+      File.open('output2/index.html', 'w') { |io| io.write 'this is a index.' }
+
+      assert_raises SystemExit do
+        Nanoc::CLI.run %w( prune )
+      end
+
+      assert File.file?('output2/index.html')
+      assert File.file?('output2/foo.html')
+    end
+  end
+
+  def test_run_with_yes
+    with_site do |site|
+      # Set output dir
+      File.open('config.yaml', 'w') { |io| io.write 'output_dir: output2' }
+      FileUtils.mkdir_p('output2')
+
+      # Create source files
+      File.open('content/index.html', 'w') { |io| io.write 'stuff' }
+
+      # Create output files
+      File.open('output2/foo.html', 'w')   { |io| io.write 'this is a foo.' }
+      File.open('output2/index.html', 'w') { |io| io.write 'this is a index.' }
+
+      Nanoc::CLI.run %w( prune --yes )
+
+      assert File.file?('output2/index.html')
+      assert !File.file?('output2/foo.html')
+    end
+  end
+
+  def test_run_with_dry_run
+    with_site do |site|
+      # Set output dir
+      File.open('config.yaml', 'w') { |io| io.write 'output_dir: output2' }
+      FileUtils.mkdir_p('output2')
+
+      # Create source files
+      File.open('content/index.html', 'w') { |io| io.write 'stuff' }
+
+      # Create output files
+      File.open('output2/foo.html', 'w')   { |io| io.write 'this is a foo.' }
+      File.open('output2/index.html', 'w') { |io| io.write 'this is a index.' }
+
+      Nanoc::CLI.run %w( prune --dry-run )
+
+      assert File.file?('output2/index.html')
+      assert File.file?('output2/foo.html')
+    end
+  end
+
+  def test_run_with_exclude
+     with_site do |site|
+      # Set output dir
+      File.open('config.yaml', 'w') { |io| io.write "prune:\n  exclude: [ 'good-dir', 'good-file.html' ]" }
+      FileUtils.mkdir_p('output')
+
+      # Create source files
+      File.open('content/index.html', 'w') { |io| io.write 'stuff' }
+
+      # Create output files
+      FileUtils.mkdir_p('output/good-dir')
+      FileUtils.mkdir_p('output/bad-dir')
+      File.open('output/good-file.html', 'w') { |io| io.write 'stuff' }
+      File.open('output/good-dir/blah', 'w')  { |io| io.write 'stuff' }
+      File.open('output/bad-file.html', 'w')  { |io| io.write 'stuff' }
+      File.open('output/bad-dir/blah', 'w')   { |io| io.write 'stuff' }
+      File.open('output/index.html', 'w')     { |io| io.write 'stuff' }
+
+      Nanoc::CLI.run %w( prune --yes )
+
+      assert File.file?('output/index.html')
+      assert File.file?('output/good-dir/blah')
+      assert File.file?('output/good-file.html')
+      assert !File.file?('output/bad-dir/blah')
+      assert !File.file?('output/bad-file.html')
+    end
+  end
+
+end
+

data/test/cli/commands/test_update.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+class Nanoc::CLI::Commands::UpdateTest < MiniTest::Unit::TestCase
+
+  include Nanoc::TestHelpers
+
+  def test_stub
+  end
+
+end

data/test/cli/test_cli.rb

@@ -0,0 +1,102 @@
+# encoding: utf-8
+
+class Nanoc::CLITest < MiniTest::Unit::TestCase
+
+  include Nanoc::TestHelpers
+
+  COMMAND_CODE = <<EOS
+# encoding: utf-8
+
+usage       '_test [options]'
+summary     'meh'
+description 'longer meh'
+
+run do |opts, args, cmd|
+  File.open('_test.out', 'w') { |io| io.write('It works!') }
+end
+EOS
+
+  SUBCOMMAND_CODE = <<EOS
+# encoding: utf-8
+
+usage       '_sub [options]'
+summary     'meh sub'
+description 'longer meh sub'
+
+run do |opts, args, cmd|
+  File.open('_test_sub.out', 'w') { |io| io.write('It works sub!') }
+end
+EOS
+
+  def test_load_custom_commands
+    Nanoc::CLI.run %w( create_site foo )
+
+    FileUtils.cd('foo') do
+      # Create command
+      FileUtils.mkdir_p('commands')
+      File.open('commands/_test.rb', 'w') { |io| io.write(COMMAND_CODE) }
+
+      # Run command
+      begin
+        Nanoc::CLI.run %w( _test )
+      rescue SystemExit
+        assert false, 'Running _test should not cause system exit'
+      end
+
+      # Check
+      assert File.file?('_test.out')
+      assert_equal 'It works!', File.read('_test.out')
+    end
+  end
+
+  def test_load_custom_commands_nested
+    Nanoc::CLI.run %w( create_site foo )
+    FileUtils.cd('foo') do
+      # Create command
+      FileUtils.mkdir_p('commands')
+      File.open('commands/_test.rb', 'w') do |io|
+        io.write(COMMAND_CODE)
+      end
+
+      # Create subcommand
+      FileUtils.mkdir_p('commands/_test')
+      File.open('commands/_test/_sub.rb', 'w') do |io|
+        io.write(SUBCOMMAND_CODE)
+      end
+
+      # Run command
+      begin
+        Nanoc::CLI.run %w( _test _sub )
+      rescue SystemExit
+        assert false, 'Running _test sub should not cause system exit'
+      end
+
+      # Check
+      assert File.file?('_test_sub.out')
+      assert_equal 'It works sub!', File.read('_test_sub.out')
+    end
+  end
+
+  def test_load_custom_commands_broken
+    Nanoc::CLI.run %w( create_site foo )
+
+    FileUtils.cd('foo') do
+      # Create command
+      FileUtils.mkdir_p('commands')
+      File.open('commands/_test.rb', 'w') { |io| io.write('raise "meh"') }
+
+      # Run command
+      position_before = $stderr.tell
+      assert_raises SystemExit do
+        Nanoc::CLI.run %w( _test )
+      end
+      position_after = $stderr.tell
+
+      # Check error output
+      stderr_addition = $stderr.string[position_before, position_after]
+      assert_match(/=== BACKTRACE:/, stderr_addition)
+      assert_match(/commands\/_test.rb/, stderr_addition)
+    end
+  end
+
+end

data/test/cli/test_error_handler.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+class Nanoc::CLI::ErrorHandlerTest < MiniTest::Unit::TestCase
+
+  include Nanoc::TestHelpers
+
+  def test_resolution_for_with_unknown_gem
+    error = LoadError.new('no such file to load -- afjlrestjlsgrshter')
+    assert_nil handler.send(:resolution_for, error)
+  end
+
+  def test_resolution_for_with_known_gem
+    $loud = true
+    error = LoadError.new('no such file to load -- kramdown')
+    assert_match /^Try installing /, handler.send(:resolution_for, error)
+  ensure
+    $loud = false
+  end
+
+  def test_resolution_for_with_not_load_error
+    error = RuntimeError.new('nuclear meltdown detected')
+    assert_nil handler.send(:resolution_for, error)
+  end
+
+  def handler
+    Nanoc::CLI::ErrorHandler.new
+  end
+
+end

data/test/cli/test_logger.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+class Nanoc::CLI::LoggerTest < MiniTest::Unit::TestCase
+
+  include Nanoc::TestHelpers
+
+  def test_stub
+  end
+
+end

data/test/data_sources/test_filesystem.rb

@@ -0,0 +1,433 @@
+# encoding: utf-8
+
+class Nanoc::DataSources::FilesystemTest < MiniTest::Unit::TestCase
+
+  include Nanoc::TestHelpers
+
+  class SampleFilesystemDataSource < Nanoc::DataSource
+    include Nanoc::DataSources::Filesystem
+  end
+
+  def test_setup
+    # Create data source
+    data_source = SampleFilesystemDataSource.new(nil, nil, nil, nil)
+
+    # Remove files to make sure they are recreated
+    FileUtils.rm_rf('content')
+    FileUtils.rm_rf('layouts/default')
+    FileUtils.rm_rf('lib')
+
+    # Mock VCS
+    vcs = mock
+    vcs.expects(:add).times(2) # One time for each directory
+    data_source.vcs = vcs
+
+    # Recreate files
+    data_source.setup
+
+    # Ensure essential files have been recreated
+    assert(File.directory?('content/'))
+    assert(File.directory?('layouts/'))
+
+    # Ensure no non-essential files have been recreated
+    assert(!File.file?('content/index.html'))
+    assert(!File.file?('layouts/default.html'))
+    refute(File.directory?('lib/'))
+  end
+
+  def test_items
+    # Create data source
+    data_source = SampleFilesystemDataSource.new(nil, nil, nil, nil)
+
+    # Check
+    data_source.expects(:load_objects).with('content', 'item', Nanoc::Item)
+    data_source.items
+  end
+
+  def test_layouts
+    # Create data source
+    data_source = SampleFilesystemDataSource.new(nil, nil, nil, nil)
+
+    # Check
+    data_source.expects(:load_objects).with('layouts', 'layout', Nanoc::Layout)
+    data_source.layouts
+  end
+
+  def test_create_item
+    # Create data source
+    data_source = SampleFilesystemDataSource.new(nil, nil, nil, nil)
+
+    # Check
+    data_source.expects(:create_object).with('content', 'the content', 'the attributes', 'the identifier', {})
+    data_source.create_item('the content', 'the attributes', 'the identifier')
+  end
+
+  def test_create_layout
+    # Create data source
+    data_source = SampleFilesystemDataSource.new(nil, nil, nil, nil)
+
+    # Check
+    data_source.expects(:create_object).with('layouts', 'the content', 'the attributes', 'the identifier', {})
+    data_source.create_layout('the content', 'the attributes', 'the identifier')
+  end
+
+  def test_all_split_files_in_allowing_periods_in_identifiers
+    # Create data source
+    data_source = Nanoc::DataSources::FilesystemCompact.new(nil, nil, nil, { :allow_periods_in_identifiers => true })
+
+    # Write sample files
+    FileUtils.mkdir_p('foo')
+    %w( foo.html foo.yaml bar.entry.html foo/qux.yaml ).each do |filename|
+      File.open(filename, 'w') { |io| io.write('test') }
+    end
+
+    # Write stray files
+    %w( foo.html~ foo.yaml.orig bar.entry.html.bak ).each do |filename|
+      File.open(filename, 'w') { |io| io.write('test') }
+    end
+
+    # Get all files
+    output_expected = {
+      './foo'       => [ 'yaml', 'html' ],
+      './bar.entry' => [ nil,    'html' ],
+      './foo/qux'   => [ 'yaml', nil    ]
+    }
+    output_actual = data_source.send :all_split_files_in, '.'
+
+    # Check
+    assert_equal output_expected, output_actual
+  end
+
+  def test_all_split_files_in_disallowing_periods_in_identifiers
+    # Create data source
+    data_source = Nanoc::DataSources::FilesystemCompact.new(nil, nil, nil, nil)
+
+    # Write sample files
+    FileUtils.mkdir_p('foo')
+    %w( foo.html foo.yaml bar.html.erb foo/qux.yaml ).each do |filename|
+      File.open(filename, 'w') { |io| io.write('test') }
+    end
+
+    # Write stray files
+    %w( foo.html~ foo.yaml.orig bar.entry.html.bak ).each do |filename|
+      File.open(filename, 'w') { |io| io.write('test') }
+    end
+
+    # Get all files
+    output_expected = {
+      './foo'       => [ 'yaml', 'html'     ],
+      './bar'       => [ nil,    'html.erb' ],
+      './foo/qux'   => [ 'yaml', nil        ]
+    }
+    output_actual = data_source.send :all_split_files_in, '.'
+
+    # Check
+    assert_equal output_expected, output_actual
+  end
+
+  def test_all_split_files_in_with_multiple_dirs
+    # Create data source
+    data_source = Nanoc::DataSources::FilesystemCompact.new(nil, nil, nil, nil)
+
+    # Write sample files
+    %w( aaa/foo.html bbb/foo.html ccc/foo.html ).each do |filename|
+      FileUtils.mkdir_p(File.dirname(filename))
+      File.open(filename, 'w') { |io| io.write('test') }
+    end
+
+    # Check
+    expected = {
+      './aaa/foo' => [ nil, 'html' ],
+      './bbb/foo' => [ nil, 'html' ],
+      './ccc/foo' => [ nil, 'html' ]
+    }
+    assert_equal expected, data_source.send(:all_split_files_in, '.')
+  end
+
+  def test_all_split_files_in_with_multiple_content_files
+    # Create data source
+    data_source = Nanoc::DataSources::FilesystemCompact.new(nil, nil, nil, nil)
+
+    # Write sample files
+    %w( foo.html foo.xhtml foo.txt foo.yaml bar.html qux.yaml ).each do |filename|
+      File.open(filename, 'w') { |io| io.write('test') }
+    end
+
+    # Check
+    assert_raises RuntimeError do
+      data_source.send(:all_split_files_in, '.')
+    end
+  end
+
+  def test_basename_of_allowing_periods_in_identifiers
+    # Create data source
+    data_source = Nanoc::DataSources::FilesystemCompact.new(nil, nil, nil, { :allow_periods_in_identifiers => true })
+
+    # Get input and expected output
+    expected = {
+      '/'                 => '/',
+      '/foo'              => '/foo',
+      '/foo.html'         => '/foo',
+      '/foo.xyz.html'     => '/foo.xyz',
+      '/foo/'             => '/foo/',
+      '/foo.xyz/'         => '/foo.xyz/',
+      '/foo/bar'          => '/foo/bar',
+      '/foo/bar.html'     => '/foo/bar',
+      '/foo/bar.xyz.html' => '/foo/bar.xyz',
+      '/foo/bar/'         => '/foo/bar/',
+      '/foo/bar.xyz/'     => '/foo/bar.xyz/',
+      '/foo.xyz/bar.xyz/' => '/foo.xyz/bar.xyz/'
+    }
+
+    # Check
+    expected.each_pair do |input, expected_output|
+      actual_output = data_source.send(:basename_of, input)
+      assert_equal(
+        expected_output, actual_output,
+        "basename_of(#{input.inspect}) should equal #{expected_output.inspect}, not #{actual_output.inspect}"
+      )
+    end
+  end
+
+  def test_basename_of_disallowing_periods_in_identifiers
+    # Create data source
+    data_source = Nanoc::DataSources::FilesystemCompact.new(nil, nil, nil, nil)
+
+    # Get input and expected output
+    expected = {
+      '/'                 => '/',
+      '/foo'              => '/foo',
+      '/foo.html'         => '/foo',
+      '/foo.xyz.html'     => '/foo',
+      '/foo/'             => '/foo/',
+      '/foo.xyz/'         => '/foo.xyz/',
+      '/foo/bar'          => '/foo/bar',
+      '/foo/bar.html'     => '/foo/bar',
+      '/foo/bar.xyz.html' => '/foo/bar',
+      '/foo/bar/'         => '/foo/bar/',
+      '/foo/bar.xyz/'     => '/foo/bar.xyz/',
+      '/foo.xyz/bar.xyz/' => '/foo.xyz/bar.xyz/'
+    }
+
+    # Check
+    expected.each_pair do |input, expected_output|
+      actual_output = data_source.send(:basename_of, input)
+      assert_equal(
+        expected_output, actual_output,
+        "basename_of(#{input.inspect}) should equal #{expected_output.inspect}, not #{actual_output.inspect}"
+      )
+    end
+  end
+
+  def test_ext_of_allowing_periods_in_identifiers
+    # Create data source
+    data_source = Nanoc::DataSources::FilesystemCompact.new(nil, nil, nil, { :allow_periods_in_identifiers => true })
+
+    # Get input and expected output
+    expected = {
+      '/'                 => '',
+      '/foo'              => '',
+      '/foo.html'         => '.html',
+      '/foo.xyz.html'     => '.html',
+      '/foo/'             => '',
+      '/foo.xyz/'         => '',
+      '/foo/bar'          => '',
+      '/foo/bar.html'     => '.html',
+      '/foo/bar.xyz.html' => '.html',
+      '/foo/bar/'         => '',
+      '/foo/bar.xyz/'     => '',
+      '/foo.xyz/bar.xyz/' => ''
+    }
+
+    # Check
+    expected.each_pair do |input, expected_output|
+      actual_output = data_source.send(:ext_of, input)
+      assert_equal(
+        expected_output, actual_output,
+        "basename_of(#{input.inspect}) should equal #{expected_output.inspect}, not #{actual_output.inspect}"
+      )
+    end
+  end
+
+  def test_ext_of_disallowing_periods_in_identifiers
+    # Create data source
+    data_source = Nanoc::DataSources::FilesystemCompact.new(nil, nil, nil, nil)
+
+    # Get input and expected output
+    expected = {
+      '/'                 => '',
+      '/foo'              => '',
+      '/foo.html'         => '.html',
+      '/foo.xyz.html'     => '.xyz.html',
+      '/foo/'             => '',
+      '/foo.xyz/'         => '',
+      '/foo/bar'          => '',
+      '/foo/bar.html'     => '.html',
+      '/foo/bar.xyz.html' => '.xyz.html',
+      '/foo/bar/'         => '',
+      '/foo/bar.xyz/'     => '',
+      '/foo.xyz/bar.xyz/' => ''
+    }
+
+    # Check
+    expected.each_pair do |input, expected_output|
+      actual_output = data_source.send(:ext_of, input)
+      assert_equal(
+        expected_output, actual_output,
+        "basename_of(#{input.inspect}) should equal #{expected_output.inspect}, not #{actual_output.inspect}"
+      )
+    end
+  end
+
+  def test_parse_embedded_invalid_2
+    # Create a file
+    File.open('test.html', 'w') do |io|
+      io.write "-----\n"
+      io.write "blah blah\n"
+    end
+
+    # Create data source
+    data_source = Nanoc::DataSources::FilesystemCombined.new(nil, nil, nil, nil)
+
+    # Parse it
+    assert_raises(RuntimeError) do
+      data_source.instance_eval { parse('test.html', nil, 'foobar') }
+    end
+  end
+
+  def test_parse_embedded_separators_but_not_metadata
+    # Create a file
+    File.open('test.html', 'w') do |io|
+      io.write "blah blah\n"
+      io.write "-----\n"
+      io.write "blah blah\n"
+    end
+
+    # Create data source
+    data_source = Nanoc::DataSources::FilesystemCombined.new(nil, nil, nil, nil)
+
+    # Parse it
+    result = data_source.instance_eval { parse('test.html', nil, 'foobar') }
+    assert_equal(File.read('test.html'), result[1])
+    assert_equal({},                     result[0])
+  end
+
+  def test_parse_embedded_full_meta
+    # Create a file
+    File.open('test.html', 'w') do |io|
+      io.write "-----\n"
+      io.write "foo: bar\n"
+      io.write "-----\n"
+      io.write "blah blah\n"
+    end
+
+    # Create data source
+    data_source = Nanoc::DataSources::FilesystemCombined.new(nil, nil, nil, nil)
+
+    # Parse it
+    result = data_source.instance_eval { parse('test.html', nil, 'foobar') }
+    assert_equal({ 'foo' => 'bar' }, result[0])
+    assert_equal('blah blah', result[1])
+  end
+
+  def test_parse_embedded_with_extra_spaces
+    # Create a file
+    File.open('test.html', 'w') do |io|
+      io.write "-----             \n"
+      io.write "foo: bar\n"
+      io.write "-----\t\t\t\t\t\n"
+      io.write "blah blah\n"
+    end
+
+    # Create data source
+    data_source = Nanoc::DataSources::FilesystemCombined.new(nil, nil, nil, nil)
+
+    # Parse it
+    result = data_source.instance_eval { parse('test.html', nil, 'foobar') }
+    assert_equal({ 'foo' => 'bar' }, result[0])
+    assert_equal('blah blah', result[1])
+  end
+
+  def test_parse_embedded_empty_meta
+    # Create a file
+    File.open('test.html', 'w') do |io|
+      io.write "-----\n"
+      io.write "-----\n"
+      io.write "blah blah\n"
+    end
+
+    # Create data source
+    data_source = Nanoc::DataSources::FilesystemCombined.new(nil, nil, nil, nil)
+
+    # Parse it
+    result = data_source.instance_eval { parse('test.html', nil, 'foobar') }
+    assert_equal({}, result[0])
+    assert_equal('blah blah', result[1])
+  end
+
+  def test_parse_utf8_bom
+    File.open('test.html', 'w') do |io|
+      io.write [ 0xEF, 0xBB, 0xBF ].map { |i| i.chr }.join
+      io.write "-----\n"
+      io.write "utf8bomawareness: high\n"
+      io.write "-----\n"
+      io.write "content goes here\n"
+    end
+
+    data_source = Nanoc::DataSources::FilesystemCombined.new(nil, nil, nil, nil)
+
+    result = data_source.instance_eval { parse('test.html', nil, 'foobar') }
+    assert_equal({ 'utf8bomawareness' => 'high' }, result[0])
+    assert_equal('content goes here', result[1])
+  end
+
+  def test_parse_embedded_no_meta
+    content = "blah\n" \
+      "blah blah blah\n" \
+      "blah blah\n"
+
+    # Create a file
+    File.open('test.html', 'w') { |io| io.write(content) }
+
+    # Create data source
+    data_source = Nanoc::DataSources::FilesystemCombined.new(nil, nil, nil, nil)
+
+    # Parse it
+    result = data_source.instance_eval { parse('test.html', nil, 'foobar') }
+    assert_equal({}, result[0])
+    assert_equal(content, result[1])
+  end
+
+  def test_parse_embedded_diff
+    content = \
+      "--- a/foo\n" \
+      "+++ b/foo\n" \
+      "blah blah\n"
+
+    # Create a file
+    File.open('test.html', 'w') { |io| io.write(content) }
+
+    # Create data source
+    data_source = Nanoc::DataSources::FilesystemCombined.new(nil, nil, nil, nil)
+
+    # Parse it
+    result = data_source.instance_eval { parse('test.html', nil, 'foobar') }
+    assert_equal({}, result[0])
+    assert_equal(content, result[1])
+  end
+
+  def test_parse_external
+    # Create a file
+    File.open('test.html', 'w') { |io| io.write("blah blah") }
+    File.open('test.yaml', 'w') { |io| io.write("foo: bar") }
+
+    # Create data source
+    data_source = Nanoc::DataSources::FilesystemCombined.new(nil, nil, nil, nil)
+
+    # Parse it
+    result = data_source.instance_eval { parse('test.html', 'test.yaml', 'foobar') }
+    assert_equal({ "foo" => "bar"}, result[0])
+    assert_equal("blah blah",       result[1])
+  end
+
+end