prawn 0.11.1.pre → 0.11.1

data/spec/formatted_text_fragment_spec.rb

@@ -2,6 +2,59 @@
 
 require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
 
+describe "Text::Formatted::Fragment#space_count" do
+  it "should return the number of spaces in the fragment" do
+    create_pdf
+    format_state = { }
+    fragment = Prawn::Text::Formatted::Fragment.new("hello world ",
+                                                     format_state,
+                                                     @pdf)
+    fragment.space_count.should == 2
+  end
+  it "should exclude trailing spaces from the count when " +
+    ":exclude_trailing_white_space => true" do
+    create_pdf
+    format_state = { :exclude_trailing_white_space => true }
+    fragment = Prawn::Text::Formatted::Fragment.new("hello world ",
+                                                     format_state,
+                                                     @pdf)
+    fragment.space_count.should == 1
+  end
+end
+
+describe "Text::Formatted::Fragment#include_trailing_white_space!" do
+  it "should make the fragment include trailing white space" do
+    create_pdf
+    format_state = { :exclude_trailing_white_space => true }
+    fragment = Prawn::Text::Formatted::Fragment.new("hello world ",
+                                                     format_state,
+                                                     @pdf)
+    fragment.space_count.should == 1
+    fragment.include_trailing_white_space!
+    fragment.space_count.should == 2
+  end
+end
+
+describe "Text::Formatted::Fragment#text" do
+  it "should return the fragment text" do
+    create_pdf
+    format_state = { }
+    fragment = Prawn::Text::Formatted::Fragment.new("hello world ",
+                                                     format_state,
+                                                     @pdf)
+    fragment.text.should == "hello world "
+  end
+  it "should return the fragment text without trailing spaces when " +
+    ":exclude_trailing_white_space => true" do
+    create_pdf
+    format_state = { :exclude_trailing_white_space => true }
+    fragment = Prawn::Text::Formatted::Fragment.new("hello world ",
+                                                     format_state,
+                                                     @pdf)
+    fragment.text.should == "hello world"
+  end
+end
+
 describe "Text::Formatted::Fragment#word_spacing=" do
   before(:each) do
     create_pdf
@@ -209,3 +262,37 @@ describe "Text::Formatted::Fragment that is a superscript" do
     end
   end
 end
+
+describe "Text::Formatted::Fragment with :direction => :rtl" do
+  it "#text should be reversed" do
+    create_pdf
+    format_state = { :direction => :rtl }
+    fragment = Prawn::Text::Formatted::Fragment.new("hello world",
+                                                     format_state,
+                                                     @pdf)
+    fragment.text.should == "dlrow olleh"
+  end
+end
+
+describe "Text::Formatted::Fragment default_direction=" do
+  it "should set the direction if there is no fragment level direction " +
+     "specification" do
+    create_pdf
+    format_state = { }
+    fragment = Prawn::Text::Formatted::Fragment.new("hello world",
+                                                     format_state,
+                                                     @pdf)
+    fragment.default_direction = :rtl
+    fragment.direction.should == :rtl
+  end
+  it "should not set the direction if there is a fragment level direction " +
+     "specification" do
+    create_pdf
+    format_state = { :direction => :rtl }
+    fragment = Prawn::Text::Formatted::Fragment.new("hello world",
+                                                     format_state,
+                                                    @pdf)
+    fragment.default_direction = :ltr
+    fragment.direction.should == :rtl
+  end
+end

data/spec/graphics_spec.rb

@@ -159,7 +159,7 @@ end
 describe "When drawing an ellipse" do
   before(:each) do
     create_pdf
-    @pdf.ellipse_at [100,100], 25, 50
+    @pdf.ellipse [100,100], 25, 50
     @curve = PDF::Inspector::Graphics::Curve.analyze(@pdf.render)
   end
 
@@ -172,8 +172,8 @@ end
 describe "When drawing a circle" do
   before(:each) do
     create_pdf
-    @pdf.circle_at [100,100], :radius => 25
-    @pdf.ellipse_at [100,100], 25, 25
+    @pdf.circle [100,100], 25
+    @pdf.ellipse [100,100], 25, 25
     @curve = PDF::Inspector::Graphics::Curve.analyze(@pdf.render)
   end
 
@@ -203,26 +203,68 @@ describe "When setting colors" do
 
   it "should reset the colors on each new page if they have been defined" do
     @pdf.fill_color "ccff00"
