nanoc 4.0.0b3 → 4.0.0b4

data/lib/nanoc/cli/commands/create-site.rb

@@ -1,8 +1,8 @@
 usage 'create-site [options] path'
 aliases :create_site, :cs
 summary 'create a site'
-description "Create a new site at the given path. The site will use the `filesystem` data source."
-flag nil, :force, "Force creation of new site. Disregards previous existence of site in destination"
+description 'Create a new site at the given path. The site will use the `filesystem` data source.'
+flag nil, :force, 'Force creation of new site. Disregards previous existence of site in destination'
 
 module Nanoc::CLI::Commands
   class CreateSite < ::Nanoc::CLI::CommandRunner
@@ -288,10 +288,10 @@ EOS
       path = arguments[0]
 
       # Check whether site exists
-      if File.exist?(path) && (!File.directory?(path) || !(Dir.entries(path) - %w{ . .. }).empty?) && !options[:force]
+      if File.exist?(path) && (!File.directory?(path) || !(Dir.entries(path) - %w(. ..)).empty?) && !options[:force]
         raise Nanoc::Int::Errors::GenericTrivial,
-          "The site was not created because '#{path}' already exists. " +
-          "Re-run the command using --force to create the site anyway."
+          "The site was not created because '#{path}' already exists. " \
+          'Re-run the command using --force to create the site anyway.'
       end
 
       # Setup notifications

data/lib/nanoc/cli/commands/show-data.rb

@@ -64,8 +64,18 @@ module Nanoc::CLI::Commands
         puts "item #{item.identifier} depends on:"
         predecessors = dependency_tracker.objects_causing_outdatedness_of(item).sort_by { |i| i ? i.identifier : '' }
         predecessors.each do |pred|
+          type =
+            case pred
+            when Nanoc::Int::Layout
+              'layout'
+            when Nanoc::Int::ItemRep
+              'item rep'
+            when Nanoc::Int::Item
+              'item'
+            end
+
           if pred
-            puts "  [ #{format '%6s', pred.type} ] #{pred.identifier}"
+            puts "  [ #{format '%6s', type} ] #{pred.identifier}"
           else
             puts '  ( removed item )'
           end

data/lib/nanoc/data_sources/filesystem.rb

@@ -45,7 +45,7 @@ module Nanoc::DataSources
     def load_objects(dir_name, kind, klass)
       res = []
 
-     return [] if dir_name.nil?
+      return [] if dir_name.nil?
 
       all_split_files_in(dir_name).each do |base_filename, (meta_ext, content_exts)|
         content_exts.each do |content_ext|
@@ -73,10 +73,10 @@ module Nanoc::DataSources
           }.merge(meta)
 
           # Get identifier
-          if meta_filename
-            identifier = identifier_for_filename(meta_filename[dir_name.length..-1])
-          elsif content_filename
+          if content_filename
             identifier = identifier_for_filename(content_filename[dir_name.length..-1])
+          elsif meta_filename
+            identifier = identifier_for_filename(meta_filename[dir_name.length..-1])
           else
             raise 'meta_filename and content_filename are both nil'
           end
@@ -93,12 +93,19 @@ module Nanoc::DataSources
           else
             raise 'meta_mtime and content_mtime are both nil'
           end
-
-          # Create layout object
-          res << klass.new(
-            content_or_filename, attributes, identifier,
-            binary: is_binary, mtime: mtime
-          )
+          attributes[:mtime] = mtime
+
+          # Create content
+          full_content_filename = content_filename && File.expand_path(content_filename)
+          content =
+            if is_binary
+              Nanoc::Int::BinaryContent.new(full_content_filename)
+            else
+              Nanoc::Int::TextualContent.new(content_or_filename, filename: full_content_filename)
+            end
+
+          # Create object
+          res << klass.new(content, attributes, identifier)
         end
       end
 

data/lib/nanoc/helpers/capturing.rb

@@ -113,8 +113,7 @@ module Nanoc::Helpers
             @site.unwrap.captures_store_compiled_items << item
             item.forced_outdated = true
             item.reps.each do |r|
-              raw_content = item.raw_content
-              r.content = { raw: raw_content, last: raw_content }
+              r.content_snapshots = { last: item.content }
               raise Nanoc::Int::Errors::UnmetDependency.new(r)
             end
           end

data/lib/nanoc/helpers/filtering.rb

@@ -31,7 +31,19 @@ module Nanoc::Helpers
       # Find filter
       klass = Nanoc::Filter.named(filter_name)
       raise Nanoc::Int::Errors::UnknownFilter.new(filter_name) if klass.nil?
