RubyGems - roadie - Versions diffs - 2.4.3 → 3.0.0 - Mend

roadie 2.4.3 → 3.0.0

Files changed (89) hide show

checksums.yaml +7 -0
data/.gitignore +3 -0
data/.travis.yml +10 -14
data/.yardopts +1 -1
data/Changelog.md +38 -5
data/Gemfile +3 -4
data/Guardfile +12 -1
data/README.md +168 -164
data/Rakefile +2 -19
data/lib/roadie.rb +15 -68
data/lib/roadie/asset_provider.rb +7 -58
data/lib/roadie/asset_scanner.rb +92 -0
data/lib/roadie/document.rb +103 -0
data/lib/roadie/errors.rb +57 -0
data/lib/roadie/filesystem_provider.rb +30 -60
data/lib/roadie/inliner.rb +72 -217
data/lib/roadie/markup_improver.rb +88 -0
data/lib/roadie/null_provider.rb +13 -0
data/lib/roadie/null_url_rewriter.rb +12 -0
data/lib/roadie/provider_list.rb +71 -0
data/lib/roadie/rspec.rb +1 -0
data/lib/roadie/rspec/asset_provider.rb +49 -0
data/lib/roadie/selector.rb +43 -18
data/lib/roadie/style_attribute_builder.rb +25 -0
data/lib/roadie/style_block.rb +32 -0
data/lib/roadie/style_property.rb +93 -0
data/lib/roadie/stylesheet.rb +65 -0
data/lib/roadie/upgrade_guide.rb +36 -0
data/lib/roadie/url_generator.rb +126 -0
data/lib/roadie/url_rewriter.rb +84 -0
data/lib/roadie/version.rb +1 -1
data/roadie.gemspec +8 -11
data/spec/fixtures/big_em.css +1 -0
data/spec/fixtures/stylesheets/green.css +1 -0
data/spec/integration_spec.rb +125 -95
data/spec/lib/roadie/asset_scanner_spec.rb +153 -0
data/spec/lib/roadie/css_not_found_spec.rb +17 -0
data/spec/lib/roadie/document_spec.rb +123 -0
data/spec/lib/roadie/filesystem_provider_spec.rb +44 -68
data/spec/lib/roadie/inliner_spec.rb +105 -537
data/spec/lib/roadie/markup_improver_spec.rb +78 -0
data/spec/lib/roadie/null_provider_spec.rb +21 -0
data/spec/lib/roadie/null_url_rewriter_spec.rb +19 -0
data/spec/lib/roadie/provider_list_spec.rb +89 -0
data/spec/lib/roadie/selector_spec.rb +15 -10
data/spec/lib/roadie/style_attribute_builder_spec.rb +29 -0
data/spec/lib/roadie/style_block_spec.rb +35 -0
data/spec/lib/roadie/style_property_spec.rb +82 -0
data/spec/lib/roadie/stylesheet_spec.rb +41 -0
data/spec/lib/roadie/test_provider_spec.rb +29 -0
data/spec/lib/roadie/url_generator_spec.rb +121 -0
data/spec/lib/roadie/url_rewriter_spec.rb +79 -0
data/spec/shared_examples/asset_provider.rb +11 -0
data/spec/shared_examples/url_rewriter.rb +23 -0
data/spec/spec_helper.rb +6 -60
data/spec/support/have_attribute_matcher.rb +2 -2
data/spec/support/have_node_matcher.rb +4 -4
data/spec/support/have_selector_matcher.rb +3 -3
data/spec/support/have_styling_matcher.rb +51 -15
data/spec/support/test_provider.rb +13 -0
metadata +86 -175
data/Appraisals +0 -15
data/gemfiles/rails_3.0.gemfile +0 -7
data/gemfiles/rails_3.0.gemfile.lock +0 -123
data/gemfiles/rails_3.1.gemfile +0 -7
data/gemfiles/rails_3.1.gemfile.lock +0 -126
data/gemfiles/rails_3.2.gemfile +0 -7
data/gemfiles/rails_3.2.gemfile.lock +0 -124
data/gemfiles/rails_4.0.gemfile +0 -7
data/gemfiles/rails_4.0.gemfile.lock +0 -119
data/lib/roadie/action_mailer_extensions.rb +0 -95
data/lib/roadie/asset_pipeline_provider.rb +0 -28
data/lib/roadie/css_file_not_found.rb +0 -22
data/lib/roadie/railtie.rb +0 -39
data/lib/roadie/style_declaration.rb +0 -42
data/spec/fixtures/app/assets/stylesheets/integration.css +0 -10
data/spec/fixtures/public/stylesheets/integration.css +0 -10
data/spec/fixtures/views/integration_mailer/marketing.html.erb +0 -2
data/spec/fixtures/views/integration_mailer/notification.html.erb +0 -8
data/spec/fixtures/views/integration_mailer/notification.text.erb +0 -6
data/spec/lib/roadie/action_mailer_extensions_spec.rb +0 -227
data/spec/lib/roadie/asset_pipeline_provider_spec.rb +0 -65
data/spec/lib/roadie/css_file_not_found_spec.rb +0 -29
data/spec/lib/roadie/style_declaration_spec.rb +0 -49
data/spec/lib/roadie_spec.rb +0 -101
data/spec/shared_examples/asset_provider_examples.rb +0 -11
data/spec/support/anonymous_mailer.rb +0 -21
data/spec/support/change_url_options.rb +0 -5
data/spec/support/parse_styling.rb +0 -25

