middleman-core 4.3.0.rc.1 → 4.3.0.rc.2

data/spec/middleman-core/core_extensions/data_spec.rb

@@ -6,142 +6,138 @@ describe Middleman::CoreExtensions::Data do
 end
 
 describe Middleman::CoreExtensions::Data::DataStore do
-
-  describe "#store" do
+  describe '#store' do
     before :each do
-      @subject = described_class.new instance_double("Middleman::Application"),
+      @subject = described_class.new instance_double('Middleman::Application'),
                                      Middleman::CoreExtensions::Data::DATA_FILE_MATCHER
     end
 
-    context "when given a name and data" do
-      it "adds data at the given name" do
-        @subject.store :foo, { 'bar' => 'baz' }
-        @subject.store :baz, [:wu, :tang]
+    context 'when given a name and data' do
+      it 'adds data at the given name' do
+        @subject.store :foo, 'bar' => 'baz'
+        @subject.store :baz, %i[wu tang]
 
-        expect( @subject.store['foo'] ).to eq({ 'bar' => 'baz' })
-        expect( @subject.store['baz'] ).to match_array [:wu, :tang]
+        expect(@subject.store['foo']).to eq('bar' => 'baz')
+        expect(@subject.store['baz']).to match_array %i[wu tang]
       end
 
-      it "overwrites previous keys if given the same key" do
-        @subject.store :foo, { 'bar' => 'baz' }
-        @subject.store :foo, [:wu, :tang]
+      it 'overwrites previous keys if given the same key' do
+        @subject.store :foo, 'bar' => 'baz'
+        @subject.store :foo, %i[wu tang]
 
-        expect( @subject.store['foo'] ).to match_array [:wu, :tang]
+        expect(@subject.store['foo']).to match_array %i[wu tang]
       end
     end
 
-    context "when given no args" do
-      it "returns @local_sources instance var" do
-        @subject.instance_variable_set :"@local_sources", { foo: 'bar' }
-        expect( @subject.store ).to eq({ foo: 'bar' })
+    context 'when given no args' do
+      it 'returns @local_sources instance var' do
+        @subject.instance_variable_set :"@local_sources", foo: 'bar'
+        expect(@subject.store).to eq(foo: 'bar')
       end
     end
   end
 
-  describe "#callbacks" do
+  describe '#callbacks' do
     before :each do
-      @subject = described_class.new instance_double("Middleman::Application"),
+      @subject = described_class.new instance_double('Middleman::Application'),
                                      Middleman::CoreExtensions::Data::DATA_FILE_MATCHER
     end
 
-    context "when given a name and proc" do
-      it "adds a callback at the given name" do
-        @subject.callbacks :foo, lambda { "bar" }
+    context 'when given a name and proc' do
+      it 'adds a callback at the given name' do
+        @subject.callbacks :foo, -> { 'bar' }
         callback = @subject.instance_variable_get(:@callback_sources)['foo']
 
-        expect( callback.call ).to eq "bar"
+        expect(callback.call).to eq 'bar'
       end
 
-      it "overwrites previous keys if given the same key" do
-        @subject.callbacks :foo, lambda { "bar" }
-        @subject.callbacks :foo, lambda { "baz" }
+      it 'overwrites previous keys if given the same key' do
+        @subject.callbacks :foo, -> { 'bar' }
+        @subject.callbacks :foo, -> { 'baz' }
         callback = @subject.instance_variable_get(:@callback_sources)['foo']
 
-        expect( callback.call ).to eq "baz"
+        expect(callback.call).to eq 'baz'
       end
     end
 
-    context "when given no args" do
-      it "returns @callback_sources instance var" do
-        @subject.instance_variable_set :"@callback_sources", { foo: 'bar' }
-        expect( @subject.callbacks ).to eq({ foo: 'bar' })
+    context 'when given no args' do
+      it 'returns @callback_sources instance var' do
+        @subject.instance_variable_set :"@callback_sources", foo: 'bar'
+        expect(@subject.callbacks).to eq(foo: 'bar')
       end
     end
   end
 
-  describe "#data_for_path" do
+  describe '#data_for_path' do
     before :each do
-      @subject = described_class.new instance_double("Middleman::Application"),
+      @subject = described_class.new instance_double('Middleman::Application'),
                                      Middleman::CoreExtensions::Data::DATA_FILE_MATCHER
     end
 
