rmagick 2.16.0 → 5.5.0

data/lib/rmagick_internal.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # $Id: RMagick.rb,v 1.84 2009/09/15 22:08:41 rmagick Exp $
 #==============================================================================
 #                  Copyright (C) 2009 by Timothy P. Hunter
@@ -8,36 +10,55 @@
 #               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) if File.exist?(File.join(path, 'CORE_RL_magick_.dll')) || File.exist?(File.join(path, 'CORE_RL_MagickCore_.dll'))
+    end
+  rescue LoadError
+  end
+end
+
 require 'English'
+require 'observer'
 require 'RMagick2.so'
 
 module Magick
-  @formats = nil
-  @trace_proc = nil
-  @exit_block_set_up = nil
+  IMAGEMAGICK_VERSION = Magick::Magick_version.split[1].split('-').first
 
   class << self
-    def formats(&block)
-      @formats ||= init_formats
+    # Describes the image formats supported by ImageMagick.
+    # If the optional block is present, calls the block once for each image format.
+    # The first argument, +k+, is the format name. The second argument, +v+, is the
+    # properties string described below.
+    #
+    # - +B+ is "*" if the format has native blob support, or " " otherwise.
+    # - +R+ is "r" if ImageMagick can read that format, or "-" otherwise.
+    # - +W+ is "w" if ImageMagick can write that format, or "-" otherwise.
+    # - +A+ is "+" if the format supports multi-image files, or "-" otherwise.
+    #
+    # @overload formats
+    #   @return [Hash] the formats hash
+    #
+    # @overload formats
+    #   @yield [k, v]
+    #   @yieldparam k [String] the format name
+    #   @yieldparam v [String] the properties string
+    #   @return [Magick]
+    #
+    # @example
+    #   p Magick.formats
+    #   => {"3FR"=>" r-+", "3G2"=>" r-+", "3GP"=>" r-+", "A"=>"*rw+",
+    #   ...
+    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
-      end
-    end
-
-    # remove reference to the proc at exit
-    def trace_proc=(p)
-      m = Mutex.new
-      m.synchronize do
-        if @trace_proc.nil? && !p.nil? && !@exit_block_set_up
-          at_exit { @trace_proc = nil }
-          @exit_block_set_up = true
-        end
-
-        @trace_proc = p
+        formats
       end
     end
   end
@@ -55,21 +76,23 @@ module Magick
   MinimumGeometry  = GeometryValue.new(:MinimumGeometry, 6).freeze
 
   class Geometry
-    FLAGS = ['', '%', '!', '<', '>', '@', '^']
-    RFLAGS = { '%' => PercentGeometry,
-               '!' => AspectGeometry,
-               '<' => LessGeometry,
-               '>' => GreaterGeometry,
-               '@' => AreaGeometry,
-               '^' => MinimumGeometry }
+    FLAGS = ['', '%', '!', '<', '>', '@', '^'].freeze
+    RFLAGS = {
+      '%' => PercentGeometry,
+      '!' => AspectGeometry,
+      '<' => LessGeometry,
+      '>' => GreaterGeometry,
+      '@' => AreaGeometry,
+      '^' => MinimumGeometry
+    }.freeze
 
     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,24 +134,20 @@ 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
 
     # Convert object to a geometry string
     def to_s
