prawn 0.13.0 → 0.13.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ad2fdbe5f0c7d9075d0a6467217a996304aa4983
-  data.tar.gz: 6db5219bdb341f2c8d36c3cc0aca48720adbdccc
+  metadata.gz: 97df184b88392e64c3213125e2e3d49ed8921dfd
+  data.tar.gz: ae198cc6d4e658db982a4fcab6119c6c082937d1
 SHA512:
-  metadata.gz: c2795eaa023f044fdf99b91f79a4e56f181c8dcb13fd73112dcf181156234230117e17221521634c728e60c92a7f05a607f16cec47cd72eff9a77995e91f750f
-  data.tar.gz: cdf2c886e7bea9946289a11fa1f33c4574884ca65d2eebbaec6967016bc31aee008a9048fccecb73756a4950a6b4e686c838ddbf5e3c3c258bd1dd2ed6fea379
+  metadata.gz: fcf93119b67b6497601c38ebdfce11c7ff22739941a5c2adafe7f0f2636bfeefdb86f7fd6a35285e387bc77dc76896c87b1120e44ce3e357ce99754ac0380d52
+  data.tar.gz: afbfa0adfca9f371ada957a127e7737f6248a3be75f99fc401d1081199d22e9fdeac62e13ea752dd24418c76e29d6aaa3aad4e4bf503433dc585169f03b52e47

data/Gemfile

@@ -3,7 +3,6 @@ source "https://rubygems.org"
 gem "ttfunk", "~>1.0.3"
 gem "pdf-reader", "~> 1.2"
 gem "ruby-rc4"
-gem "afm"
 
 group :development do
   gem "coderay", "~> 1.0.7"

data/README.md

