cairo 1.17.5 → 1.17.8

data/test/test_font_face.rb

@@ -119,6 +119,13 @@ class FontFaceTest < Test::Unit::TestCase
       render_glyph_args << args
     end
 
+    render_color_glyph_args = []
+    if face.respond_to?(:on_render_color_glyph)
+      face.on_render_color_glyph do |*args|
+        render_color_glyph_args << args
+      end
+    end
+
     text_to_glyphs_args = []
     face.on_text_to_glyphs do |*args|
       text_to_glyphs_args << args
@@ -137,36 +144,56 @@ class FontFaceTest < Test::Unit::TestCase
                                         Cairo::Matrix.identity,
                                         Cairo::Matrix.identity,
                                         Cairo::FontOptions.new)
-    result = scaled_font.text_to_glyphs(0, 0, "text")
-    assert_equal([[[Cairo::ScaledFont, Cairo::Context, Cairo::FontExtents]],
-                  [[Cairo::ScaledFont, codepoint("t"),
-                    Cairo::Context, Cairo::TextExtents],
-                   [Cairo::ScaledFont, codepoint("e"),
-                    Cairo::Context, Cairo::TextExtents],
-                   [Cairo::ScaledFont, codepoint("x"),
-                    Cairo::Context, Cairo::TextExtents]],
-                  [[Cairo::ScaledFont, "text",
-                    Cairo::UserFontFace::TextToGlyphsData]],
-                  [[Cairo::ScaledFont, codepoint("t")],
-                   [Cairo::ScaledFont, codepoint("e")],
-                   [Cairo::ScaledFont, codepoint("x")],
-                   [Cairo::ScaledFont, codepoint("t")]],
-                  [[], [], Cairo::TextClusterFlag::BACKWARD]],
-                 [classify_cairo_object(init_args),
-                  classify_cairo_object(render_glyph_args),
-                  classify_cairo_object(text_to_glyphs_args),
-                  classify_cairo_object(unicode_to_glyph_args),
-                  result])
+    result = scaled_font.text_to_glyphs(0, 0, "abc")
+    expected = {
+      init_args: [
+        [Cairo::ScaledFont, Cairo::Context, Cairo::FontExtents],
+      ],
+      render_glyph_args: [
+        [Cairo::ScaledFont, codepoint("a"), Cairo::Context, Cairo::TextExtents],
+        [Cairo::ScaledFont, codepoint("b"), Cairo::Context, Cairo::TextExtents],
+        [Cairo::ScaledFont, codepoint("c"), Cairo::Context, Cairo::TextExtents],
+      ],
+      render_color_glyph_args: [],
+      text_to_glyphs_args: [
+        [Cairo::ScaledFont, "abc", Cairo::UserFontFace::TextToGlyphsData],
+      ],
+      unicode_to_glyph_args: [
+        [Cairo::ScaledFont, codepoint("a")],
+        [Cairo::ScaledFont, codepoint("b")],
+        [Cairo::ScaledFont, codepoint("c")],
+      ],
+      result: [[], [], Cairo::TextClusterFlag::BACKWARD],
+    }
+    actual = {
+      init_args: classify_cairo_object(init_args),
+      render_glyph_args: classify_cairo_object(render_glyph_args),
+      render_color_glyph_args: classify_cairo_object(render_color_glyph_args),
+      text_to_glyphs_args: classify_cairo_object(text_to_glyphs_args),
+      unicode_to_glyph_args: classify_cairo_object(unicode_to_glyph_args),
+      result: result,
+    }
+    if Cairo.satisfied_version?(1, 17, 6)
+      expected[:render_glyph_args],
+        expected[:render_color_glyph_args] =
+          expected[:render_color_glyph_args],
+            expected[:render_glyph_args]
+    end
+    assert_equal(expected, actual)
   end
 
   if Cairo.satisfied_version?(1, 7, 2)
     class CustomUserFontFace < Cairo::UserFontFace
