rmagick 2.16.0 → 3.0.0

data/ext/RMagick/rminfo.c

@@ -1734,6 +1734,9 @@ Info_monitor_eq(VALUE self, VALUE monitor)
         (void) SetImageInfoProgressMonitor(info, rm_progress_monitor, (void *)monitor);
     }
 
+#if defined(_WIN32)
+    rb_warn("Info#monitor= does not work on Windows");
+#endif
 
     return self;
 }
@@ -1839,10 +1842,12 @@ Info_origin_eq(VALUE self, VALUE origin_arg)
 
     if (IsGeometry(origin) == MagickFalse)
     {
-        rb_raise(rb_eArgError, "invalid origin geometry: %s", origin);
+        magick_free(origin);
+        rb_raise(rb_eArgError, "invalid origin geometry");
     }
 
     (void) SetImageOption(info, "origin", origin);
+    magick_free(origin);
 
     RB_GC_GUARD(origin_str);
 
@@ -1902,7 +1907,7 @@ Info_page_eq(VALUE self, VALUE page_arg)
         info->page = NULL;
         return self;
     }
-    magick_clone_string(&info->page, geometry);
+    info->page = geometry;
 
     RB_GC_GUARD(geom_str);
 

data/ext/RMagick/rmkinfo.c

@@ -0,0 +1,247 @@
+/************************************************************************//**
+ * KernelInfo class definitions for RMagick.
+ *
+ * Copyright © RMagick Project
+ *
+ * @file rmkinfo.c
+ * @version $Id: rmkinfo.c,v 1.0 2011/11/29 15:33:14 naquad Exp $
+ * @author Naquad
+ ****************************************************************************/
+
+#include "rmagick.h"
+
+/**
+ * If there's a kernel info, delete it before destroying the KernelInfo 
+ *
+ * No Ruby usage (internal function)
+ *
+ * @param kernel pointer to the KernelInfo object associated with instance
+ */
+
+static void
+rm_kernel_info_destroy(void *kernel)
+{
+  if (kernel)
+    DestroyKernelInfo((KernelInfo*)kernel);
+}
+
+/**
+ * Create a KernelInfo object.
+ *
+ * No Ruby usage (internal function)
+ *
+ * @param class the Ruby class to use
+ * @return a new KernelInfo object
+ */
+VALUE
+KernelInfo_alloc(VALUE class)
+{
+  return Data_Wrap_Struct(class, NULL, rm_kernel_info_destroy, NULL);
+}
+
+/**
+ * KernelInfo object constructor
+ *
+ * Ruby usage:
+ *   - @verbatim KernelInfo#initialize @endverbatim
+ *
+ * @param self this object
+ * @param kernel_string kernel info string representation to be parsed
+ * @return self
+ */
+VALUE
+KernelInfo_initialize(VALUE self, VALUE kernel_string)
+{
+  KernelInfo *kernel;
+
+  Check_Type(kernel_string, T_STRING);
+
+  kernel = AcquireKernelInfo(StringValueCStr(kernel_string));
+
+  if (kernel == NULL)
+    rb_raise(rb_eRuntimeError, "failed to parse kernel string");
+
+  DATA_PTR(self) = kernel;
+
+  return self;
+}
+
+/**
+ * Zero kerne NaNs.
+ *
+ * Ruby usage:
+ *   - @verbatim KernelInfo#zero_nans @endverbatim
+ *
+ * @param self this object
+ */
+VALUE
+KernelInfo_zero_nans(VALUE self)
+{
+  ZeroKernelNans((KernelInfo*)DATA_PTR(self));
+  return Qnil;
+}
+
+/**
+ * Adds a given amount of the 'Unity' Convolution Kernel to the given pre-scaled and normalized Kernel.
+ *
+ * Ruby usage:
+ *   - @verbatim KernelInfo#unity_add(scale) @endverbatim
+ *
+ * @param self this object
+ * @param scale scale to add
+ */
+VALUE
+KernelInfo_unity_add(VALUE self, VALUE scale)
+{
+  if (!FIXNUM_P(scale))
+    Check_Type(scale, T_FLOAT);
+
+  UnityAddKernelInfo((KernelInfo*)DATA_PTR(self), NUM2DBL(scale));
+  return Qnil;
+}
+
+/**
+ * Dumps KernelInfo object to stderr
+ *
+ * Ruby usage:
+ *   - @verbatim KernelInfo#show @endverbatim
+ *
+ * @param self this object
+ */
+VALUE
+KernelInfo_show(VALUE self)
+{
+  ShowKernelInfo((KernelInfo*)DATA_PTR(self));
+  return Qnil;
+}
+
+/**
+ * Scales the given kernel list by the given amount, with or without normalization
+ * of the sum of the kernel values (as per given flags).
+ *
+ * Ruby usage:
+ *   - @verbatim KernelInfo#scale(scale, flags) @endverbatim
+ *
+ * @param scale scale to use
+ * @param flags one of Magick::NormalizeValue, Magick::CorrelateNormalizeValue,
+ *                     and/or Magick::PercentValue
+ * @param self this object
+ */
+VALUE
+KernelInfo_scale(VALUE self, VALUE scale, VALUE flags)
+{
+  GeometryFlags geoflags;
+
+  if (!FIXNUM_P(scale))
+    Check_Type(scale, T_FLOAT);
+
+  if (rb_obj_is_instance_of(flags, Class_GeometryFlags))
+    VALUE_TO_ENUM(flags, geoflags, GeometryFlags);
+  else
+    rb_raise(rb_eArgError, "expected Fixnum or Magick::GeometryFlags to specify flags");
+
+  ScaleKernelInfo((KernelInfo*)DATA_PTR(self), NUM2DBL(scale), geoflags);
+  return Qnil;
+}
+
+/**
+ * Takes a geometry argument string, typically provided as a "-set option:convolve:scale {geometry}" user setting,
+ * and modifies the kernel according to the parsed arguments of that setting.
+ *
+ * Ruby usage:
+ *   - @verbatim KernelInfo#scale_geometry(geometry) @endverbatim
+ *
+ * @param geometry geometry string to parse and apply
+ * @param self this object
+ */
+VALUE
+KernelInfo_scale_geometry(VALUE self, VALUE geometry)
+{
+  Check_Type(geometry, T_STRING);
+  ScaleGeometryKernelInfo((KernelInfo*)DATA_PTR(self), StringValueCStr(geometry));
+  return Qnil;
+}
+
+/**
+ * Creates a new clone of the object so that its can be modified without effecting the original.
+ *
+ * Ruby usage:
+ *   - @verbatim KernelInfo#clone @endverbatim
+ *
+ * @param self this object
+ * @return new KernelInfo instance
+ */
+VALUE
+KernelInfo_clone(VALUE self)
+{
+  KernelInfo *kernel = CloneKernelInfo((KernelInfo*)DATA_PTR(self));
+  return Data_Wrap_Struct(Class_KernelInfo, NULL, rm_kernel_info_destroy, kernel);
+}
+
+/**
+ * Create new instance of KernelInfo with one of the 'named' built-in types of
+ * kernels used for special purposes such as gaussian blurring, skeleton
+ * pruning, and edge distance determination.
+ *
+ * Ruby usage:
+ *   - @verbatim KernelInfo.builtin(kernel, geometry = nil) @endverbatim
+ *
+ * @parms kernel one of Magick::KernelInfoType enums:
+ *                      Magick::UndefinedKernel
+ *                      Magick::UnityKernel
+ *                      Magick::GaussianKernel
+ *                      Magick::DoGKernel
+ *                      Magick::LoGKernel
+ *                      Magick::BlurKernel
+ *                      Magick::CometKernel
+ *                      Magick::LaplacianKernel
+ *                      Magick::SobelKernel
+ *                      Magick::FreiChenKernel
+ *                      Magick::RobertsKernel
+ *                      Magick::PrewittKernel
+ *                      Magick::CompassKernel
+ *                      Magick::KirschKernel
+ *                      Magick::DiamondKernel
+ *                      Magick::SquareKernel
+ *                      Magick::RectangleKernel
+ *                      Magick::OctagonKernel
+ *                      Magick::DiskKernel
+ *                      Magick::PlusKernel
+ *                      Magick::CrossKernel
+ *                      Magick::RingKernel
+ *                      Magick::PeaksKernel
+ *                      Magick::EdgesKernel
+ *                      Magick::CornersKernel
+ *                      Magick::DiagonalsKernel
+ *                      Magick::LineEndsKernel
+ *                      Magick::LineJunctionsKernel
+ *                      Magick::RidgesKernel
+ *                      Magick::ConvexHullKernel
+ *                      Magick::ThinSEKernel
+ *                      Magick::SkeletonKernel
+ *                      Magick::ChebyshevKernel
+ *                      Magick::ManhattanKernel
+ *                      Magick::OctagonalKernel
+ *                      Magick::EuclideanKernel
+ *                      Magick::UserDefinedKernel
+ * @param geometry geometry to pass to default kernel
+ * @return KernelInfo instance
+ */
+VALUE
+KernelInfo_builtin(VALUE self, VALUE what, VALUE geometry)
+{
+  KernelInfo *kernel;
+  KernelInfoType kernel_type;
+  GeometryInfo info;
+
+  Check_Type(geometry, T_STRING);
+  VALUE_TO_ENUM(what, kernel_type, KernelInfoType);
+  ParseGeometry(StringValueCStr(geometry), &info);
+
+  kernel = AcquireKernelBuiltIn(kernel_type, &info);
+
+  if (!kernel)
+    rb_raise(rb_eRuntimeError, "failed to acquire builtin kernel");
+
+  return Data_Wrap_Struct(self, NULL, rm_kernel_info_destroy, kernel);
+}

