nanoc 3.7.4 → 3.7.5

data/test/base/test_dependency_tracker.rb

@@ -1,7 +1,6 @@
 # encoding: utf-8
 
 class Nanoc::DependencyTrackerTest < Nanoc::TestCase
-
   def test_initialize
     # Mock items
     items = [mock, mock]
@@ -256,5 +255,4 @@ class Nanoc::DependencyTrackerTest < Nanoc::TestCase
     tracker.forget_dependencies_for(items[0])
     assert_empty tracker.objects_causing_outdatedness_of(items[0])
   end
-
 end

data/test/base/test_directed_graph.rb

@@ -1,7 +1,6 @@
 # encoding: utf-8
 
 class Nanoc::DirectedGraphTest < Nanoc::TestCase
-
   def test_direct_predecessors
     graph = Nanoc::DirectedGraph.new([1, 2, 3])
     graph.add_edge(1, 2)
@@ -63,7 +62,7 @@ class Nanoc::DirectedGraphTest < Nanoc::TestCase
 
   def test_add_edge
     graph = Nanoc::DirectedGraph.new([1, 2, 3])
-    
+
     assert_equal [], graph.successors_of(1)
     assert_equal [], graph.predecessors_of(2)
 
@@ -84,7 +83,7 @@ class Nanoc::DirectedGraphTest < Nanoc::TestCase
 
   def test_delete_edge
     graph = Nanoc::DirectedGraph.new([1, 2, 3])
-    graph.add_edge(1,2)
+    graph.add_edge(1, 2)
 
     assert_equal [2], graph.successors_of(1)
     assert_equal [1], graph.predecessors_of(2)
@@ -285,5 +284,4 @@ class Nanoc::DirectedGraphTest < Nanoc::TestCase
     YARD.parse(LIB_DIR + '/nanoc/base/directed_graph.rb')
     assert_examples_correct 'Nanoc::DirectedGraph'
   end
-
 end

data/test/base/test_filter.rb

@@ -1,7 +1,6 @@
 # encoding: utf-8
 
 class Nanoc::FilterTest < Nanoc::TestCase
-
   def test_initialize
     # Create filter
     filter = Nanoc::Filter.new
@@ -12,7 +11,7 @@ class Nanoc::FilterTest < Nanoc::TestCase
 
   def test_assigns
     # Create filter
-    filter = Nanoc::Filter.new({ :foo => 'bar' })
+    filter = Nanoc::Filter.new({ foo: 'bar' })
 
     # Check assigns
     assert_equal('bar', filter.assigns[:foo])
@@ -20,7 +19,7 @@ class Nanoc::FilterTest < Nanoc::TestCase
 
   def test_assigns_with_instance_variables
     # Create filter
-    filter = Nanoc::Filter.new({ :foo => 'bar' })
+    filter = Nanoc::Filter.new({ foo: 'bar' })
 
     # Check assigns
     assert_equal('bar', filter.instance_eval { @foo })
@@ -28,7 +27,7 @@ class Nanoc::FilterTest < Nanoc::TestCase
 
   def test_assigns_with_instance_methods
     # Create filter
-    filter = Nanoc::Filter.new({ :foo => 'bar' })
+    filter = Nanoc::Filter.new({ foo: 'bar' })
 
     # Check assigns
     assert_equal('bar', filter.instance_eval { foo })
@@ -52,7 +51,7 @@ class Nanoc::FilterTest < Nanoc::TestCase
     item_rep.expects(:name).returns(:quux)
 
     # Create filter
-    filter = Nanoc::Filter.new({ :item => item, :item_rep => item_rep })
+    filter = Nanoc::Filter.new({ item: item, item_rep: item_rep })
 
     # Check filename
     assert_equal('item /foo/bar/baz/ (rep quux)', filter.filename)
@@ -64,7 +63,7 @@ class Nanoc::FilterTest < Nanoc::TestCase
     layout.expects(:identifier).returns('/wohba/')
 
     # Create filter
-    filter = Nanoc::Filter.new({ :item => mock, :item_rep => mock, :layout => layout })
+    filter = Nanoc::Filter.new({ item: mock, item_rep: mock, layout: layout })
 
     # Check filename
     assert_equal('layout /wohba/', filter.filename)
@@ -77,5 +76,4 @@ class Nanoc::FilterTest < Nanoc::TestCase
     # Check filename
     assert_equal('?', filter.filename)
   end
-
 end

data/test/base/test_item.rb

