prawn 2.1.0 → 2.4.0

data/lib/prawn/graphics/transformation.rb

@@ -1,5 +1,5 @@
-# encoding: utf-8
-#
+# frozen_string_literal: true
+
 # transformation.rb: Implements rotate, translate, skew, scale and a generic
 #                     transformation_matrix
 #
@@ -48,7 +48,8 @@ module Prawn
         if options[:origin].nil?
           transformation_matrix(cos, sin, -sin, cos, 0, 0, &block)
         else
-          fail Prawn::Errors::BlockRequired unless block_given?
+          raise Prawn::Errors::BlockRequired unless block
+
           x = options[:origin][0] + bounds.absolute_left
           y = options[:origin][1] + bounds.absolute_bottom
           x_prime = x * cos - y * sin
@@ -59,8 +60,8 @@ module Prawn
         end
       end
 
-      # Translate the user space.  If a block is not provided, then you must save
-      # and restore the graphics state yourself.
+      # Translate the user space.  If a block is not provided, then you must
+      # save and restore the graphics state yourself.
       #
       # Example without a block: move the text up and over 10
       #
@@ -117,7 +118,8 @@ module Prawn
         if options[:origin].nil?
           transformation_matrix(factor, 0, 0, factor, 0, 0, &block)
         else
-          fail Prawn::Errors::BlockRequired unless block_given?
+          raise Prawn::Errors::BlockRequired unless block
+
           x = options[:origin][0] + bounds.absolute_left
           y = options[:origin][1] + bounds.absolute_bottom
           x_prime = factor * x
@@ -142,12 +144,16 @@ module Prawn
       # Transform the user space (see notes for rotate regarding graphics state)
       # Generally, one would use the rotate, scale, translate, and skew
       # convenience methods instead of calling transformation_matrix directly
-      def transformation_matrix(a, b, c, d, e, f)
-        values = [a, b, c, d, e, f].map { |x| "%.5f" % x }.join(" ")
+      def transformation_matrix(*matrix)
+        if matrix.length != 6
+          raise ArgumentError,
+            'Transformation matrix must have exacty 6 elements'
+        end
         save_graphics_state if block_given?
 
-        add_to_transformation_stack(a, b, c, d, e, f)
+        add_to_transformation_stack(*matrix)
 
+        values = PDF::Core.real_params(matrix)
         renderer.add_content "#{values} cm"
         if block_given?
           yield

data/lib/prawn/graphics/transparency.rb

@@ -1,5 +1,5 @@
-# encoding: utf-8
-#
+# frozen_string_literal: true
+
 # transparency.rb : Implements transparency
 #
 # Copyright October 2009, Daniel Nelson. All Rights Reserved.
@@ -51,14 +51,16 @@ module Prawn
       #     pdf.fill_and_stroke_circle([x, y], 25)
       #   end
       #
-      def transparent(opacity, stroke_opacity = opacity, &block)
+      def transparent(opacity, stroke_opacity = opacity)
         renderer.min_version(1.4)
 
-        opacity        = [[opacity, 0.0].max, 1.0].min
+        opacity = [[opacity, 0.0].max, 1.0].min
         stroke_opacity = [[stroke_opacity, 0.0].max, 1.0].min
 
         save_graphics_state
-        renderer.add_content "/#{opacity_dictionary_name(opacity, stroke_opacity)} gs"
+        renderer.add_content(
+          "/#{opacity_dictionary_name(opacity, stroke_opacity)} gs"
+        )
         yield
         restore_graphics_state
       end
@@ -77,21 +79,23 @@ module Prawn
         key = "#{opacity}_#{stroke_opacity}"
 
         if opacity_dictionary_registry[key]