-      str = ''
+      str = String.new
       if @width > 0
         fmt = @width.truncate == @width ? '%d' : '%.2f'
         str << sprintf(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'
@@ -136,9 +155,7 @@ module Magick
         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 << FLAGS[@flag.to_i] if @flag != PercentGeometry
       str
     end
   end
@@ -167,7 +184,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',
@@ -209,13 +226,31 @@ module Magick
     private
 
     def enquote(str)
+      str = to_string(str)
       if str.length > 2 && /\A(?:\"[^\"]+\"|\'[^\']+\'|\{[^\}]+\})\z/.match(str)
-        return str
+        str
       else
-        return '"' + str + '"'
+        '"' + str + '"'
       end
     end
 
+    def to_opacity(opacity)
+      return opacity if opacity.is_a?(String) && opacity.end_with?('%')
+
+      value = Float(opacity)
+      Kernel.raise ArgumentError, 'opacity must be >= 0 and <= 1.0' if value < 0 || value > 1.0
+
+      value
+    end
+
+    def to_string(obj)
+      return obj if obj.is_a?(String)
+      return obj.to_s if obj.is_a?(Symbol)
+      return obj.to_str if obj.respond_to?(:to_str)
+
+      Kernel.raise TypeError, "no implicit conversion of #{obj.class} into String"
+    end
+
     public
 
     # Apply coordinate transformations to support scaling (s), rotation (r),
@@ -224,61 +259,67 @@ module Magick
       primitive 'affine ' + sprintf('%g,%g,%g,%g,%g,%g', sx, rx, ry, sy, tx, ty)
     end
 
+    # Set alpha (make transparent) in image according to the specified
+    # colorization rule
+    def alpha(x, y, method)
+      Kernel.raise ArgumentError, 'Unknown paint method' unless PAINT_METHOD_NAMES.key?(method.to_i)
+      name = Gem::Version.new(Magick::IMAGEMAGICK_VERSION) > Gem::Version.new('7.0.0') ? 'alpha ' : 'matte '
+      primitive name + sprintf('%g,%g, %s', x, y, PAINT_METHOD_NAMES[method.to_i])
+    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 ' + sprintf(
+        '%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'
       end
-      primitive 'bezier ' + points.join(',')
+      primitive 'bezier ' + points.map! { |x| sprintf('%g', x) }.join(',')
     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 ' + sprintf('%g,%g %g,%g', origin_x, origin_y, perim_x, perim_y)
     end
 
     # Invoke a clip-path defined by def_clip_path.
     def clip_path(name)
-      primitive "clip-path #{name}"
+      primitive "clip-path #{to_string(name)}"
     end
 
     # Define the clipping rule.
     def clip_rule(rule)
-      unless  ['evenodd', 'nonzero'].include?(rule.downcase)
-        Kernel.raise ArgumentError, "Unknown clipping rule #{rule}"
-      end
+      rule = to_string(rule)
+      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
+      unit = to_string(unit)
+      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
-      primitive "color #{x},#{y},#{PAINT_METHOD_NAMES[method.to_i]}"
+      Kernel.raise ArgumentError, "Unknown PaintMethod: #{method}" unless PAINT_METHOD_NAMES.key?(method.to_i)
+      primitive 'color ' + sprintf('%g,%g,%s', 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)}"
@@ -292,7 +333,7 @@ module Magick
     # (pop) graphic-context".
     def define_clip_path(name)
       push('defs')
-      push('clip-path', name)
+      push("clip-path #{enquote(name)}")
       push('graphic-context')
       yield
     ensure
@@ -302,136 +343,104 @@ 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 ' + sprintf(
+        '%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
     # is "UTF-8". All others are apparently ignored.
     def encoding(encoding)
-      primitive "encoding #{encoding}"
+      primitive "encoding #{to_string(encoding)}"
     end
 
     # Specify object fill, a color name or pattern name
     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)
+      opacity = to_opacity(opacity)
       primitive "fill-opacity #{opacity}"
     end
 
     def fill_rule(rule)
-      unless  ['evenodd', 'nonzero'].include?(rule.downcase)
-        Kernel.raise ArgumentError, "Unknown fill rule #{rule}"
-      end
+      rule = to_string(rule)
+      Kernel.raise ArgumentError, "Unknown fill rule #{rule}" unless %w[evenodd nonzero].include?(rule.downcase)
       primitive "fill-rule #{rule}"
     end
 
     # Specify text drawing font
     def font(name)
-      primitive "font \'#{name}\'"
+      primitive "font #{enquote(name)}"
     end
 
     def font_family(name)
-      primitive "font-family \'#{name}\'"
+      primitive "font-family #{enquote(name)}"
     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 weight.is_a?(WeightType)
         primitive "font-weight #{FONT_WEIGHT_NAMES[weight.to_i]}"
       else
-        primitive "font-weight #{weight}"
+        primitive "font-weight #{Integer(weight)}"
       end
     end
 
     # 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
 
+    def image(composite, x, y, width, height, image_file_path)
+      Kernel.raise ArgumentError, 'Unknown composite' unless composite.is_a?(CompositeOperator)
+      composite_name = composite.to_s.sub!('CompositeOp', '')
+      primitive 'image ' + sprintf('%s %g,%g %g,%g %s', composite_name, x, y, width, height, enquote(image_file_path))
+    end
+
     # IM 6.5.5-8 and later
     def interline_spacing(space)
