podoff 0.9.0 → 1.0.0

data/spec/core_spec.rb

@@ -12,11 +12,58 @@ describe Podoff do
 
   describe '.load' do
 
+    it 'loads a PDF document' do
+
+      d = Podoff.load('pdfs/t0.pdf')
+
+      expect(d.class).to eq(Podoff::Document)
+      expect(d.xref).to eq(414)
+      expect(d.objs.keys).to eq([ '1 0', '2 0', '3 0', '4 0', '5 0', '6 0' ])
+
+      #pp d.objs.values.collect(&:to_a)
+
+      expect(d.objs['1 0'].to_a).to eq(
+        [ '1 0', 9, 54, { type: '/Catalog' } ])
+      expect(d.objs['3 0'].to_a).to eq(
+        [ '3 0', 111, 213, { type: '/Page', contents: '6 0 R' } ])
+
+      expect(d.objs.values.first.document).not_to be(nil)
+
+      expect(d.obj_counters.keys).to eq(
+        [ '1 0', '2 0', '3 0', '4 0', '5 0', '6 0' ])
+      expect(d.obj_counters.values).to eq(
+        [ 1, 1, 1, 1, 1, 1 ])
+
+      expect(d.root).to eq('1 0')
+    end
+
     it 'loads a PDF document' do
 
       d = Podoff.load('pdfs/udocument0.pdf')
 
       expect(d.class).to eq(Podoff::Document)
+      expect(d.xref).to eq(3138351)
+      expect(d.objs.size).to eq(273)
+      expect(d.objs.keys).to include('1 0')
+      expect(d.objs.keys).to include('273 0')
+
+      expect(d.root).to eq('65 0')
+    end
+
+    it 'loads a PDF document with incremental updates' do
+
+      d = Podoff.load('pdfs/t1.pdf')
+
+      expect(d.class).to eq(Podoff::Document)
+      expect(d.xref).to eq(698)
+      expect(d.objs.keys).to eq([ '1 0', '2 0', '3 0', '4 0', '5 0', '6 0' ])
+
+      expect(d.obj_counters.keys).to eq(
+        [ '1 0', '2 0', '3 0', '4 0', '5 0', '6 0' ])
+      expect(d.obj_counters.values).to eq(
+        [ 1, 1, 1, 1, 1, 2 ])
+
+      expect(d.root).to eq('1 0')
     end
 
     it 'rejects items that are not PDF documents' do

data/spec/document_spec.rb

@@ -39,9 +39,10 @@ describe Podoff::Document do
     it 'returns a page given an index (starts at 1)' do
 
       p = @d.page(1)
-
       expect(p.class).to eq(Podoff::Obj)
-      expect(p.type).to eq('Page')
+      expect(p.type).to eq('/Page')
+      expect(p.attributes[:pagenum]).to eq('1')
+      expect(p.page_number).to eq(1)
     end
 
     it 'returns nil if the page doesn\'t exist' do
@@ -49,14 +50,30 @@ describe Podoff::Document do
       expect(@d.page(0)).to eq(nil)
       expect(@d.page(9)).to eq(nil)
     end
-  end
 
-  describe '#fonts' do
+    it 'returns the page, even for a doc without pdftk_PageNum' do
+
+      d = Podoff::Document.load('pdfs/t2.pdf')
 
-    it 'returns the font obj' do
+      expect(d.page(1).ref).to eq('3 0')
+      expect(d.page(1).page_number).to eq(nil)
 
-      expect(@d.fonts.size).to eq(35)
-      expect(@d.fonts.first.class).to eq(Podoff::Obj)
+      expect(d.page(0)).to eq(nil)
+      expect(d.page(2)).to eq(nil)
+    end
+
+    it 'returns pages from the last when the index is negative' do
+
+      expect(@d.page(-1).ref).to eq('33 0')
+      expect(@d.page(-1).page_number).to eq(3)
+    end
+
+    it 'returns pages from the last when the index is negative (no PageNum)' do
+
+      d = Podoff::Document.load('pdfs/t2.pdf')
+
+      expect(d.page(-1).ref).to eq('3 0')
+      expect(d.page(-1).page_number).to eq(nil)
     end
   end
 
@@ -72,6 +89,29 @@ describe Podoff::Document do
       expect(lines.first).to match(/^%PDF-1.7$/)
       expect(lines.last).to match(/^%%EOF$/)
     end
+
+    it 'writes open streams as well' do
+
+      d = Podoff.load('pdfs/t0.pdf')
+
+      pa = d.re_add(d.page(1))
+      st = d.add_stream
+      st.bt(10, 20, 'hello open stream')
+      pa.insert_contents(st)
+
+      s = d.write(:string)
+
+      expect(
+        d.write(:string).index(%{
+7 0 obj
+<< /Length 37 >>
+stream
+BT 10 20 Td (hello open stream) Tj ET
+endstream
+endobj
+        }.strip)
+      ).to eq(722)
+    end
   end
 
   describe '#dup' do
@@ -80,15 +120,158 @@ describe Podoff::Document do
 
       d = @d.dup
 
-      expect(d.class
-        ).to eq(Podoff::Document)
-      expect(d.objs.hash
-        ).not_to eq(@d.objs.hash)
-      expect(d.objs.values.first.hash
-        ).not_to eq(@d.objs.values.first.hash)
+      expect(d.class).to eq(Podoff::Document)
+      expect(d.hash).not_to eq(@d.hash)
+
+      expect(d.objs.hash).not_to eq(@d.objs.hash)
+
+      expect(d.objs.values.first.hash).not_to eq(@d.objs.values.first.hash)
+      expect(d.objs.values.first.class).to eq(Podoff::Obj)
+      expect(d.objs.values.first.document.class).to eq(Podoff::Document)
+
+      expect(d.objs.values.first.document).to equal(d)
+      expect(@d.objs.values.first.document).to equal(@d)
+
+      expect(d.root).to eq('65 0')
+    end
+  end
+
+  context 'additions' do
+
+    before :each do
+
+      @d = Podoff.load('pdfs/t0.pdf')
+    end
+
+    describe '#add_base_font' do
+
+      it 'adds a new /Font obj to the document' do
+
+        fo = @d.add_base_font('Helvetica')
+
+        expect(@d.additions.size).to eq(1)
+        expect(@d.objs.keys).to eq((1..7).map { |i| "#{i} 0" })
+        expect(@d.additions.keys).to eq([ '7 0' ])
+
+        expect(fo.document).to eq(@d)
+        expect(fo.ref).to eq('7 0')
+
+        expect(fo.source).to eq(
+          '7 0 obj ' +
+          '<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >> endobj')
+
+        s = @d.write(:string)
+        d = Podoff.parse(s)
+
+        expect(d.xref).to eq(682)
+      end
+
+      it 'doesn\'t mind a slash in front of the font name' do
+
+        fo = @d.add_base_font('/Helvetica')
+
+        expect(@d.additions.size).to eq(1)
+        expect(@d.objs.keys).to eq((1..7).map { |i| "#{i} 0" })
+        expect(@d.additions.keys).to eq([ '7 0' ])
+
+        expect(fo.document).to eq(@d)
+        expect(fo.ref).to eq('7 0')
+
+        expect(fo.source).to eq(
+          '7 0 obj ' +
+          '<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >> endobj')
+      end
+    end
+
+    describe '#add_stream' do
+
+      it 'adds a new obj with a stream to the document' do
+
+        st = @d.add_stream('BT 70 80 Td /Helvetica 35 Tf (Hello!) Tj ET')
+
+        expect(@d.additions.size).to eq(1)
+        expect(@d.objs.keys).to eq((1..7).map { |i| "#{i} 0" })
+        expect(@d.additions.keys).to eq([ '7 0' ])
+
+        expect(st.document).to eq(@d)
+        expect(st.ref).to eq('7 0')
+
+        expect(st.source).to eq(%{
+7 0 obj
+<< /Length 43 >>
+stream
+BT 70 80 Td /Helvetica 35 Tf (Hello!) Tj ET
+endstream
+endobj
+        }.strip)
+
+        d = Podoff.parse(@d.write(:string))
+
+        expect(d.xref).to eq(705)
+      end
+
+      it 'accepts a block' do
+
+        st =
+          @d.add_stream {
+            tf '/Helvetica', 35
+            bt 10, 20, 'thirty here'
+            bt 40, 50, 'sixty there'
+          }
+
+        expect(st.obj.document).to eq(@d)
+        expect(st.obj.ref).to eq('7 0')
+
+        expect(st.obj.source.to_s).to eq(%{
+BT /Helvetica 35 Tf 10 20 Td (thirty here) Tj ET
+BT /Helvetica 35 Tf 40 50 Td (sixty there) Tj ET
+        }.strip)
+
+        d = Podoff.parse(@d.write(:string))
+
+        expect(d.source.index('<< /Length 97 >>')).to eq(618)
+        expect(d.xref).to eq(759)
+      end
+
+      it 'returns the open stream when no arg given' do
+
+        st = @d.add_stream
+
+        expect(st.class).to eq(Podoff::Stream)
+      end
+    end
+
+    describe '#re_add' do
+
+      it 'replicates an obj and adds the replica to the document' do
+
+        pa = @d.page(1)
+        re = @d.re_add(pa)
+
+        expect(@d.additions.size).to eq(1)
+        expect(@d.objs.keys).to eq((1..6).map { |i| "#{i} 0" })
+        expect(@d.additions.keys).to eq([ '3 0' ])
+
+        expect(re.document).to eq(@d)
+        expect(re.ref).to eq(pa.ref)
+        expect(re.source).to eq(pa.source)
+        expect(re.source).not_to equal(pa.source)
+      end
+
+      it 'accepts a ref' do
+
+        pa = @d.page(1)
+        re = @d.re_add(pa.ref)
+
+        expect(@d.additions.size).to eq(1)
+        expect(@d.objs.keys).to eq((1..6).map { |i| "#{i} 0" })
+        expect(@d.additions.keys).to eq([ '3 0' ])
 
