prawn 1.0.0.rc1 → 1.0.0.rc2

data/lib/prawn/font/ttf.rb

@@ -47,7 +47,7 @@ module Prawn
             end
           end * scale
         else
-          string.unpack("U*").inject(0) do |s,r|
+          string.codepoints.inject(0) do |s,r|
             s + character_width_by_code(r)
           end * scale
         end
@@ -160,44 +160,18 @@ module Prawn
       end
 
       def normalize_encoding(text)
-        if text.respond_to?(:encode)
-          # if we're running under a M17n aware VM, ensure the string provided is
-          # UTF-8 (by converting it if necessary)
-          begin
-            text.encode("UTF-8")
-          rescue
-            raise Prawn::Errors::IncompatibleStringEncoding, "Encoding " +
-            "#{text.encoding} can not be transparently converted to UTF-8. " +
-            "Please ensure the encoding of the string you are attempting " +
-            "to use is set correctly"
-          end
-        else
-          # on a non M17N aware VM, use unpack as a hackish way to verify the
-          # string is valid utf-8. I thought it was better than loading iconv
-          # though.
-          begin
-            text.unpack("U*")
-            return text.dup
-          rescue
-            raise Prawn::Errors::IncompatibleStringEncoding, "The string you " +
-              "are attempting to render is not encoded in valid UTF-8."
-          end
-        end
+        text.normalize_to_utf8
       end
 
       def glyph_present?(char)
-        code = char.unpack("U*").first
+        code = char.codepoints.first
         cmap[code] > 0
       end
 
       # Returns the number of characters in +str+ (a UTF-8-encoded string).
       #
       def character_count(str)
-        if str.respond_to?(:encode)
-          str.length
-        else
-          str.unpack("U*").length
-        end
+        str.unicode_length
       end
 
       private
@@ -214,7 +188,7 @@ module Prawn
       def kern(string)
         a = []
 
-        string.unpack("U*").each do |r|
+        string.codepoints do |r|
           if a.empty?
             a << [r]
           elsif (kern = kern_pairs_table[[cmap[a.last.last], cmap[r]]])
@@ -282,8 +256,7 @@ module Prawn
 
         compressed_font = Zlib::Deflate.deflate(font_content)
 