-      begin
-        Float(space)
-      rescue ArgumentError
-        Kernel.raise ArgumentError, 'invalid value for interline_spacing'
-      rescue TypeError
-        Kernel.raise TypeError, "can't convert #{space.class} into Float"
-      end
-      primitive "interline-spacing #{space}"
+      primitive "interline-spacing #{Float(space)}"
     end
 
     # IM 6.4.8-3 and later
     def interword_spacing(space)
-      begin
-        Float(space)
-      rescue ArgumentError
-        Kernel.raise ArgumentError, 'invalid value for interword_spacing'
-      rescue TypeError
-        Kernel.raise TypeError, "can't convert #{space.class} into Float"
-      end
-      primitive "interword-spacing #{space}"
+      primitive "interword-spacing #{Float(space)}"
     end
 
     # IM 6.4.8-3 and later
     def kerning(space)
-      begin
-        Float(space)
-      rescue ArgumentError
-        Kernel.raise ArgumentError, 'invalid value for kerning'
-      rescue TypeError
-        Kernel.raise TypeError, "can't convert #{space.class} into Float"
-      end
-      primitive "kerning #{space}"
+      primitive "kerning #{Float(space)}"
     end
 
     # Draw a line
-    def line(startX, startY, endX, endY)
-      primitive 'line ' + sprintf('%g,%g %g,%g', startX, startY, endX, endY)
-    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
-      primitive "matte #{x},#{y} #{PAINT_METHOD_NAMES[method.to_i]}"
+    def line(start_x, start_y, end_x, end_y)
+      primitive 'line ' + sprintf('%g,%g %g,%g', start_x, start_y, end_x, end_y)
     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
-      end
+      opacity = to_opacity(opacity)
       primitive "opacity #{opacity}"
     end
 
@@ -439,7 +448,7 @@ module Magick
     # primitive requires that the commands be surrounded by quotes or
     # apostrophes. Here we simply use apostrophes.
     def path(cmds)
-      primitive "path '" + cmds + "'"
+      primitive "path #{enquote(cmds)}"
     end
 
     # Define a pattern. In the block, call primitive methods to
@@ -447,7 +456,7 @@ module Magick
     # as the argument to the 'fill' or 'stroke' methods
     def pattern(name, x, y, width, height)
       push('defs')
-      push("pattern #{name} #{x} #{y} #{width} #{height}")
+      push("pattern #{to_string(name)} " + sprintf('%g %g %g %g', x, y, width, height))
       push('graphic-context')
       yield
     ensure
@@ -458,34 +467,34 @@ module Magick
 
     # Set point to fill color.
     def point(x, y)
-      primitive "point #{x},#{y}"
+      primitive 'point ' + sprintf('%g,%g', x, y)
     end
 
     # Specify the font size in points. Yes, the primitive is "font-size" but
     # in other places this value is called the "pointsize". Give it both names.
     def pointsize(points)
-      primitive "font-size #{points}"
+      primitive 'font-size ' + sprintf('%g', 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'
       end
-      primitive 'polygon ' + points.join(',')
+      primitive 'polygon ' + points.map! { |x| sprintf('%g', x) }.join(',')
     end
 
     # 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'
       end
-      primitive 'polyline ' + points.join(',')
+      primitive 'polyline ' + points.map! { |x| sprintf('%g', x) }.join(',')
     end
 
     # Return to the previously-saved set of whatever
@@ -495,11 +504,10 @@ 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 { |x| to_string(x) }.join(' ')
       end
     end
 
@@ -509,50 +517,53 @@ 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 { |x| to_string(x) }.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 ' + sprintf(
+        '%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
     def rotate(angle)
-      primitive "rotate #{angle}"
+      primitive 'rotate ' + sprintf('%g', angle)
     end
 
     # 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 ' + sprintf(
+        '%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.
     def scale(x, y)
-      primitive "scale #{x},#{y}"
+      primitive 'scale ' + sprintf('%g,%g', x, y)
     end
 
     def skewx(angle)
-      primitive "skewX #{angle}"
+      primitive 'skewX ' + sprintf('%g', angle)
     end
 
     def skewy(angle)
-      primitive "skewY #{angle}"
+      primitive 'skewY ' + sprintf('%g', angle)
     end
 
     # Specify the object stroke, a color name or pattern name.
     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,88 +573,79 @@ 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
+        list.map! { |x| Float(x) }.each do |x|
+          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)
-      primitive "stroke-dashoffset #{value}"
+    def stroke_dashoffset(value = 0)
+      primitive 'stroke-dashoffset ' + sprintf('%g', value)
     end
 
     def stroke_linecap(value)
