prawn 0.11.1.pre → 0.11.1

data/spec/document_spec.rb

@@ -318,13 +318,23 @@ describe "The mask() feature" do
 end
 
 describe "The group() feature" do
+  it "should return a true value if the content fits on one page" do
+    pdf = Prawn::Document.new do
+      val = group { text "Hello"; text "World" }
+      (!!val).should == true
+    end
+  end
+
   it "should group a simple block on a single page" do
     pdf = Prawn::Document.new do
       self.y = 50
-      group do
+      val = group do
         text "Hello"
         text "World"
       end
+
+      # group should return a false value since a new page was started
+      (!!val).should == false
     end
     pages = PDF::Inspector::Page.analyze(pdf.render).pages
     pages.size.should == 2
@@ -341,6 +351,25 @@ describe "The group() feature" do
       end.render
     }.should.raise(Prawn::Errors::CannotGroup)
   end
+
+   it "should group within individual column boxes" do
+    pdf = Prawn::Document.new do
+      # Set up columns with grouped blocks of 0..49. 0 to 49 is slightly short
+      # of the height of one page / column, so each column should get its own
+      # group (every column should start with zero).
+      column_box([0, bounds.top], :width => bounds.width, :columns => 7) do
+        10.times do
+          group { 50.times { |i| text(i.to_s) } }
+        end
+      end
+    end
+
+    # Second page should start with a 0 because it's a new group.
+    pages = PDF::Inspector::Page.analyze(pdf.render).pages
+    pages.size.should == 2
+    pages[1][:strings].first.should == '0'
+  end
+
 end
 
 describe "The render() feature" do
@@ -373,6 +402,14 @@ describe "The render() feature" do
     render_body.call(StringIO.new)
     pdf.render
   end
+
+  it "should be idempotent" do
+    pdf = Prawn::Document.new
+
+    contents  = pdf.render
+    contents2 = pdf.render
+    contents2.should == contents
+  end
 end
 
 describe "The :optimize_objects option" do
@@ -454,7 +491,7 @@ describe "content stream characteristics" do
     @pdf = Prawn::Document.new
     @pdf.text "James"
     output = StringIO.new(@pdf.render)
-    hash = PDF::Hash.new(output)
+    hash = PDF::Reader::ObjectHash.new(output)
 
     streams = hash.values.select { |obj| obj.kind_of?(PDF::Reader::Stream) }
 
@@ -467,10 +504,157 @@ describe "content stream characteristics" do
     @pdf.go_to_page(1)
     @pdf.text "Healy"
     output = StringIO.new(@pdf.render)
-    hash = PDF::Hash.new(output)
+    hash = PDF::Reader::ObjectHash.new(output)
 
     streams = hash.values.select { |obj| obj.kind_of?(PDF::Reader::Stream) }
 
     streams.size.should == 1
   end
 end
+
+describe "The number_pages method" do
+  before do
+    @pdf = Prawn::Document.new(:skip_page_creation => true)
+  end
+  
+  it "replaces the '<page>' string with the proper page number" do
+    @pdf.start_new_page
+    @pdf.expects(:text_box).with("1, test", { :height => 50 })
+    @pdf.number_pages "<page>, test", {:page_filter => :all}
+  end
+  
+  it "replaces the '<total>' string with the total page count" do
+    @pdf.start_new_page
+    @pdf.expects(:text_box).with("test, 1", { :height => 50 })
+    @pdf.number_pages "test, <total>", {:page_filter => :all}
+  end
+ 
+  it "must print the page if the page number matches" do
+    10.times { @pdf.start_new_page }
+    @pdf.expects(:text_box).at_least_once
+    @pdf.number_pages "test", {:page_filter => :all}
+  end
+
+  it "must not print the page number without a filter" do
+    10.times { @pdf.start_new_page }
+    @pdf.expects(:text_box).never
+    @pdf.number_pages "test", {:page_filter => nil}
+  end
+  
+  context "start_count_at option" do    
+    [1, 2].each do |startat|
+      context "equal to #{startat}" do
+        it "increments the pages" do
+          2.times { @pdf.start_new_page }
+          options = {:page_filter => :all, :start_count_at => startat}
+          @pdf.expects(:text_box).with("#{startat} 2", { :height => 50 })
+          @pdf.expects(:text_box).with("#{startat+1} 2", { :height => 50 })
+          @pdf.number_pages "<page> <total>", options
+        end  
+      end
+    end
+      
+    [0, nil].each do |val|
+      context "equal to #{val}" do
+        it "defaults to start at page 1" do
+          3.times { @pdf.start_new_page }
+          options = {:page_filter => :all, :start_count_at => val}
+          @pdf.expects(:text_box).with("1 3", { :height => 50 })
+          @pdf.expects(:text_box).with("2 3", { :height => 50 })
+          @pdf.expects(:text_box).with("3 3", { :height => 50 })
+          @pdf.number_pages "<page> <total>", options
+        end
+      end
+    end
+  end
+  
+  context "total_pages option" do
+    it "allows the total pages count to be overridden" do
+      2.times { @pdf.start_new_page }
+      @pdf.expects(:text_box).with("1 10", { :height => 50 })
+      @pdf.expects(:text_box).with("2 10", { :height => 50 })
+      @pdf.number_pages "<page> <total>", :page_filter => :all, :total_pages => 10
+    end
+  end
+  
+  context "special page filter" do
+    context "such as :odd" do
+      it "increments the pages" do
+        3.times { @pdf.start_new_page }
+        @pdf.expects(:text_box).with("1 3", { :height => 50 })
+        @pdf.expects(:text_box).with("3 3", { :height => 50 })
+        @pdf.expects(:text_box).with("2 3", { :height => 50 }).never
+        @pdf.number_pages "<page> <total>", :page_filter => :odd
+      end
+    end
+    context "missing" do
+      it "does not print any page numbers" do
+        3.times { @pdf.start_new_page }
+        @pdf.expects(:text_box).never
+        @pdf.number_pages "<page> <total>", :page_filter => nil
+      end
+    end
+  end
+
+  context "given both a special page filter and a start_count_at parameter" do
+    context "such as :odd and 7" do
+      it "increments the pages" do
+        3.times { @pdf.start_new_page }
+        @pdf.expects(:text_box).with("1 3", { :height => 50 }).never
+        @pdf.expects(:text_box).with("5 3", { :height => 50 }) # page 1
+        @pdf.expects(:text_box).with("6 3", { :height => 50 }).never # page 2
+        @pdf.expects(:text_box).with("7 3", { :height => 50 }) # page 3
+        @pdf.number_pages "<page> <total>", :page_filter => :odd, :start_count_at => 5
+      end
+    end
+    context "some crazy proc and 2" do
+      it "increments the pages" do
+        6.times { @pdf.start_new_page }
+        options = {:page_filter => lambda {|p| p != 2 && p != 5}, :start_count_at => 4}
+        @pdf.expects(:text_box).with("4 6", { :height => 50 }) # page 1
+        @pdf.expects(:text_box).with("5 6", { :height => 50 }).never # page 2
+        @pdf.expects(:text_box).with("6 6", { :height => 50 }) # page 3
+        @pdf.expects(:text_box).with("7 6", { :height => 50 }) # page 4
+        @pdf.expects(:text_box).with("8 6", { :height => 50 }).never # page 5
+        @pdf.expects(:text_box).with("9 6", { :height => 50 }) # page 6
+        @pdf.number_pages "<page> <total>", options
+      end
+    end
+  end
+end
+
+describe "The page_match? method" do
+  before do
+    @pdf = Prawn::Document.new(:skip_page_creation => true)
+    10.times {@pdf.start_new_page}
+  end
+  
+  it "returns nil given no filter" do
+    assert ! @pdf.page_match?(:nil, 1)
+  end
+  
+  it "must provide an :all filter" do
+    assert (1..@pdf.page_count).all? { |i| @pdf.page_match?(:all, i) }
+  end
+
+  it "must provide an :odd filter" do
+    odd, even = (1..@pdf.page_count).partition { |e| e % 2 == 1 }
+    assert odd.all? { |i| @pdf.page_match?(:odd, i) }
+    assert ! even.any? { |i| @pdf.page_match?(:odd, i) }
+  end
+
+  it "must be able to filter by an array of page numbers" do
+    fltr = [1,2,7]
+    assert_equal [1,2,7], (1..10).select { |i| @pdf.page_match?(fltr, i) }
+  end
+
+  it "must be able to filter by a range of page numbers" do
+    fltr = 2..4
+    assert_equal [2,3,4], (1..10).select { |i| @pdf.page_match?(fltr, i) }
+  end
+
+  it "must be able to filter by an arbitrary proc" do
+    fltr = lambda { |x| x == 1 or x % 3 == 0 }
+    assert_equal [1,3,6,9], (1..10).select { |i| @pdf.page_match?(fltr, i) }
+  end    
+end

data/spec/extensions/mocha.rb

@@ -0,0 +1,45 @@
+# Allow speccing things when an expectation matcher runs. Similar to #with, but
+# always succeeds.
+#
+#   @pdf.expects(:stroke_line).checking do |from, to|
+#     @pdf.map_to_absolute(from).should == [0, 0]
+#   end
+#
+# Note that the outer expectation does *not* fail only because the inner one
+# does; in the above example, the outer expectation would only fail if
+# stroke_line were not called.
+
+class ParameterChecker < Mocha::ParametersMatcher
+  def initialize(&matching_block)
+    @matching_block = matching_block
+    @run_matching_block = false
+  end
+
+  def match?(actual_parameters = [])
+    @matching_block.call(*actual_parameters) unless @run_matching_block
+    @run_matching_block = true
+
+    true # always succeed
+  end
+end
+
+class Mocha::Expectation
+  def checking(&block)
+    @parameters_matcher = ParameterChecker.new(&block)
+    self
+  end
+end
+
+
+# Equivalent to expects(method_name).at_least(0). More useful when combined
+# with parameter matchers to ignore certain calls for the sake of parameter
+# matching.
+#
+#   @pdf.ignores(:stroke_color=).with("000000")
+#   @pdf.expects(:stroke_color=).with("ff0000")
+#
+module Mocha::ObjectMethods
+  def ignores(method_name)
+    expects(method_name).at_least(0)
+  end
+end

data/spec/font_spec.rb

@@ -206,6 +206,33 @@ describe "AFM fonts" do
   
 end
 
+describe "#glyph_present" do
+  before(:each) { create_pdf }
+
+  it "should return true when present in an AFM font" do
+    font = @pdf.find_font("Helvetica")
+    font.glyph_present?("H").should.be true
+  end
+
+  it "should return false when absent in an AFM font" do
+    font = @pdf.find_font("Helvetica")
+    font.glyph_present?("再").should.be false
+  end
+
+  it "should return true when present in a TTF font" do
+    font = @pdf.find_font("#{Prawn::BASEDIR}/data/fonts/Activa.ttf")
+    font.glyph_present?("H").should.be true
+  end
+
+  it "should return false when absent in a TTF font" do
+    font = @pdf.find_font("#{Prawn::BASEDIR}/data/fonts/Activa.ttf")
+    font.glyph_present?("再").should.be false
+
+    font = @pdf.find_font("#{Prawn::BASEDIR}/data/fonts/gkai00mp.ttf")
+    font.glyph_present?("€").should.be false
+  end
+end
+
 describe "TTF fonts" do
   
   setup do
@@ -224,7 +251,11 @@ describe "TTF fonts" do
   
   it "should encode text without kerning by default" do
     @activa.encode_text("To").should == [[0, "To"]]
-    @activa.encode_text("Télé").should == [[0, "T\216l\216"]]
+
+    tele = (RUBY_VERSION < '1.9') ? "T\216l\216" :
+      "T\216l\216".force_encoding("US-ASCII")
+    @activa.encode_text("Télé").should == [[0, tele]]
+
     @activa.encode_text("Technology").should == [[0, "Technology"]]
     @activa.encode_text("Technology...").should == [[0, "Technology..."]]
     @activa.encode_text("Teχnology...").should == [[0, "Te"], [1, "!"], [0, "nology..."]]

data/spec/formatted_text_arranger_spec.rb

@@ -178,12 +178,26 @@ describe "Core::Text::Formatted::Arranger#update_last_string" do
     arranger.format_array = array
     while string = arranger.next_string
     end
-    arranger.update_last_string(" you", " now?")
+    arranger.update_last_string(" you", " now?", nil)
     arranger.consumed[3].should == { :text => " you",
-                                      :styles => [:bold, :italic] }
+                                     :styles => [:bold, :italic] }
     arranger.unconsumed.should == [{ :text => " now?",
-                                      :styles => [:bold, :italic] }]
+                                     :styles => [:bold, :italic] }]
   end
+  it "should set the format state to the previously processed fragment" do
+    create_pdf
+    arranger = Prawn::Core::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
@@ -195,7 +209,7 @@ describe "Core::Text::Formatted::Arranger#update_last_string" do
     arranger.format_array = array
       while string = arranger.next_string
       end
-      arranger.update_last_string(" you now?", "")
+      arranger.update_last_string(" you now?", "", nil)
       arranger.unconsumed.should == []
     end
   end
@@ -223,7 +237,8 @@ describe "Core::Text::Formatted::Arranger#space_count" do
   end
 end
 describe "Core::Text::Formatted::Arranger#finalize_line" do
-  it "should make it so the last consumed fragment ends with non-white-space" do
+  it "should make it so that all trailing white space fragments " +
+     "exclude trailing white space" do
     create_pdf
     arranger = Prawn::Core::Text::Formatted::Arranger.new(@pdf)
     array = [{ :text => "hello " },
@@ -233,9 +248,16 @@ describe "Core::Text::Formatted::Arranger#finalize_line" do
     while string = arranger.next_string
     end
     arranger.finalize_line
-    arranger.fragments.length.should == 2
-    arranger.retrieve_fragment.text
-    arranger.retrieve_fragment.text.should == "world how"
+    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
 
@@ -343,7 +365,7 @@ describe "Core::Text::Formatted::Arranger#finished" do
     arranger.format_array = array
     while string = arranger.next_string
     end
-    arranger.update_last_string(" you", "now?")
+    arranger.update_last_string(" you", "now?", nil)
     arranger.should.not.be.finished
   end
   it "should be false if everything was printed" do
@@ -360,47 +382,20 @@ describe "Core::Text::Formatted::Arranger#finished" do
   end
 end
 
-describe "Core::Text::Formatted::Arranger#unfinished" do
-  it "should be false if anything was not printed" do
-    create_pdf
-    arranger = Prawn::Core::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?")
-    arranger.should.be.unfinished
-  end
-  it "should be false if everything was printed" do
-    create_pdf
-    arranger = Prawn::Core::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.not.be.unfinished
-  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::Core::Text::Formatted::Arranger.new(@pdf)
     array = [{ :text => "hello " },
              { :text => "world how ", :styles => [:bold] },
-             { :text => "are", :styles => [:bold, :italic] },
+             { :text => "are", :styles => [:bold, :italic],
+               :size => 28 },
              { :text => " you now?" }]
     arranger.format_array = array
     while string = arranger.next_string
     end
-    arranger.update_last_string(" you", "now?")
-    arranger.should.be.unfinished
+    arranger.finalize_line
+    arranger.max_line_height.should.be.close(33.32, 0.0001)
   end
 end