piglop-prawn 0.10.2.1

data/spec/images_spec.rb

@@ -0,0 +1,96 @@
+# encoding: utf-8
+
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")  
+
+describe "the image() function" do
+
+  before(:each) do
+    @filename = "#{Prawn::BASEDIR}/data/images/pigs.jpg" 
+    create_pdf
+  end
+
+  it "should only embed an image once, even if it's added multiple times" do
+    @pdf.image @filename, :at => [100,100]
+    @pdf.image @filename, :at => [300,300]
+           
+    output = @pdf.render
+    images = PDF::Inspector::XObject.analyze(output)
+    # there should be 2 images in the page resources
+    images.page_xobjects.first.size.should == 2
+    # but only 1 image xobject
+    output.scan(/\/Type \/XObject/).size.should == 1
+  end  
+  
+  it "should return the image info object" do
+    info =  @pdf.image(@filename)
+    
+    info.should.be.kind_of(Prawn::Images::JPG)
+    
+    info.height.should == 453
+  end
+  
+  it "should accept IO objects" do
+    file = File.open(@filename, "rb")
+    info = @pdf.image(file)
+    
+    info.height.should == 453
+  end
+
+  it "should raise an UnsupportedImageType if passed a BMP" do
+    filename = "#{Prawn::BASEDIR}/data/images/tru256.bmp"
+    lambda { @pdf.image filename, :at => [100,100] }.should.raise(Prawn::Errors::UnsupportedImageType)
+  end
+
+  it "should raise an UnsupportedImageType if passed an interlaced PNG" do
+    filename = "#{Prawn::BASEDIR}/data/images/dice_interlaced.png"
+    lambda { @pdf.image filename, :at => [100,100] }.should.raise(Prawn::Errors::UnsupportedImageType)
+  end
+
+  it "should bump PDF version to 1.5 or greater on embedding 16-bit PNGs" do
+    @pdf.image "#{Prawn::BASEDIR}/data/images/16bit.png"
+    @pdf.state.version.should >= 1.5
+  end
+
+  # to support Adobe Reader, which apparently doesn't handle 16-bit alpha
+  # channels. Verified experimentally [BE] but not confirmed in documentation
+  # or anything. OS X Preview handles those files just fine.
+  #
+  it "should embed 8-bit alpha channels for 16-bit PNGs" do
+    @pdf.image "#{Prawn::BASEDIR}/data/images/16bit.png"
+
+    output = @pdf.render
+    output.should =~ /\/BitsPerComponent 16/
+    output.should =~ /\/BitsPerComponent 8/
+  end
+  
+  describe ":fit option" do
+    it "should fit inside the defined constraints" do
+      info = @pdf.image @filename, :fit => [100,400]
+      info.scaled_width.should <= 100
+      info.scaled_height.should <= 400
+
+      info = @pdf.image @filename, :fit => [400,100]
+      info.scaled_width.should <= 400
+      info.scaled_height.should <= 100
+
+      info = @pdf.image @filename, :fit => [604,453]
+      info.scaled_width.should == 604
+      info.scaled_height.should == 453
+    end
+    it "should move text position" do
+      @y = @pdf.y
+      info = @pdf.image @filename, :fit => [100,400]
+      @pdf.y.should < @y
+    end
+  end
+
+  describe ":at option" do
+    it "should not move text position" do
+      @y = @pdf.y
+      info = @pdf.image @filename, :at => [100,400]
+      @pdf.y.should == @y
+    end
+  end
+
+end
+

data/spec/inline_formatted_text_parser_spec.rb

