nanoc3 3.1.9 → 3.2.0a1

data/test/base/test_compiler.rb

@@ -1,410 +0,0 @@
-# encoding: utf-8
-
-require 'test/helper'
-
-class Nanoc3::CompilerTest < MiniTest::Unit::TestCase
-
-  include Nanoc3::TestHelpers
-
-  def test_run_without_item
-    # Mock items
-    items = [ mock('Nanoc3::Item 1'), mock('Nanoc3::Item 2') ]
-    items[0]
-    items[1]
-
-    # Mock reps
-    items[0].stubs(:reps).returns([ mock('Nanoc3::ItemRep 1.1') ])
-    items[1].stubs(:reps).returns([ mock('Nanoc3::ItemRep 2.1'), mock('Nanoc3::ItemRep 2.2') ])
-    reps = items[0].reps + items[1].reps
-    reps.each { |r| r.quacks_like(Object.new) }
-
-    # Mock site
-    site = mock
-    site.stubs(:config).returns({ :output_dir => 'foo/bar/baz' })
-    site.stubs(:items).returns(items)
-
-    # Create compiler
-    compiler = Nanoc3::Compiler.new(site)
-    compiler.expects(:compile_reps).with(reps)
-    compiler.expects(:forget_dependencies_if_outdated).with(items)
-
-    # Mock dependency tracker
-    dependency_tracker = mock('Nanoc3::DependencyTracker')
-    dependency_tracker.expects(:load_graph)
-    dependency_tracker.expects(:store_graph)
-    dependency_tracker.expects(:start)
-    dependency_tracker.expects(:stop)
-    dependency_tracker.expects(:propagate_outdatedness)
-    compiler.stubs(:dependency_tracker).returns(dependency_tracker)
-
-    # Run
-    compiler.run
-
-    # Make sure output dir is created
-    assert(File.directory?('foo/bar/baz'))
-  end
-
-  def test_run_with_item
-    # Mock items
-    item = mock
-    other_items = [ mock, mock ]
-
-    # Mock reps
-    item.stubs(:reps).returns([ mock, mock, mock ])
-    other_items.each { |i| i.stubs(:reps).returns([ mock ]) }
-    reps = item.reps + other_items[0].reps
-    reps.each { |r| r.quacks_like(Object.new) }
-
-    # Mock site
-    site = mock
-    site.expects(:config).returns({ :output_dir => 'foo/bar/baz' })
-
-    # Create compiler
-    compiler = Nanoc3::Compiler.new(site)
-    compiler.expects(:compile_reps).with(reps)
-    compiler.expects(:forget_dependencies_if_outdated).with([ item, other_items[0] ])
-
-    # Mock dependency tracker
-    dependency_tracker = mock
-    dependency_tracker.expects(:load_graph)
-    dependency_tracker.expects(:store_graph)
-    dependency_tracker.expects(:start)
-    dependency_tracker.expects(:stop)
-    dependency_tracker.expects(:propagate_outdatedness)
-    dependency_tracker.expects(:successors_of).with(item).returns([ other_items[0] ])
-    compiler.stubs(:dependency_tracker).returns(dependency_tracker)
-
-    # Run
-    compiler.run(item)
-
-    # Make sure output dir is created
-    assert(File.directory?('foo/bar/baz'))
-  end
-
-  def test_run_with_force
-    # Mock items
-    items = [
-      Nanoc3::Item.new('content 0', {}, '/item0/'),
-      Nanoc3::Item.new('content 1', {}, '/item1/')
-    ]
-
-    # Mock reps
-    items[0].reps << Nanoc3::ItemRep.new(items[0], :rep00)
-    items[1].reps << Nanoc3::ItemRep.new(items[1], :rep10)
-    items[1].reps << Nanoc3::ItemRep.new(items[1], :rep11)
-    reps = items[0].reps + items[1].reps
-    reps.each { |r| r.expects(:force_outdated=).with(true) }
-
-    # Mock site
-    site = mock
-    site.stubs(:config).returns({ :output_dir => 'foo/bar/baz' })
-    site.stubs(:items).returns(items)
-
-    # Create compiler
-    compiler = Nanoc3::Compiler.new(site)
-    compiler.expects(:compile_reps).with(reps)
-    compiler.expects(:forget_dependencies_if_outdated).with(items)
-
-    # Mock dependency tracker
-    dependency_tracker = mock
-    dependency_tracker.expects(:load_graph)
-    dependency_tracker.expects(:store_graph)
-    dependency_tracker.expects(:start)
-    dependency_tracker.expects(:stop)
-    compiler.stubs(:dependency_tracker).returns(dependency_tracker)
-
-    # Run
-    compiler.run(nil, :force => true)
-
-    # Make sure output dir is created
-    assert(File.directory?('foo/bar/baz'))
-  end
-
-  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 = Nanoc3::Compiler.new(nil)
-    compiler.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.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 = Nanoc3::Compiler.new(nil)
-    compiler.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.routing_rule_for(rep)
-  end
-
-  def test_filter_for_layout_with_existant_layout
-    # Mock site
-    site = mock
-
-    # Create compiler
-    compiler = Nanoc3::Compiler.new(site)
-    compiler.layout_filter_mapping[/.*/] = [ :erb, { :foo => 'bar' } ]
-
-    # Mock layout
-    layout = MiniTest::Mock.new
-    layout.expect(:identifier, '/some_layout/')
-
-    # Check
-    assert_equal([ :erb, { :foo => 'bar' } ], compiler.filter_for_layout(layout))
-  end
-
-  def test_filter_for_layout_with_existant_layout_and_unknown_filter
-    # Mock site
-    site = mock
-
-    # Create compiler
-    compiler = Nanoc3::Compiler.new(site)
-    compiler.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.filter_for_layout(layout))
-  end
-
-  def test_filter_for_layout_with_nonexistant_layout
-    # Mock site
-    site = mock
-
-    # Create compiler
-    compiler = Nanoc3::Compiler.new(site)
-    compiler.layout_filter_mapping[%r{^/foo/$}] = [ :erb, { :foo => 'bar' } ]
-
-    # Mock layout
-    layout = MiniTest::Mock.new
-    layout.expect(:identifier, '/bar/')
-
-    # Check
-    assert_equal(nil, compiler.filter_for_layout(layout))
-  end
-
-  def test_filter_for_layout_with_many_layouts
-    # Mock site
-    site = mock
-
-    # Create compiler
-    compiler = Nanoc3::Compiler.new(site)
-    compiler.layout_filter_mapping[%r{^/a/b/c/.*/$}] = [ :erb, { :char => 'd' } ]
-    compiler.layout_filter_mapping[%r{^/a/.*/$}]     = [ :erb, { :char => 'b' } ]
-    compiler.layout_filter_mapping[%r{^/a/b/.*/$}]   = [ :erb, { :char => 'c' } ] # never used!
-    compiler.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.filter_for_layout(layouts[num])
-      refute_nil(filter_and_args)
-      assert_equal(char, filter_and_args[1][:char])
-    end
-  end
-
-  def test_compile_rep
-    # Mock rep
-    item = mock
-    rep = mock
-    rep.expects(:compiled=).with(true)
-    rep.expects(:raw_path).returns('output/foo.html')
-    rep.expects(:write)
-    rep.stubs(:item).returns(item)
-
-    # Create compiler
-    compiler = Nanoc3::Compiler.new(nil)
-    compilation_rule = mock
-    compilation_rule.expects(:apply_to).with(rep)
-    compiler.expects(:compilation_rule_for).returns(compilation_rule)
-
-    # Compile
-    compiler.send :compile_rep, rep
-  end
-
-  def test_compile_reps_with_no_reps
-    # Create compiler
-    compiler = Nanoc3::Compiler.new(nil)
-    compiler.expects(:compile_rep).never
-
-    # Compile
-    compiler.send :compile_reps, []
-  end
-
-  def test_compile_reps_with_one_rep
-    # Mock rep
-    rep = mock
-    rep.expects(:outdated?).returns(true)
-
-    # Create compiler
-    compiler = Nanoc3::Compiler.new(nil)
-    compiler.expects(:compile_rep).with(rep)
-
-    # Compile
-    compiler.send :compile_reps, [ rep ]
-  end
-
-  def test_compile_reps_with_two_independent_reps
-    # Mock reps
-    reps = [ mock, mock ]
-    reps[0].expects(:outdated?).returns(true)
-    reps[1].expects(:outdated?).returns(true)
-
-    # Create compiler
-    compiler = Nanoc3::Compiler.new(nil)
-    compiler.expects(:compile_rep).times(2)
-
-    # Compile
-    compiler.send :compile_reps, reps
-
-    # Check size of reps array
-    assert_equal 2, reps.size
-  end
-
-  def test_compile_reps_with_two_dependent_reps
-    # Mock items
-    items = [ mock, mock ]
-    items[1].expects(:identifier).returns('/foo/bar/')
-
-    # Mock reps
-    reps  = [ mock, mock ]
-    reps[0].expects(:outdated?).returns(true)
-    reps[0].expects(:forget_progress)
-    reps[1].expects(:item).returns(items[1])
-    reps[1].expects(:name).returns('somerepname')
-    reps[1].expects(:outdated?).returns(true)
-
-    # Create compiler
-    compiler = Nanoc3::Compiler.new(nil)
-    compiler.instance_eval { @_reps = reps }
-    def compiler.compile_rep(rep)
-      @_invocation_id ||= 0
-      @_called_reps   ||= []
-
-      case @_invocation_id
-      when 0
-        @_invocation_id = 1
-        @_called_reps[0] = rep
-        raise Nanoc3::Errors::UnmetDependency.new(@_reps[1])
-      when 1
-        @_invocation_id = 2
-        @_called_reps[1] = rep
-      when 2
-        @_invocation_id = 3
-        @_called_reps[2] = rep
-      end
-    end
-
-    # Compile
-    compiler.send :compile_reps, reps
-
-    # Check
-    assert_equal reps[0], compiler.instance_eval { @_called_reps[0] }
-    assert_equal reps[1], compiler.instance_eval { @_called_reps[1] }
-    assert_equal reps[0], compiler.instance_eval { @_called_reps[2] }
-  end
-
-  def test_compile_reps_with_two_mutually_dependent_reps
-    # Mock items
-    items = [ mock, mock ]
-    items[0].expects(:identifier).returns('/first/')
-    items[1].expects(:identifier).returns('/second/')
-
-    # Mock reps
-    reps  = [ mock, mock ]
-    reps[0].expects(:item).returns(items[0])
-    reps[0].expects(:name).returns('firstrep')
-    reps[0].expects(:outdated?).returns(true)
-    reps[0].expects(:forget_progress)
-    reps[1].expects(:item).returns(items[1])
-    reps[1].expects(:name).returns('secondrep')
-    reps[1].expects(:outdated?).returns(true)
-    reps[1].expects(:forget_progress)
-
-    # Create compiler
-    compiler = Nanoc3::Compiler.new(nil)
-    compiler.instance_eval { @_reps = reps }
-    def compiler.compile_rep(rep)
-      if rep == @_reps[0]
-        raise Nanoc3::Errors::UnmetDependency.new(@_reps[1])
-      elsif rep == @_reps[1]
-        raise Nanoc3::Errors::UnmetDependency.new(@_reps[0])
-      else
-        raise RuntimeError.new("this shouldn't have happened")
-      end
-    end
-
-    # Compile
-    assert_raises Nanoc3::Errors::RecursiveCompilation do
-      compiler.send :compile_reps, reps
-    end
-  end
-
-  def test_forget_dependencies_if_outdated
-    # Mock items
-    items = [ mock, mock, mock, mock ]
-    items[0].stubs(:outdated?).returns(false)
-    items[0].stubs(:outdated_due_to_dependencies?).returns(false)
-    items[1].stubs(:outdated?).returns(true)
-    items[1].stubs(:outdated_due_to_dependencies?).returns(false)
-    items[2].stubs(:outdated?).returns(false)
-    items[2].stubs(:outdated_due_to_dependencies?).returns(true)
-    items[3].stubs(:outdated?).returns(true)
-    items[3].stubs(:outdated_due_to_dependencies?).returns(true)
-
-    # Mock dependency tracker
-    dependency_tracker = mock
-    dependency_tracker.expects(:forget_dependencies_for).times(3)
-
-    # Create compiler
-    compiler = Nanoc3::Compiler.new(nil)
-    compiler.stubs(:dependency_tracker).returns(dependency_tracker)
-    compiler.send :forget_dependencies_if_outdated, items
-  end
-
-end