data/spec/lib/roadie/asset_scanner_spec.rb ADDED Viewed

@@ -0,0 +1,153 @@
+# encoding: UTF-8
+require 'spec_helper'
+module Roadie
+  describe AssetScanner do
+    let(:provider) { TestProvider.new }
+    let(:dom) { dom_document "<html></html>" }
+    def dom_fragment(html); Nokogiri::HTML.fragment html; end
+    def dom_document(html); Nokogiri::HTML.parse html; end
+    it "is initialized with a DOM tree and a asset provider set" do
+      scanner = AssetScanner.new dom, 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
+        expect(scanner.find_css).to eq([])
+      end
+      it "finds all embedded stylesheets" do
+        dom = dom_document <<-HTML
+          <html>
+            <head>
+              <style>a { color: green; }</style>
+            </head>
+            <body>
+              <style>
+                body { color: red; }
+              </style>
+            </body>
+          </html>
+        HTML
+        scanner = AssetScanner.new dom, provider
+        stylesheets = scanner.find_css
+        expect(stylesheets).to have(2).stylesheets
+        expect(stylesheets[0].to_s).to include("green")
+        expect(stylesheets[1].to_s).to include("red")
+        expect(stylesheets.first.name).to eq("(inline)")
+      end
+      it "does not find any embedded stylesheets marked for ignoring" do
+        dom = dom_document <<-HTML
+          <html>
+            <head>
+              <style>a { color: green; }</style>
+              <style data-roadie-ignore>a { color: red; }</style>
+            </head>
+          </html>
+        HTML
+        scanner = AssetScanner.new dom, provider
+        expect(scanner.find_css).to have(1).stylesheet
+      end
+      it "finds referenced stylesheets through the provider" do
+        stylesheet = double "A 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
+        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">)
+        expect(provider).not_to receive(:find_stylesheet!)
+        scanner = AssetScanner.new dom, provider
+        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>)
+        expect(provider).not_to receive(:find_stylesheet!)
+        scanner = AssetScanner.new dom, provider
+        expect(scanner.find_css).to eq([])
+      end
+      it 'ignores HTML comments and CDATA sections' do
+        # TinyMCE posts invalid CSS. We support that just to be pragmatic.
+        dom = dom_fragment %(<style><![CDATA[
+          <!--
+          p { color: green }
+          -->
+        ]]></style>)
+        scanner = AssetScanner.new dom, provider
+        stylesheet = scanner.find_css.first
+        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
+        dom = dom_fragment <<-HTML
+          <script>
+            var color = "red";
+            document.write("<style type='text/css'>p { color: " + color + "; }</style>");
+          </script>
+        HTML
+        scanner = AssetScanner.new dom, provider
+        expect(scanner.find_css).to eq([])
+      end
+    end
+    describe "extracting" do
+      it "returns the stylesheets found, and removes them from the DOM" do
+        dom = dom_document <<-HTML
+          <html>
+            <head>
+              <title>Hello world!</title>
+              <style>span { color: green; }</style>
+              <link rel="stylesheet" href="/some/url.css">
+              <link rel="stylesheet" href="/error.css" media="print">
+              <link rel="stylesheet" href="/cool.css" data-roadie-ignore>
+            </head>
+            <body>
+              <style data-roadie-ignore>a { color: red; }</style>
+            </body>
+          </html>
+        HTML
+        provider = TestProvider.new "/some/url.css" => "body { color: green; }"
+        scanner = AssetScanner.new dom, provider
+        stylesheets = scanner.extract_css
+        expect(stylesheets).to have(2).stylesheets
+        expect(stylesheets[0].to_s).to include("span")
+        expect(stylesheets[1].to_s).to include("body")
+        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]")
+        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
+end

data/spec/lib/roadie/css_not_found_spec.rb ADDED Viewed