-        fontfile = @document.ref!(:Length => compressed_font.size,
-                                 :Length1 => font_content.size,
+        fontfile = @document.ref!(:Length1 => font_content.size,
                                  :Filter => :FlateDecode )
         fontfile << compressed_font
 

data/lib/prawn/graphics.rb

@@ -12,7 +12,7 @@ require "prawn/graphics/cap_style"
 require "prawn/graphics/join_style"
 require "prawn/graphics/transparency"
 require "prawn/graphics/transformation"
-require "prawn/graphics/gradient"
+require "prawn/graphics/patterns"
 
 module Prawn
 
@@ -30,7 +30,7 @@ module Prawn
     include JoinStyle
     include Transparency
     include Transformation
-    include Gradient
+    include Patterns
 
     #######################################################################
     # Low level drawing operations must map the point to absolute coords! #
@@ -222,19 +222,19 @@ module Prawn
 
       # Upper right hand corner
       curve_to [x,  y + r2],
-        :bounds => [[x + r1, y + l1], [x + l2, y + r2]]
+        :bounds => [[x + r1, y + l2], [x + l1, y + r2]]
 
       # Upper left hand corner
       curve_to [x - r1, y],
-        :bounds => [[x - l2, y + r2], [x - r1, y + l1]]
+        :bounds => [[x - l1, y + r2], [x - r1, y + l2]]
 
       # Lower left hand corner
       curve_to [x, y - r2],
-        :bounds => [[x - r1, y - l1], [x - l2, y - r2]]
+        :bounds => [[x - r1, y - l2], [x - l1, y - r2]]
 
       # Lower right hand corner
       curve_to [x + r1, y],
-        :bounds => [[x + l2, y - r2], [x + r1, y - l1]]
+        :bounds => [[x + l1, y - r2], [x + r1, y - l2]]
 
       move_to(x, y)
     end
@@ -337,23 +337,148 @@ module Prawn
       add_content "h"
     end
 
-    # Provides the following shortcuts:
-    #
-    #    stroke_some_method(*args) #=> some_method(*args); stroke
-    #    fill_some_method(*args) #=> some_method(*args); fill
-    #    fill_and_stroke_some_method(*args) #=> some_method(*args); fill_and_stroke
-    #
-    def method_missing(id,*args,&block)
-      case(id.to_s)
-      when /^fill_and_stroke_(.*)/
-        send($1,*args,&block); fill_and_stroke
-      when /^stroke_(.*)/
-        send($1,*args,&block); stroke
-      when /^fill_(.*)/
-        send($1,*args,&block); fill
-      else
-        super
-      end
+    ##
+    # :method: stroke_rectangle
+    # Draws and strokes a rectangle given +point+, +width+ and +height+. The rectangle is bounded by its upper-left corner.
+    # :call-seq:
+    #   stroke_rectangle(point,width,height)
+
+    ##
+    # :method: fill_rectangle
+    # Draws and fills ills a rectangle given +point+, +width+ and +height+. The rectangle is bounded by its upper-left corner.
+    # :call-seq:
+    #   fill_rectangle(point,width,height)
+
+    ##
+    # :method: fill_and_stroke_rectangle
+    # Draws, fills, and strokes a rectangle given +point+, +width+ and +height+. The rectangle is bounded by its upper-left corner.
+    # :call-seq:
+    #   fill_and_stroke_rectangle(point,width,height)
+
+    ##
+    # :method: stroke_rounded_rectangle
+    # Draws and strokes a rounded rectangle given +point+, +width+ and +height+ and +radius+ for the rounded corner. The rectangle is bounded by its upper-left corner.
+    # :call-seq:
+    #   stroke_rounded_rectangle(point,width,height,radius)
+
+    ##
+    # :method: fill_rounded_rectangle
+    # Draws and fills a rounded rectangle given +point+, +width+ and +height+ and +radius+ for the rounded corner. The rectangle is bounded by its upper-left corner.
+    # :call-seq:
+    #   fill_rounded_rectangle(point,width,height,radius)
+
+    ##
+    # :method: stroke_and_fill_rounded_rectangle
+    # Draws, fills, and strokes a rounded rectangle given +point+, +width+ and +height+ and +radius+ for the rounded corner. The rectangle is bounded by its upper-left corner.
+    # :call-seq:
+    #   stroke_and_fill_rounded_rectangle(point,width,height,radius)
+
+    ##
+    # :method: stroke_line
+    # Strokes a line from one point to another. Points may be specified as tuples or flattened argument list.
+    # :call-seq:
+    #   stroke_line(*points)
+
+    ##
+    # :method: stroke_horizontal_line
+    # Strokes a horizontal line from +x1+ to +x2+ at the current y position, or the position specified by the :at option.
+    # :call-seq:
+    #   stroke_horizontal_line(x1,x2,options={})
+
+    ##
+    # :method: stroke_horizontal_rule
+    # Strokes a horizontal line from the left border to the right border of the bounding box at the current y position.
+
+    ##
+    # :method: stroke_vertical_line
+    # Strokes a vertical line at the x coordinate given by :at from y1 to y2.
+    # :call-seq:
+    #   stroke_vertical_line(y1,y2,params)
+
+    ##
+    # :method: stroke_curve
+    # Strokes a Bezier curve between two points, bounded by two additional points. 
+    # :call-seq:
+    #   stroke_curve(origin,dest,options={})
+
+    ##
+    # :method: stroke_circle
+    # Draws and strokes a circle of radius +radius+ with the centre-point at +point+.
+    # :call-seq:
+    #   stroke_circle(center,radius)
+
+    ##
+    # :method: fill_circle
+    # Draws and fills a circle of radius +radius+ with the centre-point at +point+.
+    # :call-seq:
+    #   fill_circle(center,radius)
+
+    ##
+    # :method: fill_and_stroke_circle
+    # Draws, strokes, and fills a circle of radius +radius+ with the centre-point at +point+.
+    # :call-seq:
+    #   fill_and_stroke_circle(center,radius)
+
+    ##
+    # :method: stroke_ellipse
+    # Draws and strokes an ellipse of x radius +r1+ and y radius +r2+ with the centre-point at +point+.
+    # :call-seq:
+    #   stroke_ellipse(point, r1, r2 = r1)
+
+    ##
+    # :method: fill_ellipse
+    # Draws and fills an ellipse of x radius +r1+ and y radius +r2+ with the centre-point at +point+.
+    # :call-seq:
+    #   fill_ellipse(point, r1, r2 = r1)
+
+    ##
+    # :method: fill_and_stroke_ellipse
+    # Draws, strokes, and fills an ellipse of x radius +r1+ and y radius +r2+ with the centre-point at +point+.
+    # :call-seq:
+    #   fill_and_stroke_ellipse(point, r1, r2 = r1)
+
+    ##
+    # :method: stroke_polygon
+    # Draws and strokes a polygon from the specified points.
+    # :call-seq:
+    #   stroke_polygon(*points)
+
+    ##
+    # :method: fill_polygon
+    # Draws and fills a polygon from the specified points.
+    # :call-seq:
+    #   fill_polygon(*points)
+
+    ##
+    # :method: fill_and_stroke_polygon
+    # Draws, strokes, and fills a polygon from the specified points.
+    # :call-seq:
+    #   fill_and_stroke_polygon(*points)
+
+    ##
+    # :method: stroke_rounded_polygon
+    # Draws and strokes a rounded polygon from specified points, using +radius+ to define Bezier curves.
+    # :call-seq:
+    #   stroke_rounded_polygon(radius, *points)
+
+    ##
+    # :method: fill_rounded_polygon
+    # Draws and fills a rounded polygon from specified points, using +radius+ to define Bezier curves.
+    # :call-seq:
+    #   fill_rounded_polygon(radius, *points)
+
+    ##
+    # :method: fill_and_stroke_rounded_polygon
+    # Draws, strokes, and fills a rounded polygon from specified points, using +radius+ to define Bezier curves.
+    # :call-seq:
+    #   fill_and_stroke_rounded_polygon(radius, *points)
+    
+    ops    = %w{fill stroke fill_and_stroke}
+    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|
+      class_eval "def #{operation}_#{shape}(*args); #{shape}(*args); #{operation}; end"
     end
 
     private

data/lib/prawn/graphics/color.rb

@@ -95,7 +95,14 @@ module Prawn
         when String
           :RGB
         when Array
-          :CMYK
+          case color.length
+          when 3
+            :RGB
+          when 4
+            :CMYK
+          else
+            raise ArgumentError, "Unknown type of color: #{color.inspect}"
+          end
         end
       end
 

data/lib/prawn/graphics/patterns.rb

@@ -0,0 +1,137 @@
+# encoding: utf-8
+
+# patterns.rb : Implements axial & radial gradients
+#
+# Originally implemented by Wojciech Piekutowski. November, 2009
+# Copyright September 2012, Alexander Mankuta. All Rights Reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+#
+module Prawn
+  module Graphics
+    module Patterns
+
+      # Sets the fill gradient from color1 to color2.
+      # old arguments: point, width, height, color1, color2, options = {}
+      # new arguments: from, to, color1, color1
+      #            or  from, r1, to, r2, color1, color2
+      def fill_gradient(*args)
+        if args[1].is_a?(Array) || args[2].is_a?(Array)
+          set_gradient(:fill, *args)
+        else
+          warn "[DEPRECATION] 'fill_gradient(point, width, height,...)' is deprecated in favor of 'fill_gradient(from, to,...)'. " +
+               "Old arguments will be removed in release 1.1"
+          set_gradient :fill, args[0], [args[0].first, args[0].last - args[2]], args[3], args[4]
+        end
+      end
+
+      # Sets the stroke gradient from color1 to color2.
+      # old arguments: point, width, height, color1, color2, options = {}
+      # new arguments: from, to, color1, color2
+      #            or  from, r1, to, r2, color1, color2
+      def stroke_gradient(*args)
+        if args[1].is_a?(Array) || args[2].is_a?(Array)
+          set_gradient(:stroke, *args)
+        else
+          warn "[DEPRECATION] 'stroke_gradient(point, width, height,...)' is deprecated in favor of 'stroke_gradient(from, to,...)'. " +
+               "Old arguments will be removed in release 1.1"
+          set_gradient :stroke, args[0], [args[0].first, args[0].last - args[2]], args[3], args[4]
+        end
+      end
+
+      private
+
+      def set_gradient(type, *grad)
+        patterns = page.resources[:Pattern] ||= {}
+
+        registry_key = gradient_registry_key grad
+
+        if patterns["SP#{registry_key}"]
+          shading = patterns["SP#{registry_key}"]
+        else
+          unless shading = gradient_registry[registry_key]
+            shading = gradient(*grad)
+            gradient_registry[registry_key] = shading
+          end
+
+          patterns["SP#{registry_key}"] = shading
+        end
+
+        operator = case type
+        when :fill
+          'scn'
+        when :stroke
+          'SCN'
+        else
+          raise ArgumentError, "unknown type '#{type}'"
+        end
+
+        set_color_space type, :Pattern
+        add_content "/SP#{registry_key} #{operator}"
+      end
+
+      def gradient_registry_key(gradient)
+        if gradient[1].is_a?(Array) # axial
+          [
+            map_to_absolute(gradient[0]),
+            map_to_absolute(gradient[1]),
+            gradient[2], gradient[3]
+          ]
+        else # radial
+          [
+            map_to_absolute(gradient[0]),
+            gradient[1],
+            map_to_absolute(gradient[2]),
+            gradient[3],
+            gradient[4], gradient[5]
+          ]
+        end.hash
+      end
+
+      def gradient_registry
+        @gradient_registry ||= {}
+      end
+
+      def gradient(*args)
+        if args.length != 4 && args.length != 6
+          raise 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}"
+        end
+
+        process_color color1
+        process_color color2
+
+        shader = ref!({
+          :FunctionType => 2,
+          :Domain => [0.0, 1.0],
+          :C0 => color1,
+          :C1 => color2,
+          :N => 1.0,
+        })
+
+        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]],
+          :Function => shader,
+          :Extend => [true, true],
+        })
+
+        shading_pattern = ref!({
+          :PatternType => 2, # shading pattern
+          :Shading => shading,
+          :Matrix => [1, 0,
+                      0, 1] + map_to_absolute(args[0]),
+        })
+      end
+    end
+  end
+end

