weasyprint 0.1.0

data/lib/weasyprint/source.rb

@@ -0,0 +1,23 @@
+class WeasyPrint
+  class Source
+    def initialize(url_file_or_html)
+      @source = url_file_or_html
+    end
+    
+    def url?
+      @source.is_a?(String) && @source.match(/\Ahttp/)
+    end
+    
+    def file?
+      @source.kind_of?(File)
+    end
+    
+    def html?
+      !(url? || file?)
+    end
+    
+    def to_s
+      file? ? @source.path : @source
+    end
+  end
+end

data/lib/weasyprint/version.rb

@@ -0,0 +1,3 @@
+class WeasyPrint
+  VERSION = "0.1.0"
+end

data/lib/weasyprint/weasyprint.rb

@@ -0,0 +1,154 @@
+require 'shellwords'
+
+class WeasyPrint
+
+  class NoExecutableError < StandardError
+    def initialize
+      msg  = "No weasyprint executable found at #{WeasyPrint.configuration.weasyprint}\n"
+      msg << ">> Please install weasyprint - http://weasyprint.org/docs/install/"
+      super(msg)
+    end
+  end
+
+  class ImproperSourceError < StandardError
+    def initialize(msg)
+      super("Improper Source: #{msg}")
+    end
+  end
+
+  attr_accessor :source, :stylesheets
+  attr_reader :options
+
+  def initialize(url_file_or_html, options = {})
+    @source = Source.new(url_file_or_html)
+
+    @stylesheets = []
+
+    @options = WeasyPrint.configuration.default_options.merge(options)
+    @options = normalize_options(@options)
+
+    raise NoExecutableError.new unless File.exists?(WeasyPrint.configuration.weasyprint)
+  end
+
+  def command(path = nil)
+    args = [executable]
+    args += @options.to_a.flatten.compact
+
+    if @source.html?
+      args << '-' # Get HTML from stdin
+    else
+      args << @source.to_s
+    end
+
+    args << (path || '-') # Write to file or stdout
+
+    args.shelljoin
+  end
+
+  def executable
+    default = WeasyPrint.configuration.weasyprint
+    return default if default !~ /^\// # its not a path, so nothing we can do
+    if File.exist?(default)
+      default
+    else
+      default.split('/').last
+    end
+  end
+
+  def to_pdf(path=nil)
+    append_stylesheets
+
+    invoke = command(path)
+
+    result = IO.popen(invoke, "wb+") do |pdf|
+      pdf.puts(@source.to_s) if @source.html?
+      pdf.close_write
+      pdf.gets(nil)
+    end
+    result = File.read(path) if path
+
+    # $? is thread safe per http://stackoverflow.com/questions/2164887/thread-safe-external-process-in-ruby-plus-checking-exitstatus
+    raise "command failed (exitstatus=#{$?.exitstatus}): #{invoke}" if result.to_s.strip.empty? or !successful?($?)
+    return result
+  end
+
+  def to_file(path)
+    self.to_pdf(path)
+    File.new(path)
+  end
+
+  protected
+
+    REPEATABLE_OPTIONS = %w[]
+
+    def style_tag_for(stylesheet)
+      "<style>#{File.read(stylesheet)}</style>"
+    end
+
+    def append_stylesheets
+      raise ImproperSourceError.new('Stylesheets may only be added to an HTML source') if stylesheets.any? && !@source.html?
+
+      stylesheets.each do |stylesheet|
+        if @source.to_s.match(/<\/head>/)
+          @source = Source.new(@source.to_s.gsub(/(<\/head>)/) {|s| style_tag_for(stylesheet) + s })
+        else
+          @source.to_s.insert(0, style_tag_for(stylesheet))
+        end
+      end
+    end
+
+    def normalize_options(options)
+      normalized_options = {}
+
+      options.each do |key, value|
+        next if !value
+
+        # The actual option for weasyprint
+        normalized_key = "--#{normalize_arg key}"
+
+        # If the option is repeatable, attempt to normalize all values
+        if REPEATABLE_OPTIONS.include? normalized_key
+          normalize_repeatable_value(value) do |normalized_key_piece, normalized_value|
+            normalized_options[[normalized_key, normalized_key_piece]] = normalized_value
+          end
+        else # Otherwise, just normalize it like usual
+          normalized_options[normalized_key] = normalize_value(value)
+        end
+      end
+
+      normalized_options
+    end
+
+    def normalize_arg(arg)
+      arg.to_s.downcase.gsub(/[^a-z0-9]/,'-')
+    end
+
+    def normalize_value(value)
+      case value
+      when TrueClass, 'true' #ie, ==true, see http://www.ruby-doc.org/core-1.9.3/TrueClass.html
+        nil
+      when Hash
+        value.to_a.flatten.collect{|x| normalize_value(x)}.compact
+      when Array
+        value.flatten.collect{|x| x.to_s}
+      else
+        value.to_s
+      end
+    end
+
+    def normalize_repeatable_value(value)
+      case value
+      when Hash, Array
+        value.each do |(key, value)|
+          yield [normalize_value(key), normalize_value(value)]
+        end
+      else
+        [normalize_value(value), '']
+      end
+    end
+
+    def successful?(status)
+      status.success?
+    end
+
+end