-      filter = klass.new(@item_rep.unwrap.assigns)
+
+      # Create filter
+      assigns = {
+        item: @item,
+        rep: @rep,
+        item_rep: @item_rep,
+        items: @items,
+        layouts: @layouts,
+        config: @config,
+        site: @site,
+        content: @content,
+      }
+      filter = klass.new(assigns)
 
       # Filter captured data
       Nanoc::Int::NotificationCenter.post(:filtering_started, @item_rep.unwrap, filter_name)

data/lib/nanoc/helpers/rendering.rb

@@ -92,7 +92,7 @@ module Nanoc::Helpers
         item: @item,
         item_rep: @item_rep,
         items: @items,
-        layout: Nanoc::LayoutView.new(layout),
+        layout: Nanoc::LayoutView.new(layout), # FIXME: this does not need to be rewrapped
         layouts: @layouts,
         config: @config,
         site: @site
@@ -114,7 +114,9 @@ module Nanoc::Helpers
         Nanoc::Int::NotificationCenter.post(:processing_started, layout)
 
         # Layout
-        result = filter.setup_and_run(layout.raw_content, filter_args)
+        content = layout.unwrap.content
+        arg = content.binary? ? content.filename : content.string
+        result = filter.setup_and_run(arg, filter_args)
 
         # Append to erbout if we have a block
         if block_given?

data/lib/nanoc/version.rb

@@ -1,4 +1,4 @@
 module Nanoc
   # The current nanoc version.
-  VERSION = '4.0.0b3'
+  VERSION = '4.0.0b4'
 end

data/test/base/core_ext/array_spec.rb

@@ -38,10 +38,3 @@ describe 'Array#__nanoc_freeze_recursively' do
     assert_equal a, a[0]
   end
 end
-
-describe 'Array#__nanoc_checksum' do
-  it 'should work' do
-    expectation = 'CEUlNvu/3DUmlbtpFRiLHU8oHA0='
-    [[:foo, 123]].__nanoc_checksum.must_equal expectation
-  end
-end

data/test/base/core_ext/hash_spec.rb

@@ -44,16 +44,3 @@ describe 'Hash#__nanoc_freeze_recursively' do
     assert_equal a, a[:x]
   end
 end
-
-describe 'Hash#__nanoc_checksum' do
-  it 'should work' do
-    expectation = 'wy7gHokc700tqJ/BmJ+EK6/F0bc='
-    { foo: 123 }.__nanoc_checksum.must_equal expectation
-  end
-
-  it 'should not sort keys' do
-    a = { a: 1, c: 2, b: 3 }.__nanoc_checksum
-    b = { a: 1, b: 3, c: 2 }.__nanoc_checksum
-    a.wont_equal b
-  end
-end

data/test/base/core_ext/pathname_spec.rb

@@ -1,33 +0,0 @@
-describe 'Pathname#checksum' do
-  it 'should work on empty files' do
-    begin
-      # Create file
-      FileUtils.mkdir_p('tmp')
-      File.open('tmp/myfile', 'w') { |io| io.write('') }
-      timestamp = Time.at(1_234_569)
-      File.utime(timestamp, timestamp, 'tmp/myfile')
-
-      # Create checksum
-      pathname = Pathname.new('tmp/myfile')
-      pathname.__nanoc_checksum.must_equal 'oU+0fYgGm4EDTl+uErBv8rB9YhU='
-    ensure
-      FileUtils.rm_rf('tmp')
-    end
-  end
-
-  it 'should work on all files' do
-    begin
-      # Create file
-      FileUtils.mkdir_p('tmp')
-      File.open('tmp/myfile', 'w') { |io| io.write('abc') }
-      timestamp = Time.at(1_234_569)
-      File.utime(timestamp, timestamp, 'tmp/myfile')
-
-      # Create checksum
-      pathname = Pathname.new('tmp/myfile')
-      pathname.__nanoc_checksum.must_equal 'IAoqYXvcDheQjaYmZ8waPtEO8zU='
-    ensure
-      FileUtils.rm_rf('tmp')
-    end
-  end
-end

data/test/base/core_ext/string_spec.rb

@@ -19,13 +19,3 @@ describe 'String#__nanoc_cleaned_identifier' do
     '/foo/bar//'.__nanoc_cleaned_identifier.must_equal '/foo/bar/'
   end
 end
