inliner_spec.rb in roadie-5.0.0

- old
+ new

@@ -1,72 +1,74 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 module Roadie
   describe Inliner do
-    before { @stylesheet = "".freeze }
-    def use_css(css) @stylesheet = Stylesheet.new("example", css) end
+    before { @stylesheet = "" }
+    def use_css(css)
+      @stylesheet = Stylesheet.new("example", css)
+    end
 
     def rendering(html, stylesheet = @stylesheet)
       dom = Nokogiri::HTML.parse html
       Inliner.new([stylesheet], dom).inline
       dom
     end
 
     describe "inlining styles" do
       it "inlines simple attributes" do
-        use_css 'p { color: green }'
-        expect(rendering('<p></p>')).to have_styling('color' => 'green')
+        use_css "p { color: green }"
+        expect(rendering("<p></p>")).to have_styling("color" => "green")
       end
 
       it "keeps multiple versions of the same property to support progressive enhancement" do
         # https://github.com/premailer/css_parser/issues/44
         pending "css_parser issue #44"
 
-        use_css 'p { color: #eee; color: rgba(255, 255, 255, 0.9); }'
-        expect(rendering('<p></p>')).to have_styling(
-          [['color', 'green'], ['color', 'rgba(255, 255, 255, 0.9)']]
+        use_css "p { color: #eee; color: rgba(255, 255, 255, 0.9); }"
+        expect(rendering("<p></p>")).to have_styling(
+          [["color", "green"], ["color", "rgba(255, 255, 255, 0.9)"]]
         )
       end
 
       it "de-duplicates identical styles" do
         use_css '
           p { color: green; }
           .message { color: blue; }
           .positive { color: green; }
         '
         expect(rendering('<p class="message positive"></p>')).to have_styling(
-          [['color', 'blue'], ['color', 'green']]
+          [["color", "blue"], ["color", "green"]]
         )
       end
 
       it "inlines browser-prefixed attributes" do
-        use_css 'p { -vendor-color: green }'
-        expect(rendering('<p></p>')).to have_styling('-vendor-color' => 'green')
+        use_css "p { -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; }'
-        expect(rendering('<p></p>')).to have_styling('border-radius' => '2px')
+        use_css "p { 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; }'
-        expect(rendering('<h1></h1>')).to have_styling([['padding', '2px'], ['margin', '5px']])
+        use_css "h1 { 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; }'
-        expect(rendering('<p class="tip"></p>')).to 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; }"
-        expect(rendering('<p class="safe"></p>')).to 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
         use_css 'p          { important: no; }
                  #important { important: very; }
@@ -80,37 +82,37 @@
           %w[important no], %w[important yes], %w[important very]
         ])
       end
 
       it "supports multiple selectors for the same rules" do
-        use_css 'p, a { color: green; }'
-        rendering('<p></p><a></a>').tap do |document|
-          expect(document).to have_styling('color' => 'green').at_selector('p')
-          expect(document).to have_styling('color' => 'green').at_selector('a')
+        use_css "p, a { color: green; }"
+        rendering("<p></p><a></a>").tap do |document|
+          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; }"
         expect(rendering('<a class="hard-to-spot"></a>')).to have_styling([
-          ['text-decoration', 'none'], ['text-decoration', 'underline !important']
+          ["text-decoration", "none"], ["text-decoration", "underline !important"]
         ])
       end
 
       it "combines with already present inline styles" do
         use_css "p { color: green }"
-        expect(rendering('<p style="font-size: 1.1em"></p>')).to 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
         expect(rendering('<p style="color: green"></p>')).to have_styling([
-          ['text-transform', 'uppercase'],
-          ['color', 'red'],
-          ['color', 'green'],
+          ["text-transform", "uppercase"],
+          ["color", "red"],
+          ["color", "green"]
         ])
       end
 
       it "does not apply link and dynamic pseudo selectors" do
         use_css "
