prawn 0.3.0 → 0.4.0

data/lib/prawn/graphics/cell.rb

@@ -1,264 +0,0 @@
-# encoding: utf-8   
-
-# cell.rb : Table support functions
-#
-# Copyright June 2008, Gregory Brown.  All Rights Reserved.
-#
-# This is free software. Please see the LICENSE and COPYING files for details.
-module Prawn
-
-  class Document
-    # Builds and renders a Graphics::Cell.  A cell is essentially a
-    # special-purpose bounding box designed for flowing text within a bordered
-    # area.  For available options, see Graphics::Cell#new.
-    #
-    #    Prawn::Document.generate("cell.pdf") do
-    #       cell [100,500], 
-    #         :width => 200,
-    #         :text  => "The rain in Spain falls mainly on the plains"
-    #    end
-    #
-    def cell(point, options={})
-      Prawn::Graphics::Cell.new(
-        options.merge(:document => self, :point => point)).draw
-    end
-  end
-
-  module Graphics
-    # A cell is a special-purpose bounding box designed to flow text within a
-    # bordered area. This is used by Prawn's Document::Table implementation but
-    # can also be used standalone for drawing text boxes via Document#cell
-    #
-    class Cell
-
-      # Creates a new cell object.  Generally used indirectly via Document#cell
-      #
-      # Of the available options listed below, <tt>:point</tt>, <tt>:width</tt>,
-      # and <tt>:text</tt> must be provided. If you are not using the
-      # Document#cell shortcut, the <tt>:document</tt> must also be provided.
-      #
-      # <tt>:point</tt>:: Absolute [x,y] coordinate of the top-left corner of the cell.
-      # <tt>:document</tt>:: The Prawn::Document object to render on. 
-      # <tt>:text</tt>:: The text to be flowed within the cell
-      # <tt>:text_color</tt>:: The color of the text to be displayed
-      # <tt>:width</tt>:: The width in PDF points of the cell.
-      # <tt>:height</tt>:: The height in PDF points of the cell.
-      # <tt>:horizontal_padding</tt>:: The horizontal padding in PDF points
-      # <tt>:vertical_padding</tt>:: The vertical padding in PDF points
-      # <tt>:padding</tt>:: Overrides both horizontal and vertical padding
-      # <tt>:align</tt>:: One of <tt>:left</tt>, <tt>:right</tt>, <tt>:center</tt>
-      # <tt>:borders</tt>:: An array of sides which should have a border. Any of <tt>:top</tt>, <tt>:left</tt>, <tt>:right</tt>, <tt>:bottom</tt>
-      # <tt>:border_width</tt>:: The border line width. Defaults to 1.
-      # <tt>:border_style</tt>:: One of <tt>:all</tt>, <tt>:no_top</tt>, <tt>:no_bottom</tt>, <tt>:sides</tt>, <tt>:none</tt>, <tt>:bottom_only</tt>. Defaults to :all.
-      # <tt>:border_color</tt>:: The color of the cell border.
-      # <tt>:font_size</tt>:: The font size for the cell text.
-      #
-      def initialize(options={})
-        @point        = options[:point]
-        @document     = options[:document]
-        @text         = options[:text].to_s
-        @text_color   = options[:text_color]
-        @width        = options[:width]
-        @height       = options[:height]
-        @borders      = options[:borders]
-        @border_width = options[:border_width] || 1
-        @border_style = options[:border_style] || :all               
-        @border_color = options[:border_color]
-        @background_color = options[:background_color] 
-        @align            = options[:align] || :left
-        @font_size        = options[:font_size]
-
-        @horizontal_padding = options[:horizontal_padding] || 0
-        @vertical_padding   = options[:vertical_padding]   || 0
-
-        if options[:padding]
-          @horizontal_padding = @vertical_padding = options[:padding]
-        end
-      end
-
-      attr_accessor :point, :border_style, :border_width, :background_color,
-                    :document, :horizontal_padding, :vertical_padding, :align,
-                    :borders, :text_color, :border_color
-                    
-      attr_writer   :height, :width #:nodoc:   
-           
-      # Returns the cell's text as a string.
-      #
-      def to_s
-        @text
-      end
-
-      # The width of the text area excluding the horizonal padding
-      #
-      def text_area_width
-        width - 2*@horizontal_padding
-      end
-
-      # The width of the cell in PDF points
-      #
-      def width
-        @width || (@document.font.metrics.string_width(@text,
-          @font_size || @document.font.size)) + 2*@horizontal_padding
-      end
-
-      # The height of the cell in PDF points
-      #
-      def height  
-        @height || text_area_height + 2*@vertical_padding
-      end
-
-      # The height of the text area excluding the vertical padding
-      #
-      def text_area_height
-        @document.font.height_of(@text, :line_width => text_area_width) 
-      end
-
-      # Draws the cell onto the PDF document
-      # 
-      def draw
-        rel_point = @point                
-        
-        if @background_color    
-          @document.mask(:fill_color) do
-            @document.fill_color @background_color  
-            h  = borders.include?(:bottom) ? 
-              height - border_width : height + border_width / 2.0
-            @document.fill_rectangle [rel_point[0] + border_width / 2.0, 
-                                      rel_point[1] - border_width / 2.0 ], 
-                width - border_width, h  
-          end
-        end
-
-        if @border_width > 0
-          @document.mask(:line_width) do
-            @document.line_width = @border_width
-
-            @document.mask(:stroke_color) do
-              @document.stroke_color @border_color if @border_color
-
-              if borders.include?(:left)
-                @document.stroke_line [rel_point[0], rel_point[1] + (@border_width / 2.0)], 
-                  [rel_point[0], rel_point[1] - height - @border_width / 2.0 ]
-              end
-
-              if borders.include?(:right)
-                @document.stroke_line( 
-                  [rel_point[0] + width, rel_point[1] + (@border_width / 2.0)],
-                  [rel_point[0] + width, rel_point[1] - height - @border_width / 2.0] )
-              end
-
-              if borders.include?(:top)
-                @document.stroke_line(
-                  [ rel_point[0] + @border_width / 2.0, rel_point[1] ], 
-                  [ rel_point[0] - @border_width / 2.0 + width, rel_point[1] ])
-              end
-
-              if borders.include?(:bottom)
-                @document.stroke_line [rel_point[0], rel_point[1] - height ],
-                                    [rel_point[0] + width, rel_point[1] - height]
-              end
-            end
-
-          end
-          
-          borders
-
-        end
-
-        @document.bounding_box( [@point[0] + @horizontal_padding, 
-                                 @point[1] - @vertical_padding], 
-                                :width   => text_area_width,
-                                :height  => height - @vertical_padding) do
-          @document.move_up @document.font.line_gap
-
-          options = {:align => @align}
-
-          options[:size] = @font_size if @font_size
-
-          @document.mask(:fill_color) do
-            @document.fill_color @text_color if @text_color                        
-            @document.text @text, options
-          end
-        end
-      end
-
-      private
-
-      def borders
-        @borders ||= case @border_style
-        when :all
-          [:top,:left,:right,:bottom]
-        when :sides
-          [:left,:right]
-        when :no_top
-          [:left,:right,:bottom]
-        when :no_bottom
-          [:left,:right,:top]
-        when :bottom_only
-          [:bottom]
-        when :none
-          []
-        end
-      end
-
-    end
-
-    class CellBlock #:nodoc:
-
-      # Not sure if this class is something I want to expose in the public API.
-
-      def initialize(document)
-        @document = document
-        @cells    = []
-        @width    = 0
-        @height   = 0
-      end
-
-      attr_reader :width, :height, :cells
-      attr_accessor :background_color, :text_color, :border_color
-
-      def <<(cell)
-        @cells << cell
-        @height = cell.height if cell.height > @height 
-        @width += cell.width
-        self
-      end
-
-      def draw
-        y = @document.y
-        x = @document.bounds.absolute_left
-
-        @cells.each do |e|
-          e.point  = [x - @document.bounds.absolute_left, 
-                      y - @document.bounds.absolute_bottom]
-          e.height = @height
-          e.background_color ||= @background_color
-          e.text_color ||= @text_color
-          e.border_color ||= @border_color
-          e.draw
-          x += e.width
-        end
-        
-        @document.y = y - @height
-      end
-
-      def border_width
-        @cells[0].border_width
-      end
-
-      def border_style=(s)
-        @cells.each { |e| e.border_style = s }
-      end    
-      
-      def align=(align) 
-        @cells.each { |e| e.align = align } 
-      end           
-      
-      def border_style
-        @cells[0].border_style
-      end
-
-    end
-  end
- 
-end

