roadie 3.0.0.pre1 → 3.0.0

data/spec/lib/roadie/asset_scanner_spec.rb

@@ -11,14 +11,14 @@ module Roadie
 
     it "is initialized with a DOM tree and a asset provider set" do
       scanner = AssetScanner.new dom, provider
-      scanner.dom.should == dom
-      scanner.asset_provider.should == provider
+      expect(scanner.dom).to eq(dom)
+      expect(scanner.asset_provider).to eq(provider)
     end
 
     describe "finding" do
       it "returns nothing when no stylesheets are referenced" do
         scanner = AssetScanner.new dom, provider
-        scanner.find_css.should == []
+        expect(scanner.find_css).to eq([])
       end
 
       it "finds all embedded stylesheets" do
@@ -38,11 +38,11 @@ module Roadie
 
         stylesheets = scanner.find_css
 
-        stylesheets.should have(2).stylesheets
-        stylesheets[0].to_s.should include("green")
-        stylesheets[1].to_s.should include("red")
+        expect(stylesheets).to have(2).stylesheets
+        expect(stylesheets[0].to_s).to include("green")
+        expect(stylesheets[1].to_s).to include("red")
 
-        stylesheets.first.name.should == "(inline)"
+        expect(stylesheets.first.name).to eq("(inline)")
       end
 
       it "does not find any embedded stylesheets marked for ignoring" do
@@ -55,35 +55,35 @@ module Roadie
           </html>
         HTML
         scanner = AssetScanner.new dom, provider
-        scanner.find_css.should have(1).stylesheet
+        expect(scanner.find_css).to have(1).stylesheet
       end
 
       it "finds referenced stylesheets through the provider" do
         stylesheet = double "A stylesheet"
-        provider.should_receive(:find_stylesheet!).with("/some/url.css").and_return stylesheet
+        expect(provider).to receive(:find_stylesheet!).with("/some/url.css").and_return stylesheet
 
         dom = dom_fragment %(<link rel="stylesheet" href="/some/url.css">)
         scanner = AssetScanner.new dom, provider
 
-        scanner.find_css.should == [stylesheet]
+        expect(scanner.find_css).to eq([stylesheet])
       end
 
       it "ignores referenced print stylesheets" do
         dom = dom_fragment %(<link rel="stylesheet" href="/error.css" media="print">)
-        provider.should_not_receive(:find_stylesheet!)
+        expect(provider).not_to receive(:find_stylesheet!)
 
         scanner = AssetScanner.new dom, provider
 
-        scanner.find_css.should == []
+        expect(scanner.find_css).to eq([])
       end
 
       it "does not look for ignored referenced stylesheets" do
         dom = dom_fragment %(<link rel="stylesheet" href="/error.css" data-roadie-ignore>)
-        provider.should_not_receive(:find_stylesheet!)
+        expect(provider).not_to receive(:find_stylesheet!)
 
         scanner = AssetScanner.new dom, provider
 
-        scanner.find_css.should == []
+        expect(scanner.find_css).to eq([])
       end
 
       it 'ignores HTML comments and CDATA sections' do
@@ -97,9 +97,9 @@ module Roadie
         scanner = AssetScanner.new dom, provider
         stylesheet = scanner.find_css.first
 
-        stylesheet.to_s.should include("green")
-        stylesheet.to_s.should_not include("!--")
-        stylesheet.to_s.should_not include("CDATA")
+        expect(stylesheet.to_s).to include("green")
+        expect(stylesheet.to_s).not_to include("!--")
+        expect(stylesheet.to_s).not_to include("CDATA")
       end
 
       it "does not pick up scripts generating styles" do
@@ -111,7 +111,7 @@ module Roadie
         HTML
 
         scanner = AssetScanner.new dom, provider
-        scanner.find_css.should == []
+        expect(scanner.find_css).to eq([])
       end
     end
 
@@ -136,17 +136,17 @@ module Roadie
 
         stylesheets = scanner.extract_css
 
-        stylesheets.should have(2).stylesheets
-        stylesheets[0].to_s.should include("span")
-        stylesheets[1].to_s.should include("body")
+        expect(stylesheets).to have(2).stylesheets
+        expect(stylesheets[0].to_s).to include("span")
+        expect(stylesheets[1].to_s).to include("body")
 
