prawn 1.1.0 → 1.2.1

data/manual/table/creation.rb

@@ -1,27 +0,0 @@
-# encoding: utf-8
-#
-# Creating tables with Prawn is fairly easy. There are two methods that will
-# create tables for us <code>table</code> and <code>make_table</code>.
-#
-# Both are wrappers that create a new <code>Prawn::Table</code> object. The
-# difference is that <code>table</code> calls the <code>draw</code> method
-# after creating the table and <code>make_table</code> only returns the created
-# table, so you have to call the <code>draw</code> method yourself.
-#
-# The most simple table can be created by providing only an array of arrays
-# containing your data where each inner array represents one row.
-#
-require File.expand_path(File.join(File.dirname(__FILE__),
-                                   %w[.. example_helper]))
-
-filename = File.basename(__FILE__).gsub('.rb', '.pdf')
-Prawn::ManualBuilder::Example.generate(filename) do
-  t = make_table([ ["this is the first row"],
-                   ["this is the second row"] ])
-  t.draw
-  move_down 20
-
-  table([ ["short", "short", "loooooooooooooooooooong"],
-          ["short", "loooooooooooooooooooong", "short"],
-          ["loooooooooooooooooooong", "short", "short"] ])
-end

data/manual/table/filtering.rb

@@ -1,36 +0,0 @@
-# encoding: utf-8
-#
-# Another way to reduce the number of cells is to <code>filter</code> the table.
-#
-# <code>filter</code> is just like <code>Enumerable#select</code>. Pass it a
-# block and it will iterate through the cells returning a new
-# <code>Prawn::Table::Cells</code> instance containing only those cells for
-# which the block was not false.
-#
-require File.expand_path(File.join(File.dirname(__FILE__),
-                                   %w[.. example_helper]))
-
-filename = File.basename(__FILE__).gsub('.rb', '.pdf')
-Prawn::ManualBuilder::Example.generate(filename) do
-  data = [ ["Item", "Jan Sales", "Feb Sales"],
-           ["Oven", 17, 89],
-           ["Fridge", 62, 30],
-           ["Microwave", 71, 47]
-         ]
-
-  table(data) do
-    values = cells.columns(1..-1).rows(1..-1)
-
-    bad_sales = values.filter do |cell|
-      cell.content.to_i < 40
-    end
-
-    bad_sales.background_color = "FFAAAA"
-
-    good_sales = values.filter do |cell|
-      cell.content.to_i > 70
-    end
-
-    good_sales.background_color = "AAFFAA"
-  end
-end

data/manual/table/flow_and_header.rb

@@ -1,17 +0,0 @@
-# encoding: utf-8
-#
-# If the table cannot fit on the current page it will flow to the next page just
-# like free flowing text. If you would like to have the first row treated as a
-# header which will be repeated on subsequent pages set the <code>:header</code>
-# option to true.
-#
-require File.expand_path(File.join(File.dirname(__FILE__),
-                                   %w[.. example_helper]))
-
-filename = File.basename(__FILE__).gsub('.rb', '.pdf')
-Prawn::ManualBuilder::Example.generate(filename) do
-  data = [["This row should be repeated on every new page"]]
-  data += [["..."]] * 30
-
-  table(data, :header => true)
-end

data/manual/table/image_cells.rb

@@ -1,33 +0,0 @@
-# encoding: utf-8
-#
-# Prawn can insert images into a table. Just pass a hash into
-# <code>table()</code> with an <code>:image</code> key pointing to the image.
-#
-# You can pass the <code>:scale</code>, <code>:fit</code>,
-# <code>:position</code>, and <code>:vposition</code> arguments in alongside
-# <code>:image</code>; these will function just as in <code>image()</code>.
-#
-# The <code>:image_width</code> and <code>:image_height</code> arguments set
-# the width/height of the image within the cell, as opposed to the
-# <code>:width</code> and <code>:height</code> arguments, which set the table
-# cell's dimensions.
-#
-require File.expand_path(File.join(File.dirname(__FILE__),
-                                   %w[.. example_helper]))
-
-filename = File.basename(__FILE__).gsub('.rb', '.pdf')
-Prawn::ManualBuilder::Example.generate(filename) do
-  image = "#{Prawn::DATADIR}/images/prawn.png"
-
-  table [
-    ["Standard image cell",   {:image => image}],
-    [":scale => 0.5",         {:image => image, :scale => 0.5}],
-    [":fit => [100, 200]",    {:image => image, :fit => [100, 200]}],
-    [":image_height => 50,
-      :image_width => 100",   {:image => image, :image_height => 50,
-                                                :image_width  => 100}],
-    [":position => :center",  {:image => image, :position  => :center}],
-    [":vposition => :center", {:image => image, :vposition => :center,
-                                                :height => 200}]
-  ], :width => bounds.width
-end