-    context "given path matches local data" do
-      it "returns hash for key" do
-        @subject.store :foo, { 'bar' => 'baz' }
-        expect( @subject.data_for_path(:foo) ).to eq({ 'bar' => 'baz' })
+    context 'given path matches local data' do
+      it 'returns hash for key' do
+        @subject.store :foo, 'bar' => 'baz'
+        expect(@subject.data_for_path(:foo)).to eq('bar' => 'baz')
       end
 
-      it "returns array for key" do
-        @subject.store :foo, [:bar, :baz]
-        expect( @subject.data_for_path(:foo) ).to match_array [:bar, :baz]
+      it 'returns array for key' do
+        @subject.store :foo, %i[bar baz]
+        expect(@subject.data_for_path(:foo)).to match_array %i[bar baz]
       end
     end
 
-    context "given path matches callback data" do
-      it "returns value of calback lambda" do
-        @subject.callbacks :foo, lambda { { 'bar' => 'baz' } }
-        @subject.callbacks :wu, lambda { [:tang, :clan] }
+    context 'given path matches callback data' do
+      it 'returns value of calback lambda' do
+        @subject.callbacks :foo, -> { { 'bar' => 'baz' } }
+        @subject.callbacks :wu, -> { %i[tang clan] }
 
-        expect( @subject.data_for_path(:foo) ).to eq({ 'bar' => 'baz' })
-        expect( @subject.data_for_path(:wu) ).to match_array [:tang, :clan]
+        expect(@subject.data_for_path(:foo)).to eq('bar' => 'baz')
+        expect(@subject.data_for_path(:wu)).to match_array %i[tang clan]
       end
     end
 
-    context "given path matches both sources" do
-      it "returns match from local data" do
-        @subject.store :foo, { 'local' => 'data' }
-        @subject.callbacks :foo, lambda { { 'callback' => 'data' } }
+    context 'given path matches both sources' do
+      it 'returns match from local data' do
+        @subject.store :foo, 'local' => 'data'
+        @subject.callbacks :foo, -> { { 'callback' => 'data' } }
 
-        expect( @subject.data_for_path(:foo) ).to eq({ 'local' => 'data' })
+        expect(@subject.data_for_path(:foo)).to eq('local' => 'data')
       end
     end
 
-    context "given path matches no sources" do
-      it "returns nil" do
-        expect( @subject.data_for_path(:missing) ).to be_nil
+    context 'given path matches no sources' do
+      it 'returns nil' do
+        expect(@subject.data_for_path(:missing)).to be_nil
       end
     end
   end
 
-  describe "#key?" do
-
-    it "returns true if key included in local_data, local_sources, or callback_sources" do
-      subject = described_class.new instance_double("Middleman::Application"), Middleman::CoreExtensions::Data::DATA_FILE_MATCHER
-      subject.store :"foo-store", { foo: "bar" }
-      subject.callbacks :"foo-callback", Proc.new { "bar" }
-      subject.instance_variable_get(:@local_data)["foo-local"] = "bar"
+  describe '#key?' do
+    it 'returns true if key included in local_data, local_sources, or callback_sources' do
+      subject = described_class.new instance_double('Middleman::Application'), Middleman::CoreExtensions::Data::DATA_FILE_MATCHER
+      subject.store :"foo-store", foo: 'bar'
+      subject.callbacks :"foo-callback", proc { 'bar' }
+      subject.instance_variable_get(:@local_data)['foo-local'] = 'bar'
 
-      expect( subject.key?("foo-store") ).to be_truthy
-      expect( subject.key?("foo-callback") ).to be_truthy
-      expect( subject.key?("foo-local") ).to be_truthy
+      expect(subject.key?('foo-store')).to be_truthy
+      expect(subject.key?('foo-callback')).to be_truthy
+      expect(subject.key?('foo-local')).to be_truthy
     end
 
-    it "returns false if key not in local_data, local_sources, or callback_sources" do
-      subject = described_class.new instance_double("Middleman::Application"), Middleman::CoreExtensions::Data::DATA_FILE_MATCHER
+    it 'returns false if key not in local_data, local_sources, or callback_sources' do
+      subject = described_class.new instance_double('Middleman::Application'), Middleman::CoreExtensions::Data::DATA_FILE_MATCHER
 
-      expect( subject.key?("foo-store") ).to be_falsy
-      expect( subject.key?("foo-callback") ).to be_falsy
-      expect( subject.key?("foo-local") ).to be_falsy
+      expect(subject.key?('foo-store')).to be_falsy
+      expect(subject.key?('foo-callback')).to be_falsy
+      expect(subject.key?('foo-local')).to be_falsy
     end
 
     it "doesn't raise a stack error if missing the given key" do