@@ -1,7 +1,6 @@
 # encoding: utf-8
 
 class Nanoc::ItemTest < Nanoc::TestCase
-
   def test_initialize_with_attributes_with_string_keys
     item = Nanoc::Item.new('foo', { 'abc' => 'xyz' }, '/foo/')
 
@@ -27,7 +26,7 @@ class Nanoc::ItemTest < Nanoc::TestCase
     # Create item
     item = Nanoc::Item.new(
       'content',
-      { :one => 'one in item' },
+      { one: 'one in item' },
       '/path/'
     )
 
@@ -49,7 +48,9 @@ class Nanoc::ItemTest < Nanoc::TestCase
   def test_compiled_content_with_default_rep_and_default_snapshot
     # Mock rep
     rep = Object.new
-    def rep.name; :default; end
+    def rep.name
+      :default
+    end
     def rep.compiled_content(params)
       "content at #{params[:snapshot].inspect}"
     end
@@ -65,7 +66,9 @@ class Nanoc::ItemTest < Nanoc::TestCase
   def test_compiled_content_with_custom_rep_and_default_snapshot
     # Mock reps
     rep = Object.new
-    def rep.name; :foo; end
+    def rep.name
+      :foo
+    end
     def rep.compiled_content(params)
       "content at #{params[:snapshot].inspect}"
     end
@@ -75,13 +78,15 @@ class Nanoc::ItemTest < Nanoc::TestCase
     item.expects(:reps).returns([rep])
 
     # Check
-    assert_equal 'content at nil', item.compiled_content(:rep => :foo)
+    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.name
+      :default
+    end
     def rep.compiled_content(params)
       "content at #{params[:snapshot].inspect}"
     end
@@ -91,7 +96,7 @@ class Nanoc::ItemTest < Nanoc::TestCase
     item.expects(:reps).returns([rep])
 
     # Check
-    assert_equal 'content at :blah', item.compiled_content(:snapshot => :blah)
+    assert_equal 'content at :blah', item.compiled_content(snapshot: :blah)
   end
 
   def test_compiled_content_with_custom_nonexistant_rep
@@ -101,7 +106,7 @@ class Nanoc::ItemTest < Nanoc::TestCase
 
     # Check
     assert_raises(Nanoc::Errors::Generic) do
-      item.compiled_content(:rep => :lkasdhflahgwfe)
+      item.compiled_content(rep: :lkasdhflahgwfe)
     end
   end
 
@@ -130,11 +135,11 @@ class Nanoc::ItemTest < Nanoc::TestCase
     item.expects(:reps).returns([rep])
 
     # Check
-    assert_equal 'the correct path', item.path(:rep => :moo)
+    assert_equal 'the correct path', item.path(rep: :moo)
   end
 
   def test_freeze_should_disallow_changes
-    item = Nanoc::Item.new('foo', { :a => { :b => 123 }}, '/foo/')
+    item = Nanoc::Item.new('foo', { a: { b: 123 } }, '/foo/')
     item.freeze
 
     assert_raises_frozen_error do
@@ -149,14 +154,13 @@ class Nanoc::ItemTest < Nanoc::TestCase
   def test_dump_and_load
     item = Nanoc::Item.new(
       'foobar',
-      { :a => { :b => 123 }},
+      { a: { b: 123 } },
       '/foo/')
 
     item = Marshal.load(Marshal.dump(item))
 
     assert_equal '/foo/', item.identifier
     assert_equal 'foobar', item.raw_content
-    assert_equal({ :a => { :b => 123 }}, item.attributes)
+    assert_equal({ a: { b: 123 } }, item.attributes)
   end
-
 end

data/test/base/test_item_array.rb

@@ -1,7 +1,6 @@
 # encoding: utf-8
 
 class Nanoc::ItemArrayTest < Nanoc::TestCase
-
   def setup
     super
 
@@ -229,7 +228,7 @@ class Nanoc::ItemArrayTest < Nanoc::TestCase
     assert_equal 'Item 1', @items['/new/1/'].raw_content
   end
 
-  if Array.new.respond_to?(:keep_if)
+  if [].respond_to?(:keep_if)
     def test_keep_if
       assert_equal @two, @items[1]
       assert_equal @two, @items['/two/']
@@ -289,7 +288,7 @@ class Nanoc::ItemArrayTest < Nanoc::TestCase
     assert_equal mona, @items['/mona/']
   end
 