-      attr_reader :init_args, :render_glyph_args
-      attr_reader :text_to_glyphs_args, :unicode_to_glyph_args
+      attr_reader :init_args
+      attr_reader :render_glyph_args
+      attr_reader :render_color_glyph_args
+      attr_reader :text_to_glyphs_args
+      attr_reader :unicode_to_glyph_args
       def initialize
         super
         @init_args = []
         @render_glyph_args = []
+        @render_color_glyph_args = []
         @text_to_glyphs_args = []
         @unicode_to_glyph_args = []
       end
@@ -179,6 +206,10 @@ class FontFaceTest < Test::Unit::TestCase
         @render_glyph_args << args
       end
 
+      def render_color_glyph(*args)
+        @render_color_glyph_args << args
+      end
+
       def text_to_glyphs(*args)
         @text_to_glyphs_args << args
         scaled_font, utf8, data = args
@@ -202,26 +233,54 @@ class FontFaceTest < Test::Unit::TestCase
                                         Cairo::Matrix.identity,
                                         Cairo::Matrix.identity,
                                         Cairo::FontOptions.new)
-    result = scaled_font.text_to_glyphs(0, 0, "text")
-    assert_equal([[[Cairo::ScaledFont, Cairo::Context, Cairo::FontExtents]],
-                  [[Cairo::ScaledFont, codepoint("t"),
-                    Cairo::Context, Cairo::TextExtents],
-                   [Cairo::ScaledFont, codepoint("e"),
-                    Cairo::Context, Cairo::TextExtents],
-                   [Cairo::ScaledFont, codepoint("x"),
-                    Cairo::Context, Cairo::TextExtents]],
-                  [[Cairo::ScaledFont, "text",
-                    Cairo::UserFontFace::TextToGlyphsData]],
-                  [[Cairo::ScaledFont, codepoint("t")],
-                   [Cairo::ScaledFont, codepoint("e")],
-                   [Cairo::ScaledFont, codepoint("x")],
-                   [Cairo::ScaledFont, codepoint("t")]],
-                  [[], [], Cairo::TextClusterFlag::BACKWARD]],
-                 [classify_cairo_object(face.init_args),
-                  classify_cairo_object(face.render_glyph_args),
-                  classify_cairo_object(face.text_to_glyphs_args),
-                  classify_cairo_object(face.unicode_to_glyph_args),
-                  result])
+    result = scaled_font.text_to_glyphs(0, 0, "abc")
+    expected = {
+      init_args: [
+        [Cairo::ScaledFont, Cairo::Context, Cairo::FontExtents]
+      ],
+      text_to_glyphs_args: [
+        [Cairo::ScaledFont, "abc", Cairo::UserFontFace::TextToGlyphsData],
+      ],
+      unicode_to_glyph_args: [
+        [Cairo::ScaledFont, codepoint("a")],
+        [Cairo::ScaledFont, codepoint("b")],
+        [Cairo::ScaledFont, codepoint("c")],
+      ],
+      result: [
+        [],
+        [],
+        Cairo::TextClusterFlag::BACKWARD,
+      ],
+    }
+    actual = {
+      init_args: classify_cairo_object(face.init_args),
+      text_to_glyphs_args:
+        classify_cairo_object(face.text_to_glyphs_args),
+      unicode_to_glyph_args:
+        classify_cairo_object(face.unicode_to_glyph_args),
+      result: result,
+    }
+    if Cairo.satisfied_version?(1, 17, 6)
+      expected[:render_color_glyph_args] = [
+        [Cairo::ScaledFont, codepoint("a"), Cairo::Context, Cairo::TextExtents],
+        [Cairo::ScaledFont, codepoint("b"), Cairo::Context, Cairo::TextExtents],
+        [Cairo::ScaledFont, codepoint("c"), Cairo::Context, Cairo::TextExtents],
+      ]
+      actual[:render_color_glyph_args] =
+        classify_cairo_object(face.render_color_glyph_args)
+      expected[:render_glyph_args] = []
+      actual[:render_glyph_args] =
+        classify_cairo_object(face.render_glyph_args)
+    else
+      expected[:render_glyph_args] = [
+        [Cairo::ScaledFont, codepoint("a"), Cairo::Context, Cairo::TextExtents],
+        [Cairo::ScaledFont, codepoint("b"), Cairo::Context, Cairo::TextExtents],
+        [Cairo::ScaledFont, codepoint("c"), Cairo::Context, Cairo::TextExtents],
+      ]
+      actual[:render_glyph_args] =
+        classify_cairo_object(face.render_glyph_args)
+    end
+    assert_equal(expected, actual)
   end
 
   def test_user_font_face_class_and_callback