data/manual/table/position.rb

@@ -1,29 +0,0 @@
-# encoding: utf-8
-#
-# The <code>table()</code> method accepts a <code>:position</code> argument to
-# determine horizontal position of the table within its bounding box. It can be
-# <code>:left</code> (the default), <code>:center</code>, <code>:right</code>,
-# or a number specifying a distance in PDF points from the left side.
-#
-require File.expand_path(File.join(File.dirname(__FILE__),
-                                   %w[.. example_helper]))
-
-filename = File.basename(__FILE__).gsub('.rb', '.pdf')
-Prawn::ManualBuilder::Example.generate(filename) do
-  data = [["The quick brown fox jumped over the lazy dogs."]] * 2
-
-  text "Left:"
-  table data, :position => :left
-  move_down 10
-
-  text "Center:"
-  table data, :position => :center
-  move_down 10
-
-  text "Right:"
-  table data, :position => :right
-  move_down 10
-
-  text "100pt:"
-  table data, :position => 100
-end

data/manual/table/row_colors.rb

@@ -1,20 +0,0 @@
-# encoding: utf-8
-#
-# One of the most common table styling techniques is to stripe the rows with
-# alternating colors.
-#
-# There is one helper just for that. Just provide the <code>:row_colors</code>
-# option an array with color values.
-#
-require File.expand_path(File.join(File.dirname(__FILE__),
-                                   %w[.. example_helper]))
-
-filename = File.basename(__FILE__).gsub('.rb', '.pdf')
-Prawn::ManualBuilder::Example.generate(filename) do
-  data = [["This row should have one color"],
-          ["And this row should have another"]]
-
-  data += [["..."]] * 10
-
-  table(data, :row_colors => ["F0F0F0", "FFFFCC"])
-end

data/manual/table/span.rb

@@ -1,30 +0,0 @@
-# encoding: utf-8
-#
-# Table cells can span multiple columns, rows, or both. When building a cell,
-# use the hash argument constructor with a <code>:colspan</code> and/or
-# <code>:rowspan</code> argument. Row or column spanning must be specified when
-# building the data array; you can't set the span in the table's initialization
-# block. This is because cells are laid out in the grid before that block is
-# called, so that references to row and column numbers make sense.
-#
-# Cells are laid out in the order given, skipping any positions spanned by
-# previously instantiated cells. Therefore, a cell with <code>rowspan: 2</code>
-# will be missing at least one cell in the row below it. See the code and table
-# below for an example.
-#
-# It is illegal to overlap cells via spanning. A
-# <code>Prawn::Errors::InvalidTableSpan</code> error will be raised if spans
-# would cause cells to overlap.
-#
-require File.expand_path(File.join(File.dirname(__FILE__),
-                                   %w[.. example_helper]))
-
-filename = File.basename(__FILE__).gsub('.rb', '.pdf')
-Prawn::ManualBuilder::Example.generate(filename) do
-  table([
-    ["A", {:content => "2x1", :colspan => 2}, "B"],
-    [{:content => "1x2", :rowspan => 2}, "C", "D", "E"],
-    [{:content => "2x2", :colspan => 2, :rowspan => 2}, "F"],
-    ["G", "H"]
-  ])
-end

data/manual/table/style.rb

