krill 0.1.0 → 0.2.0

data/lib/krill/fragment.rb

@@ -0,0 +1,146 @@
+module Krill
+  class Fragment
+    attr_reader :format_state, :text
+    attr_writer :width
+    attr_accessor :line_height, :descender, :ascender
+    attr_accessor :word_spacing, :left, :baseline
+
+    attr_reader :font
+    alias formatter font
+
+    def initialize(text, format_state)
+      @format_state = format_state
+      @font = format_state.fetch(:font)
+      @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
+
+    def width
+      return @width if @word_spacing.zero?
+      @width + @word_spacing * space_count
+    end
+
+    def height
+      top - bottom
+    end
+
+    def superscript?
+      formatter.superscript?
+    end
+
+    def subscript?
+      formatter.subscript?
+    end
+
+    def character_spacing
+      formatter.character_spacing
+    end
+
+    def y_offset
+      if subscript? then -descender
+      elsif superscript? then 0.85 * ascender
+      else 0
+      end
+    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 direction
+      @format_state[:direction]
+    end
+
+    def default_direction=(direction)
+      unless @format_state[:direction]
+        @format_state[:direction] = direction
+        @text = process_text(@original_text)
+      end
+    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 right
+      left + width
+    end
+
+    def top
+      baseline + ascender
+    end
+
+    def bottom
+      baseline - descender
+    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..-1]
+        end
+      else
+        if soft_hyphens_need_processing?(string)
+          string = process_soft_hyphens(string)
+        end
+      end
+
+      case direction
+      when :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.length > 0 && 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(ZWSP, "")
+      else
+        string
+      end
+    end
+
+  end
+end

data/lib/krill/line_wrap.rb

@@ -0,0 +1,287 @@
+module Krill
+  class LineWrap
+
+    # The width of the last wrapped line
+    #
+    def width
+      @accumulated_width || 0
+    end
+
+    # The number of spaces in the last wrapped line
+    attr_reader :space_count
+    attr_reader :soft_hyphen
+    attr_reader :zero_width_space
+
+    # Whether this line is the last line in the paragraph
+    def paragraph_finished?
+      @newline_encountered || is_next_string_newline? || @arranger.finished?
+    end
+
+    def tokenize(fragment)
+      fragment.scan(scan_pattern)
+    end
+
+    # Work in conjunction with the PDF::Formatted::Arranger
+    # defined in the :arranger option to determine what formatted text
+    # will fit within the width defined by the :width option
+    #
+    def wrap_line(width:, arranger:, kerning: nil, disable_wrap_by_char: nil)
+      initialize_line(
+        kerning: kerning,
+        width: width,
+        arranger: arranger,
+        disable_wrap_by_char: disable_wrap_by_char)
+
+      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? && is_next_string_newline?
+      @arranger.update_last_string("", "", soft_hyphen) if empty
+      empty
+    end
+
+    def is_next_string_newline?
+      @arranger.preview_next_string == "\n"
+    end
+
+    def apply_font_settings_and_add_fragment_to_line(fragment)
+      # if font has changed from Unicode to non-Unicode, or vice versa,
+      # the characters used for soft hyphens and zero-width spaces will
+      # be different.
+      set_soft_hyphen_and_zero_width_space(@arranger.current_formatter)
+      add_fragment_to_line(fragment, @arranger.current_formatter)
+    end
+
+    # returns true if all text was printed without running into the end of
+    # the line
+    #
+    def add_fragment_to_line(fragment, formatter)
+      if fragment == ""
+        true
+      elsif fragment == "\n"
+        @newline_encountered = true
+        false
+      else
+        tokenize(fragment).each do |segment|
+          if segment == zero_width_space
+            segment_width = 0
+          else
+            segment_width = formatter.width_of(segment, kerning: @kerning)
+          end
+
+          if @accumulated_width + segment_width <= @width
+            @accumulated_width += segment_width
+            if segment[-1] == soft_hyphen
+              sh_width = formatter.width_of("#{soft_hyphen}", kerning: @kerning)
+              @accumulated_width -= sh_width
+            end
+            @fragment_output += segment
+          else
+            end_of_the_line_reached(formatter, 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 do |c|
+        c.encode(encoding)
+      end
+
+      Regexp.union(
+        common_whitespaces +
+        [
+          zero_width_space(encoding),
+          soft_hyphen(encoding),
+          hyphen(encoding)
+        ].compact
+      )
+    end
+
+    def soft_hyphen(encoding = ::Encoding::UTF_8)
+      Krill::SHY.encode(encoding)
+    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)
+      Krill::ZWSP.encode(encoding)
+    end
+
+    def whitespace(encoding = ::Encoding::UTF_8)
+      "\s\t#{zero_width_space(encoding)}".encode(encoding)
+    end
+
+    def hyphen(_encoding = ::Encoding::UTF_8)
+      '-'
+    end
+
+
+
+    def line_empty?
+      @line_empty && @accumulated_width == 0
+    end
+
+    def initialize_line(kerning:, width:, arranger:, disable_wrap_by_char:)
+      @kerning = kerning
+      @width = width
+
+      @disable_wrap_by_char = disable_wrap_by_char
+
+      @accumulated_width = 0
+      @line_empty = true
+      @line_contains_more_than_one_word = false
+
+      @arranger = arranger
+      @arranger.initialize_line
+
+      @newline_encountered = false
+      @line_full = false
+    end
+
+    def set_soft_hyphen_and_zero_width_space(formatter)
+      # this is done once per fragment, after the font settings for the fragment are applied --
+      #   it could actually be skipped if the font hasn't changed
+      @soft_hyphen = formatter.normalize_encoding(SHY)
+      @zero_width_space = formatter.unicode? ? ZWSP : ""
+    end
+
+    def fragment_finished(fragment)
+      if fragment == "\n"
+        @newline_encountered = true
+        @line_empty = false
+      else
+        update_output_based_on_last_fragment(fragment, soft_hyphen)
+        update_line_status_based_on_last_output
+        determine_whether_to_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)
+      fail 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 determine_whether_to_pull_preceding_fragment_to_join_this_one(current_fragment)
+      if @fragment_output.empty? && !current_fragment.empty? && @line_contains_more_than_one_word
+        unless 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
+    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}]$/
+      last_word = pf.slice(/[^#{break_chars}]*$/)
+      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}]/
+    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 =~ word_division_scan_pattern
+    end
+
+    def end_of_the_line_reached(formatter, segment)
+      update_line_status_based_on_last_output
+      wrap_by_char(formatter, segment) unless @disable_wrap_by_char || @line_contains_more_than_one_word
+      @line_full = true
+    end
+
+    def wrap_by_char(formatter, segment)
+      segment.each_char do |char|
+        break unless append_char(char, formatter)
+      end
+    end
+
+    def append_char(char, formatter)
+      # kerning doesn't make sense in the context of a single character
+      char_width = formatter.compute_width_of(char, kerning: false)
+
+      if @accumulated_width + char_width <= @width
+        @accumulated_width += char_width
+        @fragment_output << char
+        true
+      else
+        false
+      end
+    end
+
+  end
+end

