gamba 2.0.0

data/lib/gamba/text/formatted/arranger.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+module Prawn
+  module Text
+    module Formatted
+      # Hands the line wrapper one string at a time out of formatted text, takes back what did not fit, and
+      # measures the fragments of each finished line.
+      class Arranger
+        class NotFinalized < StandardError
+          DEFAULT_MESSAGE = "Lines must be finalized"
+
+          def initialize(message = DEFAULT_MESSAGE, method: nil)
+            super((method && message == DEFAULT_MESSAGE) ? "Lines must be finalized before calling ##{method}" : message)
+          end
+        end
+
+        class BadFontFamily < StandardError
+          def initialize(message = "Bad font family")
+            super
+          end
+        end
+
+        # Relative size of subscript and superscript text.
+        SCRIPT_SIZE_RATIO = 0.583
+
+        attr_reader :max_line_height, :max_descender, :max_ascender, :finalized, :unconsumed, :fragments, :current_format_state
+        attr_accessor :consumed
+
+        def initialize(document, options = {})
+          @document = document
+          @fragments = []
+          @unconsumed = []
+          @kerning = options[:kerning]
+        end
+
+        def space_count
+          raise NotFinalized.new(method: "space_count") unless finalized
+
+          @fragments.sum(&:space_count)
+        end
+
+        def line_width
+          raise NotFinalized.new(method: "line_width") unless finalized
+
+          @fragments.inject(0) { |sum, fragment| sum + fragment.width }
+        end
+
+        def line
+          raise NotFinalized.new(method: "line") unless finalized
+
+          @fragments.map do |fragment|
+            fragment.text.encode(::Encoding::UTF_8)
+          rescue ::Encoding::InvalidByteSequenceError, ::Encoding::UndefinedConversionError
+            fragment.text.dup.force_encoding(::Encoding::UTF_8)
+          end.join
+        end
+
+        def finalize_line
+          @finalized = true
+          omit_trailing_whitespace_from_line_width
+          @fragments = []
+          @consumed.each do |hash|
+            fragment = Fragment.new(hash[:text], hash.except(:text), @document)
+            @fragments << fragment
+            measure(fragment)
+            @max_line_height = [@max_line_height, fragment.line_height].compact.max
+            @max_descender = [@max_descender, fragment.descender].compact.max
+            @max_ascender = [@max_ascender, fragment.ascender].compact.max
+          end
+        end
+
+        def format_array=(array)
+          initialize_line
+          @unconsumed = []
+          array.each do |hash|
+            hash[:text].scan(/[^\n]+|\n/) { |line| @unconsumed << hash.merge(text: line) }
+          end
+        end
+
+        def initialize_line
+          @finalized = false
+          @max_line_height = 0
+          @max_descender = 0
+          @max_ascender = 0
+          @consumed = []
+          @fragments = []
+        end
+
+        def finished?
+          @unconsumed.empty?
+        end
+
+        def next_string
+          raise NotFinalized.new(method: "next_string") if finalized
+
+          next_unconsumed_hash = @unconsumed.shift
+          return unless next_unconsumed_hash
+
+          @consumed << next_unconsumed_hash.dup
+          @current_format_state = next_unconsumed_hash.except(:text)
+          next_unconsumed_hash[:text]
+        end
+
+        def preview_next_string
+          @unconsumed.first&.fetch(:text)
+        end
+
+        def apply_color_and_font_settings(fragment, &)
+          return apply_font_settings(fragment, &) unless fragment.color
+
+          original_fill_color = @document.fill_color
+          original_stroke_color = @document.stroke_color
+          @document.fill_color(*fragment.color)
+          @document.stroke_color(*fragment.color)
+          apply_font_settings(fragment, &)
+          @document.stroke_color = original_stroke_color
+          @document.fill_color = original_fill_color
+        end
+
+        def apply_font_settings(fragment = nil, &)
+          if fragment
+            font = fragment.font
+            size = fragment.size
+            character_spacing = fragment.character_spacing
+            styles = fragment.styles
+          else
+            font = current_format_state[:font]
+            size = current_format_state[:size]
+            character_spacing = current_format_state[:character_spacing] || @document.character_spacing
+            styles = current_format_state[:styles]
+          end
+          font_style = font_style(styles)
+
+          @document.character_spacing(character_spacing) do
+            if font || font_style != :normal
+              raise BadFontFamily unless @document.font.family
+
+              @document.font(font || @document.font.family, style: font_style) { apply_font_size(size, styles, &) }
+            else
+              apply_font_size(size, styles, &)
+            end
+          end
+        end
+
+        def update_last_string(printed, unprinted, normalized_soft_hyphen = nil)
+          return if printed.nil?
+
+          if printed.empty?
+            @consumed.pop
+          else
+            @consumed.last[:text] = printed
+            @consumed.last[:normalized_soft_hyphen] = normalized_soft_hyphen if normalized_soft_hyphen
+          end
+          @unconsumed.unshift(@current_format_state.merge(text: unprinted)) unless unprinted.empty?
+          load_previous_format_state if printed.empty?
+        end
+
+        def retrieve_fragment
+          raise NotFinalized, "Lines must be finalized before fragments can be retrieved" unless finalized
+
+          @fragments.shift
+        end
+
+        def repack_unretrieved
+          new_unconsumed = []
+          while (fragment = retrieve_fragment)
+            fragment.include_trailing_white_space!
+            new_unconsumed << fragment.format_state.merge(text: fragment.text)
+          end
+          @unconsumed = new_unconsumed.concat(@unconsumed)
+        end
+
+        def font_style(styles)
+          styles = Array(styles)
+          bold = styles.include?(:bold)
+          italic = styles.include?(:italic)
+          if bold && italic then :bold_italic
+          elsif bold then :bold
+          elsif italic then :italic
+          else :normal
+          end
+        end
+
+        private
+
+        def load_previous_format_state
+          @current_format_state = @consumed.empty? ? {} : @consumed.last.except(:text)
+        end
+
+        def apply_font_size(size, styles, &)
+          if styles&.include?(:subscript) || styles&.include?(:superscript)
+            size = (size || @document.font_size) * SCRIPT_SIZE_RATIO
+          end
+          size.nil? ? yield : @document.font_size(size, &)
+        end
+
+        def omit_trailing_whitespace_from_line_width
+          @consumed.reverse_each do |hash|
+            break if hash[:text] == "\n"
+
+            hash[:exclude_trailing_white_space] = true
+            break unless hash[:text].strip.empty? && @consumed.length > 1
+          end
+        end
+
+        def measure(fragment)
+          apply_font_settings(fragment) do
+            fragment.width = @document.width_of(fragment.text, kerning: @kerning)
+            fragment.line_height = @document.font.height
+            fragment.descender = @document.font.descender
+            fragment.ascender = @document.font.ascender
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gamba/text/formatted/box.rb

@@ -0,0 +1,312 @@
+# frozen_string_literal: true
+
+module Prawn
+  module Text
+    module Formatted
+      # Formatted text laid out in a rectangle: wrapped, aligned, shrunk or truncated to fit, possibly rotated.
+      class Box
+        include Wrap
+
+        VALID_OPTIONS = (Text::VALID_OPTIONS + %i[
+          at height width align valign rotate rotate_around overflow min_font_size disable_wrap_by_char leading
+          character_spacing mode single_line document direction fallback_fonts draw_text_callback
+        ]).freeze
+        DEFAULT_MINIMUM_FONT_SIZE = 5
+        SHRINK_STEP = 0.5
+
+        attr_reader :text, :at, :line_height, :ascender, :descender, :leading
+
+        # Modules every new box of this class extends itself with: a subclass starts with its parent's.
+        def self.extensions
+          @extensions ||= []
+        end
+
+        def self.inherited(subclass)
+          super
+          subclass.extensions.concat(extensions)
+        end
+
+        def initialize(formatted_text, options = {})
+          @inked = false
+          self.class.extensions.reverse_each { extend(_1) }
+          Prawn.verify_options(valid_options, options)
+          options = options.dup
+          @overflow = options[:overflow] || :truncate
+          @disable_wrap_by_char = options[:disable_wrap_by_char]
+          @original_array = formatted_text
+          @text = nil
+          @document = options[:document]
+          @direction = options[:direction] || @document.text_direction
+          @fallback_fonts = options[:fallback_fonts] || @document.fallback_fonts
+          @at = (options[:at] || [@document.bounds.left, @document.bounds.top]).dup
+          @width = options[:width] || (@document.bounds.right - @at[0])
+          @height = options[:height] || default_height
+          @align = options[:align] || ((@direction == :rtl) ? :right : :left)
+          @vertical_align = options[:valign] || :top
+          @leading = options[:leading] || @document.default_leading
+          @character_spacing = options[:character_spacing] || @document.character_spacing
+          @mode = options[:mode] || @document.text_rendering_mode
+          @mode = :fill if @mode == :unknown
+          @rotate = options[:rotate] || 0
+          @rotate_around = options[:rotate_around] || :upper_left
+          @single_line = options[:single_line]
+          @draw_text_callback = options[:draw_text_callback]
+          if @overflow == :expand
+            @height = default_height
+            @overflow = :truncate
+          end
+          @min_font_size = options[:min_font_size] || DEFAULT_MINIMUM_FONT_SIZE
+          options[:kerning] = @document.default_kerning? if options[:kerning].nil?
+          @options = {kerning: options[:kerning], size: options[:size], style: options[:style]}
+          super
+        end
+
+        def nothing_printed?
+          @nothing_printed
+        end
+
+        def everything_printed?
+          @everything_printed
+        end
+
+        def line_gap
+          line_height - (ascender + descender)
+        end
+
+        def render(flags = {})
+          unprinted_text = []
+          @laid_out_lines = flags[:keep_layout] ? [] : nil
+          with_text_settings do
+            text = normalized_text(flags)
+            shrink_to_fit(text) if @overflow == :shrink_to_fit
+            process_vertical_alignment(text)
+            @inked = true unless flags[:dry_run]
+            unprinted_text = (@rotate != 0 && @inked) ? render_rotated(text) : wrap(text)
+            @inked = false
+          end
+          unprinted_text.map { |fragment| fragment.merge(text: @document.font.to_utf8(fragment[:text])) }
+        end
+
+        # Whether the lines of a `render(dry_run: true, keep_layout: true)` can be drawn again as they are.
+        def layout_reusable?
+          !@laid_out_lines.nil? && @everything_printed && @rotate.zero? && @vertical_align == :top &&
+            @overflow != :shrink_to_fit && self.class.extensions.empty? && @original_array.none? { _1[:color] }
+        end
+
+        # Draws, with its top left corner at `at`, the lines the last kept layout wrapped, without wrapping them again.
+        def render_laid_out(at)
+          @at = at.dup
+          with_text_settings do
+            @inked = true
+            @laid_out_lines.each do |baseline_y, drawn_fragments|
+              @baseline_y = baseline_y
+              drawn_fragments.each { format_and_draw_fragment(*_1) }
+            end
+            @inked = false
+          end
+        end
+
+        def available_width
+          @width
+        end
+
+        def height
+          return 0 if @baseline_y.nil? || @descender.nil?
+
+          (@baseline_y - @descender).abs
+        end
+
+        def draw_fragment(fragment, accumulated_width = 0, line_width = 0, word_spacing = 0)
+          x =
+            case @align
+            when :left then @at[0]
+            when :center then @at[0] + (@width * 0.5) - (line_width * 0.5)
+            when :right then @at[0] + @width - line_width
+            when :justify then (@direction == :ltr) ? @at[0] : @at[0] + @width - line_width
+            else raise ArgumentError, "align must be one of :left, :right, :center or :justify symbols"
+            end
+          x += accumulated_width
+          y = @at[1] + @baseline_y + fragment.y_offset
+          fragment.left = x
+          fragment.baseline = y
+          return unless @inked
+
+          fragment.callback_objects.each { |callback| callback.render_behind(fragment) if callback.respond_to?(:render_behind) }
+          @document.word_spacing(word_spacing) do
+            if @draw_text_callback
+              @draw_text_callback.call(fragment.text, at: [x, y], kerning: @kerning)
+            else
+              @document.draw_text!(fragment.text, at: [x, y], kerning: @kerning)
+            end
+          end
+          draw_fragment_overlays(fragment)
+        end
+
+        def valid_options
+          VALID_OPTIONS
+        end
+
+        private
+
+        def with_text_settings(&)
+          @document.save_font do
+            @document.character_spacing(@character_spacing) do
+              @document.text_rendering_mode(@mode) do
+                process_options
+                @document.font_size(@font_size, &)
+              end
+            end
+          end
+        end
+
+        def normalized_text(flags)
+          text = normalize_encoding
+          text.each { _1.delete(:color) } if flags[:dry_run]
+          text
+        end
+
+        def original_text
+          @original_array.map(&:dup)
+        end
+
+        def normalize_encoding
+          formatted_text = original_text
+          formatted_text = formatted_text.flat_map { fragments_by_fallback_font(_1) } unless @fallback_fonts.empty?
+          formatted_text.each do |hash|
+            if hash[:font]
+              @document.font(hash[:font]) { hash[:text] = @document.font.normalize_encoding(hash[:text]) }
+            else
+              hash[:text] = @document.font.normalize_encoding(hash[:text])
+            end
+          end
+          formatted_text
+        end
+
+        def fragments_by_fallback_font(hash)
+          original_font = @document.font.family
+          fragment_font = hash[:font] || original_font
+          fragment_font_style = @arranger.font_style(hash[:styles])
+          fragment_font_options = (fragment_font_style == :normal) ? {} : {style: fragment_font_style}
+          fallback_fonts = [*@fallback_fonts, fragment_font]
+
+          font_glyph_pairs = []
+          @document.save_font do
+            hash[:text].each_char do |character|
+              font_glyph_pairs << [font_for_glyph(character, fragment_font, fallback_fonts.dup, fragment_font_options), character]
+            end
+          end
+          font_glyph_pairs.each { |pair| pair[0] = nil if pair[0] == original_font } if hash[:font].nil?
+
+          fragments = []
+          current_font = nil
+          font_glyph_pairs.each do |font, character|
+            if font != current_font || fragments.empty?
+              current_font = font
+              fragment = hash.merge(text: character)
+              fragment[:font] = font unless font.nil?
+              fragments << fragment
+            else
+              fragments.last[:text] += character
+            end
+          end
+          fragments
+        end
+
+        def font_for_glyph(character, current_font, fallback_fonts, current_font_options = {})
+          loop do
+            @document.font(current_font, current_font_options)
+            return current_font if fallback_fonts.empty? || @document.font.glyph_present?(character)
+
+            current_font = fallback_fonts.shift
+          end
+        end
+
+        def move_baseline_down
+          if @baseline_y.zero?
+            @baseline_y = -@ascender
+          else
+            @baseline_y -= @line_height + @leading
+          end
+        end
+
+        def default_height
+          frame = @document.bounds
+          frame = frame.parent while frame.stretchy? && frame.parent
+          @at[1] + @document.bounds.absolute_bottom - frame.absolute_bottom
+        end
+
+        def process_vertical_alignment(text)
+          return if @vertical_alignment_processed
+
+          @vertical_alignment_processed = true
+          return if @vertical_align == :top
+
+          wrap(text)
+          case @vertical_align
+          when :center then @at[1] -= (@height - height + @descender) * 0.5
+          when :bottom then @at[1] -= @height - height
+          else raise ArgumentError, "valign must be one of :left, :right or :center symbols"
+          end
+          @height = height
+        end
+
+        def shrink_to_fit(text)
+          loop do
+            if @disable_wrap_by_char && @font_size > @min_font_size
+              begin
+                wrap(text)
+              rescue Errors::CannotFit
+                # Too big for a word to fit whole: the next, smaller size may make it fit.
+              end
+            else
+              wrap(text)
+            end
+            break if @everything_printed || @font_size <= @min_font_size
+
+            @font_size = [@font_size - SHRINK_STEP, @min_font_size].max
+            @document.font_size = @font_size
+          end
+        end
+
+        def process_options
+          @document.process_text_options(@options)
+          @font_size = @options[:size]
+          @kerning = @options[:kerning]
+        end
+
+        def render_rotated(text)
+          x, y =
+            case @rotate_around
+            when :center then [@at[0] + (@width * 0.5), @at[1] - (@height * 0.5)]
+            when :upper_right then [@at[0] + @width, @at[1]]
+            when :lower_right then [@at[0] + @width, @at[1] - @height]
+            when :lower_left then [@at[0], @at[1] - @height]
+            else [@at[0], @at[1]]
+            end
+          unprinted_text = ""
+          @document.rotate(@rotate, origin: [x, y]) { unprinted_text = wrap(text) }
+          unprinted_text
+        end
+
+        def draw_fragment_overlays(fragment)
+          @document.stroke_line(fragment.underline_points) if fragment.styles.include?(:underline)
+          @document.stroke_line(fragment.strikethrough_points) if fragment.styles.include?(:strikethrough)
+          draw_link_annotations(fragment)
+          fragment.callback_objects.each { |callback| callback.render_in_front(fragment) if callback.respond_to?(:render_in_front) }
+        end
+
+        def draw_link_annotations(fragment)
+          if fragment.link
+            @document.link_annotation(fragment.absolute_bounding_box, Border: [0, 0, 0],
+              A: {Type: :Action, S: :URI, URI: PDF::Core::LiteralString.new(fragment.link)})
+          end
+          @document.link_annotation(fragment.absolute_bounding_box, Border: [0, 0, 0], Dest: fragment.anchor) if fragment.anchor
+          return unless fragment.local
+
+          @document.link_annotation(fragment.absolute_bounding_box, Border: [0, 0, 0],
+            A: {Type: :Action, S: :Launch, F: PDF::Core::LiteralString.new(fragment.local), NewWindow: true})
+        end
+      end
+    end
+  end
+end