prawn 2.0.1 → 2.0.2

data/lib/prawn/font_metric_cache.rb

@@ -8,22 +8,20 @@
 #
 
 module Prawn
-
   # Cache used internally by Prawn::Document instances to calculate the width
   # of various strings for layout purposes.
   #
   # @private
   class FontMetricCache
+    CacheEntry = Struct.new(:font, :options, :string)
 
-    CacheEntry = Struct.new( :font, :options, :string )
-
-    def initialize( document )
+    def initialize(document)
       @document = document
 
       @cache = {}
     end
 
-    def width_of( string, options )
+    def width_of(string, options)
       f = if options[:style]
             # override style with :style => :bold
             @document.find_font(@document.font.family, :style => options[:style])
@@ -31,7 +29,7 @@ module Prawn
             @document.font
           end
 
-      key = CacheEntry.new( f, options, string )
+      key = CacheEntry.new(f, options, string)
 
       unless length = @cache[ key ]
         length = @cache[ key ] = f.compute_width_of(string, options)
@@ -40,7 +38,5 @@ module Prawn
       length +
         (@document.character_spacing * @document.font.character_count(string))
     end
-
   end
-
 end

data/lib/prawn/graphics.rb

@@ -6,7 +6,6 @@
 #
 # This is free software. Please see the LICENSE and COPYING files for details.
 
-
 require_relative "graphics/color"
 require_relative "graphics/dash"
 require_relative "graphics/cap_style"
@@ -16,7 +15,6 @@ require_relative "graphics/transformation"
 require_relative "graphics/patterns"
 
 module Prawn
-
   # Implements the drawing facilities for Prawn::Document.
   # Use this to draw the most beautiful imaginable things.
   #
@@ -24,7 +22,6 @@ module Prawn
   # ruby-pdf.rubyforge.org
   #
   module Graphics
-
     include Color
     include Dash
     include CapStyle
@@ -66,15 +63,16 @@ module Prawn
     #
     #   pdf.curve_to [100,100], :bounds => [[90,90],[75,75]]
     #
-    def curve_to(dest,options={})
-       options[:bounds] or raise Prawn::Errors::InvalidGraphicsPath,
-         "Bounding points for bezier curve must be specified "+
-         "as :bounds => [[x1,y1],[x2,y2]]"
+    def curve_to(dest, options = {})
+      options[:bounds] or fail Prawn::Errors::InvalidGraphicsPath,
+                               "Bounding points for bezier curve must be specified " \
+                               "as :bounds => [[x1,y1],[x2,y2]]"
 
-       curve_points = PDF::Core.real_params(
-        (options[:bounds] << dest).flat_map { |e| map_to_absolute(e) })
+      curve_points = PDF::Core.real_params(
+        (options[:bounds] << dest).flat_map { |e| map_to_absolute(e) }
+      )
 
-       renderer.add_content("#{curve_points} c")
+      renderer.add_content("#{curve_points} c")
     end
 
     # Draws a rectangle given <tt>point</tt>, <tt>width</tt> and
@@ -82,8 +80,8 @@ module Prawn
     #
     #    pdf.rectangle [300,300], 100, 200
     #
-    def rectangle(point,width,height)
-      x,y = map_to_absolute(point)
+    def rectangle(point, width, height)
+      x, y = map_to_absolute(point)
       box = PDF::Core.real_params([x, y - height, width, height])
 
       renderer.add_content("#{box} re")
@@ -95,12 +93,11 @@ module Prawn
     #
     #    pdf.rounded_rectangle [300,300], 100, 200, 10
     #
-    def rounded_rectangle(point,width,height,radius)
+    def rounded_rectangle(point, width, height, radius)
       x, y = point
       rounded_polygon(radius, point, [x + width, y], [x + width, y - height], [x, y - height])
     end
 
-
     ###########################################################
     #  Higher level functions: May use relative coords        #
     ###########################################################
@@ -120,7 +117,7 @@ module Prawn
     #   pdf.line_width(5)
     #   pdf.line_width #=> 5
     #
-    def line_width(width=nil)
+    def line_width(width = nil)
       if width
         self.line_width = width
       else
@@ -135,7 +132,7 @@ module Prawn
     #   pdf.line(100,100,200,250)
     #
     def line(*points)
-      x0,y0,x1,y1 = points.flatten
+      x0, y0, x1, y1 = points.flatten
       move_to(x0, y0)
       line_to(x1, y1)
     end
@@ -146,14 +143,14 @@ module Prawn
     #  # draw a line from [25, 75] to [100, 75]
     #  horizontal_line 25, 100, :at => 75
     #
