nanoc 3.2.4 → 3.3.0

data/test/base/test_compiler_dsl.rb

@@ -0,0 +1,161 @@
+# encoding: utf-8
+
+class Nanoc::CompilerDSLTest < MiniTest::Unit::TestCase
+
+  include Nanoc::TestHelpers
+
+  def test_compile
+    # TODO implement
+  end
+
+  def test_route
+    # TODO implement
+  end
+
+  def test_layout
+    # TODO implement
+  end
+
+  def test_passthrough
+    # Create site
+    Nanoc::CLI.run %w( create_site bar)
+    FileUtils.cd('bar') do
+      # Create rep
+      item = Nanoc::Item.new('foo', { :extension => 'bar' }, '/foo/')
+      rep = Nanoc::ItemRep.new(item, :default)
+
+      # Create other necessary stuff
+      site = Nanoc::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 = Nanoc::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 = Nanoc::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 = Nanoc::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 = Nanoc::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 = Nanoc::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 = Nanoc::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 = Nanoc::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 = Nanoc::CompilerDSL.new(nil, {})
+    assert_raises(NameError) do
+      compiler_dsl.instance_eval { compiler }
+    end
+  end
+
+  def test_config
+    $venetian = 'unsnares'
+    compiler_dsl = Nanoc::CompilerDSL.new(nil, { :venetian => 'snares' })
+    compiler_dsl.instance_eval { $venetian = @config[:venetian] }
+    assert_equal 'snares', $venetian
+  end
+
+end

data/test/base/test_context.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+class Nanoc::ContextTest < MiniTest::Unit::TestCase
+
+  include Nanoc::TestHelpers
+
+  def test_context_with_instance_variable
+    # Create context
+    context = Nanoc::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 = Nanoc::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/nanoc/base/context.rb')
+
+    # Run
+    assert_examples_correct 'Nanoc::Context#initialize'
+  end
+
+end

data/test/base/test_data_source.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+class Nanoc::DataSourceTest < MiniTest::Unit::TestCase
+
+  include Nanoc::TestHelpers
+
+  def test_loading
+    # Create data source
+    data_source = Nanoc::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 = Nanoc::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

@@ -0,0 +1,262 @@
+# encoding: utf-8
+
+class Nanoc::DependencyTrackerTest < MiniTest::Unit::TestCase
+
+  include Nanoc::TestHelpers
+
+  def test_initialize
+    # Mock items
+    items = [ mock, mock ]
+
+    # Create
+    tracker = Nanoc::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 = Nanoc::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 = Nanoc::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 = Nanoc::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 = Nanoc::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 = Nanoc::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 = Nanoc::DependencyTracker.new(items)
+
+    # Start, do something and stop
+    tracker.start
+    Nanoc::NotificationCenter.post(:visit_started, items[0])
+    Nanoc::NotificationCenter.post(:visit_started, items[1])
+    Nanoc::NotificationCenter.post(:visit_ended,   items[1])
+    Nanoc::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 = Nanoc::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 = Nanoc::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 = Nanoc::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 = Nanoc::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 = Nanoc::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 = Nanoc::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 = Nanoc::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 = Nanoc::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 = Nanoc::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