prawn 2.1.0 → 2.2.0

data/spec/prawn/text/formatted/fragment_spec.rb

@@ -0,0 +1,341 @@
+require 'spec_helper'
+
+describe Prawn::Text::Formatted::Fragment do
+  let(:pdf) { create_pdf }
+
+  describe 'Text::Formatted::Fragment' do
+    let(:fragment) do
+      format_state = {
+        styles: [:bold, :italic],
+        color: nil,
+        link: nil,
+        anchor: nil,
+        font: nil,
+        size: nil
+      }
+      described_class.new(
+        'hello world',
+        format_state,
+        pdf
+      ).tap do |fragment|
+        fragment.width = 100
+        fragment.left = 50
+        fragment.baseline = 200
+        fragment.line_height = 27
+        fragment.descender = 7
+        fragment.ascender = 17
+      end
+    end
+
+    describe '#width' do
+      it 'returns the width' do
+        expect(fragment.width).to eq(100)
+      end
+    end
+
+    describe '#styles' do
+      it 'returns the styles array' do
+        expect(fragment.styles).to eq([:bold, :italic])
+      end
+
+      it 'nevers return nil' do
+        format_state = {
+          styles: nil,
+          color: nil,
+          link: nil,
+          anchor: nil,
+          font: nil,
+          size: nil
+        }
+        fragment = described_class.new(
+          'hello world',
+          format_state,
+          pdf
+        )
+        expect(fragment.styles).to eq([])
+      end
+    end
+
+    describe '#line_height' do
+      it 'returns the line_height' do
+        expect(fragment.line_height).to eq(27)
+      end
+    end
+
+    describe '#ascender' do
+      it 'returns the ascender' do
+        expect(fragment.ascender).to eq(17)
+      end
+    end
+
+    describe '#descender' do
+      it 'returns the descender' do
+        expect(fragment.descender).to eq(7)
+      end
+    end
+
+    describe '#y_offset' do
+      it 'is zero' do
+        expect(fragment.y_offset).to eq(0)
+      end
+    end
+
+    describe '#bounding_box' do
+      it 'returns the bounding box surrounding the fragment' do
+        target_box = [50, 193, 150, 217]
+        expect(fragment.bounding_box).to eq(target_box)
+      end
+    end
+
+    describe '#absolute_bounding_box' do
+      it 'should return the bounding box surrounding the fragment' \
+        ' in absolute coordinates' do
+        target_box = [50, 193, 150, 217]
+        target_box[0] += pdf.bounds.absolute_left
+        target_box[1] += pdf.bounds.absolute_bottom
+        target_box[2] += pdf.bounds.absolute_left
+        target_box[3] += pdf.bounds.absolute_bottom
+
+        expect(fragment.absolute_bounding_box).to eq(target_box)
+      end
+    end
+
+    describe '#underline_points' do
+      it 'defines a line under the fragment' do
+        y = 198.75
+        target_points = [[50, y], [150, y]]
+        expect(fragment.underline_points).to eq(target_points)
+      end
+    end
+
+    describe '#strikethrough_points' do
+      it 'defines a line through the fragment' do
+        y = 200 + fragment.ascender * 0.3
+        target_points = [[50, y], [150, y]]
+        expect(fragment.strikethrough_points).to eq(target_points)
+      end
+    end
+  end
+
+  describe '#space_count' do
+    it 'returns the number of spaces in the fragment' do
+      format_state = {}
+      fragment = described_class.new(
+        'hello world ',
+        format_state,
+        pdf
+      )
+      expect(fragment.space_count).to eq(2)
+    end
+
+    it 'should exclude trailing spaces from the count when ' \
+      ':exclude_trailing_white_space => true' do
+      format_state = { exclude_trailing_white_space: true }
+      fragment = described_class.new(
+        'hello world ',
+        format_state,
+        pdf
+      )
+      expect(fragment.space_count).to eq(1)
+    end
+  end
+
+  describe '#include_trailing_white_space!' do
+    it 'makes the fragment include trailing white space' do
+      format_state = { exclude_trailing_white_space: true }
+      fragment = described_class.new(
+        'hello world ',
+        format_state,
+        pdf
+      )
+      expect(fragment.space_count).to eq(1)
+      fragment.include_trailing_white_space!
+      expect(fragment.space_count).to eq(2)
+    end
+  end
+
+  describe '#text' do
+    it 'returns the fragment text' do
+      format_state = {}
+      fragment = described_class.new(
+        'hello world ',
+        format_state,
+        pdf
+      )
+      expect(fragment.text).to eq('hello world ')
+    end
+
+    it 'should return the fragment text without trailing spaces when ' \
+      ':exclude_trailing_white_space => true' do
+      format_state = { exclude_trailing_white_space: true }
+      fragment = described_class.new(
+        'hello world ',
+        format_state,
+        pdf
+      )
+      expect(fragment.text).to eq('hello world')
+    end
+  end
+
+  describe '#word_spacing=' do
+    let(:fragment) do
+      format_state = {
+        styles: [:bold, :italic],
+        color: nil,
+        link: nil,
+        anchor: nil,
+        font: nil,
+        size: nil
+      }
+      described_class.new(
+        'hello world',
+        format_state,
+        pdf
+      ).tap do |fragment|
+        fragment.width = 100
+        fragment.left = 50
+        fragment.baseline = 200
+        fragment.line_height = 27
+        fragment.descender = 7
+        fragment.ascender = 17
+        fragment.word_spacing = 10
+      end
+    end
+
+    it 'accounts for word_spacing in #width' do
+      expect(fragment.width).to eq(110)
+    end
+
+    it 'accounts for word_spacing in #bounding_box' do
+      target_box = [50, 193, 160, 217]
+      expect(fragment.bounding_box).to eq(target_box)
+    end
+
+    it 'accounts for word_spacing in #absolute_bounding_box' do
+      target_box = [50, 193, 160, 217]
+      target_box[0] += pdf.bounds.absolute_left
+      target_box[1] += pdf.bounds.absolute_bottom
+      target_box[2] += pdf.bounds.absolute_left
+      target_box[3] += pdf.bounds.absolute_bottom
+      expect(fragment.absolute_bounding_box).to eq(target_box)
+    end
+
+    it 'accounts for word_spacing in #underline_points' do
+      y = 198.75
+      target_points = [[50, y], [160, y]]
+      expect(fragment.underline_points).to eq(target_points)
+    end
+
+    it 'accounts for word_spacing in #strikethrough_points' do
+      y = 200 + fragment.ascender * 0.3
+      target_points = [[50, y], [160, y]]
+      expect(fragment.strikethrough_points).to eq(target_points)
+    end
+  end
+
+  describe 'subscript' do
+    let(:fragment) do
+      format_state = {
+        styles: [:subscript],
+        color: nil,
+        link: nil,
+        anchor: nil,
+        font: nil,
+        size: nil
+      }
+      described_class.new(
+        'hello world',
+        format_state,
+        pdf
+      ).tap do |fragment|
+        fragment.line_height = 27
+        fragment.descender = 7
+        fragment.ascender = 17
+      end
+    end
+
+    describe '#subscript?' do
+      it 'be_trues' do
+        expect(fragment).to be_subscript
+      end
+    end
+
+    describe '#y_offset' do
+      it 'returns a negative value' do
+        expect(fragment.y_offset).to be < 0
+      end
+    end
+  end
+
+  describe 'superscript' do
+    let(:fragment) do
+      format_state = {
+        styles: [:superscript],
+        color: nil,
+        link: nil,
+        anchor: nil,
+        font: nil,
+        size: nil
+      }
+      described_class.new(
+        'hello world',
+        format_state,
+        pdf
+      ).tap do |fragment|
+        fragment.line_height = 27
+        fragment.descender = 7
+        fragment.ascender = 17
+      end
+    end
+
+    describe '#superscript?' do
+      it 'be_trues' do
+        expect(fragment).to be_superscript
+      end
+    end
+
+    describe '#y_offset' do
+      it 'returns a positive value' do
+        expect(fragment.y_offset).to be > 0
+      end
+    end
+  end
+
+  context 'with :direction => :rtl' do
+    it '#text should be reversed' do
+      format_state = { direction: :rtl }
+      fragment = described_class.new(
+        'hello world',
+        format_state,
+        pdf
+      )
+      expect(fragment.text).to eq('dlrow olleh')
+    end
+  end
+
+  describe '#default_direction=' do
+    it 'should set the direction if there is no fragment level direction ' \
+      'specification' do
+      format_state = {}
+      fragment = described_class.new(
+        'hello world',
+        format_state,
+        pdf
+      )
+      fragment.default_direction = :rtl
+      expect(fragment.direction).to eq(:rtl)
+    end
+
+    it 'should not set the direction if there is a fragment level direction ' \
+      'specification' do
+      format_state = { direction: :rtl }
+      fragment = described_class.new(
+        'hello world',
+        format_state,
+        pdf
+      )
+      fragment.default_direction = :ltr
+      expect(fragment.direction).to eq(:rtl)
+    end
+  end
+end