@@ -239,6 +298,13 @@ class FontFaceTest < Test::Unit::TestCase
       render_glyph_args << args
     end
 
+    render_color_glyph_args = []
+    if face.respond_to?(:on_render_color_glyph)
+      face.on_render_color_glyph do |*args|
+        render_color_glyph_args << args
+      end
+    end
+
     text_to_glyphs_args = []
     face.on_text_to_glyphs do |*args|
       text_to_glyphs_args << args
@@ -257,34 +323,63 @@ class FontFaceTest < Test::Unit::TestCase
                                         Cairo::Matrix.identity,
                                         Cairo::Matrix.identity,
                                         Cairo::FontOptions.new)
-    result = scaled_font.text_to_glyphs(0, 0, "text")
-    assert_equal([[[Cairo::ScaledFont, Cairo::Context, Cairo::FontExtents]],
-                  [[Cairo::ScaledFont, codepoint("t"),
-                    Cairo::Context, Cairo::TextExtents],
-                   [Cairo::ScaledFont, codepoint("e"),
-                    Cairo::Context, Cairo::TextExtents],
-                   [Cairo::ScaledFont, codepoint("x"),
-                    Cairo::Context, Cairo::TextExtents]],
-                  [[Cairo::ScaledFont, "text",
-                    Cairo::UserFontFace::TextToGlyphsData]],
-                  [[Cairo::ScaledFont, codepoint("t")],
-                   [Cairo::ScaledFont, codepoint("e")],
-                   [Cairo::ScaledFont, codepoint("x")],
-                   [Cairo::ScaledFont, codepoint("t")]],
-                  [],
-                  [],
-                  [],
-                  [],
-                  [[], [], Cairo::TextClusterFlag::BACKWARD]],
-                 [classify_cairo_object(init_args),
-                  classify_cairo_object(render_glyph_args),
-                  classify_cairo_object(text_to_glyphs_args),
-                  classify_cairo_object(unicode_to_glyph_args),
-                  classify_cairo_object(face.init_args),
-                  classify_cairo_object(face.render_glyph_args),
-                  classify_cairo_object(face.text_to_glyphs_args),
-                  classify_cairo_object(face.unicode_to_glyph_args),
-                  result])
+    result = scaled_font.text_to_glyphs(0, 0, "abc")
+    expected = {
+      callback_init_args: [
+        [
+          Cairo::ScaledFont, Cairo::Context, Cairo::FontExtents,
+        ],
+      ],
+      callback_render_glyph_args: [
+        [Cairo::ScaledFont, codepoint("a"), Cairo::Context, Cairo::TextExtents],
+        [Cairo::ScaledFont, codepoint("b"), Cairo::Context, Cairo::TextExtents],
+        [Cairo::ScaledFont, codepoint("c"), Cairo::Context, Cairo::TextExtents],
+      ],
+      callback_render_color_glyph_args: [],
+      callback_text_to_glyphs_args: [
+        [Cairo::ScaledFont, "abc", Cairo::UserFontFace::TextToGlyphsData],
+      ],
+      callback_unicode_to_glyph_args: [
+        [Cairo::ScaledFont, codepoint("a")],
+        [Cairo::ScaledFont, codepoint("b")],
+        [Cairo::ScaledFont, codepoint("c")],
+      ],
+      object_init_args: [],
+      object_render_glyph_args: [],
+      object_render_color_glyph_args: [],
+      object_text_to_glyphs_args: [],
+      object_unicode_to_glyph_args: [],
+      result: [[], [], Cairo::TextClusterFlag::BACKWARD],
+    }
+    actual = {
+      callback_init_args: classify_cairo_object(init_args),
+      callback_render_glyph_args:
+        classify_cairo_object(render_glyph_args),
+      callback_render_color_glyph_args:
+        classify_cairo_object(render_color_glyph_args),
+      callback_text_to_glyphs_args:
+        classify_cairo_object(text_to_glyphs_args),
+      callback_unicode_to_glyph_args:
+        classify_cairo_object(unicode_to_glyph_args),
+      object_init_args:
+        classify_cairo_object(face.init_args),
+      object_render_glyph_args:
+        classify_cairo_object(face.render_glyph_args),
+      object_render_color_glyph_args:
+        classify_cairo_object(face.render_color_glyph_args),
+      object_text_to_glyphs_args:
+        classify_cairo_object(face.text_to_glyphs_args),
+      object_unicode_to_glyph_args:
+        classify_cairo_object(face.unicode_to_glyph_args),
+      result: result,
+    }
+    if Cairo.satisfied_version?(1, 17, 6)
+      expected[:callback_render_glyph_args],
+        expected[:callback_render_color_glyph_args] =
+          expected[:callback_render_color_glyph_args],
+            expected[:callback_render_glyph_args]
+    end
+    assert_equal(expected, actual)
   end
 
   def classify_cairo_object(object)