-    colors = PDF::Inspector::Graphics::Color.analyze(@pdf.render)
+    #colors = PDF::Inspector::Graphics::Color.analyze(@pdf.render)
 
-    colors.fill_color_count.should == 2
-    colors.stroke_color_count.should == 1
+    # colors.fill_color_count.should == 2
+    # colors.stroke_color_count.should == 1
     @pdf.start_new_page
     @pdf.stroke_color "ff00cc"
 
-    colors = PDF::Inspector::Graphics::Color.analyze(@pdf.render)
-    colors.fill_color_count.should == 3
-    colors.stroke_color_count.should == 3
+    #colors = PDF::Inspector::Graphics::Color.analyze(@pdf.render)
+    # colors.fill_color_count.should == 3
 
     @pdf.start_new_page
     colors = PDF::Inspector::Graphics::Color.analyze(@pdf.render)
-    colors.fill_color_count.should == 4
-    colors.stroke_color_count.should == 4
+    colors.fill_color_count.should == 3
+    colors.stroke_color_count.should == 2
 
     colors.fill_color.should   == [0.8,1.0,0.0]
     colors.stroke_color.should == [1.0,0.0,0.8]
   end
+  
+  it "should set the color space when setting colors on new pages to please fussy readers" do
+    @pdf.stroke_color "000000"
+    @pdf.stroke { @pdf.rectangle([10, 10], 10, 10) }
+    @pdf.start_new_page
+    @pdf.stroke_color "000000"
+    @pdf.stroke { @pdf.rectangle([10, 10], 10, 10) }
+    colors = PDF::Inspector::Graphics::Color.analyze(@pdf.render)
+    colors.stroke_color_space_count[:DeviceRGB].should == 2
+  end
+end
+
+describe "Gradients" do
+  before(:each) { create_pdf }
+
+  it "should create a /Pattern resource" do
+    @pdf.fill_gradient [0, @pdf.bounds.height],
+      @pdf.bounds.width, @pdf.bounds.height, 'FF0000', '0000FF'
+
+    grad = PDF::Inspector::Graphics::Pattern.analyze(@pdf.render)
+    pattern = grad.patterns[:SP1]
+
+    pattern.should.not.be.nil
+    assert pattern[:Shading][:Function][:C0].zip([1, 0, 0]).
+      all?{ |x1, x2| (x1-x2).abs < 0.01 }
+    assert pattern[:Shading][:Function][:C1].zip([0, 0, 1]).
+      all?{ |x1, x2| (x1-x2).abs < 0.01 }
+  end
+
+  it "fill_gradient should set fill color to the pattern" do
+    @pdf.fill_gradient [0, @pdf.bounds.height],
+      @pdf.bounds.width, @pdf.bounds.height, 'FF0000', '0000FF'
+
+    str = @pdf.render
+    str.should =~ %r{/Pattern\s+cs\s*/SP1\s+scn}
+  end
 
+  it "stroke_gradient should set stroke color to the pattern" do
+    @pdf.stroke_gradient [0, @pdf.bounds.height],
+      @pdf.bounds.width, @pdf.bounds.height, 'FF0000', '0000FF'
+
+    str = @pdf.render
+    str.should =~ %r{/Pattern\s+CS\s*/SP1\s+SCN}
+  end
 end
 
 describe "When using painting shortcuts" do
@@ -256,7 +298,7 @@ describe "When using graphics states" do
     
     @pdf.save_graphics_state
   end
-
+  
   it "should add the right content on restore_graphics_state" do
     @pdf.expects(:add_content).with('Q')
     
@@ -273,6 +315,80 @@ describe "When using graphics states" do
       @pdf.foo
     end
   end
+  
+  it "should add the previous color space when restoring to a graphic state with different color space" do
+    @pdf.stroke_color '000000'
+    @pdf.save_graphics_state
+    @pdf.stroke_color 0, 0, 0, 0
+    @pdf.restore_graphics_state 
+    @pdf.stroke_color 0, 0, 100, 0
+    @pdf.graphic_state.color_space.should == {:stroke=>:DeviceCMYK}
+    colors = PDF::Inspector::Graphics::Color.analyze(@pdf.render)
+    colors.color_space.should == :DeviceCMYK
+    colors.stroke_color_space_count[:DeviceCMYK].should == 2
+  end
+  
+  it "should use the correct dash setting after restoring and starting new page" do
+    @pdf.dash 5
+    @pdf.save_graphics_state
+    @pdf.dash 10
+    @pdf.graphic_state.dash[:dash].should == 10
+    @pdf.restore_graphics_state 
+    @pdf.start_new_page
+    @pdf.graphic_state.dash[:dash].should == 5
+  end
+  
+  it "the current graphic state should keep track of previous unchanged settings" do
+    @pdf.stroke_color '000000'
+    @pdf.save_graphics_state
+    @pdf.dash 5
+    @pdf.save_graphics_state
+    @pdf.cap_style :round
+    @pdf.save_graphics_state 
+    @pdf.fill_color 0, 0, 100, 0
+    @pdf.save_graphics_state
+    
+    @pdf.graphic_state.stroke_color.should == "000000" 
+    @pdf.graphic_state.join_style.should == :miter
+    @pdf.graphic_state.fill_color.should == [0, 0, 100, 0] 
+    @pdf.graphic_state.cap_style.should == :round 
+    @pdf.graphic_state.color_space.should == {:fill=>:DeviceCMYK, :stroke=>:DeviceRGB} 
+    @pdf.graphic_state.dash.should == {:space=>5, :phase=>0, :dash=>5}
+    @pdf.graphic_state.line_width.should == 1
+  end
+    
+    
+  
+  it "should not add extra graphic space closings when rendering multiple times" do
+    @pdf.render
+    state = PDF::Inspector::Graphics::State.analyze(@pdf.render)
+    state.save_graphics_state_count.should == 1
+    state.restore_graphics_state_count.should == 1
+  end
+  
+  it "should add extra graphic state enclosings when content is added on multiple renderings" do
+    @pdf.render
+    @pdf.text "Adding a bit more content"
+    state = PDF::Inspector::Graphics::State.analyze(@pdf.render)
+    state.save_graphics_state_count.should == 2
+    state.restore_graphics_state_count.should == 2
+  end
+  
+  it "adds extra graphic state enclosings when new settings are applied on multiple renderings" do
+    @pdf.render
+    @pdf.stroke_color 0, 0, 0, 0
+    state = PDF::Inspector::Graphics::State.analyze(@pdf.render)
+    state.save_graphics_state_count.should == 2
+    state.restore_graphics_state_count.should == 2
+  end
+    
+  
+  it "should raise error if closing an empty graphic stack" do
+    assert_raise Prawn::Errors::EmptyGraphicStateStack do
+      @pdf.render
+      @pdf.restore_graphics_state
+    end
+  end
 end
 
 describe "When using transformation matrix" do

data/spec/grid_spec.rb

@@ -67,7 +67,7 @@ describe "A document's grid" do
       
       # Hardcoded default color as I haven't been able to come up with a stable converter
       # between fill_color without lots code.
-      colors.fill_color.should   == [0.0,0.0,0.0]
+      #colors.fill_color.should   == [0.0,0.0,0.0]
       colors.stroke_color.should == [0.0,0.0,0.0]
     end
 

data/spec/images_spec.rb

@@ -1,6 +1,8 @@
 # encoding: utf-8
 
 require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")  
+require 'set'
+require 'pathname'
 
 describe "the image() function" do
 
@@ -36,6 +38,11 @@ describe "the image() function" do
     info.height.should == 453
   end
 
+  it "should accept Pathname objects" do
+    info = @pdf.image(Pathname.new(@filename))
+    info.height.should == 453
+  end
+
   it "should raise an UnsupportedImageType if passed a BMP" do
     filename = "#{Prawn::BASEDIR}/data/images/tru256.bmp"
     lambda { @pdf.image filename, :at => [100,100] }.should.raise(Prawn::Errors::UnsupportedImageType)
@@ -67,7 +74,7 @@ describe "the image() function" do
     @pdf.image @filename, :fit => [600, 600]
     @pdf.image @filename, :fit => [600, 600]
     output = StringIO.new(@pdf.render, 'r+')
-    hash = PDF::Hash.new(output)
+    hash = PDF::Reader::ObjectHash.new(output)
     pages = hash.values.find {|obj| obj.is_a?(Hash) && obj[:Type] == :Pages}[:Kids]
     pages.size.should == 2 
     hash[pages[0]][:Resources][:XObject].keys.should == [:I1]