-          dictionary =  opacity_dictionary_registry[key][:obj]
-          dictionary_name =  opacity_dictionary_registry[key][:name]
+          dictionary = opacity_dictionary_registry[key][:obj]
+          dictionary_name = opacity_dictionary_registry[key][:name]
         else
           dictionary = ref!(
-            :Type => :ExtGState,
-            :CA   => stroke_opacity,
-            :ca   => opacity
+            Type: :ExtGState,
+            CA: stroke_opacity,
+            ca: opacity
           )
 
           dictionary_name = "Tr#{next_opacity_dictionary_id}"
-          opacity_dictionary_registry[key] = { :name => dictionary_name,
-                                               :obj  => dictionary }
+          opacity_dictionary_registry[key] = {
+            name: dictionary_name,
+            obj: dictionary
+          }
         end
 
-        page.ext_gstates.merge!(dictionary_name => dictionary)
+        page.ext_gstates[dictionary_name] = dictionary
         dictionary_name
       end
     end

data/lib/prawn/grid.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 # grid.rb: Provides a basic grid layout system for Prawn
 #
@@ -33,21 +33,21 @@ module Prawn
     #
     def grid(*args)
       @boxes ||= {}
-      return @boxes[args] if @boxes[args]
-
-      if args.empty?
-        @boxes[args] = @grid
-      else
-        g1, g2 = args
-
-        if g1.class == Array && g2.class == Array && g1.length == 2 && g2.length == 2
-          @boxes[args] = multi_box(single_box(*g1), single_box(*g2))
-        else
-          @boxes[args] = single_box(g1, g2)
+      @boxes[args] ||=
+        begin
+          if args.empty?
+            @grid
+          else
+            g1, g2 = args
+
+            if g1.is_a?(Array) && g2.is_a?(Array) &&
+                g1.length == 2 && g2.length == 2
+              multi_box(single_box(*g1), single_box(*g2))
+            else
+              single_box(g1, g2)
+            end
+          end
         end
-      end
-
-      @boxes[args]
     end
 
     # A Grid represents the entire grid system of a Page and calculates
@@ -56,14 +56,15 @@ module Prawn
     # @group Experimental API
     class Grid
       attr_reader :pdf, :columns, :rows, :gutter, :row_gutter, :column_gutter
+
       def initialize(pdf, options = {}) # :nodoc:
-        valid_options = [:columns, :rows, :gutter, :row_gutter, :column_gutter]
+        valid_options = %i[columns rows gutter row_gutter column_gutter]
         Prawn.verify_options valid_options, options
 
         @pdf = pdf
         @columns = options[:columns]
         @rows = options[:rows]
-        set_gutter(options)
+        apply_gutter(options)
       end
 
       # Calculates the base width of boxes.
@@ -77,10 +78,10 @@ module Prawn
       end
 
       # Diagnostic tool to show all of the grids.  Defaults to gray.
-      def show_all(color = "CCCCCC")
-        self.rows.times do |i|
-          self.columns.times do |j|
-            pdf.grid(i, j).show(color)
+      def show_all(color = 'CCCCCC')
+        rows.times do |row|
+          columns.times do |column|
+            pdf.grid(row, column).show(color)
           end
         end
       end
@@ -91,12 +92,13 @@ module Prawn
         (total.to_f - (gutter * (num - 1).to_f)) / num.to_f
       end
 
-      def set_gutter(options)
+      def apply_gutter(options)
         if options.key?(:gutter)
           @gutter = options[:gutter].to_f
-          @row_gutter, @column_gutter = @gutter, @gutter
+          @row_gutter = @gutter
+          @column_gutter = @gutter
         else
-          @row_gutter    = options[:row_gutter].to_f
+          @row_gutter = options[:row_gutter].to_f
           @column_gutter = options[:column_gutter].to_f
           @gutter = 0
         end
@@ -111,17 +113,17 @@ module Prawn
     class GridBox
       attr_reader :pdf
 
-      def initialize(pdf, i, j)
+      def initialize(pdf, rows, columns)
         @pdf = pdf
-        @i = i
-        @j = j
+        @rows = rows
+        @columns = columns
       end
 
       # Mostly diagnostic method that outputs the name of a box as
       # col_num, row_num
       #
       def name
