prawn 0.1.2 → 0.2.0

data/lib/prawn/images.rb

@@ -19,7 +19,7 @@ module Prawn
     #
     # Options:
     # <tt>:at</tt>:: the location of the top left corner of the image.
-    # <tt>:position/tt>::  
+    # <tt>:position</tt>::  One of (:left, :center, :right) or an x-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      
@@ -36,12 +36,11 @@ module Prawn
     # proportionally.  When both are provided, the image will be stretched to 
     # fit the dimensions without maintaining the aspect ratio.
     #
-    def image(filename, options={})
+    def image(filename, options={})     
+      Prawn.verify_options [:at,:position, :height, :width, :scale], options
       raise ArgumentError, "#{filename} not found" unless File.file?(filename)  
       
-      
-      read_mode = ruby_18 { "rb" } || ruby_19 { "rb:ASCII-8BIT" }
-      image_content =  File.open(filename, read_mode) { |f| f.read }
+      image_content =  File.read_binary(filename)
       
       image_sha1 = Digest::SHA1.hexdigest(image_content)
 
@@ -90,17 +89,15 @@ module Prawn
     
     def image_position(w,h,options)
       options[:position] ||= :left
-      case options[:position] 
+      x = case options[:position] 
       when :left
-        x,y = bounds.absolute_left, self.y
+        bounds.absolute_left
       when :center
-        x = bounds.absolute_left + (bounds.width - w) / 2.0 
-        y = self.y
+        bounds.absolute_left + (bounds.width - w) / 2.0 
       when :right
-        x,y = bounds.absolute_right - w, self.y  
+        bounds.absolute_right - w
       when Numeric
-        x = options[:position] + bounds.absolute_left
-        y = self.y
+        options[:position] + bounds.absolute_left
       end       
       
       return [x,y]
@@ -185,13 +182,37 @@ module Prawn
                                  :DeviceRGB,
                                  (png.palette.size / 3) -1,
                                  palette_obj]
+      end
+
+      # *************************************
+      # add transparency data if necessary
+      # *************************************
 
-        # add transparency data if necessary
-        #if png.transparency && png.transparency[:type] == 'indexed'
-        #  obj.data[:Mask] = png.transparency[:data]
-        #end
+      # For PNG color types 0, 2 and 3, the transparency data is stored in
+      # a dedicated PNG chunk, and is exposed via the transparency attribute
+      # of the PNG class.
+      if png.transparency[:grayscale]
+        # Use Color Key Masking (spec section 4.8.5)
+        # - An array with N elements, where N is two times the number of color
+        #   components.
+        val = png.transparency[:grayscale]
+        obj.data[:Mask] = [val, val]
+      elsif png.transparency[:rgb]
+        # Use Color Key Masking (spec section 4.8.5)
+        # - An array with N elements, where N is two times the number of color
+        #   components.
+        rgb = png.transparency[:rgb]
+        obj.data[:Mask] = rgb.collect { |val| [val,val] }.flatten
+      elsif png.transparency[:indexed]
+        # TODO: broken. I was attempting to us Color Key Masking, but I think
+        #       we need to construct an SMask i think. Maybe do it inside
+        #       the PNG class, and store it in alpha_channel
+        #obj.data[:Mask] = png.transparency[:indexed]
       end
 
