prawn-git 2.0.1

data/spec/formatted_text_arranger_spec.rb

@@ -0,0 +1,421 @@
+# encoding: utf-8
+
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
+
+describe "Core::Text::Formatted::Arranger#format_array" do
+  it "should populate unconsumed array" do
+    create_pdf
+    arranger = Prawn::Text::Formatted::Arranger.new(@pdf)
+    array = [{ :text => "hello " },
+             { :text => "world how ", :styles => [:bold] },
+             { :text => "are", :styles => [:bold, :italic] },
+             { :text => " you?" }]
+    arranger.format_array = array
+    arranger.unconsumed[0].should == { :text => "hello " }
+    arranger.unconsumed[1].should == { :text => "world how ",
+                                              :styles => [:bold] }
+    arranger.unconsumed[2].should == { :text => "are",
+                                              :styles => [:bold, :italic] }
+    arranger.unconsumed[3].should == { :text => " you?" }
+  end
+  it "should split newlines into their own elements" do
+    create_pdf
+    arranger = Prawn::Text::Formatted::Arranger.new(@pdf)
+    array = [{ :text => "\nhello\nworld" }]
+    arranger.format_array = array
+    arranger.unconsumed[0].should == { :text => "\n" }
+    arranger.unconsumed[1].should == { :text => "hello" }
+    arranger.unconsumed[2].should == { :text => "\n" }
+    arranger.unconsumed[3].should == { :text => "world" }
+  end
+end
+describe "Core::Text::Formatted::Arranger#preview_next_string" do
+  it "should not populate the consumed array" do
+    create_pdf
+    arranger = Prawn::Text::Formatted::Arranger.new(@pdf)
+    array = [{ :text => "hello" }]
+    arranger.format_array = array
+    arranger.preview_next_string
+    arranger.consumed.should == []
+  end
+  it "should not consumed array" do
+    create_pdf
+    arranger = Prawn::Text::Formatted::Arranger.new(@pdf)
+    array = [{ :text => "hello" }]
+    arranger.format_array = array
+    arranger.preview_next_string.should == "hello"
+  end
+end
+describe "Core::Text::Formatted::Arranger#next_string" do
+  before(:each) do
+    create_pdf
+    @arranger = Prawn::Text::Formatted::Arranger.new(@pdf)
+    array = [{ :text => "hello " },
+             { :text => "world how ", :styles => [:bold] },
+             { :text => "are", :styles => [:bold, :italic] },
+             { :text => " you?" }]
+    @arranger.format_array = array
+  end
+  it "should raise_error an error if called after a line was finalized and" +
+     " before a new line was initialized" do
+    @arranger.finalize_line
+    lambda do
+      @arranger.next_string
+    end.should raise_error(RuntimeError)
+  end
+  it "should populate consumed array" do
+    while string = @arranger.next_string
+    end
+    @arranger.consumed[0].should == { :text => "hello " }
+    @arranger.consumed[1].should == { :text => "world how ",
+                                              :styles => [:bold] }
+    @arranger.consumed[2].should == { :text => "are",
+                                              :styles => [:bold, :italic] }
+    @arranger.consumed[3].should == { :text => " you?" }
+  end
+  it "should populate current_format_state array" do
+    create_pdf
+    arranger = Prawn::Text::Formatted::Arranger.new(@pdf)
+    array = [{ :text => "hello " },
+             { :text => "world how ", :styles => [:bold] },
+             { :text => "are", :styles => [:bold, :italic] },
+             { :text => " you?" }]
+    arranger.format_array = array
+    counter = 0
+    while string = arranger.next_string
+      case counter
+      when 0
+        arranger.current_format_state.should == { }
+      when 1
+        arranger.current_format_state.should == { :styles => [:bold] }
+      when 2
+        arranger.current_format_state.should == { :styles => [:bold, :italic] }
+      when 3
+        arranger.current_format_state.should == { }
+      end
+      counter += 1
+    end
+  end
+end
+
+describe "Core::Text::Formatted::Arranger#retrieve_fragment" do
+  it "should raise_error an error if called before finalize_line was called" do
+    create_pdf
+    arranger = Prawn::Text::Formatted::Arranger.new(@pdf)
+    array = [{ :text => "hello " },
+             { :text => "world how ", :styles => [:bold] },
+             { :text => "are", :styles => [:bold, :italic] },
+             { :text => " you?" }]
+    arranger.format_array = array
+    while string = arranger.next_string
+    end
+    lambda do
+      arranger.retrieve_fragment
+    end.should raise_error(RuntimeError)
+  end
+  it "should return the consumed fragments in order of consumption" +
+     " and update" do
+    create_pdf
+    arranger = Prawn::Text::Formatted::Arranger.new(@pdf)
+    array = [{ :text => "hello " },
+             { :text => "world how ", :styles => [:bold] },
+             { :text => "are", :styles => [:bold, :italic] },
+             { :text => " you?" }]
+    arranger.format_array = array
+    while string = arranger.next_string
+    end
+    arranger.finalize_line
+    arranger.retrieve_fragment.text.should == "hello "
+    arranger.retrieve_fragment.text.should == "world how "
+    arranger.retrieve_fragment.text.should == "are"
+    arranger.retrieve_fragment.text.should == " you?"
+  end
+  it "should never return a fragment whose text is an empty string" do
+    create_pdf
+    arranger = Prawn::Text::Formatted::Arranger.new(@pdf)
+    array = [{ :text => "hello\nworld\n\n\nhow are you?" },
+             { :text => "\n" },
+             { :text => "\n" },
+             { :text => "\n" },
+             { :text => "" },
+             { :text => "fine, thanks." },
+             { :text => "" },
+             { :text => "\n" },
+             { :text => "" }]
+    arranger.format_array = array
+    while string = arranger.next_string
+    end
+    arranger.finalize_line
+    while fragment = arranger.retrieve_fragment
+      fragment.text.should_not be_empty
+    end
+  end
+  it "should not alter the current font style" do
+    create_pdf
+    arranger = Prawn::Text::Formatted::Arranger.new(@pdf)
+    array = [{ :text => "hello " },
+             { :text => "world how ", :styles => [:bold] },
+             { :text => "are", :styles => [:bold, :italic] },
+             { :text => " you?" }]
+    arranger.format_array = array
+    while string = arranger.next_string
+    end
+    arranger.finalize_line
+    arranger.retrieve_fragment
+    arranger.current_format_state[:styles].should be_nil
+  end
+end
+
+describe "Core::Text::Formatted::Arranger#update_last_string" do
+  it "should update the last retrieved string with what actually fit on" +
+     "the line and the list of unconsumed with what did not" do
+    create_pdf
+    arranger = Prawn::Text::Formatted::Arranger.new(@pdf)
+    array = [{ :text => "hello " },
+             { :text => "world how ", :styles => [:bold] },
+             { :text => "are", :styles => [:bold, :italic] },
+             { :text => " you now?", :styles => [:bold, :italic] }]
+    arranger.format_array = array
+    while string = arranger.next_string
+    end
+    arranger.update_last_string(" you", " now?", nil)
+    arranger.consumed[3].should == { :text => " you",
+                                     :styles => [:bold, :italic] }
+    arranger.unconsumed.should == [{ :text => " now?",
+                                     :styles => [:bold, :italic] }]
+  end
+  it "should set the format state to the previously processed fragment" do
+    create_pdf
+    arranger = Prawn::Text::Formatted::Arranger.new(@pdf)
+    array = [{ :text => "hello " },
+             { :text => "world how ", :styles => [:bold] },
+             { :text => "are", :styles => [:bold, :italic] },
+             { :text => " you now?" }]
+    arranger.format_array = array
+    3.times { arranger.next_string }
+    arranger.current_format_state.should == { :styles => [:bold, :italic] }
+    arranger.update_last_string("", "are", "-")
+    arranger.current_format_state.should == { :styles => [:bold] }
+  end
+
+  context "when the entire string was used" do
+    it "should not push empty string onto unconsumed" do
+    create_pdf
+    arranger = Prawn::Text::Formatted::Arranger.new(@pdf)
+    array = [{ :text => "hello " },
+             { :text => "world how ", :styles => [:bold] },
+             { :text => "are", :styles => [:bold, :italic] },
+             { :text => " you now?" }]
+    arranger.format_array = array
+      while string = arranger.next_string
+      end
+      arranger.update_last_string(" you now?", "", nil)
+      arranger.unconsumed.should == []
+    end
+  end
+end
+describe "Core::Text::Formatted::Arranger#space_count" do
+  before(:each) do
+    create_pdf
+    @arranger = Prawn::Text::Formatted::Arranger.new(@pdf)
+    array = [{ :text => "hello " },
+             { :text => "world how ", :styles => [:bold] },
+             { :text => "are", :styles => [:bold, :italic] },
+             { :text => " you?" }]
+    @arranger.format_array = array
+    while string = @arranger.next_string
+    end
+  end
+  it "should raise_error an error if called before finalize_line was called" do
+    lambda do
+      @arranger.space_count
+    end.should raise_error(RuntimeError)
+  end
+  it "should return the total number of spaces in all fragments" do
+    @arranger.finalize_line
+    @arranger.space_count.should == 4
+  end
+end
+describe "Core::Text::Formatted::Arranger#finalize_line" do
+  it "should make it so that all trailing white space fragments " +
+     "exclude trailing white space" do
+    create_pdf
+    arranger = Prawn::Text::Formatted::Arranger.new(@pdf)
+    array = [{ :text => "hello " },
+             { :text => "world how ", :styles => [:bold] },
+             { :text => "   ", :styles => [:bold, :italic] }]
+    arranger.format_array = array
+    while string = arranger.next_string
+    end
+    arranger.finalize_line
+    arranger.fragments.length.should == 3
+
+    fragment = arranger.retrieve_fragment
+    fragment.text.should == "hello "
+
+    fragment = arranger.retrieve_fragment
+    fragment.text.should == "world how"
+
+    fragment = arranger.retrieve_fragment
+    fragment.text.should == ""
+  end
+end
+
+describe "Core::Text::Formatted::Arranger#line_width" do
+  before(:each) do
+    create_pdf
+    @arranger = Prawn::Text::Formatted::Arranger.new(@pdf)
+    array = [{ :text => "hello " },
+             { :text => "world", :styles => [:bold] }]
+    @arranger.format_array = array
+    while string = @arranger.next_string
+    end
+  end
+  it "should raise_error an error if called before finalize_line was called" do
+    lambda do
+      @arranger.line_width
+    end.should raise_error(RuntimeError)
+  end
+  it "should return the width of the complete line" do
+    @arranger.finalize_line
+    @arranger.line_width.should be > 0
+  end
+end
+
+describe "Core::Text::Formatted::Arranger#line_width with character_spacing > 0" do
+  it "should return a width greater than a line without a character_spacing" do
+    create_pdf
+    arranger = Prawn::Text::Formatted::Arranger.new(@pdf)
+
+    array = [{ :text => "hello " },
+             { :text => "world", :styles => [:bold] }]
+    arranger.format_array = array
+    while string = arranger.next_string
+    end
+    arranger.finalize_line
+
+    base_line_width = arranger.line_width
+
+
+    array = [{ :text => "hello " },
+             { :text => "world", :styles => [:bold],
+               :character_spacing => 7}]
+    arranger.format_array = array
+    while string = arranger.next_string
+    end
+    arranger.finalize_line
+    arranger.line_width.should be > base_line_width
+  end
+end
+
+describe "Core::Text::Formatted::Arranger#line" do
+  before(:each) do
+    create_pdf
+    @arranger = Prawn::Text::Formatted::Arranger.new(@pdf)
+    array = [{ :text => "hello " },
+             { :text => "world", :styles => [:bold] }]
+    @arranger.format_array = array
+    while string = @arranger.next_string
+    end
+  end
+  it "should raise_error an error if called before finalize_line was called" do
+    lambda do
+      @arranger.line
+    end.should raise_error(RuntimeError)
+  end
+  it "should return the complete line" do
+    @arranger.finalize_line
+    @arranger.line.should == "hello world"
+  end
+end
+
+describe "Core::Text::Formatted::Arranger#unconsumed" do
+  it "should return the original array if nothing was consumed" do
+    create_pdf
+    arranger = Prawn::Text::Formatted::Arranger.new(@pdf)
+    array = [{ :text => "hello " },
+             { :text => "world how ", :styles => [:bold] },
+             { :text => "are", :styles => [:bold, :italic] },
+             { :text => " you now?" }]
+    arranger.format_array = array
+    arranger.unconsumed.should == array
+  end
+  it "should return an empty array if everything was consumed" do
+    create_pdf
+    arranger = Prawn::Text::Formatted::Arranger.new(@pdf)
+    array = [{ :text => "hello " },
+             { :text => "world how ", :styles => [:bold] },
+             { :text => "are", :styles => [:bold, :italic] },
+             { :text => " you now?" }]
+    arranger.format_array = array
+    while string = arranger.next_string
+    end
+    arranger.unconsumed.should == []
+  end
+end
+
+describe "Core::Text::Formatted::Arranger#finished" do
+  it "should be_false if anything was not printed" do
+    create_pdf
+    arranger = Prawn::Text::Formatted::Arranger.new(@pdf)
+    array = [{ :text => "hello " },
+             { :text => "world how ", :styles => [:bold] },
+             { :text => "are", :styles => [:bold, :italic] },
+             { :text => " you now?" }]
+    arranger.format_array = array
+    while string = arranger.next_string
+    end
+    arranger.update_last_string(" you", "now?", nil)
+    arranger.should_not be_finished
+  end
+  it "should be_false if everything was printed" do
+    create_pdf
+    arranger = Prawn::Text::Formatted::Arranger.new(@pdf)
+    array = [{ :text => "hello " },
+             { :text => "world how ", :styles => [:bold] },
+             { :text => "are", :styles => [:bold, :italic] },
+             { :text => " you now?" }]
+    arranger.format_array = array
+    while string = arranger.next_string
+    end
+    arranger.should be_finished
+  end
+end
+
+describe "Core::Text::Formatted::Arranger.max_line_height" do
+  it "should be the height of the maximum consumed fragment" do
+    create_pdf
+    arranger = Prawn::Text::Formatted::Arranger.new(@pdf)
+    array = [{ :text => "hello " },
+             { :text => "world how ", :styles => [:bold] },
+             { :text => "are", :styles => [:bold, :italic],
+               :size => 28 },
+             { :text => " you now?" }]
+    arranger.format_array = array
+    while string = arranger.next_string
+    end
+    arranger.finalize_line
+    arranger.max_line_height.should be_within(0.0001).of(33.32)
+  end
+end
+
+describe "Core::Text::Formatted::Arranger#repack_unretrieved" do
+  it "should restore part of the original string" do
+    create_pdf
+    arranger = Prawn::Text::Formatted::Arranger.new(@pdf)
+    array = [{ :text => "hello " },
+             { :text => "world how ", :styles => [:bold] },
+             { :text => "are", :styles => [:bold, :italic] },
+             { :text => " you now?" }]
+    arranger.format_array = array
+    while string = arranger.next_string
+    end
+    arranger.finalize_line
+    arranger.retrieve_fragment
+    arranger.retrieve_fragment
+    arranger.repack_unretrieved
+    arranger.unconsumed.should == [
+             { :text => "are", :styles => [:bold, :italic] },
+             { :text => " you now?" }]
+  end
+end