-    def horizontal_line(x1,x2,options={})
+    def horizontal_line(x1, x2, options = {})
       if options[:at]
         y1 = options[:at]
       else
         y1 = y - bounds.absolute_bottom
       end
 
-      line(x1,y1,x2,y1)
+      line(x1, y1, x2, y1)
     end
 
     # Draws a horizontal line from the left border to the right border of the
@@ -168,8 +165,8 @@ module Prawn
     #   # draw a line from [25, 100] to [25, 300]
     #   vertical_line 100, 300, :at => 25
     #
-    def vertical_line(y1,y2,params)
-      line(params[:at],y1,params[:at],y2)
+    def vertical_line(y1, y2, params)
+      line(params[:at], y1, params[:at], y2)
     end
 
     # Draws a Bezier curve between two points, bounded by two additional
@@ -177,9 +174,9 @@ module Prawn
     #
     #    pdf.curve [50,100], [100,100], :bounds => [[90,90],[75,75]]
     #
-    def curve(origin,dest, options={})
+    def curve(origin, dest, options = {})
       move_to(*origin)
-      curve_to(dest,options)
+      curve_to(dest, options)
     end
 
     # This constant is used to approximate a symmetrical arc using a cubic
@@ -214,19 +211,19 @@ module Prawn
 
       # Upper right hand corner
       curve_to [x,  y + r2],
-        :bounds => [[x + r1, y + l2], [x + l1, y + r2]]
+               :bounds => [[x + r1, y + l2], [x + l1, y + r2]]
 
       # Upper left hand corner
       curve_to [x - r1, y],
-        :bounds => [[x - l1, y + r2], [x - r1, y + l2]]
+               :bounds => [[x - l1, y + r2], [x - r1, y + l2]]
 
       # Lower left hand corner
       curve_to [x, y - r2],
-        :bounds => [[x - r1, y - l2], [x - l1, y - r2]]
+               :bounds => [[x - r1, y - l2], [x - l1, y - r2]]
 
       # Lower right hand corner
       curve_to [x + r1, y],
-        :bounds => [[x + l1, y - r2], [x + r1, y - l2]]
+               :bounds => [[x + l1, y - r2], [x + r1, y - l2]]
 
       move_to(x, y)
     end
@@ -261,15 +258,14 @@ module Prawn
       renderer.add_content "h"
     end
 
-
     # Creates a rounded vertex for a line segment used for building a rounded polygon
     # requires a radius to define bezier curve and three points. The first two points define
     # the line segment and the third point helps define the curve for the vertex.
     def rounded_vertex(radius, *points)
       radial_point_1 = point_on_line(radius, points[0], points[1])
-      bezier_point_1 = point_on_line((radius - radius*KAPPA), points[0], points[1] )
+      bezier_point_1 = point_on_line((radius - radius * KAPPA), points[0], points[1])
       radial_point_2 = point_on_line(radius, points[2], points[1])
-      bezier_point_2 = point_on_line((radius - radius*KAPPA), points[2], points[1])
+      bezier_point_2 = point_on_line((radius - radius * KAPPA), points[2], points[1])
       line_to(radial_point_1)
       curve_to(radial_point_2, :bounds => [bezier_point_1, bezier_point_2])
     end
