prawn 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: edf9e637f24e5c4554e995712cb589f0b21737fb
-  data.tar.gz: 97750f73864c853ff874f8a5a0f7984a6f9d8279
+  metadata.gz: 8492b319da06bf93faa4e58cfa4932b46fd8a474
+  data.tar.gz: ba94547a9eda37f13c91b7293203a12df99b9815
 SHA512:
-  metadata.gz: bd80b65ac0360fa6786b6bffacfc34a87511cc8d79e260dfd8db78b86a5003182a41d5ad559e5c1403724273c83b71b29d426c31a422fd7b1e5986a859ac1a5d
-  data.tar.gz: 4b63fc53c8481155ed173cb3e4b8146ac052173e0bd91f4fa27aece66525ad5f6968a48230addbb5ae2a043a3bc33829c79c9447a8c734f3bd2da45468b913da
+  metadata.gz: d898304c9f63ac7826f49b3802106ec84e36fb8a0efcb07d85b2b88d0e7a2f3016f722655fea9e4992e028a8a740ef5d29a5ee9e7287164f6768d9435179891c
+  data.tar.gz: 0127f4e217c2588fe196665712cb1fe7e3914a49d3ba4e0b248e1a7bd3615f52e6c97e2288c4c7fb9295383e48c03ad48557c137e8d1f822841c65d1a8f77d62

data/Rakefile

@@ -5,8 +5,9 @@ require 'rake'
 require 'rspec/core/rake_task'
 require 'yard'
 require 'rubygems/package_task'
+require 'rubocop/rake_task'
 
-task :default => [:spec]
+task :default => [:rubocop, :spec]
 
 desc "Run all rspec files"
 RSpec::Core::RakeTask.new("spec") do |c|
@@ -31,7 +32,7 @@ desc "Generate the 'Prawn by Example' manual"
 task :manual do
   puts "Building manual..."
   require File.expand_path(File.join(File.dirname(__FILE__),
-    %w[manual manual manual]))
+    %w[manual contents]))
   puts "The Prawn manual is available at manual.pdf. Happy Prawning!"
 end
 
@@ -52,3 +53,4 @@ task :console do
   IRB.start
 end
 
+Rubocop::RakeTask.new

data/lib/prawn.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 # Welcome to Prawn, the best PDF Generation library ever.
 # This documentation covers user level functionality.
 #
@@ -7,7 +9,7 @@ require 'ttfunk'
 require "pdf/core"
 
 module Prawn
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 
   extend self
 
@@ -20,7 +22,7 @@ module Prawn
   #
   BASEDIR = File.expand_path(File.join(dir, '..'))
   DATADIR = File.expand_path(File.join(dir, '..', 'data'))
-  
+
   FLOAT_PRECISION = 1.0e-9
 
   # Whe set to true, Prawn will verify hash options to ensure only valid keys
@@ -81,7 +83,7 @@ require_relative "prawn/encoding"
 require_relative "prawn/measurements"
 require_relative "prawn/repeater"
 require_relative "prawn/outline"
-require_relative "prawn/layout"
+require_relative "prawn/grid"
 
 require_relative "prawn/image_handler"
 

data/lib/prawn/document.rb

@@ -97,7 +97,7 @@ module Prawn
     end
 
     # @private
-    def self.inherited(base) 
+    def self.inherited(base)
       extensions.each { |e| base.extensions << e }
     end
 
@@ -148,7 +148,7 @@ module Prawn
     # Creates a new PDF Document.  The following options are available (with
     # the default values marked in [])
     #
-    # <tt>:page_size</tt>:: One of the Document::PageGeometry sizes [LETTER]
+    # <tt>:page_size</tt>:: One of the PDF::Core::PageGeometry sizes [LETTER]
     # <tt>:page_layout</tt>:: Either <tt>:portrait</tt> or <tt>:landscape</tt>
     # <tt>:margin</tt>:: Sets the margin on all sides in points [0.5 inch]
     # <tt>:left_margin</tt>:: Sets the left margin in points [0.5 inch]
