roadie 3.0.0.pre1 → 3.0.0

data/spec/lib/roadie/null_provider_spec.rb

@@ -7,10 +7,10 @@ module Roadie
     it_behaves_like "asset provider role"
 
     def expect_empty_stylesheet(stylesheet)
-      stylesheet.should_not be_nil
-      stylesheet.name.should == "(null)"
-      stylesheet.should have(0).blocks
-      stylesheet.to_s.should be_empty
+      expect(stylesheet).not_to be_nil
+      expect(stylesheet.name).to eq("(null)")
+      expect(stylesheet).to have(0).blocks
+      expect(stylesheet.to_s).to be_empty
     end
 
     it "finds an empty stylesheet for every name" do

data/spec/lib/roadie/provider_list_spec.rb

@@ -16,19 +16,27 @@ module Roadie
       second = TestProvider.new "bar.css" => "bar { color: green; }"
       provider = ProviderList.new [first, second]
 
-      provider.find_stylesheet("foo.css").to_s.should include "foo"
-      provider.find_stylesheet("bar.css").to_s.should include "bar"
-      provider.find_stylesheet("baz.css").should be_nil
+      expect(provider.find_stylesheet("foo.css").to_s).to include "foo"
+      expect(provider.find_stylesheet("bar.css").to_s).to include "bar"
+      expect(provider.find_stylesheet("baz.css")).to be_nil
     end
 
     it "is enumerable" do
-      provider.should be_kind_of(Enumerable)
-      provider.should respond_to(:each)
-      provider.each.to_a.should == [test_provider]
+      expect(provider).to be_kind_of(Enumerable)
+      expect(provider).to respond_to(:each)
+      expect(provider.each.to_a).to eq([test_provider])
     end
 
     it "has a size" do
-      provider.size.should == 1
+      expect(provider.size).to eq(1)
+      expect(provider).not_to be_empty
+    end
+
+    it "has a first and a last element" do
+      providers = [double("1"), double("2"), double("3")]
+      list = ProviderList.new(providers)
+      expect(list.first).to eq(providers.first)
+      expect(list.last).to eq(providers.last)
     end
 
     it "can have providers pushed and popped" do
@@ -40,7 +48,7 @@ module Roadie
       }.to change(provider, :size).by(2)
 
       expect {
-        provider.pop.should == other
+        expect(provider.pop).to eq(other)
       }.to change(provider, :size).by(-1)
     end
 
@@ -52,29 +60,29 @@ module Roadie
       }.to change(provider, :size).by(1)
 
       expect {
-        provider.shift.should == other
+        expect(provider.shift).to eq(other)
       }.to change(provider, :size).by(-1)
     end
 
     describe "wrapping" do
       it "creates provider lists with the arguments" do
-        ProviderList.wrap(test_provider).should be_instance_of(ProviderList)
-        ProviderList.wrap(test_provider, test_provider).size.should == 2
+        expect(ProviderList.wrap(test_provider)).to be_instance_of(ProviderList)
+        expect(ProviderList.wrap(test_provider, test_provider).size).to eq(2)
       end
 
       it "flattens arrays" do
-        ProviderList.wrap([test_provider, test_provider], test_provider).size.should == 3
-        ProviderList.wrap([test_provider, test_provider]).size.should == 2
+        expect(ProviderList.wrap([test_provider, test_provider], test_provider).size).to eq(3)
+        expect(ProviderList.wrap([test_provider, test_provider]).size).to eq(2)
       end
 
       it "combines with providers from other lists" do
         other_list = ProviderList.new([test_provider, test_provider])
-        ProviderList.wrap(test_provider, other_list).size.should == 3
+        expect(ProviderList.wrap(test_provider, other_list).size).to eq(3)
       end
 
       it "returns the passed list if only a single ProviderList is passed" do
         other_list = ProviderList.new([test_provider])
-        ProviderList.wrap(other_list).should eql other_list
+        expect(ProviderList.wrap(other_list)).to eql other_list
       end
     end
   end

data/spec/lib/roadie/selector_spec.rb

@@ -4,11 +4,11 @@ require 'spec_helper'
 module Roadie
   describe Selector do
     it "can be coerced into String" do
-      ("I love " + Selector.new("html")).should == "I love html"
+      expect("I love " + Selector.new("html")).to eq("I love html")
     end
 
     it "can be inlined when simple" do
