prawnx 0.1.1

data/lib/prawn/svg/paint.rb

@@ -0,0 +1,67 @@
+module Prawn::SVG
+  Paint = Struct.new(:color, :url) do
+    class << self
+      def none
+        new(:none, nil)
+      end
+
+      def black
+        new(Color.black, nil)
+      end
+
+      def parse(value)
+        case CSS::ValuesParser.parse(value)
+        in [['url', [url]]]
+          # If there is no fallback color, and the URL is unresolvable, the spec says that the document is in error.
+          # Chrome appears to treat this the same as an explicit 'none', so we do the same.
+          new(:none, url)
+        in [['url', [url]], keyword_or_color]
+          parse_keyword_or_color(keyword_or_color, url)
+        in [['url', [url]], keyword_or_color, ['icc-color', _args]] # rubocop:disable Lint/DuplicateBranch
+          parse_keyword_or_color(keyword_or_color, url)
+        in [keyword_or_color, ['icc-color', _args]]
+          parse_keyword_or_color(keyword_or_color, nil)
+        in [keyword_or_color] # rubocop:disable Lint/DuplicateBranch
+          parse_keyword_or_color(keyword_or_color, nil)
+        else
+          nil
+        end
+      end
+
+      private
+
+      def parse_keyword_or_color(value, url)
+        if value.is_a?(String)
+          keyword = value.downcase
+          return new(keyword.to_sym, url) if ['none', 'currentcolor'].include?(keyword)
+        end
+
+        color = Color.parse(value)
+        new(color, url) if color
+      end
+    end
+
+    def none?
+      color == :none && (url.nil? || !!@unresolved_url)
+    end
+
+    def resolve(gradients, current_color, color_mode)
+      if url
+        if url[0] == '#' && gradients && (gradient = gradients[url[1..]])
+          return gradient
+        else
+          @unresolved_url = true
+        end
+      end
+
+      case color
+      when :currentcolor
+        current_color
+      when :none
+        nil
+      else
+        color_mode == :cmyk ? color.to_cmyk : color
+      end
+    end
+  end
+end

data/lib/prawn/svg/pathable.rb

@@ -0,0 +1,153 @@
+module Prawn::SVG::Pathable
+  Move = Struct.new(:destination)
+  Close = Struct.new(:destination)
+  Line = Struct.new(:destination)
+  Curve = Struct.new(:destination, :point1, :point2)
+
+  def bounding_box
+    points = commands.map { |command| translate(command.destination) }
+    x1, x2 = points.map(&:first).minmax
+    y2, y1 = points.map(&:last).minmax
+
+    [x1, y1, x2, y2]
+  end
+
+  protected
+
+  def apply_commands
+    commands.each do |command|
+      case command
+      when Move
+        add_call 'move_to', translate(command.destination)
+      when Close
+        add_call 'close_path'
+      when Line
+        add_call 'line_to', translate(command.destination)
+      when Curve
+        add_call 'curve_to', translate(command.destination),
+          bounds: [translate(command.point1), translate(command.point2)]
+      else
+        raise NotImplementedError, 'Unknown path command type'
+      end
+    end
+  end
+
+  def apply_markers
+    if (marker = extract_element_from_url_id_reference(properties.marker_start, 'marker'))
+      marker.apply_marker(self, point: commands.first.destination, angle: angles.first)
+    end
+
+    if (marker = extract_element_from_url_id_reference(properties.marker_mid, 'marker'))
+      (1..commands.length - 2).each do |index|
+        marker.apply_marker(self, point: commands[index].destination, angle: angles[index])
+      end
+    end
+
+    if (marker = extract_element_from_url_id_reference(properties.marker_end, 'marker'))
+      marker.apply_marker(self, point: commands.last.destination, angle: angles.last)
+    end
+  end
+
+  def angles
+    return @angles if @angles
+
+    last_point = nil
+
+    destination_angles = commands.map do |command|
+      angles =
+        case command
+        when Move
+          [nil, nil]
+        when Close, Line
+          angle = Math.atan2(command.destination[1] - last_point[1],
+            command.destination[0] - last_point[0]) * 180.0 / Math::PI
+          [angle, angle]
+        when Curve
+          point = select_non_equal_point(last_point, command.point1, command.point2, command.destination)
+          start = Math.atan2(point[1] - last_point[1], point[0] - last_point[0]) * 180.0 / Math::PI
+
+          point = select_non_equal_point(command.destination, command.point2, command.point1, last_point)
+          stop = Math.atan2(command.destination[1] - point[1],
+            command.destination[0] - point[0]) * 180.0 / Math::PI
+
+          [start, stop]
+        else
+          raise NotImplementedError, 'Unknown path command type'
+        end
+
+      last_point = command.destination
+      angles
+    end
+
+    angles = destination_angles.each_cons(2).map do |first_angles, second_angles|
+      if first_angles.first.nil?
+        second_angles.first || 0
+      elsif second_angles.first.nil?
+        first_angles.last
+      else
+        first = first_angles.last
+        second = second_angles.last
+        bisect = (first + second) / 2.0
+
+        if (first - second).abs > 180
+          bisect >= 0 ? bisect - 180 : bisect + 180
+        else
+          bisect
+        end
+      end
+    end
+
+    if commands.last.is_a?(Close)
+      first = destination_angles.last.last || 0
+      second = angles.first
+      bisect = (first + second) / 2.0
+
+      closing_angle = if (first - second).abs > 180
+                        bisect >= 0 ? bisect - 180 : bisect + 180
+                      else
+                        bisect
+                      end
+
+      angles[0] = closing_angle
+      angles << closing_angle
+    else
+      angles << destination_angles.last.last
+    end
+
+    @angles = angles
+  end
+
+  def parse_points(points_string)
+    values = points_string
+             .to_s
+             .strip
+             .gsub(/(\d)-(\d)/, '\1 -\2')
+             .split(Prawn::SVG::Elements::COMMA_WSP_REGEXP)
+             .map(&:to_f)
+
+    if values.length.odd?
+      document.warnings << 'points attribute has an odd number of points; ignoring the last one'
+      values.pop
+    end
+
+    raise Prawn::SVG::Elements::Base::SkipElementQuietly if values.empty?
+
+    values.each_slice(2).to_a
+  end
+
+  def translate(point)
+    [point[0].to_f, document.sizing.output_height - point[1].to_f]
+  end
+
+  private
+
+  def select_non_equal_point(base, point_a, point_b, point_c)
+    if point_a != base
+      point_a
+    elsif point_b != base
+      point_b
+    else
+      point_c
+    end
+  end
+end

