bandoola 0.1.0

data/lib/bandoola/svg.rb

@@ -0,0 +1,349 @@
+module Bandoola
+  # A tiny SVG reader that turns a path-based SVG into PDF path-painting
+  # operators. It is deliberately small: it understands <path> elements with
+  # solid fills — which covers icon/logo SVGs like a BankID mark — and not
+  # gradients, strokes, text, or raster <image> data.
+  #
+  # It is a standalone value object that knows nothing about View or layout:
+  # give it SVG source and a target box, get back PDF operators.
+  #
+  # The SVG coordinate system has its origin at the top-left with y pointing
+  # down; PDF's points up from the bottom-left. #to_pdf emits a `cm` transform
+  # that maps the viewBox into a target box and flips y, so the path data can
+  # be written out essentially verbatim.
+  class Svg
+    VIEWBOX = /viewBox="\s*([-\d.]+)[\s,]+([-\d.]+)[\s,]+([-\d.]+)[\s,]+([-\d.]+)"/
+    DIMENSION = /\A(\d*\.?\d+)/
+    PATH_TAG = /<path\b([^>]*)>/m
+    ATTRIBUTE = ->(name) { /#{name}="([^"]*)"/ }
+
+    # <mask> (and <clipPath>) define stencils, not visible artwork; the paths
+    # inside them must not be painted, so we strip these blocks before scanning.
+    STENCIL = %r{<(mask|clipPath)\b[^>]*>.*?</\1>}m
+
+    # A <mask id="..."> definition and its body, captured to build a clip.
+    MASK = %r{<mask\b[^>]*\bid="([^"]*)"[^>]*>(.*?)</mask>}m
+    # A <rect> inside a mask, turned into a rectangular clip subpath.
+    RECT_TAG = %r{<rect\b([^>]*?)/?>}m
+    # Open <g>, close </g>, or <path> — walked in document order so a path
+    # inherits the mask of any enclosing group.
+    ELEMENT = %r{<g\b([^>]*)>|</g>|<path\b([^>]*)>}m
+    # The id inside a mask="url(#id)" reference.
+    MASK_REF = /#([\w-]+)/
+
+    # A path command letter or a number (incl. decimals and exponents).
+    TOKEN = /[MmLlHhVvCcSsZz]|-?\d*\.?\d+(?:[eE][-+]?\d+)?/
+
+    def self.load(src)
+      new(File.read(src))
+    end
+
+    def initialize(source)
+      @source = source
+      @view_width, @view_height = parse_viewbox
+      @paths = parse_paths
+    end
+
+    attr_reader :view_width, :view_height
+
+    # Intrinsic display size: the SVG's width/height attributes if present,
+    # otherwise the viewBox dimensions.
+    def intrinsic_width
+      dimension("width") || view_width
+    end
+
+    def intrinsic_height
+      dimension("height") || view_height
+    end
+
+    # Content aspect ratio (width / height) of the viewBox.
+    def aspect
+      view_width / view_height
+    end
+
+    # Paint the SVG into +box+ ([left, top, width, height]). SVG paths draw
+    # inline, so +resources+ is unused (only raster images register XObjects);
+    # the signature matches Jpeg so Img can treat both the same.
+    def paint_into(buffer, _resources, box)
+      buffer << to_pdf(*box)
+    end
+
+    # PDF operators that paint the SVG into the box whose top-left corner is
+    # (left, top) and whose size is width x height, in PDF points.
+    def to_pdf(left, top, width, height)
+      scale_x = width / view_width
+      scale_y = height / view_height
+
+      out = +"q\n"
+      out << "#{fmt(scale_x)} 0 0 #{fmt(-scale_y)} #{fmt(left)} #{fmt(top)} cm\n"
+      @paths.each { |path| paint_path(out, path) }
+      out << "Q\n"
+    end
+
+    private
+
+    # Paint one parsed path. If it carries mask geometry, the fill is wrapped
+    # in its own save-state and clipped to that geometry first. Masks use the
+    # even-odd rule (W*) so the white-rect-with-knockouts idiom resolves to the
+    # expected holes.
+    def paint_path(out, path)
+      clip = path[:clip]
+      clipped = clip && !clip.empty?
+      out << "q\n" << clip << "W* n\n" if clipped
+      red, green, blue = path[:color]
+      out << "#{fmt(red)} #{fmt(green)} #{fmt(blue)} rg\n"
+      out << path[:ops]
+      out << (path[:even_odd] ? "f*\n" : "f\n")
+      out << "Q\n" if clipped
+    end
+
+    def parse_viewbox
+      if (match = @source.match(VIEWBOX))
+        [match[3].to_f, match[4].to_f]
+      else
+        [dimension("width") || 1.0, dimension("height") || 1.0]
+      end
+    end
+
+    def dimension(name)
+      match = @source.match(ATTRIBUTE.call(name))
+      return nil unless match
+
+      number = match[1].match(DIMENSION)
+      number && number[1].to_f
+    end
+
+    def parse_paths
+      masks = parse_masks
+      groups = [] # stack of enclosing-group mask ids (nil when a group is unmasked)
+
+      @source.gsub(STENCIL, "").scan(ELEMENT).filter_map do |group_attrs, path_attrs|
+        if group_attrs
+          groups.push(mask_ref(group_attrs))
+          next
+        elsif path_attrs.nil? # a </g>
+          groups.pop
+          next
+        end
+
+        build_path(path_attrs, masks, groups.compact.last)
+      end
+    end
+
+    def build_path(attributes, masks, group_mask)
+      fill = attribute(attributes, "fill")
+      return if fill.nil? || fill == "none"
+
+      data = attribute(attributes, "d")
+      return if data.nil?
+
+      mask = mask_ref(attributes) || group_mask
+      {
+        ops: Pen.new(data.scan(TOKEN)).draw,
+        color: rgb(fill),
+        even_odd: attribute(attributes, "fill-rule") == "evenodd",
+        clip: mask && masks[mask]
+      }
+    end
+
+    # id => clip operators, for every <mask> in the document. A mask's <path>
+    # and <rect> children become the clip geometry; other shapes are ignored.
+    def parse_masks
+      @source.scan(MASK).to_h do |id, body|
+        [id, mask_clip(body)]
+      end
+    end
+
+    def mask_clip(body)
+      ops = +""
+      body.scan(PATH_TAG).each do |(attributes)|
+        data = attribute(attributes, "d")
+        ops << Pen.new(data.scan(TOKEN)).draw if data
+      end
+      body.scan(RECT_TAG).each { |(attributes)| ops << rect_path(attributes) }
+      ops
+    end
+
+    # A <rect> as an explicit closed subpath (rx/ry rounding is ignored).
+    def rect_path(attributes)
+      x = number_attribute(attributes, "x")
+      y = number_attribute(attributes, "y")
+      width = number_attribute(attributes, "width")
+      height = number_attribute(attributes, "height")
+
+      "#{fmt(x)} #{fmt(y)} m\n" \
+        "#{fmt(x + width)} #{fmt(y)} l\n" \
+        "#{fmt(x + width)} #{fmt(y + height)} l\n" \
+        "#{fmt(x)} #{fmt(y + height)} l\n" \
+        "h\n"
+    end
+
+    def number_attribute(attributes, name)
+      value = attribute(attributes, name)
+      value ? value.to_f : 0.0
+    end
+
+    # The id referenced by a mask="url(#id)" attribute, or nil if absent.
+    def mask_ref(attributes)
+      ref = attribute(attributes, "mask")
+      ref && ref[MASK_REF, 1]
+    end
+
+    def attribute(attributes, name)
+      match = attributes.match(ATTRIBUTE.call(name))
+      match && match[1]
+    end
+
+    # "#193E4F" => [0.098, 0.243, 0.310], each channel scaled to 0..1.
+    # Shorthand 3-digit hex ("#fff") expands to its 6-digit form first.
+    def rgb(hex)
+      digits = hex.delete("#")
+      digits = digits.chars.map { |digit| digit * 2 }.join if digits.length == 3
+      [0, 2, 4].map { |offset| digits[offset, 2].to_i(16) / 255.0 }
+    end
+
+    def fmt(value)
+      format("%.3f", value).sub(/\.?0+\z/, "")
+    end
+
+    # Walks the token stream of one path's `d` attribute, tracking the current
+    # point so relative commands and implicit repeats resolve, and emits PDF
+    # path operators (m/l/c/h) in the SVG's own coordinate space.
+    class Pen
+      # SVG path command letter (upper = absolute, lower = relative) to the
+      # method that emits it.
+      COMMANDS = {
+        "M" => :move, "m" => :move,
+        "L" => :line, "l" => :line,
+        "H" => :horizontal, "h" => :horizontal,
+        "V" => :vertical, "v" => :vertical,
+        "C" => :cubic, "c" => :cubic,
+        "S" => :smooth_cubic, "s" => :smooth_cubic,
+        "Z" => :close, "z" => :close
+      }.freeze
+
+      def initialize(tokens)
+        @tokens = tokens
+        @index = 0
+        @x = 0.0
+        @y = 0.0
+        @start_x = 0.0
+        @start_y = 0.0
+        @command = nil
+        @control_x = nil
+        @control_y = nil
+        @ops = +""
+      end
+
+      def draw
+        while @index < @tokens.length
+          token = @tokens[@index]
+          if token.match?(/[A-Za-z]/)
+            @command = token
+            @index += 1
+          end
+          step(@command)
+        end
+        @ops
+      end
+
+      private
+
+      def step(command)
+        action = COMMANDS[command]
+        return @index += 1 unless action # skip unsupported/leading token, ensuring progress
+
+        send(action)
+      end
+
+      def number
+        value = @tokens[@index].to_f
+        @index += 1
+        value
+      end
+
+      def relative?
+        @command == @command.downcase
+      end
+
+      def move
+        implicit = relative? ? "l" : "L"
+        target = point
+        @x = @start_x = target[0]
+        @y = @start_y = target[1]
+        @ops << "#{fmt(target[0])} #{fmt(target[1])} m\n"
+        # Subsequent coordinate pairs after a moveto are implicit linetos.
+        @command = implicit
+      end
+
+      def line
+        line_to(point)
+      end
+
+      def horizontal
+        along = number
+        along += @x if relative?
+        line_to([along, @y])
+      end
+
+      def vertical
+        along = number
+        along += @y if relative?
+        line_to([@x, along])
+      end
+
+      def cubic
+        control1 = point
+        control2 = point
+        endpoint = point
+        curve_to(control1, control2, endpoint)
+      end
+
+      def smooth_cubic
+        control2 = point
+        endpoint = point
+        curve_to(reflected_control, control2, endpoint)
+      end
+
+      # Read the next coordinate pair, resolving relative commands against the
+      # current point.
+      def point
+        coords = [number, number]
+        return coords unless relative?
+
+        [coords[0] + @x, coords[1] + @y]
+      end
+
+      def reflected_control
+        return [@x, @y] unless @control_x
+
+        [(2 * @x) - @control_x, (2 * @y) - @control_y]
+      end
+
+      def close
+        @ops << "h\n"
+        @x = @start_x
+        @y = @start_y
+        @command = nil # a fresh command (or EOF) must follow a closepath
+      end
+
+      def line_to(target)
+        @x, @y = target
+        @control_x = @control_y = nil
+        @ops << "#{fmt(@x)} #{fmt(@y)} l\n"
+      end
+
+      def curve_to(control1, control2, target)
+        @ops << "#{fmt(control1[0])} #{fmt(control1[1])} " \
+                "#{fmt(control2[0])} #{fmt(control2[1])} " \
+                "#{fmt(target[0])} #{fmt(target[1])} c\n"
+        @control_x, @control_y = control2
+        @x, @y = target
+      end
+
+      def fmt(value)
+        format("%.3f", value).sub(/\.?0+\z/, "")
+      end
+    end
+  end
+end

