prawn 0.11.1.pre → 0.11.1

data/spec/formatted_text_box_spec.rb

@@ -2,23 +2,256 @@
 
 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 Encoding::CompatibilityError when keeping a TTF and an " +
+    "AFM font together" do
+    ruby_19 do
+      file = "#{Prawn::BASEDIR}/data/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"))
+      lambda {
+        text_box.render
+      }.should.not.raise(Encoding::CompatibilityError)
+    end
+  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
+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::BASEDIR}/data/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::BASEDIR}/data/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::BASEDIR}/data/fonts/gkai00mp.ttf"
+    @pdf.font_families["Kai"] = {
+      :normal => { :file => file, :font => "Kai" }
+    }
+    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::BASEDIR}/data/fonts/gkai00mp.ttf"
+    @pdf.font_families["Kai"] = {
+      :normal => { :file => file, :font => "Kai" }
+    }
+    @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.formatted_text_box(@formatted_text, :fallback_fonts => ["Courier"])
+
+    text = PDF::Inspector::Text.analyze(@pdf.render)
+
+    fonts_used = text.font_settings.map { |e| e[:name] }
+    fonts_used.length.should == 1
+    fonts_used[0].should == :"Helvetica"
+  end
+  it "should omit the fallback fonts overhead when passing an empty array " +
+    "as the :fallback_fonts" do
+    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)
+    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 use the primary font" do
+    create_pdf
+    formatted_text = [{ :text => "hello world. 世界你好。" }]
+    @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 == 1
+    fonts_used[0].should == :"Helvetica"
+  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"
-    Prawn::Text::Formatted::Box.extensions.delete(TestFormattedWrapOverride)
   end
-  it "overriding Text::Box line wrapping should not affect " +
-     "Text::Formatted::Box wrapping" do
+  it "overriding Text::Formatted::Box line wrapping should not affect " +
+     "Text::Box wrapping" do
     create_pdf
-    Prawn::Text::Box.extensions << TestWrapOverride
-    @pdf.formatted_text_box([{ :text => "hello world" }], {})
+    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"
-    Prawn::Text::Box.extensions.delete(TestWrapOverride)
+  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
 
@@ -39,97 +272,40 @@ describe "Text::Formatted::Box#render" do
     text_box.render
     text_box.text.should == "hello\nworld"
   end
-  it "should omit spaces from the end of the line" 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 be okay printing a line of whitespace" do
     create_pdf
-    array = [{ :text => "hello\n    \nworld "}]
+    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"
-  end
-end
 
-describe "Text::Formatted::Box#render with :align => :justify" do
-  it "should draw the word spacing to the document" do
-    create_pdf
-    array = [{ :text => "hello world " * 10}]
-    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[0].should.be > 0
-  end
-end
 
-describe "Text::Formatted::Box#height without leading" do
-  it "should equal the sum of the height of each line" do
-    create_pdf
-    format_array = [{ :text => "line 1" },
-                    { :text => "\n" },
-                    { :text => "line 2" }]
+    array = [{ :text => "hello" + " " * 500},
+             { :text => " " * 500 },
+             { :text => " " * 500 + "\n"},
+             { :text => "world"}]
     options = { :document => @pdf }
-    text_box = Prawn::Text::Formatted::Box.new(format_array, options)
-    text_box.render
-    text_box.height.should == @pdf.font.height * 2
-  end
-end
-
-describe "Text::Formatted::Box#height with leading" do
-  it "should equal the sum of the height of each line" +
-     " plus all but the last leading" do
-    create_pdf
-    format_array = [{ :text => "line 1" },
-                    { :text => "\n" },
-                    { :text => "line 2" }]
-    leading = 12
-    options = { :document => @pdf, :leading => leading }
-    text_box = Prawn::Text::Formatted::Box.new(format_array, options)
+    text_box = Prawn::Text::Formatted::Box.new(array, options)
     text_box.render
-    text_box.height.should == @pdf.font.height * 2 + leading
+    text_box.text.should == "hello\n\nworld"
   end
-end
-
-describe "Text::Formatted::Box#render(:single_line => true)" do
-  it "should draw only one line to the page" do
+  it "should enable fragment level direction setting" do
     create_pdf