@@ -0,0 +1,17 @@
+require 'spec_helper'
+module Roadie
+  describe CssNotFound do
+    it "is initialized with a name" do
+      error = CssNotFound.new('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
+      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 ADDED Viewed

@@ -0,0 +1,123 @@
+# encoding: UTF-8
+require 'spec_helper'
+module Roadie
+  describe Document do
+    sample_html = "<html><body><p>Hello world!</p></body></html>"
+    subject(:document) { described_class.new sample_html }
+    it "is initialized with HTML" do
+      doc = Document.new "<html></html>"
+      expect(doc.html).to eq("<html></html>")
+    end
+    it "has an accessor for URL options" do
+      document.url_options = {host: "foo.bar"}
+      expect(document.url_options).to eq({host: "foo.bar"})
+    end
+    it "has a ProviderList" do
+      expect(document.asset_providers).to be_instance_of(ProviderList)
+    end
+    it "defaults to having just a FilesystemProvider in the provider list" do
+      expect(document).to have(1).asset_providers
+      provider = document.asset_providers.first
+      expect(provider).to be_instance_of(FilesystemProvider)
+    end
+    it "allows changes to the asset providers" do
+      other_provider = double "Other proider"
+      old_list = document.asset_providers
+      document.asset_providers = [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
+      expect(document.asset_providers).to eq(old_list)
+    end
+    it "can store callbacks for inlining" do
+      callable = double "Callable"
+      document.before_transformation = callable
+      document.after_transformation = callable
+      expect(document.before_transformation).to eq(callable)
+      expect(document.after_transformation).to eq(callable)
+    end
+    describe "transforming" do
+      it "runs the before and after callbacks" do
+        document = Document.new "<body></body>"
+        before = double call: nil
+        after = double call: nil
+        document.before_transformation = before
+        document.after_transformation = after
+        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
+    end
+  end
+  describe Document, "(integration)" do
+    it "can transform the document" do
+      document = Document.new <<-HTML
+        <html>
+          <head>
+            <title>Greetings</title>
+          </head>
+          <body>
+            <p>Hello, world!</p>
+          </body>
+        </html>
+      HTML
+      document.add_css "p { color: green; }"
+      result = Nokogiri::HTML.parse document.transform
+      expect(result).to have_selector('html > head > title')
+      expect(result.at_css('title').text).to eq("Greetings")
+      expect(result).to have_selector('html > body > p')
+      paragraph = result.at_css('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
+      document = Document.new <<-HTML
+        <html>
+          <head>
+            <title>Greetings</title>
+            <link rel="stylesheet" href="/sample.css" type="text/css">
+          </head>
+          <body>
+            <p>Hello, world!</p>
+          </body>
+        </html>
+      HTML
+      document.asset_providers = TestProvider.new({
+        "/sample.css" => "p { color: red; text-align: right; }",
+      })
+      document.add_css "p { color: green; text-size: 2em; }"
+      result = Nokogiri::HTML.parse document.transform
+      expect(result).to have_styling([
+        %w[color red],
+        %w[text-align right],
+        %w[color green],
+        %w[text-size 2em]
+      ]).at_selector("p")
+    end
+  end
+end

data/spec/lib/roadie/filesystem_provider_spec.rb CHANGED Viewed

@@ -1,93 +1,69 @@
+# encoding: UTF-8
 require 'spec_helper'
-require 'shared_examples/asset_provider_examples'
-require 'tmpdir'
+require 'roadie/rspec'
+require 'shared_examples/asset_provider'
 module Roadie
   describe FilesystemProvider do
-    let(:provider) { FilesystemProvider.new }
+    let(:fixtures_path) { File.expand_path "../../../fixtures", __FILE__ }
+    subject(:provider) { FilesystemProvider.new(fixtures_path) }
-    it_behaves_like AssetProvider
+    it_behaves_like "roadie asset provider", valid_name: "stylesheets/green.css", invalid_name: "foo"
-    it "has a configurable prefix" do
-      FilesystemProvider.new("/prefix").prefix.should == "/prefix"
+    it "takes a path" do
+      expect(FilesystemProvider.new("/tmp").path).to eq("/tmp")
     end
-    it "has a configurable path" do
-      path = Pathname.new("/path")
-      FilesystemProvider.new('', path).path.should == path
+    it "defaults to the current working directory" do
+      expect(FilesystemProvider.new.path).to eq(Dir.pwd)
     end
-    it "bases the path on the project root if passed a string with a relative path" do
-      FilesystemProvider.new('', "foo/bar").path.should == Roadie.app.root.join("foo", "bar")
-      FilesystemProvider.new('', "/foo/bar").path.should == Pathname.new("/foo/bar")
-    end
-    it 'has a path of "<root>/public/stylesheets" by default' do
-      FilesystemProvider.new.path.should == Roadie.app.root.join('public', 'stylesheets')
-    end
-    it 'has a prefix of "/stylesheets" by default' do
-      FilesystemProvider.new.prefix.should == "/stylesheets"
-    end
+    describe "finding stylesheets" do
+      it "finds files in the path" do
+        full_path = File.join(fixtures_path, "stylesheets", "green.css")
+        file_contents = File.read full_path
-    describe "#find(file)" do
-      around(:each) do |example|
-        Dir.mktmpdir do |path|
-          Dir.chdir(path) { example.run }
-        end
-      end
-      let(:provider) { FilesystemProvider.new('/prefix', Pathname.new('.')) }
-      def create_file(name, contents = '')
-        Pathname.new(name).tap do |path|
-          path.dirname.mkpath unless path.dirname.directory?
-          path.open('w') { |file| file << contents }
-        end
+        stylesheet = provider.find_stylesheet("stylesheets/green.css")
+        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 "loads files from the filesystem" do
-        create_file('foo.css', 'contents of foo.css')
-        provider.find('foo.css').should == 'contents of foo.css'
+      it "returns nil on non-existant files" do
+        expect(provider.find_stylesheet("non/existant.css")).to be_nil
       end
-      it "removes the prefix" do
-        create_file('foo.css', 'contents of foo.css')
-        provider.find('/prefix/foo.css').should == 'contents of foo.css'
-        provider.find('prefix/foo.css').should == 'contents of foo.css'
+      it "finds files inside the base path when using absolute paths" do
+        full_path = File.join(fixtures_path, "stylesheets", "green.css")
+        expect(provider.find_stylesheet("/stylesheets/green.css").name).to eq(full_path)
       end
-      it 'tries the filename with a ".css" extension if it does not exist' do
-        create_file('bar',     'in bare bar')
-        create_file('bar.css', 'in bar.css')
-        create_file('foo.css', 'in foo.css')
-        provider.find('bar').should == 'in bare bar'
-        provider.find('foo').should == 'in foo.css'
-      end
-      it "strips the contents" do
-        create_file('foo.css', "   contents  \n ")
-        provider.find('foo.css').should == "contents"
+      it "does not read files above the base directory" do
+        expect {
+          provider.find_stylesheet("../#{File.basename(__FILE__)}")
+        }.to raise_error FilesystemProvider::InsecurePathError
       end
+    end
-      it "supports nested directories" do
-        create_file('path/to/foo.css')
-        create_file('path/from/bar.css')
-        provider.find('path/to/foo.css')
-        provider.find('path/from/bar.css')
-      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
-      it "works with double slashes in the path" do
-        create_file('path/to/foo.css')
-        provider.find('path/to//foo.css')
+        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 "raises a Roadie::CSSFileNotFound error when the file could not be found" do
-        expect {
-          provider.find('not_here.css')
-        }.to raise_error(Roadie::CSSFileNotFound, /not_here/)
+      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

data/spec/lib/roadie/inliner_spec.rb CHANGED Viewed

@@ -1,581 +1,149 @@
 # encoding: UTF-8
 require 'spec_helper'
-describe Roadie::Inliner do
-  let(:provider) { double("asset provider", :all => '') }
+module Roadie
+  describe Inliner do
+    before { @stylesheet = "" }
+    def use_css(css) @stylesheet = Stylesheet.new("example", css) end
-  def use_css(css)
-    provider.stub(:all).with(['global.css']).and_return(css)
-  end
-  def rendering(html, options = {})
-    url_options = options.fetch(:url_options, {:host => 'example.com'})
-    after_inlining_handler = options[:after_inlining_handler]
-    Nokogiri::HTML.parse Roadie::Inliner.new(provider, ['global.css'], html, url_options, after_inlining_handler).execute
-  end
-  describe "initialization" do
-    it "warns about asset_path_prefix being non-functional" do
-      expect {
-        Roadie::Inliner.new(provider, [], '', :asset_path_prefix => 'foo')
-      }.to raise_error(ArgumentError, /asset_path_prefix/)
-    end
-  end
-  describe "inlining styles" do
-    before(:each) do
-      # Make sure to have some css even when we don't specify any
-      # We have specific tests for when this is nil
-      use_css ''
-    end
-    it "inlines simple attributes" do
-      use_css 'p { color: green }'
-      rendering('<p></p>').should 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')
-    end
-    it "inlines CSS3 attributes" do
-      use_css 'p { border-radius: 2px; }'
-      rendering('<p></p>').should 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']])
-    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']])
-    end
-    it "uses the attributes with the highest specificity when conflicts arises" do
-      use_css "p { color: red; }
-              .safe { color: green; }"
-      rendering('<p class="safe"></p>').should have_styling('color' => 'green')
-    end
-    it "sorts styles by specificity order" do
-      use_css 'p      { margin: 2px; }
-               #big   { margin: 10px; }
-               .down  { margin-bottom: 5px; }'
-      rendering('<p class="down"></p>').should have_styling([
-        ['margin', '2px'], ['margin-bottom', '5px']
-      ])
-      rendering('<p class="down" id="big"></p>').should have_styling([
-        ['margin-bottom', '5px'], ['margin', '10px']
-      ])
-    end
-    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')
-      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('text-decoration' => 'underline !important')
+    def rendering(html, stylesheet = @stylesheet)
+      dom = Nokogiri::HTML.parse html
+      Inliner.new([stylesheet]).inline(dom)
+      dom
     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']])
-    end
-    it "does not touch already present inline styles" do
-      use_css "p { color: red }"
-      rendering('<p style="color: green"></p>').should have_styling([['color', 'red'], ['color', 'green']])
-    end
-    it "does not apply link and dynamic pseudo selectors" do
-      use_css "
-        p:active { color: red }
-        p:focus { color: red }
-        p:hover { color: red }
-        p:link { color: red }
-        p:target { color: red }
-        p:visited { color: red }
-        p.active { width: 100%; }
-      "
-      rendering('<p class="active"></p>').should 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; }
-      "
-      rendering('<p class="some-element"></p>').should have_styling('width' => '100%')
-    end
-    it "works with nth-child" do
-      use_css "
-        p { color: red; }
-        p:nth-child(2n) { color: green; }
-      "
-      rendering("
-        <p class='one'></p>
-        <p class='two'></p>
-      ").should have_styling('color' => 'green').at_selector('.two')
-    end
-    it "ignores selectors with @" do
-      use_css '@keyframes progress-bar-stripes {
-        from {
-          background-position: 40px 0;
-        }
-        to {
-          background-position: 0 0;
-        }
-      }'
-      expect { rendering('<p></p>') }.not_to raise_error
-    end
-    it 'ignores HTML comments and CDATA sections' do
-      # TinyMCE posts invalid CSS. We support that just to be pragmatic.
-      use_css %(<![CDATA[
-        <!--
-        p { color: green }
-        -->
-      ]]>)
-      expect { rendering '<p></p>' }.not_to raise_error
-      use_css %(
-        <!--
-        <![CDATA[
-            <![CDATA[
-        span { color: red }
-        ]]>
-        -->
-      )
-      expect { rendering '<p></p>' }.not_to raise_error
-    end
-    it "does not pick up scripts generating styles" do
-      expect {
-        rendering <<-HTML
-          <script>
-            var color = "red";
-            document.write("<style type='text/css'>p { color: " + color + "; }</style>");
-          </script>
-        HTML
-      }.not_to raise_error
-    end
-    describe "inline <style> element" do
-      it "is used for inlined styles" do
-        rendering(<<-HTML).should have_styling([['color', 'green'], ['font-size', '1.1em']])
-          <html>
-            <head>
-              <style type="text/css">p { color: green; }</style>
-            </head>
-            <body>
-              <p>Hello World</p>
-              <style type="text/css">p { font-size: 1.1em; }</style>
-            </body>
-          </html>
-        HTML
+    describe "inlining styles" do
+      it "inlines simple attributes" do
+        use_css 'p { color: green }'
+        expect(rendering('<p></p>')).to have_styling('color' => 'green')
       end
-      it "is removed" do
-        rendering(<<-HTML).should_not have_selector('style')
-          <html>
-            <head>
-              <style type="text/css">p { color: green; }</style>
-            </head>
-            <body>
-              <style type="text/css">p { font-size: 1.1em; }</style>
-            </body>
-          </html>
-        HTML
+      it "inlines browser-prefixed attributes" do
+        use_css 'p { -vendor-color: green }'
+        expect(rendering('<p></p>')).to have_styling('-vendor-color' => 'green')
       end
-      it "is not touched when data-immutable is set" do
-        document = rendering <<-HTML
-          <style type="text/css" data-immutable>p { color: red; }</style>
-          <p></p>
-        HTML
-        document.should have_selector('style[data-immutable]')
-        document.should_not have_styling('color' => 'red')
+      it "inlines CSS3 attributes" do
+        use_css 'p { border-radius: 2px; }'
+        expect(rendering('<p></p>')).to have_styling('border-radius' => '2px')
       end
-      it "is not touched when for print media" do
-        document = rendering <<-HTML
-          <style type="text/css" media="print">p { color: red; }</style>
-          <p></p>
-        HTML
-        document.should have_selector('style[media=print]')
-        document.should_not have_styling('color' => 'red').at_selector('p')
+      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']])
       end
-      it "is still inlined when no external css rules are defined" do
-        # This is just testing that the main code paths are still active even
-        # when css is set to nil
-        use_css nil
-        rendering(<<-HTML).should have_styling('color' => 'green').at_selector('p')
-          <style type="text/css">p { color: green; }</style>
-          <p>Hello World</p>
-        HTML
+      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']])
       end
-      it "is not touched when inside a SVG element" do
-        expect {
-          rendering <<-HTML
-            <p>Hello World</p>
-            <svg>
-              <style>This is not parseable by the CSS parser!</style>
-            </svg>
-          HTML
-        }.to_not raise_error
+      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']])
       end
-    end
-  end
-  describe "linked stylesheets" do
-    def fake_file(name, contents)
-      provider.should_receive(:find).with(name).and_return(contents)
-    end
-    it "inlines styles from the linked stylesheet" do
-      fake_file('/assets/green_paragraphs.css', 'p { color: green; }')
-      rendering(<<-HTML).should have_styling('color' => 'green').at_selector('p')
-        <html>
-          <head>
-            <link rel="stylesheet" href="/assets/green_paragraphs.css">
-          </head>
-          <body>
-            <p></p>
-          </body>
-        </html>
-      HTML
-    end
-    it "inlines styles from the linked stylesheet in subdirectory" do
-      fake_file('/assets/subdirectory/red_paragraphs.css', 'p { color: red; }')
-      rendering(<<-HTML).should have_styling('color' => 'red').at_selector('p')
-        <html>
-          <head>
-            <link rel="stylesheet" href="/assets/subdirectory/red_paragraphs.css">
-          </head>
-          <body>
-            <p></p>
-          </body>
-        </html>
-      HTML
-    end
-    it "inlines styles from more than one linked stylesheet" do
-      fake_file('/assets/large_purple_paragraphs.css', 'p { font-size: 18px; color: purple; }')
-      fake_file('/assets/green_paragraphs.css', 'p { color: green; }')
+      it "sorts styles by specificity order" do
+        use_css 'p          { important: no; }
+                 #important { important: very; }
+                 .important { important: yes; }'
-      html = <<-HTML
-        <html>
-          <head>
-            <link rel="stylesheet" href="/assets/large_purple_paragraphs.css">
-            <link rel="stylesheet" href="/assets/green_paragraphs.css">
-          </head>
-          <body>
-            <p></p>
-          </body>
-        </html>
-      HTML
+        expect(rendering('<p class="important"></p>')).to have_styling([
+          %w[important no], %w[important yes]
+        ])
-      rendering(html).should have_styling([
-        ['font-size', '18px'],
-        ['color', 'green'],
-      ]).at_selector('p')
-    end
-    it "removes the stylesheet links from the DOM" do
-      provider.stub(:find => '')
-      rendering(<<-HTML).should_not have_selector('link')
-        <html>
-          <head>
-            <link rel="stylesheet" href="/assets/green_paragraphs.css">
-            <link rel="stylesheet" href="/assets/large_purple_paragraphs.css">
-          </head>
-          <body>
-          </body>
-        </html>
-      HTML
-    end
-    context "when stylesheet is for print media" do
-      it "does not inline the stylesheet" do
-        rendering(<<-HTML).should_not have_styling('color' => 'green').at_selector('p')
-          <html>
-            <head>
-              <link rel="stylesheet" href="/assets/green_paragraphs.css" media="print">
-            </head>
-            <body>
-              <p></p>
-            </body>
-          </html>
-        HTML
+        expect(rendering('<p class="important" id="important"></p>')).to have_styling([
+          %w[important no], %w[important yes], %w[important very]
+        ])
       end
-      it "does not remove the links" do
-        rendering(<<-HTML).should have_selector('link')
-          <html>
-            <head>
-              <link rel="stylesheet" href="/assets/green_paragraphs.css" media="print">
-            </head>
-            <body>
-            </body>
-          </html>
-        HTML
-      end
-    end
-    context "when stylesheet is marked as immutable" do
-      it "does not inline the stylesheet" do
-        rendering(<<-HTML).should_not have_styling('color' => 'green').at_selector('p')
-          <html>
-            <head>
-              <link rel="stylesheet" href="/assets/green_paragraphs.css" data-immutable="true">
-            </head>
-            <body>
-              <p></p>
-            </body>
-          </html>
-        HTML
+      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')
+        end
       end
-      it "does not remove link" do
-        rendering(<<-HTML).should have_selector('link')
-          <html>
-            <head>
-              <link rel="stylesheet" href="/assets/green_paragraphs.css" data-immutable="true">
-            </head>
-            <body>
-            </body>
-          </html>
-        HTML
+      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']
+        ])
       end
-    end
-    context "when stylesheet link uses an absolute URL" do
-      it "does not inline the stylesheet" do
-        rendering(<<-HTML).should_not have_styling('color' => 'green').at_selector('p')
-          <html>
-            <head>
-              <link rel="stylesheet" href="http://www.example.com/green_paragraphs.css">
-            </head>
-            <body>
-              <p></p>
-            </body>
-          </html>
-        HTML
+      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']])
       end
-      it "does not remove link" do
-        rendering(<<-HTML).should have_selector('link')
-          <html>
-            <head>
-              <link rel="stylesheet" href="http://www.example.com/green_paragraphs.css">
-            </head>
-            <body>
-            </body>
-          </html>
-        HTML
+      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'],
+        ])
       end
