prawn 2.1.0 → 2.2.0

data/spec/prawn/repeater_spec.rb

@@ -0,0 +1,163 @@
+require 'spec_helper'
+
+describe Prawn::Repeater do
+  it 'creates a stamp and increments Prawn::Repeater.count on initialize' do
+    orig_count = described_class.count
+
+    doc = sample_document
+    allow(doc).to receive(:create_stamp).with("prawn_repeater(#{orig_count})")
+
+    repeater(doc, :all) { :do_nothing }
+
+    expect(doc).to have_received(:create_stamp)
+      .with("prawn_repeater(#{orig_count})")
+
+    expect(described_class.count).to eq(orig_count + 1)
+  end
+
+  it 'must provide an :all filter' do
+    doc = sample_document
+    r = repeater(doc, :all) { :do_nothing }
+
+    expect((1..doc.page_count).all? { |i| r.match?(i) }).to eq true
+  end
+
+  it 'must provide an :odd filter' do
+    doc = sample_document
+    r = repeater(doc, :odd) { :do_nothing }
+
+    odd, even = (1..doc.page_count).partition(&:odd?)
+
+    expect(odd.all? { |i| r.match?(i) }).to eq true
+    expect(even.any? { |i| r.match?(i) }).to eq false
+  end
+
+  it 'must be able to filter by an array of page numbers' do
+    doc = sample_document
+    r = repeater(doc, [1, 2, 7]) { :do_nothing }
+
+    expect((1..10).select { |i| r.match?(i) }).to eq([1, 2, 7])
+  end
+
+  it 'must be able to filter by a range of page numbers' do
+    doc = sample_document
+    r = repeater(doc, 2..4) { :do_nothing }
+
+    expect((1..10).select { |i| r.match?(i) }).to eq([2, 3, 4])
+  end
+
+  it 'must be able to filter by an arbitrary proc' do
+    doc = sample_document
+    r = repeater(doc, ->(x) { x == 1 || x % 3 == 0 })
+
+    expect((1..10).select { |i| r.match?(i) }).to eq([1, 3, 6, 9])
+  end
+
+  it 'must try to run a stamp if the page number matches' do
+    doc = sample_document
+    allow(doc).to receive(:stamp)
+
+    repeater(doc, :odd).run(3)
+    expect(doc).to have_received(:stamp)
+  end
+
+  it 'must not try to run a stamp unless the page number matches' do
+    doc = sample_document
+
+    allow(doc).to receive(:stamp)
+    repeater(doc, :odd).run(2)
+    expect(doc).to_not have_received(:stamp)
+  end
+
+  it 'must not try to run a stamp if dynamic is selected' do
+    doc = sample_document
+
+    allow(doc).to receive(:stamp)
+    (1..10).each { |p| repeater(doc, :all, true) { :do_nothing }.run(p) }
+    expect(doc).to_not have_received(:stamp)
+  end
+
+  it 'must try to run a block if the page number matches' do
+    doc = sample_document
+
+    allow(doc).to receive(:draw_text)
+    (1..10).each do |p|
+      repeater(doc, [1, 2], true) { doc.draw_text 'foo' }.run(p)
+    end
+    expect(doc).to have_received(:draw_text).twice
+  end
+
+  it 'must not try to run a block unless the page number matches' do
+    doc = sample_document
+
+    allow(doc).to receive(:draw_text)
+    repeater(doc, :odd, true) { doc.draw_text 'foo' }.run(2)
+    expect(doc).to_not have_received(:draw_text)
+  end
+
+  it 'must treat any block as a closure' do
+    doc = sample_document
+
+    page = 'Page' # ensure access to ivars
+    doc.repeat(:all, dynamic: true) do
+      doc.draw_text "#{page} #{doc.page_number}", at: [500, 0]
+    end
+
+    text = PDF::Inspector::Text.analyze(doc.render)
+    expect(text.strings).to eq((1..10).to_a.map { |p| "Page #{p}" })
+  end
+
+  it 'must treat any block as a closure (Document.new instance_eval form)' do
+    doc = Prawn::Document.new(skip_page_creation: true) do
+      10.times { start_new_page }
+
+      page = 'Page'
+      repeat(:all, dynamic: true) do
+        # ensure self is accessible here
+        draw_text "#{page} #{page_number}", at: [500, 0]
+      end
+    end
+
+    text = PDF::Inspector::Text.analyze(doc.render)
+    expect(text.strings).to eq((1..10).to_a.map { |p| "Page #{p}" })
+  end
+
+  def sample_document
+    doc = Prawn::Document.new(skip_page_creation: true)
+    10.times { |_e| doc.start_new_page }
+    doc
+  end
+
+  def repeater(*args, &b)
+    Prawn::Repeater.new(*args, &b)
+  end
+
+  context 'graphic state' do
+    let(:pdf) { create_pdf }
+
+    it 'does not alter the graphic state stack color space' do
+      starting_color_space = pdf.state.page.graphic_state.color_space.dup
+      pdf.repeat :all do
+        pdf.text 'Testing', size: 24, style: :bold
+      end
+      expect(pdf.state.page.graphic_state.color_space)
+        .to eq(starting_color_space)
+    end
+
+    context 'dynamic repeaters' do
+      it 'preserves the graphic state at creation time' do
+        pdf.repeat :all, dynamic: true do
+          pdf.text "fill_color: #{pdf.graphic_state.fill_color}"
+          pdf.text "cap_style: #{pdf.graphic_state.cap_style}"
+        end
+        pdf.fill_color '666666'
+        pdf.cap_style :round
+        text = PDF::Inspector::Text.analyze(pdf.render)
+        expect(text.strings.include?('fill_color: 666666')).to eq(false)
+        expect(text.strings.include?('fill_color: 000000')).to eq(true)
+        expect(text.strings.include?('cap_style: round')).to eq(false)
+        expect(text.strings.include?('cap_style: butt')).to eq(true)
+      end
+    end
+  end
+end

