pdf-core 0.2.4 → 0.2.5

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,56 @@
+PDF::Core is copyrighted free software produced by Gregory Brown along with 
+community contributions.  See git log for authorship information.
+
+Licensing terms follow:
+
+You can redistribute PDF::Core and/or modify it under either the terms of the GPLv2
+or GPLv3 (see GPLv2 and GPLv3 files), or the conditions below:
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+    modifications to Usenet or an equivalent medium, or by allowing
+    the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) rename any non-standard executables so the names do not conflict
+    with standard executables, which must also be provided.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or executable
+     form, provided that you do at least ONE of the following:
+
+       a) distribute the executables and library files of the software,
+    together with instructions (in the manual page or equivalent)
+    on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+    the software.
+
+       c) give non-standard executables non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial). 
+
+  5. The scripts and library files supplied as input to or produced as 
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them, 
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler"
+Bundler.setup
+
+require 'rake'
+require 'rspec/core/rake_task'
+task :default => [:spec]
+
+desc "Run all rspec files"
+RSpec::Core::RakeTask.new("spec") do |c|
+  c.rspec_opts = "-t ~unresolved"
+end

data/pdf-core.gemspec

@@ -3,7 +3,9 @@ Gem::Specification.new do |spec|
   spec.version = File.read(File.expand_path('VERSION', File.dirname(__FILE__))).strip
   spec.platform = Gem::Platform::RUBY
   spec.summary = "PDF::Core is used by Prawn to render PDF documents"
-  spec.files =  Dir.glob("{lib}/**/**/*") +
+  spec.files =  Dir.glob("{lib,spec}/**/**/*") +
+                ["COPYING", "GPLv2", "GPLv3", "LICENSE"] +
+                ["Gemfile", "Rakefile"] +
                 ["pdf-core.gemspec"]
   spec.require_path = "lib"
   spec.required_ruby_version = '>= 1.9.3'

data/spec/filters_spec.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require_relative "spec_helper"
+
+FILTERS = {
+  :FlateDecode    => {'test' => "x\x9C+I-.\x01\x00\x04]\x01\xC1".force_encoding(Encoding::ASCII_8BIT) },
+  :DCTDecode      => {'test' => "test"}
+}
+
+FILTERS.each do |filter_name, examples|
+  filter = PDF::Core::Filters.const_get(filter_name)
+
+  describe "#{filter_name} filter" do
+    it "should encode stream" do
+      examples.each do |in_stream, out_stream|
+        filter.encode(in_stream).should == out_stream
+      end
+    end
+
+    it "should decode stream" do
+      examples.each do |in_stream, out_stream|
+        filter.decode(out_stream).should == in_stream
+      end
+    end
+
+    it "should be symmetric" do
+      examples.each do |in_stream, out_stream|
+        filter.decode(filter.encode(in_stream)).should == in_stream
+
+        filter.encode(filter.decode(out_stream)).should == out_stream
+      end
+    end
+  end
+end

data/spec/name_tree_spec.rb

