prawn 2.0.2 → 2.1.0

data/spec/graphics_spec.rb

@@ -200,22 +200,22 @@ describe "When filling" do
   before(:each) { create_pdf }
 
   it "should default to the f operator (nonzero winding number rule)" do
-    @pdf.renderer.expects(:add_content).with("f")
+    expect(@pdf.renderer).to receive(:add_content).with("f")
     @pdf.fill
   end
 
   it "should use f* for :fill_rule => :even_odd" do
-    @pdf.renderer.expects(:add_content).with("f*")
+    expect(@pdf.renderer).to receive(:add_content).with("f*")
     @pdf.fill(:fill_rule => :even_odd)
   end
 
   it "should use b by default for fill_and_stroke (nonzero winding number)" do
-    @pdf.renderer.expects(:add_content).with("b")
+    expect(@pdf.renderer).to receive(:add_content).with("b")
     @pdf.fill_and_stroke
   end
 
   it "should use b* for fill_and_stroke(:fill_rule => :even_odd)" do
-    @pdf.renderer.expects(:add_content).with("b*")
+    expect(@pdf.renderer).to receive(:add_content).with("b*")
     @pdf.fill_and_stroke(:fill_rule => :even_odd)
   end
 end
@@ -280,10 +280,10 @@ describe "Patterns" do
       expect(pattern[:Shading][:Coords]).to eq([0, 0, @pdf.bounds.width, 0])
       expect(pattern[:Shading][:Function][:C0].zip([1, 0, 0]).all?{ |x1, x2|
         (x1 - x2).abs < 0.01
-      }).to be_true
+      }).to eq true
       expect(pattern[:Shading][:Function][:C1].zip([0, 0, 1]).all?{ |x1, x2|
         (x1 - x2).abs < 0.01
-      }).to be_true
+      }).to eq true
     end
 
     it "fill_gradient should set fill color to the pattern" do
@@ -319,10 +319,10 @@ describe "Patterns" do
       expect(pattern[:Shading][:Coords]).to eq([0, 0, 10, @pdf.bounds.width, 0, 20])
       expect(pattern[:Shading][:Function][:C0].zip([1, 0, 0]).all?{ |x1, x2|
         (x1 - x2).abs < 0.01
-      }).to be_true
+      }).to eq true
       expect(pattern[:Shading][:Function][:C1].zip([0, 0, 1]).all?{ |x1, x2|
         (x1 - x2).abs < 0.01
-      }).to be_true
+      }).to eq true
     end
 
     it "fill_gradient should set fill color to the pattern" do
@@ -343,21 +343,60 @@ describe "Patterns" do
       expect(str).to match(%r{/Pattern\s+CS\s*/SP-?\d+\s+SCN})
     end
   end
+
+  describe "gradient transformations" do
+    subject do
+      @pdf.scale 2 do
+        @pdf.translate 40, 40 do
+          @pdf.fill_gradient [0, 10], [15, 15], 'FF0000', '0000FF', opts
+          @pdf.fill_gradient [0, 10], 15, [15, 15], 25, 'FF0000', '0000FF', opts
+        end
+      end
+
+      grad = PDF::Inspector::Graphics::Pattern.analyze(@pdf.render)
+      grad.patterns.values.map { |pattern| pattern[:Matrix] }.uniq
+    end
+
+    context "when :apply_transformations is true" do
+      let(:opts) { { apply_transformations: true } }
+
+      it "uses the transformation stack to translate user co-ordinates to document co-ordinates required by /Pattern" do
+        expect(subject).to eq([[2, 0, 0, 2, 80, 100]])
+      end
+    end
+
+    context "when :apply_transformations is false" do
+      let(:opts) { { apply_transformations: false } }
+
+      it "doesn't transform the gradient" do
+        expect(subject).to eq([[1, 0, 0, 1, 0, 10]])
+      end
+    end
+
+    context "when :apply_transformations is unset" do
+      let(:opts) { {} }
+
+      it "doesn't transform the gradient and displays a warning" do
+        expect(@pdf).to receive(:warn).twice
+        expect(subject).to eq([[1, 0, 0, 1, 0, 10]])
+      end
+    end
+  end
 end
 
 describe "When using painting shortcuts" do
   before(:each) { create_pdf }
 
   it "should convert stroke_some_method(args) into some_method(args); stroke" do