data/spec/prawn/soft_mask_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe Prawn::SoftMask do
+  let(:pdf) { create_pdf }
+
+  def make_soft_mask
+    pdf.save_graphics_state do
+      pdf.soft_mask do
+        if block_given?
+          yield
+        else
+          pdf.fill_color '808080'
+          pdf.fill_rectangle [100, 100], 200, 200
+        end
+      end
+
+      pdf.fill_color '000000'
+      pdf.fill_rectangle [0, 0], 200, 200
+    end
+  end
+
+  it 'has PDF version at least 1.4' do
+    make_soft_mask
+    str = pdf.render
+    expect(str[0, 8]).to eq('%PDF-1.4')
+  end
+
+  it 'creates a new extended graphics state for each unique soft mask' do
+    make_soft_mask do
+      pdf.fill_color '808080'
+      pdf.fill_rectangle [100, 100], 200, 200
+    end
+
+    make_soft_mask do
+      pdf.fill_color '808080'
+      pdf.fill_rectangle [10, 10], 200, 200
+    end
+
+    extgstates = PDF::Inspector::ExtGState.analyze(pdf.render).extgstates
+    expect(extgstates.length).to eq(2)
+  end
+
+  it 'a new extended graphics state contains soft mask with drawing '\
+    'instructions' do
+    make_soft_mask do
+      pdf.fill_color '808080'
+      pdf.fill_rectangle [100, 100], 200, 200
+    end
+
+    extgstate = PDF::Inspector::ExtGState.analyze(pdf.render).extgstates.first
+    expect(extgstate[:soft_mask][:G].data).to eq(
+      "q\n/DeviceRGB cs\n0.0 0.0 0.0 scn\n/DeviceRGB CS\n0.0 0.0 0.0 SCN\n"\
+      "1 w\n0 J\n0 j\n[] 0 d\n/DeviceRGB cs\n0.502 0.502 0.502 scn\n"\
+      "100.0 -100.0 200.0 200.0 re\nf\nQ\n"
+    )
+  end
+
+  it 'does not create duplicate extended graphics states' do
+    make_soft_mask do
+      pdf.fill_color '808080'
+      pdf.fill_rectangle [100, 100], 200, 200
+    end
+
+    make_soft_mask do
+      pdf.fill_color '808080'
+      pdf.fill_rectangle [100, 100], 200, 200
+    end
+
+    extgstates = PDF::Inspector::ExtGState.analyze(pdf.render).extgstates
+    expect(extgstates.length).to eq(1)
+  end
+end

data/spec/prawn/stamp_spec.rb

@@ -0,0 +1,168 @@
+require 'spec_helper'
+
+describe Prawn::Stamp do
+  describe 'create_stamp before any page is added' do
+    let(:pdf) { Prawn::Document.new(skip_page_creation: true) }
+    it 'works with the font class' do
+      # If anything goes wrong, Prawn::Errors::NotOnPage will be raised
+      pdf.create_stamp('my_stamp') do
+        pdf.font.height
+      end
+    end
+
+    it 'works with setting color' do
+      # If anything goes wrong, Prawn::Errors::NotOnPage will be raised
+      pdf.create_stamp('my_stamp') do
+        pdf.fill_color = 'ff0000'
+      end
+    end
+  end
+
+  describe '#stamp_at' do
+    let(:pdf) { create_pdf }
+
+    it 'works' do
+      pdf.create_stamp('MyStamp')
+      pdf.stamp_at('MyStamp', [100, 200])
+      # I had modified PDF::Inspector::XObject to receive the
+      # invoke_xobject message and count the number of times it was
+      # called, but it was only called once, so I reverted checking the
+      # output with a regular expression
+      expect(pdf.render).to match(%r{/Stamp1 Do.*?}m)
+    end
+  end
+
+  describe 'Document with a stamp' do
+    let(:pdf) { create_pdf }
+
+    it 'should raise_error NameTaken error when attempt to create stamp ' \
+      'with same name as an existing stamp' do
+      pdf.create_stamp('MyStamp')
+      expect do
+        pdf.create_stamp('MyStamp')
+      end.to raise_error(Prawn::Errors::NameTaken)
+    end
+
+    it 'should raise_error InvalidName error when attempt to create ' \
+      'stamp with a blank name' do
+      expect do
+        pdf.create_stamp('')
+      end.to raise_error(Prawn::Errors::InvalidName)
+    end
+
+    it 'a new XObject should be defined for each stamp created' do
+      pdf.create_stamp('MyStamp')
+      pdf.create_stamp('AnotherStamp')
+      pdf.stamp('MyStamp')
+      pdf.stamp('AnotherStamp')
+
+      inspector = PDF::Inspector::XObject.analyze(pdf.render)
+      xobjects = inspector.page_xobjects.last
+      expect(xobjects.length).to eq(2)
+    end
+
+    it 'calling stamp with a name that does not match an existing stamp ' \
+      'should raise_error UndefinedObjectName' do
+      pdf.create_stamp('MyStamp')
+      expect do
+        pdf.stamp('OtherStamp')
+      end.to raise_error(Prawn::Errors::UndefinedObjectName)
+    end
+
+    it 'stamp should be drawn into the document each time stamp is called' do
+      pdf.create_stamp('MyStamp')
+      pdf.stamp('MyStamp')
+      pdf.stamp('MyStamp')
+      pdf.stamp('MyStamp')
+      # I had modified PDF::Inspector::XObject to receive the
+      # invoke_xobject message and count the number of times it was
+      # called, but it was only called once, so I reverted checking the
+      # output with a regular expression
+      expect(pdf.render).to match(%r{(/Stamp1 Do.*?){3}}m)
+    end
+
+    it 'stamp should render clickable links' do
+      pdf.create_stamp 'bar' do
+        pdf.text '<b>Prawn</b> <link href="http://github.com">GitHub</link>',
+          inline_format: true
+      end
+      pdf.stamp 'bar'
+
+      output = pdf.render
+      objects = output.split('endobj')
+
+      objects.each do |obj|
+        next unless obj =~ %r{/Type /Page$}
+        # The page object must contain the annotation reference
+        # to render a clickable link
+        expect(obj).to match(%r{^/Annots \[\d \d .\]$})
+      end
+    end
+
+    it 'resources added during stamp creation should be added to the ' \
+      'stamp XObject, not the page' do
+      pdf.create_stamp('MyStamp') do
+        pdf.transparent(0.5) { pdf.circle([100, 100], 10) }
+      end
+      pdf.stamp('MyStamp')
+
+      # Inspector::XObject does not give information about resources, so
+      # resorting to string matching
+
+      output = pdf.render
+      objects = output.split('endobj')
+      objects.each do |object|
+        if object =~ %r{/Type /Page$}
+          expect(object).to_not match(%r{/ExtGState})
+        elsif object =~ %r{/Type /XObject$}
+          expect(object).to match(%r{/ExtGState})
+        end
+      end
+    end
+
+    it 'stamp stream should be wrapped in a graphic state' do
+      pdf.create_stamp('MyStamp') do
+        pdf.text "This should have a 'q' before it and a 'Q' after it"
+      end
+      pdf.stamp('MyStamp')
+      stamps = PDF::Inspector::XObject.analyze(pdf.render)
+      expect(stamps.xobject_streams[:Stamp1].data.chomp).to match(/q(.|\s)*Q\Z/)
+    end
+
+    it 'does not add to the page graphic state stack' do
+      expect(pdf.state.page.stack.stack.size).to eq(1)
+
+      pdf.create_stamp('MyStamp') do
+        pdf.save_graphics_state
+        pdf.save_graphics_state
+        pdf.save_graphics_state
+        pdf.text "This should have a 'q' before it and a 'Q' after it"
+        pdf.restore_graphics_state
+      end
+      expect(pdf.state.page.stack.stack.size).to eq(1)
+    end
+
+    it 'is able to change fill and stroke colors within the stamp stream' do
+      pdf.create_stamp('MyStamp') do
+        pdf.fill_color(100, 100, 20, 0)
+        pdf.stroke_color(100, 100, 20, 0)
+      end
+      pdf.stamp('MyStamp')
+      stamps = PDF::Inspector::XObject.analyze(pdf.render)
+      stamp_stream = stamps.xobject_streams[:Stamp1].data
+      expect(stamp_stream).to include("/DeviceCMYK cs\n1.0 1.0 0.2 0.0 scn")
+      expect(stamp_stream).to include("/DeviceCMYK CS\n1.0 1.0 0.2 0.0 SCN")
+    end
+
+    it 'saves the color space even when same as current page color space' do
+      pdf.stroke_color(100, 100, 20, 0)
+      pdf.create_stamp('MyStamp') do
+        pdf.stroke_color(100, 100, 20, 0)
+      end
+      pdf.stamp('MyStamp')
+      stamps = PDF::Inspector::XObject.analyze(pdf.render)
+      stamp_stream = stamps.xobject_streams[:Stamp1].data
+      expect(stamp_stream).to include("/DeviceCMYK CS\n1.0 1.0 0.2 0.0 SCN")
+    end
+  end
+end