@@ -0,0 +1,122 @@
+require_relative "spec_helper"
+
+def tree_dump(tree)
+  if tree.is_a?(PDF::Core::NameTree::Node)
+    "[" + tree.children.map { |child| tree_dump(child) }.join(",") + "]"
+  else
+    "#{tree.name}=#{tree.value}"
+  end
+end
+
+def tree_add(tree, *args)
+  args.each do |(name, value)|
+    tree.add(name, value)
+  end
+end
+
+def tree_value(name, value)
+  PDF::Core::NameTree::Value.new(name, value)
+end
+
+# FIXME: This is a dummy that's meant to stand in for a Prawn::Document.
+# It causes the tests to pass but I have no idea if it's really a
+# sufficient test double or not.
+class RefExposingDocument
+  def initialize
+    @object_store = []
+  end
+
+  attr_reader :object_store
+
+  def ref!(obj)
+    @object_store << obj
+  end
+end
+
+describe "Name Tree" do
+  before(:each) { @pdf = RefExposingDocument.new }
+
+  it "should have no children when first initialized" do
+    node = PDF::Core::NameTree::Node.new(@pdf, 3)
+    node.children.length.should == 0
+  end
+
+  it "should have no subtrees while child limit is not reached" do
+    node = PDF::Core::NameTree::Node.new(@pdf, 3)
+    tree_add(node, ["one", 1], ["two", 2], ["three", 3])
+    tree_dump(node).should == "[one=1,three=3,two=2]"
+  end
+
+  it "should split into subtrees when limit is exceeded" do
+    node = PDF::Core::NameTree::Node.new(@pdf, 3)
+    tree_add(node, ["one", 1], ["two", 2], ["three", 3], ["four", 4])
+    tree_dump(node).should == "[[four=4,one=1],[three=3,two=2]]"
+  end
+
+  it "should create a two new references when root is split" do
+    ref_count = @pdf.object_store.length
+    node = PDF::Core::NameTree::Node.new(@pdf, 3)
+    tree_add(node, ["one", 1], ["two", 2], ["three", 3], ["four", 4])
+    @pdf.object_store.length.should == ref_count+2
+  end
+
+  it "should create a one new reference when subtree is split" do
+    node = PDF::Core::NameTree::Node.new(@pdf, 3)
+    tree_add(node, ["one", 1], ["two", 2], ["three", 3], ["four", 4])
+
+    ref_count = @pdf.object_store.length # save when root is split
+    tree_add(node, ["five", 5], ["six", 6], ["seven", 7])
+    tree_dump(node).should == "[[five=5,four=4,one=1],[seven=7,six=6],[three=3,two=2]]"
+    @pdf.object_store.length.should == ref_count+1
+  end
+
+  it "should keep tree balanced when subtree split cascades to root" do
+    node = PDF::Core::NameTree::Node.new(@pdf, 3)
+    tree_add(node, ["one", 1], ["two", 2], ["three", 3], ["four", 4])
+    tree_add(node, ["five", 5], ["six", 6], ["seven", 7], ["eight", 8])
+    tree_dump(node).should == "[[[eight=8,five=5],[four=4,one=1]],[[seven=7,six=6],[three=3,two=2]]]"
+  end
+
+  it "should maintain order of already properly ordered nodes" do
+    node = PDF::Core::NameTree::Node.new(@pdf, 3)
+    tree_add(node, ["eight", 8], ["five", 5], ["four", 4], ["one", 1])
+    tree_add(node, ['seven', 7], ['six', 6], ['three', 3], ['two', 2])
+    tree_dump(node).should == "[[[eight=8,five=5],[four=4,one=1]],[[seven=7,six=6],[three=3,two=2]]]"
+  end
+
+  it "should emit only :Names key with to_hash if root is only node" do
+    node = PDF::Core::NameTree::Node.new(@pdf, 3)
+    tree_add(node, ["one", 1], ["two", 2], ["three", 3])
+    node.to_hash.should ==(
+      { :Names => [tree_value("one", 1), tree_value("three", 3), tree_value("two", 2)] }
+    )
+  end
+
+  it "should emit only :Kids key with to_hash if root has children" do
+    node = PDF::Core::NameTree::Node.new(@pdf, 3)
+    tree_add(node, ["one", 1], ["two", 2], ["three", 3], ["four", 4])
+    node.to_hash.should ==({ :Kids => node.children.map { |child| child.ref } })
+  end
+
+  it "should emit :Limits and :Names keys with to_hash for leaf node" do
+    node = PDF::Core::NameTree::Node.new(@pdf, 3)
+    tree_add(node, ["one", 1], ["two", 2], ["three", 3], ["four", 4])
+    node.children.first.to_hash.should ==(
+      { :Limits => %w(four one),
+        :Names => [tree_value("four", 4), tree_value("one", 1)] }
+    )
+  end
+
+  it "should emit :Limits and :Kids keys with to_hash for inner node" do
+    node = PDF::Core::NameTree::Node.new(@pdf, 3)
+    tree_add(node, ["one", 1], ["two", 2], ["three", 3], ["four", 4])
+    tree_add(node, ["five", 5], ["six", 6], ["seven", 7], ["eight", 8])
+    tree_add(node, ["nine", 9], ["ten", 10], ["eleven", 11], ["twelve", 12])
+    tree_add(node, ["thirteen", 13], ["fourteen", 14], ["fifteen", 15], ["sixteen", 16])
+    node.children.first.to_hash.should ==(
+      { :Limits => %w(eight one),
+        :Kids => node.children.first.children.map { |child| child.ref } }
+    )
+  end
+end
+

data/spec/object_store_spec.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require_relative "spec_helper"
+
+describe "PDF::Core::ObjectStore" do
+  before(:each) do
+    @store = PDF::Core::ObjectStore.new
+  end
+
+  it "should create required roots by default, including info passed to new" do
+    store = PDF::Core::ObjectStore.new(:info => {:Test => 3})
+    store.size.should == 3 # 3 default roots
+    store.info.data[:Test].should == 3
+    store.pages.data[:Count].should == 0
+    store.root.data[:Pages].should == store.pages
+  end
+
+ 
+  it "should add to its objects when ref() is called" do
+    count = @store.size
+    @store.ref("blah")
+    @store.size.should == count + 1
+  end
+
+  it "should accept push with a Prawn::Reference" do
+    r = PDF::Core::Reference(123, "blah")
+    @store.push(r)
+    @store[r.identifier].should == r
+  end
+
+  it "should accept arbitrary data and use it to create a Prawn::Reference" do
+    @store.push(123, "blahblah")
+    @store[123].data.should == "blahblah"
+  end
+
+  it "should be Enumerable, yielding in order of submission" do
+    # higher IDs to bypass the default roots
+    [10, 11, 12].each do |id|
+      @store.push(id, "some data #{id}")
+    end
+    @store.map{|ref| ref.identifier}[-3..-1].should == [10, 11, 12]
+  end
+
+  it "should accept option to disabling PDF scaling in PDF clients" do
+    @store = PDF::Core::ObjectStore.new(:print_scaling => :none)
+    @store.root.data[:ViewerPreferences].should == {:PrintScaling => :None}
+  end
+
+end

