prawnx 0.1.1

data/lib/prawnx/text.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+module PrawnX
+  module Text
+    NBSP = " "
+    ZWSP = "​"
+    SHY = "­"
+
+    VALID_OPTIONS = %i[kerning size style].freeze
+    MODES = {fill: 0, stroke: 1, fill_stroke: 2, invisible: 3, fill_clip: 4, stroke_clip: 5, fill_stroke_clip: 6, clip: 7}.freeze
+
+    class BadFontFamily < StandardError
+      def initialize(message = "Bad font family")
+        super
+      end
+    end
+
+    def text(string, options = {})
+      return false if string.nil?
+
+      options = options.dup
+      inline_format = options.delete(:inline_format)
+      array =
+        if inline_format
+          text_formatter.format(string, *(inline_format.is_a?(Array) ? inline_format : []))
+        else
+          [{text: string}]
+        end
+      formatted_text(array, options)
+    end
+
+    def formatted_text(array, options = {})
+      options = inspect_options_for_text(options.dup)
+      color = options.delete(:color)
+      array = array.map { it[:color] ? it : it.merge(color:) } if color
+
+      if @indent_paragraphs
+        text_formatter.array_paragraphs(array).each do |paragraph|
+          remaining_text = draw_indented_formatted_line(paragraph, options)
+          if @no_text_printed && !@all_text_printed
+            @bounding_box.move_past_bottom
+            remaining_text = draw_indented_formatted_line(paragraph, options)
+          end
+          next if @all_text_printed
+
+          remaining_text = fill_formatted_text_box(remaining_text, options)
+          draw_remaining_formatted_text_on_new_pages(remaining_text, options)
+        end
+      else
+        remaining_text = fill_formatted_text_box(array, options)
+        draw_remaining_formatted_text_on_new_pages(remaining_text, options)
+      end
+    end
+
+    def text_box(string, options = {})
+      options = options.dup
+      options[:document] = self
+      inline_format = options.delete(:inline_format)
+      box =
+        if inline_format
+          Formatted::Box.new(text_formatter.format(string, *(inline_format.is_a?(Array) ? inline_format : [])), options)
+        else
+          Box.new(string, options)
+        end
+      box.render
+    end
+
+    def formatted_text_box(array, options = {})
+      Formatted::Box.new(array, options.merge(document: self)).render
+    end
+
+    def height_of(string, options = {})
+      height_of_formatted([{text: string}], options)
+    end
+
+    def height_of_formatted(array, options = {})
+      raise NotImplementedError, ":indent_paragraphs option not available with height_of" if options[:indent_paragraphs]
+
+      process_final_gap_option(options)
+      box = Formatted::Box.new(array, options.merge(height: 100_000_000, document: self))
+      box.render(dry_run: true)
+      @final_gap ? box.height + box.line_gap + box.leading : box.height
+    end
+
+    def draw_text(text, options)
+      options = inspect_options_for_draw_text(options.dup)
+      text = text.to_s.dup
+      save_font do
+        process_text_options(options)
+        text = font.normalize_encoding(text)
+        font_size(options[:size]) { draw_text!(text, options) }
+      end
+    end
+
+    def draw_text!(text, options)
+      unless font.unicode? || font.class.hide_m17n_warning || text.ascii_only?
+        warn "PDF's built-in fonts have very limited support for internationalized text.\n" \
+          "If you need full UTF-8 support, consider using an external font instead.\n\n" \
+          "To disable this warning, add the following line to your code:\nPrawn::Fonts::AFM.hide_m17n_warning = true\n"
+        font.class.hide_m17n_warning = true
+      end
+      x, y = map_to_absolute(options[:at])
+      add_text_content(text, x, y, options)
+    end
+
+    def process_text_options(options)
+      if options[:style]
+        raise BadFontFamily unless font.family
+
+        font(font.family, style: options[:style])
+      end
+      options[:kerning] = font.has_kerning_data? unless options[:kerning] == false
+      options[:size] ||= font_size
+    end
+
+    def default_kerning?
+      return true unless defined?(@default_kerning)
+
+      @default_kerning
+    end
+
+    def default_kerning(value)
+      @default_kerning = value
+    end
+    alias default_kerning= default_kerning
+
+    def default_leading(number = nil)
+      return @default_leading || 0 if number.nil?
+
+      @default_leading = number
+    end
+    alias default_leading= default_leading
+
+    def text_direction(direction = nil)
+      return @text_direction || :ltr if direction.nil?
+
+      @text_direction = direction
+    end
+    alias text_direction= text_direction
+
+    def fallback_fonts(fallback_fonts = nil)
+      return @fallback_fonts || [] if fallback_fonts.nil?
+
+      @fallback_fonts = fallback_fonts
+    end
+    alias fallback_fonts= fallback_fonts
+
+    def text_rendering_mode(mode = nil, &)
+      return @text_rendering_mode || :fill if mode.nil?
+      raise ArgumentError, "mode must be between one of #{MODES.keys.join(", ")} (#{mode})" unless MODES.key?(mode)
+      return yield if text_rendering_mode == mode
+
+      wrap_and_restore(:@text_rendering_mode, mode, -> { "\n#{MODES[text_rendering_mode]} Tr" }, &)
+    end
+
+    def forget_text_rendering_mode!
+      @text_rendering_mode = :unknown
+    end
+
+    def character_spacing(amount = nil, &)
+      return @character_spacing || 0 if amount.nil?
+      return yield if character_spacing == amount
+
+      wrap_and_restore(:@character_spacing, amount, -> { "\n#{PDF.real(character_spacing)} Tc" }, &)
+    end
+
+    def word_spacing(amount = nil, &)
+      return @word_spacing || 0 if amount.nil?
+      return yield if word_spacing == amount
+
+      wrap_and_restore(:@word_spacing, amount, -> { "\n#{PDF.real(word_spacing)} Tw" }, &)
+    end
+
+    def horizontal_text_scaling(amount = nil, &)
+      return @horizontal_text_scaling || 100 if amount.nil?
+      return yield if horizontal_text_scaling == amount
+
+      wrap_and_restore(:@horizontal_text_scaling, amount, -> { "\n#{PDF.real(horizontal_text_scaling)} Tz" }, &)
+    end
+
+    def rise(amount = nil, &)
+      return @rise || 0 if amount.nil?
+      return yield if rise == amount
+
+      wrap_and_restore(:@rise, amount, -> { "\n#{PDF.real(rise)} Ts" }, &)
+    end
+
+    def add_text_content(text, x, y, options)
+      chunks = font.encode_text(text, options.merge(word_spacing:, font_size:))
+      add_content("\nBT")
+      if options[:rotate]
+        radians = Float(options[:rotate]) * Math::PI / 180
+        add_content("#{PDF.real_params([Math.cos(radians), Math.sin(radians), -Math.sin(radians), Math.cos(radians), x, y])} Tm")
+      else
+        add_content("#{PDF.real(x)} #{PDF.real(y)} Td")
+      end
+      chunks.each do |subset, string|
+        font.add_to_current_page(subset)
+        add_content("#{PDF.serialize(font.identifier_for(subset), true)} #{PDF.serialize(font_size, true)} Tf")
+        operator = string.is_a?(Array) ? "TJ" : "Tj"
+        add_content("#{PDF.serialize(string, true)} #{operator}")
+      end
+      add_content("ET\n")
+    end
+
+    private
+
+    def draw_remaining_formatted_text_on_new_pages(remaining_text, options)
+      until remaining_text.empty?
+        @bounding_box.move_past_bottom
+        previous_remaining_text = remaining_text
+        remaining_text = fill_formatted_text_box(remaining_text, options)
+        break if remaining_text == previous_remaining_text
+      end
+    end
+
+    def draw_indented_formatted_line(string, options)
+      gap = options.fetch(:direction, text_direction) == :ltr ? [@indent_paragraphs, 0] : [0, @indent_paragraphs]
+      indent(*gap) { fill_formatted_text_box(string, options.merge(single_line: true)) }
+    end
+
+    def fill_formatted_text_box(text, options)
+      merge_text_box_positioning_options(options)
+      box = Formatted::Box.new(text, options)
+      remaining_text = box.render
+      @no_text_printed = box.nothing_printed?
+      @all_text_printed = box.everything_printed?
+      self.y -= box.height
+      self.y -= box.line_gap + box.leading if @final_gap || (options[:single_line] && !@all_text_printed)
+      remaining_text
+    end
+
+    def merge_text_box_positioning_options(options)
+      bottom = @bounding_box.stretchy? ? @margin_box.absolute_bottom : @bounding_box.absolute_bottom
+      options[:height] = y - bottom
+      options[:width] = bounds.width
+      options[:at] = [@bounding_box.left_side - @bounding_box.absolute_left, y - @bounding_box.absolute_bottom]
+    end
+
+    def inspect_options_for_text(options)
+      raise ArgumentError, ":at is no longer a valid option with text.use draw_text or text_box instead" if options[:at]
+
+      process_final_gap_option(options)
+      @indent_paragraphs = options.delete(:indent_paragraphs)
+      options[:document] = self
+      options
+    end
+
+    def process_final_gap_option(options)
+      @final_gap = options[:final_gap].nil? || options[:final_gap]
+      options.delete(:final_gap)
+    end
+
+    def move_text_position(amount)
+      bottom = @bounding_box.stretchy? ? @margin_box.absolute_bottom : @bounding_box.absolute_bottom
+      @bounding_box.move_past_bottom if (y - amount) < bottom
+      self.y -= amount
+    end
+
+    def wrap_and_restore(variable, value, operator)
+      original_value = instance_variable_get(variable)
+      instance_variable_set(variable, value)
+      add_content(operator.call)
+      begin
+        yield
+      ensure
+        instance_variable_set(variable, original_value)
+        add_content(operator.call)
+      end
+    end
+
+    def inspect_options_for_draw_text(options)
+      raise ArgumentError, "The :at option is required for draw_text" if options[:at].nil?
+      raise ArgumentError, "The :align option does not work with draw_text" if options[:align]
+
+      options[:kerning] = default_kerning? if options[:kerning].nil?
+      PrawnX.verify_options(VALID_OPTIONS + %i[at rotate], options)
+      options
+    end
+  end
+end