-    text = "Oh hai text rect. " * 10
-    format_array = [:text => text]
-    options = { :document => @pdf,
-                 :single_line => true }
-    text_box = Prawn::Text::Formatted::Box.new(format_array, options)
+    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
-    contents = PDF::Inspector::Text.analyze(@pdf.render)
-    contents.strings.length.should == 1
-  end
-end
-
-describe "Text::Formatted::Box#render(:dry_run => true)" do
-  it "should not draw any content to the page" do
-    create_pdf
-    text = "Oh hai text rect. " * 10
-    format_array = [:text => text]
-    options = { :document => @pdf }
-    text_box = Prawn::Text::Formatted::Box.new(format_array, options)
-    text_box.render(:dry_run => true)
-    contents = PDF::Inspector::Text.analyze(@pdf.render)
-    contents.strings.should.be.empty
-  end
-  it "subsequent calls to render should not raise an ArgumentError exception" do
-    create_pdf
-    text = "™©"
-    format_array = [:text => text]
-    options = { :document => @pdf }
-    text_box = Prawn::Text::Formatted::Box.new(format_array, options)
-    text_box.render(:dry_run => true)
-    lambda { text_box.render }.should.not.raise(ArgumentError)
+    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
 
@@ -227,24 +403,24 @@ describe "Text::Formatted::Box#render" do
   it "should be able to set subscript" do
     create_pdf
     array = [{ :text => "this contains " },
-             { :text => "subscript", :styles => [:subscript] },
+             { :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.close(12 * 0.583, 0.0001)
+    contents.font_settings[1][:size].should.be.close(18 * 0.583, 0.0001)
   end
   it "should be able to set superscript" do
     create_pdf
     array = [{ :text => "this contains " },
-             { :text => "superscript", :styles => [:superscript] },
+             { :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.close(12 * 0.583, 0.0001)
+    contents.font_settings[1][:size].should.be.close(18 * 0.583, 0.0001)
   end
   it "should be able to set compound bold and italic text" do
     create_pdf
@@ -315,7 +491,7 @@ describe "Text::Formatted::Box#render" do
     text_box = Prawn::Text::Formatted::Box.new(array, :document => @pdf)
     text_box.render
     @pdf.font_size(24) do
-      text_box.height.should.be.close(@pdf.font.height, 0.001)
+      text_box.height.should.be.close(@pdf.font.ascender + @pdf.font.descender, 0.001)
     end
   end
   it "should be able to set color via an rgb hex string" do
@@ -325,8 +501,8 @@ describe "Text::Formatted::Box#render" do
     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 == 3
-    colors.stroke_color_count.should == 3
+    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
@@ -335,210 +511,8 @@ describe "Text::Formatted::Box#render" do
     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 == 3
-    colors.stroke_color_count.should == 3
-  end
-end
-
-describe "Text::Formatted::Box with text than can fit in the box" do
-  before(:each) do
-    create_pdf
-    @text = "Oh hai text rect. " * 10
-    @format_array = [:text => @text]
-    @options = {
-      :width => 162.0,
-      :height => 162.0,
-      :document => @pdf
-    }
-  end
-  
-  it "printed text should match requested text, except for trailing or" +
-     " leading white space and that spaces may be replaced by newlines" do
-    text_box = Prawn::Text::Formatted::Box.new(@format_array, @options)
-    text_box.render
-    text_box.text.gsub("\n", " ").should == @text.strip
-  end
-  
-  it "render should return an empty array because no text remains unprinted" do
-    text_box = Prawn::Text::Formatted::Box.new(@format_array, @options)
-    text_box.render.should == []
-  end
-
-  it "should be truncated when the leading is set high enough to prevent all" +
-     " the lines from being printed" do
-    @options[:leading] = 40
-    text_box = Prawn::Text::Formatted::Box.new(@format_array, @options)
-    text_box.render
-    text_box.text.gsub("\n", " ").should.not == @text.strip
-  end
-end
-
-describe "Text::Formatted::Box printing UTF-8 string with higher bit characters with" +
-         " inline styling" do
-  before(:each) do
-    create_pdf    
-    @text = "©"
-    format_array = [:text => @text]
-    # 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
-    }
-    @text_box = Prawn::Text::Formatted::Box.new(format_array, options)
-  end
-  describe "when using a TTF font" do
-    before(:each) do
-      file = "#{Prawn::BASEDIR}/data/fonts/Action Man.dfont"
-      @pdf.font_families["Action Man"] = {
-        :normal      => { :file => file, :font => "ActionMan" },
-        :italic      => { :file => file, :font => "ActionMan-Italic" },
-        :bold        => { :file => file, :font => "ActionMan-Bold" },
-        :bold_italic => { :file => file, :font => "ActionMan-BoldItalic" }
-      }
-    end
-    it "unprinted text should be in UTF-8 encoding" do
-      @pdf.font("Action Man")
-      remaining_text = @text_box.render
-      remaining_text.first[:text].should == @text
-    end
-    it "subsequent calls to Text::Formatted::Box need not include the" +
-       " :skip_encoding => true option" do
-      @pdf.font("Action Man")
-      remaining_text = @text_box.render
-      lambda {
-        @pdf.formatted_text_box(remaining_text, :document => @pdf)
-      }.should.not.raise(ArgumentError)
-    end
-  end
-  describe "when using an AFM font" do
-    it "unprinted text should be in WinAnsi encoding" do
-      remaining_text = @text_box.render
-      remaining_text.first[:text].should == @pdf.font.normalize_encoding(@text)
-    end
-    it "subsequent calls to Text::Formatted::Box must include the" +
-       " :skip_encoding => true option" do
-      remaining_text = @text_box.render
-      lambda {
-        @pdf.formatted_text_box(remaining_text, :document => @pdf)
-      }.should.raise(ArgumentError)
-      lambda {
-        @pdf.formatted_text_box(remaining_text, :document => @pdf,
-                                :skip_encoding => true)
-      }.should.not.raise(ArgumentError)
-    end
-  end
-end
-          
-
-describe "Text::Formatted::Box with more text than can fit in the box" do
-  before(:each) do
-    create_pdf    
-    @text = "Oh hai text rect. " * 30
-    @format_array = [:text => @text]
-    @bounding_height = 162.0
-    @options = {
-      :width => 162.0,
-      :height => @bounding_height,
-      :document => @pdf
-    }
-  end
-
-  context "truncated overflow" do
-    before(:each) do
-      @options[:overflow] = :truncate
-      @text_box = Prawn::Text::Formatted::Box.new(@format_array, @options)
-    end
-    it "should be truncated" do
-      @text_box.render
-      @text_box.text.gsub("\n", " ").should.not == @text.strip
-    end
-    it "render should not return an empty string because some text remains" +
-      " unprinted" do
-      @text_box.render.should.not == ""
-    end
-    it "#height should be no taller than the specified height" do
-      @text_box.render
-      @text_box.height.should.be <= @bounding_height
-    end
-    it "#height should be within one font height of the specified height" do
-      @text_box.render
-      @text_box.height.should.be.close(@bounding_height, @pdf.font.height)
-    end
-  end
-  
-  context "ellipses overflow" do
-    it "should raise NotImplementedError" do
-      @options[:overflow] = :ellipses
-      lambda {
-        Prawn::Text::Formatted::Box.new(@format_array, @options)
-      }.should.raise(NotImplementedError)
-    end
-  end
-
-  context "expand overflow" do
-    before(:each) do
-      @options[:overflow] = :expand
-      @text_box = Prawn::Text::Formatted::Box.new(@format_array, @options)
-    end
-    it "height should expand to encompass all the text (but not exceed the" +
-      "height of the page)" do
-      @text_box.render
-      @text_box.height.should > @bounding_height
-    end
-    it "should display the entire string (as long as there was space" +
-      " remaining on the page to print all the text)" do
-      @text_box.render
-      @text_box.text.gsub("\n", " ").should == @text.strip
-    end
-    it "render should return an empty array because no text remains" +
-      " unprinted(as long as there was space remaining on the page to" +
-      " print all the text)" do
-      @text_box.render.should == []
-    end
-  end
-
-  context "shrink_to_fit overflow" do
-    before(:each) do
-      @options[:overflow] = :shrink_to_fit
-      @options[:min_font_size] = 2
-      @text_box = Prawn::Text::Formatted::Box.new(@format_array, @options)
-    end
-    it "should display the entire text" do
-      @text_box.render
-      @text_box.text.gsub("\n", " ").should == @text.strip
-    end
-    it "render should return an empty array because no text" +
-      " remains unprinted" do
-      @text_box.render.should == []
-    end
-  end
-end
-
-describe "Text::Formatted::Box#render with box level :character_spacing option" do
-  it "should draw the character spacing to the document only one time" do
-    create_pdf
-    array = [{ :text => "hello world" }]
-    options = { :document => @pdf,
-                :character_spacing => 7 }
-    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
-    contents.character_spacing.length.should == 2
-  end
-  it "should draw the character spacing to the document" do
-    create_pdf
-    array = [{ :text => "hello world",
-               :font => "Courier" }]
-    options = { :document => @pdf,
-                :width => 100,
-                :overflow => :expand,
-                :character_spacing => 10 }
-    text_box = Prawn::Text::Formatted::Box.new(array, options)
-    text_box.render
-    text_box.text.should == "hello\nworld"
+    colors.fill_color_count.should == 2
+    colors.stroke_color_count.should == 2
   end
 end
 
@@ -567,138 +541,18 @@ describe "Text::Formatted::Box#render with fragment level :character_spacing opt
   end
 end
 
-describe "Text::Formatted::Box wrapping" do
-  before(:each) do
+describe "Text::Formatted::Box#render with :align => :justify" do
+  it "should not justify the last line of a paragraph" do
     create_pdf
-  end
-
-  it "should wrap text" do
-    text = "Please wrap this text about HERE. More text that should be wrapped"
-    format_array = [:text => text]
-    expect = "Please wrap this text about\nHERE. " +
-      "More text that should be\nwrapped"
-
-    @pdf.font "Courier"
-    text_box = Prawn::Text::Formatted::Box.new(format_array,
-                                             :width    => 220,
-                                             :overflow => :expand,
-                                             :document => @pdf)
-    text_box.render
-    text_box.text.should == expect
-  end
-
-  it "should respect end of line when wrapping text" do
-    text = "Please wrap only before\nTHIS word. Don't wrap this"
-    format_array = [:text => text]
-    expect = text
-
-    @pdf.font "Courier"
-    text_box = Prawn::Text::Formatted::Box.new(format_array,
-                                             :width    => 220,
-                                             :overflow => :expand,
-                                             :document => @pdf)
-    text_box.render
-    text_box.text.should == expect
-  end
-
-  it "should respect multiple newlines when wrapping text" do
-    text = "Please wrap only before THIS\n\nword. Don't wrap this"
-    format_array = [:text => text]
-    expect= "Please wrap only before\nTHIS\n\nword. Don't wrap this"
-
-    @pdf.font "Courier"
-    text_box = Prawn::Text::Formatted::Box.new(format_array,
-                                             :width    => 200,
-                                             :overflow => :expand,
-                                             :document => @pdf)
-    text_box.render
-    text_box.text.should == expect
-  end
-
-  it "should respect 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"
-    format_array = [:text => text]
-    expect = text
-
-    @pdf.font "Courier"
-    text_box = Prawn::Text::Formatted::Box.new(format_array,
-                                             :width    => 220,
-                                             :overflow => :expand,
-                                             :document => @pdf)
-    text_box.render
-    text_box.text.should == expect
-  end
-
-  it "should respect initial newlines" do
-    text = "\nThis should be on line 2"
-    format_array = [:text => text]
-    expect = text
-
-    @pdf.font "Courier"
-    text_box = Prawn::Text::Formatted::Box.new(format_array,
-                                             :width    => 220,
-                                             :overflow => :expand,
-                                             :document => @pdf)
-    text_box.render
-    text_box.text.should == expect
-  end
-
-  it "should wrap lines comprised of a single word of the bounds when" +
-    " wrapping text" do
-    text = "You_can_wrap_this_text_HERE"
-    format_array = [:text => text]
-    expect = "You_can_wrap_this_text_HE\nRE"
-
-    @pdf.font "Courier"
-    text_box = Prawn::Text::Formatted::Box.new(format_array,
-                                             :width    => 180,
-                                             :overflow => :expand,
-                                             :document => @pdf)
-    text_box.render
-    text_box.text.should == expect
-  end
-
-  it "should wrap lines comprised of a single word of the bounds when" +
-    " wrapping text" do
-    text = "©" * 30
-    format_array = [:text => text]
-
-    @pdf.font "Courier"
-    text_box = Prawn::Text::Formatted::Box.new(format_array, :width => 180,
-                                             :overflow => :expand,
-                                             :document => @pdf)
-
-    text_box.render
-
-    expected = "©" * 25 + "\n" + "©" * 5
-    @pdf.font.normalize_encoding!(expected)
-
-    text_box.text.should == expected
-  end
-
-  it "should wrap non-unicode strings using single-byte word-wrapping" do
-    text = "continúa esforzandote " * 5
-    format_array = [:text => text]
-    text_box = Prawn::Text::Formatted::Box.new(format_array, :width => 180,
-                                             :document => @pdf)
-    text_box.render
-    results_with_accent = text_box.text
-
-    text = "continua esforzandote " * 5
-    format_array = [:text => text]
-    text_box = Prawn::Text::Formatted::Box.new(format_array, :width => 180,
-                                             :document => @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
-    no_accent = text_box.text
-
-    results_with_accent.first_line.length.should == no_accent.first_line.length
+    contents = PDF::Inspector::Text.analyze(@pdf.render)
+    contents.word_spacing.should.be.empty
   end
-  
-end
-
-def reduce_precision(float)
-  ("%.5f" % float).to_f
 end
 
 class TestFragmentCallback
@@ -732,25 +586,15 @@ class TestFragmentCallbackInFront
 end
 
 module TestFormattedWrapOverride
-  def wrap(string)
-    @text = nil
-    @line_height = @document.font.height
-    @descender   = @document.font.descender
-    @ascender    = @document.font.ascender
-    @baseline_y  = -@ascender
-    draw_line("all your base are belong to us")
-    []
-  end
-end
+  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)
 
-module TestWrapOverride
-  def wrap(string)
-    @text = nil
-    @line_height = @document.font.height
-    @descender   = @document.font.descender
-    @ascender    = @document.font.ascender
-    @baseline_y  = -@ascender
-    draw_line("all your base are belong to us")
-    ""
+    []
   end
 end