-
-describe 'String#__nanoc_checksum' do
-  it 'should work on empty strings' do
-    ''.__nanoc_checksum.must_equal 'PfY7essFItpoXa1f6EuB/deyUmQ='
-  end
-
-  it 'should work on all strings' do
-    'abc'.__nanoc_checksum.must_equal 'NkkYRO+25f6psNSeCYykXKCg3C0='
-  end
-end

data/test/base/test_compiler_dsl.rb

@@ -60,7 +60,7 @@ class Nanoc::Int::CompilerDSLTest < Nanoc::TestCase
 
       # Apply preprocess blocks
       site.compiler.preprocess
-      assert item[:preprocessed]
+      assert item.attributes[:preprocessed]
     end
   end
 
@@ -286,7 +286,7 @@ EOS
   def test_create_pattern_with_regex
     compiler_dsl = Nanoc::Int::CompilerDSL.new(nil, { string_pattern_type: 'glob' })
 
-    pattern = compiler_dsl.create_pattern(%r<\A/foo/a*/>)
+    pattern = compiler_dsl.create_pattern(%r{\A/foo/a*/})
     assert pattern.match?('/foo/aaaa/')
   end
 
@@ -396,7 +396,7 @@ EOS
     assert_equal(expected.casefold?, actual.casefold?)
     assert_equal(expected.options,   actual.options)
     assert('/foo/bar/' =~ actual)
-    refute('/foo/'     =~ actual)
+    refute('/foo/' =~ actual)
   end
 
   def test_dsl_has_no_access_to_compiler

data/test/base/test_data_source.rb

@@ -34,7 +34,7 @@ class Nanoc::DataSourceTest < Nanoc::TestCase
     data_source = Nanoc::DataSource.new(nil, nil, nil, nil)
 
     item = data_source.new_item('stuff', { title: 'Stuff!' }, '/asdf/')
-    assert_equal 'stuff', item.raw_content
+    assert_equal 'stuff', item.content.string
     assert_equal 'Stuff!', item.attributes[:title]
     assert_equal Nanoc::Identifier.new('/asdf/'), item.identifier
   end
@@ -43,7 +43,7 @@ class Nanoc::DataSourceTest < Nanoc::TestCase
     data_source = Nanoc::DataSource.new(nil, nil, nil, nil)
 
     layout = data_source.new_layout('stuff', { title: 'Stuff!' }, '/asdf/')
-    assert_equal 'stuff', layout.raw_content
+    assert_equal 'stuff', layout.content.string
     assert_equal 'Stuff!', layout.attributes[:title]
     assert_equal Nanoc::Identifier.new('/asdf/'), layout.identifier
   end

data/test/base/test_item.rb

@@ -16,120 +16,9 @@ class Nanoc::Int::ItemTest < Nanoc::TestCase
     assert_equal([:item, '/path/'], item.reference)
   end
 
-  def test_lookup
-    # Create item
-    item = Nanoc::Int::Item.new(
-      'content',
-      { one: 'one in item' },
-      '/path/'
-    )
-
-    # Test finding one
-    assert_equal('one in item', item[:one])
-
-    # Test finding two
-    assert_equal(nil, item[:two])
-  end
-
-  def test_set_attribute
-    item = Nanoc::Int::Item.new('foo', {}, '/foo')
-    assert_equal nil, item[:motto]
-
-    item[:motto] = 'More human than human'
-    assert_equal 'More human than human', item[:motto]
-  end
-
-  def test_compiled_content_with_default_rep_and_default_snapshot
-    # Mock rep
-    rep = Object.new
-    def rep.name
-      :default
-    end
-    def rep.compiled_content(params)
-      "content at #{params[:snapshot].inspect}"
-    end
-
-    # Mock item
-    item = Nanoc::Int::Item.new('foo', {}, '/foo')
-    item.expects(:reps).returns([rep])
-
-    # Check
-    assert_equal 'content at nil', item.compiled_content
-  end
-
-  def test_compiled_content_with_custom_rep_and_default_snapshot
-    # Mock reps
-    rep = Object.new
-    def rep.name
-      :foo
-    end
-    def rep.compiled_content(params)
-      "content at #{params[:snapshot].inspect}"
-    end
-
-    # Mock item
-    item = Nanoc::Int::Item.new('foo', {}, '/foo')
-    item.expects(:reps).returns([rep])
-
-    # Check
-    assert_equal 'content at nil', item.compiled_content(rep: :foo)
-  end
-
-  def test_compiled_content_with_default_rep_and_custom_snapshot
-    # Mock reps
-    rep = Object.new
-    def rep.name
-      :default
-    end
-    def rep.compiled_content(params)
-      "content at #{params[:snapshot].inspect}"
-    end
-
-    # Mock item
-    item = Nanoc::Int::Item.new('foo', {}, '/foo')
-    item.expects(:reps).returns([rep])
-
-    # Check
-    assert_equal 'content at :blah', item.compiled_content(snapshot: :blah)
-  end
-
-  def test_compiled_content_with_custom_nonexistant_rep
-    # Mock item
-    item = Nanoc::Int::Item.new('foo', {}, '/foo')
-    item.expects(:reps).returns([])
-
-    # Check
-    assert_raises(Nanoc::Int::Errors::Generic) do
-      item.compiled_content(rep: :lkasdhflahgwfe)
-    end
-  end
-
-  def test_path_with_default_rep
-    # Mock reps
-    rep = mock
-    rep.expects(:name).returns(:default)
-    rep.expects(:path).returns('the correct path')
-
-    # Mock item
-    item = Nanoc::Int::Item.new('foo', {}, '/foo')
-    item.expects(:reps).returns([rep])
-
-    # Check
-    assert_equal 'the correct path', item.path
-  end
-
-  def test_path_with_custom_rep
-    # Mock reps
-    rep = mock
-    rep.expects(:name).returns(:moo)
-    rep.expects(:path).returns('the correct path')
-
-    # Mock item
-    item = Nanoc::Int::Item.new('foo', {}, '/foo')
-    item.expects(:reps).returns([rep])
-
-    # Check
-    assert_equal 'the correct path', item.path(rep: :moo)
+  def test_attributes
+    item = Nanoc::Int::Item.new('content', { 'one' => 'one in item' }, '/path/')
+    assert_equal({ one: 'one in item' }, item.attributes)
   end
 
   def test_freeze_should_disallow_changes
