giga-fast-kit 0.0.1

data/prawn-2.5.0/lib/prawn/text/box.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require_relative 'formatted/box'
+
+module Prawn
+  module Text # rubocop: disable Style/Documentation
+    # @group Stable API
+
+    # Draws the requested text into a box.
+    #
+    # When the text overflows the rectangle, you shrink to fit, or truncate the
+    # text. Text boxes are independent of the document y position.
+    #
+    # #### Encoding
+    #
+    # Note that strings passed to this function should be encoded as UTF-8. If
+    # you get unexpected characters appearing in your rendered document, check
+    # this.
+    #
+    # If the current font is a built-in one, although the string must be encoded
+    # as UTF-8, only characters that are available in WinAnsi are allowed.
+    #
+    # If an empty box is rendered to your PDF instead of the character you
+    # wanted it usually means the current font doesn't include that character.
+    #
+    # @param string [String]
+    # @param options [Hash{Symbol => any}]
+    # @option options :kerning [Boolean] (value of document.default_kerning?)
+    #   Whether or not to use kerning (if it is available with the current
+    #   font).
+    # @option options :size [Number] (current font size)
+    #   The font size to use.
+    # @option options :character_spacing [Number] (0)
+    #   The amount of space to add to or remove from the default character
+    #   spacing.
+    # @option options :disable_wrap_by_char [Boolean] (false)
+    #   Whether or not to prevent mid-word breaks when text does not fit in box.
+    # @option options :mode [Symbol] (:fill)
+    #   The text rendering mode. See documentation for
+    #   {Prawn::Document#text_rendering_mode} for a list of valid options.
+    # @option option :style [Symbol] (current style)
+    #   The style to use. The requested style must be part of the current font
+    #   family.
+    # @option option :at [Array(Number, Number)] (bounds top left corner)
+    #   The upper left corner of the box.
+    # @option options :width [Number] (bounds.right - at[0])
+    #   The width of the box.
+    # @option options :height [Number] (default_height())
+    #   The height of the box.
+    # @option options :direction [:ltr, :rtl] (value of document.text_direction)
+    #   Direction of the text (left-to-right or right-to-left).
+    # @option options :fallback_fonts [Array<String>]
+    #   An array of font names. Each name must be the name of an AFM font or the
+    #   name that was used to register a family of external fonts (see
+    #   {Prawn::Document#font_families}). If present, then each glyph will be
+    #   rendered using the first font that includes the glyph, starting with the
+    #   current font and then moving through `:fallback_fonts`.
+    # @option options :align [:left, :center, :right, :justify]
+    #   (:left if direction is :ltr, :right if direction is :rtl)
+    #   Alignment within the bounding box.
+    # @option options :valign [:top, :center, :bottom] (:top)
+    #   Vertical alignment within the bounding box.
+    # @option options :rotate [Number]
+    #   The angle to rotate the text.
+    # @option options :rotate_around
+    #   [:center, :upper_left, :upper_right, :lower_right, :lower_left]
+    #   (:upper_left)
+    #   The point around which to rotate the text.
+    # @option options :leading [Number] (value of document.default_leading)
+    #   Additional space between lines.
+    # @option options :single_line [Boolean] (false)
+    #   If true, then only the first line will be drawn.
+    # @option options :overflow [:truncate, :shrink_to_fit, :expand] (:truncate)
+    #   This controls the behavior when the amount of text exceeds the available
+    #   space.
+    # @option options :min_font_size [Number] (5)
+    #   The minimum font size to use when `:overflow` is set to `:shrink_to_fit`
+    #   (that is the font size will not be reduced to less than this value, even
+    #   if it means that some text will be cut off).
+    # @return [String] Any text that did not print under the current settings.
+    # @raise [Prawn::Errors::CannotFit]
+    #   If not wide enough to print any text.
+    def text_box(string, options = {})
+      options = options.dup
+      options[:document] = self
+
+      box =
+        if options[:inline_format]
+          p = options.delete(:inline_format)
+          p = [] unless p.is_a?(Array)
+          array = text_formatter.format(string, *p)
+          Text::Formatted::Box.new(array, options)
+        else
+          Text::Box.new(string, options)
+        end
+
+      box.render
+    end
+
+    # @group Experimental API
+
+    # Text box.
+    #
+    # Generally, one would use the {Prawn::Text#text_box} convenience method.
+    # However, using {Prawn::Text::Box#initialize Box.new} in conjunction with
+    # `render(dry_run: true)` enables one to do calculations prior to placing
+    # text on the page, or to determine how much vertical space was consumed by
+    # the printed text.
+    class Box < Prawn::Text::Formatted::Box
+      # @param string [String]
+      # @param options [Hash{Symbol => any}]
+      # @option options :document [Prawn::Document] Owning document.
+      # @option options :kerning [Boolean] (value of document.default_kerning?)
+      #   Whether or not to use kerning (if it is available with the current
+      #   font).
+      # @option options :size [Number] (current font size)
+      #   The font size to use.
+      # @option options :character_spacing [Number] (0)
+      #   The amount of space to add to or remove from the default character
+      #   spacing.
+      # @option options :disable_wrap_by_char [Boolean] (false)
+      #   Whether or not to prevent mid-word breaks when text does not fit in box.
+      # @option options :mode [Symbol] (:fill)
+      #   The text rendering mode. See documentation for
+      #   {Prawn::Document#text_rendering_mode} for a list of valid options.
+      # @option option :style [Symbol] (current style)
+      #   The style to use. The requested style must be part of the current font
+      #   family.
+      # @option option :at [Array(Number, Number)] (bounds top left corner)
+      #   The upper left corner of the box.
+      # @option options :width [Number] (bounds.right - at[0])
+      #   The width of the box.
+      # @option options :height [Number] (default_height())
+      #   The height of the box.
+      # @option options :direction [:ltr, :rtl] (value of document.text_direction)
+      #   Direction of the text (left-to-right or right-to-left).
+      # @option options :fallback_fonts [Array<String>]
+      #   An array of font names. Each name must be the name of an AFM font or the
+      #   name that was used to register a family of external fonts (see
+      #   {Prawn::Document#font_families}). If present, then each glyph will be
+      #   rendered using the first font that includes the glyph, starting with the
+      #   current font and then moving through `:fallback_fonts`.
+      # @option options :align [:left, :center, :right, :justify]
+      #   (:left if direction is :ltr, :right if direction is :rtl)
+      #   Alignment within the bounding box.
+      # @option options :valign [:top, :center, :bottom] (:top)
+      #   Vertical alignment within the bounding box.
+      # @option options :rotate [Number]
+      #   The angle to rotate the text.
+      # @option options :rotate_around
+      #   [:center, :upper_left, :upper_right, :lower_right, :lower_left]
+      #   (:upper_left)
+      #   The point around which to rotate the text.
+      # @option options :leading [Number] (value of document.default_leading)
+      #   Additional space between lines.
+      # @option options :single_line [Boolean] (false)
+      #   If true, then only the first line will be drawn.
+      # @option options :overflow [:truncate, :shrink_to_fit, :expand] (:truncate)
+      #   This controls the behavior when the amount of text exceeds the available
+      #   space.
+      # @option options :min_font_size [Number] (5)
+      #   The minimum font size to use when `:overflow` is set to `:shrink_to_fit`
+      #   (that is the font size will not be reduced to less than this value, even
+      #   if it means that some text will be cut off).
+      def initialize(string, options = {})
+        super([{ text: string }], options)
+      end
+
+      # Render text to the document based on the settings defined in
+      # constructor.
+      #
+      # In order to facilitate look-ahead calculations, this method accepts
+      # a `dry_run: true` option. If provided, then everything is executed as if
+      # rendering, with the exception that nothing is drawn on the page.  Useful
+      # for look-ahead computations of height, unprinted text, etc.
+      #
+      # @param flags [Hash{Symbol => any}]
+      # @option flags :dry_run [Boolean] (false)
+      #   Do not draw the text. Everything else is done.
+      # @return [String]
+      #   Any text that did not print under the current settings.
+      # @raise [Prawn::Text::Formatted::Arranger::BadFontFamily]
+      #   If no font family is defined for the current font.
+      # @raise [Prawn::Errors::CannotFit]
+      #   If not wide enough to print any text.
+      def render(flags = {})
+        leftover = super(flags)
+        leftover.map { |hash| hash[:text] }.join
+      end
+    end
+  end
+end

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

