alphasights-prawn 0.10.0

data/spec/annotations_spec.rb

@@ -0,0 +1,90 @@
+# encoding: utf-8
+
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")  
+                               
+class PageAnnotations
+  attr_reader :pages
+
+  def self.parse(document)
+    receiver = new
+    PDF::Reader.string(document.render, receiver)
+    return receiver
+  end
+
+  def initialize
+    @pages = []
+  end
+
+  def begin_page(params)
+    @pages << params
+  end
+end
+
+describe "When creating annotations" do 
+ 
+  before(:each) { create_pdf }
+  
+  it "should append annotation to current page" do 
+    @pdf.start_new_page
+    @pdf.annotate(:Rect => [0,0,10,10], :Subtype => :Text, :Contents => "Hello world!")
+    obj = PageAnnotations.parse(@pdf)
+    obj.pages[0][:Annots].nil?.should == true
+    obj.pages[1][:Annots].length.should == 1
+  end
+
+  it "should force :Type to be :Annot" do
+    opts = @pdf.annotate(:Rect => [0,0,10,10], :Subtype => :Text, :Contents => "Hello world!")
+    opts[:Type].should == :Annot
+    opts = @pdf.annotate(:Type => :Bogus, :Rect => [0,0,10,10], :Subtype => :Text, :Contents => "Hello world!")
+    opts[:Type].should == :Annot
+  end
+
+end
+
+describe "When creating text annotations" do
+ 
+  before(:each) do
+    @rect = [0,0,10,10]
+    @content = "Hello, world!"
+    create_pdf
+  end
+  
+  it "should build appropriate annotation" do 
+    opts = @pdf.text_annotation(@rect, @content)
+    opts[:Type].should == :Annot
+    opts[:Subtype].should == :Text
+    opts[:Rect].should == @rect
+    opts[:Contents].should == @content
+  end
+
+  it "should merge extra options" do 
+    opts = @pdf.text_annotation(@rect, @content, :Open => true, :Subtype => :Bogus)
+    opts[:Subtype].should == :Text
+    opts[:Open].should == true
+  end
+
+end
+
+describe "When creating link annotations" do
+ 
+  before(:each) do
+    @rect = [0,0,10,10]
+    @dest = "home"
+    create_pdf
+  end
+  
+  it "should build appropriate annotation" do 
+    opts = @pdf.link_annotation(@rect, :Dest => @dest)
+    opts[:Type].should == :Annot
+    opts[:Subtype].should == :Link
+    opts[:Rect].should == @rect
+    opts[:Dest].should == @dest
+  end
+
+  it "should merge extra options" do 
+    opts = @pdf.link_annotation(@rect, :Dest => @dest, :Subtype => :Bogus)
+    opts[:Subtype].should == :Link
+    opts[:Dest].should == @dest
+  end
+
+end

data/spec/bounding_box_spec.rb