-      Selector.new("html body #main p.class").should be_inlinable
+      expect(Selector.new("html body #main p.class")).to be_inlinable
     end
 
     it "cannot be inlined when containing pseudo functions" do
@@ -19,42 +19,45 @@ module Roadie
         p:link
         p:target
         p:visited
-        p:before
-        p:after
         p:-ms-input-placeholder
         p:-moz-placeholder
+        p:before
+        p:after
+        p:enabled
+        p:disabled
+        p:checked
       ].each do |bad_selector|
-        Selector.new(bad_selector).should_not be_inlinable
+        expect(Selector.new(bad_selector)).not_to be_inlinable
       end
 
-      Selector.new('p.active').should be_inlinable
+      expect(Selector.new('p.active')).to be_inlinable
     end
 
     it "cannot be inlined when containing pseudo elements" do
-      Selector.new('p::some-element').should_not be_inlinable
+      expect(Selector.new('p::some-element')).not_to be_inlinable
     end
 
     it "cannot be inlined when selector is an at-rule" do
-      Selector.new('@keyframes progress-bar-stripes').should_not be_inlinable
+      expect(Selector.new('@keyframes progress-bar-stripes')).not_to be_inlinable
     end
 
     it "has a calculated specificity" do
       selector = "html p.active.nice #main.deep-selector"
-      Selector.new(selector).specificity.should == CssParser.calculate_specificity(selector)
+      expect(Selector.new(selector).specificity).to eq(CssParser.calculate_specificity(selector))
     end
 
     it "can be told about the specificity at initialization" do
       selector = "html p.active.nice #main.deep-selector"
-      Selector.new(selector, 1337).specificity.should == 1337
+      expect(Selector.new(selector, 1337).specificity).to eq(1337)
     end
 
     it "is equal to other selectors when they match the same things" do
-      Selector.new("foo").should == Selector.new("foo ")
-      Selector.new("foo").should_not == "foo"
+      expect(Selector.new("foo")).to eq(Selector.new("foo "))
+      expect(Selector.new("foo")).not_to eq("foo")
     end
 
     it "strips the given selector" do
-      Selector.new(" foo  \n").to_s.should == Selector.new("foo").to_s
+      expect(Selector.new(" foo  \n").to_s).to eq(Selector.new("foo").to_s)
     end
   end
 end

data/spec/lib/roadie/style_attribute_builder_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+module Roadie
+  describe StyleAttributeBuilder do
+    it "sorts the added properties" do
+      builder = StyleAttributeBuilder.new
+
+      builder << StyleProperty.new("color", "green", true, 1)
+      builder << StyleProperty.new("font-size", "110%", false, 15)
+      builder << StyleProperty.new("color", "red", false, 15)
+
+      expect(builder.attribute_string).to eq "font-size:110%;color:red;color:green !important"
+    end
+
+    it "preserves the order of added attributes with the same specificity" do
+      builder = StyleAttributeBuilder.new
+
+      builder << StyleProperty.new("color", "pink",  false, 50)
+      builder << StyleProperty.new("color", "red",   false, 50)
+      builder << StyleProperty.new("color", "green", false, 50)
+
+      # We need one different element to trigger the problem with Ruby's
+      # unstable sort
+      builder << StyleProperty.new("background", "white", false, 1)
+
+      expect(builder.attribute_string).to eq "background:white;color:pink;color:red;color:green"
+    end
+  end
+end

data/spec/lib/roadie/style_block_spec.rb

@@ -8,28 +8,28 @@ module Roadie
       selector = double "Selector"
 
       block = StyleBlock.new(selector, properties)
-      block.selector.should == selector
-      block.properties.should == properties
+      expect(block.selector).to eq(selector)
+      expect(block.properties).to eq(properties)
     end
 
     it "delegates #specificity to the selector" do
       selector = double "Selector", specificity: 45
-      StyleBlock.new(selector, []).specificity.should == 45
+      expect(StyleBlock.new(selector, []).specificity).to eq(45)
     end
 
     it "delegates #inlinable? to the selector" do
       selector = double "Selector", inlinable?: "maybe"
-      StyleBlock.new(selector, []).inlinable?.should == "maybe"
+      expect(StyleBlock.new(selector, []).inlinable?).to eq("maybe")
     end
 
     it "delegates #selector_string to selector#to_s" do
       selector = double "Selector", to_s: "yey"