-    end
-    context "stylesheet cannot be found on disk" do
-      it "raises an error" do
-        html = <<-HTML
-          <html>
-            <head>
-              <link rel="stylesheet" href="/assets/not_found.css">
-            </head>
-            <body>
-            </body>
-          </html>
-        HTML
+      it "does not apply link and dynamic pseudo selectors" do
+        use_css "
+          p:active { color: red }
+          p:focus { color: red }
+          p:hover { color: red }
+          p:link { color: red }
+          p:target { color: red }
+          p:visited { color: red }
-        expect { rendering(html) }.to raise_error do |error|
-          error.should be_a(Roadie::CSSFileNotFound)
-          error.filename.should == Roadie.app.assets['not_found.css']
-          error.guess.should == '/assets/not_found.css'
-        end
+          p.active { width: 100%; }
+        "
+        expect(rendering('<p class="active"></p>')).to have_styling('width' => '100%')
       end
-    end
-    context "link element is not for a stylesheet" do
-      it "is ignored" do
-        html = <<-HTML
-          <html>
-            <head>
-              <link rel="not_stylesheet" href="/assets/green_paragraphs.css">
-            </head>
-            <body>
-              <p></p>
-            </body>
-          </html>
-        HTML
-        rendering(html).tap do |document|
-          document.should_not have_styling('color' => 'green').at_selector('p')
-          document.should have_selector('link')
-        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%')
       end