data/spec/pdf_object_spec.rb

@@ -0,0 +1,172 @@
+# encoding: ASCII-8BIT
+require_relative "spec_helper"
+
+# See PDF Reference, Sixth Edition (1.7) pp51-60 for details
+describe "PDF Object Serialization" do
+
+  it "should convert Ruby's nil to PDF null" do
+    PDF::Core::PdfObject(nil).should == "null"
+  end
+
+  it "should convert Ruby booleans to PDF booleans" do
+    PDF::Core::PdfObject(true).should  == "true"
+    PDF::Core::PdfObject(false).should == "false"
+  end
+
+  it "should convert a Ruby number to PDF number" do
+    PDF::Core::PdfObject(1).should == "1"
+    PDF::Core::PdfObject(1.214112421).should == "1.214112421"
+    # scientific notation is not valid in PDF
+    PDF::Core::PdfObject(0.000005).should == "0.000005"
+  end
+
+  it "should convert a Ruby time object to a PDF timestamp" do
+    t = Time.now
+    PDF::Core::PdfObject(t).should == t.strftime("(D:%Y%m%d%H%M%S%z").chop.chop + "'00')"
+  end
+
+  it "should convert a Ruby string to PDF string when inside a content stream" do
+    s = "I can has a string"
+    PDF::Inspector.parse(PDF::Core::PdfObject(s, true)).should == s
+  end
+
+  it "should convert a Ruby string to a UTF-16 PDF string when outside a content stream" do
+    s = "I can has a string"
+    s_utf16 = "\xFE\xFF" + s.unpack("U*").pack("n*")
+    PDF::Inspector.parse(PDF::Core::PdfObject(s, false)).should == s_utf16
+  end
+
+  it "should convert a Ruby string with characters outside the BMP to its " +
+     "UTF-16 representation with a BOM" do
+    # U+10192 ROMAN SEMUNCIA SIGN
+    semuncia = [65938].pack("U")
+    PDF::Core::PdfObject(semuncia, false).upcase.should == "<FEFFD800DD92>"
+  end
+
+  it "should pass through bytes regardless of content stream status for ByteString" do
+    PDF::Core::PdfObject(PDF::Core::ByteString.new("\xDE\xAD\xBE\xEF")).upcase.
+      should == "<DEADBEEF>"
+  end
+
+  it "should escape parens when converting from Ruby string to PDF" do
+    s =  'I )(can has a string'
+    PDF::Inspector.parse(PDF::Core::PdfObject(s, true)).should == s
+  end
+
+  it "should handle ruby escaped parens when converting to PDF string" do
+    s = 'I can \\)( has string'
+    PDF::Inspector.parse(PDF::Core::PdfObject(s, true)).should == s
+  end
+
+  it "should escape various strings correctly when converting a LiteralString" do
+    ls = PDF::Core::LiteralString.new("abc")
+    PDF::Core::PdfObject(ls).should == "(abc)"
+
+    ls = PDF::Core::LiteralString.new("abc\x0Ade") # should escape \n
+    PDF::Core::PdfObject(ls).should == "(abc\x5C\x0Ade)"
+
+    ls = PDF::Core::LiteralString.new("abc\x0Dde") # should escape \r
+    PDF::Core::PdfObject(ls).should == "(abc\x5C\x0Dde)"
+
+    ls = PDF::Core::LiteralString.new("abc\x09de") # should escape \t
+    PDF::Core::PdfObject(ls).should == "(abc\x5C\x09de)"
+
+    ls = PDF::Core::LiteralString.new("abc\x08de") # should escape \b
+    PDF::Core::PdfObject(ls).should == "(abc\x5C\x08de)"
+
+    ls = PDF::Core::LiteralString.new("abc\x0Cde") # should escape \f
+    PDF::Core::PdfObject(ls).should == "(abc\x5C\x0Cde)"
+
+    ls = PDF::Core::LiteralString.new("abc(de") # should escape \(
+    PDF::Core::PdfObject(ls).should == "(abc\x5C(de)"
+
+    ls = PDF::Core::LiteralString.new("abc)de") # should escape \)
+    PDF::Core::PdfObject(ls).should == "(abc\x5C)de)"
+
+    ls = PDF::Core::LiteralString.new("abc\x5Cde") # should escape \\
+    PDF::Core::PdfObject(ls).should == "(abc\x5C\x5Cde)"
+    PDF::Core::PdfObject(ls).size.should == 9
+  end
+
+  it "should escape strings correctly when converting a LiteralString that is not utf-8" do
+    data = "\x43\xaf\xc9\x7f\xef\xf\xe6\xa8\xcb\x5c\xaf\xd0"
+    ls = PDF::Core::LiteralString.new(data)
+    PDF::Core::PdfObject(ls).should == "(\x43\xaf\xc9\x7f\xef\xf\xe6\xa8\xcb\x5c\x5c\xaf\xd0)"
+  end
+
+  it "should convert a Ruby symbol to PDF name" do
+    PDF::Core::PdfObject(:my_symbol).should == "/my_symbol"
+    PDF::Core::PdfObject(:"A;Name_With-Various***Characters?").should ==
+     "/A;Name_With-Various***Characters?"
+  end
+
+  it "should convert a whitespace or delimiter containing Ruby symbol to a PDF name" do
+    PDF::Core::PdfObject(:"my symbol").should == "/my#20symbol"
+    PDF::Core::PdfObject(:"my#symbol").should == "/my#23symbol"
+    PDF::Core::PdfObject(:"my/symbol").should == "/my#2Fsymbol"
+    PDF::Core::PdfObject(:"my(symbol").should == "/my#28symbol"
+    PDF::Core::PdfObject(:"my)symbol").should == "/my#29symbol"
+    PDF::Core::PdfObject(:"my<symbol").should == "/my#3Csymbol"
+    PDF::Core::PdfObject(:"my>symbol").should == "/my#3Esymbol"
+  end
+
+  it "should convert a Ruby array to PDF Array when inside a content stream" do
+    PDF::Core::PdfObject([1,2,3]).should == "[1 2 3]"
+    PDF::Inspector.parse(PDF::Core::PdfObject([[1,2],:foo,"Bar"], true)).should ==
+      [[1,2],:foo, "Bar"]
+  end
+
+  it "should convert a Ruby array to PDF Array when outside a content stream" do
+    bar = "\xFE\xFF" + "Bar".unpack("U*").pack("n*")
+    PDF::Core::PdfObject([1,2,3]).should == "[1 2 3]"
+    PDF::Inspector.parse(PDF::Core::PdfObject([[1,2],:foo,"Bar"], false)).should ==
+      [[1,2],:foo, bar]
+  end
+
+  it "should convert a Ruby hash to a PDF Dictionary when inside a content stream" do
+    dict = PDF::Core::PdfObject( {:foo  => :bar,
+                              "baz" => [1,2,3],
+                              :bang => {:a => "what", :b => [:you, :say] }}, true )
+
+    res = PDF::Inspector.parse(dict)
+
+    res[:foo].should == :bar
+    res[:baz].should == [1,2,3]
+    res[:bang].should == { :a => "what", :b => [:you, :say] }
+
+  end
+
+  it "should convert a Ruby hash to a PDF Dictionary when outside a content stream" do
+    what = "\xFE\xFF" + "what".unpack("U*").pack("n*")
+    dict = PDF::Core::PdfObject( {:foo  => :bar,
+                              "baz" => [1,2,3],
+                              :bang => {:a => "what", :b => [:you, :say] }}, false )
+
+    res = PDF::Inspector.parse(dict)
+
+    res[:foo].should == :bar
+    res[:baz].should == [1,2,3]
+    res[:bang].should == { :a => what, :b => [:you, :say] }
+
+  end
+
+  it "should not allow keys other than strings or symbols for PDF dicts" do
+    lambda { PDF::Core::PdfObject(:foo => :bar, :baz => :bang, 1 => 4) }.
+      should raise_error(PDF::Core::Errors::FailedObjectConversion)
+  end
+
+  it "should convert a Prawn::Reference to a PDF indirect object reference" do
+    ref = PDF::Core::Reference(1,true)
+    PDF::Core::PdfObject(ref).should == ref.to_s
+  end
+
+  it "should convert a NameTree::Node to a PDF hash" do
+    # FIXME: Soft dependench on Prawn::Document exists in Node
+    node = PDF::Core::NameTree::Node.new(nil, 10)
+    node.add "hello", 1.0
+    node.add "world", 2.0
+    data = PDF::Core::PdfObject(node)
+    res = PDF::Inspector.parse(data)
+    res.should == {:Names => ["hello", 1.0, "world", 2.0]}
+  end
+end