prawn-svg 0.22.1 → 0.23.0

data/lib/prawn/svg/loaders/web.rb

@@ -0,0 +1,28 @@
+require 'net/http'
+
+module Prawn::SVG::Loaders
+  class Web
+    def from_url(url)
+      uri = build_uri(url)
+
+      if uri && %w(http https).include?(uri.scheme)
+        perform_request(uri)
+      end
+    end
+
+    private
+
+    def build_uri(url)
+      begin
+        URI(url)
+      rescue URI::InvalidURIError
+      end
+    end
+
+    def perform_request(uri)
+      Net::HTTP.get(uri)
+    rescue => e
+      raise Prawn::SVG::UrlLoader::Error, e.message
+    end
+  end
+end

data/lib/prawn/svg/state.rb

@@ -0,0 +1,39 @@
+class Prawn::SVG::State
+  attr_accessor :disable_drawing,
+    :color, :display,
+    :font_size, :font_weight, :font_style, :font_family, :font_subfamily,
+    :text_anchor, :text_relative, :text_x_positions, :text_y_positions, :preserve_space,
+    :fill_opacity, :stroke_opacity,
+    :fill, :stroke
+
+  def initialize
+    @fill = true
+    @stroke = false
+    @fill_opacity = 1
+    @stroke_opacity = 1
+  end
+
+  def enable_draw_type(type)
+    case type
+    when 'fill'   then @fill = true
+    when 'stroke' then @stroke = true
+    else raise
+    end
+  end
+
+  def disable_draw_type(type)
+    case type
+    when 'fill'   then @fill = false
+    when 'stroke' then @stroke = false
+    else raise
+    end
+  end
+
+  def draw_type(type)
+    case type
+    when 'fill'   then @fill
+    when 'stroke' then @stroke
+    else raise
+    end
+  end
+end

data/lib/prawn/svg/ttf.rb

@@ -0,0 +1,61 @@
+class Prawn::SVG::TTF
+  SFNT_VERSION_STRINGS = ["\x00\x01\x00\x00", "true", "typ1"]
+  LANGUAGE_IDS = [0, 0x409] # English, US English
+  UTF_16BE_PLATFORM_IDS = [0, 3] # Unicode, Microsoft
+
+  attr_reader :family, :subfamily
+
+  def initialize(filename)
+    load_data_from_file(filename)
+  end
+
+  private
+
+  def load_data_from_file(filename)
+    File.open(filename, "rb") do |f|
+      offset_table = f.read(12)
+      return unless offset_table && offset_table.length == 12 && SFNT_VERSION_STRINGS.include?(offset_table[0..3])
+
+      table_count = offset_table[4].ord * 256 + offset_table[5].ord
+      tables = f.read(table_count * 16)
+      return unless tables && tables.length == table_count * 16
+
+      offset, length = table_count.times do |index|
+        start = index * 16
+        if tables[start..start+3] == 'name'
+          break tables[start+8..start+15].unpack("NNN")
+        end
+      end
+
+      return unless length
+      f.seek(offset)
+      data = f.read(length)
+      return unless data && data.length == length
+
+      format, name_count, string_offset = data[0..5].unpack("nnn")
+
+      names = {}
+      name_count.times do |index|
+        start = 6 + index * 12
+        platform_id, platform_specific_id, language_id, name_id, length, offset = data[start..start+11].unpack("nnnnnn")
+        next unless offset
+        next unless LANGUAGE_IDS.include?(language_id)
+        next unless [1, 2, 16, 17].include?(name_id)
+
+        offset += string_offset
+        field = data[offset..offset+length-1]
+        next unless field && field.length == length
+
+        names[name_id] = if UTF_16BE_PLATFORM_IDS.include?(platform_id)
+          field.force_encoding(Encoding::UTF_16BE).encode(Encoding::UTF_8) rescue field
+        else
+          field
+        end
+      end
+
+      @family = names[16] || names[1]
+      @subfamily = names[17] || names[2]
+    end
+  rescue Errno::ENOENT # in case the file disappears between the scan and the load, we don't want to crash
+  end
+end

