prawn-svg 0.22.1 → 0.23.0

data/lib/prawn/svg/elements/root.rb

@@ -1,4 +1,8 @@
 class Prawn::SVG::Elements::Root < Prawn::SVG::Elements::Base
+  def initialize(document, source = document.root, parent_calls = [], state = ::Prawn::SVG::State.new)
+    super
+  end
+
   def apply
     add_call 'fill_color', '000000'
     add_call 'transformation_matrix', @document.sizing.x_scale, 0, 0, @document.sizing.y_scale, 0, 0

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

@@ -2,12 +2,12 @@ class Prawn::SVG::Elements::Text < Prawn::SVG::Elements::Base
   def parse
     case attributes['xml:space']
     when 'preserve'
-      state[:preserve_space] = true
+      state.preserve_space = true
     when 'default'
-      state[:preserve_space] = false
+      state.preserve_space = false
     end
 
-    @relative = state[:text_relative] || false
+    @relative = state.text_relative || false
 
     if attributes['x'] || attributes['y']
       @relative = false
@@ -15,12 +15,12 @@ class Prawn::SVG::Elements::Text < Prawn::SVG::Elements::Base
       @y_positions = attributes['y'].split(COMMA_WSP_REGEXP).collect {|n| document.y(n)} if attributes['y']
     end
 
-    @x_positions ||= state[:text_x_positions] || [document.x(0)]
-    @y_positions ||= state[:text_y_positions] || [document.y(0)]
+    @x_positions ||= state.text_x_positions || [document.x(0)]
+    @y_positions ||= state.text_y_positions || [document.y(0)]
   end
 
   def apply
-    raise SkipElementQuietly if state[:display] == "none"
+    raise SkipElementQuietly if state.display == "none"
 
     add_call_and_enter "text_group" if name == 'text'
 
@@ -29,14 +29,14 @@ class Prawn::SVG::Elements::Text < Prawn::SVG::Elements::Base
     end
 
     opts = {}
-    if size = state[:font_size]
+    if size = state.font_size
       opts[:size] = size
     end
-    opts[:style] = state[:font_subfamily]
+    opts[:style] = state.font_subfamily
 
     # This is not a prawn option but we can't work out how to render it here -
     # it's handled by SVG#rewrite_call_arguments
-    if (anchor = attributes['text-anchor'] || state[:text_anchor]) &&
+    if (anchor = attributes['text-anchor'] || state.text_anchor) &&
         ['start', 'middle', 'end'].include?(anchor)
       opts[:text_anchor] = anchor
     end
@@ -47,7 +47,7 @@ class Prawn::SVG::Elements::Text < Prawn::SVG::Elements::Base
 
     source.children.each do |child|
       if child.node_type == :text
-        text = child.value.strip.gsub(state[:preserve_space] ? /[\n\t]/ : /\s+/, " ")
+        text = child.value.strip.gsub(state.preserve_space ? /[\n\t]/ : /\s+/, " ")
 
         while text != ""
           opts[:at] = [@x_positions.first, @y_positions.first]
@@ -70,10 +70,10 @@ class Prawn::SVG::Elements::Text < Prawn::SVG::Elements::Base
         add_call 'save'
 
         new_state = state.dup
-        new_state[:text_x_positions] = @x_positions
-        new_state[:text_y_positions] = @y_positions
-        new_state[:text_relative] = @relative
-        new_state[:text_anchor] = opts[:text_anchor]
+        new_state.text_x_positions = @x_positions
+        new_state.text_y_positions = @y_positions
+        new_state.text_relative = @relative
+        new_state.text_anchor = opts[:text_anchor]
 
         Prawn::SVG::Elements::Text.new(document, child, calls, new_state).process
 

data/lib/prawn/svg/font.rb

@@ -4,22 +4,11 @@ class Prawn::SVG::Font
     "sans-serif" => "Helvetica",
     "cursive"    => "Times-Roman",
     "fantasy"    => "Times-Roman",
-    "monospace"  => "Courier"}
+    "monospace"  => "Courier"
+  }
 
   attr_reader :name, :weight, :style
 