data/spec/metrics_spec.rb

@@ -1,62 +0,0 @@
-# encoding: utf-8
-
-require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")  
-require "iconv"
-
-describe "adobe font metrics" do
-  
-  setup do
-    @times = Prawn::Font::Metrics["Times-Roman"]
-    @iconv = ::Iconv.new('ISO-8859-1', 'utf-8')
-  end
-  
-  it "should calculate string width taking into account accented characters" do
-    @times.string_width(@iconv.iconv("é"), 12).should == @times.string_width("e", 12)
-  end
-  
-  it "should calculate string width taking into account kerning pairs" do
-    @times.string_width(@iconv.iconv("To"), 12).should == 13.332
-    @times.string_width(@iconv.iconv("To"), 12, :kerning => true).should == 12.372
-    @times.string_width(@iconv.iconv("Tö"), 12, :kerning => true).should == 12.372
-  end
-  
-  it "should kern a string" do
-    @times.kern(@iconv.iconv("To")).should == ["T", 80, "o"]
-    @times.kern(@iconv.iconv("Télé")).should == ["T", 70, @iconv.iconv("élé")]
-    @times.kern(@iconv.iconv("Technology")).should == ["T", 70, "echnology"]
-    @times.kern(@iconv.iconv("Technology...")).should == ["T", 70, "echnology", 65, "..."]
-  end
-  
-end
-
-describe "ttf font metrics" do
-  
-  setup do
-    @activa = Prawn::Font::Metrics["#{Prawn::BASEDIR}/data/fonts/Activa.ttf"]
-  end
-  
-  it "should calculate string width taking into account accented characters" do
-    @activa.string_width("é", 12).should == @activa.string_width("e", 12)
-  end
-  
-  it "should calculate string width taking into account kerning pairs" do
-    @activa.string_width("To", 12).should == 15.228
-    @activa.string_width("To", 12, :kerning => true).should.to_s == 12.996.to_s
-  end
-  
-  it "should kern a string" do
-    @activa.kern("To").should == ["\0007", 186.0, "\000R"]
-    
-    # Does activa use kerning classes here? Ruby/TTF doesn't support
-    # format 2 kerning tables, so don't bother for now.
-    
-    # @activa.kern("Télé").should == ["T", -186, "élé"]
-    
-    @activa.kern("Technology").should == ["\0007", 186.0, 
-      "\000H\000F\000K\000Q\000R\000O\000R\000J\000\\"]
-    @activa.kern("Technology...").should == ["\0007", 186.0,
-       "\000H\000F\000K\000Q\000R\000O\000R\000J\000\\", 88.0, 
-       "\000\021\000\021\000\021"] 
-  end
-  
-end