-  if Array.new.respond_to?(:select!)
+  if [].respond_to?(:select!)
     def test_select_bang
       assert_equal @two, @items[1]
       assert_equal @two, @items['/two/']
@@ -330,5 +329,4 @@ class Nanoc::ItemArrayTest < Nanoc::TestCase
     assert_equal @two, @items[2]
     assert_equal @two, @items['/two/']
   end
-
 end

data/test/base/test_item_rep.rb

@@ -1,19 +1,18 @@
 # encoding: utf-8
 
 class Nanoc::ItemRepTest < Nanoc::TestCase
-
   def test_created_modified_compiled
-    # TODO implement
+    # TODO: implement
   end
 
   def test_compiled_content_with_only_last_available
     # Create rep
     item = Nanoc::Item.new(
       'blah blah blah', {}, '/',
-      :binary => false, :mtime => Time.now-500
+      binary: false, mtime: Time.now - 500
     )
     rep = Nanoc::ItemRep.new(item, nil)
-    rep.instance_eval { @content = { :last => 'last content' } }
+    rep.instance_eval { @content = { last: 'last content' } }
     rep.expects(:compiled?).returns(true)
 
     # Check
@@ -24,10 +23,10 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
     # Create rep
     item = Nanoc::Item.new(
       'blah blah blah', {}, '/',
-      :binary => false, :mtime => Time.now-500
+      binary: false, mtime: Time.now - 500
     )
     rep = Nanoc::ItemRep.new(item, nil)
-    rep.instance_eval { @content = { :pre => 'pre content', :last => 'last content' } }
+    rep.instance_eval { @content = { pre: 'pre content', last: 'last content' } }
     rep.expects(:compiled?).returns(true)
 
     # Check
@@ -38,28 +37,28 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
     # Create rep
     item = Nanoc::Item.new(
       'blah blah blah', {}, '/',
-      :binary => false, :mtime => Time.now-500
+      binary: false, mtime: Time.now - 500
     )
     rep = Nanoc::ItemRep.new(item, nil)
-    rep.instance_eval { @content = { :pre => 'pre content', :last => 'last content' } }
+    rep.instance_eval { @content = { pre: 'pre content', last: 'last content' } }
     rep.expects(:compiled?).returns(true)
 
     # Check
-    assert_equal 'last content', rep.compiled_content(:snapshot => :last)
+    assert_equal 'last content', rep.compiled_content(snapshot: :last)
   end
 
   def test_compiled_content_with_invalid_snapshot
     # Create rep
     item = Nanoc::Item.new(
       'blah blah blah', {}, '/',
-      :binary => false, :mtime => Time.now-500
+      binary: false, mtime: Time.now - 500
     )
     rep = Nanoc::ItemRep.new(item, nil)
-    rep.instance_eval { @content = { :pre => 'pre content', :last => 'last content' } }
+    rep.instance_eval { @content = { pre: 'pre content', last: 'last content' } }
 
     # Check
     assert_raises Nanoc::Errors::NoSuchSnapshot do
-      rep.compiled_content(:snapshot => :klsjflkasdfl)
+      rep.compiled_content(snapshot: :klsjflkasdfl)
     end
   end
 
@@ -67,7 +66,7 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
     # Create rep
     item = Nanoc::Item.new(
       'blah blah', {}, '/',
-      :binary => false
+      binary: false
     )
     rep = Nanoc::ItemRep.new(item, nil)
     rep.expects(:compiled?).returns(false)
@@ -88,7 +87,7 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
     # Mock item
     item = Nanoc::Item.new(
       %(<%= '<%= "blah" %' + '>' %>), {}, '/',
-      :binary => false
+      binary: false
     )
 
     # Create item rep
@@ -116,7 +115,7 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
     # Mock item
     item = Nanoc::Item.new(
       'blah blah', {}, '/',
-      :binary => false
+      binary: false
     )
 
     # Create item rep
@@ -142,7 +141,7 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
     # Mock item
     item = Nanoc::Item.new(
       %(<%= '<%= "blah" %' + '>' %>), {}, '/foobar/',
-      :binary => false
+      binary: false
     )
 
     # Create item rep
@@ -170,36 +169,36 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
     # Mock item
     item = Nanoc::Item.new(
       'blah blah', {}, '/',
-      :binary => false
+      binary: false
     )
 
     # Create rep
     item_rep = Nanoc::ItemRep.new(item, :foo)
     item_rep.instance_eval { @content[:last] = 'Lorem ipsum, etc.' }