+      # For PNG color types 4 and 6, the transparency data is stored as a alpha
+      # channel mixed in with the main image data. The PNG class seperates
+      # it out for us and makes it available via the alpha_channel attribute
       if png.alpha_channel
         smask_obj = ref(:Type             => :XObject,
                         :Subtype          => :Image,

data/lib/prawn/images/png.rb

@@ -30,6 +30,7 @@ module Prawn
 
         @palette  = ""
         @img_data = ""
+        @transparency = {}
 
         loop do
           chunk_size  = data.read(4).unpack("N")[0]
@@ -61,16 +62,17 @@ module Prawn
               # the palette index in the PLTE ("palette") chunk up until the
               # last non-opaque entry. Set up an array, stretching over all
               # palette entries which will be 0 (opaque) or 1 (transparent).
-              @transparency[:type]  = 'indexed'
-              @transparency[:data]  = data.read(chunk_size).unpack("C*")
+              @transparency[:indexed]  = data.read(chunk_size).unpack("C*")
+              short = 255 - @transparency[:indexed].size
+              @transparency[:indexed] += ([255] * short) if short > 0
             when 0
               # Greyscale. Corresponding to entries in the PLTE chunk.
               # Grey is two bytes, range 0 .. (2 ^ bit-depth) - 1
-              @transparency[:grayscale] = data.read(2).unpack("n")
-              @transparency[:type]      = 'indexed'
+              grayval = data.read(chunk_size).unpack("n").first
+              @transparency[:grayscale] = grayval
             when 2
               # True colour with proper alpha channel.
-              @transparency[:rgb] = data.read(6).unpack("nnn")
+              @transparency[:rgb] = data.read(chunk_size).unpack("nnn")
             end
           when 'IEND'
             # we've got everything we need, exit the loop
@@ -88,8 +90,8 @@ module Prawn
       end
 
       def pixel_bytes
-        case @color_type
-        when 0, 4    then 1
+        @pixel_bytes ||= case @color_type
+        when 0, 3, 4 then 1
         when 1, 2, 6 then 3
         end
       end
@@ -100,17 +102,6 @@ module Prawn
         @color_type == 4 || @color_type == 6
       end
 
-      def paeth(a, b, c) # left, above, upper left
-        p = a + b - c
-        pa = (p - a).abs
-        pb = (p - b).abs
-        pc = (p - c).abs
-
-        return a if pa <= pb && pa <= pc
-        return b if pb <= pc
-        c
-      end
-
       def unfilter_image_data
         data = Zlib::Inflate.inflate(@img_data).unpack 'C*'
         @img_data = ""
@@ -120,7 +111,8 @@ module Prawn
         pixel_length = pixel_bytes + 1
         scanline_length = pixel_length * @width + 1 # for filter
         row = 0
-        pixels = []
+        pixels = []    
+        paeth, pa, pb, pc = nil
         until data.empty? do
           row_data = data.slice! 0, scanline_length
           filter = row_data.shift
@@ -152,15 +144,27 @@ module Prawn
               col = index / pixel_length
 
               left = index < pixel_length ? 0 : row_data[index - pixel_length]
-              if row == 0 then
+              if row.zero?
                 upper = upper_left = 0
               else
                 upper = pixels[row-1][col][index % pixel_length]
-                upper_left = col == 0 ? 0 :
+                upper_left = col.zero? ? 0 :
                   pixels[row-1][col-1][index % pixel_length]
               end
 
-              paeth = paeth left, upper, upper_left
+              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] = (byte + paeth) % 256
               #p [byte, paeth, row_data[index]]
             end
@@ -168,10 +172,11 @@ module Prawn
             raise ArgumentError, "Invalid filter algorithm #{filter}"
           end
 
-          pixels << []
+          s = []
           row_data.each_slice pixel_length do |slice|
-            pixels.last << slice
+            s << slice
           end
+          pixels << s
           row += 1
         end
 

data/lib/prawn/pdf_object.rb

@@ -6,6 +6,8 @@
 #
 # This is free software. Please see the LICENSE and COPYING files for details.
 
+# Top level Module
+#
 module Prawn 
                                              
   module_function
@@ -24,7 +26,7 @@ module Prawn
   #     PdfObject(:Symbol)   #=> "/Symbol"
   #     PdfObject(["foo",:bar, [1,2]]) #=> "[foo /bar [1 2]]"
   # 
-  def PdfObject(obj, in_content_stream = false) #:nodoc:
+  def PdfObject(obj, in_content_stream = false)
     case(obj)        
     when NilClass   then "null" 
     when TrueClass  then "true"

data/spec/bounding_box_spec.rb

@@ -84,10 +84,11 @@ describe "A bounding box" do
 
 end
 
-describe "drawing bounding boxes" do
+describe "drawing bounding boxes" do    
+  
+  before(:each) { create_pdf }   
 
   it "should restore the margin box when bounding box exits" do
-    @pdf = Prawn::Document.new
     margin_box = @pdf.bounds
 
     @pdf.bounding_box [100,500] do
@@ -99,7 +100,6 @@ describe "drawing bounding boxes" do
   end
 
   it "should restore the parent bounding box when calls are nested" do
-    @pdf = Prawn::Document.new
     @pdf.bounding_box [100,500], :width => 300, :height => 300 do 
 
       @pdf.bounds.absolute_top.should  == 500 + @pdf.margin_box.absolute_bottom