data/lib/bandoola/true_type_font.rb

@@ -0,0 +1,206 @@
+module Bandoola
+  # A minimal TrueType font reader: enough to embed the font in a PDF and look
+  # up the metrics PDF needs. It parses the table directory and the head/hhea/
+  # maxp/hmtx/cmap/post/OS2/name tables — not the glyph outlines, which travel
+  # to the viewer untouched inside the embedded font file.
+  #
+  # Metrics are scaled to PDF glyph space (1000 units per em). Character codes
+  # are treated as Unicode (Latin-1 for 0..255), resolved to glyphs through a
+  # format-4 Unicode cmap subtable.
+  class TrueTypeFont
+    # A right-leaning slant for fonts flagged italic whose post table doesn't
+    # report an angle (common in variable fonts, where the slant is in the
+    # variation data). PDF measures the angle counter-clockwise from vertical.
+    DEFAULT_ITALIC_ANGLE = -12
+
+    def self.load(path)
+      new(File.binread(path))
+    end
+
+    def initialize(data)
+      @data = data
+      @tables = read_directory
+      read_head
+      read_hhea
+      @num_glyphs = u16(table_offset("maxp") + 4)
+      read_cmap
+    end
+
+    attr_reader :data, :ascent, :descent, :cap_height, :font_bbox, :italic_angle
+
+    # The glyph index for a Unicode code point (0 = .notdef / missing).
+    def glyph(codepoint)
+      glyph_for(codepoint)
+    end
+
+    # The advance width (in 1000-unit em) of a glyph index.
+    def glyph_width(glyph)
+      index = glyph < @num_hmetrics ? glyph : @num_hmetrics - 1
+      scale(u16(table_offset("hmtx") + (index * 4)))
+    end
+
+    # The advance width (in 1000-unit em) of a character code.
+    def width(codepoint)
+      glyph_width(glyph(codepoint))
+    end
+
+    def widths(first, last)
+      (first..last).map { |code| width(code) }
+    end
+
+    # A PDF/PostScript-safe BaseFont name, from the font's name table.
+    def postscript_name
+      @postscript_name ||= read_postscript_name
+    end
+
+    # FontDescriptor flags: 32 = Nonsymbolic (uses a standard Latin set), plus
+    # 64 if the font is italic.
+    def flags
+      @italic ? 96 : 32
+    end
+
+    private
+
+    def read_directory
+      tables = {}
+      u16(4).times do |i|
+        entry = 12 + (i * 16)
+        tables[@data[entry, 4]] = u32(entry + 8)
+      end
+      tables
+    end
+
+    def table_offset(tag)
+      @tables.fetch(tag) { raise Error, "TrueType font missing #{tag} table" }
+    end
+
+    def read_head
+      offset = table_offset("head")
+      @units_per_em = u16(offset + 18)
+      @font_bbox = [offset + 36, offset + 38, offset + 40, offset + 42].map { |pos| scale(i16(pos)) }
+      @italic = u16(offset + 44).anybits?(0x0002) || os2_italic? # head.macStyle bit 1
+    end
+
+    def os2_italic?
+      return false unless @tables["OS/2"]
+
+      u16(table_offset("OS/2") + 62).anybits?(0x0001) # fsSelection bit 0
+    end
+
+    def read_hhea
+      offset = table_offset("hhea")
+      @ascent = scale(i16(offset + 4))
+      @descent = scale(i16(offset + 6))
+      @num_hmetrics = u16(offset + 34)
+      @cap_height = cap_height_from_os2 || @ascent
+      @italic_angle = italic_angle_value
+    end
+
+    def cap_height_from_os2
+      return nil unless @tables["OS/2"]
+
+      offset = table_offset("OS/2")
+      return nil if u16(offset) < 2 # sCapHeight only exists from version 2
+
+      scale(i16(offset + 88))
+    end
+
+    def italic_angle_value
+      from_post = @tables["post"] ? (i32(table_offset("post") + 4) / 65_536.0).round : 0
+      return from_post unless from_post.zero?
+
+      @italic ? DEFAULT_ITALIC_ANGLE : 0
+    end
+
+    # Locate a format-4 Unicode cmap subtable (preferring Windows 3,1) and
+    # cache the offsets of its parallel segment arrays.
+    def read_cmap
+      base = table_offset("cmap")
+      subtable = find_format4_subtable(base)
+      raise Error, "TrueType font has no usable Unicode cmap" unless subtable
+
+      @seg_count = u16(subtable + 6) / 2
+      @cmap_end = subtable + 14
+      @cmap_start = @cmap_end + (@seg_count * 2) + 2
+      @cmap_delta = @cmap_start + (@seg_count * 2)
+      @cmap_range = @cmap_delta + (@seg_count * 2)
+    end
+
+    def find_format4_subtable(base)
+      fallback = nil
+      u16(base + 2).times do |i|
+        record = base + 4 + (i * 8)
+        platform = u16(record)
+        encoding = u16(record + 2)
+        subtable = base + u32(record + 4)
+        next unless u16(subtable) == 4
+
+        return subtable if platform == 3 && encoding == 1
+
+        fallback ||= subtable if platform.zero?
+      end
+      fallback
+    end
+
+    # cmap format 4 lookup: find the segment covering +code+ and map it to a
+    # glyph index via idRangeOffset/idDelta.
+    def glyph_for(code)
+      segment = 0
+      segment += 1 while segment < @seg_count && u16(@cmap_end + (2 * segment)) < code
+      return 0 if segment >= @seg_count
+      return 0 if u16(@cmap_start + (2 * segment)) > code
+
+      range = u16(@cmap_range + (2 * segment))
+      delta = i16(@cmap_delta + (2 * segment))
+      return (code + delta) % 65_536 if range.zero?
+
+      start = u16(@cmap_start + (2 * segment))
+      glyph = u16(@cmap_range + (2 * segment) + range + (2 * (code - start)))
+      glyph.zero? ? 0 : (glyph + delta) % 65_536
+    end
+
+    def read_postscript_name
+      return "Embedded" unless @tables["name"]
+
+      offset = table_offset("name")
+      strings = offset + u16(offset + 4)
+      u16(offset + 2).times do |i|
+        record = offset + 6 + (i * 12)
+        next unless u16(record + 6) == 6 # nameID 6 = PostScript name
+
+        raw = @data[strings + u16(record + 10), u16(record + 8)] || ""
+        # Keep printable ASCII, which also drops the 0x00s of UTF-16BE names.
+        ascii = raw.bytes.grep(0x21..0x7E).pack("C*")
+        return sanitize(ascii) unless ascii.empty?
+      end
+      "Embedded"
+    end
+
+    def sanitize(name)
+      cleaned = name.gsub(/[^A-Za-z0-9-]/, "")
+      cleaned.empty? ? "Embedded" : cleaned
+    end
+
+    def scale(value)
+      (value * 1000.0 / @units_per_em).round
+    end
+
+    def u16(offset)
+      (@data.getbyte(offset) << 8) | @data.getbyte(offset + 1)
+    end
+
+    def i16(offset)
+      value = u16(offset)
+      value >= 0x8000 ? value - 0x10000 : value
+    end
+
+    def u32(offset)
+      (u16(offset) << 16) | u16(offset + 2)
+    end
+
+    def i32(offset)
+      value = u32(offset)
+      value >= 0x8000_0000 ? value - 0x1_0000_0000 : value
+    end
+  end
+end