receipts 2.4.0 → 3.0.0

data/lib/receipts/pdf/font.rb

@@ -0,0 +1,168 @@
+module Receipts
+  module PDF
+    # A TrueType font used in a document. Tracks which glyphs are used so only
+    # those are embedded when the document is rendered.
+    class Font
+      # Skew applied to fake an italic style when a font family has no italic font
+      OBLIQUE_SKEW = Math.tan(12 * Math::PI / 180)
+
+      attr_reader :ttf
+
+      def initialize(path)
+        @ttf = TrueType.load(path)
+        @used = {}
+        @widths = {}
+      end
+
+      def width_of(text, size, character_spacing: 0)
+        units = text.each_char.sum { |char| @widths[char] ||= @ttf.advance(@ttf.glyph_id(char.ord)) }
+        scale(units, size) + character_spacing * text.length
+      end
+
+      def ascender(size)
+        scale(@ttf.ascender, size)
+      end
+
+      # Distance below the baseline, as a positive number
+      def descender(size)
+        -scale(@ttf.descender, size)
+      end
+
+      def line_gap(size)
+        scale(@ttf.line_gap, size)
+      end
+
+      def underline_position(size)
+        scale(@ttf.underline_position, size)
+      end
+
+      def underline_thickness(size)
+        scale(@ttf.underline_thickness, size)
+      end
+
+      def strikeout_position(size)
+        scale(@ttf.strikeout_position, size)
+      end
+
+      def strikeout_size(size)
+        scale(@ttf.strikeout_size, size)
+      end
+
+      def bold?
+        @ttf.weight >= 600
+      end
+
+      # Encodes text as 2-byte original glyph IDs (Identity-H encoding)
+      def encode(text)
+        text.each_char.map do |char|
+          gid = @ttf.glyph_id(char.ord)
+          @used[gid] ||= char
+          gid
+        end.pack("n*")
+      end
+
+      def build(writer)
+        gids = @used.keys.sort
+        subset, mapping = @ttf.subset(gids)
+        name = :"#{subset_tag(gids)}+#{@ttf.postscript_name}"
+
+        font_file = writer.add(Stream.new(subset, {Length1: subset.bytesize}))
+        descriptor = writer.add(
+          Type: :FontDescriptor,
+          FontName: name,
+          Flags: flags,
+          FontBBox: @ttf.bbox.map { |v| to_glyph_space(v) },
+          ItalicAngle: @ttf.italic_angle,
+          Ascent: to_glyph_space(@ttf.ascender),
+          Descent: to_glyph_space(@ttf.descender),
+          CapHeight: to_glyph_space(@ttf.cap_height),
+          XHeight: to_glyph_space(@ttf.x_height),
+          StemV: bold? ? 120 : 80,
+          FontFile2: font_file
+        )
+        cid_font = writer.add(
+          Type: :Font,
+          Subtype: :CIDFontType2,
+          BaseFont: name,
+          CIDSystemInfo: {Registry: "Adobe", Ordering: "Identity", Supplement: 0},
+          FontDescriptor: descriptor,
+          DW: to_glyph_space(@ttf.advance(0)),
+          W: glyph_widths(gids),
+          CIDToGIDMap: writer.add(Stream.new(cid_to_gid_map(gids, mapping)))
+        )
+        writer.add(
+          Type: :Font,
+          Subtype: :Type0,
+          BaseFont: name,
+          Encoding: :"Identity-H",
+          DescendantFonts: [cid_font],
+          ToUnicode: writer.add(Stream.new(to_unicode_cmap))
+        )
+      end
+
+      private
+
+      def scale(units, size)
+        units * size / @ttf.units_per_em.to_f
+      end
+
+      def to_glyph_space(units)
+        (units * 1000.0 / @ttf.units_per_em).round
+      end
+
+      def flags
+        flags = 32 # Nonsymbolic
+        flags |= 1 if @ttf.fixed_pitch?
+        flags |= 64 unless @ttf.italic_angle.zero?
+        flags
+      end
+
+      # Subset fonts are named with a tag of 6 uppercase letters, like ABCDEF+Inter-Regular
+      def subset_tag(gids)
+        Digest::MD5.digest(gids.pack("n*") + @ttf.postscript_name).bytes.first(6).map { |b| (65 + b % 26).chr }.join
+      end
+
+      # Text is encoded with the original glyph IDs as CIDs. This maps them to the renumbered subset glyphs.
+      def cid_to_gid_map(gids, mapping)
+        map = Array.new((gids.max || 0) + 1, 0)
+        gids.each { |gid| map[gid] = mapping.fetch(gid) }
+        map.pack("n*")
+      end
+
+      # Widths array grouping consecutive glyph IDs: [first [w1 w2 ...] first [w1 ...]]
+      def glyph_widths(gids)
+        gids.slice_when { |a, b| b != a + 1 }.flat_map do |run|
+          [run.first, run.map { |gid| to_glyph_space(@ttf.advance(gid)) }]
+        end
+      end
+
+      # Maps glyph IDs back to Unicode so text can be copied and searched
+      def to_unicode_cmap
+        mappings = @used.sort.map do |gid, char|
+          format("<%04X> <%s>", gid, char.encode(Encoding::UTF_16BE).unpack1("H*").upcase)
+        end
+
+        blocks = mappings.each_slice(100).map do |slice|
+          "#{slice.size} beginbfchar\n#{slice.join("\n")}\nendbfchar"
+        end
+
+        <<~CMAP
+          /CIDInit /ProcSet findresource begin
+          12 dict begin
+          begincmap
+          /CIDSystemInfo << /Registry (Adobe) /Ordering (UCS) /Supplement 0 >> def
+          /CMapName /Adobe-Identity-UCS def
+          /CMapType 2 def
+          1 begincodespacerange
+          <0000> <FFFF>
+          endcodespacerange
+          #{blocks.join("\n")}
+          endcmap
+          CMapName currentdict /CMap defineresource pop
+          end
+          end
+        CMAP
+      end
+    end
+  end
+end