data/test/base/test_compiler_dsl.rb

@@ -1,121 +0,0 @@
-# encoding: utf-8
-
-require 'test/helper'
-
-class Nanoc3::CompilerDSLTest < MiniTest::Unit::TestCase
-
-  include Nanoc3::TestHelpers
-
-  def test_compile
-    # TODO implement
-  end
-
-  def test_route
-    # TODO implement
-  end
-
-  def test_layout
-    # TODO implement
-  end
-
-  def test_identifier_to_regex_without_wildcards
-    # Create compiler DSL
-    compiler_dsl = Nanoc3::CompilerDSL.new(nil)
-
-    actual   = compiler_dsl.instance_eval { identifier_to_regex('foo') }
-    expected = %r{^/foo/$}
-
-    assert_equal(expected.to_s,      actual.to_s)
-    assert_equal(expected.source,    actual.source)
-    assert_equal(expected.kcode,     actual.kcode) if expected.respond_to?(:kcode)
-    assert_equal(expected.casefold?, actual.casefold?)
-    assert_equal(expected.options,   actual.options)
-  end
-
-  def test_identifier_to_regex_with_one_wildcard
-    # Create compiler DSL
-    compiler_dsl = Nanoc3::CompilerDSL.new(nil)
-
-    actual   = compiler_dsl.instance_eval { identifier_to_regex('foo/*/bar') }
-    expected = %r{^/foo/(.*?)/bar/$}
-
-    assert_equal(expected.to_s,      actual.to_s)
-    assert_equal(expected.source,    actual.source)
-    assert_equal(expected.kcode,     actual.kcode) if expected.respond_to?(:kcode)
-    assert_equal(expected.casefold?, actual.casefold?)
-    assert_equal(expected.options,   actual.options)
-  end
-
-  def test_identifier_to_regex_with_two_wildcards
-    # Create compiler DSL
-    compiler_dsl = Nanoc3::CompilerDSL.new(nil)
-
-    actual   = compiler_dsl.instance_eval { identifier_to_regex('foo/*/bar/*/qux') }
-    expected = %r{^/foo/(.*?)/bar/(.*?)/qux/$}
-
-    assert_equal(expected.to_s,      actual.to_s)
-    assert_equal(expected.source,    actual.source)
-    assert_equal(expected.kcode,     actual.kcode) if expected.respond_to?(:kcode)
-    assert_equal(expected.casefold?, actual.casefold?)
-    assert_equal(expected.options,   actual.options)
-  end
-
-  def test_identifier_to_regex_with_just_one_wildcard
-    # Create compiler DSL
-    compiler_dsl = Nanoc3::CompilerDSL.new(nil)
-
-    actual   = compiler_dsl.instance_eval { identifier_to_regex('*') }
-    expected = %r{^/(.*?)$}
-
-    assert_equal(expected.to_s,      actual.to_s)
-    assert_equal(expected.source,    actual.source)
-    assert_equal(expected.kcode,     actual.kcode) if expected.respond_to?(:kcode)
-    assert_equal(expected.casefold?, actual.casefold?)
-    assert_equal(expected.options,   actual.options)
-  end
-
-  def test_identifier_to_regex_with_root
-    # Create compiler DSL
-    compiler_dsl = Nanoc3::CompilerDSL.new(nil)
-
-    actual   = compiler_dsl.instance_eval { identifier_to_regex('/') }
-    expected = %r{^/$}
-
-    assert_equal(expected.to_s,      actual.to_s)
-    assert_equal(expected.source,    actual.source)
-    assert_equal(expected.kcode,     actual.kcode) if expected.respond_to?(:kcode)
-    assert_equal(expected.casefold?, actual.casefold?)
-    assert_equal(expected.options,   actual.options)
-  end
-
-  def test_identifier_to_regex_with_only_children
-    # Create compiler DSL
-    compiler_dsl = Nanoc3::CompilerDSL.new(nil)
-
-    actual   = compiler_dsl.instance_eval { identifier_to_regex('/foo/*/') }
-    expected = %r{^/foo/(.*?)/$}
-
-    assert_equal(expected.to_s,      actual.to_s)
-    assert_equal(expected.source,    actual.source)
-    assert_equal(expected.kcode,     actual.kcode) if expected.respond_to?(:kcode)
-    assert_equal(expected.casefold?, actual.casefold?)
-    assert_equal(expected.options,   actual.options)
-  end
-
-  def test_identifier_to_regex_with_plus_wildcard
-    # Create compiler DSL
-    compiler_dsl = Nanoc3::CompilerDSL.new(nil)
-
-    actual   = compiler_dsl.instance_eval { identifier_to_regex('/foo/+') }
-    expected = %r{^/foo/(.+?)/$}
-
-    assert_equal(expected.to_s,      actual.to_s)
-    assert_equal(expected.source,    actual.source)
-    assert_equal(expected.kcode,     actual.kcode) if expected.respond_to?(:kcode)
-    assert_equal(expected.casefold?, actual.casefold?)
-    assert_equal(expected.options,   actual.options)
-    assert('/foo/bar/' =~ actual)
-    refute('/foo/'     =~ actual)
-  end
-
-end

