giga-fast-kit 0.0.1

data/prawn-2.5.0/lib/prawn/text/formatted/fragment.rb

@@ -0,0 +1,373 @@
+# frozen_string_literal: true
+
+module Prawn
+  module Text
+    module Formatted
+      # Prawn::Text::Formatted::Fragment is a state store for a formatted text
+      # fragment. It does not render anything.
+      #
+      # @private
+      class Fragment
+        attr_reader :format_state
+        attr_reader :text
+        attr_writer :width
+        attr_accessor :line_height
+        attr_accessor :descender
+        attr_accessor :ascender
+        attr_accessor :word_spacing
+        attr_accessor :left
+        attr_accessor :baseline
+
+        # @param text [String]
+        # @param format_state [Hash{Symbol => any}]
+        # @param document [Prawn::Documnt]
+        def initialize(text, format_state, document)
+          @format_state = format_state
+          @document = document
+          @word_spacing = 0
+
+          # keep the original value of "text", so we can reinitialize @text if
+          # formatting parameters like text direction are changed
+          @original_text = text
+          @text = process_text(@original_text)
+        end
+
+        # Width of fragment.
+        #
+        # @return [Number]
+        def width
+          if @word_spacing.zero? then @width
+          else
+            @width + (@word_spacing * space_count)
+          end
+        end
+
+        # Height of fragment.
+        #
+        # @return [Number]
+        def height
+          top - bottom
+        end
+
+        # Is this a subscript fragment?
+        #
+        # @return [Boolean]
+        def subscript?
+          styles.include?(:subscript)
+        end
+
+        # Is this a superscript fragment?
+        #
+        # @return [Boolean]
+        def superscript?
+          styles.include?(:superscript)
+        end
+
+        # Vertical offset of the fragment.
+        #
+        # @return [Number]
+        def y_offset
+          if subscript? then -descender
+          elsif superscript? then 0.85 * ascender
+          else
+            0
+          end
+        end
+
+        # Fragment bounding box, relative to the containing bounding box.
+        #
+        # @return [Array(Number, Number, Number, Number)]
+        def bounding_box
+          [left, bottom, right, top]
+        end
+
+        # Fragment bounding box, relative to the containing page.
+        #
+        # @return [Array(Number, Number, Number, Number)]
+        def absolute_bounding_box
+          box = bounding_box
+          box[0] += @document.bounds.absolute_left
+          box[2] += @document.bounds.absolute_left
+          box[1] += @document.bounds.absolute_bottom
+          box[3] += @document.bounds.absolute_bottom
+          box
+        end
+
+        # Underline endpoints.
+        #
+        # @return [Array(Array(Number, Number), Array(Number, Number))]
+        def underline_points
+          y = baseline - 1.25
+          [[left, y], [right, y]]
+        end
+
+        # Strikethrough endpoints.
+        #
+        # @return [Array(Array(Number, Number), Array(Number, Number))]
+        def strikethrough_points
+          y = baseline + (ascender * 0.3)
+          [[left, y], [right, y]]
+        end
+
+        # Fragment font styles.
+        #
+        # @return [Array<Symbol>]
+        def styles
+          @format_state[:styles] || []
+        end
+
+        # Fragment link.
+        #
+        # @return [String, nil]
+        def link
+          @format_state[:link]
+        end
+
+        # Anchor.
+        #
+        # @return [PDF::Core::Reference, Array, Hash]
+        def anchor
+          @format_state[:anchor]
+        end
+
+        # Local destination.
+        #
+        # @return [String]
+        def local
+          @format_state[:local]
+        end
+
+        # Fragment color.
+        #
+        # @return [Color]
+        def color
+          @format_state[:color]
+        end
+
+        # Fragment font name.
+        #
+        # @return [String]
+        def font
+          @format_state[:font]
+        end
+
+        # Font size.
+        #
+        # @return [Number]
+        def size
+          @format_state[:size]
+        end
+
+        # Character spacing.
+        #
+        # @return [Number]
+        def character_spacing
+          @format_state[:character_spacing] ||
+            @document.character_spacing
+        end
+
+        # Text direction.
+        #
+        # @return [:ltr, :rtl]
+        def direction
+          @format_state[:direction]
+        end
+
+        # Set default text direction.
+        #
+        # @param direction [:ltr, :rtl]
+        # @return [void]
+        def default_direction=(direction)
+          unless @format_state[:direction]
+            @format_state[:direction] = direction
+            @text = process_text(@original_text)
+          end
+        end
+
+        # Keep trailing spaces.
+        #
+        # @return [void]
+        def include_trailing_white_space!
+          @format_state.delete(:exclude_trailing_white_space)
+          @text = process_text(@original_text)
+        end
+
+        # Number of spaces in the text.
+        #
+        # @return [Integer]
+        def space_count
+          @text.count(' ')
+        end
+
+        # Callbacks.
+        #
+        # @return [Array]
+        def callback_objects
+          callback = @format_state[:callback]
+          if callback.nil?
+            []
+          elsif callback.is_a?(Array)
+            callback
+          else
+            [callback]
+          end
+        end
+
+        # Horizontal coordinate of the right side of the fragment.
+        #
+        # @return [Number]
+        def right
+          left + width
+        end
+
+        # Vertical coordinate of the top side of the fragment.
+        #
+        # @return [Number]
+        def top
+          baseline + ascender
+        end
+
+        # Vertical coordinate of the bottom side of the fragment.
+        #
+        # @return [Number]
+        def bottom
+          baseline - descender
+        end
+
+        # Coordinates of the top left corner of the fragment.
+        #
+        # @return [Array(Number, Number)]
+        def top_left
+          [left, top]
+        end
+
+        # Coordinates of the top right corner of the fragment.
+        #
+        # @return [Array(Number, Number)]
+        def top_right
+          [right, top]
+        end
+
+        # Coordinates of the bottom right corner of the fragment.
+        #
+        # @return [Array(Number, Number)]
+        def bottom_right
+          [right, bottom]
+        end
+
+        # Coordinates of the bottom left corner of the fragment.
+        #
+        # @return [Array(Number, Number)]
+        def bottom_left
+          [left, bottom]
+        end
+
+        # Absolute horizontal coordinate of the left side of the fragment.
+        #
+        # @return [Number]
+        def absolute_left
+          absolute_bounding_box[0]
+        end
+
+        # Absolute horizontal coordinate of the right side of the fragment.
+        #
+        # @return [Number]
+        def absolute_right
+          absolute_bounding_box[2]
+        end
+
+        # Absolute vertical coordinate of the top side of the fragment.
+        #
+        # @return [Number]
+        def absolute_top
+          absolute_bounding_box[3]
+        end
+
+        # Absolute vertical coordinate of the bottom side of the fragment.
+        #
+        # @return [Number]
+        def absolute_bottom
+          absolute_bounding_box[1]
+        end
+
+        # Absolute coordinates of the top left corner of the fragment.
+        #
+        # @return [Array(Number, Number)]
+        def absolute_top_left
+          [absolute_left, absolute_top]
+        end
+
+        # Absolute coordinates of the top right corner of the fragment.
+        #
+        # @return [Array(Number, Number)]
+        def absolute_top_right
+          [absolute_right, absolute_top]
+        end
+
+        # Absolute coordinates of the bottom left corner of the fragment.
+        #
+        # @return [Array(Number, Number)]
+        def absolute_bottom_left
+          [absolute_left, absolute_bottom]
+        end
+
+        # Absolute coordinates of the bottom right corner of the fragment.
+        #
+        # @return [Array(Number, Number)]
+        def absolute_bottom_right
+          [absolute_right, absolute_bottom]
+        end
+
+        private
+
+        def process_text(text)
+          string = strip_zero_width_spaces(text)
+
+          if exclude_trailing_white_space?
+            string = string.rstrip
+
+            if soft_hyphens_need_processing?(string)
+              string = process_soft_hyphens(string[0..-2]) + string[-1..]
+            end
+          elsif soft_hyphens_need_processing?(string)
+            string = process_soft_hyphens(string)
+          end
+
+          if direction == :rtl
+            string.reverse
+          else
+            string
+          end
+        end
+
+        def exclude_trailing_white_space?
+          @format_state[:exclude_trailing_white_space]
+        end
+
+        def soft_hyphens_need_processing?(string)
+          !string.empty? && normalized_soft_hyphen
+        end
+
+        def normalized_soft_hyphen
+          @format_state[:normalized_soft_hyphen]
+        end
+
+        def process_soft_hyphens(string)
+          if string.encoding != normalized_soft_hyphen.encoding
+            string.force_encoding(normalized_soft_hyphen.encoding)
+          end
+
+          string.gsub(normalized_soft_hyphen, '')
+        end
+
+        def strip_zero_width_spaces(string)
+          if string.encoding == ::Encoding::UTF_8
+            string.gsub(Prawn::Text::ZWSP, '')
+          else
+            string
+          end
+        end
+      end
+    end
+  end
+end