data/lib/prawnx/transformation_stack.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module PrawnX
+  # The current transformation matrix, tracked alongside the graphic state so gradients and soft masks can be
+  # placed in page space.
+  module TransformationStack
+    IDENTITY = [1, 0, 0, 1, 0, 0].freeze
+
+    def add_to_transformation_stack(a, b, c, d, e, f)
+      @transformation_stack ||= [IDENTITY.dup]
+      @transformation_stack.push(multiply(@transformation_stack.last, [a, b, c, d, e, f]))
+    end
+
+    def save_transformation_stack
+      @transformation_stack ||= [IDENTITY.dup]
+      @saved_transformation_stack_lengths ||= []
+      @saved_transformation_stack_lengths.push(@transformation_stack.length)
+    end
+
+    def restore_transformation_stack
+      return if @saved_transformation_stack_lengths.nil? || @saved_transformation_stack_lengths.empty?
+
+      @transformation_stack.pop(@transformation_stack.length - @saved_transformation_stack_lengths.pop)
+    end
+
+    def current_transformation_matrix_with_translation(x = 0, y = 0)
+      a, b, c, d, e, f = (@transformation_stack || [IDENTITY]).last
+      [a, b, c, d, (a * x) + (c * y) + e, (b * x) + (d * y) + f].map { Float(it) }
+    end
+
+    private
+
+    def multiply(first, second)
+      a1, b1, c1, d1, e1, f1 = first
+      a2, b2, c2, d2, e2, f2 = second
+      [
+        (a2 * a1) + (b2 * c1), (a2 * b1) + (b2 * d1),
+        (c2 * a1) + (d2 * c1), (c2 * b1) + (d2 * d1),
+        (e2 * a1) + (f2 * c1) + e1, (e2 * b1) + (f2 * d1) + f1,
+      ]
+    end
+  end
+end