@@ -78,10 +85,11 @@ describe "the image() function" do
     @pdf.image @filename, :fit => [400, 400]
     @pdf.image @filename, :fit => [400, 400]
     output = StringIO.new(@pdf.render, 'r+')
-    hash = PDF::Hash.new(output)
+    hash = PDF::Reader::ObjectHash.new(output)
     pages = hash.values.find {|obj| obj.is_a?(Hash) && obj[:Type] == :Pages}[:Kids]
     pages.size.should == 1 
-    hash[pages[0]][:Resources][:XObject].keys.should == [:I1, :I2] 
+    Set.new(hash[pages[0]][:Resources][:XObject].keys).should ==
+      Set.new([:I1, :I2])
   end
   
   describe ":fit option" do

data/spec/inline_formatted_text_parser_spec.rb

@@ -499,4 +499,12 @@ describe "Text::Formatted::Parser#array_paragraphs" do
                { :text => "you" }]]
     Prawn::Text::Formatted::Parser.array_paragraphs(array).should == target
   end
+
+  it "should work properly if ending in an empty paragraph" do
+    array = [{ :text => "\nhello\nworld\n" }]
+    target = [[{ :text => "\n" }],
+              [{ :text => "hello" }],
+              [{ :text => "world" }]]
+    Prawn::Text::Formatted::Parser.array_paragraphs(array).should == target
+  end
 end

data/spec/line_wrap_spec.rb

@@ -2,289 +2,231 @@
 
 require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
 
-describe "Core::Text::LineWrap#wrap_line" do
+describe "Core::Text::Formatted::LineWrap#wrap_line" do
   before(:each) do
     create_pdf
-    @line_wrap = Prawn::Core::Text::LineWrap.new
+    @arranger = Prawn::Core::Text::Formatted::Arranger.new(@pdf)
+    @line_wrap = Prawn::Core::Text::Formatted::LineWrap.new
+    @one_word_width = 50
   end