-      unless  ['butt', 'round', 'square'].include?(value.downcase)
-        Kernel.raise ArgumentError, "Unknown linecap type: #{value}"
-      end
+      value = to_string(value)
+      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
+      value = to_string(value)
+      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
+      value = Float(value)
+      Kernel.raise ArgumentError, 'miterlimit must be >= 1' if value < 1
       primitive "stroke-miterlimit #{value}"
     end
 
     # Specify opacity of stroke drawing color
     #  (use "xx%" to indicate percentage)
-    def stroke_opacity(value)
-      primitive "stroke-opacity #{value}"
+    def stroke_opacity(opacity)
+      opacity = to_opacity(opacity)
+      primitive "stroke-opacity #{opacity}"
     end
 
     # Specify stroke (outline) width in pixels.
     def stroke_width(pixels)
-      primitive "stroke-width #{pixels}"
+      primitive 'stroke-width ' + sprintf('%g', pixels)
     end
 
     # 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
+      text = to_string(text)
+      Kernel.raise ArgumentError, 'missing text argument' if text.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}"
+      primitive 'text ' + sprintf('%g,%g %s', 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
 
@@ -661,7 +663,7 @@ module Magick
     # Specify center of coordinate space to use for subsequent drawing
     # commands.
     def translate(x, y)
-      primitive "translate #{x},#{y}"
+      primitive 'translate ' + sprintf('%g,%g', x, y)
     end
   end # class Magick::Draw
 
@@ -764,19 +766,13 @@ module Magick
     module Post_ObjectData_Descriptor
       Confirmed_ObjectData_Size              = '9:10'
     end
-
-    # Make all constants above immutable
-    constants.each do |record|
-      rec = const_get(record)
-      rec.constants.each { |ds| rec.const_get(ds).freeze }
-    end
   end # module Magick::IPTC
 
   # Ruby-level Magick::Image methods
   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 +826,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 +837,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 +853,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[sprintf('#%04X', num.to_i)]
           hash[num] = rval == 'unknown' ? nil : rval
         end
       end
@@ -881,7 +875,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 +903,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 +915,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)
@@ -936,9 +928,9 @@ module Magick
     # Make the pixel at (x,y) transparent.
     def matte_point(x, y)
       f = copy
-      f.opacity = OpaqueOpacity unless f.matte
-      pixel = f.pixel_color(x,y)
-      pixel.opacity = TransparentOpacity
+      f.alpha(OpaqueAlphaChannel) unless f.alpha?
+      pixel = f.pixel_color(x, y)
+      pixel.alpha = TransparentAlpha
       f.pixel_color(x, y, pixel)
       f
     end
@@ -947,7 +939,7 @@ module Magick
     # pixel at (x, y).
     def matte_replace(x, y)
       f = copy
-      f.opacity = OpaqueOpacity unless f.matte
+      f.alpha(OpaqueAlphaChannel) unless f.alpha?
       target = f.pixel_color(x, y)
       f.transparent(target)
     end
@@ -956,56 +948,54 @@ module Magick
     # at (x,y) and is a neighbor.
     def matte_floodfill(x, y)
       f = copy
-      f.opacity = OpaqueOpacity unless f.matte
+      f.alpha(OpaqueAlphaChannel) unless f.alpha?
       target = f.pixel_color(x, y)
-      f.matte_flood_fill(target, TransparentOpacity,
-                         x, y, FloodfillMethod)
+      f.matte_flood_fill(target, x, y, FloodfillMethod, alpha: TransparentAlpha)
     end
 
     # Make transparent any neighbor pixel that is not the border color.
     def matte_fill_to_border(x, y)
       f = copy
