rmagick 7.1.5 → 7.1.7

data/ext/RMagick/rmkinfo.cpp

@@ -82,14 +82,28 @@ KernelInfo_alloc(VALUE klass)
 /**
  * KernelInfo object constructor
  *
+ * - Calling it again on an initialized object replaces its kernel and destroys the old one.
+ * - A kernel string whose first non-blank character is '@' is rejected: ImageMagick would read the
+ *   kernel from the file it names. A string that contains a %[fx:@...], %[hex:@...] or
+ *   %[pixel:@...] escape is rejected as well, by the same check as the other options that name files.
+ *
  * @param kernel_string [String] kernel info string representation to be parsed
  * @return [Magick::KernelInfo] self
+ * @raise [FrozenError] if the object is frozen
+ * @raise [ArgumentError] if the kernel string names a file with '@'
  */
 VALUE
 KernelInfo_initialize(VALUE self, VALUE kernel_string)
 {
-    KernelInfo *kernel;
-    char *string = StringValueCStr(kernel_string);
+    KernelInfo *kernel, *old_kernel;
+    char *string;
+
+    rb_check_frozen(self);
+    string = StringValueCStr(kernel_string);
+    if (rm_has_file_reference(string))
+    {
+        rb_raise(rb_eArgError, "the kernel must not name a file with '@'");
+    }
 
 #if defined(IMAGEMAGICK_7)
     ExceptionInfo *exception;
@@ -113,7 +127,12 @@ KernelInfo_initialize(VALUE self, VALUE kernel_string)
         rb_raise(rb_eRuntimeError, "failed to parse kernel string");
     }
 
+    old_kernel = (KernelInfo *)DATA_PTR(self);
     DATA_PTR(self) = kernel;
+    if (old_kernel)
+    {
+        DestroyKernelInfo(old_kernel);
+    }
 
     return self;
 }
@@ -145,6 +164,24 @@ get_kernel_info(VALUE self)
 }
 
 
+/**
+ * Return the KernelInfo struct of an object that is about to be changed,
+ * raising FrozenError if the object is frozen.
+ *
+ * No Ruby usage (internal function)
+ *
+ * @param self the KernelInfo object
+ * @return the KernelInfo struct
+ * @throw FrozenError if the object is frozen
+ */
+static KernelInfo *
+get_unfrozen_kernel_info(VALUE self)
+{
+    rb_check_frozen(self);
+    return get_kernel_info(self);
+}
+
+
 /**
  * Adds a given amount of the 'Unity' Convolution Kernel to the given pre-scaled and normalized Kernel.
  *
@@ -153,7 +190,7 @@ get_kernel_info(VALUE self)
 VALUE
 KernelInfo_unity_add(VALUE self, VALUE scale)
 {
-    GVL_STRUCT_TYPE(UnityAddKernelInfo) args = { get_kernel_info(self), NUM2DBL(scale) };
+    GVL_STRUCT_TYPE(UnityAddKernelInfo) args = { get_unfrozen_kernel_info(self), NUM2DBL(scale) };
     CALL_FUNC_WITHOUT_GVL(GVL_FUNC(UnityAddKernelInfo), &args);
     return Qnil;
 }
@@ -164,8 +201,10 @@ KernelInfo_unity_add(VALUE self, VALUE scale)
  * of the sum of the kernel values (as per given flags).
  *
  * @param scale [Numeric] scale to use
- * @param flags [Magick::GeometryFlags] one of Magick::NormalizeValue, Magick::CorrelateNormalizeValue,
- *   and/or Magick::PercentValue
+ * @param flags [Magick::GeometryFlags] Magick::NoValue, Magick::NormalizeValue or
+ *   Magick::CorrelateNormalizeValue. ScaleKernelInfo ignores the other values, including
+ *   Magick::PercentValue; use {KernelInfo#scale_geometry} for a percentage.
+ * @return [nil]
  */
 VALUE
 KernelInfo_scale(VALUE self, VALUE scale, VALUE flags)
@@ -174,7 +213,7 @@ KernelInfo_scale(VALUE self, VALUE scale, VALUE flags)
 
     VALUE_TO_ENUM(flags, geoflags, GeometryFlags);
 
-    GVL_STRUCT_TYPE(ScaleKernelInfo) args = { get_kernel_info(self), NUM2DBL(scale), geoflags };
+    GVL_STRUCT_TYPE(ScaleKernelInfo) args = { get_unfrozen_kernel_info(self), NUM2DBL(scale), geoflags };
     CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ScaleKernelInfo), &args);
     return Qnil;
 }
