gamba 2.0.0

data/lib/prawn/svg/calculators/document_sizing.rb

@@ -0,0 +1,103 @@
+module Prawn::SVG::Calculators
+  class DocumentSizing
+    DEFAULT_ASPECT_RATIO = "xMidYMid meet".freeze
+
+    attr_writer :document_width, :document_height
+    attr_writer :view_box, :preserve_aspect_ratio
+
+    attr_reader :bounds
+    attr_reader :x_offset, :y_offset, :x_scale, :y_scale
+    attr_reader :viewport_width, :viewport_height, :viewport_diagonal, :output_width, :output_height
+
+    def initialize(bounds, attributes = nil)
+      @bounds = bounds
+      set_from_attributes(attributes) if attributes
+    end
+
+    def set_from_attributes(attributes)
+      @document_width = attributes["width"]
+      @document_height = attributes["height"]
+      @view_box = attributes["viewBox"]
+      @preserve_aspect_ratio = attributes["preserveAspectRatio"] || DEFAULT_ASPECT_RATIO
+    end
+
+    def calculate
+      @x_offset = @y_offset = 0
+      @x_scale = @y_scale = 1
+
+      container_width = @requested_width || @bounds[0]
+      container_height = @requested_height || @bounds[1]
+
+      @output_width = Pixels::Measurement.to_pixels(@document_width || @requested_width, container_width)
+      @output_height = Pixels::Measurement.to_pixels(@document_height || @requested_height, container_height)
+
+      if @view_box
+        values = @view_box.strip.split(Prawn::SVG::Elements::COMMA_WSP_REGEXP)
+        @x_offset, @y_offset, @viewport_width, @viewport_height = values.map(&:to_f)
+
+        if @viewport_width.positive? && @viewport_height.positive?
+          # If neither the width nor height was specified, use the entire width and the viewbox ratio
+          # to determine the height.
+          @output_width = container_width if @output_width.nil? && @output_height.nil?
+
+          # If one of the output dimensions is missing, calculate it from the other one
+          # using the ratio of the viewport width to height.
+          @output_width ||= @output_height * @viewport_width / @viewport_height
+          @output_height ||= @output_width * @viewport_height / @viewport_width
+
+          aspect = AspectRatio.new(@preserve_aspect_ratio, [@output_width, @output_height],
+            [@viewport_width, @viewport_height])
+          @x_scale = aspect.width / @viewport_width
+          @y_scale = aspect.height / @viewport_height
+          @x_offset -= aspect.x / @x_scale
+          @y_offset -= aspect.y / @y_scale
+        end
+      else
+        @output_width ||= container_width
+        @output_height ||= container_height
+
+        @viewport_width = @output_width
+        @viewport_height = @output_height
+      end
+
+      return if invalid?
+
+      # SVG 1.1 section 7.10
+      @viewport_diagonal = Math.sqrt((@viewport_width**2) + (@viewport_height**2)) / Math.sqrt(2)
+
+      if @requested_width
+        scale = @requested_width / @output_width
+        @output_width = @requested_width
+        @output_height *= scale
+        @x_scale *= scale
+        @y_scale *= scale
+
+      elsif @requested_height
+        scale = @requested_height / @output_height
+        @output_height = @requested_height
+        @output_width *= scale
+        @x_scale *= scale
+        @y_scale *= scale
+      end
+
+      self
+    end
+
+    def invalid?
+      @viewport_width <= 0 ||
+        @viewport_height <= 0 ||
+        @output_width <= 0 ||
+        @output_height <= 0 ||
+        (@requested_width && @requested_width <= 0) ||
+        (@requested_height && @requested_height <= 0)
+    end
+
+    def requested_width=(value)
+      @requested_width = value&.to_f
+    end
+
+    def requested_height=(value)
+      @requested_height = value&.to_f
+    end
+  end
+end

data/lib/prawn/svg/calculators/path_length.rb

