hexapdf 0.1.0

data/test/data/standard-security-handler/userpwd-aes-256bit-V5.pdf

@@ -0,0 +1,43 @@
+%PDF-1.7
+%����
+1 0 obj
+<< /Extensions << /ADBE << /BaseVersion /1.7 /ExtensionLevel 8 >> >> /Pages 3 0 R /Type /Catalog >>
+endobj
+2 0 obj
+<< /ModDate <b96936934c92f6becc11a0c5fa22e8dd9bc6e03ddd57ef3bf97bea18282fdf47f060dc40e90a8ac1ddaf2c1211327a16> >>
+endobj
+3 0 obj
+<< /Count 1 /Kids [ 4 0 R ] /MediaBox [ 0 0 612 446 ] /Type /Pages >>
+endobj
+4 0 obj
+<< /Contents 5 0 R /Parent 3 0 R /Resources 6 0 R /Type /Page >>
+endobj
+5 0 obj
+<< /Length 80 >>
+stream
+-�µi�#���yG��E����[�G�oE[z4k�_*_:z2�-m�"xт�^���5)G$�V:K�s&ۘAiE��ij�jWendstream
+endobj
+6 0 obj
+<< /Font << /F1 7 0 R >> /ProcSet [ /PDF /Text ] >>
+endobj
+7 0 obj
+<< /BaseFont /Helvetica /Name /F1 /Subtype /Type1 /Type /Font >>
+endobj
+8 0 obj
+<< /CF << /StdCF << /AuthEvent /DocOpen /CFM /AESV3 /Length 32 >> >> /Filter /Standard /Length 256 /O <371f521e2a1d5e550454704e52b598897491ff515d37b82648cf5f8f067b2076f271e7c6415ad9cef7a2f2683999a984> /OE <8a33575bdaef7c0bdae19fa684f26f1cb257c4efa3f30dd19196383cfe52de1b> /P -4 /Perms <003a9be14d9b17bf018c4b8cdb74934f> /R 6 /StmF /StdCF /StrF /StdCF /U <f8ad231585ebecdd9f64b5975bf57d1c3a0298937c1870abb91b93d920cddd878909d17f739201d1a7cde787148521e7> /UE <53452d54254f6bbabf566b41dd9302ae3863021efeb6af13adc6d512768d9829> /V 5 >>
+endobj
+xref
+0 9
+0000000000 65535 f 
+0000000015 00000 n 
+0000000130 00000 n 
+0000000259 00000 n 
+0000000344 00000 n 
+0000000424 00000 n 
+0000000553 00000 n 
+0000000620 00000 n 
+0000000700 00000 n 
+trailer << /Info 2 0 R /Root 1 0 R /Size 9 /ID [<6790ffa610024e78369114311fc0df96><ebca00a8b6842be1f05f9356799522b4>] /Encrypt 8 0 R >>
+startxref
+1247
+%%EOF

data/test/data/standard-security-handler/userpwd-arc4-40bit-V1.pdf

