nanoc 3.8.0 → 4.0.0a1

data/test/base/test_item.rb

@@ -1,30 +1,32 @@
 # encoding: utf-8
 
-class Nanoc::ItemTest < Nanoc::TestCase
+class Nanoc::Int::ItemTest < Nanoc::TestCase
   def test_initialize_with_attributes_with_string_keys
-    item = Nanoc::Item.new('foo', { 'abc' => 'xyz' }, '/foo/')
+    item = Nanoc::Int::Item.new('foo', { 'abc' => 'xyz' }, '/foo/')
 
     assert_equal nil,   item.attributes['abc']
     assert_equal 'xyz', item.attributes[:abc]
   end
 
   def test_initialize_with_unclean_identifier
-    item = Nanoc::Item.new('foo', {}, '/foo')
+    item = Nanoc::Int::Item.new('foo', {}, '/foo')
 
-    assert_equal '/foo/', item.identifier
+    assert_equal '/foo/', item.identifier.to_s
   end
 
-  def test_frozen_identifier
-    item = Nanoc::Item.new('foo', {}, '/foo')
+  def test_reference
+    item = Nanoc::Int::Item.new(
+      'content',
+      { one: 'one in item' },
+      '/path/'
+    )
 
-    assert_raises_frozen_error do
-      item.identifier.chop!
-    end
+    assert_equal([:item, '/path/'], item.reference)
   end
 
   def test_lookup
     # Create item
