hexapdf 0.15.8 → 0.17.1

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

@@ -1,90 +0,0 @@
-# -*- 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
-    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_geom2d.rb

@@ -1,79 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-require 'test_helper'
-require_relative '../common'
-require 'hexapdf/document'
-require 'hexapdf/content'
-require 'hexapdf/content/graphic_object'
-
-describe HexaPDF::Content::GraphicObject::Geom2D do
-  before do
-    @obj = HexaPDF::Content::GraphicObject::Geom2D.new
-  end
-
-  it "allows creation via the ::configure method" do
-    obj = HexaPDF::Content::GraphicObject::Geom2D.configure(object: Geom2D::Point(5, 5))
-    assert_equal(Geom2D::Point(5, 5), obj.object)
-  end
-
-  it "creates a default Geom2D drawing support object" do
-    obj = HexaPDF::Content::GraphicObject::Geom2D.new
-    assert_nil(obj.object)
-    assert_equal(1, obj.point_radius)
-    assert_equal(false, obj.path_only)
-  end
-
-  it "allows configuration of the object" do
-    @obj.configure(object: Geom2D::Point(5, 5), point_radius: 3, path_only: true)
-    assert_equal(Geom2D::Point(5, 5), @obj.object)
-    assert_equal(3, @obj.point_radius)
-    assert_equal(true, @obj.path_only)
-  end
-
-  describe "draw" do
-    before do
-      doc = HexaPDF::Document.new
-      @canvas = doc.pages.add.canvas
-    end
-
-    it "draws a Geom2D::Point onto the canvas" do
-      @obj.object = Geom2D::Point(5, 5)
-      @obj.draw(@canvas)
-      assert_operators(@canvas.contents,
-                       [:move_to, :curve_to, :curve_to, :curve_to, :curve_to, :curve_to, :curve_to,
-                        :close_subpath, :fill_path_non_zero],
-                       only_names: true)
-    end
-
-    it "draws a Geom2D::Segment onto the canvas" do
-      @obj.object = Geom2D::Segment([5, 6], [10, 11])
-      @obj.draw(@canvas)
-      assert_operators(@canvas.contents,
-                       [[:move_to, [5, 6]], [:line_to, [10, 11]], [:stroke_path]])
-    end
-
-    it "draws a Geom2D::Polygon onto the canvas" do
-      @obj.object = Geom2D::Polygon([5, 6], [10, 11], [7, 9])
-      @obj.draw(@canvas)
-      assert_operators(@canvas.contents,
-                       [[:move_to, [5, 6]], [:line_to, [10, 11]], [:line_to, [7, 9]],
-                        [:stroke_path]])
-    end
-
-    it "draws a Geom2D::PolygonSet onto the canvas" do
-      @obj.object = Geom2D::PolygonSet(Geom2D::Polygon([5, 6], [10, 11], [7, 9]),
-                                       Geom2D::Polygon([0, 0], [4, 0], [2, 3]))
-      @obj.draw(@canvas)
-      assert_operators(@canvas.contents,
-                       [[:move_to, [5, 6]], [:line_to, [10, 11]], [:line_to, [7, 9]],
-                        [:close_subpath],
-                        [:move_to, [0, 0]], [:line_to, [4, 0]], [:line_to, [2, 3]],
-                        [:close_subpath], [:stroke_path]])
-    end
-
-    it "fails for unkown classes" do
-      @obj.object = 5
-      assert_raises(HexaPDF::Error) { @obj.draw(@canvas) }
-    end
-  end
-end

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

@@ -1,86 +0,0 @@
-# -*- 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
-      @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