roadie 2.4.3 → 3.0.0

data/spec/lib/roadie/test_provider_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'roadie/rspec'
+
+describe TestProvider do
+  subject(:provider) { TestProvider.new }
+
+  it_behaves_like "roadie asset provider", valid_name: "existing.css", invalid_name: "invalid.css" do
+    subject { TestProvider.new "existing.css" => "" }
+  end
+
+  it "finds styles from a predefined hash" do
+    provider = TestProvider.new({
+      "foo.css" => "a { color: red; }",
+      "bar.css" => "body { color: green; }",
+    })
+    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
+    provider = TestProvider.new({
+      "foo.css" => "a { color: red; }",
+      :default  => "body { color: green; }",
+    })
+    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

@@ -0,0 +1,121 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+module Roadie
+  describe UrlGenerator do
+    it "is initialized with URL options" do
+      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
+      expect {
+        UrlGenerator.new(nil)
+      }.to raise_error ArgumentError, /url options/i
+    end
+
+    it "raises an argument error if no host is specified" do
+      expect {
+        UrlGenerator.new(port: 3000)
+      }.to raise_error ArgumentError, /host/i
+    end
+
+    it "raises an argument error if unknown option is passed" do
+      expect {
+        UrlGenerator.new(host: "localhost", secret: true)
+      }.to raise_error ArgumentError, /secret/
+    end
+
+    describe "generating URLs" do
+      def url(path, options = {})
+        UrlGenerator.new(options).generate_url(path)
+      end
+
+      it "uses the given host" do
+        expect(url("/hello.jpg", host: "goats.com")).to eq("http://goats.com/hello.jpg")
+      end
+
+      it "uses the given port" do
+        expect(url("/", host: "example.com", port: 1337)).to eq("http://example.com:1337/")
+      end
+
+      it "uses the given scheme" do
+        expect(url("/", host: "example.com", scheme: "https")).to eq("https://example.com/")
+      end
+
+      it "regards :protocol as an alias for scheme" do
+        expect(url("/", host: "example.com", protocol: "https")).to eq("https://example.com/")
+      end
+
+      it "strips extra characters from the scheme" do
+        expect(url("/", host: "example.com", scheme: "https://")).to eq("https://example.com/")
+      end
+
+      it "uses the given path as a prefix" do
+        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
+        expect(url("http://foo.com/", host: "bar.com")).to eq("http://foo.com/")
+      end
+
+      it "returns the base URL for blank paths" do
+        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
+        expect {
+          url("://", host: "example.com")
+        }.to raise_error InvalidUrlPath, %r{://}
+      end
+
+      it "accepts base paths without a slash in the beginning" do
+        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
+        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
+        expect(url("data:deadbeef", host: "example.com")).to eq("data:deadbeef")
+      end
+    end
+
+    # URLs in resources that are not based inside the root requires that we may
+    # specify a "custom base" to properly handle relative paths. Here's an
+    # example:
+    #
+    #   # /
+    #   #  document.html
+    #   #  images/
+    #   #    bg.png
+    #   #  stylesheets/
+    #   #    my_style.css
+    #
+    #   # stylesheets/my_style.css
+    #   body { background-image: url(../images/bg.png); }
+    #
+    # In this example, the stylesheet refers to /images/bg.png by using a
+    # relative path from /stylesheets/. In order to understand these cases, we
+    # need to specify where the "base" is in relation to the root.
+    describe "generating URLs with custom base" do
+      it "resolves relative paths" do
+        generator = UrlGenerator.new(host: "foo.com")
+        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")
+        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
+end

data/spec/lib/roadie/url_rewriter_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+require 'shared_examples/url_rewriter'
+
+module Roadie
+  describe UrlRewriter do
+    let(:generator) { double("URL generator") }
+    subject(:rewriter) { UrlRewriter.new(generator) }
+
+    it_behaves_like "url rewriter"
+
+    describe "transforming DOM trees" do
+      def dom_document(html); Nokogiri::HTML.parse html; end
+
+      it "rewrites all a[href]" do
+        expect(generator).to receive(:generate_url).with("some/path").and_return "http://foo.com/"
+        dom = dom_document <<-HTML
+          <body>
+            <a href="some/path">Some path</a>
+          </body>
+        HTML
+
+        expect {
+          rewriter.transform_dom dom
+        }.to change { dom.at_css("a")["href"] }.to "http://foo.com/"
+      end
+
+      it "rewrites relative img[src]" do
+        expect(generator).to receive(:generate_url).with("some/path.jpg").and_return "http://foo.com/image.jpg"
+        dom = dom_document <<-HTML
+          <body>
+            <img src="some/path.jpg">
+          </body>
+        HTML
+
+        expect {
+          rewriter.transform_dom dom
+        }.to change { dom.at_css("img")["src"] }.to "http://foo.com/image.jpg"
+      end
+
+      it "rewrites url() directives inside style attributes" do
+        expect(generator).to receive(:generate_url).with("some/path.jpg").and_return "http://foo.com/image.jpg"
+        dom = dom_document <<-HTML
+          <body>
+            <div style="background-image: url(&quot;some/path.jpg&quot;);">
+          </body>
+        HTML
+
+        expect {
+          rewriter.transform_dom dom
+        }.to change { dom.at_css("div")["style"] }.to 'background-image: url("http://foo.com/image.jpg");'
+      end
+    end
+
+    describe "transforming css" do
+      it "rewrites all url() directives" do
+        expect(generator).to receive(:generate_url).with("some/path.jpg").and_return "http://foo.com/image.jpg"
+        css = "body { background: top url(some/path.jpg) #eee; }"
+        expect {
+          rewriter.transform_css css
+        }.to change { css }.to "body { background: top url(http://foo.com/image.jpg) #eee; }"
+      end
+
+      it "correctly identifies URLs with single quotes" do
+        expect(generator).to receive(:generate_url).with("images/foo.png").and_return "x"
+        rewriter.transform_css "url('images/foo.png')"
+      end
+
+      it "correctly identifies URLs with double quotes" do
+        expect(generator).to receive(:generate_url).with("images/foo.png").and_return "x"
+        rewriter.transform_css 'url("images/foo.png")'
+      end
+
+      it "correctly identifies URLs with parenthesis inside them" do
+        expect(generator).to receive(:generate_url).with("images/map_(large_(extra)).png").and_return "x"
+        rewriter.transform_css 'url(images/map_(large_(extra)).png)'
+      end
+    end
+  end
+end

data/spec/shared_examples/asset_provider.rb

@@ -0,0 +1,11 @@
+shared_examples_for "asset provider role" do
+  it "responds to #find_stylesheet" do
+    expect(subject).to respond_to(:find_stylesheet)
+    expect(subject.method(:find_stylesheet).arity).to eq(1)
+  end
+
+  it "responds to #find_stylesheet!" do
+    expect(subject).to respond_to(:find_stylesheet!)
+    expect(subject.method(:find_stylesheet!).arity).to eq(1)
+  end
+end

data/spec/shared_examples/url_rewriter.rb

@@ -0,0 +1,23 @@
+shared_examples_for "url rewriter" do
+  it "is constructed with a generator" do
+    generator = double "URL generator"
+    expect {
+      described_class.new(generator)
+    }.to_not raise_error
+  end
+
+  it "has a #transform_dom(dom) method that returns nil" do
+    expect(subject).to respond_to(:transform_dom)
+    expect(subject.method(:transform_dom).arity).to eq(1)
+
+    dom = Nokogiri::HTML.parse "<body></body>"
+    expect(subject.transform_dom(dom)).to be_nil
+  end
+
+  it "has a #transform_css(css) method that returns nil" do
+    expect(subject).to respond_to(:transform_css)
+    expect(subject.method(:transform_css).arity).to eq(1)
+
+    expect(subject.transform_css("")).to be_nil
+  end
+end

data/spec/spec_helper.rb

@@ -1,68 +1,14 @@
-$: << File.dirname(__FILE__) + '/../lib'
-
-require 'ostruct'
-require 'rubygems'
-require 'bundler'
+require 'rspec/collection_matchers'
 
-begin
-  Bundler.setup(:default, :development)
-rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
+if ENV['CI']
+  require 'coveralls'
+  Coveralls.wear!
 end
 
-require 'rspec'
-require 'rails'
-require 'sprockets'
-
-require 'roadie/railtie'
-require 'action_mailer/railtie'
-
-FIXTURES_PATH = Pathname.new(File.dirname(__FILE__)).join('fixtures')
-
-class TestApplication < Rails::Application
-  def config
-    @config
-  end
-
-  def assets
-    env = Sprockets::Environment.new
-    env.append_path root.join('app','assets','stylesheets')
-    env
-  end
-
-  def root
-    FIXTURES_PATH
-  end
-
-  def reset_test_config
-    @config = OpenStruct.new({
-      :action_mailer => OpenStruct.new(:default_url_options => {}),
-      :assets => OpenStruct.new(:enabled => false),
-      :roadie => OpenStruct.new(:provider => nil, :enabled => true),
-    })
-    change_default_url_options(:host => "example.com")
-  end
-end
-
-if Roadie::Railtie.respond_to?(:run_initializers)
-  # Rails >= 3.1
-  ActionMailer::Railtie.run_initializers(:default, Rails.application)
-  Roadie::Railtie.run_initializers(:default, Rails.application)
-else
-  # Rails 3.0
-  Rails.application.config.active_support.deprecation = :log
-  Rails.logger = Logger.new('/dev/null')
-  Rails.application.initialize!
-end
+$: << File.dirname(__FILE__) + '/../lib'
+require 'roadie'
 
 RSpec.configure do |config|
-  config.before(:each) do
-    Rails.application.reset_test_config
-  end
-
-  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
 end
 

data/spec/support/have_attribute_matcher.rb

@@ -11,11 +11,11 @@ RSpec::Matchers.define :have_attribute do |attribute|
   end
 
   description { "have attribute #{attribute.inspect} at selector #{@selector.inspect}" }
-  failure_message_for_should do |document|
+  failure_message do |document|
     name, expected = attribute.first
     "expected #{name} attribute at #{@selector.inspect} to be #{expected.inspect} but was #{attribute(document, name).inspect}"
   end
-  failure_message_for_should_not do |document|
+  failure_message_when_negated do |document|
     name, expected = attribute.first
     "expected #{name} attribute at #{@selector.inspect} to not be #{expected.inspect}"
   end

data/spec/support/have_node_matcher.rb

@@ -3,14 +3,14 @@ RSpec::Matchers.define :have_node do |selector|
   match do |document|
     node = document.at_css(selector)
     if @attributes
-      node.present? and match_attributes(node.attributes)
+      node && match_attributes(node.attributes)
     else
-      node.present?
+      node
     end
   end
 
-  failure_message_for_should { "expected document to #{name_to_sentence}#{expected_to_sentence}"}
-  failure_message_for_should_not { "expected document to not #{name_to_sentence}#{expected_to_sentence}"}
+  failure_message { "expected document to #{name_to_sentence}#{expected_to_sentence}"}
+  failure_message_when_negated { "expected document to not #{name_to_sentence}#{expected_to_sentence}"}
 
   def match_attributes(node_attributes)
     attributes = Hash[node_attributes.map { |name, attribute| [name, attribute.value] }]

data/spec/support/have_selector_matcher.rb

@@ -1,6 +1,6 @@
 RSpec::Matchers.define :have_selector do |selector|
-  match { |document| document.css(selector).present? }
-  failure_message_for_should { "expected document to #{name_to_sentence}#{expected_to_sentence}"}
-  failure_message_for_should_not { "expected document to not #{name_to_sentence}#{expected_to_sentence}"}
+  match { |document| !document.css(selector).empty? }
+  failure_message { "expected document to #{name_to_sentence}#{to_sentence selector}"}
+  failure_message_when_negated { "expected document to not #{name_to_sentence}#{to_sentence selector}"}
 end
 

data/spec/support/have_styling_matcher.rb

@@ -1,25 +1,61 @@
 RSpec::Matchers.define :have_styling do |rules|
-  @selector = 'body > *:first'
+  normalized_rules = StylingExpectation.new(rules)
 
-  chain :at_selector do |selector|
-    @selector = selector
+  chain(:at_selector) { |selector| @selector = selector }
+  match { |document|
+    @selector ||= 'body > *:first'
+    normalized_rules == styles_at_selector(document)
+  }
+
+  description {
+    "have styles #{normalized_rules.inspect} at selector #{@selector.inspect}"
+  }
+
+  failure_message { |document|
+    "expected styles at #{@selector.inspect} to be:\n#{normalized_rules}\nbut was:\n#{styles_at_selector(document)}"
+  }
+
+  failure_message_when_negated {
+    "expected styles at #{@selector.inspect} to not be:\n#{normalized_rules}"
+  }
+
+  def styles_at_selector(document)
+    expect(document).to have_selector(@selector)
+    StylingExpectation.new document.at_css(@selector)['style']
   end
+end
 
-  match do |document|
-    if rules.nil?
-      parsed_styles(document).blank?
-    else
-      rules.to_a.should == parsed_styles(document)
+class StylingExpectation
+  def initialize(styling)
+    case styling
+    when String then @rules = parse_rules(styling)
+    when Array then @rules = styling
+    when Hash then @rules = styling.to_a
+    else fail "I don't understand #{styling.inspect}!"
     end
   end
 
-  description { "have styles #{rules.inspect} at selector #{@selector.inspect}" }
-  failure_message_for_should { |document| "expected styles at #{@selector.inspect} to be #{rules.inspect} but was #{parsed_styles(document).inspect}" }
-  failure_message_for_should_not { "expected styles at #{@selector.inspect} to not be #{rules.inspect}" }
+  def ==(other)
+    rules == other.rules
+  end
+
+  def to_s() rules.to_s end
 
-  def parsed_styles(document)
-    node = document.css(@selector).first
-    SpecHelpers.styling_of_node(node)
+  protected
+  attr_reader :rules
+
+  private
+  def parse_rules(css)
+    css.split(';').map { |property| parse_property(property) }
+  end
+
+  def parse_property(property)
+    rule, value = property.split(':', 2).map(&:strip)
+    [rule, normalize_quotes(value)]
   end
-end
 
+  # JRuby's Nokogiri encodes quotes
+  def normalize_quotes(string)
+    string.gsub '%22', '"'
+  end
+end