-  it "should strip preceding and trailing spaces" do
-    string = @line_wrap.wrap_line("    hello world    ",
+  it "should strip leading and trailing spaces" do
+    array = [{ :text => " hello world, " },
+             { :text => "goodbye  ", :style => [:bold] }]
+    @arranger.format_array = array
+    string = @line_wrap.wrap_line(:arranger => @arranger,
                                  :width => 300,
                                  :document => @pdf)
-    string.should == "hello world"
+    string.should == "hello world, goodbye"
+  end
+  it "should strip trailing spaces when a white-space-only fragment was" +
+     " successfully pushed onto the end of a line but no other non-white" +
+     " space fragment fits after it" do
+    array = [{ :text => "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa " },
+             { :text => "  ", :style => [:bold] },
+             { :text => " bbbbbbbbbbbbbbbbbbbbbbbbbbbb" }]
+    @arranger.format_array = array
+    string = @line_wrap.wrap_line(:arranger => @arranger,
+                                 :width => 300,
+                                 :document => @pdf)
+    string.should == "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
   end
-
   it "should raise CannotFit if a too-small width is given" do
+    array = [{ :text => " hello world, " },
+             { :text => "goodbye  ", :style => [:bold] }]
+    @arranger.format_array = array
     lambda do
-      @line_wrap.wrap_line("    hello world    ",
-                          :width => 1,
-                          :document => @pdf)
+      @line_wrap.wrap_line(:arranger => @arranger,
+                           :width => 1,
+                           :document => @pdf)
     end.should.raise(Prawn::Errors::CannotFit)
   end
-end
 
-describe "Core::Text::LineWrap#wrap_line" do
-  before(:each) do
-    create_pdf
-    @line_wrap = Prawn::Core::Text::LineWrap.new
-    @one_word_width = 50
-  end
   it "should break on space" do
-    normalized_string = @pdf.font.normalize_encoding("hello world")
-    string = @line_wrap.wrap_line(normalized_string,
-                                 :width => @one_word_width,
-                                 :document => @pdf)
+    array = [{ :text => "hello world" }]
+    @arranger.format_array = array
+    string = @line_wrap.wrap_line(:arranger => @arranger,
+                                  :width => @one_word_width,
+                                  :document => @pdf)
+    string.should == "hello"
+  end
+
+  it "should break on zero-width space" do
+    @pdf.font("#{Prawn::BASEDIR}/data/fonts/DejaVuSans.ttf")
+    array = [{ :text => "hello#{Prawn::Text::ZWSP}world" }]
+    @arranger.format_array = array
+    string = @line_wrap.wrap_line(:arranger => @arranger,
+                                  :width => @one_word_width,
+                                  :document => @pdf)
     string.should == "hello"
   end
 
+  it "should not display zero-width space" do
+    @pdf.font("#{Prawn::BASEDIR}/data/fonts/DejaVuSans.ttf")
+    array = [{ :text => "hello#{Prawn::Text::ZWSP}world" }]
+    @arranger.format_array = array
+    string = @line_wrap.wrap_line(:arranger => @arranger,
+                                  :width => 300,
+                                  :document => @pdf)
+    string.should == "helloworld"
+  end
+
   it "should break on tab" do
-    normalized_string = @pdf.font.normalize_encoding("hello\tworld")
-    string = @line_wrap.wrap_line(normalized_string,
-                                 :width => @one_word_width,
-                                 :document => @pdf)
+    array = [{ :text => "hello\tworld" }]
+    @arranger.format_array = array
+    string = @line_wrap.wrap_line(:arranger => @arranger,
+                                  :width => @one_word_width,
+                                  :document => @pdf)
     string.should == "hello"
   end
 
   it "should break on hyphens" do
-    normalized_string = @pdf.font.normalize_encoding("hello-world")
-    string = @line_wrap.wrap_line(normalized_string,
-                                 :width => @one_word_width,
-                                 :document => @pdf)
+    array = [{ :text => "hello-world" }]
+    @arranger.format_array = array
+    string = @line_wrap.wrap_line(:arranger => @arranger,
+                                  :width => @one_word_width,
+                                  :document => @pdf)
     string.should == "hello-"
   end
 
   it "should not break after a hyphen that follows white space and" +
      "precedes a word" do
-    normalized_string = @pdf.font.normalize_encoding("hello -")
-    string = @line_wrap.wrap_line(normalized_string,
-                                 :width => @one_word_width,
-                                 :document => @pdf)
+    array = [{ :text => "hello -" }]
+    @arranger.format_array = array
+    string = @line_wrap.wrap_line(:arranger => @arranger,
+                                  :width => @one_word_width,
+                                  :document => @pdf)
     string.should == "hello -"
 
-    normalized_string = @pdf.font.normalize_encoding("hello -world")
-    string = @line_wrap.wrap_line(normalized_string,
-                                 :width => @one_word_width,
-                                 :document => @pdf)
+    array = [{ :text => "hello -world" }]
+    @arranger.format_array = array
+    string = @line_wrap.wrap_line(:arranger => @arranger,
+                                  :width => @one_word_width,
+                                  :document => @pdf)
     string.should == "hello"
   end
 
   it "should break on a soft hyphen" do
-    normalized_string = @pdf.font.normalize_encoding("hello­world")
-    string = @line_wrap.wrap_line(normalized_string,
-                                 :width => @one_word_width,
-                                 :document => @pdf)
-    string.should == @pdf.font.normalize_encoding("hello­")
-
+    string = @pdf.font.normalize_encoding("hello#{Prawn::Text::SHY}world")
+    array = [{ :text => string }]
+    @arranger.format_array = array
+    string = @line_wrap.wrap_line(:arranger => @arranger,
+                                  :width => @one_word_width,
+                                  :document => @pdf)
+    expected = @pdf.font.normalize_encoding("hello#{Prawn::Text::SHY}")
+    expected.force_encoding("utf-8") if "".respond_to?(:force_encoding)
+    string.should == expected
 
     @pdf.font("#{Prawn::BASEDIR}/data/fonts/DejaVuSans.ttf")
-    @line_wrap = Prawn::Core::Text::LineWrap.new
+    @line_wrap = Prawn::Core::Text::Formatted::LineWrap.new
 
-    normalized_string = @pdf.font.normalize_encoding("hello­world")
-    string = @line_wrap.wrap_line(normalized_string,
-                                 :width => @one_word_width,
-                                 :document => @pdf)
-    string.should == @pdf.font.normalize_encoding("hello­")
+    string = "hello#{Prawn::Text::SHY}world"
+    array = [{ :text => string }]
+    @arranger.format_array = array
+    string = @line_wrap.wrap_line(:arranger => @arranger,
+                                  :width => @one_word_width,
+                                  :document => @pdf)
+    string.should == "hello#{Prawn::Text::SHY}"
   end
 
   it "should not display soft hyphens except at the end of a line" do
-    normalized_string = @pdf.font.normalize_encoding("hello­world")
-    string = @line_wrap.wrap_line(normalized_string,
-                                 :width => 300,
-                                 :document => @pdf)
+    string = @pdf.font.normalize_encoding("hello#{Prawn::Text::SHY}world")
+    array = [{ :text => string }]
+    @arranger.format_array = array
+    string = @line_wrap.wrap_line(:arranger => @arranger,
+                                  :width => 300,
+                                  :document => @pdf)
     string.should == "helloworld"
 
-
     @pdf.font("#{Prawn::BASEDIR}/data/fonts/DejaVuSans.ttf")
-    @line_wrap = Prawn::Core::Text::LineWrap.new
+    @line_wrap = Prawn::Core::Text::Formatted::LineWrap.new
 
-    normalized_string = @pdf.font.normalize_encoding("hello­world")
-    string = @line_wrap.wrap_line(normalized_string,
-                                 :width => 300,
-                                 :document => @pdf)
+    string = "hello#{Prawn::Text::SHY}world"
+    array = [{ :text => string }]
+    @arranger.format_array = array
+    string = @line_wrap.wrap_line(:arranger => @arranger,
+                                  :width => 300,
+                                  :document => @pdf)
     string.should == "helloworld"
   end
 
   it "should not break before a hard hyphen that follows a word" do
     enough_width_for_hello_world = 60
-    normalized_string = @pdf.font.normalize_encoding("hello world")
-    string = @line_wrap.wrap_line(normalized_string,
-                                 :width => enough_width_for_hello_world,
-                                 :document => @pdf)
-    string.should == @pdf.font.normalize_encoding("hello world")
-
-    normalized_string = @pdf.font.normalize_encoding("hello world-")
-    string = @line_wrap.wrap_line(normalized_string,
-                                 :width => enough_width_for_hello_world,
-                                 :document => @pdf)
-    string.should == @pdf.font.normalize_encoding("hello")
-
-    @pdf.font("#{Prawn::BASEDIR}/data/fonts/DejaVuSans.ttf")
-    @line_wrap = Prawn::Core::Text::LineWrap.new
-    enough_width_for_hello_world = 68
 
-    normalized_string = @pdf.font.normalize_encoding("hello world")
-    string = @line_wrap.wrap_line(normalized_string,
-                                 :width => enough_width_for_hello_world,
-                                 :document => @pdf)
-    string.should == @pdf.font.normalize_encoding("hello world")
-
-    normalized_string = @pdf.font.normalize_encoding("hello world-")
-    string = @line_wrap.wrap_line(normalized_string,
-                                 :width => enough_width_for_hello_world,
-                                 :document => @pdf)
-    string.should == @pdf.font.normalize_encoding("hello")
-  end
-
-  it "should not break after a hard hyphen that follows a soft hyphen and" +
-     "precedes a word" do
-    normalized_string = @pdf.font.normalize_encoding("hello­-")
-    string = @line_wrap.wrap_line(normalized_string,
-                                 :width => @one_word_width,
-                                 :document => @pdf)
-    string.should == @pdf.font.normalize_encoding("hello-")
+    array = [{ :text => "hello world" }]
+    @arranger.format_array = array
+    string = @line_wrap.wrap_line(:arranger => @arranger,
+                                  :width => enough_width_for_hello_world,
+                                  :document => @pdf)
+    string.should == "hello world"
 
-    normalized_string = @pdf.font.normalize_encoding("hello­-world")
-    string = @line_wrap.wrap_line(normalized_string,
-                                 :width => @one_word_width,
-                                 :document => @pdf)
-    string.should == @pdf.font.normalize_encoding("hello­")
+    array = [{ :text => "hello world-" }]
+    @arranger.format_array = array
+    string = @line_wrap.wrap_line(:arranger => @arranger,
+                                  :width => enough_width_for_hello_world,
+                                  :document => @pdf)
+    string.should == "hello"
 
     @pdf.font("#{Prawn::BASEDIR}/data/fonts/DejaVuSans.ttf")
-    @line_wrap = Prawn::Core::Text::LineWrap.new
-
-    normalized_string = @pdf.font.normalize_encoding("hello­-world")
-    string = @line_wrap.wrap_line(normalized_string,
-                                 :width => @one_word_width,
-                                 :document => @pdf)
-    string.should == @pdf.font.normalize_encoding("hello­")
-  end
-end
-
-describe "Core::Text::LineWrap#consumed_char_count" do
-  before(:each) do
-    create_pdf
-    @line_wrap = Prawn::Core::Text::LineWrap.new
-  end
-  it "should return the total number of characters incorporated into" +
-     " or deleted from the last line" do
-    string = @line_wrap.wrap_line("    hello world    ",
-                                 :width => 300,
-                                 :document => @pdf)
-    @line_wrap.consumed_char_count.should == 19
-  end
-end
-
-describe "Core::Text::LineWrap#width" do
-  before(:each) do
-    create_pdf
-    @line_wrap = Prawn::Core::Text::LineWrap.new
-  end
-  it "should return the width of the last wrapped line" do
-    @line_wrap.wrap_line("hello world" * 10,
-                        :width => 300,
-                        :document => @pdf)
-    @line_wrap.width.should.be > 0
-    @line_wrap.width.should.be <= 300
-  end
-end
-
-describe "Core::Text::LineWrap#space_count" do
-  before(:each) do
-    create_pdf
-    @line_wrap = Prawn::Core::Text::LineWrap.new
-  end
-  it "should return the number of spaces in the last wrapped line" do
-    @line_wrap.wrap_line("hello world, goobye",
-                        :width => 300,
-                        :document => @pdf)
-    @line_wrap.space_count.should == 2
-  end
-  it "should exclude trailing spaces from the count" do
-    @line_wrap.wrap_line("hello world, goobye  ",
-                        :width => 300,
-                        :document => @pdf)
-    @line_wrap.space_count.should == 2
-  end
-end
-
-describe "Core::Text::Formatted::Wrap#line_wrap" do
-  before(:each) do
-    create_pdf
-    @arranger = Prawn::Core::Text::Formatted::Arranger.new(@pdf)
     @line_wrap = Prawn::Core::Text::Formatted::LineWrap.new
-    @one_word_width = 50
-  end
-  it "should strip preceding and trailing spaces" do
-    array = [{ :text => " hello world, " },
-             { :text => "goodbye  ", :style => [:bold] }]
+    enough_width_for_hello_world = 68
+
+    array = [{ :text => "hello world" }]
     @arranger.format_array = array
     string = @line_wrap.wrap_line(:arranger => @arranger,
-                                 :width => 300,
-                                 :document => @pdf)
-    string.should == "hello world, goodbye"
-  end
-  it "should strip trailing spaces when we try but fail to push any of a" +
-     " fragment onto the end of a line that currently ends with a space" do
-    array = [{ :text => "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa " },
-             { :text => "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb ", :style => [:bold] }]
+                                  :width => enough_width_for_hello_world,
+                                  :document => @pdf)
+    string.should == "hello world"
+
+    array = [{ :text => "hello world-" }]
     @arranger.format_array = array
     string = @line_wrap.wrap_line(:arranger => @arranger,
-                                 :width => 300,
-                                 :document => @pdf)
-    string.should == "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+                                  :width => enough_width_for_hello_world,
+                                  :document => @pdf)
+    string.should == "hello"
   end