data/test/test_quartz_image_surface.rb

@@ -6,8 +6,10 @@ class QuartzImageSurfaceTest < Test::Unit::TestCase
   end
 
   def test_quartz_image_surface
-    surface = Cairo::ImageSurface.new(100, 100)
-    quartz_surface = Cairo::QuartzImageSurface.new(surface)
-    assert_kind_of(Cairo::QuartzImageSurface, quartz_surface)
+    Cairo::ImageSurface.create(100, 100) do |surface|
+      Cairo::QuartzImageSurface.create(surface) do |quartz_surface|
+        assert_kind_of(Cairo::QuartzImageSurface, quartz_surface)
+      end
+    end
   end
 end

data/test/test_svg_surface.rb

@@ -10,7 +10,11 @@ class SVGSurfaceTest < Test::Unit::TestCase
     only_cairo_version(1, 15, 10)
     output = StringIO.new
     surface = Cairo::SVGSurface.new(output, 10, 20)
-    assert_equal(Cairo::SVGUnit::PT, surface.document_unit)
+    if Cairo.satisfied_version?(1, 17, 6)
+      assert_equal(Cairo::SVGUnit::USER, surface.document_unit)
+    else
+      assert_equal(Cairo::SVGUnit::PT, surface.document_unit)
+    end
     surface.document_unit = Cairo::SVGUnit::CM
     assert_equal(Cairo::SVGUnit::CM, surface.document_unit)
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cairo
 version: !ruby/object:Gem::Version
-  version: 1.17.5
+  version: 1.17.8
 platform: ruby
 authors:
 - Kouhei Sutou
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-02-04 00:00:00.000000000 Z
+date: 2022-09-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: native-package-installer
@@ -219,7 +219,7 @@ metadata:
   mailing_list_uri: https://cairographics.org/cgi-bin/mailman/listinfo/cairo
   source_code_uri: https://github.com/rcairo/rcairo
   msys2_mingw_dependencies: cairo
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -235,8 +235,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements:
 - cairo >= 1.2.0
-rubygems_version: 3.3.0.dev
-signing_key: 
+rubygems_version: 3.4.0.dev
+signing_key:
 specification_version: 4
 summary: Ruby bindings for cairo
 test_files: