prawn-svg 0.15.0.0 → 0.19.0

data/lib/prawn/svg/interface.rb

@@ -5,6 +5,8 @@
 module Prawn
   module Svg
     class Interface
+      VALID_OPTIONS = [:at, :position, :vposition, :width, :height, :cache_images, :fallback_font_name]
+
       DEFAULT_FONT_PATHS = ["/Library/Fonts", "/System/Library/Fonts", "#{ENV["HOME"]}/Library/Fonts", "/usr/share/fonts/truetype"]
 
       @font_path = []
@@ -19,51 +21,99 @@ module Prawn
       #
       # +data+ is the SVG data to convert.  +prawn+ is your Prawn::Document object.
       #
-      # +options+ must contain the key :at, which takes a tuple of x and y co-ordinates.
+      # Options:
+      # <tt>:at</tt>:: an array [x,y] specifying the location of the top-left corner of the SVG.
+      # <tt>:position</tt>::  one of (nil, :left, :center, :right) or an x-offset
+      # <tt>:vposition</tt>::  one of (nil, :top, :center, :bottom) or a y-offset
+      # <tt>:width</tt>:: the width that the SVG is to be rendered
+      # <tt>:height</tt>:: the height that the SVG is to be rendered
+      #
+      # If <tt>:at</tt> is provided, the SVG will be placed in the current page but
+      # the text position will not be changed.
       #
-      # +options+ can optionally contain the key :width or :height.  If both are
-      # specified, only :width will be used.
+      # If both <tt>:width</tt> and <tt>:height</tt> are specified, only the width will be used.
       #
-      def initialize(data, prawn, options)
+      def initialize(data, prawn, options, &block)
+        Prawn.verify_options VALID_OPTIONS, options
+
         @data = data
         @prawn = prawn
         @options = options
 
-        @options[:at] or raise "options[:at] must be specified"
-
         Prawn::Svg::Font.load_external_fonts(prawn.font_families)
 
-        @document = Document.new(data, [prawn.bounds.width, prawn.bounds.height], options)
+        @document = Document.new(data, [prawn.bounds.width, prawn.bounds.height], options, &block)
       end
 
       #
       # Draws the SVG to the Prawn::Document object.
       #
       def draw
-        prawn.bounding_box(@options[:at], :width => @document.width, :height => @document.height) do
+        prawn.bounding_box(position, :width => @document.sizing.output_width, :height => @document.sizing.output_height) do
           prawn.save_graphics_state do
-            clip_rectangle 0, 0, @document.width, @document.height
+            clip_rectangle 0, 0, @document.sizing.output_width, @document.sizing.output_height
             proc_creator(prawn, Parser.new(@document).parse).call
           end
         end
       end
 
+      def position
+        @options[:at] || [x_based_on_requested_alignment, y_based_on_requested_alignment]
+      end
 
       private
+
+      def x_based_on_requested_alignment
+        case options[:position]
+        when :left, nil
+          0
+        when :center, :centre
+          (@document.sizing.bounds[0] - @document.sizing.output_width) / 2.0
+        when :right
+          @document.sizing.bounds[0] - @document.sizing.output_width
+        when Numeric
+          options[:position]
+        else
+          raise ArgumentError, "options[:position] must be one of nil, :left, :right, :center or a number"
+        end
+      end
+
+      def y_based_on_requested_alignment
+        case options[:vposition]
+        when nil
+          prawn.cursor
+        when :top
+          @document.sizing.bounds[1]
+        when :center, :centre
+          @document.sizing.bounds[1] - (@document.sizing.bounds[1] - @document.sizing.output_height) / 2.0
+        when :bottom
+          @document.sizing.output_height
+        when Numeric
+          @document.sizing.bounds[1] - options[:vposition]
+        else
+          raise ArgumentError, "options[:vposition] must be one of nil, :top, :right, :bottom or a number"
+        end
+      end
+
       def proc_creator(prawn, calls)
         Proc.new {issue_prawn_command(prawn, calls)}
       end
 
       def issue_prawn_command(prawn, calls)
         calls.each do |call, arguments, children|