-      StyleBlock.new(selector, []).selector_string.should == "yey"
+      expect(StyleBlock.new(selector, []).selector_string).to eq("yey")
     end
 
     it "has a string representation" do
       properties = [double(to_s: "bar"), double(to_s: "baz")]
-      StyleBlock.new(double(to_s: "foo"), properties).to_s.should == "foo{bar;baz}"
+      expect(StyleBlock.new(double(to_s: "foo"), properties).to_s).to eq("foo{bar;baz}")
     end
   end
 end

data/spec/lib/roadie/style_property_spec.rb

@@ -4,21 +4,21 @@ module Roadie
   describe StyleProperty do
     it "is initialized with a property, value, if it is marked as important, and the specificity" do
       StyleProperty.new('color', 'green', true, 45).tap do |declaration|
-        declaration.property.should == 'color'
-        declaration.value.should == 'green'
-        declaration.should be_important
-        declaration.specificity.should == 45
+        expect(declaration.property).to eq('color')
+        expect(declaration.value).to eq('green')
+        expect(declaration).to be_important
+        expect(declaration.specificity).to eq(45)
       end
     end
 
     describe "string representation" do
       it "is the property and the value joined with a colon" do
-        StyleProperty.new('color', 'green', false, 1).to_s.should == 'color:green'
-        StyleProperty.new('font-size', '1.1em', false, 1).to_s.should == 'font-size:1.1em'
+        expect(StyleProperty.new('color', 'green', false, 1).to_s).to eq('color:green')
+        expect(StyleProperty.new('font-size', '1.1em', false, 1).to_s).to eq('font-size:1.1em')
       end
 
       it "contains the !important flag when set" do
-        StyleProperty.new('color', 'green', true, 1).to_s.should == 'color:green !important'
+        expect(StyleProperty.new('color', 'green', true, 1).to_s).to eq('color:green !important')
       end
     end
 
@@ -28,20 +28,20 @@ module Roadie
       end
 
       it "compares on specificity" do
-        declaration(5).should be == declaration(5)
-        declaration(4).should be < declaration(5)
-        declaration(6).should be > declaration(5)
+        expect(declaration(5)).to eq(declaration(5))
+        expect(declaration(4)).to be < declaration(5)
+        expect(declaration(6)).to be > declaration(5)
       end
 
       context "with an important declaration" do
         it "is less than the important declaration regardless of the specificity" do
-          declaration(99, false).should be < declaration(1, true)
+          expect(declaration(99, false)).to be < declaration(1, true)
         end
 
         it "compares like normal when both declarations are important" do
-          declaration(5, true).should be == declaration(5, true)
-          declaration(4, true).should be < declaration(5, true)
-          declaration(6, true).should be > declaration(5, true)
+          expect(declaration(5, true)).to eq(declaration(5, true))
+          expect(declaration(4, true)).to be < declaration(5, true)
+          expect(declaration(6, true)).to be > declaration(5, true)
         end
       end
     end
@@ -53,23 +53,23 @@ module Roadie
       end
 
       it "understands simple declarations" do
-        parsing("color: green", 1).should == ["color", "green", false, 1]
-        parsing(" color:green; ", 1).should == ["color", "green", false, 1]
-        parsing("color: green  ", 1).should == ["color", "green", false, 1]
-        parsing("color: green  ; ", 1).should == ["color", "green", false, 1]
+        expect(parsing("color: green", 1)).to eq(["color", "green", false, 1])
+        expect(parsing(" color:green; ", 1)).to eq(["color", "green", false, 1])
+        expect(parsing("color: green  ", 1)).to eq(["color", "green", false, 1])
+        expect(parsing("color: green  ; ", 1)).to eq(["color", "green", false, 1])
       end
 
       it "understands more complex values" do
-        parsing("padding:0 1px 5rem 9%;", 89).should == ["padding", "0 1px 5rem 9%", false, 89]
+        expect(parsing("padding:0 1px 5rem 9%;", 89)).to eq(["padding", "0 1px 5rem 9%", false, 89])
       end
 
       it "understands more complex names" do
-        parsing("font-size: 50%", 10).should == ["font-size", "50%", false, 10]
+        expect(parsing("font-size: 50%", 10)).to eq(["font-size", "50%", false, 10])
       end
 
       it "correctly reads !important declarations" do
