prawn 1.0.0.rc1 → 1.0.0.rc2

data/lib/prawn/images/jpg.rb

@@ -25,8 +25,9 @@ module Prawn
       # <tt>:data</tt>:: A binary string of JPEG data
       #
       def initialize(data)
-        @data = data
-        data = StringIO.new(data.dup)
+        @data = data.dup
+        ruby_19 { data.force_encoding("binary") }
+        data = StringIO.new(data)
 
         c_marker = "\xff" # Section marker.
         data.read(2)   # Skip the first two bytes of JPEG identifier.
@@ -65,8 +66,7 @@ module Prawn
           :ColorSpace       => color_space,
           :BitsPerComponent => bits,
           :Width            => width,
-          :Height           => height,
-          :Length           => @data.size
+          :Height           => height
         ) 
 
         # add extra decode params for CMYK images. By swapping the

data/lib/prawn/images/png.rb

@@ -169,7 +169,6 @@ module Prawn
           :Height           => height,
           :Width            => width,
           :BitsPerComponent => bits,
-          :Length           => img_data.size,
           :Filter           => :FlateDecode
         )
 
@@ -182,17 +181,17 @@ module Prawn
 
         # append the actual image data to the object as a stream
         obj << img_data
-        
+
         # sort out the colours of the image
         if palette.empty?
           obj.data[:ColorSpace] = color
         else
           # embed the colour palette in the PDF as a object stream
-          palette_obj = document.ref!(:Length => palette.size)
+          palette_obj = document.ref!({})
           palette_obj << palette
 
           # build the color space array for the image