@@ -137,24 +26,11 @@ class Nanoc::Int::ItemTest < Nanoc::TestCase
     item.freeze
 
     assert_raises_frozen_error do
-      item[:abc] = '123'
+      item.attributes[:abc] = '123'
     end
 
     assert_raises_frozen_error do
-      item[:a][:b] = '456'
+      item.attributes[:a][:b] = '456'
     end
   end
-
-  def test_dump_and_load
-    item = Nanoc::Int::Item.new(
-      'foobar',
-      { a: { b: 123 } },
-      '/foo/')
-
-    item = Marshal.load(Marshal.dump(item))
-
-    assert_equal Nanoc::Identifier.new('/foo/'), item.identifier
-    assert_equal 'foobar', item.raw_content
-    assert_equal({ a: { b: 123 } }, item.attributes)
-  end
 end

data/test/base/test_item_rep.rb

@@ -1,16 +1,13 @@
 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::Int::Item.new(
       'blah blah blah', {}, '/',
-      binary: false, mtime: Time.now - 500
     )
     rep = Nanoc::Int::ItemRep.new(item, nil)
-    rep.instance_eval { @content = { last: 'last content' } }
+    rep.content_snapshots = {
+      last: Nanoc::Int::TextualContent.new('last content'),
+    }
     rep.expects(:compiled?).returns(true)
 
     # Check
@@ -21,10 +18,12 @@ class Nanoc::Int::ItemRepTest < Nanoc::TestCase
     # Create rep
     item = Nanoc::Int::Item.new(
       'blah blah blah', {}, '/',
-      binary: false, mtime: Time.now - 500
     )
     rep = Nanoc::Int::ItemRep.new(item, nil)
-    rep.instance_eval { @content = { pre: 'pre content', last: 'last content' } }
+    rep.content_snapshots = {
+      pre: Nanoc::Int::TextualContent.new('pre content'),
+      last: Nanoc::Int::TextualContent.new('last content'),
+    }
     rep.expects(:compiled?).returns(true)
 
     # Check
@@ -35,10 +34,12 @@ class Nanoc::Int::ItemRepTest < Nanoc::TestCase
     # Create rep
     item = Nanoc::Int::Item.new(
       'blah blah blah', {}, '/',
-      binary: false, mtime: Time.now - 500
     )
     rep = Nanoc::Int::ItemRep.new(item, nil)
-    rep.instance_eval { @content = { pre: 'pre content', last: 'last content' } }
+    rep.content_snapshots = {
+      pre: Nanoc::Int::TextualContent.new('pre content'),
+      last: Nanoc::Int::TextualContent.new('last content'),
+    }
     rep.expects(:compiled?).returns(true)
 
     # Check