-    @pdf.expects(:line_to).with([100, 100])
-    @pdf.expects(:stroke)
+    expect(@pdf).to receive(:line_to).with([100, 100])
+    expect(@pdf).to receive(:stroke)
 
     @pdf.stroke_line_to [100, 100]
   end
 
   it "should convert fill_some_method(args) into some_method(args); fill" do
-    @pdf.expects(:line_to).with([100, 100])
-    @pdf.expects(:fill)
+    expect(@pdf).to receive(:line_to).with([100, 100])
+    expect(@pdf).to receive(:fill)
 
     @pdf.fill_line_to [100, 100]
   end
@@ -372,22 +411,21 @@ describe "When using graphics states" do
   before(:each) { create_pdf }
 
   it "should add the right content on save_graphics_state" do
-    @pdf.renderer.expects(:add_content).with('q')
+    expect(@pdf.renderer).to receive(:add_content).with('q')
 
     @pdf.save_graphics_state
   end
 
   it "should add the right content on restore_graphics_state" do
-    @pdf.renderer.expects(:add_content).with('Q')
+    expect(@pdf.renderer).to receive(:add_content).with('Q')
 
     @pdf.restore_graphics_state
   end
 
   it "should save and restore when save_graphics_state is used with a block" do
-    state = sequence "state"
-    @pdf.renderer.expects(:add_content).with('q').in_sequence(state)
-    @pdf.expects(:foo).in_sequence(state)
-    @pdf.renderer.expects(:add_content).with('Q').in_sequence(state)
+    expect(@pdf.renderer).to receive(:add_content).with('q').ordered
+    allow(@pdf).to receive(:foo).ordered
+    expect(@pdf.renderer).to receive(:add_content).with('Q').ordered
 
     @pdf.save_graphics_state do
       @pdf.foo
@@ -503,14 +541,14 @@ describe "When using transformation matrix" do
   # part is 5 (PDF Reference, Third Edition, p. 706)
 
   it "should send the right content on transformation_matrix" do
-    @pdf.renderer.expects(:add_content).with('1.00000 0.00000 0.12346 -1.00000 5.50000 20.00000 cm')
+    expect(@pdf.renderer).to receive(:add_content).with('1.00000 0.00000 0.12346 -1.00000 5.50000 20.00000 cm')
     @pdf.transformation_matrix 1, 0, 0.123456789, -1.0, 5.5, 20
   end
 
   it "should use fixed digits with very small number" do
     values = Array.new(6, 0.000000000001)
     string = Array.new(6, "0.00000").join " "
-    @pdf.renderer.expects(:add_content).with("#{string} cm")
+    expect(@pdf.renderer).to receive(:add_content).with("#{string} cm")
     @pdf.transformation_matrix(*values)
   end
 
@@ -523,12 +561,13 @@ describe "When using transformation matrix" do
   it "should save the graphics state inside the given block" do
     values = Array.new(6, 0.000000000001)
     string = Array.new(6, "0.00000").join " "
-    process = sequence "process"
 
-    @pdf.expects(:save_graphics_state).with.in_sequence(process)
-    @pdf.renderer.expects(:add_content).with("#{string} cm").in_sequence(process)
-    @pdf.expects(:do_something).with.in_sequence(process)
-    @pdf.expects(:restore_graphics_state).with.in_sequence(process)
+    expect(@pdf).to receive(:save_graphics_state).with(no_args).ordered
+    allow(@pdf.renderer).to receive(:add_content).with(any_args).twice
+    expect(@pdf.renderer).to receive(:add_content).with("#{string} cm").ordered
+    allow(@pdf).to receive(:do_something).ordered
+    expect(@pdf).to receive(:restore_graphics_state).with(no_args).ordered
+
     @pdf.transformation_matrix(*values) do
       @pdf.do_something
     end
@@ -547,7 +586,7 @@ describe "When using transformations shortcuts" do
 
   describe "#rotate" do
     it "should rotate" do