data/lib/prawn/svg/url_loader.rb

@@ -1,34 +1,46 @@
-require 'open-uri'
-require 'base64'
-
 class Prawn::SVG::UrlLoader
-  attr_accessor :enable_cache, :enable_web
-  attr_reader :url_cache
+  Error = Class.new(StandardError)
 
-  DATAURL_REGEXP = /(data:image\/(png|jpg);base64(;[a-z0-9]+)*,)/
-  URL_REGEXP = /^https?:\/\/|#{DATAURL_REGEXP}/
+  attr_reader :enable_cache, :loaders
 
-  def initialize(opts = {})
+  def initialize(enable_cache: false, enable_web: true, enable_file_with_root: nil)
     @url_cache = {}
-    @enable_cache = opts.fetch(:enable_cache, false)
-    @enable_web = opts.fetch(:enable_web, true)
-  end
+    @enable_cache = enable_cache
 
-  def valid?(url)
-    !!url.match(URL_REGEXP)
+    @loaders = []
+    loaders << Prawn::SVG::Loaders::Data.new
+    loaders << Prawn::SVG::Loaders::Web.new if enable_web
+    loaders << Prawn::SVG::Loaders::File.new(enable_file_with_root) if enable_file_with_root
   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
+    retrieve_from_cache(url) || perform_and_cache(url)
+  end
+
+  def add_to_cache(url, data)
+    @url_cache[url] = data
+  end
+
+  def retrieve_from_cache(url)
+    @url_cache[url]
+  end
+
+  private
+
+  def perform_and_cache(url)
+    data = perform(url)
+    add_to_cache(url, data) if enable_cache
+    data
+  end
+
+  def perform(url)
+    try_each_loader(url) or raise Error, "No handler available for this URL scheme"
+  end
+
+  def try_each_loader(url)
+    loaders.detect do |loader|
+      data = loader.from_url(url)
+      break data if data
     end
   end
 end

data/lib/prawn/svg/version.rb

@@ -1,5 +1,5 @@
 module Prawn
   module SVG
-    VERSION = '0.22.1'
+    VERSION = '0.23.0'
   end
 end

data/spec/integration_spec.rb

@@ -5,7 +5,7 @@ describe "Integration test" do
 
   describe "a basic SVG file" do
     let(:document) { Prawn::SVG::Document.new(svg, [800, 600], {}) }
-    let(:element) { Prawn::SVG::Elements::Root.new(document, document.root, [], {}) }
+    let(:element) { Prawn::SVG::Elements::Root.new(document) }
 
     let(:svg) do
       <<-SVG
@@ -100,15 +100,16 @@ describe "Integration test" do
 
     files.each do |file|
       it "renders the #{File.basename file} sample file without warnings or crashing" do
+        expect(Net::HTTP).to_not receive(:get)
+
         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")
+          r = prawn.svg IO.read(file), :at => [0, prawn.bounds.top], :width => prawn.bounds.width, :enable_file_requests_with_root => File.dirname(__FILE__) do |doc|
+            doc.url_loader.add_to_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.add_to_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/ || w =~ /render gradients$/}
+          warnings = r[:warnings].reject {|w| w =~ /Verdana/ && w =~ /is not a known font/ || w =~ /(render gradients$|waiting on the Prawn project)/}
         end
         warnings.should == []
       end

data/spec/prawn/svg/attributes/font_spec.rb

@@ -4,16 +4,19 @@ describe Prawn::SVG::Attributes::Font do
   class FontTestElement
     include Prawn::SVG::Attributes::Font
 
-    attr_accessor :attributes, :warnings
+    attr_accessor :attributes, :warnings, :state, :document
 
-    def initialize
-      @state = {}
+    def initialize(document)
+      @state = Prawn::SVG::State.new
+      @document = document
       @warnings = []
     end
   end
 
-  let(:element) { FontTestElement.new }
-  let(:document) { double(fallback_font_name: "Times-Roman") }
+  let(:pdf) { Prawn::Document.new }
+  let(:font_registry) { Prawn::SVG::FontRegistry.new(pdf.font_families) }
+  let(:document) { double(fallback_font_name: "Times-Roman", font_registry: font_registry) }
+  let(:element) { FontTestElement.new(document) }
 
   before do
     allow(element).to receive(:document).and_return(document)

data/spec/prawn/svg/css_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+RSpec.describe Prawn::SVG::CSS do
+  describe "#parse_font_family_string" do
+    it "correctly handles quotes and escaping" do
+      tests = {
+        "" => [],
+        "font" => ["font"],
+        "font name, other font" => ["font name", "other font"],
+        "'font name', other font" => ["font name", "other font"],
+        "'font, name', other font" => ["font, name", "other font"],
+        '"font name", other font' => ["font name", "other font"],
+        '"font, name", other font' => ["font, name", "other font"],
+        'weird \\" name' => ['weird " name'],
+        'weird\\, name' => ["weird, name"],
+        ' stupid , spacing ' => ["stupid", "spacing"],
+      }
+
+      tests.each do |string, expected|
+        expect(Prawn::SVG::CSS.parse_font_family_string(string)).to eq expected
+      end
+    end
+  end
+end

data/spec/prawn/svg/document_spec.rb

@@ -1,21 +1,46 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 
-describe Prawn::SVG::Document do  
-  before do
-    sizing = instance_double(Prawn::SVG::Calculators::DocumentSizing, viewport_width: 600, viewport_height: 400, viewport_diagonal: 500, :requested_width= => nil, :requested_height= => nil)
-    expect(sizing).to receive(:calculate)
-    expect(Prawn::SVG::Calculators::DocumentSizing).to receive(:new).and_return(sizing)
+describe Prawn::SVG::Document do
+  let(:bounds) { [100, 100] }
+  let(:options) { {} }
+
+  describe "#initialize" do
+    context "when unparsable XML is provided" do
+      let(:svg) { "this isn't SVG data" }
+
+      it "raises an exception" do
+        expect {
+          Prawn::SVG::Document.new(svg, bounds, options)
+        }.to raise_error Prawn::SVG::Document::InvalidSVGData, "The data supplied is not a valid SVG document."
+      end
+    end
+
+    context "when the user passes in a filename instead of SVG data" do
+      let(:svg) { "some_file.svg" }
+
+      it "raises an exception letting them know what they've done" do
+        expect {
+          Prawn::SVG::Document.new(svg, bounds, options)
+        }.to raise_error Prawn::SVG::Document::InvalidSVGData, "The data supplied is not a valid SVG document.  It looks like you've supplied a filename instead; use IO.read(filename) to get the data before you pass it to prawn-svg."
+      end
+    end
   end
 
-  let(:document) { Prawn::SVG::Document.new("<svg></svg>", [100, 100], {}) }
+  describe "#points" do
+    before do
+      sizing = instance_double(Prawn::SVG::Calculators::DocumentSizing, viewport_width: 600, viewport_height: 400, viewport_diagonal: 500, :requested_width= => nil, :requested_height= => nil)
+      expect(sizing).to receive(:calculate)
+      expect(Prawn::SVG::Calculators::DocumentSizing).to receive(:new).and_return(sizing)
+    end
+
+    let(:document) { Prawn::SVG::Document.new("<svg></svg>", [100, 100], {}) }
 
-  describe :points do    
     it "converts a variety of measurement units to points" do
-      document.send(:points, 32).should == 32.0      
-      document.send(:points, 32.0).should == 32.0      
+      document.send(:points, 32).should == 32.0
+      document.send(:points, 32.0).should == 32.0
       document.send(:points, "32").should == 32.0
       document.send(:points, "32unknown").should == 32.0
-      document.send(:points, "32pt").should == 32.0      
+      document.send(:points, "32pt").should == 32.0
       document.send(:points, "32in").should == 32.0 * 72
       document.send(:points, "32ft").should == 32.0 * 72 * 12
       document.send(:points, "32pc").should == 32.0 * 15

data/spec/prawn/svg/elements/base_spec.rb

@@ -2,9 +2,9 @@ require 'spec_helper'
 
 describe Prawn::SVG::Elements::Base do
   let(:svg) { "<svg></svg>" }
-  let(:document) { Prawn::SVG::Document.new(svg, [800, 600], {}) }
+  let(:document) { Prawn::SVG::Document.new(svg, [800, 600], {}, font_registry: Prawn::SVG::FontRegistry.new("Helvetica" => {:normal => nil})) }
   let(:parent_calls) { [] }
-  let(:element) { Prawn::SVG::Elements::Base.new(document, document.root, parent_calls, {}) }
+  let(:element) { Prawn::SVG::Elements::Base.new(document, document.root, parent_calls, Prawn::SVG::State.new) }
 
   describe "#initialize" do
     let(:svg) { '<something id="hello"/>' }
@@ -52,7 +52,7 @@ describe Prawn::SVG::Elements::Base do
       end
 
       element.process
-      expect(element.parent_calls).to eq [["end_path", [], [["test", ["argument"], []]]]]
+      expect(element.parent_calls).to eq [["fill", [], [["test", ["argument"], []]]]]
     end
 
     it "quietly absorbs a SkipElementQuietly exception" do
@@ -79,47 +79,69 @@ describe Prawn::SVG::Elements::Base do
 
     it "doesn't change anything if no fill attribute provided" do
       subject
-      expect(element.state[:fill]).to be nil
+      expect(element.state.fill).to be true
+
+      element.state.fill = false
+      subject
+      expect(element.state.fill).to be false
     end
 
     it "doesn't change anything if 'inherit' fill attribute provided" do
       element.attributes['fill'] = 'inherit'
       subject
-      expect(element.state[:fill]).to be nil
+      expect(element.state.fill).to be true
+
+      element.state.fill = false
+      subject
+      expect(element.state.fill).to be false
     end
 
     it "turns off filling if 'none' fill attribute provided" do
       element.attributes['fill'] = 'none'
       subject
-      expect(element.state[:fill]).to be false
+      expect(element.state.fill).to be false
     end
 
     it "uses the fill attribute's color" do
       expect(element).to receive(:add_call).with('fill_color', 'ff0000')
       element.attributes['fill'] = 'red'
       subject
-      expect(element.state[:fill]).to be true
+      expect(element.state.fill).to be true
     end
 
     it "uses black if the fill attribute's color is unparseable" do
       expect(element).to receive(:add_call).with('fill_color', '000000')
       element.attributes['fill'] = 'blarble'
       subject
-      expect(element.state[:fill]).to be true
+      expect(element.state.fill).to be true
     end
 
     it "uses the color attribute if 'currentColor' fill attribute provided" do
       expect(element).to receive(:add_call).with('fill_color', 'ff0000')
       element.attributes['fill'] = 'currentColor'
       element.attributes['color'] = 'red'
+      element.send :parse_color_attribute
       subject
-      expect(element.state[:fill]).to be true
+      expect(element.state.fill).to be true
+    end
+
+    context "with a color attribute defined on a parent element" do
+      let(:svg) { '<svg style="color: green;"><g style="color: red;"><rect width="10" height="10" style="fill: currentColor;"></rect></g></svg>' }
+      let(:element) { Prawn::SVG::Elements::Root.new(document, document.root, parent_calls) }
+      let(:flattened_calls) { flatten_calls(element.base_calls) }
+
+      it "uses the parent's color element if 'currentColor' fill attribute provided" do
+        element.process
+
+        expect(flattened_calls).to include ['fill_color', ['ff0000']]
+        expect(flattened_calls).not_to include ['fill_color', ['00ff00']]
+      end
     end
 
     it "turns off filling if UnresolvableURLWithNoFallbackError is raised" do
       element.attributes['fill'] = 'url()'
       subject
-      expect(element.state[:fill]).to be false
+      expect(element.state.fill).to be false
     end
   end
 end