-          if rewrite_call_arguments(prawn, call, arguments) == false
+          skip = false
+
+          rewrite_call_arguments(prawn, call, arguments) do
             issue_prawn_command(prawn, children) if children.any?
+            skip = true
+          end
+
+          if skip
+            # the call has been overridden
+          elsif children.empty?
+            prawn.send(call, *arguments)
           else
-            if children.empty?
-              prawn.send(call, *arguments)
-            else
-              prawn.send(call, *arguments, &proc_creator(prawn, children))
-            end
+            prawn.send(call, *arguments, &proc_creator(prawn, children))
           end
         end
       end
@@ -77,7 +127,7 @@ module Prawn
         case call
         when 'text_group'
           @relative_text_position = nil
-          false
+          yield
 
         when 'draw_text'
           text, options = arguments
@@ -100,15 +150,26 @@ module Prawn
 
         when 'clip'
           prawn.add_content "W n" # clip to path
-          false
+          yield
 
         when 'save'
           prawn.save_graphics_state
-          false
+          yield
 
         when 'restore'
           prawn.restore_graphics_state
-          false
+          yield
+
+        when "end_path"
+          yield
+          prawn.add_content "n" # end path
+
+        when 'fill_and_stroke'
+          yield
+          # prawn (as at 2.0.1 anyway) uses 'b' for its fill_and_stroke.  'b' is 'h' (closepath) + 'B', and we
+          # never want closepath to be automatically run as it stuffs up many drawing operations, such as dashes
+          # and line caps, and makes paths close that we didn't ask to be closed when fill is specified.
+          prawn.add_content 'B'
         end
       end
 

data/lib/prawn/svg/parser/image.rb

@@ -1,12 +1,6 @@
-require 'open-uri'
-require 'base64'
-
 class Prawn::Svg::Parser::Image
   Error = Class.new(StandardError)
 
-  DATAURL_REGEXP = /(data:image\/(png|jpg);base64(;[a-z0-9]+)*,)/
-  URL_REGEXP = /^https?:\/\/|#{DATAURL_REGEXP}/
-
   class FakeIO
     def initialize(data)
       @data = data
@@ -24,18 +18,20 @@ class Prawn::Svg::Parser::Image
   end
 
   def parse(element)
+    return if element.state[:display] == "none"
+
     attrs = element.attributes
     url = attrs['xlink:href'] || attrs['href']
     if url.nil?
       raise Error, "image tag must have an xlink:href"
     end
 
-    if !url.match(URL_REGEXP)
+    if !@document.url_loader.valid?(url)
       raise Error, "image tag xlink:href attribute must use http, https or data scheme"
     end
 
     image = begin
-      retrieve_data_from_url(url)
+      @document.url_loader.load(url)
     rescue => e
       raise Error, "Error retrieving URL #{url}: #{e.message}"
     end
@@ -48,50 +44,18 @@ class Prawn::Svg::Parser::Image
     return if width.zero? || height.zero?
     raise Error, "width and height must be 0 or higher" if width < 0 || height < 0
 
-    par = (attrs['preserveAspectRatio'] || "xMidYMid meet").strip.split(/\s+/)
-    par.shift if par.first == "defer"
-    align, meet_or_slice = par
-    slice = meet_or_slice == "slice"
+    aspect = Prawn::Svg::Calculators::AspectRatio.new(attrs['preserveAspectRatio'], [width, height], image_dimensions(image))
 
-    if slice
+    if aspect.slice?
       element.add_call "save"
       element.add_call "rectangle", [x, y], width, height
       element.add_call "clip"
     end
 
-    options = {}
-    case align
-    when /\Ax(Min|Mid|Max)Y(Min|Mid|Max)\z/
-      ratio = image_ratio(image)
-
-      options[:fit] = [width, height] unless slice
-
-      if (width/height > ratio) == slice
-        options[:width] = width if slice
-        y -= case $2
-             when "Min" then 0
-             when "Mid" then (height - width/ratio)/2
-             when "Max" then height - width/ratio
-             end
-      else
-        options[:height] = height if slice
-        x += case $1
-             when "Min" then 0
-             when "Mid" then (width - height*ratio)/2
-             when "Max" then width - height*ratio
-             end
-      end
-    when 'none'
-      options[:width] = width
-      options[:height] = height
-    else
-      raise Error, "unknown preserveAspectRatio align keyword; ignoring image"
-    end
-
-    options[:at] = [x, y]
+    options = {:width => aspect.width, :height => aspect.height, :at => [x + aspect.x, y - aspect.y]}
 
     element.add_call "image", FakeIO.new(image), options