@@ -116,5 +116,14 @@ describe "drawing bounding boxes" do
       @pdf.bounds.absolute_left.should == 100 + @pdf.margin_box.absolute_left
 
     end
+  end   
+  
+  it "should calculate a height if none is specified" do 
+    @pdf.bounding_box([100, 500], :width => 100) do
+      @pdf.text "The rain in Spain falls mainly on the plains." 
+    end     
+    
+    @pdf.y.should.be.close 458.384, 0.001 
   end
+  
 end

data/spec/document_spec.rb

@@ -3,74 +3,61 @@
 require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")  
                                
 describe "When creating multi-page documents" do 
-  
-  class PageCounter
-    attr_accessor :pages
-
-    def initialize
-      @pages = 0
-    end
-
-    # Called when page parsing ends
-    def end_page
-      @pages += 1
-    end
-  end
-  
-  
+ 
   before(:each) { create_pdf }
   
   it "should initialize with a single page" do 
-    page_counter = count_pages
+    page_counter = PDF::Inspector::Page.analyze(@pdf.render)
     
-    page_counter.pages.should == 1            
+    page_counter.pages.size.should == 1            
     @pdf.page_count.should == 1  
   end
   
   it "should provide an accurate page_count" do
     3.times { @pdf.start_new_page }           
-    page_counter = count_pages
+    page_counter = PDF::Inspector::Page.analyze(@pdf.render)
     
-    page_counter.pages.should == 4
+    page_counter.pages.size.should == 4
     @pdf.page_count.should == 4
-  end        
-  
-  def count_pages        
-    output = @pdf.render
-    obs = PageCounter.new
-    PDF::Reader.string(output,obs) 
-    return obs
-  end              
+  end                 
   
 end   
 
 describe "When beginning each new page" do
 
-  it "should execute the lambda specified by on_page_start" do
-    on_start = mock("page_start_proc")
-
-    on_start.expects(:[]).times(3)
+  it "should execute codeblock given to Document#header" do
+    call_count = 0    
    
-    pdf = Prawn::Document.new(:on_page_start => on_start)
+    pdf = Prawn::Document.new      
+    pdf.header(pdf.margin_box.top_left) do 
+      call_count += 1   
+    end
+    
     pdf.start_new_page 
-    pdf.start_new_page
-  end
+    pdf.start_new_page 
+    pdf.render
+    
+    call_count.should == 3
+  end                   
 
 end
 
-
 describe "When ending each page" do
 
-  it "should execute the lambda specified by on_page_end" do
-
-    on_end = mock("page_end_proc")
-
-    on_end.expects(:[]).times(3)
-
-    pdf = Prawn::Document.new(:on_page_stop => on_end)
-    pdf.start_new_page
-    pdf.start_new_page
+  it "should execute codeblock given to Document#footer" do
+   
+    call_count = 0    
+   
+    pdf = Prawn::Document.new      
+    pdf.footer([pdf.margin_box.left, pdf.margin_box.bottom + 50]) do 
+      call_count += 1   
+    end
+    
+    pdf.start_new_page 
+    pdf.start_new_page 
     pdf.render
+    
+    call_count.should == 3
   end
 
   it "should not compress the page content stream if compression is disabled" do
@@ -99,44 +86,25 @@ describe "When ending each page" do
 
 end                                 
 
-class PageDetails      
-  
-  def begin_page(params)
-    @geometry = params[:MediaBox]
-  end                       
-  
-  def size
-    @geometry[-2..-1] 
-  end
-  
-end
-
-def detect_page_details
-  output = @pdf.render
-  obs = PageDetails.new
-  PDF::Reader.string(output,obs) 
-  return obs      
-end
-
 describe "When setting page size" do
   it "should default to LETTER" do
     @pdf = Prawn::Document.new
-    page = detect_page_details
-    page.size.should == Prawn::Document::PageGeometry::SIZES["LETTER"]    
+    pages = PDF::Inspector::Page.analyze(@pdf.render).pages
+    pages.first[:size].should == Prawn::Document::PageGeometry::SIZES["LETTER"]    
   end                                                                  
   
   (Prawn::Document::PageGeometry::SIZES.keys - ["LETTER"]).each do |k|
     it "should provide #{k} geometry" do
       @pdf = Prawn::Document.new(:page_size => k)
