roadie 2.4.3 → 3.0.0.pre1

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; }",
+    })
+    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
+  end
+
+  it "can have a default for missing entries" do
+    provider = TestProvider.new({
+      "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")
+  end
+end

data/spec/lib/roadie/url_generator_spec.rb

@@ -0,0 +1,120 @@
+# encoding: UTF-8
+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"}
+    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
+        url("/hello.jpg", host: "goats.com").should == "http://goats.com/hello.jpg"
+      end
+
+      it "uses the given port" do
+        url("/", host: "example.com", port: 1337).should == "http://example.com:1337/"
+      end
+
+      it "uses the given scheme" do
+        url("/", host: "example.com", scheme: "https").should == "https://example.com/"
+      end
+
+      it "regards :protocol as an alias for scheme" do
+        url("/", host: "example.com", protocol: "https").should == "https://example.com/"
+      end
+
+      it "strips extra characters from the scheme" do
+        url("/", host: "example.com", scheme: "https://").should == "https://example.com/"
+      end
+
+      it "uses the given path as a prefix" do
+        url("/my_file", host: "example.com", path: "/my_app").should ==
+          "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/"
+      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"
+      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
+        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/"
+      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"
+      end
+
+      it "does not touch data: URIs" do
+        url("data:deadbeef", host: "example.com").should == "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")
+        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"
+      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"
+      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
+        generator.should_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
+        generator.should_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
+        generator.should_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
+        generator.should_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
+        generator.should_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
+        generator.should_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
+        generator.should_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
+    subject.should respond_to(:find_stylesheet)
+    subject.method(:find_stylesheet).arity.should == 1
+  end
+
+  it "responds to #find_stylesheet!" do
+    subject.should respond_to(:find_stylesheet!)
+    subject.method(:find_stylesheet!).arity.should == 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
+    subject.should respond_to(:transform_dom)
+    subject.method(:transform_dom).arity.should == 1
+
+    dom = Nokogiri::HTML.parse "<body></body>"
+    subject.transform_dom(dom).should be_nil
+  end
+
+  it "has a #transform_css(css) method that returns nil" do
+    subject.should respond_to(:transform_css)
+    subject.method(:transform_css).arity.should == 1
+
+    subject.transform_css("").should be_nil
+  end
+end

data/spec/spec_helper.rb

@@ -1,67 +1,12 @@
-$: << File.dirname(__FILE__) + '/../lib'
-
-require 'ostruct'
-require 'rubygems'
-require 'bundler'
-
-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
-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
+if ENV['CI']
+  require 'coveralls'
+  Coveralls.wear!
 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_node_matcher.rb

@@ -3,9 +3,9 @@ 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
 

data/spec/support/have_selector_matcher.rb

@@ -1,5 +1,5 @@
 RSpec::Matchers.define :have_selector do |selector|
-  match { |document| document.css(selector).present? }
+  match { |document| !document.css(selector).empty? }
   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}"}
 end

data/spec/support/have_styling_matcher.rb

@@ -1,25 +1,59 @@
 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| normalized_rules == styles_at_selector(document) }
+
+  description {
+    "have styles #{normalized_rules.inspect} at selector #{@selector.inspect}"
+  }
+
+  failure_message_for_should { |document|
+    "expected styles at #{@selector.inspect} to be:\n#{normalized_rules}\nbut was:\n#{styles_at_selector(document)}"
+  }
+
+  failure_message_for_should_not {
+    "expected styles at #{@selector.inspect} to not be:\n#{normalized_rules}"
+  }
+
+  def styles_at_selector(document)
+    document.should 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

data/spec/support/test_provider.rb

@@ -0,0 +1,13 @@
+class TestProvider
+  include Roadie::AssetProvider
+
+  def initialize(files = {})
+    @files = files
+    @default = files[:default]
+  end
+
+  def find_stylesheet(name)
+    contents = @files.fetch(name, @default)
+    Roadie::Stylesheet.new name, contents if contents
+  end
+end