data/lib/prawn/svg/pattern_renderer.rb

@@ -0,0 +1,112 @@
+class Prawn::SVG::PatternRenderer
+  include Prawn::SVG::PDFMatrix
+
+  def initialize(prawn, draw_type, renderer, tile_x:, tile_y:, tile_width:, tile_height:, transform:, calls:)
+    @prawn = prawn
+    @draw_type = draw_type
+    @renderer = renderer
+    @tile_x = tile_x
+    @tile_y = tile_y
+    @tile_width = tile_width
+    @tile_height = tile_height
+    @transform = transform
+    @calls = calls
+  end
+
+  def draw
+    key = Prawn::SVG::GradientRenderer.next_key
+
+    pattern_ref = create_tiling_pattern(key)
+
+    prawn.page.resources[:Pattern] ||= {}
+    prawn.page.resources[:Pattern]["PSVG-Pattern-#{key}"] = pattern_ref
+
+    prawn.send(:set_color_space, draw_type, :Pattern)
+    draw_operator = draw_type == :fill ? 'scn' : 'SCN'
+    prawn.renderer.add_content("/PSVG-Pattern-#{key} #{draw_operator}")
+  end
+
+  private
+
+  attr_reader :prawn, :draw_type, :renderer, :tile_x, :tile_y, :tile_width, :tile_height, :transform, :calls
+
+  def create_tiling_pattern(key)
+    stamp_name = "PSVG-PatternContent-#{key}"
+
+    prawn.create_stamp(stamp_name) do
+      renderer.render_calls(prawn, calls)
+    end
+
+    registry = prawn.instance_variable_get(:@stamp_dictionary_registry)
+    stamp_entry = registry[stamp_name]
+    stamp_dict = stamp_entry[:stamp_dictionary]
+
+    # The content shift uses the base matrix (without patternTransform) so that
+    # content fills the tile correctly. The pattern Matrix includes the transform
+    # so the tiling grid is rotated/scaled, but each tile's content is not.
+    base = base_pattern_matrix
+    inverse = base.inverse
+
+    pattern_ref = prawn.ref!(
+      PatternType: 1,
+      PaintType:   1,
+      TilingType:  1,
+      BBox:        [0, 0, tile_width, tile_height],
+      XStep:       tile_width,
+      YStep:       tile_height,
+      Matrix:      matrix_for_pdf(full_pattern_matrix),
+      Resources:   stamp_dict.data[:Resources] || {}
+    )
+
+    inv_pdf = matrix_for_pdf(inverse)
+    cm_str = inv_pdf.map { |v| v.is_a?(Float) ? format('%.6f', v) : v.to_s }.join(' ')
+    pattern_ref.stream << "#{cm_str} cm\n"
+    pattern_ref.stream << stamp_dict.stream
+
+    registry.delete(stamp_name)
+
+    pattern_ref
+  end
+
+  def svg_to_page_matrix
+    bounds_x, bounds_y = prawn.bounds.anchor
+    output_height = prawn.bounds.height
+
+    Matrix[
+      [1.0, 0.0, bounds_x.to_f],
+      [0.0, -1.0, bounds_y.to_f + output_height],
+      [0.0, 0.0, 1.0]
+    ]
+  end
+
+  def pattern_to_svg_matrix
+    output_height = prawn.bounds.height
+    svg_x = tile_x.to_f
+    svg_y = (output_height - tile_y - tile_height).to_f
+
+    Matrix[
+      [1.0, 0.0, svg_x],
+      [0.0, -1.0, svg_y + tile_height],
+      [0.0, 0.0, 1.0]
+    ]
+  end
+
+  # Maps pattern space to page space WITHOUT patternTransform.
+  # Used to shift stamp content (in page coords) to pattern-local coords.
+  def base_pattern_matrix
+    svg_to_page_matrix * pattern_to_svg_matrix
+  end
+
+  # Maps pattern space to page space WITH patternTransform and viewport scaling.
+  # Used as the pattern's Matrix field so the tiling grid is transformed.
+  # Viewport scaling is needed because stamp content is in SVG user units,
+  # but shapes on the page are scaled by the document's viewport transform.
+  def full_pattern_matrix
+    viewport_scale = scale_matrix(sizing.x_scale, sizing.y_scale)
+    svg_to_page_matrix * viewport_scale * transform * pattern_to_svg_matrix
+  end
+
+  def sizing
+    renderer.document.sizing
+  end
+end