data/spec/formatted_text_box_spec.rb

@@ -0,0 +1,705 @@
+# encoding: utf-8
+
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
+
+describe "Text::Formatted::Box wrapping" do
+  before(:each) do
+    create_pdf
+  end
+
+  it "should not wrap between two fragments" do
+    texts = [
+      {:text => "Hello "},
+      {:text => "World"},
+      {:text => "2", :styles => [:superscript]},
+      ]
+    text_box = Prawn::Text::Formatted::Box.new(texts, :document => @pdf, :width => @pdf.width_of("Hello World"))
+    text_box.render
+    text_box.text.should == "Hello\nWorld2"
+  end
+
+  it "should not raise an Encoding::CompatibilityError when keeping a TTF and an AFM font together" do
+    file = "#{Prawn::DATADIR}/fonts/gkai00mp.ttf"
+
+    @pdf.font_families["Kai"] = {
+      :normal => { :file => file, :font => "Kai" }
+    }
+
+    texts = [{ :text => "Hello " },
+              { :text => "再见", :font => "Kai"},
+              { :text => "World" }]
+    text_box = Prawn::Text::Formatted::Box.new(texts, :document => @pdf, :width => @pdf.width_of("Hello World"))
+
+    text_box.render
+  end
+
+  it "should wrap between two fragments when the preceding fragment ends with white space" do
+    texts = [
+      {:text => "Hello "},
+      {:text => "World "},
+      {:text => "2", :styles => [:superscript]},
+      ]
+    text_box = Prawn::Text::Formatted::Box.new(texts, :document => @pdf, :width => @pdf.width_of("Hello World"))
+    text_box.render
+    text_box.text.should == "Hello World\n2"
+
+    texts = [
+      {:text => "Hello "},
+      {:text => "World\n"},
+      {:text => "2", :styles => [:superscript]},
+      ]
+    text_box = Prawn::Text::Formatted::Box.new(texts, :document => @pdf, :width => @pdf.width_of("Hello World"))
+    text_box.render
+    text_box.text.should == "Hello World\n2"
+  end
+
+  it "should wrap between two fragments when the final fragment begins with white space" do
+    texts = [
+      {:text => "Hello "},
+      {:text => "World"},
+      {:text => " 2", :styles => [:superscript]},
+      ]
+    text_box = Prawn::Text::Formatted::Box.new(texts, :document => @pdf, :width => @pdf.width_of("Hello World"))
+    text_box.render
+    text_box.text.should == "Hello World\n2"
+
+    texts = [
+      {:text => "Hello "},
+      {:text => "World"},
+      {:text => "\n2", :styles => [:superscript]},
+      ]
+    text_box = Prawn::Text::Formatted::Box.new(texts, :document => @pdf, :width => @pdf.width_of("Hello World"))
+    text_box.render
+    text_box.text.should == "Hello World\n2"
+  end
+
+  it "should properly handle empty slices using default encoding" do
+    texts = [{ :text => "Noua Delineatio Geographica generalis | Apostolicarum peregrinationum | S FRANCISCI XAUERII | Indiarum & Iaponiæ Apostoli", :font => 'Courier', :size => 10 }]
+    text_box = Prawn::Text::Formatted::Box.new(texts, :document => @pdf, :width => @pdf.width_of("Noua Delineatio Geographica gen"))
+    lambda {
+      text_box.render
+    }.should_not raise_error
+    text_box.text.should == "Noua Delineatio Geographica\ngeneralis | Apostolicarum\nperegrinationum | S FRANCISCI\nXAUERII | Indiarum & Iaponi\346\nApostoli"
+  end
+end
+
+describe "Text::Formatted::Box with :fallback_fonts option that includes" +
+  "a Chinese font and set of Chinese glyphs not in the current font" do
+  it "should change the font to the Chinese font for the Chinese glyphs" do
+    create_pdf
+    file = "#{Prawn::DATADIR}/fonts/gkai00mp.ttf"
+    @pdf.font_families["Kai"] = {
+      :normal => { :file => file, :font => "Kai" }
+    }
+    formatted_text = [{ :text => "hello你好" },
+                      { :text => "再见goodbye" }]
+    @pdf.formatted_text_box(formatted_text, :fallback_fonts => ["Kai"])
+
+    text = PDF::Inspector::Text.analyze(@pdf.render)
+
+    fonts_used = text.font_settings.map { |e| e[:name] }
+    fonts_used.length.should == 4
+    fonts_used[0].should == :"Helvetica"
+    fonts_used[1].to_s.should =~ /GBZenKai-Medium/
+    fonts_used[2].to_s.should =~ /GBZenKai-Medium/
+    fonts_used[3].should == :"Helvetica"
+
+    text.strings[0].should == "hello"
+    text.strings[1].should == "你好"
+    text.strings[2].should == "再见"
+    text.strings[3].should == "goodbye"
+  end
+end
+
+describe "Text::Formatted::Box with :fallback_fonts option that includes" +
+  "an AFM font and Win-Ansi glyph not in the current Chinese font" do
+  it "should change the font to the AFM font for the Win-Ansi glyph" do
+    create_pdf
+    file = "#{Prawn::DATADIR}/fonts/gkai00mp.ttf"
+    @pdf.font_families["Kai"] = {
+      :normal => { :file => file, :font => "Kai" }
+    }
+    @pdf.font("Kai")
+    formatted_text = [{ :text => "hello你好" },
+                      { :text => "再见€" }]
+    @pdf.formatted_text_box(formatted_text, :fallback_fonts => ["Helvetica"])
+
+    text = PDF::Inspector::Text.analyze(@pdf.render)
+
+    fonts_used = text.font_settings.map { |e| e[:name] }
+    fonts_used.length.should == 4
+    fonts_used[0].to_s.should =~ /GBZenKai-Medium/
+    fonts_used[1].to_s.should =~ /GBZenKai-Medium/
+    fonts_used[2].to_s.should =~ /GBZenKai-Medium/
+    fonts_used[3].should == :"Helvetica"
+
+    text.strings[0].should == "hello"
+    text.strings[1].should == "你好"
+    text.strings[2].should == "再见"
+    text.strings[3].should == "€"
+  end
+end
+
+describe "Text::Formatted::Box with :fallback_fonts option and fragment " +
+  "level font" do
+  it "should use the fragment level font except for glyphs not in that font" do
+    create_pdf
+    file = "#{Prawn::DATADIR}/fonts/gkai00mp.ttf"
+    @pdf.font_families["Kai"] = {
+      :normal => { :file => file, :font => "Kai" }
+    }
+
+    file = "#{Prawn::DATADIR}/fonts/DejaVuSans.ttf"
+    @pdf.font_families["DejaVu Sans"] = {
+      :normal => { :file => file }
+    }
+
+    formatted_text = [{ :text => "hello你好" },
+                      { :text => "再见goodbye", :font => "Times-Roman" }]
+    @pdf.formatted_text_box(formatted_text, :fallback_fonts => ["Kai"])
+
+    text = PDF::Inspector::Text.analyze(@pdf.render)
+
+    fonts_used = text.font_settings.map { |e| e[:name] }
+    fonts_used.length.should == 4
+    fonts_used[0].should == :"Helvetica"
+    fonts_used[1].to_s.should =~ /GBZenKai-Medium/
+    fonts_used[2].to_s.should =~ /GBZenKai-Medium/
+    fonts_used[3].should == :"Times-Roman"
+
+    text.strings[0].should == "hello"
+    text.strings[1].should == "你好"
+    text.strings[2].should == "再见"
+    text.strings[3].should == "goodbye"
+  end
+end
+
+describe "Text::Formatted::Box" do
+  before(:each) do
+    create_pdf
+    file = "#{Prawn::DATADIR}/fonts/gkai00mp.ttf"
+    @pdf.font_families["Kai"] = {
+      :normal => { :file => file, :font => "Kai" }
+    }
+
+    file = "#{Prawn::DATADIR}/fonts/DejaVuSans.ttf"
+    @pdf.font_families["DejaVu Sans"] = {
+      :normal => { :file => file }
+    }
+
+
+    @formatted_text = [{ :text => "hello你好" }]
+    @pdf.fallback_fonts(["Kai"])
+    @pdf.fallback_fonts = ["Kai"]
+  end
+  it "#fallback_fonts should return the document-wide fallback fonts" do
+    @pdf.fallback_fonts.should == ["Kai"]
+  end
+  it "should be able to set text fallback_fonts document-wide" do
+    @pdf.formatted_text_box(@formatted_text)
+
+    text = PDF::Inspector::Text.analyze(@pdf.render)
+
+    fonts_used = text.font_settings.map { |e| e[:name] }
+    fonts_used.length.should == 2
+    fonts_used[0].should == :"Helvetica"
+    fonts_used[1].to_s.should =~ /GBZenKai-Medium/
+  end
+  it "should be able to override document-wide fallback_fonts" do
+    @pdf.fallback_fonts = ["DejaVu Sans"]
+    @pdf.formatted_text_box(@formatted_text, :fallback_fonts => ["Kai"])
+
+    text = PDF::Inspector::Text.analyze(@pdf.render)
+
+    fonts_used = text.font_settings.map { |e| e[:name] }
+    fonts_used.length.should == 2
+    fonts_used[0].should == :"Helvetica"
+    fonts_used[1].should =~ /Kai/
+  end
+  it "should omit the fallback fonts overhead when passing an empty array " +
+    "as the :fallback_fonts" do
+    @pdf.font("Kai")
+
+    box = Prawn::Text::Formatted::Box.new(@formatted_text,
+                                          :document => @pdf,
+                                          :fallback_fonts => [])
+
+    box.expects(:process_fallback_fonts).never
+    box.render
+  end
+
+  it "should be able to clear document-wide fallback_fonts" do
+    @pdf.fallback_fonts([])
+    box = Prawn::Text::Formatted::Box.new(@formatted_text,
+                                          :document => @pdf)
+
+    @pdf.font("Kai")
+
+    box.expects(:process_fallback_fonts).never
+    box.render
+  end
+end
+
+describe "Text::Formatted::Box with :fallback_fonts option " +
+  "with glyphs not in the primary or the fallback fonts" do
+
+  it "should raise an exception" do
+   file = "#{Prawn::DATADIR}/fonts/gkai00mp.ttf"
+    create_pdf
+    formatted_text = [{ :text => "hello world. 世界你好。" }]
+
+    lambda {
+      @pdf.formatted_text_box(formatted_text, :fallback_fonts => ["Courier"])
+    }.should raise_error(Prawn::Errors::IncompatibleStringEncoding)
+  end
+end
+
+describe "Text::Formatted::Box#extensions" do
+  it "should be able to override default line wrapping" do
+    create_pdf
+    Prawn::Text::Formatted::Box.extensions << TestFormattedWrapOverride
+    @pdf.formatted_text_box([{ :text => "hello world" }], {})
+    Prawn::Text::Formatted::Box.extensions.delete(TestFormattedWrapOverride)
+    text = PDF::Inspector::Text.analyze(@pdf.render)
+    text.strings[0].should == "all your base are belong to us"
+  end
+  it "overriding Text::Formatted::Box line wrapping should not affect " +
+     "Text::Box wrapping" do
+    create_pdf
+    Prawn::Text::Formatted::Box.extensions << TestFormattedWrapOverride
+    @pdf.text_box("hello world", {})
+    Prawn::Text::Formatted::Box.extensions.delete(TestFormattedWrapOverride)
+    text = PDF::Inspector::Text.analyze(@pdf.render)
+    text.strings[0].should == "hello world"
+  end
+  it "overriding Text::Box line wrapping should override Text::Box wrapping" do
+    create_pdf
+    Prawn::Text::Box.extensions << TestFormattedWrapOverride
+    @pdf.text_box("hello world", {})
+    Prawn::Text::Box.extensions.delete(TestFormattedWrapOverride)
+    text = PDF::Inspector::Text.analyze(@pdf.render)
+    text.strings[0].should == "all your base are belong to us"
+  end
+end
+
+describe "Text::Formatted::Box#render" do
+  it "should handle newlines" do
+    create_pdf
+    array = [{ :text => "hello\nworld"}]
+    options = { :document => @pdf }
+    text_box = Prawn::Text::Formatted::Box.new(array, options)
+    text_box.render
+    text_box.text.should == "hello\nworld"
+  end
+  it "should omit spaces from the beginning of the line" do
+    create_pdf
+    array = [{ :text => " hello\n world"}]
+    options = { :document => @pdf }
+    text_box = Prawn::Text::Formatted::Box.new(array, options)
+    text_box.render
+    text_box.text.should == "hello\nworld"
+  end
+  it "should be okay printing a line of whitespace" do
+    create_pdf
+    array = [{ :text => "hello\n    \nworld"}]
+    options = { :document => @pdf }
+    text_box = Prawn::Text::Formatted::Box.new(array, options)
+    text_box.render
+    text_box.text.should == "hello\n\nworld"
+
+
+    array = [{ :text => "hello" + " " * 500},
+             { :text => " " * 500 },
+             { :text => " " * 500 + "\n"},
+             { :text => "world"}]
+    options = { :document => @pdf }
+    text_box = Prawn::Text::Formatted::Box.new(array, options)
+    text_box.render
+    text_box.text.should == "hello\n\nworld"
+  end
+  it "should enable fragment level direction setting" do
+    create_pdf
+    number_of_hellos = 18
+    array = [
+             { :text => "hello " * number_of_hellos },
+             { :text => "world", :direction => :ltr },
+             { :text => ", how are you?" }
+            ]
+    options = { :document => @pdf, :direction => :rtl }
+    text_box = Prawn::Text::Formatted::Box.new(array, options)
+    text_box.render
+    text = PDF::Inspector::Text.analyze(@pdf.render)
+    text.strings[0].should == "era woh ,"
+    text.strings[1].should == "world"
+    text.strings[2].should == " olleh" * number_of_hellos
+    text.strings[3].should == "?uoy"
+  end
+end
+
+describe "Text::Formatted::Box#render" do
+  it "should be able to perform fragment callbacks" do
+    create_pdf
+    callback_object = TestFragmentCallback.new("something", 7,
+                                               :document => @pdf)
+    callback_object.expects(:render_behind).with(
+                                      kind_of(Prawn::Text::Formatted::Fragment))
+    callback_object.expects(:render_in_front).with(
+                                      kind_of(Prawn::Text::Formatted::Fragment))
+    array = [{ :text => "hello world " },
+             { :text => "callback now",
+               :callback => callback_object }]
+    text_box = Prawn::Text::Formatted::Box.new(array, :document => @pdf)
+    text_box.render
+  end
+  it "should be able to perform fragment callbacks on multiple objects" do
+    create_pdf
+
+    callback_object = TestFragmentCallback.new("something", 7,
+                                               :document => @pdf)
+    callback_object.expects(:render_behind).with(
+                                      kind_of(Prawn::Text::Formatted::Fragment))
+    callback_object.expects(:render_in_front).with(
+                                      kind_of(Prawn::Text::Formatted::Fragment))
+
+    callback_object2 = TestFragmentCallback.new("something else", 14,
+                                               :document => @pdf)
+    callback_object2.expects(:render_behind).with(
+                                      kind_of(Prawn::Text::Formatted::Fragment))
+    callback_object2.expects(:render_in_front).with(
+                                      kind_of(Prawn::Text::Formatted::Fragment))
+
+    array = [{ :text => "hello world " },
+             { :text => "callback now",
+               :callback => [callback_object, callback_object2] }]
+    text_box = Prawn::Text::Formatted::Box.new(array, :document => @pdf)
+    text_box.render
+  end
+  it "fragment callbacks should be able to define only the callback they need" do
+    create_pdf
+    behind = TestFragmentCallbackBehind.new("something", 7,
+                                            :document => @pdf)
+    in_front = TestFragmentCallbackInFront.new("something", 7,
+                                               :document => @pdf)
+    array = [{ :text => "hello world " },
+             { :text => "callback now",
+               :callback => [behind, in_front] }]
+    text_box = Prawn::Text::Formatted::Box.new(array, :document => @pdf)
+
+    text_box.render # trigger callbacks
+  end
+  it "should be able to set the font" do
+    create_pdf
+    array = [{ :text => "this contains " },
+             { :text => "Times-Bold",
+               :styles => [:bold],
+               :font => "Times-Roman" },
+             { :text => " text" }]
+    text_box = Prawn::Text::Formatted::Box.new(array, :document => @pdf)
+    text_box.render
+    contents = PDF::Inspector::Text.analyze(@pdf.render)
+    fonts = contents.font_settings.map { |e| e[:name] }
+    fonts.should == [:Helvetica, :"Times-Bold", :Helvetica]
+    contents.strings[0].should == "this contains "
+    contents.strings[1].should == "Times-Bold"
+    contents.strings[2].should == " text"
+  end
+  it "should be able to set bold" do
+    create_pdf
+    array = [{ :text => "this contains " },
+             { :text => "bold", :styles => [:bold] },
+             { :text => " text" }]
+    text_box = Prawn::Text::Formatted::Box.new(array, :document => @pdf)
+    text_box.render
+    contents = PDF::Inspector::Text.analyze(@pdf.render)
+    fonts = contents.font_settings.map { |e| e[:name] }
+    fonts.should == [:Helvetica, :"Helvetica-Bold", :Helvetica]
+    contents.strings[0].should == "this contains "
+    contents.strings[1].should == "bold"
+    contents.strings[2].should == " text"
+  end
+  it "should be able to set italics" do
+    create_pdf
+    array = [{ :text => "this contains " },
+             { :text => "italic", :styles => [:italic] },
+             { :text => " text" }]
+    text_box = Prawn::Text::Formatted::Box.new(array, :document => @pdf)
+    text_box.render
+    contents = PDF::Inspector::Text.analyze(@pdf.render)
+    fonts = contents.font_settings.map { |e| e[:name] }
+    fonts.should == [:Helvetica, :"Helvetica-Oblique", :Helvetica]
+  end
+  it "should be able to set subscript" do
+    create_pdf
+    array = [{ :text => "this contains " },
+             { :text => "subscript", :size => 18, :styles => [:subscript] },
+             { :text => " text" }]
+    text_box = Prawn::Text::Formatted::Box.new(array, :document => @pdf)
+    text_box.render
+    contents = PDF::Inspector::Text.analyze(@pdf.render)
+    contents.font_settings[0][:size].should == 12
+    contents.font_settings[1][:size].should be_within(0.0001).of(18 * 0.583)
+  end
+  it "should be able to set superscript" do
+    create_pdf
+    array = [{ :text => "this contains " },
+             { :text => "superscript", :size => 18, :styles => [:superscript] },
+             { :text => " text" }]
+    text_box = Prawn::Text::Formatted::Box.new(array, :document => @pdf)
+    text_box.render
+    contents = PDF::Inspector::Text.analyze(@pdf.render)
+    contents.font_settings[0][:size].should == 12
+    contents.font_settings[1][:size].should be_within(0.0001).of(18 * 0.583)
+  end
+  it "should be able to set compound bold and italic text" do
+    create_pdf
+    array = [{ :text => "this contains " },
+             { :text => "bold italic", :styles => [:bold, :italic] },
+             { :text => " text" }]
+    text_box = Prawn::Text::Formatted::Box.new(array, :document => @pdf)
+    text_box.render
+    contents = PDF::Inspector::Text.analyze(@pdf.render)
+    fonts = contents.font_settings.map { |e| e[:name] }
+    fonts.should == [:Helvetica, :"Helvetica-BoldOblique", :Helvetica]
+  end
+  it "should be able to underline" do
+    create_pdf
+    array = [{ :text => "this contains " },
+             { :text => "underlined", :styles => [:underline] },
+             { :text => " text" }]
+    text_box = Prawn::Text::Formatted::Box.new(array, :document => @pdf)
+    text_box.render
+    line_drawing = PDF::Inspector::Graphics::Line.analyze(@pdf.render)
+    line_drawing.points.length.should == 2
+  end
+  it "should be able to strikethrough" do
+    create_pdf
+    array = [{ :text => "this contains " },
+             { :text => "struckthrough", :styles => [:strikethrough] },
+             { :text => " text" }]
+    text_box = Prawn::Text::Formatted::Box.new(array, :document => @pdf)
+    text_box.render
+    line_drawing = PDF::Inspector::Graphics::Line.analyze(@pdf.render)
+    line_drawing.points.length.should == 2
+  end
+  it "should be able to add URL links" do
+    create_pdf
+    @pdf.expects(:link_annotation).with(kind_of(Array), :Border => [0,0,0],
+           :A => { :Type => :Action, :S => :URI, :URI => "http://example.com" })
+    array = [{ :text => "click " },
+             { :text => "here", :link => "http://example.com" },
+             { :text => " to visit" }]
+    text_box = Prawn::Text::Formatted::Box.new(array, :document => @pdf)
+    text_box.render
+  end
+  it "should be able to add destination links" do
+    create_pdf
+    @pdf.expects(:link_annotation).with(kind_of(Array), :Border => [0,0,0],
+                                        :Dest => "ToC")
+    array = [{ :text => "Go to the " },
+             { :text => "Table of Contents", :anchor => "ToC" }]
+    text_box = Prawn::Text::Formatted::Box.new(array, :document => @pdf)
+    text_box.render
+  end
+  it "should be able to add local actions" do
+    create_pdf
+    @pdf.expects(:link_annotation).with(kind_of(Array), :Border => [0,0,0],
+           :A => { :Type => :Action, :S => :Launch, :F => "../example.pdf", :NewWindow => true })
+    array = [{ :text => "click " },
+             { :text => "here", :local => "../example.pdf" },
+             { :text => " to open a local file" }]
+    text_box = Prawn::Text::Formatted::Box.new(array, :document => @pdf)
+    text_box.render
+  end
+  it "should be able to set font size" do
+    create_pdf
+    array = [{ :text => "this contains " },
+             { :text => "sized", :size => 24 },
+             { :text => " text" }]
+    text_box = Prawn::Text::Formatted::Box.new(array, :document => @pdf)
+    text_box.render
+    contents = PDF::Inspector::Text.analyze(@pdf.render)
+    contents.font_settings[0][:size].should == 12
+    contents.font_settings[1][:size].should == 24
+  end
+  it "should set the baseline based on the tallest fragment on a given line" do
+    create_pdf
+    array = [{ :text => "this contains " },
+             { :text => "sized", :size => 24 },
+             { :text => " text" }]
+    text_box = Prawn::Text::Formatted::Box.new(array, :document => @pdf)
+    text_box.render
+    @pdf.font_size(24) do
+      text_box.height.should be_within(0.001).of(@pdf.font.ascender + @pdf.font.descender)
+    end
+  end
+  it "should be able to set color via an rgb hex string" do
+    create_pdf
+    array = [{ :text => "rgb",
+               :color => "ff0000" }]
+    text_box = Prawn::Text::Formatted::Box.new(array, :document => @pdf)
+    text_box.render
+    colors = PDF::Inspector::Graphics::Color.analyze(@pdf.render)
+    colors.fill_color_count.should == 2
+    colors.stroke_color_count.should == 2
+  end
+  it "should be able to set color using a cmyk array" do
+    create_pdf
+    array = [{ :text => "cmyk",
+               :color => [100, 0, 0, 0] }]
+    text_box = Prawn::Text::Formatted::Box.new(array, :document => @pdf)
+    text_box.render
+    colors = PDF::Inspector::Graphics::Color.analyze(@pdf.render)
+    colors.fill_color_count.should == 2
+    colors.stroke_color_count.should == 2
+  end
+end
+
+describe "Text::Formatted::Box#render(:dry_run => true)" do
+  it "should not change the graphics state of the document" do
+    create_pdf
+
+    state_before = PDF::Inspector::Graphics::Color.analyze(@pdf.render)
+    fill_color_count = state_before.fill_color_count
+    stroke_color_count = state_before.stroke_color_count
+    stroke_color_space_count = state_before.stroke_color_space_count
+
+    array = [{ :text => 'Foo',
+               :color => [0, 0, 0, 100] }]
+    options = { :document => @pdf }
+    text_box = Prawn::Text::Formatted::Box.new(array, options)
+    text_box.render(:dry_run => true)
+
+    state_after = PDF::Inspector::Graphics::Color.analyze(@pdf.render)
+    state_after.fill_color_count.should == fill_color_count
+    state_after.stroke_color_count.should == stroke_color_count
+    state_after.stroke_color_space_count.should == stroke_color_space_count
+  end
+end
+
+describe "Text::Formatted::Box#render with fragment level :character_spacing option" do
+  it "should draw the character spacing to the document" do
+    create_pdf
+    array = [{ :text => "hello world",
+               :character_spacing => 7 }]
+    options = { :document => @pdf }
+    text_box = Prawn::Text::Formatted::Box.new(array, options)
+    text_box.render
+    contents = PDF::Inspector::Text.analyze(@pdf.render)
+    contents.character_spacing[0].should == 7
+  end
+  it "should draw the character spacing to the document" do
+    create_pdf
+    array = [{ :text => "hello world",
+               :font => "Courier",
+               :character_spacing => 10 }]
+    options = { :document => @pdf,
+                :width => 100,
+                :overflow => :expand }
+    text_box = Prawn::Text::Formatted::Box.new(array, options)
+    text_box.render
+    text_box.text.should == "hello\nworld"
+  end
+end
+
+describe "Text::Formatted::Box#render with :align => :justify" do
+  it "should not justify the last line of a paragraph" do
+    create_pdf
+    array = [{ :text => "hello world " },
+             { :text => "\n" },
+             { :text => "goodbye" }]
+    options = { :document => @pdf, :align => :justify }
+    text_box = Prawn::Text::Formatted::Box.new(array, options)
+    text_box.render
+    contents = PDF::Inspector::Text.analyze(@pdf.render)
+    contents.word_spacing.should be_empty
+  end
+end
+
+describe "Text::Formatted::Box#render with :valign => :center" do
+  it "should have a bottom gap equal to baseline and bottom of box" do
+    create_pdf
+    box_height = 100
+    y = 450
+    array = [{ :text => 'Vertical Align' }]
+    options = {
+     :document => @pdf,
+     :valign => :center,
+     :at => [0,y],
+     :width => 100,
+     :height => box_height,
+     :size => 16
+    }
+    text_box = Prawn::Text::Formatted::Box.new(array, options)
+    text_box.render
+    line_padding = (box_height - text_box.height + text_box.descender) * 0.5
+    baseline = y - line_padding
+
+    text_box.at[1].should be_within(0.01).of(baseline)
+  end
+end
+
+describe "Text::Formatted::Box#render with :valign => :bottom" do
+  it "should not render a gap between the text and bottom of box" do
+    create_pdf
+    box_height = 100
+    y = 450
+    array = [{ :text => 'Vertical Align' }]
+    options = {
+     :document => @pdf,
+     :valign => :bottom,
+     :at => [0,y],
+     :width => 100,
+     :height => box_height,
+     :size => 16
+    }
+    text_box = Prawn::Text::Formatted::Box.new(array, options)
+    text_box.render
+    top_padding = y - (box_height - text_box.height)
+
+    text_box.at[1].should be_within(0.01).of(top_padding)
+  end
+end
+
+class TestFragmentCallback
+  def initialize(string, number, options)
+    @document = options[:document]
+  end
+
+  def render_behind(fragment)
+  end
+
+  def render_in_front(fragment)
+  end
+end
+
+class TestFragmentCallbackBehind
+  def initialize(string, number, options)
+    @document = options[:document]
+  end
+
+  def render_behind(fragment)
+  end
+end
+
+class TestFragmentCallbackInFront
+  def initialize(string, number, options)
+    @document = options[:document]
+  end
+
+  def render_in_front(fragment)
+  end
+end
+
+module TestFormattedWrapOverride
+  def wrap(array)
+    initialize_wrap([{ :text => 'all your base are belong to us' }])
+    line_to_print = @line_wrap.wrap_line(:document => @document,
+                                         :kerning => @kerning,
+                                         :width => 10000,
+                                         :arranger => @arranger)
+    fragment = @arranger.retrieve_fragment
+    format_and_draw_fragment(fragment, 0, @line_wrap.width, 0)
+
+    []
+  end
+end