-        "#{@i.to_s},#{@j.to_s}"
+        "#{@rows},#{@columns}"
       end
 
       # :nodoc
@@ -146,7 +148,7 @@ module Prawn
 
       # x-coordinate of left side
       def left
-        @left ||= (width + grid.column_gutter) * @j.to_f
+        @left ||= (width + grid.column_gutter) * @columns.to_f
       end
 
       # x-coordinate of right side
@@ -156,7 +158,7 @@ module Prawn
 
       # y-coordinate of the top
       def top
-        @top ||= total_height - ((height + grid.row_gutter) * @i.to_f)
+        @top ||= total_height - ((height + grid.row_gutter) * @rows.to_f)
       end
 
       # y-coordinate of the bottom
@@ -186,16 +188,16 @@ module Prawn
 
       # Creates a standard bounding box based on the grid box.
       def bounding_box(&blk)
-        pdf.bounding_box(top_left, :width => width, :height => height, &blk)
+        pdf.bounding_box(top_left, width: width, height: height, &blk)
       end
 
       # Diagnostic method
-      def show(grid_color = "CCCCCC")
-        self.bounding_box do
+      def show(grid_color = 'CCCCCC')
+        bounding_box do
           original_stroke_color = pdf.stroke_color
 
           pdf.stroke_color = grid_color
-          pdf.text self.name
+          pdf.text name
           pdf.stroke_bounds
 
           pdf.stroke_color = original_stroke_color
@@ -212,18 +214,20 @@ module Prawn
     # A MultiBox is specified by 2 Boxes and spans the areas between.
     #
     # @group Experimental API
-    class MultiBox < GridBox
-      def initialize(pdf, b1, b2)
+    class MultiBox
+      def initialize(pdf, box1, box2)
         @pdf = pdf
-        @bs = [b1, b2]
+        @boxes = [box1, box2]
       end
 
+      attr_reader :pdf
+
       def name
-        @bs.map(&:name).join(":")
+        @boxes.map(&:name).join(':')
       end
 
       def total_height
-        @bs[0].total_height
+        @boxes[0].total_height
       end
 
       def width
@@ -235,7 +239,7 @@ module Prawn
       end
 
       def gutter
-        @bs[0].gutter
+        @boxes[0].gutter
       end
 
       def left
@@ -254,33 +258,65 @@ module Prawn
         bottom_box.bottom
       end
 
+      def top_left
+        [left, top]
+      end
+
+      def top_right
+        [right, top]
+      end
+
+      def bottom_left
+        [left, bottom]
+      end
+
+      def bottom_right
+        [right, bottom]
+      end
+
+      def bounding_box(&blk)
+        pdf.bounding_box(top_left, width: width, height: height, &blk)
+      end
+
+      def show(grid_color = 'CCCCCC')
+        bounding_box do
+          original_stroke_color = pdf.stroke_color
+
+          pdf.stroke_color = grid_color
+          pdf.text name
+          pdf.stroke_bounds
+
+          pdf.stroke_color = original_stroke_color
+        end
+      end
+
       private
 
       def left_box
-        @left_box ||= @bs.min { |a, b| a.left <=> b.left }
+        @left_box ||= @boxes.min_by(&:left)
       end
 
       def right_box
-        @right_box ||= @bs.max { |a, b| a.right <=> b.right }
+        @right_box ||= @boxes.max_by(&:right)
       end
 
       def top_box
-        @top_box ||= @bs.max { |a, b| a.top <=> b.top }
+        @top_box ||= @boxes.max_by(&:top)
       end
 
       def bottom_box
-        @bottom_box ||= @bs.min { |a, b| a.bottom <=> b.bottom }
+        @bottom_box ||= @boxes.min_by(&:bottom)
       end
     end
 
     private
 