-      @pdf.expects(:transformation_matrix).with(@cos, @sin, -@sin, @cos, 0, 0)
+      expect(@pdf).to receive(:transformation_matrix).with(@cos, @sin, -@sin, @cos, 0, 0)
       @pdf.rotate(@angle)
     end
   end
@@ -603,14 +642,14 @@ describe "When using transformations shortcuts" do
   describe "#translate" do
     it "should translate" do
       x, y = 12, 54.32
-      @pdf.expects(:transformation_matrix).with(1, 0, 0, 1, x, y)
+      expect(@pdf).to receive(:transformation_matrix).with(1, 0, 0, 1, x, y)
       @pdf.translate(x, y)
     end
   end
 
   describe "#scale" do
     it "should scale" do
-      @pdf.expects(:transformation_matrix).with(@factor, 0, 0, @factor, 0, 0)
+      expect(@pdf).to receive(:transformation_matrix).with(@factor, 0, 0, @factor, 0, 0)
       @pdf.scale(@factor)
     end
   end

data/spec/image_handler_spec.rb

@@ -5,11 +5,11 @@ require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
 describe "ImageHandler" do
   let(:image_handler) { Prawn::ImageHandler.new }
 
-  let(:handler_a) { mock("Handler A") }
-  let(:handler_b) { mock("Handler B") }
+  let(:handler_a) { double("Handler A") }
+  let(:handler_b) { double("Handler B") }
 
   it "finds the image handler for an image" do
-    handler_a.expects(:can_render? => true)
+    allow(handler_a).to receive(:can_render?).and_return(true)
 
     image_handler.register(handler_a)
     image_handler.register(handler_b)
@@ -19,7 +19,7 @@ describe "ImageHandler" do
   end
 
   it "can prepend handlers" do
-    handler_b.expects(:can_render? => true)
+    allow(handler_b).to receive(:can_render?).and_return(true)
 
     image_handler.register(handler_a)
     image_handler.register!(handler_b)
@@ -29,7 +29,7 @@ describe "ImageHandler" do
   end
 
   it "can unregister a handler" do
-    handler_b.expects(:can_render? => true)
+    allow(handler_b).to receive(:can_render?).and_return(true)
 
     image_handler.register(handler_a)
     image_handler.register(handler_b)
@@ -41,8 +41,8 @@ describe "ImageHandler" do
   end
 
   it "raises an error when no matching handler is found" do
-    handler_a.expects(:can_render? => false)
-    handler_b.expects(:can_render? => false)
+    allow(handler_a).to receive(:can_render?).and_return(false)
+    allow(handler_b).to receive(:can_render?).and_return(false)
 
     image_handler.register(handler_a)
     image_handler.register(handler_b)

data/spec/images_spec.rb

@@ -114,7 +114,7 @@ describe "the image() function" do
   end
 
   it "should not start a new page just for a stretchy bounding box" do
-    @pdf.expects(:start_new_page).times(0)
+    expect(@pdf).to_not receive(:start_new_page)
     @pdf.bounding_box([0, @pdf.cursor], :width => @pdf.bounds.width) do
       @pdf.image @filename
     end

data/spec/png_spec.rb

@@ -95,10 +95,32 @@ describe "When reading an RGB PNG file with transparency (color type 2)" do
 end
 
 describe "When reading an indexed color PNG file with transparency (color type 3)" do
-  it "raises a not supported error" do
-    bin = File.binread("#{Prawn::DATADIR}/images/pal_bk.png")
-    expect { Prawn::Images::PNG.new(bin) }.to(
-      raise_error(Prawn::Errors::UnsupportedImageType))
+  let(:filename) { "#{Prawn::DATADIR}/images/indexed_transparency.png" }
+  let(:color_filename) { "#{Prawn::DATADIR}/images/indexed_transparency_color.dat" }
+  let(:transparency_filename) { "#{Prawn::DATADIR}/images/indexed_transparency_alpha.dat" }
+  let(:img_data) { File.binread(filename) }
+  let(:png) { Prawn::Images::PNG.new(img_data) }
+
+  it "reads the attributes from the header chunk correctly" do
+    expect(png.width).to eq(200)
+    expect(png.height).to eq(200)
+    expect(png.bits).to eq(8)
+    expect(png.color_type).to eq(3)
+    expect(png.compression_method).to eq(0)
+    expect(png.filter_method).to eq(0)
+    expect(png.interlace_method).to eq(0)
+  end
+
+  it "reads the image data correctly" do
+    data = Zlib::Inflate.inflate(File.binread(color_filename))
+    expect(png.img_data).to eq(data)
+  end
+
+  it "reads the image transparency correctly" do
+    png.split_alpha_channel!
+
+    data = Zlib::Inflate.inflate(File.binread(transparency_filename))
+    expect(png.alpha_channel).to eq(data)
   end
 end
 

