nanoc3 3.2.4 → 3.3.0

data/test/base/test_compiler_dsl.rb

@@ -1,161 +0,0 @@
-# encoding: utf-8
-
-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_passthrough
-    # Create site
-    Nanoc3::CLI.run %w( create_site bar)
-    FileUtils.cd('bar') do
-      # Create rep
-      item = Nanoc3::Item.new('foo', { :extension => 'bar' }, '/foo/')
-      rep = Nanoc3::ItemRep.new(item, :default)
-
-      # Create other necessary stuff
-      site = Nanoc3::Site.new('.')
-      site.items << item
-      compiler = site.compiler
-      dsl = site.compiler.rules_collection.dsl
-
-      # Create rule
-      dsl.passthrough '/foo/'
-
-      # Route and compile
-      rule = compiler.rules_collection.routing_rule_for(rep)
-      path = rule.apply_to(rep, :compiler => compiler)
-      compiler.send :compile_rep, rep
-
-      # Check result
-      assert_equal 'foo', rep.compiled_content
-      assert_equal '/foo.bar', path
-    end
-  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
-
-  def test_dsl_has_no_access_to_compiler
-    compiler_dsl = Nanoc3::CompilerDSL.new(nil, {})
-    assert_raises(NameError) do
-      compiler_dsl.instance_eval { compiler }
-    end
-  end
-
-  def test_config
-    $venetian = 'unsnares'
-    compiler_dsl = Nanoc3::CompilerDSL.new(nil, { :venetian => 'snares' })
-    compiler_dsl.instance_eval { $venetian = @config[:venetian] }
-    assert_equal 'snares', $venetian
-  end
-
-end

data/test/base/test_context.rb

@@ -1,31 +0,0 @@
-# encoding: utf-8
-
-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,46 +0,0 @@
-# encoding: utf-8
-
-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

data/test/base/test_dependency_tracker.rb

