prawnx 0.1.1

data/lib/prawn/svg/properties.rb

@@ -0,0 +1,329 @@
+module Prawn::SVG
+  class Properties
+    Config = Struct.new(:default, :inheritable?, :valid_values, :attr, :ivar, :id)
+
+    EM = 16
+    STRETCH_ORDER = %w[
+      ultra-condensed extra-condensed condensed semi-condensed normal
+      semi-expanded expanded extra-expanded ultra-expanded
+    ].freeze
+
+    FONT_SIZES = {
+      'xx-small' => EM / 4,
+      'x-small'  => EM / 4 * 2,
+      'small'    => EM / 4 * 3,
+      'medium'   => EM / 4 * 4,
+      'large'    => EM / 4 * 5,
+      'x-large'  => EM / 4 * 6,
+      'xx-large' => EM / 4 * 7
+    }.freeze
+
+    PROPERTIES = {
+      'alignment-baseline' => Config.new('auto', false,
+        %w[auto baseline before-edge text-before-edge middle central after-edge text-after-edge ideographic alphabetic hanging mathematical]),
+      'baseline-shift'     => Config.new('baseline', false, ['baseline', 'sub', 'super', :length, :percentage]),
+      'clip-path'          => Config.new('none', false, ['none', :funciri]),
+      'clip-rule'          => Config.new('nonzero', true, %w[nonzero evenodd]),
+      'color'              => Config.new(Color.black, true, [:color]),
+      'display'            => Config.new('inline', false, %w[inline none]),
+      'dominant-baseline'  => Config.new('auto', true, %w[auto middle central hanging alphabetic text-before-edge text-after-edge]),
+      'fill'               => Config.new(Paint.black, true, [:paint]),
+      'fill-opacity'       => Config.new(1.0, true, [:number]),
+      'fill-rule'          => Config.new('nonzero', true, %w[nonzero evenodd]),
+      'font-family'        => Config.new('sans-serif', true, [:any]),
+      # Only the computed (numeric) value of font-size is inherited, not the value itself
+      'font-size'          => Config.new(nil, false,
+        [:positive_length, :positive_percentage, 'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large', 'larger', 'smaller']),
+      'font-stretch'       => Config.new('normal', true, STRETCH_ORDER + %w[wider narrower]),
+      'font-style'         => Config.new('normal', true, %w[normal italic oblique]),
+      'font-variant'       => Config.new('normal', true, %w[normal small-caps]),
+      'font-weight'        => Config.new('normal', true, %w[normal bold bolder lighter 100 200 300 400 500 600 700 800 900]),
+      # font-kerning is SVG 2 / CSS Fonts Level 3, supported here for forwards compatibility
+      # since modern browsers have deprecated the SVG 1.1 kerning property.
+      'font-kerning'       => Config.new('auto', true, %w[auto normal none]),
+      'kerning'            => Config.new('auto', true, [:length, 'auto']),
+      'letter-spacing'     => Config.new('normal', true, [:length, 'normal']),
+      'word-spacing'       => Config.new('normal', true, [:length, 'normal']),
+      'marker-end'         => Config.new('none', true, [:funciri, 'none']),
+      'marker-mid'         => Config.new('none', true, [:funciri, 'none']),
+      'marker-start'       => Config.new('none', true, [:funciri, 'none']),
+      'mask'               => Config.new('none', false, [:funciri, 'none']),
+      'opacity'            => Config.new(1.0, false, [:number]),
+      'overflow'           => Config.new('visible', false, %w[visible hidden scroll auto]),
+      'stop-color'         => Config.new(Color.black, false, [:color_with_icc, 'currentcolor']),
+      'stop-opacity'       => Config.new(1.0, false, [:number]),
+      'stroke'             => Config.new(Paint.none, true, [:paint]),
+      'stroke-dasharray'   => Config.new('none', true, [:dasharray, 'none']),
+      'stroke-dashoffset'  => Config.new(0, true, [:length, :percentage]),
+      'stroke-linecap'     => Config.new('butt', true, %w[butt round square]),
+      'stroke-linejoin'    => Config.new('miter', true, %w[miter round bevel]),
+      'stroke-miterlimit'  => Config.new(4.0, true, [:positive_number]),
+      'stroke-opacity'     => Config.new(1.0, true, [:number]),
+      'stroke-width'       => Config.new(1.0, true, [:positive_length, :positive_percentage]),
+      'text-anchor'        => Config.new('start', true, %w[start middle end]),
+      'text-decoration'    => Config.new('none', true, [:text_decoration]),
+      'visibility'         => Config.new('visible', true, %w[visible hidden collapse]),
+      'writing-mode'       => Config.new('horizontal-tb', true, %w[horizontal-tb vertical-rl vertical-lr])
+    }.freeze
+
+    PROPERTIES.each do |name, value|
+      value.attr = name.gsub('-', '_')
+      value.id = value.attr.to_sym
+      value.ivar = "@#{value.attr}"
+    end
+
+    PROPERTY_CONFIGS = PROPERTIES.values
+    NAMES = PROPERTIES.keys
+    ATTR_NAMES = PROPERTIES.keys.map { |name| name.gsub('-', '_') }
+
+    attr_accessor(*ATTR_NAMES)
+    attr_reader :important_ids
+
+    def initialize
+      @numeric_font_size = EM
+      @important_ids = []
+    end
+
+    def load_default_stylesheet
+      PROPERTY_CONFIGS.each do |config|
+        instance_variable_set(config.ivar, config.default)
+      end
+
+      self
+    end
+
+    def set(name, value, important: false)
+      name = name.to_s.downcase
+      if (config = PROPERTIES[name])
+        if (value = parse_value(config, value.strip)) && (important || !@important_ids.include?(config.id))
+          @important_ids << config.id if important
+          instance_variable_set(config.ivar, value)
+        end
+      elsif name == 'font'
+        apply_font_shorthand(value)
+      elsif name == 'marker'
+        apply_marker_shorthand(value, important: important)
+      end
+    end
+
+    def numeric_font_size
+      @numeric_font_size or raise 'numeric_font_size not set; this is only present in computed properties'
+    end
+
+    def to_h
+      PROPERTIES.each.with_object({}) do |(name, config), result|
+        result[name] = instance_variable_get(config.ivar)
+      end
+    end
+
+    def load_hash(hash)
+      hash.each { |name, value| set(name, value) if value }
+    end
+
+    def compute_properties(other)
+      parent_font_stretch = @font_stretch_before_relative || font_stretch
+      parent_font_weight = font_weight
+
+      PROPERTY_CONFIGS.each do |config|
+        value = other.send(config.attr)
+
+        if value && value != 'inherit' && (!@important_ids.include?(config.id) || other.important_ids.include?(config.id))
+          instance_variable_set(config.ivar, value)
+
+        elsif value.nil? && !config.inheritable?
+          instance_variable_set(config.ivar, config.default)
+        end
+      end
+
+      if ['wider', 'narrower'].include?(font_stretch)
+        @font_stretch_before_relative ||= parent_font_stretch
+      else
+        @font_stretch_before_relative = nil
+      end
+
+      @font_stretch = resolve_font_stretch(parent_font_stretch)
+      @font_weight = resolve_font_weight(parent_font_weight)
+      @important_ids += other.important_ids
+      @numeric_font_size = calculate_numeric_font_size
+      nil
+    end
+
+    private
+
+    BOLDER_MAP = {
+      '100' => '400', '200' => '400', '300' => '400',
+      '400' => '700', '500' => '700',
+      '600' => '900', '700' => '900', '800' => '900', '900' => '900'
+    }.freeze
+
+    LIGHTER_MAP = {
+      '100' => '100', '200' => '100', '300' => '100',
+      '400' => '100', '500' => '100',
+      '600' => '400', '700' => '400',
+      '800' => '700', '900' => '700'
+    }.freeze
+
+    FONT_WEIGHT_TO_NUMERIC = {
+      'normal' => '400', 'bold' => '700'
+    }.freeze
+
+    def resolve_font_weight(parent_weight)
+      case font_weight
+      when 'bolder'
+        numeric = FONT_WEIGHT_TO_NUMERIC[parent_weight] || parent_weight || '400'
+        BOLDER_MAP[numeric] || '900'
+      when 'lighter'
+        numeric = FONT_WEIGHT_TO_NUMERIC[parent_weight] || parent_weight || '400'
+        LIGHTER_MAP[numeric] || '100'
+      else
+        font_weight
+      end
+    end
+
+    def resolve_font_stretch(parent_stretch)
+      case font_stretch
+      when 'wider'
+        index = STRETCH_ORDER.index(parent_stretch || 'normal') || 4
+        STRETCH_ORDER[[index + 1, STRETCH_ORDER.length - 1].min]
+      when 'narrower'
+        index = STRETCH_ORDER.index(parent_stretch || 'normal') || 4
+        STRETCH_ORDER[[index - 1, 0].max]
+      else
+        font_stretch
+      end
+    end
+
+    def calculate_numeric_font_size
+      case font_size
+      when Length
+        font_size.to_pixels(nil, numeric_font_size)
+      when Percentage
+        font_size.to_factor * numeric_font_size
+      when Numeric
+        font_size
+      when 'larger'
+        numeric_font_size + 4
+      when 'smaller'
+        numeric_font_size - 4
+      when nil, 'inherit'
+        numeric_font_size
+      when String
+        FONT_SIZES[font_size] or raise "Unknown font size keyword: #{font_size}"
+      else
+        raise "Unknown font size property value: #{font_size.inspect}"
+      end
+    end
+
+    def parse_value(config, value)
+      keyword = value.downcase
+
+      return 'inherit' if keyword == 'inherit'
+
+      config.valid_values.detect do |type|
+        result = parse_value_with_type(type, value, keyword)
+        break result if result
+      end
+    end
+
+    def parse_value_with_type(type, value, keyword)
+      case type
+      when String
+        keyword if type == keyword
+      when :color
+        values = Prawn::SVG::CSS::ValuesParser.parse(value)
+        Prawn::SVG::Color.parse(values[0]) if values.length == 1
+      when :color_with_icc
+        case Prawn::SVG::CSS::ValuesParser.parse(value)
+        in [other, ['icc-color', _args]]
+          Prawn::SVG::Color.parse(other)
+        in [other] # rubocop:disable Lint/DuplicateBranch
+          Prawn::SVG::Color.parse(other)
+        else
+          nil
+        end
+      when :paint
+        Paint.parse(value)
+      when :funciri
+        FuncIRI.parse(value)
+      when :dasharray
+        value.split(Prawn::SVG::Elements::COMMA_WSP_REGEXP).map do |value|
+          Length.parse(value) || Percentage.parse(value) || break
+        end
+      when :number
+        Float(value, exception: false)
+      when :length
+        Length.parse(value)
+      when :percentage
+        Percentage.parse(value)
+      when :positive_number
+        value = Float(value, exception: false)
+        value if value && value >= 1
+      when :positive_length
+        Length.parse(value, positive_only: true)
+      when :positive_percentage
+        Percentage.parse(value, positive_only: true)
+      when :text_decoration
+        parts = keyword.split
+        valid = %w[none underline overline line-through]
+        return nil unless parts.all? { |p| valid.include?(p) }
+        return 'none' if parts.include?('none')
+
+        parts.uniq.sort.join(' ')
+      when :any
+        value
+      else
+        raise "Unknown valid value type: #{type}"
+      end
+    end
+
+    FONT_KEYWORD_MAPPING = ['font-style', 'font-variant', 'font-weight'].each.with_object({}) do |property, result|
+      PROPERTIES[property].valid_values.each do |value|
+        result[value] = property
+      end
+    end
+
+    def apply_font_shorthand(value)
+      if value.strip.match(/\s/).nil?
+        case value.strip.downcase
+        when 'inherit'
+          load_hash('font-style' => 'inherit', 'font-variant' => 'inherit', 'font-weight' => 'inherit',
+            'font-stretch' => 'inherit', 'font-size' => 'inherit', 'font-family' => 'inherit')
+        when 'caption', 'icon', 'menu', 'message-box', 'small-caption', 'status-bar'
+          load_hash('font-style' => 'normal', 'font-variant' => 'normal', 'font-weight' => 'normal',
+            'font-stretch' => 'normal', 'font-size' => 'medium', 'font-family' => 'sans-serif')
+        end
+
+        return
+      end
+
+      properties = ['font-style', 'font-variant', 'font-weight', 'font-stretch'].each.with_object({}) do |property, result|
+        result[property] = PROPERTIES[property].default
+      end
+
+      values = CSS::FontParser.parse(value)
+      return if values.length < 2
+
+      properties['font-family'] = values.pop
+      font_size = values.pop.sub(%r{/.*}, '')
+
+      values.each do |keyword|
+        keyword = keyword.downcase
+        if (property = FONT_KEYWORD_MAPPING[keyword])
+          properties[property] = keyword
+        else
+          break
+        end
+      end or return
+
+      set('font-size', font_size) or return
+      load_hash(properties)
+      value
+    end
+
+    def apply_marker_shorthand(value, important: false)
+      %w[marker-start marker-mid marker-end].each do |property|
+        set(property, value, important: important)
+      end
+    end
+  end
+end