data/lib/krill/text_box.rb

@@ -0,0 +1,244 @@
+require "krill/line_wrap"
+require "krill/arranger"
+
+module Krill
+  class TextBox
+
+    def initialize(formatted_text, options={})
+      @original_array       = formatted_text
+      @text                 = nil
+      @at                   = [0, 720.0] # was [ @document.bounds.left, @document.bounds.top ]
+      @width                = options.fetch(:width)
+      @height               = options.fetch(:height, @at[1])
+      @direction            = options.fetch(:direction, :ltr)
+      @align                = options.fetch(:align, @direction == :rtl ? :right : :left)
+      @leading              = options.fetch(:leading, 0)
+      @kerning              = options.fetch(:kerning, true)
+      @disable_wrap_by_char = options[:disable_wrap_by_char]
+      @line_wrap            = Krill::LineWrap.new
+      @arranger             = Krill::Arranger.new(kerning: @kerning)
+    end
+
+    def render
+      wrap(normalize_encoding(original_text))
+    end
+
+    # The text that was successfully printed (or, if <tt>dry_run</tt> was
+    # used, the text that would have been successfully printed)
+    attr_reader :text
+
+    # True if nothing printed (or, if <tt>dry_run</tt> was
+    # used, nothing would have been successfully printed)
+    def nothing_printed?
+      @nothing_printed
+    end
+
+    # True if everything printed (or, if <tt>dry_run</tt> was
+    # used, everything would have been successfully printed)
+    def everything_printed?
+      @everything_printed
+    end
+
+    # The upper left corner of the text box
+    attr_reader :at
+
+    # The line height of the last line printed
+    attr_reader :line_height
+
+    # The height of the ascender of the last line printed
+    attr_reader :ascender
+
+    # The height of the descender of the last line printed
+    attr_reader :descender
+
+    # The leading used during printing
+    attr_reader :leading
+
+    def line_gap
+      line_height - (ascender + descender)
+    end
+
+    # The height actually used during the previous <tt>render</tt>
+    def height
+      return 0 if @baseline_y.nil? || @descender.nil?
+      (@baseline_y - @descender).abs
+    end
+
+  private
+
+    # The width available at this point in the box
+    def available_width
+      @width
+    end
+
+    # <tt>fragment</tt> is a Krill::Fragment object
+    def draw_fragment(fragment, accumulated_width=0, line_width=0, word_spacing=0)
+      case @align
+      when :left
+        x = @at[0]
+      when :center
+        x = @at[0] + @width * 0.5 - line_width * 0.5
+      when :right
+        x = @at[0] + @width - line_width
+      when :justify
+        x = if @direction == :ltr
+              @at[0]
+            else
+              @at[0] + @width - line_width
+            end
+      end
+
+      x += accumulated_width
+
+      y = @at[1] + @baseline_y
+
+      y += fragment.y_offset
+
+      fragment.left = x
+      fragment.baseline = y
+    end
+
+    def original_text
+      @original_array.collect(&:dup)
+    end
+
+    def normalize_encoding(text)
+      text.each do |hash|
+        hash[:text] = hash.fetch(:font).normalize_encoding(hash.fetch(:text))
+      end
+    end
+
+    def move_baseline_down
+      if @baseline_y.zero?
+        @baseline_y = -@ascender
+      else
+        @baseline_y -= (@line_height + @leading)
+      end
+    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(
+          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 ||= @arranger.finished?
+      end
+      @text = @printed_lines.join("\n")
+      @everything_printed = @arranger.finished?
+      @arranger.unconsumed
+    end
+
+    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 do |s|
+        s.force_encoding(::Encoding::UTF_8)
+      end.join
+    end
+
+    def word_spacing_for_this_line
+      if @align == :justify && @line_wrap.space_count > 0 && !@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)
+      draw_fragment(fragment, accumulated_width, line_width, word_spacing)
+    end
+
+  end
+end