receipts 2.3.0 → 3.0.0

data/lib/receipts/pdf/text_layout.rb

@@ -0,0 +1,175 @@
+module Receipts
+  module PDF
+    # Wraps styled text into lines that fit a given width.
+    #
+    # Input is an Array of [text, Style] chunks. Lines break at spaces, after
+    # hyphens, and at newlines. Words wider than the line are broken anywhere.
+    module TextLayout
+      Style = Struct.new(:font, :size, :color, :link, :underline, :strikethrough, :rise,
+        :character_spacing, :oblique, :fake_bold, keyword_init: true)
+      Run = Struct.new(:text, :style, :width)
+      Line = Struct.new(:runs, :width, :ascender, :descender, :line_gap) do
+        def height
+          ascender + descender
+        end
+      end
+
+      EPSILON = 0.0001
+
+      module_function
+
+      def wrap(chunks, max_width, default_style)
+        lines = []
+
+        paragraphs(chunks, default_style).each do |paragraph_style, paragraph|
+          line = []
+          line_width = 0
+          pending = []
+          pending_width = 0
+
+          items(paragraph).each do |type, pieces|
+            width = measure_pieces(pieces)
+
+            if type == :space
+              next if line.empty?
+              pending.concat(pieces)
+              pending_width += width
+              next
+            end
+
+            if line.any? && line_width + pending_width + width > max_width + EPSILON
+              lines << build_line(line, paragraph_style)
+              line = []
+              line_width = 0
+            else
+              line.concat(pending)
+              line_width += pending_width
+            end
+            pending = []
+            pending_width = 0
+
+            if line.empty? && width > max_width + EPSILON
+              pieces, width = break_word(pieces, max_width, paragraph_style, lines)
+            end
+
+            line.concat(pieces)
+            line_width += width
+          end
+
+          lines << build_line(line, paragraph_style)
+        end
+
+        lines
+      end
+
+      # Width of the text without wrapping
+      def natural_width(chunks, default_style)
+        paragraphs(chunks, default_style).map do |_, paragraph|
+          measure_pieces(paragraph)
+        end.max || 0
+      end
+
+      # Width of the widest word, the narrowest the text can wrap without breaking words
+      def minimum_width(chunks, default_style)
+        paragraphs(chunks, default_style).flat_map do |_, paragraph|
+          items(paragraph).map { |type, pieces| (type == :word) ? measure_pieces(pieces) : 0 }
+        end.max || 0
+      end
+
+      def height_of(lines, leading = 0)
+        return 0 if lines.empty?
+        lines.sum(&:height) + lines[0...-1].sum { |line| line.line_gap + leading }
+      end
+
+      def measure(text, style)
+        style.font.width_of(text, style.size, character_spacing: style.character_spacing)
+      end
+
+      def measure_pieces(pieces)
+        pieces.sum { |text, style| measure(text, style) }
+      end
+
+      # Splits chunks at newlines. Empty paragraphs keep the style of the text around them for their height.
+      def paragraphs(chunks, default_style)
+        paragraphs = [[default_style, []]]
+        chunks.each do |text, style|
+          paragraphs.last[0] = style if paragraphs.last[1].empty?
+          text.split("\n", -1).each_with_index do |part, index|
+            paragraphs << [style, []] if index > 0
+            paragraphs.last[1] << [part, style] unless part.empty?
+          end
+        end
+        paragraphs
+      end
+
+      # Groups text into [:word, pieces] and [:space, pieces] items. A word can span
+      # several chunks with different styles, like "<b>Total</b>:".
+      def items(chunks)
+        items = []
+        word = nil
+
+        chunks.each do |text, style|
+          text.scan(/[ \t]+|[^ \t]+/) do |token|
+            if token.start_with?(" ", "\t")
+              items << [:space, [[token.tr("\t", " "), style]]]
+              word = nil
+            else
+              token.scan(/[^-]*-+|[^-]+/) do |piece|
+                unless word
+                  word = []
+                  items << [:word, word]
+                end
+                word << [piece, style]
+                word = nil if piece.end_with?("-")
+              end
+            end
+          end
+        end
+
+        items
+      end
+
+      # Breaks a word too wide for a line into full lines, returning the remainder
+      def break_word(pieces, max_width, paragraph_style, lines)
+        current = []
+        current_width = 0
+
+        pieces.each do |text, style|
+          text.each_char do |char|
+            width = measure(char, style)
+            if current.any? && current_width + width > max_width + EPSILON
+              lines << build_line(current, paragraph_style)
+              current = []
+              current_width = 0
+            end
+            current << [char, style]
+            current_width += width
+          end
+        end
+
+        [current, current_width]
+      end
+
+      def build_line(pieces, fallback_style)
+        runs = []
+        pieces.each do |text, style|
+          if runs.any? && runs.last.style.equal?(style)
+            runs.last.text += text
+          else
+            runs << Run.new(text.dup, style, 0)
+          end
+        end
+        runs.each { |run| run.width = measure(run.text, run.style) }
+
+        styles = runs.empty? ? [fallback_style] : runs.map(&:style)
+        Line.new(
+          runs,
+          runs.sum(&:width),
+          styles.map { |s| s.font.ascender(s.size) + s.rise }.max,
+          styles.map { |s| s.font.descender(s.size) - s.rise }.max,
+          styles.map { |s| s.font.line_gap(s.size) }.max
+        )
+      end
+    end
+  end
+end

