gamba 2.0.0

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

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+module Prawn
+  module Text
+    module Formatted
+      # A run of text sharing one format on one line, with its measurements and, once drawn, its position.
+      class Fragment
+        attr_reader :format_state, :text
+        attr_writer :width
+        attr_accessor :line_height, :descender, :ascender, :word_spacing, :left, :baseline
+
+        def initialize(text, format_state, document)
+          @format_state = format_state
+          @document = document
+          @word_spacing = 0
+          @original_text = text
+          @text = process_text(@original_text)
+        end
+
+        def width
+          @word_spacing.zero? ? @width : @width + (@word_spacing * space_count)
+        end
+
+        def height
+          top - bottom
+        end
+
+        def subscript?
+          styles.include?(:subscript)
+        end
+
+        def superscript?
+          styles.include?(:superscript)
+        end
+
+        def y_offset
+          if subscript? then -descender
+          elsif superscript? then 0.85 * ascender
+          else 0
+          end
+        end
+
+        def bounding_box
+          [left, bottom, right, top]
+        end
+
+        def absolute_bounding_box
+          left, bottom, right, top = bounding_box
+          bounds = @document.bounds
+          [left + bounds.absolute_left, bottom + bounds.absolute_bottom, right + bounds.absolute_left, top + bounds.absolute_bottom]
+        end
+
+        def underline_points
+          y = baseline - 1.25
+          [[left, y], [right, y]]
+        end
+
+        def strikethrough_points
+          y = baseline + (ascender * 0.3)
+          [[left, y], [right, y]]
+        end
+
+        def styles
+          @format_state[:styles] || []
+        end
+
+        def link
+          @format_state[:link]
+        end
+
+        def anchor
+          @format_state[:anchor]
+        end
+
+        def local
+          @format_state[:local]
+        end
+
+        def color
+          @format_state[:color]
+        end
+
+        def font
+          @format_state[:font]
+        end
+
+        def size
+          @format_state[:size]
+        end
+
+        def character_spacing
+          @format_state[:character_spacing] || @document.character_spacing
+        end
+
+        def direction
+          @format_state[:direction]
+        end
+
+        def default_direction=(direction)
+          return if @format_state[:direction]
+
+          @format_state[:direction] = direction
+          @text = process_text(@original_text)
+        end
+
+        def include_trailing_white_space!
+          @format_state.delete(:exclude_trailing_white_space)
+          @text = process_text(@original_text)
+        end
+
+        def space_count
+          @text.count(" ")
+        end
+
+        def callback_objects
+          callback = @format_state[:callback]
+          callback.nil? ? [] : Array(callback)
+        end
+
+        def right
+          left + width
+        end
+
+        def top
+          baseline + ascender
+        end
+
+        def bottom
+          baseline - descender
+        end
+
+        def top_left
+          [left, top]
+        end
+
+        def top_right
+          [right, top]
+        end
+
+        def bottom_right
+          [right, bottom]
+        end
+
+        def bottom_left
+          [left, bottom]
+        end
+
+        def absolute_left
+          absolute_bounding_box[0]
+        end
+
+        def absolute_right
+          absolute_bounding_box[2]
+        end
+
+        def absolute_top
+          absolute_bounding_box[3]
+        end
+
+        def absolute_bottom
+          absolute_bounding_box[1]
+        end
+
+        def absolute_top_left
+          [absolute_left, absolute_top]
+        end
+
+        def absolute_top_right
+          [absolute_right, absolute_top]
+        end
+
+        def absolute_bottom_left
+          [absolute_left, absolute_bottom]
+        end
+
+        def absolute_bottom_right
+          [absolute_right, absolute_bottom]
+        end
+
+        private
+
+        def process_text(text)
+          string = (text.encoding == ::Encoding::UTF_8) ? text.gsub(ZWSP, "") : text
+          if @format_state[:exclude_trailing_white_space]
+            string = string.rstrip
+            string = process_soft_hyphens(string[0..-2]) + string[-1..] if soft_hyphens_need_processing?(string)
+          elsif soft_hyphens_need_processing?(string)
+            string = process_soft_hyphens(string)
+          end
+          (direction == :rtl) ? string.reverse : string
+        end
+
+        def soft_hyphens_need_processing?(string)
+          !string.empty? && @format_state[:normalized_soft_hyphen]
+        end
+
+        def process_soft_hyphens(string)
+          soft_hyphen = @format_state[:normalized_soft_hyphen]
+          string = string.dup.force_encoding(soft_hyphen.encoding) if string.encoding != soft_hyphen.encoding
+          string.gsub(soft_hyphen, "")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+module Prawn
+  module Text
+    module Formatted
+      # Fills one line with as many words of the arranger's fragments as fit, breaking after spaces, hyphens and
+      # soft hyphens, and inside a word only when the line holds a single one.
+      class LineWrap
+        # Characters and patterns of one encoding, computed once: Prawn rebuilt them for every line.
+        Breaks = Data.define(:soft_hyphen, :zero_width_space, :scan_pattern, :word_division_pattern, :ends_with_break_pattern,
+          :last_word_pattern, :begins_with_break_pattern)
+
+        BREAKS_BY_ENCODING = Hash.new do |cache, encoding|
+          cache[encoding] = breaks_for(encoding)
+        end
+
+        def self.encode_or_nil(character, encoding)
+          character.encode(encoding)
+        rescue ::Encoding::InvalidByteSequenceError, ::Encoding::UndefinedConversionError
+          nil
+        end
+
+        def self.breaks_for(encoding)
+          soft_hyphen = encode_or_nil(SHY, encoding)
+          zero_width_space = encode_or_nil(ZWSP, encoding)
+          whitespace = " \t#{zero_width_space}".encode(encoding)
+          break_characters = [whitespace, soft_hyphen, "-"].join
+          patterns = ["[^#{break_characters}]+#{soft_hyphen}", "[^#{break_characters}]+-+", "[^#{break_characters}]+", "[#{whitespace}]+",
+            "-+[^#{break_characters}]*", soft_hyphen.to_s]
+          Breaks.new(
+            soft_hyphen: soft_hyphen&.freeze,
+            zero_width_space: zero_width_space&.freeze,
+            scan_pattern: Regexp.new(patterns.map { _1.encode(encoding) }.join("|")),
+            word_division_pattern: Regexp.union([*["\t", "\n", "\v", "\r", " "].map { _1.encode(encoding) }, zero_width_space, soft_hyphen, "-"].compact),
+            ends_with_break_pattern: Regexp.new("[#{break_characters}]$"),
+            last_word_pattern: Regexp.new("[^#{break_characters}]*$"),
+            begins_with_break_pattern: Regexp.new("^[#{break_characters}]")
+          )
+        end
+
+        attr_reader :space_count
+
+        def width
+          @accumulated_width || 0
+        end
+
+        def paragraph_finished?
+          @newline_encountered || next_string_newline? || @arranger.finished?
+        end
+
+        def tokenize(fragment)
+          fragment.scan(BREAKS_BY_ENCODING[fragment.encoding].scan_pattern)
+        end
+
+        def wrap_line(options)
+          initialize_line(options)
+          while (fragment = @arranger.next_string)
+            @fragment_output = +""
+            fragment.lstrip! if first_fragment_on_this_line?(fragment)
+            next if empty_line?(fragment)
+            break unless apply_font_settings_and_add_fragment_to_line(fragment)
+          end
+          @arranger.finalize_line
+          @accumulated_width = @arranger.line_width
+          @space_count = @arranger.space_count
+          @arranger.line
+        end
+
+        private
+
+        def first_fragment_on_this_line?(fragment)
+          line_empty? && fragment != "\n"
+        end
+
+        def empty_line?(fragment)
+          empty = line_empty? && fragment.empty? && next_string_newline?
+          @arranger.update_last_string("", "", BREAKS_BY_ENCODING[fragment.encoding].soft_hyphen) if empty
+          empty
+        end
+
+        def next_string_newline?
+          @arranger.preview_next_string == "\n"
+        end
+
+        def apply_font_settings_and_add_fragment_to_line(fragment)
+          added = nil
+          @arranger.apply_font_settings { added = add_fragment_to_line(fragment) }
+          added
+        end
+
+        def add_fragment_to_line(fragment)
+          case fragment
+          when "" then return true
+          when "\n"
+            @newline_encountered = true
+            return false
+          end
+
+          breaks = BREAKS_BY_ENCODING[fragment.encoding]
+          # Words are read one at a time: a line stops long before the end of its paragraph.
+          scanner = StringScanner.new(fragment)
+          while (segment = scanner.scan(breaks.scan_pattern))
+            segment_width = (segment == breaks.zero_width_space) ? 0 : @document.width_of(segment, @width_options)
+            if @accumulated_width + segment_width <= @width
+              @accumulated_width += segment_width
+              @accumulated_width -= @document.width_of(breaks.soft_hyphen, @width_options) if breaks.soft_hyphen && segment.end_with?(breaks.soft_hyphen)
+              @fragment_output << segment
+            else
+              @line_contains_more_than_one_word = false if @accumulated_width.zero? && @line_contains_more_than_one_word
+              end_of_the_line_reached(segment)
+              fragment_finished(fragment)
+              return false
+            end
+          end
+          fragment_finished(fragment)
+          true
+        end
+
+        def line_empty?
+          @line_empty && @accumulated_width.zero?
+        end
+
+        def initialize_line(options)
+          @document = options[:document]
+          # Shared by every word measured on the line: passing kerning: to each call built a hash per word.
+          @width_options = {kerning: options[:kerning]}
+          @width = options[:width]
+          @disable_wrap_by_char = options[:disable_wrap_by_char]
+          @accumulated_width = 0
+          @line_empty = true
+          @line_contains_more_than_one_word = false
+          @arranger = options[:arranger]
+          @arranger.initialize_line
+          @newline_encountered = false
+          @line_full = false
+        end
+
+        def fragment_finished(fragment)
+          if fragment == "\n"
+            @newline_encountered = true
+            @line_empty = false
+          else
+            update_output_based_on_last_fragment(fragment, BREAKS_BY_ENCODING[fragment.encoding].soft_hyphen)
+            update_line_status_based_on_last_output
+            pull_preceding_fragment_to_join_this_one?(fragment)
+          end
+          remember_this_fragment_for_backward_looking_ops
+        end
+
+        def update_output_based_on_last_fragment(fragment, normalized_soft_hyphen = nil)
+          remaining_text = fragment.slice(@fragment_output.length..fragment.length)
+          raise Errors::CannotFit if line_finished? && line_empty? && @fragment_output.empty? && !fragment.strip.empty?
+
+          @arranger.update_last_string(@fragment_output, remaining_text, normalized_soft_hyphen)
+        end
+
+        def pull_preceding_fragment_to_join_this_one?(current_fragment)
+          return unless @fragment_output.empty? && !current_fragment.empty? && @line_contains_more_than_one_word
+          return if @previous_fragment_ended_with_breakable || fragment_begins_with_breakable?(current_fragment)
+
+          @fragment_output = @previous_fragment_output_without_last_word
+          update_output_based_on_last_fragment(@previous_fragment)
+        end
+
+        def remember_this_fragment_for_backward_looking_ops
+          @previous_fragment = @fragment_output.dup
+          breaks = BREAKS_BY_ENCODING[@previous_fragment.encoding]
+          @previous_fragment_ended_with_breakable = @previous_fragment.match?(breaks.ends_with_break_pattern)
+          last_word = @previous_fragment.slice(breaks.last_word_pattern)
+          @previous_fragment_output_without_last_word = @previous_fragment.slice(0, @previous_fragment.length - (last_word&.length || 0))
+        end
+
+        def fragment_begins_with_breakable?(fragment)
+          fragment.match?(BREAKS_BY_ENCODING[fragment.encoding].begins_with_break_pattern)
+        end
+
+        def line_finished?
+          @line_full || paragraph_finished?
+        end
+
+        def update_line_status_based_on_last_output
+          @line_contains_more_than_one_word = true if @fragment_output&.match?(BREAKS_BY_ENCODING[@fragment_output.encoding].word_division_pattern)
+        end
+
+        def end_of_the_line_reached(segment)
+          update_line_status_based_on_last_output
+          wrap_by_char(segment) unless @disable_wrap_by_char || @line_contains_more_than_one_word
+          @line_full = true
+        end
+
+        def wrap_by_char(segment)
+          segment.each_char do |character|
+            character_width = @document.width_of(character)
+            break unless @accumulated_width + character_width <= @width
+
+            @accumulated_width += character_width
+            @fragment_output << character
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Prawn
+  module Text
+    module Formatted
+      # Turns inline markup (<b>, <i>, <u>, <strikethrough>, <sub>, <sup>, <link>, <a>, <color>, <font>, <br>)
+      # into formatted text arrays, and back.
+      class Parser
+        PARSER_REGEX = Regexp.new(
+          "\n|<b>|</b>|<i>|</i>|<u>|</u>|<strikethrough>|</strikethrough>|<sub>|</sub>|<sup>|</sup>|<link[^>]*>|</link>|" \
+          "<color[^>]*>|</color>|<font[^>]*>|</font>|<strong>|</strong>|<em>|</em>|<a[^>]*>|</a>|[^<\n]+",
+          Regexp::MULTILINE
+        )
+        ESCAPE_CHARS = {"&" => "&amp;", ">" => "&gt;", "<" => "&lt;"}.freeze
+        UNESCAPE_CHARS = ESCAPE_CHARS.invert.freeze
+        CMYK_ATTRIBUTES = %w[c m y k].freeze
+        ESCAPE_PATTERN = Regexp.union(ESCAPE_CHARS.keys)
+        UNESCAPE_PATTERN = Regexp.union(UNESCAPE_CHARS.keys)
+        STYLE_BY_OPENING_TAG = {
+          "<b>" => :bold, "<strong>" => :bold, "<i>" => :italic, "<em>" => :italic, "<u>" => :underline,
+          "<strikethrough>" => :strikethrough, "<sub>" => :subscript, "<sup>" => :superscript
+        }.freeze
+        STYLE_BY_CLOSING_TAG = STYLE_BY_OPENING_TAG.transform_keys { _1.sub("<", "</") }.freeze
+        PREFIX_BY_STYLE = {bold: "<b>", italic: "<i>", underline: "<u>", strikethrough: "<strikethrough>", subscript: "<sub>", superscript: "<sup>"}.freeze
+        SUFFIX_BY_STYLE = PREFIX_BY_STYLE.transform_values { _1.sub("<", "</") }.freeze
+
+        def self.format(string, *_arguments)
+          array_from_tokens(string.gsub(%r{<br\s*/?>}, "\n").scan(PARSER_REGEX))
+        end
+
+        def self.to_string(array)
+          array.map do |hash|
+            prefix = +""
+            suffix = +""
+            hash[:styles]&.each do |style|
+              prefix << PREFIX_BY_STYLE[style]
+              suffix = SUFFIX_BY_STYLE[style] + suffix
+            end
+            font = (" name='#{hash[:font]}'" if hash[:font])
+            size = (" size='#{hash[:size]}'" if hash[:size])
+            character_spacing = (" character_spacing='#{hash[:character_spacing]}'" if hash[:character_spacing])
+            if font || size || character_spacing
+              prefix << "<font#{font}#{size}#{character_spacing}>"
+              suffix = "</font>"
+            end
+            link = (" href='#{hash[:link]}'" if hash[:link])
+            anchor = (" anchor='#{hash[:anchor]}'" if hash[:anchor])
+            if link || anchor
+              prefix << "<link#{link}#{anchor}>"
+              suffix = "</link>"
+            end
+            if hash[:color]
+              prefix <<
+                if hash[:color].is_a?(Array)
+                  c, m, y, k = hash[:color]
+                  "<color c='#{c}' m='#{m}' y='#{y}' k='#{k}'>"
+                else
+                  "<color rgb='#{hash[:color]}'>"
+                end
+              suffix = "</color>"
+            end
+            prefix + escape(hash[:text]) + suffix
+          end.join
+        end
+
+        def self.array_paragraphs(array)
+          paragraphs = []
+          paragraph = []
+          previous_string = "\n"
+          array.each do |hash|
+            hash[:text].scan(/[^\n]+|\n/).each do |string|
+              if string == "\n"
+                paragraph << hash.merge(text: "\n") if previous_string == "\n"
+                paragraphs << paragraph unless paragraph.empty?
+                paragraph = []
+              else
+                paragraph << hash.merge(text: string)
+              end
+              previous_string = string
+            end
+          end
+          paragraphs << paragraph unless paragraph.empty?
+          paragraphs
+        end
+
+        def self.array_from_tokens(tokens)
+          array = []
+          styles = []
+          colors = []
+          link = nil
+          anchor = nil
+          local = nil
+          fonts = []
+          sizes = []
+          character_spacings = []
+          tokens.each do |token|
+            if (style = STYLE_BY_OPENING_TAG[token])
+              styles << style
+            elsif (style = STYLE_BY_CLOSING_TAG[token])
+              styles.delete(style)
+            else
+              case token
+              when "</link>", "</a>"
+                link = anchor = local = nil
+              when "</color>"
+                colors.pop
+              when "</font>"
+                fonts.pop
+                sizes.pop
+                character_spacings.pop
+              when /^<link[^>]*>$/, /^<a[^>]*>$/
+                link = attribute(token, "href") || link
+                anchor = attribute(token, "anchor") || anchor
+                local = attribute(token, "local") || local
+              when /^<color[^>]*>$/
+                rgb = attribute(token, "rgb", hash_prefixed: true)
+                colors << rgb if rgb
+                cmyk = CMYK_ATTRIBUTES.map { |name| attribute(token, name, hash_prefixed: true)&.then { |value| Integer(value, 10) } }
+                colors << cmyk if cmyk.all?
+              when /^<font[^>]*>$/
+                attribute(token, "name")&.then { fonts << _1 }
+                attribute(token, "size")&.then { sizes << Float(_1) }
+                attribute(token, "character_spacing")&.then { character_spacings << Float(_1) }
+              else
+                array << {
+                  text: unescape(token), styles: styles.dup, color: colors.last, local:, link:, anchor:,
+                  font: fonts.last, size: sizes.last, character_spacing: character_spacings.last
+                }
+              end
+            end
+          end
+          array
+        end
+
+        def self.attribute(token, name, hash_prefixed: false)
+          prefix = hash_prefixed ? "#?" : ""
+          token[/\b#{name}="#{prefix}([^"]*)"/, 1] || token[/\b#{name}='#{prefix}([^']*)'/, 1]
+        end
+
+        def self.escape(text)
+          text.gsub(ESCAPE_PATTERN, ESCAPE_CHARS)
+        end
+
+        def self.unescape(text)
+          text.gsub(UNESCAPE_PATTERN, UNESCAPE_CHARS)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Prawn
+  module Text
+    module Formatted
+      # Lays formatted text out line by line inside a box's width and height.
+      module Wrap
+        def initialize(_array, options)
+          @line_wrap = LineWrap.new
+          @arranger = Arranger.new(@document, kerning: options[:kerning])
+          @disable_wrap_by_char = options[:disable_wrap_by_char]
+        end
+
+        def wrap(array)
+          initialize_wrap(array)
+          loop do
+            @line_wrap.wrap_line(document: @document, kerning: @kerning, width: available_width, arranger: @arranger,
+              disable_wrap_by_char: @disable_wrap_by_char)
+            break unless enough_height_for_this_line?
+
+            move_baseline_down
+            print_line
+            break if @single_line || @arranger.finished?
+          end
+          @text = @printed_lines.join("\n")
+          @everything_printed = @arranger.finished?
+          @arranger.unconsumed
+        end
+
+        private
+
+        def print_line
+          @nothing_printed = false
+          printed_fragments = []
+          fragments_this_line = []
+          word_spacing = word_spacing_for_this_line
+          @arranger.fragments.each do |fragment|
+            fragment.word_spacing = word_spacing
+            if fragment.text == "\n"
+              printed_fragments << "\n" if @printed_lines.last == ""
+              break
+            end
+            printed_fragments << fragment.text
+            fragments_this_line << fragment
+          end
+          @arranger.fragments.replace([])
+
+          accumulated_width = 0
+          drawn_fragments = []
+          fragments_this_line.reverse! if @direction == :rtl
+          fragments_this_line.each do |fragment|
+            fragment.default_direction = @direction
+            drawn_fragment = [fragment, accumulated_width, @line_wrap.width, word_spacing]
+            format_and_draw_fragment(*drawn_fragment)
+            drawn_fragments << drawn_fragment if @laid_out_lines
+            accumulated_width += fragment.width
+          end
+          @laid_out_lines << [@baseline_y, drawn_fragments] if @laid_out_lines
+          @printed_lines << printed_fragments.map { _1.dup.force_encoding(::Encoding::UTF_8) }.join
+        end
+
+        def word_spacing_for_this_line
+          return 0 unless @align == :justify && @line_wrap.space_count.positive? && !@line_wrap.paragraph_finished?
+
+          (available_width - @line_wrap.width) / @line_wrap.space_count
+        end
+
+        # Slack in points, so floating point sums do not drop a line that fits exactly.
+        HEIGHT_TOLERANCE = 0.0001
+
+        def enough_height_for_this_line?
+          @line_height = @arranger.max_line_height
+          @descender = @arranger.max_descender
+          @ascender = @arranger.max_ascender
+          line_extent = @baseline_y.zero? ? @ascender + @descender : @descender + @line_height + @leading
+          return true if @baseline_y.abs + line_extent <= @height + HEIGHT_TOLERANCE
+
+          @arranger.repack_unretrieved
+          false
+        end
+
+        def initialize_wrap(array)
+          @text = nil
+          @arranger.format_array = array
+          @line_height = 0
+          @descender = 0
+          @ascender = 0
+          @baseline_y = 0
+          @printed_lines = []
+          @laid_out_lines&.clear
+          @nothing_printed = true
+          @everything_printed = false
+        end
+
+        def format_and_draw_fragment(fragment, accumulated_width, line_width, word_spacing)
+          @arranger.apply_color_and_font_settings(fragment) do
+            draw_fragment(fragment, accumulated_width, line_width, word_spacing)
+          end
+        end
+      end
+    end
+  end
+end