@@ -0,0 +1,168 @@
+module Prawn::SVG::Calculators
+  class PathLength
+    Segment = Data.define(:start_point, :end_point, :type, :control_points, :segment_length, :cumulative_length, :lookup_table)
+
+    SUBDIVISION_TOLERANCE = 0.01
+    LOOKUP_TABLE_STEPS = 64
+
+    attr_reader :total_length
+
+    def initialize(commands)
+      @segments = []
+      @total_length = 0.0
+
+      current_point = nil
+      subpath_start = nil
+
+      commands.each do |command|
+        case command
+        when Prawn::SVG::Pathable::Move
+          current_point = command.destination
+          subpath_start = current_point
+
+        when Prawn::SVG::Pathable::Close
+          if current_point && subpath_start && current_point != subpath_start
+            add_line_segment(current_point, subpath_start)
+            current_point = subpath_start
+          end
+
+        when Prawn::SVG::Pathable::Line
+          if current_point
+            add_line_segment(current_point, command.destination)
+            current_point = command.destination
+          end
+
+        when Prawn::SVG::Pathable::Curve
+          if current_point
+            add_curve_segment(current_point, command.point1, command.point2, command.destination)
+            current_point = command.destination
+          end
+        end
+      end
+    end
+
+    def point_at(distance)
+      return nil if distance.negative? || distance > @total_length || @segments.empty?
+
+      @segments.each do |segment|
+        start_distance = segment.cumulative_length - segment.segment_length
+
+        next unless distance <= segment.cumulative_length
+
+        local_distance = distance - start_distance
+
+        case segment.type
+        when :line
+          t = segment.segment_length.positive? ? local_distance / segment.segment_length : 0.0
+          x = segment.start_point[0] + (t * (segment.end_point[0] - segment.start_point[0]))
+          y = segment.start_point[1] + (t * (segment.end_point[1] - segment.start_point[1]))
+          dx = segment.end_point[0] - segment.start_point[0]
+          dy = segment.end_point[1] - segment.start_point[1]
+          angle = Math.atan2(dy, dx) * 180.0 / Math::PI
+          return [x, y, angle]
+
+        when :curve
+          t = find_t_for_distance(segment, local_distance)
+          p0, p1, p2, p3 = segment.start_point, *segment.control_points, segment.end_point
+          x, y = evaluate_cubic(p0, p1, p2, p3, t)
+          dx, dy = evaluate_cubic_derivative(p0, p1, p2, p3, t)
+          angle = Math.atan2(dy, dx) * 180.0 / Math::PI
+          return [x, y, angle]
+        end
+      end
+
+      # Exactly at the end
+      segment = @segments.last
+      [segment.end_point[0], segment.end_point[1], end_angle(segment)]
+    end
+
+    private
+
+    def add_line_segment(start_point, end_point)
+      length = Math.sqrt(((end_point[0] - start_point[0])**2) + ((end_point[1] - start_point[1])**2))
+      @total_length += length
+      @segments << Segment.new(start_point, end_point, :line, nil, length, @total_length, nil)
+    end
+
+    def add_curve_segment(start_point, control1, control2, end_point)
+      lookup_table = build_lookup_table(start_point, control1, control2, end_point)
+      length = lookup_table.last
+      @total_length += length
+      @segments << Segment.new(start_point, end_point, :curve, [control1, control2], length, @total_length, lookup_table)
+    end
+
+    def build_lookup_table(p0, p1, p2, p3)
+      table = [0.0]
+      prev_point = p0
+      cumulative = 0.0
+
+      1.upto(LOOKUP_TABLE_STEPS) do |i|
+        t = i.to_f / LOOKUP_TABLE_STEPS
+        point = evaluate_cubic(p0, p1, p2, p3, t)
+        cumulative += Math.sqrt(((point[0] - prev_point[0])**2) + ((point[1] - prev_point[1])**2))
+        table << cumulative
+        prev_point = point
+      end
+
+      table
+    end
+
+    def find_t_for_distance(segment, target_distance)
+      table = segment.lookup_table
+      return 0.0 if target_distance <= 0
+      return 1.0 if target_distance >= segment.segment_length
+
+      # Binary search in the lookup table
+      low = 0
+      high = LOOKUP_TABLE_STEPS
+
+      while low < high - 1
+        mid = (low + high) / 2
+        if table[mid] < target_distance
+          low = mid
+        else
+          high = mid
+        end
+      end
+
+      # Linear interpolation between low and high
+      d_low = table[low]
+      d_high = table[high]
+      fraction = (d_high > d_low) ? (target_distance - d_low) / (d_high - d_low) : 0.0
+      (low + fraction) / LOOKUP_TABLE_STEPS
+    end
+
+    def evaluate_cubic(p0, p1, p2, p3, t)
+      mt = 1.0 - t
+      mt2 = mt * mt
+      mt3 = mt2 * mt
+      t2 = t * t
+      t3 = t2 * t
+
+      x = (mt3 * p0[0]) + (3 * mt2 * t * p1[0]) + (3 * mt * t2 * p2[0]) + (t3 * p3[0])
+      y = (mt3 * p0[1]) + (3 * mt2 * t * p1[1]) + (3 * mt * t2 * p2[1]) + (t3 * p3[1])
+      [x, y]
+    end
+
+    def evaluate_cubic_derivative(p0, p1, p2, p3, t)
+      mt = 1.0 - t
+
+      dx = (3 * mt * mt * (p1[0] - p0[0])) + (6 * mt * t * (p2[0] - p1[0])) + (3 * t * t * (p3[0] - p2[0]))
+      dy = (3 * mt * mt * (p1[1] - p0[1])) + (6 * mt * t * (p2[1] - p1[1])) + (3 * t * t * (p3[1] - p2[1]))
+      [dx, dy]
+    end
+
+    def end_angle(segment)
+      case segment.type
+      when :line
+        dx = segment.end_point[0] - segment.start_point[0]
+        dy = segment.end_point[1] - segment.start_point[1]
+        Math.atan2(dy, dx) * 180.0 / Math::PI
+      when :curve
+        p0, p1, p2, p3 = segment.start_point, *segment.control_points, segment.end_point
+        dx, dy = evaluate_cubic_derivative(p0, p1, p2, p3, 1.0)
+        Math.atan2(dy, dx) * 180.0 / Math::PI
+      end
+    end
+  end
+end

