roadie 2.4.3 → 3.0.0.pre1

data/lib/roadie/url_generator.rb

@@ -0,0 +1,126 @@
+require 'set'
+
+module Roadie
+  # @api private
+  # Class that handles URL generation
+  #
+  # URL generation is all about converting relative URLs into absolute URLS
+  # according to the given options. It is written such as absolute URLs will
+  # get passed right through, so all URLs could be passed through here.
+  class UrlGenerator
+    attr_reader :url_options
+
+    # Create a new instance with the given URL options.
+    #
+    # Initializing without a host setting raises an error, as do unknown keys.
+    #
+    # @param [Hash] url_options
+    # @option url_options [String] :host (required)
+    # @option url_options [String, Integer] :port
+    # @option url_options [String] :path root path
+    # @option url_options [String] :scheme URL scheme ("http" is default)
+    # @option url_options [String] :protocol alias for :scheme
+    def initialize(url_options)
+      raise ArgumentError, "No URL options were specified" unless url_options
+      raise ArgumentError, "No :host was specified; options are: #{url_options.inspect}" unless url_options[:host]
+      validate_options url_options
+
+      @url_options = url_options
+      @root_uri = build_root_uri
+    end
+
+    # Generate an absolute URL from a relative URL.
+    #
+    # If the passed path is already an absolute URL, it will be returned as-is.
+    # If passed a blank path, the "root URL" will be returned. The root URL is
+    # the URL that the {#url_options} would generate by themselves.
+    #
+    # An optional base can be specified. The base is another relative path from
+    # the root that specifies an "offset" from which the path was found in. A
+    # common use-case is to convert a relative path found in a stylesheet which
+    # resides in a subdirectory.
+    #
+    # @example Normal conversions
+    #   generator = Roadie::UrlGenerator.new host: "foo.com", scheme: "https"
+    #   generator.generate_url("bar.html") # => "https://foo.com/bar.html"
+    #   generator.generate_url("/bar.html") # => "https://foo.com/bar.html"
+    #   generator.generate_url("") # => "https://foo.com"
+    #
+    # @example Conversions with a base
+    #   generator = Roadie::UrlGenerator.new host: "foo.com", scheme: "https"
+    #   generator.generate_url("../images/logo.png", "/css") # => "https://foo.com/images/logo.png"
+    #   generator.generate_url("../images/logo.png", "/assets/css") # => "https://foo.com/assets/images/logo.png"
+    #
+    # @param [String] base The base which the relative path comes from
+    # @return [String] an absolute URL
+    def generate_url(path, base = "/")
+      return root_uri.to_s if path.nil? or path.empty?
+      return path if path_is_absolute?(path)
+
+      combine_segments(root_uri, base, path).to_s
+    end
+
+    private
+    attr_reader :root_uri
+
+    def build_root_uri
+      path = make_absolute url_options[:path]
+      port = parse_port url_options[:port]
+      scheme = normalize_scheme(url_options[:scheme] || url_options[:protocol])
+      URI::Generic.build(scheme: scheme, host: url_options[:host], port: port, path: path)
+    end
+
+    def combine_segments(root, base, path)
+      new_path = apply_base(base, path)
+      if root.path
+        new_path = File.join(root.path, new_path)
+      end
+      root.merge(new_path)
+    end
+
+    def apply_base(base, path)
+      if path[0] == "/"
+        path
+      else
+        File.join(base, path)
+      end
+    end
+
+    # Strip :// from any scheme, if present
+    def normalize_scheme(scheme)
+      return 'http' unless scheme
+      scheme.to_s[/^\w+/]
+    end
+
+    def parse_port(port)
+      (port ? port.to_i : port)
+    end
+
+    def make_absolute(path)
+      if path.nil? || path[0] == "/"
+        path
+      else
+        "/#{path}"
+      end
+    end
+
+    def path_is_absolute?(path)
+      not parse_path(path).relative?
+    end
+
+    def parse_path(path)
+      URI.parse(path)
+    rescue URI::InvalidURIError => error
+      raise InvalidUrlPath.new(path, error)
+    end
+
+    VALID_OPTIONS = Set[:host, :port, :path, :protocol, :scheme].freeze
+
+    def validate_options(options)
+      keys = Set.new(options.keys)
+      unless keys.subset? VALID_OPTIONS
+        raise ArgumentError, "Passed invalid options: #{(keys - VALID_OPTIONS).to_a}, valid options are: #{VALID_OPTIONS.to_a}"
+      end
+    end
+  end
+end