-          obj.data[:ColorSpace] = [:Indexed, 
+          obj.data[:ColorSpace] = [:Indexed,
                                    :DeviceRGB,
                                    (palette.size / 3) -1,
                                    palette_obj]
@@ -234,7 +233,6 @@ module Prawn
             :Height           => height,
             :Width            => width,
             :BitsPerComponent => alpha_channel_bits,
-            :Length           => alpha_channel.size,
             :Filter           => :FlateDecode,
             :ColorSpace       => :DeviceGray,
             :Decode           => [0, 1]
@@ -262,7 +260,7 @@ module Prawn
       private
 
       def unfilter_image_data
-        data = Zlib::Inflate.inflate(@img_data).unpack 'C*'
+        data = Zlib::Inflate.inflate(@img_data).bytes
         @img_data = ""
         @alpha_channel = ""
 
@@ -270,9 +268,16 @@ module Prawn
         scanline_length = pixel_bytes * self.width + 1
         row = 0
         pixels = []
+        row_data = [] # reused for each row of the image
         paeth, pa, pb, pc = nil
-        until data.empty? do
-          row_data = data.slice! 0, scanline_length
+
+        data.each do |byte|
+          # accumulate a whole scanline of bytes, and then process it all at once
+          # we could do this with Enumerable#each_slice, but it allocates memory,
+          #   and we are trying to avoid that
+          row_data << byte
+          next if row_data.length < scanline_length
+          
           filter = row_data.shift
           case filter
           when 0 # None
@@ -284,13 +289,13 @@ module Prawn
             end
           when 2 # Up
             row_data.each_with_index do |byte, index|
-              col = index / pixel_bytes
+              col = (index / pixel_bytes).floor
               upper = row == 0 ? 0 : pixels[row-1][col][index % pixel_bytes]
               row_data[index] = (upper + byte) % 256
             end
           when 3  # Average
             row_data.each_with_index do |byte, index|
-              col = index / pixel_bytes
+              col = (index / pixel_bytes).floor
               upper = row == 0 ? 0 : pixels[row-1][col][index % pixel_bytes]
               left = index < pixel_bytes ? 0 : row_data[index - pixel_bytes]
 
@@ -299,7 +304,7 @@ module Prawn
           when 4 # Paeth
             left = upper = upper_left = nil
             row_data.each_with_index do |byte, index|
-              col = index / pixel_bytes
+              col = (index / pixel_bytes).floor
 
               left = index < pixel_bytes ? 0 : row_data[index - pixel_bytes]
               if row.zero?
@@ -335,9 +340,10 @@ module Prawn
           end
           pixels << s
           row += 1
+          row_data.clear
         end
 
-        # convert the pixel data to seperate strings for colours and alpha
+        # convert the pixel data to separate strings for colours and alpha
         color_byte_size = self.colors * self.bits / 8
         alpha_byte_size = alpha_channel_bits / 8
         pixels.each do |this_row|

data/lib/prawn/security.rb

@@ -7,7 +7,7 @@
 # This is free software. Please see the LICENSE and COPYING files for details.
 
 require 'digest/md5'
-require 'prawn/security/arcfour'
+require 'rc4'
 require 'prawn/core/byte_string'
 
 module Prawn
@@ -116,7 +116,7 @@ module Prawn
 
         # Compute the RC4 key from the extended key and perform the encryption
         rc4_key = Digest::MD5.digest(extended_key)[0, 10]
-        Arcfour.new(rc4_key).encrypt(str)
+        RC4.new(rc4_key).encrypt(str)
       end
 
       private
@@ -186,13 +186,13 @@ module Prawn
       def owner_password_hash
         @owner_password_hash ||= begin
           key = Digest::MD5.digest(pad_password(@owner_password))[0, 5]
-          Arcfour.new(key).encrypt(pad_password(@user_password))
+          RC4.new(key).encrypt(pad_password(@user_password))
         end
       end
 
       # The U (user) value in the encryption dictionary. Algorithm 3.4.
       def user_password_hash
-        Arcfour.new(user_encryption_key).encrypt(PasswordPadding)
+        RC4.new(user_encryption_key).encrypt(PasswordPadding)
       end
 
     end
@@ -239,6 +239,8 @@ module Prawn
       when NameTree::Value
         PdfObject(obj.name) + " " +
           EncryptedPdfObject(obj.value, key, id, gen, in_content_stream)
+      when Prawn::OutlineRoot, Prawn::OutlineItem
+        EncryptedPdfObject(obj.to_hash, key, id, gen, in_content_stream)
       else # delegate back to PdfObject
         PdfObject(obj, in_content_stream)
       end

data/lib/prawn/soft_mask.rb

@@ -0,0 +1,94 @@
+# encoding: utf-8
+#
+# soft_mask.rb : Implements soft-masking
+#
+# Copyright September 2012, Alexander Mankuta. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+#
+
+module Prawn
+
+  # The Prawn::SoftMask module is used to create arbitrary transparency in
+  # document. Using a soft mask allows creaing more visually rich documents.
+  #
+  # You must group soft mask and graphics it's applied to under
+  # save_graphics_state because soft mask is a part of graphic state in PDF.
+  #
+  # Example:
+  #   pdf.save_graphics_state do
+  #     pdf.soft_mask do
+  #       pdf.fill_color "444444"
+  #       pdf.fill_polygon [0, 40], [60, 10], [120, 40], [60, 68]
+  #     end
+  #     pdf.fill_color '000000'
+  #     pdf.fill_rectangle [0, 50], 120, 68
+  #   end
+  #
+  module SoftMask
+    def soft_mask(&block)
+      min_version(1.4)
+
+      group_attrs = ref!({
+        :Type => :Group,
+        :S => :Transparency,
+        :CS => :DeviceRGB,
+        :I => false,
+        :K => false
+      })
+
+      group = ref!({
+        :Type => :XObject,
+        :Subtype => :Form,
+        :BBox => state.page.dimensions,
+        :Group => group_attrs,
+      })
+
+      state.page.stamp_stream(group, &block)
+
+      mask = ref!({
+        :Type => :Mask,
+        :S => :Luminosity,
+        :G => group
+      })
+
+      g_state = ref!({
+        :Type => :ExtGState,
+        :SMask => mask,
+
+        :AIS => false,
+        :BM => :Normal,
+        :OP => false,
+        :op => false,
+        :OPM => 1,
+        :SA => true,
+      })
+
+      registry_key = {
+        :bbox => state.page.dimensions,
+        :mask => group.stream,
+        :page => state.page_count,
+      }.hash
+
+      if soft_mask_registry[registry_key]
+        [g_state, mask, group, group_attrs].each { |ref| ref.live = false }
+
+        add_content "/#{soft_mask_registry[registry_key]} gs"
+      else
+        masks = page.resources[:ExtGState] ||= {}
+        id = masks.empty? ? 'GS1' : masks.keys.sort.last.succ
+        masks[id] = g_state
+
+        soft_mask_registry[registry_key] = id
+
+        add_content "/#{id} gs"
+      end
+    end
+
+    private
+
+    def soft_mask_registry
+      @soft_mask_registry ||= {}
+    end
+  end
+end

data/lib/prawn/table.rb

@@ -12,6 +12,7 @@ require 'prawn/table/cell/in_table'
 require 'prawn/table/cell/text'
 require 'prawn/table/cell/subtable'
 require 'prawn/table/cell/image'
+require 'prawn/table/cell/span_dummy'
 
 module Prawn
 
@@ -155,6 +156,20 @@ module Prawn
     #
     attr_writer :position
 
+    # Returns a Prawn::Table::Cells object representing all of the cells in
+    # this table.
+    #
+    attr_reader :cells
+
+    # Specify a callback to be called before each page of cells is rendered.
+    # The block is passed a Cells object containing all cells to be rendered on
+    # that page. You can change styling of the cells in this block, but keep in
+    # mind that the cells have already been positioned and sized.
+    # 
+    def before_rendering_page(&block)
+      @before_rendering_page = block
+    end
+
     # Returns the width of the table in PDF points.
     #
     def width
@@ -270,6 +285,13 @@ module Prawn
           end
         end
 
+        # Duplicate each cell of the header row into @header_row so it can be
+        # modified in before_rendering_page callbacks.
+        if @header
+          @header_row = Cells.new
+          row(0).each { |cell| @header_row[cell.row, cell.column] = cell.dup }
+        end
+
         # Track cells to be drawn on this page. They will all be drawn when this
         # page is finished.
         cells_this_page = []
@@ -278,13 +300,21 @@ module Prawn
           if cell.height > (cell.y + offset) - ref_bounds.absolute_bottom &&
              cell.row > started_new_page_at_row
             # Ink all cells on the current page
+            if @before_rendering_page
+              c = Cells.new(cells_this_page.map { |c, _| c })
+              @before_rendering_page.call(c)
+            end
             Cell.draw_cells(cells_this_page)
             cells_this_page = []
 
             # start a new page or column
             @pdf.bounds.move_past_bottom
-            draw_header unless cell.row == 0
-            offset = @pdf.y - cell.y
+            if cell.row > 0 && @header
+              header_height = add_header(cells_this_page, @pdf.cursor, cell.row-1)
+            else
+              header_height = 0
+            end
+            offset = @pdf.y - cell.y - header_height
             started_new_page_at_row = cell.row
           end
    
@@ -301,7 +331,9 @@ module Prawn
 
           # Set background color, if any.
           if @row_colors && (!@header || cell.row > 0)
-            index = @header ? (cell.row - 1) : cell.row
+            # Ensure coloring restarts on every page (to make sure the header
+            # and first row of a page are not colored the same way).
+            index = cell.row - [started_new_page_at_row, @header ? 1 : 0].max
             cell.background_color ||= @row_colors[index % @row_colors.length]
           end
 
@@ -309,6 +341,10 @@ module Prawn
           last_y = y
         end
         # Draw the last page of cells
+        if @before_rendering_page
+          c = Cells.new(cells_this_page.map { |c, _| c })
+          @before_rendering_page.call(c)
+        end
         Cell.draw_cells(cells_this_page)
 
         @pdf.move_cursor_to(last_y - @cells.last.height)
@@ -343,7 +379,7 @@ module Prawn
           f = (width - cells.min_width).to_f / (natural_width - cells.min_width)
 
           (0...column_length).map do |c|
-            min, nat = column(c).min_width, column(c).width
+            min, nat = column(c).min_width, natural_column_widths[c]
             (f * (nat - min)) + min
           end
         elsif width - natural_width > epsilon
@@ -351,7 +387,7 @@ module Prawn
           f = (width - cells.width).to_f / (cells.max_width - cells.width)
 
           (0...column_length).map do |c|
-            nat, max = column(c).width, column(c).max_width
+            nat, max = natural_column_widths[c], column(c).max_width
             (f * (max - nat)) + nat
           end
         else
@@ -363,7 +399,21 @@ module Prawn
     # Returns an array with the height of each row.
     #
     def row_heights
-      @natural_row_heights ||= (0...row_length).map{ |r| row(r).height }
+      @natural_row_heights ||=
+        begin
+          heights_by_row = Hash.new(0)
+          cells.each do |cell|
+            next if cell.is_a?(Cell::SpanDummy)
+
+            # Split the height of row-spanned cells evenly by rows
+            height_per_row = cell.height.to_f / cell.rowspan
+            cell.rowspan.times do |i|
+              heights_by_row[cell.row + i] =
+                [heights_by_row[cell.row + i], height_per_row].max
+            end
+          end
+          heights_by_row.sort_by { |row, _| row }.map { |_, h| h }
+        end
     end
 
     protected
@@ -375,23 +425,77 @@ module Prawn
     def make_cells(data)
       assert_proper_table_data(data)
 
-      cells = []
+      cells = Cells.new
       
-      @row_length = data.length
-      @column_length = data.map{ |r| r.length }.max
-
-      data.each_with_index do |row_cells, row_number|
-        row_cells.each_with_index do |cell_data, column_number|
+      row_number = 0
+      data.each do |row_cells|
+        column_number = 0
+        row_cells.each do |cell_data|
+          # If we landed on a spanned cell (from a rowspan above), continue
+          # until we find an empty spot.
+          column_number += 1 until cells[row_number, column_number].nil?
+
+          # Build the cell and store it in the Cells collection.
           cell = Cell.make(@pdf, cell_data)
-          cell.extend(Cell::InTable)
-          cell.row = row_number
-          cell.column = column_number
-          cells << cell
+          cells[row_number, column_number] = cell
+
+          # Add dummy cells for the rest of the cells in the span group. This
+          # allows Prawn to keep track of the horizontal and vertical space
+          # occupied in each column and row spanned by this cell, while still
+          # leaving the master (top left) cell in the group responsible for
+          # drawing. Dummy cells do not put ink on the page.
+          cell.rowspan.times do |i|
+            cell.colspan.times do |j|
+              next if i == 0 && j == 0
+
+              # It is an error to specify spans that overlap; catch this here
+              if bad_cell = cells[row_number + i, column_number + j]
+                raise Prawn::Errors::InvalidTableSpan,
+                  "Spans overlap at row #{row_number + i}, " +
+                  "column #{column_number + j}."
+              end
+
+              dummy = Cell::SpanDummy.new(@pdf, cell)
+              cells[row_number + i, column_number + j] = dummy
+              cell.dummy_cells << dummy
+            end
+          end
+
+          column_number += cell.colspan
         end
+
+        row_number += 1
       end
+
+      # Calculate the number of rows and columns in the table, taking into
+      # account that some cells may span past the end of the physical cells we
+      # have.
+      @row_length = cells.map do |cell|
+        cell.row + cell.rowspan
+      end.max
+
+      @column_length = cells.map do |cell|
+        cell.column + cell.colspan
+      end.max
+
       cells
     end
 
+    # Add the header row to the given array of cells at the given y-position.
+    # Number the row with the given +row+ index, so that the header appears (in
+    # any Cells built for this page) immediately prior to the first data row on
+    # this page.
+    #
+    # Return the height of the header.
+    #
+    def add_header(page_of_cells, y, row)
+      @header_row.each do |cell|
+        cell.row = row
+        page_of_cells << [cell, [cell.x, y]]
+      end
+      @header_row.height
+    end
+
     # Raises an error if the data provided cannot be converted into a valid
     # table.
     #
@@ -408,23 +512,24 @@ module Prawn
       end
     end
 
-    # If the table has a header, draw it at the current position.
-    #
-    def draw_header
-      if @header
-        y = @pdf.cursor
-        row(0).each do |cell|
-          cell.y = y
-          cell.draw
-        end
-        @pdf.move_cursor_to(y - row(0).height)
-      end
-    end
-
     # Returns an array of each column's natural (unconstrained) width.
     #
     def natural_column_widths
-      @natural_column_widths ||= (0...column_length).map { |c| column(c).width }
+      @natural_column_widths ||=
+        begin
+          widths_by_column = Hash.new(0)
+          cells.each do |cell|
+            next if cell.is_a?(Cell::SpanDummy)
+
+            # Split the width of colspanned cells evenly by columns
+            width_per_column = cell.width.to_f / cell.colspan
+            cell.colspan.times do |i|
+              widths_by_column[cell.column + i] =
+                [widths_by_column[cell.column + i], width_per_column].max
+            end
+          end
+          widths_by_column.sort_by { |col, _| col }.map { |_, w| w }
+        end
     end
 
     # Returns the "natural" (unconstrained) width of the table. This may be
@@ -433,7 +538,7 @@ module Prawn
     # a mile long.
     #
     def natural_width
-      @natural_width ||= natural_column_widths.inject(0) { |sum, w| sum + w }
+      @natural_width ||= natural_column_widths.inject(0, &:+)
     end
 
     # Assigns the calculated column widths to each cell. This ensures that each