@@ -0,0 +1,43 @@
+%PDF-1.3
+%����
+1 0 obj
+<< /Pages 3 0 R /Type /Catalog >>
+endobj
+2 0 obj
+<< /ModDate <6a8f7aee72b95ba745f34cb4d716b1f9> >>
+endobj
+3 0 obj
+<< /Count 1 /Kids [ 4 0 R ] /MediaBox [ 0 0 612 446 ] /Type /Pages >>
+endobj
+4 0 obj
+<< /Contents 5 0 R /Parent 3 0 R /Resources 6 0 R /Type /Page >>
+endobj
+5 0 obj
+<< /Length 51 >>
+stream
+��<��.���:αu�g�>k|O,�.wq�د�m�qBZ{�I�~�y��endstream
+endobj
+6 0 obj
+<< /Font << /F1 7 0 R >> /ProcSet [ /PDF /Text ] >>
+endobj
+7 0 obj
+<< /BaseFont /Helvetica /Name /F1 /Subtype /Type1 /Type /Font >>
+endobj
+8 0 obj
+<< /Filter /Standard /Length 40 /O <c94a371cecfd0749dece3d88358ef57d9c31b4312dcc0e8e6a30032b8fb0ab5b> /P -4 /R 2 /U <bf3574d85c47a8ae0f5e7f59d499a785944f96280b201f41ec92f6bf682dd20a> /V 1 >>
+endobj
+xref
+0 9
+0000000000 65535 f 
+0000000015 00000 n 
+0000000064 00000 n 
+0000000129 00000 n 
+0000000214 00000 n 
+0000000294 00000 n 
+0000000394 00000 n 
+0000000461 00000 n 
+0000000541 00000 n 
+trailer << /Info 2 0 R /Root 1 0 R /Size 9 /ID [<6790ffa610024e78369114311fc0df96><7fdb6c0379284bdb698f2c7884d09ff8>] /Encrypt 8 0 R >>
+startxref
+747
+%%EOF

data/test/hexapdf/common_tokenizer_tests.rb

@@ -0,0 +1,204 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+
+module CommonTokenizerTests
+  extend Minitest::Spec::DSL
+
+  it "next_token: returns all available kinds of tokens on next_token" do
+    create_tokenizer(<<-EOF.chomp.gsub(/^ {8}/, ''))
+        % Regular tokens
+          		
+        true false
+        123 +17 -98 0 0059
+        34.5 -3.62 +123.6 4. -.002 .002 0.0
+
+        % Keywords
+        obj endobj f* *f
+
+        % Specials
+        { }
+
+        % Literal string tests
+        (parenthese\\s ( ) and \\(\r
+        special \\0053\\053\\53characters\r (*!&}^% and \\
+        so \\\r
+        on).\\n)
+        ()
+
+        % Hex strings
+        <4E6F762073 686D6F7A20	6B612070
+        6F702E>
+        < 901FA3 ><901fA>
+
+        % Names
+        /Name1
+        /ASomewhatLongerName
+        /A;Name_With-Various***Characters?
+        /1.2/$$
+        /@pattern
+        /.notdef
+        /lime#20Green
+        /paired#28#29parentheses
+        /The_Key_of_F#23_Minor
+        /A#42
+        /
+
+        % Arrays
+        [ 5 6 /Name ]
+        [5 6 /Name]
+
+        % Dictionaries
+        <</Name 5>>
+
+        % Test
+        EOF
+
+    expected_tokens = [
+      true, false,
+      123, 17, -98, 0, 59,
+      34.5, -3.62, 123.6, 4.0, -0.002, 0.002, 0.0,
+      'obj', 'endobj', 'f*', '*f', '{', '}',
+      "parentheses ( ) and (\nspecial \0053++characters\n (*!&}^% and so on).\n", '',
+      "Nov shmoz ka pop.", "\x90\x1F\xA3", "\x90\x1F\xA0",
+      :Name1, :ASomewhatLongerName, :"A;Name_With-Various***Characters?",
+      :"1.2", :"$$", :"@pattern", :".notdef", :"lime Green", :"paired()parentheses",
+      :"The_Key_of_F#_Minor", :AB, :"",
+      '[', 5, 6, :Name, ']', '[', 5, 6, :Name, ']',
+      '<<', :Name, 5, '>>'
+    ].each {|t| t.force_encoding('BINARY') if t.respond_to?(:force_encoding)}
+
+    while expected_tokens.length > 0
+      expected_token = expected_tokens.shift
+      token = @tokenizer.next_token
+      assert_equal(expected_token, token)
+      assert_equal(Encoding::BINARY, token.encoding) if token.kind_of?(String)
+    end
+    assert_equal(0, expected_tokens.length)
+    assert_equal(HexaPDF::Tokenizer::NO_MORE_TOKENS, @tokenizer.next_token)
+  end
+
+  it "next_token: should return name tokens in US-ASCII/UTF-8 or binary encoding" do
+    create_tokenizer("/ASomewhatLongerName")
+    token = @tokenizer.next_token
+    assert_equal(:ASomewhatLongerName, token)
+    assert_equal(Encoding::US_ASCII, token.encoding)
+
+    create_tokenizer("/Hößgang")
+    token = @tokenizer.next_token
+    assert_equal(:"Hößgang", token)
+    assert_equal(Encoding::UTF_8, token.encoding)
+
+    create_tokenizer('/H#c3#b6#c3#9fgang')
+    token = @tokenizer.next_token
+    assert_equal(:"Hößgang", token)
+    assert_equal(Encoding::UTF_8, token.encoding)
+
+    create_tokenizer('/H#E8lp')
+    token = @tokenizer.next_token
+    assert_equal("H\xE8lp".b.intern, token)
+    assert_equal(Encoding::BINARY, token.encoding)
+  end
+
+  it "next_token: fails on a greater than sign that is not part of a hex string" do
+    create_tokenizer(" >")
+    assert_raises(HexaPDF::MalformedPDFError) { @tokenizer.next_token }
+  end
+
+  it "next_token: fails on a missing greater than sign in a hex string" do
+    create_tokenizer("<ABCD")
+    assert_raises(HexaPDF::MalformedPDFError) { @tokenizer.next_token }
+  end
+
+  it "next_token: fails on unbalanced parentheses in a literal string" do
+    create_tokenizer("(href(test)")
+    assert_raises(HexaPDF::MalformedPDFError) { @tokenizer.next_token }
+  end
+
+  it "next_object: works for all PDF object types, including array and dictionary" do
+    create_tokenizer(<<-EOF.chomp.gsub(/^ {8}/, ''))
+        true false null 123 34.5 (string) <4E6F76> /Name
+        [5 6 /Name] <</Name 5>>
+        EOF
+    assert_equal(true, @tokenizer.next_object)
+    assert_equal(false, @tokenizer.next_object)
+    assert_nil(@tokenizer.next_object)
+    assert_equal(123, @tokenizer.next_object)
+    assert_equal(34.5, @tokenizer.next_object)
+    assert_equal("string".b, @tokenizer.next_object)
+    assert_equal("Nov".b, @tokenizer.next_object)
+    assert_equal(:Name, @tokenizer.next_object)
+    assert_equal([5, 6, :Name], @tokenizer.next_object)
+    assert_equal({Name: 5}, @tokenizer.next_object)
+  end
+
+  it "next_object: allows keywords if the corresponding option is set" do
+    create_tokenizer("name")
+    obj = @tokenizer.next_object(allow_keyword: true)
+    assert_kind_of(HexaPDF::Tokenizer::Token, obj)
+    assert_equal('name', obj)
+  end
+
+  it "next_object: fails if the value is not a correct object" do
+    create_tokenizer("<< /name ] >>")
+    assert_raises(HexaPDF::MalformedPDFError) { @tokenizer.next_object }
+    create_tokenizer("other")
+    assert_raises(HexaPDF::MalformedPDFError) { @tokenizer.next_object }
+    create_tokenizer("<< (string) (key) >>")
+    assert_raises(HexaPDF::MalformedPDFError) { @tokenizer.next_object }
+    create_tokenizer("<< /NoValueForKey >>")
+    assert_raises(HexaPDF::MalformedPDFError) { @tokenizer.next_object }
+  end
+
+  it "returns the correct position on operations" do
+    create_tokenizer("hallo du" + " " * 50000 + "hallo du")
+    @tokenizer.next_token
+    assert_equal(5, @tokenizer.pos)
+
+    @tokenizer.skip_whitespace
+    assert_equal(6, @tokenizer.pos)
+
+    @tokenizer.next_byte
+    assert_equal(7, @tokenizer.pos)
+
+    @tokenizer.peek_token
+    assert_equal(7, @tokenizer.pos)
+
+    @tokenizer.next_token
+    assert_equal(8, @tokenizer.pos)
+
+    @tokenizer.next_token
+    assert_equal(50013, @tokenizer.pos)
+
+    @tokenizer.next_token
+    assert_equal(50016, @tokenizer.pos)
+
+    @tokenizer.next_token
+    assert_equal(50016, @tokenizer.pos)
+  end
+
+  it "returns the next byte" do
+    create_tokenizer('hallo')
+    assert_equal('h'.ord, @tokenizer.next_byte)
+    assert_equal('a'.ord, @tokenizer.next_byte)
+  end
+
+  it "returns the next token but doesn't advance the position on peek_token" do
+    create_tokenizer("hallo du")
+    2.times do
+      assert_equal('hallo', @tokenizer.peek_token)
+      assert_equal(0, @tokenizer.pos)
+    end
+  end
+
+  it "next_xref_entry: works on correct entries" do
+    create_tokenizer("0000000001 00001 n \n0000000001 00032 f \n")
+    assert_equal([1, 1, 'n'], @tokenizer.next_xref_entry)
+    assert_equal([1, 32, 'f'], @tokenizer.next_xref_entry)
+  end
+
+  it "next_xref_entry: fails on invalidly formatted entries" do
+    create_tokenizer("0000000001 00001 g \n")
+    assert_raises(HexaPDF::MalformedPDFError) { @tokenizer.next_xref_entry }
+  end
+end

data/test/hexapdf/content/common.rb

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/content/processor'
+
+module TestHelper
+
+  # Can be used to to record operators parsed from content streams.
+  class OperatorRecorder < HexaPDF::Content::Processor
+
+    undef :paint_xobject
+
+    attr_reader :recorded_ops
+
+    def initialize
+      super
+      operators.clear
+      @recorded_ops = []
+    end
+
+    def respond_to_missing?(*)
+      true
+    end
+
+    def method_missing(msg, *params)
+      @recorded_ops << (params.empty? ? [msg] : [msg, params])
+    end
+
+  end
+
+end

data/test/hexapdf/content/graphic_object/test_arc.rb

@@ -0,0 +1,93 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/document'
+require 'hexapdf/content'
+require 'hexapdf/content/graphic_object'
+
+describe HexaPDF::Content::GraphicObject::Arc do
+  before do
+    @arc = HexaPDF::Content::GraphicObject::Arc.configure(start_angle: -30, end_angle: 30,
+                                                          inclination: 90)
+  end
+
+  describe "initialize" do
+    it "creates a default arc representing the counterclockwise unit circle at the origin" do
+      arc = HexaPDF::Content::GraphicObject::Arc.new
+      assert_equal(0, arc.cx)
+      assert_equal(0, arc.cy)
+      assert_equal(1, arc.a)
+      assert_equal(1, arc.b)
+      assert_equal(0, arc.start_angle)
+      assert_equal(360, arc.end_angle)
+      assert_equal(0, arc.inclination)
+    end
+  end
+
+  it "returns the start and end points" do
+    x, y = @arc.start_point
+    assert_in_delta(0.5, x, 0.00001)
+    assert_in_delta(Math.sin(Math::PI / 3), y, 0.00001)
+
+    x, y = @arc.end_point
+    assert_in_delta(-0.5, x, 0.00001)
+    assert_in_delta(Math.sin(Math::PI / 3), y, 0.00001)
+  end
+
+  describe "point_at" do
+    it "returns an arbitrary point on the arc" do
+      x, y = @arc.point_at(0)
+      assert_in_delta(0, x, 0.00001)
+      assert_in_delta(1, y, 0.00001)
+    end
+  end
+
+  describe "configure" do
+    it "fails if a == 0 or b == 0" do
+      assert_raises(HexaPDF::Error) do
+        HexaPDF::Content::GraphicObject::Arc.configure(a: 0)
+      end
+      assert_raises(HexaPDF::Error) do
+        HexaPDF::Content::GraphicObject::Arc.configure(b: 0)
+      end
+    end
+  end
+
+  describe "curves" do
+    def assert_curve_values(exp, act)
+      assert_in_delta(exp[0], act[0], 0.00001)
+      assert_in_delta(exp[1], act[1], 0.00001)
+      assert_in_delta(exp[2][:p1][0], act[2][:p1][0], 0.00001)
+      assert_in_delta(exp[2][:p1][1], act[2][:p1][1], 0.00001)
+      assert_in_delta(exp[2][:p2][0], act[2][:p2][0], 0.00001)
+      assert_in_delta(exp[2][:p2][1], act[2][:p2][1], 0.00001)
+    end
+
+    it "returns the curves for the arc" do
+      arc = HexaPDF::Content::GraphicObject::Arc.configure(end_angle: 180)
+      arc.max_curves = 4
+      curves = arc.curves
+      assert_equal(2, curves.size)
+      assert_curve_values([0, 1, p1: [1, 0.548584], p2: [0.548584, 1]], curves[0])
+      assert_curve_values([-1, 0, p1: [-0.548584, 1], p2: [-1, 0.548584]], curves[1])
+
+      arc.configure(clockwise: true)
+      curves = arc.curves
+      assert_equal(2, curves.size)
+      assert_curve_values([0, -1, p1: [1, -0.548584], p2: [0.548584, -1]], curves[0])
+      assert_curve_values([-1, 0, p1: [-0.548584, -1], p2: [-1, -0.548584]], curves[1])
+    end
+  end
+
+  describe "draw" do
+    it "draws the arc onto the canvas" do
+      doc = HexaPDF::Document.new
+      page = doc.pages.add_page
+      canvas = page.canvas
+      @arc.max_curves = 4
+      @arc.draw(canvas)
+      assert_equal(doc.config['graphic_object.arc.max_curves'], @arc.max_curves)
+      refute(page.contents.empty?)
+    end
+  end
+end

data/test/hexapdf/content/graphic_object/test_endpoint_arc.rb

@@ -0,0 +1,91 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require 'hexapdf/content/canvas'
+require 'hexapdf/content/graphic_object'
+require 'hexapdf/document'
+
+describe HexaPDF::Content::GraphicObject::EndpointArc do
+  describe "initialize" do
+    it "creates a default arc representing a line from the current point to the origin" do
+      arc = HexaPDF::Content::GraphicObject::EndpointArc.new
+      assert_equal(0, arc.x)
+      assert_equal(0, arc.y)
+      assert_equal(0, arc.a)
+      assert_equal(0, arc.b)
+      assert_equal(0, arc.inclination)
+      assert(arc.large_arc)
+      refute(arc.clockwise)
+    end
+  end
+
+
+  describe "configure" do
+    it "changes the values" do
+      arc = HexaPDF::Content::GraphicObject::EndpointArc.new
+      arc.configure(x: 1, y: 2, a: 3, b: 4, inclination: 5, large_arc: false, clockwise: true)
+      assert_equal(1, arc.x)
+      assert_equal(2, arc.y)
+      assert_equal(3, arc.a)
+      assert_equal(4, arc.b)
+      assert_equal(5, arc.inclination)
+      refute(arc.large_arc)
+      assert(arc.clockwise)
+    end
+  end
+
+  describe "draw" do
+    before do
+      @doc = HexaPDF::Document.new
+      @page = @doc.pages.add_page
+    end
+
+    it "draws nothing if the endpoint is the same as the current point" do
+      canvas = @page.canvas
+      canvas.move_to(50, 50)
+      canvas.draw(:endpoint_arc, x: 50, y: 50, a: 50, b: 25)
+      assert_equal("50 50 m\n", canvas.contents)
+    end
+
+    it "draws only a straight line if either one of the semi-axis is zero" do
+      canvas = @page.canvas
+      canvas.move_to(50, 50)
+      canvas.draw(:endpoint_arc, x: 100, y: 50, a: 0, b: 25)
+      assert_equal("50 50 m\n100 50 l\n", canvas.contents)
+    end
+
+    it "draws the arc onto the canvas" do
+      {
+        [false, false] => {cx: 100, cy: 50, start_angle: 180, end_angle: 270, clockwise: false},
+        [false, true] => {cx: 50, cy: 25, start_angle: 90, end_angle: 0, clockwise: true},
+        [true, false] => {cx: 50, cy: 25, start_angle: 90, end_angle: 360, clockwise: false},
+        [true, true] => {cx: 100, cy: 50, start_angle: 180, end_angle: -90, clockwise: true},
+      }.each do |(large_arc, clockwise), data|
+        @page.delete(:Contents)
+        canvas = @page.canvas
+        canvas.draw(:arc, a: 50, b: 25, inclination: 0, **data)
+        arc_data = @page.contents
+
+        canvas.contents.clear
+        assert(@page.contents.empty?)
+        canvas.move_to(50.0, 50.0)
+        canvas.draw(:endpoint_arc, x: 100, y: 25, a: 50, b: 25, inclination: 0,
+                    large_arc: large_arc, clockwise: clockwise)
+        assert_equal(arc_data, @page.contents)
+      end
+    end
+
+    it "draws the correct arc even if it is inclined" do
+      canvas = @page.canvas
+      canvas.draw(:arc, cx: 25, cy: 0, a: 50, b: 25, start_angle: 90, end_angle: 270,
+                  inclination: 90, clockwise: false)
+      arc_data = @page.contents
+
+      canvas.contents.clear
+      canvas.move_to(0.0, 1e-15)
+      canvas.draw(:endpoint_arc, x: 50, y: 0, a: 20, b: 10, inclination: 90, large_arc: false,
+                  clockwise: false)
+      assert_equal(arc_data, @page.contents)
+    end
+  end
+end

data/test/hexapdf/content/graphic_object/test_solid_arc.rb

@@ -0,0 +1,86 @@
+# -*- encoding: utf-8 -*-
+
+require 'test_helper'
+require_relative '../common'
+require 'hexapdf/document'
+require 'hexapdf/content'
+require 'hexapdf/content/graphic_object'
+
+describe HexaPDF::Content::GraphicObject::SolidArc do
+  describe "initialize" do
+    it "creates a default solid arc representing the disk at the origin" do
+      arc = HexaPDF::Content::GraphicObject::SolidArc.configure
+      assert_equal(0, arc.cx)
+      assert_equal(0, arc.cy)
+      assert_equal(0, arc.inner_a)
+      assert_equal(0, arc.inner_b)
+      assert_equal(1, arc.outer_a)
+      assert_equal(1, arc.outer_b)
+      assert_equal(0, arc.start_angle)
+      assert_equal(0, arc.end_angle)
+      assert_equal(0, arc.inclination)
+    end
+  end
+
+  describe "configure" do
+    it "changes the values" do
+      arc = HexaPDF::Content::GraphicObject::SolidArc.new
+      arc.configure(cx: 1, cy: 2, inner_a: 3, inner_b: 4, outer_a: 5, outer_b: 6,
+                    start_angle: 7, end_angle: 8, inclination: 9)
+      assert_equal(1, arc.cx)
+      assert_equal(2, arc.cy)
+      assert_equal(3, arc.inner_a)
+      assert_equal(4, arc.inner_b)
+      assert_equal(5, arc.outer_a)
+      assert_equal(6, arc.outer_b)
+      assert_equal(7, arc.start_angle)
+      assert_equal(8, arc.end_angle)
+      assert_equal(9, arc.inclination)
+    end
+  end
+
+  describe "draw" do
+    def operators(content)
+      processor = TestHelper::OperatorRecorder.new
+      parser = HexaPDF::Content::Parser.new
+      parser.parse(content, processor)
+      processor.recorded_ops
+    end
+
+    before do
+      @doc = HexaPDF::Document.new
+      @doc.config['graphic_object.arc.max_curves'] = 4
+      @page = @doc.pages.add_page
+      @canvas = @page.canvas
+    end
+
+    it "draws a disk" do
+      @canvas.draw(:solid_arc)
+      ops = operators(@canvas.contents)
+      assert_equal([:move_to, :curve_to, :curve_to, :curve_to, :curve_to, :close_subpath],
+                   ops.map(&:first))
+    end
+
+    it "draws a sector" do
+      @canvas.draw(:solid_arc, end_angle: 90)
+      ops = operators(@canvas.contents)
+      assert_equal([:move_to, :line_to, :curve_to, :close_subpath],
+                   ops.map(&:first))
+    end
+
+    it "draws an annulus" do
+      @canvas.draw(:solid_arc, inner_a: 5, inner_b: 5)
+      ops = operators(@canvas.contents)
+      assert_equal([:move_to, :curve_to, :curve_to, :curve_to, :curve_to, :close_subpath,
+                    :move_to, :curve_to, :curve_to, :curve_to, :curve_to, :close_subpath],
+                   ops.map(&:first))
+    end
+
+    it "draws an annular sector" do
+      @canvas.draw(:solid_arc, inner_a: 5, inner_b: 5, end_angle: 90)
+      ops = operators(@canvas.contents)
+      assert_equal([:move_to, :curve_to, :line_to, :curve_to, :close_subpath],
+                   ops.map(&:first))
+    end
+  end
+end