@@ -0,0 +1,396 @@
+# frozen_string_literal: true
+
+module Prawn
+  module Text
+    module Formatted
+      # D data structure for 2-stage processing of lines of formatted text.
+      # @private
+      class Arranger
+        # You're getting this because you're trying to get some information from
+        # the arranger before it finished processing text.
+        class NotFinalized < StandardError
+          # @private
+          DEFAULT_MESSAGE = 'Lines must be finalized'
+
+          # @private
+          MESSAGE_WITH_METHOD = 'Lines must be finalized before calling #%<method>s'
+
+          def initialize(message = DEFAULT_MESSAGE, method: nil)
+            if method && message == DEFAULT_MESSAGE
+              super(format(MESSAGE_WITH_METHOD, method: method))
+            else
+              super(message)
+            end
+          end
+        end
+
+        # You're getting this because a font doesn't have a family name.
+        class BadFontFamily < StandardError
+          def initialize(message = 'Bad font family')
+            super
+          end
+        end
+
+        attr_reader :max_line_height
+        attr_reader :max_descender
+        attr_reader :max_ascender
+        attr_reader :finalized
+        attr_accessor :consumed
+
+        # The following present only for testing purposes
+        attr_reader :unconsumed
+        attr_reader :fragments
+        attr_reader :current_format_state
+
+        def initialize(document, options = {})
+          @document = document
+          @fragments = []
+          @unconsumed = []
+          @kerning = options[:kerning]
+        end
+
+        # Number of spaces in the text.
+        #
+        # @return [Integer]
+        # @raise [NotFinalized]
+        def space_count
+          unless finalized
+            raise NotFinalized.new(method: 'space_count')
+          end
+
+          @fragments.reduce(0) do |sum, fragment|
+            sum + fragment.space_count
+          end
+        end
+
+        # Line width.
+        #
+        # @return [Number]
+        # @raise [NotFinalized]
+        def line_width
+          unless finalized
+            raise raise NotFinalized.new(method: 'line_width')
+          end
+
+          @fragments.reduce(0) do |sum, fragment|
+            sum + fragment.width
+          end
+        end
+
+        # Line text.
+        #
+        # @return [String]
+        # @raise [NotFinalized]
+        def line
+          unless finalized
+            raise NotFinalized.new(method: 'line')
+          end
+
+          @fragments.map { |fragment|
+            begin
+              fragment.text.dup.encode(::Encoding::UTF_8)
+            rescue ::Encoding::InvalidByteSequenceError, ::Encoding::UndefinedConversionError
+              fragment.text.dup.force_encoding(::Encoding::UTF_8)
+            end
+          }.join
+        end
+
+        # Finish laying out current line.
+        #
+        # @return [void]
+        def finalize_line
+          @finalized = true
+
+          omit_trailing_whitespace_from_line_width
+          @fragments = []
+          @consumed.each do |hash|
+            text = hash[:text]
+            format_state = hash.dup
+            format_state.delete(:text)
+            fragment = Prawn::Text::Formatted::Fragment.new(
+              text,
+              format_state,
+              @document,
+            )
+            @fragments << fragment
+            self.fragment_measurements = fragment
+            self.line_measurement_maximums = fragment
+          end
+        end
+
+        # Set new fragment array.
+        #
+        # @param array [Array<Hash>]
+        # @return [void]
+        def format_array=(array)
+          initialize_line
+          @unconsumed = []
+          array.each do |hash|
+            hash[:text].scan(/[^\n]+|\n/) do |line|
+              @unconsumed << hash.merge(text: line)
+            end
+          end
+        end
+
+        # Prepare for new line layout.
+        #
+        # @return [void]
+        def initialize_line
+          @finalized = false
+          @max_line_height = 0
+          @max_descender = 0
+          @max_ascender = 0
+
+          @consumed = []
+          @fragments = []
+        end
+
+        # Were all fragments processed?
+        #
+        # @return [Boolean]
+        def finished?
+          @unconsumed.empty?
+        end
+
+        # Get the next unprocessed string.
+        #
+        # @return [String, nil]
+        # @raise [NotFinalized]
+        def next_string
+          if finalized
+            raise NotFinalized.new(method: 'next_string')
+          end
+
+          next_unconsumed_hash = @unconsumed.shift
+
+          if next_unconsumed_hash
+            @consumed << next_unconsumed_hash.dup
+            @current_format_state = next_unconsumed_hash.dup
+            @current_format_state.delete(:text)
+
+            next_unconsumed_hash[:text]
+          end
+        end
+
+        # Get the next unprocessed string keeping it in the queue.
+        #
+        # @return [String, nil]
+        def preview_next_string
+          next_unconsumed_hash = @unconsumed.first
+
+          if next_unconsumed_hash
+            next_unconsumed_hash[:text]
+          end
+        end
+
+        # Apply color and font settings.
+        #
+        # @param fragment [Prawn::Text::Formatted::Fragment]
+        # @yield
+        # @return [void]
+        def apply_color_and_font_settings(fragment, &block)
+          if 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, &block)
+            @document.stroke_color = original_stroke_color
+            @document.fill_color = original_fill_color
+          else
+            apply_font_settings(fragment, &block)
+          end
+        end
+
+        # Apply font settings.
+        #
+        # @param fragment [Prawn::Text::Formatted::Fragment]
+        # @yield
+        # @return [void]
+        def apply_font_settings(fragment = nil, &block)
+          if fragment.nil?
+            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]
+          else
+            font = fragment.font
+            size = fragment.size
+            character_spacing = fragment.character_spacing
+            styles = fragment.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,
+              ) do
+                apply_font_size(size, styles, &block)
+              end
+            else
+              apply_font_size(size, styles, &block)
+            end
+          end
+        end
+
+        # Update last fragment's text.
+        #
+        # @param printed [String]
+        # @param unprinted [String]
+        # @param normalized_soft_hyphen [Boolean]
+        # @return [void]
+        def update_last_string(printed, unprinted, normalized_soft_hyphen = nil)
+          return if printed.nil?
+
+          if printed.empty?
+            @consumed.pop
+          else
+            @consumed.last[:text] = printed
+            if normalized_soft_hyphen
+              @consumed.last[:normalized_soft_hyphen] = normalized_soft_hyphen
+            end
+          end
+
+          unless unprinted.empty?
+            @unconsumed.unshift(@current_format_state.merge(text: unprinted))
+          end
+
+          load_previous_format_state if printed.empty?
+        end
+
+        # Get the next fragment.
+        #
+        # @return [Prawn::Text::Formatted::Fragment]
+        # @raise [NotFinalized]
+        def retrieve_fragment
+          unless finalized
+            raise NotFinalized, 'Lines must be finalized before fragments can be retrieved'
+          end
+
+          @fragments.shift
+        end
+
+        # Repack remaining fragments.
+        #
+        # @return [void]
+        def repack_unretrieved
+          new_unconsumed = []
+          # rubocop: disable Lint/AssignmentInCondition
+          while fragment = retrieve_fragment
+            # rubocop: enable Lint/AssignmentInCondition
+            fragment.include_trailing_white_space!
+            new_unconsumed << fragment.format_state.merge(text: fragment.text)
+          end
+          @unconsumed = new_unconsumed.concat(@unconsumed)
+        end
+
+        # Get font variant from fragment styles.
+        #
+        # @param styles [Array<Symbol>]
+        # @return [Symbol]
+        def font_style(styles)
+          styles = Array(styles)
+          if styles.include?(:bold) && styles.include?(:italic)
+            :bold_italic
+          elsif styles.include?(:bold)
+            :bold
+          elsif styles.include?(:italic)
+            :italic
+          else
+            :normal
+          end
+        end
+
+        private
+
+        def load_previous_format_state
+          if @consumed.empty?
+            @current_format_state = {}
+          else
+            hash = @consumed.last
+            @current_format_state = hash.dup
+            @current_format_state.delete(:text)
+          end
+        end
+
+        def apply_font_size(size, styles, &block)
+          if subscript?(styles) || superscript?(styles)
+            relative_size = 0.583
+            size =
+              if size.nil?
+                @document.font_size * relative_size
+              else
+                size * relative_size
+              end
+          end
+          if size.nil?
+            yield
+          else
+            @document.font_size(size, &block)
+          end
+        end
+
+        def subscript?(styles)
+          if styles.nil? then false
+          else
+            styles.include?(:subscript)
+          end
+        end
+
+        def superscript?(styles)
+          if styles.nil? then false
+          else
+            styles.include?(:superscript)
+          end
+        end
+
+        def omit_trailing_whitespace_from_line_width
+          @consumed.reverse_each do |hash|
+            if hash[:text] == "\n"
+              break
+            elsif hash[:text].strip.empty? && @consumed.length > 1
+              # this entire fragment is trailing white space
+              hash[:exclude_trailing_white_space] = true
+            else
+              # this fragment contains the first non-white space we have
+              # encountered since the end of the line
+              hash[:exclude_trailing_white_space] = true
+              break
+            end
+          end
+        end
+
+        def fragment_measurements=(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
+
+        def line_measurement_maximums=(fragment)
+          @max_line_height = [
+            defined?(@max_line_height) && @max_line_height,
+            fragment.line_height,
+          ].compact.max
+          @max_descender = [
+            defined?(@max_descender) && @max_descender,
+            fragment.descender,
+          ].compact.max
+          @max_ascender = [
+            defined?(@max_ascender) && @max_ascender,
+            fragment.ascender,
+          ].compact.max
+        end
+      end
+    end
+  end
+end