data/lib/prawn/svg/pdfmatrix.rb

@@ -0,0 +1,37 @@
+module Prawn::SVG::PDFMatrix
+  def load_matrix(matrix)
+    if matrix.is_a?(Matrix) && matrix.row_count == 3 && matrix.column_count == 3
+      matrix
+    elsif matrix.is_a?(Array) && matrix.length == 6
+      Matrix[
+        [matrix[0], matrix[2], matrix[4]],
+        [matrix[1], matrix[3], matrix[5]],
+        [0.0, 0.0, 1.0]
+      ]
+    else
+      raise ArgumentError, 'unexpected matrix format'
+    end
+  end
+
+  def matrix_for_pdf(matrix)
+    matrix.to_a[0..1].transpose.flatten
+  end
+
+  def translation_matrix(x = 0, y = 0)
+    Matrix[[1.0, 0.0, x.to_f], [0.0, 1.0, y.to_f], [0.0, 0.0, 1.0]]
+  end
+
+  def scale_matrix(x = 1, y = x)
+    Matrix[[x.to_f, 0.0, 0.0], [0.0, y.to_f, 0.0], [0.0, 0.0, 1.0]]
+  end
+
+  def rotation_matrix(angle, space: :pdf)
+    dir = space == :svg ? 1.0 : -1.0
+
+    Matrix[
+      [Math.cos(angle), -dir * Math.sin(angle), 0],
+      [dir * Math.sin(angle), Math.cos(angle), 0],
+      [0, 0, 1]
+    ]
+  end
+end

data/lib/prawn/svg/percentage.rb

@@ -0,0 +1,24 @@
+Prawn::SVG::Percentage = Struct.new(:value)
+
+class Prawn::SVG::Percentage
+  REGEXP = /\A([+-]?\d*(?:\.\d+)?)%\z/i.freeze
+
+  def self.parse(value, positive_only: false)
+    if (matches = value.match(REGEXP))
+      number = Float(matches[1], exception: false)
+      new(number) if number && (!positive_only || number >= 0)
+    end
+  end
+
+  def to_f
+    value
+  end
+
+  def to_factor
+    value / 100.0
+  end
+
+  def to_pixels(axis_length, _font_size)
+    value * axis_length / 100.0
+  end
+end