-      subject = described_class.new instance_double("Middleman::Application"), Middleman::CoreExtensions::Data::DATA_FILE_MATCHER
+      subject = described_class.new instance_double('Middleman::Application'), Middleman::CoreExtensions::Data::DATA_FILE_MATCHER
 
-      expect{
+      expect do
         subject.respond_to? :test
-      }.not_to raise_error
+      end.not_to raise_error
     end
-
   end
-
 end

data/spec/middleman-core/dns_resolver_spec.rb

@@ -29,7 +29,7 @@ RSpec.describe Middleman::DnsResolver do
       end
 
       let(:unresolved_ip) { '127.0.0.1' }
-      let(:resolved_names) { %w(localhost) }
+      let(:resolved_names) { %w[localhost] }
 
       it { expect(resolver.names_for(unresolved_ip)).to eq resolved_names }
     end
@@ -46,7 +46,7 @@ RSpec.describe Middleman::DnsResolver do
       end
 
       let(:unresolved_ip) { '127.0.0.1' }
-      let(:resolved_names) { %w(localhost) }
+      let(:resolved_names) { %w[localhost] }
 
       it { expect(resolver.names_for(unresolved_ip)).to eq resolved_names }
     end
@@ -61,7 +61,7 @@ RSpec.describe Middleman::DnsResolver do
       end
 
       let(:unresolved_ip) { '127.0.0.1' }
-      let(:resolved_names) { %w(localhost) }
+      let(:resolved_names) { %w[localhost] }
 
       it { expect(resolver.names_for(unresolved_ip)).to eq resolved_names }
     end
@@ -78,7 +78,7 @@ RSpec.describe Middleman::DnsResolver do
       end
 
       let(:unresolved_ips) { '127.0.0.1' }
-      let(:resolved_name) { %w(localhost) }
+      let(:resolved_name) { %w[localhost] }
 
       it { expect(resolver.ips_for(unresolved_ips)).to eq resolved_name }
     end
@@ -95,7 +95,7 @@ RSpec.describe Middleman::DnsResolver do
       end
 
       let(:unresolved_ips) { '127.0.0.1' }
-      let(:resolved_name) { %w(localhost) }
+      let(:resolved_name) { %w[localhost] }
 
       it { expect(resolver.ips_for(unresolved_ips)).to eq resolved_name }
     end
@@ -110,7 +110,7 @@ RSpec.describe Middleman::DnsResolver do
       end
 
       let(:unresolved_ips) { '127.0.0.1' }
-      let(:resolved_name) { %w(localhost) }
+      let(:resolved_name) { %w[localhost] }
 
       it { expect(resolver.ips_for(unresolved_ips)).to eq resolved_name }
     end

data/spec/middleman-core/util_spec.rb

@@ -2,85 +2,82 @@ require 'spec_helper'
 require 'middleman-core'
 
 describe Middleman::Util do
-
-  describe "::path_match" do
-    it "matches a literal string" do
-      expect(Middleman::Util.path_match '/index.html', '/index.html').to be true
+  describe '::path_match' do
+    it 'matches a literal string' do
+      expect(Middleman::Util.path_match('/index.html', '/index.html')).to be true
     end
 
     it "won't match a wrong string" do
-      expect(Middleman::Util.path_match '/foo.html', '/index.html').to be false
+      expect(Middleman::Util.path_match('/foo.html', '/index.html')).to be false
     end
 
     it "won't match a partial string" do
-      expect(Middleman::Util.path_match 'ind', '/index.html').to be false
+      expect(Middleman::Util.path_match('ind', '/index.html')).to be false
     end
 
-    it "works with a regex" do
-      expect(Middleman::Util.path_match /\.html$/, '/index.html').to be true
-      expect(Middleman::Util.path_match /\.js$/, '/index.html').to be false
+    it 'works with a regex' do
+      expect(Middleman::Util.path_match(/\.html$/, '/index.html')).to be true
+      expect(Middleman::Util.path_match(/\.js$/, '/index.html')).to be false
     end
 
-    it "works with a proc" do
-      matcher = lambda {|p| p.length > 5 }
+    it 'works with a proc' do
+      matcher = ->(p) { p.length > 5 }
 
-      expect(Middleman::Util.path_match matcher, '/index.html').to be true
-      expect(Middleman::Util.path_match matcher, '/i').to be false
+      expect(Middleman::Util.path_match(matcher, '/index.html')).to be true
+      expect(Middleman::Util.path_match(matcher, '/i')).to be false
     end
 