data/lib/roadie/url_rewriter.rb

@@ -0,0 +1,84 @@
+module Roadie
+  # @api private
+  #
+  # Class that rewrites URLs in the DOM.
+  class UrlRewriter
+    # @param [UrlGenerator] generator
+    def initialize(generator)
+      @generator = generator
+    end
+
+    # Mutates the passed DOM tree, rewriting certain element's attributes.
+    #
+    # This will make all a[href] and img[src] into absolute URLs, as well as
+    # all "url()" directives inside style-attributes.
+    #
+    # [nil] is returned so no one can misunderstand that this method mutates
+    # the passed instance.
+    #
+    # @param [Nokogiri::HTML::Document] dom
+    # @return [nil] DOM tree is mutated
+    def transform_dom(dom)
+      # Use only a single loop to do this
+      dom.css("a[href], img[src], *[style]").each do |element|
+        transform_element_style element if element.has_attribute?('style')
+        transform_element element
+      end
+      nil
+    end
+
+    # Mutates passed CSS, rewriting url() directives.
+    #
+    # This will make all URLs inside url() absolute.
+    #
+    # [nil] is returned so no one can misunderstand that this method mutates
+    # the passed string.
+    #
+    # @param [String] css the css to mutate
+    # @return [nil] css is mutated
+    def transform_css(css)
+      css.gsub!(CSS_URL_REGEXP) do
+        matches = Regexp.last_match
+        "url(#{matches[:quote]}#{generate_url(matches[:url])}#{matches[:quote]})"
+      end
+    end
+
+    private
+    def generate_url(*args) @generator.generate_url(*args) end
+
+    # Regexp matching all the url() declarations in CSS
+    #
+    # It matches without any quotes and with both single and double quotes
+    # inside the parenthesis. There's much room for improvement, of course.
+    CSS_URL_REGEXP = %r{
+      url\(
+        (?<quote>
+          (?:["']|%22)?    # Optional opening quote
+        )
+        (?<url>            # The URL.
+                           # We match URLs with parenthesis inside it here,
+                           # so url(foo(bar)baz) will match correctly.
+          [^(]*               # Text leading up to before opening parens
+          (?:\([^)]*\))*      # Texts containing parens pairs
+          [^(]+               # Texts without parens - required
+        )
+        \k'quote'          # Closing quote
+      \)
+    }x
+
+    def transform_element(element)
+      case element.name
+      when "a" then element["href"] = generate_url element["href"]
+      when "img" then element["src"] = generate_url element["src"]
+      end
+    end
+
+    def transform_element_style(element)
+      # We need to use a setter for Nokogiri to detect the string mutation.
+      # If nokogiri used "dumber" data structures, this would all be redundant.
+      css = element["style"]
+      transform_css css
+      element["style"] = css
+    end
+  end
+end

data/lib/roadie/version.rb

@@ -1,3 +1,3 @@
 module Roadie
-  VERSION = '2.4.3'
+  VERSION = '3.0.0.pre1'
 end

data/roadie.gemspec

@@ -11,20 +11,16 @@ Gem::Specification.new do |s|
   s.authors     = ['Magnus Bergmark']
   s.email       = ['magnus.bergmark@gmail.com']
   s.homepage    = 'http://github.com/Mange/roadie'
-  s.summary     = %q{Making HTML emails comfortable for the Rails rockstars}
-  s.description = %q{Roadie tries to make sending HTML emails a little less painful in Rails 3 by inlining stylesheets and rewrite relative URLs for you.}
+  s.summary     = %q{Making HTML emails comfortable for the Ruby rockstars}
+  s.description = %q{Roadie tries to make sending HTML emails a little less painful by inlining stylesheets and rewriting relative URLs for you.}
+  s.license     = "MIT"
 
-  s.add_dependency 'nokogiri', RUBY_VERSION < '1.9.3' ? ['> 1.5.0', '< 1.6.0'] : '> 1.5.0'
+  s.required_ruby_version = ">= 1.9"
+
+  s.add_dependency 'nokogiri', '~> 1.6.0'
   s.add_dependency 'css_parser', '~> 1.3.4'
-  s.add_dependency 'actionmailer', '> 3.0.0', '< 5.0.0'
-  s.add_dependency 'sprockets'
 
-  s.add_development_dependency 'rake'
-  s.add_development_dependency 'rails'
   s.add_development_dependency 'rspec'
-  s.add_development_dependency 'rspec-rails'
-
-  s.add_development_dependency 'appraisal'
 
   s.extra_rdoc_files = %w[README.md Changelog.md]
   s.require_paths = %w[lib]

data/spec/fixtures/big_em.css

@@ -0,0 +1 @@
+em { font-size: 200%; }

data/spec/fixtures/stylesheets/green.css

@@ -0,0 +1 @@
+body { color: green; }

data/spec/integration_spec.rb

@@ -1,110 +1,140 @@
 require 'spec_helper'
 
-module Roadie
-  shared_examples "roadie integration" do
-    mailer = Class.new(AnonymousMailer) do
-      default :css => 'integration', :from => 'john@example.com'
-      append_view_path FIXTURES_PATH.join('views')
-
-      # Needed for correct path lookup
-      self.mailer_name = "integration_mailer"
-
-      def notification(to, reason)
-        @reason = reason
-        mail(:subject => 'Notification for you', :to => to) { |format| format.html; format.text }
-      end
-
-      def marketing(to)
-        headers('X-Spam' => 'No way! Trust us!')
-        mail(:subject => 'Buy cheap v1agra', :to => to)
-      end
-
-      def url_options
-        # This allows apps to calculate any options on a per-email basis
-        super.merge(:protocol => 'https')
-      end
-    end
-
-    def parse_html_in_email(mail)
-      Nokogiri::HTML.parse mail.html_part.body.decoded
-    end
-
-    before(:each) do
-      change_default_url_options(:host => 'example.app.org')
-      mailer.delivery_method = :test
-    end
-
-    it "inlines styles for an email" do
-      email = mailer.notification('doe@example.com', 'your quota limit has been reached')
-
-      email.to.should == ['doe@example.com']
-      email.from.should == ['john@example.com']
-      email.should have(2).parts
-
-      email.text_part.body.decoded.should_not match(/<.*>/)
-
-      html = email.html_part.body.decoded
-      html.should include '<!DOCTYPE'
-      html.should include '<head'
-
-      document = parse_html_in_email(email)
-      document.should have_selector('body #message h1')
-      document.should have_styling('background' => 'url(https://example.app.org/images/dots.png) repeat-x').at_selector('body')
-      document.should have_selector('strong[contains("quota")]')
-
-      # If we deliver mails we can catch weird problems with headers being invalid
-      email.deliver
-    end
-
-    it "does not add headers for the roadie options" do
-      email = mailer.notification('doe@example.com', 'no berries left in chest')
-      email.header.fields.map(&:name).should_not include('css')
-    end
-
-    it "keeps custom headers in place" do
-      email = mailer.marketing('everyone@inter.net')
-      email.header['X-Spam'].should be_present
-    end
+describe "Roadie functionality" do
+  def parse_html(html)
+    Nokogiri::HTML.parse(html)
+  end
 
-    it "applies CSS3 styles" do
-      email = mailer.notification('doe@example.com', 'your quota limit has been reached')
-      document = parse_html_in_email(email)
-      strong_node = document.css('strong').first
-      stylings = SpecHelpers.styling_of_node(strong_node)
-      stylings.should include(['box-shadow', '#62b0d7 1px 1px 1px 1px inset, #aaaaaa 1px 1px 3px 0'])
-      stylings.should include(['-o-box-shadow', '#62b0d7 1px 1px 1px 1px inset, #aaaaaa 1px 1px 3px 0'])
+  it "adds missing structure" do
+    html = "<h1>Hello world!</h1>".encode("Shift_JIS")
+    document = Roadie::Document.new(html)
+    result = document.transform
+
+    unless defined?(JRuby)
+      # JRuby has a bug that makes DTD manipulation impossible
+      # See Nokogiri bugs #984 and #985
+      # https://github.com/sparklemotion/nokogiri/issues/984
+      # https://github.com/sparklemotion/nokogiri/issues/985
+      result.should include("<!DOCTYPE html>")
     end
 
-    it "only removes the css option when disabled" do
-      Rails.application.config.roadie.enabled = false
-
-      email = mailer.notification('doe@example.com', 'your quota limit has been reached')
+    result.should include("<html>")
+    result.should include("<head>")
+    result.should include("<body>")
 
-      email.header.fields.map(&:name).should_not include('css')
+    result.should include("<meta")
+    result.should include("text/html; charset=Shift_JIS")
+  end
 
-      email.to.should == ['doe@example.com']
-      email.from.should == ['john@example.com']
-      email.should have(2).parts
+  it "inlines given css" do
+    document = Roadie::Document.new <<-HTML
+      <html>
+        <head>
+          <title>Hello world!</title>
+        </head>
+        <body>
+          <h1>Hello world!</h1>
+          <p>Check out these <em>awesome</em> prices!</p>
+        </body>
+      </html>
+    HTML
+    document.add_css <<-CSS
+      em { color: red; }
+      h1 { text-align: center; }
+    CSS
+
+    result = parse_html document.transform
+    result.should have_styling('text-align' => 'center').at_selector('h1')
+    result.should have_styling('color' => 'red').at_selector('p > em')
+  end
 
-      html = email.html_part.body.decoded
-      html.should_not include '<!DOCTYPE'
-      html.should_not include '<head'
+  it "inlines css from disk" do
+    document = Roadie::Document.new <<-HTML
+      <!DOCTYPE html>
+      <html>
+        <head>
+          <title>Hello world!</title>
+          <link rel="stylesheet" href="/spec/fixtures/big_em.css">
+        </head>
+        <body>
+          <h1>Hello world!</h1>
+          <p>Check out these <em>awesome</em> prices!</p>
+        </body>
+      </html>
+    HTML
+
+    result = parse_html document.transform
+    result.should have_styling('font-size' => '200%').at_selector('p > em')
+  end
 
-      document = parse_html_in_email(email)
-      document.should_not have_styling('color' => '#eee').at_selector('h1')
-      document.should_not have_styling('background' => 'url(https://example.app.org/images/dots.png) repeat-x').at_selector('body')
-    end
+  it "crashes when stylesheets cannot be found, unless using NullProvider" do
+    document = Roadie::Document.new <<-HTML
+      <!DOCTYPE html>
+      <html>
+        <head>
+          <link rel="stylesheet" href="/spec/fixtures/does_not_exist.css">
+        </head>
+        <body>
+        </body>
+      </html>
+    HTML
+
+    expect { document.transform }.to raise_error(Roadie::CssNotFound, /does_not_exist\.css/)
+
+    document.asset_providers << Roadie::NullProvider.new
+    expect { document.transform }.to_not raise_error
   end
 
-  describe "filesystem integration" do
-    it_behaves_like "roadie integration" do
-      before(:each) { Rails.application.config.assets.enabled = false }
-    end
+  it "makes URLs absolute" do
+    document = Roadie::Document.new <<-HTML
+      <!DOCTYPE html>
+      <html>
+        <head>
+          <style>
+            body { background: url("/assets/bg-abcdef1234567890.png"); }
+          </style>
+          <link rel="stylesheet" href="/style.css">
+        </head>
+        <body>
+          <a href="/about_us"><img src="/assets/about_us-abcdef1234567890.png" alt="About us"></a>
+        </body>
+      </html>
+    HTML
+
+    document.asset_providers = TestProvider.new(
+      "/style.css" => "a { background: url(/assets/link-abcdef1234567890.png); }"
+    )
+    document.url_options = {host: "myapp.com", scheme: "https", path: "rails/app/"}
+    result = parse_html document.transform
+
+    result.at_css("a")["href"].should == "https://myapp.com/rails/app/about_us"
+
+    result.at_css("img")["src"].should == "https://myapp.com/rails/app/assets/about_us-abcdef1234567890.png"
+
+    result.should have_styling(
+      "background" => 'url("https://myapp.com/rails/app/assets/bg-abcdef1234567890.png")'
+    ).at_selector("body")
+
+    result.should have_styling(
+      "background" => 'url(https://myapp.com/rails/app/assets/link-abcdef1234567890.png)'
+    ).at_selector("a")
   end
 
-  describe "asset pipeline integration" do
-    it_behaves_like "roadie integration" do
-      before(:each) { Rails.application.config.assets.enabled = true }
-    end
+  it "allows custom callbacks during inlining" do
+    document = Roadie::Document.new <<-HTML
+      <!DOCTYPE html>
+      <html>
+        <body>
+          <span>Hello world</span>
+        </body>
+      </html>
+    HTML
+
+    document.before_transformation = proc { |dom| dom.at_css("body")["class"] = "roadie" }
+    document.after_transformation = proc { |dom| dom.at_css("span").remove }
+
+    result = parse_html document.transform
+    result.at_css("body")["class"].should == "roadie"
+    result.at_css("span").should be_nil
   end
 end