-    element.add_call "restore" if slice
+    element.add_call "restore" if aspect.slice?
   rescue Error => e
     @document.warnings << e.message
   end
@@ -108,24 +72,7 @@ class Prawn::Svg::Parser::Image
     end
 
     image = handler.new(data)
-    [image.width, image.height]
-  end
-
-  def image_ratio(data)
-    w, h = image_dimensions(data)
-    w.to_f / h.to_f
-  end
-
-  def retrieve_data_from_url(url)
-    @url_cache[url] || begin
-      if m = url.match(DATAURL_REGEXP)
-        data = Base64.decode64(url[m[0].length .. -1])
-      else
-        data = open(url).read
-      end
-      @url_cache[url] = data if @document.cache_images
-      data
-    end
+    [image.width.to_f, image.height.to_f]
   end
 
   %w(x y distance).each do |method|

data/lib/prawn/svg/parser/path.rb

@@ -10,6 +10,7 @@ module Prawn
       VALUES_REGEXP = /^#{INSIDE_REGEXP}/
       COMMAND_REGEXP = /^#{OUTSIDE_SPACE_REGEXP}([A-Za-z])((?:#{INSIDE_REGEXP})*)#{OUTSIDE_SPACE_REGEXP}/
 
+      FLOAT_ERROR_DELTA = 1e-10
 
       #
       # Parses an SVG path and returns a Prawn-compatible call tree.
@@ -173,15 +174,28 @@ module Prawn
             rx, ry, phi, fa, fs, x2, y2 = (1..7).collect {values.shift}
             x1, y1 = @last_point
 
+            return if rx.zero? && ry.zero?
+
             if relative
               x2 += x1
               y2 += y1
             end
 
+            # Normalise values as per F.6.2
             rx = rx.abs
             ry = ry.abs
             phi = (phi % 360) * 2 * Math::PI / 360.0
 
+            # F.6.2: If the endpoints (x1, y1) and (x2, y2) are identical, then this is equivalent to omitting the elliptical arc segment entirely.
+            return if within_float_delta?(x1, x2) && within_float_delta?(y1, y2)
+
+            # F.6.2: If rx = 0 or ry = 0 then this arc is treated as a straight line segment (a "lineto") joining the endpoints.
+            if within_float_delta?(rx, 0) || within_float_delta?(ry, 0)
+              @last_point = [x2, y2]
+              @calls << ["line_to", @last_point]
+              return
+            end
+
             # We need to get the center co-ordinates, as well as the angles from the X axis to the start and end
             # points.  To do this, we use the algorithm documented in the SVG specification section F.6.5.
 
@@ -202,7 +216,7 @@ module Prawn
             r2x = rx * rx
             r2y = ry * ry
             square = (r2x * r2y - r2x * yp1 * yp1 - r2y * xp1 * xp1) / (r2x * yp1 * yp1 + r2y * xp1 * xp1)
-            square = 0 if square < 0 && square > -1e-10 # catch rounding errors
+            square = 0 if square < 0 && square > -FLOAT_ERROR_DELTA # catch rounding errors
             base = Math.sqrt(square)
             base *= -1 if fa == fs
             cpx = base * rx * yp1 / ry
@@ -252,6 +266,10 @@ module Prawn
         @previous_quadratic_control_point = nil unless %w(Q T).include?(upcase_command)
       end
 
+      def within_float_delta?(a, b)
+        (a - b).abs < FLOAT_ERROR_DELTA
+      end
+
       def match_all(string, regexp) # regexp must start with ^
         result = []
         while string != ""

data/lib/prawn/svg/parser/text.rb

@@ -6,6 +6,8 @@ class Prawn::Svg::Parser::Text
 
   protected
   def internal_parse(element, x_positions, y_positions, relative)
+    return if element.state[:display] == "none"
+
     attrs = element.attributes
 
     if attrs['x'] || attrs['y']

data/lib/prawn/svg/parser.rb

@@ -13,6 +13,7 @@ require 'rexml/document'
 #
 class Prawn::Svg::Parser
   CONTAINER_TAGS = %w(g svg symbol defs clipPath)
+  COMMA_WSP_REGEXP = /(?:\s+,?\s*|,\s*)/
 
   #
   # Construct a Parser object.
@@ -42,6 +43,19 @@ class Prawn::Svg::Parser
     @document.warnings.clear
 
     calls = [['fill_color', '000000', []]]
+
+    calls << [
+      'transformation_matrix',
+      [@document.sizing.x_scale, 0, 0, @document.sizing.y_scale, 0, 0],
+      []
+    ]
+
+    calls << [
+      'transformation_matrix',
+      [1, 0, 0, 1, @document.sizing.x_offset, @document.sizing.y_offset],
+      []
+    ]
+
     root_element = Prawn::Svg::Element.new(@document, @document.root, calls, :ids => {}, :fill => true)
 
     parse_element(root_element)
@@ -92,44 +106,51 @@ class Prawn::Svg::Parser
       element.add_call 'line', x(attrs['x1'] || '0'), y(attrs['y1'] || '0'), x(attrs['x2'] || '0'), y(attrs['y2'] || '0')
 
     when 'polyline'
-      points = attrs['points'].split(/\s+/)
-      return unless base_point = points.shift
-      x, y = base_point.split(",")
+      points = parse_points(attrs['points'])
+      return unless points.length > 0
+      x, y = points.shift
       element.add_call 'move_to', x(x), y(y)
       element.add_call_and_enter 'stroke'
-      points.each do |point|
-        x, y = point.split(",")
+      points.each do |x, y|
         element.add_call "line_to", x(x), y(y)
       end
 
     when 'polygon'
-      points = attrs['points'].split(/\s+/).collect do |point|
-        x, y = point.split(",")
+      points = parse_points(attrs['points']).collect do |x, y|
         [x(x), y(y)]
       end
       element.add_call "polygon", *points
 
     when 'circle'
+      xy, r = [x(attrs['cx'] || "0"), y(attrs['cy'] || "0")], distance(attrs['r'])
+
+      return if zero_argument?(r)
+
       if USE_NEW_CIRCLE_CALL
-        element.add_call "circle",
-          [x(attrs['cx'] || "0"), y(attrs['cy'] || "0")], distance(attrs['r'])
+        element.add_call "circle", xy, r
       else
-        element.add_call "circle_at",
-          [x(attrs['cx'] || "0"), y(attrs['cy'] || "0")], :radius => distance(attrs['r'])
+        element.add_call "circle_at", xy, :radius => r
       end
 
     when 'ellipse'
-      element.add_call USE_NEW_ELLIPSE_CALL ? "ellipse" : "ellipse_at",
-        [x(attrs['cx'] || "0"), y(attrs['cy'] || "0")], distance(attrs['rx']), distance(attrs['ry'])
+      xy, rx, ry = [x(attrs['cx'] || "0"), y(attrs['cy'] || "0")], distance(attrs['rx'], :x), distance(attrs['ry'], :y)
+
+      return if zero_argument?(rx, ry)
+
+      element.add_call USE_NEW_ELLIPSE_CALL ? "ellipse" : "ellipse_at", xy, rx, ry
 
     when 'rect'
-      radius = distance(attrs['rx'] || attrs['ry'])
-      args = [[x(attrs['x'] || '0'), y(attrs['y'] || '0')], distance(attrs['width']), distance(attrs['height'])]
+      xy            = [x(attrs['x'] || '0'), y(attrs['y'] || '0')]
+      width, height = distance(attrs['width'], :x), distance(attrs['height'], :y)
+      radius        = distance(attrs['rx'] || attrs['ry'])
+
+      return if zero_argument?(width, height)
+
       if radius
         # n.b. does not support both rx and ry being specified with different values
-        element.add_call "rounded_rectangle", *(args + [radius])
+        element.add_call "rounded_rectangle", xy, width, height, radius
       else
