receipts 2.3.0 → 3.0.0

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

data/lib/receipts/pdf/table.rb

@@ -0,0 +1,250 @@
+module Receipts
+  module PDF
+    # Simple tables with text cells, borders, padding and automatic column widths.
+    #
+    #   table(data, width: bounds.width, column_widths: [200, nil, 100], header: true,
+    #     cell_style: {padding: 6, borders: [:bottom], border_color: "eeeeee", inline_format: true}) do
+    #     row(0).font_style = :bold
+    #     column(-1).align = :right
+    #   end
+    #
+    # Cells may be strings, nil, or hashes with :content and cell options.
+    class Table
+      class Cell
+        attr_accessor :borders, :border_color, :border_width, :align, :font_style,
+          :size, :text_color, :background_color, :inline_format, :font, :leading
+        attr_reader :content, :padding
+
+        def initialize(document, options = {})
+          @document = document
+          @content = ""
+          @padding = [5, 5, 5, 5]
+          @borders = [:top, :right, :bottom, :left]
+          @border_color = "000000"
+          @border_width = 1
+          @align = :left
+          @inline_format = false
+          @leading = 0
+          options.each { |key, value| public_send(:"#{key}=", value) }
+        end
+
+        def content=(value)
+          @content = value.to_s
+        end
+
+        def padding=(value)
+          @padding = Geometry.expand_box(value)
+        end
+
+        def horizontal_padding
+          @padding[1] + @padding[3]
+        end
+
+        def vertical_padding
+          @padding[0] + @padding[2]
+        end
+
+        def text_options
+          {inline_format: @inline_format, style: @font_style, size: @size, color: @text_color, font: @font}.compact
+        end
+
+        def natural_width
+          measure.first + horizontal_padding
+        end
+
+        def minimum_width
+          measure.last + horizontal_padding
+        end
+
+        def lines(width)
+          @document.text_lines(@content, text_options, [width - horizontal_padding, 0].max)
+        end
+
+        private
+
+        def measure
+          @measure ||= @document.measure_text(@content, text_options)
+        end
+      end
+
+      # A selection of cells. Assigning an attribute sets it on every cell: `row(0).borders = [:bottom]`
+      class Cells < Array
+        def style(options)
+          options.each { |key, value| public_send(:"#{key}=", value) }
+          self
+        end
+
+        def method_missing(name, *args, &block)
+          if name.to_s.end_with?("=") && Cell.method_defined?(name)
+            each { |cell| cell.public_send(name, *args) }
+          else
+            super
+          end
+        end
+
+        def respond_to_missing?(name, include_private = false)
+          (name.to_s.end_with?("=") && Cell.method_defined?(name)) || super
+        end
+      end
+
+      def initialize(document, data, options = {}, &block)
+        @document = document
+        @width = options[:width]
+        @column_widths = options[:column_widths]
+        @header = options[:header]
+        @position = options.fetch(:position, :left)
+        cell_style = options.fetch(:cell_style, {})
+
+        columns = data.map { |row| Array(row).size }.max || 0
+        @rows = data.map do |row|
+          row = Array(row)
+          Array.new(columns) do |index|
+            value = row[index]
+            Cell.new(document, cell_style.merge(value.is_a?(Hash) ? value : {content: value}))
+          end
+        end
+
+        return unless block
+        (block.arity == 1) ? block.call(self) : instance_exec(&block)
+      end
+
+      def cells
+        Cells.new(@rows.flatten)
+      end
+
+      def row(selector)
+        Cells.new(select(@rows, selector).flatten)
+      end
+      alias_method :rows, :row
+
+      def column(selector)
+        Cells.new(@rows.flat_map { |row| select(row, selector) })
+      end
+      alias_method :columns, :column
+
+      def column_widths
+        @computed_column_widths ||= compute_column_widths
+      end
+
+      def draw
+        widths = column_widths
+        bounds = @document.bounds
+        x = bounds.absolute_left + Geometry.align_offset(@position, bounds.width, widths.sum)
+
+        header_count = case @header
+        when true then 1
+        when Integer then @header
+        else 0
+        end
+        headers = @rows.first(header_count).map { |row| [row, *layout_row(row, widths)] }
+
+        @rows.each_with_index do |row, index|
+          lines, height = layout_row(row, widths)
+
+          if @document.start_new_page_if_needed(height) && index >= header_count
+            headers.each { |header, header_lines, header_height| draw_row(header, header_lines, header_height, widths, x) }
+          end
+
+          draw_row(row, lines, height, widths, x)
+        end
+
+        nil
+      end
+
+      private
+
+      def select(list, selector)
+        selector.is_a?(Integer) ? [list[selector]].compact : Array(list[selector])
+      end
+
+      def layout_row(row, widths)
+        lines = row.each_with_index.map { |cell, index| cell.lines(widths[index]) }
+        height = row.each_with_index.map do |cell, index|
+          TextLayout.height_of(lines[index], cell.leading) + cell.vertical_padding
+        end.max || 0
+        [lines, height]
+      end
+
+      def draw_row(row, lines, height, widths, x)
+        top = @document.y
+
+        row.each_with_index do |cell, index|
+          width = widths[index]
+          bottom = top - height
+
+          @document.fill_rectangle(x, bottom, width, height, color: cell.background_color) if cell.background_color
+
+          @document.draw_text_lines(lines[index], x + cell.padding[3], top - cell.padding[0],
+            width - cell.horizontal_padding, align: cell.align, leading: cell.leading)
+
+          edges = {top: [x, top, x + width, top], bottom: [x, bottom, x + width, bottom], left: [x, top, x, bottom], right: [x + width, top, x + width, bottom]}
+          edges.values_at(*Array(cell.borders)).compact.each do |edge|
+            @document.stroke_line(*edge, color: cell.border_color, width: cell.border_width)
+          end
+
+          x += width
+        end
+
+        @document.y = top - height
+      end
+
+      # Columns start at their natural (unwrapped) width. When the table is too wide,
+      # narrow columns keep their width and wider columns shrink proportionally, never past the table width.
+      # When a table width is given and there's space left over, it's split evenly between columns.
+      def compute_column_widths
+        count = @rows.first&.size || 0
+        natural = Array.new(count) { |i| @rows.map { |row| row[i].natural_width }.max }
+        minimum = Array.new(count) { |i| @rows.map { |row| row[i].minimum_width }.max }
+
+        fixed = case @column_widths
+        when Array then @column_widths.each_with_index.map { |width, i| [i, width] }.reject { |_, width| width.nil? }.to_h
+        when Hash then @column_widths
+        when Numeric then (0...count).map { |i| [i, @column_widths] }.to_h
+        else {}
+        end
+
+        widths = natural.dup
+        fixed.each { |i, width| widths[i] = width }
+        flexible = (0...count).reject { |i| fixed.key?(i) }
+        return widths if flexible.empty?
+
+        target = @width || [widths.sum, @document.bounds.width].min
+        available = target - fixed.values.sum
+        flexible_natural = flexible.sum { |i| natural[i] }
+
+        if flexible_natural > available
+          budget = available
+          columns = flexible.dup
+          loop do
+            share = budget / columns.size.to_f
+            narrow = columns.select { |i| natural[i] <= share }
+            break if narrow.empty?
+            budget -= narrow.sum { |i| natural[i] }
+            columns -= narrow
+            break if columns.empty?
+          end
+
+          # The rest share the budget in proportion to their natural width, but not below their widest
+          # word. If the widest words can't all fit, words are broken rather than overflowing the table.
+          loop do
+            total = columns.sum { |i| natural[i] }
+            break if total.zero?
+            short = columns.select { |i| budget * natural[i] / total < minimum[i] }
+            break if short.empty? || short.sum { |i| minimum[i] } >= budget
+            short.each { |i| widths[i] = minimum[i] }
+            budget -= short.sum { |i| minimum[i] }
+            columns -= short
+          end
+
+          total = columns.sum { |i| natural[i] }
+          columns.each { |i| widths[i] = total.zero? ? 0 : [budget * natural[i] / total, 0].max }
+        elsif @width && flexible_natural < available
+          extra = (available - flexible_natural) / flexible.size.to_f
+          flexible.each { |i| widths[i] += extra }
+        end
+
+        widths
+      end
+    end
+  end
+end