data/spec/repeater_spec.rb

@@ -7,7 +7,7 @@ describe "Repeaters" do
     orig_count = Prawn::Repeater.count
 
     doc = sample_document
-    doc.expects(:create_stamp).with("prawn_repeater(#{orig_count})")
+    expect(doc).to receive(:create_stamp).with("prawn_repeater(#{orig_count})")
 
     r = repeater(doc, :all) { :do_nothing }
 
@@ -18,7 +18,7 @@ describe "Repeaters" do
     doc = sample_document
     r = repeater(doc, :all) { :do_nothing }
 
-    expect((1..doc.page_count).all? { |i| r.match?(i) }).to be_true
+    expect((1..doc.page_count).all? { |i| r.match?(i) }).to eq true
   end
 
   it "must provide an :odd filter" do
@@ -27,8 +27,8 @@ describe "Repeaters" do
 
     odd, even = (1..doc.page_count).partition(&:odd?)
 
-    expect(odd.all? { |i| r.match?(i) }).to be_true
-    expect(even.any? { |i| r.match?(i) }).to be_false
+    expect(odd.all? { |i| r.match?(i) }).to eq true
+    expect(even.any? { |i| r.match?(i) }).to eq false
   end
 
   it "must be able to filter by an array of page numbers" do
@@ -54,7 +54,7 @@ describe "Repeaters" do
 
   it "must try to run a stamp if the page number matches" do
     doc = sample_document
-    doc.expects(:stamp)
+    expect(doc).to receive(:stamp)
 
     repeater(doc, :odd).run(3)
   end
@@ -62,28 +62,28 @@ describe "Repeaters" do
   it "must not try to run a stamp unless the page number matches" do
     doc = sample_document
 
-    doc.expects(:stamp).never
+    expect(doc).to_not receive(:stamp)
     repeater(doc, :odd).run(2)
   end
 
   it "must not try to run a stamp if dynamic is selected" do
     doc = sample_document
 
-    doc.expects(:stamp).never
+    expect(doc).to_not receive(:stamp)
     (1..10).each { |p| repeater(doc, :all, true){ :do_nothing }.run(p) }
   end
 
   it "must try to run a block if the page number matches" do
     doc = sample_document
 
-    doc.expects(:draw_text).twice
+    expect(doc).to receive(:draw_text).twice
     (1..10).each { |p| repeater(doc, [1, 2], true){ doc.draw_text "foo" }.run(p) }
   end
 
   it "must not try to run a block unless the page number matches" do
     doc = sample_document
 
-    doc.expects(:draw_text).never
+    expect(doc).to_not receive(:draw_text)
     repeater(doc, :odd, true){ doc.draw_text "foo" }.run(2)
   end
 

data/spec/spec_helper.rb

@@ -18,7 +18,6 @@ Prawn.debug = true
 Prawn::Font::AFM.hide_m17n_warning = true
 
 require "rspec"
-require "mocha/api"
 require "pdf/reader"
 require "pdf/inspector"
 
@@ -27,9 +26,7 @@ require "pdf/inspector"
 Dir[File.dirname(__FILE__) + "/extensions/**/*.rb"].each { |f| require f }
 
 RSpec.configure do |config|
-  config.mock_framework = :mocha
   config.include EncodingHelpers
-  config.treat_symbols_as_metadata_keys_with_true_values = true
 end
 
 def create_pdf(klass = Prawn::Document)
@@ -41,7 +38,7 @@ RSpec::Matchers.define :have_parseable_xobjects do
     expect { PDF::Inspector::XObject.analyze(actual.render) }.not_to raise_error
     true
   end