-    item = Nanoc::Item.new(
+    item = Nanoc::Int::Item.new(
       'content',
       { one: 'one in item' },
       '/path/'
@@ -38,7 +40,7 @@ class Nanoc::ItemTest < Nanoc::TestCase
   end
 
   def test_set_attribute
-    item = Nanoc::Item.new('foo', {}, '/foo')
+    item = Nanoc::Int::Item.new('foo', {}, '/foo')
     assert_equal nil, item[:motto]
 
     item[:motto] = 'More human than human'
@@ -56,7 +58,7 @@ class Nanoc::ItemTest < Nanoc::TestCase
     end
 
     # Mock item
-    item = Nanoc::Item.new('foo', {}, '/foo')
+    item = Nanoc::Int::Item.new('foo', {}, '/foo')
     item.expects(:reps).returns([rep])
 
     # Check
@@ -74,7 +76,7 @@ class Nanoc::ItemTest < Nanoc::TestCase
     end
 
     # Mock item
-    item = Nanoc::Item.new('foo', {}, '/foo')
+    item = Nanoc::Int::Item.new('foo', {}, '/foo')
     item.expects(:reps).returns([rep])
 
     # Check
@@ -92,7 +94,7 @@ class Nanoc::ItemTest < Nanoc::TestCase
     end
 
     # Mock item
-    item = Nanoc::Item.new('foo', {}, '/foo')
+    item = Nanoc::Int::Item.new('foo', {}, '/foo')
     item.expects(:reps).returns([rep])
 
     # Check
@@ -101,11 +103,11 @@ class Nanoc::ItemTest < Nanoc::TestCase
 
   def test_compiled_content_with_custom_nonexistant_rep
     # Mock item
-    item = Nanoc::Item.new('foo', {}, '/foo')
+    item = Nanoc::Int::Item.new('foo', {}, '/foo')
     item.expects(:reps).returns([])
 
     # Check
-    assert_raises(Nanoc::Errors::Generic) do
+    assert_raises(Nanoc::Int::Errors::Generic) do
       item.compiled_content(rep: :lkasdhflahgwfe)
     end
   end
@@ -117,7 +119,7 @@ class Nanoc::ItemTest < Nanoc::TestCase
     rep.expects(:path).returns('the correct path')
 
     # Mock item
-    item = Nanoc::Item.new('foo', {}, '/foo')
+    item = Nanoc::Int::Item.new('foo', {}, '/foo')
     item.expects(:reps).returns([rep])
 
     # Check
@@ -131,7 +133,7 @@ class Nanoc::ItemTest < Nanoc::TestCase
     rep.expects(:path).returns('the correct path')
 
     # Mock item
-    item = Nanoc::Item.new('foo', {}, '/foo')
+    item = Nanoc::Int::Item.new('foo', {}, '/foo')
     item.expects(:reps).returns([rep])
 
     # Check
@@ -139,7 +141,7 @@ class Nanoc::ItemTest < Nanoc::TestCase
   end
 
   def test_freeze_should_disallow_changes
-    item = Nanoc::Item.new('foo', { a: { b: 123 } }, '/foo/')
+    item = Nanoc::Int::Item.new('foo', { a: { b: 123 } }, '/foo/')
     item.freeze
 
     assert_raises_frozen_error do
@@ -152,14 +154,14 @@ class Nanoc::ItemTest < Nanoc::TestCase
   end
 
   def test_dump_and_load
-    item = Nanoc::Item.new(
+    item = Nanoc::Int::Item.new(
       'foobar',
       { a: { b: 123 } },
       '/foo/')
 
     item = Marshal.load(Marshal.dump(item))
 
-    assert_equal '/foo/', item.identifier
+    assert_equal Nanoc::Identifier.new('/foo/'), item.identifier
     assert_equal 'foobar', item.raw_content
     assert_equal({ a: { b: 123 } }, item.attributes)
   end

data/test/base/test_item_array.rb

@@ -1,13 +1,13 @@
 # encoding: utf-8
 
-class Nanoc::ItemArrayTest < Nanoc::TestCase
+class Nanoc::Int::ItemArrayTest < Nanoc::TestCase
   def setup
     super
 
-    @one = Nanoc::Item.new('Item One', {}, '/one/')
-    @two = Nanoc::Item.new('Item Two', {}, '/two/')
+    @one = Nanoc::Int::Item.new('Item One', {}, '/one/')
+    @two = Nanoc::Int::Item.new('Item Two', {}, '/two/')
 
-    @items = Nanoc::ItemArray.new
+    @items = Nanoc::Int::ItemArray.new
     @items << @one
     @items << @two
   end
@@ -97,7 +97,7 @@ class Nanoc::ItemArrayTest < Nanoc::TestCase
   end
 
   def test_regex
-    foo = Nanoc::Item.new('Item Foo', {}, '/foo/')
+    foo = Nanoc::Int::Item.new('Item Foo', {}, '/foo/')
     @items << foo
 
     assert_equal [@one], @items[/n/]
@@ -108,7 +108,7 @@ class Nanoc::ItemArrayTest < Nanoc::TestCase
     assert_nil @items[2]
     assert_nil @items['/foo/']
 
-    foo = Nanoc::Item.new('Item Foo', {}, '/foo/')
+    foo = Nanoc::Int::Item.new('Item Foo', {}, '/foo/')
     @items << foo
 
     assert_equal foo, @items[2]
@@ -117,10 +117,10 @@ class Nanoc::ItemArrayTest < Nanoc::TestCase
 
   def test_assign
     assert_raises(TypeError) do
-      @items['/blah/'] = Nanoc::Item.new('Item blah', {}, '/blah/')
+      @items['/blah/'] = Nanoc::Int::Item.new('Item blah', {}, '/blah/')
     end
 
-    new_item =  Nanoc::Item.new('New Item One', {}, '/one-new/')
+    new_item =  Nanoc::Int::Item.new('New Item One', {}, '/one-new/')
     @items[0] = new_item
 
     assert_equal new_item, @items[0]
@@ -131,7 +131,7 @@ class Nanoc::ItemArrayTest < Nanoc::TestCase
   def test_assign_frozen
     @items.freeze
 
-    new_item = Nanoc::Item.new('New Item One', {}, '/one-new/')
+    new_item = Nanoc::Int::Item.new('New Item One', {}, '/one-new/')
 
     assert_raises_frozen_error do
       @items[0] = new_item
@@ -151,7 +151,7 @@ class Nanoc::ItemArrayTest < Nanoc::TestCase
 
   def test_collect_bang
     @items.collect! do |i|
-      Nanoc::Item.new("New #{i.raw_content}", {}, "/new#{i.identifier}")
+      Nanoc::Int::Item.new("New #{i.raw_content}", {}, "/new#{i.identifier}")
     end
 
     assert_nil @items['/one/']
@@ -169,13 +169,13 @@ class Nanoc::ItemArrayTest < Nanoc::TestCase
 
     assert_raises_frozen_error do
       @items.collect! do |i|
-        Nanoc::Item.new("New #{i.raw_content}", {}, "/new#{i.identifier}")
+        Nanoc::Int::Item.new("New #{i.raw_content}", {}, "/new#{i.identifier}")
       end
     end
   end
 
   def test_concat
-    new_item = Nanoc::Item.new('New item', {}, '/new/')
+    new_item = Nanoc::Int::Item.new('New item', {}, '/new/')
     @items.concat([new_item])
 
     assert_equal new_item, @items[2]
@@ -213,7 +213,7 @@ class Nanoc::ItemArrayTest < Nanoc::TestCase
   end
 
   def test_fill_all
-    @items.fill { |i| Nanoc::Item.new("Item #{i}", {}, "/new/#{i}/") }
+    @items.fill { |i| Nanoc::Int::Item.new("Item #{i}", {}, "/new/#{i}/") }
 
     assert_nil @items['/one/']
     assert_nil @items['/two/']
@@ -225,7 +225,7 @@ class Nanoc::ItemArrayTest < Nanoc::TestCase
   end
 
   def test_fill_range
-    @items.fill(1..-1) { |i| Nanoc::Item.new("Item #{i}", {}, "/new/#{i}/") }
+    @items.fill(1..-1) { |i| Nanoc::Int::Item.new("Item #{i}", {}, "/new/#{i}/") }
 
     assert_equal @one, @items['/one/']
     assert_nil @items['/two/']
@@ -260,7 +260,7 @@ class Nanoc::ItemArrayTest < Nanoc::TestCase
   end
 
   def test_push
-    pushy = Nanoc::Item.new('Pushy', {}, '/pushy/')
+    pushy = Nanoc::Int::Item.new('Pushy', {}, '/pushy/')
     @items.push(pushy)
 
     assert_equal @one, @items[0]
@@ -282,8 +282,8 @@ class Nanoc::ItemArrayTest < Nanoc::TestCase
   end
 
   def test_replace
-    max  = Nanoc::Item.new('Max', {}, '/max/')
-    mona = Nanoc::Item.new('Mona', {}, '/mona/')
+    max  = Nanoc::Int::Item.new('Max', {}, '/max/')
+    mona = Nanoc::Int::Item.new('Mona', {}, '/mona/')
 
     @items.replace([max, mona])
 
@@ -327,7 +327,7 @@ class Nanoc::ItemArrayTest < Nanoc::TestCase
   end
 
   def test_unshift
-    unshifty = Nanoc::Item.new('Unshifty', {}, '/unshifty/')
+    unshifty = Nanoc::Int::Item.new('Unshifty', {}, '/unshifty/')
     @items.unshift(unshifty)
 
     assert_equal unshifty, @items[0]

data/test/base/test_item_rep.rb

@@ -1,17 +1,17 @@
 # encoding: utf-8
 
-class Nanoc::ItemRepTest < Nanoc::TestCase
+class Nanoc::Int::ItemRepTest < Nanoc::TestCase
   def test_created_modified_compiled
     # TODO: implement
   end
 
   def test_compiled_content_with_only_last_available
     # Create rep
-    item = Nanoc::Item.new(
+    item = Nanoc::Int::Item.new(
       'blah blah blah', {}, '/',
       binary: false, mtime: Time.now - 500
     )
-    rep = Nanoc::ItemRep.new(item, nil)
+    rep = Nanoc::Int::ItemRep.new(item, nil)
     rep.instance_eval { @content = { last: 'last content' } }
     rep.expects(:compiled?).returns(true)
 
@@ -21,11 +21,11 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
 
   def test_compiled_content_with_pre_and_last_available
     # Create rep
-    item = Nanoc::Item.new(
+    item = Nanoc::Int::Item.new(
       'blah blah blah', {}, '/',
       binary: false, mtime: Time.now - 500
     )
-    rep = Nanoc::ItemRep.new(item, nil)
+    rep = Nanoc::Int::ItemRep.new(item, nil)
     rep.instance_eval { @content = { pre: 'pre content', last: 'last content' } }
     rep.expects(:compiled?).returns(true)
 
@@ -35,11 +35,11 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
 
   def test_compiled_content_with_custom_snapshot
     # Create rep
-    item = Nanoc::Item.new(
+    item = Nanoc::Int::Item.new(
       'blah blah blah', {}, '/',
       binary: false, mtime: Time.now - 500
     )
-    rep = Nanoc::ItemRep.new(item, nil)
+    rep = Nanoc::Int::ItemRep.new(item, nil)
     rep.instance_eval { @content = { pre: 'pre content', last: 'last content' } }
     rep.expects(:compiled?).returns(true)
 
@@ -49,57 +49,57 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
 
   def test_compiled_content_with_invalid_snapshot
     # Create rep
-    item = Nanoc::Item.new(
+    item = Nanoc::Int::Item.new(
       'blah blah blah', {}, '/',
       binary: false, mtime: Time.now - 500
     )
-    rep = Nanoc::ItemRep.new(item, nil)
+    rep = Nanoc::Int::ItemRep.new(item, nil)
     rep.instance_eval { @content = { pre: 'pre content', last: 'last content' } }
 
     # Check
-    assert_raises Nanoc::Errors::NoSuchSnapshot do
+    assert_raises Nanoc::Int::Errors::NoSuchSnapshot do
       rep.compiled_content(snapshot: :klsjflkasdfl)
     end
   end
 
   def test_compiled_content_with_uncompiled_content
     # Create rep
-    item = Nanoc::Item.new(
+    item = Nanoc::Int::Item.new(
       'blah blah', {}, '/',
       binary: false
     )
-    rep = Nanoc::ItemRep.new(item, nil)
+    rep = Nanoc::Int::ItemRep.new(item, nil)
     rep.expects(:compiled?).returns(false)
 
     # Check
-    assert_raises(Nanoc::Errors::UnmetDependency) do
+    assert_raises(Nanoc::Int::Errors::UnmetDependency) do
       rep.compiled_content
     end
   end
 
   def test_compiled_content_with_moving_pre_snapshot
     # Create rep
-    item = Nanoc::Item.new(
+    item = Nanoc::Int::Item.new(
       'blah blah', {}, '/',
       binary: false
     )
-    rep = Nanoc::ItemRep.new(item, nil)
+    rep = Nanoc::Int::ItemRep.new(item, nil)
     rep.expects(:compiled?).returns(false)
     rep.instance_eval { @content = { pre: 'pre!', last: 'last!' } }
 
     # Check
-    assert_raises(Nanoc::Errors::UnmetDependency) do
+    assert_raises(Nanoc::Int::Errors::UnmetDependency) do
       rep.compiled_content(snapshot: :pre)
     end
   end
 
   def test_compiled_content_with_non_moving_pre_snapshot
     # Create rep
-    item = Nanoc::Item.new(
+    item = Nanoc::Int::Item.new(
       'blah blah', {}, '/',
       binary: false
     )
-    rep = Nanoc::ItemRep.new(item, nil)
+    rep = Nanoc::Int::ItemRep.new(item, nil)
     rep.expects(:compiled?).returns(false)
     rep.snapshots = [[:pre, true]]
     rep.instance_eval { @content = { pre: 'pre!', post: 'post!', last: 'last!' } }
@@ -110,13 +110,13 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
 
   def test_compiled_content_with_final_pre_snapshot_in_layout
     # Mock layout
-    layout = Nanoc::Layout.new(
+    layout = Nanoc::Int::Layout.new(
       %(BEFORE <%= @item_rep.compiled_content(snapshot: :pre) %> AFTER),
       {},
       '/somelayout/')
 
     # Create item and item rep
-    item = Nanoc::Item.new(
+    item = Nanoc::Int::Item.new(
       'blah blah', {}, '/',
       binary: false
     )
@@ -136,13 +136,13 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
     site.expect(:layouts, [])
 
     # Mock item
-    item = Nanoc::Item.new(
+    item = Nanoc::Int::Item.new(
       %(<%= '<%= "blah" %' + '>' %>), {}, '/',
       binary: false
     )
 
     # Create item rep
-    item_rep = Nanoc::ItemRep.new(item, :foo)
+    item_rep = Nanoc::Int::ItemRep.new(item, :foo)
     item_rep.instance_eval do
       @content[:raw]  = item.raw_content
       @content[:last] = @content[:raw]
@@ -161,16 +161,16 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
 
   def test_layout
     # Mock layout
-    layout = Nanoc::Layout.new(%(<%= "blah" %>), {}, '/somelayout/')
+    layout = Nanoc::Int::Layout.new(%(<%= "blah" %>), {}, '/somelayout/')
 
     # Mock item
-    item = Nanoc::Item.new(
+    item = Nanoc::Int::Item.new(
       'blah blah', {}, '/',
       binary: false
     )
 
     # Create item rep
-    item_rep = Nanoc::ItemRep.new(item, :foo)
+    item_rep = Nanoc::Int::ItemRep.new(item, :foo)
     item_rep.instance_eval do
       @content[:raw]  = item.raw_content
       @content[:last] = @content[:raw]
@@ -190,13 +190,13 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
     site.expect(:layouts, [])
 
     # Mock item
-    item = Nanoc::Item.new(
+    item = Nanoc::Int::Item.new(
       %(<%= '<%= "blah" %' + '>' %>), {}, '/foobar/',
       binary: false
     )
 
     # Create item rep
-    item_rep = Nanoc::ItemRep.new(item, :foo)
+    item_rep = Nanoc::Int::ItemRep.new(item, :foo)
     item_rep.instance_eval do
       @content[:raw]  = item.raw_content
       @content[:last] = @content[:raw]
@@ -218,13 +218,13 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
 
   def test_snapshot_should_be_written
     # Mock item
-    item = Nanoc::Item.new(
+    item = Nanoc::Int::Item.new(
       'blah blah', {}, '/',
       binary: false
     )
 
     # Create rep
-    item_rep = Nanoc::ItemRep.new(item, :foo)
+    item_rep = Nanoc::Int::ItemRep.new(item, :foo)
     item_rep.instance_eval { @content[:last] = 'Lorem ipsum, etc.' }
     item_rep.raw_paths = { moo: 'foo-moo.txt' }
 
@@ -247,16 +247,16 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
 
   def test_write_should_not_touch_identical_textual_files
     # Mock item
-    item = Nanoc::Item.new(
+    item = Nanoc::Int::Item.new(
       'blah blah', {}, '/',
       binary: false
     )
 
     # Create rep
-    item_rep = Nanoc::ItemRep.new(item, :foo)
+    item_rep = Nanoc::Int::ItemRep.new(item, :foo)
     def item_rep.generate_diff; end
     item_rep.instance_eval { @content[:last] = 'Lorem ipsum, etc.' }
-    item_rep.raw_path = 'foo/bar/baz/quux.txt'
+    item_rep.raw_paths[:last] = 'foo/bar/baz/quux.txt'
 
     # Write once
     item_rep.write
@@ -271,15 +271,15 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
 
   def test_write
     # Mock item
-    item = Nanoc::Item.new(
+    item = Nanoc::Int::Item.new(
       'blah blah', {}, '/',
       binary: false
     )
 
     # Create rep
-    item_rep = Nanoc::ItemRep.new(item, :foo)
+    item_rep = Nanoc::Int::ItemRep.new(item, :foo)
     item_rep.instance_eval { @content[:last] = 'Lorem ipsum, etc.' }
-    item_rep.raw_path = 'foo/bar/baz/quux.txt'
+    item_rep.raw_paths[:last] = 'foo/bar/baz/quux.txt'
 
     # Write
     item_rep.write
@@ -291,13 +291,13 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
 
   def test_filter_text_to_binary
     # Mock item
-    item = Nanoc::Item.new(
+    item = Nanoc::Int::Item.new(
       'blah blah', {}, '/',
       binary: false
     )
 
     # Create rep
-    rep = Nanoc::ItemRep.new(item, :foo)
+    rep = Nanoc::Int::ItemRep.new(item, :foo)
     def rep.assigns
       {}
     end
@@ -321,13 +321,13 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
 
   def test_filter_with_textual_rep_and_binary_filter
     # Mock item
-    item = Nanoc::Item.new(
+    item = Nanoc::Int::Item.new(
       'blah blah', {}, '/',
       binary: false
     )
 
     # Create rep
-    rep = Nanoc::ItemRep.new(item, :foo)
+    rep = Nanoc::Int::ItemRep.new(item, :foo)
     def rep.assigns
       {}
     end
@@ -343,7 +343,7 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
     end
 
     # Run
-    assert_raises ::Nanoc::Errors::CannotUseBinaryFilter do
+    assert_raises ::Nanoc::Int::Errors::CannotUseBinaryFilter do
       rep.filter(:foo)
     end
   end
@@ -359,7 +359,7 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
     create_textual_filter
 
     assert rep.binary?
-    assert_raises(Nanoc::Errors::CannotUseTextualFilter) { rep.filter(:text_filter) }
+    assert_raises(Nanoc::Int::Errors::CannotUseTextualFilter) { rep.filter(:text_filter) }
   end
 
   def test_writing_binary_reps_uses_content_in_last_filename
@@ -383,7 +383,7 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
 
   def test_converted_binary_rep_can_be_layed_out
     # Mock layout
-    layout = Nanoc::Layout.new(%(<%= "blah" %> <%= yield %>), {}, '/somelayout/')
+    layout = Nanoc::Int::Layout.new(%(<%= "blah" %> <%= yield %>), {}, '/somelayout/')
 
     # Create item and item rep
     item = create_binary_item
@@ -464,7 +464,7 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
     end
     rep.filter(:binary_to_text)
     refute rep.binary?
-    assert_raises(Nanoc::Errors::CannotUseBinaryFilter) { rep.filter(:binary_filter) }
+    assert_raises(Nanoc::Int::Errors::CannotUseBinaryFilter) { rep.filter(:binary_filter) }
   end
 
   def test_new_content_should_be_frozen
@@ -475,8 +475,8 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
       end
     end
 
-    item = Nanoc::Item.new('foo bar', {}, '/foo/')
-    rep = Nanoc::ItemRep.new(item, :default)
+    item = Nanoc::Int::Item.new('foo bar', {}, '/foo/')
+    rep = Nanoc::Int::ItemRep.new(item, :default)
     rep.instance_eval { @filter_class = filter_class }
     def rep.filter_named(_name)
       @filter_class
@@ -495,8 +495,8 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
       end
     end
 
-    item = Nanoc::Item.new('foo bar', {}, '/foo/')
-    rep = Nanoc::ItemRep.new(item, :default)
+    item = Nanoc::Int::Item.new('foo bar', {}, '/foo/')
+    rep = Nanoc::Int::ItemRep.new(item, :default)
     rep.instance_eval { @filter_class = filter_class }
     def rep.filter_named(_name)
       @filter_class
@@ -510,19 +510,19 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
 
   def test_raw_path_should_generate_dependency
     items = [
-      Nanoc3::Item.new('foo', {}, '/foo/'),
-      Nanoc3::Item.new('bar', {}, '/bar/')
+      Nanoc::Int::Item.new('foo', {}, '/foo/'),
+      Nanoc::Int::Item.new('bar', {}, '/bar/')
     ]
     item_reps = [
-      Nanoc3::ItemRep.new(items[0], :default),
-      Nanoc3::ItemRep.new(items[1], :default)
+      Nanoc::Int::ItemRep.new(items[0], :default),
+      Nanoc::Int::ItemRep.new(items[1], :default)
     ]
 
-    dt = Nanoc3::DependencyTracker.new(items)
+    dt = Nanoc::Int::DependencyTracker.new(items)
     dt.start
-    Nanoc3::NotificationCenter.post(:visit_started, items[0])
+    Nanoc::Int::NotificationCenter.post(:visit_started, items[0])
     item_reps[1].raw_path
-    Nanoc3::NotificationCenter.post(:visit_ended,   items[0])
+    Nanoc::Int::NotificationCenter.post(:visit_ended,   items[0])
     dt.stop
 
     assert_equal [items[1]], dt.objects_causing_outdatedness_of(items[0])
@@ -530,28 +530,28 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
 
   def test_path_should_generate_dependency
     items = [
-      Nanoc3::Item.new('foo', {}, '/foo/'),
-      Nanoc3::Item.new('bar', {}, '/bar/')
+      Nanoc::Int::Item.new('foo', {}, '/foo/'),
+      Nanoc::Int::Item.new('bar', {}, '/bar/')
     ]
     item_reps = [
-      Nanoc3::ItemRep.new(items[0], :default),
-      Nanoc3::ItemRep.new(items[1], :default)
+      Nanoc::Int::ItemRep.new(items[0], :default),
+      Nanoc::Int::ItemRep.new(items[1], :default)
     ]
 
-    dt = Nanoc3::DependencyTracker.new(items)
+    dt = Nanoc::Int::DependencyTracker.new(items)
     dt.start
-    Nanoc3::NotificationCenter.post(:visit_started, items[0])
+    Nanoc::Int::NotificationCenter.post(:visit_started, items[0])
     item_reps[1].path
-    Nanoc3::NotificationCenter.post(:visit_ended,   items[0])
+    Nanoc::Int::NotificationCenter.post(:visit_ended,   items[0])
     dt.stop
 
     assert_equal [items[1]], dt.objects_causing_outdatedness_of(items[0])
   end
 
   def test_access_compiled_content_of_binary_item
-    item = Nanoc::Item.new('content/somefile.dat', {}, '/somefile/', binary: true)
-    item_rep = Nanoc::ItemRep.new(item, :foo)
-    assert_raises(Nanoc::Errors::CannotGetCompiledContentOfBinaryItem) do
+    item = Nanoc::Int::Item.new('content/somefile.dat', {}, '/somefile/', binary: true)
+    item_rep = Nanoc::Int::ItemRep.new(item, :foo)
+    assert_raises(Nanoc::Int::Errors::CannotGetCompiledContentOfBinaryItem) do
       item_rep.compiled_content
     end
   end
@@ -560,64 +560,64 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
     # Mock item
     FileUtils.mkdir_p('content')
     File.open('content/meow.dat', 'w') { |io| io.write('asdf') }
-    item = Nanoc::Item.new(
+    item = Nanoc::Int::Item.new(
       'content/meow.dat', {}, '/',
       binary: true
     )
 
     # Create rep
-    item_rep = Nanoc::ItemRep.new(item, :foo)
+    item_rep = Nanoc::Int::ItemRep.new(item, :foo)
     FileUtils.mkdir_p('tmp')
     File.open('tmp/woof.dat', 'w') { |io| io.write('fdsa') }
     item_rep.instance_eval { @temporary_filenames[:last] = 'tmp/woof.dat' }
-    item_rep.raw_path = 'output/woof.dat'
+    item_rep.raw_paths[:last] = 'output/woof.dat'
 
     # Write
     notified = false
-    Nanoc::NotificationCenter.on(:rep_written, self) do |_rep, _raw_path, is_created, is_modified|
+    Nanoc::Int::NotificationCenter.on(:rep_written, self) do |_rep, _raw_path, is_created, is_modified|
       notified = true
       assert is_created
       assert is_modified
     end
     item_rep.write
     assert notified
-    Nanoc::NotificationCenter.remove(:rep_written, self)
+    Nanoc::Int::NotificationCenter.remove(:rep_written, self)
   end
 
   def test_write_should_calculate_is_modified_correctly_for_binary_items_existing
     # Mock item
     FileUtils.mkdir_p('content')
     File.open('content/meow.dat', 'w') { |io| io.write('asdf') }
-    item = Nanoc::Item.new(
+    item = Nanoc::Int::Item.new(
       'content/meow.dat', {}, '/',
       binary: true
     )
 
     # Create rep
-    item_rep = Nanoc::ItemRep.new(item, :foo)
+    item_rep = Nanoc::Int::ItemRep.new(item, :foo)
     FileUtils.mkdir_p('tmp')
     File.open('tmp/woof.dat', 'w') { |io| io.write('fdsa') }
     FileUtils.mkdir_p('output')
     File.open('output/woof.dat', 'w') { |io| io.write('fdsa but different') }
     item_rep.instance_eval { @temporary_filenames[:last] = 'tmp/woof.dat' }
-    item_rep.raw_path = 'output/woof.dat'
+    item_rep.raw_paths[:last] = 'output/woof.dat'
 
     # Write
     notified = false
-    Nanoc::NotificationCenter.on(:rep_written, self) do |_rep, _raw_path, is_created, is_modified|
+    Nanoc::Int::NotificationCenter.on(:rep_written, self) do |_rep, _raw_path, is_created, is_modified|
       notified = true
       refute is_created
       assert is_modified
     end
     item_rep.write
     assert notified
-    Nanoc::NotificationCenter.remove(:rep_written, self)
+    Nanoc::Int::NotificationCenter.remove(:rep_written, self)
   end
 
   private
 
   def create_binary_item
-    Nanoc::Item.new(
+    Nanoc::Int::Item.new(
       '/a/file/name.dat', {}, '/',
       binary: true
     )
@@ -632,7 +632,7 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
   end
 
   def create_rep_for(item, name)
-    Nanoc::ItemRep.new(item, name)
+    Nanoc::Int::ItemRep.new(item, name)
   end
 
   def create_textual_filter