-    it "works with globs" do
-      expect(Middleman::Util.path_match '/foo/*.html', '/foo/index.html').to be true
-      expect(Middleman::Util.path_match '/foo/*.html', '/foo/index.js').to be false
-      expect(Middleman::Util.path_match '/bar/*.html', '/foo/index.js').to be false
+    it 'works with globs' do
+      expect(Middleman::Util.path_match('/foo/*.html', '/foo/index.html')).to be true
+      expect(Middleman::Util.path_match('/foo/*.html', '/foo/index.js')).to be false
+      expect(Middleman::Util.path_match('/bar/*.html', '/foo/index.js')).to be false
 
-      expect(Middleman::Util.path_match '/foo/*', '/foo/bar/index.html').to be true
-      expect(Middleman::Util.path_match '/foo/**/*', '/foo/bar/index.html').to be true
-      expect(Middleman::Util.path_match '/foo/**', '/foo/bar/index.html').to be true
+      expect(Middleman::Util.path_match('/foo/*', '/foo/bar/index.html')).to be true
+      expect(Middleman::Util.path_match('/foo/**/*', '/foo/bar/index.html')).to be true
+      expect(Middleman::Util.path_match('/foo/**', '/foo/bar/index.html')).to be true
     end
   end
 
-  describe "::binary?" do
-    %w(plain.txt unicode.txt unicode).each do |file|
+  describe '::binary?' do
+    %w[plain.txt unicode.txt unicode].each do |file|
       it "recognizes #{file} as not binary" do
         expect(Middleman::Util.binary?(File.join(File.dirname(__FILE__), "binary_spec/#{file}"))).to be false
       end
     end
 
-    %w(middleman.png middleman stars.svgz).each do |file|
+    %w[middleman.png middleman stars.svgz].each do |file|
       it "recognizes #{file} as binary" do
         expect(Middleman::Util.binary?(File.join(File.dirname(__FILE__), "binary_spec/#{file}"))).to be true
       end
     end
   end
 
-  describe "::recursively_enhance" do
-    it "returns Hashie extended Hash if given a hash" do
-      input   = {test: "subject"}
+  describe '::recursively_enhance' do
+    it 'returns Hashie extended Hash if given a hash' do
+      input   = { test: 'subject' }
       subject = Middleman::Util.recursively_enhance input
 
-      expect( subject.test ).to eq "subject"
+      expect(subject.test).to eq 'subject'
     end
 
-    it "returns Array with strings, or IndifferentHash, true, false" do
-      indifferent_hash = {test: "subject"}
-      regular_hash     = {regular: "hash"}
-      input   = [ indifferent_hash, regular_hash, true, false ]
+    it 'returns Array with strings, or IndifferentHash, true, false' do
+      indifferent_hash = { test: 'subject' }
+      regular_hash     = { regular: 'hash' }
+      input   = [indifferent_hash, regular_hash, true, false]
       subject = Middleman::Util.recursively_enhance input
 
-      expect( subject[1].regular ).to eq "hash"
-      expect( subject[2] ).to eq true
-      expect( subject[3] ).to eq false
+      expect(subject[1].regular).to eq 'hash'
+      expect(subject[2]).to eq true
+      expect(subject[3]).to eq false
     end
   end
 
-  describe "::asset_url" do
-
+  describe '::asset_url' do
     after(:each) do
       Given.cleanup!
     end
 
-    context "when http_prefix is activated" do
-
+    context 'when http_prefix is activated' do
       before(:each) do
         Given.fixture 'clean-dir-app'
         Given.file 'source/images/blank.gif', ''
@@ -89,61 +86,60 @@ describe Middleman::Util do
         end
       end
 
-      it "returns path with http_prefix pre-pended if resource is found" do
-        expect( Middleman::Util.asset_url( @mm, 'blank.gif', 'images', http_prefix: 'http_prefix' ) ).to eq 'http_prefix/images/blank.gif'
+      it 'returns path with http_prefix pre-pended if resource is found' do
+        expect(Middleman::Util.asset_url(@mm, 'blank.gif', 'images', http_prefix: 'http_prefix')).to eq 'http_prefix/images/blank.gif'
       end
 
-      it "returns path with http_prefix pre-pended if resource is not found" do
-        expect( Middleman::Util.asset_url( @mm, 'missing.gif', 'images', http_prefix: 'http_prefix' ) ).to eq 'http_prefix/images/missing.gif'
+      it 'returns path with http_prefix pre-pended if resource is not found' do
+        expect(Middleman::Util.asset_url(@mm, 'missing.gif', 'images', http_prefix: 'http_prefix')).to eq 'http_prefix/images/missing.gif'
       end
     end
 