@@ -1,22 +0,0 @@
-# encoding: utf-8
-#
-# We've seen how to apply styles to a selection of cells by setting the
-# individual properties. Another option is to use the <code>style</code> method
-#
-# <code>style</code> lets us define multiple properties at once with a hash. It
-# also accepts a block that will be called for each cell and can be used for
-# some complex styling.
-#
-require File.expand_path(File.join(File.dirname(__FILE__),
-                                   %w[.. example_helper]))
-
-filename = File.basename(__FILE__).gsub('.rb', '.pdf')
-Prawn::ManualBuilder::Example.generate(filename) do
-  table([[""] * 8] * 8) do
-    cells.style(:width => 24, :height => 24)
-
-    cells.style do |c|
-      c.background_color = ((c.row + c.column) % 2).zero? ? '000000' : 'ffffff'
-    end
-  end
-end

data/manual/table/table.rb

@@ -1,52 +0,0 @@
-# encoding: utf-8
-#
-# Examples for tables.
-#
-require File.expand_path(File.join(File.dirname(__FILE__),
-                                   %w[.. example_helper]))
-
-Prawn::ManualBuilder::Example.generate("table.pdf", :page_size => "FOLIO") do
-
-  package "table" do |p|
-
-    p.section "Basics" do |s|
-      s.example "creation"
-      s.example "content_and_subtables"
-      s.example "flow_and_header"
-      s.example "position"
-    end
-
-    p.section "Styling" do |s|
-      s.example "column_widths"
-      s.example "width"
-      s.example "row_colors"
-      s.example "cell_dimensions"
-      s.example "cell_borders_and_bg"
-      s.example "cell_border_lines"
-      s.example "cell_text"
-      s.example "image_cells"
-      s.example "span"
-      s.example "before_rendering_page"
-    end
-
-    p.section "Initializer Block" do |s|
-      s.example "basic_block"
-      s.example "filtering"
-      s.example "style"
-    end
-
-    p.intro do
-      prose("Prawn comes with table support out of the box. Tables can be styled in whatever way you see fit. The whole table, rows, columns and cells can be styled independently from each other.
-
-      The examples show:")
-
-      list( "How to create tables",
-            "What content can be placed on tables",
-            "Subtables (or tables within tables)",
-            "How to style the whole table",
-            "How to use initializer blocks to style only specific portions of the table"
-          )
-    end
-
-  end
-end

data/manual/table/width.rb

@@ -1,27 +0,0 @@
-# encoding: utf-8
-#
-# The default table width depends on the content provided. It will expand up
-# to the current bounding box width to fit the content. If you want the table to
-# have a fixed width no matter the content you may use the <code>:width</code>
-# option to manually set the width.
-#
-require File.expand_path(File.join(File.dirname(__FILE__),
-                                   %w[.. example_helper]))
-
-filename = File.basename(__FILE__).gsub('.rb', '.pdf')
-Prawn::ManualBuilder::Example.generate(filename) do
-  text "Normal width:"
-  table [%w[A B C]]
-  move_down 20
-
-  text "Fixed width:"
-  table([%w[A B C]], :width => 300)
-  move_down 20
-
-  text "Normal width:"
-  table([["A", "Blah " * 20, "C"]])
-  move_down 20
-
-  text "Fixed width:"
-  table([["A", "Blah " * 20, "C"]], :width => 300)
-end

data/spec/cell_spec.rb

@@ -1,629 +0,0 @@
-# encoding: utf-8
-
-require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
-require_relative "../lib/prawn/table"
-
-module CellHelpers
-
-  # Build, but do not draw, a cell on @pdf.
-  def cell(options={})
-    at = options[:at] || [0, @pdf.cursor]
-    Prawn::Table::Cell::Text.new(@pdf, at, options)
-  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 "accepts :content => nil in a hash" do
-      @pdf.cell(:content => nil).should be_a_kind_of(Prawn::Table::Cell::Text)
-      @pdf.make_cell(:content => nil).should be_a_kind_of(Prawn::Table::Cell::Text)
-    end
-
-    it "should convert nil, Numeric, and Date values to strings" do
-      [nil, 123, 123.45, Date.today].each do |value|
-        c = @pdf.cell(:content => value)
-        c.should be_a_kind_of Prawn::Table::Cell::Text
-        c.content.should == value.to_s
-      end
-    end
-
-    it "should allow inline styling with a hash argument" do
-      # used for table([[{:text => "...", :font_style => :bold, ...}, ...]])
-      c = Prawn::Table::Cell.make(@pdf,
-                                  {:content => 'hello', :font_style => :bold})
-      c.should be_a_kind_of Prawn::Table::Cell::Text
-      c.content.should == "hello"
-      c.font.name.should == 'Helvetica-Bold'
-    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,
-                :font_style => :bold)
-    end
-  end
-
-  describe "Prawn::Document#make_cell" do
-    it "should not draw the cell" do
-      Prawn::Table::Cell::Text.any_instance.expects(:draw).never
-      @pdf.make_cell("text")
-    end
-
-    it "should return a Cell" do
-      @pdf.make_cell("text", :size => 7).should be_a_kind_of Prawn::Table::Cell
-    end
-  end
-
-  describe "#style" do
-    include CellHelpers
-
-    it "should set each property in turn" do
-      c = cell(:content => "text")
-
-      c.expects(:padding=).with(50)
-      c.expects(:size=).with(7)
-
-      c.style(:padding => 50, :size => 7)
-    end
-
-    it "ignores unknown properties" do
-      c = cell(:content => 'text')
-
-      c.style(:foobarbaz => 'frobnitz')
-    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_within(0.01).of(@pdf.width_of("text") + 6)
-    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_within(0.01).of(380)
-    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]
-
-      @pdf.height_of("text", :width => min_content_width).should be <
-        (5 * @pdf.height_of("text"))
-    end
-
-    it "should defer min_width's evaluation of padding" do
-      c = cell(:content => "text", :padding => 100)
-      c.padding = 0
-
-      # Make sure we use the new value of padding in calculating min_width
-      c.min_width.should be < 100
-    end
-
-    it "should defer min_width's evaluation of size" do
-      c = cell(:content => "text", :size => 50)
-      c.size = 8
-      c.padding = 0
-      c.min_width.should be < 10
-    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_within(0.01).of(1 + 3 +
-        @pdf.height_of("text", :width => @pdf.width_of("text")))
-    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_within(0.01).of(380)
-    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_error(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).checking do |(x, y), w, h|
-        x.should be_within(0.01).of(0)
-        y.should be_within(0.01).of(@pdf.cursor)
-        w.should be_within(0.01).of(29.344)
-        h.should be_within(0.01).of(23.872)
-      end
-      @pdf.cell(:content => "text", :background_color => '123456')
-    end
-
-    it "should draw the background in the right place if cell is drawn at a " +
-       "different location" 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).checking do |(x, y), w, h|
-        x.should be_within(0.01).of(12.0)
-        y.should be_within(0.01).of(34.0)
-        w.should be_within(0.01).of(29.344)
-        h.should be_within(0.01).of(23.872)
-      end
-      c = @pdf.make_cell(:content => "text", :background_color => '123456')
-      c.draw([12.0, 34.0])
-    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).checking do |from, to|
-        @pdf.map_to_absolute(from).map{|x| x.round}.should == [36, 756]
-        @pdf.map_to_absolute(to).map{|x| x.round}.should == [65, 756]
-      end
-      @pdf.cell(:content => "text", :borders => [:top])
-    end
-
-    it "should draw bottom border when requested" do
-      @pdf.expects(:stroke_line).checking do |from, to|
-        @pdf.map_to_absolute(from).map{|x| x.round}.should == [36, 732]
-        @pdf.map_to_absolute(to).map{|x| x.round}.should == [65, 732]
-      end
-      @pdf.cell(:content => "text", :borders => [:bottom])
-    end
-
-    it "should draw left border when requested" do
-      @pdf.expects(:stroke_line).checking do |from, to|
-        @pdf.map_to_absolute(from).map{|x| x.round}.should == [36, 756]
-        @pdf.map_to_absolute(to).map{|x| x.round}.should == [36, 732]
-      end
-      @pdf.cell(:content => "text", :borders => [:left])
-    end
-
-    it "should draw right border when requested" do
-      @pdf.expects(:stroke_line).checking do |from, to|
-        @pdf.map_to_absolute(from).map{|x| x.round}.should == [65, 756]
-        @pdf.map_to_absolute(to).map{|x| x.round}.should == [65, 732]
-      end
-      @pdf.cell(:content => "text", :borders => [:right])
-    end
-
-    it "should draw borders at the same location when in or out of bbox" do
-      @pdf.expects(:stroke_line).checking do |from, to|
-        @pdf.map_to_absolute(from).map{|x| x.round}.should == [36, 756]
-        @pdf.map_to_absolute(to).map{|x| x.round}.should == [65, 756]
-      end
-      @pdf.bounding_box([0, @pdf.cursor], :width => @pdf.bounds.width) do
-        @pdf.cell(:content => "text", :borders => [:top])
-      end
-    end
-
-    it "should set border color with :border_..._color" do
-      @pdf.ignores(:stroke_color=).with("000000")
-      @pdf.expects(:stroke_color=).with("ff0000")
-
-      c = @pdf.cell(:content => "text", :border_top_color => "ff0000")
-      c.border_top_color.should == "ff0000"
-      c.border_colors[0].should == "ff0000"
-    end
-
-    it "should set border colors with :border_color" do
-      @pdf.ignores(:stroke_color=).with("000000")
-      @pdf.expects(:stroke_color=).with("ff0000")
-      @pdf.expects(:stroke_color=).with("00ff00")
-      @pdf.expects(:stroke_color=).with("0000ff")
-      @pdf.expects(:stroke_color=).with("ff00ff")
-
-      c = @pdf.cell(:content => "text",
-        :border_color => %w[ff0000 00ff00 0000ff ff00ff])
-
-      c.border_colors.should == %w[ff0000 00ff00 0000ff ff00ff]
-    end
-
-    it "border_..._width should return 0 if border not selected" do
-      c = @pdf.cell(:content => "text", :borders => [:top])
-      c.border_bottom_width.should == 0
-    end
-
-    it "should set border width with :border_..._width" do
-      @pdf.ignores(:line_width=).with(1)
-      @pdf.expects(:line_width=).with(2)
-
-      c = @pdf.cell(:content => "text", :border_bottom_width => 2)
-      c.border_bottom_width.should == 2
-      c.border_widths[2].should == 2
-    end
-
-    it "should set border widths with :border_width" do
-      @pdf.ignores(:line_width=).with(1)
-      @pdf.expects(:line_width=).with(2)
-      @pdf.expects(:line_width=).with(3)
-      @pdf.expects(:line_width=).with(4)
-      @pdf.expects(:line_width=).with(5)
-
-      c = @pdf.cell(:content => "text",
-        :border_width => [2, 3, 4, 5])
-      c.border_widths.should == [2, 3, 4, 5]
-    end
-
-    it "should set default border lines to :solid" do
-      c = @pdf.cell(:content => "text")
-      c.border_top_line.should == :solid
-      c.border_right_line.should == :solid
-      c.border_bottom_line.should == :solid
-      c.border_left_line.should == :solid
-      c.border_lines.should == [:solid] * 4
-    end
-
-    it "should set border line with :border_..._line" do
-      c = @pdf.cell(:content => "text", :border_bottom_line => :dotted)
-      c.border_bottom_line.should == :dotted
-      c.border_lines[2].should == :dotted
-    end
-
-    it "should set border lines with :border_lines" do
-      c = @pdf.cell(:content => "text",
-        :border_lines => [:solid, :dotted, :dashed, :solid])
-      c.border_lines.should == [:solid, :dotted, :dashed, :solid]
-    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).checking do |text, options|
-        text.should == "text"
-        options[:align].should == :right
-      end.at_least_once.returns(box)
-
-      c.draw
-    end
-
-    it "should use font_style for Text::Box#style" do
-      c = cell(:content => "text", :font_style => :bold)
-
-      box = Prawn::Text::Box.new("text", :document => @pdf)
-
-      Prawn::Text::Box.expects(:new).checking do |text, options|
-        text.should == "text"
-        options[:style].should == :bold
-      end.at_least_once.returns(box)
-
-      c.draw
-    end
-
-    it "supports variant styles of the current font" do
-      font_path = "#{Prawn::BASEDIR}/data/fonts/Panic+Sans.dfont"
-      @pdf.font_families.merge!("Panic Sans" => {
-        :normal    => { :file => font_path, :font => "PanicSans" },
-        :bold      => { :file => font_path, :font => "PanicSans-Bold" },
-      })
-      @pdf.font "Panic Sans"
-
-      c = cell(:content => "text", :font_style => :bold)
-
-      box = Prawn::Text::Box.new("text", :document => @pdf)
-      Prawn::Text::Box.expects(:new).checking do |text, options|
-        text.should == "text"
-        options[:style].should == :bold
-        @pdf.font.family.should == 'Panic Sans'
-      end.at_least_once.returns(box)
-
-      c.draw
-    end
-
-
-    it "uses the style of the current font if none given" do
-      font_path = "#{Prawn::BASEDIR}/data/fonts/Panic+Sans.dfont"
-      @pdf.font_families.merge!("Panic Sans" => {
-        :normal    => { :file => font_path, :font => "PanicSans" },
-        :bold      => { :file => font_path, :font => "PanicSans-Bold" },
-      })
-      @pdf.font "Panic Sans", :style => :bold
-
-      c = cell(:content => "text")
-
-      box = Prawn::Text::Box.new("text", :document => @pdf)
-      Prawn::Text::Box.expects(:new).checking do |text, options|
-        text.should == "text"
-        @pdf.font.family.should == 'Panic Sans'
-        @pdf.font.options[:style].should == :bold
-      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).checking do |array, options|
-        array[0][:text].should == "foo "
-        array[0][:styles].should == []
-
-        array[1][:text].should == "bar"
-        array[1][:styles].should == [:bold]
-
-        array[2][:text].should == " baz"
-        array[2][:styles].should == []
-      end.at_least_once.returns(box)
-
-      c.draw
-    end
-
-  end
-
-  describe "Font handling" do
-    include CellHelpers
-
-    it "should allow only :font_style to be specified, defaulting to the " +
-       "document's font" do
-      c = cell(:content => "text", :font_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.font_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", :font_style => :bold)
-      font = @pdf.find_font('Helvetica-Bold')
-      c.content_width.should == font.compute_width_of("text")
-    end
-
-    it "should properly calculate inline-formatted text" do
-      c = cell(:content => "<b>text</b>", :inline_format => true)
-      font = @pdf.find_font('Helvetica-Bold')
-      c.content_width.should == font.compute_width_of("text")
-    end
-  end
-end
-
-describe "Image cells" do
-  before(:each) do
-    create_pdf
-  end
-
-  describe "with default options" do
-    before(:each) do
-      @cell = Prawn::Table::Cell.make(@pdf,
-        :image => "#{Prawn::DATADIR}/images/prawn.png")
-    end
-
-    it "should create a Cell::Image" do
-      @cell.should be_a_kind_of(Prawn::Table::Cell::Image)
-    end
-
-    it "should pull the natural width and height from the image" do
-      @cell.natural_content_width.should == 141
-      @cell.natural_content_height.should == 142
-    end
-  end
-
-  describe "hash syntax" do
-    before(:each) do
-      @table = @pdf.make_table([[{
-        :image => "#{Prawn::DATADIR}/images/prawn.png",
-        :scale => 2,
-        :fit => [100, 200],
-        :image_width => 123,
-        :image_height => 456,
-        :position => :center,
-        :vposition => :center
-      }]])
-      @cell = @table.cells[0, 0]
-    end
-
-
-    it "should create a Cell::Image" do
-      @cell.should be_a_kind_of(Prawn::Table::Cell::Image)
-    end
-
-    it "should pass through image options" do
-      @pdf.expects(:embed_image).checking do |_, _, options|
-        options[:scale].should == 2
-        options[:fit].should == [100, 200]
-        options[:width].should == 123
-        options[:height].should == 456
-        options[:position].should == :center
-        options[:vposition].should == :center
-      end
-
-      @table.draw
-    end
-  end
-
-end