data/lib/prawn/svg/calculators/pixels.rb

@@ -0,0 +1,57 @@
+module Prawn::SVG::Calculators::Pixels
+  class Measurement
+    def self.to_pixels(value, axis_length = nil, font_size: Prawn::SVG::Properties::EM)
+      if value.respond_to?(:to_pixels)
+        value.to_pixels(axis_length, font_size)
+      elsif value.is_a?(String)
+        value = value.strip
+        value = Prawn::SVG::Length.parse(value) || Prawn::SVG::Percentage.parse(value)
+        value&.to_pixels(axis_length, font_size) || 0.0
+      elsif value
+        value.to_f
+      end
+    end
+  end
+
+  protected
+
+  def x(value)
+    x_pixels(value)
+  end
+
+  def y(value)
+    # This uses document.sizing, not state.viewport_sizing, because we always
+    # want to subtract from the total height of the document.
+    document.sizing.output_height - y_pixels(value)
+  end
+
+  def pixels(value)
+    value && Measurement.to_pixels(value, state.viewport_sizing.viewport_diagonal,
+      font_size: computed_properties.numeric_font_size)
+  end
+
+  def x_pixels(value)
+    value && Measurement.to_pixels(value, state.viewport_sizing.viewport_width,
+      font_size: computed_properties.numeric_font_size)
+  end
+
+  def y_pixels(value)
+    value && Measurement.to_pixels(value, state.viewport_sizing.viewport_height,
+      font_size: computed_properties.numeric_font_size)
+  end
+
+  def percentage_or_proportion(string, default = 0)
+    string = string.to_s.strip
+    percentage = false
+
+    if string[-1] == "%"
+      percentage = true
+      string = string[0..-2]
+    end
+
+    value = Float(string, exception: false)
+    return default unless value
+
+    percentage ? value / 100.0 : value
+  end
+end