data/spec/fixtures/example.css

@@ -0,0 +1 @@
+body { font-size: 20px; }

data/spec/fixtures/example.html

@@ -0,0 +1,5 @@
+<html>
+  <body>
+    <h1>Oh Hai!</h1>
+  </body>
+</html>

data/spec/fixtures/example_with_hex_symbol.css

@@ -0,0 +1,3 @@
+.test:before {
+    content: '\2039';
+}

data/spec/middleware_spec.rb

@@ -0,0 +1,384 @@
+require 'spec_helper'
+
+def app; Rack::Lint.new(@app); end
+
+def mock_app(options = {}, conditions = {}, custom_headers = {})
+  main_app = lambda { |env|
+    @env = env
+    full_headers = headers.merge custom_headers
+    [200, full_headers, @body || ['Hello world!']]
+  }
+
+  builder = Rack::Builder.new
+  builder.use WeasyPrint::Middleware, options, conditions
+  builder.run main_app
+  @app = builder.to_app
+end
+
+describe WeasyPrint::Middleware do
+  let(:headers) { {'Content-Type' => "text/html"} }
+
+  describe "#call" do
+    describe "caching" do
+      let(:headers) { {'Content-Type' => "text/html", 'ETag' => 'foo', 'Cache-Control' => 'max-age=2592000, public'} }
+
+      context "by default" do
+        before { mock_app }
+
+        it "deletes ETag" do
+          get 'http://www.example.org/public/test.pdf'
+          expect(last_response.headers["ETag"]).to be_nil
+        end
+        it "deletes Cache-Control" do
+          get 'http://www.example.org/public/test.pdf'
+          expect(last_response.headers["Cache-Control"]).to be_nil
+        end
+      end
+
+      context "when on" do
+        before { mock_app({}, :caching => true) }
+
+        it "preserves ETag" do
+          get 'http://www.example.org/public/test.pdf'
+          expect(last_response.headers["ETag"]).not_to be_nil
+        end
+        it "preserves Cache-Control" do
+          get 'http://www.example.org/public/test.pdf'
+          expect(last_response.headers["Cache-Control"]).not_to be_nil
+        end
+      end
+    end
+
+    describe "conditions" do
+      describe ":only" do
+
+        describe "regex" do
+          describe "one" do
+            before { mock_app({}, :only => %r[^/public]) }
+
+            context "matching" do
+              specify do
+                get 'http://www.example.org/public/test.pdf'
+                expect(last_response.headers["Content-Type"]).to eq("application/pdf")
+                expect(last_response.body.bytesize).to eq(WeasyPrint.new("Hello world!").to_pdf.bytesize)
+              end
+            end
+
+            context "not matching" do
+              specify do
+                get 'http://www.example.org/secret/test.pdf'
+                expect(last_response.headers["Content-Type"]).to eq("text/html")
+                expect(last_response.body).to eq("Hello world!")
+              end
+            end
+          end # one regex
+
+          describe "multiple" do
+            before { mock_app({}, :only => [%r[^/invoice], %r[^/public]]) }
+
+            context "matching" do
+              specify do
+                get 'http://www.example.org/public/test.pdf'
+                expect(last_response.headers["Content-Type"]).to eq("application/pdf")
+                expect(last_response.body.bytesize).to eq(WeasyPrint.new("Hello world!").to_pdf.bytesize)
+              end
+            end
+
+            context "not matching" do
+              specify do
+                get 'http://www.example.org/secret/test.pdf'
+                expect(last_response.headers["Content-Type"]).to eq("text/html")
+                expect(last_response.body).to eq("Hello world!")
+              end
+            end
+          end # multiple regex
+        end # regex
+
+        describe "string" do
+          describe "one" do
+            before { mock_app({}, :only => '/public') }
+
+            context "matching" do
+              specify do
+                get 'http://www.example.org/public/test.pdf'
+                expect(last_response.headers["Content-Type"]).to eq("application/pdf")
+                expect(last_response.body.bytesize).to eq(WeasyPrint.new("Hello world!").to_pdf.bytesize)
+              end
+            end
+
+            context "not matching" do
+              specify do
+                get 'http://www.example.org/secret/test.pdf'
+                expect(last_response.headers["Content-Type"]).to eq("text/html")
+                expect(last_response.body).to eq("Hello world!")
+              end
+            end
+          end # one string
+
+          describe "multiple" do
+            before { mock_app({}, :only => ['/invoice', '/public']) }
+
+            context "matching" do
+              specify do
+                get 'http://www.example.org/public/test.pdf'
+                expect(last_response.headers["Content-Type"]).to eq("application/pdf")
+                expect(last_response.body.bytesize).to eq(WeasyPrint.new("Hello world!").to_pdf.bytesize)
+              end
+            end
+
+            context "not matching" do
+              specify do
+                get 'http://www.example.org/secret/test.pdf'
+                expect(last_response.headers["Content-Type"]).to eq("text/html")
+                expect(last_response.body).to eq("Hello world!")
+              end
+            end
+          end # multiple string
+        end # string
+
+      end
+
+      describe ":except" do
+
+        describe "regex" do
+          describe "one" do
+            before { mock_app({}, :except => %r[^/secret]) }
+
+            context "matching" do
+              specify do
+                get 'http://www.example.org/public/test.pdf'
+                expect(last_response.headers["Content-Type"]).to eq("application/pdf")
+                expect(last_response.body.bytesize).to eq(WeasyPrint.new("Hello world!").to_pdf.bytesize)
+              end
+            end
+
+            context "not matching" do
+              specify do
+                get 'http://www.example.org/secret/test.pdf'
+                expect(last_response.headers["Content-Type"]).to eq("text/html")
+                expect(last_response.body).to eq("Hello world!")
+              end
+            end
+          end # one regex
+
+          describe "multiple" do
+            before { mock_app({}, :except => [%r[^/prawn], %r[^/secret]]) }
+
+            context "matching" do
+              specify do
+                get 'http://www.example.org/public/test.pdf'
+                expect(last_response.headers["Content-Type"]).to eq("application/pdf")
+                expect(last_response.body.bytesize).to eq(WeasyPrint.new("Hello world!").to_pdf.bytesize)
+              end
+            end
+
+            context "not matching" do
+              specify do
+                get 'http://www.example.org/secret/test.pdf'
+                expect(last_response.headers["Content-Type"]).to eq("text/html")
+                expect(last_response.body).to eq("Hello world!")
+              end
+            end
+          end # multiple regex
+        end # regex
+
+        describe "string" do
+          describe "one" do
+            before { mock_app({}, :except => '/secret') }
+
+            context "matching" do
+              specify do
+                get 'http://www.example.org/public/test.pdf'
+                expect(last_response.headers["Content-Type"]).to eq("application/pdf")
+                expect(last_response.body.bytesize).to eq(WeasyPrint.new("Hello world!").to_pdf.bytesize)
+              end
+            end
+
+            context "not matching" do
+              specify do
+                get 'http://www.example.org/secret/test.pdf'
+                expect(last_response.headers["Content-Type"]).to eq("text/html")
+                expect(last_response.body).to eq("Hello world!")
+              end
+            end
+          end # one string
+
+          describe "multiple" do
+            before { mock_app({}, :except => ['/prawn', '/secret']) }
+
+            context "matching" do
+              specify do
+                get 'http://www.example.org/public/test.pdf'
+                expect(last_response.headers["Content-Type"]).to eq("application/pdf")
+                expect(last_response.body.bytesize).to eq(WeasyPrint.new("Hello world!").to_pdf.bytesize)
+              end
+            end
+
+            context "not matching" do
+              specify do
+                get 'http://www.example.org/secret/test.pdf'
+                expect(last_response.headers["Content-Type"]).to eq("text/html")
+                expect(last_response.body).to eq("Hello world!")
+              end
+            end
+          end # multiple string
+        end # string
+
+      end
+
+      describe "saving generated pdf to disk" do
+	before do
+          #make sure tests don't find an old test_save.pdf
+          File.delete('spec/test_save.pdf') if File.exists?('spec/test_save.pdf')
+          expect(File.exists?('spec/test_save.pdf')).to be_false
+	end
+
+        context "when header WeasyPrint-save-pdf is present" do
+          it "should saved the .pdf to disk" do
+	    headers = { 'WeasyPrint-save-pdf' => 'spec/test_save.pdf' }
+            mock_app({}, {only: '/public'}, headers)
+	    get 'http://www.example.org/public/test_save.pdf'
+            expect(File.exists?('spec/test_save.pdf')).to be_true
+	  end
+
+          it "should not raise when target directory does not exist" do
+	    headers = { 'WeasyPrint-save-pdf' => '/this/dir/does/not/exist/spec/test_save.pdf' }
+            mock_app({}, {only: '/public'}, headers)
+            expect {
+              get 'http://www.example.com/public/test_save.pdf'
+            }.not_to raise_error
+          end
+        end
+
+        context "when header WeasyPrint-save-pdf is not present" do
+          it "should not saved the .pdf to disk" do
+            mock_app({}, {only: '/public'}, {} )
+	    get 'http://www.example.org/public/test_save.pdf'
+            expect(File.exists?('spec/test_save.pdf')).to be_false
+          end
+        end
+      end
+    end
+
+  describe "remove .pdf from PATH_INFO and REQUEST_URI" do
+    before { mock_app }
+
+      context "matching" do
+
+        specify do
+          get 'http://www.example.org/public/file.pdf'
+          expect(@env["PATH_INFO"]).to eq("/public/file")
+          expect(@env["REQUEST_URI"]).to eq("/public/file")
+          expect(@env["SCRIPT_NAME"]).to be_empty
+        end
+        specify do
+          get 'http://www.example.org/public/file.txt'
+          expect(@env["PATH_INFO"]).to eq("/public/file.txt")
+          expect(@env["REQUEST_URI"]).to be_nil
+          expect(@env["SCRIPT_NAME"]).to be_empty
+        end
+      end
+
+      context "subdomain matching" do
+        before do
+          main_app = lambda { |env|
+            @env = env
+            @env['SCRIPT_NAME'] = '/example.org'
+            headers = {'Content-Type' => "text/html"}
+            [200, headers, @body || ['Hello world!']]
+          }
+
+          builder = Rack::Builder.new
+          builder.use WeasyPrint::Middleware
+          builder.run main_app
+          @app = builder.to_app
+        end
+        specify do
+          get 'http://example.org/sub/public/file.pdf'
+          expect(@env["PATH_INFO"]).to eq("/sub/public/file")
+          expect(@env["REQUEST_URI"]).to eq("/sub/public/file")
+          expect(@env["SCRIPT_NAME"]).to eq("/example.org")
+        end
+        specify do
+          get 'http://example.org/sub/public/file.txt'
+          expect(@env["PATH_INFO"]).to eq("/sub/public/file.txt")
+          expect(@env["REQUEST_URI"]).to be_nil
+          expect(@env["SCRIPT_NAME"]).to eq("/example.org")
+        end
+      end
+
+    end
+  end
+
+  describe "#translate_paths" do
+    before do
+      @pdf = WeasyPrint::Middleware.new({})
+      @env = { 'REQUEST_URI' => 'http://example.com/document.pdf', 'rack.url_scheme' => 'http', 'HTTP_HOST' => 'example.com' }
+    end
+
+    it "should correctly parse relative url with single quotes" do
+      @body = %{<html><head><link href='/stylesheets/application.css' media='screen' rel='stylesheet' type='text/css' /></head><body><img alt='test' src="/test.png" /></body></html>}
+      body = @pdf.send :translate_paths, @body, @env
+      expect(body).to eq("<html><head><link href='http://example.com/stylesheets/application.css' media='screen' rel='stylesheet' type='text/css' /></head><body><img alt='test' src=\"http://example.com/test.png\" /></body></html>")
+    end
+
+    it "should correctly parse relative url with double quotes" do
+      @body = %{<link href="/stylesheets/application.css" media="screen" rel="stylesheet" type="text/css" />}
+      body = @pdf.send :translate_paths, @body, @env
+      expect(body).to eq("<link href=\"http://example.com/stylesheets/application.css\" media=\"screen\" rel=\"stylesheet\" type=\"text/css\" />")
+    end
+
+    it "should correctly parse relative url with double quotes" do
+      @body = %{<link href='//fonts.googleapis.com/css?family=Open+Sans:400,600' rel='stylesheet' type='text/css'>}
+      body = @pdf.send :translate_paths, @body, @env
+      expect(body).to eq("<link href='//fonts.googleapis.com/css?family=Open+Sans:400,600' rel='stylesheet' type='text/css'>")
+    end
+
+    it "should return the body even if there are no valid substitutions found" do
+      @body = "NO MATCH"
+      body = @pdf.send :translate_paths, @body, @env
+      expect(body).to eq("NO MATCH")
+    end
+  end
+
+  describe "#translate_paths with root_url configuration" do
+    before do
+      @pdf = WeasyPrint::Middleware.new({})
+      @env = { 'REQUEST_URI' => 'http://example.com/document.pdf', 'rack.url_scheme' => 'http', 'HTTP_HOST' => 'example.com' }
+      WeasyPrint.configure do |config|
+        config.root_url = "http://example.net/"
+      end
+    end
+
+    it "should add the root_url" do
+      @body = %{<html><head><link href='/stylesheets/application.css' media='screen' rel='stylesheet' type='text/css' /></head><body><img alt='test' src="/test.png" /></body></html>}
+      body = @pdf.send :translate_paths, @body, @env
+      expect(body).to eq("<html><head><link href='http://example.net/stylesheets/application.css' media='screen' rel='stylesheet' type='text/css' /></head><body><img alt='test' src=\"http://example.net/test.png\" /></body></html>")
+    end
+
+    after do
+      WeasyPrint.configure do |config|
+        config.root_url = nil
+      end
+    end
+  end
+
+  it "should not get stuck rendering each request as pdf" do
+    mock_app
+    # false by default. No requests.
+    expect(@app.send(:rendering_pdf?)).to be_false
+
+    # Remain false on a normal request
+    get 'http://www.example.org/public/file'
+    expect(@app.send(:rendering_pdf?)).to be_false
+
+    # Return true on a pdf request.
+    get 'http://www.example.org/public/file.pdf'
+    expect(@app.send(:rendering_pdf?)).to be_true
+
+    # Restore to false on any non-pdf request.
+    get 'http://www.example.org/public/file'
+    expect(@app.send(:rendering_pdf?)).to be_false
+  end
+
+end