prawnx 0.1.1

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

@@ -0,0 +1,168 @@
+module Prawn::SVG::Calculators
+  class PathLength
+    Segment = Struct.new(: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..])
+
+      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: url, format: format }
+        when 'local'
+          name = first[1][0]
+          return unless name
+
+          { type: :local, name: 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

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

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