@@ -587,7 +587,7 @@ module Prawn
     #
     # @private
     def group(*a, &b)
-      raise NotImplementedError, 
+      raise NotImplementedError,
         "Document#group has been disabled because its implementation "+
         "lead to corrupted documents whenever a page boundary was "+
         "crossed. We will try to work on reimplementing it in a "+
@@ -596,7 +596,7 @@ module Prawn
 
     # @private
     def transaction
-      raise NotImplementedError, 
+      raise NotImplementedError,
         "Document#transaction has been disabled because its implementation "+
         "lead to corrupted documents whenever a page boundary was "+
         "crossed. We will try to work on reimplementing it in a "+
@@ -629,8 +629,8 @@ module Prawn
     end
 
     # @private
-   
-    def mask(*fields) 
+
+    def mask(*fields)
      # Stores the current state of the named attributes, executes the block, and
      # then restores the original values after the block has executed.
      # -- I will remove the nodoc if/when this feature is a little less hacky
@@ -696,7 +696,7 @@ module Prawn
 
       # we must update bounding box if not flowing from the previous page
       #
-      @bounding_box = @margin_box unless @bounding_box && @bounding_box.parent    
+      @bounding_box = @margin_box unless @bounding_box && @bounding_box.parent
     end
 
     def apply_margin_options(options)

data/lib/prawn/document/bounding_box.rb

@@ -199,7 +199,7 @@ module Prawn
       # If the user actions did not modify the y position
       # restore the original y position before the bounding
       # box was created.
-      
+
       if y == @bounding_box.absolute_top
         self.y = original_ypos
       end

data/lib/prawn/document/column_box.rb

@@ -20,12 +20,12 @@ module Prawn
     #
     # column_box accepts the same parameters as bounding_box, as well as the
     # number of :columns and a :spacer (in points) between columns. If resetting
-    # the top margin is desired on a new page (e.g. to allow for initial page 
+    # the top margin is desired on a new page (e.g. to allow for initial page
     # wide column titles) the option :reflow_margins => true can be set.
     #
-    # Defaults are :columns = 3, :spacer = font_size, and 
+    # Defaults are :columns = 3, :spacer = font_size, and
     # :reflow_margins => false
-    # 
+    #
     # Under PDF::Writer, "spacer" was known as "gutter"
     #
     def column_box(*args, &block)

data/lib/prawn/document/internals.rb

@@ -15,7 +15,7 @@ module Prawn
     # are you won't need anything you find here.
     #
     # @private
-    module Internals 
+    module Internals
       # Creates a new Prawn::Reference and adds it to the Document's object
       # list.  The +data+ argument is anything that Prawn::PdfObject() can convert.
       #

data/lib/prawn/font.rb

@@ -237,7 +237,15 @@ module Prawn
         end
       end
       key = "#{name}:#{options[:font] || 0}"
-      font_registry[key] ||= Font.load(self, name, options.merge(:family => family))
+
+      if name.is_a? Prawn::Font
+        font_registry[key] = name
+      else
+        font_registry[key] ||= Font.load( self,
+                                          name,
+                                          options.merge(family: family)
+                               )
+      end
     end
 
     # Hash of Font objects keyed by names
@@ -279,13 +287,21 @@ module Prawn
     # Shortcut interface for constructing a font object.  Filenames of the form
     # *.ttf will call Font::TTF.new, *.dfont Font::DFont.new, and anything else
     # will be passed through to Font::AFM.new()
-    #
-    def self.load(document,name,options={})
-      case name.to_s
-      when /\.ttf$/i   then TTF.new(document, name, options)
-      when /\.dfont$/i then DFont.new(document, name, options)
-      when /\.afm$/i   then AFM.new(document, name, options)
-      else                  AFM.new(document, name, options)
+    def self.load(document, src, options={})
+      case font_format(src, options)
+      when 'ttf'   then TTF.new(document, src, options)
+      when 'dfont' then DFont.new(document, src, options)
+      else AFM.new(document, src, options)
+      end
+    end
+
+    def self.font_format(src, options)
+      return options.fetch(:format, 'ttf') if src.respond_to? :read
+
+      case src.to_s
+      when /\.ttf$/i   then return 'ttf'
+      when /\.dfont$/i then return 'dfont'
+      else return 'afm'
       end
     end
 