data/lib/prawn/svg/color.rb

@@ -0,0 +1,240 @@
+class Prawn::SVG::Color
+  CMYK = Struct.new(:value) do
+    def to_cmyk
+      self
+    end
+  end
+
+  RGB = Struct.new(:value) do
+    def to_rgb
+      [value[0..1], value[2..3], value[4..5]].map { |h| h.to_i(16) / 255.0 }
+    end
+
+    def to_cmyk
+      r, g, b = rgb = to_rgb
+      k = 1 - rgb.max
+      if k == 1
+        CMYK.new([0, 0, 0, 100])
+      else
+        c = (1 - r - k) / (1 - k)
+        m = (1 - g - k) / (1 - k)
+        y = (1 - b - k) / (1 - k)
+        CMYK.new([c, m, y, k].map { |v| (v * 100).round })
+      end
+    end
+  end
+
+  RGB_DEFAULT_COLOR = RGB.new("000000")
+  CMYK_DEFAULT_COLOR = CMYK.new([0, 0, 0, 100])
+
+  HTML_COLORS = {
+    "aliceblue" => "f0f8ff",
+    "antiquewhite" => "faebd7",
+    "aqua" => "00ffff",
+    "aquamarine" => "7fffd4",
+    "azure" => "f0ffff",
+    "beige" => "f5f5dc",
+    "bisque" => "ffe4c4",
+    "black" => "000000",
+    "blanchedalmond" => "ffebcd",
+    "blue" => "0000ff",
+    "blueviolet" => "8a2be2",
+    "brown" => "a52a2a",
+    "burlywood" => "deb887",
+    "cadetblue" => "5f9ea0",
+    "chartreuse" => "7fff00",
+    "chocolate" => "d2691e",
+    "coral" => "ff7f50",
+    "cornflowerblue" => "6495ed",
+    "cornsilk" => "fff8dc",
+    "crimson" => "dc143c",
+    "cyan" => "00ffff",
+    "darkblue" => "00008b",
+    "darkcyan" => "008b8b",
+    "darkgoldenrod" => "b8860b",
+    "darkgray" => "a9a9a9",
+    "darkgreen" => "006400",
+    "darkgrey" => "a9a9a9",
+    "darkkhaki" => "bdb76b",
+    "darkmagenta" => "8b008b",
+    "darkolivegreen" => "556b2f",
+    "darkorange" => "ff8c00",
+    "darkorchid" => "9932cc",
+    "darkred" => "8b0000",
+    "darksalmon" => "e9967a",
+    "darkseagreen" => "8fbc8f",
+    "darkslateblue" => "483d8b",
+    "darkslategray" => "2f4f4f",
+    "darkslategrey" => "2f4f4f",
+    "darkturquoise" => "00ced1",
+    "darkviolet" => "9400d3",
+    "deeppink" => "ff1493",
+    "deepskyblue" => "00bfff",
+    "dimgray" => "696969",
+    "dimgrey" => "696969",
+    "dodgerblue" => "1e90ff",
+    "firebrick" => "b22222",
+    "floralwhite" => "fffaf0",
+    "forestgreen" => "228b22",
+    "fuchsia" => "ff00ff",
+    "gainsboro" => "dcdcdc",
+    "ghostwhite" => "f8f8ff",
+    "gold" => "ffd700",
+    "goldenrod" => "daa520",
+    "gray" => "808080",
+    "grey" => "808080",
+    "green" => "008000",
+    "greenyellow" => "adff2f",
+    "honeydew" => "f0fff0",
+    "hotpink" => "ff69b4",
+    "indianred" => "cd5c5c",
+    "indigo" => "4b0082",
+    "ivory" => "fffff0",
+    "khaki" => "f0e68c",
+    "lavender" => "e6e6fa",
+    "lavenderblush" => "fff0f5",
+    "lawngreen" => "7cfc00",
+    "lemonchiffon" => "fffacd",
+    "lightblue" => "add8e6",
+    "lightcoral" => "f08080",
+    "lightcyan" => "e0ffff",
+    "lightgoldenrodyellow" => "fafad2",
+    "lightgray" => "d3d3d3",
+    "lightgreen" => "90ee90",
+    "lightgrey" => "d3d3d3",
+    "lightpink" => "ffb6c1",
+    "lightsalmon" => "ffa07a",
+    "lightseagreen" => "20b2aa",
+    "lightskyblue" => "87cefa",
+    "lightslategray" => "778899",
+    "lightslategrey" => "778899",
+    "lightsteelblue" => "b0c4de",
+    "lightyellow" => "ffffe0",
+    "lime" => "00ff00",
+    "limegreen" => "32cd32",
+    "linen" => "faf0e6",
+    "magenta" => "ff00ff",
+    "maroon" => "800000",
+    "mediumaquamarine" => "66cdaa",
+    "mediumblue" => "0000cd",
+    "mediumorchid" => "ba55d3",
+    "mediumpurple" => "9370db",
+    "mediumseagreen" => "3cb371",
+    "mediumslateblue" => "7b68ee",
+    "mediumspringgreen" => "00fa9a",
+    "mediumturquoise" => "48d1cc",
+    "mediumvioletred" => "c71585",
+    "midnightblue" => "191970",
+    "mintcream" => "f5fffa",
+    "mistyrose" => "ffe4e1",
+    "moccasin" => "ffe4b5",
+    "navajowhite" => "ffdead",
+    "navy" => "000080",
+    "oldlace" => "fdf5e6",
+    "olive" => "808000",
+    "olivedrab" => "6b8e23",
+    "orange" => "ffa500",
+    "orangered" => "ff4500",
+    "orchid" => "da70d6",
+    "palegoldenrod" => "eee8aa",
+    "palegreen" => "98fb98",
+    "paleturquoise" => "afeeee",
+    "palevioletred" => "db7093",
+    "papayawhip" => "ffefd5",
+    "peachpuff" => "ffdab9",
+    "peru" => "cd853f",
+    "pink" => "ffc0cb",
+    "plum" => "dda0dd",
+    "powderblue" => "b0e0e6",
+    "purple" => "800080",
+    "red" => "ff0000",
+    "rosybrown" => "bc8f8f",
+    "royalblue" => "4169e1",
+    "saddlebrown" => "8b4513",
+    "salmon" => "fa8072",
+    "sandybrown" => "f4a460",
+    "seagreen" => "2e8b57",
+    "seashell" => "fff5ee",
+    "sienna" => "a0522d",
+    "silver" => "c0c0c0",
+    "skyblue" => "87ceeb",
+    "slateblue" => "6a5acd",
+    "slategray" => "708090",
+    "slategrey" => "708090",
+    "snow" => "fffafa",
+    "springgreen" => "00ff7f",
+    "steelblue" => "4682b4",
+    "tan" => "d2b48c",
+    "teal" => "008080",
+    "thistle" => "d8bfd8",
+    "tomato" => "ff6347",
+    "turquoise" => "40e0d0",
+    "violet" => "ee82ee",
+    "wheat" => "f5deb3",
+    "white" => "ffffff",
+    "whitesmoke" => "f5f5f5",
+    "yellow" => "ffff00",
+    "yellowgreen" => "9acd32"
+  }.freeze
+
+  class << self
+    def black
+      RGB_DEFAULT_COLOR
+    end
+
+    def parse(value)
+      case value
+      in ["rgb", args]
+        return unless args.length == 3
+
+        rgb =
+          args.map do |arg|
+            number = to_float(arg, 2.55) or break
+            format("%02x", number.round.clamp(0, 255))
+          end
+
+        rgb && RGB.new(rgb.join)
+
+      in ["device-cmyk", args]
+        return unless args.length == 4
+
+        cymk =
+          args.map do |arg|
+            number = to_float(arg, 0.01) or break
+            (number * 100).clamp(0, 100)
+          end
+
+        cymk && CMYK.new(cymk)
+
+      in /\A#([0-9a-f])([0-9a-f])([0-9a-f])\z/i
+        RGB.new("#{$1 * 2}#{$2 * 2}#{$3 * 2}")
+
+      in /\A#[0-9a-f]{6}\z/i
+        RGB.new(value[1..]) # rubocop:disable Performance/ArraySemiInfiniteRangeSlice -- String
+
+      in String => color
+        if (hex = HTML_COLORS[color.downcase])
+          RGB.new(hex)
+        end
+
+      else
+        nil
+      end
+    end
+
+    def default_color(color_mode)
+      (color_mode == :cmyk) ? CMYK_DEFAULT_COLOR : RGB_DEFAULT_COLOR
+    end
+
+    private
+
+    def to_float(string, percentage_multiplier)
+      if string[-1] == "%"
+        number = Float(string[0..-2], exception: false)
+        number && (number * percentage_multiplier)
+      else
+        Float(string, exception: false)
+      end
+    end
+  end
+end