-  it "should strip trailing spaces when a white-space-only fragment was" +
-     " successfully pushed onto the end of a line but no other non-white" +
-     " space fragment fits after it" do
-    array = [{ :text => "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa " },
-             { :text => "  ", :style => [:bold] },
-             { :text => " bbbbbbbbbbbbbbbbbbbbbbbbbbbb" }]
+
+  it "should not break after a hard hyphen that follows a soft hyphen and" +
+    "precedes a word" do
+    string = @pdf.font.normalize_encoding("hello#{Prawn::Text::SHY}-")
+    array = [{ :text => string }]
     @arranger.format_array = array
     string = @line_wrap.wrap_line(:arranger => @arranger,
-                                 :width => 300,
-                                 :document => @pdf)
-    string.should == "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
-  end
-  it "should raise CannotFit if a too-small width is given" do
-    array = [{ :text => " hello world, " },
-             { :text => "goodbye  ", :style => [:bold] }]
-    @arranger.format_array = array
-    lambda do
-      @line_wrap.wrap_line(:arranger => @arranger,
-                           :width => 1,
-                           :document => @pdf)
-    end.should.raise(Prawn::Errors::CannotFit)
-  end
+                                  :width => @one_word_width,
+                                  :document => @pdf)
+    string.should == "hello-"
 