@@ -322,12 +318,12 @@ module Prawn
     #
     def stroke_axis(options = {})
       options = {
-        :at => [0,0],
-        :height => bounds.height.to_i - (options[:at] || [0,0])[1],
-        :width => bounds.width.to_i - (options[:at] || [0,0])[0],
+        :at => [0, 0],
+        :height => bounds.height.to_i - (options[:at] || [0, 0])[1],
+        :width => bounds.width.to_i - (options[:at] || [0, 0])[0],
         :step_length => 100,
         :negative_axes_length => 20,
-        :color => "000000",
+        :color => "000000"
       }.merge(options)
 
       Prawn.verify_options([:at, :width, :height, :step_length,
@@ -365,7 +361,7 @@ module Prawn
     # will be used. See the PDF reference, "Graphics -> Path Construction and
     # Painting -> Clipping Path Operators" for details on the difference.
     #
-    def fill(options={})
+    def fill(options = {})
       yield if block_given?
       renderer.add_content(options[:fill_rule] == :even_odd ? "f*" : "f")
     end
@@ -379,7 +375,7 @@ module Prawn
     # will be used. See the PDF reference, "Graphics -> Path Construction and
     # Painting -> Clipping Path Operators" for details on the difference.
     #
-    def fill_and_stroke(options={})
+    def fill_and_stroke(options = {})
       yield if block_given?
       renderer.add_content(options[:fill_rule] == :even_odd ? "b*" : "b")
     end
@@ -600,7 +596,7 @@ module Prawn
     shapes = %w{line_to curve_to rectangle rounded_rectangle line horizontal_line horizontal_rule vertical_line
                 curve circle_at circle ellipse_at ellipse polygon rounded_polygon rounded_vertex}
 
-    ops.product(shapes).each do |operation,shape|
+    ops.product(shapes).each do |operation, shape|
       class_eval "def #{operation}_#{shape}(*args); #{shape}(*args); #{operation}; end"
     end
 
@@ -619,7 +615,7 @@ module Prawn
     end
 
     def map_to_absolute(*point)
-      x,y = point.flatten
+      x, y = point.flatten
       [@bounding_box.absolute_left + x, @bounding_box.absolute_bottom + y]
     end
 
@@ -628,19 +624,18 @@ module Prawn
     end
 
     def degree_to_rad(angle)
-       angle * Math::PI / 180
+      angle * Math::PI / 180
     end
 
     # Returns the coordinates for a point on a line that is a given distance away from the second
     # point defining the line segement
     def point_on_line(distance_from_end, *points)
-      x0,y0,x1,y1 = points.flatten
+      x0, y0, x1, y1 = points.flatten
       length = Math.sqrt((x1 - x0)**2 + (y1 - y0)**2)
       p = (length - distance_from_end) / length
-      xr = x0 + p*(x1 - x0)
-      yr = y0 + p*(y1 - y0)
+      xr = x0 + p * (x1 - x0)
+      yr = y0 + p * (y1 - y0)
       [xr, yr]
     end
-
   end
 end

data/lib/prawn/graphics/cap_style.rb

@@ -19,7 +19,7 @@ module Prawn
       #
       # NOTE: If this method is never called, :butt will be used by default.
       #
-      def cap_style(style=nil)
+      def cap_style(style = nil)
         return current_cap_style || :butt if style.nil?
 
         self.current_cap_style = style

data/lib/prawn/graphics/color.rb

@@ -74,8 +74,8 @@ module Prawn
       #  => [255, 120, 8]
       #
       def hex2rgb(hex)
-        r,g,b = hex[0..1], hex[2..3], hex[4..5]
-        [r,g,b].map { |e| e.to_i(16) }
+        r, g, b = hex[0..1], hex[2..3], hex[4..5]
+        [r, g, b].map { |e| e.to_i(16) }
       end
 
       private
@@ -87,7 +87,7 @@ module Prawn
         when 4
           color
         else
-          raise ArgumentError, 'wrong number of arguments supplied'
+          fail ArgumentError, 'wrong number of arguments supplied'
         end
       end
 
@@ -102,7 +102,7 @@ module Prawn
           when 4
             :CMYK
           else
-            raise ArgumentError, "Unknown type of color: #{color.inspect}"
+            fail ArgumentError, "Unknown type of color: #{color.inspect}"
           end
         end
       end
@@ -110,10 +110,10 @@ module Prawn
       def normalize_color(color)
         case color_type(color)
         when :RGB
-          r,g,b = hex2rgb(color)
+          r, g, b = hex2rgb(color)
           [r / 255.0, g / 255.0, b / 255.0]
         when :CMYK
-          c,m,y,k = *color
+          c, m, y, k = *color
           [c / 100.0, m / 100.0, y / 100.0, k / 100.0]
         end
       end
@@ -139,30 +139,30 @@ module Prawn
         set_current_color_space(color_space, type)
 
         unless COLOR_SPACES.include?(color_space)
-          raise ArgumentError, "unknown color space: '#{color_space}'"
+          fail ArgumentError, "unknown color space: '#{color_space}'"
         end
 
         operator = case type
-        when :fill
-          'cs'
-        when :stroke
-          'CS'
-        else
-          raise ArgumentError, "unknown type '#{type}'"
-        end
+                   when :fill
+                     'cs'
+                   when :stroke
+                     'CS'
+                   else
+                     fail ArgumentError, "unknown type '#{type}'"
+                   end
 
         renderer.add_content "/#{color_space} #{operator}"
       end
 
       def set_color(type, color, options = {})
         operator = case type
-        when :fill
-          'scn'
-        when :stroke
-          'SCN'
-        else
-          raise ArgumentError, "unknown type '#{type}'"
-        end
+                   when :fill
+                     'scn'
+                   when :stroke
+                     'SCN'
+                   else
+                     fail ArgumentError, "unknown type '#{type}'"
+                   end
 
         if options[:pattern]
           set_color_space type, :Pattern
@@ -225,8 +225,6 @@ module Prawn
       def write_color(color, operator)
         renderer.add_content "#{color} #{operator}"
       end
-
     end
   end
 end
-

data/lib/prawn/graphics/dash.rb

@@ -52,17 +52,17 @@ module Prawn
       # Integers or Floats may be used for length and the option values.
       # Dash units are in PDF points (1/72 inch).
       #
-      def dash(length=nil, options={})
+      def dash(length = nil, options = {})
         return current_dash_state if length.nil?
 
         if length == 0 || length.kind_of?(Array) && length.any? { |e| e == 0 }
-          raise ArgumentError,
-            "Zero length dashes are invalid. Call #undash to disable dashes."
+          fail ArgumentError,
+               "Zero length dashes are invalid. Call #undash to disable dashes."
         end
 
         self.current_dash_state = { :dash  => length,
-                  :space => length.kind_of?(Array) ? nil : options[:space] || length,
-                  :phase => options[:phase] || 0 }
+                                    :space => length.kind_of?(Array) ? nil : options[:space] || length,
+                                    :phase => options[:phase] || 0 }
 
         write_stroke_dash
       end
@@ -103,7 +103,6 @@ module Prawn
       def dash_setting
         graphic_state.dash_setting
       end
-
     end
   end
 end

data/lib/prawn/graphics/join_style.rb

@@ -20,7 +20,7 @@ module Prawn
       # NOTE: if this method is never called, :miter will be used for join style
       # throughout the document
       #
-      def join_style(style=nil)
+      def join_style(style = nil)
         return current_join_style || :miter if style.nil?
 
         self.current_join_style = style
@@ -40,7 +40,6 @@ module Prawn
         graphic_state.join_style = style
       end
 
-
       def write_stroke_join_style
         renderer.add_content "#{JOIN_STYLES[current_join_style]} j"
       end

data/lib/prawn/graphics/patterns.rb

@@ -47,13 +47,13 @@ module Prawn
         end
 
         operator = case type
-        when :fill
-          'scn'
-        when :stroke
-          'SCN'
-        else
-          raise ArgumentError, "unknown type '#{type}'"
-        end
+                   when :fill
+                     'scn'
+                   when :stroke
+                     'SCN'
+                   else
+                     fail ArgumentError, "unknown type '#{type}'"
+                   end
 
         set_color_space type, :Pattern
         renderer.add_content "/SP#{registry_key} #{operator}"
@@ -83,43 +83,47 @@ module Prawn
 
       def gradient(*args)
         if args.length != 4 && args.length != 6
-          raise ArgumentError, "Unknown type of gradient: #{args.inspect}"
+          fail ArgumentError, "Unknown type of gradient: #{args.inspect}"
         end
 
         color1 = normalize_color(args[-2]).dup.freeze
         color2 = normalize_color(args[-1]).dup.freeze
 
         if color_type(color1) != color_type(color2)
-          raise ArgumentError, "Both colors must be of the same color space: #{color1.inspect} and #{color2.inspect}"
+          fail ArgumentError, "Both colors must be of the same color space: #{color1.inspect} and #{color2.inspect}"
         end
 
         process_color color1
         process_color color2
 
-        shader = ref!({
+        shader = ref!(
           :FunctionType => 2,
           :Domain => [0.0, 1.0],
           :C0 => color1,
           :C1 => color2,
-          :N => 1.0,
-        })
+          :N => 1.0
+        )
+
+        if args.length == 4
+          coords = [0, 0, args[1].first - args[0].first, args[1].last - args[0].last]
+        else
+          coords = [0, 0, args[1], args[2].first - args[0].first, args[2].last - args[0].last, args[3]]
+        end
 
-        shading = ref!({
+        shading = ref!(
           :ShadingType => args.length == 4 ? 2 : 3, # axial : radial shading
           :ColorSpace => color_space(color1),
-          :Coords => args.length == 4 ?
-                        [0, 0, args[1].first - args[0].first, args[1].last - args[0].last] :
-                        [0, 0, args[1], args[2].first - args[0].first, args[2].last - args[0].last, args[3]],
+          :Coords => coords,
           :Function => shader,
-          :Extend => [true, true],
-        })
+          :Extend => [true, true]
+        )
 
-        ref!({
+        ref!(
           :PatternType => 2, # shading pattern
           :Shading => shading,
           :Matrix => [1, 0,
-                      0, 1] + map_to_absolute(args[0]),
-        })
+                      0, 1] + map_to_absolute(args[0])
+        )
       end
     end
   end