data/lib/prawn/svg/css/font_face_parser.rb

@@ -0,0 +1,72 @@
+module Prawn::SVG::CSS
+  class FontFaceParser
+    SUPPORTED_FORMATS = %w[truetype opentype].freeze
+
+    class << self
+      def parse_src(src)
+        split_sources(src).filter_map { |entry| parse_source_entry(entry.strip) }
+      end
+
+      private
+
+      def split_sources(value)
+        entries = []
+        current = +""
+        depth = 0
+        in_quote = nil
+
+        value.each_char do |char|
+          if in_quote
+            current << char
+            in_quote = nil if char == in_quote
+          elsif ['"', "'"].include?(char)
+            in_quote = char
+            current << char
+          elsif char == "("
+            depth += 1
+            current << char
+          elsif char == ")"
+            depth -= 1
+            current << char
+          elsif char == "," && depth.zero?
+            entries << current
+            current = +""
+          else
+            current << char
+          end
+        end
+
+        entries << current unless current.strip.empty?
+        entries
+      end
+
+      def parse_source_entry(entry)
+        parts = Prawn::SVG::CSS::ValuesParser.parse(entry)
+        return if parts.empty?
+
+        first = parts[0]
+        return unless first.is_a?(Array)
+
+        case first[0]
+        when "url"
+          url = first[1][0]
+          return unless url
+
+          format = extract_format(parts[1])
+          {type: :url, url:, format:}
+        when "local"
+          name = first[1][0]
+          return unless name
+
+          {type: :local, name:}
+        end
+      end
+
+      def extract_format(part)
+        return unless part.is_a?(Array) && part[0] == "format"
+
+        part[1][0]
+      end
+    end
+  end
+end

data/lib/prawn/svg/css/font_family_parser.rb

@@ -0,0 +1,39 @@
+module Prawn::SVG::CSS
+  class FontFamilyParser
+    def self.parse(string)
+      in_quote = nil
+      in_escape = false
+      current = nil
+      fonts = []
+
+      string.each_char do |char|
+        if in_escape
+          in_escape = false
+          if current.nil?
+            current = char
+            fonts << current
+          else
+            current << char
+          end
+        elsif char == "," && in_quote.nil?
+          current = nil
+        elsif char == in_quote
+          in_quote = nil
+        elsif in_quote.nil? && ['"', "'"].include?(char)
+          in_quote = char
+        elsif char == "\\"
+          in_escape = true
+        elsif current.nil?
+          if char.match(/\s/).nil?
+            current = char
+            fonts << current
+          end
+        else
+          current << char
+        end
+      end
+
+      fonts.map(&:rstrip)
+    end
+  end
+end