data/lib/receipts/pdf/geometry.rb

@@ -0,0 +1,29 @@
+module Receipts
+  module PDF
+    module Geometry
+      module_function
+
+      # [top, right, bottom, left] from a number, [vertical, horizontal], [top, horizontal, bottom] or [top, right, bottom, left]
+      def expand_box(value)
+        values = Array(value)
+        case values.size
+        when 1 then values * 4
+        when 2 then [values[0], values[1], values[0], values[1]]
+        when 3 then [values[0], values[1], values[2], values[1]]
+        else values.first(4)
+        end
+      end
+
+      # Offset that aligns content of the used width within the available width.
+      # Position is :left, :center, :right or an offset.
+      def align_offset(position, available, used)
+        case position
+        when :center then (available - used) / 2.0
+        when :right then available - used
+        when Numeric then position
+        else 0
+        end
+      end
+    end
+  end
+end

data/lib/receipts/pdf/image.rb

@@ -0,0 +1,242 @@
+module Receipts
+  module PDF
+    class UnsupportedImageError < StandardError; end
+
+    module Image
+      PNG_SIGNATURE = "\x89PNG\r\n\x1A\n".b
+
+      # Recently used images, keyed by content, so a logo used on every receipt is only decoded once
+      CACHE = {}
+      CACHE_MUTEX = Mutex.new
+      CACHE_SIZE = 16
+
+      # Accepts a path, Pathname, or IO-like object
+      def self.load(source)
+        data = if source.respond_to?(:read)
+          source.binmode if source.respond_to?(:binmode)
+          source.rewind if source.respond_to?(:rewind)
+          source.read
+        else
+          File.binread(source.to_s)
+        end.b
+
+        key = Digest::MD5.digest(data)
+        CACHE_MUTEX.synchronize do
+          CACHE[key] ||= parse(data)
+          CACHE.shift while CACHE.size > CACHE_SIZE
+          CACHE[key]
+        end
+      end
+
+      def self.parse(data)
+        if data.start_with?("\xFF\xD8".b)
+          JPEG.new(data)
+        elsif data.start_with?(PNG_SIGNATURE)
+          PNG.new(data)
+        else
+          raise UnsupportedImageError, "only PNG and JPEG images are supported"
+        end
+      end
+
+      def self.xobject(width, height, color_space, bits)
+        {Type: :XObject, Subtype: :Image, Width: width, Height: height, ColorSpace: color_space, BitsPerComponent: bits}
+      end
+
+      class JPEG
+        START_OF_FRAME = [0xC0..0xC3, 0xC5..0xC7, 0xC9..0xCB, 0xCD..0xCF].freeze
+        COLOR_SPACES = {1 => :DeviceGray, 3 => :DeviceRGB, 4 => :DeviceCMYK}.freeze
+
+        attr_reader :width, :height
+
+        def initialize(data)
+          @data = data
+          pos = 2
+
+          while pos + 4 <= data.bytesize
+            raise UnsupportedImageError, "invalid JPEG image" unless data.getbyte(pos) == 0xFF
+            marker = data.getbyte(pos + 1)
+            if marker == 0xFF # fill byte
+              pos += 1
+              next
+            end
+
+            length = data.byteslice(pos + 2, 2).unpack1("n")
+            @adobe = true if marker == 0xEE && data.byteslice(pos + 4, 5) == "Adobe"
+
+            if START_OF_FRAME.any? { |range| range.cover?(marker) }
+              @bits, @height, @width, @components = data.byteslice(pos + 4, 6).unpack("CnnC")
+              break
+            end
+
+            pos += 2 + length
+          end
+
+          raise UnsupportedImageError, "invalid JPEG image" unless @width
+          raise UnsupportedImageError, "unsupported JPEG color components: #{@components}" unless COLOR_SPACES.key?(@components)
+        end
+
+        def build(writer)
+          dictionary = Image.xobject(@width, @height, COLOR_SPACES.fetch(@components), @bits).merge(Filter: :DCTDecode)
+          # Adobe CMYK JPEGs store inverted values
+          dictionary[:Decode] = [1, 0] * 4 if @components == 4 && @adobe
+          writer.add(Stream.new(@data, dictionary))
+        end
+      end
+
+      class PNG
+        CHANNELS = {0 => 1, 2 => 3, 3 => 1, 4 => 2, 6 => 4}.freeze
+
+        attr_reader :width, :height
+
+        def initialize(data)
+          @idat = String.new(encoding: Encoding::BINARY)
+          pos = PNG_SIGNATURE.bytesize
+
+          while pos + 8 <= data.bytesize
+            length, type = data.byteslice(pos, 8).unpack("Na4")
+            chunk = data.byteslice(pos + 8, length)
+
+            case type
+            when "IHDR" then @width, @height, @bit_depth, @color_type, _, _, @interlace = chunk.unpack("NNCCCCC")
+            when "PLTE" then @palette = chunk
+            when "tRNS" then @transparency = chunk
+            when "IDAT" then @idat << chunk
+            when "IEND" then break
+            end
+
+            pos += 12 + length
+          end
+
+          raise UnsupportedImageError, "invalid PNG image" unless @width && CHANNELS.key?(@color_type)
+          raise UnsupportedImageError, "interlaced PNG images are not supported" if @interlace == 1
+        end
+
+        def build(writer)
+          if @color_type == 4 || @color_type == 6
+            dictionary = Image.xobject(@width, @height, color_space, 8).merge(Filter: :FlateDecode, SMask: soft_mask(writer))
+            return writer.add(Stream.new(decoded[:color], dictionary))
+          end
+
+          # Compressed PNG data can be embedded directly using the PNG predictor
+          dictionary = Image.xobject(@width, @height, color_space, @bit_depth).merge(
+            Filter: :FlateDecode,
+            DecodeParms: {Predictor: 15, Colors: CHANNELS[@color_type], BitsPerComponent: @bit_depth, Columns: @width}
+          )
+
+          if @transparency && @color_type == 3
+            dictionary[:SMask] = soft_mask(writer)
+          elsif @transparency
+            # Color key masking: [min max] per channel
+            dictionary[:Mask] = @transparency.unpack("n*").first(CHANNELS[@color_type]).flat_map { |v| [v, v] }
+          end
+
+          writer.add(Stream.new(@idat, dictionary))
+        end
+
+        private
+
+        def color_space
+          case @color_type
+          when 0, 4 then :DeviceGray
+          when 2, 6 then :DeviceRGB
+          when 3 then [:Indexed, :DeviceRGB, @palette.bytesize / 3 - 1, HexString.new(@palette)]
+          end
+        end
+
+        def soft_mask(writer)
+          dictionary = Image.xobject(@width, @height, :DeviceGray, 8).merge(Filter: :FlateDecode)
+          writer.add(Stream.new(decoded[:alpha], dictionary))
+        end
+
+        # Compressed color and alpha data, memoized since images are cached across documents
+        def decoded
+          @decoded ||= begin
+            color, alpha = (@color_type == 3) ? [nil, palette_alpha] : split_alpha
+            {color: color && Zlib::Deflate.deflate(color), alpha: Zlib::Deflate.deflate(alpha)}
+          end
+        end
+
+        # Alpha channel for palette images from the per-palette-entry tRNS values
+        def palette_alpha
+          alphas = @transparency.bytes
+          alpha = String.new(capacity: @width * @height, encoding: Encoding::BINARY)
+
+          each_row(1, (@width * @bit_depth + 7) / 8) do |row|
+            indexes = if @bit_depth == 8
+              row
+            else
+              row.pack("C*").unpack1("B*").scan(/.{#{@bit_depth}}/).first(@width).map { |bits| bits.to_i(2) }
+            end
+            alpha << indexes.map { |index| alphas[index] || 255 }.pack("C*")
+          end
+          alpha
+        end
+
+        # Splits gray+alpha or RGBA pixels into color and alpha, reduced to 8 bits per sample
+        def split_alpha
+          channels = CHANNELS[@color_type]
+          sample = @bit_depth / 8
+          step = channels * sample
+          # Positions of each sample's high byte within a row
+          color_bytes = Array.new(@width) { |x| Array.new(channels - 1) { |c| x * step + c * sample } }.flatten
+          alpha_bytes = Array.new(@width) { |x| x * step + (channels - 1) * sample }
+
+          color = String.new(capacity: @width * @height * (channels - 1), encoding: Encoding::BINARY)
+          alpha = String.new(capacity: @width * @height, encoding: Encoding::BINARY)
+          each_row(step, @width * step) do |row|
+            color << row.values_at(*color_bytes).pack("C*")
+            alpha << row.values_at(*alpha_bytes).pack("C*")
+          end
+          [color, alpha]
+        end
+
+        # Decompresses the image data and reverses the per-row PNG filters, yielding each row's bytes
+        def each_row(bpp, row_bytes)
+          data = Zlib::Inflate.inflate(@idat)
+          previous = Array.new(row_bytes, 0)
+
+          @height.times do |y|
+            pos = y * (row_bytes + 1)
+            filter = data.getbyte(pos)
+            row = data.byteslice(pos + 1, row_bytes).bytes
+
+            case filter
+            when 0
+              nil
+            when 1
+              (bpp...row_bytes).each { |i| row[i] = (row[i] + row[i - bpp]) & 0xFF }
+            when 2
+              row_bytes.times { |i| row[i] = (row[i] + previous[i]) & 0xFF }
+            when 3
+              row_bytes.times do |i|
+                left = (i >= bpp) ? row[i - bpp] : 0
+                row[i] = (row[i] + ((left + previous[i]) >> 1)) & 0xFF
+              end
+            when 4
+              row_bytes.times do |i|
+                a = (i >= bpp) ? row[i - bpp] : 0
+                b = previous[i]
+                c = (i >= bpp) ? previous[i - bpp] : 0
+                p = a + b - c
+                pa = (p - a).abs
+                pb = (p - b).abs
+                pc = (p - c).abs
+                predictor = if pa <= pb && pa <= pc
+                  a
+                else
+                  (pb <= pc) ? b : c
+                end
+                row[i] = (row[i] + predictor) & 0xFF
+              end
+            else
+              raise UnsupportedImageError, "invalid PNG filter type: #{filter}"
+            end
+
+            yield row
+            previous = row
+          end
+        end
+      end
+    end
+  end
+end

data/lib/receipts/pdf/inline_format.rb

@@ -0,0 +1,79 @@
+module Receipts
+  module PDF
+    # Parses HTML-like inline formatting into styled text fragments:
+    #   <b> <strong> <i> <em> <u> <strikethrough> <sub> <sup> <br>
+    #   <font name="..." size="..." character_spacing="...">
+    #   <color rgb="#ff0000"> or <color c="0" m="100" y="100" k="0">
+    #   <link href="..."> or <a href="...">
+    #
+    # Each fragment is a Hash with :text and any of :styles, :color, :link,
+    # :font, :size and :character_spacing.
+    module InlineFormat
+      TAG = %r{<(/?)(b|strong|i|em|u|strikethrough|sub|sup|font|color|link|a|br)(\s[^>]*?)?\s*/?>}i
+      ATTRIBUTE = /(\w+)\s*=\s*(?:"([^"]*)"|'([^']*)')/
+      ENTITIES = {"&lt;" => "<", "&gt;" => ">", "&amp;" => "&"}.freeze
+      STYLES = {
+        "b" => :bold, "strong" => :bold, "i" => :italic, "em" => :italic, "u" => :underline,
+        "strikethrough" => :strikethrough, "sub" => :subscript, "sup" => :superscript
+      }.freeze
+
+      module_function
+
+      def parse(string)
+        fragments = []
+        stack = [[nil, {}]]
+        pos = 0
+
+        while (match = TAG.match(string, pos))
+          add(fragments, string[pos...match.begin(0)], stack.last.last)
+          name = match[2].downcase
+
+          if name == "br"
+            add(fragments, "\n", stack.last.last)
+          elsif match[1] == "/"
+            index = stack.rindex { |tag, _| tag == name }
+            stack = stack.first(index) if index
+          else
+            stack.push([name, apply(stack.last.last, name, attributes(match[3].to_s))])
+          end
+
+          pos = match.end(0)
+        end
+
+        add(fragments, string[pos..], stack.last.last)
+        fragments
+      end
+
+      def add(fragments, text, style)
+        return if text.empty?
+        fragments << style.merge(text: text.gsub(/&(?:lt|gt|amp);/, ENTITIES))
+      end
+
+      def attributes(string)
+        string.scan(ATTRIBUTE).map { |key, double, single| [key.downcase, double || single] }.to_h
+      end
+
+      def apply(style, name, attributes)
+        style = style.dup
+
+        if STYLES.key?(name)
+          style[:styles] = Array(style[:styles]) | [STYLES[name]]
+        elsif name == "font"
+          style[:font] = attributes["name"] if attributes["name"]
+          style[:size] = attributes["size"].to_f if attributes["size"]
+          style[:character_spacing] = attributes["character_spacing"].to_f if attributes["character_spacing"]
+        elsif name == "color"
+          if attributes["rgb"]
+            style[:color] = attributes["rgb"].delete("#")
+          elsif %w[c m y k].all? { |key| attributes.key?(key) }
+            style[:color] = attributes.values_at("c", "m", "y", "k").map(&:to_f)
+          end
+        elsif attributes["href"]
+          style[:link] = attributes["href"]
+        end
+
+        style
+      end
+    end
+  end
+end