-      page = detect_page_details
-      page.size.should == Prawn::Document::PageGeometry::SIZES[k]
+      pages = PDF::Inspector::Page.analyze(@pdf.render).pages   
+      pages.first[:size].should == Prawn::Document::PageGeometry::SIZES[k]
     end
   end
   
   it "should allow custom page size" do 
-      @pdf = Prawn::Document.new(:page_size => [1920, 1080] )
-      page = detect_page_details
-      page.size.should == [1920, 1080]
+    @pdf = Prawn::Document.new(:page_size => [1920, 1080] )
+    pages = PDF::Inspector::Page.analyze(@pdf.render).pages   
+    pages.first[:size].should == [1920, 1080]   
   end
 
 end       
@@ -144,8 +112,8 @@ end
 describe "When setting page layout" do
   it "should reverse coordinates for landscape" do
     @pdf = Prawn::Document.new(:page_size => "A4", :page_layout => :landscape)
-    page = detect_page_details
-    page.size.should == Prawn::Document::PageGeometry::SIZES["A4"].reverse
+    pages = PDF::Inspector::Page.analyze(@pdf.render).pages    
+    pages.first[:size].should == Prawn::Document::PageGeometry::SIZES["A4"].reverse
   end   
 end
 

data/spec/font_spec.rb

@@ -0,0 +1,97 @@
+# encoding: utf-8
+
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")           
+
+describe "Font Metrics" do  
+
+  it "should default to Helvetica if no font is specified" do
+    @pdf = Prawn::Document.new
+    @pdf.font.metrics.should == Prawn::Font::Metrics["Helvetica"]
+  end
+
+  it "should use the currently set font for font_metrics" do
+    @pdf = Prawn::Document.new
+    @pdf.font "Courier"
+    @pdf.font.metrics.should == Prawn::Font::Metrics["Courier"]
+   
+    comicsans = "#{Prawn::BASEDIR}/data/fonts/comicsans.ttf"
+    @pdf.font(comicsans)
+    @pdf.font.metrics.should == Prawn::Font::Metrics[comicsans]
+  end         
+  
+end    
+
+describe "font style support" do
+  before(:each) { create_pdf }
+  
+  it "should allow specifying font style by style name and font family" do    
+    @pdf.font "Courier", :style => :bold
+    @pdf.text "In Courier bold"    
+    
+    @pdf.font "Courier", :style => :bold_italic
+    @pdf.text "In Courier bold-italic"   
+     
+    @pdf.font "Courier", :style => :italic
+    @pdf.text "In Courier italic"    
+    
+    @pdf.font "Courier", :style => :normal
+    @pdf.text "In Normal Courier"  
+           
+    @pdf.font "Helvetica"
+    @pdf.text "In Normal Helvetica"     
+    
+    text = PDF::Inspector::Text.analyze(@pdf.render)
+    text.font_settings.map { |e| e[:name] }.should == 
+     [:"Courier-Bold", :"Courier-BoldOblique", :"Courier-Oblique", 
+      :Courier, :Helvetica]
+ end
+      
+end
+
+describe "Document#page_fonts" do
+  before(:each) { create_pdf } 
+  
+  it "should register the current font when changing pages" do
+    @pdf.font "Courier"
+    page_should_include_font("Courier") 
+    @pdf.start_new_page  
+    page_should_include_font("Courier")       
+  end 
+  
+  it "should register fonts properly by page" do
+    @pdf.font "Courier"
+    @pdf.font "Helvetica"
+    @pdf.font "Times-Roman"          
+    ["Courier","Helvetica","Times-Roman"].each { |f|
+      page_should_include_font(f)
+    }                                        
+    
+    @pdf.start_new_page    
+    @pdf.font "Helvetica"
+    ["Times-Roman","Helvetica"].each { |f|
+      page_should_include_font(f)    
+    }    
+    page_should_not_include_font("Courier")                           
+  end    
+  
+  def page_includes_font?(font)          
+    @pdf.page_fonts.values.map { |e| e.data[:BaseFont] }.include?(font.to_sym)     
+  end                             
+  
+  def page_should_include_font(font)    
+    assert_block("Expected page to include font: #{font}") do
+      page_includes_font?(font)
+    end
+  end   
+  
+  def page_should_not_include_font(font)
+    assert_block("Did not expect page to include font: #{font}") do
+      not page_includes_font?(font) 
+    end
+  end
+      
+end
+    
+    
+    
+