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

roadie 2.4.3 → 3.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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