-    def single_box(i, j)
-      GridBox.new(self, i, j)
+    def single_box(rows, columns)
+      GridBox.new(self, rows, columns)
     end
 
-    def multi_box(b1, b2)
-      MultiBox.new(self, b1, b2)
+    def multi_box(box1, box2)
+      MultiBox.new(self, box1, box2)
     end
   end
 end

data/lib/prawn/image_handler.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 # ImageHandler provides a way to register image processors with Prawn
 #
@@ -29,16 +29,16 @@ module Prawn
     end
 
     def unregister(handler)
-      @handlers.reject!{ |h| h == handler }
+      @handlers.reject! { |h| h == handler }
     end
 
     def find(image_blob)
-      handler = @handlers.find{ |h| h.can_render? image_blob }
+      handler = @handlers.find { |h| h.can_render? image_blob }
 
       return handler if handler
 
-      fail Prawn::Errors::UnsupportedImageType,
-           "image file is an unrecognised format"
+      raise Prawn::Errors::UnsupportedImageType,
+        'image file is an unrecognised format'
     end
   end
 end

data/lib/prawn/images.rb

@@ -1,4 +1,7 @@
 # encoding: ASCII-8BIT
+
+# frozen_string_literal: true
+
 # images.rb : Implements PDF image embedding
 #
 # Copyright April 2008, James Healy, Gregory Brown.  All Rights Reserved.
@@ -17,16 +20,19 @@ module Prawn
     # images with alpha channels can be processor and memory intensive.)
     #
     # Arguments:
-    # <tt>file</tt>:: path to file or an object that responds to #read and #rewind
+    # <tt>file</tt>:: path to file or an object that responds to #read and
+    #   #rewind
     #
     # Options:
-    # <tt>:at</tt>:: an array [x,y] with the location of the top left corner of the image.
+    # <tt>:at</tt>:: an array [x,y] with the location of the top left corner of
+    #   the image.
     # <tt>:position</tt>::  One of (:left, :center, :right) or an x-offset
-    # <tt>:vposition</tt>::  One of (:top, :center, :center) or an y-offset
+    # <tt>:vposition</tt>::  One of (:top, :center, :bottom) or an y-offset
     # <tt>:height</tt>:: the height of the image [actual height of the image]
     # <tt>:width</tt>:: the width of the image [actual width of the image]
     # <tt>:scale</tt>:: scale the dimensions of the image proportionally
-    # <tt>:fit</tt>:: scale the dimensions of the image proportionally to fit inside [width,height]
+    # <tt>:fit</tt>:: scale the dimensions of the image proportionally to fit
+    #   inside [width,height]
     #
     #   Prawn::Document.generate("image2.pdf", :page_layout => :landscape) do
     #     pigs = "#{Prawn::DATADIR}/images/pigs.jpg"
@@ -52,7 +58,7 @@ module Prawn
     #   require "open-uri"
     #
     #   Prawn::Document.generate("remote_images.pdf") do
-    #     image open("http://prawn.majesticseacreature.com/media/prawn_logo.png")
+    #     image open("http://prawnpdf.org/media/prawn_logo.png")
     #   end
     #
     # This method returns an image info object which can be used to check the
@@ -60,8 +66,10 @@ module Prawn
     # (See also: Prawn::Images::PNG , Prawn::Images::JPG)
     #
     def image(file, options = {})
-      Prawn.verify_options [:at, :position, :vposition, :height,
-                            :width, :scale, :fit], options
+      Prawn.verify_options(
+        %i[at position vposition height width scale fit],
+        options
+      )
 
       pdf_obj, info = build_image_object(file)
       embed_image(pdf_obj, info, options)
@@ -74,8 +82,7 @@ module Prawn
     #
     # @private
     def build_image_object(file)
-      io = verify_and_open_image(file)
-      image_content = io.read
+      image_content = verify_and_read_image(file)
       image_sha1 = Digest::SHA1.hexdigest(image_content)
 
       # if this image has already been embedded, just reuse it
