Merge pull request #4947 from pathawks/rubocop/tests

Merge pull request 4947

.rubocop.yml

@@ -39,17 +39,6 @@ AllCops:
   - features/step_definitions.rb
   - features/support/formatter.rb
   - features/support/helpers.rb
-  - test/test_configuration.rb
-  - test/test_document.rb
-  - test/test_entry_filter.rb
-  - test/test_filters.rb
-  - test/test_kramdown.rb
-  - test/test_liquid_renderer.rb
-  - test/test_page.rb
-  - test/test_regenerator.rb
-  - test/test_site.rb
-  - test/test_tags.rb
-  - test/test_utils.rb
   - bin/**/*
   - benchmark/**/*
   - script/**/*
@@ -66,6 +55,7 @@ Metrics/ClassLength:
   Max: 240
   Exclude:
   - !ruby/regexp /features\/.*.rb$/
+  - !ruby/regexp /test\/.*.rb$/
 Metrics/CyclomaticComplexity:
   Max: 8
 Metrics/LineLength:

test/test_configuration.rb

@@ -1,7 +1,7 @@
-require 'helper'
+require "helper"
 
 class TestConfiguration < JekyllUnitTest
-  @@test_config = {
+  test_config = {
     "source"      => new(nil).source_dir,
     "destination" => dest_dir
   }
@@ -12,48 +12,77 @@ class TestConfiguration < JekyllUnitTest
     end
 
     should "merge input over defaults" do
-      result = Configuration.from({"source" => "blah"})
+      result = Configuration.from({ "source" => "blah" })
       refute_equal result["source"], Configuration::DEFAULTS["source"]
       assert_equal result["source"], "blah"
     end
 
     should "fix common mistakes" do
-      result = Configuration.from({"paginate" => 0})
-      assert_nil result["paginate"], "Expected 'paginate' to be corrected to 'nil', but was #{result["paginate"].inspect}"
+      result = Configuration.from({ "paginate" => 0 })
+      assert_nil(
+        result["paginate"],
+        "Expected 'paginate' to be corrected to 'nil', " \
+        "but was #{result["paginate"].inspect}"
+      )
     end
 
     should "add default collections" do
       result = Configuration.from({})
-      assert_equal result["collections"], {"posts" => {"output" => true, "permalink" => "/:categories/:year/:month/:day/:title:output_ext"}}
+      assert_equal(
+        result["collections"],
+        {
+          "posts" => {
+            "output"    => true,
+            "permalink" => "/:categories/:year/:month/:day/:title:output_ext"
+          }
+        }
+      )
     end
 
     should "NOT backwards-compatibilize" do
-      assert Configuration.from("watch" => true)["watch"], "Expected the 'watch' key to not be removed."
+      assert(
+        Configuration.from("watch" => true)["watch"],
+        "Expected the 'watch' key to not be removed."
+      )
     end
   end
 
   context "#add_default_collections" do
     should "no-op if collections is nil" do
-      result = Configuration[{"collections" => nil}].add_default_collections
+      result = Configuration[{ "collections" => nil }].add_default_collections
       assert_nil result["collections"]
     end
 
     should "turn an array into a hash" do
-      result = Configuration[{"collections" => %w{methods}}].add_default_collections
+      result = Configuration[{ "collections" => %w(methods) }].add_default_collections
       assert_instance_of Hash, result["collections"]
-      assert_equal result["collections"], {"posts" => {"output" => true}, "methods" => {}}
+      assert_equal(
+        result["collections"],
+        { "posts" => { "output" => true }, "methods" => {} }
+      )
     end
 
     should "only assign collections.posts.permalink if a permalink is specified" do
-      result = Configuration[{"permalink" => "pretty", "collections" => {}}].add_default_collections
-      assert_equal result["collections"], {"posts" => {"output" => true, "permalink" => "/:categories/:year/:month/:day/:title/"}}
+      result = Configuration[{ "permalink" => "pretty", "collections" => {} }]
+        .add_default_collections
+      assert_equal(
+        result["collections"],
+        {
+          "posts" => {
+            "output"    => true,
+            "permalink" => "/:categories/:year/:month/:day/:title/"
+          }
+        }
+      )
 
-      result = Configuration[{"permalink" => nil, "collections" => {}}].add_default_collections
-      assert_equal result["collections"], {"posts" => {"output" => true}}
+      result = Configuration[{ "permalink" => nil, "collections" => {} }]
+        .add_default_collections
+      assert_equal result["collections"], { "posts" => { "output" => true } }
     end
 
     should "forces posts to output" do
-      result = Configuration[{"collections" => {"posts" => {"output" => false}}}].add_default_collections
+      result = Configuration[{ "collections" => { "posts" => { "output" => false } } }]
+        .add_default_collections
       assert_equal result["collections"]["posts"]["output"], true
     end
   end
@@ -61,18 +90,18 @@ class TestConfiguration < JekyllUnitTest
   context "#stringify_keys" do
     setup do
       @mixed_keys = Configuration[{
-        'markdown' => 'kramdown',
-        :permalink => 'date',
-        'baseurl'  => '/',
-        :include   => ['.htaccess'],
-        :source    => './'
+        "markdown" => "kramdown",
+        :permalink => "date",
+        "baseurl"  => "/",
+        :include   => [".htaccess"],
+        :source    => "./"
       }]
       @string_keys = Configuration[{
-        'markdown'  => 'kramdown',
-        'permalink' => 'date',
-        'baseurl'   => '/',
-        'include'   => ['.htaccess'],
-        'source'    => './'
+        "markdown"  => "kramdown",
+        "permalink" => "date",
+        "baseurl"   => "/",
+        "include"   => [".htaccess"],
+        "source"    => "./"
       }]
     end
     should "stringify symbol keys" do
@@ -84,10 +113,12 @@ class TestConfiguration < JekyllUnitTest
   end
   context "#config_files" do
     setup do
-      @config = Configuration[{"source" => source_dir}]
+      @config = Configuration[{ "source" => source_dir }]
       @no_override     = {}
-      @one_config_file = {"config" => "config.yml"}
-      @multiple_files  = {"config" => %w[config/site.yml config/deploy.toml configuration.yml]}
+      @one_config_file = { "config" => "config.yml" }
+      @multiple_files  = {
+        "config" => %w(config/site.yml config/deploy.toml configuration.yml)
+      }
     end
 
     should "always return an array" do
@@ -108,38 +139,44 @@ class TestConfiguration < JekyllUnitTest
       assert_equal [source_dir("_config.yml")], @config.config_files(@no_override)
     end
     should "return the config if given one config file" do
-      assert_equal %w[config.yml], @config.config_files(@one_config_file)
+      assert_equal %w(config.yml), @config.config_files(@one_config_file)
     end
     should "return an array of the config files if given many config files" do
-      assert_equal %w[config/site.yml config/deploy.toml configuration.yml], @config.config_files(@multiple_files)
+      assert_equal(
+        %w(config/site.yml config/deploy.toml configuration.yml),
+        @config.config_files(@multiple_files)
+      )
     end
   end
 
   context "#read_config_file" do
     setup do
-      @config = Configuration[{"source" => source_dir('empty.yml')}]
+      @config = Configuration[{ "source" => source_dir("empty.yml") }]
     end
 
     should "not raise an error on empty files" do
-      allow(SafeYAML).to receive(:load_file).with('empty.yml').and_return(false)
+      allow(SafeYAML).to receive(:load_file).with("empty.yml").and_return(false)
       Jekyll.logger.log_level = :warn
-      @config.read_config_file('empty.yml')
+      @config.read_config_file("empty.yml")
       Jekyll.logger.log_level = :info
     end
   end
 
   context "#read_config_files" do
     setup do
-      @config = Configuration[{"source" => source_dir}]
+      @config = Configuration[{ "source" => source_dir }]
     end
 
     should "continue to read config files if one is empty" do
-      allow(SafeYAML).to receive(:load_file).with('empty.yml').and_return(false)
-      allow(SafeYAML).to receive(:load_file).with('not_empty.yml').and_return({'foo' => 'bar', 'include' => '', 'exclude' => ''})
+      allow(SafeYAML).to receive(:load_file).with("empty.yml").and_return(false)
+      allow(SafeYAML)
+        .to receive(:load_file)
+        .with("not_empty.yml")
+        .and_return({ "foo" => "bar", "include" => "", "exclude" => "" })
       Jekyll.logger.log_level = :warn
-      read_config = @config.read_config_files(['empty.yml', 'not_empty.yml'])
+      read_config = @config.read_config_files(["empty.yml", "not_empty.yml"])
       Jekyll.logger.log_level = :info
-      assert_equal 'bar', read_config['foo']
+      assert_equal "bar", read_config["foo"]
     end
   end
   context "#backwards_compatibilize" do
@@ -153,7 +190,7 @@ class TestConfiguration < JekyllUnitTest
         "pygments"    => true,
         "plugins"     => true,
         "layouts"     => true,
-        "data_source" => true,
+        "data_source" => true
       }]
     end
     should "unset 'auto' and 'watch'" do
@@ -169,12 +206,18 @@ class TestConfiguration < JekyllUnitTest
     should "transform string exclude into an array" do
       assert @config.key?("exclude")
       assert @config.backwards_compatibilize.key?("exclude")
-      assert_equal @config.backwards_compatibilize["exclude"], %w[READ-ME.md Gemfile CONTRIBUTING.hello.markdown]
+      assert_equal(
+        @config.backwards_compatibilize["exclude"],
+        %w(READ-ME.md Gemfile CONTRIBUTING.hello.markdown)
+      )
     end
     should "transform string include into an array" do
       assert @config.key?("include")
       assert @config.backwards_compatibilize.key?("include")
-      assert_equal @config.backwards_compatibilize["include"], %w[STOP_THE_PRESSES.txt .heloses .git]
+      assert_equal(
+        @config.backwards_compatibilize["include"],
+        %w(STOP_THE_PRESSES.txt .heloses .git)
+      )
     end
     should "set highlighter to pygments" do
       assert @config.key?("pygments")
@@ -195,62 +238,79 @@ class TestConfiguration < JekyllUnitTest
   end
   context "#fix_common_issues" do
     setup do
-      @config = Proc.new do |val|
+      @config = proc do |val|
         Configuration[{
-          'paginate' => val
+          "paginate" => val
         }]
       end
     end
     should "sets an invalid 'paginate' value to nil" do
-      assert_nil @config.call(0).fix_common_issues['paginate']
-      assert_nil @config.call(-1).fix_common_issues['paginate']
-      assert_nil @config.call(true).fix_common_issues['paginate']
+      assert_nil @config.call(0).fix_common_issues["paginate"]
+      assert_nil @config.call(-1).fix_common_issues["paginate"]
+      assert_nil @config.call(true).fix_common_issues["paginate"]
     end
   end
   context "loading configuration" do
     setup do
-      @path = source_dir('_config.yml')
+      @path = source_dir("_config.yml")
       @user_config = File.join(Dir.pwd, "my_config_file.yml")
     end
 
     should "fire warning with no _config.yml" do
-      allow(SafeYAML).to receive(:load_file).with(@path) { raise SystemCallError, "No such file or directory - #{@path}" }
+      allow(SafeYAML).to receive(:load_file).with(@path) do
+        raise SystemCallError, "No such file or directory - #{@path}"
+      end
       allow($stderr).to receive(:puts).with("Configuration file: none".yellow)
-      assert_equal site_configuration, Jekyll.configuration(@@test_config)
+      assert_equal site_configuration, Jekyll.configuration(test_config)
     end
 
     should "load configuration as hash" do
-      allow(SafeYAML).to receive(:load_file).with(@path).and_return(Hash.new)
+      allow(SafeYAML).to receive(:load_file).with(@path).and_return({})
       allow($stdout).to receive(:puts).with("Configuration file: #{@path}")
-      assert_equal site_configuration, Jekyll.configuration(@@test_config)
+      assert_equal site_configuration, Jekyll.configuration(test_config)
     end
 
     should "fire warning with bad config" do
-      allow(SafeYAML).to receive(:load_file).with(@path).and_return(Array.new)
-      allow($stderr).to receive(:puts).and_return(("WARNING: ".rjust(20) + "Error reading configuration. Using defaults (and options).").yellow)
-      allow($stderr).to receive(:puts).and_return("Configuration file: (INVALID) #{@path}".yellow)
-      assert_equal site_configuration, Jekyll.configuration(@@test_config)
+      allow(SafeYAML).to receive(:load_file).with(@path).and_return([])
+      allow($stderr)
+        .to receive(:puts)
+        .and_return(
+          ("WARNING: "
+             .rjust(20) + "Error reading configuration. Using defaults (and options).")
+              .yellow
+        )
+      allow($stderr)
+        .to receive(:puts)
+        .and_return("Configuration file: (INVALID) #{@path}".yellow)
+      assert_equal site_configuration, Jekyll.configuration(test_config)
     end
 
     should "fire warning when user-specified config file isn't there" do
-      allow(SafeYAML).to receive(:load_file).with(@user_config) { raise SystemCallError, "No such file or directory - #{@user_config}" }
-      allow($stderr).to receive(:puts).with(("Fatal: ".rjust(20) + "The configuration file '#{@user_config}' could not be found.").red)
+      allow(SafeYAML).to receive(:load_file).with(@user_config) do
+        raise SystemCallError, "No such file or directory - #{@user_config}"
+      end
+      allow($stderr)
+        .to receive(:puts)
+        .with((
+          "Fatal: ".rjust(20) + \
+          "The configuration file '#{@user_config}' could not be found."
+        ).red)
       assert_raises LoadError do
-        Jekyll.configuration({'config' => [@user_config]})
+        Jekyll.configuration({ "config" => [@user_config] })
       end
     end
 
     should "not clobber YAML.load to the dismay of other libraries" do
-      assert_equal :foo, YAML.load(':foo')
+      assert_equal :foo, YAML.load(":foo")
       # as opposed to: assert_equal ':foo', SafeYAML.load(':foo')
     end
   end
   context "loading config from external file" do
     setup do
       @paths = {
-        :default => source_dir('_config.yml'),
-        :other   => source_dir('_config.live.yml'),
-        :toml    => source_dir('_config.dev.toml'),
+        :default => source_dir("_config.yml"),
+        :other   => source_dir("_config.live.yml"),
+        :toml    => source_dir("_config.dev.toml"),
         :empty   => ""
       }
     end
@@ -258,16 +318,19 @@ class TestConfiguration < JekyllUnitTest
     should "load default plus posts config if no config_file is set" do
       allow(SafeYAML).to receive(:load_file).with(@paths[:default]).and_return({})
       allow($stdout).to receive(:puts).with("Configuration file: #{@paths[:default]}")
-      assert_equal site_configuration, Jekyll.configuration(@@test_config)
+      assert_equal site_configuration, Jekyll.configuration(test_config)
     end
 
     should "load different config if specified" do
-      allow(SafeYAML).to receive(:load_file).with(@paths[:other]).and_return({"baseurl" => "http://wahoo.dev"})
+      allow(SafeYAML)
+        .to receive(:load_file)
+        .with(@paths[:other])
+        .and_return({ "baseurl" => "http://wahoo.dev" })
       allow($stdout).to receive(:puts).with("Configuration file: #{@paths[:other]}")
       Jekyll.configuration({ "config" => @paths[:other] })
       assert_equal \
         site_configuration({ "baseurl" => "http://wahoo.dev" }),
-        Jekyll.configuration(@@test_config.merge({ "config" => @paths[:other] }))
+        Jekyll.configuration(test_config.merge({ "config" => @paths[:other] }))
     end
 
     should "load default config if path passed is empty" do
@@ -275,68 +338,94 @@ class TestConfiguration < JekyllUnitTest
       allow($stdout).to receive(:puts).with("Configuration file: #{@paths[:default]}")
       assert_equal \
         site_configuration,
-        Jekyll.configuration(@@test_config.merge({ "config" => [@paths[:empty]] }))
+        Jekyll.configuration(test_config.merge({ "config" => [@paths[:empty]] }))
     end
 
     should "successfully load a TOML file" do
       Jekyll.logger.log_level = :warn
       assert_equal \
-        site_configuration({ "baseurl" => "/you-beautiful-blog-you", "title" => "My magnificent site, wut" }),
-        Jekyll.configuration(@@test_config.merge({ "config" => [@paths[:toml]] }))
+        site_configuration({ "baseurl" => "/you-beautiful-blog-you",
+                             "title"   => "My magnificent site, wut" }),
+        Jekyll.configuration(test_config.merge({ "config" => [@paths[:toml]] }))
       Jekyll.logger.log_level = :info
     end
 
     should "load multiple config files" do
-      External.require_with_graceful_fail('toml')
+      External.require_with_graceful_fail("toml")
 
-      allow(SafeYAML).to receive(:load_file).with(@paths[:default]).and_return(Hash.new)
-      allow(SafeYAML).to receive(:load_file).with(@paths[:other]).and_return(Hash.new)
-      allow(TOML).to receive(:load_file).with(@paths[:toml]).and_return(Hash.new)
+      allow(SafeYAML).to receive(:load_file).with(@paths[:default]).and_return({})
+      allow(SafeYAML).to receive(:load_file).with(@paths[:other]).and_return({})
+      allow(TOML).to receive(:load_file).with(@paths[:toml]).and_return({})
       allow($stdout).to receive(:puts).with("Configuration file: #{@paths[:default]}")
       allow($stdout).to receive(:puts).with("Configuration file: #{@paths[:other]}")
       allow($stdout).to receive(:puts).with("Configuration file: #{@paths[:toml]}")
-      assert_equal \
+      assert_equal(
         site_configuration,
-        Jekyll.configuration(@@test_config.merge({ "config" => [@paths[:default], @paths[:other], @paths[:toml]] }))
+        Jekyll.configuration(
+          test_config.merge(
+            { "config" => [@paths[:default], @paths[:other], @paths[:toml]] }
+          )
+        )
+      )
     end
 
     should "load multiple config files and last config should win" do
-      allow(SafeYAML).to receive(:load_file).with(@paths[:default]).and_return({"baseurl" => "http://example.dev"})
-      allow(SafeYAML).to receive(:load_file).with(@paths[:other]).and_return({"baseurl" => "http://wahoo.dev"})
-      allow($stdout).to receive(:puts).with("Configuration file: #{@paths[:default]}")
-      allow($stdout).to receive(:puts).with("Configuration file: #{@paths[:other]}")
+      allow(SafeYAML)
+        .to receive(:load_file)
+        .with(@paths[:default])
+        .and_return({ "baseurl" => "http://example.dev" })
+      allow(SafeYAML)
+        .to receive(:load_file)
+        .with(@paths[:other])
+        .and_return({ "baseurl" => "http://wahoo.dev" })
+      allow($stdout)
+        .to receive(:puts)
+        .with("Configuration file: #{@paths[:default]}")
+      allow($stdout)
+        .to receive(:puts)
+        .with("Configuration file: #{@paths[:other]}")
       assert_equal \
         site_configuration({ "baseurl" => "http://wahoo.dev" }),