-        element.add_call "rectangle", *args
+        element.add_call "rectangle", xy, width, height
       end
 
     when 'path'
@@ -191,7 +212,7 @@ class Prawn::Svg::Parser
           x = element.attributes['x']
           y = element.attributes['y']
           if x || y
-            element.add_call_and_enter "translate", distance(x || 0), -distance(y || 0)
+            element.add_call_and_enter "translate", distance(x || 0, :x), -distance(y || 0, :y)
           end
           element.add_calls_from_element definition_element
         else
@@ -227,7 +248,21 @@ class Prawn::Svg::Parser
     missing_attrs.empty?
   end
 
+  def zero_argument?(*args)
+    args.any? {|arg| arg.nil? || arg <= 0}
+  end
+
   %w(x y distance).each do |method|
     define_method(method) {|*a| @document.send(method, *a)}
   end
+
+  def parse_points(points_string)
+    points_string.
+      to_s.
+      strip.
+      gsub(/(\d)-(\d)/, '\1 -\2').
+      split(COMMA_WSP_REGEXP).
+      each_slice(2).
+      to_a
+  end
 end

data/lib/prawn/svg/url_loader.rb

@@ -0,0 +1,34 @@
+require 'open-uri'
+require 'base64'
+
+class Prawn::Svg::UrlLoader
+  attr_accessor :enable_cache, :enable_web
+  attr_reader :url_cache
+
+  DATAURL_REGEXP = /(data:image\/(png|jpg);base64(;[a-z0-9]+)*,)/
+  URL_REGEXP = /^https?:\/\/|#{DATAURL_REGEXP}/
+
+  def initialize(opts = {})
+    @url_cache = {}
+    @enable_cache = opts.fetch(:enable_cache, false)
+    @enable_web = opts.fetch(:enable_web, true)
+  end
+
+  def valid?(url)
+    !!url.match(URL_REGEXP)
+  end
+
+  def load(url)
+    @url_cache[url] || begin
+      if m = url.match(DATAURL_REGEXP)
+        data = Base64.decode64(url[m[0].length .. -1])
+      elsif enable_web
+        data = open(url).read
+      else
+        raise "No handler available to retrieve URL #{url}"
+      end
+      @url_cache[url] = data if enable_cache
+      data
+    end
+  end
+end

data/lib/prawn/svg/version.rb

@@ -1,5 +1,5 @@
 module Prawn
   module Svg
-    VERSION = '0.15.0.0'
+    VERSION = '0.19.0'
   end
 end

data/lib/prawn-svg.rb

@@ -1,6 +1,10 @@
 require 'prawn'
 require 'prawn/svg/version'
 
+require 'prawn/svg/calculators/aspect_ratio'
+require 'prawn/svg/calculators/document_sizing'
+require 'prawn/svg/calculators/pixels'
+require 'prawn/svg/url_loader'
 require 'prawn/svg/color'
 require 'prawn/svg/extension'
 require 'prawn/svg/interface'

data/prawn-svg.gemspec

@@ -5,7 +5,7 @@ spec = Gem::Specification.new do |gem|
   gem.name = 'prawn-svg'
   gem.version = Prawn::Svg::VERSION
   gem.summary = "SVG renderer for Prawn PDF library"
-  gem.description = "SVG renderer for Prawn PDF library"
+  gem.description = "This gem allows you to render SVG directly into a PDF using the 'prawn' gem.  Since PDF is vector-based, you'll get nice scaled graphics if you use SVG instead of an image."
   gem.has_rdoc = false
   gem.author = "Roger Nesbitt"
   gem.email = "roger@seriousorange.com"
@@ -18,7 +18,10 @@ spec = Gem::Specification.new do |gem|
   gem.name          = "prawn-svg"
   gem.require_paths = ["lib"]
 
-  gem.add_dependency "prawn", ">= 0.8.4"
-  gem.add_development_dependency "rspec", "~> 2.14.1"
-  gem.add_development_dependency "rake"
+  gem.required_ruby_version = '>= 1.9.3'
+
+  gem.add_runtime_dependency "prawn", ">= 0.8.4", "< 3"
+  gem.add_runtime_dependency "css_parser", "~> 1.3"
+  gem.add_development_dependency "rspec", "~> 3.0"
+  gem.add_development_dependency "rake", "~> 10.1"
 end