-      expect(d.objs.values.first.document).to eq(d)
-      expect(@d.objs.values.first.document).to eq(@d)
+        expect(re.document).to eq(@d)
+        expect(re.ref).to eq(pa.ref)
+        expect(re.source).to eq(pa.source)
+        expect(re.source).not_to equal(pa.source)
+      end
     end
   end
 end

data/spec/obj_spec.rb

@@ -23,160 +23,214 @@ describe Podoff::Obj do
     end
   end
 
-  describe '#type' do
+  describe '#source' do
 
-    it 'returns the type of the obj' do
+    it 'returns the source behind the obj' do
 
-      expect(@d.objs['23 0'].type).to eq('Font')
-    end
-
-    it 'returns nil if there is no type' do
+      o = @d.objs['20 0']
 
-      expect(@d.objs['17 0'].type).to eq(nil)
+      expect(o.source).to eq(%{
+20 0 obj [21 0 R]
+endobj
+      }.strip)
     end
   end
 
-  describe '#parent' do
-
-    it 'returns the parent ref if any' do
-
-      expect(@d.objs.values.first.parent).to eq('2 0')
-    end
-
-    it 'returns nil if there is no parent' do
-
-      expect(@d.objs['2 0'].parent).to eq(nil)
-    end
-  end
+#  describe '#match' do
+#
+#    it 'returns a MatchData instance if there is a match' do
+#
+#      o = @d.objs['1 0']
+#
+#      m = o.match(/\/Contents ([^\n]+)/)
+#
+#      expect(m).not_to eq(nil)
+#      expect(m[1]).to eq('3 0 R')
+#      expect(m.offset(0)).to eq([ 123, 138 ]) # /!\
+#    end
+#
+#    it 'returns nil if the match exits the obj' do
+#
+#      o = @d.objs['1 0']
+#
+#      m = o.match(/3 0 obj/)
+#
+#      expect(m).to eq(nil)
+#    end
+#
+#    it 'returns nil if there is no match' do
+#
+#      o = @d.objs['1 0']
+#
+#      m = o.match(/nada/)
+#
+#      expect(m).to eq(nil)
+#    end
+#  end
+#
+#  describe '#dmatch' do
+#
+#    it 'matches with the zero offset set to the document' do
+#
+#      o = @d.objs['1 0']
+#
+#      m = o.dmatch(/\/Contents ([^\n]+)/)
+#
+#      expect(m).not_to eq(nil)
+#      expect(m[1]).to eq('3 0 R')
+#      expect(m.offset(0)).to eq([ 138, 153 ]) # /!\
+#    end
+#  end
 
-  describe '#kids' do
+  describe '#type' do
 
-    it 'returns a list of refs' do
+    it 'returns the type of the obj' do
 
-      expect(@d.objs['2 0'].kids).to eq([ '1 0', '16 0', '33 0' ])
+      expect(@d.objs['23 0'].type).to eq('/Font')
     end
 
-    it 'returns an empty list if there are no kids' do
+    it 'returns nil if there is no type' do
 
-      expect(@d.objs['224 0'].kids).to eq([])
+      expect(@d.objs['17 0'].type).to eq(nil)
     end
-  end
 
-  describe '#contents' do
+    it 'works on open streams' do
 
-    it 'returns the Contents reference' do
+      st = @d.add_stream
 
-      expect(@d.objs['1 0'].contents).to eq('3 0')
-    end
-
-    it 'returns nil if none' do
-
-      expect(@d.objs['224 0'].contents).to eq(nil)
+      expect(st.obj.type).to eq(nil)
     end
   end
 
-  describe '#font_names' do
-
-    it 'returns a list of font names visible in this obj' do
-
-      expect(
-        @d.objs.values.first.font_names
-      ).to eq(%w[
-        C2_0 TT2 TT1 TT0 C2_2 C2_1 Helv
-      ])
-    end
-  end
+#  describe '#parent' do
+#
+#    it 'returns the parent ref if any' do
+#
+#      expect(@d.objs.values.first.parent).to eq('2 0')
+#    end
+#
+#    it 'returns nil if there is no parent' do
+#
+#      expect(@d.objs['2 0'].parent).to eq(nil)
+#    end
+#  end
 
-  describe '#index' do
+#  describe '#kids' do
+#
+#    it 'returns a list of refs' do
+#
+#      expect(@d.objs['2 0'].kids).to eq([ '1 0', '16 0', '33 0' ])
+#    end
+#
+#    it 'returns an empty list if there are no kids' do
+#
+#      expect(@d.objs['224 0'].kids).to eq([])
+#    end
+#  end
+#
+#  describe '#contents' do
+#
+#    it 'returns the Contents references (single)' do
+#
+#      expect(@d.objs['1 0'].contents).to eq([ '3 0' ])
+#    end
+#
+#    it 'returns the Contents references (array)' do
+#
+#      expect(@d.objs['16 0'].contents).to eq([ '17 0' ])
+#    end
+#
+#    it 'returns an empty list if none' do
+#
+#      expect(@d.objs['224 0'].contents).to eq([])
+#    end
+#  end
 
-    it 'returns the for a given line' do
+  context 'insertions' do
 
-      o = @d.objs['3 0']
+    before :each do
 
-      expect(o.index('stream')).to eq(4)
-      expect(o.index('BT')).to eq(14)
+      @d = Podoff.load('pdfs/udocument0.pdf')
     end
 
-    it 'returns nil when it doesn\'t find' do
+    describe '#insert_contents' do
 
-      o = @d.objs['3 0']
+      it 'fails if the target hasn\'t been replicated' do
 
-      expect(o.index('nada')).to eq(nil)
-    end
+        expect {
+          @d.objs['23 0'].insert_contents('-1 0')
+        }.to raise_error(ArgumentError, "target '23 0' not a replica")
+      end
 
-    it 'accepts regexes' do
+      it 'fails if the target doesn\'t have /Contents' do
 
-      o = @d.objs['1 0']
+        expect {
+          ta = @d.re_add('23 0')
+          ta.insert_contents('-1 0')
+        }.to raise_error(ArgumentError, "target '23 0' doesn't have /Contents")
+      end
 
-      i = o.index(/^\/B.+Box /)
+      it 'accepts an obj' do
 
-      expect(i).to eq(40)
-      expect(o.lines[i]).to eq('/BleedBox [0.0 0.0 612.0 792.0]')
-    end
-
-    it 'accepts a start index' do
+        pa = @d.re_add(@d.page(1))
 
-      o = @d.objs['1 0']
+        st = @d.add_stream('BT 70 80 Td /Font0 35 Tf (content is king!) Tj ET')
 
-      i = o.index(/^\/.+Box /, 3)
+        pa.insert_contents(st)
 