-        Jekyll.configuration(@@test_config.merge({ "config" => [@paths[:default], @paths[:other]] }))
+        Jekyll.configuration(
+          test_config.merge({ "config" => [@paths[:default], @paths[:other]] })
+        )
     end
   end
 
   context "#add_default_collections" do
     should "not do anything if collections is nil" do
-      conf = Configuration[default_configuration].tap {|c| c['collections'] = nil }
+      conf = Configuration[default_configuration].tap { |c| c["collections"] = nil }
       assert_equal conf.add_default_collections, conf
-      assert_nil conf.add_default_collections['collections']
+      assert_nil conf.add_default_collections["collections"]
     end
 
     should "converts collections to a hash if an array" do
-      conf = Configuration[default_configuration].tap {|c| c['collections'] = ['docs'] }
+      conf = Configuration[default_configuration].tap do |c|
+        c["collections"] = ["docs"]
+      end
       assert_equal conf.add_default_collections, conf.merge({
         "collections" => {
           "docs"  => {},
           "posts" => {
             "output"    => true,
             "permalink" => "/:categories/:year/:month/:day/:title:output_ext"
-          }}})
+          }
+        }
+      })
     end
 
     should "force collections.posts.output = true" do
-      conf = Configuration[default_configuration].tap {|c| c['collections'] = {'posts' => {'output' => false}} }
+      conf = Configuration[default_configuration].tap do |c|
+        c["collections"] = { "posts" => { "output" => false } }
+      end
       assert_equal conf.add_default_collections, conf.merge({
         "collections" => {
           "posts" => {
             "output"    => true,
             "permalink" => "/:categories/:year/:month/:day/:title:output_ext"
-          }}})
+          }
+        }
+      })
     end
 
     should "set collections.posts.permalink if it's not set" do
@@ -346,13 +435,15 @@ class TestConfiguration < JekyllUnitTest
           "posts" => {
             "output"    => true,
             "permalink" => "/:categories/:year/:month/:day/:title:output_ext"
-          }}})
+          }
+        }
+      })
     end
 
     should "leave collections.posts.permalink alone if it is set" do
       posts_permalink = "/:year/:title/"
       conf = Configuration[default_configuration].tap do |c|
-        c['collections'] = {
+        c["collections"] = {
           "posts" => { "permalink" => posts_permalink }
         }
       end
@@ -361,7 +452,9 @@ class TestConfiguration < JekyllUnitTest
           "posts" => {
             "output"    => true,
             "permalink" => posts_permalink
-          }}})
+          }
+        }
+      })
     end
   end
 end

test/test_document.rb

@@ -1,7 +1,6 @@
-require 'helper'
+require "helper"
 
 class TestDocument < JekyllUnitTest
-
   def assert_equal_value(key, one, other)
     assert_equal(one[key], other[key])
   end
@@ -12,7 +11,9 @@ class TestDocument < JekyllUnitTest
         "collections" => ["methods"]
       })
       @site.process
-      @document = @site.collections["methods"].docs.detect {|d| d.relative_path == "_methods/configuration.md" }
+      @document = @site.collections["methods"].docs.detect do |d|
+        d.relative_path == "_methods/configuration.md"
+      end
     end
 
     should "exist" do
@@ -86,11 +87,12 @@ class TestDocument < JekyllUnitTest
     end
 
     context "with YAML ending in three dots" do
-
       setup do
-        @site = fixture_site({"collections" => ["methods"]})
+        @site = fixture_site({ "collections" => ["methods"] })
         @site.process
-        @document = @site.collections["methods"].docs.detect {|d| d.relative_path == "_methods/yaml_with_dots.md" }
+        @document = @site.collections["methods"].docs.detect do |d|
+          d.relative_path == "_methods/yaml_with_dots.md"
+        end
       end
 
       should "know its data" do
@@ -100,13 +102,12 @@ class TestDocument < JekyllUnitTest
     end
 
     should "output the collection name in the #to_liquid method" do
-      assert_equal @document.to_liquid['collection'], "methods"
+      assert_equal @document.to_liquid["collection"], "methods"
     end
 
     should "output its relative path as path in Liquid" do
-      assert_equal @document.to_liquid['path'], "_methods/configuration.md"
+      assert_equal @document.to_liquid["path"], "_methods/configuration.md"
     end
-
   end
 
   context "a document as part of a collection with frontmatter defaults" do
@@ -114,22 +115,22 @@ class TestDocument < JekyllUnitTest
       @site = fixture_site({
         "collections" => ["slides"],
         "defaults"    => [{
-          "scope"=> {"path"=>"", "type"=>"slides"},
-          "values"=> {
-            "nested"=> {
-              "key"=>"myval",
+          "scope"  => { "path"=>"", "type"=>"slides" },
+          "values" => {
+            "nested" => {
+              "key" => "myval"
             }
           }
         }]
       })
       @site.process
-      @document = @site.collections["slides"].docs.select{|d| d.is_a?(Document) }.first
+      @document = @site.collections["slides"].docs.select { |d| d.is_a?(Document) }.first
     end
 
     should "know the frontmatter defaults" do
       assert_equal "Example slide", @document.data["title"]
       assert_equal "slide", @document.data["layout"]
-      assert_equal({"key"=>"myval"}, @document.data["nested"])
+      assert_equal({ "key"=>"myval" }, @document.data["nested"])
     end
   end
 
@@ -138,11 +139,11 @@ class TestDocument < JekyllUnitTest
       @site = fixture_site({
         "collections" => ["slides"],
         "defaults"    => [{
-          "scope"=> {"path"=>"", "type"=>"slides"},
-          "values"=> {
-            "nested"=> {
-              "test1"=>"default1",
-              "test2"=>"default1"
+          "scope"  => { "path"=>"", "type"=>"slides" },
+          "values" => {
+            "nested" => {
+              "test1" => "default1",
+              "test2" => "default1"
             }
           }
         }]
@@ -154,7 +155,10 @@ class TestDocument < JekyllUnitTest
     should "override default values in the document frontmatter" do
       assert_equal "Override title", @document.data["title"]
       assert_equal "slide", @document.data["layout"]
-      assert_equal({"test1"=>"override1","test2"=>"override2"}, @document.data["nested"])
+      assert_equal(
+        { "test1"=>"override1", "test2"=>"override2" },
+        @document.data["nested"]
+      )
     end
   end
 
@@ -163,10 +167,10 @@ class TestDocument < JekyllUnitTest
       @site = fixture_site({
         "collections" => ["slides"],
         "defaults"    => [{
-          "scope"=> {"path"=>"_slides", "type"=>"slides"},
-          "values"=> {
-            "nested"=> {
-              "key"=>"value123",
+          "scope"  => { "path"=>"_slides", "type"=>"slides" },
+          "values" => {
+            "nested" => {
+              "key" => "value123"
             }
           }
         }]
@@ -178,7 +182,7 @@ class TestDocument < JekyllUnitTest
     should "know the frontmatter defaults" do
       assert_equal "Example slide", @document.data["title"]
       assert_equal "slide", @document.data["layout"]
-      assert_equal({"key"=>"value123"}, @document.data["nested"])
+      assert_equal({ "key"=>"value123" }, @document.data["nested"])
     end
   end
 
@@ -187,10 +191,10 @@ class TestDocument < JekyllUnitTest
       @site = fixture_site({
         "collections" => ["slides"],
         "defaults"    => [{
-          "scope"=> {"path"=>"somepath", "type"=>"slides"},
-          "values"=> {
-            "nested"=> {
-              "key"=>"myval",
+          "scope"  => { "path"=>"somepath", "type"=>"slides" },
+          "values" => {
+            "nested" => {
+              "key" => "myval"
             }
           }
         }]
@@ -259,9 +263,9 @@ class TestDocument < JekyllUnitTest
       @site = fixture_site({
         "collections" => {
           "slides" => {
-            "output"    => true,
+            "output" => true
+          }
         }
-        },
       })
       @site.permalink_style = :pretty
       @site.process
@@ -283,9 +287,9 @@ class TestDocument < JekyllUnitTest
       @site = fixture_site({
         "collections" => {
           "slides" => {
-             "output" => true,
+            "output" => true
+          }
         }
-        },
       })
       @site.permalink_style = :pretty
       @site.process
@@ -337,7 +341,7 @@ class TestDocument < JekyllUnitTest
             "output"    => true,
             "permalink" => "/slides/:title"
           }
-        },
+        }
       })
       @site.process
       @document = @site.collections["slides"].docs[3]
@@ -363,7 +367,10 @@ class TestDocument < JekyllUnitTest
     end
 
     should "produce the right URL if they have a wild slug" do
-      assert_equal "/slides/Well,-so-what-is-Jekyll,-then", @document_with_strange_slug.url
+      assert_equal(
+        "/slides/Well,-so-what-is-Jekyll,-then",
+        @document_with_strange_slug.url
+      )
     end
     should "produce the right destination file if they have a wild slug" do
       dest_file = dest_dir("/slides/Well,-so-what-is-Jekyll,-then.html")
@@ -373,9 +380,9 @@ class TestDocument < JekyllUnitTest
 
   context "document with a permalink with dots & a trailing slash" do
     setup do
-      @site = fixture_site({"collections" => {
+      @site = fixture_site({ "collections" => {
         "with.dots" => { "output" => true }
-      }})
+      } })
       @site.process
       @document = @site.collections["with.dots"].docs.last
       @dest_file = dest_dir("with.dots", "permalink.with.slash.tho", "index.html")
@@ -401,7 +408,7 @@ class TestDocument < JekyllUnitTest
           "slides" => {
             "output" => true
           }
-        },
+        }
       })
       @site.process
       @files = @site.collections["slides"].docs
@@ -409,13 +416,17 @@ class TestDocument < JekyllUnitTest
 
     context "without output overrides" do
       should "be output according to collection defaults" do
-        refute_nil @files.find { |doc| doc.relative_path == "_slides/example-slide-4.html" }
+        refute_nil @files.find do |doc|
+          doc.relative_path == "_slides/example-slide-4.html"
+        end
       end
     end
 
     context "with output overrides" do
       should "be output according its front matter" do
-        assert_nil @files.find { |doc| doc.relative_path == "_slides/non-outputted-slide.html" }
+        assert_nil @files.find { |doc|
+          doc.relative_path == "_slides/non-outputted-slide.html"
+        }
       end
     end
   end
@@ -430,7 +441,9 @@ class TestDocument < JekyllUnitTest
         }
       })
       @site.process
-      @document = @site.collections["slides"].files.find { |doc| doc.relative_path == "_slides/octojekyll.png" }
+      @document = @site.collections["slides"].files.find do |doc|
+        doc.relative_path == "_slides/octojekyll.png"
+      end
       @dest_file = dest_dir("slides/octojekyll.png")
     end
 
@@ -458,10 +471,12 @@ class TestDocument < JekyllUnitTest
           "methods" => {
             "output" => true
           }
-        },
+        }
       })
       @site.process
-      @document = @site.collections["methods"].docs.find { |doc| doc.relative_path == "_methods/escape-+ #%20[].md" }
+      @document = @site.collections["methods"].docs.find do |doc|
+        doc.relative_path == "_methods/escape-+ #%20[].md"
+      end
       @dest_file = dest_dir("methods/escape-+ #%20[].html")
     end
 
@@ -476,7 +491,5 @@ class TestDocument < JekyllUnitTest
     should "be output in the correct place" do
       assert_equal true, File.file?(@dest_file)
     end
-
   end
-
 end

test/test_entry_filter.rb

@@ -1,4 +1,4 @@
-require 'helper'
+require "helper"
 
 class TestEntryFilter < JekyllUnitTest
   context "Filtering entries" do
@@ -7,16 +7,16 @@ class TestEntryFilter < JekyllUnitTest
     end
 
     should "filter entries" do
-      ent1 = %w[foo.markdown bar.markdown baz.markdown #baz.markdown#
-              .baz.markdow foo.markdown~ .htaccess _posts _pages ~$benbalter.docx]
+      ent1 = %w(foo.markdown bar.markdown baz.markdown #baz.markdown#
+              .baz.markdow foo.markdown~ .htaccess _posts _pages ~$benbalter.docx)
 
       entries = EntryFilter.new(@site).filter(ent1)
-      assert_equal %w[foo.markdown bar.markdown baz.markdown .htaccess], entries
+      assert_equal %w(foo.markdown bar.markdown baz.markdown .htaccess), entries
     end
 
     should "allow regexp filtering" do
       files = %w(README.md)