-  def self.load(family, weight = nil, style = nil)
-    family.split(",").detect do |name|
-      name = name.gsub(/['"]/, '').gsub(/\s{2,}/, ' ').strip.downcase
-
-      # If it's a standard CSS font name, map it to one of the standard PDF fonts.
-      name = GENERIC_CSS_FONT_MAPPING[name] || name
-
-      font = new(name, weight, style)
-      break font if font.installed?
-    end
-  end
-
   def self.weight_for_css_font_weight(weight)
     case weight
     when '100', '200', '300' then :light
@@ -31,47 +20,23 @@ class Prawn::SVG::Font
     end
   end
 
-  # This method is passed prawn's font_families hash.  It'll be pre-populated with the fonts that prawn natively
-  # supports.  We'll add fonts we find in the font path to this hash.
-  def self.load_external_fonts(fonts)
-    Prawn::SVG::Interface.font_path.uniq.collect {|path| Dir["#{path}/**/*"]}.flatten.each do |filename|
-      information = font_information(filename) rescue nil
-      if information && font_name = (information[16] || information[1])
-        subfamily = (information[17] || information[2] || "normal").gsub(/\s+/, "_").downcase.to_sym
-        subfamily = :normal if subfamily == :regular
-        (fonts[font_name] ||= {})[subfamily] ||= filename
-      end
-    end
-
-    @font_case_mapping = {}
-    fonts.each {|key, _| @font_case_mapping[key.downcase] = key}
-
-    @installed_fonts = fonts
-  end
-
-  def self.installed_fonts
-    @installed_fonts
-  end
-
-  def self.correctly_cased_font_name(name)
-    @font_case_mapping[name.downcase]
-  end
+  def initialize(name, weight, style, font_registry: font_registry)
+    name = GENERIC_CSS_FONT_MAPPING.fetch(name, name) # If it's a standard CSS font name, map it to one of the standard PDF fonts.
 
-
-  def initialize(name, weight, style)
-    @name = self.class.correctly_cased_font_name(name) || name
+    @font_registry = font_registry
+    @name = font_registry.correctly_cased_font_name(name) || name
     @weight = weight
     @style = style
   end
 
   def installed?
-    subfamilies = self.class.installed_fonts[name]
+    subfamilies = @font_registry.installed_fonts[name]
     !subfamilies.nil? && subfamilies.key?(subfamily)
   end
 
   # Construct a subfamily name, ensuring that the subfamily is a valid one for the font.
   def subfamily
-    if subfamilies = self.class.installed_fonts[name]
+    if subfamilies = @font_registry.installed_fonts[name]
       if subfamilies.key?(subfamily_name)
         subfamily_name
       elsif subfamilies.key?(:normal)
@@ -82,8 +47,8 @@ class Prawn::SVG::Font
     end
   end
 
-
   private
+
   # Construct a subfamily name from the weight and style information.
   # Note that this name might not actually exist in the font.
   def subfamily_name
@@ -97,51 +62,4 @@ class Prawn::SVG::Font
 
     sfn.strip.gsub(/\s+/, "_").downcase.to_sym
   end
-
-  def self.font_information(filename)
-    File.open(filename, "r") do |f|
-      x = f.read(12)
-      table_count = x[4].ord * 256 + x[5].ord
-      tables = f.read(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("NN")
-        end
-      end
-
-      return unless length
-      f.seek(offset)
-      data = f.read(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 language_id == 0 # English
-        next unless [1, 2, 16, 17].include?(name_id)
-
-        offset += string_offset
-        field = data[offset..offset+length-1]
-        names[name_id] = if platform_id == 0
-          begin
-            if field.respond_to?(:encode)
-              field.encode(Encoding::UTF16)
-            else
-              require "iconv"
-              Iconv.iconv('UTF-8', 'UTF-16', field)
-            end
-          rescue
-            field
-          end
-        else
-          field
-        end
-      end
-      names
-    end
-  end
 end

data/lib/prawn/svg/font_registry.rb

@@ -0,0 +1,73 @@
+class Prawn::SVG::FontRegistry
+  DEFAULT_FONT_PATHS = [
+    "/Library/Fonts",
+    "/System/Library/Fonts",
+    "#{ENV["HOME"]}/Library/Fonts",
+    "/usr/share/fonts/truetype"
+  ]
+
+  @font_path = DEFAULT_FONT_PATHS.select { |path| Dir.exist?(path) }
+
+  def initialize(font_families)
+    @font_families = font_families
+  end
+
+  def installed_fonts
+    merge_external_fonts
+    @font_families
+  end
+
+  def correctly_cased_font_name(name)
+    merge_external_fonts
+    @font_case_mapping[name.downcase]
+  end
+
+  def load(family, weight = nil, style = nil)
+    Prawn::SVG::CSS.parse_font_family_string(family).detect do |name|
+      name = name.gsub(/\s{2,}/, ' ').downcase
+
+      font = Prawn::SVG::Font.new(name, weight, style, font_registry: self)
+      break font if font.installed?
+    end
+  end
+
+  private
+
+  def merge_external_fonts
+    if @font_case_mapping.nil?
+      self.class.load_external_fonts unless self.class.external_font_families
+      @font_families.merge!(self.class.external_font_families)
+
+      @font_case_mapping = @font_families.keys.each.with_object({}) do |key, result|
+        result[key.downcase] = key
+      end
+    end
+  end
+
+  class << self
+    attr_reader :external_font_families, :font_path
+
+    def load_external_fonts
+      @external_font_families = {}
+
+      external_font_paths.each do |filename|
+        ttf = Prawn::SVG::TTF.new(filename)
+        if ttf.family
+          subfamily = (ttf.subfamily || "normal").gsub(/\s+/, "_").downcase.to_sym
+          subfamily = :normal if subfamily == :regular
+          (external_font_families[ttf.family] ||= {})[subfamily] ||= filename
+        end
+      end
+    end
+
+    private
+
+    def external_font_paths
+      font_path
+        .uniq
+        .flat_map { |path| Dir["#{path}/**/*"] }
+        .uniq
+        .select { |path| File.file?(path) }
+    end
+  end
+end

data/lib/prawn/svg/interface.rb

@@ -5,14 +5,7 @@
 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 = []
-      DEFAULT_FONT_PATHS.each {|path| @font_path << path if File.exists?(path)}
-
-      class << self; attr_accessor :font_path; end
+      VALID_OPTIONS = [:at, :position, :vposition, :width, :height, :cache_images, :enable_web_requests, :enable_file_requests_with_root, :fallback_font_name]
 
       attr_reader :data, :prawn, :document, :options
 
@@ -21,17 +14,7 @@ module Prawn
       #
       # +data+ is the SVG data to convert.  +prawn+ is your Prawn::Document object.
       #
-      # 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.
-      #
-      # If both <tt>:width</tt> and <tt>:height</tt> are specified, only the width will be used.
+      # See README.md for the options that can be passed to this method.
       #
       def initialize(data, prawn, options, &block)
         Prawn.verify_options VALID_OPTIONS, options
@@ -40,9 +23,9 @@ module Prawn
         @prawn = prawn
         @options = options
 
-        Prawn::SVG::Font.load_external_fonts(prawn.font_families)
+        font_registry = Prawn::SVG::FontRegistry.new(prawn.font_families)
 
-        @document = Document.new(data, [prawn.bounds.width, prawn.bounds.height], options, &block)
+        @document = Document.new(data, [prawn.bounds.width, prawn.bounds.height], options, font_registry: font_registry, &block)
       end
 
       #
@@ -61,7 +44,7 @@ module Prawn
             clip_rectangle 0, 0, @document.sizing.output_width, @document.sizing.output_height
 
             calls = []
-            root_element = Prawn::SVG::Elements::Root.new(@document, @document.root, calls, fill: true)
+            root_element = Prawn::SVG::Elements::Root.new(@document, @document.root, calls)
             root_element.process
 
             proc_creator(prawn, calls).call
@@ -73,6 +56,10 @@ module Prawn
         @options[:at] || [x_based_on_requested_alignment, y_based_on_requested_alignment]
       end
 
+      def self.font_path # backwards support for when the font_path used to be stored on this class
+        Prawn::SVG::FontRegistry.font_path
+      end
+
       private
 
       def x_based_on_requested_alignment

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

@@ -0,0 +1,18 @@
+require 'base64'
+
+module Prawn::SVG::Loaders
+  class Data
+    REGEXP = %r[\A(?i:data):image/(png|jpeg);base64(;[a-z0-9]+)*,]
+
+    def from_url(url)
+      return if url[0..4].downcase != "data:"
+
+      matches = url.match(REGEXP)
+      if matches.nil?
+        raise Prawn::SVG::UrlLoader::Error, "prawn-svg only supports base64-encoded image/png and image/jpeg data URLs"
+      end
+
+      Base64.decode64(matches.post_match)
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+module Prawn::SVG::Loaders
+  class File
+    attr_reader :root_path
+
+    def initialize(root_path)
+      @root_path = ::File.expand_path(root_path)
+
+      raise ArgumentError, "#{root_path} is not a directory" unless Dir.exist?(@root_path)
+    end
+
+    def from_url(url)
+      uri = build_uri(url)
+
+      if uri && uri.scheme.nil? && uri.path
+        path = build_absolute_path(uri.path)
+        load_file(path)
+
+      elsif uri && uri.scheme == 'file'
+        assert_valid_file_uri!(uri)
+        load_file(uri.path)
+      end
+    end
+
+    private
+
+    def load_file(path)
+      path = ::File.expand_path(path)
+      assert_valid_path!(path)
+      assert_file_exists!(path)
+      IO.read(path)
+    end
+
+    def build_uri(url)
+      begin
+        URI(url)
+      rescue URI::InvalidURIError
+      end
+    end
+
+    def assert_valid_path!(path)
+      if !path.start_with?("#{root_path}/")
+        raise Prawn::SVG::UrlLoader::Error, "file path is not inside the root path of #{root_path}"
+      end
+    end
+
+    def build_absolute_path(path)
+      if path[0] == "/"
+        path
+      else
+        "#{root_path}/#{path}" 
+      end
+    end
+
+    def assert_valid_file_uri!(uri)
+      if uri.host
+        raise Prawn::SVG::UrlLoader::Error, "prawn-svg does not suport file: URLs with a host. Your URL probably doesn't start with three slashes, and it should."
+      end
+    end
+
+    def assert_file_exists!(path)
+      if !::File.exist?(path)
+        raise Prawn::SVG::UrlLoader::Error, "File #{path} does not exist"
+      end
+    end
+  end
+end