data/lib/prawn/svg/renderer.rb

@@ -0,0 +1,249 @@
+module Prawn
+  module SVG
+    class Renderer
+      attr_reader :prawn, :document, :options
+
+      #
+      # Creates a Prawn::SVG object.
+      #
+      # +data+ is the SVG data to convert.  +prawn+ is your Prawn::Document object.
+      #
+      # See README.md for the options that can be passed to this method.
+      #
+      def initialize(prawn, document, options)
+        @prawn = prawn
+        @document = document
+        @options = options
+      end
+
+      #
+      # Draws the SVG to the Prawn::Document object.
+      #
+      def draw
+        if sizing.invalid?
+          document.warnings << 'Zero or negative sizing data means this SVG cannot be rendered'
+          return
+        end
+
+        document.warnings.clear
+
+        prawn.save_font do
+          prawn.bounding_box(position, width: sizing.output_width, height: sizing.output_height) do
+            prawn.save_graphics_state do
+              clip_rectangle 0, 0, sizing.output_width, sizing.output_height
+
+              calls = []
+              root_element = Prawn::SVG::Elements::Root.new(document, document.root, calls)
+              root_element.process
+
+              proc_creator(prawn, calls).call
+            end
+          end
+        end
+      end
+
+      def sizing
+        document.sizing
+      end
+
+      def position
+        options[:at] || [x_based_on_requested_alignment, y_based_on_requested_alignment]
+      end
+
+      def render_calls(prawn, calls)
+        issue_prawn_command(prawn, calls)
+      end
+
+      private
+
+      def x_based_on_requested_alignment
+        case options[:position]
+        when :left, nil
+          0
+        when :center, :centre
+          (sizing.bounds[0] - sizing.output_width) / 2.0
+        when :right
+          sizing.bounds[0] - 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
+          sizing.bounds[1]
+        when :center, :centre
+          sizing.bounds[1] - ((sizing.bounds[1] - sizing.output_height) / 2.0)
+        when :bottom
+          sizing.output_height
+        when Numeric
+          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 { issue_prawn_command(prawn, calls) }
+      end
+
+      def issue_prawn_command(prawn, calls)
+        calls.each do |call, arguments, kwarguments, children|
+          skip = false
+
+          rewrite_call_arguments(prawn, call, arguments, kwarguments, children) do
+            issue_prawn_command(prawn, children) if children.any?
+            skip = true
+          end
+
+          if skip
+            # the call has been overridden
+          elsif children.empty? && call != 'transparent' # some prawn calls complain if they aren't supplied a block
+            if kwarguments.empty?
+              prawn.send(call, *arguments)
+            else
+              prawn.send(call, *arguments, **kwarguments)
+            end
+          elsif kwarguments.empty?
+            prawn.send(call, *arguments, &proc_creator(prawn, children))
+          else
+            prawn.send(call, *arguments, **kwarguments, &proc_creator(prawn, children))
+          end
+        end
+      end
+
+      def rewrite_call_arguments(prawn, call, arguments, kwarguments, children)
+        case call
+        when 'svg:render'
+          element = arguments.first
+          raise ArgumentError, "Expected a Prawn::SVG::Elements::DirectRenderBase, got #{element.class}" unless element.is_a?(Prawn::SVG::Elements::DirectRenderBase)
+
+          begin
+            element.render(prawn, self)
+          rescue Prawn::SVG::Elements::Base::SkipElementQuietly
+          rescue Prawn::SVG::Elements::Base::SkipElementError => e
+            @document.warnings << e.message
+          end
+
+          yield
+
+        when 'svg:yield'
+          block = arguments.first
+          block.call
+          yield
+
+        when 'transformation_matrix'
+          left = prawn.bounds.absolute_left
+          top = prawn.bounds.absolute_top
+          arguments[4] += left - ((left * arguments[0]) + (top * arguments[2]))
+          arguments[5] += top - ((left * arguments[1]) + (top * arguments[3]))
+
+        when 'curve_to'
+          # Prawn appends the destination to bounds, mutating bounds.
+          # Preserve it for path replay by passing a .dup instead.
+          # See: https://github.com/prawnpdf/prawn/issues/1401
+          prawn.curve_to(arguments.first, **kwarguments.merge(bounds: kwarguments[:bounds].dup))
+          yield
+
+        when 'miter_limit'
+          prawn.add_content("#{arguments.first} M")
+          yield
+
+        when 'clip'
+          even_odd = kwarguments[:clip_rule] == :even_odd
+          prawn.add_content(even_odd ? 'W* n' : 'W n')
+          yield
+
+        when 'save'
+          prawn.save_graphics_state
+          yield
+
+        when 'restore'
+          prawn.restore_graphics_state
+          yield
+
+        when 'end_path'
+          yield
+          prawn.add_content 'n' # end path
+
+        when 'fill_and_stroke'
+          yield
+          # Using separate fill and stroke operations instead of the combined B operator.
+          # Chromium's PDF renderer (PDFium) doesn't correctly apply stroke alpha (CA) with
+          # the B operator when fill and stroke have different opacities.
+          # Also avoids Prawn's 'b' which includes closepath (h) that breaks dashes and line caps.
+          even_odd = kwarguments[:fill_rule] == :even_odd
+          prawn.add_content(even_odd ? 'f*' : 'f')
+          issue_prawn_command(prawn, children)
+          prawn.add_content('S')
+
+        when 'noop'
+          yield
+
+        when 'svg:render_sub_document'
+          sub_document = arguments.first
+          sub_options = inheritable_options.merge({ at: [0, 0] })
+
+          Renderer.new(prawn, sub_document, sub_options).draw
+          document.warnings.concat(sub_document.warnings)
+          yield
+
+        when 'soft_mask'
+          with_large_page_dimensions(prawn) do
+            prawn.soft_mask do
+              issue_prawn_command(prawn, children) if children.any?
+            end
+          end
+          # Clear children so issue_prawn_command doesn't re-process them
+          # after soft_mask has already rendered them above.
+          children.clear
+          yield
+
+        when 'svg:render_gradient'
+          type = arguments.first
+          GradientRenderer.new(prawn, type, **kwarguments).draw
+          yield
+
+        when 'svg:render_pattern'
+          type = arguments[0]
+          PatternRenderer.new(prawn, type, self, **kwarguments).draw
+          yield
+
+        when 'svg:add_link'
+          LinkRenderer.new(*arguments).render(prawn)
+          yield
+        end
+      end
+
+      # Prawn's soft_mask hardcodes BBox to page.dimensions, which causes
+      # Chrome and Firefox to clip mask content that extends beyond the page.
+      # Temporarily override dimensions to use a large BBox.
+      def with_large_page_dimensions(prawn)
+        page = prawn.state.page
+        large_bbox = [-10_000, -10_000, 10_000, 10_000]
+        page.define_singleton_method(:dimensions) { large_bbox }
+        yield
+      ensure
+        page.singleton_class.remove_method(:dimensions)
+      end
+
+      def inheritable_options
+        (options || {}).slice(Prawn::SVG::Interface::INHERITABLE_OPTIONS)
+      end
+
+      def clip_rectangle(x, y, width, height)
+        prawn.move_to x, y
+        prawn.line_to x + width, y
+        prawn.line_to x + width, y + height
+        prawn.line_to x, y + height
+        prawn.close_path
+        prawn.add_content 'W n' # clip to path
+      end
+    end
+  end
+end