@@ -0,0 +1,446 @@
+# -*- coding: utf-8 -*-
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
+
+describe "Text::Formatted::Parser#to_array" do
+  it "should handle sup" do
+    string = "<sup>superscript</sup>"
+    array = Prawn::Text::Formatted::Parser.to_array(string)
+    array[0].should == { :text => "superscript",
+                         :styles => [:superscript],
+                         :color => nil,
+                         :link => nil,
+                         :anchor => nil,
+                         :font => nil,
+                         :size => nil }
+  end
+  it "should handle sub" do
+    string = "<sub>subscript</sub>"
+    array = Prawn::Text::Formatted::Parser.to_array(string)
+    array[0].should == { :text => "subscript",
+                         :styles => [:subscript],
+                         :color => nil,
+                         :link => nil,
+                         :anchor => nil,
+                         :font => nil,
+                         :size => nil }
+  end
+  it "should handle rgb" do
+    string = "<color rgb='#ff0000'>red text</color>"
+    array = Prawn::Text::Formatted::Parser.to_array(string)
+    array[0].should == { :text => "red text",
+                         :styles => [],
+                         :color => "ff0000",
+                         :link => nil,
+                         :anchor => nil,
+                         :font => nil,
+                         :size => nil }
+  end
+  it "# should be optional in rgb" do
+    string = "<color rgb='ff0000'>red text</color>"
+    array = Prawn::Text::Formatted::Parser.to_array(string)
+    array[0].should == { :text => "red text",
+                         :styles => [],
+                         :color => "ff0000",
+                         :link => nil,
+                         :anchor => nil,
+                         :font => nil,
+                         :size => nil }
+  end
+  it "should handle cmyk" do
+    string = "<color c='0' m='100' y='0' k='0'>magenta text</color>"
+    array = Prawn::Text::Formatted::Parser.to_array(string)
+    array[0].should == { :text => "magenta text",
+                         :styles => [],
+                         :color => [0, 100, 0, 0],
+                         :link => nil,
+                         :anchor => nil,
+                         :font => nil,
+                         :size => nil }
+  end
+  it "should handle fonts" do
+    string = "<font name='Courier'>Courier text</font>"
+    array = Prawn::Text::Formatted::Parser.to_array(string)
+    array[0].should == { :text => "Courier text",
+                         :styles => [],
+                         :color => nil,
+                         :link => nil,
+                         :anchor => nil,
+                         :font => "Courier",
+                         :size => nil }
+  end
+  it "should handle size" do
+    string = "<font size='14'>14 point text</font>"
+    array = Prawn::Text::Formatted::Parser.to_array(string)
+    array[0].should == { :text => "14 point text",
+                         :styles => [],
+                         :color => nil,
+                         :link => nil,
+                         :anchor => nil,
+                         :font => nil,
+                         :size => 14 }
+  end
+  it "should handle links" do
+    string = "<link href='http://example.com'>external link</link>"
+    array = Prawn::Text::Formatted::Parser.to_array(string)
+    array[0].should == { :text => "external link",
+                         :styles => [],
+                         :color => nil,
+                         :link => "http://example.com",
+                         :anchor => nil,
+                         :font => nil,
+                         :size => nil }
+  end
+  it "should handle anchors" do
+    string = "<link anchor='ToC'>internal link</link>"
+    array = Prawn::Text::Formatted::Parser.to_array(string)
+    array[0].should == { :text => "internal link",
+                         :styles => [],
+                         :color => nil,
+                         :link => nil,
+                         :anchor => "ToC",
+                         :font => nil,
+                         :size => nil }
+  end
+  it "should handle higher order characters properly" do
+    string = "<b>©\n©</b>"
+    array = Prawn::Text::Formatted::Parser.to_array(string)
+    array[0].should == { :text => "©",
+                         :styles => [:bold],
+                         :color => nil,
+                         :link => nil,
+                         :anchor => nil,
+                         :font => nil,
+                         :size => nil }
+    array[1].should == { :text => "\n",
+                         :styles => [:bold],
+                         :color => nil,
+                         :link => nil,
+                         :anchor => nil,
+                         :font => nil,
+                         :size => nil }
+    array[2].should == { :text => "©",
+                         :styles => [:bold],
+                         :color => nil,
+                         :link => nil,
+                         :anchor => nil,
+                         :font => nil,
+                         :size => nil }
+  end
+  it "should convert &lt; &gt;, and &amp; to <, >, and &, respectively" do
+    string = "hello <b>&lt;, &gt;, and &amp;</b>"
+    array = Prawn::Text::Formatted::Parser.to_array(string)
+    array[1].should == { :text => "<, >, and &",
+                         :styles => [:bold],
+                         :color => nil,
+                         :link => nil,
+                         :anchor => nil,
+                         :font => nil,
+                         :size => nil }
+  end
+  it "should handle double qoutes around tag attributes" do
+    string = 'some <font size="14">sized</font> text'
+    array = Prawn::Text::Formatted::Parser.to_array(string)
+    array[1].should == { :text => "sized",
+                         :styles => [],
+                         :color => nil,
+                         :link => nil,
+                         :anchor => nil,
+                         :font => nil,
+                         :size => 14 }
+  end
+  it "should handle single qoutes around tag attributes" do
+    string = "some <font size='14'>sized</font> text"
+    array = Prawn::Text::Formatted::Parser.to_array(string)
+    array[1].should == { :text => "sized",
+                         :styles => [],
+                         :color => nil,
+                         :link => nil,
+                         :anchor => nil,
+                         :font => nil,
+                         :size => 14 }
+  end
+  it "should construct a formatted text array from a string" do
+    string = "hello <b>world\nhow <i>are</i></b> you?"
+    array = Prawn::Text::Formatted::Parser.to_array(string)
+
+    array[0].should == { :text => "hello ",
+                         :styles => [],
+                         :color => nil,
+                         :link => nil,
+                         :anchor => nil,
+                         :font => nil,
+                         :size => nil }
+    array[1].should == { :text => "world",
+                         :styles => [:bold],
+                         :color => nil,
+                         :link => nil,
+                         :anchor => nil,
+                         :font => nil,
+                         :size => nil }
+    array[2].should == { :text => "\n",
+                         :styles => [:bold],
+                         :color => nil,
+                         :link => nil,
+                         :anchor => nil,
+                         :font => nil,
+                         :size => nil }
+    array[3].should == { :text => "how ",
+                         :styles => [:bold],
+                         :color => nil,
+                         :link => nil,
+                         :anchor => nil,
+                         :font => nil,
+                         :size => nil }
+    array[4].should == { :text => "are",
+                         :styles => [:bold, :italic],
+                         :color => nil,
+                         :link => nil,
+                         :anchor => nil,
+                         :font => nil,
+                         :size => nil }
+    array[5].should == { :text => " you?",
+                         :styles => [],
+                         :color => nil,
+                         :link => nil,
+                         :anchor => nil,
+                         :font => nil,
+                         :size => nil }
+  end
+  it "should accept <strong> as an alternative to <b>" do
+    string = "<strong>bold</strong> not bold"
+    array = Prawn::Text::Formatted::Parser.to_array(string)
+
+    array[0].should == { :text => "bold",
+                         :styles => [:bold],
+                         :color => nil,
+                         :link => nil,
+                         :anchor => nil,
+                         :font => nil,
+                         :size => nil }
+    array[1].should == { :text => " not bold",
+                         :styles => [],
+                         :color => nil,
+                         :link => nil,
+                         :anchor => nil,
+                         :font => nil,
+                         :size => nil }
+  end
+  it "should accept <em> as an alternative to <i>" do
+    string = "<em>italic</em> not italic"
+    array = Prawn::Text::Formatted::Parser.to_array(string)
+
+    array[0].should == { :text => "italic",
+                         :styles => [:italic],
+                         :color => nil,
+                         :link => nil,
+                         :anchor => nil,
+                         :font => nil,
+                         :size => nil }
+    array[1].should == { :text => " not italic",
+                         :styles => [],
+                         :color => nil,
+                         :link => nil,
+                         :anchor => nil,
+                         :font => nil,
+                         :size => nil }
+  end
+  it "should accept <a> as an alternative to <link>" do
+    string = "<a href='http://example.com'>link</a> not a link"
+    array = Prawn::Text::Formatted::Parser.to_array(string)
+
+    array[0].should == { :text => "link",
+                         :styles => [],
+                         :color => nil,
+                         :link => "http://example.com",
+                         :anchor => nil,
+                         :font => nil,
+                         :size => nil }
+    array[1].should == { :text => " not a link",
+                         :styles => [],
+                         :color => nil,
+                         :link => nil,
+                         :anchor => nil,
+                         :font => nil,
+                         :size => nil }
+  end
+end
+
+
+describe "Text::Formatted::Parser#to_string" do
+  it "should handle sup" do
+    string = "<sup>superscript</sup>"
+    array = [{ :text => "superscript",
+                         :styles => [:superscript],
+                         :color => nil,
+                         :link => nil,
+                         :anchor => nil,
+                         :font => nil,
+                         :size => nil }]
+    Prawn::Text::Formatted::Parser.to_string(array).should == string
+  end
+  it "should handle sub" do
+    string = "<sub>subscript</sub>"
+    array = [{ :text => "subscript",
+                         :styles => [:subscript],
+                         :color => nil,
+                         :link => nil,
+                         :anchor => nil,
+                         :font => nil,
+                         :size => nil }]
+    Prawn::Text::Formatted::Parser.to_string(array).should == string
+  end
+  it "should handle rgb" do
+    string = "<color rgb='ff0000'>red text</color>"
+    array = [{ :text => "red text",
+                         :styles => [],
+                         :color => "ff0000",
+                         :link => nil,
+                         :anchor => nil,
+                         :font => nil,
+                         :size => nil }]
+    Prawn::Text::Formatted::Parser.to_string(array).should == string
+  end
+  it "should handle cmyk" do
+    string = "<color c='0' m='100' y='0' k='0'>magenta text</color>"
+    array = [{ :text => "magenta text",
+                         :styles => [],
+                         :color => [0, 100, 0, 0],
+                         :link => nil,
+                         :anchor => nil,
+                         :font => nil,
+                         :size => nil }]
+    Prawn::Text::Formatted::Parser.to_string(array).should == string
+  end
+  it "should handle fonts" do
+    string = "<font name='Courier'>Courier text</font>"
+    array = [{ :text => "Courier text",
+                         :styles => [],
+                         :color => nil,
+                         :link => nil,
+                         :anchor => nil,
+                         :font => "Courier",
+                         :size => nil }]
+    Prawn::Text::Formatted::Parser.to_string(array).should == string
+  end
+  it "should handle size" do
+    string = "<font size='14'>14 point text</font>"
+    array = [{ :text => "14 point text",
+                         :styles => [],
+                         :color => nil,
+                         :link => nil,
+                         :anchor => nil,
+                         :font => nil,
+                         :size => 14 }]
+    Prawn::Text::Formatted::Parser.to_string(array).should == string
+  end
+  it "should handle size" do
+    array = [{ :text => "external link",
+               :styles => [],
+               :color => nil,
+               :link => "http://example.com",
+               :anchor => nil,
+               :font => nil,
+               :size => nil }]
+    string = "<link href='http://example.com'>external link</link>"
+    Prawn::Text::Formatted::Parser.to_string(array).should == string
+  end
+  it "should handle links" do
+    array = [{ :text => "external link",
+               :styles => [],
+               :color => nil,
+               :link => "http://example.com",
+               :anchor => nil,
+               :font => nil,
+               :size => nil }]
+    string = "<link href='http://example.com'>external link</link>"
+    Prawn::Text::Formatted::Parser.to_string(array).should == string
+  end
+  it "should handle anchors" do
+    array = [{ :text => "internal link",
+               :styles => [],
+               :color => nil,
+               :link => nil,
+               :anchor => "ToC",
+               :font => nil,
+               :size => nil }]
+    string = "<link anchor='ToC'>internal link</link>"
+    Prawn::Text::Formatted::Parser.to_string(array).should == string
+  end
+  it "should convert <, >, and & to &lt; &gt;, and &amp;, respectively" do
+    array = [{ :text => "hello ",
+               :styles => [],
+               :color => nil,
+               :link => nil,
+               :font => nil,
+               :size => nil },
+            { :text => "<, >, and &",
+               :styles => [:bold],
+               :color => nil,
+               :link => nil,
+               :font => nil,
+               :size => nil }]
+    string = "hello <b>&lt;, &gt;, and &amp;</b>"
+    Prawn::Text::Formatted::Parser.to_string(array).should == string
+  end
+  it "should construct an HTML-esque string from a formatted" +
+    " text array" do
+    array = [
+             { :text => "hello ",
+               :styles => [],
+               :color => nil,
+               :link => nil,
+               :font => nil,
+               :size => 14 },
+             { :text => "world",
+               :styles => [:bold],
+               :color => nil,
+               :link => nil,
+               :font => nil,
+               :size => nil },
+             { :text => "\n",
+               :styles => [:bold],
+               :color => nil,
+               :link => nil,
+               :font => nil,
+               :size => nil },
+             { :text => "how ",
+               :styles => [:bold],
+               :color => nil,
+               :link => nil,
+               :font => nil,
+               :size => nil },
+             { :text => "are",
+               :styles => [:bold, :italic],
+               :color => nil,
+               :link => nil,
+               :font => nil,
+               :size => nil },
+             { :text => " you?",
+               :styles => [],
+               :color => nil,
+               :link => nil,
+               :font => nil,
+               :size => nil }
+             ]
+    string = "<font size='14'>hello </font><b>world</b><b>\n</b><b>how </b><b><i>are</i></b> you?"
+    Prawn::Text::Formatted::Parser.to_string(array).should == string
+  end
+end
+
+describe "Text::Formatted::Parser#array_paragraphs" do
+  it "should group fragments separated by newlines" do
+    array = [{ :text => "\nhello\nworld" },
+             { :text => "\n\n" },
+             { :text => "how" },
+             { :text => "are" },
+             { :text => "you" }]
+    target = [[{ :text => "\n"}],
+              [{ :text => "hello" }],
+              [{ :text => "world" }],
+              [{ :text => "\n"}],
+              [{ :text => "how" },
+               { :text => "are" },
+               { :text => "you" }]]
+    Prawn::Text::Formatted::Parser.array_paragraphs(array).should == target
+  end
+end

data/spec/jpg_spec.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+# Spec'ing the PNG class. Not complete yet - still needs to check the
+# contents of palette and transparency to ensure they're correct.
+# Need to find files that have these sections first.
+
+require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")  
+
+describe "When reading a JPEG file" do
+
+  before(:each) do
+    @filename = "#{Prawn::BASEDIR}/data/images/pigs.jpg"
+    @img_data = File.open(@filename, "rb") { |f| f.read }
+  end
+   
+  it "should read the basic attributes correctly" do
+    jpg = Prawn::Images::JPG.new(@img_data)
+    
+    jpg.width.should == 604
+    jpg.height.should == 453
+    jpg.bits.should == 8
+    jpg.channels.should == 3
+  end
+end
+