-        parsing("color: green !important", 1).should == ["color", "green", true, 1]
-        parsing("color: green !important;", 1).should == ["color", "green", true, 1]
+        expect(parsing("color: green !important", 1)).to eq(["color", "green", true, 1])
+        expect(parsing("color: green !important;", 1)).to eq(["color", "green", true, 1])
       end
 
       it "raises an error on unparseable declarations" do

data/spec/lib/roadie/stylesheet_spec.rb

@@ -5,7 +5,7 @@ module Roadie
   describe Stylesheet do
     it "is initialized with a name and CSS" do
       stylesheet = Stylesheet.new("foo.css", "body { color: green; }")
-      stylesheet.name.should == "foo.css"
+      expect(stylesheet.name).to eq("foo.css")
     end
 
     it "has a list of blocks" do
@@ -13,12 +13,12 @@ module Roadie
         body { color: green !important; font-size: 200%; }
         a, i { color: red; }
       CSS
-      stylesheet.should have(3).blocks
-      stylesheet.blocks.map(&:to_s).should == [
+      expect(stylesheet).to have(3).blocks
+      expect(stylesheet.blocks.map(&:to_s)).to eq([
         "body{color:green !important;font-size:200%}",
         "a{color:red}",
         "i{color:red}",
-      ]
+      ])
     end
 
     it "can iterate all inlinable blocks" do
@@ -26,16 +26,16 @@ module Roadie
       bad = double(inlinable?: false, selector: "bad", properties: "props")
 
       stylesheet = Stylesheet.new("example.css", "")
-      stylesheet.stub blocks: [bad, inlinable, bad]
+      allow(stylesheet).to receive_messages blocks: [bad, inlinable, bad]
 
-      stylesheet.each_inlinable_block.to_a.should == [
+      expect(stylesheet.each_inlinable_block.to_a).to eq([
         ["good", "props"],
-      ]
+      ])
     end
 
     it "has a string representation of the contents" do
       stylesheet = Stylesheet.new("example.css", "body { color: green;}a{ color: red; font-size: small }")
-      stylesheet.to_s.should == "body{color:green}\na{color:red;font-size:small}"
+      expect(stylesheet.to_s).to eq("body{color:green}\na{color:red;font-size:small}")
     end
   end
 end

data/spec/lib/roadie/test_provider_spec.rb

@@ -13,9 +13,9 @@ describe TestProvider do
       "foo.css" => "a { color: red; }",
       "bar.css" => "body { color: green; }",
     })
-    provider.find_stylesheet("foo.css").to_s.should_not include("body")
-    provider.find_stylesheet("bar.css").to_s.should include("body")
-    provider.find_stylesheet("baz.css").should be_nil
+    expect(provider.find_stylesheet("foo.css").to_s).not_to include("body")
+    expect(provider.find_stylesheet("bar.css").to_s).to include("body")
+    expect(provider.find_stylesheet("baz.css")).to be_nil
   end
 
   it "can have a default for missing entries" do
@@ -23,7 +23,7 @@ describe TestProvider do
       "foo.css" => "a { color: red; }",
       :default  => "body { color: green; }",
     })
-    provider.find_stylesheet("foo.css").to_s.should_not include("body")
-    provider.find_stylesheet("bar.css").to_s.should include("body")
+    expect(provider.find_stylesheet("foo.css").to_s).not_to include("body")
+    expect(provider.find_stylesheet("bar.css").to_s).to include("body")
   end
 end

data/spec/lib/roadie/url_generator_spec.rb

@@ -4,7 +4,7 @@ require 'spec_helper'
 module Roadie
   describe UrlGenerator do
     it "is initialized with URL options" do
-      UrlGenerator.new(host: "foo.com").url_options.should == {host: "foo.com"}
+      expect(UrlGenerator.new(host: "foo.com").url_options).to eq({host: "foo.com"})
     end
 
     it "raises an argument error if no URL options are specified" do
@@ -31,37 +31,38 @@ module Roadie
       end
 
       it "uses the given host" do
-        url("/hello.jpg", host: "goats.com").should == "http://goats.com/hello.jpg"
+        expect(url("/hello.jpg", host: "goats.com")).to eq("http://goats.com/hello.jpg")
       end
 
       it "uses the given port" do
-        url("/", host: "example.com", port: 1337).should == "http://example.com:1337/"
+        expect(url("/", host: "example.com", port: 1337)).to eq("http://example.com:1337/")
       end
 
       it "uses the given scheme" do