data/spec/prawn/text/box_spec.rb

@@ -0,0 +1,1113 @@
+require 'spec_helper'
+
+describe Prawn::Text::Box do
+  let(:pdf) { create_pdf }
+
+  it 'is able to set leading document-wide' do
+    pdf.default_leading(7)
+    pdf.default_leading = 7
+    text_box = described_class.new('hello world', document: pdf)
+    expect(text_box.leading).to eq(7)
+  end
+
+  it 'option should be able to override document-wide leading' do
+    pdf.default_leading = 7
+    text_box = described_class.new(
+      'hello world',
+      document: pdf,
+      leading: 20
+    )
+    expect(text_box.leading).to eq(20)
+  end
+
+  it 'is able to set text direction document-wide' do
+    pdf.text_direction(:rtl)
+    pdf.text_direction = :rtl
+    string = "Hello world, how are you?\nI'm fine, thank you."
+    text_box = described_class.new(string, document: pdf)
+    text_box.render
+    text = PDF::Inspector::Text.analyze(pdf.render)
+    expect(text.strings[0]).to eq('?uoy era woh ,dlrow olleH')
+    expect(text.strings[1]).to eq(".uoy knaht ,enif m'I")
+  end
+
+  it 'is able to reverse multi-byte text' do
+    pdf.text_direction(:rtl)
+    pdf.text_direction = :rtl
+    pdf.text_direction = :rtl
+    pdf.font("#{Prawn::DATADIR}/fonts/gkai00mp.ttf", size: 16) do
+      pdf.text '写个小'
+    end
+    text = PDF::Inspector::Text.analyze(pdf.render)
+    expect(text.strings[0]).to eq('小个写')
+  end
+
+  it 'option should be able to override document-wide text direction' do
+    pdf.text_direction = :rtl
+    string = "Hello world, how are you?\nI'm fine, thank you."
+    text_box = described_class.new(
+      string,
+      document: pdf,
+      direction: :ltr
+    )
+    text_box.render
+    text = PDF::Inspector::Text.analyze(pdf.render)
+    expect(text.strings[0]).to eq('Hello world, how are you?')
+    expect(text.strings[1]).to eq("I'm fine, thank you.")
+  end
+
+  it 'should only require enough space for the descender and the ascender ' \
+    'when determining whether a line can fit' do
+    text = 'Oh hai text rect'
+    options = {
+      document: pdf,
+      height: pdf.font.ascender + pdf.font.descender
+    }
+    text_box = described_class.new(text, options)
+    text_box.render
+    expect(text_box.text).to eq('Oh hai text rect')
+
+    text = "Oh hai text rect\nOh hai text rect"
+    options = {
+      document: pdf,
+      height: pdf.font.height + pdf.font.ascender + pdf.font.descender
+    }
+    text_box = described_class.new(text, options)
+    text_box.render
+    expect(text_box.text).to eq("Oh hai text rect\nOh hai text rect")
+  end
+
+  describe '#nothing_printed?' do
+    it 'returns true when nothing printed' do
+      string = "Hello world, how are you?\nI'm fine, thank you."
+      text_box = described_class.new(string, height: 2, document: pdf)
+      text_box.render
+      expect(text_box.nothing_printed?).to eq true
+    end
+
+    it 'returns false when something printed' do
+      string = "Hello world, how are you?\nI'm fine, thank you."
+      text_box = described_class.new(string, height: 14, document: pdf)
+      text_box.render
+      expect(text_box.nothing_printed?).to eq false
+    end
+  end
+
+  describe '#everything_printed?' do
+    it 'returns false when not everything printed' do
+      string = "Hello world, how are you?\nI'm fine, thank you."
+      text_box = described_class.new(string, height: 14, document: pdf)
+      text_box.render
+      expect(text_box.everything_printed?).to eq false
+    end
+
+    it 'returns true when everything printed' do
+      string = "Hello world, how are you?\nI'm fine, thank you."
+      text_box = described_class.new(string, document: pdf)
+      text_box.render
+      expect(text_box.everything_printed?).to eq true
+    end
+  end
+
+  describe '#line_gap' do
+    it 'should == the line gap of the font when using a single ' \
+      'font and font size' do
+      string = "Hello world, how are you?\nI'm fine, thank you."
+      text_box = described_class.new(string, document: pdf)
+      text_box.render
+      expect(text_box.line_gap).to be_within(0.0001).of(pdf.font.line_gap)
+    end
+  end
+
+  describe '#render with :align => :justify' do
+    it 'draws the word spacing to the document' do
+      string = 'hello world ' * 20
+      options = { document: pdf, align: :justify }
+      text_box = described_class.new(string, options)
+      text_box.render
+      contents = PDF::Inspector::Text.analyze(pdf.render)
+      expect(contents.word_spacing[0]).to be > 0
+    end
+
+    it 'does not justify the last line of a paragraph' do
+      string = 'hello world '
+      options = { document: pdf, align: :justify }
+      text_box = described_class.new(string, options)
+      text_box.render
+      contents = PDF::Inspector::Text.analyze(pdf.render)
+      expect(contents.word_spacing).to be_empty
+    end
+  end
+
+  describe '#height without leading' do
+    it 'should == the sum of the height of each line, ' \
+      'not including the space below the last line' do
+      text = "Oh hai text rect.\nOh hai text rect."
+      options = { document: pdf }
+      text_box = described_class.new(text, options)
+      text_box.render
+      expect(text_box.height).to be_within(0.001)
+        .of(pdf.font.height * 2 - pdf.font.line_gap)
+    end
+  end
+
+  describe '#height with leading' do
+    it 'should == the sum of the height of each line plus leading, ' \
+      'but not including the space below the last line' do
+      text = "Oh hai text rect.\nOh hai text rect."
+      leading = 12
+      options = { document: pdf, leading: leading }
+      text_box = described_class.new(text, options)
+      text_box.render
+      expect(text_box.height).to be_within(0.001).of(
+        (pdf.font.height + leading) * 2 - pdf.font.line_gap - leading
+      )
+    end
+  end
+
+  context 'with :draw_text_callback' do
+    it 'hits the callback whenever text is drawn' do
+      draw_block = instance_spy('Draw block')
+
+      pdf.text_box 'this text is long enough to span two lines',
+        width: 150,
+        draw_text_callback: ->(text, _) { draw_block.kick(text) }
+
+      expect(draw_block).to have_received(:kick)
+        .with('this text is long enough to')
+      expect(draw_block).to have_received(:kick).with('span two lines')
+    end
+
+    it 'hits the callback once per fragment for :inline_format' do
+      draw_block = instance_spy('Draw block')
+
+      pdf.text_box 'this text has <b>fancy</b> formatting',
+        inline_format: true, width: 500,
+        draw_text_callback: ->(text, _) { draw_block.kick(text) }
+
+      expect(draw_block).to have_received(:kick).with('this text has ')
+      expect(draw_block).to have_received(:kick).with('fancy')
+      expect(draw_block).to have_received(:kick).with(' formatting')
+    end
+
+    it 'does not call #draw_text!' do
+      allow(pdf).to receive(:draw_text!)
+      pdf.text_box 'some text', width: 500,
+                                draw_text_callback: ->(_, _) {}
+      expect(pdf).to_not have_received(:draw_text!)
+    end
+  end
+
+  describe '#valid_options' do
+    it 'returns an array' do
+      text_box = described_class.new('', document: pdf)
+      expect(text_box.valid_options).to be_a_kind_of(Array)
+    end
+  end
+
+  describe '#render' do
+    it 'does not fail if height is smaller than 1 line' do
+      text = 'Oh hai text rect. ' * 10
+      options = {
+        height: pdf.font.height * 0.5,
+        document: pdf
+      }
+      text_box = described_class.new(text, options)
+      text_box.render
+      expect(text_box.text).to eq('')
+    end
+
+    it 'draws content to the page' do
+      text = 'Oh hai text rect. ' * 10
+      options = { document: pdf }
+      text_box = described_class.new(text, options)
+      text_box.render
+      text = PDF::Inspector::Text.analyze(pdf.render)
+      expect(text.strings).to_not be_empty
+    end
+
+    it 'does not draw a transformation matrix' do
+      text = 'Oh hai text rect. ' * 10
+      options = { document: pdf }
+      text_box = described_class.new(text, options)
+      text_box.render
+      matrices = PDF::Inspector::Graphics::Matrix.analyze(pdf.render)
+      expect(matrices.matrices.length).to eq(0)
+    end
+  end
+
+  describe '#render(:single_line => true)' do
+    it 'draws only one line to the page' do
+      text = 'Oh hai text rect. ' * 10
+      options = {
+        document: pdf,
+        single_line: true
+      }
+      text_box = described_class.new(text, options)
+      text_box.render
+      text = PDF::Inspector::Text.analyze(pdf.render)
+      expect(text.strings.length).to eq(1)
+    end
+  end
+
+  describe '#render(:dry_run => true)' do
+    it 'does not draw any content to the page' do
+      text = 'Oh hai text rect. ' * 10
+      options = { document: pdf }
+      text_box = described_class.new(text, options)
+      text_box.render(dry_run: true)
+      text = PDF::Inspector::Text.analyze(pdf.render)
+      expect(text.strings).to be_empty
+    end
+
+    it 'subsequent calls to render do not raise an ArgumentError exception' do
+      text = '™©'
+      options = { document: pdf }
+      text_box = described_class.new(text, options)
+      text_box.render(dry_run: true)
+
+      expect do
+        text_box.render
+      end.to_not raise_exception
+    end
+  end
+
+  describe '#render(:valign => :bottom)' do
+    it '#at should be the same from one dry run to the next' do
+      text = 'this is center text ' * 12
+      options = {
+        width: 162,
+        valign: :bottom,
+        document: pdf
+      }
+      text_box = described_class.new(text, options)
+
+      text_box.render(dry_run: true)
+      original_at = text_box.at.dup
+
+      text_box.render(dry_run: true)
+      expect(text_box.at).to eq(original_at)
+    end
+  end
+
+  describe '#render(:valign => :center)' do
+    it '#at should be the same from one dry run to the next' do
+      text = 'this is center text ' * 12
+      options = {
+        width: 162,
+        valign: :center,
+        document: pdf
+      }
+      text_box = described_class.new(text, options)
+
+      text_box.render(dry_run: true)
+      original_at = text_box.at.dup
+
+      text_box.render(dry_run: true)
+      expect(text_box.at).to eq(original_at)
+    end
+  end
+
+  describe '#render with :rotate option of 30)' do
+    let(:angle) { 30 }
+    let(:x) { 300 }
+    let(:y) { 70 }
+    let(:width) { 100 }
+    let(:height) { 50 }
+    let(:cos) { Math.cos(angle * Math::PI / 180) }
+    let(:sin) { Math.sin(angle * Math::PI / 180) }
+    let(:text) { 'Oh hai text rect. ' * 10 }
+    let(:options) do
+      {
+        document: pdf,
+        rotate: angle,
+        at: [x, y],
+        width: width,
+        height: height
+      }
+    end
+
+    context ':rotate_around option of :center' do
+      it 'draws content to the page rotated about the center of the text' do
+        options[:rotate_around] = :center
+        text_box = described_class.new(text, options)
+        text_box.render
+
+        matrices = PDF::Inspector::Graphics::Matrix.analyze(pdf.render)
+        x_ = x + width / 2
+        y_ = y - height / 2
+        x_prime = x_ * cos - y_ * sin
+        y_prime = x_ * sin + y_ * cos
+        expect(matrices.matrices[0]).to eq([
+          1, 0, 0, 1,
+          reduce_precision(x_ - x_prime),
+          reduce_precision(y_ - y_prime)
+        ])
+        expect(matrices.matrices[1]).to eq([
+          reduce_precision(cos),
+          reduce_precision(sin),
+          reduce_precision(-sin),
+          reduce_precision(cos),
+          0, 0
+        ])
+
+        text = PDF::Inspector::Text.analyze(pdf.render)
+        expect(text.strings).to_not be_empty
+      end
+    end
+
+    context ':rotate_around option of :upper_left' do
+      it 'draws content to the page rotated about the upper left corner of '\
+        'the text' do
+        options[:rotate_around] = :upper_left
+        text_box = described_class.new(text, options)
+        text_box.render
+
+        matrices = PDF::Inspector::Graphics::Matrix.analyze(pdf.render)
+        x_prime = x * cos - y * sin
+        y_prime = x * sin + y * cos
+        expect(matrices.matrices[0]).to eq([
+          1, 0, 0, 1,
+          reduce_precision(x - x_prime),
+          reduce_precision(y - y_prime)
+        ])
+        expect(matrices.matrices[1]).to eq([
+          reduce_precision(cos),
+          reduce_precision(sin),
+          reduce_precision(-sin),
+          reduce_precision(cos),
+          0, 0
+        ])
+
+        text = PDF::Inspector::Text.analyze(pdf.render)
+        expect(text.strings).to_not be_empty
+      end
+    end
+
+    context 'default :rotate_around' do
+      it 'draws content to the page rotated about the upper left corner of '\
+        'the text' do
+        text_box = described_class.new(text, options)
+        text_box.render
+
+        matrices = PDF::Inspector::Graphics::Matrix.analyze(pdf.render)
+        x_prime = x * cos - y * sin
+        y_prime = x * sin + y * cos
+        expect(matrices.matrices[0]).to eq([
+          1, 0, 0, 1,
+          reduce_precision(x - x_prime),
+          reduce_precision(y - y_prime)
+        ])
+        expect(matrices.matrices[1]).to eq([
+          reduce_precision(cos),
+          reduce_precision(sin),
+          reduce_precision(-sin),
+          reduce_precision(cos),
+          0, 0
+        ])
+
+        text = PDF::Inspector::Text.analyze(pdf.render)
+        expect(text.strings).to_not be_empty
+      end
+    end
+
+    context ':rotate_around option of :upper_right' do
+      it 'draws content to the page rotated about the upper right corner of '\
+        'the text' do
+        options[:rotate_around] = :upper_right
+        text_box = described_class.new(text, options)
+        text_box.render
+
+        matrices = PDF::Inspector::Graphics::Matrix.analyze(pdf.render)
+        x_ = x + width
+        y_ = y
+        x_prime = x_ * cos - y_ * sin
+        y_prime = x_ * sin + y_ * cos
+        expect(matrices.matrices[0]).to eq([
+          1, 0, 0, 1,
+          reduce_precision(x_ - x_prime),
+          reduce_precision(y_ - y_prime)
+        ])
+        expect(matrices.matrices[1]).to eq([
+          reduce_precision(cos),
+          reduce_precision(sin),
+          reduce_precision(-sin),
+          reduce_precision(cos),
+          0, 0
+        ])
+
+        text = PDF::Inspector::Text.analyze(pdf.render)
+        expect(text.strings).to_not be_empty
+      end
+    end
+
+    context ':rotate_around option of :lower_right' do
+      it 'draws content to the page rotated about the lower right corner of '\
+        'the text' do
+        options[:rotate_around] = :lower_right
+        text_box = described_class.new(text, options)
+        text_box.render
+
+        matrices = PDF::Inspector::Graphics::Matrix.analyze(pdf.render)
+        x_ = x + width
+        y_ = y - height
+        x_prime = x_ * cos - y_ * sin
+        y_prime = x_ * sin + y_ * cos
+        expect(matrices.matrices[0]).to eq([
+          1, 0, 0, 1,
+          reduce_precision(x_ - x_prime),
+          reduce_precision(y_ - y_prime)
+        ])
+        expect(matrices.matrices[1]).to eq([
+          reduce_precision(cos),
+          reduce_precision(sin),
+          reduce_precision(-sin),
+          reduce_precision(cos),
+          0, 0
+        ])
+
+        text = PDF::Inspector::Text.analyze(pdf.render)
+        expect(text.strings).to_not be_empty
+      end
+    end
+
+    context ':rotate_around option of :lower_left' do
+      it 'draws content to the page rotated about the lower left corner of '\
+        'the text' do
+        options[:rotate_around] = :lower_left
+        text_box = described_class.new(text, options)
+        text_box.render
+
+        matrices = PDF::Inspector::Graphics::Matrix.analyze(pdf.render)
+        x_ = x
+        y_ = y - height
+        x_prime = x_ * cos - y_ * sin
+        y_prime = x_ * sin + y_ * cos
+        expect(matrices.matrices[0]).to eq([
+          1, 0, 0, 1,
+          reduce_precision(x_ - x_prime),
+          reduce_precision(y_ - y_prime)
+        ])
+        expect(matrices.matrices[1]).to eq([
+          reduce_precision(cos),
+          reduce_precision(sin),
+          reduce_precision(-sin),
+          reduce_precision(cos),
+          0, 0
+        ])
+
+        text = PDF::Inspector::Text.analyze(pdf.render)
+        expect(text.strings).to_not be_empty
+      end
+    end
+  end
+
+  describe 'default height' do
+    it 'is the height from the bottom bound to document.y' do
+      target_height = pdf.y - pdf.bounds.bottom
+      text = "Oh hai\n" * 60
+      text_box = described_class.new(text, document: pdf)
+      text_box.render
+      expect(text_box.height).to be_within(pdf.font.height).of(target_height)
+    end
+
+    it 'uses the margin-box bottom if only in a stretchy bbox' do
+      pdf.bounding_box([0, pdf.cursor], width: pdf.bounds.width) do
+        target_height = pdf.y - pdf.bounds.bottom
+        text = "Oh hai\n" * 60
+        text_box = described_class.new(text, document: pdf)
+        text_box.render
+        expect(text_box.height).to be_within(pdf.font.height).of(target_height)
+      end
+    end
+
+    it 'should use the parent-box bottom if in a stretchy bbox and ' \
+      'overflow is :expand, even with an explicit height' do
+      pdf.bounding_box([0, pdf.cursor], width: pdf.bounds.width) do
+        target_height = pdf.y - pdf.bounds.bottom
+        text = "Oh hai\n" * 60
+        text_box = described_class.new(
+          text,
+          document: pdf,
+          height: 100,
+          overflow: :expand
+        )
+        text_box.render
+        expect(text_box.height).to be_within(pdf.font.height).of(target_height)
+      end
+    end
+
+    it 'uses the innermost non-stretchy bbox, not the margin box' do
+      pdf.bounding_box(
+        [0, pdf.cursor],
+        width: pdf.bounds.width,
+        height: 200
+      ) do
+        pdf.bounding_box([0, pdf.cursor], width: pdf.bounds.width) do
+          text = "Oh hai\n" * 60
+          text_box = described_class.new(text, document: pdf)
+          text_box.render
+          expect(text_box.height).to be_within(pdf.font.height).of(200)
+        end
+      end
+    end
+  end
+
+  describe 'default at' do
+    it 'is the left corner of the bounds, and the current document.y' do
+      target_at = [pdf.bounds.left, pdf.y]
+      text = 'Oh hai text rect. ' * 100
+      options = { document: pdf }
+      text_box = described_class.new(text, options)
+      text_box.render
+      expect(text_box.at).to eq(target_at)
+    end
+  end
+
+  context 'with text than can fit in the box' do
+    let(:text) { 'Oh hai text rect. ' * 10 }
+    let(:options) do
+      {
+        width: 162.0,
+        height: 162.0,
+        document: pdf
+      }
+    end
+
+    it 'printed text should match requested text, except that preceding and ' \
+      'trailing white space will be stripped from each line, and newlines ' \
+      'may be inserted' do
+      text_box = described_class.new('  ' + text, options)
+      text_box.render
+      expect(text_box.text.tr("\n", ' ')).to eq(text.strip)
+    end
+
+    it 'render returns an empty string because no text remains unprinted' do
+      text_box = described_class.new(text, options)
+      expect(text_box.render).to eq('')
+    end
+
+    it 'is truncated when the leading is set high enough to prevent all the '\
+      'lines from being printed' do
+      options[:leading] = 40
+      text_box = described_class.new(text, options)
+      text_box.render
+      expect(text_box.text.tr("\n", ' ')).to_not eq(text.strip)
+    end
+  end
+
+  context 'with text that fits exactly in the box' do
+    let(:lines) { 3 }
+    let(:interlines) { lines - 1 }
+    let(:text) { (1..lines).to_a.join("\n") }
+    let(:options) do
+      {
+        width: 162.0,
+        height: pdf.font.ascender + pdf.font.height * interlines +
+          pdf.font.descender,
+        document: pdf
+      }
+    end
+
+    it 'has the expected height' do
+      expected_height = options.delete(:height)
+      text_box = described_class.new(text, options)
+      text_box.render
+      expect(text_box.height).to be_within(0.0001).of(expected_height)
+    end
+
+    it 'prints everything' do
+      text_box = described_class.new(text, options)
+      text_box.render
+      expect(text_box.text).to eq(text)
+    end
+
+    describe 'with leading' do
+      before do
+        options[:leading] = 15
+      end
+
+      it 'does not overflow when enough height is added' do
+        options[:height] += options[:leading] * interlines
+        text_box = described_class.new(text, options)
+        text_box.render
+        expect(text_box.text).to eq(text)
+      end
+
+      it 'overflows when insufficient height is added' do
+        options[:height] += options[:leading] * interlines - 1
+        text_box = described_class.new(text, options)
+        text_box.render
+        expect(text_box.text).to_not eq(text)
+      end
+    end
+
+    context 'with negative leading' do
+      before do
+        options[:leading] = -4
+      end
+
+      it 'does not overflow when enough height is removed' do
+        options[:height] += options[:leading] * interlines
+        text_box = described_class.new(text, options)
+        text_box.render
+        expect(text_box.text).to eq(text)
+      end
+
+      it 'overflows when too much height is removed' do
+        options[:height] += options[:leading] * interlines - 1
+        text_box = described_class.new(text, options)
+        text_box.render
+        expect(text_box.text).to_not eq(text)
+      end
+    end
+  end
+
+  context 'printing UTF-8 string with higher bit characters' do
+    let(:text) { '©' }
+
+    let(:text_box) do
+      # not enough height to print any text, so we can directly compare against
+      # the input string
+      bounding_height = 1.0
+      options = {
+        height: bounding_height,
+        document: pdf
+      }
+      described_class.new(text, options)
+    end
+
+    before do
+      file = "#{Prawn::DATADIR}/fonts/Panic+Sans.dfont"
+      pdf.font_families['Panic Sans'] = {
+        normal: { file: file, font: 'PanicSans' },
+        italic: { file: file, font: 'PanicSans-Italic' },
+        bold: { file: file, font: 'PanicSans-Bold' },
+        bold_italic: { file: file, font: 'PanicSans-BoldItalic' }
+      }
+    end
+
+    describe 'when using a TTF font' do
+      it 'unprinted text should be in UTF-8 encoding' do
+        pdf.font('Panic Sans')
+        remaining_text = text_box.render
+        expect(remaining_text).to eq(text)
+      end
+    end
+
+    describe 'when using an AFM font' do
+      it 'unprinted text should be in UTF-8 encoding' do
+        remaining_text = text_box.render
+        expect(remaining_text).to eq(text)
+      end
+    end
+  end
+
+  context 'with more text than can fit in the box' do
+    let(:text) { 'Oh hai text rect. ' * 30 }
+    let(:bounding_height) { 162.0 }
+    let(:options) do
+      {
+        width: 162.0,
+        height: bounding_height,
+        document: pdf
+      }
+    end
+
+    context 'truncated overflow' do
+      let(:text_box) do
+        described_class.new(text, options.merge(overflow: :truncate))
+      end
+
+      it 'is truncated' do
+        text_box.render
+        expect(text_box.text.tr("\n", ' ')).to_not eq(text.strip)
+      end
+
+      it 'render does not return an empty string because some text remains '\
+        'unprinted' do
+        expect(text_box.render).to_not be_empty
+      end
+
+      it '#height should be no taller than the specified height' do
+        text_box.render
+        expect(text_box.height).to be <= bounding_height
+      end
+
+      it '#height should be within one font height of the specified height' do
+        text_box.render
+        expect(bounding_height).to be_within(pdf.font.height)
+          .of(text_box.height)
+      end
+
+      context 'with :rotate option' do
+        it 'unrendered text should be the same as when not rotated' do
+          remaining_text = text_box.render
+
+          rotate = 30
+          x = 300
+          y = 70
+          options[:document] = pdf
+          options[:rotate] = rotate
+          options[:at] = [x, y]
+          rotated_text_box = described_class.new(text, options)
+          expect(rotated_text_box.render).to eq(remaining_text)
+        end
+      end
+    end
+
+    context 'truncated with text and size taken from the manual' do
+      it 'returns the right text' do
+        text = 'This is the beginning of the text. It will be cut somewhere ' \
+          'and the rest of the text will procede to be rendered this time by '\
+          'calling another method.' + ' . ' * 50
+        options[:width] = 300
+        options[:height] = 50
+        options[:size] = 18
+        text_box = described_class.new(text, options)
+        remaining_text = text_box.render
+        expect(remaining_text).to eq(
+          'text will procede to be rendered this time by calling another ' \
+          'method. .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  ' \
+          '.  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  ' \
+          '.  .  .  .  .  .  .  .  . '
+        )
+      end
+    end
+
+    context 'expand overflow' do
+      let(:text_box) do
+        described_class.new(text, options.merge(overflow: :expand))
+      end
+
+      it 'height expands to encompass all the text '\
+        '(but not exceed the height of the page)' do
+        text_box.render
+        expect(text_box.height).to be > bounding_height
+      end
+
+      it 'displays the entire string (as long as there was space remaining on '\
+        'the page to print all the text)' do
+        text_box.render
+        expect(text_box.text.tr("\n", ' ')).to eq(text.strip)
+      end
+
+      it 'render returns an empty string because no text remains unprinted '\
+        '(as long as there was space remaining on the page to print all '\
+        'the text)' do
+        expect(text_box.render).to eq('')
+      end
+    end
+
+    context 'shrink_to_fit overflow' do
+      let(:text_box) do
+        described_class.new(
+          text,
+          options.merge(
+            overflow: :shrink_to_fit,
+            min_font_size: 2
+          )
+        )
+      end
+
+      it 'displays the entire text' do
+        text_box.render
+        expect(text_box.text.tr("\n", ' ')).to eq(text.strip)
+      end
+
+      it 'render returns an empty string because no text remains unprinted' do
+        expect(text_box.render).to eq('')
+      end
+    end
+
+    context 'shrink_to_fit overflow' do
+      it 'does not drop below the minimum font size' do
+        options[:overflow] = :shrink_to_fit
+        options[:min_font_size] = 10.1
+        text_box = described_class.new(text, options)
+        text_box.render
+
+        actual_text = PDF::Inspector::Text.analyze(pdf.render)
+        expect(actual_text.font_settings[0][:size]).to eq(10.1)
+      end
+    end
+  end
+
+  context 'with enough space to fit the text but using the ' \
+    'shrink_to_fit overflow' do
+    it 'does not shrink the text when there is no need to' do
+      bounding_height = 162.0
+      options = {
+        width: 162.0,
+        height: bounding_height,
+        overflow: :shrink_to_fit,
+        min_font_size: 5,
+        document: pdf
+      }
+      text_box = described_class.new("hello\nworld", options)
+      text_box.render
+
+      text = PDF::Inspector::Text.analyze(pdf.render)
+      expect(text.font_settings[0][:size]).to eq(12)
+    end
+  end
+
+  context 'with a solid block of Chinese characters' do
+    it 'printed text should match requested text, except for newlines' do
+      text = '写中国字' * 10
+      options = {
+        width: 162.0,
+        height: 162.0,
+        document: pdf,
+        overflow: :truncate
+      }
+      pdf.font "#{Prawn::DATADIR}/fonts/gkai00mp.ttf"
+      text_box = described_class.new(text, options)
+      text_box.render
+      expect(text_box.text.delete("\n")).to eq(text)
+    end
+  end
+
+  describe 'drawing bounding boxes' do
+    it 'restores the margin box when bounding box exits' do
+      margin_box = pdf.bounds
+
+      pdf.text_box 'Oh hai text box. ' * 11, height: pdf.font.height * 10
+
+      expect(pdf.bounds).to eq(margin_box)
+    end
+  end
+
+  describe '#render with :character_spacing option' do
+    it 'draws the character spacing to the document' do
+      string = 'hello world'
+      options = { document: pdf, character_spacing: 10 }
+      text_box = described_class.new(string, options)
+      text_box.render
+      contents = PDF::Inspector::Text.analyze(pdf.render)
+      expect(contents.character_spacing[0]).to eq(10)
+    end
+
+    it 'takes character spacing into account when wrapping' do
+      pdf.font 'Courier'
+      text_box = described_class.new(
+        'hello world',
+        width: 100,
+        overflow: :expand,
+        character_spacing: 10,
+        document: pdf
+      )
+      text_box.render
+      expect(text_box.text).to eq("hello\nworld")
+    end
+  end
+
+  describe 'wrapping' do
+    it 'wraps text' do
+      text = 'Please wrap this text about HERE. ' \
+        'More text that should be wrapped'
+      expect = "Please wrap this text about\n"\
+        "HERE. More text that should be\nwrapped"
+
+      pdf.font 'Courier'
+      text_box = described_class.new(
+        text,
+        width: 220,
+        overflow: :expand,
+        document: pdf
+      )
+      text_box.render
+      expect(text_box.text).to eq(expect)
+    end
+
+    # white space was being stripped after the entire line was generated,
+    # meaning that leading white space characters reduced the amount of space on
+    # the line for other characters, so wrapping "hello hello" resulted in
+    # "hello\n\nhello", rather than "hello\nhello"
+    #
+    it 'white space at beginning of line should not be taken into account ' \
+      'when computing line width' do
+      text = 'hello hello'
+      expect = "hello\nhello"
+
+      pdf.font 'Courier'
+      text_box = described_class.new(
+        text,
+        width: 40,
+        overflow: :expand,
+        document: pdf
+      )
+      text_box.render
+      expect(text_box.text).to eq(expect)
+    end
+
+    it 'respects end of line when wrapping text' do
+      text = "Please wrap only before\nTHIS word. Don't wrap this"
+      expect = text
+
+      pdf.font 'Courier'
+      text_box = described_class.new(
+        text,
+        width: 220,
+        overflow: :expand,
+        document: pdf
+      )
+      text_box.render
+      expect(text_box.text).to eq(expect)
+    end
+
+    it 'respects multiple newlines when wrapping text' do
+      text = "Please wrap only before THIS\n\nword. Don't wrap this"
+      expect = "Please wrap only before\nTHIS\n\nword. Don't wrap this"
+
+      pdf.font 'Courier'
+      text_box = described_class.new(
+        text,
+        width: 200,
+        overflow: :expand,
+        document: pdf
+      )
+      text_box.render
+      expect(text_box.text).to eq(expect)
+    end
+
+    it 'respects multiple newlines when wrapping text when those newlines '\
+      'coincide with a line break' do
+      text = "Please wrap only before\n\nTHIS word. Don't wrap this"
+      expect = text
+
+      pdf.font 'Courier'
+      text_box = described_class.new(
+        text,
+        width: 220,
+        overflow: :expand,
+        document: pdf
+      )
+      text_box.render
+      expect(text_box.text).to eq(expect)
+    end
+
+    it 'respects initial newlines' do
+      text = "\nThis should be on line 2"
+      expect = text
+
+      pdf.font 'Courier'
+      text_box = described_class.new(
+        text,
+        width: 220,
+        overflow: :expand,
+        document: pdf
+      )
+      text_box.render
+      expect(text_box.text).to eq(expect)
+    end
+
+    it 'wraps lines comprised of a single word of the bounds when '\
+      'wrapping text' do
+      text = 'You_can_wrap_this_text_HERE'
+      expect = "You_can_wrap_this_text_HE\nRE"
+
+      pdf.font 'Courier'
+      text_box = described_class.new(
+        text,
+        width: 180,
+        overflow: :expand,
+        document: pdf
+      )
+      text_box.render
+      expect(text_box.text).to eq(expect)
+    end
+
+    it 'wraps lines comprised of a single word of the bounds when '\
+      'wrapping text' do
+      text = '©' * 30
+
+      pdf.font 'Courier'
+      text_box = described_class.new(
+        text, width: 180,
+              overflow: :expand,
+              document: pdf
+      )
+
+      text_box.render
+
+      expected = '©' * 25 + "\n" + '©' * 5
+      pdf.font.normalize_encoding!(expected)
+      expected = expected.force_encoding(Encoding::UTF_8)
+      expect(text_box.text).to eq(expected)
+    end
+
+    it 'wraps non-unicode strings using single-byte word-wrapping' do
+      text = 'continúa esforzandote ' * 5
+      text_box = described_class.new(
+        text, width: 180,
+              document: pdf
+      )
+      text_box.render
+      results_with_accent = text_box.text
+
+      text = 'continua esforzandote ' * 5
+      text_box = described_class.new(
+        text, width: 180,
+              document: pdf
+      )
+      text_box.render
+      results_without_accent = text_box.text
+
+      expect(first_line(results_with_accent).length)
+        .to eq(first_line(results_without_accent).length)
+    end
+
+    it 'allows you to disable wrapping by char' do
+      text = 'You_cannot_wrap_this_text_at_all_because_we_are_disabling_' \
+        'wrapping_by_char_and_there_are_no_word_breaks'
+
+      pdf.font 'Courier'
+      text_box = described_class.new(
+        text,
+        width: 180,
+        overflow: :shrink_to_fit,
+        disable_wrap_by_char: true,
+        document: pdf
+      )
+      expect { text_box.render }.to raise_error(Prawn::Errors::CannotFit)
+    end
+
+    it 'retains full words with :shrink_to_fit if char wrapping is disabled' do
+      text = 'Wrapped_words'
+      expect = 'Wrapped_words'
+
+      pdf.font 'Courier'
+      text_box = described_class.new(
+        text,
+        width: 50,
+        height: 50,
+        size: 50,
+        overflow: :shrink_to_fit,
+        disable_wrap_by_char: true,
+        document: pdf
+      )
+      text_box.render
+      expect(text_box.text).to eq(expect)
+    end
+  end
+
+  describe 'Text::Box#render with :mode option' do
+    it 'alters the text rendering mode of the document' do
+      string = 'hello world'
+      options = { document: pdf, mode: :fill_stroke }
+      text_box = described_class.new(string, options)
+      text_box.render
+      contents = PDF::Inspector::Text.analyze(pdf.render)
+      expect(contents.text_rendering_mode).to eq([2, 0])
+    end
+  end
+
+  def reduce_precision(float)
+    (format '%.5f', float).to_f
+  end
+
+  def first_line(str)
+    str.each_line { |line| return line }
+  end
+end