@@ -87,11 +94,13 @@ module Prawn
         info = Prawn.image_handler.find(image_content).new(image_content)
 
         # Bump PDF version if the image requires it
-        renderer.min_version(info.min_pdf_version) if info.respond_to?(:min_pdf_version)
+        if info.respond_to?(:min_pdf_version)
+          renderer.min_version(info.min_pdf_version)
+        end
 
         # Add the image to the PDF and register it in case we see it again.
         image_obj = info.build_pdf_object(self)
-        image_registry[image_sha1] = { :obj => image_obj, :info => info }
+        image_registry[image_sha1] = { obj: image_obj, info: info }
       end
 
       [image_obj, info]
@@ -117,15 +126,15 @@ module Prawn
       # add a reference to the image object to the current page
       # resource list and give it a label
       label = "I#{next_image_id}"
-      state.page.xobjects.merge!(label => pdf_obj)
+      state.page.xobjects[label] = pdf_obj
 
-      cm_params = PDF::Core.real_params([ w, 0, 0, h, x, y - h])
+      cm_params = PDF::Core.real_params([w, 0, 0, h, x, y - h])
       renderer.add_content("\nq\n#{cm_params} cm\n/#{label} Do\nQ")
     end
 
     private
 
-    def verify_and_open_image(io_or_path)
+    def verify_and_read_image(io_or_path)
       # File or IO
       if io_or_path.respond_to?(:rewind)
         io = io_or_path
@@ -135,54 +144,56 @@ module Prawn
         # read the file as binary so the size is calculated correctly
         # guard binmode because some objects acting io-like don't implement it
         io.binmode if io.respond_to?(:binmode)
-        return io
+        return io.read
       end
       # String or Pathname
       io_or_path = Pathname.new(io_or_path)
-      fail ArgumentError, "#{io_or_path} not found" unless io_or_path.file?
-      io = io_or_path.open('rb')
-      io
+      raise ArgumentError, "#{io_or_path} not found" unless io_or_path.file?
+
+      io_or_path.binread
     end
 
-    def image_position(w, h, options)
+    def image_position(width, height, options)
       options[:position] ||= :left
 
-      y = case options[:vposition]
-          when :top
-            bounds.absolute_top
-          when :center
-            bounds.absolute_top - (bounds.height - h) / 2.0
-          when :bottom
-            bounds.absolute_bottom + h
-          when Numeric
-            bounds.absolute_top - options[:vposition]
-          else
-            determine_y_with_page_flow(h)
-          end
-
-      x = case options[:position]
-          when :left
-            bounds.left_side
-          when :center
-            bounds.left_side + (bounds.width - w) / 2.0
-          when :right
-            bounds.right_side - w
-          when Numeric
-            options[:position] + bounds.left_side
-          end
-
-      return [x, y]
+      y =
+        case options[:vposition]
+        when :top
+          bounds.absolute_top
+        when :center
+          bounds.absolute_top - (bounds.height - height) / 2.0
+        when :bottom
+          bounds.absolute_bottom + height
+        when Numeric
+          bounds.absolute_top - options[:vposition]
+        else
+          determine_y_with_page_flow(height)
+        end
+
+      x =
+        case options[:position]
+        when :left
+          bounds.left_side
+        when :center
+          bounds.left_side + (bounds.width - width) / 2.0
+        when :right
+          bounds.right_side - width
+        when Numeric
+          options[:position] + bounds.left_side
+        end
+
+      [x, y]
     end
 
-    def determine_y_with_page_flow(h)
-      if overruns_page?(h)
+    def determine_y_with_page_flow(height)
+      if overruns_page?(height)
         bounds.move_past_bottom
       end
-      self.y
+      y
     end
 
-    def overruns_page?(h)
-      (self.y - h) < reference_bounds.absolute_bottom
+    def overruns_page?(height)
+      (y - height) < reference_bounds.absolute_bottom
     end
 
     def image_registry