-        url("/", host: "example.com", scheme: "https").should == "https://example.com/"
+        expect(url("/", host: "example.com", scheme: "https")).to eq("https://example.com/")
       end
 
       it "regards :protocol as an alias for scheme" do
-        url("/", host: "example.com", protocol: "https").should == "https://example.com/"
+        expect(url("/", host: "example.com", protocol: "https")).to eq("https://example.com/")
       end
 
       it "strips extra characters from the scheme" do
-        url("/", host: "example.com", scheme: "https://").should == "https://example.com/"
+        expect(url("/", host: "example.com", scheme: "https://")).to eq("https://example.com/")
       end
 
       it "uses the given path as a prefix" do
-        url("/my_file", host: "example.com", path: "/my_app").should ==
+        expect(url("/my_file", host: "example.com", path: "/my_app")).to eq(
           "http://example.com/my_app/my_file"
+        )
       end
 
       it "returns the original URL if it is absolute" do
-        url("http://foo.com/", host: "bar.com").should == "http://foo.com/"
+        expect(url("http://foo.com/", host: "bar.com")).to eq("http://foo.com/")
       end
 
       it "returns the base URL for blank paths" do
-        url("", host: "foo.com").should == "http://foo.com"
-        url(nil, host: "foo.com").should == "http://foo.com"
+        expect(url("", host: "foo.com")).to eq("http://foo.com")
+        expect(url(nil, host: "foo.com")).to eq("http://foo.com")
       end
 
       it "raises an error on invalid path" do
@@ -71,17 +72,17 @@ module Roadie
       end
 
       it "accepts base paths without a slash in the beginning" do
-        url("/bar", host: "example.com", path: "foo").should == "http://example.com/foo/bar"
-        url("/bar/", host: "example.com", path: "foo/").should == "http://example.com/foo/bar/"
+        expect(url("/bar", host: "example.com", path: "foo")).to eq("http://example.com/foo/bar")
+        expect(url("/bar/", host: "example.com", path: "foo/")).to eq("http://example.com/foo/bar/")
       end
 
       it "accepts input paths without a slash in the beginning" do
-        url("bar", host: "example.com", path: "/foo").should == "http://example.com/foo/bar"
-        url("bar", host: "example.com", path: "/foo/").should == "http://example.com/foo/bar"
+        expect(url("bar", host: "example.com", path: "/foo")).to eq("http://example.com/foo/bar")
+        expect(url("bar", host: "example.com", path: "/foo/")).to eq("http://example.com/foo/bar")
       end
 
       it "does not touch data: URIs" do
-        url("data:deadbeef", host: "example.com").should == "data:deadbeef"
+        expect(url("data:deadbeef", host: "example.com")).to eq("data:deadbeef")
       end
     end
 
@@ -105,15 +106,15 @@ module Roadie
     describe "generating URLs with custom base" do
       it "resolves relative paths" do
         generator = UrlGenerator.new(host: "foo.com")
-        generator.generate_url("../images/bg.png", "/stylesheets").should == "http://foo.com/images/bg.png"
-        generator.generate_url("../images/bg.png", "email/stylesheets").should == "http://foo.com/email/images/bg.png"
-        generator.generate_url("images/bg.png", "email/").should == "http://foo.com/email/images/bg.png"
+        expect(generator.generate_url("../images/bg.png", "/stylesheets")).to eq("http://foo.com/images/bg.png")
+        expect(generator.generate_url("../images/bg.png", "email/stylesheets")).to eq("http://foo.com/email/images/bg.png")
+        expect(generator.generate_url("images/bg.png", "email/")).to eq("http://foo.com/email/images/bg.png")
       end
 
       it "does not use the base when presented with a root-based path" do
         generator = UrlGenerator.new(host: "foo.com")
-        generator.generate_url("/images/bg.png", "/stylesheets").should == "http://foo.com/images/bg.png"
-        generator.generate_url("/images/bg.png", "email/stylesheets").should == "http://foo.com/images/bg.png"
+        expect(generator.generate_url("/images/bg.png", "/stylesheets")).to eq("http://foo.com/images/bg.png")
+        expect(generator.generate_url("/images/bg.png", "email/stylesheets")).to eq("http://foo.com/images/bg.png")
       end
     end
   end