-        dom.should have_selector("html > head > title")
-        dom.should have_selector("html > body > style[data-roadie-ignore]")
-        dom.should have_selector("link[data-roadie-ignore]")
-        dom.should have_selector("link[media=print]")
+        expect(dom).to have_selector("html > head > title")
+        expect(dom).to have_selector("html > body > style[data-roadie-ignore]")
+        expect(dom).to have_selector("link[data-roadie-ignore]")
+        expect(dom).to have_selector("link[media=print]")
 
-        dom.should_not have_selector("html > head > style")
-        dom.should_not have_selector("html > head > link[href='/some/url.css']")
+        expect(dom).not_to have_selector("html > head > style")
+        expect(dom).not_to have_selector("html > head > link[href='/some/url.css']")
       end
     end
   end

data/spec/lib/roadie/css_not_found_spec.rb

@@ -4,13 +4,14 @@ module Roadie
   describe CssNotFound do
     it "is initialized with a name" do
       error = CssNotFound.new('style.css')
-      error.css_name.should == 'style.css'
-      error.message.should == 'Could not find stylesheet "style.css"'
+      expect(error.css_name).to eq('style.css')
+      expect(error.message).to eq('Could not find stylesheet "style.css"')
     end
 
     it "can be initialized with an extra message" do
-      CssNotFound.new('file.css', "directory is missing").message.should ==
+      expect(CssNotFound.new('file.css', "directory is missing").message).to eq(
         'Could not find stylesheet "file.css": directory is missing'
+      )
     end
   end
 end

data/spec/lib/roadie/document_spec.rb

@@ -8,22 +8,22 @@ module Roadie
 
     it "is initialized with HTML" do
       doc = Document.new "<html></html>"
-      doc.html.should == "<html></html>"
+      expect(doc.html).to eq("<html></html>")
     end
 
     it "has an accessor for URL options" do
       document.url_options = {host: "foo.bar"}
-      document.url_options.should == {host: "foo.bar"}
+      expect(document.url_options).to eq({host: "foo.bar"})
     end
 
     it "has a ProviderList" do
-      document.asset_providers.should be_instance_of(ProviderList)
+      expect(document.asset_providers).to be_instance_of(ProviderList)
     end
 
     it "defaults to having just a FilesystemProvider in the provider list" do
-      document.should have(1).asset_providers
+      expect(document).to have(1).asset_providers
       provider = document.asset_providers.first
-      provider.should be_instance_of(FilesystemProvider)
+      expect(provider).to be_instance_of(FilesystemProvider)
     end
 
     it "allows changes to the asset providers" do
@@ -31,11 +31,11 @@ module Roadie
       old_list = document.asset_providers
 
       document.asset_providers = [other_provider]
-      document.asset_providers.should be_instance_of(ProviderList)
-      document.asset_providers.each.to_a.should == [other_provider]
+      expect(document.asset_providers).to be_instance_of(ProviderList)
+      expect(document.asset_providers.each.to_a).to eq([other_provider])
 
       document.asset_providers = old_list
-      document.asset_providers.should == old_list
+      expect(document.asset_providers).to eq(old_list)
     end
 
     it "can store callbacks for inlining" do
@@ -44,8 +44,8 @@ module Roadie
       document.before_transformation = callable
       document.after_transformation = callable
 
-      document.before_transformation.should == callable
-      document.after_transformation.should == callable
+      expect(document.before_transformation).to eq(callable)
+      expect(document.after_transformation).to eq(callable)
     end
 
     describe "transforming" do
@@ -56,9 +56,9 @@ module Roadie
         document.before_transformation = before
         document.after_transformation = after
 
-        before.should_receive(:call).with(instance_of(Nokogiri::HTML::Document)).ordered
-        Inliner.should_receive(:new).ordered.and_return double.as_null_object
-        after.should_receive(:call).with(instance_of(Nokogiri::HTML::Document)).ordered
+        expect(before).to receive(:call).with(instance_of(Nokogiri::HTML::Document)).ordered
+        expect(Inliner).to receive(:new).ordered.and_return double.as_null_object
+        expect(after).to receive(:call).with(instance_of(Nokogiri::HTML::Document)).ordered
 
         document.transform
       end
@@ -82,13 +82,13 @@ module Roadie
 
       result = Nokogiri::HTML.parse document.transform
 
-      result.should have_selector('html > head > title')
-      result.at_css('title').text.should == "Greetings"
+      expect(result).to have_selector('html > head > title')
+      expect(result.at_css('title').text).to eq("Greetings")
 
