prawn 2.0.2 → 2.1.0

data/spec/font_spec.rb

@@ -265,11 +265,11 @@ describe "Document#page_fonts" do
   end
 
   def page_should_include_font(font)
-    expect(page_includes_font?(font)).to be_true
+    expect(page_includes_font?(font)).to eq true
   end
 
   def page_should_not_include_font(font)
-    expect(page_includes_font?(font)).to be_false
+    expect(page_includes_font?(font)).to eq false
   end
 end
 
@@ -313,13 +313,13 @@ describe "AFM fonts" do
     it "should not modify the original string when normalize_encoding() is used" do
       original = "Foo"
       normalized = @times.normalize_encoding(original)
-      expect(original.equal?(normalized)).to be_false
+      expect(original.equal?(normalized)).to eq false
     end
 
     it "should modify the original string when normalize_encoding!() is used" do
       original = "Foo"
       normalized = @times.normalize_encoding!(original)
-      expect(original.equal?(normalized)).to be_true
+      expect(original.equal?(normalized)).to eq true
     end
   end
 
@@ -335,25 +335,25 @@ describe "#glyph_present" do
 
   it "should return true when present in an AFM font" do
     font = @pdf.find_font("Helvetica")
-    expect(font.glyph_present?("H")).to be_true
+    expect(font.glyph_present?("H")).to eq true
   end
 
   it "should return false when absent in an AFM font" do
     font = @pdf.find_font("Helvetica")
-    expect(font.glyph_present?("再")).to be_false
+    expect(font.glyph_present?("再")).to eq false
   end
 
   it "should return true when present in a TTF font" do
     font = @pdf.find_font("#{Prawn::DATADIR}/fonts/DejaVuSans.ttf")
-    expect(font.glyph_present?("H")).to be_true
+    expect(font.glyph_present?("H")).to eq true
   end
 
   it "should return false when absent in a TTF font" do
     font = @pdf.find_font("#{Prawn::DATADIR}/fonts/DejaVuSans.ttf")
-    expect(font.glyph_present?("再")).to be_false
+    expect(font.glyph_present?("再")).to eq false
 
     font = @pdf.find_font("#{Prawn::DATADIR}/fonts/gkai00mp.ttf")
-    expect(font.glyph_present?("€")).to be_false
+    expect(font.glyph_present?("€")).to eq false
   end
 end
 
@@ -410,13 +410,13 @@ describe "TTF fonts" do
     it "should not modify the original string when normalize_encoding() is used" do
       original = "Foo"
       normalized = @font.normalize_encoding(original)
-      expect(original.equal?(normalized)).to be_false
+      expect(original.equal?(normalized)).to eq false
     end
 
     it "should modify the original string when normalize_encoding!() is used" do
       original = "Foo"
       normalized = @font.normalize_encoding!(original)
-      expect(original.equal?(normalized)).to be_true
+      expect(original.equal?(normalized)).to eq true
     end
   end
 end

data/spec/formatted_text_arranger_spec.rb

@@ -2,167 +2,196 @@
 
 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
-    expect(arranger.unconsumed[0]).to eq(:text => "hello ")
-    expect(arranger.unconsumed[1]).to eq(:text => "world how ",
-                                         :styles => [:bold])
-    expect(arranger.unconsumed[2]).to eq(:text => "are",
-                                         :styles => [:bold, :italic])
-    expect(arranger.unconsumed[3]).to eq(: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
-    expect(arranger.unconsumed[0]).to eq(:text => "\n")
-    expect(arranger.unconsumed[1]).to eq(:text => "hello")
-    expect(arranger.unconsumed[2]).to eq(:text => "\n")
-    expect(arranger.unconsumed[3]).to eq(: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
-    expect(arranger.consumed).to eq([])
-  end
-  it "should not consumed array" do
-    create_pdf
-    arranger = Prawn::Text::Formatted::Arranger.new(@pdf)
-    array = [{ :text => "hello" }]
-    arranger.format_array = array
-    expect(arranger.preview_next_string).to eq("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
-    expect do
-      @arranger.next_string
-    end.to raise_error(RuntimeError)
-  end
-  it "should populate consumed array" do
-    while string = @arranger.next_string
+describe Prawn::Text::Formatted::Arranger do
+  let(:document) { create_pdf }
+  subject { Prawn::Text::Formatted::Arranger.new document }
+
+  describe '#format_array' do
+    it 'populates the unconsumed array' do
+      array = [
+        { text: 'hello ' },
+        { text: 'world how ', styles: [:bold] },
+        { text: 'are', styles: [:bold, :italic] },
+        { text: ' you?' }
+      ]
+
+      subject.format_array = array
+
+      expect(subject.unconsumed[0]).to eq(text: 'hello ')
+      expect(subject.unconsumed[1]).to eq(text: 'world how ', styles: [:bold])
+      expect(subject.unconsumed[2]).to eq(text: 'are', styles: [:bold, :italic])
+      expect(subject.unconsumed[3]).to eq(text: ' you?')
+    end
+
+    it 'splits newlins into their own elements' do
+      array = [
+        { text: "\nhello\nworld" }
+      ]
+
+      subject.format_array = array
+
+      expect(subject.unconsumed[0]).to eq(text: "\n")
+      expect(subject.unconsumed[1]).to eq(text: "hello")
+      expect(subject.unconsumed[2]).to eq(text: "\n")
+      expect(subject.unconsumed[3]).to eq(text: "world")
     end
-    expect(@arranger.consumed[0]).to eq(:text => "hello ")
-    expect(@arranger.consumed[1]).to eq(:text => "world how ",
-                                        :styles => [:bold])
-    expect(@arranger.consumed[2]).to eq(:text => "are",
-                                        :styles => [:bold, :italic])
-    expect(@arranger.consumed[3]).to eq(: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
-        expect(arranger.current_format_state).to eq({})
-      when 1
-        expect(arranger.current_format_state).to eq(:styles => [:bold])
-      when 2
-        expect(arranger.current_format_state).to eq(:styles => [:bold, :italic])
-      when 3
-        expect(arranger.current_format_state).to eq({})
+
+  describe '#preview_next_string' do
+    context 'with a formatted array' do
+      let(:array) { [{ text: 'hello' }] }
+
+      before do
+        subject.format_array = array
+      end
+
+      it 'does not populate the consumed array' do
+        subject.preview_next_string
+        expect(subject.consumed).to eq([])
+      end
+
+      it 'returns the text of the next unconsumed hash' do
+        expect(subject.preview_next_string).to eq("hello")
+      end
+
+      it 'returns nil if there is no more unconsumed text' do
+        subject.next_string
+        expect(subject.preview_next_string).to be_nil
       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
+  describe '#next_string' do
+    let(:array) {
+      [
+        { text: 'hello ' },
+        { text: 'world how ', styles: [:bold] },
+        { text: 'are', styles: [:bold, :italic] },
+        { text: ' you?' }
+      ]
+    }
+
+    before do
+      subject.format_array = array
     end
-    expect do
-      arranger.retrieve_fragment
-    end.to 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
+
+    it 'raises RuntimeError if called after a line was finalized' do
+      subject.finalize_line
+      expect { subject.next_string }.to raise_error(RuntimeError)
     end
-    arranger.finalize_line
-    expect(arranger.retrieve_fragment.text).to eq("hello ")
-    expect(arranger.retrieve_fragment.text).to eq("world how ")
-    expect(arranger.retrieve_fragment.text).to eq("are")
-    expect(arranger.retrieve_fragment.text).to eq(" 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
+
+    it 'populates the conumed array' do
+      while string = subject.next_string
+      end
+
+      expect(subject.consumed[0]).to eq(text: 'hello ')
+      expect(subject.consumed[1]).to eq(text: 'world how ', styles: [:bold])
+      expect(subject.consumed[2]).to eq(text: 'are', styles: [:bold, :italic])
+      expect(subject.consumed[3]).to eq(text: ' you?')
     end
-    arranger.finalize_line
-    while fragment = arranger.retrieve_fragment
-      expect(fragment.text).not_to be_empty
+
+    it 'populates the current_format_state array' do
+      string = subject.next_string
+      expect(subject.current_format_state).to eq({})
+
+      string = subject.next_string
+      expect(subject.current_format_state).to eq(:styles => [:bold])
+
+      string = subject.next_string
+      expect(subject.current_format_state).to eq(:styles => [:bold, :italic])
+
+      string = subject.next_string
+      expect(subject.current_format_state).to eq({})
+    end
+
+    it 'returns the text of the newly consumed hash' do
+      expect(subject.next_string).to eq('hello ')
+    end
+
+    it 'returns nil when there are no more unconsumed hashes' do
+      4.times do
+        subject.next_string
+      end
+
+      expect(subject.next_string).to be_nil
     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
+
+  describe '#retrieve_fragment' do
+    context 'with a formatted array whos text is an empty string' do
+      let(:array) {
+        [
+          { text: "hello\nworld\n\n\nhow are you?" },
+          { text: "\n" },
+          { text: "\n" },
+          { text: "\n" },
+          { text: "" },
+          { text: "fine, thanks." },
+          { text: "" },
+          { text: "\n" },
+          { text: "" }
+        ]
+      }
+
+      before do
+        subject.format_array = array
+
+        while string = subject.next_string
+        end
+
+        subject.finalize_line
+      end
+
+      it 'never returns a fragment whose text is an empty string' do
+        while fragment = subject.retrieve_fragment
+          expect(fragment.text).not_to be_empty
+        end
+      end
+    end
+
+    context 'with formatted array' do
+      let(:array) {
+        [
+          { text: 'hello ' },
+          { text: 'world how ', styles: [:bold] },
+          { text: 'are', styles: [:bold, :italic] },
+          { text: ' you?' }
+        ]
+      }
+
+      before do
+        subject.format_array = array
+      end
+
+      context 'after all strings have been consumed' do
+        before do
+          while string = subject.next_string
+          end
+        end
+
+        it 'should raise RuntimeError an error if not finalized' do
+          expect { subject.retrieve_fragment }.to raise_error(RuntimeError)
+        end
+
+        context 'and finalized' do
+          before do
+            subject.finalize_line
+          end
+
+          it 'returns the consumed fragments in order of consumption' do
+            expect(subject.retrieve_fragment.text).to eq("hello ")
+            expect(subject.retrieve_fragment.text).to eq("world how ")
+            expect(subject.retrieve_fragment.text).to eq("are")
+            expect(subject.retrieve_fragment.text).to eq(" you?")
+          end
+
+          it 'does not alter the current font style' do
+            subject.retrieve_fragment
+            expect(subject.current_format_state[:styles]).to be_nil
+          end
+        end
+      end
     end
-    arranger.finalize_line
-    arranger.retrieve_fragment
-    expect(arranger.current_format_state[:styles]).to be_nil
   end
 end
 

data/spec/formatted_text_box_spec.rb

@@ -225,7 +225,7 @@ describe "Text::Formatted::Box" do
                                           :document => @pdf,
                                           :fallback_fonts => [])
 
-    box.expects(:process_fallback_fonts).never
+    expect(box).to_not receive(:process_fallback_fonts)
     box.render
   end
 
@@ -236,7 +236,7 @@ describe "Text::Formatted::Box" do
 
     @pdf.font("Kai")
 
-    box.expects(:process_fallback_fonts).never
+    expect(box).to_not receive(:process_fallback_fonts)
     box.render
   end
 end
@@ -339,10 +339,10 @@ 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(
+    expect(callback_object).to receive(:render_behind).with(
       kind_of(Prawn::Text::Formatted::Fragment)
     )
-    callback_object.expects(:render_in_front).with(
+    expect(callback_object).to receive(:render_in_front).with(
       kind_of(Prawn::Text::Formatted::Fragment)
     )
     array = [{ :text => "hello world " },
@@ -355,18 +355,18 @@ describe "Text::Formatted::Box#render" do
     create_pdf
 
     callback_object = TestFragmentCallback.new("something", 7, :document => @pdf)
-    callback_object.expects(:render_behind).with(
+    expect(callback_object).to receive(:render_behind).with(
       kind_of(Prawn::Text::Formatted::Fragment)
     )
-    callback_object.expects(:render_in_front).with(
+    expect(callback_object).to receive(: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(
+    expect(callback_object2).to receive(:render_behind).with(
       kind_of(Prawn::Text::Formatted::Fragment)
     )
-    callback_object2.expects(:render_in_front).with(
+    expect(callback_object2).to receive(:render_in_front).with(
       kind_of(Prawn::Text::Formatted::Fragment)
     )
 
@@ -485,12 +485,12 @@ describe "Text::Formatted::Box#render" do
   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"
-                                                        })
+    expect(@pdf).to receive(: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" }]
@@ -499,8 +499,8 @@ describe "Text::Formatted::Box#render" do
   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")
+    expect(@pdf).to receive(: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)
@@ -508,13 +508,13 @@ describe "Text::Formatted::Box#render" do
   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
-                                                        })
+    expect(@pdf).to receive(: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" }]