data/spec/integration_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe Prawn::Svg::Interface do
+  root = "#{File.dirname(__FILE__)}/.."
+
+  context "with option :position" do
+    let(:svg) { IO.read("#{root}/spec/sample_svg/cubic01a.svg") }
+
+    it "aligns the image as requested" do
+      Prawn::Document.generate("#{root}/spec/sample_output/_with_position.pdf") do |prawn|
+        width = prawn.bounds.width / 3
+
+        prawn.svg svg, :width => width, :position => :left
+        prawn.svg svg, :width => width, :position => :center
+        prawn.svg svg, :width => width, :position => :right
+        prawn.svg svg, :width => width, :position => 50
+        prawn.svg svg, :width => width
+      end
+    end
+  end
+
+  context "with option :vposition" do
+    let(:svg) { IO.read("#{root}/spec/sample_svg/cubic01a.svg") }
+
+    it "aligns the image as requested" do
+      Prawn::Document.generate("#{root}/spec/sample_output/_with_vposition.pdf") do |prawn|
+        width = prawn.bounds.width / 3
+
+        prawn.svg svg, :width => width, :position => :left, :vposition => :bottom
+        prawn.svg svg, :width => width, :position => :center, :vposition => :center
+        prawn.svg svg, :width => width, :position => :right, :vposition => :top
+        prawn.svg svg, :width => width, :position => 50, :vposition => 50
+      end
+    end
+  end
+
+  describe "sample file rendering" do
+    files = Dir["#{root}/spec/sample_svg/*.svg"]
+
+    it "has at least 10 SVG sample files to test" do
+      files.length.should >= 10
+    end
+
+    files.each do |file|
+      it "renders the #{File.basename file} sample file without warnings or crashing" do
+        warnings = nil
+        Prawn::Document.generate("#{root}/spec/sample_output/#{File.basename file}.pdf") do |prawn|
+          r = prawn.svg IO.read(file), :at => [0, prawn.bounds.top], :width => prawn.bounds.width do |doc|
+            doc.url_loader.enable_web = false
+            doc.url_loader.url_cache["https://raw.githubusercontent.com/mogest/prawn-svg/master/spec/sample_images/mushroom-wide.jpg"] = IO.read("#{root}/spec/sample_images/mushroom-wide.jpg")
+            doc.url_loader.url_cache["https://raw.githubusercontent.com/mogest/prawn-svg/master/spec/sample_images/mushroom-long.jpg"] = IO.read("#{root}/spec/sample_images/mushroom-long.jpg")
+          end
+
+          warnings = r[:warnings].reject {|w| w =~ /Verdana/ && w =~ /is not a known font/ }
+        end
+        warnings.should == []
+      end
+    end
+  end
+
+  describe "multiple file rendering" do
+    it "renders multiple files on to the same PDF" do
+      Prawn::Document.generate("#{root}/spec/sample_output/_multiple.pdf") do |prawn|
+        width = prawn.bounds.width
+
+        y = prawn.bounds.top - 12
+        prawn.draw_text "This is multiple SVGs being output to the same PDF", :at => [0, y]
+
+        y -= 12
+        prawn.svg IO.read("#{root}/spec/sample_svg/arcs01.svg"),   :at => [0, y],         :width => width / 2
+        prawn.svg IO.read("#{root}/spec/sample_svg/circle01.svg"), :at => [width / 2, y], :width => width / 2
+
+        y -= 120
+        prawn.draw_text "Here are some more PDFs below", :at => [0, y]
+
+        y -= 12
+        prawn.svg IO.read("#{root}/spec/sample_svg/quad01.svg"), :at => [0, y],             :width => width / 3
+        prawn.svg IO.read("#{root}/spec/sample_svg/rect01.svg"), :at => [width / 3, y],     :width => width / 3
+        prawn.svg IO.read("#{root}/spec/sample_svg/rect02.svg"), :at => [width / 3 * 2, y], :width => width / 3
+      end
+    end
+  end
+end