-      result.should have_selector('html > body > p')
+      expect(result).to have_selector('html > body > p')
       paragraph = result.at_css('p')
-      paragraph.text.should == "Hello, world!"
-      paragraph.to_xml.should == '<p style="color:green">Hello, world!</p>'
+      expect(paragraph.text).to eq("Hello, world!")
+      expect(paragraph.to_xml).to eq('<p style="color:green">Hello, world!</p>')
     end
 
     it "extracts styles from the HTML" do
@@ -112,7 +112,7 @@ module Roadie
 
       result = Nokogiri::HTML.parse document.transform
 
-      result.should have_styling([
+      expect(result).to have_styling([
         %w[color red],
         %w[text-align right],
         %w[color green],

data/spec/lib/roadie/filesystem_provider_spec.rb

@@ -11,11 +11,11 @@ module Roadie
     it_behaves_like "roadie asset provider", valid_name: "stylesheets/green.css", invalid_name: "foo"
 
     it "takes a path" do
-      FilesystemProvider.new("/tmp").path.should == "/tmp"
+      expect(FilesystemProvider.new("/tmp").path).to eq("/tmp")
     end
 
     it "defaults to the current working directory" do
-      FilesystemProvider.new.path.should == Dir.pwd
+      expect(FilesystemProvider.new.path).to eq(Dir.pwd)
     end
 
     describe "finding stylesheets" do
@@ -24,17 +24,18 @@ module Roadie
         file_contents = File.read full_path
 
         stylesheet = provider.find_stylesheet("stylesheets/green.css")
-        stylesheet.name.should == full_path
-        stylesheet.to_s.should == Stylesheet.new("", file_contents).to_s
+        expect(stylesheet).not_to be_nil
+        expect(stylesheet.name).to eq(full_path)
+        expect(stylesheet.to_s).to eq(Stylesheet.new("", file_contents).to_s)
       end
 
       it "returns nil on non-existant files" do
-        provider.find_stylesheet("non/existant.css").should be_nil
+        expect(provider.find_stylesheet("non/existant.css")).to be_nil
       end
 
       it "finds files inside the base path when using absolute paths" do
         full_path = File.join(fixtures_path, "stylesheets", "green.css")
-        provider.find_stylesheet("/stylesheets/green.css").name.should == full_path
+        expect(provider.find_stylesheet("/stylesheets/green.css").name).to eq(full_path)
       end
 
       it "does not read files above the base directory" do
@@ -43,5 +44,27 @@ module Roadie
         }.to raise_error FilesystemProvider::InsecurePathError
       end
     end
+
+    describe "finding stylesheets with query strings" do
+      it "ignores the query string" do
+        full_path = File.join(fixtures_path, "stylesheets", "green.css")
+        file_contents = File.read full_path
+
+        stylesheet = provider.find_stylesheet("/stylesheets/green.css?time=111")
+        expect(stylesheet).not_to be_nil
+        expect(stylesheet.name).to eq(full_path)
+        expect(stylesheet.to_s).to eq(Stylesheet.new("", file_contents).to_s)
+      end
+
+      it "shows that the query string is ignored inside raised errors" do
+        begin
+          provider.find_stylesheet!("/foo.css?query-string")
+          fail "No error was raised"
+        rescue CssNotFound => error
+          expect(error.css_name).to eq("foo.css")
+          expect(error.to_s).to include("/foo.css?query-string")
+        end
+      end
+    end
   end
 end

data/spec/lib/roadie/inliner_spec.rb

@@ -15,34 +15,34 @@ module Roadie
     describe "inlining styles" do
       it "inlines simple attributes" do
         use_css 'p { color: green }'
-        rendering('<p></p>').should have_styling('color' => 'green')
+        expect(rendering('<p></p>')).to have_styling('color' => 'green')
       end
 
       it "inlines browser-prefixed attributes" do
         use_css 'p { -vendor-color: green }'
-        rendering('<p></p>').should have_styling('-vendor-color' => 'green')
+        expect(rendering('<p></p>')).to have_styling('-vendor-color' => 'green')
       end
 
       it "inlines CSS3 attributes" do
         use_css 'p { border-radius: 2px; }'
-        rendering('<p></p>').should have_styling('border-radius' => '2px')
+        expect(rendering('<p></p>')).to have_styling('border-radius' => '2px')
       end
 
       it "keeps the order of the styles that are inlined" do
         use_css 'h1 { padding: 2px; margin: 5px; }'
-        rendering('<h1></h1>').should have_styling([['padding', '2px'], ['margin', '5px']])
+        expect(rendering('<h1></h1>')).to have_styling([['padding', '2px'], ['margin', '5px']])
       end
 
       it "combines multiple selectors into one" do
         use_css 'p { color: green; }
                 .tip { float: right; }'
-        rendering('<p class="tip"></p>').should have_styling([['color', 'green'], ['float', 'right']])
+        expect(rendering('<p class="tip"></p>')).to have_styling([['color', 'green'], ['float', 'right']])
       end
 
       it "uses the attributes with the highest specificity when conflicts arises" do
         use_css ".safe { color: green; }
                 p { color: red; }"
-        rendering('<p class="safe"></p>').should have_styling([['color', 'red'], ['color', 'green']])
+        expect(rendering('<p class="safe"></p>')).to have_styling([['color', 'red'], ['color', 'green']])
       end
 
       it "sorts styles by specificity order" do
@@ -50,11 +50,11 @@ module Roadie
                  #important { important: very; }
                  .important { important: yes; }'
 
-        rendering('<p class="important"></p>').should have_styling([
+        expect(rendering('<p class="important"></p>')).to have_styling([
           %w[important no], %w[important yes]
         ])
 
-        rendering('<p class="important" id="important"></p>').should have_styling([
+        expect(rendering('<p class="important" id="important"></p>')).to have_styling([
           %w[important no], %w[important yes], %w[important very]
         ])
       end
@@ -62,28 +62,28 @@ module Roadie
       it "supports multiple selectors for the same rules" do
         use_css 'p, a { color: green; }'
         rendering('<p></p><a></a>').tap do |document|
-          document.should have_styling('color' => 'green').at_selector('p')
-          document.should have_styling('color' => 'green').at_selector('a')
+          expect(document).to have_styling('color' => 'green').at_selector('p')
+          expect(document).to have_styling('color' => 'green').at_selector('a')
         end
       end
 
       it "keeps !important properties" do
         use_css "a { text-decoration: underline !important; }
                  a.hard-to-spot { text-decoration: none; }"
-        rendering('<a class="hard-to-spot"></a>').should have_styling([
+        expect(rendering('<a class="hard-to-spot"></a>')).to have_styling([
           ['text-decoration', 'none'], ['text-decoration', 'underline !important']
         ])
       end
 
       it "combines with already present inline styles" do
         use_css "p { color: green }"
-        rendering('<p style="font-size: 1.1em"></p>').should have_styling([['color', 'green'], ['font-size', '1.1em']])
+        expect(rendering('<p style="font-size: 1.1em"></p>')).to have_styling([['color', 'green'], ['font-size', '1.1em']])
       end
 
       it "does not override inline styles" do
         use_css "p { text-transform: uppercase; color: red }"
         # The two color properties are kept to make css fallbacks work correctly
-        rendering('<p style="color: green"></p>').should have_styling([
+        expect(rendering('<p style="color: green"></p>')).to have_styling([
           ['text-transform', 'uppercase'],
           ['color', 'red'],
           ['color', 'green'],
@@ -101,7 +101,7 @@ module Roadie
 
           p.active { width: 100%; }
         "
-        rendering('<p class="active"></p>').should have_styling('width' => '100%')
+        expect(rendering('<p class="active"></p>')).to have_styling('width' => '100%')
       end
 
       it "does not crash on any pseudo element selectors" do
@@ -109,7 +109,7 @@ module Roadie
           p.some-element { width: 100%; }
           p::some-element { color: red; }
         "
-        rendering('<p class="some-element"></p>').should have_styling('width' => '100%')
+        expect(rendering('<p class="some-element"></p>')).to have_styling('width' => '100%')
       end
 
       it "warns on selectors that crash Nokogiri" do
@@ -117,7 +117,7 @@ module Roadie
 
         stylesheet = Stylesheet.new "foo.css", "p[%^=foo] { color: red; }"
         inliner = Inliner.new([stylesheet])
-        inliner.should_receive(:warn).with(
+        expect(inliner).to receive(:warn).with(
           %{Roadie cannot use "p[%^=foo]" (from "foo.css" stylesheet) when inlining stylesheets}
         )
         inliner.inline(dom)
@@ -130,8 +130,8 @@ module Roadie
         "
         result = rendering("<p></p> <p></p>")
 
-        result.should have_styling([['color', 'red']]).at_selector('p:first')
-        result.should have_styling([['color', 'red'], ['color', 'green']]).at_selector('p:last')
+        expect(result).to have_styling([['color', 'red']]).at_selector('p:first')
+        expect(result).to have_styling([['color', 'red'], ['color', 'green']]).at_selector('p:last')
       end
 
       it "ignores selectors with @" do

data/spec/lib/roadie/markup_improver_spec.rb

@@ -13,44 +13,44 @@ module Roadie
     # See https://github.com/sparklemotion/nokogiri/issues/984
     def pending_for_buggy_jruby
       # No reason to check for version yet since no existing version has a fix.
-      pending "Pending until Nokogiri issue #984 is fixed and released" if defined?(JRuby)
+      skip "Pending until Nokogiri issue #984 is fixed and released" if defined?(JRuby)
     end
 
     describe "automatic doctype" do
       it "inserts a HTML5 doctype if no doctype is present" do
         pending_for_buggy_jruby
-        improve("<html></html>").internal_subset.to_xml.should == "<!DOCTYPE html>"
+        expect(improve("<html></html>").internal_subset.to_xml).to eq("<!DOCTYPE html>")
       end
 
       it "does not insert duplicate doctypes" do
         html = improve('<!DOCTYPE html><html><body></body></html>').to_html
-        html.scan('DOCTYPE').size.should == 1
+        expect(html.scan('DOCTYPE').size).to eq(1)
       end
 
       it "leaves other doctypes alone" do
         dtd = "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.0 Transitional//EN\" \"http://www.w3.org/TR/REC-html40/loose.dtd\">"
         html = "#{dtd}<html></html>"
-        improve(html).internal_subset.to_xml.strip.should == dtd
+        expect(improve(html).internal_subset.to_xml.strip).to eq(dtd)
       end
     end
 
     describe "basic HTML structure" do
       it "inserts a <html> element as the root" do
-        improve("<h1>Hey!</h1>").should have_selector("html h1")
-        improve("<html></html>").css('html').size.should == 1
+        expect(improve("<h1>Hey!</h1>")).to have_selector("html h1")
+        expect(improve("<html></html>").css('html').size).to eq(1)
       end
 
       it "inserts <head> if not present" do
-        improve('<html><body></body></html>').should have_selector('html > head + body')
-        improve('<html></html>').should have_selector('html > head')
-        improve('Foo').should have_selector('html > head')
-        improve('<html><head></head></html>').css('head').size.should == 1
+        expect(improve('<html><body></body></html>')).to have_selector('html > head + body')
+        expect(improve('<html></html>')).to have_selector('html > head')
+        expect(improve('Foo')).to have_selector('html > head')
+        expect(improve('<html><head></head></html>').css('head').size).to eq(1)
       end
 
       it "inserts <body> if not present" do
-        improve('<h1>Hey!</h1>').should have_selector('html > body > h1')
-        improve('<html><h1>Hey!</h1></html>').should have_selector('html > body > h1')
-        improve('<html><body><h1>Hey!</h1></body></html>').css('body').size.should == 1
+        expect(improve('<h1>Hey!</h1>')).to have_selector('html > body > h1')
+        expect(improve('<html><h1>Hey!</h1></html>')).to have_selector('html > body > h1')
+        expect(improve('<html><body><h1>Hey!</h1></body></html>').css('body').size).to eq(1)
       end
     end
 
@@ -58,14 +58,14 @@ module Roadie
       it "is inserted if missing" do
         dom = improve('<html><head></head><body></body></html>')
 
-        dom.should have_selector('head meta')
+        expect(dom).to have_selector('head meta')
         meta = dom.at_css('head meta')
-        meta['http-equiv'].should == 'Content-Type'
-        meta['content'].should == 'text/html; charset=UTF-8'
+        expect(meta['http-equiv']).to eq('Content-Type')
+        expect(meta['content']).to eq('text/html; charset=UTF-8')
       end
 
       it "is left alone when predefined" do
-        improve(<<-HTML).xpath('//meta').should have(1).item
+        expect(improve(<<-HTML).xpath('//meta')).to have(1).item
         <html>
           <head>
             <meta http-equiv="content-type" content="text/html; charset=iso-8859-1" />