@@ -190,7 +229,7 @@ KernelInfo_scale_geometry(VALUE self, VALUE geometry)
 {
     char *geom = StringValueCStr(geometry);
 
-    GVL_STRUCT_TYPE(ScaleGeometryKernelInfo) args = { get_kernel_info(self), geom };
+    GVL_STRUCT_TYPE(ScaleGeometryKernelInfo) args = { get_unfrozen_kernel_info(self), geom };
     CALL_FUNC_WITHOUT_GVL(GVL_FUNC(ScaleGeometryKernelInfo), &args);
 
     RB_GC_GUARD(geometry);
@@ -199,19 +238,32 @@ KernelInfo_scale_geometry(VALUE self, VALUE geometry)
 }
 
 /**
- * Creates a new clone of the object so that it can be modified without affecting the original.
+ * Initialize a copy made by clone or dup with a copy of the kernel of the original.
  *
- * @return [Magick::KernelInfo] new KernelInfo object
+ * @param orig the original object
+ * @return [Magick::KernelInfo] self
+ * @raise [FrozenError] if the object is frozen
  */
 VALUE
-KernelInfo_clone(VALUE self)
+KernelInfo_init_copy(VALUE self, VALUE orig)
 {
-    KernelInfo *kernel = CloneKernelInfo(get_kernel_info(self));
+    KernelInfo *kernel, *old_kernel;
+
+    rb_check_frozen(self);
+    kernel = CloneKernelInfo(get_kernel_info(orig));
     if (!kernel)
     {
         rb_raise(rb_eNoMemError, "not enough memory to continue");
     }
-    return TypedData_Wrap_Struct(Class_KernelInfo, &rm_kernel_info_data_type, kernel);
+
+    old_kernel = (KernelInfo *)DATA_PTR(self);
+    DATA_PTR(self) = kernel;
+    if (old_kernel)
+    {
+        DestroyKernelInfo(old_kernel);
+    }
+
+    return self;
 }
 
 /**
@@ -219,6 +271,9 @@ KernelInfo_clone(VALUE self)
  * kernels used for special purposes such as gaussian blurring, skeleton
  * pruning, and edge distance determination.
  *
+ * - The kernel is parsed from "name:geometry" as KernelInfo.new does, so the
+ *   arguments that are left out get ImageMagick's defaults.
+ *
  * @param what [Magick::KernelInfoType] kernel one of Magick::KernelInfoType enums
  * @param geometry [String] geometry to pass to default kernel
  * @return [Magick::KernelInfo] a new KernelInfo object
@@ -229,21 +284,32 @@ KernelInfo_builtin(VALUE self, VALUE what, VALUE geometry)
     KernelInfo *kernel;
     KernelInfoType kernel_type;
     GeometryInfo info;
-    const char *geom_str;
+    const char *geom_str, *name;
+    char kernel_string[MaxTextExtent];
+    int length;
 #if defined(IMAGEMAGICK_7)
     ExceptionInfo *exception;
 #endif
 
     VALUE_TO_ENUM(what, kernel_type, KernelInfoType);
     geom_str = StringValueCStr(geometry);
-    if (ParseGeometry(geom_str, &info) == NoValue && *geom_str)
+    // AcquireKernelInfo() reads a list of kernels separated by ';'. ParseGeometry() rejects such a
+    // string today, but builtin makes one built-in kernel, so reject ';' explicitly as well.
+    if ((ParseGeometry(geom_str, &info) == NoValue && *geom_str) || strchr(geom_str, ';'))
     {
         rb_raise(rb_eArgError, "invalid geometry string");
     }
 
+    name = CommandOptionToMnemonic(MagickKernelOptions, kernel_type);
+    length = snprintf(kernel_string, sizeof(kernel_string), "%s:%s", name, geom_str);
+    if (length < 0 || (size_t)length >= sizeof(kernel_string))
+    {
+        rb_raise(rb_eArgError, "geometry string too long");
+    }
+
 #if defined(IMAGEMAGICK_7)
     exception = AcquireExceptionInfo();
-    kernel = AcquireKernelBuiltIn(kernel_type, &info, exception);
+    kernel = AcquireKernelInfo(kernel_string, exception);
     if (rm_should_raise_exception(exception, DestroyExceptionRetention))
     {
         if (kernel != (KernelInfo *) NULL)
@@ -253,9 +319,11 @@ KernelInfo_builtin(VALUE self, VALUE what, VALUE geometry)
         rm_raise_exception(exception);
     }
 #else
-    kernel = AcquireKernelBuiltIn(kernel_type, &info);
+    kernel = AcquireKernelInfo(kernel_string);
 #endif
 
+    RB_GC_GUARD(geometry);
+
     if (!kernel)
     {
         rb_raise(rb_eRuntimeError, "failed to acquire builtin kernel");

data/ext/RMagick/rmmain.cpp

@@ -267,6 +267,7 @@ Init_RMagick2(void)
     rb_define_module_function(Module_Magick, "fonts", RUBY_METHOD_FUNC(Magick_fonts), 0);
     rb_define_module_function(Module_Magick, "init_formats", RUBY_METHOD_FUNC(Magick_init_formats), 0);
     rb_define_module_function(Module_Magick, "limit_resource", RUBY_METHOD_FUNC(Magick_limit_resource), -1);
+    rb_define_module_function(Module_Magick, "resource_usage", RUBY_METHOD_FUNC(Magick_resource_usage), 1);
     rb_define_module_function(Module_Magick, "set_cache_threshold", RUBY_METHOD_FUNC(Magick_set_cache_threshold), 1);
     rb_define_module_function(Module_Magick, "set_log_event_mask", RUBY_METHOD_FUNC(Magick_set_log_event_mask), -1);
     rb_define_module_function(Module_Magick, "set_log_format", RUBY_METHOD_FUNC(Magick_set_log_format), 1);
@@ -436,7 +437,6 @@ Init_RMagick2(void)
     rb_define_method(Class_Image, "charcoal", RUBY_METHOD_FUNC(Image_charcoal), -1);
     rb_define_method(Class_Image, "chop", RUBY_METHOD_FUNC(Image_chop), 4);
     rb_define_method(Class_Image, "clut_channel", RUBY_METHOD_FUNC(Image_clut_channel), -1);
-    rb_define_method(Class_Image, "clone", RUBY_METHOD_FUNC(Image_clone), 0);
     rb_define_method(Class_Image, "color_flood_fill", RUBY_METHOD_FUNC(Image_color_flood_fill), 5);
     rb_define_method(Class_Image, "color_histogram", RUBY_METHOD_FUNC(Image_color_histogram), 0);
     rb_define_method(Class_Image, "colorize", RUBY_METHOD_FUNC(Image_colorize), -1);
@@ -476,7 +476,6 @@ Init_RMagick2(void)
     rb_define_method(Class_Image, "distort", RUBY_METHOD_FUNC(Image_distort), -1);
     rb_define_method(Class_Image, "distortion_channel", RUBY_METHOD_FUNC(Image_distortion_channel), -1);
     rb_define_method(Class_Image, "_dump", RUBY_METHOD_FUNC(Image__dump), 1);
-    rb_define_method(Class_Image, "dup", RUBY_METHOD_FUNC(Image_dup), 0);
     rb_define_method(Class_Image, "each_profile", RUBY_METHOD_FUNC(Image_each_profile), 0);
     rb_define_method(Class_Image, "edge", RUBY_METHOD_FUNC(Image_edge), -1);
     rb_define_method(Class_Image, "emboss", RUBY_METHOD_FUNC(Image_emboss), -1);
@@ -678,10 +677,8 @@ Init_RMagick2(void)
     rb_include_module(Class_Draw, Module_DrawAttribute);
 
     rb_define_method(Class_Draw, "annotate", RUBY_METHOD_FUNC(Draw_annotate), 6);
-    rb_define_method(Class_Draw, "clone", RUBY_METHOD_FUNC(Draw_clone), 0);
     rb_define_method(Class_Draw, "composite", RUBY_METHOD_FUNC(Draw_composite), -1);
     rb_define_method(Class_Draw, "draw", RUBY_METHOD_FUNC(Draw_draw), 1);
-    rb_define_method(Class_Draw, "dup", RUBY_METHOD_FUNC(Draw_dup), 0);
     rb_define_method(Class_Draw, "get_type_metrics", RUBY_METHOD_FUNC(Draw_get_type_metrics), -1);
     rb_define_method(Class_Draw, "get_multiline_type_metrics", RUBY_METHOD_FUNC(Draw_get_multiline_type_metrics), -1);
     rb_define_method(Class_Draw, "initialize", RUBY_METHOD_FUNC(Draw_initialize), 0);
@@ -747,8 +744,6 @@ Init_RMagick2(void)
     rb_define_method(Class_Pixel, "eql?", RUBY_METHOD_FUNC(Pixel_eql_q), 1);
     rb_define_method(Class_Pixel, "initialize", RUBY_METHOD_FUNC(Pixel_initialize), -1);
     rb_define_method(Class_Pixel, "initialize_copy", RUBY_METHOD_FUNC(Pixel_init_copy), 1);
-    rb_define_method(Class_Pixel, "clone", RUBY_METHOD_FUNC(Pixel_clone), 0);
-    rb_define_method(Class_Pixel, "dup", RUBY_METHOD_FUNC(Pixel_dup), 0);
     rb_define_method(Class_Pixel, "fcmp", RUBY_METHOD_FUNC(Pixel_fcmp), -1);
     rb_define_method(Class_Pixel, "hash", RUBY_METHOD_FUNC(Pixel_hash), 0);
     rb_define_method(Class_Pixel, "intensity", RUBY_METHOD_FUNC(Pixel_intensity), 0);
@@ -907,8 +902,7 @@ Init_RMagick2(void)
     rb_define_method(Class_KernelInfo, "unity_add", RUBY_METHOD_FUNC(KernelInfo_unity_add), 1);
     rb_define_method(Class_KernelInfo, "scale", RUBY_METHOD_FUNC(KernelInfo_scale), 2);
     rb_define_method(Class_KernelInfo, "scale_geometry", RUBY_METHOD_FUNC(KernelInfo_scale_geometry), 1);
-    rb_define_method(Class_KernelInfo, "clone", RUBY_METHOD_FUNC(KernelInfo_clone), 0);
-    rb_define_method(Class_KernelInfo, "dup", RUBY_METHOD_FUNC(KernelInfo_clone), 0);
+    rb_define_method(Class_KernelInfo, "initialize_copy", RUBY_METHOD_FUNC(KernelInfo_init_copy), 1);
 
     rb_define_singleton_method(Class_KernelInfo, "builtin", RUBY_METHOD_FUNC(KernelInfo_builtin), 2);
 

data/ext/RMagick/rmpixel.cpp

@@ -531,50 +531,8 @@ Pixel_case_eq(VALUE self, VALUE other)
 }
 
 
-/**
- * Clone a Pixel.
- *
- * @return [Magick::Pixel] a clone object
- * @see #dup
- * @see #initialize_copy
- */
-VALUE
-Pixel_clone(VALUE self)
-{
-    VALUE clone;
-
-    clone = Pixel_dup(self);
-    if (OBJ_FROZEN(self))
-    {
-        OBJ_FREEZE(clone);
-    }
-
-    RB_GC_GUARD(clone);
-
-    return clone;
-}
 
 
-/**
- * Duplicate a Pixel.
- *
- * @return [Magick::Pixel] a duplicated object
- * @see #clone
- * @see #initialize_copy
- */
-VALUE
-Pixel_dup(VALUE self)
-{
-    Pixel *pixel;
-    VALUE dup;
-
-    pixel = ALLOC(Pixel);
-    memset(pixel, '\0', sizeof(Pixel));
-    dup = TypedData_Wrap_Struct(CLASS_OF(self), &rm_pixel_data_type, pixel);
-    RB_GC_GUARD(dup);
-
-    return rb_funcall(dup, rm_ID_initialize_copy, 1, self);
-}
 
 
 /**

data/ext/RMagick/rmstruct.cpp

@@ -838,7 +838,7 @@ Import_TypeMetric(TypeMetric *tm)
     max_advance         = rb_float_new(tm->max_advance);
     bounds              = Import_SegmentInfo(&tm->bounds);
     underline_position  = rb_float_new(tm->underline_position);
-    underline_thickness = rb_float_new(tm->underline_position);
+    underline_thickness = rb_float_new(tm->underline_thickness);
 
     RB_GC_GUARD(pixels_per_em);
     RB_GC_GUARD(ascent);

data/lib/rmagick/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Magick
-  VERSION = '7.1.5'
+  VERSION = '7.1.7'
   MIN_RUBY_VERSION = '3.2.0'
   MIN_IM6_VERSION = '6.9.0'
   MIN_IM7_VERSION = '7.1.0'

data/lib/rmagick_internal.rb

@@ -1410,12 +1410,6 @@ module Magick
       @images.clear
     end
 
-    def clone
-      ditto = dup
-      ditto.freeze if frozen?
-      ditto
-    end
-
     # override Enumerable#collect
     def collect(&)
       current = get_current
@@ -1507,13 +1501,6 @@ module Magick
       self
     end
 
-    def dup
-      ditto = self.class.new
-      @images.each { |img| ditto << img }
-      ditto.scene = @scene
-      ditto
-    end
-
     def eql?(other)
       begin
         assert_image_array other
@@ -1570,6 +1557,13 @@ module Magick
       @scene = length - 1 if length > 0 # last image in array
     end
 
+    # Called by clone and dup, after the instance variables are copied. The copy
+    # has its own array of the same images.
+    def initialize_copy(other)
+      super
+      @images = @images.dup
+    end
+
     def insert(index, *args)
       args.each { |image| assert_image image }
       current = get_current

data/sig/rmagick/_image_common_methods.rbs

@@ -23,8 +23,8 @@ module Magick
     def matte_floodfill: (int x, int y) -> Image
     def matte_fill_to_border: (int x, int y) -> Image
     def matte_reset!: () -> Image
-    def resize_to_fill: (real ncols, ?real nrows, ?GravityType gravity) -> Image
-    def resize_to_fill!: (real ncols, ?real nrows, ?GravityType gravity) -> Image
+    def resize_to_fill: (real ncols, ?real? nrows, ?GravityType gravity) -> Image
+    def resize_to_fill!: (real ncols, ?real? nrows, ?GravityType gravity) -> self
     alias crop_resized resize_to_fill
     alias crop_resized! resize_to_fill!
     def resize_to_fit: (magick_real cols, ?magick_real rows) -> Image
@@ -147,15 +147,16 @@ module Magick
     def alpha: () -> bool
              | (AlphaChannelOption value) -> AlphaChannelOption
     def alpha?: () -> bool
-    def artifact: (string artifact) -> String?
+    def artifact: (interned artifact) -> String?
     def auto_gamma_channel: (*ChannelType channel) -> Image
     def auto_level_channel: (*ChannelType channel) -> Image
     def auto_orient: () -> Image
-    def auto_orient!: () -> self
+    def auto_orient!: () -> self?
     def properties: () -> Hash[String, String]
                   | () { ([String, String]) -> void } -> self
     def bilevel_channel: (magick_real threshold, *ChannelType channel) -> Image
-    def black_threshold: (magick_real red, ?magick_real green, ?magick_real blue, ?int alpha) -> Image
+    def black_threshold: (magick_real red, ?magick_real green, ?magick_real blue) -> Image
+                       | (magick_real red, magick_real green, magick_real blue, alpha: int) -> Image
     def blend: (magick_image overlay, magick_percentage src_percent, ?magick_percentage dst_percent, ?GravityType gravity, ?int x_offset, ?int y_offset) -> Image
              | (magick_image overlay, magick_percentage src_percent, magick_percentage dst_percent, ?int x_offset, ?int y_offset) -> Image
     def blue_shift: (?magick_real factor) -> Image
@@ -180,7 +181,7 @@ module Magick
     def charcoal: (?magick_real radius, ?magick_real sigma) -> Image
     def chop: (int x, int y, int width, int height) -> Image
     def clut_channel: (magick_image clut_image, *ChannelType channel) -> self
-    def clone: () -> Image
+    def clone: (?freeze: bool?) -> Image
     def color_flood_fill: (magick_color target_color, magick_color fill_color, int xv, int yv, PaintMethod method) -> Image
     def color_histogram: () -> Hash[Pixel, Integer]
     def colorize: (magick_real red, magick_real green, magick_real blue, magick_color target) -> Image
@@ -203,10 +204,13 @@ module Magick
                              | (magick_image image, magick_real a, magick_real b, magick_real c, magick_real d, int x_off, int y_off) -> Image
                              | (magick_image image, magick_real a, magick_real b, magick_real c, magick_real d, GravityType gravity, int x_off, int y_off) -> Image
     def composite_tiled: (magick_image src, ?CompositeOperator composite_op, *ChannelType channel) -> Image
+                       | (magick_image src, *ChannelType channel) -> Image
     def composite_tiled!: (magick_image src, ?CompositeOperator composite_op, *ChannelType channel) -> self
+                        | (magick_image src, *ChannelType channel) -> self
     def compress_colormap!: () -> Image
     def contrast: (?bool sharpen) -> Image
-    def contrast_stretch_channel: (magick_percentage black_point, magick_percentage white_point, *ChannelType channel) -> Image
+    def contrast_stretch_channel: (magick_percentage black_point, ?magick_percentage white_point, *ChannelType channel) -> Image
+                                | (magick_percentage black_point, *ChannelType channel) -> Image
     def convolve: (int order_arg, Array[magick_real] kernel_arg) -> Image
     def convolve_channel: (int order_arg, Array[magick_real] kernel_arg, *ChannelType channel) -> Image
     def morphology: (MorphologyMethod method_v, int iterations, KernelInfo kernel_v) -> Image
@@ -220,7 +224,7 @@ module Magick
              | (int x, int y, int width, int height, ?bool reset) -> Image
     def cycle_colormap: (int amount) -> Image
     def decipher: (string passphrase) -> Image
-    def define: (string artifact, string? value) -> string?
+    def define: (interned artifact, (string | Numeric)? value) -> String?
     def deskew: (?magick_percentage threshold, ?int auto_crop_width) -> Image
     def delete_compose_mask: () -> self
     def delete_profile: (string name) -> self
@@ -228,12 +232,13 @@ module Magick
     def difference: (magick_image other) -> [Float, Float, Float]
     def dispatch: (int x, int y, int columns, int rows, string map, ?bool float) -> Array[Integer]
     def displace: (magick_image displacement_map, magick_real x_amp, ?magick_real y_amp, ?GravityType gravity, ?int x_offset, ?int y_offset) -> Image
+                | (magick_image displacement_map, magick_real x_amp, magick_real y_amp, int x_offset, ?int y_offset) -> Image
     def dissolve: (magick_image overlay, magick_percentage src_percent, ?magick_percentage dst_percent, ?GravityType gravity, ?int x_offset, ?int y_offset) -> Image
     def distort: (DistortMethod method, Array[magick_real] points, ?bool bestfit) -> Image
     def distortion_channel: (magick_image reconstructed_image, MetricType metric, *ChannelType channel) -> Float
     def _dump: (untyped depth) -> String
     def dup: () -> Image
-    def each_profile: () { (String name, String val) -> void } -> untyped
+    def each_profile: () { ([String, String?] profile) -> void } -> untyped
     def edge: (?magick_real radius) -> Image
     def emboss: (?magick_real radius, ?magick_real sigma) -> Image
     def encipher: (string passphrase) -> Image
@@ -246,13 +251,13 @@ module Magick
     def export_pixels: (?int x, ?int y, ?int cols, ?int rows, ?string map) -> Array[Integer]
     def export_pixels_to_str: (?int x, ?int y, ?int cols, ?int rows, ?string map, ?StorageType storage_type) -> String
     def extent: (int width, int height, ?int x, ?int y) -> Image
-    def find_similar_region: (magick_image target, int x, int y) -> [Integer, Integer]?
+    def find_similar_region: (magick_image target, ?int x, ?int y) -> [Integer, Integer]?
     def flip: () -> Image
     def flip!: () -> self
     def flop: () -> Image
     def flop!: () -> self
     def frame: (?int width, ?int height, ?int x, ?int y, ?int inner_bevel, ?int outer_bevel, ?magick_color color) -> Image
-    def function_channel: (MagickFunction function, ?magick_real arg1, ?magick_real arg2, ?magick_real arg3, ?magick_real arg4, *ChannelType channel) -> Image
+    def function_channel: (MagickFunction function, *(magick_real | ChannelType) args) -> Image
     def fx: (string expression, *ChannelType channel) -> Image
     def gamma_channel: (magick_real gamma, *ChannelType channel) -> Image
     def gamma_correct: (magick_real red_gamma, ?magick_real green_gamma, ?magick_real blue_gamma) -> Image
@@ -275,7 +280,7 @@ module Magick
     def magnify!: () -> self
     def mask: (?magick_image image) -> Image?
     def matte_flood_fill: (magick_color color, int x_obj, int y_obj, PaintMethod method, alpha: int) -> Image
-    def median_filter: (magick_real radius) -> Image
+    def median_filter: (?magick_real radius) -> Image
     def minify: () -> Image
     def minify!: () -> self
     def modulate: (?magick_percentage brightness, ?magick_percentage saturation, ?magick_percentage hue) -> Image
@@ -300,7 +305,7 @@ module Magick
                 | (?magick_real angle) { (Image::PolaroidOptions) -> void } -> Image
     def posterize: (?int levels, ?bool dither) -> Image
     def preview: (PreviewType preview) -> Image
-    def profile!: (string name, ?string profile) -> self
+    def profile!: (string name, string? profile) -> self
     def quantum_operator: (QuantumExpressionOperator quantum_expression_op, magick_real rvalue, ?ChannelType channel) -> self
     def radial_blur: (magick_real angle) -> Image
     def radial_blur_channel: (magick_real angle, *ChannelType channel) -> Image
@@ -330,7 +335,7 @@ module Magick
     def segment: (?ColorspaceType colorspace, ?magick_real cluster_threshold, ?magick_real smoothing_threshold, ?bool verbose) -> Image
     def selective_blur_channel: (magick_real radius, magick_real sigma, magick_percentage threshold, *ChannelType channel) -> Image
     def separate: (*ChannelType channel) -> ImageList
-    def sepiatone: (magick_real threshold) -> Image
+    def sepiatone: (?magick_real threshold) -> Image
     def set_channel_depth: (ChannelType channel, int depth) -> self
     def shade: (?bool shading, ?magick_real azimuth, ?magick_real elevation) -> Image
     def shadow: (?int x_offset, ?int y_offset, ?magick_real sigma, ?magick_percentage alpha) -> Image
@@ -385,6 +390,7 @@ module Magick
                  | (magick_image mark, magick_percentage brightness, magick_percentage saturation, GravityType gravity, ?int x_off, ?int y_off) -> Image
     def wave: (?magick_real amplitude, ?magick_real wavelength) -> Image
     def wet_floor: (?magick_real initial, ?magick_real rate) -> Image
-    def white_threshold: (magick_real red, ?magick_real green, ?magick_real blue, ?alpha: int) -> Image
+    def white_threshold: (magick_real red, ?magick_real green, ?magick_real blue) -> Image
+                       | (magick_real red, magick_real green, magick_real blue, alpha: int) -> Image
   end
 end

data/sig/rmagick/image.rbs

@@ -11,7 +11,7 @@ module Magick
     # If define as Array[Image] implies the possibility of returning nil.
     # it would require consideration of nil in subsequent method calls.
     # So, it defined in Tuple type to avoid allowing unnecessary guard statements to be written.
-    def self.constitute: (int witdth_arg, int height_arg, string map_arg, Array[Pixel] pixels_arg) -> Image
+    def self.constitute: (int witdth_arg, int height_arg, string map_arg, Array[Integer] | Array[Float] pixels_arg) -> Image
     def self._load: (string str) -> Image
     def self.capture: (bool silent, bool frame, bool descend, bool screen, bool borders) -> Image
                     | (bool silent, bool frame, bool descend, bool screen, bool borders) { (Image::Info) -> void } -> Image
@@ -24,8 +24,8 @@ module Magick
     def self.from_blob: (string blob) -> [Image]
                       | (string blob) { (Image::Info) -> void } -> [Image]
 
-    def initialize: (int cols, int rows, ?magick_fill fill) -> void
-                  | (int cols, int rows, ?magick_fill fill) { (Image::Info) -> void } -> void
+    def initialize: (int cols, int rows, ?magick_fill? fill) -> void
+                  | (int cols, int rows, ?magick_fill? fill) { (Image::Info) -> void } -> void
     def <=>: (untyped object) -> (Integer | nil)
     def []: (interned key_arg) -> String?
     def []=: (interned key_arg, String attr_arg) -> self
@@ -35,7 +35,7 @@ module Magick
     def marshal_dump: () -> [String, String]
     def marshal_load: ([string, string] ary) -> self
     def montage: () -> String?
-    def quantize: (?int number_colors, ?ColorspaceType colorspace, ?bool dither, ?int tree_depth, ?bool measure_error) -> Image
+    def quantize: (?int number_colors, ?ColorspaceType colorspace, ?(DitherMethod | bool) dither, ?int tree_depth, ?bool measure_error) -> Image
     def scene: () -> Integer
     def ticks_per_second=: (int tps) -> int
     def to_blob: () -> String?

data/sig/rmagick/image_list.rbs

@@ -37,7 +37,7 @@ module Magick
     def []=: (int nth, magick_image | Array[Image] image) -> void
            | (Range[Integer] range, magick_image | Array[Image] image) -> void
            | (int start, int length, magick_image | Array[Image] image) -> void
-    def at: () -> Image
+    def at: (int index) -> Image?
     def each: () -> Enumerator[Image, self]
             | () { (Image) -> void } -> void
     def each_index: () -> Enumerator[Integer, self]
@@ -54,13 +54,14 @@ module Magick
              | () { (Image) -> boolish } -> Integer?
              | () -> ::Enumerator[Image, Integer?]
     def length: () -> Integer
+    alias size length
     def rindex: (Image | ImageList | Array[Image] obj) -> ::Integer?
               | () { (Image) -> boolish } -> Integer?
               | () -> ::Enumerator[Image, Integer?]
     def sort!: () -> self
              | () { (Image a, Image b) -> Integer } -> self
     def clear: () -> void
-    def clone: () -> ImageList
+    def clone: (?freeze: bool?) -> ImageList
              | ...
     def collect: () { (Image) -> Image } -> ImageList
     def collect!: () { (Image) -> Image } -> self
@@ -83,7 +84,7 @@ module Magick
                  | () -> self
     def dup: () -> ImageList
            | ...
-    def eql?: (ImageList | Array[Image] other) -> bool
+    def eql?: (untyped other) -> bool
     def fill: (Image image, ?int start, ?int length) -> ImageList
             | (Image image, Range[Integer] range) -> ImageList
             | (?int start, ?int length) { (Integer index) -> Image } -> ImageList
@@ -102,8 +103,8 @@ module Magick
     def marshal_dump: () -> Array[(Integer | String)?]
     def marshal_load: (Array[(Integer | String)?] ary) -> void
     def method_missing: (untyped meth_id, *untyped args) ?{ (*untyped, **untyped) -> untyped } -> untyped
-    def new_image: (int cols, int rows, ?magick_fill fill) -> self
-                 | (int cols, int rows, ?magick_fill fill) { (Image::Info) -> void } -> self
+    def new_image: (int cols, int rows, ?magick_fill? fill) -> self
+                 | (int cols, int rows, ?magick_fill? fill) { (Image::Info) -> void } -> self
     def partition: () { (Image) -> boolish } -> [ImageList, ImageList]
     def ping: (*(File | string) files) -> self
             | (*(File | string) files) { (Image::Info) -> void } -> self
@@ -123,8 +124,8 @@ module Magick
              | (int start, int length) -> ImageList?
              | (Range[Integer] range) -> ImageList?
     def slice!: (int index) -> Image?
-              | (int start, int length) -> Image?
-              | (Range[Integer] range) -> Image?
+              | (int start, int length) -> Array[Image]?
+              | (Range[Integer] range) -> Array[Image]?
     def ticks_per_second=: (int t) -> void
     def to_a: () -> Array[Image]
     def uniq: () -> ImageList
@@ -132,6 +133,8 @@ module Magick
     def unshift: (Image obj) -> self
     def values_at: (*int index) -> ImageList
                  | (Range[Integer] range) -> ImageList
+    alias indexes values_at
+    alias indices values_at
 
     alias __display__ display
     def remap: (?magick_image? remap_image, ?DitherMethod dither_method) -> self

data/sig/rmagick/kernel_info.rbs

@@ -8,7 +8,7 @@ module Magick
     def unity_add: (magick_real scale) -> nil
     def scale: (magick_real scale, GeometryFlags flags) -> nil
     def scale_geometry: (string geometry) -> nil
-    def clone: () -> KernelInfo
+    def clone: (?freeze: bool?) -> KernelInfo
     def dup: () -> KernelInfo
   end
 end

data/sig/rmagick/pixel.rbs

@@ -28,13 +28,13 @@ module Magick
     attr_writer black: real
 
     def self.from_color: (string name) -> Pixel
-    def self.from_hsla: (magick_percentage hue, magick_percentage saturation, magick_percentage lightness, magick_percentage alpha) -> Pixel
+    def self.from_hsla: (magick_percentage hue, magick_percentage saturation, magick_percentage lightness, ?magick_percentage alpha) -> Pixel
 
     def <=>: (untyped other) -> (-1 | 0 | 1 | nil)
     def ===: (untyped other) -> bool
     def eql?: (untyped other) -> bool
     def initialize: (?real red, ?real green, ?real blue, ?real opacity) -> void
-    def clone: () -> Pixel
+    def clone: (?freeze: bool?) -> Pixel
     def dup: () -> Pixel
     def fcmp: (magick_color other, ?magick_real fuzz, ?ColorspaceType colorspace) -> bool
     def hash: () -> Integer

data/sig/rmagick.rbs

@@ -38,6 +38,7 @@ module Magick
   def self.init_formats: () -> Hash[String, String]
   def self.limit_resource: (interned resource) -> Integer
                          | (interned resource, int limit) -> Integer
+  def self.resource_usage: (interned resource) -> Integer
   def self.set_cache_threshold: (int threshold) -> self
   def self.set_log_event_mask: (*string args) -> self
   def self.set_log_format: (string format) -> self

data/sig/rvg/embellishable.rbs

@@ -46,7 +46,7 @@ module Magick
       # Define an SVG path. The argument can be either a path string
       # or a PathData object.
       # Use the RVG::ShapeConstructors#path method to create Path objects in a container.
-      def initialize: (interned path) -> void
+      def initialize: (interned | PathData path) -> void
     end
 
     class Rect < Shape
@@ -139,7 +139,7 @@ module Magick
 
       # Draws a path defined by an SVG path string or a PathData
       # object.
-      def path: (interned path) -> Path
+      def path: (interned | PathData path) -> Path
 
       # Draws a rectangle whose upper-left corner is [<tt>x</tt>, <tt>y</tt>] and
       # with the specified +width+ and +height+. Unless otherwise

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rmagick
 version: !ruby/object:Gem::Version
-  version: 7.1.5
+  version: 7.1.7
 platform: ruby
 authors:
 - Tim Hunter