@@ -49,10 +50,12 @@ class Nanoc::Int::ItemRepTest < Nanoc::TestCase
     # Create rep
     item = Nanoc::Int::Item.new(
       'blah blah blah', {}, '/',
-      binary: false, mtime: Time.now - 500
     )
     rep = Nanoc::Int::ItemRep.new(item, nil)
-    rep.instance_eval { @content = { pre: 'pre content', last: 'last content' } }
+    rep.content_snapshots = {
+      pre: Nanoc::Int::TextualContent.new('pre content'),
+      last: Nanoc::Int::TextualContent.new('last content'),
+    }
 
     # Check
     assert_raises Nanoc::Int::Errors::NoSuchSnapshot do
@@ -64,7 +67,6 @@ class Nanoc::Int::ItemRepTest < Nanoc::TestCase
     # Create rep
     item = Nanoc::Int::Item.new(
       'blah blah', {}, '/',
-      binary: false
     )
     rep = Nanoc::Int::ItemRep.new(item, nil)
     rep.expects(:compiled?).returns(false)
@@ -79,11 +81,13 @@ class Nanoc::Int::ItemRepTest < Nanoc::TestCase
     # Create rep
     item = Nanoc::Int::Item.new(
       'blah blah', {}, '/',
-      binary: false
     )
     rep = Nanoc::Int::ItemRep.new(item, nil)
     rep.expects(:compiled?).returns(false)
-    rep.instance_eval { @content = { pre: 'pre!', last: 'last!' } }
+    rep.content_snapshots = {
+      pre: Nanoc::Int::TextualContent.new('pre!'),
+      last: Nanoc::Int::TextualContent.new('last!'),
+    }
 
     # Check
     assert_raises(Nanoc::Int::Errors::UnmetDependency) do
@@ -95,568 +99,32 @@ class Nanoc::Int::ItemRepTest < Nanoc::TestCase
     # Create rep
     item = Nanoc::Int::Item.new(
       'blah blah', {}, '/',
-      binary: false
     )
     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!' } }
+    rep.content_snapshots = {
+      pre: Nanoc::Int::TextualContent.new('pre!'),
+      post: Nanoc::Int::TextualContent.new('post!'),
+      last: Nanoc::Int::TextualContent.new('last!'),
+    }
 
     # Check
     assert_equal 'pre!', rep.compiled_content(snapshot: :pre)
   end
 