-    it "returns path relative to the provided current_resource" do
+    it 'returns path relative to the provided current_resource' do
       Given.fixture 'clean-dir-app'
       Given.file 'source/a-path/index.html', ''
       Given.file 'source/a-path/images/blank.gif', ''
       @mm = Middleman::Application.new
       current_resource = @mm.sitemap.find_resource_by_path('a-path/index.html')
-      expect( Middleman::Util.asset_url( @mm, 'images/blank.gif', 'images', current_resource: current_resource ) ).to eq '/a-path/images/blank.gif'
+      expect(Middleman::Util.asset_url(@mm, 'images/blank.gif', 'images', current_resource: current_resource)).to eq '/a-path/images/blank.gif'
     end
 
-    context "when relative is true" do
-
+    context 'when relative is true' do
       before(:each) do
         Given.fixture 'relative-assets-app'
         @mm = Middleman::Application.new
       end
 
-      it "returns path relative to the provided current_resource" do
-        current_resource = instance_double("Middleman::Sitemap::Resource", destination_path: 'a-path/index.html', path: 'a-path/index.html')
-        expect( Middleman::Util.asset_url( @mm, 'blank.gif', 'images', current_resource: current_resource,
-                                                                       relative: true ) ).to eq '../images/blank.gif'
+      it 'returns path relative to the provided current_resource' do
+        current_resource = instance_double('Middleman::Sitemap::Resource', destination_path: 'a-path/index.html', path: 'a-path/index.html')
+        expect(Middleman::Util.asset_url(@mm, 'blank.gif', 'images', current_resource: current_resource,
+                                                                     relative: true)).to eq '../images/blank.gif'
       end
 
-      context "when the asset is stored in the same directory as current_resource" do
+      context 'when the asset is stored in the same directory as current_resource' do
         before do
           Given.file 'source/a-path/index.html', ''
           Given.file 'source/a-path/blank.gif', ''
           @mm = Middleman::Application.new
         end
 
-        it "returns path relative to the provided current_resource" do
+        it 'returns path relative to the provided current_resource' do
           current_resource = @mm.sitemap.find_resource_by_path('a-path/index.html')
-          expect( Middleman::Util.asset_url( @mm, 'blank.gif', 'images', current_resource: current_resource,
-                                                                        relative: true) ).to eq 'blank.gif'
+          expect(Middleman::Util.asset_url(@mm, 'blank.gif', 'images', current_resource: current_resource,
+                                                                       relative: true)).to eq 'blank.gif'
         end
       end
 
-      it "raises error if not given a current_resource" do
-        expect{
-          Middleman::Util.asset_url( @mm, 'blank.gif', 'images', relative: true )
-        }.to raise_error ArgumentError
+      it 'raises error if not given a current_resource' do
+        expect do
+          Middleman::Util.asset_url(@mm, 'blank.gif', 'images', relative: true)
+        end.to raise_error ArgumentError
       end
     end
 
-    it "returns path if it is already a full path" do
-      expect( Middleman::Util.asset_url( @mm, 'http://example.com' ) ).to eq 'http://example.com'
-      expect( Middleman::Util.asset_url( @mm, 'data:example' ) ).to eq 'data:example'
+    it 'returns path if it is already a full path' do
+      expect(Middleman::Util.asset_url(@mm, 'http://example.com')).to eq 'http://example.com'
+      expect(Middleman::Util.asset_url(@mm, 'data:example')).to eq 'data:example'
     end
 
     it "returns a resource url if given a resource's destination path" do
@@ -151,27 +147,26 @@ describe Middleman::Util do
       Given.file 'source/how/about/that.html', ''
       @mm = Middleman::Application.new
 
-      expect( Middleman::Util.asset_url( @mm, '/how/about/that/index.html' ) ).to eq '/how/about/that/'
+      expect(Middleman::Util.asset_url(@mm, '/how/about/that/index.html')).to eq '/how/about/that/'
     end
 
-    it "returns a resource url if given a resources path" do
+    it 'returns a resource url if given a resources path' do
       Given.fixture 'clean-dir-app' # includes directory indexes extension
       Given.file 'source/how/about/that.html', ''
       @mm = Middleman::Application.new
 