data/lib/prawnx/true_type/cff_subset.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module PrawnX
+  module TrueType
+    # A Compact Font Format program (Adobe Technical Note #5176) keeping only the outlines a document uses: other
+    # glyphs become an empty charstring, so glyph indices and subroutines stay where they were.
+    class CffSubset
+      ENDCHAR = "\x0E".b
+      CHARSTRINGS = [17].freeze
+      PRIVATE = [18].freeze
+      CHARSET = [15].freeze
+      ENCODING = [16].freeze
+      FD_ARRAY = [12, 36].freeze
+      FD_SELECT = [12, 37].freeze
+      # Offsets 0 to 2 of charset and Encoding name predefined tables, not places in the font.
+      PREDEFINED_TABLE_LIMIT = 2
+      FIVE_BYTE_INTEGER = 29
+
+      def initialize(cff)
+        @cff = cff.b
+      end
+
+      def bytes(glyphs_kept)
+        build(glyphs_kept)
+      rescue *File::MALFORMED_FONT_ERRORS => exception
+        raise Error, "Malformed CFF font program: #{exception.message}"
+      end
+
+      private
+
+      def build(glyphs_kept)
+        header_size = @cff.getbyte(2)
+        _names, names_end = read_index(header_size)
+        top_dicts, top_end = read_index(names_end)
+        top_operators = parse_dict(top_dicts.first)
+
+        old_charstrings_offset = operands(top_operators, CHARSTRINGS).first
+        charstrings, = read_index(old_charstrings_offset)
+        kept = glyphs_kept.to_h { [it, true] }
+        new_charstrings = charstrings.each_with_index.map { |charstring, glyph| kept[glyph] ? charstring : ENDCHAR }
+
+        font_dicts = nil
+        if (fd_array_offset = operands(top_operators, FD_ARRAY).first)
+          font_dicts = read_index(fd_array_offset).first.map { parse_dict(it) }
+        end
+
+        # Every offset operand is written as a five-byte integer, so the new Top DICT's size is known before its
+        # offsets are: everything after it then moves by the same delta.
+        placeholder_top = encode_dict(relocated(top_operators, 0, 0, 0))
+        delta = index([placeholder_top]).bytesize - (top_end - names_end)
+        tail = @cff.byteslice(top_end..)
+        charstrings_offset = top_end + delta + tail.bytesize
+        appended = index(new_charstrings)
+        fd_array_new_offset = nil
+        if font_dicts
+          fd_array_new_offset = charstrings_offset + appended.bytesize
+          appended += index(font_dicts.map { encode_dict(relocated(it, delta, nil, nil)) })
+        end
+        new_top = encode_dict(relocated(top_operators, delta, charstrings_offset, fd_array_new_offset))
+        @cff.byteslice(0, names_end) + index([new_top]) + tail + appended
+      end
+
+      def read_index(offset)
+        count = @cff.unpack1("@#{offset} n")
+        return [[], offset + 2] if count.zero?
+
+        offset_size = @cff.getbyte(offset + 2)
+        offsets = Array.new(count + 1) { read_offset(offset + 3 + (it * offset_size), offset_size) }
+        data_start = offset + 3 + ((count + 1) * offset_size) - 1
+        items = offsets.each_cons(2).map { |first, last| @cff.byteslice(data_start + first, last - first) }
+        [items, data_start + offsets.last]
+      end
+
+      def read_offset(position, size)
+        @cff.byteslice(position, size).bytes.inject(0) { (_1 << 8) | _2 }
+      end
+
+      def index(items)
+        return [0].pack("n") if items.empty?
+
+        offsets = items.each_with_object([1]) { |item, list| list << (list.last + item.bytesize) }
+        offset_size = [1, 2, 3, 4].find { offsets.last < (1 << (8 * it)) }
+        packed_offsets = offsets.map { [it].pack("N").byteslice(4 - offset_size, offset_size) }.join
+        [items.size].pack("n") + offset_size.chr + packed_offsets + items.join.b
+      end
+
+      # [operator bytes, operand values, raw operand bytes] in order.
+      def parse_dict(data)
+        entries = []
+        operands = []
+        raw_start = 0
+        position = 0
+        while position < data.bytesize
+          byte = data.getbyte(position)
+          if byte <= 21
+            operator = byte == 12 ? [12, data.getbyte(position + 1)] : [byte]
+            position += operator.size
+            entries << [operator, operands, data.byteslice(raw_start, position - operator.size - raw_start)]
+            operands = []
+            raw_start = position
+          else
+            value, size = read_operand(data, position)
+            operands << value
+            position += size
+          end
+        end
+        entries
+      end
+
+      def read_operand(data, position)
+        byte = data.getbyte(position)
+        case byte
+        when 28 then [data.unpack1("@#{position + 1} s>"), 3]
+        when 29 then [data.unpack1("@#{position + 1} l>"), 5]
+        when 30
+          size = 1
+          loop do
+            nibbles = data.getbyte(position + size)
+            size += 1
+            break if (nibbles >> 4) == 0x0F || (nibbles & 0x0F) == 0x0F
+          end
+          [:real, size]
+        when 32..246 then [byte - 139, 1]
+        when 247..250 then [((byte - 247) * 256) + data.getbyte(position + 1) + 108, 2]
+        when 251..254 then [(-(byte - 251) * 256) - data.getbyte(position + 1) - 108, 2]
+        else raise Error, "Unexpected byte #{byte} in a CFF dictionary"
+        end
+      end
+
+      def operands(entries, operator)
+        entries.find { it[0] == operator }&.dig(1) || []
+      end
+
+      # Offsets into the font move by delta; CharStrings and FDArray point at their new copies at the end.
+      def relocated(entries, delta, charstrings_offset, fd_array_offset)
+        entries.map do |operator, values, raw|
+          new_values =
+            case operator
+            when CHARSTRINGS then charstrings_offset && [charstrings_offset]
+            when FD_ARRAY then fd_array_offset && [fd_array_offset]
+            when PRIVATE then [values[0], values[1] + delta]
+            when CHARSET, ENCODING then [values[0] > PREDEFINED_TABLE_LIMIT ? values[0] + delta : values[0]]
+            when FD_SELECT then [values[0] + delta]
+            end
+          [operator, new_values, raw]
+        end
+      end
+
+      def encode_dict(entries)
+        entries.each_with_object(+"".b) do |(operator, new_values, raw), dict|
+          dict << (new_values ? new_values.map { [FIVE_BYTE_INTEGER, it].pack("Cl>") }.join : raw)
+          dict << operator.pack("C*")
+        end
+      end
+    end
+  end
+end