-    item_rep.raw_paths = { :moo => 'foo-moo.txt' }
+    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))
+    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))
+    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))
+    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::Item.new(
       'blah blah', {}, '/',
-      :binary => false
+      binary: false
     )
 
     # Create rep
@@ -210,7 +209,7 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
 
     # Write once
     item_rep.write
-    a_long_time_ago = Time.now-1_000_000
+    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
@@ -223,7 +222,7 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
     # Mock item
     item = Nanoc::Item.new(
       'blah blah', {}, '/',
-      :binary => false
+      binary: false
     )
 
     # Create rep
@@ -243,18 +242,20 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
     # Mock item
     item = Nanoc::Item.new(
       'blah blah', {}, '/',
-      :binary => false
+      binary: false
     )
 
     # Create rep
     rep = Nanoc::ItemRep.new(item, :foo)
-    def rep.assigns; {}; end
+    def rep.assigns
+      {}
+    end
 
     # Create fake filter
-    def rep.filter_named(name)
+    def rep.filter_named(_name)
       @filter ||= Class.new(::Nanoc::Filter) do
-        type :text => :binary
-        def run(content, params = {})
+        type text: :binary
+        def run(content, _params = {})
           File.open(output_filename, 'w') { |io| io.write(content) }
         end
       end
@@ -271,18 +272,20 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
     # Mock item
     item = Nanoc::Item.new(
       'blah blah', {}, '/',
-      :binary => false
+      binary: false
     )
 
     # Create rep
     rep = Nanoc::ItemRep.new(item, :foo)
-    def rep.assigns; {}; end
+    def rep.assigns
+      {}
+    end
 
     # Create fake filter
-    def rep.filter_named(name)
+    def rep.filter_named(_name)
       @filter ||= Class.new(::Nanoc::Filter) do
         type :binary
-        def run(content, params = {})
+        def run(content, _params = {})
           File.open(output_filename, 'w') { |io| io.write(content) }
         end
       end
@@ -296,9 +299,9 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
 
   def test_using_textual_filters_on_binary_reps_raises
     item = create_binary_item