-      f.opacity = Magick::OpaqueOpacity unless f.matte
-      f.matte_flood_fill(border_color, TransparentOpacity,
-                         x, y, FillToBorderMethod)
+      f.alpha(OpaqueAlphaChannel) unless f.alpha?
+      f.matte_flood_fill(border_color, x, y, FillToBorderMethod, alpha: TransparentAlpha)
     end
 
     # Make all pixels transparent.
     def matte_reset!
-      self.opacity = Magick::TransparentOpacity
+      alpha(TransparentAlphaChannel)
       self
     end
 
     # 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 +1018,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 +1035,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 +1053,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 +1062,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,18 +1072,18 @@ module Magick
         include Observable
 
         # Define a getter and a setter for each channel.
-        [:red, :green, :blue, :opacity].each do |c|
-          module_eval <<-END_EVAL
+        %i[red green blue opacity].each do |c|
+          module_eval <<-END_EVAL, __FILE__, __LINE__ + 1
             def #{c}
-                return collect { |p| p.#{c} }
+              return collect { |p| p.#{c} }
             end
             def #{c}=(v)
-                each { |p| p.#{c} = v }
-                changed
-                notify_observers(self)
-                nil
+              each { |p| p.#{c} = v }
+              changed
+              notify_observers(self)
+              v
             end
-        END_EVAL
+          END_EVAL
         end
       end # class Magick::Image::View::Pixels
 
@@ -1119,7 +1103,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 +1117,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
@@ -1145,7 +1129,6 @@ module Magick
           each { |x| @view[x] = rv.dup }
           changed
           notify_observers(self)
-          nil
         end
 
         # A pixel has been modified. Tell the view.
@@ -1159,7 +1142,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 +1156,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 +1168,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 +1192,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 +1204,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 +1224,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,31 +1244,27 @@ 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
-      true
+    def assert_image(obj)
+      Kernel.raise ArgumentError, "Magick::Image required (#{obj.class} given)" unless obj.is_a? Magick::Image
     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
-      ary.each { |obj| is_an_image obj }
-      true
+    def assert_image_array(ary)
+      Kernel.raise ArgumentError, "Magick::ImageList or array of Magick::Images required (#{ary.class} given)" unless ary.respond_to? :each
+      ary.each { |obj| assert_image obj }
     end
 
     # 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 +1275,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,56 +1288,45 @@ 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
+        return
+      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|
-      module_eval <<-END_BINOPS
+    %w[& + - |].each do |op|
+      module_eval <<-END_BINOPS, __FILE__, __LINE__ + 1
         def #{op}(other)
+          assert_image_array(other)
           ilist = self.class.new
-          begin
-            a = other #{op} @images
-          rescue TypeError
-            Kernel.raise ArgumentError, "Magick::ImageList expected, got " + other.class.to_s
-          end
+          a = other #{op} @images
           current = get_current()
-          a.each do |image|
-            is_an_image image
-            ilist << image
-          end
+          a.each { |image| ilist << image }
           ilist.set_current current
           return ilist
         end
       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
 
     def <<(obj)
-      is_an_image obj
+      assert_image obj
       @images << obj
       @scene = @images.length - 1
       self
@@ -1392,23 +1338,21 @@ 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
+      return 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?
+      return if @scene.nil? && !other.scene.nil?
+      return 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 +1360,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
@@ -1425,32 +1369,31 @@ module Magick
     def []=(*args)
       obj = @images.[]=(*args)
       if obj && obj.respond_to?(:each)
-        is_an_image_array(obj)
+        assert_image_array(obj)
         set_current obj.last.__id__
       elsif obj
-        is_an_image(obj)
+        assert_image(obj)
         set_current obj.__id__
       else
         set_current nil
       end
-      obj
     end
 
-    [:at, :each, :each_index, :empty?, :fetch,
-     :first, :hash, :include?, :index, :length, :rindex, :sort!].each do |mth|
-      module_eval <<-END_SIMPLE_DELEGATES
+    %i[
+      at each each_index empty? fetch
+      first hash include? index length rindex
+    ].each do |mth|
+      module_eval <<-END_SIMPLE_DELEGATES, __FILE__, __LINE__ + 1
         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')
-      def nitems
-        @images.nitems
-      end
+    def sort!(*args, &block)
+      @images.sort!(*args, &block)
+      self
     end
 
     def clear
@@ -1467,16 +1410,16 @@ module Magick
     # override Enumerable#collect
     def collect(&block)
       current = get_current
-      a = @images.collect(&block)
+      a = @images.map(&block)
       ilist = self.class.new
-      a.each {|image| ilist << image}
+      a.each { |image| ilist << image }
       ilist.set_current current
       ilist
     end
 
     def collect!(&block)
-      @images.collect!(&block)
-      is_an_image_array @images
+      @images.map!(&block)
+      assert_image_array @images
       self
     end
 
@@ -1485,59 +1428,56 @@ module Magick
       ditto = self.class.new
       @images.each { |f| ditto << f.copy }
       ditto.scene = @scene
-      ditto.taint if tainted?
       ditto
     end
 
     # 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!
+    alias __map__! collect!
 
-    # ImageMagic used affinity in 6.4.3, switch to remap in 6.4.4.
-    alias_method :affinity, :remap
+    # ImageMagick used affinity in 6.4.3, switch to remap in 6.4.4.
+    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
+      assert_image_array other
+      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
 
     def delete(obj, &block)
-      is_an_image obj
+      assert_image obj
       current = get_current
       a = @images.delete(obj, &block)
       set_current current
@@ -1560,14 +1500,18 @@ 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
     end
 
     def eql?(other)
-      is_an_image_array other
+      begin
+        assert_image_array other
+      rescue ArgumentError
+        return false
+      end
+
       eql = other.eql?(@images)
       begin # "other" is another ImageList
         eql &&= @scene == other.scene
@@ -1578,10 +1522,10 @@ module Magick
     end
 
     def fill(*args, &block)
-      is_an_image args[0] unless block_given?
+      assert_image args[0] unless block_given?
       current = get_current
       @images.fill(*args, &block)
-      is_an_image_array self
+      assert_image_array self
       set_current current
       self
     end
@@ -1589,20 +1533,18 @@ module Magick
     # Override Enumerable's find_all
     def find_all(&block)
       current = get_current
-      a = @images.find_all(&block)
+      a = @images.select(&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
@@ -1615,14 +1557,12 @@ module Magick
       filenames.each do |f|
         Magick::Image.read(f, &block).each { |n| @images << n }
       end
-      if length > 0
-        @scene = length - 1     # last image in array
-      end
-      self
+
+      @scene = length - 1 if length > 0 # last image in array
     end
 
     def insert(index, *args)
-      args.each {|image| is_an_image image}
+      args.each { |image| assert_image image }
       current = get_current
       @images.insert(index, *args)
       set_current current
@@ -1632,27 +1572,24 @@ 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}
-      self
+      Kernel.raise ArgumentError, 'iterations must be between 0 and 65535' if n < 0 || n > 65_535
+      @images.each { |f| f.iterations = n }
     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 +1599,30 @@ 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)
+        img = @images[@scene]
+        new_img = img.send(meth_id, *args, &block)
+        img.object_id == new_img.object_id ? self : new_img
       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 +1636,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,14 +1656,14 @@ module Magick
 
     def pop
       current = get_current
-      a = @images.pop       # can return nil
+      a = @images.pop # can return nil
       set_current current
       a
     end
 
     def push(*objs)
       objs.each do |image|
-        is_an_image image
+        assert_image image
         @images << image
       end
       @scene = length - 1
@@ -1735,9 +1672,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 +1685,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
@@ -1764,21 +1699,22 @@ module Magick
     end
 
     def replace(other)
-      is_an_image_array other
+      assert_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 +1723,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 +1736,7 @@ module Magick
     end
 
     def reverse_each
-      @images.reverse_each {|image| yield(image)}
+      @images.reverse_each { |image| yield(image) }
       self
     end
 
@@ -1816,7 +1752,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 +1770,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
@@ -1863,23 +1797,27 @@ module Magick
 
     # @scene -> new object
     def unshift(obj)
-      is_an_image obj
+      assert_image obj
       @images.unshift(obj)
       @scene = 0
       self
     end
 
     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
 
+  class Pixel
+    # include Observable for Image::View class
+    include Observable
+  end
+
   #  Collects non-specific optional method arguments
   class OptionalMethodArguments
     def initialize(img)
@@ -1914,21 +1852,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)
+      @hatchpixel = hatchcolor.is_a?(Pixel) ? hatchcolor : 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