-  it "should break on space" do
-    array = [{ :text => "hello world" }]
+    string = @pdf.font.normalize_encoding("hello#{Prawn::Text::SHY}-world")
+    array = [{ :text => string }]
     @arranger.format_array = array
     string = @line_wrap.wrap_line(:arranger => @arranger,
                                   :width => @one_word_width,
                                   :document => @pdf)
-    string.should == "hello"
-  end
+    expected = @pdf.font.normalize_encoding("hello#{Prawn::Text::SHY}")
+    expected.force_encoding("utf-8") if "".respond_to?(:force_encoding)
+    string.should == expected
 
-  it "should break on tab" do
-    array = [{ :text => "hello\tworld" }]
+    @pdf.font("#{Prawn::BASEDIR}/data/fonts/DejaVuSans.ttf")
+    @line_wrap = Prawn::Core::Text::Formatted::LineWrap.new
+
+    string = "hello#{Prawn::Text::SHY}-"
+    array = [{ :text => string }]
     @arranger.format_array = array
     string = @line_wrap.wrap_line(:arranger => @arranger,
                                   :width => @one_word_width,
                                   :document => @pdf)
-    string.should == "hello"
-  end
+    string.should == "hello-"
 
-  it "should break on hyphens" do
-    array = [{ :text => "hello-world" }]
+    string = "hello#{Prawn::Text::SHY}-world"
+    array = [{ :text => string }]
     @arranger.format_array = array
     string = @line_wrap.wrap_line(:arranger => @arranger,
                                   :width => @one_word_width,
                                   :document => @pdf)