-    end
-  end
-  describe "making urls absolute" do
-    it "works on image sources" do
-      rendering('<img src="/images/foo.jpg" />').should have_attribute('src' => 'http://example.com/images/foo.jpg')
-      rendering('<img src="../images/foo.jpg" />').should have_attribute('src' => 'http://example.com/images/foo.jpg')
-      rendering('<img src="foo.jpg" />').should have_attribute('src' => 'http://example.com/foo.jpg')
-    end
-    it "does not touch image sources that are already absolute" do
-      rendering('<img src="http://other.example.org/images/foo.jpg" />').should have_attribute('src' => 'http://other.example.org/images/foo.jpg')
-    end
-    it "works on inlined style attributes" do
-      rendering('<p style="background: url(/paper.png)"></p>').should have_styling('background' => 'url(http://example.com/paper.png)')
-      rendering('<p style="background: url(&quot;/paper.png&quot;)"></p>').should have_styling('background' => 'url("http://example.com/paper.png")')
-    end
-    it "works on external style declarations" do
-      use_css "p { background-image: url(/paper.png); }
-               table { background-image: url('/paper.png'); }
-               div { background-image: url(\"/paper.png\"); }"
-      rendering('<p></p>').should have_styling('background-image' => 'url(http://example.com/paper.png)')
-      rendering('<table></table>').should have_styling('background-image' => "url('http://example.com/paper.png')")
-      rendering('<div></div>').should have_styling('background-image' => 'url("http://example.com/paper.png")')
-    end
-    it "does not touch style urls that are already absolute" do
-      external_url = 'url(http://other.example.org/paper.png)'
-      use_css "p { background-image: #{external_url}; }"
-      rendering('<p></p>').should have_styling('background-image' => external_url)
-      rendering(%(<div style="background-image: #{external_url}"></div>)).should have_styling('background-image' => external_url)
-    end
+      it "warns on selectors that crash Nokogiri" do
+        dom = Nokogiri::HTML.parse "<p></p>"
-    it "does not touch the urls when no url options are defined" do
-      use_css "img { background: url(/a.jpg); }"
-      rendering('<img src="/b.jpg" />', :url_options => nil).tap do |document|
-        document.should have_attribute('src' => '/b.jpg').at_selector('img')
-        document.should have_styling('background' => 'url(/a.jpg)')
+        stylesheet = Stylesheet.new "foo.css", "p[%^=foo] { color: red; }"
+        inliner = Inliner.new([stylesheet])
+        expect(inliner).to receive(:warn).with(
+          %{Roadie cannot use "p[%^=foo]" (from "foo.css" stylesheet) when inlining stylesheets}
+        )
+        inliner.inline(dom)
       end
-    end
-    it "supports port and protocol settings" do
-      use_css "img { background: url(/a.jpg); }"
-      rendering('<img src="/b.jpg" />', :url_options => {:host => 'example.com', :protocol => 'https', :port => '8080'}).tap do |document|
-        document.should have_attribute('src' => 'https://example.com:8080/b.jpg').at_selector('img')
-        document.should have_styling('background' => 'url(https://example.com:8080/a.jpg)')
-      end
-    end
+      it "works with nth-child" do
+        use_css "
+          p { color: red; }
+          p:nth-child(2n) { color: green; }
+        "
+        result = rendering("<p></p> <p></p>")
-    # This case was happening for some users when emails were rendered as part
-    # of the request cycle. I do not know it we *really* should accept these
-    # values, but it looks like Rails do accept it so we might as well do it
-    # too.
-    it "supports protocol settings with additional tokens" do
-      use_css "img { background: url(/a.jpg); }"
-      rendering('<img src="/b.jpg" />', :url_options => {:host => 'example.com', :protocol => 'https://'}).tap do |document|
-        document.should have_attribute('src' => 'https://example.com/b.jpg').at_selector('img')
-        document.should have_styling('background' => 'url(https://example.com/a.jpg)')
+        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
-    end
-    it "does not touch data: URIs" do
-      use_css "div { background: url(data:abcdef); }"
-      rendering('<div></div>').should have_styling('background' => 'url(data:abcdef)')
-    end
-  end
-  describe "custom converter" do
-    let(:html) { '<div id="foo"></div>' }
-    it "is invoked" do
-      after_inlining_handler = double("converter")
-      after_inlining_handler.should_receive(:call).with(anything)
-      rendering(html, :after_inlining_handler => after_inlining_handler)
-    end
-    it "modifies the document using lambda" do
-      after_inlining_handler = lambda {|d| d.css("#foo").first["class"] = "bar"}
-      rendering(html, :after_inlining_handler => after_inlining_handler).css("#foo").first["class"].should == "bar"
-    end
-    it "modifies the document using object" do
-      klass = Class.new do
-        def call(d)
-          d.css("#foo").first["class"] = "bar"
-        end
-      end
-      after_inlining_handler = klass.new
-      rendering(html, :after_inlining_handler => after_inlining_handler).css("#foo").first["class"].should == "bar"
-    end
-  end
-  describe "inserting tags" do
-    it "inserts a doctype if not present" do
-      rendering('<html><body></body></html>').to_xml.should include('<!DOCTYPE ')
-      rendering('<!DOCTYPE html><html><body></body></html>').to_xml.should_not match(/(DOCTYPE.*?){2}/)
-    end
-    it "sets xmlns of <html> to that of XHTML" do
-      rendering('<html><body></body></html>').should have_node('html').with_attributes("xmlns" => "http://www.w3.org/1999/xhtml")
-    end
-    it "inserts basic html structure if not present" do
-      rendering('<h1>Hey!</h1>').should have_selector('html > head + body > h1')
-    end
-    it "inserts <head> if not present" do
-      rendering('<html><body></body></html>').should have_selector('html > head + body')
-    end
-    it "inserts meta tag describing content-type" do
-      rendering('<html><head></head><body></body></html>').tap do |document|
-        document.should have_selector('head meta[http-equiv="Content-Type"]')
-        document.css('head meta[http-equiv="Content-Type"]').first['content'].should == 'text/html; charset=UTF-8'
-      end
-    end
-    it "does not insert duplicate meta tags describing content-type" do
-      rendering(<<-HTML).to_html.scan('meta').should have(1).item
-      <html>
-        <head>
-          <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
-        </head>
-      </html>
-      HTML
-    end
-  end
-  describe "css url regex" do
-    it "parses css urls" do
-      {
-        %{url(/foo.jpg)}                   => '/foo.jpg',
-        %{url("/foo.jpg")}                 => '/foo.jpg',
-        %{url('/foo.jpg')}                 => '/foo.jpg',
-        %{url(http://localhost/foo.jpg)}   => 'http://localhost/foo.jpg',
-        %{url("http://localhost/foo.jpg")} => 'http://localhost/foo.jpg',
-        %{url('http://localhost/foo.jpg')} => 'http://localhost/foo.jpg',
-        %{url(/andromeda_(galaxy).jpg)}    => '/andromeda_(galaxy).jpg',
-      }.each do |raw, expected|
-        raw =~ Roadie::Inliner::CSS_URL_REGEXP
-        $2.should == expected
+      it "ignores selectors with @" do
+        use_css '@keyframes progress-bar-stripes {
+          from {
+            background-position: 40px 0;
+          }
+          to {
+            background-position: 0 0;
+          }
+        }'
+        expect { rendering('<p></p>') }.not_to raise_error
       end
     end
   end