-      @site.exclude = excludes = [
+      @site.exclude = [
         /README/
       ]
 
@@ -26,63 +26,69 @@ class TestEntryFilter < JekyllUnitTest
     end
 
     should "filter entries with exclude" do
-      excludes = %w[README TODO vendor/bundle]
-      files = %w[index.html site.css .htaccess vendor]
+      excludes = %w(README TODO vendor/bundle)
+      files = %w(index.html site.css .htaccess vendor)
 
       @site.exclude = excludes + ["exclude*"]
       assert_equal files, @site.reader.filter_entries(excludes + files + ["excludeA"])
     end
 
     should "filter entries with exclude relative to site source" do
-      excludes = %w[README TODO css]
-      files = %w[index.html vendor/css .htaccess]
+      excludes = %w(README TODO css)
+      files = %w(index.html vendor/css .htaccess)
 
       @site.exclude = excludes
       assert_equal files, @site.reader.filter_entries(excludes + files + ["css"])
     end
 
     should "filter excluded directory and contained files" do
-      excludes = %w[README TODO css]
-      files = %w[index.html .htaccess]
+      excludes = %w(README TODO css)
+      files = %w(index.html .htaccess)
 
       @site.exclude = excludes
-      assert_equal files, @site.reader.filter_entries(excludes + files + ["css", "css/main.css", "css/vendor.css"])
+      assert_equal(
+        files,
+        @site.reader.filter_entries(
+          excludes + files + ["css", "css/main.css", "css/vendor.css"]
+        )
+      )
     end
 
     should "not filter entries within include" do
-      includes = %w[_index.html .htaccess include*]
-      files = %w[index.html _index.html .htaccess includeA]
+      includes = %w(_index.html .htaccess include*)
+      files = %w(index.html _index.html .htaccess includeA)
 
       @site.include = includes
       assert_equal files, @site.reader.filter_entries(files)
     end
 
     should "keep safe symlink entries when safe mode enabled" do
-      site = Site.new(site_configuration('safe' => true))
-      allow(File).to receive(:symlink?).with('symlink.js').and_return(true)
-      files = %w[symlink.js]
+      allow(File).to receive(:symlink?).with("symlink.js").and_return(true)
+      files = %w(symlink.js)
       assert_equal files, @site.reader.filter_entries(files)
     end
 
     should "not filter symlink entries when safe mode disabled" do
-      allow(File).to receive(:symlink?).with('symlink.js').and_return(true)
-      files = %w[symlink.js]
+      allow(File).to receive(:symlink?).with("symlink.js").and_return(true)
+      files = %w(symlink.js)
       assert_equal files, @site.reader.filter_entries(files)
     end
 
     should "filter symlink pointing outside site source" do
-      ent1 = %w[_includes/tmp]
+      ent1 = %w(_includes/tmp)
       entries = EntryFilter.new(@site).filter(ent1)
-      assert_equal %w[], entries
+      assert_equal %w(), entries
     end
 
+    # rubocop:disable Performance/FixedSize
     should "include only safe symlinks in safe mode" do
-      site = Site.new(site_configuration('safe' => true))
-
+      site = Site.new(site_configuration("safe" => true))
       site.reader.read_directories("symlink-test")
-      assert_equal %w[main.scss symlinked-file].length, site.pages.length
+
+      assert_equal %w(main.scss symlinked-file).length, site.pages.length
       refute_equal [], site.static_files
     end
+    # rubocop:enable Performance/FixedSize
 
     should "include symlinks in unsafe mode" do
       site = Site.new(site_configuration)
@@ -118,9 +124,9 @@ class TestEntryFilter < JekyllUnitTest
     end
 
     should "match even if there is no leading slash" do
-      data = ['vendor/bundle']
-      assert @filter.glob_include?(data, '/vendor/bundle')
-      assert @filter.glob_include?(data, 'vendor/bundle')
+      data = ["vendor/bundle"]
+      assert @filter.glob_include?(data, "/vendor/bundle")
+      assert @filter.glob_include?(data, "vendor/bundle")
     end
   end
 end

test/test_filters.rb

@@ -1,6 +1,6 @@
 # coding: utf-8
 
-require 'helper'
+require "helper"
 
 class TestFilters < JekyllUnitTest
   class JekyllFilter
@@ -8,18 +8,24 @@ class TestFilters < JekyllUnitTest
     attr_accessor :site, :context
 
     def initialize(opts = {})
-      @site = Jekyll::Site.new(Jekyll.configuration(opts.merge('skip_config_files' => true)))
+      @site = Jekyll::Site.new(
+        Jekyll.configuration(opts.merge("skip_config_files" => true))
+      )
       @context = Liquid::Context.new({}, {}, { :site => @site })
     end
   end
 
   context "filters" do
     setup do
-      @filter = JekyllFilter.new({"source" => source_dir, "destination" => dest_dir, "timezone" => "UTC"})
+      @filter = JekyllFilter.new({
+        "source"      => source_dir,
+        "destination" => dest_dir,
+        "timezone"    => "UTC"
+      })
       @sample_time = Time.utc(2013, 03, 27, 11, 22, 33)
       @sample_date = Date.parse("2013-03-27")
       @time_as_string = "September 11, 2001 12:46:30 -0000"
-      @time_as_numeric = 1399680607
+      @time_as_numeric = 1_399_680_607
       @array_of_objects = [
         { "color" => "red",  "size" => "large"  },
         { "color" => "red",  "size" => "medium" },
@@ -28,18 +34,30 @@ class TestFilters < JekyllUnitTest
     end
 
     should "markdownify with simple string" do
-      assert_equal "<p>something <strong>really</strong> simple</p>\n", @filter.markdownify("something **really** simple")
+      assert_equal(
+        "<p>something <strong>really</strong> simple</p>\n",
+        @filter.markdownify("something **really** simple")
+      )
     end
 
     context "smartify filter" do
       should "convert quotes and typographic characters" do
-        assert_equal "SmartyPants is *not* Markdown", @filter.smartify("SmartyPants is *not* Markdown")
-        assert_equal "“This filter’s test…”", @filter.smartify(%q{"This filter's test..."})
+        assert_equal(
+          "SmartyPants is *not* Markdown",
+          @filter.smartify("SmartyPants is *not* Markdown")
+        )
+        assert_equal(
+          "“This filter’s test…”",
+          @filter.smartify(%q{"This filter's test..."})
+        )
       end
 
       should "escapes special characters when configured to do so" do
-        kramdown = JekyllFilter.new({:kramdown => {:entity_output => :symbolic}})
-        assert_equal "&ldquo;This filter&rsquo;s test&hellip;&rdquo;", kramdown.smartify(%q{"This filter's test..."})
+        kramdown = JekyllFilter.new({ :kramdown => { :entity_output => :symbolic } })
+        assert_equal(
+          "&ldquo;This filter&rsquo;s test&hellip;&rdquo;",
+          kramdown.smartify(%q{"This filter's test..."})
+        )
       end
 
       should "convert HTML entities to unicode characters" do
@@ -48,8 +66,14 @@ class TestFilters < JekyllUnitTest
       end
 
       should "allow raw HTML passthrough" do
-        assert_equal "Span HTML is <em>not</em> escaped", @filter.smartify("Span HTML is <em>not</em> escaped")
-        assert_equal "<div>Block HTML is not escaped</div>", @filter.smartify("<div>Block HTML is not escaped</div>")
+        assert_equal(
+          "Span HTML is <em>not</em> escaped",
+          @filter.smartify("Span HTML is <em>not</em> escaped")
+        )
+        assert_equal(
+          "<div>Block HTML is not escaped</div>",
+          @filter.smartify("<div>Block HTML is not escaped</div>")
+        )
       end
 
       should "escape special characters" do
@@ -60,11 +84,17 @@ class TestFilters < JekyllUnitTest
     end
 
     should "sassify with simple string" do
-      assert_equal "p {\n  color: #123456; }\n", @filter.sassify("$blue:#123456\np\n  color: $blue")
+      assert_equal(
+        "p {\n  color: #123456; }\n",
+        @filter.sassify("$blue:#123456\np\n  color: $blue")
+      )
     end
 
     should "scssify with simple string" do
-      assert_equal "p {\n  color: #123456; }\n", @filter.scssify("$blue:#123456; p{color: $blue}")
+      assert_equal(
+        "p {\n  color: #123456; }\n",
+        @filter.scssify("$blue:#123456; p{color: $blue}")
+      )
     end
 
     should "convert array to sentence string with no args" do
@@ -78,12 +108,15 @@ class TestFilters < JekyllUnitTest
 
     should "convert array to sentence string with two args" do
       assert_equal "1 and 2", @filter.array_to_sentence_string([1, 2])
-      assert_equal "chunky and bacon", @filter.array_to_sentence_string(["chunky", "bacon"])
+      assert_equal "chunky and bacon", @filter.array_to_sentence_string(%w(chunky bacon))
     end
 
     should "convert array to sentence string with multiple args" do
       assert_equal "1, 2, 3, and 4", @filter.array_to_sentence_string([1, 2, 3, 4])
-      assert_equal "chunky, bacon, bits, and pieces", @filter.array_to_sentence_string(["chunky", "bacon", "bits", "pieces"])
+      assert_equal(
+        "chunky, bacon, bits, and pieces",
+        @filter.array_to_sentence_string(%w(chunky bacon bits pieces))
+      )
     end
 
     context "date filters" do
@@ -97,11 +130,17 @@ class TestFilters < JekyllUnitTest
         end
 
         should "format a time with xmlschema" do
-          assert_equal "2013-03-27T11:22:33+00:00", @filter.date_to_xmlschema(@sample_time)
+          assert_equal(
+            "2013-03-27T11:22:33+00:00",
+            @filter.date_to_xmlschema(@sample_time)
+          )
         end
 
         should "format a time according to RFC-822" do
-          assert_equal "Wed, 27 Mar 2013 11:22:33 +0000", @filter.date_to_rfc822(@sample_time)
+          assert_equal(
+            "Wed, 27 Mar 2013 11:22:33 +0000",
+            @filter.date_to_rfc822(@sample_time)
+          )
         end
 
         should "not modify a time in-place when using filters" do
@@ -122,11 +161,17 @@ class TestFilters < JekyllUnitTest
         end
 
         should "format a time with xmlschema" do
-          assert_equal "2013-03-27T00:00:00+00:00", @filter.date_to_xmlschema(@sample_date)
+          assert_equal(
+            "2013-03-27T00:00:00+00:00",
+            @filter.date_to_xmlschema(@sample_date)
+          )
         end
 
         should "format a time according to RFC-822" do
-          assert_equal "Wed, 27 Mar 2013 00:00:00 +0000", @filter.date_to_rfc822(@sample_date)
+          assert_equal(
+            "Wed, 27 Mar 2013 00:00:00 +0000",
+            @filter.date_to_rfc822(@sample_date)
+          )
         end
       end
 
@@ -140,11 +185,17 @@ class TestFilters < JekyllUnitTest
         end
 
         should "format a time with xmlschema" do
-          assert_equal "2001-09-11T12:46:30+00:00", @filter.date_to_xmlschema(@time_as_string)
+          assert_equal(
+            "2001-09-11T12:46:30+00:00",
+            @filter.date_to_xmlschema(@time_as_string)
+          )
         end
 
         should "format a time according to RFC-822" do
-          assert_equal "Tue, 11 Sep 2001 12:46:30 +0000", @filter.date_to_rfc822(@time_as_string)
+          assert_equal(
+            "Tue, 11 Sep 2001 12:46:30 +0000",
+            @filter.date_to_rfc822(@time_as_string)
+          )
         end
       end
 
@@ -158,18 +209,27 @@ class TestFilters < JekyllUnitTest
         end
 
         should "format a time with xmlschema" do
-          assert_match(/2014-05-10T00:10:07/, @filter.date_to_xmlschema(@time_as_numeric))
+          assert_match(
+            "2014-05-10T00:10:07",
+            @filter.date_to_xmlschema(@time_as_numeric)
+          )
         end
 
         should "format a time according to RFC-822" do
-          assert_equal "Sat, 10 May 2014 00:10:07 +0000", @filter.date_to_rfc822(@time_as_numeric)
+          assert_equal(
+            "Sat, 10 May 2014 00:10:07 +0000",
+            @filter.date_to_rfc822(@time_as_numeric)
+          )
         end
       end
     end
 
     should "escape xml with ampersands" do
       assert_equal "AT&amp;T", @filter.xml_escape("AT&T")
-      assert_equal "&lt;code&gt;command &amp;lt;filename&amp;gt;&lt;/code&gt;", @filter.xml_escape("<code>command &lt;filename&gt;</code>")
+      assert_equal(
+        "&lt;code&gt;command &amp;lt;filename&amp;gt;&lt;/code&gt;",
+        @filter.xml_escape("<code>command &lt;filename&gt;</code>")
+      )
     end
 
     should "not error when xml escaping nil" do
@@ -190,12 +250,15 @@ class TestFilters < JekyllUnitTest
 
     context "jsonify filter" do
       should "convert hash to json" do
-        assert_equal "{\"age\":18}", @filter.jsonify({:age => 18})
+        assert_equal "{\"age\":18}", @filter.jsonify({ :age => 18 })
       end
 
       should "convert array to json" do
         assert_equal "[1,2]", @filter.jsonify([1, 2])
-        assert_equal "[{\"name\":\"Jack\"},{\"name\":\"Smith\"}]", @filter.jsonify([{:name => 'Jack'}, {:name => 'Smith'}])
+        assert_equal(
+          "[{\"name\":\"Jack\"},{\"name\":\"Smith\"}]",
+          @filter.jsonify([{ :name => "Jack" }, { :name => "Smith" }])
+        )
       end
 
       should "convert drop to json" do
@@ -240,6 +303,7 @@ class TestFilters < JekyllUnitTest
         }
       end
 
+      # rubocop:disable Style/StructInheritance
       class M < Struct.new(:message)
         def to_liquid
           [message]
@@ -247,7 +311,12 @@ class TestFilters < JekyllUnitTest
       end
       class T < Struct.new(:name)
         def to_liquid
-          { "name" => name, :v => 1, :thing => M.new({:kay => "jewelers"}), :stuff => true }
+          {
+            "name" => name,
+            :v     => 1,
+            :thing => M.new({ :kay => "jewelers" }),
+            :stuff => true
+          }
         end
       end
 
@@ -277,6 +346,7 @@ class TestFilters < JekyllUnitTest
         result = @filter.jsonify([T.new("Jeremiah"), T.new("Smathers")])
         assert_equal expected, JSON.parse(result)
       end
+      # rubocop:enable Style/StructInheritance
 
       should "handle hashes with all sorts of weird keys and values" do
         my_hash = { "posts" => Array.new(3) { |i| T.new(i) } }
@@ -324,16 +394,28 @@ class TestFilters < JekyllUnitTest
         @filter.site.process
         grouping = @filter.group_by(@filter.site.pages, "layout")
         grouping.each do |g|
-          assert ["default", "nil", ""].include?(g["name"]), "#{g['name']} isn't a valid grouping."
+          assert(
+            ["default", "nil", ""].include?(g["name"]),
+            "#{g["name"]} isn't a valid grouping."
+          )
           case g["name"]
           when "default"
-            assert g["items"].is_a?(Array), "The list of grouped items for 'default' is not an Array."
+            assert(
+              g["items"].is_a?(Array),
+              "The list of grouped items for 'default' is not an Array."
+            )
             assert_equal 5, g["items"].size
           when "nil"
-            assert g["items"].is_a?(Array), "The list of grouped items for 'nil' is not an Array."
+            assert(
+              g["items"].is_a?(Array),
+              "The list of grouped items for 'nil' is not an Array."
+            )
             assert_equal 2, g["items"].size
           when ""
-            assert g["items"].is_a?(Array), "The list of grouped items for '' is not an Array."
+            assert(
+              g["items"].is_a?(Array),
+              "The list of grouped items for '' is not an Array."
+            )
             assert_equal 13, g["items"].size
           end
         end
@@ -343,7 +425,11 @@ class TestFilters < JekyllUnitTest
         grouping = @filter.group_by(@filter.site.pages, "layout")
         grouping.each do |g|
           p g
-          assert_equal g["items"].size, g["size"], "The size property for '#{g["name"]}' doesn't match the size of the Array."
+          assert_equal(
+            g["items"].size,
+            g["size"],
+            "The size property for '#{g["name"]}' doesn't match the size of the Array."
+          )
         end
       end
     end
@@ -354,9 +440,9 @@ class TestFilters < JekyllUnitTest
       end
 
       should "filter objects in a hash appropriately" do
-        hash = {"a"=>{"color"=>"red"}, "b"=>{"color"=>"blue"}}
+        hash = { "a"=>{ "color"=>"red" }, "b"=>{ "color"=>"blue" } }
         assert_equal 1, @filter.where(hash, "color", "red").length
-        assert_equal [{"color"=>"red"}], @filter.where(hash, "color", "red")
+        assert_equal [{ "color"=>"red" }], @filter.where(hash, "color", "red")
       end
 
       should "filter objects appropriately" do
@@ -364,25 +450,37 @@ class TestFilters < JekyllUnitTest
       end
 
       should "filter array properties appropriately" do
-        hash = {"a"=>{"tags"=>["x","y"]}, "b"=>{"tags"=>["x"]}, "c"=>{"tags"=>["y","z"]}}
+        hash = {
+          "a" => { "tags"=>%w(x y) },
+          "b" => { "tags"=>["x"] },
+          "c" => { "tags"=>%w(y z) }
+        }
         assert_equal 2, @filter.where(hash, "tags", "x").length
       end
 
       should "filter array properties alongside string properties" do
-        hash = {"a"=>{"tags"=>["x","y"]}, "b"=>{"tags"=>"x"}, "c"=>{"tags"=>["y","z"]}}
+        hash = {
+          "a" => { "tags"=>%w(x y) },
+          "b" => { "tags"=>"x" },
+          "c" => { "tags"=>%w(y z) }
+        }
         assert_equal 2, @filter.where(hash, "tags", "x").length
       end
 
       should "not match substrings" do
-        hash = {"a"=>{"category"=>"bear"}, "b"=>{"category"=>"wolf"}, "c"=>{"category"=>["bear","lion"]}}
+        hash = {
+          "a" => { "category"=>"bear" },
+          "b" => { "category"=>"wolf" },
+          "c" => { "category"=>%w(bear lion) }
+        }
         assert_equal 0, @filter.where(hash, "category", "ear").length
       end
 
       should "stringify during comparison for compatibility with liquid parsing" do
         hash = {
-          "The Words" => {"rating" => 1.2, "featured" => false},
-          "Limitless" => {"rating" => 9.2, "featured" => true},
-          "Hustle"    => {"rating" => 4.7, "featured" => true},
+          "The Words" => { "rating" => 1.2, "featured" => false },
+          "Limitless" => { "rating" => 9.2, "featured" => true },
+          "Hustle"    => { "rating" => 4.7, "featured" => true }
         }
 
         results = @filter.where(hash, "featured", "true")
@@ -402,20 +500,26 @@ class TestFilters < JekyllUnitTest
       end
 
       should "filter objects in a hash appropriately" do
-        hash = {"a"=>{"color"=>"red"}, "b"=>{"color"=>"blue"}}
+        hash = { "a"=>{ "color"=>"red" }, "b"=>{ "color"=>"blue" } }
         assert_equal 1, @filter.where_exp(hash, "item", "item.color == 'red'").length
-        assert_equal [{"color"=>"red"}], @filter.where_exp(hash, "item", "item.color == 'red'")
+        assert_equal(
+          [{ "color"=>"red" }],
+          @filter.where_exp(hash, "item", "item.color == 'red'")
+        )
       end
 
       should "filter objects appropriately" do
-        assert_equal 2, @filter.where_exp(@array_of_objects, "item", "item.color == 'red'").length
+        assert_equal(
+          2,
+          @filter.where_exp(@array_of_objects, "item", "item.color == 'red'").length
+        )
       end
 
       should "stringify during comparison for compatibility with liquid parsing" do
         hash = {
-          "The Words" => {"rating" => 1.2, "featured" => false},
-          "Limitless" => {"rating" => 9.2, "featured" => true},
-          "Hustle"    => {"rating" => 4.7, "featured" => true},
+          "The Words" => { "rating" => 1.2, "featured" => false },
+          "Limitless" => { "rating" => 9.2, "featured" => true },
+          "Hustle"    => { "rating" => 4.7, "featured" => true }
         }
 
         results = @filter.where_exp(hash, "item", "item.featured == true")
@@ -465,28 +569,31 @@ class TestFilters < JekyllUnitTest
         assert_equal [1, 2, 2.2, 3], @filter.sort([3, 2.2, 2, 1])
       end
       should "return sorted strings" do
-        assert_equal ["10", "2"], @filter.sort(["10", "2"])
-        assert_equal [{"a" => "10"}, {"a" => "2"}], @filter.sort([{"a" => "10"}, {"a" => "2"}], "a")
-        assert_equal ["FOO", "Foo", "foo"], @filter.sort(["foo", "Foo", "FOO"])
-        assert_equal ["_foo", "foo", "foo_"], @filter.sort(["foo_", "_foo", "foo"])
+        assert_equal %w(10 2), @filter.sort(%w(10 2))
+        assert_equal(
+          [{ "a" => "10" }, { "a" => "2" }],
+          @filter.sort([{ "a" => "10" }, { "a" => "2" }], "a")
+        )
+        assert_equal %w(FOO Foo foo), @filter.sort(%w(foo Foo FOO))
+        assert_equal %w(_foo foo foo_), @filter.sort(%w(foo_ _foo foo))
         # Cyrillic
-        assert_equal ["ВУЗ", "Вуз", "вуз"], @filter.sort(["Вуз", "вуз", "ВУЗ"])
-        assert_equal ["_вуз", "вуз", "вуз_"], @filter.sort(["вуз_", "_вуз", "вуз"])
+        assert_equal %w(ВУЗ Вуз вуз), @filter.sort(%w(Вуз вуз ВУЗ))
+        assert_equal %w(_вуз вуз вуз_), @filter.sort(%w(вуз_ _вуз вуз))
         # Hebrew
-        assert_equal ["אלף", "בית"], @filter.sort(["בית", "אלף"])
+        assert_equal %w(אלף בית), @filter.sort(%w(בית אלף))
       end
       should "return sorted by property array" do
-        assert_equal [{"a" => 1}, {"a" => 2}, {"a" => 3}, {"a" => 4}],
-          @filter.sort([{"a" => 4}, {"a" => 3}, {"a" => 1}, {"a" => 2}], "a")
+        assert_equal [{ "a" => 1 }, { "a" => 2 }, { "a" => 3 }, { "a" => 4 }],
+          @filter.sort([{ "a" => 4 }, { "a" => 3 }, { "a" => 1 }, { "a" => 2 }], "a")
       end
       should "return sorted by property array with nils first" do
-        ary = [{"a" => 2}, {"b" => 1}, {"a" => 1}]
-        assert_equal [{"b" => 1}, {"a" => 1}, {"a" => 2}], @filter.sort(ary, "a")
+        ary = [{ "a" => 2 }, { "b" => 1 }, { "a" => 1 }]
+        assert_equal [{ "b" => 1 }, { "a" => 1 }, { "a" => 2 }], @filter.sort(ary, "a")
         assert_equal @filter.sort(ary, "a"), @filter.sort(ary, "a", "first")
       end
       should "return sorted by property array with nils last" do
-        assert_equal [{"a" => 1}, {"a" => 2}, {"b" => 1}],
-          @filter.sort([{"a" => 2}, {"b" => 1}, {"a" => 1}], "a", "last")
+        assert_equal [{ "a" => 1 }, { "a" => 2 }, { "b" => 1 }],
+          @filter.sort([{ "a" => 2 }, { "b" => 1 }, { "a" => 1 }], "a", "last")
       end
     end
 
@@ -512,41 +619,41 @@ class TestFilters < JekyllUnitTest
 
     context "push filter" do
       should "return a new array with the element pushed to the end" do
-        assert_equal %w{hi there bernie}, @filter.push(%w{hi there}, "bernie")
+        assert_equal %w(hi there bernie), @filter.push(%w(hi there), "bernie")
       end
     end
 
     context "pop filter" do
       should "return a new array with the last element popped" do
-        assert_equal %w{hi there}, @filter.pop(%w{hi there bernie})
+        assert_equal %w(hi there), @filter.pop(%w(hi there bernie))
       end
 
       should "allow multiple els to be popped" do
-        assert_equal %w{hi there bert}, @filter.pop(%w{hi there bert and ernie}, 2)
+        assert_equal %w(hi there bert), @filter.pop(%w(hi there bert and ernie), 2)
       end
 
       should "cast string inputs for # into nums" do
-        assert_equal %w{hi there bert}, @filter.pop(%w{hi there bert and ernie}, "2")
+        assert_equal %w(hi there bert), @filter.pop(%w(hi there bert and ernie), "2")
       end
     end
 
     context "shift filter" do
       should "return a new array with the element removed from the front" do
-        assert_equal %w{a friendly greeting}, @filter.shift(%w{just a friendly greeting})
+        assert_equal %w(a friendly greeting), @filter.shift(%w(just a friendly greeting))
       end
 
       should "allow multiple els to be shifted" do
-        assert_equal %w{bert and ernie}, @filter.shift(%w{hi there bert and ernie}, 2)
+        assert_equal %w(bert and ernie), @filter.shift(%w(hi there bert and ernie), 2)
       end
 
       should "cast string inputs for # into nums" do
-        assert_equal %w{bert and ernie}, @filter.shift(%w{hi there bert and ernie}, "2")
+        assert_equal %w(bert and ernie), @filter.shift(%w(hi there bert and ernie), "2")
       end
     end
 
     context "unshift filter" do
       should "return a new array with the element put at the front" do
-        assert_equal %w{aloha there bernie}, @filter.unshift(%w{there bernie}, "aloha")
+        assert_equal %w(aloha there bernie), @filter.unshift(%w(there bernie), "aloha")
       end
     end
 
@@ -563,6 +670,5 @@ class TestFilters < JekyllUnitTest
         end
       end
     end
-
   end
 end

test/test_kramdown.rb

@@ -1,22 +1,22 @@
 # encoding: UTF-8
 
-require 'helper'
+require "helper"
 
 class TestKramdown < JekyllUnitTest
   context "kramdown" do
     setup do
       @config = {
-        'markdown' => 'kramdown',
-        'kramdown' => {
-          'smart_quotes' => 'lsquo,rsquo,ldquo,rdquo',
-          'entity_output' => 'as_char',
-          'toc_levels' => '1..6',
-          'auto_ids' => false,
-          'footnote_nr' => 1,
+        "markdown" => "kramdown",
+        "kramdown" => {
+          "smart_quotes"            => "lsquo,rsquo,ldquo,rdquo",
+          "entity_output"           => "as_char",
+          "toc_levels"              => "1..6",
+          "auto_ids"                => false,
+          "footnote_nr"             => 1,
 
-          'syntax_highlighter' => 'rouge',
-          'syntax_highlighter_opts' => {
-            'bold_every' => 8, 'css' => :class
+          "syntax_highlighter"      => "rouge",
+          "syntax_highlighter_opts" => {
+            "bold_every" => 8, "css" => :class
           }
         }
       }
@@ -33,25 +33,28 @@ class TestKramdown < JekyllUnitTest
 
     context "when asked to convert smart quotes" do
       should "convert" do
-        assert_match %r!<p>(&#8220;|“)Pit(&#8217;|’)hy(&#8221;|”)<\/p>!, @markdown.convert(%{"Pit'hy"}).strip
+        assert_match(
+          %r!<p>(&#8220;|“)Pit(&#8217;|’)hy(&#8221;|”)<\/p>!,
+          @markdown.convert(%("Pit'hy")).strip
+        )
       end
 
       should "support custom types" do
         override = {
           "highlighter" => nil,
-          'kramdown' => {
-            'smart_quotes' => 'lsaquo,rsaquo,laquo,raquo'
+          "kramdown"    => {
+            "smart_quotes" => "lsaquo,rsaquo,laquo,raquo"
           }
         }
 
         markdown = Converters::Markdown.new(Utils.deep_merge_hashes(@config, override))
         assert_match %r!<p>(&#171;|«)Pit(&#8250;|›)hy(&#187;|»)<\/p>!, \
-          markdown.convert(%{"Pit'hy"}).strip
+          markdown.convert(%("Pit'hy")).strip
       end
     end
 
     should "render fenced code blocks with syntax highlighting" do
-      result = nokogiri_fragment(@markdown.convert(Utils.strip_heredoc <<-MARKDOWN))
+      result = nokogiri_fragment(@markdown.convert(Utils.strip_heredoc(<<-MARKDOWN)))
         ~~~ruby
         puts "Hello World"
         ~~~
@@ -72,7 +75,7 @@ class TestKramdown < JekyllUnitTest
         }
 
         markdown = Converters::Markdown.new(Utils.deep_merge_hashes(@config, override))
-        result = nokogiri_fragment(markdown.convert(Utils.strip_heredoc <<-MARKDOWN))
+        result = nokogiri_fragment(markdown.convert(Utils.strip_heredoc(<<-MARKDOWN)))
           ~~~ruby
           puts "Hello World"
           ~~~
@@ -86,14 +89,14 @@ class TestKramdown < JekyllUnitTest
         override = {
           "markdown" => "kramdown",
           "kramdown" => {
-            "enable_coderay" => true,
+            "enable_coderay" => true
           }
         }
 
         @config.delete("highlighter")
         @config["kramdown"].delete("syntax_highlighter")
         markdown = Converters::Markdown.new(Utils.deep_merge_hashes(@config, override))
-        result = nokogiri_fragment(markdown.convert(Utils.strip_heredoc <<-MARKDOWN))
+        result = nokogiri_fragment(markdown.convert(Utils.strip_heredoc(<<-MARKDOWN)))
           ~~~ruby
           puts "Hello World"
           ~~~

test/test_liquid_renderer.rb

@@ -1,4 +1,4 @@
-require 'helper'
+require "helper"
 
 class TestLiquidRenderer < JekyllUnitTest
   context "profiler" do
@@ -12,11 +12,13 @@ class TestLiquidRenderer < JekyllUnitTest
 
       output = @renderer.stats_table
 
+      # rubocop:disable Metrics/LineLength
       expected = [
         /^Filename\s+|\s+Count\s+|\s+Bytes\s+|\s+Time$/,
         /^-+\++-+\++-+\++-+$/,
-        /^_posts\/2010-01-09-date-override\.markdown\s+|\s+\d+\s+|\s+\d+\.\d{2}K\s+|\s+\d+\.\d{3}$/,
+        %r!^_posts/2010-01-09-date-override\.markdown\s+|\s+\d+\s+|\s+\d+\.\d{2}K\s+|\s+\d+\.\d{3}$!
       ]
+      # rubocop:enable Metrics/LineLength
 
       expected.each do |regexp|
         assert_match regexp, output

test/test_page.rb

@@ -1,15 +1,18 @@
-require 'helper'
+require "helper"
 
 class TestPage < JekyllUnitTest
   def setup_page(*args)
     dir, file = args
-    dir, file = ['', dir] if file.nil?
+    if file.nil?
+      file = dir
+      dir = ""
+    end
     @page = Page.new(@site, source_dir, dir, file)
   end
 
   def do_render(page)
     layouts = {
-      "default" => Layout.new(@site, source_dir('_layouts'), "simple.html")
+      "default" => Layout.new(@site, source_dir("_layouts"), "simple.html")
     }
     page.render(layouts, @site.site_payload)
   end
@@ -26,7 +29,7 @@ class TestPage < JekyllUnitTest
 
     context "processing pages" do
       should "create url based on filename" do
-        @page = setup_page('contacts.html')
+        @page = setup_page("contacts.html")
         assert_equal "/contacts.html", @page.url
       end
 
@@ -36,29 +39,29 @@ class TestPage < JekyllUnitTest
       end
 
       should "create url with non-alphabetic characters" do
-        @page = setup_page('+', '%# +.md')
+        @page = setup_page("+", '%# +.md')
         assert_equal "/+/%25%23%20+.html", @page.url
       end
 
       context "in a directory hierarchy" do
         should "create url based on filename" do
-          @page = setup_page('/contacts', 'bar.html')
+          @page = setup_page("/contacts", "bar.html")
           assert_equal "/contacts/bar.html", @page.url
         end
 
         should "create index url based on filename" do
-          @page = setup_page('/contacts', 'index.html')
+          @page = setup_page("/contacts", "index.html")
           assert_equal "/contacts/", @page.url
         end
       end
 
       should "deal properly with extensions" do
-        @page = setup_page('deal.with.dots.html')
+        @page = setup_page("deal.with.dots.html")
         assert_equal ".html", @page.ext
       end
 
       should "deal properly with non-html extensions" do
-        @page = setup_page('dynamic_page.php')
+        @page = setup_page("dynamic_page.php")
         @dest_file = dest_dir("dynamic_page.php")
         assert_equal ".php", @page.ext
         assert_equal "dynamic_page", @page.basename
@@ -67,7 +70,7 @@ class TestPage < JekyllUnitTest
       end
 
       should "deal properly with dots" do
-        @page = setup_page('deal.with.dots.html')
+        @page = setup_page("deal.with.dots.html")
         @dest_file = dest_dir("deal.with.dots.html")
 
         assert_equal "deal.with.dots", @page.basename
@@ -75,19 +78,19 @@ class TestPage < JekyllUnitTest
       end
 
       should "make properties accessible through #[]" do
-        page = setup_page('properties.html')
+        page = setup_page("properties.html")
         attrs = {
-          content: "All the properties.\n",
-          dir: "/properties/",
-          excerpt: nil,
-          foo: 'bar',
-          layout: 'default',
-          name: "properties.html",
-          path: "properties.html",
-          permalink: '/properties/',
-          published: nil,
-          title: 'Properties Page',
-          url: "/properties/"
+          :content   => "All the properties.\n",
+          :dir       => "/properties/",
+          :excerpt   => nil,
+          :foo       => "bar",
+          :layout    => "default",
+          :name      => "properties.html",
+          :path      => "properties.html",
+          :permalink => "/properties/",
+          :published => nil,
+          :title     => "Properties Page",
+          :url       => "/properties/"
         }
 
         attrs.each do |attr, val|
@@ -103,38 +106,38 @@ class TestPage < JekyllUnitTest
         end
 
         should "return dir, url, and destination correctly" do
-          @page = setup_page('contacts.html')
+          @page = setup_page("contacts.html")
           @dest_file = dest_dir("contacts/index.html")
 
-          assert_equal '/contacts/', @page.dir
-          assert_equal '/contacts/', @page.url
+          assert_equal "/contacts/", @page.dir
+          assert_equal "/contacts/", @page.url
           assert_equal @dest_file, @page.destination(dest_dir)
         end
 
         should "return dir correctly for index page" do
-          @page = setup_page('index.html')
-          assert_equal '/', @page.dir
+          @page = setup_page("index.html")
+          assert_equal "/", @page.dir
         end
 
         context "in a directory hierarchy" do
           should "create url based on filename" do
-            @page = setup_page('/contacts', 'bar.html')
+            @page = setup_page("/contacts", "bar.html")
             assert_equal "/contacts/bar/", @page.url
           end
 
           should "create index url based on filename" do
-            @page = setup_page('/contacts', 'index.html')
+            @page = setup_page("/contacts", "index.html")
             assert_equal "/contacts/", @page.url
           end
 
           should "return dir correctly" do
-            @page = setup_page('/contacts', 'bar.html')
-            assert_equal '/contacts/bar/', @page.dir
+            @page = setup_page("/contacts", "bar.html")
+            assert_equal "/contacts/bar/", @page.dir
           end
 
           should "return dir correctly for index page" do
-            @page = setup_page('/contacts', 'index.html')
-            assert_equal '/contacts/', @page.dir
+            @page = setup_page("/contacts", "index.html")
+            assert_equal "/contacts/", @page.dir
           end
         end
       end
@@ -145,16 +148,16 @@ class TestPage < JekyllUnitTest
         end
 
         should "return url and destination correctly" do
-          @page = setup_page('contacts.html')
+          @page = setup_page("contacts.html")
           @dest_file = dest_dir("contacts.html")
-          assert_equal '/contacts.html', @page.url
+          assert_equal "/contacts.html", @page.url
           assert_equal @dest_file, @page.destination(dest_dir)
         end
 
         should "return dir correctly" do
-          assert_equal '/', setup_page('contacts.html').dir
-          assert_equal '/contacts/', setup_page('contacts/bar.html').dir
-          assert_equal '/contacts/', setup_page('contacts/index.html').dir
+          assert_equal "/", setup_page("contacts.html").dir
+          assert_equal "/contacts/", setup_page("contacts/bar.html").dir
+          assert_equal "/contacts/", setup_page("contacts/index.html").dir
         end
       end
 
@@ -164,9 +167,9 @@ class TestPage < JekyllUnitTest
         end
 
         should "return url and destination correctly" do
-          @page = setup_page('contacts.html')
+          @page = setup_page("contacts.html")
           @dest_file = dest_dir("contacts/index.html")
-          assert_equal '/contacts/', @page.url
+          assert_equal "/contacts/", @page.url
           assert_equal @dest_file, @page.destination(dest_dir)
         end
       end
@@ -177,9 +180,9 @@ class TestPage < JekyllUnitTest
         end
 
         should "return url and destination correctly" do
-          @page = setup_page('contacts.html')
+          @page = setup_page("contacts.html")
           @dest_file = dest_dir("contacts.html")
-          assert_equal '/contacts.html', @page.url
+          assert_equal "/contacts.html", @page.url
           assert_equal @dest_file, @page.destination(dest_dir)
         end
       end
@@ -190,9 +193,9 @@ class TestPage < JekyllUnitTest
         end
 
         should "return url and destination correctly" do
-          @page = setup_page('contacts.html')
+          @page = setup_page("contacts.html")
           @dest_file = dest_dir("contacts.html")
-          assert_equal '/contacts', @page.url
+          assert_equal "/contacts", @page.url
           assert_equal @dest_file, @page.destination(dest_dir)
         end
       end
@@ -200,9 +203,9 @@ class TestPage < JekyllUnitTest
       context "with any other permalink style" do
         should "return dir correctly" do
           @site.permalink_style = nil
-          assert_equal '/', setup_page('contacts.html').dir
-          assert_equal '/contacts/', setup_page('contacts/index.html').dir
-          assert_equal '/contacts/', setup_page('contacts/bar.html').dir
+          assert_equal "/", setup_page("contacts.html").dir
+          assert_equal "/contacts/", setup_page("contacts/index.html").dir
+          assert_equal "/contacts/", setup_page("contacts/bar.html").dir
         end
       end
 
@@ -216,7 +219,7 @@ class TestPage < JekyllUnitTest
       end
 
       should "return nil permalink if no permalink exists" do
-        @page = setup_page('')
+        @page = setup_page("")
         assert_equal nil, @page.permalink
       end
 
@@ -233,7 +236,7 @@ class TestPage < JekyllUnitTest
 
     context "with specified layout of nil" do
       setup do
-        @page = setup_page('sitemap.xml')
+        @page = setup_page("sitemap.xml")
       end
 
       should "layout of nil is respected" do
@@ -247,60 +250,60 @@ class TestPage < JekyllUnitTest
       end
 
       should "write properly" do
-        page = setup_page('contacts.html')
+        page = setup_page("contacts.html")
         do_render(page)
         page.write(dest_dir)
 
         assert File.directory?(dest_dir)
-        assert_exist dest_dir('contacts.html')
+        assert_exist dest_dir("contacts.html")
       end
 
       should "write even when the folder name is plus and permalink has +" do
-        page = setup_page('+', 'foo.md')
+        page = setup_page("+", "foo.md")
         do_render(page)
         page.write(dest_dir)
 
         assert File.directory?(dest_dir), "#{dest_dir} should be a directory"
-        assert_exist dest_dir('+', 'plus+in+url.html')
+        assert_exist dest_dir("+", "plus+in+url.html")
       end
 
       should "write even when permalink has '%# +'" do
-        page = setup_page('+', '%# +.md')
+        page = setup_page("+", '%# +.md')
         do_render(page)
         page.write(dest_dir)
 
         assert File.directory?(dest_dir)
-        assert_exist dest_dir('+', '%# +.html')
+        assert_exist dest_dir("+", '%# +.html')
       end
 
       should "write properly without html extension" do
-        page = setup_page('contacts.html')
+        page = setup_page("contacts.html")
         page.site.permalink_style = :pretty
         do_render(page)
         page.write(dest_dir)
 
         assert File.directory?(dest_dir)
-        assert_exist dest_dir('contacts', 'index.html')
+        assert_exist dest_dir("contacts", "index.html")
       end
 
       should "support .htm extension and respects that" do
-        page = setup_page('contacts.htm')
+        page = setup_page("contacts.htm")
         page.site.permalink_style = :pretty
         do_render(page)
         page.write(dest_dir)
 
         assert File.directory?(dest_dir)
-        assert_exist dest_dir('contacts', 'index.htm')
+        assert_exist dest_dir("contacts", "index.htm")
       end
 
       should "support .xhtml extension and respects that" do
-        page = setup_page('contacts.xhtml')
+        page = setup_page("contacts.xhtml")
         page.site.permalink_style = :pretty
         do_render(page)
         page.write(dest_dir)
 
         assert File.directory?(dest_dir)
-        assert_exist dest_dir('contacts', 'index.xhtml')
+        assert_exist dest_dir("contacts", "index.xhtml")
       end
 
       should "write properly with extension different from html" do
@@ -312,48 +315,47 @@ class TestPage < JekyllUnitTest
         assert_equal "/sitemap.xml", page.url
         assert_nil page.url[/\.html$/]
         assert File.directory?(dest_dir)
-        assert_exist dest_dir('sitemap.xml')
+        assert_exist dest_dir("sitemap.xml")
       end
 
       should "write dotfiles properly" do
-        page = setup_page('.htaccess')
+        page = setup_page(".htaccess")
         do_render(page)
         page.write(dest_dir)
 
         assert File.directory?(dest_dir)
-        assert_exist dest_dir('.htaccess')
+        assert_exist dest_dir(".htaccess")
       end
 
       context "in a directory hierarchy" do
         should "write properly the index" do
-          page = setup_page('/contacts', 'index.html')
+          page = setup_page("/contacts", "index.html")
           do_render(page)
           page.write(dest_dir)
 
           assert File.directory?(dest_dir)
-          assert_exist dest_dir('contacts', 'index.html')
+          assert_exist dest_dir("contacts", "index.html")
         end
 
         should "write properly" do
-          page = setup_page('/contacts', 'bar.html')
+          page = setup_page("/contacts", "bar.html")
           do_render(page)
           page.write(dest_dir)
 
           assert File.directory?(dest_dir)
-          assert_exist dest_dir('contacts', 'bar.html')
+          assert_exist dest_dir("contacts", "bar.html")
         end
 
         should "write properly without html extension" do
-          page = setup_page('/contacts', 'bar.html')
+          page = setup_page("/contacts", "bar.html")
           page.site.permalink_style = :pretty
           do_render(page)
           page.write(dest_dir)
 
           assert File.directory?(dest_dir)
-          assert_exist dest_dir('contacts', 'bar', 'index.html')
+          assert_exist dest_dir("contacts", "bar", "index.html")
         end
       end
     end
-
   end
 end

test/test_regenerator.rb

@@ -1,4 +1,4 @@
-require 'helper'
+require "helper"
 
 class TestRegenerator < JekyllUnitTest
   context "The site regenerator" do
@@ -39,12 +39,11 @@ class TestRegenerator < JekyllUnitTest
       # we need to create the destinations for these files,
       # because regenerate? checks if the destination exists
       [@page, @post, @document, @asset_file].each do |item|
-        if item.respond_to?(:destination)
+        next unless item.respond_to?(:destination)
         dest = item.destination(@site.dest)
         FileUtils.mkdir_p(File.dirname(dest))
         FileUtils.touch(dest)
       end
-      end
       @regenerator.write_metadata
       @regenerator = Regenerator.new(@site)
 
@@ -69,7 +68,7 @@ class TestRegenerator < JekyllUnitTest
       [@page, @post, @document, @asset_file].each do |item|
         if item.respond_to?(:destination)
           dest = item.destination(@site.dest)
-          File.unlink(dest) unless !File.exist?(dest)
+          File.unlink(dest) if File.exist?(dest)
         end
       end
 
@@ -171,7 +170,7 @@ class TestRegenerator < JekyllUnitTest
       metadata_file = source_dir(".jekyll-metadata")
       @regenerator = Regenerator.new(@site)
 
-      File.open(metadata_file, 'w') do |f|
+      File.open(metadata_file, "w") do |f|
         f.write(@regenerator.metadata.to_yaml)
       end
 
@@ -182,7 +181,7 @@ class TestRegenerator < JekyllUnitTest
     should "not crash when reading corrupted marshal file" do
       metadata_file = source_dir(".jekyll-metadata")
       File.open(metadata_file, "w") do |file|
-        file.puts Marshal.dump({ foo: 'bar' })[0,5]
+        file.puts Marshal.dump({ :foo => "bar" })[0, 5]
       end
 
       @regenerator = Regenerator.new(@site)
@@ -282,7 +281,7 @@ class TestRegenerator < JekyllUnitTest
     end
 
     should "not regenerate again if multiple dependencies" do
-      multi_deps = @regenerator.metadata.select {|k,v| v['deps'].length > 2}
+      multi_deps = @regenerator.metadata.select { |_k, v| v["deps"].length > 2 }
       multi_dep_path = multi_deps.keys.first
 
       assert @regenerator.metadata[multi_dep_path]["deps"].length > 2

test/test_site.rb

@@ -1,45 +1,47 @@
-require 'helper'
+require "helper"
 
 class TestSite < JekyllUnitTest
   context "configuring sites" do
     should "have an array for plugins by default" do
       site = Site.new default_configuration
-      assert_equal [File.join(Dir.pwd, '_plugins')], site.plugins
+      assert_equal [File.join(Dir.pwd, "_plugins")], site.plugins
     end
 
     should "look for plugins under the site directory by default" do
       site = Site.new(site_configuration)
-      assert_equal [source_dir('_plugins')], site.plugins
+      assert_equal [source_dir("_plugins")], site.plugins
     end
 
     should "have an array for plugins if passed as a string" do
-      site = Site.new(site_configuration({ 'plugins_dir' => '/tmp/plugins' }))
-      assert_equal ['/tmp/plugins'], site.plugins
+      site = Site.new(site_configuration({ "plugins_dir" => "/tmp/plugins" }))
+      assert_equal ["/tmp/plugins"], site.plugins
     end
 
     should "have an array for plugins if passed as an array" do
-      site = Site.new(site_configuration({ 'plugins_dir' => ['/tmp/plugins', '/tmp/otherplugins'] }))
-      assert_equal ['/tmp/plugins', '/tmp/otherplugins'], site.plugins
+      site = Site.new(site_configuration({
+        "plugins_dir" => ["/tmp/plugins", "/tmp/otherplugins"]
+      }))
+      assert_equal ["/tmp/plugins", "/tmp/otherplugins"], site.plugins
     end
 
     should "have an empty array for plugins if nothing is passed" do
-      site = Site.new(site_configuration({ 'plugins_dir' => [] }))
+      site = Site.new(site_configuration({ "plugins_dir" => [] }))
       assert_equal [], site.plugins
     end
 
     should "have the default for plugins if nil is passed" do
-      site = Site.new(site_configuration({ 'plugins_dir' => nil }))
-      assert_equal [source_dir('_plugins')], site.plugins
+      site = Site.new(site_configuration({ "plugins_dir" => nil }))
+      assert_equal [source_dir("_plugins")], site.plugins
     end
 
     should "expose default baseurl" do
       site = Site.new(default_configuration)
-      assert_equal Jekyll::Configuration::DEFAULTS['baseurl'], site.baseurl
+      assert_equal Jekyll::Configuration::DEFAULTS["baseurl"], site.baseurl
     end
 
     should "expose baseurl passed in from config" do
-      site = Site.new(site_configuration({ 'baseurl' => '/blog' }))
-      assert_equal '/blog', site.baseurl
+      site = Site.new(site_configuration({ "baseurl" => "/blog" }))
+      assert_equal "/blog", site.baseurl
     end
   end
   context "creating sites" do
@@ -55,7 +57,7 @@ class TestSite < JekyllUnitTest
     end
 
     should "have an empty tag hash by default" do
-      assert_equal Hash.new, @site.tags
+      assert_equal({}, @site.tags)
     end
 
     should "give site with parsed pages and posts to generators" do
@@ -65,14 +67,14 @@ class TestSite < JekyllUnitTest
             raise "#{page} isn't a page" unless page.is_a?(Page)
             raise "#{page} doesn't respond to :name" unless page.respond_to?(:name)
           end
-          site.file_read_opts[:secret_message] = 'hi'
+          site.file_read_opts[:secret_message] = "hi"
         end
       end
       @site = Site.new(site_configuration)
       @site.read
       @site.generate
       refute_equal 0, @site.pages.size
-      assert_equal 'hi', @site.file_read_opts[:secret_message]
+      assert_equal "hi", @site.file_read_opts[:secret_message]
     end
 
     should "reset data before processing" do
@@ -157,13 +159,21 @@ class TestSite < JekyllUnitTest
     end
 
     should "setup plugins in priority order" do
-      assert_equal @site.converters.sort_by(&:class).map{|c|c.class.priority}, @site.converters.map{|c|c.class.priority}
-      assert_equal @site.generators.sort_by(&:class).map{|g|g.class.priority}, @site.generators.map{|g|g.class.priority}
+      assert_equal(
+        @site.converters.sort_by(&:class).map { |c| c.class.priority },
+        @site.converters.map { |c| c.class.priority }
+      )
+      assert_equal(
+        @site.generators.sort_by(&:class).map { |g| g.class.priority },
+        @site.generators.map { |g| g.class.priority }
+      )
     end
 
     should "sort pages alphabetically" do
       method = Dir.method(:entries)
-      allow(Dir).to receive(:entries) { |*args, &block| method.call(*args, &block).reverse }
+      allow(Dir).to receive(:entries) do |*args, &block|
+        method.call(*args, &block).reverse
+      end
       @site.process
       # files in symlinked directories may appear twice
       sorted_pages = %w(
@@ -192,9 +202,11 @@ class TestSite < JekyllUnitTest
     end
 
     should "read posts" do
-      @site.posts.docs.concat(PostReader.new(@site).read_posts(''))
-      posts = Dir[source_dir('_posts', '**', '*')]
-      posts.delete_if { |post| File.directory?(post) && !(post =~ Document::DATE_FILENAME_MATCHER) }
+      @site.posts.docs.concat(PostReader.new(@site).read_posts(""))
+      posts = Dir[source_dir("_posts", "**", "*")]
+      posts.delete_if do |post|
+        File.directory?(post) && !(post =~ Document::DATE_FILENAME_MATCHER)
+      end
       assert_equal posts.size - @num_invalid_posts, @site.posts.size
     end
 
@@ -209,11 +221,11 @@ class TestSite < JekyllUnitTest
     end
 
     should "expose jekyll version to site payload" do
-      assert_equal Jekyll::VERSION, @site.site_payload['jekyll']['version']
+      assert_equal Jekyll::VERSION, @site.site_payload["jekyll"]["version"]
     end
 
     should "expose list of static files to site payload" do
-      assert_equal @site.static_files, @site.site_payload['site']['static_files']
+      assert_equal @site.static_files, @site.site_payload["site"]["static_files"]
     end
 
     should "deploy payload" do
@@ -221,118 +233,125 @@ class TestSite < JekyllUnitTest
       @site.process
 
       posts = Dir[source_dir("**", "_posts", "**", "*")]
-      posts.delete_if { |post| File.directory?(post) && !(post =~ Document::DATE_FILENAME_MATCHER) }
-      categories = %w(2013 bar baz category foo z_category MixedCase Mixedcase publish_test win).sort
+      posts.delete_if do |post|
+        File.directory?(post) && !(post =~ Document::DATE_FILENAME_MATCHER)
+      end
+      categories = %w(
+        2013 bar baz category foo z_category MixedCase Mixedcase publish_test win
+      ).sort
 
       assert_equal posts.size - @num_invalid_posts, @site.posts.size
       assert_equal categories, @site.categories.keys.sort
-      assert_equal 5, @site.categories['foo'].size
+      assert_equal 5, @site.categories["foo"].size
     end
 
-    context 'error handling' do
+    context "error handling" do
       should "raise if destination is included in source" do
         assert_raises Jekyll::Errors::FatalException do
-          Site.new(site_configuration('destination' => source_dir))
+          Site.new(site_configuration("destination" => source_dir))
         end
       end
 
       should "raise if destination is source" do
         assert_raises Jekyll::Errors::FatalException do
-          Site.new(site_configuration('destination' => File.join(source_dir, "..")))
+          Site.new(site_configuration("destination" => File.join(source_dir, "..")))
         end
       end
     end
 
-    context 'with orphaned files in destination' do
+    context "with orphaned files in destination" do
       setup do
         clear_dest
         @site.regenerator.clear
         @site.process
         # generate some orphaned files:
         # single file
-        File.open(dest_dir('obsolete.html'), 'w')
+        File.open(dest_dir("obsolete.html"), "w")
         # single file in sub directory
-        FileUtils.mkdir(dest_dir('qux'))
-        File.open(dest_dir('qux/obsolete.html'), 'w')
+        FileUtils.mkdir(dest_dir("qux"))
+        File.open(dest_dir("qux/obsolete.html"), "w")
         # empty directory
-        FileUtils.mkdir(dest_dir('quux'))
-        FileUtils.mkdir(dest_dir('.git'))
-        FileUtils.mkdir(dest_dir('.svn'))
-        FileUtils.mkdir(dest_dir('.hg'))
+        FileUtils.mkdir(dest_dir("quux"))
+        FileUtils.mkdir(dest_dir(".git"))
+        FileUtils.mkdir(dest_dir(".svn"))
+        FileUtils.mkdir(dest_dir(".hg"))
         # single file in repository
-        File.open(dest_dir('.git/HEAD'), 'w')
-        File.open(dest_dir('.svn/HEAD'), 'w')
-        File.open(dest_dir('.hg/HEAD'), 'w')
+        File.open(dest_dir(".git/HEAD"), "w")
+        File.open(dest_dir(".svn/HEAD"), "w")
+        File.open(dest_dir(".hg/HEAD"), "w")
       end
 
       teardown do
-        FileUtils.rm_f(dest_dir('obsolete.html'))
-        FileUtils.rm_rf(dest_dir('qux'))
-        FileUtils.rm_f(dest_dir('quux'))
-        FileUtils.rm_rf(dest_dir('.git'))
-        FileUtils.rm_rf(dest_dir('.svn'))
-        FileUtils.rm_rf(dest_dir('.hg'))
+        FileUtils.rm_f(dest_dir("obsolete.html"))
+        FileUtils.rm_rf(dest_dir("qux"))
+        FileUtils.rm_f(dest_dir("quux"))
+        FileUtils.rm_rf(dest_dir(".git"))
+        FileUtils.rm_rf(dest_dir(".svn"))
+        FileUtils.rm_rf(dest_dir(".hg"))
       end
 
-      should 'remove orphaned files in destination' do
+      should "remove orphaned files in destination" do
         @site.process
-        refute_exist dest_dir('obsolete.html')
-        refute_exist dest_dir('qux')
-        refute_exist dest_dir('quux')
-        assert_exist dest_dir('.git')
-        assert_exist dest_dir('.git', 'HEAD')
+        refute_exist dest_dir("obsolete.html")
+        refute_exist dest_dir("qux")
+        refute_exist dest_dir("quux")
+        assert_exist dest_dir(".git")
+        assert_exist dest_dir(".git", "HEAD")
       end
 
-      should 'remove orphaned files in destination - keep_files .svn' do
-        config = site_configuration('keep_files' => %w{.svn})
+      should "remove orphaned files in destination - keep_files .svn" do
+        config = site_configuration("keep_files" => %w(.svn))
         @site = Site.new(config)
         @site.process
-        refute_exist dest_dir('.htpasswd')
-        refute_exist dest_dir('obsolete.html')
-        refute_exist dest_dir('qux')
-        refute_exist dest_dir('quux')
-        refute_exist dest_dir('.git')
-        refute_exist dest_dir('.git', 'HEAD')
-        assert_exist dest_dir('.svn')
-        assert_exist dest_dir('.svn', 'HEAD')
+        refute_exist dest_dir(".htpasswd")
+        refute_exist dest_dir("obsolete.html")
+        refute_exist dest_dir("qux")
+        refute_exist dest_dir("quux")
+        refute_exist dest_dir(".git")
+        refute_exist dest_dir(".git", "HEAD")
+        assert_exist dest_dir(".svn")
+        assert_exist dest_dir(".svn", "HEAD")
       end
     end
 
-    context 'using a non-default markdown processor in the configuration' do
-      should 'use the non-default markdown processor' do
+    context "using a non-default markdown processor in the configuration" do
+      should "use the non-default markdown processor" do
         class Jekyll::Converters::Markdown::CustomMarkdown
           def initialize(*args)
             @args = args
           end
 
-          def convert(*args)
+          def convert(*_args)
             ""
           end
         end
 
         custom_processor = "CustomMarkdown"
-        s = Site.new(site_configuration('markdown' => custom_processor))
+        s = Site.new(site_configuration("markdown" => custom_processor))
         s.process
 
         # Do some cleanup, we don't like straggling stuff's.
         Jekyll::Converters::Markdown.send(:remove_const, :CustomMarkdown)
       end
 
-      should 'ignore, if there are any bad characters in the class name' do
+      should "ignore, if there are any bad characters in the class name" do
         module Jekyll::Converters::Markdown::Custom
           class Markdown
             def initialize(*args)
               @args = args
             end
 
-            def convert(*args)
+            def convert(*_args)
               ""
             end
           end
         end
 
         bad_processor = "Custom::Markdown"
-        s = Site.new(site_configuration('markdown' => bad_processor, 'incremental' => false))
+        s = Site.new(site_configuration(
+          "markdown"    => bad_processor,
+          "incremental" => false
+        ))
         assert_raises Jekyll::Errors::FatalException do
           s.process
         end
@@ -342,96 +361,105 @@ class TestSite < JekyllUnitTest
       end
     end
 
-    context 'with an invalid markdown processor in the configuration' do
-      should 'not throw an error at initialization time' do
-        bad_processor = 'not a processor name'
-        assert Site.new(site_configuration('markdown' => bad_processor))
+    context "with an invalid markdown processor in the configuration" do
+      should "not throw an error at initialization time" do
+        bad_processor = "not a processor name"
+        assert Site.new(site_configuration("markdown" => bad_processor))
       end
 
-      should 'throw FatalException at process time' do
-        bad_processor = 'not a processor name'
-        s = Site.new(site_configuration('markdown' => bad_processor, 'incremental' => false))
+      should "throw FatalException at process time" do
+        bad_processor = "not a processor name"
+        s = Site.new(site_configuration(
+          "markdown"    => bad_processor,
+          "incremental" => false
+        ))
         assert_raises Jekyll::Errors::FatalException do
           s.process
         end
       end
     end
 
-    context 'data directory' do
-      should 'auto load yaml files' do
+    context "data directory" do
+      should "auto load yaml files" do
         site = Site.new(site_configuration)
         site.process
 
-        file_content = SafeYAML.load_file(File.join(source_dir, '_data', 'members.yaml'))
+        file_content = SafeYAML.load_file(File.join(source_dir, "_data", "members.yaml"))
 
-        assert_equal site.data['members'], file_content
-        assert_equal site.site_payload['site']['data']['members'], file_content
+        assert_equal site.data["members"], file_content
+        assert_equal site.site_payload["site"]["data"]["members"], file_content
       end
 
-      should 'load yaml files from extracted method' do
+      should "load yaml files from extracted method" do
         site = Site.new(site_configuration)
         site.process
 
-        file_content = DataReader.new(site).read_data_file(source_dir('_data', 'members.yaml'))
+        file_content = DataReader.new(site)
+          .read_data_file(source_dir("_data", "members.yaml"))
 
-        assert_equal site.data['members'], file_content
-        assert_equal site.site_payload['site']['data']['members'], file_content
+        assert_equal site.data["members"], file_content
+        assert_equal site.site_payload["site"]["data"]["members"], file_content
       end
 
-      should 'auto load yml files' do
+      should "auto load yml files" do
         site = Site.new(site_configuration)
         site.process
 
-        file_content = SafeYAML.load_file(File.join(source_dir, '_data', 'languages.yml'))
+        file_content = SafeYAML.load_file(File.join(source_dir, "_data", "languages.yml"))
 
-        assert_equal site.data['languages'], file_content
-        assert_equal site.site_payload['site']['data']['languages'], file_content
+        assert_equal site.data["languages"], file_content
+        assert_equal site.site_payload["site"]["data"]["languages"], file_content
       end
 
-      should 'auto load json files' do
+      should "auto load json files" do
         site = Site.new(site_configuration)
         site.process
 
-        file_content = SafeYAML.load_file(File.join(source_dir, '_data', 'members.json'))
+        file_content = SafeYAML.load_file(File.join(source_dir, "_data", "members.json"))
 
-        assert_equal site.data['members'], file_content
-        assert_equal site.site_payload['site']['data']['members'], file_content
+        assert_equal site.data["members"], file_content
+        assert_equal site.site_payload["site"]["data"]["members"], file_content
       end
 
-      should 'auto load yaml files in subdirectory' do
+      should "auto load yaml files in subdirectory" do
         site = Site.new(site_configuration)
         site.process
 
-        file_content = SafeYAML.load_file(File.join(source_dir, '_data', 'categories', 'dairy.yaml'))
+        file_content = SafeYAML.load_file(File.join(
+          source_dir, "_data", "categories", "dairy.yaml"
+        ))
 
-        assert_equal site.data['categories']['dairy'], file_content
-        assert_equal site.site_payload['site']['data']['categories']['dairy'], file_content
+        assert_equal site.data["categories"]["dairy"], file_content
+        assert_equal(
+          site.site_payload["site"]["data"]["categories"]["dairy"],
+          file_content
+        )
       end
 
       should "load symlink files in unsafe mode" do
-        site = Site.new(site_configuration('safe' => false))
+        site = Site.new(site_configuration("safe" => false))
         site.process
 
-        file_content = SafeYAML.load_file(File.join(source_dir, '_data', 'products.yml'))
+        file_content = SafeYAML.load_file(File.join(source_dir, "_data", "products.yml"))
 
-        assert_equal site.data['products'], file_content
-        assert_equal site.site_payload['site']['data']['products'], file_content
+        assert_equal site.data["products"], file_content
+        assert_equal site.site_payload["site"]["data"]["products"], file_content
       end
 
-      should "load the symlink files in safe mode, as they resolve to inside site.source" do
-        site = Site.new(site_configuration('safe' => true))
+      should "load the symlink files in safe mode, " \
+             "as they resolve to inside site.source" do
+        site = Site.new(site_configuration("safe" => true))
         site.process
-        file_content = SafeYAML.load_file(File.join(source_dir, '_data', 'products.yml'))
-        assert_equal site.data['products'], file_content
-        assert_equal site.site_payload['site']['data']['products'], file_content
+        file_content = SafeYAML.load_file(File.join(source_dir, "_data", "products.yml"))
+        assert_equal site.data["products"], file_content
+        assert_equal site.site_payload["site"]["data"]["products"], file_content
       end
-
     end
 
     context "manipulating the Jekyll environment" do
       setup do
         @site = Site.new(site_configuration({
-          'incremental' => false
+          "incremental" => false
         }))
         @site.process
         @page = @site.pages.find { |p| p.name == "environment.html" }
@@ -445,7 +473,7 @@ class TestSite < JekyllUnitTest
         setup do
           ENV["JEKYLL_ENV"] = "production"
           @site = Site.new(site_configuration({
-            'incremental' => false
+            "incremental" => false
           }))
           @site.process
           @page = @site.pages.find { |p| p.name == "environment.html" }
@@ -463,7 +491,7 @@ class TestSite < JekyllUnitTest
 
     context "with liquid profiling" do
       setup do
-        @site = Site.new(site_configuration('profile' => true))
+        @site = Site.new(site_configuration("profile" => true))
       end
 
       # Suppress output while testing
@@ -483,7 +511,7 @@ class TestSite < JekyllUnitTest
     context "incremental build" do
       setup do
         @site = Site.new(site_configuration({
-          'incremental' => true
+          "incremental" => true
         }))
         @site.read
       end
@@ -533,8 +561,6 @@ class TestSite < JekyllUnitTest
         mtime2 = File.stat(dest).mtime.to_i
         refute_equal mtime1, mtime2 # must be regenerated
       end
-
     end
-
   end
 end

test/test_tags.rb

@@ -1,18 +1,17 @@
 # coding: utf-8
-
-require 'helper'
+require "helper"
 
 class TestTags < JekyllUnitTest
-
   def setup
     FileUtils.mkdir_p("tmp")
   end
 
+  # rubocop:disable Metrics/AbcSize
   def create_post(content, override = {}, converter_class = Jekyll::Converters::Markdown)
-    site = fixture_site({"highlighter" => "rouge"}.merge(override))
+    site = fixture_site({ "highlighter" => "rouge" }.merge(override))
 
-    site.posts.docs.concat(PostReader.new(site).read_posts('')) if override['read_posts']
-    CollectionReader.new(site).read if override['read_collections']
+    site.posts.docs.concat(PostReader.new(site).read_posts("")) if override["read_posts"]
+    CollectionReader.new(site).read if override["read_collections"]
 
     info = { :filters => [Jekyll::Filters], :registers => { :site => site } }
     @converter = site.converters.find { |c| c.class == converter_class }
@@ -22,6 +21,7 @@ class TestTags < JekyllUnitTest
     @result = Liquid::Template.parse(content).render!(payload, info)
     @result = @converter.convert(@result)
   end
+  # rubocop:enable Metrics/AbcSize
 
   def fill_post(code, override = {})
     content = <<CONTENT
@@ -42,7 +42,12 @@ CONTENT
   end
 
   def highlight_block_with_opts(options_string)
-    Jekyll::Tags::HighlightBlock.parse('highlight', options_string, ["test", "{% endhighlight %}", "\n"], {})
+    Jekyll::Tags::HighlightBlock.parse(
+      "highlight",
+      options_string,
+      ["test", "{% endhighlight %}", "\n"],
+      {}
+    )
   end
 
   context "language name" do
@@ -63,73 +68,96 @@ CONTENT
 
   context "highlight tag in unsafe mode" do
     should "set the no options with just a language name" do
-      tag = highlight_block_with_opts('ruby ')
+      tag = highlight_block_with_opts("ruby ")
       assert_equal({}, tag.instance_variable_get(:@highlight_options))
     end
 
     should "set the linenos option as 'inline' if no linenos value" do
-      tag = highlight_block_with_opts('ruby linenos ')
-      assert_equal({ :linenos => 'inline' }, tag.instance_variable_get(:@highlight_options))
+      tag = highlight_block_with_opts("ruby linenos ")
+      assert_equal(
+        { :linenos => "inline" },
+        tag.instance_variable_get(:@highlight_options)
+      )
     end
 
-    should "set the linenos option to 'table' if the linenos key is given the table value" do
-      tag = highlight_block_with_opts('ruby linenos=table ')
-      assert_equal({ :linenos => 'table' }, tag.instance_variable_get(:@highlight_options))
+    should "set the linenos option to 'table' " \
+           "if the linenos key is given the table value" do
+      tag = highlight_block_with_opts("ruby linenos=table ")
+      assert_equal(
+        { :linenos => "table" },
+        tag.instance_variable_get(:@highlight_options)
+      )
     end
 
     should "recognize nowrap option with linenos set" do
-      tag = highlight_block_with_opts('ruby linenos=table nowrap ')
-      assert_equal({ :linenos => 'table', :nowrap => true }, tag.instance_variable_get(:@highlight_options))
+      tag = highlight_block_with_opts("ruby linenos=table nowrap ")
+      assert_equal(
+        { :linenos => "table", :nowrap => true },
+        tag.instance_variable_get(:@highlight_options)
+      )
     end
 
     should "recognize the cssclass option" do
-      tag = highlight_block_with_opts('ruby linenos=table cssclass=hl ')
-      assert_equal({ :cssclass => 'hl', :linenos => 'table' }, tag.instance_variable_get(:@highlight_options))
+      tag = highlight_block_with_opts("ruby linenos=table cssclass=hl ")
+      assert_equal(
+        { :cssclass => "hl", :linenos => "table" },
+        tag.instance_variable_get(:@highlight_options)
+      )
     end
 
     should "recognize the hl_linenos option and its value" do
-      tag = highlight_block_with_opts('ruby linenos=table cssclass=hl hl_linenos=3 ')
-      assert_equal({ :cssclass => 'hl', :linenos => 'table', :hl_linenos => '3' }, tag.instance_variable_get(:@highlight_options))
+      tag = highlight_block_with_opts("ruby linenos=table cssclass=hl hl_linenos=3 ")
+      assert_equal(
+        { :cssclass => "hl", :linenos => "table", :hl_linenos => "3" },
+        tag.instance_variable_get(:@highlight_options)
+      )
     end
 
     should "recognize multiple values of hl_linenos" do
-      tag = highlight_block_with_opts('ruby linenos=table cssclass=hl hl_linenos="3 5 6" ')
-      assert_equal({ :cssclass => 'hl', :linenos => 'table', :hl_linenos => ['3', '5', '6'] }, tag.instance_variable_get(:@highlight_options))
+      tag = highlight_block_with_opts 'ruby linenos=table cssclass=hl hl_linenos="3 5 6" '
+      assert_equal(
+        { :cssclass => "hl", :linenos => "table", :hl_linenos => %w(3 5 6) },
+        tag.instance_variable_get(:@highlight_options)
+      )
     end
 
     should "treat language name as case insensitive" do
-      tag = highlight_block_with_opts('Ruby ')
-      assert_equal "ruby", tag.instance_variable_get(:@lang), "lexers should be case insensitive"
+      tag = highlight_block_with_opts("Ruby ")
+      assert_equal(
+        "ruby",
+        tag.instance_variable_get(:@lang),
+        "lexers should be case insensitive"
+      )
     end
   end
 
   context "in safe mode" do
     setup do
-      @tag = highlight_block_with_opts('text ')
+      @tag = highlight_block_with_opts("text ")
     end
 
     should "allow linenos" do
-      sanitized = @tag.sanitized_opts({:linenos => true}, true)
+      sanitized = @tag.sanitized_opts({ :linenos => true }, true)
       assert_equal true, sanitized[:linenos]
     end
 
     should "allow hl_lines" do
-      sanitized = @tag.sanitized_opts({:hl_lines => %w[1 2 3 4]}, true)
-      assert_equal %w[1 2 3 4], sanitized[:hl_lines]
+      sanitized = @tag.sanitized_opts({ :hl_lines => %w(1 2 3 4) }, true)
+      assert_equal %w(1 2 3 4), sanitized[:hl_lines]
     end
 
     should "allow cssclass" do
-      sanitized = @tag.sanitized_opts({:cssclass => "ahoy"}, true)
+      sanitized = @tag.sanitized_opts({ :cssclass => "ahoy" }, true)
       assert_equal "ahoy", sanitized[:cssclass]
     end
 
     should "allow startinline" do
-      sanitized = @tag.sanitized_opts({:startinline => true}, true)
+      sanitized = @tag.sanitized_opts({ :startinline => true }, true)
       assert_equal true, sanitized[:startinline]
     end
 
     should "strip unknown options" do
-      sanitized = @tag.sanitized_opts({:light => true}, true)
+      sanitized = @tag.sanitized_opts({ :light => true }, true)
       assert_nil sanitized[:light]
     end
   end
@@ -145,7 +173,7 @@ CONTENT
 
     context "post content has highlight tag" do
       setup do
-        fill_post("test", {'highlighter' => 'pygments'})
+        fill_post("test", { "highlighter" => "pygments" })
       end
 
       should "not cause a markdown error" do
@@ -153,31 +181,45 @@ CONTENT
       end
 
       should "render markdown with pygments" do
-        assert_match %{<pre><code class="language-text" data-lang="text">test</code></pre>}, @result
+        assert_match(
+          %(<pre><code class="language-text" data-lang="text">test</code></pre>),
+          @result
+        )
       end
 
       should "render markdown with pygments with line numbers" do
-        assert_match %{<pre><code class="language-text" data-lang="text"><span class="lineno">1</span> test</code></pre>}, @result
+        assert_match(
+          %(<pre><code class="language-text" data-lang="text">) +
+          %(<span class="lineno">1</span> test</code></pre>),
+          @result
+        )
       end
     end
 
     context "post content has highlight with file reference" do
       setup do
-        fill_post("./jekyll.gemspec", {'highlighter' => 'pygments'})
+        fill_post("./jekyll.gemspec", { "highlighter" => "pygments" })
       end
 
       should "not embed the file" do
-        assert_match %{<pre><code class="language-text" data-lang="text">./jekyll.gemspec</code></pre>}, @result
+        assert_match(
+          %(<pre><code class="language-text" data-lang="text">) +
+          %(./jekyll.gemspec</code></pre>),
+          @result
+        )
       end
     end
 
     context "post content has highlight tag with UTF character" do
       setup do
-        fill_post("Æ", {'highlighter' => 'pygments'})
+        fill_post("Æ", { "highlighter" => "pygments" })
       end
 
       should "render markdown with pygments line handling" do
-        assert_match %{<pre><code class="language-text" data-lang="text">Æ</code></pre>}, @result
+        assert_match(
+          %(<pre><code class="language-text" data-lang="text">Æ</code></pre>),
+          @result
+        )
       end
     end
 
@@ -190,15 +232,19 @@ CONTENT
 [1,] FALSE TRUE
 [2,] FALSE TRUE
 EOS
-        fill_post(code, {'highlighter' => 'pygments'})
+        fill_post(code, { "highlighter" => "pygments" })
       end
 
       should "only strip the preceding newlines" do
-        assert_match %{<pre><code class=\"language-text\" data-lang=\"text\">     [,1] [,2]}, @result
+        assert_match(
+          %(<pre><code class=\"language-text\" data-lang=\"text\">     [,1] [,2]),
+          @result
+        )
       end
     end
 
-    context "post content has highlight tag with preceding spaces & lines in several places" do
+    context "post content has highlight tag " \
+            "with preceding spaces & lines in several places" do
       setup do
         code = <<-EOS
 
@@ -211,21 +257,29 @@ EOS
 
 
 EOS
-        fill_post(code, {'highlighter' => 'pygments'})
+        fill_post(code, { "highlighter" => "pygments" })
       end
 
       should "only strip the newlines which precede and succeed the entire block" do
-        assert_match "<pre><code class=\"language-text\" data-lang=\"text\">     [,1] [,2]\n\n\n[1,] FALSE TRUE\n[2,] FALSE TRUE</code></pre>", @result
+        assert_match(
+          "<pre><code class=\"language-text\" data-lang=\"text\">" \
+          "     [,1] [,2]\n\n\n[1,] FALSE TRUE\n[2,] FALSE TRUE</code></pre>",
+          @result
+        )
       end
     end
 
-    context "post content has highlight tag with preceding spaces & Windows-style newlines" do
+    context "post content has highlight tag with " \
+            "preceding spaces & Windows-style newlines" do
       setup do
-        fill_post "\r\n\r\n\r\n     [,1] [,2]", {'highlighter' => 'pygments'}
+        fill_post "\r\n\r\n\r\n     [,1] [,2]", { "highlighter" => "pygments" }
       end
 
       should "only strip the preceding newlines" do
-        assert_match %{<pre><code class=\"language-text\" data-lang=\"text\">     [,1] [,2]}, @result
+        assert_match(
+          %(<pre><code class="language-text" data-lang="text">     [,1] [,2]),
+          @result
+        )
       end
     end
 
@@ -236,11 +290,14 @@ EOS
 [1,] FALSE TRUE
 [2,] FALSE TRUE
 EOS
-        fill_post(code, {'highlighter' => 'pygments'})
+        fill_post(code, { "highlighter" => "pygments" })
       end
 
       should "only strip the preceding newlines" do
-        assert_match %{<pre><code class=\"language-text\" data-lang=\"text\">     [,1] [,2]}, @result
+        assert_match(
+          %(<pre><code class=\"language-text\" data-lang=\"text\">     [,1] [,2]),
+          @result
+        )
       end
     end
   end
@@ -252,11 +309,21 @@ EOS
       end
 
       should "render markdown with rouge" do
-        assert_match %{<pre><code class="language-text" data-lang="text">test</code></pre>}, @result
+        assert_match(
+          %(<pre><code class="language-text" data-lang="text">test</code></pre>),
+          @result
+        )
       end
 
       should "render markdown with rouge with line numbers" do
-        assert_match %{<table style="border-spacing: 0"><tbody><tr><td class="gutter gl" style="text-align: right"><pre class="lineno">1</pre></td><td class="code"><pre>test<span class="w">\n</span></pre></td></tr></tbody></table>}, @result
+        assert_match(
+          %(<table style="border-spacing: 0"><tbody>) +
+            %(<tr><td class="gutter gl" style="text-align: right">) +
+            %(<pre class="lineno">1</pre></td>) +
+            %(<td class="code"><pre>test<span class="w">\n</span></pre></td></tr>) +
+            %(</tbody></table>),
+          @result
+        )
       end
     end
 
@@ -266,7 +333,11 @@ EOS
       end
 
       should "not embed the file" do
-        assert_match %{<pre><code class="language-text" data-lang="text">./jekyll.gemspec</code></pre>}, @result
+        assert_match(
+          '<pre><code class="language-text" data-lang="text">' \
+          "./jekyll.gemspec</code></pre>",
+          @result
+        )
       end
     end
 
@@ -276,7 +347,10 @@ EOS
       end
 
       should "render markdown with pygments line handling" do
-        assert_match %{<pre><code class="language-text" data-lang="text">Æ</code></pre>}, @result
+        assert_match(
+          '<pre><code class="language-text" data-lang="text">Æ</code></pre>',
+          @result
+        )
       end
     end
 
@@ -292,11 +366,15 @@ EOS
       end
 
       should "only strip the preceding newlines" do
-        assert_match %{<pre><code class=\"language-text\" data-lang=\"text\">     [,1] [,2]}, @result
+        assert_match(
+          '<pre><code class="language-text" data-lang="text">     [,1] [,2]',
+          @result
+        )
       end
     end
 
-    context "post content has highlight tag with preceding spaces & lines in several places" do
+    context "post content has highlight tag with " \
+            "preceding spaces & lines in several places" do
       setup do
         fill_post <<-EOS
 
@@ -312,7 +390,11 @@ EOS
       end
 
       should "only strip the newlines which precede and succeed the entire block" do
-        assert_match "<pre><code class=\"language-text\" data-lang=\"text\">     [,1] [,2]\n\n\n[1,] FALSE TRUE\n[2,] FALSE TRUE</code></pre>", @result
+        assert_match(
+          "<pre><code class=\"language-text\" data-lang=\"text\">     [,1] [,2]\n\n\n" \
+          "[1,] FALSE TRUE\n[2,] FALSE TRUE</code></pre>",
+          @result
+        )
       end
     end
 
@@ -333,17 +415,29 @@ EOS
       end
 
       should "should stop highlighting at boundary" do
-        assert_match "<p>This is not yet highlighted</p>\n\n<figure class=\"highlight\"><pre><code class=\"language-php\" data-lang=\"php\"><table style=\"border-spacing: 0\"><tbody><tr><td class=\"gutter gl\" style=\"text-align: right\"><pre class=\"lineno\">1</pre></td><td class=\"code\"><pre>test<span class=\"w\">\n</span></pre></td></tr></tbody></table></code></pre></figure>\n\n<p>This should not be highlighted, right?</p>", @result
+        expected = <<-EOS
+<p>This is not yet highlighted</p>
+
+<figure class="highlight"><pre><code class="language-php" data-lang="php"><table style="border-spacing: 0"><tbody><tr><td class="gutter gl" style="text-align: right"><pre class="lineno">1</pre></td><td class="code"><pre>test<span class="w">
+</span></pre></td></tr></tbody></table></code></pre></figure>
+
+<p>This should not be highlighted, right?</p>
+EOS
+        assert_match(expected, @result)
       end
     end
 
-    context "post content has highlight tag with preceding spaces & Windows-style newlines" do
+    context "post content has highlight tag with " \
+            "preceding spaces & Windows-style newlines" do
       setup do
         fill_post "\r\n\r\n\r\n     [,1] [,2]"
       end
 
       should "only strip the preceding newlines" do
-        assert_match %{<pre><code class=\"language-text\" data-lang=\"text\">     [,1] [,2]}, @result
+        assert_match(
+          '<pre><code class="language-text" data-lang="text">     [,1] [,2]',
+          @result
+        )
       end
     end
 
@@ -357,7 +451,10 @@ EOS
       end
 
       should "only strip the preceding newlines" do
-        assert_match %{<pre><code class=\"language-text\" data-lang=\"text\">     [,1] [,2]}, @result
+        assert_match(
+          '<pre><code class="language-text" data-lang="text">     [,1] [,2]',
+          @result
+        )
       end
     end
   end
@@ -388,24 +485,24 @@ CONTENT
         end
 
         create_post(@content, {
-          'markdown' => 'rdiscount'
+          "markdown" => "rdiscount"
         })
       end
 
       should "parse correctly" do
         assert_match %r{<em>FIGHT!</em>}, @result
-        assert_match %r{<em>FINISH HIM</em>}, @result
+        assert_match %r!<em>FINISH HIM</em>!, @result
       end
     end
 
     context "using Kramdown" do
       setup do
-        create_post(@content, 'markdown' => 'kramdown')
+        create_post(@content, "markdown" => "kramdown")
       end
 
       should "parse correctly" do
         assert_match %r{<em>FIGHT!</em>}, @result
-        assert_match %r{<em>FINISH HIM</em>}, @result
+        assert_match %r!<em>FINISH HIM</em>!, @result
       end
     end
 
@@ -418,13 +515,13 @@ CONTENT
         end
 
         create_post(@content, {
-          'markdown' => 'redcarpet'
+          "markdown" => "redcarpet"
         })
       end
 
       should "parse correctly" do
         assert_match %r{<em>FIGHT!</em>}, @result
-        assert_match %r{<em>FINISH HIM</em>}, @result
+        assert_match %r!<em>FINISH HIM</em>!, @result
       end
     end
   end
@@ -438,7 +535,12 @@ title: Post linking
 
 {% post_url 2008-11-21-complex %}
 CONTENT
-      create_post(content, {'permalink' => 'pretty', 'source' => source_dir, 'destination' => dest_dir, 'read_posts' => true})
+      create_post(content, {
+        "permalink"   => "pretty",
+        "source"      => source_dir,
+        "destination" => dest_dir,
+        "read_posts"  => true
+      })
     end
 
     should "not cause an error" do
@@ -446,7 +548,7 @@ CONTENT
     end
 
     should "have the url to the \"complex\" post from 2008-11-21" do
-      assert_match %r{/2008/11/21/complex/}, @result
+      assert_match %r!/2008/11/21/complex/!, @result
     end
   end
 
@@ -462,7 +564,12 @@ title: Post linking
 - 3 {% post_url es/2008-11-21-nested %}
 - 4 {% post_url /es/2008-11-21-nested %}
 CONTENT
-      create_post(content, {'permalink' => 'pretty', 'source' => source_dir, 'destination' => dest_dir, 'read_posts' => true})
+      create_post(content, {
+        "permalink"   => "pretty",
+        "source"      => source_dir,
+        "destination" => dest_dir,
+        "read_posts"  => true
+      })
     end
 
     should "not cause an error" do
@@ -470,13 +577,13 @@ CONTENT
     end
 
     should "have the url to the \"complex\" post from 2008-11-21" do
-      assert_match %r{1\s/2008/11/21/complex/}, @result
-      assert_match %r{2\s/2008/11/21/complex/}, @result
+      assert_match %r!1\s/2008/11/21/complex/!, @result
+      assert_match %r!2\s/2008/11/21/complex/!, @result
     end
 
     should "have the url to the \"nested\" post from 2008-11-21" do
-      assert_match %r{3\s/2008/11/21/nested/}, @result
-      assert_match %r{4\s/2008/11/21/nested/}, @result
+      assert_match %r!3\s/2008/11/21/nested/!, @result
+      assert_match %r!4\s/2008/11/21/nested/!, @result
     end
   end
 
@@ -492,10 +599,10 @@ CONTENT
 
       assert_raises Jekyll::Errors::PostURLError do
         create_post(content, {
-          'permalink' => 'pretty',
-          'source' => source_dir,
-          'destination' => dest_dir,
-          'read_posts' => true
+          "permalink"   => "pretty",
+          "source"      => source_dir,
+          "destination" => dest_dir,
+          "read_posts"  => true
         })
       end
     end
@@ -511,10 +618,10 @@ CONTENT
 
       assert_raises Jekyll::Errors::InvalidDateError do
         create_post(content, {
-          'permalink' => 'pretty',
-          'source' => source_dir,
-          'destination' => dest_dir,
-          'read_posts' => true
+          "permalink"   => "pretty",
+          "source"      => source_dir,
+          "destination" => dest_dir,
+          "read_posts"  => true
         })
       end
     end
@@ -529,15 +636,20 @@ title: linking
 
 {% link _methods/yaml_with_dots.md %}
 CONTENT
-      create_post(content, {'source' => source_dir, 'destination' => dest_dir, 'collections' => { 'methods' => { 'output' => true }}, 'read_collections' => true})
+      create_post(content, {
+        "source"           => source_dir,
+        "destination"      => dest_dir,
+        "collections"      => { "methods" => { "output" => true } },
+        "read_collections" => true
+      })
     end
 
     should "not cause an error" do
-      refute_match /markdown\-html\-error/, @result
+      refute_match(/markdown\-html\-error/, @result)
     end
 
     should "have the url to the \"yaml_with_dots\" item" do
-      assert_match %r{/methods/yaml_with_dots\.html}, @result
+      assert_match(%r!/methods/yaml_with_dots\.html!, @result)
     end
   end
 
@@ -551,19 +663,24 @@ title: linking
 - 1 {% link _methods/sanitized_path.md %}
 - 2 {% link _methods/site/generate.md %}
 CONTENT
-      create_post(content, {'source' => source_dir, 'destination' => dest_dir, 'collections' => { 'methods' => { 'output' => true }}, 'read_collections' => true})
+      create_post(content, {
+        "source"           => source_dir,
+        "destination"      => dest_dir,
+        "collections"      => { "methods" => { "output" => true } },
+        "read_collections" => true
+      })
     end
 
     should "not cause an error" do
-      refute_match /markdown\-html\-error/, @result
+      refute_match(/markdown\-html\-error/, @result)
     end
 
     should "have the url to the \"sanitized_path\" item" do
-      assert_match %r{1\s/methods/sanitized_path\.html}, @result
+      assert_match %r!1\s/methods/sanitized_path\.html!, @result
     end
 
     should "have the url to the \"site/generate\" item" do
-      assert_match %r{2\s/methods/site/generate\.html}, @result
+      assert_match %r!2\s/methods/site/generate\.html!, @result
     end
   end
 
@@ -578,17 +695,20 @@ title: Invalid linking
 CONTENT
 
       assert_raises ArgumentError do
-        create_post(content, {'source' => source_dir, 'destination' => dest_dir, 'collections' => { 'methods' => { 'output' => true }}, 'read_collections' => true})
+        create_post(content, {
+          "source"           => source_dir,
+          "destination"      => dest_dir,
+          "collections"      => { "methods" => { "output" => true } },
+          "read_collections" => true
+        })
       end
     end
   end
 
   context "include tag with parameters" do
-
     context "with symlink'd include" do
-
       should "not allow symlink includes" do
-        File.open("tmp/pages-test", 'w') { |file| file.write("SYMLINK TEST") }
+        File.open("tmp/pages-test", "w") { |file| file.write("SYMLINK TEST") }
         assert_raises IOError do
           content = <<CONTENT
 ---
@@ -598,9 +718,15 @@ title: Include symlink
 {% include tmp/pages-test %}
 
 CONTENT
-          create_post(content, {'permalink' => 'pretty', 'source' => source_dir, 'destination' => dest_dir, 'read_posts' => true, 'safe' => true })
+          create_post(content, {
+            "permalink"   => "pretty",
+            "source"      => source_dir,
+            "destination" => dest_dir,
+            "read_posts"  => true,
+            "safe"        => true
+          })
         end
-        @result ||= ''
+        @result ||= ""
         refute_match(/SYMLINK TEST/, @result)
       end
 
@@ -614,9 +740,19 @@ title: Include symlink
 {% include tmp/pages-test-does-not-exist %}
 
 CONTENT
-          create_post(content, {'permalink' => 'pretty', 'source' => source_dir, 'destination' => dest_dir, 'read_posts' => true, 'safe' => true })
+          create_post(content, {
+            "permalink"   => "pretty",
+            "source"      => source_dir,
+            "destination" => dest_dir,
+            "read_posts"  => true,
+            "safe"        => true
+          })
         end
-        assert_match "Could not locate the included file 'tmp/pages-test-does-not-exist' in any of [\"#{source_dir}/_includes\"].", ex.message
+        assert_match(
+          "Could not locate the included file 'tmp/pages-test-does-not-exist' " \
+          "in any of [\"#{source_dir}/_includes\"].",
+          ex.message
+        )
       end
     end
 
@@ -631,7 +767,12 @@ title: Include tag parameters
 
 {% include params.html param="value" %}
 CONTENT
-        create_post(content, {'permalink' => 'pretty', 'source' => source_dir, 'destination' => dest_dir, 'read_posts' => true})
+        create_post(content, {
+          "permalink"   => "pretty",
+          "source"      => source_dir,
+          "destination" => dest_dir,
+          "read_posts"  => true
+        })
       end
 
       should "correctly output include variable" do
@@ -652,8 +793,14 @@ title: Invalid parameter syntax
 
 {% include params.html param s="value" %}
 CONTENT
-        assert_raises ArgumentError, 'Did not raise exception on invalid "include" syntax' do
-          create_post(content, {'permalink' => 'pretty', 'source' => source_dir, 'destination' => dest_dir, 'read_posts' => true})
+        assert_raises ArgumentError, "Did not raise exception on invalid " \
+                                     '"include" syntax' do
+          create_post(content, {
+            "permalink"   => "pretty",
+            "source"      => source_dir,
+            "destination" => dest_dir,
+            "read_posts"  => true
+          })
         end
 
         content = <<CONTENT
@@ -663,8 +810,14 @@ title: Invalid parameter syntax
 
 {% include params.html params="value %}
 CONTENT
-        assert_raises ArgumentError, 'Did not raise exception on invalid "include" syntax' do
-          create_post(content, {'permalink' => 'pretty', 'source' => source_dir, 'destination' => dest_dir, 'read_posts' => true})
+        assert_raises ArgumentError, "Did not raise exception on invalid " \
+                                     '"include" syntax' do
+          create_post(content, {
+            "permalink"   => "pretty",
+            "source"      => source_dir,
+            "destination" => dest_dir,
+            "read_posts"  => true
+          })
         end
       end
     end
@@ -678,12 +831,17 @@ title: multiple include parameters
 
 {% include params.html param1="new_value" param2="another" %}
 CONTENT
-        create_post(content, {'permalink' => 'pretty', 'source' => source_dir, 'destination' => dest_dir, 'read_posts' => true})
+        create_post(content, {
+          "permalink"   => "pretty",
+          "source"      => source_dir,
+          "destination" => dest_dir,
+          "read_posts"  => true
+        })
       end
 
       should "list all parameters" do
-        assert_match '<li>param1 = new_value</li>', @result
-        assert_match '<li>param2 = another</li>', @result
+        assert_match "<li>param1 = new_value</li>", @result
+        assert_match "<li>param2 = another</li>", @result
       end
 
       should "not include previously used parameters" do
@@ -700,7 +858,12 @@ title: without parameters
 
 {% include params.html %}
 CONTENT
-        create_post(content, {'permalink' => 'pretty', 'source' => source_dir, 'destination' => dest_dir, 'read_posts' => true})
+        create_post(content, {
+          "permalink"   => "pretty",
+          "source"      => source_dir,
+          "destination" => dest_dir,
+          "read_posts"  => true
+        })
       end
 
       should "include file with empty parameters" do
@@ -717,7 +880,13 @@ title: custom includes directory
 
 {% include custom.html %}
 CONTENT
-        create_post(content, {'includes_dir' => '_includes_custom', 'permalink' => 'pretty', 'source' => source_dir, 'destination' => dest_dir, 'read_posts' => true})
+        create_post(content, {
+          "includes_dir" => "_includes_custom",
+          "permalink"    => "pretty",
+          "source"       => source_dir,
+          "destination"  => dest_dir,
+          "read_posts"   => true
+        })
       end
 
       should "include file from custom directory" do
@@ -734,7 +903,12 @@ title: without parameters within if statement
 
 {% if true %}{% include params.html %}{% endif %}
 CONTENT
-        create_post(content, {'permalink' => 'pretty', 'source' => source_dir, 'destination' => dest_dir, 'read_posts' => true})
+        create_post(content, {
+          "permalink"   => "pretty",
+          "source"      => source_dir,
+          "destination" => dest_dir,
+          "read_posts"  => true
+        })
       end
 
       should "include file with empty parameters within if statement" do
@@ -755,72 +929,85 @@ CONTENT
 
       should "raise error relative to source directory" do
         exception = assert_raises IOError do
-          create_post(@content, {'permalink' => 'pretty', 'source' => source_dir, 'destination' => dest_dir, 'read_posts' => true})
+          create_post(@content, {
+            "permalink"   => "pretty",
+            "source"      => source_dir,
+            "destination" => dest_dir,
+            "read_posts"  => true
+          })
         end
-        assert_match "Could not locate the included file 'missing.html' in any of [\"#{source_dir}/_includes\"].", exception.message
+        assert_match(
+          "Could not locate the included file 'missing.html' in any of " \
+          "[\"#{source_dir}/_includes\"].",
+          exception.message
+        )
       end
     end
 
     context "include tag with variable and liquid filters" do
       setup do
-        site = fixture_site({'pygments' => true}).tap(&:read).tap(&:render)
-        post = site.posts.docs.find {|p| p.basename.eql? "2013-12-17-include-variable-filters.markdown" }
+        site = fixture_site({ "pygments" => true }).tap(&:read).tap(&:render)
+        post = site.posts.docs.find do |p|
+          p.basename.eql? "2013-12-17-include-variable-filters.markdown"
+        end
         @content = post.output
       end
 
       should "include file as variable with liquid filters" do
-        assert_match %r{1 included}, @content
-        assert_match %r{2 included}, @content
-        assert_match %r{3 included}, @content
+        assert_match(/1 included/, @content)
+        assert_match(/2 included/, @content)
+        assert_match(/3 included/, @content)
       end
 
       should "include file as variable and liquid filters with arbitrary whitespace" do
-        assert_match %r{4 included}, @content
-        assert_match %r{5 included}, @content
-        assert_match %r{6 included}, @content
+        assert_match(/4 included/, @content)
+        assert_match(/5 included/, @content)
+        assert_match(/6 included/, @content)
       end
 
       should "include file as variable and filters with additional parameters" do
-        assert_match '<li>var1 = foo</li>', @content
-        assert_match '<li>var2 = bar</li>', @content
+        assert_match("<li>var1 = foo</li>", @content)
+        assert_match("<li>var2 = bar</li>", @content)
       end
 
       should "include file as partial variable" do
-        assert_match %r{8 included}, @content
+        assert_match(/8 included/, @content)
       end
     end
   end
 
   context "relative include tag with variable and liquid filters" do
     setup do
-      site = fixture_site({'pygments' => true}).tap(&:read).tap(&:render)
-      post = site.posts.docs.find {|p| p.basename.eql? "2014-09-02-relative-includes.markdown" }
+      site = fixture_site({ "pygments" => true }).tap(&:read).tap(&:render)
+      post = site.posts.docs.find do |p|
+        p.basename.eql? "2014-09-02-relative-includes.markdown"
+      end
       @content = post.output
     end
 
     should "include file as variable with liquid filters" do
-      assert_match %r{1 relative_include}, @content
-      assert_match %r{2 relative_include}, @content
-      assert_match %r{3 relative_include}, @content
+      assert_match(/1 relative_include/, @content)
+      assert_match(/2 relative_include/, @content)
+      assert_match(/3 relative_include/, @content)
     end
 
     should "include file as variable and liquid filters with arbitrary whitespace" do
-      assert_match %r{4 relative_include}, @content
-      assert_match %r{5 relative_include}, @content
-      assert_match %r{6 relative_include}, @content
+      assert_match(/4 relative_include/, @content)
+      assert_match(/5 relative_include/, @content)
+      assert_match(/6 relative_include/, @content)
     end
 
     should "include file as variable and filters with additional parameters" do
-      assert_match '<li>var1 = foo</li>', @content
-      assert_match '<li>var2 = bar</li>', @content
+      assert_match("<li>var1 = foo</li>", @content)
+      assert_match("<li>var2 = bar</li>", @content)
     end
 
     should "include file as partial variable" do
-      assert_match %r{8 relative_include}, @content
+      assert_match(/8 relative_include/, @content)
     end
 
     should "include files relative to self" do
-      assert_match %r{9 —\ntitle: Test Post Where YAML}, @content
+      assert_match(/9 —\ntitle: Test Post Where YAML/, @content)
     end
 
     context "trying to do bad stuff" do
@@ -837,9 +1024,15 @@ CONTENT
 
         should "raise error relative to source directory" do
           exception = assert_raises IOError do
-            create_post(@content, {'permalink' => 'pretty', 'source' => source_dir, 'destination' => dest_dir, 'read_posts' => true})
+            create_post(@content, {
+              "permalink"   => "pretty",
+              "source"      => source_dir,
+              "destination" => dest_dir,
+              "read_posts"  => true
+            })
           end
-          assert_match "Could not locate the included file 'missing.html' in any of [\"#{source_dir}\"].", exception.message
+          assert_match "Could not locate the included file 'missing.html' in any of " \
+                       "[\"#{source_dir}\"].", exception.message
         end
       end
 
@@ -856,17 +1049,26 @@ CONTENT
 
         should "raise error relative to source directory" do
           exception = assert_raises ArgumentError do
-            create_post(@content, {'permalink' => 'pretty', 'source' => source_dir, 'destination' => dest_dir, 'read_posts' => true})
+            create_post(@content, {
+              "permalink"   => "pretty",
+              "source"      => source_dir,
+              "destination" => dest_dir,
+              "read_posts"  => true
+            })
           end
-          assert_equal "Invalid syntax for include tag. File contains invalid characters or sequences:\n\n  ../README.markdown\n\nValid syntax:\n\n  {% include_relative file.ext param='value' param2='value' %}\n\n", exception.message
+          assert_equal(
+            "Invalid syntax for include tag. File contains invalid characters or " \
+            "sequences:\n\n  ../README.markdown\n\nValid syntax:\n\n  " \
+            "{% include_relative file.ext param='value' param2='value' %}\n\n",
+            exception.message
+          )
         end
       end
     end
 
     context "with symlink'd include" do
-
       should "not allow symlink includes" do
-        File.open("tmp/pages-test", 'w') { |file| file.write("SYMLINK TEST") }
+        File.open("tmp/pages-test", "w") { |file| file.write("SYMLINK TEST") }
         assert_raises IOError do
           content = <<CONTENT
 ---
@@ -876,9 +1078,15 @@ title: Include symlink
 {% include_relative tmp/pages-test %}
 
 CONTENT
-          create_post(content, {'permalink' => 'pretty', 'source' => source_dir, 'destination' => dest_dir, 'read_posts' => true, 'safe' => true })
+          create_post(content, {
+            "permalink"   => "pretty",
+            "source"      => source_dir,
+            "destination" => dest_dir,
+            "read_posts"  => true,
+            "safe"        => true
+          })
         end
-        @result ||= ''
+        @result ||= ""
         refute_match(/SYMLINK TEST/, @result)
       end
 
@@ -892,9 +1100,19 @@ title: Include symlink
 {% include_relative tmp/pages-test-does-not-exist %}
 
 CONTENT
-          create_post(content, {'permalink' => 'pretty', 'source' => source_dir, 'destination' => dest_dir, 'read_posts' => true, 'safe' => true })
+          create_post(content, {
+            "permalink"   => "pretty",
+            "source"      => source_dir,
+            "destination" => dest_dir,
+            "read_posts"  => true,
+            "safe"        => true
+          })
         end
-        assert_match /Ensure it exists in one of those directories and, if it is a symlink, does not point outside your site source./, ex.message
+        assert_match(
+          "Ensure it exists in one of those directories and, if it is a symlink, does " \
+          "not point outside your site source.",
+          ex.message
+        )
       end
     end
   end

test/test_utils.rb

@@ -1,4 +1,4 @@
-require 'helper'
+require "helper"
 
 class TestUtils < JekyllUnitTest
   context "The \`Utils.deep_merge_hashes\` method" do
@@ -9,7 +9,7 @@ class TestUtils < JekyllUnitTest
     end
 
     should "merge a drop into a hash" do
-      data = {"page" => {}}
+      data = { "page" => {} }
       merged = Utils.deep_merge_hashes(data, @site.site_payload)
       assert merged.is_a? Hash
       assert merged["site"].is_a? Drops::SiteDrop
@@ -17,7 +17,7 @@ class TestUtils < JekyllUnitTest
     end
 
     should "merge a hash into a drop" do
-      data = {"page" => {}}
+      data = { "page" => {} }
       assert_nil @site.site_payload["page"]
       merged = Utils.deep_merge_hashes(@site.site_payload, data)
       assert merged.is_a? Drops::UnifiedPayloadDrop
@@ -27,66 +27,64 @@ class TestUtils < JekyllUnitTest
   end
 
   context "hash" do
-
     context "pluralized_array" do
-
       should "return empty array with no values" do
         data = {}
-        assert_equal [], Utils.pluralized_array_from_hash(data, 'tag', 'tags')
+        assert_equal [], Utils.pluralized_array_from_hash(data, "tag", "tags")
       end
 
       should "return empty array with no matching values" do
-        data = { 'foo' => 'bar' }
-        assert_equal [], Utils.pluralized_array_from_hash(data, 'tag', 'tags')
+        data = { "foo" => "bar" }
+        assert_equal [], Utils.pluralized_array_from_hash(data, "tag", "tags")
       end
 
       should "return plural array with nil singular" do
-        data = { 'foo' => 'bar', 'tag' => nil, 'tags' => ['dog', 'cat'] }
-        assert_equal ['dog', 'cat'], Utils.pluralized_array_from_hash(data, 'tag', 'tags')
+        data = { "foo" => "bar", "tag" => nil, "tags" => %w(dog cat) }
+        assert_equal %w(dog cat), Utils.pluralized_array_from_hash(data, "tag", "tags")
       end
 
       should "return single value array with matching singular" do
-        data = { 'foo' => 'bar', 'tag' => 'dog', 'tags' => ['dog', 'cat'] }
-        assert_equal ['dog'], Utils.pluralized_array_from_hash(data, 'tag', 'tags')
+        data = { "foo" => "bar", "tag" => "dog", "tags" => %w(dog cat) }
+        assert_equal ["dog"], Utils.pluralized_array_from_hash(data, "tag", "tags")
       end
 
       should "return single value array with matching singular with spaces" do
-        data = { 'foo' => 'bar', 'tag' => 'dog cat', 'tags' => ['dog', 'cat'] }
-        assert_equal ['dog cat'], Utils.pluralized_array_from_hash(data, 'tag', 'tags')
+        data = { "foo" => "bar", "tag" => "dog cat", "tags" => %w(dog cat) }
+        assert_equal ["dog cat"], Utils.pluralized_array_from_hash(data, "tag", "tags")
       end
 
       should "return empty array with matching nil plural" do
-        data = { 'foo' => 'bar', 'tags' => nil }
-        assert_equal [], Utils.pluralized_array_from_hash(data, 'tag', 'tags')
+        data = { "foo" => "bar", "tags" => nil }
+        assert_equal [], Utils.pluralized_array_from_hash(data, "tag", "tags")
       end
 
       should "return empty array with matching empty array" do
-        data = { 'foo' => 'bar', 'tags' => [] }
-        assert_equal [], Utils.pluralized_array_from_hash(data, 'tag', 'tags')
+        data = { "foo" => "bar", "tags" => [] }
+        assert_equal [], Utils.pluralized_array_from_hash(data, "tag", "tags")
       end
 
       should "return single value array with matching plural with single string value" do
-        data = { 'foo' => 'bar', 'tags' => 'dog' }
-        assert_equal ['dog'], Utils.pluralized_array_from_hash(data, 'tag', 'tags')
+        data = { "foo" => "bar", "tags" => "dog" }
+        assert_equal ["dog"], Utils.pluralized_array_from_hash(data, "tag", "tags")
       end
 
-      should "return multiple value array with matching plural with single string value with spaces" do
-        data = { 'foo' => 'bar', 'tags' => 'dog cat' }
-        assert_equal ['dog', 'cat'], Utils.pluralized_array_from_hash(data, 'tag', 'tags')
+      should "return multiple value array with matching plural with " \
+             "single string value with spaces" do
+        data = { "foo" => "bar", "tags" => "dog cat" }
+        assert_equal %w(dog cat), Utils.pluralized_array_from_hash(data, "tag", "tags")
       end
 
       should "return single value array with matching plural with single value array" do
-        data = { 'foo' => 'bar', 'tags' => ['dog'] }
-        assert_equal ['dog'], Utils.pluralized_array_from_hash(data, 'tag', 'tags')
+        data = { "foo" => "bar", "tags" => ["dog"] }
+        assert_equal ["dog"], Utils.pluralized_array_from_hash(data, "tag", "tags")
       end
 
-      should "return multiple value array with matching plural with multiple value array" do
-        data = { 'foo' => 'bar', 'tags' => ['dog', 'cat'] }
-        assert_equal ['dog', 'cat'], Utils.pluralized_array_from_hash(data, 'tag', 'tags')
+      should "return multiple value array with matching plural with " \
+             "multiple value array" do
+        data = { "foo" => "bar", "tags" => %w(dog cat) }
+        assert_equal %w(dog cat), Utils.pluralized_array_from_hash(data, "tag", "tags")
       end
-
     end
-
   end
 
   context "The \`Utils.parse_date\` method" do
@@ -108,7 +106,10 @@ class TestUtils < JekyllUnitTest
 
     should "throw an error with the default message if no message is passed in" do
       date = "Blah this is invalid"
-      assert_raises Jekyll::Errors::InvalidDateError, "Invalid date '#{date}': Input could not be parsed." do
+      assert_raises(
+        Jekyll::Errors::InvalidDateError,
+        "Invalid date '#{date}': Input could not be parsed."
+      ) do
         Utils.parse_date(date)
       end
     end
@@ -116,7 +117,10 @@ class TestUtils < JekyllUnitTest
     should "throw an error with the provided message if a message is passed in" do
       date = "Blah this is invalid"
       message = "Aaaah, the world has exploded!"
-      assert_raises Jekyll::Errors::InvalidDateError, "Invalid date '#{date}': #{message}" do
+      assert_raises(
+        Jekyll::Errors::InvalidDateError,
+        "Invalid date '#{date}': #{message}"
+      ) do
         Utils.parse_date(date, message)
       end
     end
@@ -144,7 +148,10 @@ class TestUtils < JekyllUnitTest
     end
 
     should "drop trailing punctuation" do
-      assert_equal "so-what-is-jekyll-exactly", Utils.slugify("So what is Jekyll, exactly?")
+      assert_equal(
+        "so-what-is-jekyll-exactly",
+        Utils.slugify("So what is Jekyll, exactly?")
+      )
       assert_equal "كيف-حالك", Utils.slugify("كيف حالك؟")
     end
 
@@ -157,7 +164,10 @@ class TestUtils < JekyllUnitTest
     end
 
     should "combine adjacent hyphens and spaces" do
-      assert_equal "customizing-git-git-hooks", Utils.slugify("Customizing Git - Git Hooks")
+      assert_equal(
+        "customizing-git-git-hooks",
+        Utils.slugify("Customizing Git - Git Hooks")
+      )
     end
 
     should "replace punctuation in any scripts by hyphens" do
@@ -171,7 +181,10 @@ class TestUtils < JekyllUnitTest
     end
 
     should "not change behaviour if mode is default" do
-      assert_equal "the-config-yml-file", Utils.slugify("The _config.yml file?", mode: "default")
+      assert_equal(
+        "the-config-yml-file",
+        Utils.slugify("The _config.yml file?", :mode => "default")
+      )
     end
 
     should "not change behaviour if mode is nil" do
@@ -179,53 +192,128 @@ class TestUtils < JekyllUnitTest
     end
 
     should "not replace period and underscore if mode is pretty" do
-      assert_equal "the-_config.yml-file", Utils.slugify("The _config.yml file?", mode: "pretty")
+      assert_equal(
+        "the-_config.yml-file",
+        Utils.slugify("The _config.yml file?", :mode => "pretty")
+      )
     end
 
     should "only replace whitespace if mode is raw" do
-      assert_equal "the-_config.yml-file?", Utils.slugify("The _config.yml file?", mode: "raw")
+      assert_equal(
+        "the-_config.yml-file?",
+        Utils.slugify("The _config.yml file?", :mode => "raw")
+      )
     end
 
     should "return the given string if mode is none" do
-      assert_equal "the _config.yml file?", Utils.slugify("The _config.yml file?", mode: "none")
+      assert_equal(
+        "the _config.yml file?",
+        Utils.slugify("The _config.yml file?", :mode => "none")
+      )
     end
 
     should "Keep all uppercase letters if cased is true" do
-      assert_equal "Working-with-drafts", Utils.slugify("Working with drafts", cased: true)
-      assert_equal "Basic-Usage", Utils.slugify("Basic   Usage", cased: true)
-      assert_equal "Working-with-drafts", Utils.slugify("  Working with drafts   ", cased: true)
-      assert_equal "So-what-is-Jekyll-exactly", Utils.slugify("So what is Jekyll, exactly?", cased: true)
-      assert_equal "Pre-releases", Utils.slugify("Pre-releases", cased: true)
-      assert_equal "The-config-yml-file", Utils.slugify("The _config.yml file", cased: true)
-      assert_equal "Customizing-Git-Git-Hooks", Utils.slugify("Customizing Git - Git Hooks", cased: true)
-      assert_equal "The-config-yml-file", Utils.slugify("The _config.yml file?", mode: "default", cased: true)
-      assert_equal "The-config-yml-file", Utils.slugify("The _config.yml file?", cased: true)
-      assert_equal "The-_config.yml-file", Utils.slugify("The _config.yml file?", mode: "pretty", cased: true)
-      assert_equal "The-_config.yml-file?", Utils.slugify("The _config.yml file?", mode: "raw", cased: true)
-      assert_equal "The _config.yml file?", Utils.slugify("The _config.yml file?", mode: "none", cased: true)
+      assert_equal(
+        "Working-with-drafts",
+        Utils.slugify("Working with drafts", :cased => true)
+      )
+      assert_equal(
+        "Basic-Usage",
+        Utils.slugify("Basic   Usage", :cased => true)
+      )
+      assert_equal(
+        "Working-with-drafts",
+        Utils.slugify("  Working with drafts   ", :cased => true)
+      )
+      assert_equal(
+        "So-what-is-Jekyll-exactly",
+        Utils.slugify("So what is Jekyll, exactly?", :cased => true)
+      )
+      assert_equal(
+        "Pre-releases",
+        Utils.slugify("Pre-releases", :cased => true)
+      )
+      assert_equal(
+        "The-config-yml-file",
+        Utils.slugify("The _config.yml file", :cased => true)
+      )
+      assert_equal(
+        "Customizing-Git-Git-Hooks",
+        Utils.slugify("Customizing Git - Git Hooks", :cased => true)
+      )
+      assert_equal(
+        "The-config-yml-file",
+        Utils.slugify("The _config.yml file?", :mode => "default", :cased => true)
+      )
+      assert_equal(
+        "The-config-yml-file",
+        Utils.slugify("The _config.yml file?", :cased => true)
+      )
+      assert_equal(
+        "The-_config.yml-file",
+        Utils.slugify("The _config.yml file?", :mode => "pretty", :cased => true)
+      )
+      assert_equal(
+        "The-_config.yml-file?",
+        Utils.slugify("The _config.yml file?", :mode => "raw", :cased => true)
+      )
+      assert_equal(
+        "The _config.yml file?",
+        Utils.slugify("The _config.yml file?", :mode => "none", :cased => true)
+      )
     end
   end
 
   context "The \`Utils.titleize_slug\` method" do
     should "capitalize all words and not drop any words" do
-      assert_equal "This Is A Long Title With Mixed Capitalization", Utils.titleize_slug("This-is-a-Long-title-with-Mixed-capitalization")
-      assert_equal "This Is A Title With Just The Initial Word Capitalized", Utils.titleize_slug("This-is-a-title-with-just-the-initial-word-capitalized")
-      assert_equal "This Is A Title With No Capitalization", Utils.titleize_slug("this-is-a-title-with-no-capitalization")
+      assert_equal(
+        "This Is A Long Title With Mixed Capitalization",
+        Utils.titleize_slug("This-is-a-Long-title-with-Mixed-capitalization")
+      )
+      assert_equal(
+        "This Is A Title With Just The Initial Word Capitalized",
+        Utils.titleize_slug("This-is-a-title-with-just-the-initial-word-capitalized")
+      )
+      assert_equal(
+        "This Is A Title With No Capitalization",
+        Utils.titleize_slug("this-is-a-title-with-no-capitalization")
+      )
     end
   end
 
   context "The \`Utils.add_permalink_suffix\` method" do
     should "handle built-in permalink styles" do
-      assert_equal "/:basename/", Utils.add_permalink_suffix("/:basename", :pretty)
-      assert_equal "/:basename:output_ext", Utils.add_permalink_suffix("/:basename", :date)
-      assert_equal "/:basename:output_ext", Utils.add_permalink_suffix("/:basename", :ordinal)
-      assert_equal "/:basename:output_ext", Utils.add_permalink_suffix("/:basename", :none)
+      assert_equal(
+        "/:basename/",
+        Utils.add_permalink_suffix("/:basename", :pretty)
+      )
+      assert_equal(
+        "/:basename:output_ext",
+        Utils.add_permalink_suffix("/:basename", :date)
+      )
+      assert_equal(
+        "/:basename:output_ext",
+        Utils.add_permalink_suffix("/:basename", :ordinal)
+      )
+      assert_equal(
+        "/:basename:output_ext",
+        Utils.add_permalink_suffix("/:basename", :none)
+      )
     end
 
     should "handle custom permalink styles" do
-      assert_equal "/:basename/", Utils.add_permalink_suffix("/:basename", "/:title/")
-      assert_equal "/:basename:output_ext", Utils.add_permalink_suffix("/:basename", "/:title:output_ext")
-      assert_equal "/:basename", Utils.add_permalink_suffix("/:basename", "/:title")
+      assert_equal(
+        "/:basename/",
+        Utils.add_permalink_suffix("/:basename", "/:title/")
+      )
+      assert_equal(
+        "/:basename:output_ext",
+        Utils.add_permalink_suffix("/:basename", "/:title:output_ext")
+      )
+      assert_equal(
+        "/:basename",
+        Utils.add_permalink_suffix("/:basename", "/:title")
+      )
     end
   end
 
@@ -270,17 +358,17 @@ class TestUtils < JekyllUnitTest
   context "The \`Utils.has_yaml_header?\` method" do
     should "accept files with yaml front matter" do
       file = source_dir("_posts", "2008-10-18-foo-bar.markdown")
-      assert_equal "---\n", File.open(file, 'rb') { |f| f.read(4) }
+      assert_equal "---\n", File.open(file, "rb") { |f| f.read(4) }
       assert Utils.has_yaml_header?(file)
     end
     should "accept files with extraneous spaces after yaml front matter" do
       file = source_dir("_posts", "2015-12-27-extra-spaces.markdown")
-      assert_equal "---  \n", File.open(file, 'rb') { |f| f.read(6) }
+      assert_equal "---  \n", File.open(file, "rb") { |f| f.read(6) }
       assert Utils.has_yaml_header?(file)
     end
     should "reject pgp files and the like which resemble front matter" do
       file = source_dir("pgp.key")
-      assert_equal "-----B", File.open(file, 'rb') { |f| f.read(6) }
+      assert_equal "-----B", File.open(file, "rb") { |f| f.read(6) }
       refute Utils.has_yaml_header?(file)
     end
   end