data/lib/prawn/svg/state.rb

@@ -0,0 +1,24 @@
+class Prawn::SVG::State
+  attr_accessor :text, :preserve_space,
+    :opacity, :last_fill_opacity, :last_stroke_opacity,
+    :stroke_width,
+    :computed_properties,
+    :viewport_sizing,
+    :inside_use, :inside_clip_path, :anchor_href
+
+  def initialize
+    @stroke_width = 1
+    @opacity = 1
+    @last_fill_opacity = 1
+    @last_stroke_opacity = 1
+    @computed_properties = Prawn::SVG::Properties.new.load_default_stylesheet
+  end
+
+  def initialize_dup(_other)
+    @computed_properties = @computed_properties.dup
+  end
+
+  def disable_drawing
+    inside_clip_path
+  end
+end

data/lib/prawn/svg/transform_parser.rb

@@ -0,0 +1,78 @@
+module Prawn::SVG::TransformParser
+  include Prawn::SVG::PDFMatrix
+
+  def parse_transform_attribute(transform, space: :pdf)
+    matrix = Matrix.identity(3)
+
+    flip = space == :svg ? 1.0 : -1.0
+
+    parse_css_method_calls(transform).each do |name, arguments|
+      case name
+      when 'translate'
+        x, y = arguments
+        matrix *= translation_matrix(x_pixels(x.to_f), flip * y_pixels(y.to_f))
+
+      when 'translateX'
+        x = arguments.first
+        matrix *= translation_matrix(x_pixels(x.to_f), 0.0)
+
+      when 'translateY'
+        y = arguments.first
+        matrix *= translation_matrix(0.0, flip * y_pixels(y.to_f))
+
+      when 'rotate'
+        angle, x, y = arguments.collect(&:to_f)
+        angle = angle * Math::PI / 180.0
+
+        rotation = rotation_matrix(angle, space: space)
+
+        case arguments.length
+        when 1
+          matrix *= rotation
+        when 3
+          matrix *= translation_matrix(x_pixels(x.to_f), flip * y_pixels(y.to_f))
+          matrix *= rotation
+          matrix *= translation_matrix(-x_pixels(x.to_f), -flip * y_pixels(y.to_f))
+        else
+          warnings << "transform 'rotate' must have either one or three arguments"
+        end
+
+      when 'scale'
+        x_scale = arguments[0].to_f
+        y_scale = (arguments[1] || x_scale).to_f
+        matrix *= scale_matrix(x_scale, y_scale)
+
+      when 'skewX'
+        angle = arguments[0].to_f * Math::PI / 180.0
+        matrix *= Matrix[[1, flip * Math.tan(angle), 0], [0, 1, 0], [0, 0, 1]]
+
+      when 'skewY'
+        angle = arguments[0].to_f * Math::PI / 180.0
+        matrix *= Matrix[[1, 0, 0], [flip * Math.tan(angle), 1, 0], [0, 0, 1]]
+
+      when 'matrix'
+        if arguments.length == 6
+          a, b, c, d, e, f = arguments.collect(&:to_f)
+          matrix *= Matrix[[a, flip * c, e], [flip * b, d, flip * f], [0, 0, 1]]
+        else
+          warnings << "transform 'matrix' must have six arguments"
+        end
+
+      else
+        warnings << "Unknown/unsupported transformation '#{name}'; ignoring"
+      end
+    end
+
+    matrix
+  end
+
+  private
+
+  def parse_css_method_calls(string)
+    string.scan(/\s*(\w+)\(([^)]+)\)\s*/).collect do |call|
+      name, argument_string = call
+      arguments = argument_string.strip.split(/\s*[,\s]\s*/)
+      [name, arguments]
+    end
+  end
+end