data/spec/prawn/text/formatted/line_wrap_spec.rb

@@ -0,0 +1,491 @@
+require 'spec_helper'
+
+describe Prawn::Text::Formatted::LineWrap do
+  let(:pdf) { create_pdf }
+  let(:arranger) do
+    Prawn::Text::Formatted::Arranger.new(pdf).tap do |a|
+      a.format_array = [
+        { text: "hello\nworld\n\n\nhow are you?" },
+        { text: "\n" },
+        { text: "\n" },
+        { text: '' },
+        { text: 'fine, thanks. ' * 4 },
+        { text: '' },
+        { text: "\n" },
+        { text: '' }
+      ]
+    end
+  end
+  let(:line_wrap) { described_class.new }
+
+  it 'should only return an empty string if nothing fit or there' \
+     'was nothing to wrap' do
+    8.times do
+      line = line_wrap.wrap_line(
+        arranger: arranger,
+        width: 200,
+        document: pdf
+      )
+      expect(line).to_not be_empty
+    end
+    line = line_wrap.wrap_line(
+      arranger: arranger,
+      width: 200,
+      document: pdf
+    )
+    expect(line).to be_empty
+  end
+
+  it 'tokenizes a string using the scan_pattern' do
+    tokens = line_wrap.tokenize('one two three')
+    expect(tokens.length).to eq(5)
+  end
+
+  describe 'Core::Text::Formatted::LineWrap#wrap_line' do
+    let(:arranger) { Prawn::Text::Formatted::Arranger.new(pdf) }
+    let(:one_word_width) { 50 }
+
+    it 'strips leading and trailing spaces' do
+      array = [
+        { text: ' hello world, ' },
+        { text: 'goodbye  ', style: [:bold] }
+      ]
+      arranger.format_array = array
+      string = line_wrap.wrap_line(
+        arranger: arranger,
+        width: 300,
+        document: pdf
+      )
+      expect(string).to eq('hello world, goodbye')
+    end
+
+    it 'should strip trailing spaces when a white-space-only fragment was' \
+      ' successfully pushed onto the end of a line but no other non-white' \
+      ' space fragment fits after it' do
+      array = [
+        { text: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ' },
+        { text: '  ', style: [:bold] },
+        { text: ' bbbbbbbbbbbbbbbbbbbbbbbbbbbb' }
+      ]
+      arranger.format_array = array
+      string = line_wrap.wrap_line(
+        arranger: arranger,
+        width: 300,
+        document: pdf
+      )
+      expect(string).to eq('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')
+    end
+    it 'raise_errors CannotFit if a too-small width is given' do
+      array = [
+        { text: ' hello world, ' },
+        { text: 'goodbye  ', style: [:bold] }
+      ]
+      arranger.format_array = array
+      expect do
+        line_wrap.wrap_line(
+          arranger: arranger,
+          width: 1,
+          document: pdf
+        )
+      end.to raise_error(Prawn::Errors::CannotFit)
+    end
+
+    it 'breaks on space' do
+      array = [{ text: 'hello world' }]
+      arranger.format_array = array
+      string = line_wrap.wrap_line(
+        arranger: arranger,
+        width: one_word_width,
+        document: pdf
+      )
+      expect(string).to eq('hello')
+    end
+
+    it 'breaks on zero-width space' do
+      pdf.font("#{Prawn::DATADIR}/fonts/DejaVuSans.ttf")
+      array = [{ text: "hello#{Prawn::Text::ZWSP}world" }]
+      arranger.format_array = array
+      string = line_wrap.wrap_line(
+        arranger: arranger,
+        width: one_word_width,
+        document: pdf
+      )
+      expect(string).to eq('hello')
+    end
+
+    it 'does not display zero-width space' do
+      pdf.font("#{Prawn::DATADIR}/fonts/DejaVuSans.ttf")
+      array = [{ text: "hello#{Prawn::Text::ZWSP}world" }]
+      arranger.format_array = array
+      string = line_wrap.wrap_line(
+        arranger: arranger,
+        width: 300,
+        document: pdf
+      )
+      expect(string).to eq('helloworld')
+    end
+
+    it 'does not raise CannotFit if first fragment is a zero-width space' do
+      pdf.font("#{Prawn::DATADIR}/fonts/DejaVuSans.ttf")
+      array = [{ text: Prawn::Text::ZWSP }, { text: 'stringofchars' }]
+      arranger.format_array = array
+      string = line_wrap.wrap_line(
+        arranger: arranger,
+        width: 50,
+        document: pdf
+      )
+      expect(string).to eq('stringof')
+    end
+
+    it 'breaks on tab' do
+      array = [{ text: "hello\tworld" }]
+      arranger.format_array = array
+      string = line_wrap.wrap_line(
+        arranger: arranger,
+        width: one_word_width,
+        document: pdf
+      )
+      expect(string).to eq('hello')
+    end
+
+    it 'does not break on NBSP' do
+      array = [{ text: "hello#{Prawn::Text::NBSP}world" }]
+      arranger.format_array = array
+      string = line_wrap.wrap_line(
+        arranger: arranger,
+        width: one_word_width,
+        document: pdf
+      )
+      expect(string).to eq("hello#{Prawn::Text::NBSP}wor")
+    end
+
+    it 'does not break on NBSP in a Win-1252 encoded string' do
+      array = [{
+        text: "hello#{Prawn::Text::NBSP}world".encode(Encoding::Windows_1252)
+      }]
+      arranger.format_array = array
+      string = line_wrap.wrap_line(
+        arranger: arranger,
+        width: one_word_width,
+        document: pdf
+      )
+      expect(string).to eq("hello#{Prawn::Text::NBSP}wor")
+    end
+
+    it 'breaks on hyphens' do
+      array = [{ text: 'hello-world' }]
+      arranger.format_array = array
+      string = line_wrap.wrap_line(
+        arranger: arranger,
+        width: one_word_width,
+        document: pdf
+      )
+      expect(string).to eq('hello-')
+    end
+
+    it 'should not break after a hyphen that follows white space and' \
+      'precedes a word' do
+      array = [{ text: 'hello -' }]
+      arranger.format_array = array
+      string = line_wrap.wrap_line(
+        arranger: arranger,
+        width: one_word_width,
+        document: pdf
+      )
+      expect(string).to eq('hello -')
+
+      array = [{ text: 'hello -world' }]
+      arranger.format_array = array
+      string = line_wrap.wrap_line(
+        arranger: arranger,
+        width: one_word_width,
+        document: pdf
+      )
+      expect(string).to eq('hello')
+    end
+
+    it 'breaks on a soft hyphen' do
+      string = pdf.font.normalize_encoding("hello#{Prawn::Text::SHY}world")
+      array = [{ text: string }]
+      arranger.format_array = array
+      string = line_wrap.wrap_line(
+        arranger: arranger,
+        width: one_word_width,
+        document: pdf
+      )
+      expect(string).to eq("hello#{Prawn::Text::SHY}")
+
+      pdf.font("#{Prawn::DATADIR}/fonts/DejaVuSans.ttf")
+      line_wrap = described_class.new
+
+      string = "hello#{Prawn::Text::SHY}world"
+      array = [{ text: string }]
+      arranger.format_array = array
+      string = line_wrap.wrap_line(
+        arranger: arranger,
+        width: one_word_width,
+        document: pdf
+      )
+      expect(string).to eq("hello#{Prawn::Text::SHY}")
+    end
+
+    it 'ignores width of a soft-hyphen during adding fragments to line',
+      issue: 775 do
+      hyphen_string = "Hy#{Prawn::Text::SHY}phe#{Prawn::Text::SHY}nat"\
+        "#{Prawn::Text::SHY}ions "
+      string1 = pdf.font.normalize_encoding(hyphen_string * 5)
+      string2 = pdf.font.normalize_encoding('Hyphenations ' * 3 + hyphen_string)
+
+      array1 = [{ text: string1 }]
+      array2 = [{ text: string2 }]
+
+      arranger.format_array = array1
+
+      res1 = line_wrap.wrap_line(
+        arranger: arranger,
+        width: 300,
+        document: pdf
+      )
+
+      line_wrap = described_class.new
+
+      arranger.format_array = array2
+
+      res2 = line_wrap.wrap_line(
+        arranger: arranger,
+        width: 300,
+        document: pdf
+      )
+      expect(res1).to eq(res2)
+    end
+
+    it 'should not display soft hyphens except at the end of a line ' \
+      'for more than one element in format_array', issue: 347 do
+      pdf.font("#{Prawn::DATADIR}/fonts/DejaVuSans.ttf")
+      line_wrap = described_class.new
+
+      string1 = pdf.font.normalize_encoding("hello#{Prawn::Text::SHY}world ")
+      string2 = pdf.font.normalize_encoding("hi#{Prawn::Text::SHY}earth")
+      array = [{ text: string1 }, { text: string2 }]
+      arranger.format_array = array
+      string = line_wrap.wrap_line(
+        arranger: arranger,
+        width: 300,
+        document: pdf
+      )
+      expect(string).to eq('helloworld hiearth')
+    end
+
+    it 'does not break before a hard hyphen that follows a word' do
+      enough_width_for_hello_world = 60
+
+      array = [{ text: 'hello world' }]
+      arranger.format_array = array
+      string = line_wrap.wrap_line(
+        arranger: arranger,
+        width: enough_width_for_hello_world,
+        document: pdf
+      )
+      expect(string).to eq('hello world')
+
+      array = [{ text: 'hello world-' }]
+      arranger.format_array = array
+      string = line_wrap.wrap_line(
+        arranger: arranger,
+        width: enough_width_for_hello_world,
+        document: pdf
+      )
+      expect(string).to eq('hello')
+
+      pdf.font("#{Prawn::DATADIR}/fonts/DejaVuSans.ttf")
+      line_wrap = described_class.new
+      enough_width_for_hello_world = 68
+
+      array = [{ text: 'hello world' }]
+      arranger.format_array = array
+      string = line_wrap.wrap_line(
+        arranger: arranger,
+        width: enough_width_for_hello_world,
+        document: pdf
+      )
+      expect(string).to eq('hello world')
+
+      array = [{ text: 'hello world-' }]
+      arranger.format_array = array
+      string = line_wrap.wrap_line(
+        arranger: arranger,
+        width: enough_width_for_hello_world,
+        document: pdf
+      )
+      expect(string).to eq('hello')
+    end
+
+    it 'should not break after a hard hyphen that follows a soft hyphen and' \
+      'precedes a word' do
+      string = pdf.font.normalize_encoding("hello#{Prawn::Text::SHY}-")
+      array = [{ text: string }]
+      arranger.format_array = array
+      string = line_wrap.wrap_line(
+        arranger: arranger,
+        width: one_word_width,
+        document: pdf
+      )
+      expect(string).to eq('hello-')
+
+      string = pdf.font.normalize_encoding("hello#{Prawn::Text::SHY}-world")
+      array = [{ text: string }]
+      arranger.format_array = array
+      string = line_wrap.wrap_line(
+        arranger: arranger,
+        width: one_word_width,
+        document: pdf
+      )
+      expect(string).to eq("hello#{Prawn::Text::SHY}")
+
+      pdf.font("#{Prawn::DATADIR}/fonts/DejaVuSans.ttf")
+      line_wrap = described_class.new
+
+      string = "hello#{Prawn::Text::SHY}-"
+      array = [{ text: string }]
+      arranger.format_array = array
+      string = line_wrap.wrap_line(
+        arranger: arranger,
+        width: one_word_width,
+        document: pdf
+      )
+      expect(string).to eq('hello-')
+
+      string = "hello#{Prawn::Text::SHY}-world"
+      array = [{ text: string }]
+      arranger.format_array = array
+      string = line_wrap.wrap_line(
+        arranger: arranger,
+        width: one_word_width,
+        document: pdf
+      )
+      expect(string).to eq("hello#{Prawn::Text::SHY}")
+    end
+
+    it 'does not process UTF-8 chars with default font', issue: 693 do
+      array = [{ text: 'Ｔｅｓｔ' }]
+      arranger.format_array = array
+
+      expect do
+        line_wrap.wrap_line(
+          arranger: arranger,
+          width: 300,
+          document: pdf
+        )
+      end.to raise_exception(Prawn::Errors::IncompatibleStringEncoding)
+    end
+
+    it 'processes UTF-8 chars with UTF-8 font', issue: 693 do
+      array = [{ text: 'Ｔｅｓｔ' }]
+      arranger.format_array = array
+
+      pdf.font Pathname.new("#{Prawn::DATADIR}/fonts/DejaVuSans.ttf")
+      string = line_wrap.wrap_line(
+        arranger: arranger,
+        width: 300,
+        document: pdf
+      )
+
+      expect(string).to eq('Ｔｅｓｔ')
+    end
+  end
+
+  describe '#space_count' do
+    let(:arranger) { Prawn::Text::Formatted::Arranger.new(pdf) }
+
+    it 'returns the number of spaces in the last wrapped line' do
+      array = [
+        { text: 'hello world, ' },
+        { text: 'goodbye', style: [:bold] }
+      ]
+      arranger.format_array = array
+      line_wrap.wrap_line(
+        arranger: arranger,
+        width: 300,
+        document: pdf
+      )
+      expect(line_wrap.space_count).to eq(2)
+    end
+
+    it 'excludes preceding and trailing spaces from the count' do
+      array = [
+        { text: ' hello world, ' },
+        { text: 'goodbye  ', style: [:bold] }
+      ]
+      arranger.format_array = array
+      line_wrap.wrap_line(
+        arranger: arranger,
+        width: 300,
+        document: pdf
+      )
+      expect(line_wrap.space_count).to eq(2)
+    end
+  end
+
+  describe '#paragraph_finished?' do
+    let(:arranger) { Prawn::Text::Formatted::Arranger.new(pdf) }
+    let(:line_wrap) { described_class.new }
+    let(:one_word_width) { 50 }
+
+    it 'is false when the last printed line is not the end of the paragraph' do
+      array = [{ text: 'hello world' }]
+      arranger.format_array = array
+      line_wrap.wrap_line(
+        arranger: arranger,
+        width: one_word_width,
+        document: pdf
+      )
+
+      expect(line_wrap.paragraph_finished?).to eq(false)
+    end
+
+    it 'is true when the last printed line is the last fragment to print' do
+      array = [{ text: 'hello world' }]
+      arranger.format_array = array
+      line_wrap.wrap_line(
+        arranger: arranger,
+        width: one_word_width,
+        document: pdf
+      )
+      line_wrap.wrap_line(
+        arranger: arranger,
+        width: one_word_width,
+        document: pdf
+      )
+
+      expect(line_wrap.paragraph_finished?).to eq(true)
+    end
+
+    it 'be_trues when a newline exists on the current line' do
+      array = [{ text: "hello\n world" }]
+      arranger.format_array = array
+      line_wrap.wrap_line(
+        arranger: arranger,
+        width: one_word_width,
+        document: pdf
+      )
+
+      expect(line_wrap.paragraph_finished?).to eq(true)
+    end
+
+    it 'be_trues when a newline exists in the next fragment' do
+      array = [
+        { text: 'hello ' },
+        { text: " \n" },
+        { text: 'world' }
+      ]
+      arranger.format_array = array
+      line_wrap.wrap_line(
+        arranger: arranger,
+        width: one_word_width,
+        document: pdf
+      )
+
+      expect(line_wrap.paragraph_finished?).to eq(true)
+    end
+  end
+end