-      expect( Middleman::Util.asset_url( @mm, '/how/about/that.html' ) ).to eq '/how/about/that/'
+      expect(Middleman::Util.asset_url(@mm, '/how/about/that.html')).to eq '/how/about/that/'
     end
 
-    it "returns a resource url when asset_hash is on" do
+    it 'returns a resource url when asset_hash is on' do
       Given.fixture 'asset-hash-app'
       @mm = Middleman::Application.new
 
-      expect( Middleman::Util.asset_url( @mm, '100px.png', 'images') ).to match %r|/images/100px-[a-f0-9]+.png|
+      expect(Middleman::Util.asset_url(@mm, '100px.png', 'images')).to match %r{/images/100px-[a-f0-9]+.png}
     end
-
   end
 
-  describe "::find_related_files" do
+  describe '::find_related_files' do
     after(:each) do
       Given.cleanup!
     end
@@ -185,44 +180,44 @@ describe Middleman::Util do
       Pathname(File.expand_path("source/#{path}"))
     end
 
-    it "Finds partials possibly related to ERb files" do
+    it 'Finds partials possibly related to ERb files' do
       related = Middleman::Util.find_related_files(@mm, [source_file('partials/_test.erb')]).map { |f| f[:full_path].to_s }
-      expect(related).to include File.expand_path("source/index.html.erb")
+      expect(related).to include File.expand_path('source/index.html.erb')
 
       related = Middleman::Util.find_related_files(@mm, [source_file('partials/_test2.haml')]).map { |f| f[:full_path].to_s }
-      expect(related).to include File.expand_path("source/index.html.erb")
+      expect(related).to include File.expand_path('source/index.html.erb')
     end
 
-    it "Finds partials possible related to Scss files" do
+    it 'Finds partials possible related to Scss files' do
       related = Middleman::Util.find_related_files(@mm, [source_file('stylesheets/_include4.scss')]).map { |f| f[:full_path].to_s }
-      expect(related).to include File.expand_path("source/stylesheets/site.css.scss")
-      expect(related).to include File.expand_path("source/stylesheets/include2.css.scss")
+      expect(related).to include File.expand_path('source/stylesheets/site.css.scss')
+      expect(related).to include File.expand_path('source/stylesheets/include2.css.scss')
 
       related = Middleman::Util.find_related_files(@mm, [source_file('stylesheets/include2.css.scss')]).map { |f| f[:full_path].to_s }
-      expect(related).to include File.expand_path("source/stylesheets/site.css.scss")
-      expect(related).not_to include File.expand_path("source/stylesheets/include2.css.scss")
+      expect(related).to include File.expand_path('source/stylesheets/site.css.scss')
+      expect(related).not_to include File.expand_path('source/stylesheets/include2.css.scss')
 
       related = Middleman::Util.find_related_files(@mm, [source_file('stylesheets/include1.css')]).map { |f| f[:full_path].to_s }
-      expect(related).to include File.expand_path("source/stylesheets/site.css.scss")
-      expect(related).to include File.expand_path("source/stylesheets/include2.css.scss")
+      expect(related).to include File.expand_path('source/stylesheets/site.css.scss')
+      expect(related).to include File.expand_path('source/stylesheets/include2.css.scss')
 
       related = Middleman::Util.find_related_files(@mm, [source_file('stylesheets/_include3.sass')]).map { |f| f[:full_path].to_s }
-      expect(related).to include File.expand_path("source/stylesheets/site.css.scss")
-      expect(related).to include File.expand_path("source/stylesheets/include2.css.scss")
+      expect(related).to include File.expand_path('source/stylesheets/site.css.scss')
+      expect(related).to include File.expand_path('source/stylesheets/include2.css.scss')
     end
   end
 
-  describe "::step_through_extensions" do
-    it "returns the base name after templating engine extensions are removed" do
+  describe '::step_through_extensions' do
+    it 'returns the base name after templating engine extensions are removed' do
       result = Middleman::Util.step_through_extensions('my_file.html.haml.erb')
       expect(result).to eq 'my_file.html'
     end
 
-    it "does not loop infinitely when file name is a possible templating engine" do
+    it 'does not loop infinitely when file name is a possible templating engine' do
       expect do
-        Timeout::timeout(3.0) do
-          result = Middleman::Util.step_through_extensions("markdown.scss")
-          expect(result).to eq "markdown"
+        Timeout.timeout(3.0) do
+          result = Middleman::Util.step_through_extensions('markdown.scss')
+          expect(result).to eq 'markdown'
         end
       end.not_to raise_error
     end