middleman-core 4.3.0.rc.4 → 4.3.0

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

@@ -6,138 +6,142 @@ 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, %i[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, [:wu, :tang]
 
-        expect(@subject.store['foo']).to eq('bar' => 'baz')
-        expect(@subject.store['baz']).to match_array %i[wu tang]
+        expect( @subject.store['foo'] ).to eq({ 'bar' => 'baz' })
+        expect( @subject.store['baz'] ).to match_array [:wu, :tang]
       end
 
-      it 'overwrites previous keys if given the same key' do
-        @subject.store :foo, 'bar' => 'baz'
-        @subject.store :foo, %i[wu tang]
+      it "overwrites previous keys if given the same key" do
+        @subject.store :foo, { 'bar' => 'baz' }
+        @subject.store :foo, [:wu, :tang]
 
-        expect(@subject.store['foo']).to match_array %i[wu tang]
+        expect( @subject.store['foo'] ).to match_array [: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, -> { 'bar' }
+    context "when given a name and proc" do
+      it "adds a callback at the given name" do
+        @subject.callbacks :foo, lambda { "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, -> { 'bar' }
-        @subject.callbacks :foo, -> { 'baz' }
+      it "overwrites previous keys if given the same key" do
+        @subject.callbacks :foo, lambda { "bar" }
+        @subject.callbacks :foo, lambda { "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, %i[bar baz]
-        expect(@subject.data_for_path(:foo)).to match_array %i[bar baz]
+      it "returns array for key" do
+        @subject.store :foo, [:bar, :baz]
+        expect( @subject.data_for_path(:foo) ).to match_array [:bar, :baz]
       end
     end
 
-    context 'given path matches callback data' do
-      it 'returns value of callback lambda' do
-        @subject.callbacks :foo, -> { { 'bar' => 'baz' } }
-        @subject.callbacks :wu, -> { %i[tang clan] }
+    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] }
 
-        expect(@subject.data_for_path(:foo)).to eq('bar' => 'baz')
-        expect(@subject.data_for_path(:wu)).to match_array %i[tang clan]
+        expect( @subject.data_for_path(:foo) ).to eq({ 'bar' => 'baz' })
+        expect( @subject.data_for_path(:wu) ).to match_array [: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, -> { { 'callback' => 'data' } }
+    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' } }
 
-        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 { '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.new { "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 do
+      expect{
         subject.respond_to? :test
-      end.not_to raise_error
+      }.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,82 +2,85 @@ 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 = ->(p) { p.length > 5 }
+    it "works with a proc" do
+      matcher = lambda {|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', ''
@@ -86,60 +89,61 @@ 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 do
-          Middleman::Util.asset_url(@mm, 'blank.gif', 'images', relative: true)
-        end.to raise_error ArgumentError
+      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
       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
@@ -147,26 +151,27 @@ 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
@@ -180,44 +185,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

data/spec/spec_helper.rb

@@ -1,6 +1,11 @@
 require 'simplecov'
 SimpleCov.root(File.expand_path(File.dirname(__FILE__) + '/..'))
-SimpleCov.start
+
+require 'coveralls'
+Coveralls.wear!
+
+require 'codeclimate-test-reporter'
+CodeClimate::TestReporter.start
 
 require 'aruba/api'
 RSpec.configure do |config|

data/spec/support/given.rb

@@ -1,38 +1,42 @@
 module Given
-  ROOT = File.expand_path('../..', __dir__)
-  TMP  = File.join(ROOT, 'tmp')
+  ROOT = File.expand_path( '../..', File.dirname( File.realpath(__FILE__) ) )
+  TMP  = File.join( ROOT, 'tmp' )
 
   class << self
-    def fixture(name)
+
+    def fixture name
       cleanup!
 
-      `rsync -av #{File.join(ROOT, 'fixtures', name)}/ #{TMP}/`
+      `rsync -av #{File.join( ROOT, 'fixtures', name )}/ #{TMP}/`
       Dir.chdir TMP
       ENV['MM_ROOT'] = TMP
     end
 
-    def no_file(name)
+    def no_file name
       FileUtils.rm name, force: true
     end
 
-    def symlink(source, destination)
+    def symlink source, destination
       no_file destination
       FileUtils.symlink File.expand_path(source),
                         File.expand_path(destination),
                         force: true
     end
 
-    def file(name, content)
-      file_path = File.join(TMP, name)
-      FileUtils.mkdir_p(File.dirname(file_path))
-      File.open(file_path, 'w') do |file|
+    def file name, content
+      file_path = File.join( TMP, name )
+      FileUtils.mkdir_p( File.dirname(file_path) )
+      File.open( file_path, 'w' ) do |file|
         file.write content
       end
     end
 
     def cleanup!
       Dir.chdir ROOT
-      `rm -rf #{TMP}` if File.exist? TMP
+      if File.exist? TMP
+        `rm -rf #{TMP}`
+      end
     end
+
   end
 end