@@ -0,0 +1,190 @@
+# encoding: utf-8
+
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
+
+describe "A bounding box" do
+
+  before(:each) do
+    @x      = 100
+    @y      = 125
+    @width  = 50
+    @height = 75
+    @box = Prawn::Document::BoundingBox.new(nil, [@x,@y], :width  => @width,
+                                                          :height => @height )
+  end
+
+  it "should have an anchor at (x, y - height)" do
+    @box.anchor.should == [@x,@y-@height]           
+  end
+
+  it "should have a left boundary of 0" do
+    @box.left.should == 0
+  end
+  
+  it "should have a right boundary equal to the width" do
+    @box.right.should == @width
+  end
+  
+  it "should have a top boundary of height" do
+    @box.top.should == @height
+  end
+  
+  it "should have a bottom boundary of 0" do
+    @box.bottom.should == 0
+  end
+
+  it "should have a top-left of [0,height]" do
+    @box.top_left.should == [0,@height]
+  end
+
+  it "should have a top-right of [width,height]" do
+    @box.top_right.should == [@width,@height]
+  end
+
+  it "should have a bottom-left of [0,0]" do
+    @box.bottom_left.should == [0,0]
+  end
+
+  it "should have a bottom-right of [width,0]" do
+    @box.bottom_right.should == [@width,0]
+  end
+
+  it "should have an absolute left boundary of x" do
+    @box.absolute_left.should == @x
+  end
+  
+  it "should have an absolute right boundary of x + width" do
+    @box.absolute_right.should == @x + @width
+  end
+  
+  it "should have an absolute top boundary of y" do
+    @box.absolute_top.should == @y
+  end
+  
+  it "should have an absolute bottom boundary of y - height" do
+    @box.absolute_bottom.should == @y - @height
+  end
+
+  it "should have an absolute bottom-left of [x,y-height]" do
+    @box.absolute_bottom_left.should == [@x, @y - @height]
+  end
+
+  it "should have an absolute bottom-right of [x+width,y-height]" do
+    @box.absolute_bottom_right.should == [@x + @width , @y - @height]
+  end
+
+  it "should have an absolute top-left of [x,y]" do
+    @box.absolute_top_left.should == [@x, @y]
+  end
+
+  it "should have an absolute top-right of [x+width,y]" do
+    @box.absolute_top_right.should == [@x + @width, @y]
+  end
+
+  it "should require width to be set" do
+    assert_raises(ArgumentError) do
+      Prawn::Document::BoundingBox.new(nil, [100,100])
+    end
+  end
+
+end
+
+describe "drawing bounding boxes" do    
+  
+  before(:each) { create_pdf }   
+
+  it "should restore the margin box when bounding box exits" do
+    margin_box = @pdf.bounds
+
+    @pdf.bounding_box [100,500], :width => 100 do
+      #nothing
+    end
+
+    @pdf.bounds.should == margin_box
+
+  end
+
+  it "should restore the parent bounding box when calls are nested" do
+    @pdf.bounding_box [100,500], :width => 300, :height => 300 do 
+
+      @pdf.bounds.absolute_top.should  == 500 + @pdf.margin_box.absolute_bottom
+      @pdf.bounds.absolute_left.should == 100 + @pdf.margin_box.absolute_left
+
+      parent_box = @pdf.bounds
+
+      @pdf.bounding_box [50,200], :width => 100, :height => 100 do
+        @pdf.bounds.absolute_top.should == 200 + parent_box.absolute_bottom
+        @pdf.bounds.absolute_left.should == 50 + parent_box.absolute_left
+      end
+
+      @pdf.bounds.absolute_top.should  == 500 + @pdf.margin_box.absolute_bottom
+      @pdf.bounds.absolute_left.should == 100 + @pdf.margin_box.absolute_left
+
+    end
+  end   
+  
+  it "should calculate a height if none is specified" do 
+    @pdf.bounding_box([100, 500], :width => 100) do
+      @pdf.text "The rain in Spain falls mainly on the plains." 
+    end     
+    
+    @pdf.y.should.be.close 458.384, 0.001 
+  end
+
+  it "should keep track of the max height the box was stretched to" do
+    box = @pdf.bounding_box(@pdf.bounds.top_left, :width => 100) do
+      @pdf.move_down 100
+      @pdf.move_up 15
+    end
+
+    assert_equal 100, box.height
+  end
+  
+end
+
+describe "Indentation" do
+  before(:each) { create_pdf }
+
+  it "should temporarily shift the x coordinate and width" do
+    @pdf.bounding_box([100,100], :width => 200) do
+      @pdf.indent(20) do
+        @pdf.bounds.absolute_left.should == 120
+        @pdf.bounds.width.should == 180
+      end
+    end
+  end
+
+  it "should restore the x coordinate and width after block exits" do
+    @pdf.bounding_box([100,100], :width => 200) do
+      @pdf.indent(20) do
+        # no-op
+      end
+      @pdf.bounds.absolute_left.should == 100
+      @pdf.bounds.width.should == 200
+    end
+  end
+
+  it "should restore the x coordinate and width on error" do
+    @pdf.bounding_box([100,100], :width => 200) do
+      begin
+        @pdf.indent(20) { raise }
+      rescue
+        @pdf.bounds.absolute_left.should == 100
+        @pdf.bounds.width.should == 200
+      end
+    end
+  end
+
+end
+
+describe "A canvas" do
+  before(:each) { create_pdf }
+  
+  it "should use whatever the last set y position is" do
+    @pdf.canvas do
+      @pdf.bounding_box([100,500],:width => 200) { @pdf.move_down 50 }
+    end
+    @pdf.y.should == 450
+  end
+end      
+  