-    string.should == "hello-"
+    string.should == "hello#{Prawn::Text::SHY}"
   end
 end
 
-describe "Core::Text::Formatted::Wrap#space_count" do
+describe "Core::Text::Formatted::LineWrap#space_count" do
   before(:each) do
     create_pdf
     @arranger = Prawn::Core::Text::Formatted::Arranger.new(@pdf)
@@ -310,7 +252,7 @@ describe "Core::Text::Formatted::Wrap#space_count" do
   end
 end
 
-describe "Core::Text::Formatted::Wrap" do
+describe "Core::Text::Formatted::LineWrap" do
   before(:each) do
     create_pdf
     @arranger = Prawn::Core::Text::Formatted::Arranger.new(@pdf)
@@ -339,3 +281,53 @@ describe "Core::Text::Formatted::Wrap" do
     line.should.be.empty
   end
 end
+
+describe "Core::Text::Formatted::LineWrap#paragraph_finished?" do
+  before(:each) do
+    create_pdf
+    @arranger = Prawn::Core::Text::Formatted::Arranger.new(@pdf)
+    @line_wrap = Prawn::Core::Text::Formatted::LineWrap.new
+    @one_word_width = 50
+  end
+  it "should be false when the last printed line is not the end of the paragraph" do
+    array = [{ :text => "hello world" }]
+    @arranger.format_array = array
+    string = @line_wrap.wrap_line(:arranger => @arranger,
+                                  :width => @one_word_width,
+                                  :document => @pdf)
+
+    @line_wrap.paragraph_finished?.should == false
+  end
+  it "should be true when the last printed line is the last fragment to print" do
+    array = [{ :text => "hello world" }]
+    @arranger.format_array = array
+    string = @line_wrap.wrap_line(:arranger => @arranger,
+                                  :width => @one_word_width,
+                                  :document => @pdf)
+    string = @line_wrap.wrap_line(:arranger => @arranger,
+                                  :width => @one_word_width,
+                                  :document => @pdf)
+
+    @line_wrap.paragraph_finished?.should == true
+  end
+  it "should be true when a newline exists on the current line" do
+    array = [{ :text => "hello\n world" }]
+    @arranger.format_array = array
+    string = @line_wrap.wrap_line(:arranger => @arranger,
+                                  :width => @one_word_width,
+                                  :document => @pdf)
+
+    @line_wrap.paragraph_finished?.should == true
+  end
+  it "should be true when a newline exists in the next fragment" do
+    array = [{ :text => "hello " },
+             { :text => " \n" },
+             { :text => "world" }]
+    @arranger.format_array = array
+    string = @line_wrap.wrap_line(:arranger => @arranger,
+                                  :width => @one_word_width,
+                                  :document => @pdf)
+
+    @line_wrap.paragraph_finished?.should == true
+  end
+end