data/spec/table_spec.rb

@@ -1,179 +0,0 @@
-# encoding: utf-8
-
-require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")  
-
-describe "A table's width" do
-  it "should equal sum(col_widths)" do
-    pdf = Prawn::Document.new
-    table = Prawn::Document::Table.new( [%w[ a b c ], %w[d e f]], pdf,
-       :widths => { 0 => 50, 1 => 100, 2 => 150 })
-
-    table.width.should == 300
-  end
-
-  it "should calculate unspecified column widths as "+
-     "(max(string_width).ceil + 2*horizontal_padding)" do
-    pdf = Prawn::Document.new
-    hpad, fs = 3, 12
-    columns = 2
-    table = Prawn::Document::Table.new( [%w[ foo b ], %w[d foobar]], pdf,
-      :horizontal_padding => hpad, :font_size => fs)
-
-    col0_width = pdf.font.metrics.string_width("foo",fs)
-    col1_width = pdf.font.metrics.string_width("foobar",fs)
-
-    table.width.should == col0_width.ceil + col1_width.ceil + 2*columns*hpad
-  end
-
-  it "should allow mixing autocalculated and preset"+
-     "column widths within a single table" do
-
-    pdf = Prawn::Document.new
-    hpad, fs = 10, 6
-    stretchy_columns = 2
-    
-    col0_width = 50
-    col1_width = pdf.font.metrics.string_width("foo",fs)
-    col2_width = pdf.font.metrics.string_width("foobar",fs)
-    col3_width = 150
-
-    table = Prawn::Document::Table.new( [%w[snake foo b apple], 
-                                         %w[kitten d foobar banana]], pdf,
-      :horizontal_padding => hpad, :font_size => fs, 
-      :widths => { 0 => col0_width, 3 => col3_width } )
-
-        table.width.should == col1_width.ceil + col2_width.ceil + 
-                              2*stretchy_columns*hpad + 
-                              col0_width.ceil + col3_width.ceil
-
-  end
-      
-end   
-
-describe "A table's height" do 
-  
-  before :each do                                           
-    data = [["foo"],["bar"],["baaaz"]]
-    pdf = Prawn::Document.new
-    @num_rows = data.length
-       
-    @vpad  = 4
-    origin = pdf.y
-    pdf.table data, :vertical_padding => @vpad
-
-    @table_height = origin - pdf.y
-
-    @font_height = pdf.font.height
-  end   
-  
-  it "should have a height of n rows" do  
-    @table_height.should.be.close(
-      @num_rows*@font_height + 2*@vpad*@num_rows, 0.001 )
-  end
-  
-end
-
-describe "A table's content" do
-
-  it "should not cause an error if rendering the very first row causes a page break" do
-    Prawn::Document.new( :page_layout => :portrait ) do
-      arr = Array(1..5).collect{|i| ["cell #{i}"] }
-
-      move_down( y - (bounds.absolute_bottom + 3) )
-
-      lambda {
-        table( arr,
-            :font_size          => 9, 
-            :horizontal_padding => 3,
-            :vertical_padding   => 3,
-            :border_width       => 0.05,
-            :border_style       => :none,
-            :row_colors         => %w{ffffff eeeeee},
-            :widths             => {0 =>110},
-            :position           => :left,
-            :headers            => ["exploding header"],
-            :align              => :left,
-            :align_headers      => :center)
-      }.should.not.raise
-    end
-  end
-
-  it "should output content cell by cell, row by row" do
-    data = [["foo","bar"],["baz","bang"]]
-    @pdf = Prawn::Document.new
-    @pdf.table(data)
-    output = PDF::Inspector::Text.analyze(@pdf.render)
-    output.strings.should == data.flatten
-  end
-
-  it "should add headers to output when specified" do
-    data = [["foo","bar"],["baz","bang"]]
-    headers = %w[a b]
-    @pdf = Prawn::Document.new
-    @pdf.table(data, :headers => headers)
-    output = PDF::Inspector::Text.analyze(@pdf.render)   
-    output.strings.should == headers + data.flatten
-  end
-
-  it "should repeat headers across pages" do
-    data = [["foo","bar"]]*30
-    headers = ["baz","foobar"]
-    @pdf = Prawn::Document.new
-    @pdf.table(data, :headers => headers)
-    output = PDF::Inspector::Text.analyze(@pdf.render)   
-    output.strings.should == headers + data.flatten[0..-3] + headers +
-      data.flatten[-2..-1]
-  end
-
-  it "should allow empty fields" do
-    lambda {
-      data = [["foo","bar"],["baz",""]]
-      @pdf = Prawn::Document.new
-      @pdf.table(data)
-    }.should.not.raise
-  end   
-  
-  it "should paginate for large tables" do
-    # 30 rows fit on the table with default setting, 31 exceed.
-    data = [["foo"]] * 31
-    pdf = Prawn::Document.new
-
-    pdf.table data
-    pdf.page_count.should == 2
-
-    pdf.table data
-    pdf.page_count.should == 3
-  end
-    
-end
-
-describe "An invalid table" do
-  
-  before(:each) do
-    @pdf = Prawn::Document.new
-    @bad_data = ["Single Nested Array"]
-  end
-  
-  it "should raise error when invalid table data is given" do
-    assert_raises(Prawn::Errors::InvalidTableData) do
-      @pdf.table(@bad_data)
-    end
-  end
-
-  it "should raise an EmptyTableError with empty table data" do
-    lambda {
-      data = []
-      @pdf = Prawn::Document.new
-      @pdf.table(data)
-    }.should.raise( Prawn::Errors::EmptyTable )
-  end   
-
-  it "should raise an EmptyTableError with nil table data" do
-    lambda {
-      data = nil
-      @pdf = Prawn::Document.new
-      @pdf.table(data)
-    }.should.raise( Prawn::Errors::EmptyTable )
-  end   
-
-end