-  def test_compiled_content_with_final_pre_snapshot_in_layout
-    # Mock layout
-    layout = Nanoc::Int::Layout.new(
-      %(BEFORE <%= @item_rep.compiled_content(snapshot: :pre) %> AFTER),
-      {},
-      '/somelayout/')
-
-    # Create item and item rep
-    item = Nanoc::Int::Item.new(
-      'blah blah', {}, '/',
-      binary: false
-    )
-    rep = create_rep_for(item, :foo)
-    rep.assigns = { item_rep: rep }
-
-    # Run and check
-    rep.layout(layout, :erb, {})
-    assert_equal('BEFORE blah blah AFTER', rep.instance_eval { @content[:last] })
-  end
-
-  def test_filter
-    # Mock site
-    site = MiniTest::Mock.new
-    site.expect(:items, [])
-    site.expect(:config, [])
-    site.expect(:layouts, [])
-
-    # Mock item
-    item = Nanoc::Int::Item.new(
-      %(<%= '<%= "blah" %' + '>' %>), {}, '/',
-      binary: false
-    )
-
-    # Create item rep
-    item_rep = Nanoc::Int::ItemRep.new(item, :foo)
-    item_rep.instance_eval do
-      @content[:raw]  = item.raw_content
-      @content[:last] = @content[:raw]
-    end
-
-    # Filter once
-    item_rep.assigns = {}
-    item_rep.filter(:erb)
-    assert_equal(%(<%= "blah" %>), item_rep.instance_eval { @content[:last] })
-
-    # Filter twice
-    item_rep.assigns = {}
-    item_rep.filter(:erb)
-    assert_equal(%(blah), item_rep.instance_eval { @content[:last] })
-  end
-
-  def test_layout
-    # Mock layout
-    layout = Nanoc::Int::Layout.new(%(<%= "blah" %>), {}, '/somelayout/')
-
-    # Mock item
-    item = Nanoc::Int::Item.new(
-      'blah blah', {}, '/',
-      binary: false
-    )
-
-    # Create item rep
-    item_rep = Nanoc::Int::ItemRep.new(item, :foo)
-    item_rep.instance_eval do
-      @content[:raw]  = item.raw_content
-      @content[:last] = @content[:raw]
-    end
-
-    # Layout
-    item_rep.assigns = {}
-    item_rep.layout(layout, :erb, {})
-    assert_equal(%(blah), item_rep.instance_eval { @content[:last] })
-  end
-
-  def test_snapshot
-    # Mock site
-    site = MiniTest::Mock.new
-    site.expect(:items, [])
-    site.expect(:config, [])
-    site.expect(:layouts, [])
-
-    # Mock item
-    item = Nanoc::Int::Item.new(
-      %(<%= '<%= "blah" %' + '>' %>), {}, '/foobar/',
-      binary: false
-    )
-
-    # Create item rep
-    item_rep = Nanoc::Int::ItemRep.new(item, :foo)
-    item_rep.instance_eval do
-      @content[:raw]  = item.raw_content
-      @content[:last] = @content[:raw]
-    end
-
-    # Filter while taking snapshots
-    item_rep.assigns = {}
-    item_rep.snapshot(:foo)
-    item_rep.filter(:erb)
-    item_rep.snapshot(:bar)
-    item_rep.filter(:erb)
-    item_rep.snapshot(:qux)
-
-    # Check snapshots
-    assert_equal(%(<%= '<%= "blah" %' + '>' %>), item_rep.instance_eval { @content[:foo] })
-    assert_equal(%(<%= "blah" %>),               item_rep.instance_eval { @content[:bar] })
-    assert_equal(%(blah),                        item_rep.instance_eval { @content[:qux] })
-  end
-
-  def test_snapshot_should_be_written
-    # Mock item
-    item = Nanoc::Int::Item.new(
-      'blah blah', {}, '/',
-      binary: false
-    )
-
-    # Create rep
-    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' }
-
-    # Test non-final
-    refute File.file?(item_rep.raw_path(snapshot: :moo))
-    item_rep.snapshot(:moo, final: false)
-    refute File.file?(item_rep.raw_path(snapshot: :moo))
-
-    # Test final 1
-    item_rep.snapshot(:moo, final: true)
-    assert File.file?(item_rep.raw_path(snapshot: :moo))
-    assert_equal 'Lorem ipsum, etc.', File.read(item_rep.raw_path(snapshot: :moo))
-    FileUtils.rm_f(item_rep.raw_path(snapshot: :moo))
-
-    # Test final 2
-    item_rep.snapshot(:moo)
-    assert File.file?(item_rep.raw_path(snapshot: :moo))
-    assert_equal 'Lorem ipsum, etc.', File.read(item_rep.raw_path(snapshot: :moo))
-  end
-
-  def test_write_should_not_touch_identical_textual_files
-    # Mock item
-    item = Nanoc::Int::Item.new(
-      'blah blah', {}, '/',
-      binary: false
-    )
-
-    # Create rep
-    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_paths[:last] = 'foo/bar/baz/quux.txt'
-
-    # Write once
-    item_rep.write
-    a_long_time_ago = Time.now - 1_000_000
-    File.utime(a_long_time_ago, a_long_time_ago, item_rep.raw_path)
-
-    # Write again
-    assert_equal a_long_time_ago.to_s, File.mtime(item_rep.raw_path).to_s
-    item_rep.write
-    assert_equal a_long_time_ago.to_s, File.mtime(item_rep.raw_path).to_s
-  end
-
-  def test_write
-    # Mock item
-    item = Nanoc::Int::Item.new(
-      'blah blah', {}, '/',
-      binary: false
-    )
-
-    # Create rep
-    item_rep = Nanoc::Int::ItemRep.new(item, :foo)
-    item_rep.instance_eval { @content[:last] = 'Lorem ipsum, etc.' }
-    item_rep.raw_paths[:last] = 'foo/bar/baz/quux.txt'
-
-    # Write
-    item_rep.write
-
-    # Check
-    assert(File.file?('foo/bar/baz/quux.txt'))
-    assert_equal('Lorem ipsum, etc.', File.read('foo/bar/baz/quux.txt'))
-  end
-
-  def test_filter_text_to_binary
-    # Mock item
-    item = Nanoc::Int::Item.new(
-      'blah blah', {}, '/',
-      binary: false
-    )
-
-    # Create rep
-    rep = Nanoc::Int::ItemRep.new(item, :foo)
-    def rep.assigns
-      {}
-    end
-
-    # Create fake filter
-    def rep.filter_named(_name)
-      @filter ||= Class.new(::Nanoc::Filter) do
-        type text: :binary
-        def run(content, _params = {})
-          File.open(output_filename, 'w') { |io| io.write(content) }
-        end
-      end
-    end
-
-    # Run
-    rep.filter(:foo)
-
-    # Check
-    assert rep.binary?
-  end
-
-  def test_filter_with_textual_rep_and_binary_filter
-    # Mock item
-    item = Nanoc::Int::Item.new(
-      'blah blah', {}, '/',
-      binary: false
-    )
-
-    # Create rep
-    rep = Nanoc::Int::ItemRep.new(item, :foo)
-    def rep.assigns
-      {}
-    end
-
-    # Create fake filter
-    def rep.filter_named(_name)
-      @filter ||= Class.new(::Nanoc::Filter) do
-        type :binary
-        def run(content, _params = {})
-          File.open(output_filename, 'w') { |io| io.write(content) }
-        end
-      end
-    end
-
-    # Run
-    assert_raises ::Nanoc::Int::Errors::CannotUseBinaryFilter do
-      rep.filter(:foo)
-    end
-  end
-
-  def test_using_textual_filters_on_binary_reps_raises
-    item = create_binary_item
-    site = mock_and_stub(items: [item],
-      layouts: [],
-      config: []
-    )
-    item.stubs(:site).returns(site)
-    rep = create_rep_for(item, :foo)
-    create_textual_filter
-
-    assert rep.binary?
-    assert_raises(Nanoc::Int::Errors::CannotUseTextualFilter) { rep.filter(:text_filter) }
-  end
-
-  def test_writing_binary_reps_uses_content_in_last_filename
-    require 'tempfile'
-
-    in_filename  = 'nanoc-in'
-    out_filename = 'nanoc-out'
-    file_content = 'Some content for this test'
-    File.open(in_filename, 'w') { |io| io.write(file_content) }
-
-    item = create_binary_item
-    rep = create_rep_for(item, :foo)
-    rep.temporary_filenames[:last] = in_filename
-    rep.raw_paths[:last]           = out_filename
-
-    rep.write
-
-    assert(File.exist?(out_filename))
-    assert_equal(file_content, File.read(out_filename))
-  end
-
-  def test_converted_binary_rep_can_be_layed_out
-    # Mock layout
-    layout = Nanoc::Int::Layout.new(%(<%= "blah" %> <%= yield %>), {}, '/somelayout/')
-
-    # Create item and item rep
-    item = create_binary_item
-    rep = create_rep_for(item, :foo)
-    rep.assigns = { content: 'meh' }
-
-    # Create filter
-    Class.new(::Nanoc::Filter) do
-      type binary: :text
-      identifier :binary_to_text
-      def run(content, _params = {})
-        content + ' textified'
-      end
-    end
-
-    # Run and check
-    rep.filter(:binary_to_text)
-    rep.layout(layout, :erb, {})
-    assert_equal('blah meh', rep.instance_eval { @content[:last] })
-  end
-
-  def test_converted_binary_rep_can_be_filtered_with_textual_filters
-    item = create_binary_item
-    site = mock_and_stub(items: [item],
-      layouts: [],
-      config: []
-    )
-    item.stubs(:site).returns(site)
-    rep = create_rep_for(item, :foo)
-    rep.assigns = {}
-    create_textual_filter
-
-    assert rep.binary?
-
-    def rep.filter_named(_name)
-      Class.new(::Nanoc::Filter) do
-        type binary: :text
-        def run(_content, _params = {})
-          'Some textual content'
-        end
-      end
-    end
-    rep.filter(:binary_to_text)
-    assert !rep.binary?
-
-    def rep.filter_named(_name)
-      Class.new(::Nanoc::Filter) do
-        type :text
-        def run(_content, _params = {})
-          'Some textual content'
-        end
-      end
-    end
-    rep.filter(:text_filter)
-    assert !rep.binary?
-  end
-
-  def test_converted_binary_rep_cannot_be_filtered_with_binary_filters
-    item = create_binary_item
-    site = mock_and_stub(
-      items: [item],
-      layouts: [],
-      config: []
-    )
-    item.stubs(:site).returns(site)
-    rep = create_rep_for(item, :foo)
-    rep.assigns = {}
-    create_binary_filter
-
-    assert rep.binary?
-    def rep.filter_named(_name)
-      @filter ||= Class.new(::Nanoc::Filter) do
-        type binary: :text
-        def run(_content, _params = {})
-          'Some textual content'
-        end
-      end
-    end
-    rep.filter(:binary_to_text)
-    refute rep.binary?
-    assert_raises(Nanoc::Int::Errors::CannotUseBinaryFilter) { rep.filter(:binary_filter) }
-  end
-
-  def test_new_content_should_be_frozen
-    filter_class = Class.new(::Nanoc::Filter) do
-      def run(content, _params = {})
-        content.gsub!('foo', 'moo')
-        content
-      end
-    end
-
-    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
-    end
-
-    assert_raises_frozen_error do
-      rep.filter(:whatever)
-    end
-  end
-
-  def test_filter_should_freeze_content
-    filter_class = Class.new(::Nanoc::Filter) do
-      def run(content, _params = {})
-        content.gsub!('foo', 'moo')
-        content
-      end
-    end
-
-    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
-    end
-
-    assert_raises_frozen_error do
-      rep.filter(:erb)
-      rep.filter(:whatever)
-    end
-  end
-
-  def test_raw_path_should_generate_dependency
-    items = [
-      Nanoc::Int::Item.new('foo', {}, '/foo/'),
-      Nanoc::Int::Item.new('bar', {}, '/bar/')
-    ]
-    item_reps = [
-      Nanoc::Int::ItemRep.new(items[0], :default),
-      Nanoc::Int::ItemRep.new(items[1], :default)
-    ]
-
-    dt = Nanoc::Int::DependencyTracker.new(items)
-    dt.start
-    Nanoc::Int::NotificationCenter.post(:visit_started, items[0])
-    item_reps[1].raw_path
-    Nanoc::Int::NotificationCenter.post(:visit_ended,   items[0])
-    dt.stop
-
-    assert_equal [items[1]], dt.objects_causing_outdatedness_of(items[0])
-  end
-
-  def test_path_should_generate_dependency
-    items = [
-      Nanoc::Int::Item.new('foo', {}, '/foo/'),
-      Nanoc::Int::Item.new('bar', {}, '/bar/')
-    ]
-    item_reps = [
-      Nanoc::Int::ItemRep.new(items[0], :default),
-      Nanoc::Int::ItemRep.new(items[1], :default)
-    ]
-
-    dt = Nanoc::Int::DependencyTracker.new(items)
-    dt.start
-    Nanoc::Int::NotificationCenter.post(:visit_started, items[0])
-    item_reps[1].path
-    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::Int::Item.new('content/somefile.dat', {}, '/somefile/', binary: true)
+    content = Nanoc::Int::BinaryContent.new(File.expand_path('content/somefile.dat'))
+    item = Nanoc::Int::Item.new(content, {}, '/somefile/')
     item_rep = Nanoc::Int::ItemRep.new(item, :foo)
     assert_raises(Nanoc::Int::Errors::CannotGetCompiledContentOfBinaryItem) do
       item_rep.compiled_content
     end
   end
 