data/ext/RMagick/rmmain.c

@@ -314,6 +314,7 @@ Init_RMagick2(void)
     rb_define_method(Class_Image, "channel_depth", Image_channel_depth, -1);
     rb_define_method(Class_Image, "channel_extrema", Image_channel_extrema, -1);
     rb_define_method(Class_Image, "channel_mean", Image_channel_mean, -1);
+    rb_define_method(Class_Image, "channel_entropy", Image_channel_entropy, -1);
     rb_define_method(Class_Image, "charcoal", Image_charcoal, -1);
     rb_define_method(Class_Image, "chop", Image_chop, 4);
     rb_define_method(Class_Image, "clut_channel", Image_clut_channel, -1);
@@ -335,6 +336,8 @@ Init_RMagick2(void)
     rb_define_method(Class_Image, "contrast_stretch_channel", Image_contrast_stretch_channel, -1);
     rb_define_method(Class_Image, "convolve", Image_convolve, 2);
     rb_define_method(Class_Image, "convolve_channel", Image_convolve_channel, -1);
+    rb_define_method(Class_Image, "morphology", Image_morphology, 3);
+    rb_define_method(Class_Image, "morphology_channel", Image_morphology_channel, 4);
     rb_define_method(Class_Image, "copy", Image_copy, 0);
     rb_define_method(Class_Image, "crop", Image_crop, -1);
     rb_define_method(Class_Image, "crop!", Image_crop_bang, -1);
@@ -748,6 +751,25 @@ Init_RMagick2(void)
     DCL_ATTR_ACCESSOR(Info, units)
     DCL_ATTR_ACCESSOR(Info, view)
 
+    /*-----------------------------------------------------------------------*/
+    /* Class Magick::KernelInfo                                              */
+    /*-----------------------------------------------------------------------*/
+
+    Class_KernelInfo = rb_define_class_under(Module_Magick, "KernelInfo", rb_cObject);
+
+    rb_define_alloc_func(Class_KernelInfo, KernelInfo_alloc);
+
+    rb_define_method(Class_KernelInfo, "initialize", KernelInfo_initialize, 1);
+    rb_define_method(Class_KernelInfo, "zero_nans", KernelInfo_zero_nans, 0);
+    rb_define_method(Class_KernelInfo, "unity_add", KernelInfo_unity_add, 1);
+    rb_define_method(Class_KernelInfo, "show", KernelInfo_show, 0);
+    rb_define_method(Class_KernelInfo, "scale", KernelInfo_scale, 2);
+    rb_define_method(Class_KernelInfo, "scale_geometry", KernelInfo_scale_geometry, 1);
+    rb_define_method(Class_KernelInfo, "clone", KernelInfo_clone, 0);
+    rb_define_method(Class_KernelInfo, "dup", KernelInfo_clone, 0);
+
+    rb_define_singleton_method(Class_KernelInfo, "builtin", KernelInfo_builtin, 2);
+
 
     /*-----------------------------------------------------------------------*/
     /* Class Magick::Image::PolaroidOptions                                  */
@@ -844,6 +866,7 @@ Init_RMagick2(void)
     rb_define_method(Class_Enum, "to_i", Enum_to_i, 0);
     rb_define_method(Class_Enum, "<=>", Enum_spaceship, 1);
     rb_define_method(Class_Enum, "===", Enum_case_eq, 1);
+    rb_define_method(Class_Enum, "|", Enum_bitwise_or, 1);
 
     // AlignType constants
     DEF_ENUM(AlignType)
@@ -1552,6 +1575,79 @@ Init_RMagick2(void)
         ENUMERATOR(LighterWeight)
     END_ENUM
 
+    // For KernelInfo scaling
+    DEF_ENUM(GeometryFlags)
+        ENUMERATOR(NormalizeValue)
+        ENUMERATOR(CorrelateNormalizeValue)
+        ENUMERATOR(PercentValue)
+    END_ENUM
+
+    // Morphology methods
+    DEF_ENUM(MorphologyMethod)
+      ENUMERATOR(UndefinedMorphology)
+      ENUMERATOR(ConvolveMorphology)
+      ENUMERATOR(CorrelateMorphology)
+      ENUMERATOR(ErodeMorphology)
+      ENUMERATOR(DilateMorphology)
+      ENUMERATOR(ErodeIntensityMorphology)
+      ENUMERATOR(DilateIntensityMorphology)
+      ENUMERATOR(DistanceMorphology)
+      ENUMERATOR(OpenMorphology)
+      ENUMERATOR(CloseMorphology)
+      ENUMERATOR(OpenIntensityMorphology)
+      ENUMERATOR(CloseIntensityMorphology)
+      ENUMERATOR(SmoothMorphology)
+      ENUMERATOR(EdgeInMorphology)
+      ENUMERATOR(EdgeOutMorphology)
+      ENUMERATOR(EdgeMorphology)
+      ENUMERATOR(TopHatMorphology)
+      ENUMERATOR(BottomHatMorphology)
+      ENUMERATOR(HitAndMissMorphology)
+      ENUMERATOR(ThinningMorphology)
+      ENUMERATOR(ThickenMorphology)
+      ENUMERATOR(VoronoiMorphology)
+    END_ENUM
+
+    DEF_ENUM(KernelInfoType)
+      ENUMERATOR(UndefinedKernel)
+      ENUMERATOR(UnityKernel)
+      ENUMERATOR(GaussianKernel)
+      ENUMERATOR(DoGKernel)
+      ENUMERATOR(LoGKernel)
+      ENUMERATOR(BlurKernel)
+      ENUMERATOR(CometKernel)
+      ENUMERATOR(LaplacianKernel)
+      ENUMERATOR(SobelKernel)
+      ENUMERATOR(FreiChenKernel)
+      ENUMERATOR(RobertsKernel)
+      ENUMERATOR(PrewittKernel)
+      ENUMERATOR(CompassKernel)
+      ENUMERATOR(KirschKernel)
+      ENUMERATOR(DiamondKernel)
+      ENUMERATOR(SquareKernel)
+      ENUMERATOR(RectangleKernel)
+      ENUMERATOR(OctagonKernel)
+      ENUMERATOR(DiskKernel)
+      ENUMERATOR(PlusKernel)
+      ENUMERATOR(CrossKernel)
+      ENUMERATOR(RingKernel)
+      ENUMERATOR(PeaksKernel)
+      ENUMERATOR(EdgesKernel)
+      ENUMERATOR(CornersKernel)
+      ENUMERATOR(DiagonalsKernel)
+      ENUMERATOR(LineEndsKernel)
+      ENUMERATOR(LineJunctionsKernel)
+      ENUMERATOR(RidgesKernel)
+      ENUMERATOR(ConvexHullKernel)
+      ENUMERATOR(ThinSEKernel)
+      ENUMERATOR(SkeletonKernel)
+      ENUMERATOR(ChebyshevKernel)
+      ENUMERATOR(ManhattanKernel)
+      ENUMERATOR(OctagonalKernel)
+      ENUMERATOR(EuclideanKernel)
+      ENUMERATOR(UserDefinedKernel)
+    END_ENUM
+
     /*-----------------------------------------------------------------------*/
     /* Struct classes                                                        */
     /*-----------------------------------------------------------------------*/