data/lib/receipts/pdf/true_type.rb

@@ -0,0 +1,387 @@
+require "set"
+
+module Receipts
+  module PDF
+    class UnsupportedFontError < StandardError; end
+
+    # Reads the tables of a TrueType (.ttf) font needed to measure text and
+    # embed a subset of the font in a PDF.
+    class TrueType
+      REQUIRED_TABLES = %w[head hhea maxp hmtx cmap loca glyf].freeze
+
+      # Hinting tables copied unchanged into subsets when present
+      HINTING_TABLES = ["cvt ", "fpgm", "prep"].freeze
+
+      CACHE = {}
+      CACHE_MUTEX = Mutex.new
+      CACHE_SIZE = 16
+
+      attr_reader :units_per_em, :bbox, :ascender, :descender, :line_gap, :num_glyphs, :cmap,
+        :italic_angle, :underline_position, :underline_thickness, :strikeout_position, :strikeout_size,
+        :cap_height, :x_height, :weight, :postscript_name
+
+      # Recently used fonts are cached by path since they're reused across documents,
+      # and parsed again if the file changes
+      def self.load(path)
+        path = File.expand_path(path.to_s)
+        mtime = File.mtime(path)
+
+        CACHE_MUTEX.synchronize do
+          cached_mtime, font = CACHE[path]
+          unless cached_mtime == mtime
+            font = new(File.binread(path))
+            CACHE.delete(path)
+            CACHE[path] = [mtime, font]
+            CACHE.shift while CACHE.size > CACHE_SIZE
+          end
+          font
+        end
+      end
+
+      def initialize(data)
+        @data = data.b
+
+        case @data.byteslice(0, 4)
+        when "\x00\x01\x00\x00".b, "true"
+          nil
+        when "OTTO"
+          raise UnsupportedFontError, "OpenType fonts with CFF outlines are not supported, use a TrueType (.ttf) font"
+        when "ttcf"
+          raise UnsupportedFontError, "TrueType collections (.ttc) are not supported, use a single TrueType (.ttf) font"
+        else
+          raise UnsupportedFontError, "not a TrueType font"
+        end
+
+        @tables = {}
+        u16(4).times do |i|
+          record = 12 + i * 16
+          @tables[@data.byteslice(record, 4)] = [u32(record + 8), u32(record + 12)]
+        end
+
+        REQUIRED_TABLES.each do |tag|
+          raise UnsupportedFontError, "font is missing the #{tag} table" unless @tables[tag]
+        end
+
+        parse_head
+        parse_hhea
+        parse_maxp
+        parse_hmtx
+        parse_loca
+        parse_cmap
+        parse_post
+        parse_os2
+        parse_name
+      end
+
+      def glyph_id(codepoint)
+        @cmap.fetch(codepoint, 0)
+      end
+
+      def advance(gid)
+        @advances[gid] || @advances.last
+      end
+
+      def fixed_pitch?
+        @fixed_pitch
+      end
+
+      # Builds a font containing only the given glyphs (plus composite glyph parts),
+      # renumbered compactly. Returns the font data and a Hash of original to new glyph IDs.
+      def subset(gids)
+        glyphs = glyph_closure(Set.new(gids) << 0).sort
+        mapping = glyphs.each_with_index.to_h
+        count = glyphs.size
+
+        glyf = String.new(encoding: Encoding::BINARY)
+        loca = []
+        glyphs.each do |gid|
+          loca << glyf.bytesize
+          data = remap_components(glyph_data(gid), mapping)
+          glyf << data << padding(data)
+        end
+        loca << glyf.bytesize
+
+        head = table_data("head").dup
+        head[8, 4] = [0].pack("N") # checkSumAdjustment, set below
+        head[50, 2] = [1].pack("n") # indexToLocFormat: long offsets
+
+        hhea = table_data("hhea").dup
+        hhea[34, 2] = [count].pack("n") # numberOfHMetrics
+
+        maxp = table_data("maxp").dup
+        maxp[4, 2] = [count].pack("n") # numGlyphs
+
+        hmtx = glyphs.flat_map { |gid| [advance(gid), left_side_bearing(gid)] }.pack("ns>" * count)
+
+        tables = {"head" => head, "hhea" => hhea, "maxp" => maxp, "hmtx" => hmtx, "loca" => loca.pack("N*"), "glyf" => glyf}
+        HINTING_TABLES.each { |tag| tables[tag] = table_data(tag) if @tables[tag] }
+
+        if @tables["post"]
+          # Version 3.0 post table: metrics only, no glyph names
+          post = table_data("post").byteslice(0, 32).dup
+          post[0, 4] = [0x00030000].pack("N")
+          tables["post"] = post
+        end
+
+        [build_font(tables), mapping]
+      end
+
+      private
+
+      def u16(offset)
+        @data.byteslice(offset, 2).unpack1("n")
+      end
+
+      def i16(offset)
+        @data.byteslice(offset, 2).unpack1("s>")
+      end
+
+      def u32(offset)
+        @data.byteslice(offset, 4).unpack1("N")
+      end
+
+      def table_offset(tag)
+        @tables[tag]&.first
+      end
+
+      def table_data(tag)
+        offset, length = @tables.fetch(tag)
+        @data.byteslice(offset, length)
+      end
+
+      def padding(data)
+        "\0".b * (-data.bytesize % 4)
+      end
+
+      def parse_head
+        t = table_offset("head")
+        @units_per_em = u16(t + 18)
+        @bbox = [i16(t + 36), i16(t + 38), i16(t + 40), i16(t + 42)]
+        @index_to_loc_format = i16(t + 50)
+      end
+
+      def parse_hhea
+        t = table_offset("hhea")
+        @ascender = i16(t + 4)
+        @descender = i16(t + 6)
+        @line_gap = i16(t + 8)
+        @number_of_hmetrics = u16(t + 34)
+      end
+
+      def parse_maxp
+        @num_glyphs = u16(table_offset("maxp") + 4)
+      end
+
+      def parse_hmtx
+        @hmtx_offset = table_offset("hmtx")
+        @advances = @data.byteslice(@hmtx_offset, @number_of_hmetrics * 4).unpack("n*").each_slice(2).map(&:first)
+      end
+
+      def left_side_bearing(gid)
+        if gid < @number_of_hmetrics
+          i16(@hmtx_offset + gid * 4 + 2)
+        else
+          i16(@hmtx_offset + @number_of_hmetrics * 4 + (gid - @number_of_hmetrics) * 2)
+        end
+      end
+
+      def parse_loca
+        t = table_offset("loca")
+        @loca = if @index_to_loc_format.zero?
+          @data.byteslice(t, (@num_glyphs + 1) * 2).unpack("n*").map { |offset| offset * 2 }
+        else
+          @data.byteslice(t, (@num_glyphs + 1) * 4).unpack("N*")
+        end
+        @glyf_offset = table_offset("glyf")
+      end
+
+      def glyph_data(gid)
+        return "".b if gid >= @num_glyphs
+        @data.byteslice(@glyf_offset + @loca[gid], @loca[gid + 1] - @loca[gid])
+      end
+
+      def glyph_closure(gids)
+        glyphs = Set.new
+        queue = gids.to_a
+        until queue.empty?
+          gid = queue.pop
+          next if gid >= @num_glyphs || !glyphs.add?(gid)
+          each_component(glyph_data(gid)) { |_, component| queue << component }
+        end
+        glyphs
+      end
+
+      # Points composite glyphs at the renumbered IDs of their components
+      def remap_components(data, mapping)
+        copy = nil
+        each_component(data) do |pos, component|
+          copy ||= data.dup
+          copy[pos, 2] = [mapping.fetch(component, 0)].pack("n")
+        end
+        copy || data
+      end
+
+      # Composite glyphs reference other glyphs. Yields the byte offset of each
+      # component's glyph ID and the ID.
+      def each_component(data)
+        return if data.bytesize < 10 || data.unpack1("s>") >= 0
+
+        pos = 10
+        loop do
+          flags, component = data.byteslice(pos, 4).unpack("nn")
+          yield pos + 2, component
+          pos += 4
+          pos += (flags & 0x0001).zero? ? 2 : 4 # ARG_1_AND_2_ARE_WORDS
+          if flags & 0x0008 != 0 # WE_HAVE_A_SCALE
+            pos += 2
+          elsif flags & 0x0040 != 0 # WE_HAVE_AN_X_AND_Y_SCALE
+            pos += 4
+          elsif flags & 0x0080 != 0 # WE_HAVE_A_TWO_BY_TWO
+            pos += 8
+          end
+          break if (flags & 0x0020).zero? # MORE_COMPONENTS
+        end
+      end
+
+      def parse_cmap
+        t = table_offset("cmap")
+        subtables = Array.new(u16(t + 2)) do |i|
+          record = t + 4 + i * 8
+          offset = t + u32(record + 4)
+          [u16(record), u16(record + 2), offset, u16(offset)]
+        end
+
+        # Prefer full Unicode (format 12) over the Basic Multilingual Plane only (format 4)
+        best = subtables.find { |platform, encoding, _, format| platform == 3 && encoding == 10 && format == 12 } ||
+          subtables.find { |platform, _, _, format| platform == 0 && format == 12 } ||
+          subtables.find { |platform, encoding, _, format| platform == 3 && encoding == 1 && format == 4 } ||
+          subtables.find { |platform, _, _, format| platform == 0 && format == 4 }
+        raise UnsupportedFontError, "font has no Unicode character map" unless best
+
+        @cmap = (best[3] == 12) ? parse_cmap_format12(best[2]) : parse_cmap_format4(best[2])
+      end
+
+      def parse_cmap_format4(offset)
+        map = {}
+        seg_count = u16(offset + 6) / 2
+        ends = offset + 14
+        starts = ends + seg_count * 2 + 2
+        deltas = starts + seg_count * 2
+        range_offsets = deltas + seg_count * 2
+
+        seg_count.times do |i|
+          first = u16(starts + i * 2)
+          last = u16(ends + i * 2)
+          delta = u16(deltas + i * 2)
+          range_offset_pos = range_offsets + i * 2
+          range_offset = u16(range_offset_pos)
+
+          (first..last).each do |codepoint|
+            next if codepoint == 0xFFFF
+            gid = if range_offset.zero?
+              (codepoint + delta) & 0xFFFF
+            else
+              glyph = u16(range_offset_pos + range_offset + (codepoint - first) * 2)
+              glyph.zero? ? 0 : (glyph + delta) & 0xFFFF
+            end
+            map[codepoint] = gid unless gid.zero?
+          end
+        end
+        map
+      end
+
+      def parse_cmap_format12(offset)
+        map = {}
+        u32(offset + 12).times do |i|
+          group = offset + 16 + i * 12
+          first = u32(group)
+          last = u32(group + 4)
+          gid = u32(group + 8)
+          (first..last).each { |codepoint| map[codepoint] = gid + codepoint - first }
+        end
+        map
+      end
+
+      def parse_post
+        if (t = table_offset("post"))
+          @italic_angle = i16(t + 4) + u16(t + 6) / 65536.0
+          @underline_position = i16(t + 8)
+          @underline_thickness = i16(t + 10)
+          @fixed_pitch = u32(t + 12) != 0
+        else
+          @italic_angle = 0
+          @underline_position = -@units_per_em / 10
+          @underline_thickness = @units_per_em / 20
+          @fixed_pitch = false
+        end
+      end
+
+      def parse_os2
+        if (t = table_offset("OS/2"))
+          version = u16(t)
+          @weight = u16(t + 4)
+          @strikeout_size = i16(t + 26)
+          @strikeout_position = i16(t + 28)
+          if version >= 2
+            @x_height = i16(t + 86)
+            @cap_height = i16(t + 88)
+          end
+        end
+
+        @weight ||= 400
+        @strikeout_size ||= @underline_thickness
+        @strikeout_position ||= (@ascender * 0.25).round
+        @x_height ||= (@ascender * 0.5).round
+        @cap_height ||= (@ascender * 0.7).round
+      end
+
+      def parse_name
+        if (t = table_offset("name"))
+          strings = t + u16(t + 4)
+          u16(t + 2).times do |i|
+            record = t + 6 + i * 12
+            next unless u16(record + 6) == 6 # PostScript name
+
+            platform = u16(record)
+            raw = @data.byteslice(strings + u16(record + 10), u16(record + 8)).dup
+            name = if platform == 1
+              raw.force_encoding(Encoding::ISO_8859_1).encode(Encoding::UTF_8)
+            else
+              raw.force_encoding(Encoding::UTF_16BE).encode(Encoding::UTF_8, invalid: :replace, undef: :replace)
+            end
+            @postscript_name = name.delete("^!-~").delete("[](){}<>/%#")
+            break unless @postscript_name.empty?
+          end
+        end
+
+        @postscript_name = "Font" if @postscript_name.nil? || @postscript_name.empty?
+      end
+
+      def build_font(tables)
+        tags = tables.keys.sort
+        entry_selector = Math.log2(tags.size).floor
+        search_range = 2**entry_selector * 16
+
+        directory = [0x00010000, tags.size, search_range, entry_selector, tags.size * 16 - search_range].pack("Nnnnn")
+        body = String.new(encoding: Encoding::BINARY)
+        body_offset = 12 + tags.size * 16
+        head_offset = nil
+
+        tags.each do |tag|
+          data = tables[tag]
+          head_offset = body_offset + body.bytesize if tag == "head"
+          directory << [tag, checksum(data), body_offset + body.bytesize, data.bytesize].pack("a4NNN")
+          body << data << padding(data)
+        end
+
+        font = directory << body
+        font[head_offset + 8, 4] = [(0xB1B0AFBA - checksum(font)) & 0xFFFFFFFF].pack("N")
+        font
+      end
+
+      def checksum(data)
+        (data + padding(data)).unpack("N*").sum & 0xFFFFFFFF
+      end
+    end
+  end
+end

data/lib/receipts/pdf/writer.rb

@@ -0,0 +1,119 @@
+require "zlib"
+require "digest/md5"
+
+module Receipts
+  module PDF
+    # An indirect object reference: `12 0 R`
+    Reference = Struct.new(:id)
+
+    # A string written in hex form: `<48656C6C6F>`
+    HexString = Struct.new(:bytes)
+
+    class Stream
+      attr_reader :dictionary, :data
+
+      # Data is Flate compressed unless the dictionary already declares a filter
+      def initialize(data, dictionary = {})
+        data = data.b
+        dictionary = dictionary.dup
+
+        unless dictionary.key?(:Filter)
+          data = Zlib::Deflate.deflate(data)
+          dictionary[:Filter] = :FlateDecode
+        end
+
+        dictionary[:Length] = data.bytesize
+        @data = data
+        @dictionary = dictionary
+      end
+    end
+
+    # Serializes Ruby values into PDF syntax
+    module Serializer
+      NAME_ESCAPE = /[^\x21-\x7E]|[#%()\/<>\[\]{}]/n
+
+      module_function
+
+      def dump(value)
+        case value
+        when Reference then "#{value.id} 0 R"
+        when Symbol then name(value)
+        when Hash then "<<" + value.map { |k, v| "#{name(k)} #{dump(v)}" }.join(" ") + ">>"
+        when Array then "[" + value.map { |v| dump(v) }.join(" ") + "]"
+        when HexString then "<#{value.bytes.unpack1("H*")}>"
+        when String then literal(value)
+        when Integer then value.to_s
+        when Float then number(value)
+        when true, false then value.to_s
+        when nil then "null"
+        else raise ArgumentError, "cannot serialize #{value.class} to PDF"
+        end
+      end
+
+      def name(value)
+        "/" + value.to_s.b.gsub(NAME_ESCAPE) { |c| format("#%02X", c.ord) }
+      end
+
+      def literal(value)
+        "(" + value.b.gsub(/[\\()\r]/n) { |c| (c == "\r") ? "\\r" : "\\#{c}" } + ")"
+      end
+
+      def number(value)
+        return value.to_s if value.is_a?(Integer)
+        str = format("%.4f", value).sub(/\.?0+\z/, "")
+        (str == "-0") ? "0" : str
+      end
+
+      # Text strings (document info, etc) must be PDFDocEncoding or UTF-16BE with a BOM
+      def text_string(value)
+        value = value.to_s
+        value.ascii_only? ? value.b : "\xFE\xFF".b + value.encode("UTF-16BE").b
+      end
+    end
+
+    # Assembles numbered objects into a PDF file with a cross-reference table
+    class Writer
+      def initialize
+        @objects = []
+      end
+
+      def reserve
+        @objects << nil
+        Reference.new(@objects.size)
+      end
+
+      def set(ref, value)
+        @objects[ref.id - 1] = value
+        ref
+      end
+
+      def add(value)
+        set(reserve, value)
+      end
+
+      def render(root:, info:)
+        out = "%PDF-1.7\n%\xE2\xE3\xCF\xD3\n".b
+
+        offsets = @objects.each_with_index.map do |object, index|
+          offset = out.bytesize
+          out << "#{index + 1} 0 obj\n"
+          if object.is_a?(Stream)
+            out << Serializer.dump(object.dictionary) << "\nstream\n" << object.data << "\nendstream"
+          else
+            out << Serializer.dump(object)
+          end
+          out << "\nendobj\n"
+          offset
+        end
+
+        xref = out.bytesize
+        id = HexString.new(Digest::MD5.digest(out))
+
+        out << "xref\n0 #{@objects.size + 1}\n0000000000 65535 f \n"
+        offsets.each { |offset| out << format("%010d 00000 n \n", offset) }
+        out << "trailer\n" << Serializer.dump(Size: @objects.size + 1, Root: root, Info: info, ID: [id, id])
+        out << "\nstartxref\n#{xref}\n%%EOF\n"
+      end
+    end
+  end
+end

data/lib/receipts/version.rb

@@ -1,3 +1,3 @@
 module Receipts
-  VERSION = "2.3.0"
+  VERSION = "3.0.0"
 end

data/lib/receipts.rb

@@ -1,7 +1,14 @@
 require "receipts/version"
 require "open-uri"
-require "prawn"
-require "prawn/table"
+require "receipts/pdf/geometry"
+require "receipts/pdf/writer"
+require "receipts/pdf/true_type"
+require "receipts/pdf/font"
+require "receipts/pdf/image"
+require "receipts/pdf/inline_format"
+require "receipts/pdf/text_layout"
+require "receipts/pdf/table"
+require "receipts/pdf/document"
 
 module Receipts
   autoload :Base, "receipts/base"