data/prawn-2.5.0/lib/prawn/text/formatted/line_wrap.rb

@@ -0,0 +1,335 @@
+# frozen_string_literal: true
+
+module Prawn
+  module Text
+    module Formatted
+      # Implements individual line wrapping of formatted text.
+      #
+      # @private
+      class LineWrap
+        # The width of the last wrapped line.
+        #
+        # @return [Number]
+        def width
+          @accumulated_width || 0
+        end
+
+        # The number of spaces in the last wrapped line.
+        # @return [Integer]
+        attr_reader :space_count
+
+        # Whether this line is the last line in the paragraph.
+        #
+        # @return [Boolean]
+        def paragraph_finished?
+          @newline_encountered || next_string_newline? || @arranger.finished?
+        end
+
+        # Break the fragment into tokens.
+        #
+        # @param fragment [String]
+        # @return [Array<String>]
+        def tokenize(fragment)
+          fragment.scan(scan_pattern(fragment.encoding))
+        end
+
+        # Work in conjunction with the {Prawn::Text::Formatted::Arranger}
+        # defined in the `:arranger` option to determine what formatted text
+        # will fit within the width defined by the `:width` option.
+        #
+        # @param options [Hash{Symbol => any}]
+        # @option options :document [Prawn::Document]
+        # @option options :kerning [Boolean]
+        # @option options :width [Number]
+        # @option options :disable_wrap_by_char [Boolean]
+        # @option options :arranger [Prawn::Text::Formatted::Arranger]
+        # @return [String]
+        def wrap_line(options)
+          initialize_line(options)
+
+          # rubocop: disable Lint/AssignmentInCondition
+          while fragment = @arranger.next_string
+            # rubocop: enable Lint/AssignmentInCondition
+            @fragment_output = +''
+
+            fragment.lstrip! if first_fragment_on_this_line?(fragment)
+            next if empty_line?(fragment)
+
+            unless apply_font_settings_and_add_fragment_to_line(fragment)
+              break
+            end
+          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?
+          if empty
+            @arranger.update_last_string('', '', soft_hyphen(fragment.encoding))
+          end
+          empty
+        end
+
+        def next_string_newline?
+          @arranger.preview_next_string == "\n"
+        end
+
+        def apply_font_settings_and_add_fragment_to_line(fragment)
+          result = nil
+          @arranger.apply_font_settings do
+            result = add_fragment_to_line(fragment)
+          end
+          result
+        end
+
+        # returns true if all text was printed without running into the end of
+        # the line
+        #
+        def add_fragment_to_line(fragment)
+          case fragment
+          when ''
+            true
+          when "\n"
+            @newline_encountered = true
+            false
+          else
+            tokenize(fragment).each do |segment|
+              segment_width =
+                if segment == zero_width_space(segment.encoding)
+                  0
+                else
+                  @document.width_of(segment, kerning: @kerning)
+                end
+
+              if @accumulated_width + segment_width <= @width
+                @accumulated_width += segment_width
+                shy = soft_hyphen(segment.encoding)
+                if segment[-1] == shy
+                  sh_width = @document.width_of(shy, kerning: @kerning)
+                  @accumulated_width -= sh_width
+                end
+                @fragment_output += segment
+              else
+                if @accumulated_width.zero? && @line_contains_more_than_one_word
+                  @line_contains_more_than_one_word = false
+                end
+                end_of_the_line_reached(segment)
+                fragment_finished(fragment)
+                return false
+              end
+            end
+
+            fragment_finished(fragment)
+            true
+          end
+        end
+
+        # The pattern used to determine chunks of text to place on a given line
+        #
+        def scan_pattern(encoding = ::Encoding::UTF_8)
+          ebc = break_chars(encoding)
+          eshy = soft_hyphen(encoding)
+          ehy = hyphen(encoding)
+          ews = whitespace(encoding)
+
+          patterns = [
+            "[^#{ebc}]+#{eshy}",
+            "[^#{ebc}]+#{ehy}+",
+            "[^#{ebc}]+",
+            "[#{ews}]+",
+            "#{ehy}+[^#{ebc}]*",
+            eshy.to_s,
+          ]
+
+          pattern = patterns
+            .map { |p| p.encode(encoding) }
+            .join('|')
+
+          Regexp.new(pattern)
+        end
+
+        # The pattern used to determine whether any word breaks exist on a
+        # current line, which in turn determines whether character level
+        # word breaking is needed
+        #
+        def word_division_scan_pattern(encoding = ::Encoding::UTF_8)
+          common_whitespaces =
+            ["\t", "\n", "\v", "\r", ' '].map { |c|
+              c.encode(encoding)
+            }
+
+          Regexp.union(
+            common_whitespaces +
+            [
+              zero_width_space(encoding),
+              soft_hyphen(encoding),
+              hyphen(encoding),
+            ].compact,
+          )
+        end
+
+        def soft_hyphen(encoding = ::Encoding::UTF_8)
+          Prawn::Text::SHY.encode(encoding)
+        rescue ::Encoding::InvalidByteSequenceError,
+               ::Encoding::UndefinedConversionError
+          nil
+        end
+
+        def break_chars(encoding = ::Encoding::UTF_8)
+          [
+            whitespace(encoding),
+            soft_hyphen(encoding),
+            hyphen(encoding),
+          ].join('')
+        end
+
+        def zero_width_space(encoding = ::Encoding::UTF_8)
+          Prawn::Text::ZWSP.encode(encoding)
+        rescue ::Encoding::InvalidByteSequenceError,
+               ::Encoding::UndefinedConversionError
+          nil
+        end
+
+        def whitespace(encoding = ::Encoding::UTF_8)
+          "\s\t#{zero_width_space(encoding)}".encode(encoding)
+        end
+
+        def hyphen(_encoding = ::Encoding::UTF_8)
+          '-'
+        rescue ::Encoding::InvalidByteSequenceError,
+               ::Encoding::UndefinedConversionError
+          nil
+        end
+
+        def line_empty?
+          @line_empty && @accumulated_width.zero?
+        end
+
+        def initialize_line(options)
+          @document = options[:document]
+          @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,
+              soft_hyphen(fragment.encoding),
+            )
+            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)
+          if line_finished? && line_empty? && @fragment_output.empty? &&
+              !fragment.strip.empty?
+            raise Prawn::Errors::CannotFit
+          end
+
+          @arranger.update_last_string(
+            @fragment_output,
+            remaining_text,
+            normalized_soft_hyphen,
+          )
+        end
+
+        def pull_preceding_fragment_to_join_this_one?(current_fragment)
+          if @fragment_output.empty? && !current_fragment.empty? &&
+              @line_contains_more_than_one_word &&
+              !(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
+        end
+
+        def remember_this_fragment_for_backward_looking_ops
+          @previous_fragment = @fragment_output.dup
+          pf = @previous_fragment
+          @previous_fragment_ended_with_breakable =
+            pf =~ /[#{break_chars(pf.encoding)}]$/
+          last_word = pf.slice(/[^#{break_chars(pf.encoding)}]*$/)
+          last_word_length = last_word.nil? ? 0 : last_word.length
+          @previous_fragment_output_without_last_word =
+            pf.slice(0, pf.length - last_word_length)
+        end
+
+        def previous_fragment_ended_with_breakable?
+          @previous_fragment_ended_with_breakable
+        end
+
+        def fragment_begins_with_breakable?(fragment)
+          fragment =~ /^[#{break_chars(fragment.encoding)}]/
+        end
+
+        def line_finished?
+          @line_full || paragraph_finished?
+        end
+
+        def update_line_status_based_on_last_output
+          if @fragment_output&.match?(word_division_scan_pattern(@fragment_output.encoding))
+            @line_contains_more_than_one_word = true
+          end
+        end
+
+        def end_of_the_line_reached(segment)
+          update_line_status_based_on_last_output
+          unless @disable_wrap_by_char || @line_contains_more_than_one_word
+            wrap_by_char(segment)
+          end
+          @line_full = true
+        end
+
+        def wrap_by_char(segment)
+          segment.each_char do |char|
+            break unless append_char(char)
+          end
+        end
+
+        def append_char(char)
+          # kerning doesn't make sense in the context of a single character
+          char_width = @document.width_of(char)
+
+          if @accumulated_width + char_width <= @width
+            @accumulated_width += char_width
+            @fragment_output << char
+            true
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end