giga-fast-kit 0.0.1

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

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+module Prawn
+  module Text
+    module Formatted
+      # Implements a bi-directional parser between a subset of html and
+      # formatted text arrays.
+      class Parser
+        # @group Extension API
+
+        # Parser regular expression.
+        # @private
+        PARSER_REGEX =
+          begin
+            regex_string =
+              "\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.new(regex_string, Regexp::MULTILINE)
+          end
+
+        # Escaped characters.
+        # @private
+        ESCAPE_CHARS = {
+          '&' => '&amp;',
+          '>' => '&gt;',
+          '<' => '&lt;',
+        }.freeze
+
+        # @private
+        UNESCAPE_CHARS = ESCAPE_CHARS.invert.freeze
+
+        # Parse formatted string.
+        #
+        # @param string [String]
+        # @return [Array<Hash>] Text fragments.
+        def self.format(string, *_args)
+          tokens = string.gsub(%r{<br\s*/?>}, "\n").scan(PARSER_REGEX)
+          array_from_tokens(tokens)
+        end
+
+        # Serialize text fragments to an inline format string.
+        #
+        # @param array [Array<Hash>]
+        # @return [String]
+        def self.to_string(array)
+          prefixes = {
+            bold: '<b>',
+            italic: '<i>',
+            underline: '<u>',
+            strikethrough: '<strikethrough>',
+            subscript: '<sub>',
+            superscript: '<sup>',
+          }
+          suffixes = {
+            bold: '</b>',
+            italic: '</i>',
+            underline: '</u>',
+            strikethrough: '</strikethrough>',
+            subscript: '</sub>',
+            superscript: '</sup>',
+          }
+          array
+            .map { |hash|
+              prefix = ''
+              suffix = ''
+              hash[:styles]&.each do |style|
+                prefix += prefixes[style]
+                suffix = suffixes[style] + suffix
+              end
+
+              font = hash[:font] ? " name='#{hash[:font]}'" : nil
+              size = hash[:size] ? " size='#{hash[:size]}'" : nil
+              character_spacing =
+                if hash[:character_spacing]
+                  " character_spacing='#{hash[:character_spacing]}'"
+                end
+              if font || size || character_spacing
+                prefix += "<font#{font}#{size}#{character_spacing}>"
+                suffix = '</font>'
+              end
+
+              link = hash[:link] ? " href='#{hash[:link]}'" : nil
+              anchor = hash[:anchor] ? " anchor='#{hash[:anchor]}'" : nil
+              if link || anchor
+                prefix += "<link#{link}#{anchor}>"
+                suffix = '</link>'
+              end
+
+              if hash[:color]
+                prefix +=
+                  if hash[:color].is_a?(Array)
+                    "<color c='#{hash[:color][0]}' " \
+                      "m='#{hash[:color][1]}' " \
+                      "y='#{hash[:color][2]}' " \
+                      "k='#{hash[:color][3]}'>"
+                  else
+                    "<color rgb='#{hash[:color]}'>"
+                  end
+                suffix = '</color>'
+              end
+
+              string = escape(hash[:text])
+              prefix + string + suffix
+            }
+            .join
+        end
+
+        # Break text into paragraphs.
+        #
+        # @private
+        # @param array [Array<Hash>] Text fragments.
+        # @return [Array<Array<Hash>>] Pragraphs of text fragments.
+        def self.array_paragraphs(array)
+          paragraphs = []
+          paragraph = []
+          previous_string = "\n"
+          scan_pattern = /[^\n]+|\n/
+          array.each do |hash|
+            hash[:text].scan(scan_pattern).each do |string|
+              if string == "\n"
+                if previous_string == "\n"
+                  paragraph << hash.dup.merge(text: "\n")
+                end
+                paragraphs << paragraph unless paragraph.empty?
+                paragraph = []
+              else
+                paragraph << hash.dup.merge(text: string)
+              end
+              previous_string = string
+            end
+          end
+          paragraphs << paragraph unless paragraph.empty?
+          paragraphs
+        end
+
+        # @private
+        # @param tokens [Array<String>]
+        # @return [Array<Hash>]
+        def self.array_from_tokens(tokens)
+          array = []
+          styles = []
+          colors = []
+          link = nil
+          anchor = nil
+          local = nil
+          fonts = []
+          sizes = []
+          character_spacings = []
+
+          tokens.each do |token|
+            case token
+            when '<b>', '<strong>'
+              styles << :bold
+            when '<i>', '<em>'
+              styles << :italic
+            when '<u>'
+              styles << :underline
+            when '<strikethrough>'
+              styles << :strikethrough
+            when '<sub>'
+              styles << :subscript
+            when '<sup>'
+              styles << :superscript
+            when '</b>', '</strong>'
+              styles.delete(:bold)
+            when '</i>', '</em>'
+              styles.delete(:italic)
+            when '</u>'
+              styles.delete(:underline)
+            when '</strikethrough>'
+              styles.delete(:strikethrough)
+            when '</sub>'
+              styles.delete(:subscript)
+            when '</sup>'
+              styles.delete(:superscript)
+            when '</link>', '</a>'
+              link = nil
+              anchor = nil
+              local = nil
+            when '</color>'
+              colors.pop
+            when '</font>'
+              fonts.pop
+              sizes.pop
+              character_spacings.pop
+            when /^<link[^>]*>$/, /^<a[^>]*>$/
+              matches = /href="([^"]*)"/.match(token) ||
+                /href='([^']*)'/.match(token)
+              link = matches[1] unless matches.nil?
+
+              matches = /anchor="([^"]*)"/.match(token) ||
+                /anchor='([^']*)'/.match(token)
+              anchor = matches[1] unless matches.nil?
+
+              matches = /local="([^"]*)"/.match(token) ||
+                /local='([^']*)'/.match(token)
+              local = matches[1] unless matches.nil?
+            when /^<color[^>]*>$/
+              matches = /rgb="#?([^"]*)"/.match(token) ||
+                /rgb='#?([^']*)'/.match(token)
+              colors << matches[1] if matches
+
+              match = /c="#?([^"]*)"/.match(token) ||
+                /c='#?([^']*)'/.match(token)
+              c = Integer(match[1], 10) unless match.nil?
+              match = /m="#?([^"]*)"/.match(token) ||
+                /m='#?([^']*)'/.match(token)
+              m = Integer(match[1], 10) unless match.nil?
+              match = /y="#?([^"]*)"/.match(token) ||
+                /y='#?([^']*)'/.match(token)
+              y = Integer(match[1], 10) unless match.nil?
+              match = /k="#?([^"]*)"/.match(token) ||
+                /k='#?([^']*)'/.match(token)
+              k = Integer(match[1], 10) unless match.nil?
+              colors << [c, m, y, k] if [c, m, y, k].all?
+
+              # intend to support rgb="#ffffff" or rgb='#ffffff',
+              # r="255" g="255" b="255" or r='255' g='255' b='255',
+              # and c="100" m="100" y="100" k="100" or
+              # c='100' m='100' y='100' k='100'
+              # color = { :rgb => "#ffffff" }
+              # color = { :r => 255, :g => 255, :b => 255 }
+              # color = { :c => 100, :m => 100, :y => 100, :k => 100 }
+            when /^<font[^>]*>$/
+              matches = /name="([^"]*)"/.match(token) ||
+                /name='([^']*)'/.match(token)
+              fonts << matches[1] unless matches.nil?
+
+              matches = /size="([^"]*)"/.match(token) ||
+                /size='([^']*)'/.match(token)
+              sizes << Float(matches[1]) unless matches.nil?
+
+              matches = /character_spacing="([^"]*)"/.match(token) ||
+                /character_spacing='([^']*)'/.match(token)
+              character_spacings << Float(matches[1]) unless matches.nil?
+            else
+              string = unescape(token)
+              array << {
+                text: string,
+                styles: styles.dup,
+                color: colors.last,
+                local: local,
+                link: link,
+                anchor: anchor,
+                font: fonts.last,
+                size: sizes.last,
+                character_spacing: character_spacings.last,
+              }
+            end
+          end
+          array
+        end
+
+        # Escape characters that can interfere with inline format parsing.
+        #
+        # @param text [String]
+        # @return [String]
+        def self.escape(text)
+          text.gsub(Regexp.union(ESCAPE_CHARS.keys), ESCAPE_CHARS)
+        end
+
+        # Unescape characters that can interfere with inline format parsing.
+        #
+        # @param text [String]
+        # @return [String]
+        def self.unescape(text)
+          text.gsub(Regexp.union(UNESCAPE_CHARS.keys), UNESCAPE_CHARS)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require_relative 'line_wrap'
+require_relative 'arranger'
+
+module Prawn
+  module Text
+    module Formatted
+      # Handles text wrapping for for formatted text.
+      #
+      # @private
+      module Wrap
+        def initialize(_array, options)
+          @line_wrap = Prawn::Text::Formatted::LineWrap.new
+          @arranger = Prawn::Text::Formatted::Arranger.new(
+            @document,
+            kerning: options[:kerning],
+          )
+          @disable_wrap_by_char = options[:disable_wrap_by_char]
+        end
+
+        # See the developer documentation for PDF::Core::Text#wrap
+        #
+        # Formatted#wrap should set the following variables:
+        #   <tt>@line_height</tt>::
+        #        the height of the tallest fragment in the last printed line
+        #   <tt>@descender</tt>::
+        #        the descender height of the tallest fragment in the last
+        #        printed line
+        #   <tt>@ascender</tt>::
+        #        the ascender heigth of the tallest fragment in the last
+        #        printed line
+        #   <tt>@baseline_y</tt>::
+        #       the baseline of the current line
+        #   <tt>@nothing_printed</tt>::
+        #       set to true until something is printed, then false
+        #   <tt>@everything_printed</tt>::
+        #       set to false until everything printed, then true
+        #
+        # Returns any formatted text that was not printed
+        #
+        def wrap(array)
+          initialize_wrap(array)
+
+          stop = false
+          until stop
+            # wrap before testing if enough height for this line because the
+            # height of the highest fragment on this line will be used to
+            # determine the line height
+            @line_wrap.wrap_line(
+              document: @document,
+              kerning: @kerning,
+              width: available_width,
+              arranger: @arranger,
+              disable_wrap_by_char: @disable_wrap_by_char,
+            )
+
+            if enough_height_for_this_line?
+              move_baseline_down
+              print_line
+            else
+              stop = true
+            end
+
+            stop ||= @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
+          fragments_this_line.reverse! if @direction == :rtl
+          fragments_this_line.each do |fragment_this_line|
+            fragment_this_line.default_direction = @direction
+            format_and_draw_fragment(
+              fragment_this_line,
+              accumulated_width,
+              @line_wrap.width,
+              word_spacing,
+            )
+            accumulated_width += fragment_this_line.width
+          end
+
+          @printed_lines << printed_fragments.map { |s|
+            s.dup.force_encoding(::Encoding::UTF_8)
+          }.join
+        end
+
+        def word_spacing_for_this_line
+          if @align == :justify && @line_wrap.space_count.positive? &&
+              !@line_wrap.paragraph_finished?
+            (available_width - @line_wrap.width) / @line_wrap.space_count
+          else
+            0
+          end
+        end
+
+        def enough_height_for_this_line?
+          @line_height = @arranger.max_line_height
+          @descender = @arranger.max_descender
+          @ascender = @arranger.max_ascender
+          diff =
+            if @baseline_y.zero?
+              @ascender + @descender
+            else
+              @descender + @line_height + @leading
+            end
+          require_relatived_total_height = @baseline_y.abs + diff
+          if require_relatived_total_height > @height + 0.0001
+            # no room for the full height of this line
+            @arranger.repack_unretrieved
+            false
+          else
+            true
+          end
+        end
+
+        def initialize_wrap(array)
+          @text = nil
+          @arranger.format_array = array
+
+          # these values will depend on the maximum value within a given line
+          @line_height = 0
+          @descender = 0
+          @ascender = 0
+          @baseline_y = 0
+
+          @printed_lines = []
+          @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

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative 'formatted/wrap'
+
+module Prawn
+  module Text
+    # Fancy pretty text.
+    module Formatted
+      # @group Stable API
+
+      # Draws the requested formatted text into a box.
+      #
+      # When the text overflows the rectangle shrink to fit or truncate the
+      # text. Text boxes are independent of the document y position.
+      #
+      # @example
+      #   formatted_text_box([{ :text => "hello" },
+      #                       { :text => "world",
+      #                         :size => 24,
+      #                         :styles => [:bold, :italic] }])
+      #
+      # @param array [Array<Hash{Symbol => any}>]
+      #   Formatted text is an array of hashes, where each hash defines text and
+      #   format information. The following hash options are supported:
+      #
+      #   - `:text` --- the text to format according to the other hash options.
+      #   - `:styles` --- an array of styles to apply to this text. Available
+      #     styles include `:bold`, `:italic`, `:underline`, `:strikethrough`,
+      #     `:subscript`, and `:superscript`.
+      #   - `:size` ---a number denoting the font size to apply to this text.
+      #   - `:character_spacing` --- a number denoting how much to increase or
+      #     decrease the default spacing between characters.
+      #   - `:font` --- the name of a font. The name must be an AFM font with
+      #     the desired faces or must be a font that is already registered using
+      #     {Prawn::Document#font_families}.
+      #   - `:color` --- anything compatible with
+      #     {Prawn::Graphics::Color#fill_color} and
+      #     {Prawn::Graphics::Color#stroke_color}.
+      #   - :link` --- a URL to which to create a link. A clickable link will be
+      #     created to that URL. Note that you must explicitly underline and
+      #     color using the appropriate tags if you which to draw attention to
+      #     the link.
+      #   - `:anchor` --- a destination that has already been or will be
+      #     registered using
+      #     `PDF::Core::Destinations#add_dest`{:.language-plain}. A clickable
+      #     link will be created to that destination. Note that you must
+      #     explicitly underline and color using the appropriate tags if you
+      #     which to draw attention to the link.
+      #   - `:local` --- a file or application to be opened locally. A clickable
+      #     link will be created to the provided local file or application. If
+      #     the file is another PDF, it will be opened in a new window. Note
+      #     that you must explicitly underline and color using the appropriate
+      #     options if you which to draw attention to the link.
+      #   - `:draw_text_callback` --- if provided, this Proc will be called
+      #     instead of {#draw_text!} once per fragment for every low-level
+      #     addition of text to the page.
+      #   - `:callback` --- an object (or array of such objects) with two
+      #     methods: `#render_behind`{:.language-plain} and
+      #     `#render_in_front`{:.language-plain}, which are called immediately
+      #     prior to and immediately after rendering the text fragment and which
+      #     are passed the fragment as an argument.
+      # @param options [Hash{Symbol => any}]
+      #   Accepts the same options as {Text::Box}.
+      #
+      # @return [Array<Hash>]
+      #   A formatted text array representing 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 formatted_text_box(array, options = {})
+        Text::Formatted::Box.new(array, options.merge(document: self)).render
+      end
+    end
+  end
+end
+
+require_relative 'formatted/box'
+require_relative 'formatted/parser'
+require_relative 'formatted/fragment'