data/spec/cell_spec.rb

@@ -0,0 +1,348 @@
+# encoding: utf-8
+
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")  
+
+module CellHelpers
+
+  # Build, but do not draw, a cell on @pdf.
+  # TODO: differentiate class based on :content.
+  def cell(options={})
+    at = options[:at] || [0, @pdf.cursor]
+    Prawn::Table::Cell::Text.new(@pdf, at, options)
+  end
+
+  def close?(actual, expected, epsilon=0.01)
+    (actual - expected).abs < epsilon
+  end
+
+end
+
+describe "Prawn::Table::Cell" do
+  before(:each) do
+    @pdf = Prawn::Document.new
+  end
+
+  describe "Prawn::Document#cell" do
+    include CellHelpers
+
+    it "should draw the cell" do
+      Prawn::Table::Cell::Text.any_instance.expects(:draw).once
+      @pdf.cell(:content => "text")
+    end
+
+    it "should return a Cell" do
+      @pdf.cell(:content => "text").should.be.a.kind_of Prawn::Table::Cell
+    end
+
+    it "should generate an empty cell from nil content" do
+      c = @pdf.cell(:content => nil)
+      c.should.be.a.kind_of Prawn::Table::Cell::Text
+      c.content.should == ""
+    end
+
+    it "should draw text at the given point plus padding, with the given " +
+       "size and style" do
+      @pdf.expects(:bounding_box).yields
+      @pdf.expects(:move_down)
+      @pdf.expects(:draw_text!).with { |text, options| text == "hello world" }
+
+      @pdf.cell(:content => "hello world", 
+                :at => [10, 20],
+                :padding => [30, 40],
+                :size => 7, 
+                :style => :bold)
+    end
+  end
+
+  describe "cell width" do
+    include CellHelpers
+
+    it "should be calculated for text" do
+      c = cell(:content => "text")
+      c.width.should == @pdf.width_of("text") + c.padding[1] + c.padding[3]
+    end
+
+    it "should be overridden by manual :width" do
+      c = cell(:content => "text", :width => 400)
+      c.width.should == 400
+    end
+
+    it "should incorporate padding when specified" do
+      c = cell(:content => "text", :padding => [1, 2, 3, 4])
+      c.width.should.be.close(@pdf.width_of("text") + 6, 0.01)
+    end
+
+    it "should allow width to be reset after it has been calculated" do
+      # to ensure that if we memoize width, it can still be overridden
+      c = cell(:content => "text")
+      c.width
+      c.width = 400
+      c.width.should == 400
+    end
+
+    it "should return proper width with size set" do
+      text = "text " * 4
+      c = cell(:content => text, :size => 7)
+      c.width.should == 
+        @pdf.width_of(text, :size => 7) + c.padding[1] + c.padding[3]
+    end
+
+    it "content_width should exclude padding" do
+      c = cell(:content => "text", :padding => 10)
+      c.content_width.should == @pdf.width_of("text")
+    end
+
+    it "content_width should exclude padding even with manual :width" do
+      c = cell(:content => "text", :padding => 10, :width => 400)
+      c.content_width.should.be.close(380, 0.01)
+    end
+
+    it "should have a reasonable minimum width that can fit @content" do
+      c = cell(:content => "text", :padding => 10)
+      min_content_width = c.min_width - c.padding[1] - c.padding[3]
+
+      lambda { @pdf.height_of("text", :width => min_content_width) }.
+        should.not.raise(Prawn::Errors::CannotFit)
+
+      @pdf.height_of("text", :width => min_content_width).should.be <
+        (5 * @pdf.height_of("text"))
+    end
+
+  end
+
+  describe "cell height" do
+    include CellHelpers
+
+    it "should be calculated for text" do
+      c = cell(:content => "text")
+      c.height.should == 
+        @pdf.height_of("text", :width => @pdf.width_of("text")) +
+        c.padding[0] + c.padding[3]
+    end
+
+    it "should be overridden by manual :height" do
+      c = cell(:content => "text", :height => 400)
+      c.height.should == 400
+    end
+
+    it "should incorporate :padding when specified" do
+      c = cell(:content => "text", :padding => [1, 2, 3, 4])
+      c.height.should.be.close(1 + 3 +
+        @pdf.height_of("text", :width => @pdf.width_of("text")), 0.01)
+    end
+
+    it "should allow height to be reset after it has been calculated" do
+      # to ensure that if we memoize height, it can still be overridden
+      c = cell(:content => "text")
+      c.height
+      c.height = 400
+      c.height.should == 400
+    end
+
+    it "should return proper height for blocks of text" do
+      content = "words " * 10
+      c = cell(:content => content, :width => 100)
+      c.height.should == @pdf.height_of(content, :width => 100) +
+        c.padding[0] + c.padding[2]
+    end
+
+    it "should return proper height for blocks of text with size set" do
+      content = "words " * 10
+      c = cell(:content => content, :width => 100, :size => 7)
+
+      correct_content_height = nil
+      @pdf.font_size(7) do
+        correct_content_height = @pdf.height_of(content, :width => 100)
+      end
+
+      c.height.should == correct_content_height + c.padding[0] + c.padding[2]
+    end
+
+    it "content_height should exclude padding" do
+      c = cell(:content => "text", :padding => 10)
+      c.content_height.should == @pdf.height_of("text")
+    end
+    
+    it "content_height should exclude padding even with manual :height" do
+      c = cell(:content => "text", :padding => 10, :height => 400)
+      c.content_height.should.be.close(380, 0.01)
+    end
+  end
+
+  describe "cell padding" do
+    include CellHelpers
+
+    it "should default to zero" do
+      c = cell(:content => "text")
+      c.padding.should == [5, 5, 5, 5]
+    end
+
+    it "should accept a numeric value, setting all padding" do
+      c = cell(:content => "text", :padding => 10)
+      c.padding.should == [10, 10, 10, 10]
+    end
+
+    it "should accept [v,h]" do
+      c = cell(:content => "text", :padding => [20, 30])
+      c.padding.should == [20, 30, 20, 30]
+    end
+    
+    it "should accept [t,h,b]" do
+      c = cell(:content => "text", :padding => [10, 20, 30])
+      c.padding.should == [10, 20, 30, 20]
+    end
+
+    it "should accept [t,l,b,r]" do
+      c = cell(:content => "text", :padding => [10, 20, 30, 40])
+      c.padding.should == [10, 20, 30, 40]
+    end
+
+    it "should reject other formats" do
+      lambda{
+        cell(:content => "text", :padding => [10])
+      }.should.raise(ArgumentError)
+    end
+  end
+
+  describe "background_color" do
+    include CellHelpers
+
+    it "should fill a rectangle with the given background color" do
+      @pdf.stubs(:mask).yields
+      @pdf.expects(:mask).with(:fill_color).yields
+
+      @pdf.stubs(:fill_color)
+      @pdf.expects(:fill_color).with('123456')
+      @pdf.expects(:fill_rectangle).with do |(x, y), w, h|
+        close?(x, 0) && close?(y, @pdf.cursor) && 
+          close?(w, 29.344) && close?(h, 23.872)
+      end
+      @pdf.cell(:content => "text", :background_color => '123456')
+    end
+  end
+
+  describe "color" do
+    it "should set fill color when :text_color is provided" do
+      pdf = Prawn::Document.new
+      pdf.stubs(:fill_color)
+      pdf.expects(:fill_color).with('555555')
+      pdf.cell :content => 'foo', :text_color => '555555'
+    end
+
+    it "should reset the fill color to the original one" do
+      pdf = Prawn::Document.new
+      pdf.fill_color = '333333'
+      pdf.cell :content => 'foo', :text_color => '555555'
+      pdf.fill_color.should == '333333'
+    end
+  end
+
+  describe "Borders" do
+    it "should draw all borders by default" do
+      @pdf.expects(:stroke_line).times(4)
+      @pdf.cell(:content => "text")
+    end
+
+    it "should draw all borders when requested" do
+      @pdf.expects(:stroke_line).times(4)
+      @pdf.cell(:content => "text", :borders => [:top, :right, :bottom, :left])
+    end
+
+    # Only roughly verifying the integer coordinates so that we don't have to
+    # do any FP closeness arithmetic. Can plug in that math later if this goes
+    # wrong.
+    it "should draw top border when requested" do
+      @pdf.expects(:stroke_line).with { |*from_and_to|
+        #                                  from: x  y to: x  y
+        from_and_to.flatten.map{|x| x.round} == [0, 720, 29, 720]
+      }
+      @pdf.cell(:content => "text", :borders => [:top])
+    end
+
+    it "should draw bottom border when requested" do
+      @pdf.expects(:stroke_line).with { |*from_and_to|
+        from_and_to.flatten.map{|x| x.round} == [0, 696, 29, 696]
+      }
+      @pdf.cell(:content => "text", :borders => [:bottom])
+    end
+
+    it "should draw left border when requested" do
+      @pdf.expects(:stroke_line).with { |*from_and_to|
+        from_and_to.flatten.map{|x| x.round} == [0, 721, 0, 696]
+      }
+      @pdf.cell(:content => "text", :borders => [:left])
+    end
+
+    it "should draw right border when requested" do
+      @pdf.expects(:stroke_line).with { |*from_and_to|
+        from_and_to.flatten.map{|x| x.round} == [29, 721, 29, 696]
+      }
+      @pdf.cell(:content => "text", :borders => [:right])
+    end
+  end
+
+  describe "Text cell attributes" do
+    include CellHelpers
+
+    it "should pass through text options like :align to Text::Box" do
+      c = cell(:content => "text", :align => :right)
+
+      box = Prawn::Text::Box.new("text", :document => @pdf)
+
+      Prawn::Text::Box.expects(:new).with do |text, options|
+        text == "text" && options[:align] == :right
+      end.at_least_once.returns(box)
+
+      c.draw
+    end
+
+    it "should allow inline formatting in cells" do
+      c = cell(:content => "foo <b>bar</b> baz", :inline_format => true)
+
+      box = Prawn::Text::Formatted::Box.new([], :document => @pdf)
+
+      Prawn::Text::Formatted::Box.expects(:new).with do |array, options|
+        array[0][:text] == "foo " && array[0][:styles] == [] &&
+          array[1][:text] == "bar" && array[1][:styles] == [:bold] &&
+          array[2][:text] == " baz" && array[2][:styles] == []
+      end.at_least_once.returns(box)
+
+      c.draw
+    end
+
+  end
+
+  describe "Font handling" do
+    include CellHelpers
+
+    it "should allow only :style to be specified, defaulting to the" +
+       "document's font" do
+      c = cell(:content => "text", :style => :bold)
+      c.font.name.should == 'Helvetica-Bold'
+    end
+
+    it "should accept a font name for :font" do
+      c = cell(:content => "text", :font => 'Helvetica-Bold')
+      c.font.name.should == 'Helvetica-Bold'
+    end
+
+    it "should allow style to be changed after initialize" do
+      c = cell(:content => "text")
+      c.style = :bold
+      c.font.name.should == 'Helvetica-Bold'
+    end
+
+    it "should default to the document's font, if none is specified" do
+      c = cell(:content => "text")
+      c.font.should == @pdf.font
+    end
+
+    it "should use the metrics of the selected font (even if it is a variant " +
+       "of the document's font) to calculate width" do
+      c = cell(:content => "text", :style => :bold)
+      font = @pdf.find_font('Helvetica-Bold')
+      c.content_width.should == font.compute_width_of("text")
+    end
+  end
+
+end