nanoc3 3.2.4 → 3.3.0

data/test/cli/test_cli.rb

@@ -1,102 +0,0 @@
-# encoding: utf-8
-
-class Nanoc3::CLITest < MiniTest::Unit::TestCase
-
-  include Nanoc3::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
-    Nanoc3::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
-        Nanoc3::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
-    Nanoc3::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
-        Nanoc3::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
-    Nanoc3::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
-        Nanoc3::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

@@ -1,29 +0,0 @@
-# encoding: utf-8
-
-class Nanoc3::CLI::ErrorHandlerTest < MiniTest::Unit::TestCase
-
-  include Nanoc3::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
-    Nanoc3::CLI::ErrorHandler.new
-  end
-
-end

data/test/cli/test_logger.rb

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

data/test/data_sources/test_filesystem.rb

@@ -1,433 +0,0 @@
-# encoding: utf-8
-
-class Nanoc3::DataSources::FilesystemTest < MiniTest::Unit::TestCase
-
-  include Nanoc3::TestHelpers
-
-  class SampleFilesystemDataSource < Nanoc3::DataSource
-    include Nanoc3::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', Nanoc3::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', Nanoc3::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 = Nanoc3::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 = Nanoc3::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 = Nanoc3::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 = Nanoc3::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 = Nanoc3::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 = Nanoc3::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 = Nanoc3::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 = Nanoc3::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 = Nanoc3::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 = Nanoc3::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 = Nanoc3::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 = Nanoc3::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 = Nanoc3::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 = Nanoc3::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 = Nanoc3::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 = Nanoc3::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 = Nanoc3::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