data/test/base/test_context.rb

@@ -1,33 +0,0 @@
-# encoding: utf-8
-
-require 'test/helper'
-
-class Nanoc3::ContextTest < MiniTest::Unit::TestCase
-
-  include Nanoc3::TestHelpers
-
-  def test_context_with_instance_variable
-    # Create context
-    context = Nanoc3::Context.new({ :foo => 'bar', :baz => 'quux' })
-
-    # Ensure correct evaluation
-    assert_equal('bar', eval("@foo", context.get_binding))
-  end
-
-  def test_context_with_instance_method
-    # Create context
-    context = Nanoc3::Context.new({ :foo => 'bar', :baz => 'quux' })
-
-    # Ensure correct evaluation
-    assert_equal('bar', eval("foo", context.get_binding))
-  end
-
-  def test_example
-    # Parse
-    YARD.parse('../lib/nanoc3/base/context.rb')
-
-    # Run
-    assert_examples_correct 'Nanoc3::Context#initialize'
-  end
-
-end

data/test/base/test_data_source.rb

@@ -1,48 +0,0 @@
-# encoding: utf-8
-
-require 'test/helper'
-
-class Nanoc3::DataSourceTest < MiniTest::Unit::TestCase
-
-  include Nanoc3::TestHelpers
-
-  def test_loading
-    # Create data source
-    data_source = Nanoc3::DataSource.new(nil, nil, nil, nil)
-    data_source.expects(:up).times(1)
-    data_source.expects(:down).times(1)
-
-    # Test nested loading
-    assert_equal(0, data_source.instance_eval { @references })
-    data_source.loading do
-      assert_equal(1, data_source.instance_eval { @references })
-      data_source.loading do
-        assert_equal(2, data_source.instance_eval { @references })
-      end
-      assert_equal(1, data_source.instance_eval { @references })
-    end
-    assert_equal(0, data_source.instance_eval { @references })
-  end
-
-  def test_not_implemented
-    # Create data source
-    data_source = Nanoc3::DataSource.new(nil, nil, nil, nil)
-
-    # Test optional methods
-    data_source.up
-    data_source.down
-    data_source.update
-
-    # Test required methods - general
-    assert_raises(NotImplementedError) { data_source.setup }
-
-    # Test methods - loading data
-    assert_equal [],  data_source.items
-    assert_equal [],  data_source.layouts
-
-    # Test required method - creating data
-    assert_raises(NotImplementedError) { data_source.create_item(nil, nil, nil) }
-    assert_raises(NotImplementedError) { data_source.create_layout(nil, nil, nil) }
-  end
-
-end