data/lib/prawn/images.rb

@@ -14,8 +14,9 @@ module Prawn
     # Add the image at filename to the current page. Currently only
     # JPG and PNG files are supported.
     #
-    # NOTE: Prawn is very slow at rendering PNGs with alpha channels.  The
-    # workaround for those who don't mind installing RMagick is to use:
+    # NOTE: Prawn is very slow at rendering PNGs with alpha channels, and this
+    # uses a lot of RAM. The workaround for those who don't mind installing
+    # RMagick is to use:
     #
     # http://github.com/amberbit/prawn-fast-png
     #
@@ -32,10 +33,10 @@ module Prawn
     # <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::BASEDIR}/data/images/pigs.jpg" 
+    #     pigs = "#{Prawn::DATADIR}/images/pigs.jpg" 
     #     image pigs, :at => [50,450], :width => 450                                      
     #
-    #     dice = "#{Prawn::BASEDIR}/data/images/dice.png"
+    #     dice = "#{Prawn::DATADIR}/images/dice.png"
     #     image dice, :at => [50, 450], :scale => 0.75 
     #   end   
     #
@@ -76,6 +77,12 @@ module Prawn
     # the given image. Return a pair: [pdf_obj, info].
     #
     def build_image_object(file)
+      # Rewind if the object we're passed is an IO, so that multiple embeds of
+      # the same IO object will work
+      file.rewind  if file.respond_to?(:rewind)
+      # read the file as binary so the size is calculated correctly
+      file.binmode if file.respond_to?(:binmode)
+
       if file.respond_to?(:read)
         image_content = file.read
       else
@@ -139,17 +146,6 @@ module Prawn
     def image_position(w,h,options)
       options[:position] ||= :left
       
-      x = case options[:position] 
-      when :left
-        bounds.absolute_left
-      when :center
-        bounds.absolute_left + (bounds.width - w) / 2.0 
-      when :right
-        bounds.absolute_right - w
-      when Numeric
-        options[:position] + bounds.absolute_left
-      end
-
       y = case options[:vposition]
       when :top
         bounds.absolute_top
@@ -162,16 +158,26 @@ module Prawn
       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]
     end 
     
     def determine_y_with_page_flow(h)
       if overruns_page?(h)
-        start_new_page
-        bounds.absolute_top 
-      else
-        self.y
+        bounds.move_past_bottom
       end
+      self.y
     end 
     
     def overruns_page?(h)