@@ -1,6 +1,7 @@
 # Prawn: Fast, Nimble PDF Generation For Ruby
 
 [![Build Status](https://secure.travis-ci.org/prawnpdf/prawn.png)](http://travis-ci.org/prawnpdf/prawn)
+[![Gem Version](https://badge.fury.io/rb/prawn.png)](http://badge.fury.io/rb/prawn)
 
 Prawn is a pure Ruby PDF generation library that provides a lot of great functionality while trying to remain simple and reasonably performant. Here are some of the important features we provide:
 

data/lib/pdf/core/object_store.rb

@@ -299,21 +299,9 @@ module PDF
         end
       end
 
-      ruby_18 do
-        def is_utf8?(str)
-          begin
-            str.unpack("U*")
-            true
-          rescue
-            false
-          end
-        end
-      end
-      ruby_19 do
-        def is_utf8?(str)
-          str.force_encoding("utf-8")
-          str.valid_encoding?
-        end
+      def is_utf8?(str)
+        str.force_encoding(::Encoding::UTF_8)
+        str.valid_encoding?
       end
     end
   end

data/lib/pdf/core/pdf_object.rb

@@ -12,40 +12,15 @@ module PDF
   module Core
     module_function
 
-    if "".respond_to?(:encode)
-      # Ruby 1.9+
-      def utf8_to_utf16(str)
-        "\xFE\xFF".force_encoding("UTF-16BE") + str.encode("UTF-16BE")
-      end
-
-      # encodes any string into a hex representation. The result is a string
-      # with only 0-9 and a-f characters. That result is valid ASCII so tag
-      # it as such to account for behaviour of different ruby VMs
-      def string_to_hex(str)
-        str.unpack("H*").first.force_encoding("ascii")
-      end
-    else
-      # Ruby 1.8
-      def utf8_to_utf16(str)
-        utf16 = "\xFE\xFF"
-
-        str.codepoints do |cp|
-          if cp < 0x10000 # Basic Multilingual Plane
-            utf16 << [cp].pack("n")
-          else
-            # pull out high/low 10 bits
-            hi, lo = (cp - 0x10000).divmod(2**10)
-            # encode a surrogate pair
-            utf16 << [0xD800 + hi, 0xDC00 + lo].pack("n*")
-          end
-        end
-
-        utf16
-      end
+    def utf8_to_utf16(str)
+      "\xFE\xFF".force_encoding(::Encoding::UTF_16BE) + str.encode(::Encoding::UTF_16BE)
+    end
 
-      def string_to_hex(str)
-        str.unpack("H*").first
-      end
+    # encodes any string into a hex representation. The result is a string
+    # with only 0-9 and a-f characters. That result is valid ASCII so tag
+    # it as such to account for behaviour of different ruby VMs
+    def string_to_hex(str)
+      str.unpack("H*").first.force_encoding(::Encoding::US_ASCII)
     end
 
     # Serializes Ruby objects to their PDF equivalents.  Most primitive objects

data/lib/prawn.rb

@@ -20,7 +20,7 @@ end
 require "set"
 
 module Prawn
-  VERSION = "0.13.0"
+  VERSION = "0.13.1"
 
   extend self
 
@@ -73,7 +73,6 @@ module Prawn
   end
 end
 
-require_relative "prawn/compatibility"
 require_relative "prawn/errors"
 
 require_relative "pdf/core"

data/lib/prawn/document.rb

@@ -370,7 +370,7 @@ module Prawn
       render_trailer(output)
       if output.instance_of?(StringIO)
         str = output.string
-        str.force_encoding("ASCII-8BIT") if str.respond_to?(:force_encoding)
+        str.force_encoding(::Encoding::ASCII_8BIT)
         return str
       else
         return nil
@@ -382,8 +382,7 @@ module Prawn
     #   pdf.render_file "foo.pdf"
     #
     def render_file(filename)
-      Kernel.const_defined?("Encoding") ? mode = "wb:ASCII-8BIT" : mode = "wb"
-      File.open(filename,mode) { |f| render(f) }
+      File.open(filename, "wb") { |f| render(f) }
     end
 
     # The bounds method returns the current bounding box you are currently in,

data/lib/prawn/encoding.rb

@@ -108,8 +108,7 @@ module Prawn
       private
 
       def load_mapping
-        RUBY_VERSION >= "1.9" ? mode = "r:BINARY" : mode = "r"
-        File.open(@mapping_file, mode) do |f|
+        File.open(@mapping_file, "r:BINARY") do |f|
           f.each do |l|
             _, single_byte, unicode = *l.match(/([0-9A-Za-z]+);([0-9A-F]{4})/)
             self.class.mapping["0x#{unicode}".hex] = "0x#{single_byte}".hex if single_byte

data/lib/prawn/font/afm.rb

@@ -7,7 +7,6 @@
 # This is free software. Please see the LICENSE and COPYING files for details.
 
 require 'prawn/encoding'
-require 'afm'
 
 module Prawn
   class Font
@@ -49,21 +48,23 @@ module Prawn
         file_name << ".afm" unless file_name =~ /\.afm$/
         file_name = file_name[0] == ?/ ? file_name : find_font(file_name)
 
-        font_data = @@font_data[file_name] ||= ::AFM::Font.new(file_name)
-        @glyph_table     = build_glyph_table(font_data)
-        @kern_pairs      = font_data.kern_pairs
-        @kern_pair_table = build_kern_pair_table(@kern_pairs)
-        @attributes      = font_data.metadata
+        font_data = @@font_data[file_name] ||= parse_afm(file_name)
+        @glyph_widths    = font_data[:glyph_widths]
+        @glyph_table     = font_data[:glyph_table]
+        @bounding_boxes  = font_data[:bounding_boxes]
+        @kern_pairs      = font_data[:kern_pairs]
+        @kern_pair_table = font_data[:kern_pair_table]
+        @attributes      = font_data[:attributes]
 
-        @ascender  = @attributes["Ascender"].to_i
-        @descender = @attributes["Descender"].to_i
+        @ascender  = @attributes["ascender"].to_i
+        @descender = @attributes["descender"].to_i
         @line_gap  = Float(bbox[3] - bbox[1]) - (@ascender - @descender)
       end
 
       # The font bbox, as an array of integers
       #
       def bbox
-        @bbox ||= @attributes['FontBBox'].split(/\s+/).map { |e| Integer(e) }
+        @bbox ||= @attributes['fontbbox'].split(/\s+/).map { |e| Integer(e) }
       end
 
       # NOTE: String *must* be encoded as WinAnsi
@@ -141,7 +142,7 @@ module Prawn
       end
 
       def symbolic?
-        attributes["CharacterSet"] == "Special"
+        attributes["characterset"] == "Special"
       end
 
       def find_font(file)
@@ -152,6 +153,61 @@ module Prawn
            self.class.metrics_path.join("\n")
       end
 
+      def parse_afm(file_name)
+        data    = {:glyph_widths => {}, :bounding_boxes => {}, :kern_pairs => {}, :attributes => {}}         
+        section = []
+
+        File.foreach(file_name) do |line|
+          case line
+          when /^Start(\w+)/
+            section.push $1
+            next
+          when /^End(\w+)/
+            section.pop
+            next
+          end
+
+          case section
+          when ["FontMetrics", "CharMetrics"]
+            next unless line =~ /^CH?\s/
+
+            name                        = line[/\bN\s+(\.?\w+)\s*;/, 1]
+            data[:glyph_widths][name]   = line[/\bWX\s+(\d+)\s*;/, 1].to_i
+            data[:bounding_boxes][name] = line[/\bB\s+([^;]+);/, 1].to_s.rstrip
+          when ["FontMetrics", "KernData", "KernPairs"]
+            next unless line =~ /^KPX\s+(\.?\w+)\s+(\.?\w+)\s+(-?\d+)/
+            data[:kern_pairs][[$1, $2]] = $3.to_i
+          when ["FontMetrics", "KernData", "TrackKern"],
+            ["FontMetrics", "Composites"]
+            next
+          else
+            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|
+          data[:glyph_widths][Encoding::WinAnsi::CHARACTERS[i]].to_i
+        end
+
+        character_hash = Hash[Encoding::WinAnsi::CHARACTERS.zip((0..Encoding::WinAnsi::CHARACTERS.size).to_a)]
+        data[:kern_pair_table] = data[:kern_pairs].inject({}) do |h,p|
+          h[p[0].map { |n| character_hash[n] }] = p[1]
+          h
+        end
+
+        data.each_value { |hash| hash.freeze }
+        data.freeze
+      end
+
+      def parse_generic_afm_attribute(line, hash)
+        line =~ /(^\w+)\s+(.*)/
+        key, value = $1.to_s.downcase, $2
+
+        hash[:attributes][key] = hash[:attributes][key] ? Array(hash[:attributes][key]) << value : value
+      end
+
       # converts a string into an array with spacing offsets
       # bewteen characters that need to be kerned
       #
@@ -172,27 +228,12 @@ module Prawn
 
         kerned.map { |e|
           e = (Array === e ? e.pack("C*") : e)
-          e.respond_to?(:force_encoding) ? e.force_encoding("Windows-1252") : e
+          e.respond_to?(:force_encoding) ? e.force_encoding(::Encoding::Windows_1252) : e
         }
       end
-
-      def build_kern_pair_table(kern_pairs)
-        character_hash = Hash[Encoding::WinAnsi::CHARACTERS.zip((0..Encoding::WinAnsi::CHARACTERS.size).to_a)]
-        kern_pairs.inject({}) do |h,p|
-          h[
-            [character_hash[p[0]], character_hash[p[1]]]
-          ] = p[2]
-          h
-        end
-      end
-
-      def build_glyph_table(font_data)
-        (0..255).map do |char|
-          metrics = font_data.metrics_for(char)
-          metrics ? metrics[:wx] : 0
-        end
-      end
-
+      
+      private
+      
       def unscaled_width_of(string)
         string.bytes.inject(0) do |s,r|
           s + @glyph_table[r]

data/lib/prawn/font/ttf.rb

@@ -160,7 +160,15 @@ module Prawn
       end
 
       def normalize_encoding(text)
-        text.normalize_to_utf8
+        begin
+          text.encode(::Encoding::UTF_8)
+        rescue => e
+          puts e
+          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
       end
 
       def glyph_present?(char)
@@ -171,7 +179,7 @@ module Prawn
       # Returns the number of characters in +str+ (a UTF-8-encoded string).
       #
       def character_count(str)
-        str.unicode_length
+        str.length
       end
 
       private

data/lib/prawn/images/jpg.rb

@@ -17,8 +17,7 @@ module Prawn
       attr_reader :width, :height, :bits, :channels
       attr_accessor :scaled_width, :scaled_height
 
-      JPEG_SOF_BLOCKS = %W(\xc0 \xc1 \xc2 \xc3 \xc5 \xc6 \xc7 \xc9 \xca \xcb \xcd \xce \xcf)
-      JPEG_APP_BLOCKS = %W(\xe0 \xe1 \xe2 \xe3 \xe4 \xe5 \xe6 \xe7 \xe8 \xe9 \xea \xeb \xec \xed \xee \xef)
+      JPEG_SOF_BLOCKS = [0xC0, 0xC1, 0xC2, 0xC3, 0xC5, 0xC6, 0xC7, 0xC9, 0xCA, 0xCB, 0xCD, 0xCE, 0xCF]
 
       def self.can_render?(image_blob)
         image_blob[0, 3].unpack("C*") == [255, 216, 255]
@@ -29,22 +28,22 @@ module Prawn
       # <tt>:data</tt>:: A binary string of JPEG data
       #
       def initialize(data)
-        @data = data.dup
-        ruby_19 { data.force_encoding("binary") }
-        data = StringIO.new(data)
+        @data = data
+        d = StringIO.new(@data)
+        d.binmode
 
-        c_marker = "\xff" # Section marker.
-        data.read(2)   # Skip the first two bytes of JPEG identifier.
+        c_marker = 0xff # Section marker.
+        d.seek(2)    # Skip the first two bytes of JPEG identifier.
         loop do
-          marker, code, length = data.read(4).unpack('aan')
+          marker, code, length = d.read(4).unpack('CCn')
           raise "JPEG marker not found!" if marker != c_marker
 
           if JPEG_SOF_BLOCKS.include?(code)
-            @bits, @height, @width, @channels = data.read(6).unpack("CnnC")
+            @bits, @height, @width, @channels = d.read(6).unpack("CnnC")
             break
           end
 
-          data.read(length - 2)
+          d.seek(length - 2, IO::SEEK_CUR)
         end
       end
 

data/lib/prawn/images/png.rb

@@ -107,34 +107,17 @@ module Prawn
         end
       end
 
-      # number of bits used per pixel
-      #
-      def pixel_bitlength
-        if alpha_channel?
-          self.bits * (self.colors + 1)
-        else
-          self.bits * self.colors
-        end
-      end
-
       # split the alpha channel data from the raw image data in images
       # where it's required.
       #
       def split_alpha_channel!
-        unfilter_image_data if alpha_channel?
+        split_image_data if alpha_channel?
       end
 
       def alpha_channel?
         @color_type == 4 || @color_type == 6
       end
 
-      # Adobe Reader can't handle 16-bit png channels -- chop off the second
-      # byte (least significant)
-      #
-      def alpha_channel_bits
-        8
-      end
-
       # Build a PDF object representing this image in +document+, and return
       # a Reference to it.
       #
@@ -180,18 +163,14 @@ module Prawn
         # append the actual image data to the object as a stream
         obj << img_data
 
-        if alpha_channel
-          obj.stream.compress!
-        else
-          obj.stream.filters << {
-            :FlateDecode => {
-              :Predictor => 15,
-              :Colors    => colors,
-              :BitsPerComponent => bits,
-              :Columns   => width
-            }
+        obj.stream.filters << {
+          :FlateDecode => {
+            :Predictor => 15,
+            :Colors    => colors,
+            :BitsPerComponent => bits,
+            :Columns   => width
           }
-        end
+        }
 
         # sort out the colours of the image
         if palette.empty?
@@ -243,12 +222,20 @@ module Prawn
             :Subtype          => :Image,
             :Height           => height,
             :Width            => width,
-            :BitsPerComponent => alpha_channel_bits,
+            :BitsPerComponent => bits,
             :ColorSpace       => :DeviceGray,
             :Decode           => [0, 1]
           )
           smask_obj.stream << alpha_channel
-          smask_obj.stream.compress!
+
+          smask_obj.stream.filters << {
+            :FlateDecode => {
+              :Predictor => 15,
+              :Colors    => 1,
+              :BitsPerComponent => bits,
+              :Columns   => width
+            }
+          }
           obj.data[:SMask] = smask_obj
         end
 
@@ -270,99 +257,40 @@ module Prawn
 
       private
 
-      def unfilter_image_data
-        data = @img_data.dup
+      def split_image_data
+        alpha_bytes = bits / 8
+        color_bytes = colors * bits / 8
 
-        @img_data = ""
-        @alpha_channel = ""
-
-        pixel_bytes     = pixel_bitlength / 8
-        scanline_length = pixel_bytes * self.width + 1
-        row = 0
-        pixels = []
-        row_data = [] # reused for each row of the image
-        paeth, pa, pb, pc = nil
-
-        data.bytes.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
-          when 1 # Sub
-            row_data.each_with_index do |row_byte, index|
-              left = index < pixel_bytes ? 0 : row_data[index - pixel_bytes]
-              row_data[index] = (row_byte + left) % 256
-            end
-          when 2 # Up
-            row_data.each_with_index do |row_byte, index|
-              col = (index / pixel_bytes).floor
-              upper = row == 0 ? 0 : pixels[row-1][col][index % pixel_bytes]
-              row_data[index] = (upper + row_byte) % 256
-            end
-          when 3  # Average
-            row_data.each_with_index do |row_byte, index|
-              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]
+        scanline_length  = (color_bytes + alpha_bytes) * self.width + 1
+        scanlines = @img_data.bytesize / scanline_length
+        pixels = self.width * self.height
 
-              row_data[index] = (row_byte + ((left + upper)/2).floor) % 256
-            end
-          when 4 # Paeth
-            left = upper = upper_left = nil
-            row_data.each_with_index do |row_byte, index|
-              col = (index / pixel_bytes).floor
-
-              left = index < pixel_bytes ? 0 : row_data[index - pixel_bytes]
-              if row.zero?
-                upper = upper_left = 0
-              else
-                upper = pixels[row-1][col][index % pixel_bytes]
-                upper_left = col.zero? ? 0 :
-                  pixels[row-1][col-1][index % pixel_bytes]
-              end
-
-              p = left + upper - upper_left
-              pa = (p - left).abs
-              pb = (p - upper).abs
-              pc = (p - upper_left).abs
-
-              paeth = if pa <= pb && pa <= pc
-                left
-              elsif pb <= pc
-                upper
-              else
-                upper_left
-              end
-
-              row_data[index] = (row_byte + paeth) % 256
-            end
-          else
-            raise ArgumentError, "Invalid filter algorithm #{filter}"
-          end
+        data = StringIO.new(@img_data)
+        data.binmode
 
-          s = []
-          row_data.each_slice pixel_bytes do |slice|
-            s << slice
-          end
-          pixels << s
-          row += 1
-          row_data.clear
-        end
+        color_data = [0x00].pack('C') * (pixels * color_bytes + scanlines)
+        color = StringIO.new(color_data)
+        color.binmode
+
+        @alpha_channel = [0x00].pack('C') * (pixels * alpha_bytes + scanlines)
+        alpha = StringIO.new(@alpha_channel)
+        alpha.binmode
 
-        # 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|
-          this_row.each do |pixel|
-            @img_data << pixel[0, color_byte_size].pack("C*")
-            @alpha_channel << pixel[color_byte_size, alpha_byte_size].pack("C*")
+        scanlines.times do |line|
+          data.seek(line * scanline_length)
+
+          filter = data.getbyte
+
+          color.putc filter
+          alpha.putc filter
+
+          self.width.times do
+            color.write data.read(color_bytes)
+            alpha.write data.read(alpha_bytes)
           end
         end
+
+        @img_data = color_data
       end
     end
   end