-    site = mock_and_stub(:items => [item],
-      :layouts => [],
-      :config  => []
+    site = mock_and_stub(items: [item],
+      layouts: [],
+      config: []
     )
     item.stubs(:site).returns(site)
     rep = create_rep_for(item, :foo)
@@ -334,13 +337,13 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
     # Create item and item rep
     item = create_binary_item
     rep = create_rep_for(item, :foo)
-    rep.assigns = { :content => 'meh' }
+    rep.assigns = { content: 'meh' }
 
     # Create filter
     Class.new(::Nanoc::Filter) do
-      type :binary => :text
+      type binary: :text
       identifier :binary_to_text
-      def run(content, params = {})
+      def run(content, _params = {})
         content + ' textified'
       end
     end
@@ -353,9 +356,9 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
 
   def test_converted_binary_rep_can_be_filtered_with_textual_filters
     item = create_binary_item
-    site = mock_and_stub(:items => [item],
-      :layouts => [],
-      :config  => []
+    site = mock_and_stub(items: [item],
+      layouts: [],
+      config: []
     )
     item.stubs(:site).returns(site)
     rep = create_rep_for(item, :foo)
@@ -364,10 +367,10 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
 
     assert rep.binary?
 
-    def rep.filter_named(name)
+    def rep.filter_named(_name)
       Class.new(::Nanoc::Filter) do
-        type :binary => :text
-        def run(content, params = {})
+        type binary: :text
+        def run(_content, _params = {})
           'Some textual content'
         end
       end
@@ -375,10 +378,10 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
     rep.filter(:binary_to_text)
     assert !rep.binary?
 
-    def rep.filter_named(name)
+    def rep.filter_named(_name)
       Class.new(::Nanoc::Filter) do
         type :text
-        def run(content, params = {})
+        def run(_content, _params = {})
           'Some textual content'
         end
       end
@@ -390,9 +393,9 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
   def test_converted_binary_rep_cannot_be_filtered_with_binary_filters
     item = create_binary_item
     site = mock_and_stub(
-      :items   => [item],
-      :layouts => [],
-      :config  => []
+      items: [item],
+      layouts: [],
+      config: []
     )
     item.stubs(:site).returns(site)
     rep = create_rep_for(item, :foo)
@@ -400,10 +403,10 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
     create_binary_filter
 
     assert rep.binary?
-    def rep.filter_named(name)
+    def rep.filter_named(_name)
       @filter ||= Class.new(::Nanoc::Filter) do
-        type :binary => :text
-        def run(content, params = {})
+        type binary: :text
+        def run(_content, _params = {})
           'Some textual content'
         end
       end
@@ -415,7 +418,7 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
 
   def test_new_content_should_be_frozen
     filter_class = Class.new(::Nanoc::Filter) do
-      def run(content, params = {})
+      def run(content, _params = {})
         content.gsub!('foo', 'moo')
         content
       end
@@ -424,7 +427,9 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
     item = Nanoc::Item.new('foo bar', {}, '/foo/')
     rep = Nanoc::ItemRep.new(item, :default)
     rep.instance_eval { @filter_class = filter_class }
-    def rep.filter_named(name); @filter_class; end
+    def rep.filter_named(_name)
+      @filter_class
+    end
 
     assert_raises_frozen_error do
       rep.filter(:whatever)
@@ -433,7 +438,7 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
 
   def test_filter_should_freeze_content
     filter_class = Class.new(::Nanoc::Filter) do
-      def run(content, params = {})
+      def run(content, _params = {})
         content.gsub!('foo', 'moo')
         content
       end
@@ -442,7 +447,9 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
     item = Nanoc::Item.new('foo bar', {}, '/foo/')
     rep = Nanoc::ItemRep.new(item, :default)
     rep.instance_eval { @filter_class = filter_class }
-    def rep.filter_named(name); @filter_class; end
+    def rep.filter_named(_name)
+      @filter_class
+    end
 
     assert_raises_frozen_error do
       rep.filter(:erb)
@@ -491,7 +498,7 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
   end
 
   def test_access_compiled_content_of_binary_item
-    item = Nanoc::Item.new('content/somefile.dat', {}, '/somefile/', :binary => true)
+    item = Nanoc::Item.new('content/somefile.dat', {}, '/somefile/', binary: true)
     item_rep = Nanoc::ItemRep.new(item, :foo)
     assert_raises(Nanoc::Errors::CannotGetCompiledContentOfBinaryItem) do
       item_rep.compiled_content
@@ -504,7 +511,7 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
     File.open('content/meow.dat', 'w') { |io| io.write('asdf') }
     item = Nanoc::Item.new(
       'content/meow.dat', {}, '/',
-      :binary => true
+      binary: true
     )
 
     # Create rep
@@ -516,7 +523,7 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
 
     # Write
     notified = false
-    Nanoc::NotificationCenter.on(:rep_written, self) do |rep, raw_path, is_created, is_modified|
+    Nanoc::NotificationCenter.on(:rep_written, self) do |_rep, _raw_path, is_created, is_modified|
       notified = true
       assert is_created
       assert is_modified
@@ -532,7 +539,7 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
     File.open('content/meow.dat', 'w') { |io| io.write('asdf') }
     item = Nanoc::Item.new(
       'content/meow.dat', {}, '/',
-      :binary => true
+      binary: true
     )
 
     # Create rep
@@ -546,7 +553,7 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
 
     # Write
     notified = false
-    Nanoc::NotificationCenter.on(:rep_written, self) do |rep, raw_path, is_created, is_modified|
+    Nanoc::NotificationCenter.on(:rep_written, self) do |_rep, _raw_path, is_created, is_modified|
       notified = true
       refute is_created
       assert is_modified
@@ -561,14 +568,14 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
   def create_binary_item
     Nanoc::Item.new(
       '/a/file/name.dat', {}, '/',
-      :binary => true
+      binary: true
     )
   end
 
   def mock_and_stub(params)
     m = mock
     params.each do |method, return_value|
-      m.stubs(method.to_sym).returns( return_value )
+      m.stubs(method.to_sym).returns(return_value)
     end
     m
   end
@@ -580,7 +587,7 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
   def create_textual_filter
     f = create_filter(:text)
     f.class_eval do
-      def run(content, params = {})
+      def run(_content, _params = {})
         ''
       end
     end
@@ -590,7 +597,7 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
   def create_binary_filter
     f = create_filter(:binary)
     f.class_eval do
-      def run(content, params = {})
+      def run(content, _params = {})
         File.open(output_filename, 'w') { |io| io.write(content) }
       end
     end
@@ -603,5 +610,4 @@ class Nanoc::ItemRepTest < Nanoc::TestCase
     Nanoc::Filter.register filter_klass, "#{type}_filter".to_sym
     filter_klass
   end
-
 end