-  def test_write_should_calculate_is_modified_correctly_for_binary_items_new
-    # Mock item
-    FileUtils.mkdir_p('content')
-    File.open('content/meow.dat', 'w') { |io| io.write('asdf') }
-    item = Nanoc::Int::Item.new(
-      'content/meow.dat', {}, '/',
-      binary: true
-    )
-
-    # Create rep
-    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_paths[:last] = 'output/woof.dat'
-
-    # Write
-    notified = false
-    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::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::Int::Item.new(
-      'content/meow.dat', {}, '/',
-      binary: true
-    )
-
-    # Create rep
-    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_paths[:last] = 'output/woof.dat'
-
-    # Write
-    notified = false
-    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::Int::NotificationCenter.remove(:rep_written, self)
-  end
-
   private
 
-  def create_binary_item
-    Nanoc::Int::Item.new(
-      '/a/file/name.dat', {}, '/',
-      binary: true
-    )
-  end
-
-  def mock_and_stub(params)
-    m = mock
-    params.each do |method, return_value|
-      m.stubs(method.to_sym).returns(return_value)
-    end
-    m
-  end
-
   def create_rep_for(item, name)
     Nanoc::Int::ItemRep.new(item, name)
   end
-
-  def create_textual_filter
-    f = create_filter(:text)
-    f.class_eval do
-      def run(_content, _params = {})
-        ''
-      end
-    end
-    f
-  end
-
-  def create_binary_filter
-    f = create_filter(:binary)
-    f.class_eval do
-      def run(content, _params = {})
-        File.open(output_filename, 'w') { |io| io.write(content) }
-      end
-    end
-    f
-  end
-
-  def create_filter(type)
-    filter_klass = Class.new(Nanoc::Filter)
-    filter_klass.type(type)
-    Nanoc::Filter.register filter_klass, "#{type}_filter".to_sym
-    filter_klass
-  end
 end