data/lib/prawn/font/afm.rb

@@ -157,7 +157,7 @@ module Prawn
       end
 
       def parse_afm(file_name)
-        data    = {:glyph_widths => {}, :bounding_boxes => {}, :kern_pairs => {}, :attributes => {}}         
+        data    = {:glyph_widths => {}, :bounding_boxes => {}, :kern_pairs => {}, :attributes => {}}
         section = []
 
         File.foreach(file_name) do |line|
@@ -187,7 +187,7 @@ module Prawn
             parse_generic_afm_attribute(line, data)
           end
         end
-        
+
         # process data parsed from AFM file to build tables which
         #   will be used when measuring and kerning text
         data[:glyph_table] = (0..255).map do |i|
@@ -234,9 +234,9 @@ module Prawn
           e.respond_to?(:force_encoding) ? e.force_encoding(::Encoding::Windows_1252) : e
         }
       end
-      
+
       private
-      
+
       def unscaled_width_of(string)
         string.bytes.inject(0) do |s,r|
           s + @glyph_table[r]

data/lib/prawn/font_metric_cache.rb

@@ -13,7 +13,7 @@ module Prawn
   # of various strings for layout purposes.
   #
   # @private
-  class FontMetricCache 
+  class FontMetricCache
 
     CacheEntry = Struct.new( :font, :options, :string )
 

data/lib/prawn/grid.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 # grid.rb: Provides a basic grid layout system for Prawn
 #
 # Contributed by Andrew O'Brien in March 2009
@@ -14,7 +16,7 @@ module Prawn
     #
     # Note that a completely new grid object is built each time define_grid()
     # is called. This means that all subsequent calls to grid() will use
-    # the newly defined Grid object -- grids are not nestable like 
+    # the newly defined Grid object -- grids are not nestable like
     # bounding boxes are.
 
     def define_grid(options = {})

data/lib/prawn/image_handler.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 # ImageHandler provides a way to register image processors with Prawn
 #
 # Contributed by Evan Sharp in November 2013.
@@ -6,7 +8,7 @@
 
 module Prawn
   # @group Extension API
-  
+
   def self.image_handler
     @image_handler ||= ImageHandler.new
   end

data/lib/prawn/images/jpg.rb

@@ -16,7 +16,7 @@ module Prawn
     #
     class JPG < Image
       # @group Extension API
-      
+
       attr_reader :width, :height, :bits, :channels
       attr_accessor :scaled_width, :scaled_height
 

data/lib/prawn/measurement_extensions.rb

@@ -15,7 +15,7 @@ class Numeric
   # 72 points per inch
 
   # @group Experimental API
-  
+
   def mm
     return mm2pt(self)
   end

data/lib/prawn/outline.rb

@@ -1,7 +1,9 @@
+# encoding: utf-8
+
 module Prawn
   class Document
     # @group Stable API
-    
+
     # Lazily instantiates a Prawn::Outline object for document. This is used as point of entry
     # to methods to build the outline tree for a document's table of contents.
     def outline

data/lib/prawn/security.rb

@@ -213,7 +213,7 @@ module PDF
     # from the indirect object referencing obj.
     #
     # @private