data/ext/RMagick/rmutil.c

@@ -1445,6 +1445,7 @@ rm_progress_monitor(
     const MagickSizeType sp,
     void *client_data)
 {
+#if !defined(_WIN32)
     VALUE rval;
     VALUE method, offset, span;
 
@@ -1468,6 +1469,9 @@ rm_progress_monitor(
     RB_GC_GUARD(span);
 
     return RTEST(rval) ? MagickTrue : MagickFalse;
+#else
+    return MagickTrue;
+#endif
 }
 
 

data/lib/rmagick/version.rb

@@ -1,6 +1,6 @@
 module Magick
-  VERSION = '2.16.0'
-  MIN_RUBY_VERSION = '1.8.5'
-  MIN_IM_VERSION = '6.4.9'
+  VERSION = '3.0.0'
+  MIN_RUBY_VERSION = '2.3.0'
+  MIN_IM_VERSION = '6.8.9'
   MIN_WAND_VERSION = '6.9.0'
 end

data/lib/rmagick_internal.rb

@@ -8,6 +8,16 @@
 #               to the classes.
 #==============================================================================
 
+if RUBY_PLATFORM =~ /mingw/i
+  begin
+    require 'ruby_installer'
+    ENV['PATH'].split(File::PATH_SEPARATOR).grep(/ImageMagick/i).each do |path|
+      RubyInstaller::Runtime.add_dll_directory(path)
+    end
+  rescue LoadError
+  end
+end
+
 require 'English'
 require 'RMagick2.so'
 
@@ -17,11 +27,11 @@ module Magick
   @exit_block_set_up = nil
 
   class << self
-    def formats(&block)
+    def formats
       @formats ||= init_formats
 
       if block_given?
-        @formats.each{|k, v| yield k, v }
+        @formats.each { |k, v| yield k, v }
         self
       else
         @formats
@@ -65,11 +75,11 @@ module Magick
 
     attr_accessor :width, :height, :x, :y, :flag
 
-    def initialize(width=nil, height=nil, x=nil, y=nil, flag=nil)
-      fail(ArgumentError, "width set to #{width}") if width.is_a? GeometryValue
-      fail(ArgumentError, "height set to #{height}") if height.is_a? GeometryValue
-      fail(ArgumentError, "x set to #{x}") if x.is_a? GeometryValue
-      fail(ArgumentError, "y set to #{y}") if y.is_a? GeometryValue
+    def initialize(width = nil, height = nil, x = nil, y = nil, flag = nil)
+      raise(ArgumentError, "width set to #{width}") if width.is_a? GeometryValue
+      raise(ArgumentError, "height set to #{height}") if height.is_a? GeometryValue
+      raise(ArgumentError, "x set to #{x}") if x.is_a? GeometryValue
+      raise(ArgumentError, "y set to #{y}") if y.is_a? GeometryValue
 
       # Support floating-point width and height arguments so Geometry
       # objects can be used to specify Image#density= arguments.
@@ -111,9 +121,7 @@ module Magick
       else
         Kernel.raise ArgumentError, 'invalid geometry format'
       end
-      if str['%']
-        flag = PercentGeometry
-      end
+      flag = PercentGeometry if str['%']
       Geometry.new(width, height, x, y, flag)
     end
 
@@ -122,23 +130,19 @@ module Magick
       str = ''
       if @width > 0
         fmt = @width.truncate == @width ? '%d' : '%.2f'
-        str << sprintf(fmt, @width)
+        str << format(fmt, @width)
         str << '%' if @flag == PercentGeometry
       end
 
-      if (@width > 0 && @flag != PercentGeometry) || (@height > 0)
-        str << 'x'
-      end
+      str << 'x' if (@width > 0 && @flag != PercentGeometry) || (@height > 0)
 
       if @height > 0
         fmt = @height.truncate == @height ? '%d' : '%.2f'
-        str << sprintf(fmt, @height)
+        str << format(fmt, @height)
         str << '%' if @flag == PercentGeometry
       end
-      str << sprintf('%+d%+d', @x, @y) if @x != 0 || @y != 0
-      if @flag != PercentGeometry
-        str << FLAGS[@flag.to_i]
-      end
+      str << format('%+d%+d', @x, @y) if @x != 0 || @y != 0
+      str << FLAGS[@flag.to_i] if @flag != PercentGeometry
       str
     end
   end
@@ -167,7 +171,7 @@ module Magick
       NormalWeight.to_i => 'normal',
       BoldWeight.to_i => 'bold',
       BolderWeight.to_i => 'bolder',
-      LighterWeight.to_i => 'lighter',
+      LighterWeight.to_i => 'lighter'
     }.freeze
     GRAVITY_NAMES = {
       NorthWestGravity.to_i => 'northwest',
@@ -210,9 +214,9 @@ module Magick
 
     def enquote(str)
       if str.length > 2 && /\A(?:\"[^\"]+\"|\'[^\']+\'|\{[^\}]+\})\z/.match(str)
-        return str
+        str
       else
-        return '"' + str + '"'
+        '"' + str + '"'
       end
     end
 
@@ -221,18 +225,18 @@ module Magick
     # Apply coordinate transformations to support scaling (s), rotation (r),
     # and translation (t). Angles are specified in radians.
     def affine(sx, rx, ry, sy, tx, ty)
-      primitive 'affine ' + sprintf('%g,%g,%g,%g,%g,%g', sx, rx, ry, sy, tx, ty)
+      primitive 'affine ' + format('%g,%g,%g,%g,%g,%g', sx, rx, ry, sy, tx, ty)
     end
 
     # Draw an arc.
-    def arc(startX, startY, endX, endY, startDegrees, endDegrees)
-      primitive 'arc ' + sprintf('%g,%g %g,%g %g,%g',
-                                 startX, startY, endX, endY, startDegrees, endDegrees)
+    def arc(start_x, start_y, end_x, end_y, start_degrees, end_degrees)
+      primitive 'arc ' + format('%g,%g %g,%g %g,%g',
+                                start_x, start_y, end_x, end_y, start_degrees, end_degrees)
     end
 
     # Draw a bezier curve.
     def bezier(*points)
-      if points.length == 0
+      if points.length.zero?
         Kernel.raise ArgumentError, 'no points specified'
       elsif points.length.odd?
         Kernel.raise ArgumentError, 'odd number of arguments specified'
@@ -241,8 +245,8 @@ module Magick
     end
 
     # Draw a circle
-    def circle(originX, originY, perimX, perimY)
-      primitive 'circle ' + sprintf('%g,%g %g,%g', originX, originY, perimX, perimY)
+    def circle(origin_x, origin_y, perim_x, perim_y)
+      primitive 'circle ' + format('%g,%g %g,%g', origin_x, origin_y, perim_x, perim_y)
     end
 
     # Invoke a clip-path defined by def_clip_path.
@@ -252,33 +256,27 @@ module Magick
 
     # Define the clipping rule.
     def clip_rule(rule)
-      unless  ['evenodd', 'nonzero'].include?(rule.downcase)
-        Kernel.raise ArgumentError, "Unknown clipping rule #{rule}"
-      end
+      Kernel.raise ArgumentError, "Unknown clipping rule #{rule}" unless %w[evenodd nonzero].include?(rule.downcase)
       primitive "clip-rule #{rule}"
     end
 
     # Define the clip units
     def clip_units(unit)
-      unless  ['userspace', 'userspaceonuse', 'objectboundingbox'].include?(unit.downcase)
-        Kernel.raise ArgumentError, "Unknown clip unit #{unit}"
-      end
+      Kernel.raise ArgumentError, "Unknown clip unit #{unit}" unless %w[userspace userspaceonuse objectboundingbox].include?(unit.downcase)
       primitive "clip-units #{unit}"
     end
 
     # Set color in image according to specified colorization rule. Rule is one of
     # point, replace, floodfill, filltoborder,reset
     def color(x, y, method)
-      unless  PAINT_METHOD_NAMES.has_key?(method.to_i)
-        Kernel.raise ArgumentError, "Unknown PaintMethod: #{method}"
-      end
+      Kernel.raise ArgumentError, "Unknown PaintMethod: #{method}" unless PAINT_METHOD_NAMES.key?(method.to_i)
       primitive "color #{x},#{y},#{PAINT_METHOD_NAMES[method.to_i]}"
     end
 
     # Specify EITHER the text decoration (none, underline, overline,
     # line-through) OR the text solid background color (any color name or spec)
     def decorate(decoration)
-      if  DECORATION_TYPE_NAMES.has_key?(decoration.to_i)
+      if DECORATION_TYPE_NAMES.key?(decoration.to_i)
         primitive "decorate #{DECORATION_TYPE_NAMES[decoration.to_i]}"
       else
         primitive "decorate #{enquote(decoration)}"
@@ -302,9 +300,9 @@ module Magick
     end
 
     # Draw an ellipse
-    def ellipse(originX, originY, width, height, arcStart, arcEnd)
-      primitive 'ellipse ' + sprintf('%g,%g %g,%g %g,%g',
-                                     originX, originY, width, height, arcStart, arcEnd)
+    def ellipse(origin_x, origin_y, width, height, arc_start, arc_end)
+      primitive 'ellipse ' + format('%g,%g %g,%g %g,%g',
+                                    origin_x, origin_y, width, height, arc_start, arc_end)
     end
 
     # Let anything through, but the only defined argument
@@ -317,8 +315,8 @@ module Magick
     def fill(colorspec)
       primitive "fill #{enquote(colorspec)}"
     end
-    alias_method :fill_color, :fill
-    alias_method :fill_pattern, :fill
+    alias fill_color fill
+    alias fill_pattern fill
 
     # Specify fill opacity (use "xx%" to indicate percentage)
     def fill_opacity(opacity)
@@ -326,9 +324,7 @@ module Magick
     end
 
     def fill_rule(rule)
-      unless  ['evenodd', 'nonzero'].include?(rule.downcase)
-        Kernel.raise ArgumentError, "Unknown fill rule #{rule}"
-      end
+      Kernel.raise ArgumentError, "Unknown fill rule #{rule}" unless %w[evenodd nonzero].include?(rule.downcase)
       primitive "fill-rule #{rule}"
     end
 
@@ -342,23 +338,19 @@ module Magick
     end
 
     def font_stretch(stretch)
-      unless  STRETCH_TYPE_NAMES.has_key?(stretch.to_i)
-        Kernel.raise ArgumentError, 'Unknown stretch type'
-      end
+      Kernel.raise ArgumentError, 'Unknown stretch type' unless STRETCH_TYPE_NAMES.key?(stretch.to_i)
       primitive "font-stretch #{STRETCH_TYPE_NAMES[stretch.to_i]}"
     end
 
     def font_style(style)
-      unless  STYLE_TYPE_NAMES.has_key?(style.to_i)
-        Kernel.raise ArgumentError, 'Unknown style type'
-      end
+      Kernel.raise ArgumentError, 'Unknown style type' unless STYLE_TYPE_NAMES.key?(style.to_i)
       primitive "font-style #{STYLE_TYPE_NAMES[style.to_i]}"
     end
 
     # The font weight argument can be either a font weight
     # constant or [100,200,...,900]
     def font_weight(weight)
-      if  FONT_WEIGHT_NAMES.has_key?(weight.to_i)
+      if FONT_WEIGHT_NAMES.key?(weight.to_i)
         primitive "font-weight #{FONT_WEIGHT_NAMES[weight.to_i]}"
       else
         primitive "font-weight #{weight}"
@@ -368,9 +360,7 @@ module Magick
     # Specify the text positioning gravity, one of:
     # NorthWest, North, NorthEast, West, Center, East, SouthWest, South, SouthEast
     def gravity(grav)
-      unless  GRAVITY_NAMES.has_key?(grav.to_i)
-        Kernel.raise ArgumentError, 'Unknown text positioning gravity'
-      end
+      Kernel.raise ArgumentError, 'Unknown text positioning gravity' unless GRAVITY_NAMES.key?(grav.to_i)
       primitive "gravity #{GRAVITY_NAMES[grav.to_i]}"
     end
 
@@ -411,26 +401,22 @@ module Magick
     end
 
     # Draw a line
-    def line(startX, startY, endX, endY)
-      primitive 'line ' + sprintf('%g,%g %g,%g', startX, startY, endX, endY)
+    def line(start_x, start_y, end_x, end_y)
+      primitive 'line ' + format('%g,%g %g,%g', start_x, start_y, end_x, end_y)
     end
 
     # Set matte (make transparent) in image according to the specified
     # colorization rule
     def matte(x, y, method)
-      unless  PAINT_METHOD_NAMES.has_key?(method.to_i)
-        Kernel.raise ArgumentError, 'Unknown paint method'
-      end
+      Kernel.raise ArgumentError, 'Unknown paint method' unless PAINT_METHOD_NAMES.key?(method.to_i)
       primitive "matte #{x},#{y} #{PAINT_METHOD_NAMES[method.to_i]}"
     end
 
     # Specify drawing fill and stroke opacities. If the value is a string
     # ending with a %, the number will be multiplied by 0.01.
     def opacity(opacity)
-      if (Numeric === opacity)
-        if opacity < 0 || opacity > 1.0
-          Kernel.raise ArgumentError, 'opacity must be >= 0 and <= 1.0'
-        end
+      if opacity.is_a?(Numeric)
+        Kernel.raise ArgumentError, 'opacity must be >= 0 and <= 1.0' if opacity < 0 || opacity > 1.0
       end
       primitive "opacity #{opacity}"
     end
@@ -466,11 +452,11 @@ module Magick
     def pointsize(points)
       primitive "font-size #{points}"
     end
-    alias_method :font_size, :pointsize
+    alias font_size pointsize
 
     # Draw a polygon
     def polygon(*points)
-      if points.length == 0
+      if points.length.zero?
         Kernel.raise ArgumentError, 'no points specified'
       elsif points.length.odd?
         Kernel.raise ArgumentError, 'odd number of points specified'
@@ -480,7 +466,7 @@ module Magick
 
     # Draw a polyline
     def polyline(*points)
-      if points.length == 0
+      if points.length.zero?
         Kernel.raise ArgumentError, 'no points specified'
       elsif points.length.odd?
         Kernel.raise ArgumentError, 'odd number of points specified'
@@ -495,11 +481,11 @@ module Magick
     # pop('pattern')
 
     def pop(*what)
-      if what.length == 0
+      if what.length.zero?
         primitive 'pop graphic-context'
       else
         # to_s allows a Symbol to be used instead of a String
-        primitive 'pop ' + what.map {|w| w.to_s}.join(' ')
+        primitive 'pop ' + what.map(&:to_s).join(' ')
       end
     end
 
@@ -509,18 +495,18 @@ module Magick
     # push('gradient')
     # push('pattern')
     def push(*what)
-      if what.length == 0
+      if what.length.zero?
         primitive 'push graphic-context'
       else
         # to_s allows a Symbol to be used instead of a String
-        primitive 'push ' + what.map {|w| w.to_s}.join(' ')
+        primitive 'push ' + what.map(&:to_s).join(' ')
       end
     end
 
     # Draw a rectangle
     def rectangle(upper_left_x, upper_left_y, lower_right_x, lower_right_y)
-      primitive 'rectangle ' + sprintf('%g,%g %g,%g',
-                                       upper_left_x, upper_left_y, lower_right_x, lower_right_y)
+      primitive 'rectangle ' + format('%g,%g %g,%g',
+                                      upper_left_x, upper_left_y, lower_right_x, lower_right_y)
     end
 
     # Specify coordinate space rotation. "angle" is measured in degrees
@@ -530,8 +516,8 @@ module Magick
 
     # Draw a rectangle with rounded corners
     def roundrectangle(center_x, center_y, width, height, corner_width, corner_height)
-      primitive 'roundrectangle ' + sprintf('%g,%g,%g,%g,%g,%g',
-                                            center_x, center_y, width, height, corner_width, corner_height)
+      primitive 'roundrectangle ' + format('%g,%g,%g,%g,%g,%g',
+                                           center_x, center_y, width, height, corner_width, corner_height)
     end
 
     # Specify scaling to be applied to coordinate space on subsequent drawing commands.
@@ -551,8 +537,8 @@ module Magick
     def stroke(colorspec)
       primitive "stroke #{enquote(colorspec)}"
     end
-    alias_method :stroke_color, :stroke
-    alias_method :stroke_pattern, :stroke
+    alias stroke_color stroke
+    alias stroke_pattern stroke
 
     # Specify if stroke should be antialiased or not
     def stroke_antialias(bool)
@@ -562,41 +548,33 @@ module Magick
 
     # Specify a stroke dash pattern
     def stroke_dasharray(*list)
-      if list.length == 0
+      if list.length.zero?
         primitive 'stroke-dasharray none'
       else
         list.each do |x|
-          if x <= 0
-            Kernel.raise ArgumentError, "dash array elements must be > 0 (#{x} given)"
-          end
+          Kernel.raise ArgumentError, "dash array elements must be > 0 (#{x} given)" if x <= 0
         end
         primitive "stroke-dasharray #{list.join(',')}"
       end
     end
 
     # Specify the initial offset in the dash pattern
-    def stroke_dashoffset(value=0)
+    def stroke_dashoffset(value = 0)
       primitive "stroke-dashoffset #{value}"
     end
 
     def stroke_linecap(value)
-      unless  ['butt', 'round', 'square'].include?(value.downcase)
-        Kernel.raise ArgumentError, "Unknown linecap type: #{value}"
-      end
+      Kernel.raise ArgumentError, "Unknown linecap type: #{value}" unless %w[butt round square].include?(value.downcase)
       primitive "stroke-linecap #{value}"
     end
 
     def stroke_linejoin(value)
-      unless  ['round', 'miter', 'bevel'].include?(value.downcase)
-        Kernel.raise ArgumentError, "Unknown linejoin type: #{value}"
-      end
+      Kernel.raise ArgumentError, "Unknown linejoin type: #{value}" unless %w[round miter bevel].include?(value.downcase)
       primitive "stroke-linejoin #{value}"
     end
 
     def stroke_miterlimit(value)
-      if value < 1
-        Kernel.raise ArgumentError, 'miterlimit must be >= 1'
-      end
+      Kernel.raise ArgumentError, 'miterlimit must be >= 1' if value < 1
       primitive "stroke-miterlimit #{value}"
     end
 
@@ -613,37 +591,31 @@ module Magick
 
     # Draw text at position x,y. Add quotes to text that is not already quoted.
     def text(x, y, text)
-      if text.to_s.empty?
-        Kernel.raise ArgumentError, 'missing text argument'
-      end
+      Kernel.raise ArgumentError, 'missing text argument' if text.to_s.empty?
       if text.length > 2 && /\A(?:\"[^\"]+\"|\'[^\']+\'|\{[^\}]+\})\z/.match(text)
-        ; # text already quoted
+      # text already quoted
       elsif !text['\'']
-        text = '\''+text+'\''
+        text = '\'' + text + '\''
       elsif !text['"']
-        text = '"'+text+'"'
+        text = '"' + text + '"'
       elsif !(text['{'] || text['}'])
-        text = '{'+text+'}'
+        text = '{' + text + '}'
       else
         # escape existing braces, surround with braces
-        text = '{' +  text.gsub(/[}]/) { |b| '\\' + b } + '}'
+        text = '{' + text.gsub(/[}]/) { |b| '\\' + b } + '}'
       end
       primitive "text #{x},#{y} #{text}"
     end
 
     # Specify text alignment relative to a given point
     def text_align(alignment)
-      unless  ALIGN_TYPE_NAMES.has_key?(alignment.to_i)
-        Kernel.raise ArgumentError, "Unknown alignment constant: #{alignment}"
-      end
+      Kernel.raise ArgumentError, "Unknown alignment constant: #{alignment}" unless ALIGN_TYPE_NAMES.key?(alignment.to_i)
       primitive "text-align #{ALIGN_TYPE_NAMES[alignment.to_i]}"
     end
 
     # SVG-compatible version of text_align
     def text_anchor(anchor)
-      unless  ANCHOR_TYPE_NAMES.has_key?(anchor.to_i)
-        Kernel.raise ArgumentError, "Unknown anchor constant: #{anchor}"
-      end
+      Kernel.raise ArgumentError, "Unknown anchor constant: #{anchor}" unless ANCHOR_TYPE_NAMES.key?(anchor.to_i)
       primitive "text-anchor #{ANCHOR_TYPE_NAMES[anchor.to_i]}"
     end
 
@@ -776,7 +748,7 @@ module Magick
   class Image
     include Comparable
 
-    alias_method :affinity, :remap
+    alias affinity remap
 
     # Provide an alternate version of Draw#annotate, for folks who
     # want to find it in this class.
@@ -830,7 +802,7 @@ module Magick
     # Thanks to Russell Norris!
     def each_pixel
       get_pixels(0, 0, columns, rows).each_with_index do |p, n|
-        yield(p, n%columns, n/columns)
+        yield(p, n % columns, n / columns)
       end
       self
     end
@@ -841,13 +813,11 @@ module Magick
     # arrays.
     def get_exif_by_entry(*entry)
       ary = []
-      if entry.length == 0
+      if entry.length.zero?
         exif_data = self['EXIF:*']
-        if exif_data
-          exif_data.split("\n").each { |exif| ary.push(exif.split('=')) }
-        end
+        exif_data.split("\n").each { |exif| ary.push(exif.split('=')) } if exif_data
       else
-        get_exif_by_entry     # ensure properties is populated with exif data
+        get_exif_by_entry # ensure properties is populated with exif data
         entry.each do |name|
           rval = self["EXIF:#{name}"]
           ary.push([name, rval])
@@ -859,19 +829,19 @@ module Magick
     # Retrieve EXIF data by tag number or all tag/value pairs. The return value is a hash.
     def get_exif_by_number(*tag)
       hash = {}
-      if tag.length == 0
+      if tag.length.zero?
         exif_data = self['EXIF:!']
         if exif_data
           exif_data.split("\n").each do |exif|
             tag, value = exif.split('=')
-            tag = tag[1,4].hex
+            tag = tag[1, 4].hex
             hash[tag] = value
           end
         end
       else
-        get_exif_by_number    # ensure properties is populated with exif data
+        get_exif_by_number # ensure properties is populated with exif data
         tag.each do |num|
-          rval = self['#%04X' % num.to_i]
+          rval = self[format('#%04X', num.to_i)]
           hash[num] = rval == 'unknown' ? nil : rval
         end
       end
@@ -881,7 +851,7 @@ module Magick
     # Retrieve IPTC information by record number:dataset tag constant defined in
     # Magick::IPTC, above.
     def get_iptc_dataset(ds)
-      self['IPTC:'+ds]
+      self['IPTC:' + ds]
     end
 
     # Iterate over IPTC record number:dataset tags, yield for each non-nil dataset
@@ -909,7 +879,7 @@ module Magick
     # look like they're in the old order.
 
     # (Thanks to Al Evans for the suggestion.)
-    def level(black_point=0.0, white_point=nil, gamma=nil)
+    def level(black_point = 0.0, white_point = nil, gamma = nil)
       black_point = Float(black_point)
 
       white_point ||= Magick::QuantumRange - black_point
@@ -921,9 +891,7 @@ module Magick
 
       if gamma.abs > 10.0 || white_point.abs <= 10.0 || white_point.abs < gamma.abs
         gamma, white_point = white_point, gamma
-        unless gamma_arg
-          white_point = Magick::QuantumRange - black_point
-        end
+        white_point = Magick::QuantumRange - black_point unless gamma_arg
       end
 
       level2(black_point, white_point, gamma)
@@ -937,7 +905,7 @@ module Magick
     def matte_point(x, y)
       f = copy
       f.opacity = OpaqueOpacity unless f.matte
-      pixel = f.pixel_color(x,y)
+      pixel = f.pixel_color(x, y)
       pixel.opacity = TransparentOpacity
       f.pixel_color(x, y, pixel)
       f
@@ -978,34 +946,34 @@ module Magick
 
     # Force an image to exact dimensions without changing the aspect ratio.
     # Resize and crop if necessary. (Thanks to Jerett Taylor!)
-    def resize_to_fill(ncols, nrows=nil, gravity=CenterGravity)
+    def resize_to_fill(ncols, nrows = nil, gravity = CenterGravity)
       copy.resize_to_fill!(ncols, nrows, gravity)
     end
 
-    def resize_to_fill!(ncols, nrows=nil, gravity=CenterGravity)
+    def resize_to_fill!(ncols, nrows = nil, gravity = CenterGravity)
       nrows ||= ncols
       if ncols != columns || nrows != rows
-        scale = [ncols/columns.to_f, nrows/rows.to_f].max
-        resize!(scale*columns+0.5, scale*rows+0.5)
+        scale = [ncols / columns.to_f, nrows / rows.to_f].max
+        resize!(scale * columns + 0.5, scale * rows + 0.5)
       end
       crop!(gravity, ncols, nrows, true) if ncols != columns || nrows != rows
       self
     end
 
     # Preserve aliases used < RMagick 2.0.1
-    alias_method :crop_resized, :resize_to_fill
-    alias_method :crop_resized!, :resize_to_fill!
+    alias crop_resized resize_to_fill
+    alias crop_resized! resize_to_fill!
 
     # Convenience method to resize retaining the aspect ratio.
     # (Thanks to Robert Manni!)
-    def resize_to_fit(cols, rows=nil)
+    def resize_to_fit(cols, rows = nil)
       rows ||= cols
       change_geometry(Geometry.new(cols, rows)) do |ncols, nrows|
         resize(ncols, nrows)
       end
     end
 
-    def resize_to_fit!(cols, rows=nil)
+    def resize_to_fit!(cols, rows = nil)
       rows ||= cols
       change_geometry(Geometry.new(cols, rows)) do |ncols, nrows|
         resize!(ncols, nrows)
@@ -1028,16 +996,14 @@ module Magick
     def view(x, y, width, height)
       view = View.new(self, x, y, width, height)
 
-      if block_given?
-        begin
-          yield(view)
-        ensure
-          view.sync
-        end
-        return nil
-      else
-        return view
+      return view unless block_given?
+
+      begin
+        yield(view)
+      ensure
+        view.sync
       end
+      nil
     end
 
     # Magick::Image::View class
@@ -1047,12 +1013,8 @@ module Magick
 
       def initialize(img, x, y, width, height)
         img.check_destroyed
-        if width <= 0 || height <= 0
-          Kernel.raise ArgumentError, "invalid geometry (#{width}x#{height}+#{x}+#{y})"
-        end
-        if x < 0 || y < 0 || (x+width) > img.columns || (y+height) > img.rows
-          Kernel.raise RangeError, "geometry (#{width}x#{height}+#{x}+#{y}) exceeds image boundary"
-        end
+        Kernel.raise ArgumentError, "invalid geometry (#{width}x#{height}+#{x}+#{y})" if width <= 0 || height <= 0
+        Kernel.raise RangeError, "geometry (#{width}x#{height}+#{x}+#{y}) exceeds image boundary" if x < 0 || y < 0 || (x + width) > img.columns || (y + height) > img.rows
         @view = img.get_pixels(x, y, width, height)
         @img = img
         @x = x
@@ -1069,7 +1031,7 @@ module Magick
       end
 
       # Store changed pixels back to image
-      def sync(force=false)
+      def sync(force = false)
         @img.store_pixels(x, y, width, height, @view) if @dirty || force
         @dirty || force
       end
@@ -1078,7 +1040,7 @@ module Magick
       # true, don't change it back to false!
       def update(rows)
         @dirty = true
-        rows.delete_observer(self)      # No need to tell us again.
+        rows.delete_observer(self) # No need to tell us again.
         nil
       end
 
@@ -1088,7 +1050,7 @@ module Magick
         include Observable
 
         # Define a getter and a setter for each channel.
-        [:red, :green, :blue, :opacity].each do |c|
+        %i[red green blue opacity].each do |c|
           module_eval <<-END_EVAL
             def #{c}
                 return collect { |p| p.#{c} }
@@ -1099,7 +1061,7 @@ module Magick
                 notify_observers(self)
                 nil
             end
-        END_EVAL
+          END_EVAL
         end
       end # class Magick::Image::View::Pixels
 
@@ -1119,7 +1081,7 @@ module Magick
 
           # Both View::Pixels and Magick::Pixel implement Observable
           if @unique
-            pixels = @view[@rows[0]*@width + @cols[0]]
+            pixels = @view[@rows[0] * @width + @cols[0]]
             pixels.add_observer(self)
           else
             pixels = View::Pixels.new
@@ -1133,8 +1095,8 @@ module Magick
         end
 
         def []=(*args)
-          rv = args.delete_at(-1)     # get rvalue
-          unless rv.is_a?(Pixel)        # must be a Pixel or a color name
+          rv = args.delete_at(-1) # get rvalue
+          unless rv.is_a?(Pixel) # must be a Pixel or a color name
             begin
               rv = Pixel.from_color(rv)
             rescue TypeError
@@ -1159,7 +1121,7 @@ module Magick
         private
 
         def cols(*args)
-          @cols = args[0]     # remove the outermost array
+          @cols = args[0] # remove the outermost array
           @unique = false
 
           # Convert @rows to an Enumerable object
@@ -1173,12 +1135,8 @@ module Magick
               @rows = @rows.first
             else
               @rows = Integer(@rows.first)
-              if @rows < 0
-                @rows += @height
-              end
-              if @rows < 0 || @rows > @height-1
-                Kernel.raise IndexError, "index [#{@rows}] out of range"
-              end
+              @rows += @height if @rows < 0
+              Kernel.raise IndexError, "index [#{@rows}] out of range" if @rows < 0 || @rows > @height - 1
               # Convert back to an array
               @rows = Array.new(1, @rows)
               @unique = true
@@ -1189,27 +1147,23 @@ module Magick
             length = Integer(@rows[1])
 
             # Negative start -> start from last row
-            if start < 0
-              start += @height
-            end
+            start += @height if start < 0
 
             if start > @height || start < 0 || length < 0
               Kernel.raise IndexError, "index [#{@rows.first}] out of range"
-            else
-              if start + length > @height
-                length = @height - length
-                length = [length, 0].max
-              end
+            elsif start + length > @height
+              length = @height - length
+              length = [length, 0].max
             end
             # Create a Range for the specified set of rows
-            @rows = Range.new(start, start+length, true)
+            @rows = Range.new(start, start + length, true)
           end
 
           case @cols.length
-          when 0                  # all rows
-            @cols = Range.new(0, @width, true)  # convert to range
+          when 0 # all rows
+            @cols = Range.new(0, @width, true) # convert to range
             @unique = false
-          when 1                  # Range, Array, or a single integer
+          when 1 # Range, Array, or a single integer
             # if the single element is already an Enumerable
             # object, get it.
             if @cols.first.respond_to? :each
@@ -1217,12 +1171,8 @@ module Magick
               @unique = false
             else
               @cols = Integer(@cols.first)
-              if @cols < 0
-                @cols += @width
-              end
-              if @cols < 0 || @cols > @width-1
-                Kernel.raise IndexError, "index [#{@cols}] out of range"
-              end
+              @cols += @width if @cols < 0
+              Kernel.raise IndexError, "index [#{@cols}] out of range" if @cols < 0 || @cols > @width - 1
               # Convert back to array
               @cols = Array.new(1, @cols)
               @unique &&= true
@@ -1233,20 +1183,16 @@ module Magick
             length = Integer(@cols[1])
 
             # Negative start -> start from last row
-            if start < 0
-              start += @width
-            end
+            start += @width if start < 0
 
             if start > @width || start < 0 || length < 0
-              ; #nop
-            else
-              if start + length > @width
-                length = @width - length
-                length = [length, 0].max
-              end
+            # nop
+            elsif start + length > @width
+              length = @width - length
+              length = [length, 0].max
             end
             # Create a Range for the specified set of columns
-            @cols = Range.new(start, start+length, true)
+            @cols = Range.new(start, start + length, true)
             @unique = false
           end
         end
@@ -1257,20 +1203,16 @@ module Magick
           maxcols = @width - 1
 
           @rows.each do |j|
-            if j > maxrows
-              Kernel.raise IndexError, "index [#{j}] out of range"
-            end
+            Kernel.raise IndexError, "index [#{j}] out of range" if j > maxrows
             @cols.each do |i|
-              if i > maxcols
-                Kernel.raise IndexError, "index [#{i}] out of range"
-              end
-              yield j*@width + i
+              Kernel.raise IndexError, "index [#{i}] out of range" if i > maxcols
+              yield j * @width + i
             end
           end
-          nil    # useless return value
+          nil # useless return value
         end
       end # class Magick::Image::View::Rows
-    end     # class Magick::Image::View
+    end # class Magick::Image::View
   end # class Magick::Image
 
   class ImageList
@@ -1281,23 +1223,21 @@ module Magick
     private
 
     def get_current
-      return @images[@scene].__id__ rescue nil
+      @images[@scene].__id__
+    rescue StandardError
+      nil
     end
 
     protected
 
     def is_an_image(obj)
-      unless obj.is_a? Magick::Image
-        Kernel.raise ArgumentError, "Magick::Image required (#{obj.class} given)"
-      end
+      Kernel.raise ArgumentError, "Magick::Image required (#{obj.class} given)" unless obj.is_a? Magick::Image
       true
     end
 
     # Ensure array is always an array of Magick::Image objects
     def is_an_image_array(ary)
-      unless ary.respond_to? :each
-        Kernel.raise ArgumentError, "Magick::ImageList or array of Magick::Images required (#{ary.class} given)"
-      end
+      Kernel.raise ArgumentError, "Magick::ImageList or array of Magick::Images required (#{ary.class} given)" unless ary.respond_to? :each
       ary.each { |obj| is_an_image obj }
       true
     end
@@ -1305,7 +1245,7 @@ module Magick
     # Find old current image, update scene number
     # current is the id of the old current image.
     def set_current(current)
-      if length == 0
+      if length.zero?
         self.scene = nil
         return
       # Don't bother looking for current image
@@ -1316,10 +1256,8 @@ module Magick
         # Find last instance of "current" in the list.
         # If "current" isn't in the list, set current to last image.
         self.scene = length - 1
-        each_with_index do |f,i|
-          if f.__id__ == current
-            self.scene = i
-          end
+        each_with_index do |f, i|
+          self.scene = i if f.__id__ == current
         end
         return
       end
@@ -1331,24 +1269,22 @@ module Magick
     # Allow scene to be set to nil
     def scene=(n)
       if n.nil?
-        Kernel.raise IndexError, 'scene number out of bounds' unless @images.length == 0
+        Kernel.raise IndexError, 'scene number out of bounds' unless @images.length.zero?
         @scene = nil
         return @scene
-      elsif @images.length == 0
+      elsif @images.length.zero?
         Kernel.raise IndexError, 'scene number out of bounds'
       end
 
       n = Integer(n)
-      if n < 0 || n > length - 1
-        Kernel.raise IndexError, 'scene number out of bounds'
-      end
+      Kernel.raise IndexError, 'scene number out of bounds' if n < 0 || n > length - 1
       @scene = n
       @scene
     end
 
     # All the binary operators work the same way.
     # 'other' should be either an ImageList or an Array
-    %w{& + - |}.each do |op|
+    %w[& + - |].each do |op|
       module_eval <<-END_BINOPS
         def #{op}(other)
           ilist = self.class.new
@@ -1368,13 +1304,11 @@ module Magick
       END_BINOPS
     end
 
-    def *(n)
-      unless n.is_a? Integer
-        Kernel.raise ArgumentError, "Integer required (#{n.class} given)"
-      end
+    def *(other)
+      Kernel.raise ArgumentError, "Integer required (#{other.class} given)" unless other.is_a? Integer
       current = get_current
       ilist = self.class.new
-      (@images * n).each {|image| ilist << image}
+      (@images * other).each { |image| ilist << image }
       ilist.set_current current
       ilist
     end
@@ -1392,23 +1326,19 @@ module Magick
     #   return if A.scene != B.scene
     #   return A.length <=> B.length
     def <=>(other)
-      unless other.is_a? self.class
-        Kernel.raise TypeError, "#{self.class} required (#{other.class} given)"
-      end
+      Kernel.raise TypeError, "#{self.class} required (#{other.class} given)" unless other.is_a? self.class
       size = [length, other.length].min
       size.times do |x|
         r = self[x] <=> other[x]
-        return r unless r == 0
-      end
-      if @scene.nil? && other.scene.nil?
-        return 0
-      elsif @scene.nil? && !other.scene.nil?
-        Kernel.raise TypeError, "cannot convert nil into #{other.scene.class}"
-      elsif ! @scene.nil? && other.scene.nil?
-        Kernel.raise TypeError, "cannot convert nil into #{scene.class}"
+        return r unless r.zero?
       end
+      return 0 if @scene.nil? && other.scene.nil?
+
+      Kernel.raise TypeError, "cannot convert nil into #{other.scene.class}" if @scene.nil? && !other.scene.nil?
+      Kernel.raise TypeError, "cannot convert nil into #{scene.class}" if !@scene.nil? && other.scene.nil?
       r = scene <=> other.scene
-      return r unless r == 0
+      return r unless r.zero?
+
       length <=> other.length
     end
 
@@ -1416,7 +1346,7 @@ module Magick
       a = @images[*args]
       if a.respond_to?(:each)
         ilist = self.class.new
-        a.each {|image| ilist << image}
+        a.each { |image| ilist << image }
         a = ilist
       end
       a
@@ -1436,15 +1366,15 @@ module Magick
       obj
     end
 
-    [:at, :each, :each_index, :empty?, :fetch,
-     :first, :hash, :include?, :index, :length, :rindex, :sort!].each do |mth|
+    %i[at each each_index empty? fetch
+       first hash include? index length rindex sort!].each do |mth|
       module_eval <<-END_SIMPLE_DELEGATES
         def #{mth}(*args, &block)
           @images.#{mth}(*args, &block)
         end
       END_SIMPLE_DELEGATES
     end
-    alias_method :size, :length
+    alias size length
 
     # Array#nitems is not available in 1.9
     if Array.instance_methods.include?('nitems')
@@ -1469,7 +1399,7 @@ module Magick
       current = get_current
       a = @images.collect(&block)
       ilist = self.class.new
-      a.each {|image| ilist << image}
+      a.each { |image| ilist << image }
       ilist.set_current current
       ilist
     end
@@ -1491,48 +1421,45 @@ module Magick
 
     # Return the current image
     def cur_image
-      unless @scene
-        Kernel.raise IndexError, 'no images in this list'
-      end
+      Kernel.raise IndexError, 'no images in this list' unless @scene
       @images[@scene]
     end
 
     # ImageList#map took over the "map" name. Use alternatives.
-    alias_method :__map__, :collect
-    alias_method :map!, :collect!
-    alias_method :__map__!, :collect!
+    alias __map__ collect
+    alias map! collect!
+    alias __map__! collect!
 
     # ImageMagic used affinity in 6.4.3, switch to remap in 6.4.4.
-    alias_method :affinity, :remap
+    alias affinity remap
 
     def compact
       current = get_current
       ilist = self.class.new
       a = @images.compact
-      a.each {|image| ilist << image}
+      a.each { |image| ilist << image }
       ilist.set_current current
       ilist
     end
 
     def compact!
       current = get_current
-      a = @images.compact!    # returns nil if no changes were made
+      a = @images.compact! # returns nil if no changes were made
       set_current current
       a.nil? ? nil : self
     end
 
     def concat(other)
       is_an_image_array other
-      other.each {|image| @images << image}
-      @scene = length-1
+      other.each { |image| @images << image }
+      @scene = length - 1
       self
     end
 
     # Set same delay for all images
     def delay=(d)
-      if Integer(d) < 0
-        fail ArgumentError, 'delay must be greater than or equal to 0'
-      end
+      raise ArgumentError, 'delay must be greater than or equal to 0' if Integer(d) < 0
+
       @images.each { |f| f.delay = Integer(d) }
     end
 
@@ -1560,7 +1487,7 @@ module Magick
 
     def dup
       ditto = self.class.new
-      @images.each {|img| ditto << img}
+      @images.each { |img| ditto << img }
       ditto.scene = @scene
       ditto.taint if tainted?
       ditto
@@ -1591,18 +1518,16 @@ module Magick
       current = get_current
       a = @images.find_all(&block)
       ilist = self.class.new
-      a.each {|image| ilist << image}
+      a.each { |image| ilist << image }
       ilist.set_current current
       ilist
     end
-    alias_method :select, :find_all
+    alias select find_all
 
     def from_blob(*blobs, &block)
-      if (blobs.length == 0)
-        Kernel.raise ArgumentError, 'no blobs given'
-      end
+      Kernel.raise ArgumentError, 'no blobs given' if blobs.length.zero?
       blobs.each do |b|
-        Magick::Image.from_blob(b, &block).each { |n| @images << n  }
+        Magick::Image.from_blob(b, &block).each { |n| @images << n }
       end
       @scene = length - 1
       self
@@ -1616,13 +1541,13 @@ module Magick
         Magick::Image.read(f, &block).each { |n| @images << n }
       end
       if length > 0
-        @scene = length - 1     # last image in array
+        @scene = length - 1 # last image in array
       end
       self
     end
 
     def insert(index, *args)
-      args.each {|image| is_an_image image}
+      args.each { |image| is_an_image image }
       current = get_current
       @images.insert(index, *args)
       set_current current
@@ -1632,27 +1557,25 @@ module Magick
     # Call inspect for all the images
     def inspect
       img = []
-      @images.each {|image| img << image.inspect }
+      @images.each { |image| img << image.inspect }
       img = '[' + img.join(",\n") + "]\nscene=#{@scene}"
     end
 
     # Set the number of iterations of an animated GIF
     def iterations=(n)
       n = Integer(n)
-      if n < 0 || n > 65535
-        Kernel.raise ArgumentError, 'iterations must be between 0 and 65535'
-      end
-      @images.each {|f| f.iterations=n}
+      Kernel.raise ArgumentError, 'iterations must be between 0 and 65535' if n < 0 || n > 65_535
+      @images.each { |f| f.iterations = n }
       self
     end
 
     def last(*args)
-      if args.length == 0
+      if args.length.zero?
         a = @images.last
       else
         a = @images.last(*args)
         ilist = self.class.new
-        a.each {|img| ilist << img}
+        a.each { |img| ilist << img }
         @scene = a.length - 1
         a = ilist
       end
@@ -1662,28 +1585,28 @@ module Magick
     # Custom marshal/unmarshal for Ruby 1.8.
     def marshal_dump
       ary = [@scene]
-      @images.each {|i| ary << Marshal.dump(i)}
+      @images.each { |i| ary << Marshal.dump(i) }
       ary
     end
 
     def marshal_load(ary)
       @scene = ary.shift
       @images = []
-      ary.each {|a| @images << Marshal.load(a)}
+      ary.each { |a| @images << Marshal.load(a) }
     end
 
     # The ImageList class supports the Magick::Image class methods by simply sending
     # the method to the current image. If the method isn't explicitly supported,
     # send it to the current image in the array. If there are no images, send
     # it up the line. Catch a NameError and emit a useful message.
-    def method_missing(methID, *args, &block)
+    def method_missing(meth_id, *args, &block)
       if @scene
-        @images[@scene].send(methID, *args, &block)
+        @images[@scene].send(meth_id, *args, &block)
       else
         super
       end
     rescue NoMethodError
-      Kernel.raise NoMethodError, "undefined method `#{methID.id2name}' for #{self.class}"
+      Kernel.raise NoMethodError, "undefined method `#{meth_id.id2name}' for #{self.class}"
     rescue Exception
       $ERROR_POSITION.delete_if { |s| /:in `send'$/.match(s) || /:in `method_missing'$/.match(s) }
       Kernel.raise
@@ -1697,19 +1620,17 @@ module Magick
     def partition(&block)
       a = @images.partition(&block)
       t = self.class.new
-      a[0].each { |img| t << img}
+      a[0].each { |img| t << img }
       t.set_current nil
       f = self.class.new
-      a[1].each { |img| f << img}
+      a[1].each { |img| f << img }
       f.set_current nil
       [t, f]
     end
 
     # Ping files and concatenate the new images
     def ping(*files, &block)
-      if (files.length == 0)
-        Kernel.raise ArgumentError, 'no files given'
-      end
+      Kernel.raise ArgumentError, 'no files given' if files.length.zero?
       files.each do |f|
         Magick::Image.ping(f, &block).each { |n| @images << n }
       end
@@ -1719,7 +1640,7 @@ module Magick
 
     def pop
       current = get_current
-      a = @images.pop       # can return nil
+      a = @images.pop # can return nil
       set_current current
       a
     end
@@ -1735,9 +1656,7 @@ module Magick
 
     # Read files and concatenate the new images
     def read(*files, &block)
-      if (files.length == 0)
-        Kernel.raise ArgumentError, 'no files given'
-      end
+      Kernel.raise ArgumentError, 'no files given' if files.length.zero?
       files.each do |f|
         Magick::Image.read(f, &block).each { |n| @images << n }
       end
@@ -1750,7 +1669,7 @@ module Magick
       current = get_current
       ilist = self.class.new
       a = @images.reject(&block)
-      a.each {|image| ilist << image}
+      a.each { |image| ilist << image }
       ilist.set_current current
       ilist
     end
@@ -1767,18 +1686,19 @@ module Magick
       is_an_image_array other
       current = get_current
       @images.clear
-      other.each {|image| @images << image}
-      @scene = length == 0 ? nil : 0
+      other.each { |image| @images << image }
+      @scene = length.zero? ? nil : 0
       set_current current
       self
     end
 
     # Ensure respond_to? answers correctly when we are delegating to Image
-    alias_method :__respond_to__?, :respond_to?
-    def respond_to?(methID, priv=false)
-      return true if __respond_to__?(methID, priv)
+    alias __respond_to__? respond_to?
+    def respond_to?(meth_id, priv = false)
+      return true if __respond_to__?(meth_id, priv)
+
       if @scene
-        @images[@scene].respond_to?(methID, priv)
+        @images[@scene].respond_to?(meth_id, priv)
       else
         super
       end
@@ -1787,7 +1707,7 @@ module Magick
     def reverse
       current = get_current
       a = self.class.new
-      @images.reverse_each {|image| a << image}
+      @images.reverse_each { |image| a << image }
       a.set_current current
       a
     end
@@ -1800,7 +1720,7 @@ module Magick
     end
 
     def reverse_each
-      @images.reverse_each {|image| yield(image)}
+      @images.reverse_each { |image| yield(image) }
       self
     end
 
@@ -1816,7 +1736,7 @@ module Magick
       if slice
         ilist = self.class.new
         if slice.respond_to?(:each)
-          slice.each {|image| ilist << image}
+          slice.each { |image| ilist << image }
         else
           ilist << slice
         end
@@ -1834,27 +1754,25 @@ module Magick
     end
 
     def ticks_per_second=(t)
-      if Integer(t) < 0
-        Kernel.raise ArgumentError, 'ticks_per_second must be greater than or equal to 0'
-      end
+      Kernel.raise ArgumentError, 'ticks_per_second must be greater than or equal to 0' if Integer(t) < 0
       @images.each { |f| f.ticks_per_second = Integer(t) }
     end
 
     def to_a
       a = []
-      @images.each {|image| a << image}
+      @images.each { |image| a << image }
       a
     end
 
     def uniq
       current = get_current
       a = self.class.new
-      @images.uniq.each {|image| a << image}
+      @images.uniq.each { |image| a << image }
       a.set_current current
       a
     end
 
-    def uniq!(*args)
+    def uniq!(*_args)
       current = get_current
       a = @images.uniq!
       set_current current
@@ -1872,12 +1790,12 @@ module Magick
     def values_at(*args)
       a = @images.values_at(*args)
       a = self.class.new
-      @images.values_at(*args).each {|image| a << image}
+      @images.values_at(*args).each { |image| a << image }
       a.scene = a.length - 1
       a
     end
-    alias_method :indexes, :values_at
-    alias_method :indices, :values_at
+    alias indexes values_at
+    alias indices values_at
   end # Magick::ImageList
 
   #  Collects non-specific optional method arguments
@@ -1914,21 +1832,21 @@ module Magick
   # @dist is the number of pixels between hatch lines.
   # See Magick::Draw examples.
   class HatchFill
-    def initialize(bgcolor, hatchcolor='white', dist=10)
+    def initialize(bgcolor, hatchcolor = 'white', dist = 10)
       @bgcolor = bgcolor
       @hatchpixel = Pixel.from_color(hatchcolor)
       @dist = dist
     end
 
-    def fill(img)                # required
+    def fill(img) # required
       img.background_color = @bgcolor
-      img.erase!                # sets image to background color
+      img.erase! # sets image to background color
       pixels = Array.new([img.rows, img.columns].max, @hatchpixel)
-      @dist.step((img.columns-1)/@dist*@dist, @dist) do |x|
-        img.store_pixels(x,0,1,img.rows,pixels)
+      @dist.step((img.columns - 1) / @dist * @dist, @dist) do |x|
+        img.store_pixels(x, 0, 1, img.rows, pixels)
       end
-      @dist.step((img.rows-1)/@dist*@dist, @dist) do |y|
-        img.store_pixels(0,y,img.columns,1,pixels)
+      @dist.step((img.rows - 1) / @dist * @dist, @dist) do |y|
+        img.store_pixels(0, y, img.columns, 1, pixels)
       end
     end
   end