-  failure_message_for_should do |actual|
+  failure_message do |actual|
     "expected that #{actual}'s XObjects could be successfully parsed"
   end
 end

data/spec/text_at_spec.rb

@@ -58,7 +58,7 @@ describe "#draw_text" do
 
     text = rotated_text_inspector.analyze(@pdf.render)
 
-    expect(text.tm_operator_used).to(be_true)
+    expect(text.tm_operator_used).to eq true
   end
 
   it "should not use rotation matrix by default" do
@@ -66,7 +66,7 @@ describe "#draw_text" do
 
     text = rotated_text_inspector.analyze(@pdf.render)
 
-    expect(text.tm_operator_used).to(be_false)
+    expect(text.tm_operator_used).to eq false
   end
 
   it "should allow overriding default font for a single instance" do

data/spec/text_box_spec.rb

@@ -3,43 +3,45 @@
 require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
 
 describe "Text::Box#nothing_printed?" do
-  it "should be_true when nothing printed" do
+  it "returns true when nothing printed" do
     create_pdf
     string = "Hello world, how are you?\nI'm fine, thank you."
     text_box = Prawn::Text::Box.new(string,
                                     :height => 2,
                                     :document => @pdf)
     text_box.render
-    expect(text_box.nothing_printed?).to be_true
+    expect(text_box.nothing_printed?).to eq true
   end
-  it "should be_false when something printed" do
+
+  it "returns false when something printed" do
     create_pdf
     string = "Hello world, how are you?\nI'm fine, thank you."
     text_box = Prawn::Text::Box.new(string,
                                     :height => 14,
                                     :document => @pdf)
     text_box.render
-    expect(text_box.nothing_printed?).to be_false
+    expect(text_box.nothing_printed?).to eq false
   end
 end
 
 describe "Text::Box#everything_printed?" do
-  it "should be_false when not everything printed" do
+  it "returns false when not everything printed" do
     create_pdf
     string = "Hello world, how are you?\nI'm fine, thank you."
     text_box = Prawn::Text::Box.new(string,
                                     :height => 14,
                                     :document => @pdf)
     text_box.render
-    expect(text_box.everything_printed?).to be_false
+    expect(text_box.everything_printed?).to eq false
   end
-  it "should be_true when everything printed" do
+
+  it "returns true when everything printed" do
     create_pdf
     string = "Hello world, how are you?\nI'm fine, thank you."
     text_box = Prawn::Text::Box.new(string,
                                     :document => @pdf)
     text_box.render
-    expect(text_box.everything_printed?).to be_true
+    expect(text_box.everything_printed?).to eq true
   end
 end
 
@@ -186,28 +188,30 @@ describe "Text::Box with :draw_text_callback" do
   before(:each) { create_pdf }
 
   it "hits the callback whenever text is drawn" do
-    draw_block = stub
-    draw_block.expects(:kick).with("this text is long enough to")
-    draw_block.expects(:kick).with("span two lines")
+    draw_block = spy("Draw block")
 
     @pdf.text_box "this text is long enough to span two lines",
                   :width => 150,
                   :draw_text_callback => lambda { |text, _| draw_block.kick(text) }
+
+    expect(draw_block).to have_received(:kick).with("this text is long enough to")
+    expect(draw_block).to have_received(:kick).with("span two lines")
   end
 
   it "hits the callback once per fragment for :inline_format" do
-    draw_block = stub
-    draw_block.expects(:kick).with("this text has ")
-    draw_block.expects(:kick).with("fancy")
-    draw_block.expects(:kick).with(" formatting")
+    draw_block = spy("Draw block")
 
     @pdf.text_box "this text has <b>fancy</b> formatting",
                   :inline_format => true, :width => 500,
                   :draw_text_callback => lambda { |text, _| draw_block.kick(text) }
+
+    expect(draw_block).to have_received(:kick).with("this text has ")
+    expect(draw_block).to have_received(:kick).with("fancy")
+    expect(draw_block).to have_received(:kick).with(" formatting")
   end
 
   it "does not call #draw_text!" do
-    @pdf.expects(:draw_text!).never
+    expect(@pdf).to_not receive(:draw_text!)
     @pdf.text_box "some text", :width => 500,
                                :draw_text_callback => lambda { |_, _| }
   end