-    def EncryptedPdfObject(obj, key, id, gen, in_content_stream=false) 
+    def EncryptedPdfObject(obj, key, id, gen, in_content_stream=false)
       case obj
       when Array
         "[" << obj.map { |e|

data/lib/prawn/security/arcfour.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 # Implementation of the "ARCFOUR" algorithm ("alleged RC4 (tm)"). Implemented
 # as described at:
 # http://www.mozilla.org/projects/security/pki/nss/draft-kaukonen-cipher-arcfour-03.txt
@@ -17,7 +19,7 @@ class Arcfour
     # 1. Allocate an 256 element array of 8 bit bytes to be used as an S-box
     # 2. Initialize the S-box.  Fill each entry first with it's index
     @sbox = (0..255).to_a
-    
+
     # 3. Fill another array of the same size (256) with the key, repeating
     #    bytes as necessary.
     s2 = []
@@ -39,7 +41,7 @@ class Arcfour
   def encrypt(string)
     string.unpack('c*').map{|byte| byte ^ key_byte}.pack('c*')
   end
-  
+
   private
 
   # Produces the next byte of key material in the stream (3.2 Stream Generation)

data/lib/prawn/table.rb

@@ -43,6 +43,16 @@ module Prawn
 
   end
 
+  module Errors
+    # This error is raised when table data is malformed
+    #
+    InvalidTableData = Class.new(StandardError)
+
+    # This error is raised when an empty or nil table is rendered
+    #
+    EmptyTable = Class.new(StandardError)
+  end
+
   # Next-generation table drawing for Prawn.
   #
   # = Data
@@ -320,7 +330,9 @@ module Prawn
               c = Cells.new(cells_this_page.map { |ci, _| ci })
               @before_rendering_page.call(c)
             end
-            Cell.draw_cells(cells_this_page)
+            if @header_row.nil? || cells_this_page.size > @header_row.size
+              Cell.draw_cells(cells_this_page)
+            end
             cells_this_page = []
 
             # start a new page or column
@@ -527,7 +539,7 @@ module Prawn
       rows_to_operate_on = @header_row.rows(row_of_header) if row_of_header
       rows_to_operate_on.each do |cell|
         cell.row = row
-        cell.dummy_cells.each {|c| c.row = row }
+        cell.dummy_cells.each {|c| c.row = row + c.row }
         page_of_cells << [cell, [cell.x + x_offset, y]]
       end
       rows_to_operate_on.height

data/lib/prawn/table/cell.rb

@@ -153,7 +153,7 @@ module Prawn
       # this span group. They know their own width / height, but do not draw
       # anything.
       #
-      attr_reader :dummy_cells 
+      attr_reader :dummy_cells
 
       # Instantiates a Cell based on the given options. The particular class of
       # cell returned depends on the :content argument. See the Prawn::Table

data/lib/prawn/table/cells.rb

@@ -228,56 +228,7 @@ module Prawn
       # each cell, grouped by +row_or_column+.
       #
       def aggregate_cell_values(row_or_column, meth, aggregate)
-        values = {}
-
-        #calculate values for all cells that do not span accross multiple cells
-        #this ensures that we don't have a problem if the first line includes
-        #a cell that spans across multiple cells
-        each do |cell|
-          #don't take spanned cells
-          if cell.colspan == 1 and cell.class != Prawn::Table::Cell::SpanDummy
-            index = cell.send(row_or_column)
-            values[index] = [values[index], cell.send(meth)].compact.send(aggregate)
-          end
-        end
-
-        #if there are only colspanned or rowspanned cells in a table
-        spanned_width_needs_fixing = true
-
-        each do |cell|
-          index = cell.send(row_or_column)
-          if cell.colspan > 1
-            #calculate current (old) return value before we do anything
-            old_sum = 0
-            cell.colspan.times { |i|
-              old_sum += values[index+i] unless values[index+i].nil?
-            }
-
-            #calculate future return value
-            new_sum = cell.send(meth) * cell.colspan
-
-            #due to float rounding errors we need to ignore a small difference in the new 
-            #and the old sum the same had to be done in
-            #the column_width_calculator#natural_width
-            spanned_width_needs_fixing = ((new_sum - old_sum) > Prawn::FLOAT_PRECISION)
-
-            if spanned_width_needs_fixing
-              #not entirely sure why we need this line, but with it the tests pass
-              values[index] = [values[index], cell.send(meth)].compact.send(aggregate)
-              #overwrite the old values with the new ones, but only if all entries existed
-              entries_exist = true
-              cell.colspan.times { |i| entries_exist = false if values[index+i].nil? }
-              cell.colspan.times { |i|
-                values[index+i] = cell.send(meth) if entries_exist
-              }
-            end
-          else
-            if spanned_width_needs_fixing && cell.class == Prawn::Table::Cell::SpanDummy
-              values[index] = [values[index], cell.send(meth)].compact.send(aggregate)
-            end
-          end
-        end
-        values.values.inject(0, &:+)
+        ColumnWidthCalculator.new(self).aggregate_cell_values(row_or_column, meth, aggregate)
       end
 
       # Transforms +spec+, a column / row specification, into an object that

data/lib/prawn/table/column_width_calculator.rb

@@ -1,48 +1,104 @@
+# encoding: utf-8
+
 module Prawn
   class Table
     # @private
-    class ColumnWidthCalculator 
+    class ColumnWidthCalculator
       def initialize(cells)
         @cells = cells
 
         @widths_by_column        = Hash.new(0)
         @rows_with_a_span_dummy  = Hash.new(false)
-      end
 
-      def natural_widths
+        #calculate for each row if it includes a Cell:SpanDummy
         @cells.each do |cell|
           @rows_with_a_span_dummy[cell.row] = true if cell.is_a?(Cell::SpanDummy)
         end
+      end
+
+      # does this row include a Cell:SpanDummy?
+      #
+      # @param row - the row that should be checked for Cell:SpanDummy elements
+      #
+      def has_a_span_dummy?(row)
+        @rows_with_a_span_dummy[row]
+      end
+
+      # helper method
+      # column widths are stored in the values array
+      # a cell may span cells whose value is only partly given
+      # this function handles this special case
+      #
+      # @param values - The columns widths calculated up until now
+      # @param cell - The current cell
+      # @param index - The current column
+      # @param meth - Meth (min/max); used to calculate values to be filled
+      #
+      def fill_values_if_needed(values, cell, index, meth)
+        #have all spanned indices been filled with a value?
+        #e.g. values[0], values[1] and values[2] don't return nil given a index of 0 and a colspan of 3
+        number_of_nil_values = 0
+        cell.colspan.times do |i|
+          number_of_nil_values += 1 if values[index+i].nil?
+        end
+
+        #nothing to do? because
+        #a) all values are filled
+        return values if number_of_nil_values == 0
+        #b) no values are filled
+        return values if number_of_nil_values == cell.colspan
+        #c) I am not sure why this line is needed FIXXME
+        #some test cases manage to this line even though there is no dummy cell in the row
+        #I'm not sure if this is a sign for a further underlying bug.
+        return values unless has_a_span_dummy?(cell.row)
+        #fill up the values array
+
+        #calculate the new sum
+        new_sum = cell.send(meth) * cell.colspan
+        #substract any calculated values
+        cell.colspan.times do |i|
+          new_sum -= values[index+i] unless values[index+i].nil?
+        end
+
+        #calculate value for the remaining - not yet filled - cells.
+        new_value = new_sum.to_f / number_of_nil_values
+        #fill the not yet filled cells
+        cell.colspan.times do |i|
+          values[index+i] = new_value if values[index+i].nil?
+        end
+        return values
+      end
 
+      def natural_widths
         #calculate natural column width for all rows that do not include a span dummy
         @cells.each do |cell|
-          unless @rows_with_a_span_dummy[cell.row]
-            @widths_by_column[cell.column] = 
+          unless has_a_span_dummy?(cell.row)
+            @widths_by_column[cell.column] =
               [@widths_by_column[cell.column], cell.width.to_f].max
           end
         end
 
         #integrate natural column widths for all rows that do include a span dummy
         @cells.each do |cell|
-          next unless @rows_with_a_span_dummy[cell.row]
+          next unless has_a_span_dummy?(cell.row)
           #the width of a SpanDummy cell will be calculated by the "mother" cell
           next if cell.is_a?(Cell::SpanDummy)
 
           if cell.colspan == 1
-            @widths_by_column[cell.column] = 
+            @widths_by_column[cell.column] =
               [@widths_by_column[cell.column], cell.width.to_f].max
           else
             #calculate the current with of all cells that will be spanned by the current cell
-            current_width_of_spanned_cells = 
+            current_width_of_spanned_cells =
               @widths_by_column.to_a[cell.column..(cell.column + cell.colspan - 1)]
                                .collect{|key, value| value}.inject(0, :+)
 
             #update the Hash only if the new with is at least equal to the old one
             #due to arithmetic errors we need to ignore a small difference in the new and the old sum
             #the same had to be done in the column_widht_calculator#natural_width
-            update_hash = ((cell.width.to_f - current_width_of_spanned_cells) > 
+            update_hash = ((cell.width.to_f - current_width_of_spanned_cells) >
                            Prawn::FLOAT_PRECISION)
-            
+
             if update_hash
               # Split the width of colspanned cells evenly by columns
               width_per_column = cell.width.to_f / cell.colspan
@@ -56,6 +112,71 @@ module Prawn
 
         @widths_by_column.sort_by { |col, _| col }.map { |_, w| w }
       end
+
+      # get column widths (either min or max depending on meth)
+      # used in cells.rb
+      #
+      # @param row_or_column - you may call this on either rows or columns
+      # @param meth - min/max
+      # @param aggregate - functions from cell.rb to be used to aggregate e.g. avg_spanned_min_width
+      #
+      def aggregate_cell_values(row_or_column, meth, aggregate)
+        values = {}
+
+        #calculate values for all cells that do not span accross multiple cells
+        #this ensures that we don't have a problem if the first line includes
+        #a cell that spans across multiple cells
+        @cells.each do |cell|
+          #don't take spanned cells
+          if cell.colspan == 1 and cell.class != Prawn::Table::Cell::SpanDummy
+            index = cell.send(row_or_column)
+            values[index] = [values[index], cell.send(meth)].compact.send(aggregate)
+          end
+        end
+
+        # if there are only colspanned or rowspanned cells in a table
+        spanned_width_needs_fixing = true
+
+        @cells.each do |cell|
+          index = cell.send(row_or_column)
+          if cell.colspan > 1
+            #special treatment if some but not all spanned indices in the values array have been calculated
+            #only applies to rows
+            values = fill_values_if_needed(values, cell, index, meth) if row_or_column == :column
+            #calculate current (old) return value before we do anything
+            old_sum = 0
+            cell.colspan.times { |i|
+              old_sum += values[index+i] unless values[index+i].nil?
+            }
+
+            #calculate future return value
+            new_sum = cell.send(meth) * cell.colspan
+
+            #due to float rounding errors we need to ignore a small difference in the new
+            #and the old sum the same had to be done in
+            #the column_width_calculator#natural_width
+            spanned_width_needs_fixing = ((new_sum - old_sum) > Prawn::FLOAT_PRECISION)
+
+            if spanned_width_needs_fixing
+              #not entirely sure why we need this line, but with it the tests pass
+              values[index] = [values[index], cell.send(meth)].compact.send(aggregate)
+              #overwrite the old values with the new ones, but only if all entries existed
+              entries_exist = true
+              cell.colspan.times { |i| entries_exist = false if values[index+i].nil? }
+              cell.colspan.times { |i|
+                values[index+i] = cell.send(meth) if entries_exist
+              }
+            end
+          else
+            if spanned_width_needs_fixing && cell.class == Prawn::Table::Cell::SpanDummy
+              values[index] = [values[index], cell.send(meth)].compact.send(aggregate)
+            end
+          end
+        end
+
+        return values.values.inject(0, &:+)
+      end
     end
+
   end
 end