@@ -1,262 +0,0 @@
-# encoding: utf-8
-
-class Nanoc3::DependencyTrackerTest < MiniTest::Unit::TestCase
-
-  include Nanoc3::TestHelpers
-
-  def test_initialize
-    # Mock items
-    items = [ mock, mock ]
-
-    # Create
-    tracker = Nanoc3::DependencyTracker.new(items)
-
-    # Verify no dependencies yet
-    assert_empty tracker.objects_causing_outdatedness_of(items[0])
-    assert_empty tracker.objects_causing_outdatedness_of(items[1])
-  end
-
-  def test_record_dependency
-    # Mock items
-    items = [ mock, mock ]
-
-    # Create
-    tracker = Nanoc3::DependencyTracker.new(items)
-
-    # Record some dependencies
-    tracker.record_dependency(items[0], items[1])
-
-    # Verify dependencies
-    assert_contains_exactly [ items[1] ], tracker.objects_causing_outdatedness_of(items[0])
-  end
-
-  def test_record_dependency_no_self
-    # Mock items
-    items = [ mock, mock ]
-
-    # Create
-    tracker = Nanoc3::DependencyTracker.new(items)
-
-    # Record some dependencies
-    tracker.record_dependency(items[0], items[0])
-    tracker.record_dependency(items[0], items[1])
-
-    # Verify dependencies
-    assert_contains_exactly [ items[1] ], tracker.objects_causing_outdatedness_of(items[0])
-  end
-
-  def test_record_dependency_no_doubles
-    # Mock items
-    items = [ mock, mock ]
-
-    # Create
-    tracker = Nanoc3::DependencyTracker.new(items)
-
-    # Record some dependencies
-    tracker.record_dependency(items[0], items[1])
-    tracker.record_dependency(items[0], items[1])
-    tracker.record_dependency(items[0], items[1])
-
-    # Verify dependencies
-    assert_contains_exactly [ items[1] ], tracker.objects_causing_outdatedness_of(items[0])
-  end
-
-  def test_objects_causing_outdatedness_of
-    # Mock items
-    items = [ mock, mock, mock ]
-
-    # Create
-    tracker = Nanoc3::DependencyTracker.new(items)
-
-    # Record some dependencies
-    tracker.record_dependency(items[0], items[1])
-    tracker.record_dependency(items[1], items[2])
-
-    # Verify dependencies
-    assert_contains_exactly [ items[1] ], tracker.objects_causing_outdatedness_of(items[0])
-  end
-
-  def test_objects_outdated_due_to
-    # Mock items
-    items = [ mock, mock, mock ]
-
-    # Create
-    tracker = Nanoc3::DependencyTracker.new(items)
-
-    # Record some dependencies
-    tracker.record_dependency(items[0], items[1])
-    tracker.record_dependency(items[1], items[2])
-
-    # Verify dependencies
-    assert_contains_exactly [ items[0] ], tracker.objects_outdated_due_to(items[1])
-  end
-
-  def test_start_and_stop
-    # Mock items
-    items = [ mock, mock ]
-
-    # Create
-    tracker = Nanoc3::DependencyTracker.new(items)
-
-    # Start, do something and stop
-    tracker.start
-    Nanoc3::NotificationCenter.post(:visit_started, items[0])
-    Nanoc3::NotificationCenter.post(:visit_started, items[1])
-    Nanoc3::NotificationCenter.post(:visit_ended,   items[1])
-    Nanoc3::NotificationCenter.post(:visit_ended,   items[0])
-    tracker.stop
-
-    # Verify dependencies
-    assert_contains_exactly [ items[1] ], tracker.objects_causing_outdatedness_of(items[0])
-    assert_empty tracker.objects_causing_outdatedness_of(items[1])
-  end
-
-  def test_store_graph_and_load_graph_simple
-    # Mock items
-    items = [ mock('0'), mock('1'), mock('2'), mock('3') ]
-    items.each { |i| i.stubs(:type).returns(:item) }
-    items[0].stubs(:reference).returns([ :item, '/aaa/' ])
-    items[1].stubs(:reference).returns([ :item, '/bbb/' ])
-    items[2].stubs(:reference).returns([ :item, '/ccc/' ])
-    items[3].stubs(:reference).returns([ :item, '/ddd/' ])
-
-    # Create
-    tracker = Nanoc3::DependencyTracker.new(items)
-
-    # Record some dependencies
-    tracker.record_dependency(items[0], items[1])
-    tracker.record_dependency(items[1], items[2])
-    tracker.record_dependency(items[1], items[3])
-
-    # Store
-    tracker.store_graph
-    assert File.file?(tracker.filename)
-
-    # Re-create
-    tracker = Nanoc3::DependencyTracker.new(items)
-
-    # Load
-    tracker.load_graph
-
-    # Check loaded graph
-    assert_contains_exactly [ items[1] ],           tracker.objects_causing_outdatedness_of(items[0])
-    assert_contains_exactly [ items[2], items[3] ], tracker.objects_causing_outdatedness_of(items[1])
-    assert_empty tracker.objects_causing_outdatedness_of(items[2])
-    assert_empty tracker.objects_causing_outdatedness_of(items[3])
-  end
-
-  def test_store_graph_and_load_graph_with_removed_items
-    # Mock items
-    items = [ mock('0'), mock('1'), mock('2'), mock('3') ]
-    items.each { |i| i.stubs(:type).returns(:item) }
-    items[0].stubs(:reference).returns([ :item, '/aaa/' ])
-    items[1].stubs(:reference).returns([ :item, '/bbb/' ])
-    items[2].stubs(:reference).returns([ :item, '/ccc/' ])
-    items[3].stubs(:reference).returns([ :item, '/ddd/' ])
-
-    # Create new and old lists
-    old_items = [ items[0], items[1], items[2], items[3] ]
-    new_items = [ items[0], items[1], items[2]           ]
-
-    # Create
-    tracker = Nanoc3::DependencyTracker.new(old_items)
-
-    # Record some dependencies
-    tracker.record_dependency(old_items[0], old_items[1])
-    tracker.record_dependency(old_items[1], old_items[2])
-    tracker.record_dependency(old_items[1], old_items[3])
-
-    # Store
-    tracker.store_graph
-    assert File.file?(tracker.filename)
-
-    # Re-create
-    tracker = Nanoc3::DependencyTracker.new(new_items)
-
-    # Load
-    tracker.load_graph
-
-    # Check loaded graph
-    assert_contains_exactly [ items[1] ],       tracker.objects_causing_outdatedness_of(items[0])
-    assert_contains_exactly [ items[2], nil ],  tracker.objects_causing_outdatedness_of(items[1])
-    assert_empty tracker.objects_causing_outdatedness_of(items[2])
-  end
-
-  def test_store_graph_with_nils_in_dst
-    # Mock items
-    items = [ mock('0'), mock('1'), mock('2') ]
-    items.each { |i| i.stubs(:type).returns(:item) }
-    items[0].stubs(:reference).returns([ :item, '/aaa/' ])
-    items[1].stubs(:reference).returns([ :item, '/bbb/' ])
-    items[2].stubs(:reference).returns([ :item, '/ccc/' ])
-
-    # Create
-    tracker = Nanoc3::DependencyTracker.new(items)
-
-    # Record some dependencies
-    tracker.record_dependency(items[0], items[1])
-    tracker.record_dependency(items[1], nil)
-
-    # Store
-    tracker.store_graph
-    assert File.file?(tracker.filename)
-
-    # Re-create
-    tracker = Nanoc3::DependencyTracker.new(items)
-
-    # Load
-    tracker.load_graph
-
-    # Check loaded graph
-    assert_contains_exactly [ items[1] ], tracker.objects_causing_outdatedness_of(items[0])
-    assert_contains_exactly [ nil ],      tracker.objects_causing_outdatedness_of(items[1])
-  end
-
-  def test_store_graph_with_nils_in_src
-    # Mock items
-    items = [ mock('0'), mock('1'), mock('2') ]
-    items.each { |i| i.stubs(:type).returns(:item) }
-    items[0].stubs(:reference).returns([ :item, '/aaa/' ])
-    items[1].stubs(:reference).returns([ :item, '/bbb/' ])
-    items[2].stubs(:reference).returns([ :item, '/ccc/' ])
-
-    # Create
-    tracker = Nanoc3::DependencyTracker.new(items)
-
-    # Record some dependencies
-    tracker.record_dependency(items[0], items[1])
-    tracker.record_dependency(nil,      items[2])
-
-    # Store
-    tracker.store_graph
-    assert File.file?(tracker.filename)
-
-    # Re-create
-    tracker = Nanoc3::DependencyTracker.new(items)
-
-    # Load
-    tracker.load_graph
-
-    # Check loaded graph
-    assert_contains_exactly [ items[1] ], tracker.objects_causing_outdatedness_of(items[0])
-    assert_empty tracker.objects_causing_outdatedness_of(items[1])
-  end
-
-  def test_forget_dependencies_for
-    # Mock items
-    items = [ mock, mock, mock ]
-
-    # Create
-    tracker = Nanoc3::DependencyTracker.new(items)
-
-    # Record some dependencies
-    tracker.record_dependency(items[0], items[1])
-    tracker.record_dependency(items[1], items[2])
-    assert_contains_exactly [ items[1] ], tracker.objects_causing_outdatedness_of(items[0])
-
-    # Forget dependencies
-    tracker.forget_dependencies_for(items[0])
-    assert_empty tracker.objects_causing_outdatedness_of(items[0])
-  end
-
-end