@@ -121,28 +123,28 @@
           p:target { color: red }
           p:visited { color: red }
 
           p.active { width: 100%; }
         "
-        expect(rendering('<p class="active"></p>')).to 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
         use_css "
           p.some-element { width: 100%; }
           p::some-element { color: red; }
         "
-        expect(rendering('<p class="some-element"></p>')).to 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
         dom = Nokogiri::HTML.parse "<p></p>"
 
         stylesheet = Stylesheet.new "foo.css", "p[%^=foo] { color: red; }"
         inliner = Inliner.new([stylesheet], dom)
         expect(Utils).to receive(:warn).with(
-          %{Cannot inline "p[%^=foo]" from "foo.css" stylesheet. If this is valid CSS, please report a bug.}
+          %(Cannot inline "p[%^=foo]" from "foo.css" stylesheet. If this is valid CSS, please report a bug.)
         )
         inliner.inline
       end
 
       it "works with nth-child" do
@@ -150,21 +152,21 @@
           p { color: red; }
           p:nth-child(2n) { color: green; }
         "
         result = rendering("<p></p> <p></p>")
 
-        expect(result).to have_styling([['color', 'red']]).at_selector('p:first')
-        expect(result).to 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
 
       context "with uninlinable selectors" do
         before do
           allow(Roadie::Utils).to receive(:warn)
         end
 
         it "puts them in a new <style> element in the <head>" do
-          use_css 'a:hover { color: red; }'
+          use_css "a:hover { color: red; }"
           result = rendering("
             <html>
               <head></head>
               <body><a></a></body>
             </html>
@@ -172,11 +174,11 @@
           expect(result).to have_selector("head > style")
           expect(result.at_css("head > style").text).to eq "a:hover{color:red}"
         end
 
         it "puts them in <head> on unexpected inlining problems" do
-          use_css 'p:some-future-thing { color: red; }'
+          use_css "p:some-future-thing { color: red; }"
           result = rendering("
             <html>
               <head></head>
               <body><p></p></body>
             </html>
@@ -196,19 +198,13 @@
               background-position: 0 0;
             }
           }'
 
           use_css css
-          result = rendering('<p></p>')
+          result = rendering("<p></p>")
 
           expect(result).to have_styling([]).at_selector("p")
-
-          # css_parser actually sees an empty @keyframes on JRuby, and nothing
-          # on the others
-          if (style_element = result.at_css("head > style"))
-            expect(style_element.text).to_not include "background-position"
-          end
         end
 
         it "ignores them if told not to keep them" do
           stylesheet = use_css "
             p:hover { color: red; }
@@ -223,34 +219,34 @@
           Inliner.new([stylesheet], dom).inline(keep_uninlinable_css: false)
           expect(dom).to_not have_selector("head > style")
         end
 
         it "puts the <style> element at the root when told so" do
-          stylesheet = use_css 'a:hover { color: red; }'
+          stylesheet = use_css "a:hover { color: red; }"
           dom = Nokogiri::HTML.fragment("
             <a></a>
           ")
 
           Inliner.new([stylesheet], dom).inline(
             keep_uninlinable_css: true,
-            keep_uninlinable_in: :root,
+            keep_uninlinable_in: :root
           )
 
           expect(dom).to have_xpath("./a")
           expect(dom).to have_xpath("./style")
         end
 
         it "raises error when told to save styles in an unknown place" do
-          stylesheet = use_css 'a:hover { color: red; }'
+          stylesheet = use_css "a:hover { color: red; }"
           dom = Nokogiri::HTML.fragment("
             <a></a>
           ")
 
           inliner = Inliner.new([stylesheet], dom)
           expect {
             inliner.inline(
               keep_uninlinable_css: true,
-              keep_uninlinable_in: :unknown_place,
+              keep_uninlinable_in: :unknown_place
             )
           }.to raise_error(ArgumentError, /:unknown_place/)
         end
       end
     end