-      expect(i).to eq(5)
-      expect(o.lines[i]).to eq('/TrimBox [0.0 0.0 612.0 792.0]')
-    end
-  end
+        expect(pa.source).to match(/\/Contents \[3 0 R #{st.ref} R\]\n/)
+      end
 
-  describe '#find' do
+      it 'accepts an obj ref' do
 
-    it 'returns the first sub obj that matches the given block' do
+        pa = @d.re_add(@d.page(1))
 
-      o = @d.objs['1 0']
+        st = @d.add_stream('BT 70 80 Td /Font0 35 Tf (content is king!) Tj ET')
 
-      o1 = o.find { |o| o.index('stream') }
+        pa.insert_contents(st.ref)
 
-      expect(o1).not_to eq(nil)
-      expect(o1.lines.first).to eq('3 0 obj ')
+        expect(pa.source).to match(/\/Contents \[3 0 R #{st.ref} R\]\n/)
+      end
     end
 
-    it 'accept a :skip_root option'
-  end
-
-  describe '#gather' do
-
-    it 'returns a list of sub obj that match the given block'
-    it 'accept a :skip_root option'
-  end
+    describe '#insert_font' do
 
-  describe '#crop_box' do
+      it 'fails if the target hasn\'t been replicated' do
 
-    it 'returns the [ x, y, w, h ] box for the obj' do
+        expect {
+          @d.objs['23 0'].insert_font('/Helvetica', '-1 0')
+        }.to raise_error(ArgumentError, "target '23 0' not a replica")
+      end
 
-      o = @d.objs['1 0']
+      it 'accepts name, obj' do
 
-      expect(o.crop_box).to eq([ 0.0, 0.0, 612.0, 792.0 ])
-    end
+        fo = @d.add_base_font('/Helvetica')
+        pa = @d.re_add(@d.page(1))
 
-    it 'defaults to the MediaBox' do
+        pa.insert_font('MyHelv', fo)
 
-      o = @d.objs['16 0']
+        expect(pa.source).to match(/\/Font\s+<<\s+\/MyHelv #{fo.ref} R\s+/)
+      end
 
-      expect(o.crop_box).to eq([ 0.0, 0.0, 612.0, 792.0 ])
-    end
-  end
+      it 'accepts name, obj ref' do
 
-  describe '#crop_dims' do
+        fo = @d.add_base_font('/Helvetica')
+        pa = @d.re_add(@d.page(1))
 
-    it 'returns [ w, h ]' do
+        pa.insert_font('MyHelv', fo.ref)
 
-      o = @d.objs['1 0']
+        expect(pa.source).to match(/\/Font\s+<<\s+\/MyHelv #{fo.ref} R\s+/)
+      end
 
-      expect(o.crop_dims).to eq([ 612.0, 792.0 ])
-    end
+      it 'accepts a slash in front of the name' do
 
-    it 'defaults to the MediaBox' do
+        fo = @d.add_base_font('/Helvetica')
+        pa = @d.re_add(@d.page(1))
 
-      o = @d.objs['16 0']
+        pa.insert_font('/MyHelv', fo.ref)
 
-      expect(o.crop_dims).to eq([ 612.0, 792.0 ])
+        expect(pa.source).to match(/\/Font\s+<<\s+\/MyHelv #{fo.ref} R\s+/)
+      end
     end
   end
 end

data/spec/stream_spec.rb

@@ -0,0 +1,67 @@
+
+#
+# specifying podoff
+#
+# Fri Oct 23 08:36:38 JST 2015
+#
+
+require 'spec_helper'
+
+
+describe Podoff::Stream do
+
+  describe '#tf' do
+
+    it 'sets the current font' do
+
+      st = Podoff::Stream.new
+
+      st.tf('/Helvetica', 35)
+      st.bt(10, 20, 'helvetic')
+      st.tf('/ZapfDingbats', 21)
+      st.bt(10, 50, 'zapfesque')
+
+      expect(st.to_s).to eq(%{
+BT /Helvetica 35 Tf 10 20 Td (helvetic) Tj ET
+BT /ZapfDingbats 21 Tf 10 50 Td (zapfesque) Tj ET
+      }.strip)
+    end
+  end
+
+  describe '#bt' do
+
+    it 'works' do
+
+      st = Podoff::Stream.new
+      st.bt(10, 20, 'hello world')
+
+      expect(st.to_s).to eq('BT 10 20 Td (hello world) Tj ET')
+    end
+
+    it 'escapes the text' do
+
+      st = Podoff::Stream.new
+      st.bt(10, 20, 'hello()world')
+
+      expect(st.to_s).to eq('BT 10 20 Td (hello\(\)world) Tj ET')
+    end
+  end
+
+  describe '#write' do
+
+    it 'injects text into the stream' do
+
+      st = Podoff::Stream.new
+      st.bt(10, 20, 'abc')
+      st.write("\nBT 25 35 Td (ABC) Tj ET")
+      st.bt(30, 40, 'def')
+
+      expect(st.to_s).to eq(%{
+BT 10 20 Td (abc) Tj ET
+BT 25 35 Td (ABC) Tj ET
+BT 30 40 Td (def) Tj ET
+      }.strip)
+    end
+  end
+end
+